fathom-mcp 0.5.13 → 0.5.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fathom-mcp",
-  "version": "0.5.13",
+  "version": "0.5.16",
   "description": "MCP server for Fathom — vault operations, search, rooms, and cross-workspace communication",
   "type": "module",
   "bin": {
@@ -9,7 +9,8 @@
   "main": "src/index.js",
   "files": [
     "src/",
-    "scripts/",
+    "scripts/*.sh",
+    "scripts/*.py",
     "fathom-agents.md",
     "README.md",
     "CHANGELOG.md",

package/src/agents.js

@@ -9,7 +9,7 @@ import fs from "fs";
 import path from "path";
 import { execSync, execFileSync } from "child_process";
 
-const CONFIG_DIR = path.join(process.env.HOME || "/tmp", ".config", "fathom-mcp");
+const CONFIG_DIR = process.env.FATHOM_CONFIG_DIR || path.join(process.env.HOME || "/tmp", ".config", "fathom-mcp");
 const AGENTS_FILE = path.join(CONFIG_DIR, "agents.json");
 
 const EMPTY_CONFIG = { version: 1, agents: {} };
@@ -65,40 +65,15 @@ export function removeAgent(name) {
 export function isAgentRunning(name, entry) {
   if (entry.ssh) return "ssh";
 
-  const mode = entry.executionMode || "tmux";
-
-  if (mode === "tmux") {
-    const session = `${name}_fathom-session`;
-    try {
-      execSync(`tmux has-session -t ${JSON.stringify(session)} 2>/dev/null`, {
-        stdio: "pipe",
-      });
-      return "running";
-    } catch {
-      return "stopped";
-    }
-  }
-
-  // headless — check pids directory for any live processes
-  const pidsDir = path.join(entry.projectDir, ".fathom", "pids");
+  const session = `${name}_fathom-session`;
   try {
-    const files = fs.readdirSync(pidsDir);
-    for (const file of files) {
-      try {
-        const pid = parseInt(file, 10);
-        if (!isNaN(pid)) {
-          process.kill(pid, 0); // signal 0 = existence check
-          return "running";
-        }
-      } catch {
-        // Dead process — clean up stale PID file
-        try { fs.unlinkSync(path.join(pidsDir, file)); } catch { /* */ }
-      }
-    }
+    execSync(`tmux has-session -t ${JSON.stringify(session)} 2>/dev/null`, {
+      stdio: "pipe",
+    });
+    return "running";
   } catch {
-    // pids dir doesn't exist
+    return "stopped";
   }
-  return "stopped";
 }
 
 // ── Start / Stop ────────────────────────────────────────────────────────────
@@ -106,29 +81,39 @@ export function isAgentRunning(name, entry) {
 /**
  * Default command per agent type + execution mode.
  */
-export function defaultCommand(agentType, executionMode) {
+export function defaultCommand(agentType) {
   const cmds = {
-    "claude-code": {
-      tmux: "claude --model opus --permission-mode bypassPermissions",
-      headless:
-        "claude -p --permission-mode bypassPermissions --output-format stream-json",
-    },
-    "claude-sdk": {
-      tmux: "claude --model opus --permission-mode bypassPermissions",
-      headless:
-        "claude -p --permission-mode bypassPermissions --output-format stream-json",
-    },
-    codex: { tmux: "codex", headless: "codex" },
-    gemini: { tmux: "gemini", headless: "gemini" },
-    opencode: { tmux: "opencode", headless: "opencode" },
+    "claude-code": "claude --model opus --permission-mode bypassPermissions",
+    codex: "codex",
+    gemini: "gemini",
+    opencode: "opencode",
   };
-  const forType = cmds[agentType] || cmds["claude-code"];
-  return forType[executionMode] || forType.tmux;
+  return cmds[agentType] || cmds["claude-code"];
+}
+
+/**
+ * Check if a Claude Code project has any previous conversations to --continue from.
+ * Claude stores conversations as .jsonl files in ~/.claude/projects/<encoded-path>/.
+ */
+function hasPreviousConversation(projectDir) {
+  const encoded = projectDir.replace(/^\//, "").replace(/\//g, "-");
+  const convDir = path.join(process.env.HOME || "/tmp", ".claude", "projects", encoded);
+  try {
+    const files = fs.readdirSync(convDir);
+    return files.some((f) => f.endsWith(".jsonl"));
+  } catch {
+    return false;
+  }
 }
 
 export function startAgent(name, entry) {
-  const mode = entry.executionMode || "tmux";
-  const command = entry.command || defaultCommand(entry.agentType || "claude-code", mode);
+  let command = entry.command || defaultCommand(entry.agentType || "claude-code");
+
+  // --continue crashes if there's no previous conversation. Strip it for new agents.
+  if (command.includes("--continue") && !hasPreviousConversation(entry.projectDir)) {
+    command = command.replace(/\s*--continue\b/g, "");
+  }
+
   const session = `${name}_fathom-session`;
 
   // Build env
@@ -144,10 +129,6 @@ export function startAgent(name, entry) {
     return startAgentSSH(name, entry, command, env);
   }
 
-  if (mode === "headless") {
-    return startAgentHeadless(name, entry, command, env);
-  }
-
   return startAgentTmux(name, entry, command, session, env);
 }
 
@@ -199,12 +180,6 @@ function savePaneId(name, session) {
   }
 }
 
-function startAgentHeadless(name, entry, command, env) {
-  // Headless agents are per-invocation — no persistent process to start.
-  // The server spawns fresh claude -p processes on demand.
-  return { ok: true, message: `Headless agent "${name}" ready (per-invocation mode)` };
-}
-
 function startAgentSSH(name, entry, command, env) {
   const { host, user, key } = entry.ssh;
   const sshArgs = [];
@@ -248,33 +223,6 @@ export function stopAgent(name, entry) {
     // No tmux session
   }
 
-  // Kill headless processes (per-invocation pids directory)
-  const fathomDir = path.join(entry.projectDir, ".fathom");
-  const pidsDir = path.join(fathomDir, "pids");
-  try {
-    const files = fs.readdirSync(pidsDir);
-    for (const file of files) {
-      try {
-        const pid = parseInt(file, 10);
-        if (!isNaN(pid)) {
-          process.kill(pid);
-          messages.push(`Killed headless process: PID ${pid}`);
-          stopped = true;
-        }
-      } catch {
-        // Already dead
-      }
-      try { fs.unlinkSync(path.join(pidsDir, file)); } catch { /* */ }
-    }
-  } catch {
-    // pids dir doesn't exist
-  }
-
-  // Clean up legacy files
-  for (const f of ["agent.pid", "agent-keeper.pid", "agent.pipe"]) {
-    try { fs.unlinkSync(path.join(fathomDir, f)); } catch { /* */ }
-  }
-
   if (!stopped) {
     return { ok: false, message: `No running session found for: ${name}` };
   }
@@ -289,13 +237,10 @@ export function stopAgent(name, entry) {
  */
 export function buildEntryFromConfig(projectDir, fathomConfig) {
   const agentType = fathomConfig.agents?.[0] || "claude-code";
-  const isHeadless = agentType === "claude-sdk";
-  const executionMode = isHeadless ? "headless" : "tmux";
   return {
     projectDir,
     agentType,
-    executionMode,
-    command: defaultCommand(agentType, executionMode),
+    command: defaultCommand(agentType),
     server: fathomConfig.server || "http://localhost:4243",
     apiKey: fathomConfig.apiKey || "",
     vault: fathomConfig.vault || "vault",

package/src/cli.js

@@ -144,14 +144,6 @@ function copyScripts(targetDir) {
   }
 }
 
-// --- Headless agent integration ----------------------------------------------
-
-const HEADLESS_CMDS = {
-  "claude-code": (prompt) => ["claude", "-p", "--dangerously-skip-permissions", prompt],
-  "claude-sdk":  (prompt) => ["claude", "-p", "--dangerously-skip-permissions", prompt],
-  "gemini":      (prompt) => ["gemini", prompt],
-};
-
 function buildIntegrationPrompt(blob) {
   return [
     "The following instructions were generated by fathom-mcp init for this project.",
@@ -180,8 +172,14 @@ function detectFathomServer() {
   }
 }
 
-function runAgentHeadless(agentKey, prompt) {
-  const cmdBuilder = HEADLESS_CMDS[agentKey];
+// Agent commands for non-interactive prompt integration (init --non-interactive)
+const AGENT_PROMPT_CMDS = {
+  "claude-code": (prompt) => ["claude", "-p", "--dangerously-skip-permissions", prompt],
+  "gemini":      (prompt) => ["gemini", prompt],
+};
+
+function runAgentPrompt(agentKey, prompt) {
+  const cmdBuilder = AGENT_PROMPT_CMDS[agentKey];
   if (!cmdBuilder) return null;
   const [cmd, ...args] = cmdBuilder(prompt);
   try {
@@ -265,13 +263,6 @@ const AGENTS = {
     hasHooks: true,
     nextSteps: 'Add to CLAUDE.md: `ToolSearch query="+fathom" max_results=20`',
   },
-  "claude-sdk": {
-    name: "Claude SDK (headless)",
-    detect: (cwd) => fs.existsSync(path.join(cwd, ".claude")),
-    configWriter: writeMcpJson,
-    hasHooks: true,
-    nextSteps: "Headless Claude Code — no TUI, structured I/O. Start with: npx fathom-mcp start",
-  },
   "gemini": {
     name: "Gemini CLI",
     detect: (cwd) => fs.existsSync(path.join(cwd, ".gemini")),
@@ -358,7 +349,7 @@ async function runInit(flags = {}) {
       const agent = AGENTS[key];
       const isDetected = detected.includes(key);
       const mark = isDetected ? "✓" : " ";
-      const markers = { "claude-code": ".claude/", "claude-sdk": ".claude/", "gemini": ".gemini/" };
+      const markers = { "claude-code": ".claude/", "gemini": ".gemini/" };
       const hint = isDetected ? ` (${markers[key] || key} found)` : "";
       console.log(`    ${mark} ${agent.name}${hint}`);
     }
@@ -458,7 +449,7 @@ async function runInit(flags = {}) {
     : "vault";
 
   // 9. Hooks — ask if any hook-supporting agent is selected (Claude Code, Claude SDK, Gemini CLI)
-  const hasClaude = selectedAgents.includes("claude-code") || selectedAgents.includes("claude-sdk");
+  const hasClaude = selectedAgents.includes("claude-code");
   const hasGemini = selectedAgents.includes("gemini");
   const hasHookAgent = hasClaude || hasGemini;
   let enableRecallHook = false;
@@ -584,6 +575,11 @@ async function runInit(flags = {}) {
     }
   }
 
+  // Register in CLI agent registry (for ls/start/stop)
+  const entry = buildEntryFromConfig(cwd, configData);
+  registryAddAgent(workspace, entry);
+  console.log(`  ✓ Registered agent "${workspace}" in CLI registry`);
+
   // Context-aware next steps
   console.log(`\n  Done! Fathom MCP is configured for workspace "${workspace}".`);
   console.log(`  Vault mode: ${vaultMode}`);
@@ -628,12 +624,12 @@ async function runInit(flags = {}) {
 
   if (instructionsBlob) {
     const prompt = buildIntegrationPrompt(instructionsBlob);
-    const cmdParts = HEADLESS_CMDS[primaryAgent]?.(prompt);
+    const cmdBuilder = AGENT_PROMPT_CMDS[primaryAgent];
 
     if (nonInteractive) {
-      if (cmdParts) {
+      if (cmdBuilder) {
         console.log(`\n  Integrating instructions via ${AGENTS[primaryAgent].name}...`);
-        const result = runAgentHeadless(primaryAgent, prompt);
+        const result = runAgentPrompt(primaryAgent, prompt);
         if (result !== null) {
           console.log(result);
         } else {
@@ -644,9 +640,9 @@ async function runInit(flags = {}) {
         printInstructionsFallback(agentMdPath, selectedAgents);
       }
     } else {
-      if (cmdParts) {
-        const [cmd, ...args] = cmdParts;
-        const flagArgs = args.slice(0, -1).join(" ");
+      if (cmdBuilder) {
+        const [cmd, ...sampleArgs] = cmdBuilder("<prompt>");
+        const flagArgs = sampleArgs.slice(0, -1).join(" ");
         const displayCmd = `${cmd} ${flagArgs} <prompt>`;
         const rl2 = readline.createInterface({ input: process.stdin, output: process.stdout });
         console.log("\n" + "─".repeat(60));
@@ -659,7 +655,7 @@ async function runInit(flags = {}) {
 
         if (integrate) {
           console.log(`\n  Running ${AGENTS[primaryAgent].name}...`);
-          const result = runAgentHeadless(primaryAgent, prompt);
+          const result = runAgentPrompt(primaryAgent, prompt);
           if (result !== null) {
             console.log(result);
           } else {
@@ -679,7 +675,7 @@ async function runInit(flags = {}) {
 }
 
 function printInstructionsFallback(agentMdPath, selectedAgents) {
-  const hasNonClaude = selectedAgents.some((k) => k !== "claude-code" && k !== "claude-sdk");
+  const hasNonClaude = selectedAgents.some((k) => k !== "claude-code");
   const docTarget = hasNonClaude
     ? "your CLAUDE.md, AGENTS.md, or equivalent"
     : "your CLAUDE.md";
@@ -763,8 +759,8 @@ async function runUpdate() {
   const sessionStartCmd = "bash ~/.config/fathom-mcp/scripts/fathom-sessionstart.sh";
   const registeredHooks = [];
 
-  // Claude Code / Claude SDK
-  const hasClaude = agents.includes("claude-code") || agents.includes("claude-sdk")
+  // Claude Code
+  const hasClaude = agents.includes("claude-code")
     || fs.existsSync(path.join(projectDir, ".claude"));
   if (hasClaude) {
     const settingsPath = path.join(projectDir, ".claude", "settings.local.json");
@@ -856,12 +852,11 @@ function runList() {
   }
 
   // Header
-  const cols = { name: 16, type: 13, mode: 11, status: 10 };
+  const cols = { name: 16, type: 13, status: 10 };
   console.log(
     "\n  " +
       "NAME".padEnd(cols.name) +
       "TYPE".padEnd(cols.type) +
-      "MODE".padEnd(cols.mode) +
       "STATUS".padEnd(cols.status) +
       "DIR",
   );
@@ -869,7 +864,6 @@ function runList() {
   for (const name of names) {
     const entry = agents[name];
     const type = entry.agentType || "claude-code";
-    const mode = entry.executionMode || "tmux";
     const status = entry.ssh ? "[ssh]" : isAgentRunning(name, entry);
     const dir = entry.projectDir.replace(process.env.HOME, "~");
 
@@ -877,7 +871,6 @@ function runList() {
       "  " +
         name.padEnd(cols.name) +
         type.padEnd(cols.type) +
-        mode.padEnd(cols.mode) +
         status.padEnd(cols.status) +
         dir,
     );
@@ -954,9 +947,8 @@ async function runAdd(argv) {
 
   const name = await ask(rl, "  Agent name", nameArg || defaultName);
   const agentProjectDir = await ask(rl, "  Project directory", defaults.projectDir);
-  const agentType = await ask(rl, "  Agent type (claude-code|claude-sdk|gemini|manual)", defaults.agentType);
-  const executionMode = await ask(rl, "  Execution mode (tmux|headless)", defaults.executionMode);
-  const command = await ask(rl, "  Command", defaultCommand(agentType, executionMode));
+  const agentType = await ask(rl, "  Agent type (claude-code|gemini|manual)", defaults.agentType);
+  const command = await ask(rl, "  Command", defaultCommand(agentType));
   const server = await ask(rl, "  Server URL", defaults.server);
   const apiKey = await ask(rl, "  API key", defaults.apiKey);
   const vault = await ask(rl, "  Vault subdirectory", defaults.vault || "vault");
@@ -968,7 +960,6 @@ async function runAdd(argv) {
   const entry = {
     projectDir: path.resolve(agentProjectDir),
     agentType,
-    executionMode,
     command,
     server,
     apiKey,

package/src/config.js

@@ -20,7 +20,7 @@ const DEFAULTS = {
   workspace: "",
   vault: "vault",
   vaultMode: "local", // hosted | synced | local | none
-  server: "http://localhost:4243",
+  server: "http://127.0.0.1:4243",
   apiKey: "",
   description: "",
   agents: [],

package/src/index.js

@@ -483,6 +483,26 @@ const telegramTools = [
   },
 ];
 
+// --- Primary-agent-only tools (policy gate) ----------------------------------
+
+const primaryAgentTools = [
+  {
+    name: "fathom_session_inject",
+    description:
+      "Inject a keystroke into a workspace's tmux session. Primary agent only. " +
+      "Used by the policy gate to respond to permission prompts. " +
+      "Keys must be a single digit 1-9 (to select a numbered option) or a named key (Enter, Escape).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        workspace: { type: "string", description: "Target workspace name (e.g. 'navier-stokes')" },
+        keys: { type: "string", description: "Keys to send — single digit 1-9 or named key (Enter, Escape)" },
+      },
+      required: ["workspace", "keys"],
+    },
+  },
+];
+
 // --- Server setup & dispatch -------------------------------------------------
 
 const server = new Server(
@@ -501,7 +521,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
   } catch {
     // If settings unavailable, hide telegram tools
   }
-  const allTools = [...tools, ...(showTelegram ? telegramTools : [])];
+  const allTools = [...tools, ...(showTelegram ? [...telegramTools, ...primaryAgentTools] : [])];
   return { tools: allTools };
 });
 
@@ -797,6 +817,13 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       }
       break;
     }
+    // --- Session injection (policy gate) ---
+    case "fathom_session_inject": {
+      if (!args.workspace) { result = { error: "workspace is required" }; break; }
+      if (!args.keys) { result = { error: "keys is required" }; break; }
+      result = await client.injectKeys(args.workspace, args.keys);
+      break;
+    }
     case "fathom_telegram_send_voice": {
       const voiceContactArg = args.contact;
       if (!voiceContactArg) { result = { error: "contact is required" }; break; }

package/src/server-client.js

@@ -298,6 +298,14 @@ export function createClient(config) {
     });
   }
 
+  // --- Session injection (policy gate) ----------------------------------------
+
+  async function injectKeys(targetWorkspace, keys) {
+    return request("POST", `/api/session/${encodeURIComponent(targetWorkspace)}/inject`, {
+      body: { keys },
+    });
+  }
+
   // --- Settings --------------------------------------------------------------
 
   async function getSettings() {
@@ -361,6 +369,7 @@ export function createClient(config) {
     telegramSendVoice,
     telegramStatus,
     speak,
+    injectKeys,
     getSettings,
     getApiKey,
     rotateKey,

package/src/ws-connection.js

@@ -54,14 +54,20 @@ export function createWSConnection(config) {
   function connect() {
     if (closed) return;
 
+    // Redact token from URL for logging
+    const redactedUrl = wsUrl.replace(/token=[^&]+/, "token=***");
+    console.error(`[ws] connecting to ${redactedUrl}`);
+
     try {
       ws = new WebSocket(wsUrl);
-    } catch {
+    } catch (err) {
+      console.error(`[ws] connection constructor failed: ${err.message}`);
       scheduleReconnect();
       return;
     }
 
     ws.on("open", () => {
+      console.error(`[ws] connected — sending hello (agent=${agent}, vault_mode=${vaultMode})`);
       reconnectDelay = INITIAL_RECONNECT_MS;
 
       // Send hello handshake
@@ -85,10 +91,12 @@ export function createWSConnection(config) {
 
       switch (msg.type) {
         case "welcome":
+          console.error(`[ws] welcome received — connection established for workspace=${workspace}`);
           break;
 
         case "inject":
         case "ping_fire":
+          console.error(`[ws] received ${msg.type} (${(msg.text || "").length} chars)`);
           injectMessage(msg.text || "");
           break;
 
@@ -101,18 +109,21 @@ export function createWSConnection(config) {
           break;
 
         case "error":
+          console.error(`[ws] server error: ${msg.message || JSON.stringify(msg)}`);
           // Server rejected us — don't reconnect immediately
           reconnectDelay = MAX_RECONNECT_MS;
           break;
       }
     });
 
-    ws.on("close", () => {
+    ws.on("close", (code, reason) => {
+      console.error(`[ws] closed (code=${code}, reason=${reason || "none"})`);
       stopKeepalive();
       if (!closed) scheduleReconnect();
     });
 
-    ws.on("error", () => {
+    ws.on("error", (err) => {
+      console.error(`[ws] error: ${err.message}`);
       // Error always followed by close event — reconnect handled there
       stopKeepalive();
     });
@@ -144,6 +155,7 @@ export function createWSConnection(config) {
 
   function scheduleReconnect() {
     if (closed) return;
+    console.error(`[ws] reconnecting in ${reconnectDelay}ms`);
     setTimeout(connect, reconnectDelay);
     reconnectDelay = Math.min(reconnectDelay * 2, MAX_RECONNECT_MS);
   }
@@ -152,13 +164,6 @@ export function createWSConnection(config) {
 
   function injectMessage(text) {
     if (!text) return;
-
-    if (agent === "claude-sdk") {
-      // Headless agents are per-invocation — injection handled server-side.
-      // Nothing to do client-side.
-      return;
-    }
-
     injectToTmux(text);
   }
 
@@ -177,8 +182,8 @@ export function createWSConnection(config) {
         timeout: 5000,
         stdio: "ignore",
       });
-    } catch {
-      // tmux not available or pane not found — non-fatal
+    } catch (err) {
+      console.error(`[ws] tmux inject failed for ${pane}: ${err.message}`);
     }
   }