@agent-chat/mention-watcher 0.1.9 → 0.1.11

package/dist/watch.js

@@ -4,6 +4,7 @@
 import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
+import { spawn } from "child_process";
 import * as pty from "node-pty";
 import { WebSocket } from "ws";
 function loadEnvFile(filePath) {
@@ -20,14 +21,16 @@ function loadEnvFile(filePath) {
   }
   return result;
 }
-function syncMcpToken(workspaceDir, mcpServerName) {
-  const envToken = loadEnvFile(path.join(workspaceDir, ".env")).AGENT_TOKEN;
+function syncMcpToken(workspaceDir, mcpServerName, preferredToken) {
+  const envVars = loadEnvFile(path.join(workspaceDir, ".env"));
+  const envToken = preferredToken ?? process.env.AGENT_TOKEN ?? envVars.AGENT_TOKEN ?? envVars.BOOTSTRAP_AGENT_TOKEN;
   if (!envToken) return;
-  const claudePaths = [
+  const mcpPaths = [
     path.join(workspaceDir, ".mcp.json"),
-    path.join(workspaceDir, ".claude", "mcp.json")
+    path.join(workspaceDir, ".claude", "mcp.json"),
+    path.join(workspaceDir, ".cursor", "mcp.json")
   ];
-  for (const configPath of claudePaths) {
+  for (const configPath of mcpPaths) {
     if (!fs.existsSync(configPath)) continue;
     let config;
     try {
@@ -37,19 +40,53 @@ function syncMcpToken(workspaceDir, mcpServerName) {
 `);
       continue;
     }
-    const server = config?.mcpServers?.[mcpServerName];
-    if (!server) continue;
-    const current = server.env?.AGENT_TOKEN;
-    if (current === envToken) {
+    const servers = config?.mcpServers;
+    if (!servers || typeof servers !== "object") {
+      process.stderr.write(`[mention-watcher] No mcpServers in ${configPath}, skipping
+`);
+      continue;
+    }
+    const explicit = servers[mcpServerName];
+    const candidates = /* @__PURE__ */ new Set();
+    if (explicit) candidates.add(mcpServerName);
+    for (const [name, server] of Object.entries(servers)) {
+      const command = String(server?.command ?? "");
+      const args = Array.isArray(server?.args) ? server.args.map((a) => String(a)).join(" ") : "";
+      const signature = `${command} ${args}`;
+      if (signature.includes("agent-gateway") || signature.includes("@agent-chat")) {
+        candidates.add(name);
+      }
+    }
+    if (candidates.size === 0) {
+      process.stderr.write(
+        `[mention-watcher] No matching MCP server in ${configPath} (expected "${mcpServerName}")
+`
+      );
+      continue;
+    }
+    let changed = false;
+    let updatedCount = 0;
+    for (const name of candidates) {
+      const server = servers[name] ?? {};
+      server.env = server.env ?? {};
+      const tokenBefore = server.env.AGENT_TOKEN;
+      const bootstrapBefore = server.env.BOOTSTRAP_AGENT_TOKEN;
+      if (tokenBefore !== envToken || bootstrapBefore !== envToken) {
+        server.env.AGENT_TOKEN = envToken;
+        server.env.BOOTSTRAP_AGENT_TOKEN = envToken;
+        servers[name] = server;
+        changed = true;
+      }
+      updatedCount += 1;
+    }
+    if (!changed) {
       process.stderr.write(`[mention-watcher] MCP token up-to-date: ${configPath}
 `);
       continue;
     }
-    server.env = server.env ?? {};
-    server.env.AGENT_TOKEN = envToken;
     try {
       fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
-      process.stderr.write(`[mention-watcher] MCP token synced: ${configPath}
+      process.stderr.write(`[mention-watcher] MCP token synced (${updatedCount} server): ${configPath}
 `);
     } catch (err) {
       process.stderr.write(`[mention-watcher] Failed to write ${configPath}: ${err.message}
@@ -57,6 +94,121 @@ function syncMcpToken(workspaceDir, mcpServerName) {
     }
   }
 }
+function buildPtyEnv(env) {
+  const out = {};
+  for (const [k, v] of Object.entries(env)) {
+    if (typeof v !== "string") continue;
+    if (k.includes("\0") || v.includes("\0")) continue;
+    if (/^(npm_|npm_config_|npm_package_|npm_lifecycle_|PNPM_|pnpm_)/.test(k)) continue;
+    out[k] = v;
+  }
+  if (!out.PATH && typeof env.PATH === "string") out.PATH = env.PATH;
+  if (!out.PATH && typeof env.Path === "string") out.PATH = env.Path;
+  if (!out.HOME && typeof env.HOME === "string") out.HOME = env.HOME;
+  if (!out.SHELL && typeof env.SHELL === "string") out.SHELL = env.SHELL;
+  if (!out.TERM) out.TERM = "xterm-256color";
+  return out;
+}
+function escapePosixArg(arg) {
+  return `'${arg.replace(/'/g, "'\\''")}'`;
+}
+function escapeCmdArg(arg) {
+  if (arg.length === 0) return '""';
+  if (/[\s"]/g.test(arg)) return `"${arg.replace(/"/g, '\\"')}"`;
+  return arg;
+}
+function buildCommandLine(command, args, platform) {
+  if (platform === "win32") {
+    return [command, ...args].map(escapeCmdArg).join(" ");
+  }
+  return [command, ...args].map(escapePosixArg).join(" ");
+}
+function getShellFallbackPlan(command, args, env) {
+  if (process.platform === "win32") {
+    const cmd = env.ComSpec || process.env.ComSpec || "cmd.exe";
+    const shellCmd2 = buildCommandLine(command, args, "win32");
+    return {
+      shell: cmd,
+      argv: ["/d", "/s", "/c", shellCmd2],
+      display: `${cmd} /d /s /c "${shellCmd2}"`
+    };
+  }
+  const userShell = env.SHELL || process.env.SHELL || "/bin/zsh";
+  const shellCmd = `exec ${buildCommandLine(command, args, process.platform)}`;
+  return {
+    shell: userShell,
+    argv: ["-lc", shellCmd],
+    display: `${userShell} -lc "${shellCmd}"`
+  };
+}
+function hasScriptPtySupport() {
+  if (process.platform === "win32") return false;
+  return fs.existsSync("/usr/bin/script") || fs.existsSync("/bin/script");
+}
+function spawnViaScriptPty(command, args, cwd, env) {
+  if (!hasScriptPtySupport()) {
+    throw new Error("script command is not available on this platform");
+  }
+  const scriptArgs = process.platform === "darwin" ? ["-q", "/dev/null", command, ...args] : ["-q", "-c", buildCommandLine(command, args, process.platform), "/dev/null"];
+  const child = spawn("script", scriptArgs, {
+    cwd,
+    env,
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  return {
+    mode: "script-pty",
+    write(data) {
+      if (!child.stdin.destroyed) child.stdin.write(data);
+    },
+    onData(cb) {
+      child.stdout.on("data", (buf) => cb(buf.toString()));
+      child.stderr.on("data", (buf) => cb(buf.toString()));
+    },
+    onExit(cb) {
+      child.on("exit", (code) => cb({ exitCode: code ?? 1 }));
+      child.on("error", () => cb({ exitCode: 1 }));
+    },
+    // Resize is not supported through the `script` wrapper.
+    resize() {
+    },
+    kill(signal) {
+      try {
+        child.kill(signal ?? "SIGINT");
+      } catch {
+      }
+    }
+  };
+}
+function spawnWithoutPty(command, args, cwd, env) {
+  const child = spawn(command, args, {
+    cwd,
+    env,
+    stdio: ["pipe", "pipe", "pipe"],
+    shell: process.platform === "win32"
+  });
+  return {
+    mode: "plain",
+    write(data) {
+      if (!child.stdin.destroyed) child.stdin.write(data);
+    },
+    onData(cb) {
+      child.stdout.on("data", (buf) => cb(buf.toString()));
+      child.stderr.on("data", (buf) => cb(buf.toString()));
+    },
+    onExit(cb) {
+      child.on("exit", (code) => cb({ exitCode: code ?? 1 }));
+      child.on("error", () => cb({ exitCode: 1 }));
+    },
+    resize() {
+    },
+    kill(signal) {
+      try {
+        child.kill(signal ?? "SIGINT");
+      } catch {
+      }
+    }
+  };
+}
 var _WORKSPACE = process.env.WORKSPACE_DIR ?? process.cwd();
 {
   const dirsToCheck = [.../* @__PURE__ */ new Set([process.cwd(), _WORKSPACE])];
@@ -165,6 +317,19 @@ function scheduleInject(proc) {
 function drainQueue(proc) {
   if (queue.length === 0) return;
   const prompt = queue.shift();
+  if (proc.mode !== "pty") {
+    setTimeout(() => {
+      proc.write(prompt);
+    }, 30);
+    setTimeout(() => {
+      proc.write("\r");
+      setTimeout(() => proc.write("\n"), 20);
+      process.stderr.write(`[mention-watcher] Injected mention prompt (${proc.mode})
+`);
+      if (queue.length > 0) scheduleInject(proc);
+    }, 120);
+    return;
+  }
   proc.write("");
   setTimeout(() => {
     proc.write(prompt);
@@ -172,6 +337,7 @@ function drainQueue(proc) {
   setTimeout(() => {
     proc.write("\r");
     setTimeout(() => proc.write("\n"), 20);
+    process.stderr.write("[mention-watcher] Injected mention prompt (pty)\n");
     if (queue.length > 0) scheduleInject(proc);
   }, 200);
 }
@@ -189,8 +355,8 @@ async function main() {
     process.stderr.write("    npx @agent-chat/mention-watcher setup\n");
     process.exit(1);
   }
-  syncMcpToken(WORKSPACE_DIR, MCP_NAME);
   const jwt = await resolveJwt();
+  syncMcpToken(WORKSPACE_DIR, MCP_NAME, jwt);
   const cols = process.stdout.columns || 80;
   const rows = process.stdout.rows || 24;
   const wdSource = process.env.WORKSPACE_DIR ? "env" : "auto-detected";
@@ -198,39 +364,92 @@ async function main() {
 `);
   process.stderr.write(`[mention-watcher] Spawning: ${COMMAND} ${CMD_ARGS.join(" ")}
 `);
+  const ptyEnv = buildPtyEnv(process.env);
+  const spawnOptions = {
+    name: "xterm-256color",
+    cols,
+    rows,
+    cwd: WORKSPACE_DIR,
+    env: ptyEnv
+  };
   let proc;
   try {
-    proc = pty.spawn(COMMAND, CMD_ARGS, {
-      name: "xterm-256color",
-      cols,
-      rows,
-      cwd: WORKSPACE_DIR,
-      env: process.env
-    });
+    const p = pty.spawn(COMMAND, CMD_ARGS, spawnOptions);
+    proc = { ...p, mode: "pty" };
   } catch (err) {
-    process.stderr.write(`[mention-watcher] Failed to spawn "${COMMAND}": ${err.message}
+    const msg = String(err?.message ?? err);
+    if (!msg.includes("posix_spawnp failed")) {
+      process.stderr.write(`[mention-watcher] Failed to spawn "${COMMAND}": ${msg}
 `);
-    process.stderr.write(`  Run "which ${COMMAND}" in your terminal to confirm it is installed.
+      process.stderr.write(`  Run "which ${COMMAND}" in your terminal to confirm it is installed.
 `);
-    process.exit(1);
+      process.exit(1);
+    }
+    const shellPlan = getShellFallbackPlan(COMMAND, CMD_ARGS, ptyEnv);
+    process.stderr.write(
+      `[mention-watcher] Direct spawn failed, retry via shell: ${shellPlan.display}
+`
+    );
+    try {
+      const p = pty.spawn(shellPlan.shell, shellPlan.argv, spawnOptions);
+      proc = { ...p, mode: "pty" };
+    } catch (shellErr) {
+      const shellMsg = String(shellErr?.message ?? shellErr);
+      process.stderr.write(`[mention-watcher] Shell fallback failed: ${shellMsg}
+`);
+      process.stderr.write("[mention-watcher] Falling back to script PTY mode (if available)\n");
+      try {
+        proc = spawnViaScriptPty(COMMAND, CMD_ARGS, WORKSPACE_DIR, ptyEnv);
+      } catch (scriptErr) {
+        const scriptMsg = String(scriptErr?.message ?? scriptErr);
+        process.stderr.write(`[mention-watcher] Script PTY fallback failed: ${scriptMsg}
+`);
+        process.stderr.write("[mention-watcher] Falling back to non-PTY mode\n");
+        proc = spawnWithoutPty(COMMAND, CMD_ARGS, WORKSPACE_DIR, ptyEnv);
+      }
+    }
   }
   proc.onData((data) => {
     process.stdout.write(data);
     lastOutputAt = Date.now();
   });
+  let cleanedUp = false;
+  const cleanupTerminal = () => {
+    if (cleanedUp) return;
+    cleanedUp = true;
+    if (process.stdin.isTTY) {
+      try {
+        process.stdin.setRawMode(false);
+      } catch {
+      }
+    }
+    process.stdin.pause();
+  };
   if (process.stdin.isTTY) {
     process.stdin.setRawMode(true);
   }
   process.stdin.resume();
   process.stdin.on("data", (data) => {
+    if (data.length === 1 && data[0] === 3) {
+      proc.kill?.("SIGINT");
+      cleanupTerminal();
+      process.exit(130);
+      return;
+    }
     proc.write(data.toString("binary"));
   });
   process.stdout.on("resize", () => {
     proc.resize(process.stdout.columns || 80, process.stdout.rows || 24);
   });
   proc.onExit(({ exitCode }) => {
+    cleanupTerminal();
     process.exit(exitCode);
   });
+  process.on("SIGINT", () => {
+    proc.kill?.("SIGINT");
+    cleanupTerminal();
+    process.exit(130);
+  });
   await startWsListener(
     jwt,
     // ── mention handler ──────────────────────────────────────────────────────

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-chat/mention-watcher",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "PTY wrapper that pushes @mentions from agent-chat into Claude Code (or any LLM CLI)",
   "type": "module",
   "bin": {