fathom-mcp 0.6.4 → 2.0.0

package/src/server-client.js

@@ -1,303 +0,0 @@
-/**
- * HTTP client for fathom-server REST API.
- *
- * Handles search, rooms, workspaces, and access notifications.
- * Uses native fetch (Node 18+). Auth via Bearer token from .fathom.json.
- */
-
-/**
- * @param {object} config - Resolved config from config.js
- */
-export function createClient(config) {
-  const baseUrl = config.server;
-  const apiKey = config.apiKey;
-  const workspace = config.workspace;
-
-  /** Percent-encode each segment of a file path for safe URL interpolation. */
-  function encodeFilePath(fp) {
-    return fp.split("/").map(encodeURIComponent).join("/");
-  }
-
-  /**
-   * Make an authenticated request to the server.
-   * Returns parsed JSON on success, { error } on failure.
-   */
-  async function request(method, path, { params, body, timeout = 30000 } = {}) {
-    const url = new URL(path, baseUrl);
-    if (params) {
-      for (const [k, v] of Object.entries(params)) {
-        if (v != null) url.searchParams.set(k, String(v));
-      }
-    }
-
-    const headers = { "Content-Type": "application/json" };
-    if (apiKey) {
-      headers["Authorization"] = `Bearer ${apiKey}`;
-    }
-
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeout);
-
-    try {
-      const resp = await fetch(url.toString(), {
-        method,
-        headers,
-        body: body ? JSON.stringify(body) : undefined,
-        signal: controller.signal,
-      });
-
-      const data = await resp.json();
-
-      if (!resp.ok) {
-        return { error: data.error || `Server returned ${resp.status}` };
-      }
-
-      return data;
-    } catch (e) {
-      if (e.name === "AbortError") {
-        return { error: `Request timed out after ${timeout / 1000}s` };
-      }
-      return { error: `Server unavailable: ${e.message}` };
-    } finally {
-      clearTimeout(timer);
-    }
-  }
-
-  // --- Search ----------------------------------------------------------------
-
-  async function search(query, { mode = "bm25", limit, ws } = {}) {
-    return request("GET", "/api/search", {
-      params: { q: query, mode, n: limit, workspace: ws || workspace },
-    });
-  }
-
-  async function vsearch(query, { limit, ws } = {}) {
-    return search(query, { mode: "vector", limit, ws });
-  }
-
-  async function hybridSearch(query, { limit, ws } = {}) {
-    return search(query, { mode: "hybrid", limit, ws });
-  }
-
-  // --- Rooms -----------------------------------------------------------------
-
-  async function roomPost(room, message, sender) {
-    return request("POST", `/api/room/${encodeURIComponent(room)}`, {
-      body: { message, sender },
-    });
-  }
-
-  async function roomRead(room, minutes, start, ws, markRead) {
-    return request("GET", `/api/room/${encodeURIComponent(room)}`, {
-      params: { minutes, start, workspace: ws, mark_read: markRead },
-    });
-  }
-
-  async function roomList(ws) {
-    return request("GET", "/api/room/list", {
-      params: { workspace: ws },
-    });
-  }
-
-  async function roomMarkRead(room, ws) {
-    return request("POST", `/api/room/${encodeURIComponent(room)}/read`, {
-      body: { workspace: ws },
-    });
-  }
-
-  async function roomDescribe(room, description) {
-    return request("PUT", `/api/room/${encodeURIComponent(room)}/description`, {
-      body: { description },
-    });
-  }
-
-  // --- Direct messaging -------------------------------------------------------
-
-  async function sendToWorkspace(target, message, from) {
-    return request("POST", `/api/send/${encodeURIComponent(target)}`, {
-      body: { message, from: from || workspace },
-    });
-  }
-
-  // --- Workspaces ------------------------------------------------------------
-
-  async function listWorkspaces() {
-    return request("GET", "/api/workspaces/profiles");
-  }
-
-  async function registerWorkspace(name, projectPath, { vault, description, agents, type } = {}) {
-    const body = { name, path: projectPath };
-    if (vault) body.vault = vault;
-    if (description) body.description = description;
-    if (agents && agents.length > 0) body.agents = agents;
-    if (type) body.type = type;
-    return request("POST", "/api/workspaces", { body });
-  }
-
-  async function provisionWorkspace(name, projectPath, { vault, description, agents, type, execution, ssh } = {}) {
-    const body = { name, path: projectPath };
-    if (vault) body.vault = vault;
-    if (description) body.description = description;
-    if (agents && agents.length > 0) body.agents = agents;
-    if (type) body.type = type;
-    if (execution) body.execution = execution;
-    if (ssh) body.ssh = ssh;
-    return request("POST", "/api/workspaces/provision", { body });
-  }
-
-  // --- Access tracking -------------------------------------------------------
-
-  async function notifyAccess(filePath, ws) {
-    return request("POST", "/api/vault/access", {
-      params: { workspace: ws || workspace },
-      body: { path: filePath },
-    });
-  }
-
-  // --- Activity-enriched listings (via server) --------------------------------
-
-  async function vaultList(ws) {
-    return request("GET", "/api/vault", {
-      params: { workspace: ws || workspace },
-    });
-  }
-
-  async function vaultFolder(folder, ws) {
-    const folderPath = folder || "";
-    return request("GET", `/api/vault/folder/${encodeFilePath(folderPath)}`, {
-      params: { workspace: ws || workspace },
-    });
-  }
-
-  // --- Activation / Routines -------------------------------------------------
-
-  async function createRoutine(params, ws) {
-    const body = {};
-    if (params.name != null) body.name = params.name;
-    if (params.enabled != null) body.enabled = params.enabled;
-    if (params.intervalMinutes != null) body.intervalMinutes = params.intervalMinutes;
-    if (params.singleFire != null) body.singleFire = params.singleFire;
-    if (params.contextSources != null) body.contextSources = params.contextSources;
-    if (params.schedule !== undefined) body.schedule = params.schedule;
-    if (params.conditions != null) body.conditions = params.conditions;
-    return request("POST", "/api/activation/ping/routines", {
-      params: { workspace: ws },
-      body,
-    });
-  }
-
-  async function listRoutines(ws) {
-    return request("GET", "/api/activation/ping/routines", {
-      params: { workspace: ws },
-    });
-  }
-
-  async function updateRoutine(routineId, params, ws) {
-    const body = {};
-    if (params.name != null) body.name = params.name;
-    if (params.enabled != null) body.enabled = params.enabled;
-    if (params.intervalMinutes != null) body.intervalMinutes = params.intervalMinutes;
-    if (params.singleFire != null) body.singleFire = params.singleFire;
-    if (params.contextSources != null) body.contextSources = params.contextSources;
-    if (params.schedule !== undefined) body.schedule = params.schedule;
-    if (params.conditions != null) body.conditions = params.conditions;
-    return request("POST", `/api/activation/ping/routines/${encodeURIComponent(routineId)}`, {
-      params: { workspace: ws },
-      body,
-    });
-  }
-
-  async function deleteRoutine(routineId, ws) {
-    return request("DELETE", `/api/activation/ping/routines/${encodeURIComponent(routineId)}`, {
-      params: { workspace: ws },
-    });
-  }
-
-  async function fireRoutine(routineId, ws) {
-    return request("POST", `/api/activation/ping/routines/${encodeURIComponent(routineId)}/now`, {
-      params: { workspace: ws },
-    });
-  }
-
-  // --- Heartbeat -------------------------------------------------------------
-
-  async function heartbeat(ws, agent, vaultMode) {
-    const body = {};
-    if (agent) body.agent = agent;
-    if (vaultMode) body.vault_mode = vaultMode;
-    return request("POST", `/api/workspaces/${encodeURIComponent(ws)}/heartbeat`, { body });
-  }
-
-  // --- TTS ------------------------------------------------------------------
-
-  async function speak({ text, file, speed, play, format } = {}) {
-    return request("POST", "/api/tts/speak", {
-      body: { text, file, speed, play, format },
-      timeout: 300000,
-    });
-  }
-
-  async function voiceReply({ text, speed, workspace } = {}) {
-    return request("POST", "/api/voice/reply", {
-      body: { text, speed, workspace },
-      timeout: 300000,
-    });
-  }
-
-  // --- Settings --------------------------------------------------------------
-
-  async function getSettings() {
-    return request("GET", "/api/settings");
-  }
-
-  // --- Auth ------------------------------------------------------------------
-
-  async function getApiKey() {
-    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`, {
-        signal: AbortSignal.timeout(5000),
-      });
-      return resp.ok;
-    } catch {
-      return false;
-    }
-  }
-
-  return {
-    search,
-    vsearch,
-    hybridSearch,
-    roomPost,
-    roomRead,
-    roomList,
-    roomMarkRead,
-    roomDescribe,
-    sendToWorkspace,
-    listWorkspaces,
-    registerWorkspace,
-    provisionWorkspace,
-    notifyAccess,
-    vaultList,
-    vaultFolder,
-    createRoutine,
-    listRoutines,
-    updateRoutine,
-    deleteRoutine,
-    fireRoutine,
-    heartbeat,
-    speak,
-    voiceReply,
-    getSettings,
-    getApiKey,
-    rotateKey,
-    healthCheck,
-  };
-}

package/src/ws-connection.js

@@ -1,156 +0,0 @@
-/**
- * WebSocket push channel — receives server-pushed messages and handles them locally.
- *
- * Connects to fathom-server's /ws/agent/{workspace} endpoint. Receives:
- *   - ping → respond with pong
- *
- * Stream-json agents handle inject/ping_fire via subprocess stdin — the server
- * writes directly, so no tmux injection is needed here.
- *
- * Auto-reconnects with exponential backoff (1s → 60s cap).
- */
-
-import WebSocket from "ws";
-
-const KEEPALIVE_INTERVAL_MS = 30_000;
-const INITIAL_RECONNECT_MS = 1_000;
-const MAX_RECONNECT_MS = 60_000;
-
-/**
- * @param {object} config — resolved config from config.js
- * @returns {{ close: () => void }}
- */
-export function createWSConnection(config) {
-  const workspace = config.workspace;
-  const agent = config.agents?.[0] || "unknown";
-  const vaultMode = config.vaultMode || "local";
-
-  // Derive WS URL from HTTP server URL
-  const serverUrl = config.server || "http://localhost:4243";
-  const wsUrl = serverUrl
-    .replace(/^http:/, "ws:")
-    .replace(/^https:/, "wss:")
-    + `/ws/agent/${encodeURIComponent(workspace)}`;
-
-  let ws = null;
-  let reconnectDelay = INITIAL_RECONNECT_MS;
-  let keepaliveTimer = null;
-  let closed = false;
-
-  connect();
-
-  function connect() {
-    if (closed) return;
-
-    console.error(`[ws] connecting to ${wsUrl}`);
-
-    try {
-      ws = new WebSocket(wsUrl);
-    } 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 (token sent here, not in URL)
-      ws.send(JSON.stringify({
-        type: "hello",
-        agent,
-        vault_mode: vaultMode,
-        token: config.apiKey || "",
-      }));
-
-      // Start keepalive pong timer
-      startKeepalive();
-    });
-
-    ws.on("message", (raw) => {
-      let msg;
-      try {
-        msg = JSON.parse(raw.toString());
-      } catch {
-        return;
-      }
-
-      switch (msg.type) {
-        case "welcome":
-          console.error(`[ws] welcome received — connection established for workspace=${workspace}`);
-          break;
-
-        case "inject":
-        case "ping_fire":
-          // Stream-json agents handle injection via subprocess stdin on the server side
-          console.error(`[ws] received ${msg.type} (${(msg.text || "").length} chars) — handled by server subprocess`);
-          break;
-
-        case "ping":
-          safeSend({ type: "pong" });
-          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", (code, reason) => {
-      console.error(`[ws] closed (code=${code}, reason=${reason || "none"})`);
-      stopKeepalive();
-      if (!closed) scheduleReconnect();
-    });
-
-    ws.on("error", (err) => {
-      console.error(`[ws] error: ${err.message}`);
-      // Error always followed by close event — reconnect handled there
-      stopKeepalive();
-    });
-  }
-
-  function safeSend(obj) {
-    try {
-      if (ws && ws.readyState === WebSocket.OPEN) {
-        ws.send(JSON.stringify(obj));
-      }
-    } catch {
-      // Swallow — close event will trigger reconnect
-    }
-  }
-
-  function startKeepalive() {
-    stopKeepalive();
-    keepaliveTimer = setInterval(() => {
-      safeSend({ type: "pong" });
-    }, KEEPALIVE_INTERVAL_MS);
-  }
-
-  function stopKeepalive() {
-    if (keepaliveTimer) {
-      clearInterval(keepaliveTimer);
-      keepaliveTimer = null;
-    }
-  }
-
-  function scheduleReconnect() {
-    if (closed) return;
-    console.error(`[ws] reconnecting in ${reconnectDelay}ms`);
-    setTimeout(connect, reconnectDelay);
-    reconnectDelay = Math.min(reconnectDelay * 2, MAX_RECONNECT_MS);
-  }
-
-  function close() {
-    closed = true;
-    stopKeepalive();
-    if (ws) {
-      try { ws.close(); } catch { /* ignore */ }
-      ws = null;
-    }
-  }
-
-  return { close };
-}