#include "cbm.h" // cbm_alloc_init — bind 3rd-party allocators to mimalloc before any sqlite/git init

#include "mcp/mcp.h"

#include "watcher/watcher.h"

#include "pipeline/pipeline.h"

#include "store/store.h"

#include "cli/cli.h"

#include "cli/progress_sink.h"

#include "foundation/constants.h"

enum {

MAIN_MIN_ARGC = 1,

MAIN_CLI_ARGC = 2,

MAIN_FLAG_OFF = 5, /* strlen("--ui=") */

MAIN_PORT_OFF = 7, /* strlen("--port=") */

MAIN_MAX_PORT = 65536,

PARENT_WATCHDOG_STACK_SIZE = 64 * CBM_SZ_1K, /* watchdog only polls — tiny stack suffices */

};

#define MAIN_RAM_FRACTION 0.5

#define SLEN(s) (sizeof(s) - 1)

#include "foundation/log.h"

#include "foundation/diagnostics.h"

#include "foundation/platform.h"

#include "foundation/compat.h"

#include "foundation/compat_thread.h"

#include "foundation/mem.h"

#include "foundation/profile.h"

#include "ui/config.h"

#include "ui/http_server.h"

#include "ui/embedded_assets.h"

#include <yyjson/yyjson.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <signal.h>

#include <stdatomic.h>

#ifndef CBM_VERSION

#define CBM_VERSION "dev"

static cbm_watcher_t *g_watcher = NULL;

static cbm_mcp_server_t *g_server = NULL;

static cbm_http_server_t *g_http_server = NULL;

static atomic_int g_shutdown = 0;

static void request_shutdown(void) {

if (atomic_exchange(&g_shutdown, 1)) {

return; /* already shutting down */

}

/* Cancel any in-progress pipeline (async-signal-safe: only does atomic_store) */

if (g_server) {

cbm_pipeline_t *p = cbm_mcp_server_active_pipeline(g_server);

if (p) {

cbm_pipeline_cancel(p);

}

}

/* Release pipeline lock to prevent stale lock on restart */

cbm_pipeline_unlock();

if (g_watcher) {

cbm_watcher_stop(g_watcher);

}

if (g_http_server) {

cbm_http_server_stop(g_http_server);

}

/* Close stdin to unblock getline in the MCP server loop */

(void)fclose(stdin);

}

static void signal_handler(int sig) {

(void)sig;

request_shutdown();

}

#ifndef _WIN32

static void *parent_watchdog_thread(void *arg) {

pid_t initial_ppid = *(pid_t *)arg;

const unsigned int poll_interval_us = 500000; /* 500ms */

while (!atomic_load(&g_shutdown)) {

cbm_usleep(poll_interval_us);

if (atomic_load(&g_shutdown)) {

break;

}

/* initial_ppid > 1 guards against an already-orphaned start (ppid==1),

if (initial_ppid > 1 && getppid() != initial_ppid) {

cbm_log_warn("parent.exited", "reason", "ppid_changed");

request_shutdown();

exit(0);

}

}

return NULL;

}

static void *watcher_thread(void *arg) {

cbm_watcher_t *w = arg;

#define WATCHER_BASE_INTERVAL_MS 5000

cbm_watcher_run(w, WATCHER_BASE_INTERVAL_MS);

return NULL;

}

static void *http_thread(void *arg) {

cbm_http_server_t *srv = arg;

cbm_http_server_run(srv);

return NULL;

}

static int watcher_index_fn(const char *project_name, const char *root_path, void *user_data) {

(void)user_data;

/* Skip indexing if shutdown is in progress */

if (atomic_load(&g_shutdown)) {

return 0;

}

/* Non-blocking: skip if another pipeline is already running.

if (!cbm_pipeline_try_lock()) {

cbm_log_info("watcher.skip", "project", project_name, "reason", "pipeline_busy");

return 0;

}

cbm_log_info("watcher.reindex", "project", project_name, "path", root_path);

cbm_pipeline_t *p = cbm_pipeline_new(root_path, NULL, CBM_MODE_FULL);

if (!p) {

cbm_pipeline_unlock();

return CBM_NOT_FOUND;

}

int rc = cbm_pipeline_run(p);

cbm_pipeline_free(p);

cbm_pipeline_unlock();

return rc;

}

#define CLI_USAGE "Usage: codebase-memory-mcp cli [--progress] [--json] <tool_name> [json_args]\n"

static int cli_print_mcp_result(const char *result) {

yyjson_doc *doc = yyjson_read(result, strlen(result), 0);

if (!doc) {

printf("%s\n", result);

return 0;

}

yyjson_val *root = yyjson_doc_get_root(doc);

yyjson_val *err_val = yyjson_obj_get(root, "isError");

bool is_error = err_val && yyjson_get_bool(err_val);

const char *text = NULL;

yyjson_val *content = yyjson_obj_get(root, "content");

if (yyjson_is_arr(content) && yyjson_arr_size(content) > 0) {

yyjson_val *tv = yyjson_obj_get(yyjson_arr_get_first(content), "text");

text = tv ? yyjson_get_str(tv) : NULL;

}

if (text) {

(void)fprintf(is_error ? stderr : stdout, "%s\n", text);

} else {

printf("%s\n", result);

}

yyjson_doc_free(doc);

return is_error ? SKIP_ONE : 0;

}

static bool cli_strip_flag(int *argc, char **argv, const char *flag) {

for (int i = 0; i < *argc; i++) {

if (strcmp(argv[i], flag) != 0) {

continue;

}

for (int j = i; j < *argc - SKIP_ONE; j++) {

argv[j] = argv[j + SKIP_ONE];

}

(*argc)--;

return true;

}

return false;

}

static int run_cli(int argc, char **argv) {

if (argc < MAIN_MIN_ARGC) {

(void)fprintf(stderr, CLI_USAGE);

return SKIP_ONE;

}

bool progress = cli_strip_flag(&argc, argv, "--progress");

bool raw_json = cli_strip_flag(&argc, argv, "--json");

if (argc < MAIN_MIN_ARGC) {

(void)fprintf(stderr, CLI_USAGE);

return SKIP_ONE;

}

const char *tool_name = argv[0];

const char *args_json = argc >= MAIN_CLI_ARGC ? argv[SKIP_ONE] : "{}";

if (progress) {

cbm_progress_sink_init(stderr);

}

cbm_mcp_server_t *srv = cbm_mcp_server_new(NULL);

if (!srv) {

(void)fprintf(stderr, "error: failed to create server\n");

if (progress) {

cbm_progress_sink_fini();

}

return SKIP_ONE;

}

char *result = cbm_mcp_handle_tool(srv, tool_name, args_json);

int exit_code = 0;

if (result) {

if (raw_json) {

printf("%s\n", result);

} else {

exit_code = cli_print_mcp_result(result);

}

free(result);

}

cbm_mcp_server_free(srv);

if (progress) {

cbm_progress_sink_fini();

}

return exit_code;

}

static void print_help(void) {

printf("codebase-memory-mcp %s\n\n", CBM_VERSION);

printf("Usage:\n");

printf(" codebase-memory-mcp Run MCP server on stdio\n");

printf(" codebase-memory-mcp cli <tool> [json] Run a single tool\n");

printf(" codebase-memory-mcp install [-y|-n] [--force] [--dry-run]\n");

printf(" codebase-memory-mcp uninstall [-y|-n] [--dry-run]\n");

printf(" codebase-memory-mcp update [-y|-n]\n");

printf(" codebase-memory-mcp config <list|get|set|reset>\n");

printf(" codebase-memory-mcp --version Print version\n");

printf(" codebase-memory-mcp --help Print this help\n");

printf("\nUI options:\n");

printf(" --ui=true Enable HTTP graph visualization (persisted)\n");

printf(" --ui=false Disable HTTP graph visualization (persisted)\n");

printf(" --port=N Set UI port (default 9749, persisted)\n");

printf("\nSupported agents (auto-detected):\n");

printf(" Claude Code, CodeBuddy, Codex CLI, Gemini CLI, Zed, OpenCode,\n");

printf(" Antigravity, Aider, KiloCode, Kiro\n");

printf("\nTools: index_repository, search_graph, query_graph, trace_path,\n");

printf(" get_code_snippet, get_graph_schema, get_architecture, search_code,\n");

printf(" list_projects, delete_project, index_status, detect_changes,\n");

printf(" manage_adr, ingest_traces\n");

}

static int handle_subcommand(int argc, char **argv) {

/* First scan: global flags */

for (int i = SKIP_ONE; i < argc; i++) {

if (strcmp(argv[i], "--profile") == 0) {

cbm_profile_enable();

}

}

for (int i = SKIP_ONE; i < argc; i++) {

if (strcmp(argv[i], "--version") == 0) {

printf("codebase-memory-mcp %s\n", CBM_VERSION);

return 0;

}

if (strcmp(argv[i], "--help") == 0 || strcmp(argv[i], "-h") == 0) {

print_help();

return 0;

}

if (strcmp(argv[i], "cli") == 0) {

cbm_mem_init(MAIN_RAM_FRACTION);

return run_cli(argc - i - SKIP_ONE, argv + i + SKIP_ONE);

}

if (strcmp(argv[i], "hook-augment") == 0) {

cbm_mem_init(MAIN_RAM_FRACTION);

return cbm_cmd_hook_augment();

}

if (strcmp(argv[i], "install") == 0) {

return cbm_cmd_install(argc - i - SKIP_ONE, argv + i + SKIP_ONE);

}

if (strcmp(argv[i], "uninstall") == 0) {

return cbm_cmd_uninstall(argc - i - SKIP_ONE, argv + i + SKIP_ONE);

}

if (strcmp(argv[i], "update") == 0) {

return cbm_cmd_update(argc - i - SKIP_ONE, argv + i + SKIP_ONE);

}

if (strcmp(argv[i], "config") == 0) {

return cbm_cmd_config(argc - i - SKIP_ONE, argv + i + SKIP_ONE);

}

}

return CBM_NOT_FOUND;

}

static bool parse_ui_flags(int argc, char **argv, cbm_ui_config_t *cfg, bool *explicit_enable) {

bool changed = false;

for (int i = SKIP_ONE; i < argc; i++) {

if (strncmp(argv[i], "--ui=", SLEN("--ui=")) == 0) {

cfg->ui_enabled = (strcmp(argv[i] + MAIN_FLAG_OFF, "true") == 0);

if (explicit_enable && cfg->ui_enabled) {

*explicit_enable = true;

}

changed = true;

}

if (strncmp(argv[i], "--port=", SLEN("--port=")) == 0) {

int p = (int)strtol(argv[i] + MAIN_PORT_OFF, NULL, CBM_DECIMAL_BASE);

if (p > 0 && p < MAIN_MAX_PORT) {

cfg->ui_port = p;

changed = true;

}

}

}

return changed;

}

static void setup_signal_handlers(void) {

#ifdef _WIN32

signal(SIGTERM, signal_handler);

signal(SIGINT, signal_handler);

struct sigaction sa = {0};

sa.sa_handler = signal_handler;

sigemptyset(&sa.sa_mask);

sa.sa_flags = 0;

sigaction(SIGTERM, &sa, NULL);

sigaction(SIGINT, &sa, NULL);

}

int main(int argc, char **argv) {

/* Defense-in-depth: bind tree-sitter, sqlite3, and libgit2 to mimalloc so a

cbm_alloc_init();

cbm_profile_init(); /* reads CBM_PROFILE env var, gates all prof macros */

/* CBM_LOG_LEVEL support — distilled from #414 (closes #413). Apply before

cbm_log_init_from_env();

int subcmd = handle_subcommand(argc, argv);

if (subcmd >= 0) {

return subcmd;

}

/* parent-death watchdog — distilled from #407 (fixes #406). Start it early so

#ifndef _WIN32

/* main() outlives the watchdog (it joins before returning), so a stack

pid_t initial_ppid = getppid();

cbm_thread_t parent_watchdog_tid;

bool parent_watchdog_started = false;

if (cbm_thread_create(&parent_watchdog_tid, PARENT_WATCHDOG_STACK_SIZE, parent_watchdog_thread,

&initial_ppid) == 0) {

parent_watchdog_started = true;

} else {

cbm_log_warn("parent.watchdog.unavailable", "reason", "thread_create_failed");

}

/* Default: MCP server on stdio */

cbm_mem_init(MAIN_RAM_FRACTION); /* 50% of RAM — safe now because mimalloc tracks ALL

/* Store binary path for subprocess spawning + hook log sink */

cbm_http_server_set_binary_path(argv[0]);

cbm_log_set_sink(cbm_ui_log_append);

cbm_log_info("server.start", "version", CBM_VERSION);

cbm_diag_start(); /* starts if CBM_DIAGNOSTICS=1 */

/* Parse --ui and --port flags (persisted config) */

cbm_ui_config_t ui_cfg;

cbm_ui_config_load(&ui_cfg);

bool explicit_ui_enable = false;

if (parse_ui_flags(argc, argv, &ui_cfg, &explicit_ui_enable)) {

cbm_ui_config_save(&ui_cfg);

}

/* If the user explicitly asked for the UI but this binary has no embedded

if (explicit_ui_enable && CBM_EMBEDDED_FILE_COUNT == 0) {

(void)fprintf(stderr,

"codebase-memory-mcp: --ui requested, but this binary was built without the "

"embedded UI, so the HTTP server will not start.\n"

"Use the UI release asset (codebase-memory-mcp-ui) or rebuild with: "

"make -f Makefile.cbm cbm-with-ui\n");

}

setup_signal_handlers();

/* Open config store for runtime settings */

char config_dir[CBM_SZ_1K];

const char *cfg_home = cbm_get_home_dir();

cbm_config_t *runtime_config = NULL;

if (cfg_home) {

snprintf(config_dir, sizeof(config_dir), "%s", cbm_resolve_cache_dir());

runtime_config = cbm_config_open(config_dir);

}

/* Create MCP server */

g_server = cbm_mcp_server_new(NULL);

if (!g_server) {

cbm_log_error("server.err", "msg", "failed to create server");

cbm_config_close(runtime_config);

#ifndef _WIN32

if (parent_watchdog_started) {

atomic_store(&g_shutdown, 1);

cbm_thread_join(&parent_watchdog_tid);

}

return SKIP_ONE;

}

/* Create and start watcher in background thread */

/* Initialize log mutex before any threads are created */

cbm_ui_log_init();

cbm_store_t *watch_store = cbm_store_open_memory();

g_watcher = cbm_watcher_new(watch_store, watcher_index_fn, NULL);

/* Wire watcher + config into MCP server for session auto-index */

cbm_mcp_server_set_watcher(g_server, g_watcher);

cbm_mcp_server_set_config(g_server, runtime_config);

cbm_thread_t watcher_tid;

bool watcher_started = false;

if (g_watcher) {

if (cbm_thread_create(&watcher_tid, 0, watcher_thread, g_watcher) == 0) {

watcher_started = true;

}

}

/* Optionally start HTTP UI server in background thread */

cbm_thread_t http_tid;

bool http_started = false;

if (ui_cfg.ui_enabled && CBM_EMBEDDED_FILE_COUNT > 0) {

g_http_server = cbm_http_server_new(ui_cfg.ui_port);

if (g_http_server) {

if (cbm_thread_create(&http_tid, 0, http_thread, g_http_server) == 0) {

http_started = true;

}

}

} else if (ui_cfg.ui_enabled && CBM_EMBEDDED_FILE_COUNT == 0) {

cbm_log_warn("ui.no_assets", "hint", "rebuild with: make -f Makefile.cbm cbm-with-ui");

}

/* Run MCP event loop (blocks until EOF or signal) */

int rc = cbm_mcp_server_run(g_server, stdin, stdout);

atomic_store(&g_shutdown, 1); /* unblock the watchdog poll loop */

/* Shutdown */

cbm_log_info("server.shutdown");

#ifndef _WIN32

if (parent_watchdog_started) {

cbm_thread_join(&parent_watchdog_tid);

}

if (http_started) {

cbm_http_server_stop(g_http_server);

cbm_thread_join(&http_tid);

cbm_http_server_free(g_http_server);

g_http_server = NULL;

}

if (watcher_started) {

cbm_watcher_stop(g_watcher);

cbm_thread_join(&watcher_tid);

}

cbm_watcher_free(g_watcher);

cbm_store_close(watch_store);

cbm_mcp_server_free(g_server);

cbm_config_close(runtime_config);

g_watcher = NULL;

g_server = NULL;

cbm_diag_stop();

return rc;

}