fathom-mcp 0.5.14 → 0.5.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fathom-mcp",
-  "version": "0.5.14",
+  "version": "0.5.16",
   "description": "MCP server for Fathom — vault operations, search, rooms, and cross-workspace communication",
   "type": "module",
   "bin": {

package/src/agents.js

@@ -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;
@@ -633,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 {
@@ -649,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));
@@ -664,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 {
@@ -684,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";
@@ -768,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");
@@ -861,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",
   );
@@ -874,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, "~");
 
@@ -882,7 +871,6 @@ function runList() {
       "  " +
         name.padEnd(cols.name) +
         type.padEnd(cols.type) +
-        mode.padEnd(cols.mode) +
         status.padEnd(cols.status) +
         dir,
     );
@@ -959,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");
@@ -973,7 +960,6 @@ async function runAdd(argv) {
   const entry = {
     projectDir: path.resolve(agentProjectDir),
     agentType,
-    executionMode,
     command,
     server,
     apiKey,

package/src/ws-connection.js

@@ -164,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);
   }