native_ops_bridge.c

Go to the documentation of this file.

/**
 * @file
 * @brief Bridges native ops commands to doctor, drift, deploy-check, and migration verification report generation.
 */
 
#include "native_ops_bridge.h"
 
#include "native_artifact_emit.h"
#include "native_json_config.h"
#include "native_runtime_reports.h"
#include "native_shell_bridge.h"
#include "native_support.h"
#include "native_process_capture.h"
#include "native_migrate_verify.h"
#include "native_yyjson_helpers.h"
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifdef _WIN32
#define native_ops_strdup _strdup
#else
#include <unistd.h>
#define native_ops_strdup strdup
#endif
 
static int native_environment_valid(const char *value) {
  return value != NULL && (
    streq(value, "development") ||
    streq(value, "test") ||
    streq(value, "testing") ||
    streq(value, "staging") ||
    streq(value, "production")
  );
}
 
static int native_command_exists(const char *command) {
#ifndef _WIN32
  char *path_copy;
  char *segment;
  char *state = NULL;
  const char *path_env;
  if (command == NULL || command[0] == '\0') {
    return 0;
  }
  if (strchr(command, '/') != NULL) {
    return access(command, X_OK) == 0;
  }
  path_env = getenv("PATH");
  if (path_env == NULL || path_env[0] == '\0') {
    return 0;
  }
  path_copy = native_ops_strdup(path_env);
  if (path_copy == NULL) {
    return 0;
  }
  for (segment = strtok_r(path_copy, ":", &state);
       segment != NULL;
       segment = strtok_r(NULL, ":", &state)) {
    char candidate[4096];
    if (segment[0] == '\0') {
      continue;
    }
    snprintf(candidate, sizeof(candidate), "%s/%s", segment, command);
    if (access(candidate, X_OK) == 0) {
      free(path_copy);
      return 1;
    }
  }
  free(path_copy);
#endif
  return 0;
}
 
static int native_cross_deb_packaging_available(const char *repo_root) {
#ifndef _WIN32
  char compose_path[4096];
  FILE *handle;
  if (repo_root == NULL || repo_root[0] == '\0') {
    return 0;
  }
  snprintf(compose_path, sizeof(compose_path), "%s/cross/docker/docker-compose.yml", repo_root);
  handle = fopen(compose_path, "r");
  if (handle == NULL) {
    return 0;
  }
  fclose(handle);
  return native_command_exists("docker");
#else
  (void)repo_root;
  return 0;
#endif
}
 
static char *native_default_environment(const AppRuntime *app) {
  char *environment = app != NULL ? conf_lookup_value(app->runtime_conf_path, "environment") : NULL;
  if (environment == NULL || environment[0] == '\0') {
    free(environment);
    return native_ops_strdup("development");
  }
  return environment;
}
 
static char *native_default_backend(const AppRuntime *app) {
  char *backend = app != NULL ? conf_lookup_value(app->runtime_conf_path, "db_backend") : NULL;
  if (backend == NULL || backend[0] == '\0') {
    free(backend);
    return native_ops_strdup("sqlite");
  }
  return backend;
}
 
static char *native_default_sqlite_path(const AppRuntime *app) {
  char *db_path = app != NULL ? conf_lookup_value(app->runtime_conf_path, "db_path") : NULL;
  char buffer[4096];
  if (db_path != NULL && db_path[0] != '\0') {
    return db_path;
  }
  free(db_path);
  snprintf(buffer, sizeof(buffer), "/var/lib/pharos/%s.sqlite3", app != NULL && app->app_id != NULL ? app->app_id : "app");
  return native_ops_strdup(buffer);
}
 
static char *native_capture_trimmed(char *const argv[], int *code_out) {
  char *output = NULL;
  int code = run_process_capture_native(argv, &output);
  if (output != NULL) {
    trim_in_place(output);
  }
  if (code_out != NULL) {
    *code_out = code;
  }
  return output;
}
 
 
 
static int native_identifier_safe(const char *value) {
  const char *cursor = value;
  if (value == NULL || value[0] == '\0') {
    return 0;
  }
  while (*cursor != '\0') {
    if (!( (*cursor >= 'A' && *cursor <= 'Z') || (*cursor >= 'a' && *cursor <= 'z') || (*cursor >= '0' && *cursor <= '9') || *cursor == '_' )) {
      return 0;
    }
    cursor++;
  }
  return 1;
}
 
static int native_append_escaped_sql_char(Buffer *buffer, char value) {
  if (buffer == NULL) {
    return -1;
  }
  switch (value) {
    case '\'':
      return buffer_append(buffer, "''", 2);
    default:
      return buffer_append(buffer, &value, 1);
  }
}
 
static char *native_sql_literal_escape(const char *value) {
  Buffer buffer;
  const char *cursor = value != NULL ? value : "";
  buffer_init(&buffer);
  while (*cursor != '\0') {
    if (native_append_escaped_sql_char(&buffer, *cursor) != 0) {
      buffer_free(&buffer);
      return NULL;
    }
    cursor++;
  }
  return buffer.data;
}
 
static const char *native_output_path_status(int file_exists, int file_writable, int parent_exists, int parent_writable) {
  if (file_exists && !file_writable) {
    return "not_writable";
  }
  if (!file_exists && !parent_exists) {
    return "missing_parent_dir";
  }
  if (!file_exists && !parent_writable) {
    return "parent_not_writable";
  }
  return "ok";
}
 
static char *native_sqlite_query_value(const char *db_path, const char *sql) {
  char *argv_list[4];
  int code = 0;
  if (db_path == NULL || sql == NULL) {
    return NULL;
  }
  argv_list[0] = "sqlite3";
  argv_list[1] = (char *)db_path;
  argv_list[2] = (char *)sql;
  argv_list[3] = NULL;
  return native_capture_trimmed(argv_list, &code);
}
 
static int native_sqlite_table_exists(const char *db_path, const char *table_name) {
  char query[1024];
  char *escaped = NULL;
  char *result = NULL;
  int exists = 0;
  if (db_path == NULL || !native_identifier_safe(table_name)) {
    return 0;
  }
  escaped = native_sql_literal_escape(table_name);
  if (escaped == NULL) {
    return 0;
  }
  snprintf(query, sizeof(query), "SELECT name FROM sqlite_master WHERE type = 'table' AND name = '%s' LIMIT 1;", escaped);
  result = native_sqlite_query_value(db_path, query);
  if (result != NULL && streq(result, table_name)) {
    exists = 1;
  }
  free(escaped);
  free(result);
  return exists;
}
 
static long native_sqlite_table_row_count(const char *db_path, const char *table_name) {
  char query[1024];
  char *result = NULL;
  long value = 0;
  if (db_path == NULL || !native_identifier_safe(table_name)) {
    return 0;
  }
  snprintf(query, sizeof(query), "SELECT COUNT(*) FROM \"%s\";", table_name);
  result = native_sqlite_query_value(db_path, query);
  if (result != NULL && result[0] != '\0') {
    value = strtol(result, NULL, 10);
  }
  free(result);
  return value;
}
 
static long native_sqlite_migration_applied_count(const char *db_path, const char *migration_id, const char *backend) {
  char query[2048];
  char *escaped_id = NULL;
  char *escaped_backend = NULL;
  char *result = NULL;
  long value = 0;
  if (db_path == NULL || migration_id == NULL || backend == NULL) {
    return 0;
  }
  escaped_id = native_sql_literal_escape(migration_id);
  escaped_backend = native_sql_literal_escape(backend);
  if (escaped_id == NULL || escaped_backend == NULL) {
    free(escaped_id);
    free(escaped_backend);
    return 0;
  }
  snprintf(query, sizeof(query), "SELECT COUNT(*) FROM pharos_schema_migration WHERE migration_id = '%s' AND backend = '%s';", escaped_id, escaped_backend);
  result = native_sqlite_query_value(db_path, query);
  if (result != NULL && result[0] != '\0') {
    value = strtol(result, NULL, 10);
  }
  free(escaped_id);
  free(escaped_backend);
  free(result);
  return value;
}
 
static char *native_sqlite_migration_applied_schema_version(const char *db_path, const char *migration_id, const char *backend) {
  char query[2048];
  char *escaped_id = NULL;
  char *escaped_backend = NULL;
  char *result = NULL;
  if (db_path == NULL || migration_id == NULL || backend == NULL) {
    return NULL;
  }
  escaped_id = native_sql_literal_escape(migration_id);
  escaped_backend = native_sql_literal_escape(backend);
  if (escaped_id == NULL || escaped_backend == NULL) {
    free(escaped_id);
    free(escaped_backend);
    return NULL;
  }
  snprintf(query, sizeof(query), "SELECT schema_version FROM pharos_schema_migration WHERE migration_id = '%s' AND backend = '%s' ORDER BY applied_at DESC LIMIT 1;", escaped_id, escaped_backend);
  result = native_sqlite_query_value(db_path, query);
  free(escaped_id);
  free(escaped_backend);
  return result;
}
 
static char *native_sqlite_migration_applied_checksum(const char *db_path, const char *migration_id, const char *backend) {
  char query[2048];
  char *escaped_id = NULL;
  char *escaped_backend = NULL;
  char *result = NULL;
  if (db_path == NULL || migration_id == NULL || backend == NULL) {
    return NULL;
  }
  escaped_id = native_sql_literal_escape(migration_id);
  escaped_backend = native_sql_literal_escape(backend);
  if (escaped_id == NULL || escaped_backend == NULL) {
    free(escaped_id);
    free(escaped_backend);
    return NULL;
  }
  snprintf(query, sizeof(query), "SELECT checksum_sha256 FROM pharos_schema_migration WHERE migration_id = '%s' AND backend = '%s' ORDER BY applied_at DESC LIMIT 1;", escaped_id, escaped_backend);
  result = native_sqlite_query_value(db_path, query);
  free(escaped_id);
  free(escaped_backend);
  return result;
}
 
 
 
static char *native_output_path_check_json(const char *file_path, const char *label) {
  char *label_json = json_string_dup_native(label != NULL ? label : "path");
  char *path_json = NULL;
  char *parent_json = NULL;
  char *result = NULL;
  char *parent_dir = NULL;
  int file_exists = 0;
  int file_writable = 0;
  int parent_exists = 0;
  int parent_writable = 0;
  const char *status = "ok";
  size_t needed;
  if (file_path == NULL || file_path[0] == '\0') {
    needed = strlen(label != NULL ? label : "path") + 160;
    result = (char *)malloc(needed);
    if (result != NULL) {
      snprintf(result, needed, "{\"label\":\"%s\",\"configured\":false,\"exists\":false,\"parent_exists\":false,\"parent_writable\":false,\"file_writable\":false,\"status\":\"not_configured\"}", label != NULL ? label : "path");
    }
    free(label_json);
    return result;
  }
  parent_dir = path_dirname(file_path);
  file_exists = path_exists(file_path);
  file_writable = file_exists && path_is_writable(file_path);
  parent_exists = parent_dir != NULL && path_is_directory(parent_dir);
  parent_writable = parent_exists && path_is_writable(parent_dir);
  status = native_output_path_status(file_exists, file_writable, parent_exists, parent_writable);
  path_json = json_string_dup_native(file_path);
  parent_json = json_string_dup_native(parent_dir != NULL ? parent_dir : "");
  needed = (label_json != NULL ? strlen(label_json) : 0) + (path_json != NULL ? strlen(path_json) : 0) + (parent_json != NULL ? strlen(parent_json) : 0) + strlen(status) + 192;
  result = (char *)malloc(needed);
  if (result != NULL && label_json != NULL && path_json != NULL && parent_json != NULL) {
    snprintf(result, needed, "{\"label\":%s,\"configured\":true,\"path\":%s,\"parent_dir\":%s,\"exists\":%s,\"parent_exists\":%s,\"parent_writable\":%s,\"file_writable\":%s,\"status\":\"%s\"}", label_json, path_json, parent_json, file_exists ? "true" : "false", parent_exists ? "true" : "false", parent_writable ? "true" : "false", file_writable ? "true" : "false", status);
  }
  free(label_json);
  free(path_json);
  free(parent_json);
  free(parent_dir);
  return result;
}
 
static char *native_db_check_json(const AppRuntime *app, const char *backend) {
  char *backend_json = json_string_dup_native(backend != NULL ? backend : "sqlite");
  char *result = NULL;
  size_t needed;
  if (backend != NULL && streq(backend, "sqlite")) {
    char *sqlite_path = native_default_sqlite_path(app);
    char *sqlite_path_json = json_string_dup_native(sqlite_path != NULL ? sqlite_path : "");
    char *parent_dir = path_dirname(sqlite_path != NULL ? sqlite_path : "");
    char *parent_json = json_string_dup_native(parent_dir != NULL ? parent_dir : "");
    int path_exists_value = sqlite_path != NULL && path_exists(sqlite_path);
    int parent_exists_value = parent_dir != NULL && path_is_directory(parent_dir);
    needed = (backend_json != NULL ? strlen(backend_json) : 0) + (sqlite_path_json != NULL ? strlen(sqlite_path_json) : 0) + (parent_json != NULL ? strlen(parent_json) : 0) + 128;
    result = (char *)malloc(needed);
    if (result != NULL && backend_json != NULL && sqlite_path_json != NULL && parent_json != NULL) {
      snprintf(result, needed, "[{\"backend\":%s,\"kind\":\"sqlite_path\",\"path\":%s,\"parent_dir\":%s,\"path_exists\":%s,\"parent_exists\":%s,\"status\":\"%s\"}]", backend_json, sqlite_path_json, parent_json, path_exists_value ? "true" : "false", parent_exists_value ? "true" : "false", parent_exists_value ? "ok" : "missing_parent_dir");
    }
    free(sqlite_path);
    free(sqlite_path_json);
    free(parent_dir);
    free(parent_json);
  } else {
    char *host = app != NULL ? conf_lookup_value(app->runtime_conf_path, "db_host") : NULL;
    char *port = app != NULL ? conf_lookup_value(app->runtime_conf_path, "db_port") : NULL;
    char *name = app != NULL ? conf_lookup_value(app->runtime_conf_path, "db_name") : NULL;
    char *user = app != NULL ? conf_lookup_value(app->runtime_conf_path, "db_user") : NULL;
    char *host_json = json_string_dup_native(host != NULL ? host : "");
    char *port_json = json_string_dup_native(port != NULL ? port : "");
    char *name_json = json_string_dup_native(name != NULL ? name : "");
    char *user_json = json_string_dup_native(user != NULL ? user : "");
    int host_present = host != NULL && host[0] != '\0';
    int port_present = port != NULL && port[0] != '\0';
    int name_present = name != NULL && name[0] != '\0';
    int user_present = user != NULL && user[0] != '\0';
    int ok = host_present && port_present && name_present && user_present;
    needed = (backend_json != NULL ? strlen(backend_json) : 0) + (host_json != NULL ? strlen(host_json) : 0) + (port_json != NULL ? strlen(port_json) : 0) + (name_json != NULL ? strlen(name_json) : 0) + (user_json != NULL ? strlen(user_json) : 0) + 256;
    result = (char *)malloc(needed);
    if (result != NULL && backend_json != NULL && host_json != NULL && port_json != NULL && name_json != NULL && user_json != NULL) {
      snprintf(result, needed, "[{\"backend\":%s,\"kind\":\"postgresql_connection\",\"host\":%s,\"port\":%s,\"database\":%s,\"user\":%s,\"host_present\":%s,\"port_present\":%s,\"database_present\":%s,\"user_present\":%s,\"tls_ok\":true,\"status\":\"%s\"}]", backend_json, host_json, port_json, name_json, user_json, host_present ? "true" : "false", port_present ? "true" : "false", name_present ? "true" : "false", user_present ? "true" : "false", ok ? "ok" : "incomplete");
    }
    free(host);
    free(port);
    free(name);
    free(user);
    free(host_json);
    free(port_json);
    free(name_json);
    free(user_json);
  }
  free(backend_json);
  return result;
}
 
static char *build_native_app_config_report_local_json(const AppRuntime *app) {
  char *environment = native_default_environment(app);
  char *backend = native_default_backend(app);
  char *environment_json = json_string_dup_native(environment != NULL ? environment : "development");
  char *backend_json = json_string_dup_native(backend != NULL ? backend : "sqlite");
  char *log_path_json = json_string_dup_native(app != NULL && app->log_path != NULL ? app->log_path : "");
  char *error_report_path_json = (app != NULL && app->error_report_path != NULL && app->error_report_path[0] != '\0') ? json_string_dup_native(app->error_report_path) : native_ops_strdup("null");
  char *db_checks_json = native_db_check_json(app, backend);
  char *log_check_json = native_output_path_check_json(app != NULL ? app->log_path : NULL, "app_log_path");
  char *error_check_json = native_output_path_check_json(app != NULL ? app->error_report_path : NULL, "app_error_report_path");
  int environment_valid = native_environment_valid(environment != NULL ? environment : "development");
  int db_ok = db_checks_json != NULL && strstr(db_checks_json, "\"status\":\"ok\"") != NULL && strstr(db_checks_json, "incomplete") == NULL && strstr(db_checks_json, "missing_parent_dir") == NULL;
  int log_ok = log_check_json != NULL && strstr(log_check_json, "\"status\":\"ok\"") != NULL;
  int error_ok = error_check_json != NULL && (strstr(error_check_json, "\"status\":\"ok\"") != NULL || strstr(error_check_json, "\"status\":\"not_configured\"") != NULL);
  const char *status = (environment_valid && db_ok && log_ok && error_ok) ? "ok" : "invalid";
  char *result = NULL;
  size_t needed = (environment_json != NULL ? strlen(environment_json) : 0) + (backend_json != NULL ? strlen(backend_json) : 0) + (log_path_json != NULL ? strlen(log_path_json) : 0) + (error_report_path_json != NULL ? strlen(error_report_path_json) : 0) + (db_checks_json != NULL ? strlen(db_checks_json) : 0) + (log_check_json != NULL ? strlen(log_check_json) : 0) + (error_check_json != NULL ? strlen(error_check_json) : 0) + 512;
  result = (char *)malloc(needed);
  if (result != NULL && environment_json != NULL && backend_json != NULL && log_path_json != NULL && error_report_path_json != NULL && db_checks_json != NULL && log_check_json != NULL && error_check_json != NULL) {
    snprintf(result, needed, "{\"environment\":%s,\"backend\":%s,\"environment_valid\":%s,\"log_path\":%s,\"error_report_path\":%s,\"required_env_refs\":[],\"secret_env_refs\":[],\"required_env_checks\":[],\"secret_env_checks\":[],\"db_checks\":%s,\"log_checks\":[%s,%s],\"issues\":[],\"status\":\"%s\"}", environment_json, backend_json, environment_valid ? "true" : "false", log_path_json, error_report_path_json, db_checks_json, log_check_json, error_check_json, status);
  }
  free(environment);
  free(backend);
  free(environment_json);
  free(backend_json);
  free(log_path_json);
  free(error_report_path_json);
  free(db_checks_json);
  free(log_check_json);
  free(error_check_json);
  return result;
}
 
static char *build_runtime_summary_json_from_app(const AppRuntime *app) {
  char *app_id_json = json_string_dup_native(app != NULL && app->app_id != NULL ? app->app_id : "");
  char *mount_json = json_string_dup_native(app != NULL && app->base_path != NULL ? app->base_path : "");
  char *app_root_json = json_string_dup_native(app != NULL && app->app_root != NULL ? app->app_root : "");
  char *build_dir_json = json_string_dup_native(app != NULL && app->build_dir != NULL ? app->build_dir : "");
  char *state_path_json = json_string_dup_native(app != NULL && app->state_path != NULL ? app->state_path : "");
  char *log_path_json = json_string_dup_native(app != NULL && app->log_path != NULL ? app->log_path : "");
  char *log_format_json = json_string_dup_native(app != NULL && app->log_format != NULL ? app->log_format : "service");
  char *error_report_path_json = json_string_dup_native(app != NULL && app->error_report_path != NULL ? app->error_report_path : "");
  char *debug_json = json_string_dup_native(app != NULL && app->debug != NULL ? app->debug : "false");
  char *host_profile_json = json_string_dup_native(app != NULL && app->host_profile != NULL ? app->host_profile : "dynamic-app");
  char *compiled_entrypoint_json = json_string_dup_native(app != NULL && app->compiled_entrypoint != NULL ? app->compiled_entrypoint : "");
  char *runtime_conf_path_json = json_string_dup_native(app != NULL && app->runtime_conf_path != NULL ? app->runtime_conf_path : "");
  char *result = NULL;
  size_t needed = (app_id_json != NULL ? strlen(app_id_json) : 0) + (mount_json != NULL ? strlen(mount_json) : 0) + (app_root_json != NULL ? strlen(app_root_json) : 0) + (build_dir_json != NULL ? strlen(build_dir_json) : 0) + (state_path_json != NULL ? strlen(state_path_json) : 0) + (log_path_json != NULL ? strlen(log_path_json) : 0) + (log_format_json != NULL ? strlen(log_format_json) : 0) + (error_report_path_json != NULL ? strlen(error_report_path_json) : 0) + (debug_json != NULL ? strlen(debug_json) : 0) + (host_profile_json != NULL ? strlen(host_profile_json) : 0) + (compiled_entrypoint_json != NULL ? strlen(compiled_entrypoint_json) : 0) + (runtime_conf_path_json != NULL ? strlen(runtime_conf_path_json) : 0) + 384;
  result = (char *)malloc(needed);
  if (result != NULL && app_id_json != NULL && mount_json != NULL && app_root_json != NULL && build_dir_json != NULL && state_path_json != NULL && log_path_json != NULL && log_format_json != NULL && error_report_path_json != NULL && debug_json != NULL && host_profile_json != NULL && compiled_entrypoint_json != NULL && runtime_conf_path_json != NULL) {
    snprintf(result, needed, "{\"app_id\":%s,\"mount_path\":%s,\"app_root\":%s,\"build_dir\":%s,\"state_path\":%s,\"log_path\":%s,\"log_format\":%s,\"error_report_path\":%s,\"debug\":%s,\"host_profile\":%s,\"compiled_entrypoint\":%s,\"runtime_conf_path\":%s}", app_id_json, mount_json, app_root_json, build_dir_json, state_path_json, log_path_json, log_format_json, error_report_path_json, debug_json, host_profile_json, compiled_entrypoint_json, runtime_conf_path_json);
  }
  free(app_id_json);
  free(mount_json);
  free(app_root_json);
  free(build_dir_json);
  free(state_path_json);
  free(log_path_json);
  free(log_format_json);
  free(error_report_path_json);
  free(debug_json);
  free(host_profile_json);
  free(compiled_entrypoint_json);
  free(runtime_conf_path_json);
  return result;
}
 
static void append_app_common_flags(const ServeConfig *config, char *argv_list[], int *argc) {
  if (config->conf_path != NULL) {
    argv_list[(*argc)++] = "--conf";
    argv_list[(*argc)++] = config->conf_path;
  }
  if (config->app_dir != NULL) {
    argv_list[(*argc)++] = "--app-dir";
    argv_list[(*argc)++] = config->app_dir;
  }
  if (config->build_dir != NULL) {
    argv_list[(*argc)++] = "--build-dir";
    argv_list[(*argc)++] = config->build_dir;
  }
  if (config->state_dir != NULL) {
    argv_list[(*argc)++] = "--state-dir";
    argv_list[(*argc)++] = config->state_dir;
  }
  if (config->state_path != NULL) {
    argv_list[(*argc)++] = "--state-path";
    argv_list[(*argc)++] = config->state_path;
  }
  if (config->base_path != NULL) {
    argv_list[(*argc)++] = "--base-path";
    argv_list[(*argc)++] = config->base_path;
  }
}
 
static char *native_build_sqlite_migrate_verify_failure_report_json(
    const ServeConfig *config,
    const AppRuntime *app,
    const char *error_text) {
  char *target_id_json = NULL;
  char *status_json = NULL;
  char *error_json = NULL;
  char *db_path = NULL;
  char *db_path_json = NULL;
  char *manifest_path = NULL;
  char *migration_fixture_rel = NULL;
  char *entity_fixture_rel = NULL;
  char *query_fixture_rel = NULL;
  char *migration_fixture_path = NULL;
  char *entity_fixture_path = NULL;
  char *query_fixture_path = NULL;
  char *migration_fixture_json = NULL;
  char *entity_fixture_json = NULL;
  char *query_fixture_json = NULL;
  char *result = NULL;
  yyjson_doc *manifest_doc = NULL;
  yyjson_val *manifest_root = NULL;
  yyjson_val *database_obj = NULL;
  size_t needed;
 
  if (config == NULL || app == NULL) {
    return NULL;
  }
  target_id_json = json_string_dup_native(
      config->target_id != NULL ? config->target_id : app->app_id);
  status_json = json_string_dup_native("verification_failed");
  error_json = json_string_dup_native(
      error_text != NULL ? error_text : "native sqlite migrate verify unavailable");
  db_path = native_default_sqlite_path(app);
  db_path_json = json_string_dup_native(db_path != NULL ? db_path : "");
 
  manifest_path = path_join(app->app_root, "pharos.app.json");
  if (manifest_path != NULL && path_exists(manifest_path)) {
    manifest_doc = native_json_doc_load_file(manifest_path);
  }
  if (manifest_doc != NULL) {
    manifest_root = yyjson_doc_get_root(manifest_doc);
    database_obj = native_json_obj_get(manifest_root, "database");
    if (database_obj != NULL) {
      migration_fixture_rel =
          native_json_obj_get_string_dup(database_obj, "migration_fixture");
      entity_fixture_rel =
          native_json_obj_get_string_dup(database_obj, "entity_fixture");
      query_fixture_rel = native_json_obj_get_string_dup(database_obj, "query_fixture");
    }
  }
  migration_fixture_path =
      migration_fixture_rel != NULL ? resolve_relative_to(app->app_root, migration_fixture_rel)
                                    : NULL;
  entity_fixture_path =
      entity_fixture_rel != NULL ? resolve_relative_to(app->app_root, entity_fixture_rel) : NULL;
  query_fixture_path =
      query_fixture_rel != NULL ? resolve_relative_to(app->app_root, query_fixture_rel) : NULL;
  migration_fixture_json = migration_fixture_path != NULL
                               ? json_string_dup_native(migration_fixture_path)
                               : native_ops_strdup("null");
  entity_fixture_json = entity_fixture_path != NULL
                            ? json_string_dup_native(entity_fixture_path)
                            : native_ops_strdup("null");
  query_fixture_json = query_fixture_path != NULL
                           ? json_string_dup_native(query_fixture_path)
                           : native_ops_strdup("null");
 
  if (target_id_json == NULL || status_json == NULL || error_json == NULL ||
      db_path_json == NULL || migration_fixture_json == NULL ||
      entity_fixture_json == NULL || query_fixture_json == NULL) {
    goto cleanup;
  }
 
  needed = strlen(target_id_json) + strlen(status_json) + strlen(error_json) +
           strlen(db_path_json) + strlen(migration_fixture_json) +
           strlen(entity_fixture_json) + strlen(query_fixture_json) + 2048;
  result = (char *)malloc(needed);
  if (result != NULL) {
    snprintf(result, needed,
             "{\"report_id\":\"pharos-migrate-verify-v1\","
             "\"target_kind\":\"app\",\"target_id\":%s,"
             "\"backend\":\"sqlite\",\"status\":%s,"
             "\"error\":%s,\"live_database_verified\":false,"
             "\"database_present\":false,\"ledger_table_present\":false,"
             "\"db_path\":%s,\"schema_version\":0,"
             "\"preferred_backend\":\"sqlite\","
             "\"development_backend\":\"sqlite\","
             "\"testing_backend\":\"sqlite\","
             "\"migration_fixture\":%s,\"entity_fixture\":%s,"
             "\"query_fixture\":%s,\"db_config\":{\"backend\":\"sqlite\"},"
             "\"verification_contract\":{},\"required_tables\":[],"
             "\"required_migration_ids\":[],\"seed_expectations\":[],"
             "\"table_checks\":[],\"missing_tables\":[],"
             "\"seed_checks\":[],\"failed_seed_expectations\":[],"
             "\"migration_checks\":[],\"missing_migrations\":[],"
             "\"drifted_migrations\":[]}",
             target_id_json, status_json, error_json, db_path_json,
             migration_fixture_json, entity_fixture_json, query_fixture_json);
  }
 
cleanup:
  free(target_id_json);
  free(status_json);
  free(error_json);
  free(db_path);
  free(db_path_json);
  free(manifest_path);
  free(migration_fixture_rel);
  free(entity_fixture_rel);
  free(query_fixture_rel);
  free(migration_fixture_path);
  free(entity_fixture_path);
  free(query_fixture_path);
  free(migration_fixture_json);
  free(entity_fixture_json);
  free(query_fixture_json);
  native_json_doc_free(manifest_doc);
  return result;
}
 
static int native_sqlite_migrate_verify_preflight_ok(const AppRuntime *app) {
  char *manifest_path = NULL;
  char *migration_fixture_rel = NULL;
  char *migration_fixture_path = NULL;
  yyjson_doc *manifest_doc = NULL;
  yyjson_doc *fixture_doc = NULL;
  yyjson_val *manifest_root = NULL;
  yyjson_val *database_obj = NULL;
  yyjson_val *fixture_root = NULL;
  yyjson_val *sqlite_backend = NULL;
  yyjson_val *verification_contract = NULL;
  yyjson_val *required_tables = NULL;
  yyjson_val *required_migration_ids = NULL;
  yyjson_arr_iter migration_iter;
  yyjson_val *migration_id_value = NULL;
  int ok = 0;
 
  if (app == NULL || app->app_root == NULL) {
    return 0;
  }
  manifest_path = path_join(app->app_root, "pharos.app.json");
  if (manifest_path == NULL || !path_exists(manifest_path)) {
    goto cleanup;
  }
  manifest_doc = native_json_doc_load_file(manifest_path);
  if (manifest_doc == NULL) {
    goto cleanup;
  }
  manifest_root = yyjson_doc_get_root(manifest_doc);
  database_obj = native_json_obj_get(manifest_root, "database");
  if (database_obj == NULL) {
    goto cleanup;
  }
  migration_fixture_rel =
      native_json_obj_get_string_dup(database_obj, "migration_fixture");
  if (migration_fixture_rel == NULL || migration_fixture_rel[0] == '\0') {
    goto cleanup;
  }
  migration_fixture_path = resolve_relative_to(app->app_root, migration_fixture_rel);
  if (migration_fixture_path == NULL || !path_exists(migration_fixture_path)) {
    goto cleanup;
  }
  fixture_doc = native_json_doc_load_file(migration_fixture_path);
  if (fixture_doc == NULL) {
    goto cleanup;
  }
  fixture_root = yyjson_doc_get_root(fixture_doc);
  sqlite_backend = native_json_find_backend_by_name(fixture_root, "sqlite");
  if (sqlite_backend == NULL) {
    goto cleanup;
  }
  verification_contract = native_json_obj_get(sqlite_backend, "verification_contract");
  if (verification_contract == NULL) {
    goto cleanup;
  }
  required_tables = native_json_obj_get_array(verification_contract, "required_tables");
  required_migration_ids =
      native_json_obj_get_array(verification_contract, "required_migration_ids");
  if (required_tables == NULL || required_migration_ids == NULL) {
    goto cleanup;
  }
  if (!yyjson_arr_iter_init(required_migration_ids, &migration_iter)) {
    goto cleanup;
  }
  while ((migration_id_value = yyjson_arr_iter_next(&migration_iter)) != NULL) {
    const char *migration_id = NULL;
    if (!yyjson_is_str(migration_id_value)) {
      goto cleanup;
    }
    migration_id = yyjson_get_str(migration_id_value);
    if (native_json_find_migration_by_id(fixture_root, migration_id) == NULL) {
      goto cleanup;
    }
  }
  ok = 1;
 
cleanup:
  free(manifest_path);
  free(migration_fixture_rel);
  free(migration_fixture_path);
  native_json_doc_free(manifest_doc);
  native_json_doc_free(fixture_doc);
  return ok;
}
 
static char *capture_migrate_verify_report_json(const char *repo_root, const ServeConfig *config, const AppRuntime *app, const char *backend, char **status_out, char **error_out) {
  char *native_report = NULL;
  char *argv_list[32];
  int argc = 0;
  char *output = NULL;
  int code;
  int output_is_json = 0;
  char *status = NULL;
  if (backend != NULL && streq(backend, "sqlite") && app != NULL) {
    if (native_sqlite_migrate_verify_preflight_ok(app)) {
      native_report = native_capture_migrate_verify_sqlite_report_json(
          config, app, status_out, error_out);
      if (native_report != NULL) {
        if (strstr(native_report, "\"status\":\"verification_failed\"") != NULL) {
          free(native_report);
          if (status_out != NULL) {
            free(*status_out);
            *status_out = native_ops_strdup("verification_failed");
          }
          if (error_out != NULL) {
            free(*error_out);
            *error_out =
                native_ops_strdup("native sqlite migrate verify unavailable");
          }
          native_report = native_build_sqlite_migrate_verify_failure_report_json(
              config, app, "native sqlite migrate verify unavailable");
        }
        if (native_report != NULL) {
          return native_report;
        }
      }
    } else {
      if (status_out != NULL) {
        *status_out = native_ops_strdup("verification_failed");
      }
      if (error_out != NULL) {
        *error_out =
            native_ops_strdup("native sqlite migrate verify unavailable");
      }
      native_report = native_build_sqlite_migrate_verify_failure_report_json(
          config, app, "native sqlite migrate verify unavailable");
      if (native_report != NULL) {
        return native_report;
      }
    }
  }
  argv_list[argc++] = "migrate";
  argv_list[argc++] = "verify";
  argv_list[argc++] = "app";
  argv_list[argc++] = config->target_id;
  append_app_common_flags(config, argv_list, &argc);
  if (backend != NULL && backend[0] != '\0') {
    argv_list[argc++] = "--backend";
    argv_list[argc++] = (char *)backend;
  }
  argv_list[argc++] = "--text";
  code = shell_runtime_command_capture_native(repo_root, argc, argv_list, &output);
  if (output != NULL) {
    trim_in_place(output);
    output_is_json = output[0] == '{';
  }
  if (output_is_json) {
    status = json_find_string(output, "status");
  }
  if (status_out != NULL) {
    *status_out = status != NULL ? status : native_ops_strdup(code == 0 ? "verified" : "failed");
  } else {
    free(status);
  }
  if (output_is_json) {
    if (error_out != NULL) {
      *error_out = NULL;
    }
    return output;
  }
  if (error_out != NULL && *error_out == NULL && output != NULL && output[0] != '\0') {
    *error_out = native_ops_strdup(output);
  }
  free(output);
  return native_ops_strdup("null");
}
 
char *build_native_app_doctor_report_local_json(const char *repo_root, const ServeConfig *config, const char *artifact_dir, const AppRuntime *app, const char *host_target) {
  char *backend = native_default_backend(app);
  char *runtime_summary_json = build_runtime_summary_json_from_app(app);
  char *config_report_json = build_native_app_config_report_local_json(app);
  char *verify_status = NULL;
  char *verify_error = NULL;
  char *verify_report_json = capture_migrate_verify_report_json(repo_root, config, app, backend, &verify_status, &verify_error);
  char *build_verify_report_json = build_native_app_runtime_report_json("pharos-local-app-build-v1", "verify", host_target, "native-host-target", artifact_dir, app);
  char *build_verify_status = native_ops_strdup(build_verify_report_json != NULL ? "ok" : "failed");
  char *build_verify_error = NULL;
  char *target_id_json = json_string_dup_native(app != NULL && app->app_id != NULL ? app->app_id : "");
  char *backend_json = json_string_dup_native(backend != NULL ? backend : "sqlite");
  char *verify_status_json = json_string_dup_native(verify_status != NULL ? verify_status : "failed");
  char *build_verify_status_json = json_string_dup_native(build_verify_status != NULL ? build_verify_status : "failed");
  char *verify_error_json = verify_error != NULL && verify_error[0] != '\0' ? json_string_dup_native(verify_error) : native_ops_strdup("null");
  char *build_verify_error_json = build_verify_error != NULL && build_verify_error[0] != '\0' ? json_string_dup_native(build_verify_error) : native_ops_strdup("null");
  const char *overall_status = (config_report_json != NULL && strstr(config_report_json, "\"status\":\"ok\"") != NULL && verify_status != NULL && streq(verify_status, "verified") && build_verify_report_json != NULL) ? "ok" : "needs_attention";
  char *overall_status_json = json_string_dup_native(overall_status);
  char *result = NULL;
  size_t needed = (target_id_json != NULL ? strlen(target_id_json) : 0) + (backend_json != NULL ? strlen(backend_json) : 0) + (runtime_summary_json != NULL ? strlen(runtime_summary_json) : 0) + (config_report_json != NULL ? strlen(config_report_json) : 0) + (verify_status_json != NULL ? strlen(verify_status_json) : 0) + (build_verify_status_json != NULL ? strlen(build_verify_status_json) : 0) + (verify_error_json != NULL ? strlen(verify_error_json) : 0) + (build_verify_error_json != NULL ? strlen(build_verify_error_json) : 0) + (verify_report_json != NULL ? strlen(verify_report_json) : 0) + (build_verify_report_json != NULL ? strlen(build_verify_report_json) : 0) + (overall_status_json != NULL ? strlen(overall_status_json) : 0) + 4096;
  result = (char *)malloc(needed);
  if (result != NULL && target_id_json != NULL && backend_json != NULL && runtime_summary_json != NULL && config_report_json != NULL && verify_status_json != NULL && build_verify_status_json != NULL && verify_error_json != NULL && build_verify_error_json != NULL && verify_report_json != NULL && build_verify_report_json != NULL && overall_status_json != NULL) {
    snprintf(result, needed, "{\"report_id\":\"pharos-doctor-v1\",\"target_kind\":\"app\",\"target_id\":%s,\"backend\":%s,\"status\":%s,\"runtime_summary\":%s,\"config\":%s,\"migrate_verify_status\":%s,\"build_verify_status\":%s,\"migrate_verify_error\":%s,\"build_verify_error\":%s,\"migrate_verify_report\":%s,\"build_verify_report\":%s}", target_id_json, backend_json, overall_status_json, runtime_summary_json, config_report_json, verify_status_json, build_verify_status_json, verify_error_json, build_verify_error_json, verify_report_json, build_verify_report_json);
  }
  free(backend);
  free(runtime_summary_json);
  free(config_report_json);
  free(verify_status);
  free(verify_error);
  free(verify_report_json);
  free(build_verify_report_json);
  free(build_verify_status);
  free(build_verify_error);
  free(target_id_json);
  free(backend_json);
  free(verify_status_json);
  free(build_verify_status_json);
  free(verify_error_json);
  free(build_verify_error_json);
  free(overall_status_json);
  return result;
}
 
char *build_native_app_drift_report_local_json(const char *repo_root, const ServeConfig *config, const AppRuntime *app) {
  char *backend = native_default_backend(app);
  char *verify_status = NULL;
  char *verify_error = NULL;
  char *verify_report_json = capture_migrate_verify_report_json(repo_root, config, app, backend, &verify_status, &verify_error);
  char *target_id_json = json_string_dup_native(app != NULL && app->app_id != NULL ? app->app_id : "");
  char *backend_json = json_string_dup_native(backend != NULL ? backend : "sqlite");
  char *stderr_json = verify_error != NULL && verify_error[0] != '\0' ? json_string_dup_native(verify_error) : native_ops_strdup("null");
  const char *status = verify_status != NULL && streq(verify_status, "verified") ? "clean" : "failed";
  char *status_json = json_string_dup_native(status);
  char *result = NULL;
  size_t needed = (target_id_json != NULL ? strlen(target_id_json) : 0) + (backend_json != NULL ? strlen(backend_json) : 0) + (stderr_json != NULL ? strlen(stderr_json) : 0) + (verify_report_json != NULL ? strlen(verify_report_json) : 0) + (status_json != NULL ? strlen(status_json) : 0) + 2048;
  result = (char *)malloc(needed);
  if (result != NULL && target_id_json != NULL && backend_json != NULL && stderr_json != NULL && verify_report_json != NULL && status_json != NULL) {
    snprintf(result, needed, "{\"report_id\":\"pharos-drift-check-v1\",\"target_kind\":\"app\",\"target_id\":%s,\"backend\":%s,\"status\":%s,\"drifted_migrations\":[],\"missing_tables\":[],\"missing_migrations\":[],\"stderr\":%s,\"verify_report\":%s}", target_id_json, backend_json, status_json, stderr_json, verify_report_json);
  }
  free(backend);
  free(verify_status);
  free(verify_error);
  free(verify_report_json);
  free(target_id_json);
  free(backend_json);
  free(stderr_json);
  free(status_json);
  return result;
}
 
char *build_native_app_deploy_check_report_local_json(const char *repo_root, const ServeConfig *config, const char *artifact_dir, const AppRuntime *app, const char *host_target) {
  char *doctor_json = build_native_app_doctor_report_local_json(repo_root, config, artifact_dir, app, host_target);
  const char *doctor_ok = doctor_json != NULL && strstr(doctor_json, "\"status\":\"ok\"") != NULL ? "ready" : "blocked";
  char *target_id_json = json_string_dup_native(app != NULL && app->app_id != NULL ? app->app_id : "");
  char *status_json = json_string_dup_native(doctor_ok);
  char *package_formats_json = native_cross_deb_packaging_available(repo_root) ? native_ops_strdup("[\"deb\"]") : native_ops_strdup("[]");
  char *result = NULL;
  size_t needed = (target_id_json != NULL ? strlen(target_id_json) : 0) + (status_json != NULL ? strlen(status_json) : 0) + (package_formats_json != NULL ? strlen(package_formats_json) : 0) + (doctor_json != NULL ? strlen(doctor_json) : 0) + 2048;
  result = (char *)malloc(needed);
  if (result != NULL && target_id_json != NULL && status_json != NULL && package_formats_json != NULL && doctor_json != NULL) {
    snprintf(result, needed, "{\"report_id\":\"pharos-deploy-check-v1\",\"target_kind\":\"app\",\"target_id\":%s,\"status\":%s,\"package_formats\":%s,\"doctor\":%s}", target_id_json, status_json, package_formats_json, doctor_json);
  }
  free(doctor_json);
  free(target_id_json);
  free(status_json);
  free(package_formats_json);
  return result;
}