@sdsrs/code-graph 0.93.1 → 0.95.0

package/claude-plugin/scripts/mcp-launcher.test.js

@@ -1,162 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-/**
- * Tests for claude-plugin/scripts/mcp-launcher.js — the .mcp.json entry point
- * that resolves the binary (with auto-install fallbacks) and stdio-forwards
- * MCP JSON-RPC. install-e2e.test.js §4.3 covers find-binary in dev mode but
- * doesn't exercise the launcher's full chain (find → spawn → forward).
- *
- * The negative paths (no binary anywhere → npm install + GitHub fallback +
- * exit 1) are intentionally NOT covered here — the network-bound fallbacks
- * have ~150s timeouts and aren't deterministic in CI sandboxes. End-to-end
- * dev-mode coverage is the highest-leverage gap.
- *
- * Run: node --test claude-plugin/scripts/mcp-launcher.test.js
- */
-const test = require('node:test');
-const assert = require('node:assert/strict');
-const fs = require('fs');
-const path = require('path');
-const { spawn } = require('child_process');
-
-const PLUGIN_ROOT = path.resolve(__dirname, '..');
-const REPO_ROOT = path.resolve(PLUGIN_ROOT, '..');
-const LAUNCHER = path.join(__dirname, 'mcp-launcher.js');
-const BINARY_NAME = process.platform === 'win32' ? 'code-graph-mcp.exe' : 'code-graph-mcp';
-const REL_BINARY = path.join(REPO_ROOT, 'target', 'release', BINARY_NAME);
-
-function hasBuiltBinary() {
-  return fs.existsSync(REL_BINARY);
-}
-
-/**
- * Run the launcher, send one MCP message on stdin, collect stdout/stderr,
- * resolve once we either see a JSON-RPC response on stdout or hit timeout.
- */
-function runLauncherInitialize(timeoutMs = 15000, extraEnv = {}, cwd = REPO_ROOT) {
-  return new Promise((resolve, reject) => {
-    const child = spawn(process.execPath, [LAUNCHER], {
-      stdio: ['pipe', 'pipe', 'pipe'],
-      env: { ...process.env, ...extraEnv },
-      cwd,
-    });
-
-    let stdout = '';
-    let stderr = '';
-    const timer = setTimeout(() => {
-      child.kill('SIGTERM');
-      reject(new Error(`launcher timed out after ${timeoutMs}ms; stdout=${stdout.slice(0, 400)} stderr=${stderr.slice(0, 400)}`));
-    }, timeoutMs);
-
-    child.stdout.on('data', (d) => {
-      stdout += d.toString();
-      if (stdout.includes('"result"') || stdout.includes('"error"')) {
-        clearTimeout(timer);
-        child.kill('SIGTERM');
-        // Wait for the child to actually exit so the test doesn't leave an
-        // orphan mid-write (matters on macOS / Windows where SIGTERM
-        // delivery is less synchronous than on Linux).
-        child.once('exit', () => resolve({ stdout, stderr }));
-      }
-    });
-    child.stderr.on('data', (d) => { stderr += d.toString(); });
-    child.on('error', (err) => { clearTimeout(timer); reject(err); });
-
-    const initMsg = JSON.stringify({
-      jsonrpc: '2.0', id: 1, method: 'initialize',
-      params: {
-        protocolVersion: '2024-11-05',
-        capabilities: {},
-        clientInfo: { name: 'launcher-test', version: '1.0.0' },
-      },
-    });
-    child.stdin.write(initMsg + '\n');
-  });
-}
-
-test('mcp-launcher resolves dev binary and forwards MCP JSON-RPC stdin/stdout', async (t) => {
-  if (!hasBuiltBinary()) {
-    t.skip(`release binary missing at ${REL_BINARY} — run \`cargo build --release\` first`);
-    return;
-  }
-
-  // REPO_ROOT has its own .mcp.json registering code-graph-dev (v0.31.2
-  // landed that to capture dev session metrics), which trips the launcher's
-  // dedup gate. Force the original launch path so this test still covers
-  // it. The dedup behavior gets its own test below.
-  const { stdout, stderr } = await runLauncherInitialize(15000, { CODE_GRAPH_FORCE_PLUGIN_MCP: '1' });
-
-  // Find the JSON-RPC line in the bytes the launcher forwarded from the binary.
-  // Stderr may contain "[code-graph] ..." breadcrumbs from the launcher; those
-  // are diagnostic and shouldn't break the contract that stdout carries protocol.
-  const respLine = stdout.trim().split('\n').find((l) => l.includes('"result"'));
-  assert.ok(respLine,
-    `expected a JSON-RPC result line on launcher stdout, got: ${stdout.slice(0, 400)} | stderr: ${stderr.slice(0, 400)}`);
-  const resp = JSON.parse(respLine);
-  assert.equal(resp.jsonrpc, '2.0');
-  assert.equal(resp.id, 1);
-  assert.ok(resp.result.serverInfo, 'response must carry serverInfo from the binary');
-  assert.equal(resp.result.serverInfo.name, 'code-graph-mcp');
-});
-
-test('mcp-launcher enters dedup stub when project .mcp.json registers a code-graph server', async () => {
-  // REPO_ROOT/.mcp.json registers code-graph-dev → dedup gate fires →
-  // launcher serves a 0-tools stub with a distinctive serverInfo.name.
-  // No need for the release binary; the stub is implemented in the
-  // launcher script itself.
-  const { stdout, stderr } = await runLauncherInitialize();
-  const respLine = stdout.trim().split('\n').find((l) => l.includes('"result"'));
-  assert.ok(respLine,
-    `expected stub JSON-RPC result on stdout, got: ${stdout.slice(0, 400)} | stderr: ${stderr.slice(0, 400)}`);
-  const resp = JSON.parse(respLine);
-  assert.match(resp.result.serverInfo.name, /stub|dedup/i,
-    `serverInfo.name should indicate stub mode, got ${JSON.stringify(resp.result.serverInfo)}`);
-  assert.match(stderr, /plugin MCP serving 0 tools/,
-    `stderr should explain the dedup, got: ${stderr.slice(0, 400)}`);
-});
-
-test('mcp-launcher serves 0-tool stub in a non-project cwd (no binary spawn, no index created)', async (t) => {
-  const os = require('os');
-  // A bare temp dir with no .git/manifest → isNonProjectCwd → the launcher
-  // serves the 0-tool stub WITHOUT spawning the binary, so no .code-graph is
-  // created and no `instructions` block is injected. This is the fix for the
-  // ~2035 headless /tmp mem-lite calls that half-activated code-graph.
-  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-launcher-nonproj-'));
-  t.after(() => fs.rmSync(cwd, { recursive: true, force: true }));
-
-  const { stdout, stderr } = await runLauncherInitialize(15000, {}, cwd);
-  const respLine = stdout.trim().split('\n').find((l) => l.includes('"result"'));
-  assert.ok(respLine,
-    `expected stub JSON-RPC result on stdout, got: ${stdout.slice(0, 400)} | stderr: ${stderr.slice(0, 400)}`);
-  const resp = JSON.parse(respLine);
-  assert.match(resp.result.serverInfo.name, /stub/i,
-    `serverInfo.name should indicate stub mode, got ${JSON.stringify(resp.result.serverInfo)}`);
-  assert.equal(resp.result.instructions, undefined,
-    'stub initialize must NOT carry an instructions block (the ~780B NOISY tax)');
-  assert.match(stderr, /non-project cwd/,
-    `stderr should explain the non-project gate, got: ${stderr.slice(0, 400)}`);
-  assert.ok(!fs.existsSync(path.join(cwd, '.code-graph')),
-    'must NOT create .code-graph in a non-project cwd');
-});
-
-test('mcp-launcher sets _FIND_BINARY_ROOT from __dirname (does not trust CLAUDE_PLUGIN_ROOT)', () => {
-  // Static check: the source must derive _FIND_BINARY_ROOT from __dirname so a
-  // sibling plugin's CLAUDE_PLUGIN_ROOT can't redirect us to the wrong binary.
-  // Memory: feedback_plugin_env_isolation.md.
-  const src = fs.readFileSync(LAUNCHER, 'utf8');
-  assert.match(src, /_FIND_BINARY_ROOT\s*=\s*path\.resolve\(__dirname/,
-    'launcher must derive _FIND_BINARY_ROOT from __dirname, not CLAUDE_PLUGIN_ROOT');
-  // And must NOT read CLAUDE_PLUGIN_ROOT from env.
-  assert.doesNotMatch(src, /process\.env\.CLAUDE_PLUGIN_ROOT/,
-    'launcher must not trust CLAUDE_PLUGIN_ROOT — it can leak from sibling plugins');
-});
-
-test('mcp-launcher rejects executable-permission failure with platform-specific hint', () => {
-  // Static check: the macOS quarantine guard must surface xattr/chmod fix
-  // commands rather than silently failing on the spawn.
-  const src = fs.readFileSync(LAUNCHER, 'utf8');
-  assert.match(src, /accessSync\s*\(\s*binary\s*,\s*fs\.constants\.X_OK\s*\)/,
-    'launcher must pre-check binary X_OK before spawn');
-  assert.match(src, /xattr -d com\.apple\.quarantine/,
-    'macOS guard must surface the xattr removal command in stderr');
-});

package/claude-plugin/scripts/mcp-stub.test.js

@@ -1,207 +0,0 @@
-'use strict';
-const test = require('node:test');
-const assert = require('node:assert/strict');
-const { PassThrough } = require('stream');
-const { EventEmitter } = require('events');
-const { serveEmptyMcpStub, SENTINEL_ID } = require('./mcp-stub');
-
-const tick = () => new Promise((r) => setImmediate(r));
-
-// A fake child_process: collect what the launcher writes to child.stdin, and
-// let the test push child.stdout lines + emit exit/error.
-function makeFakeChild() {
-  const stdin = new PassThrough();
-  const stdout = new PassThrough();
-  const ee = new EventEmitter();
-  const linesToChild = [];
-  let sbuf = '';
-  stdin.setEncoding('utf8');
-  stdin.on('data', (c) => {
-    sbuf += c;
-    let nl;
-    while ((nl = sbuf.indexOf('\n')) >= 0) { linesToChild.push(sbuf.slice(0, nl)); sbuf = sbuf.slice(nl + 1); }
-  });
-  return {
-    stdin, stdout,
-    on: (e, cb) => ee.on(e, cb),
-    emit: (e, ...a) => ee.emit(e, ...a),
-    linesToChild,
-  };
-}
-
-function makeRig(upgrade) {
-  const input = new PassThrough();
-  const out = [];
-  const output = { write: (s) => { out.push(s); return true; } };
-  let exitCode = null;
-  const handle = serveEmptyMcpStub({
-    input, output,
-    setInterval: () => 0, clearInterval: () => {},   // no real timer; drive attemptUpgrade() manually
-    exit: (c) => { exitCode = c; },
-    upgrade,
-  });
-  const send = (obj) => input.write(JSON.stringify(obj) + '\n');
-  return { input, out, handle, send, getExit: () => exitCode };
-}
-
-const INIT = { jsonrpc: '2.0', id: 1, method: 'initialize', params: { protocolVersion: '2024-11-05', capabilities: {}, clientInfo: { name: 'cc', version: '1' } } };
-
-test('permanent stub: 0 tools, listChanged:false, unknown method → -32601', async () => {
-  const { out, send } = makeRig(null);
-  send(INIT);
-  send({ jsonrpc: '2.0', id: 2, method: 'tools/list', params: {} });
-  send({ jsonrpc: '2.0', id: 3, method: 'nope/nope', params: {} });
-  await tick();
-  const initResp = JSON.parse(out[0]);
-  assert.equal(initResp.result.capabilities.tools.listChanged, false);
-  assert.match(initResp.result.serverInfo.name, /dedup/);
-  assert.deepEqual(JSON.parse(out[1]).result.tools, []);
-  assert.equal(JSON.parse(out[2]).error.code, -32601);
-});
-
-test('upgradeable stub advertises tools.listChanged:true', async () => {
-  const { out, send } = makeRig({ shouldUpgrade: () => false, spawnReal: () => null });
-  send(INIT);
-  await tick();
-  assert.equal(JSON.parse(out[0]).result.capabilities.tools.listChanged, true);
-});
-
-test('upgradeable stub does NOT spawn while shouldUpgrade() is false', async () => {
-  let spawnCalls = 0;
-  const { handle } = makeRig({ shouldUpgrade: () => false, spawnReal: () => { spawnCalls++; return null; } });
-  handle.attemptUpgrade();
-  await tick();
-  assert.equal(spawnCalls, 0);
-  assert.equal(handle._state().hasChild, false);
-});
-
-test('upgrade handoff: proxies to real binary + emits tools/list_changed + forwards real tools', async () => {
-  const child = makeFakeChild();
-  let allow = false;
-  const { out, send, handle } = makeRig({ shouldUpgrade: () => allow, spawnReal: () => child });
-
-  // 1. client initialize + tools/list while still a non-project stub
-  send(INIT);
-  send({ jsonrpc: '2.0', id: 2, method: 'tools/list', params: {} });
-  await tick();
-  assert.equal(JSON.parse(out[0]).result.capabilities.tools.listChanged, true);
-  assert.deepEqual(JSON.parse(out[1]).result.tools, []);          // stub → empty
-  const outLenBeforeUpgrade = out.length;
-
-  // 2. cwd becomes a project → upgrade fires
-  allow = true;
-  handle.attemptUpgrade();
-  await tick();
-  assert.equal(handle._state().hasChild, true);
-  // launcher replayed initialize to the child under the sentinel id
-  const replay = JSON.parse(child.linesToChild[0]);
-  assert.equal(replay.method, 'initialize');
-  assert.equal(replay.id, SENTINEL_ID);
-
-  // 3. child answers the sentinel initialize
-  child.stdout.write(JSON.stringify({ jsonrpc: '2.0', id: SENTINEL_ID, result: { capabilities: { tools: { listChanged: false } }, instructions: 'real server' } }) + '\n');
-  await tick();
-  // launcher must: send initialized to child, and tools/list_changed to client
-  assert.ok(child.linesToChild.some((l) => JSON.parse(l).method === 'notifications/initialized'));
-  const newClientMsgs = out.slice(outLenBeforeUpgrade).map((s) => JSON.parse(s));
-  assert.ok(newClientMsgs.some((m) => m.method === 'notifications/tools/list_changed'),
-    'client must be told tools changed');
-  // the sentinel init reply must NOT leak to the client
-  assert.ok(!newClientMsgs.some((m) => m.id === SENTINEL_ID), 'sentinel reply must be swallowed');
-
-  // 4. client re-requests tools/list → forwarded to child (not answered empty)
-  const childLinesBefore = child.linesToChild.length;
-  send({ jsonrpc: '2.0', id: 3, method: 'tools/list', params: {} });
-  await tick();
-  const forwarded = child.linesToChild.slice(childLinesBefore).map((l) => JSON.parse(l));
-  assert.ok(forwarded.some((m) => m.id === 3 && m.method === 'tools/list'), 'tools/list forwarded to real binary');
-
-  // 5. child returns real tools → forwarded verbatim to client
-  child.stdout.write(JSON.stringify({ jsonrpc: '2.0', id: 3, result: { tools: [{ name: 'get_call_graph' }, { name: 'semantic_code_search' }] } }) + '\n');
-  await tick();
-  const toolResp = out.map((s) => JSON.parse(s)).find((m) => m.id === 3);
-  assert.ok(toolResp, 'client received a tools/list response');
-  assert.deepEqual(toolResp.result.tools.map((t) => t.name), ['get_call_graph', 'semantic_code_search']);
-});
-
-test('upgrade with unresolvable binary stays a stub and keeps answering', async () => {
-  let allow = true;
-  const { out, send, handle } = makeRig({ shouldUpgrade: () => allow, spawnReal: () => null });
-  send(INIT);
-  await tick();
-  handle.attemptUpgrade();               // spawnReal returns null → no child
-  await tick();
-  assert.equal(handle._state().hasChild, false);
-  send({ jsonrpc: '2.0', id: 9, method: 'tools/list', params: {} });
-  await tick();
-  const resp = out.map((s) => JSON.parse(s)).find((m) => m.id === 9);
-  assert.deepEqual(resp.result.tools, []);   // still served by the stub
-});
-
-test('upgrade: a request in the handoff window is queued then flushed to the child in order', async () => {
-  const child = makeFakeChild();
-  const { send, handle } = makeRig({ shouldUpgrade: () => true, spawnReal: () => child });
-  send(INIT);
-  await tick();
-  handle.attemptUpgrade();                     // child spawned; sentinel initialize sent; NOT ready yet
-  await tick();
-  // client sends a call while the child is mid-handshake → must be queued, not forwarded
-  send({ jsonrpc: '2.0', id: 7, method: 'tools/call', params: { name: 'x' } });
-  await tick();
-  assert.equal(child.linesToChild.length, 1);
-  assert.equal(JSON.parse(child.linesToChild[0]).id, SENTINEL_ID);
-  // child completes its handshake → queued request flushes AFTER initialized
-  child.stdout.write(JSON.stringify({ jsonrpc: '2.0', id: SENTINEL_ID, result: { capabilities: {} } }) + '\n');
-  await tick();
-  const methods = child.linesToChild.map((l) => { const m = JSON.parse(l); return m.method || `id:${m.id}`; });
-  assert.deepEqual(methods, ['initialize', 'notifications/initialized', 'tools/call']);
-});
-
-test('upgrade: child that exits before ready falls back to stub and answers queued requests', async () => {
-  const child = makeFakeChild();
-  const { out, send, handle } = makeRig({ shouldUpgrade: () => true, spawnReal: () => child });
-  send(INIT);
-  await tick();
-  handle.attemptUpgrade();                     // child spawned, not ready
-  await tick();
-  send({ jsonrpc: '2.0', id: 8, method: 'tools/list', params: {} });   // queued during handoff
-  await tick();
-  child.emit('exit', 1, null);                 // child dies BEFORE the sentinel reply
-  await tick();
-  assert.equal(handle._state().hasChild, false);                       // reverted to stub
-  const resp = out.map((s) => JSON.parse(s)).find((m) => m.id === 8);
-  assert.ok(resp, 'queued request got a stub answer (client not left hanging)');
-  assert.deepEqual(resp.result.tools, []);
-});
-
-test('upgrade: error on a READY child exits instead of reverting to a flapping stub', async () => {
-  const child = makeFakeChild();
-  const { send, handle, getExit } = makeRig({ shouldUpgrade: () => true, spawnReal: () => child });
-  send(INIT);
-  await tick();
-  handle.attemptUpgrade();
-  await tick();
-  child.stdout.write(JSON.stringify({ jsonrpc: '2.0', id: SENTINEL_ID, result: { capabilities: {} } }) + '\n');
-  await tick();
-  assert.equal(handle._state().childReady, true);
-  child.emit('error', new Error('boom'));      // a READY child errors
-  await tick();
-  assert.equal(handle._state().hasChild, true, 'must NOT revert to stub (that would flap)');
-  assert.equal(getExit(), 1, 'ready-child error exits the launcher like the binary died');
-});
-
-test('poller is wired to attemptUpgrade at the default interval', () => {
-  const input = new PassThrough();
-  const out = [];
-  let captured = null, spawnCalls = 0;
-  serveEmptyMcpStub({
-    input, output: { write: (s) => out.push(s) },
-    setInterval: (fn, ms) => { captured = { fn, ms }; return 1; },
-    clearInterval: () => {}, exit: () => {},
-    upgrade: { shouldUpgrade: () => true, spawnReal: () => { spawnCalls++; return null; } },
-  });
-  assert.ok(captured, 'poller started via setInterval');
-  assert.equal(captured.ms, 4000);             // DEFAULT_POLL_MS
-  captured.fn();                                // simulate one poll tick
-  assert.equal(spawnCalls, 1);                  // tick attempted the upgrade
-});