fathom-mcp 0.5.12 → 0.5.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fathom-mcp",
-  "version": "0.5.12",
+  "version": "0.5.14",
   "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: {} };

package/src/cli.js

@@ -149,9 +149,7 @@ function copyScripts(targetDir) {
 const HEADLESS_CMDS = {
   "claude-code": (prompt) => ["claude", "-p", "--dangerously-skip-permissions", prompt],
   "claude-sdk":  (prompt) => ["claude", "-p", "--dangerously-skip-permissions", prompt],
-  "codex":       (prompt) => ["codex", "exec", prompt],
   "gemini":      (prompt) => ["gemini", prompt],
-  "opencode":    (prompt) => ["opencode", "run", prompt],
 };
 
 function buildIntegrationPrompt(blob) {
@@ -249,27 +247,6 @@ function writeMcpJson(cwd) {
   return ".mcp.json";
 }
 
-function writeCodexToml(cwd) {
-  const dir = path.join(cwd, ".codex");
-  fs.mkdirSync(dir, { recursive: true });
-  const filePath = path.join(dir, "config.toml");
-
-  let content = "";
-  try {
-    content = fs.readFileSync(filePath, "utf-8");
-  } catch { /* file doesn't exist */ }
-
-  // Check if fathom-vault section already exists
-  if (/\[mcp_servers\.fathom-vault\]/.test(content)) {
-    return ".codex/config.toml (already configured)";
-  }
-
-  const section = `\n[mcp_servers.fathom-vault]\ncommand = "npx"\nargs = ["-y", "fathom-mcp"]\n`;
-  const separator = content && !content.endsWith("\n") ? "\n" : "";
-  fs.writeFileSync(filePath, content + separator + section);
-  return ".codex/config.toml";
-}
-
 function writeGeminiJson(cwd) {
   const dir = path.join(cwd, ".gemini");
   fs.mkdirSync(dir, { recursive: true });
@@ -280,22 +257,6 @@ function writeGeminiJson(cwd) {
   return ".gemini/settings.json";
 }
 
-function writeOpencodeJson(cwd) {
-  const filePath = path.join(cwd, "opencode.json");
-  const existing = readJsonFile(filePath) || {};
-  deepMerge(existing, {
-    mcp: {
-      "fathom-vault": {
-        type: "local",
-        command: ["npx", "-y", "fathom-mcp"],
-        enabled: true,
-      },
-    },
-  });
-  writeJsonFile(filePath, existing);
-  return "opencode.json";
-}
-
 const AGENTS = {
   "claude-code": {
     name: "Claude Code",
@@ -304,38 +265,31 @@ const AGENTS = {
     hasHooks: true,
     nextSteps: 'Add to CLAUDE.md: `ToolSearch query="+fathom" max_results=20`',
   },
-  "codex": {
-    name: "OpenAI Codex",
-    detect: (cwd) => fs.existsSync(path.join(cwd, ".codex")),
-    configWriter: writeCodexToml,
-    hasHooks: false,
-    nextSteps: "Run `codex` in this directory — fathom tools load automatically.",
+  "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")),
     configWriter: writeGeminiJson,
-    hasHooks: false,
+    hasHooks: true,
     nextSteps: "Run `gemini` in this directory — fathom tools load automatically.",
   },
-  "opencode": {
-    name: "OpenCode",
-    detect: (cwd) => fs.existsSync(path.join(cwd, "opencode.json")),
-    configWriter: writeOpencodeJson,
+  "manual": {
+    name: "I'll set up my agent myself",
+    detect: () => false,
+    configWriter: () => "(skipped — manual setup)",
     hasHooks: false,
-    nextSteps: "Run `opencode` in this directory — fathom tools load automatically.",
-  },
-  "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",
+    nextSteps: "Point your agent's MCP config at: npx -y fathom-mcp",
   },
 };
 
 // Exported for testing
-export { AGENTS, writeMcpJson, writeCodexToml, writeGeminiJson, writeOpencodeJson };
+export { AGENTS, writeMcpJson, writeGeminiJson };
 
 // --- Init wizard -------------------------------------------------------------
 
@@ -404,7 +358,7 @@ async function runInit(flags = {}) {
       const agent = AGENTS[key];
       const isDetected = detected.includes(key);
       const mark = isDetected ? "✓" : " ";
-      const markers = { "claude-code": ".claude/", "codex": ".codex/", "gemini": ".gemini/", "opencode": "opencode.json", "claude-sdk": ".claude/" };
+      const markers = { "claude-code": ".claude/", "claude-sdk": ".claude/", "gemini": ".gemini/" };
       const hint = isDetected ? ` (${markers[key] || key} found)` : "";
       console.log(`    ${mark} ${agent.name}${hint}`);
     }
@@ -630,6 +584,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}`);
@@ -1000,7 +959,7 @@ 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|codex|gemini|opencode)", defaults.agentType);
+  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 server = await ask(rl, "  Server URL", defaults.server);

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

@@ -346,6 +346,18 @@ const tools = [
       required: [],
     },
   },
+  {
+    name: "fathom_key_rotate",
+    description:
+      "Rotate this agent's API key. Revokes the current per-agent key and issues a new one. " +
+      "Updates the local agents.json config and reconnects the WebSocket. " +
+      "Only works with per-agent keys — admin keys use the dashboard.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: [],
+    },
+  },
 ];
 
 // --- Vault routing by mode ---------------------------------------------------
@@ -471,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(
@@ -489,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 };
 });
 
@@ -657,6 +689,41 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       break;
     }
 
+    // --- Key rotation ---
+    case "fathom_key_rotate": {
+      const rotateResult = await client.rotateKey();
+      if (rotateResult.error) {
+        result = { error: `Key rotation failed: ${rotateResult.error}` };
+        break;
+      }
+
+      // Update agents.json with new key
+      try {
+        const { loadAgentsConfig, saveAgentsConfig } = await import("./agents.js");
+        const agentsConf = loadAgentsConfig();
+        if (agentsConf.agents[config.workspace]) {
+          agentsConf.agents[config.workspace].apiKey = rotateResult.api_key;
+          saveAgentsConfig(agentsConf);
+        }
+      } catch {
+        // agents.json update failed — still return the new key
+      }
+
+      // Reconnect WebSocket with new key
+      if (wsConn) {
+        wsConn.close();
+        config.apiKey = rotateResult.api_key;
+        wsConn = createWSConnection(config);
+      }
+
+      result = {
+        ok: true,
+        workspace: rotateResult.workspace,
+        message: "Key rotated successfully. agents.json updated, WebSocket reconnected.",
+      };
+      break;
+    }
+
     // --- Telegram ---
     case "fathom_telegram_contacts":
       result = await client.telegramContacts(config.workspace);
@@ -750,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() {
@@ -310,6 +318,10 @@ export function createClient(config) {
     return request("GET", "/api/auth/key");
   }
 
+  async function rotateKey() {
+    return request("POST", "/api/auth/keys/rotate");
+  }
+
   async function healthCheck() {
     try {
       const resp = await fetch(`${baseUrl}/api/auth/status`, {
@@ -357,8 +369,10 @@ export function createClient(config) {
     telegramSendVoice,
     telegramStatus,
     speak,
+    injectKeys,
     getSettings,
     getApiKey,
+    rotateKey,
     healthCheck,
   };
 }

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);
   }
@@ -177,8 +189,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}`);
     }
   }