[Init] Initial commit - NetMesh terminal manager

scripts/verify-cursor-cli-mcp-cwd.cjs

@@ -0,0 +1,343 @@
+#!/usr/bin/env node
+"use strict";
+
+/**
+ * Local verification: packaged Cursor CLI MCP injection depends on a writable cwd.
+ *
+ * Proves:
+ * 1) mergeWorkspaceMcpJson fails when cwd is "/" (typical Dock/Finder launch)
+ * 2) mergeWorkspaceMcpJson succeeds in a writable directory (dev / terminal launch)
+ * 3) Packaged Netcatty process cwd differs: launch from "/" vs writable dir
+ * 4) Packaged MCP server script path exists under app.asar.unpacked
+ *
+ * Usage:
+ *   node scripts/verify-cursor-cli-mcp-cwd.cjs
+ *   node scripts/verify-cursor-cli-mcp-cwd.cjs --skip-app-launch
+ */
+
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const { spawn, spawnSync } = require("node:child_process");
+const {
+  mergeWorkspaceMcpJson,
+  resetMcpMergeRefcountsForTests,
+  resolveCursorCliWorkspaceCwd,
+} = require("../electron/bridges/aiBridge/sdk/cursorCliDriver.cjs");
+
+const SKIP_APP = process.argv.includes("--skip-app-launch");
+const APP_BIN = "/Applications/Netcatty.app/Contents/MacOS/Netcatty";
+const APP_MCP = "/Applications/Netcatty.app/Contents/Resources/app.asar.unpacked/electron/mcp/netcatty-mcp-server.cjs";
+const TEST_DIR = path.join(os.homedir(), "netcatty-cli-cwd-test");
+const FAKE_MCP = [{
+  name: "netcatty-remote-hosts",
+  type: "stdio",
+  command: APP_BIN,
+  args: [APP_MCP],
+  env: [
+    { name: "ELECTRON_RUN_AS_NODE", value: "1" },
+    { name: "NETCATTY_MCP_PORT", value: "1" },
+    { name: "NETCATTY_MCP_TOKEN", value: "verify-token" },
+    { name: "NETCATTY_MCP_CHAT_SESSION_ID", value: "verify-chat" },
+  ],
+}];
+
+const results = [];
+
+function pass(name, detail) {
+  results.push({ ok: true, name, detail });
+  console.log(`PASS  ${name}${detail ? ` — ${detail}` : ""}`);
+}
+
+function fail(name, detail) {
+  results.push({ ok: false, name, detail });
+  console.error(`FAIL  ${name}${detail ? ` — ${detail}` : ""}`);
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function readProcessCwd(pid) {
+  const out = spawnSync("lsof", ["-a", "-p", String(pid), "-d", "cwd", "-Fn"], {
+    encoding: "utf8",
+  });
+  if (out.status !== 0) return null;
+  const line = String(out.stdout || "").split("\n").find((l) => l.startsWith("n"));
+  return line ? line.slice(1) : null;
+}
+
+async function launchAndReadCwd(launchCwd, label) {
+  if (!fs.existsSync(APP_BIN)) {
+    fail(`app cwd (${label})`, `missing ${APP_BIN}`);
+    return null;
+  }
+
+  const child = spawn(APP_BIN, [], {
+    cwd: launchCwd,
+    stdio: "ignore",
+    detached: true,
+    env: process.env,
+  });
+  const pid = child.pid;
+  child.unref();
+
+  let cwd = null;
+  for (let i = 0; i < 20; i++) {
+    await sleep(250);
+    cwd = readProcessCwd(pid);
+    if (cwd) break;
+    try {
+      process.kill(pid, 0);
+    } catch {
+      break;
+    }
+  }
+
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch { /* already gone */ }
+  await sleep(300);
+  try {
+    process.kill(pid, "SIGKILL");
+  } catch { /* ignore */ }
+
+  return cwd;
+}
+
+function testMergeRootFails() {
+  resetMcpMergeRefcountsForTests();
+  try {
+    mergeWorkspaceMcpJson("/", FAKE_MCP);
+    fail("merge at cwd=/", "expected throw, but merge succeeded");
+    try {
+      fs.unlinkSync("/.cursor/mcp.json");
+    } catch { /* ignore */ }
+  } catch (err) {
+    pass("merge at cwd=/", `${err.code || "ERR"}: ${err.message}`);
+  }
+}
+
+function testMergeWritableSucceeds() {
+  resetMcpMergeRefcountsForTests();
+  fs.mkdirSync(TEST_DIR, { recursive: true });
+  const cursorDir = path.join(TEST_DIR, ".cursor");
+  const mcpPath = path.join(cursorDir, "mcp.json");
+  try {
+    fs.rmSync(cursorDir, { recursive: true, force: true });
+  } catch { /* ignore */ }
+
+  let handle;
+  try {
+    handle = mergeWorkspaceMcpJson(TEST_DIR, FAKE_MCP);
+  } catch (err) {
+    fail("merge in writable cwd", err.message);
+    return;
+  }
+
+  if (!fs.existsSync(mcpPath)) {
+    fail("merge in writable cwd", `missing ${mcpPath}`);
+    handle?.restore?.();
+    return;
+  }
+
+  let doc;
+  try {
+    doc = JSON.parse(fs.readFileSync(mcpPath, "utf8"));
+  } catch (err) {
+    fail("merge in writable cwd", `invalid json: ${err.message}`);
+    handle?.restore?.();
+    return;
+  }
+
+  const entry = doc?.mcpServers?.["netcatty-remote-hosts"];
+  if (!entry?.command) {
+    fail("merge in writable cwd", "netcatty-remote-hosts missing from mcp.json");
+  } else {
+    pass(
+      "merge in writable cwd",
+      `wrote ${mcpPath}; command=${entry.command}`,
+    );
+  }
+
+  handle?.restore?.();
+  // After restore of a previously non-existent file, mcp.json should be removed.
+  if (fs.existsSync(mcpPath)) {
+    fail("restore cleans mcp.json", `${mcpPath} still present after restore`);
+  } else {
+    pass("restore cleans mcp.json", "removed after turn-end restore");
+  }
+}
+
+function testMergeFailureIsLoud() {
+  const { runCursorCliTurn } = require("../electron/bridges/aiBridge/sdk/cursorCliDriver.cjs");
+  const calls = [];
+  const emitter = {
+    emitError: (message) => calls.push(message),
+    emitDone: () => {},
+    text: () => {},
+    reasoning: () => {},
+    reasoningEnd: () => {},
+    toolCall: () => {},
+    toolResult: () => {},
+    sessionId: () => {},
+  };
+  return runCursorCliTurn({
+    prompt: "hi",
+    binPath: "/bin/agent",
+    cwd: "/",
+    chatSessionId: "loud-fail",
+    getTempDir: () => path.join(os.tmpdir(), "netcatty-cli-loud-ok"),
+    model: "auto",
+    env: {},
+    permissionMode: "confirm",
+    injectedMcpServers: [{ name: "netcatty-remote-hosts", command: "node", args: ["x"] }],
+    emitter,
+    spawnImpl: () => {
+      throw new Error("spawn should not run after MCP merge failure");
+    },
+    mergeMcp: () => {
+      throw new Error("forced merge failure");
+    },
+  }).then(() => {
+    if (calls.length === 1 && /Failed to prepare Netcatty MCP for Cursor CLI/i.test(calls[0])) {
+      pass("merge failure is user-visible", calls[0]);
+    } else {
+      fail("merge failure is user-visible", JSON.stringify(calls));
+    }
+  });
+}
+
+function testPackagedMcpPath() {
+  if (fs.existsSync(APP_MCP)) {
+    pass("packaged MCP script exists", APP_MCP);
+  } else {
+    fail("packaged MCP script exists", `missing ${APP_MCP}`);
+  }
+
+  // Smoke: Electron binary can at least start the script as node long enough to print env requirement.
+  if (!fs.existsSync(APP_BIN)) {
+    fail("packaged MCP spawn smoke", `missing ${APP_BIN}`);
+    return;
+  }
+  const smoke = spawnSync(
+    APP_BIN,
+    [APP_MCP],
+    {
+      env: {
+        ...process.env,
+        ELECTRON_RUN_AS_NODE: "1",
+        // Intentionally omit NETCATTY_MCP_PORT so server exits quickly with a known message.
+      },
+      encoding: "utf8",
+      timeout: 5000,
+    },
+  );
+  const errText = `${smoke.stderr || ""}${smoke.stdout || ""}`;
+  if (/NETCATTY_MCP_PORT not set/i.test(errText)) {
+    pass("packaged MCP spawn smoke", "Electron+ELECTRON_RUN_AS_NODE runs mcp server bootstrap");
+  } else {
+    fail(
+      "packaged MCP spawn smoke",
+      `unexpected exit=${smoke.status} signal=${smoke.signal} out=${errText.slice(0, 300)}`,
+    );
+  }
+}
+
+async function testAppLaunchCwds() {
+  if (SKIP_APP) {
+    console.log("SKIP  packaged app cwd probes (--skip-app-launch)");
+    return;
+  }
+
+  // Ensure no leftover instance steals single-instance lock from a previous Dock launch.
+  spawnSync("pkill", ["-x", "Netcatty"], { encoding: "utf8" });
+  await sleep(800);
+
+  const fromRoot = await launchAndReadCwd("/", "from /");
+  if (fromRoot === "/" || fromRoot === "/System/Volumes/Data") {
+    pass("packaged cwd when launched from /", fromRoot);
+  } else if (fromRoot == null) {
+    fail("packaged cwd when launched from /", "could not read process cwd (app exited early?)");
+  } else {
+    // Still useful: report actual cwd
+    fail("packaged cwd when launched from /", `expected / , got ${fromRoot}`);
+  }
+
+  spawnSync("pkill", ["-x", "Netcatty"], { encoding: "utf8" });
+  await sleep(800);
+
+  fs.mkdirSync(TEST_DIR, { recursive: true });
+  const fromWritable = await launchAndReadCwd(TEST_DIR, "from writable");
+  if (fromWritable === TEST_DIR || fromWritable === path.resolve(TEST_DIR)) {
+    pass("packaged cwd when launched from writable dir", fromWritable);
+  } else if (fromWritable == null) {
+    fail("packaged cwd when launched from writable dir", "could not read process cwd");
+  } else {
+    fail(
+      "packaged cwd when launched from writable dir",
+      `expected ${TEST_DIR}, got ${fromWritable}`,
+    );
+  }
+
+  spawnSync("pkill", ["-x", "Netcatty"], { encoding: "utf8" });
+}
+
+function testResolveUsesTempOverRoot() {
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "netcatty-cli-fix-"));
+  try {
+    const resolved = resolveCursorCliWorkspaceCwd({
+      preferredCwd: "/",
+      chatSessionId: "verify-chat",
+      getTempDir: () => tempRoot,
+    });
+    const expected = path.join(tempRoot, "cursor-cli-mcp", "verify-chat");
+    if (resolved !== expected) {
+      fail("resolveCursorCliWorkspaceCwd", `expected ${expected}, got ${resolved}`);
+      return;
+    }
+    // Merge into the resolved workspace must succeed even when preferred cwd is /.
+    resetMcpMergeRefcountsForTests();
+    const handle = mergeWorkspaceMcpJson(resolved, FAKE_MCP);
+    const mcpPath = path.join(resolved, ".cursor", "mcp.json");
+    if (!fs.existsSync(mcpPath)) {
+      fail("resolveCursorCliWorkspaceCwd", `missing ${mcpPath}`);
+      handle?.restore?.();
+      return;
+    }
+    handle?.restore?.();
+    pass("resolveCursorCliWorkspaceCwd", `uses ${resolved} instead of /`);
+  } finally {
+    fs.rmSync(tempRoot, { recursive: true, force: true });
+  }
+}
+
+async function main() {
+  console.log("=== Cursor CLI MCP cwd verification ===\n");
+
+  testMergeRootFails();
+  testMergeWritableSucceeds();
+  await testMergeFailureIsLoud();
+  testResolveUsesTempOverRoot();
+  testPackagedMcpPath();
+  await testAppLaunchCwds();
+
+  const failed = results.filter((r) => !r.ok);
+  console.log(`\n=== Summary: ${results.length - failed.length}/${results.length} passed ===`);
+  if (failed.length) {
+    console.error("Failed checks:");
+    for (const f of failed) console.error(` - ${f.name}: ${f.detail}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  console.log("\nConclusion:");
+  console.log("- Finder/Dock cwd=/ cannot host .cursor/mcp.json.");
+  console.log("- Fix: Cursor CLI turns use Netcatty temp cursor-cli-mcp/<chatId> workspace.");
+  console.log("- Merge failures now error out instead of silently dropping MCP.");
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exitCode = 1;
+});