fathom-mcp 0.6.4 → 2.0.0

package/src/index.js

@@ -1,552 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * fathom-mcp — MCP server for Fathom vault operations.
- *
- * Dispatches tools to server-client.js (HTTP to fathom-server — search, rooms, workspaces).
- * Vault CRUD is handled by the agent's native file tools (Read, Write, Edit, Glob).
- */
-
-import fs from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
-
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-} from "@modelcontextprotocol/sdk/types.js";
-
-import { resolveConfig } from "./config.js";
-import { createClient } from "./server-client.js";
-import { createWSConnection } from "./ws-connection.js";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-
-const config = resolveConfig();
-const client = createClient(config);
-let wsConn = null;
-
-// --- Tool definitions --------------------------------------------------------
-
-const WORKSPACE_PROP = {
-  type: "string",
-  description: "Workspace name (e.g. 'fathom', 'navier-stokes'). If omitted, uses default workspace.",
-};
-
-const tools = [
-  {
-    name: "fathom_vault_search",
-    description:
-      "Keyword search (BM25) across vault files — start here for most searches. Fast, " +
-      "exact-match oriented. Best for specific terms, file names, or known phrases. " +
-      "If results miss conceptually related content, follow up with fathom_vault_vsearch.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        query: { type: "string", description: "Search query (keywords)" },
-        workspace: WORKSPACE_PROP,
-        limit: { type: "integer", description: "Max results to return (default: from settings, typically 10)" },
-      },
-      required: ["query"],
-    },
-  },
-  {
-    name: "fathom_vault_vsearch",
-    description:
-      "Semantic/vector search across vault files — use when keyword search misses or when " +
-      "exploring ideas by meaning rather than exact terms. Finds conceptually similar content " +
-      "even without keyword overlap. Slower than fathom_vault_search. " +
-      "For the most thorough results, use fathom_vault_query instead.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        query: { type: "string", description: "Search query (natural language, conceptual)" },
-        workspace: WORKSPACE_PROP,
-        limit: { type: "integer", description: "Max results to return (default: from settings, typically 10)" },
-      },
-      required: ["query"],
-    },
-  },
-  {
-    name: "fathom_vault_query",
-    description:
-      "Hybrid search combining BM25 keyword matching, vector similarity, and reranking — " +
-      "the most thorough search mode. Use when completeness matters more than speed " +
-      "(e.g. 'find everything related to X'). Slowest of the three search tools. " +
-      "For quick lookups, start with fathom_vault_search instead.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        query: { type: "string", description: "Search query (keywords or natural language)" },
-        workspace: WORKSPACE_PROP,
-        limit: { type: "integer", description: "Max results to return (default: from settings, typically 10)" },
-      },
-      required: ["query"],
-    },
-  },
-  {
-    name: "fathom_room_post",
-    description:
-      "Post a message to a shared room. Rooms are created implicitly on first post. " +
-      "Use this for ambient, multilateral communication — unlike fathom_send (point-to-point DM), " +
-      "room messages are visible to all participants. Responding is optional — use `<...>` for active silence. " +
-      "Supports @workspace mentions (e.g. @fathom, @navier-stokes) — mentioned workspaces receive " +
-      "notifications in their mentions:{workspace} virtual room via fathom_room_list. Use @all to notify every workspace except sender.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        room: { type: "string", description: "Room name, e.g. 'general', 'navier-stokes'. Created on first post." },
-        message: { type: "string", description: "Message to post. Use @workspace to mention and notify specific workspaces (e.g. '@fathom check this'), or @all for everyone." },
-      },
-      required: ["room", "message"],
-    },
-  },
-  {
-    name: "fathom_room_read",
-    description:
-      "Read recent messages from a shared room. Returns messages within a time window anchored " +
-      "to the latest message. Default: 60 minutes before the latest message. Use start to look " +
-      "further back. Example: minutes=15, start=120 returns 15 minutes of conversation starting " +
-      "2 hours before the latest message. Response includes window metadata with has_older flag " +
-      "for pseudo-pagination. All rooms are persistent — messages are never deleted on read. " +
-      "Automatically marks the room as read unless mark_read=false.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        room: { type: "string", description: "Room name to read from" },
-        minutes: { type: "number", description: "Window duration in minutes. Default: 60." },
-        start: { type: "number", description: "Offset in minutes from the latest message. Default: 0 (window ends at latest message). Set to 120 to look back starting 2 hours before the latest message." },
-        mark_read: { type: "boolean", description: "Set to false to peek without marking the room as read. Default: true." },
-      },
-      required: ["room"],
-    },
-  },
-  {
-    name: "fathom_room_list",
-    description:
-      "List all rooms with activity summary — message count, last activity time, last sender, " +
-      "description, and per-room unread_count for this workspace. Use to discover active rooms " +
-      "and see which have new messages. DM rooms (dm:a+b) are filtered by workspace param — " +
-      "only participants see them. Mention rooms (mentions:{workspace}) visible only to the target workspace.",
-    inputSchema: {
-      type: "object",
-      properties: {},
-      required: [],
-    },
-  },
-  {
-    name: "fathom_room_describe",
-    description:
-      "Set or update the description/topic for a room. Descriptions help participants " +
-      "understand what a room is for. Pass an empty string to clear.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        room: { type: "string", description: "Room name to set description for" },
-        description: { type: "string", description: "Room description/topic — what this room is about" },
-      },
-      required: ["room", "description"],
-    },
-  },
-  {
-    name: "fathom_workspaces",
-    description:
-      "List all configured workspaces — use this to discover valid workspace names before " +
-      "calling fathom_send. Returns each workspace's name, running status, model, and role.",
-    inputSchema: {
-      type: "object",
-      properties: {},
-      required: [],
-    },
-  },
-  {
-    name: "fathom_send",
-    description:
-      "Send a message to another workspace's agent instance — stored in a shared dm:a+b room " +
-      "visible to both participants. Use fathom_workspaces first to discover valid targets. " +
-      "DMs are persistent and appear in both participants' room lists via fathom_room_list.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        workspace: { type: "string", description: "Target workspace name — run fathom_workspaces to see available options" },
-        message: { type: "string", description: "Message to send to the target workspace's agent instance" },
-      },
-      required: ["workspace", "message"],
-    },
-  },
-  {
-    name: "fathom_routine_list",
-    description:
-      "List all ping routines for a workspace with their status, intervals, " +
-      "enabled state, and next fire time. Use this to see what routines exist " +
-      "before updating or deleting them.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        workspace: WORKSPACE_PROP,
-      },
-      required: [],
-    },
-  },
-  {
-    name: "fathom_routine_fire",
-    description:
-      "Fire a ping routine immediately, regardless of its schedule. Non-blocking — " +
-      "returns immediately while the routine fires in the background. The routine's " +
-      "next scheduled fire time is not affected.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        routine_id: { type: "string", description: "The routine ID to fire." },
-        workspace: WORKSPACE_PROP,
-      },
-      required: ["routine_id"],
-    },
-  },
-  {
-    name: "fathom_speak",
-    description:
-      "Generate speech using Kokoro TTS (am_echo 70% + bf_alice 30%). " +
-      "Always returns path to generated WAV file. Set play=true to also play aloud. " +
-      "Use file param to read a text file instead of inline text.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        text: { type: "string", description: "Text to speak. Ignored if file is provided." },
-        file: { type: "string", description: "Absolute path to a text file to read aloud. Overrides text param." },
-        speed: { type: "number", description: "Speech speed multiplier. Default: 1.0" },
-        play: { type: "boolean", description: "Also play audio aloud during generation. Default: false." },
-      },
-      required: [],
-    },
-  },
-  {
-    name: "fathom_send_voice",
-    description:
-      "Send a voice message to Myra via the app. Generates speech using Kokoro TTS " +
-      "(am_echo 70% + bf_alice 30%) and delivers it as a playable voice bubble in the chat. " +
-      "Use this to reply conversationally with voice when Myra sends a voice message.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        text: { type: "string", description: "Text to speak and send as voice message." },
-        speed: { type: "number", description: "Speech speed multiplier. Default: 1.0" },
-      },
-      required: ["text"],
-    },
-  },
-  {
-    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: [],
-    },
-  },
-];
-
-// --- Policy evaluation tool (permission-prompt-tool for stream-json) ---------
-
-const policyTools = [
-  {
-    name: "policy_evaluate",
-    description:
-      "Evaluate a permission request for a tool call. Called automatically by Claude " +
-      "via --permission-prompt-tool when a tool is not in the static allow list. " +
-      "Returns {behavior: 'allow'} or {behavior: 'deny', message: '...'}.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        tool_name: { type: "string", description: "The tool being requested (e.g. 'Bash', 'Edit')" },
-        input: { type: "object", description: "The tool's input arguments" },
-      },
-      required: ["tool_name", "input"],
-    },
-  },
-  {
-    name: "permission_respond",
-    description:
-      "Respond to a pending permission request from another workspace. " +
-      "Called by the policy-gate workspace to approve or deny an escalated permission. " +
-      "Returns {ok: true} on success, {error: '...'} if request not found or already resolved.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        request_id: { type: "string", description: "The permission request ID" },
-        allow: { type: "boolean", description: "true to approve, false to deny" },
-        reason: { type: "string", description: "Brief explanation for the decision" },
-      },
-      required: ["request_id", "allow"],
-    },
-  },
-];
-
-// --- Primary-agent-only tools (reserved for future use) ----------------------
-
-
-// --- Policy evaluation -------------------------------------------------------
-
-/**
- * Evaluate a permission request from Claude's --permission-prompt-tool.
- *
- * Decision logic:
- *   1. Hard deny: auto-reject dangerous operations
- *   2. Escalate: everything else goes to dashboard for human approval
- *   (Pre-approval is handled by settings.local.json allow list, not here)
- */
-async function evaluatePermission(toolName, input) {
-
-  // --- Hard deny list ---
-  if (toolName === "Bash") {
-    const cmd = (input.command || "").trim();
-    const denyPatterns = [
-      /\brm\s+-rf\s+[\/~]/,               // rm -rf broad paths
-      /\bsudo\b/,                           // privilege escalation
-      /\bsu\s/,                             // switch user
-      /\bgit\s+push\s+.*--force\s.*(main|master)/,  // force push to main
-      /\b(\.ssh|\.gnupg)\b/,               // sensitive directories
-    ];
-    for (const p of denyPatterns) {
-      if (p.test(cmd)) {
-        return { behavior: "deny", message: `Blocked by policy: ${cmd.slice(0, 100)}` };
-      }
-    }
-  }
-
-  // --- Ambiguous: escalate to dashboard ---
-  try {
-    const serverUrl = config.server || "http://localhost:4243";
-    const apiKey = config.apiKey || "";
-    const resp = await fetch(`${serverUrl}/api/permissions/request`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        ...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}),
-      },
-      body: JSON.stringify({
-        workspace: config.workspace,
-        tool_name: toolName,
-        tool_input: input,
-      }),
-    });
-    if (resp.ok) {
-      const data = await resp.json();
-      if (data.allow) {
-        return { behavior: "allow", updatedInput: input };
-      }
-      return { behavior: "deny", message: data.reason || "Denied by human" };
-    }
-  } catch (err) {
-    console.error(`[policy] Dashboard escalation failed: ${err.message}`);
-  }
-
-  // Default deny if escalation fails
-  return { behavior: "deny", message: "Could not reach dashboard for approval" };
-}
-
-
-// --- Server setup & dispatch -------------------------------------------------
-
-const server = new Server(
-  { name: "fathom-mcp", version: "0.1.0" },
-  { capabilities: { tools: {} } },
-);
-
-server.setRequestHandler(ListToolsRequestSchema, async () => {
-  const allTools = [...tools, ...policyTools];
-  return { tools: allTools };
-});
-
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-  const { name, arguments: args } = request.params;
-  let result;
-
-  switch (name) {
-    // --- Search tools (server-routed) ---
-    case "fathom_vault_search":
-      result = await client.search(args.query, { mode: "bm25", limit: args.limit, ws: args.workspace });
-      break;
-    case "fathom_vault_vsearch":
-      result = await client.vsearch(args.query, { limit: args.limit, ws: args.workspace });
-      break;
-    case "fathom_vault_query":
-      result = await client.hybridSearch(args.query, { limit: args.limit, ws: args.workspace });
-      break;
-    case "fathom_room_post":
-      result = await client.roomPost(args.room, args.message, config.workspace);
-      break;
-    case "fathom_room_read":
-      result = await client.roomRead(
-        args.room, args.minutes, args.start,
-        args.mark_read !== false ? config.workspace : undefined,
-        args.mark_read,
-      );
-      break;
-    case "fathom_room_list":
-      result = await client.roomList(config.workspace);
-      break;
-    case "fathom_room_describe":
-      result = await client.roomDescribe(args.room, args.description);
-      break;
-    case "fathom_workspaces":
-      result = await client.listWorkspaces();
-      break;
-    case "fathom_send":
-      result = await client.sendToWorkspace(args.workspace, args.message, config.workspace);
-      break;
-    case "fathom_routine_list":
-      result = await client.listRoutines(args.workspace || config.workspace);
-      break;
-    case "fathom_routine_fire":
-      result = await client.fireRoutine(args.routine_id, args.workspace || config.workspace);
-      break;
-    // --- TTS ---
-    case "fathom_speak": {
-      if (!args.text && !args.file) {
-        result = { error: "Either text or file parameter is required." };
-        break;
-      }
-      result = await client.speak({
-        text: args.text,
-        file: args.file,
-        speed: args.speed,
-        play: args.play,
-      });
-      break;
-    }
-    case "fathom_send_voice": {
-      if (!args.text) {
-        result = { error: "text parameter is required." };
-        break;
-      }
-      result = await client.voiceReply({
-        text: args.text,
-        speed: args.speed,
-        workspace: config.workspace,
-      });
-      break;
-    }
-
-    // --- Key rotation ---
-    case "fathom_key_rotate": {
-      const rotateResult = await client.rotateKey();
-      if (rotateResult.error) {
-        result = { error: `Key rotation failed: ${rotateResult.error}` };
-        break;
-      }
-
-      // Update .fathom.json with new key
-      try {
-        const { findConfigFile } = await import("./config.js");
-        const found = findConfigFile();
-        if (found) {
-          const updated = { ...found.config, apiKey: rotateResult.api_key };
-          const { writeFileSync } = await import("fs");
-          writeFileSync(found.path, JSON.stringify(updated, null, 2) + "\n");
-        }
-      } catch {
-        // .fathom.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. .fathom.json updated, WebSocket reconnected.",
-      };
-      break;
-    }
-
-    // --- Policy evaluation (permission-prompt-tool for stream-json agents) ---
-    case "policy_evaluate": {
-      result = await evaluatePermission(args.tool_name, args.input || {});
-      break;
-    }
-    case "permission_respond": {
-      const serverUrl = config.server || "http://localhost:4243";
-      const apiKey = config.apiKey || "";
-      const resp = await fetch(
-        `${serverUrl}/api/permissions/${encodeURIComponent(args.request_id)}/respond`,
-        {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            ...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}),
-          },
-          body: JSON.stringify({
-            allow: args.allow,
-            reason: args.reason || "policy-gate decision",
-            workspace: config.workspace,
-          }),
-        }
-      );
-      if (resp.ok) {
-        result = await resp.json();
-      } else {
-        const errBody = await resp.text();
-        result = { error: `Server returned ${resp.status}: ${errBody}` };
-      }
-      break;
-    }
-
-    default:
-      result = { error: `Unknown tool: ${name}` };
-  }
-
-  // Image tool returns a special content block
-  if (result?._image) {
-    return {
-      content: [{ type: "image", data: result.data, mimeType: result.mimeType }],
-    };
-  }
-
-  return {
-    content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
-    isError: !!result?.error,
-  };
-});
-
-async function main() {
-  // Auto-register workspace with server (fire-and-forget)
-  if (config.server && config.workspace) {
-    client.registerWorkspace(config.workspace, config._projectDir, {
-      vault: config._rawVault,
-      agents: config.agents,
-      type: config.vaultMode,
-    }).catch(() => {});
-  }
-
-  // WebSocket push channel — receives server-pushed messages
-  if (config.server && config.workspace && config.apiKey) {
-    wsConn = createWSConnection(config);
-  }
-
-  // Heartbeat — report liveness to server every 30s (kept for backwards compat)
-  if (config.server && config.workspace) {
-    const beat = () =>
-      client
-        .heartbeat(config.workspace, config.agents?.[0], config.vaultMode)
-        .catch(() => {});
-    beat(); // immediate
-    setInterval(beat, 30_000);
-  }
-
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-}
-
-main().catch(console.error);