fathom-mcp 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog
+
+## 0.1.0 (2026-02-25)
+
+Initial release.
+
+- 16 MCP tools: vault read/write/append, image ops, search (BM25/vector/hybrid), rooms, workspaces
+- CLI: `npx fathom-mcp init` setup wizard, `npx fathom-mcp status`
+- Config resolution: `.fathom.json` → env vars → defaults
+- Hook scripts: SessionStart context injection, PreCompact vault snapshot
+- Direct file I/O for vault operations (no server needed for reads/writes)
+- HTTP client for fathom-server API (search, rooms, workspaces)
+- API key auth support (Bearer token)

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Myra Krusemark
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,118 @@
+# fathom-mcp
+
+```
+▐▘  ▗ ▌
+▜▘▀▌▜▘▛▌▛▌▛▛▌▄▖▛▛▌▛▘▛▌
+▐ █▌▐▖▌▌▙▌▌▌▌  ▌▌▌▙▖▙▌
+                    ▌
+
+  hifathom.com  ·  fathom@myrakrusemark.com
+```
+
+MCP server for [Fathom](https://hifathom.com) — vault operations, search, rooms, and cross-workspace communication.
+
+The MCP tools that let Claude Code interact with your vault. Reads/writes happen locally (fast, no network hop). Search, rooms, and workspace management go through your [fathom-server](https://github.com/myrakrusemark/fathom-vault) instance.
+
+## Quick Start
+
+```bash
+npx fathom-mcp init
+```
+
+That's it. Restart Claude Code and fathom tools will be available.
+
+The init wizard creates:
+- `.fathom.json` — workspace config (server URL, API key, vault path)
+- `.mcp.json` — registers `npx fathom-mcp` as an MCP server
+- `.claude/settings.local.json` — hooks for context injection and precompact snapshots
+- `vault/` — creates the directory if it doesn't exist
+
+## Prerequisites
+
+- **Node.js 18+**
+- **[fathom-server](https://github.com/myrakrusemark/fathom-vault)** running (for search, rooms, and workspace features)
+
+## Commands
+
+```bash
+npx fathom-mcp              # Start MCP server (stdio — used by .mcp.json)
+npx fathom-mcp init          # Interactive setup wizard
+npx fathom-mcp status        # Check server connection + workspace status
+```
+
+## Tools
+
+### Local (direct file I/O)
+| Tool | Description |
+|------|-------------|
+| `fathom_vault_read` | Read a vault file with parsed frontmatter |
+| `fathom_vault_write` | Create or overwrite a vault file (validates frontmatter) |
+| `fathom_vault_append` | Append to a vault file (auto-creates with frontmatter if new) |
+| `fathom_vault_image` | Read a vault image as base64 |
+| `fathom_vault_write_asset` | Save a base64 image to a vault folder's assets/ |
+
+### Server (via fathom-server API)
+| Tool | Description |
+|------|-------------|
+| `fathom_vault_list` | List vault folders with activity signals |
+| `fathom_vault_folder` | List files in a folder with metadata and previews |
+| `fathom_vault_search` | BM25 keyword search |
+| `fathom_vault_vsearch` | Semantic/vector search |
+| `fathom_vault_query` | Hybrid search (BM25 + vectors + reranking) |
+| `fathom_room_post` | Post to a shared room (supports @mentions) |
+| `fathom_room_read` | Read recent room messages |
+| `fathom_room_list` | List all rooms |
+| `fathom_room_describe` | Set a room's description/topic |
+| `fathom_workspaces` | List all configured workspaces |
+| `fathom_send` | Send a message to another workspace's Claude instance |
+
+## Configuration
+
+### `.fathom.json`
+
+```json
+{
+  "workspace": "my-project",
+  "vault": "vault",
+  "server": "http://localhost:4243",
+  "apiKey": "fv_abc123...",
+  "hooks": {
+    "context-inject": { "enabled": true },
+    "precompact-snapshot": { "enabled": true }
+  }
+}
+```
+
+### Resolution order (highest priority first)
+
+1. Environment variables: `FATHOM_SERVER_URL`, `FATHOM_API_KEY`, `FATHOM_WORKSPACE`, `FATHOM_VAULT_DIR`
+2. `.fathom.json` (walked up from cwd to filesystem root)
+3. Built-in defaults
+
+## Hooks
+
+**SessionStart / UserPromptSubmit** (`fathom-context.sh`): Injects recent vault activity into Claude's context.
+
+**PreCompact** (`fathom-precompact.sh`): Records which vault files were active in the session before context compaction.
+
+## Vault Frontmatter Schema
+
+Files can optionally include YAML frontmatter:
+
+```yaml
+---
+title: My Note          # required (string)
+date: 2026-02-25        # required (string, YYYY-MM-DD)
+tags:                    # optional (list)
+  - research
+  - identity
+status: draft            # optional: draft | published | archived
+project: my-project      # optional (string)
+aliases:                 # optional (list)
+  - alt-name
+---
+```
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "fathom-mcp",
+  "version": "0.1.0",
+  "description": "MCP server for Fathom — vault operations, search, rooms, and cross-workspace communication",
+  "type": "module",
+  "bin": {
+    "fathom-mcp": "src/cli.js"
+  },
+  "main": "src/index.js",
+  "files": [
+    "src/",
+    "scripts/",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "start": "node src/index.js",
+    "test": "node --test 'test/*.test.js'",
+    "lint": "eslint src/ test/",
+    "lint:fix": "eslint --fix src/ test/"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    "js-yaml": "^4.1.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.3",
+    "eslint": "^9.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "license": "MIT",
+  "keywords": [
+    "mcp",
+    "vault",
+    "fathom",
+    "claude",
+    "ai-agent",
+    "memory"
+  ]
+}

package/scripts/fathom-context.sh

@@ -0,0 +1,65 @@
+#!/usr/bin/env bash
+# Fathom SessionStart/UserPromptSubmit hook — injects vault context.
+#
+# Reads .fathom.json to find vault path and server URL.
+# On SessionStart: injects recent heartbeat + active vault folders.
+# On UserPromptSubmit: searches vault for relevant context.
+
+set -euo pipefail
+
+# Walk up to find .fathom.json
+find_config() {
+  local dir="$PWD"
+  while [ "$dir" != "/" ]; do
+    if [ -f "$dir/.fathom.json" ]; then
+      echo "$dir/.fathom.json"
+      return 0
+    fi
+    dir="$(dirname "$dir")"
+  done
+  return 1
+}
+
+CONFIG_FILE=$(find_config 2>/dev/null) || exit 0
+
+# Extract config values
+WORKSPACE=$(python3 -c "import json; print(json.load(open('$CONFIG_FILE')).get('workspace',''))" 2>/dev/null || echo "")
+SERVER=$(python3 -c "import json; print(json.load(open('$CONFIG_FILE')).get('server','http://localhost:4243'))" 2>/dev/null || echo "http://localhost:4243")
+API_KEY=$(python3 -c "import json; print(json.load(open('$CONFIG_FILE')).get('apiKey',''))" 2>/dev/null || echo "")
+HOOK_ENABLED=$(python3 -c "import json; c=json.load(open('$CONFIG_FILE')); print(c.get('hooks',{}).get('context-inject',{}).get('enabled','true'))" 2>/dev/null || echo "true")
+
+if [ "$HOOK_ENABLED" != "True" ] && [ "$HOOK_ENABLED" != "true" ]; then
+  exit 0
+fi
+
+# Read user prompt from stdin (if UserPromptSubmit)
+INPUT=$(cat)
+
+# Build auth header
+AUTH_HEADER=""
+if [ -n "$API_KEY" ]; then
+  AUTH_HEADER="Authorization: Bearer $API_KEY"
+fi
+
+# Try to get recent vault activity from server
+CONTEXT=""
+if [ -n "$SERVER" ]; then
+  ACTIVITY=$(curl -sf -H "$AUTH_HEADER" \
+    "${SERVER}/api/vault/activity?workspace=${WORKSPACE}&limit=5" 2>/dev/null || echo "")
+  if [ -n "$ACTIVITY" ]; then
+    CONTEXT="Recent vault activity:\n$ACTIVITY"
+  fi
+fi
+
+if [ -n "$CONTEXT" ]; then
+  # Output as hook response
+  python3 -c "
+import json, sys
+result = {
+    'hookSpecificOutput': {
+        'additionalContext': '''$CONTEXT'''
+    }
+}
+json.dump(result, sys.stdout)
+"
+fi

package/scripts/fathom-precompact.sh

@@ -0,0 +1,68 @@
+#!/usr/bin/env bash
+# Fathom PreCompact hook — snapshots vault state before context compaction.
+#
+# Reads the transcript, extracts any vault file paths mentioned,
+# and records which files were active in this session for continuity.
+
+set -euo pipefail
+
+# Walk up to find .fathom.json
+find_config() {
+  local dir="$PWD"
+  while [ "$dir" != "/" ]; do
+    if [ -f "$dir/.fathom.json" ]; then
+      echo "$dir/.fathom.json"
+      return 0
+    fi
+    dir="$(dirname "$dir")"
+  done
+  return 1
+}
+
+CONFIG_FILE=$(find_config 2>/dev/null) || exit 0
+
+WORKSPACE=$(python3 -c "import json; print(json.load(open('$CONFIG_FILE')).get('workspace',''))" 2>/dev/null || echo "")
+SERVER=$(python3 -c "import json; print(json.load(open('$CONFIG_FILE')).get('server','http://localhost:4243'))" 2>/dev/null || echo "http://localhost:4243")
+API_KEY=$(python3 -c "import json; print(json.load(open('$CONFIG_FILE')).get('apiKey',''))" 2>/dev/null || echo "")
+HOOK_ENABLED=$(python3 -c "import json; c=json.load(open('$CONFIG_FILE')); print(c.get('hooks',{}).get('precompact-snapshot',{}).get('enabled','true'))" 2>/dev/null || echo "true")
+
+if [ "$HOOK_ENABLED" != "True" ] && [ "$HOOK_ENABLED" != "true" ]; then
+  exit 0
+fi
+
+# Read PreCompact input (contains transcript_path)
+INPUT=$(cat)
+TRANSCRIPT_PATH=$(echo "$INPUT" | python3 -c "import json,sys; print(json.load(sys.stdin).get('transcript_path',''))" 2>/dev/null || echo "")
+
+if [ -z "$TRANSCRIPT_PATH" ] || [ ! -f "$TRANSCRIPT_PATH" ]; then
+  exit 0
+fi
+
+# Extract vault file paths from transcript
+VAULT_FILES=$(grep -oP 'vault/[a-zA-Z0-9_/.-]+\.md' "$TRANSCRIPT_PATH" 2>/dev/null | sort -u || echo "")
+
+if [ -z "$VAULT_FILES" ]; then
+  exit 0
+fi
+
+# Notify server about accessed files (best-effort)
+AUTH_HEADER=""
+if [ -n "$API_KEY" ]; then
+  AUTH_HEADER="Authorization: Bearer $API_KEY"
+fi
+
+for FILE in $VAULT_FILES; do
+  curl -sf -X POST -H "Content-Type: application/json" -H "$AUTH_HEADER" \
+    -d "{\"path\": \"$FILE\"}" \
+    "${SERVER}/api/vault/access?workspace=${WORKSPACE}" >/dev/null 2>&1 || true
+done
+
+# Output summary
+FILE_COUNT=$(echo "$VAULT_FILES" | wc -l)
+python3 -c "
+import json, sys
+result = {
+    'systemMessage': 'Fathom: Recorded ${FILE_COUNT} vault file(s) from this session.'
+}
+json.dump(result, sys.stdout)
+"

package/src/cli.js

@@ -0,0 +1,347 @@
+#!/usr/bin/env node
+
+/**
+ * fathom-mcp CLI
+ *
+ * Usage:
+ *   npx fathom-mcp          — Start MCP server (stdio, for .mcp.json)
+ *   npx fathom-mcp init     — Interactive setup wizard
+ *   npx fathom-mcp status   — Check server connection + workspace status
+ */
+
+import fs from "fs";
+import path from "path";
+import readline from "readline";
+import { fileURLToPath } from "url";
+
+import { resolveConfig, writeConfig, findConfigFile } from "./config.js";
+import { createClient } from "./server-client.js";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const SCRIPTS_DIR = path.join(__dirname, "..", "scripts");
+
+// --- Helpers -----------------------------------------------------------------
+
+function ask(rl, question, defaultVal = "") {
+  const suffix = defaultVal ? ` (${defaultVal})` : "";
+  return new Promise((resolve) => {
+    rl.question(`${question}${suffix}: `, (answer) => {
+      resolve(answer.trim() || defaultVal);
+    });
+  });
+}
+
+function askYesNo(rl, question, defaultYes = true) {
+  const hint = defaultYes ? "Y/n" : "y/N";
+  return new Promise((resolve) => {
+    rl.question(`${question} [${hint}]: `, (answer) => {
+      const a = answer.trim().toLowerCase();
+      if (!a) return resolve(defaultYes);
+      resolve(a === "y" || a === "yes");
+    });
+  });
+}
+
+/**
+ * Deep merge obj2 into obj1 (mutates obj1). Arrays are replaced, not merged.
+ */
+function deepMerge(obj1, obj2) {
+  for (const key of Object.keys(obj2)) {
+    if (
+      obj1[key] &&
+      typeof obj1[key] === "object" &&
+      !Array.isArray(obj1[key]) &&
+      typeof obj2[key] === "object" &&
+      !Array.isArray(obj2[key])
+    ) {
+      deepMerge(obj1[key], obj2[key]);
+    } else {
+      obj1[key] = obj2[key];
+    }
+  }
+  return obj1;
+}
+
+function readJsonFile(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+function writeJsonFile(filePath, data) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
+}
+
+function appendToGitignore(dir, patterns) {
+  const gitignorePath = path.join(dir, ".gitignore");
+  let existing = "";
+  try {
+    existing = fs.readFileSync(gitignorePath, "utf-8");
+  } catch { /* file doesn't exist */ }
+
+  const missing = patterns.filter((p) => !existing.includes(p));
+  if (missing.length > 0) {
+    const suffix = existing.endsWith("\n") || !existing ? "" : "\n";
+    fs.appendFileSync(gitignorePath, suffix + missing.join("\n") + "\n");
+  }
+}
+
+function copyScripts(targetDir) {
+  fs.mkdirSync(targetDir, { recursive: true });
+  try {
+    const files = fs.readdirSync(SCRIPTS_DIR);
+    for (const file of files) {
+      const src = path.join(SCRIPTS_DIR, file);
+      const dest = path.join(targetDir, file);
+      fs.copyFileSync(src, dest);
+      fs.chmodSync(dest, 0o755);
+    }
+    return files;
+  } catch {
+    return [];
+  }
+}
+
+// --- Init wizard -------------------------------------------------------------
+
+async function runInit() {
+  const cwd = process.cwd();
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+  console.log(`
+▐▘  ▗ ▌
+▜▘▀▌▜▘▛▌▛▌▛▛▌▄▖▛▛▌▛▘▛▌
+▐ █▌▐▖▌▌▙▌▌▌▌  ▌▌▌▙▖▙▌
+                    ▌
+
+  hifathom.com  ·  fathom@myrakrusemark.com
+`);
+
+  // Check for existing config
+  const existing = findConfigFile(cwd);
+  if (existing) {
+    console.log(`  Found existing config at: ${existing.path}`);
+    const proceed = await askYesNo(rl, "  Overwrite?", false);
+    if (!proceed) {
+      console.log("  Aborted.");
+      rl.close();
+      process.exit(0);
+    }
+  }
+
+  // 1. Workspace name
+  const defaultName = path.basename(cwd);
+  const workspace = await ask(rl, "  Workspace name", defaultName);
+
+  // 2. Vault subdirectory
+  const vault = await ask(rl, "  Vault subdirectory", "vault");
+
+  // 3. Server URL
+  const serverUrl = await ask(rl, "  Fathom server URL", "http://localhost:4243");
+
+  // 4. API key
+  let apiKey = "";
+  const tryFetch = await askYesNo(rl, "  Fetch API key from server?", true);
+  if (tryFetch) {
+    console.log("  Connecting to server...");
+    const tmpClient = createClient({ server: serverUrl, apiKey: "", workspace });
+    const isUp = await tmpClient.healthCheck();
+    if (isUp) {
+      const keyResp = await tmpClient.getApiKey();
+      if (keyResp.api_key) {
+        apiKey = keyResp.api_key;
+        console.log(`  Got API key: ${apiKey.slice(0, 7)}...${apiKey.slice(-4)}`);
+      } else {
+        console.log("  Could not fetch key (auth may not be configured yet).");
+      }
+    } else {
+      console.log("  Server not reachable. You can add the API key to .fathom.json later.");
+    }
+  }
+  if (!apiKey) {
+    apiKey = await ask(rl, "  API key (or leave blank)", "");
+  }
+
+  // 5. Hooks
+  const enableContextHook = await askYesNo(rl, "  Enable SessionStart context injection hook?", true);
+  const enablePrecompactHook = await askYesNo(rl, "  Enable PreCompact vault snapshot hook?", true);
+
+  rl.close();
+
+  // --- Write files ---
+
+  console.log("\n  Creating files...\n");
+
+  // .fathom.json
+  const configData = {
+    workspace,
+    vault,
+    server: serverUrl,
+    apiKey,
+    hooks: {
+      "context-inject": { enabled: enableContextHook },
+      "precompact-snapshot": { enabled: enablePrecompactHook },
+    },
+  };
+  const configPath = writeConfig(cwd, configData);
+  console.log(`  ✓ ${path.relative(cwd, configPath)}`);
+
+  // .fathom/scripts/
+  const scriptsDir = path.join(cwd, ".fathom", "scripts");
+  const copiedScripts = copyScripts(scriptsDir);
+  if (copiedScripts.length > 0) {
+    console.log(`  ✓ .fathom/scripts/ (${copiedScripts.length} scripts)`);
+  }
+
+  // vault/ directory
+  const vaultDir = path.join(cwd, vault);
+  if (!fs.existsSync(vaultDir)) {
+    fs.mkdirSync(vaultDir, { recursive: true });
+    console.log(`  ✓ ${vault}/ (created)`);
+  } else {
+    console.log(`  · ${vault}/ (already exists)`);
+  }
+
+  // .mcp.json
+  const mcpJsonPath = path.join(cwd, ".mcp.json");
+  const mcpJson = readJsonFile(mcpJsonPath) || {};
+  deepMerge(mcpJson, {
+    mcpServers: {
+      "fathom-vault": {
+        command: "npx",
+        args: ["-y", "fathom-mcp"],
+      },
+    },
+  });
+  writeJsonFile(mcpJsonPath, mcpJson);
+  console.log("  ✓ .mcp.json");
+
+  // .claude/settings.local.json — hook registrations
+  const claudeSettingsPath = path.join(cwd, ".claude", "settings.local.json");
+  const claudeSettings = readJsonFile(claudeSettingsPath) || {};
+
+  const hooks = {};
+  if (enableContextHook) {
+    hooks["UserPromptSubmit"] = [
+      ...(claudeSettings.hooks?.["UserPromptSubmit"] || []),
+    ];
+    // Avoid duplicate
+    const contextCmd = "bash .fathom/scripts/fathom-context.sh";
+    if (!hooks["UserPromptSubmit"].some((h) => h.command === contextCmd)) {
+      hooks["UserPromptSubmit"].push({
+        type: "command",
+        command: contextCmd,
+      });
+    }
+  }
+  if (enablePrecompactHook) {
+    hooks["PreCompact"] = [
+      ...(claudeSettings.hooks?.["PreCompact"] || []),
+    ];
+    const precompactCmd = "bash .fathom/scripts/fathom-precompact.sh";
+    if (!hooks["PreCompact"].some((h) => h.command === precompactCmd)) {
+      hooks["PreCompact"].push({
+        type: "command",
+        command: precompactCmd,
+      });
+    }
+  }
+
+  if (Object.keys(hooks).length > 0) {
+    claudeSettings.hooks = { ...(claudeSettings.hooks || {}), ...hooks };
+    writeJsonFile(claudeSettingsPath, claudeSettings);
+    console.log("  ✓ .claude/settings.local.json (hooks)");
+  }
+
+  // .gitignore
+  appendToGitignore(cwd, [".fathom.json", ".fathom/scripts/"]);
+  console.log("  ✓ .gitignore");
+
+  // Register with server (best-effort)
+  if (serverUrl) {
+    const regClient = createClient({ server: serverUrl, apiKey, workspace });
+    const isUp = await regClient.healthCheck();
+    if (isUp) {
+      const regResult = await regClient.registerWorkspace(workspace, cwd);
+      if (regResult.ok) {
+        console.log(`  ✓ Registered workspace "${workspace}" with server`);
+      } else if (regResult.error) {
+        console.log(`  · Server: ${regResult.error}`);
+      }
+    }
+  }
+
+  console.log(`
+  Done! Fathom MCP is configured for workspace "${workspace}".
+
+  Next steps:
+    1. Start the server:  cd fathom-server && python app.py
+    2. Open Claude Code in this directory — fathom tools will be available.
+    3. Add the following to your CLAUDE.md:
+
+       ## Fathom Vault
+       Load fathom tools on startup: \`ToolSearch query="+fathom" max_results=20\`
+`);
+}
+
+// --- Status command ----------------------------------------------------------
+
+async function runStatus() {
+  const config = resolveConfig();
+  const client = createClient(config);
+
+  console.log("\n  Fathom MCP Status\n");
+  console.log(`  Config:    ${config._configPath || "(not found — using defaults)"}`);
+  console.log(`  Workspace: ${config.workspace}`);
+  console.log(`  Vault:     ${config.vault}`);
+  console.log(`  Server:    ${config.server}`);
+  console.log(`  API Key:   ${config.apiKey ? config.apiKey.slice(0, 7) + "..." + config.apiKey.slice(-4) : "(not set)"}`);
+
+  // Check vault directory
+  const vaultExists = fs.existsSync(config.vault);
+  console.log(`\n  Vault dir: ${vaultExists ? "✓ exists" : "✗ not found"}`);
+
+  // Check server
+  const isUp = await client.healthCheck();
+  console.log(`  Server:    ${isUp ? "✓ reachable" : "✗ not reachable"}`);
+
+  if (isUp) {
+    const wsResult = await client.listWorkspaces();
+    if (wsResult.profiles) {
+      const names = Object.keys(wsResult.profiles);
+      console.log(`  Workspaces: ${names.join(", ") || "(none)"}`);
+      for (const [name, profile] of Object.entries(wsResult.profiles)) {
+        const status = profile.running ? "running" : "stopped";
+        console.log(`    ${name}: ${status}${profile.model ? ` (${profile.model})` : ""}`);
+      }
+    }
+  }
+
+  console.log();
+}
+
+// --- Main --------------------------------------------------------------------
+
+const command = process.argv[2];
+
+if (command === "init") {
+  runInit().catch((e) => {
+    console.error(`Error: ${e.message}`);
+    process.exit(1);
+  });
+} else if (command === "status") {
+  runStatus().catch((e) => {
+    console.error(`Error: ${e.message}`);
+    process.exit(1);
+  });
+} else if (!command || command === "serve") {
+  // Default: start MCP server
+  import("./index.js");
+} else {
+  console.error(`Unknown command: ${command}`);
+  console.error("Usage: fathom-mcp [init|status|serve]");
+  process.exit(1);
+}