Local code intelligence for developers and AI agents. Connect code, docs and infrastructure in a persistent graph, with CBM Lens, MCP tools, agent integrations and change-aware test selection.
C aiderastclaude-codecode-analysiscode-intelligencecodexcursorcypherdeveloper-toolsgemini-cligraph-visualizationkilocodeknowledge-graphmcpmcp-servermodel-context-protocolopencodesqlitetree-sitterwindsurf
refactor(search): run POSIX unscoped scan as argv stages, no shell (#2634)
tahodev6b6106fa936d
diff --git a/src/mcp/mcp.c b/src/mcp/mcp.cindex 5bd02e4e3..6b79ba94f 100644--- a/src/mcp/mcp.c+++ b/src/mcp/mcp.c@@ -16474,6 +16474,28 @@ static mcp_scan_cause_t mcp_run_shell_command_cancellable_bounded(uint64_t deadline_ms, bool deadline_enabled, bool deadline_latched, bool exit_one_is_no_match,bool git_child, cbm_proc_result_t *result_out);+#ifndef _WIN32+/* POSIX-only: supervised run of one argv stage (no shell). Same latch and+ * containment contract as the shell runner; the measured file's size plus+ * output_base counts toward output_limit so chained stages share one budget.+ * tolerate_exit_one maps a plain exit-1 (grep's no-match) to SUCCESS. */+static mcp_scan_cause_t mcp_run_argv_stage_cancellable_bounded(+ cbm_mcp_server_t *srv, const char *bin, const char *const *argv,+ const char *const *env_overrides, const char *stdout_capture, uint64_t output_base,+ size_t output_limit, uint64_t deadline_ms, bool deadline_enabled, bool tolerate_exit_one,+ bool *cancellation_latched, bool *deadline_latched, bool *output_limit_latched,+ cbm_proc_result_t *result_out);++/* POSIX-only: the unscoped search_code scan as find/sort/grep argv stages. */+static mcp_scan_cause_t mcp_run_search_scan_argv(cbm_mcp_server_t *srv, bool use_regex,+ const char *file_pattern,+ const char *pattern_file, const char *filelist,+ const char *root_path,+ char output_path[CBM_SZ_2K], size_t output_limit,+ uint64_t deadline_ms, bool deadline_latched,+ cbm_proc_result_t *result_out);+#endif+static char *search_code_timeout_result(void) {static const char message[] = "search_code scan exceeded its execution deadline";static const char fallback[] =@@ -16873,10 +16895,22 @@ static char *handle_search_code(cbm_mcp_server_t *srv, const char *args) {scan_cause = MCP_SCAN_COMMAND_FAILURE;}} else {- scan_cause = mcp_run_shell_command_cancellable_bounded(- srv, scan_command, output_path, scan_output_limit, scan_deadline_ms, true,- scan_deadline_latched, /*exit_one_is_no_match=*/false, /*git_child=*/false,- &scan_result);+#ifndef _WIN32+ if (!srv->search_scan_command_override) {+ /* POSIX unscoped scans run as find/sort/grep argv stages: no+ * shell parses search scopes or file patterns anymore (#2634).+ * The command override keeps the shell runner for tests. */+ scan_cause = mcp_run_search_scan_argv(+ srv, use_regex, file_pattern, tmpfile, filelist, root_path, output_path,+ scan_output_limit, scan_deadline_ms, scan_deadline_latched, &scan_result);+ } else+#endif+ {+ scan_cause = mcp_run_shell_command_cancellable_bounded(+ srv, scan_command, output_path, scan_output_limit, scan_deadline_ms, true,+ scan_deadline_latched, /*exit_one_is_no_match=*/false, /*git_child=*/false,+ &scan_result);+ }}/* Both POSIX commands wrap grep and map its no-match status to 0, so any* non-zero exit (a failed find/sort, an unreadable operand, a broken@@ -17395,6 +17429,291 @@ static int mcp_run_shell_command_cancellable(cbm_mcp_server_t *srv, const char *return cause == MCP_SCAN_COMMAND_FAILURE || cause == MCP_SCAN_SUPERVISION_FAILURE ? -1 : 0;}+#ifndef _WIN32+/* Latch poll shared by argv stages: request-cancellation, wall-clock deadline,+ * and the cumulative measured-file output budget. Mirrors the latch updates of+ * the shell runner so both paths fail the same way. */+static void mcp_argv_stage_poll_latches(cbm_mcp_server_t *srv, const char *measured_path,+ uint64_t output_base, size_t output_limit,+ uint64_t deadline_ms, bool deadline_enabled,+ bool *cancellation_latched, bool *deadline_latched,+ bool *output_limit_latched) {+ *cancellation_latched = *cancellation_latched || mcp_request_cancelled(srv);+ *deadline_latched = *deadline_latched || (deadline_enabled && cbm_now_ms() >= deadline_ms);+ if (!*output_limit_latched && output_limit > 0 && measured_path && measured_path[0]) {+ int64_t measured_size = cbm_file_size(measured_path);+ *output_limit_latched =+ measured_size > 0 && output_base + (uint64_t)measured_size > output_limit;+ }+}++static mcp_scan_cause_t mcp_run_argv_stage_cancellable_bounded(+ cbm_mcp_server_t *srv, const char *bin, const char *const *argv,+ const char *const *env_overrides, const char *stdout_capture, uint64_t output_base,+ size_t output_limit, uint64_t deadline_ms, bool deadline_enabled, bool tolerate_exit_one,+ bool *cancellation_latched, bool *deadline_latched, bool *output_limit_latched,+ cbm_proc_result_t *result_out) {+ memset(result_out, 0, sizeof(*result_out));+ mcp_argv_stage_poll_latches(srv, stdout_capture, output_base, output_limit, deadline_ms,+ deadline_enabled, cancellation_latched, deadline_latched,+ output_limit_latched);+ if (*cancellation_latched || *deadline_latched || *output_limit_latched) {+ result_out->tree_quiesced = true; /* no child was spawned */+ return *cancellation_latched ? MCP_SCAN_CANCELLED+ : *deadline_latched ? MCP_SCAN_DEADLINE+ : MCP_SCAN_OUTPUT_LIMIT;+ }+ cbm_proc_opts_t options = {+ .bin = bin,+ .argv = argv,+ .env_overrides = env_overrides,+ .log_file = NULL,+ .quiet_timeout_ms = 0,+ .cancel_grace_ms = CBM_SUBPROCESS_DEFAULT_CANCEL_GRACE_MS,+ .delete_log_on_exit = false,+ .strip_git_repo_env = false,+ .stdout_file = stdout_capture,+ };+ cbm_subprocess_t *process = NULL;+ if (cbm_subprocess_spawn(&options, &process) != 0) {+ result_out->tree_quiesced = true;+ return MCP_SCAN_COMMAND_FAILURE;+ }+ cbm_proc_poll_t state;+ for (;;) {+ mcp_argv_stage_poll_latches(srv, stdout_capture, output_base, output_limit, deadline_ms,+ deadline_enabled, cancellation_latched, deadline_latched,+ output_limit_latched);+ if (*cancellation_latched || *deadline_latched || *output_limit_latched) {+ (void)cbm_subprocess_request_cancel(process);+ }+ state = cbm_subprocess_poll(process, result_out);+ if (state != CBM_PROC_POLL_RUNNING) {+ break;+ }+ cbm_usleep(10000);+ }+ bool contained = state == CBM_PROC_POLL_TERMINAL && result_out->tree_quiesced &&+ !result_out->supervision_failed;+ cbm_subprocess_destroy(process);+ mcp_argv_stage_poll_latches(srv, stdout_capture, output_base, output_limit, deadline_ms,+ deadline_enabled, cancellation_latched, deadline_latched,+ output_limit_latched);+ if (!contained) {+ return MCP_SCAN_SUPERVISION_FAILURE;+ }+ if (*cancellation_latched) {+ return MCP_SCAN_CANCELLED;+ }+ if (*deadline_latched) {+ return MCP_SCAN_DEADLINE;+ }+ if (*output_limit_latched) {+ return MCP_SCAN_OUTPUT_LIMIT;+ }+ if (tolerate_exit_one && result_out->outcome == CBM_PROC_EXIT_NONZERO &&+ result_out->exit_code == 1) {+ return MCP_SCAN_SUCCESS; /* ordinary grep no-match */+ }+ return result_out->outcome == CBM_PROC_CLEAN ? MCP_SCAN_SUCCESS+ : MCP_SCAN_CONTAINED_COMMAND_FAILURE;+}++/* Number of file operands per grep spawn. Bounded so argv stays far below+ * ARG_MAX even with long paths, like the xargs batching it replaces. */+#define MCP_ARGV_SCAN_GREP_CHUNK 256++/* The unscoped (unindexed or not-fully-indexed root) search_code scan as three+ * argv stages, with no shell anywhere: find writes the NUL-delimited candidate+ * list, LC_ALL=C sort orders it in place, and grep scans it in chunks. Search+ * scopes, file patterns and the pattern file now reach the tools as plain+ * arguments instead of shell-string interpolations (#2634). Exit codes keep+ * the old pipeline's contract: find/sort failures fail closed, grep's exit 1+ * is an ordinary no-match, and an empty list is a successful empty scan. */+static mcp_scan_cause_t mcp_run_search_scan_argv(cbm_mcp_server_t *srv, bool use_regex,+ const char *file_pattern,+ const char *pattern_file, const char *filelist,+ const char *root_path,+ char output_path[CBM_SZ_2K], size_t output_limit,+ uint64_t deadline_ms, bool deadline_latched,+ cbm_proc_result_t *result_out) {+ bool cancellation_latched = false;+ bool output_limit_latched = false;++ const char *find_argv[9];+ int fa = 0;+ find_argv[fa++] = "find";+ find_argv[fa++] = root_path;+ find_argv[fa++] = "-type";+ find_argv[fa++] = "f";+ if (file_pattern) {+ find_argv[fa++] = "-name";+ find_argv[fa++] = file_pattern;+ }+ find_argv[fa++] = "-print0";+ find_argv[fa] = NULL;+ mcp_scan_cause_t cause = mcp_run_argv_stage_cancellable_bounded(+ srv, "find", find_argv, NULL, filelist, 0, 0, deadline_ms, true, false,+ &cancellation_latched, &deadline_latched, &output_limit_latched, result_out);+ if (cause != MCP_SCAN_SUCCESS) {+ return cause;+ }++ const char *sort_argv[] = {"sort", "-z", "-o", filelist, filelist, NULL};+ const char *sort_env[] = {"LC_ALL=C", NULL};+ cause = mcp_run_argv_stage_cancellable_bounded(+ srv, "sort", sort_argv, sort_env, NULL, 0, 0, deadline_ms, true, false,+ &cancellation_latched, &deadline_latched, &output_limit_latched, result_out);+ if (cause != MCP_SCAN_SUCCESS) {+ return cause;+ }++ if (!mcp_command_output_path(output_path)) {+ return MCP_SCAN_COMMAND_FAILURE;+ }+ FILE *out = cbm_fopen(output_path, "wb");+ if (!out) {+ (void)cbm_unlink(output_path);+ output_path[0] = '\0';+ return MCP_SCAN_COMMAND_FAILURE;+ }+ FILE *list = cbm_fopen(filelist, "rb");+ if (!list) {+ (void)fclose(out);+ (void)cbm_unlink(output_path);+ output_path[0] = '\0';+ return MCP_SCAN_COMMAND_FAILURE;+ }++ const char *grep_flag = use_regex ? "-E" : "-F";+ const char **chunk_argv =+ malloc(((size_t)MCP_ARGV_SCAN_GREP_CHUNK + 7) * sizeof(*chunk_argv));+ char **chunk_paths = malloc((size_t)MCP_ARGV_SCAN_GREP_CHUNK * sizeof(*chunk_paths));+ char *pathbuf = malloc(CBM_SZ_4K);+ if (!chunk_argv || !chunk_paths || !pathbuf) {+ free(chunk_argv);+ free(chunk_paths);+ free(pathbuf);+ (void)fclose(list);+ (void)fclose(out);+ (void)cbm_unlink(output_path);+ output_path[0] = '\0';+ return MCP_SCAN_COMMAND_FAILURE;+ }+ size_t pathcap = CBM_SZ_4K;+ size_t pathlen = 0;+ uint64_t output_bytes = 0;+ size_t seq = 0;+ cause = MCP_SCAN_SUCCESS;+ bool io_error = false;+ while (cause == MCP_SCAN_SUCCESS) {+ size_t n = 0;+ while (n < MCP_ARGV_SCAN_GREP_CHUNK) {+ int c = fgetc(list);+ if (c == EOF) {+ if (ferror(list)) {+ io_error = true;+ }+ break;+ }+ if (c == '\0') {+ if (pathlen > 0) {+ pathbuf[pathlen] = '\0';+ chunk_paths[n] = cbm_strdup(pathbuf);+ if (!chunk_paths[n]) {+ io_error = true;+ break;+ }+ n++;+ pathlen = 0;+ }+ continue;+ }+ if (pathlen + 1 >= pathcap) {+ size_t newcap = pathcap * 2;+ char *grown = realloc(pathbuf, newcap);+ if (!grown) {+ io_error = true;+ break;+ }+ pathbuf = grown;+ pathcap = newcap;+ }+ pathbuf[pathlen++] = (char)c;+ }+ if (io_error || n == 0) {+ for (size_t i = 0; i < n; i++) {+ free(chunk_paths[i]);+ }+ break;+ }++ char chunk_path[CBM_SZ_2K];+ int written = snprintf(chunk_path, sizeof(chunk_path), "%s.grep%zu", output_path, seq++);+ if (written <= 0 || (size_t)written >= sizeof(chunk_path)) {+ io_error = true;+ } else {+ chunk_argv[0] = "grep";+ chunk_argv[1] = "-Hn";+ chunk_argv[2] = grep_flag;+ chunk_argv[3] = "-f";+ chunk_argv[4] = pattern_file;+ chunk_argv[5] = "--";+ for (size_t i = 0; i < n; i++) {+ chunk_argv[6 + i] = chunk_paths[i];+ }+ chunk_argv[6 + n] = NULL;+ cause = mcp_run_argv_stage_cancellable_bounded(+ srv, "grep", chunk_argv, NULL, chunk_path, output_bytes, output_limit,+ deadline_ms, true, true, &cancellation_latched, &deadline_latched,+ &output_limit_latched, result_out);+ if (cause == MCP_SCAN_SUCCESS) {+ FILE *chunk = cbm_fopen(chunk_path, "rb");+ if (!chunk) {+ cause = MCP_SCAN_COMMAND_FAILURE;+ } else {+ char copybuf[CBM_SZ_16K];+ size_t got;+ while ((got = fread(copybuf, 1, sizeof(copybuf), chunk)) > 0) {+ if (fwrite(copybuf, 1, got, out) != got) {+ cause = MCP_SCAN_COMMAND_FAILURE;+ break;+ }+ output_bytes += got;+ }+ if (ferror(chunk) && cause == MCP_SCAN_SUCCESS) {+ cause = MCP_SCAN_COMMAND_FAILURE;+ }+ (void)fclose(chunk);+ }+ }+ (void)cbm_unlink(chunk_path);+ }+ for (size_t i = 0; i < n; i++) {+ free(chunk_paths[i]);+ }+ }+ free(chunk_argv);+ free(chunk_paths);+ free(pathbuf);+ (void)fclose(list);+ if (fclose(out) != 0 && cause == MCP_SCAN_SUCCESS) {+ cause = MCP_SCAN_COMMAND_FAILURE;+ }+ if (io_error && cause == MCP_SCAN_SUCCESS) {+ cause = MCP_SCAN_COMMAND_FAILURE;+ }+ if (cause == MCP_SCAN_SUCCESS && output_limit > 0 && output_bytes > output_limit) {+ cause = MCP_SCAN_OUTPUT_LIMIT;+ }+ if (cause != MCP_SCAN_SUCCESS) {+ (void)cbm_unlink(output_path);+ output_path[0] = '\0';+ }+ return cause;+}+#endif+/* Does `node`'s line range overlap any recorded hunk for `file`? Used to scope* seed detection to the actually-changed lines rather than the whole file.* Non-static (declared in mcp_internal.h) so tests can exercise the overlapdiff --git a/tests/test_mcp.c b/tests/test_mcp.cindex 80a320ca5..57262d8a6 100644--- a/tests/test_mcp.c+++ b/tests/test_mcp.c@@ -12420,6 +12420,141 @@ TEST(search_code_output_limit_fails_closed_and_cleans_scan) {PASS();}+/* #2634: the POSIX unscoped scan runs find/sort/grep as argv stages with no+ * shell, so file names carrying shell metacharacters are plain operands, not+ * command text. Pin that such files are discovered and scanned. */+TEST(search_code_unscoped_argv_scans_metachar_filenames_issue2634) {+#ifdef _WIN32+ SKIP_PLATFORM("argv scan stages are POSIX-only");+#else+ char tmp[CBM_SZ_512];+ snprintf(tmp, sizeof(tmp), "%s/cbm-search-argv-meta-XXXXXX", cbm_tmpdir());+ ASSERT_NOT_NULL(cbm_mkdtemp(tmp));++ char hostile[CBM_SZ_1K];+ snprintf(hostile, sizeof(hostile), "%s/we'ird ;na`me$.go", tmp);+ ASSERT_EQ(th_write_file(hostile,+ "package main\n\nfunc HandleHostile2634() error {\n\treturn nil\n}\n"),+ 0);++ cbm_mcp_server_t *srv = cbm_mcp_server_new(NULL);+ ASSERT_NOT_NULL(srv);+ cbm_store_t *store = cbm_mcp_server_store(srv);+ ASSERT_NOT_NULL(store);+ const char *project = "search-argv-metachar";+ cbm_mcp_server_set_project(srv, project);+ ASSERT_EQ(cbm_store_upsert_project(store, project, tmp), CBM_STORE_OK);++ char *resp = cbm_mcp_handle_tool(srv, "search_code",+ "{\"pattern\":\"HandleHostile2634\","+ "\"project\":\"search-argv-metachar\",\"format\":\"json\"}");+ ASSERT_NOT_NULL(resp);+ ASSERT_TRUE(strstr(resp, "\"isError\":true") == NULL);+ char *inner = extract_text_content(resp);+ ASSERT_NOT_NULL(inner);+ ASSERT_NOT_NULL(strstr(inner, "we'ird ;na`me$.go"));+ ASSERT_NOT_NULL(strstr(inner, "\"total_grep_matches\":1"));+ free(inner);+ free(resp);+ cbm_mcp_server_free(srv);+ ASSERT_EQ(th_rmtree(tmp), 0);+ PASS();+#endif+}++/* #2634: grep's exit 1 (no match in a chunk) is an ordinary empty result, not+ * a scan failure — the same contract the retired xargs wrapper encoded. */+TEST(search_code_unscoped_argv_no_match_is_success_issue2634) {+#ifdef _WIN32+ SKIP_PLATFORM("argv scan stages are POSIX-only");+#else+ char tmp[CBM_SZ_512];+ snprintf(tmp, sizeof(tmp), "%s/cbm-search-argv-nomatch-XXXXXX", cbm_tmpdir());+ ASSERT_NOT_NULL(cbm_mkdtemp(tmp));++ char src_path[CBM_SZ_1K];+ snprintf(src_path, sizeof(src_path), "%s/handler.go", tmp);+ ASSERT_EQ(th_write_file(src_path,+ "package main\n\nfunc HandlePresent2634() error {\n\treturn nil\n}\n"),+ 0);++ cbm_mcp_server_t *srv = cbm_mcp_server_new(NULL);+ ASSERT_NOT_NULL(srv);+ cbm_store_t *store = cbm_mcp_server_store(srv);+ ASSERT_NOT_NULL(store);+ const char *project = "search-argv-nomatch";+ cbm_mcp_server_set_project(srv, project);+ ASSERT_EQ(cbm_store_upsert_project(store, project, tmp), CBM_STORE_OK);++ char *resp = cbm_mcp_handle_tool(srv, "search_code",+ "{\"pattern\":\"NoSuchSymbol2634\","+ "\"project\":\"search-argv-nomatch\",\"format\":\"json\"}");+ ASSERT_NOT_NULL(resp);+ ASSERT_TRUE(strstr(resp, "\"isError\":true") == NULL);+ char *inner = extract_text_content(resp);+ ASSERT_NOT_NULL(inner);+ ASSERT_NOT_NULL(strstr(inner, "\"total_grep_matches\":0"));+ ASSERT_NOT_NULL(strstr(inner, "\"total_relation\":\"eq\""));+ free(inner);+ free(resp);+ cbm_mcp_server_free(srv);+ ASSERT_EQ(th_rmtree(tmp), 0);+ PASS();+#endif+}++/* #2634: the unscoped file_pattern reaches find as a -name operand, so a+ * non-matching extension is excluded from the scan without any shell glob. */+TEST(search_code_unscoped_argv_honours_file_pattern_issue2634) {+#ifdef _WIN32+ SKIP_PLATFORM("argv scan stages are POSIX-only");+#else+ char tmp[CBM_SZ_512];+ snprintf(tmp, sizeof(tmp), "%s/cbm-search-argv-glob-XXXXXX", cbm_tmpdir());+ ASSERT_NOT_NULL(cbm_mkdtemp(tmp));++ char py[CBM_SZ_1K];+ snprintf(py, sizeof(py), "%s/handler.py", tmp);+ ASSERT_EQ(th_write_file(py, "def handle_python2634():\n return 1\n"), 0);++ cbm_mcp_server_t *srv = cbm_mcp_server_new(NULL);+ ASSERT_NOT_NULL(srv);+ cbm_store_t *store = cbm_mcp_server_store(srv);+ ASSERT_NOT_NULL(store);+ const char *project = "search-argv-glob";+ cbm_mcp_server_set_project(srv, project);+ ASSERT_EQ(cbm_store_upsert_project(store, project, tmp), CBM_STORE_OK);++ char *resp = cbm_mcp_handle_tool(srv, "search_code",+ "{\"pattern\":\"handle_python2634\","+ "\"project\":\"search-argv-glob\","+ "\"file_pattern\":\"*.go\",\"format\":\"json\"}");+ ASSERT_NOT_NULL(resp);+ ASSERT_TRUE(strstr(resp, "\"isError\":true") == NULL);+ char *inner = extract_text_content(resp);+ ASSERT_NOT_NULL(inner);+ ASSERT_TRUE(strstr(inner, "handler.py") == NULL);+ ASSERT_NOT_NULL(strstr(inner, "\"total_grep_matches\":0"));+ free(inner);+ free(resp);++ resp = cbm_mcp_handle_tool(srv, "search_code",+ "{\"pattern\":\"handle_python2634\","+ "\"project\":\"search-argv-glob\",\"format\":\"json\"}");+ ASSERT_NOT_NULL(resp);+ ASSERT_TRUE(strstr(resp, "\"isError\":true") == NULL);+ inner = extract_text_content(resp);+ ASSERT_NOT_NULL(inner);+ ASSERT_NOT_NULL(strstr(inner, "handler.py"));+ ASSERT_NOT_NULL(strstr(inner, "\"total_grep_matches\":1"));+ free(inner);+ free(resp);+ cbm_mcp_server_free(srv);+ ASSERT_EQ(th_rmtree(tmp), 0);+ PASS();+#endif+}+TEST(search_code_scan_deadline_fails_closed_and_resets) {mcp_search_cache_t cache;ASSERT_TRUE(mcp_search_cache_open(&cache, "cbm-search-deadline"));@@ -25224,6 +25359,9 @@ SUITE(mcp) {RUN_TEST(search_code_file_pattern_prefilter_boundaries);RUN_TEST(search_code_windows_scope_prefilter_removes_pipeline_filter);RUN_TEST(search_code_cancel_cleans_supervised_scan);+ RUN_TEST(search_code_unscoped_argv_scans_metachar_filenames_issue2634);+ RUN_TEST(search_code_unscoped_argv_no_match_is_success_issue2634);+ RUN_TEST(search_code_unscoped_argv_honours_file_pattern_issue2634);RUN_TEST(search_code_output_limit_fails_closed_and_cleans_scan);RUN_TEST(search_code_scan_deadline_fails_closed_and_resets);RUN_TEST(search_code_scan_deadline_override_is_per_server);