fathom-mcp 0.4.9 → 0.4.11

package/package.json

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

package/src/cli.js

@@ -411,19 +411,20 @@ async function runInit(flags = {}) {
   }
 
   // 5. Server URL
-  const serverUrl = nonInteractive
+  let serverUrl = nonInteractive
     ? (flagServer || "http://localhost:4243")
     : await ask(rl, "\n  Fathom server URL", "http://localhost:4243");
 
   // 6. API key
-  const apiKey = flagApiKey || (nonInteractive ? "" : await ask(rl, "  API key (from dashboard or server first-run output)", ""));
+  let apiKey = flagApiKey || (nonInteractive ? "" : await ask(rl, "  API key (from dashboard or server first-run output)", ""));
 
   // 7. Server probe — check reachability early
-  const regClient = createClient({ server: serverUrl, apiKey, workspace });
-  const serverReachable = serverUrl ? await regClient.healthCheck() : false;
+  let regClient = createClient({ server: serverUrl, apiKey, workspace });
+  let serverReachable = serverUrl ? await regClient.healthCheck() : false;
   const serverOnPath = detectFathomServer();
 
-  if (!serverReachable) {
+  // Retry loop for server connectivity (interactive mode)
+  while (!serverReachable && !nonInteractive) {
     console.log(`\n  ⚠ Fathom server not reachable at ${serverUrl}\n`);
     if (serverOnPath === "installed") {
       console.log("  Start it:  fathom-server");
@@ -433,11 +434,25 @@ async function runInit(flags = {}) {
       console.log("    # or: docker run -p 4243:4243 ghcr.io/myra/fathom-server");
     }
     console.log("\n  Without the server, only \"local\" and \"none\" vault modes are available.");
+    const retry = await askYesNo(rl, "\n  Try a different server URL or API key?", true);
+    if (!retry) break;
+    serverUrl = await ask(rl, "\n  Fathom server URL", serverUrl);
+    apiKey = await ask(rl, "  API key", apiKey);
+    regClient = createClient({ server: serverUrl, apiKey, workspace });
+    serverReachable = await regClient.healthCheck();
+    if (serverReachable) {
+      console.log("  ✓ Server connected!");
+    }
   }
 
   // 8. Vault mode selection
   let vaultMode;
   if (nonInteractive) {
+    if (!serverReachable && flagServer) {
+      console.error(`\n  Error: Server at ${serverUrl} is not reachable.`);
+      console.error("  Fix the URL or start the server, then re-run init.");
+      process.exit(1);
+    }
     vaultMode = serverReachable ? "hosted" : "local";
     console.log(`  Vault mode: ${vaultMode} (auto-selected)`);
   } else {

package/src/index.js

@@ -291,6 +291,55 @@ const tools = [
       required: ["workspace", "message"],
     },
   },
+  {
+    name: "fathom_routine_create",
+    description:
+      "Create a new ping routine for a workspace. Routines fire on an interval and inject " +
+      "context into the persistent session. Use single_fire for one-shot routines that " +
+      "auto-disable after firing once. All parameters are optional with sensible defaults.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Routine name. Default: 'New Routine'." },
+        enabled: { type: "boolean", description: "Start enabled. Default: false." },
+        interval_minutes: { type: "integer", description: "Minutes between pings. Default: 60.", minimum: 1 },
+        single_fire: { type: "boolean", description: "Auto-disable after firing once. Default: false." },
+        workspace: WORKSPACE_PROP,
+        context_sources: {
+          type: "object",
+          description: "What to inject on each ping.",
+          properties: {
+            time: { type: "boolean", description: "Include current time/date. Default: true." },
+            scripts: {
+              type: "array",
+              description: "Shell commands to run and inject output.",
+              items: {
+                type: "object",
+                properties: {
+                  label: { type: "string" },
+                  command: { type: "string" },
+                  enabled: { type: "boolean" },
+                },
+              },
+            },
+            texts: {
+              type: "array",
+              description: "Static text blocks to inject.",
+              items: {
+                type: "object",
+                properties: {
+                  label: { type: "string" },
+                  content: { type: "string" },
+                  enabled: { type: "boolean" },
+                },
+              },
+            },
+          },
+        },
+      },
+      required: [],
+    },
+  },
 ];
 
 // --- Vault routing by mode ---------------------------------------------------
@@ -480,6 +529,16 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     case "fathom_send":
       result = await client.sendToWorkspace(args.workspace, args.message, config.workspace);
       break;
+    case "fathom_routine_create": {
+      const routineParams = {};
+      if (args.name != null) routineParams.name = args.name;
+      if (args.enabled != null) routineParams.enabled = args.enabled;
+      if (args.interval_minutes != null) routineParams.intervalMinutes = args.interval_minutes;
+      if (args.single_fire != null) routineParams.singleFire = args.single_fire;
+      if (args.context_sources != null) routineParams.contextSources = args.context_sources;
+      result = await client.createRoutine(routineParams, args.workspace || config.workspace);
+      break;
+    }
     default:
       result = { error: `Unknown tool: ${name}` };
   }
@@ -539,6 +598,13 @@ async function startupSync() {
         await client.pushFile(config.workspace, filePath, content);
       }
     }
+
+    // Delete server files that no longer exist locally (local is source of truth)
+    if (diff.deleted?.length) {
+      for (const filePath of diff.deleted) {
+        await client.deleteFile(config.workspace, filePath);
+      }
+    }
   } catch {
     // Sync failure is non-fatal — local vault is source of truth
   }
@@ -551,12 +617,23 @@ async function main() {
       vault: config._rawVault,
       description: config.description,
       agents: config.agents,
+      type: config.vaultMode,
     }).catch(() => {});
   }
 
   // Startup sync for synced mode (fire-and-forget)
   startupSync().catch(() => {});
 
+  // Heartbeat — report liveness to server every 30s
+  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);
 }

package/src/server-client.js

@@ -190,6 +190,30 @@ export function createClient(config) {
     });
   }
 
+  // --- 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;
+    return request("POST", "/api/activation/ping/routines", {
+      params: { workspace: ws },
+      body,
+    });
+  }
+
+  // --- 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 });
+  }
+
   // --- Auth ------------------------------------------------------------------
 
   async function getApiKey() {
@@ -229,6 +253,8 @@ export function createClient(config) {
     listFiles,
     pushFile,
     syncManifest,
+    createRoutine,
+    heartbeat,
     getApiKey,
     healthCheck,
   };