@lifeaitools/clauth 0.3.11 → 0.4.0

package/cli/commands/serve.js

@@ -221,32 +221,36 @@ const KEY_URLS = {
 };
 
 // ── OAuth import config ─────────────────────
-// OAuth services with atomic fields — each field saved as clauth.<service>.<key>
-// No JSON blob parsing. Each field is its own vault secret.
-const OAUTH_FIELDS = {
-  "gmail": [
-    { key: "client_id",     label: "Client ID",     hint: "From Google Cloud Console → APIs & Services → Credentials → OAuth client", required: true },
-    { key: "client_secret", label: "Client Secret", hint: "From Google Cloud Console OAuth client",                                    required: true },
-    { key: "refresh_token", label: "Refresh Token", hint: "From Google OAuth Playground or your app's auth callback",                 required: true },
-    { key: "from_address",  label: "From Address",  hint: "Gmail address to send from (e.g. dave@life.ai)",                           required: false },
-  ]
+// Services where Google downloads a JSON file. jsonFields = keys to extract
+// from the downloaded JSON (top-level or under an "installed"/"web" wrapper).
+// extra = additional fields the user must provide separately.
+const OAUTH_IMPORT = {
+  "gmail": {
+    jsonFields: ["client_id", "client_secret"],
+    extra: [{ key: "refresh_token", label: "Refresh Token", hint: "From Google OAuth Playground or your app's auth callback" }]
+  }
 };
 
 function renderSetPanel(name) {
-  const fields = OAUTH_FIELDS[name];
-  if (fields) {
-    const fieldsHtml = fields.map(f => \`
+  const imp = OAUTH_IMPORT[name];
+  if (imp) {
+    const extraHtml = imp.extra.map(f => \`
       <div class="oauth-field">
-        <label class="oauth-label">\${f.label}\${f.required ? "" : " <span style='color:#475569'>(optional)</span>"}</label>
+        <label class="oauth-label">\${f.label}</label>
         \${f.hint ? \`<div class="oauth-hint">\${f.hint}</div>\` : ""}
         <input type="text" class="oauth-input" id="ofield-\${name}-\${f.key}" placeholder="Paste \${f.label}…" spellcheck="false" autocomplete="off">
       </div>
     \`).join("");
     return \`
       <div class="set-panel" id="set-panel-\${name}">
-        <label>Set <strong>\${name}</strong> credentials — paste directly from source, never in chat</label>
+        <label>Set <strong>\${name}</strong> credentials — paste directly from Google, never in chat</label>
         <div class="oauth-fields">
-          \${fieldsHtml}
+          <div class="oauth-field">
+            <label class="oauth-label">OAuth JSON from Google Cloud Console</label>
+            <div class="oauth-hint">Download from APIs & Services → Credentials → your OAuth client → ↓ Download JSON</div>
+            <textarea class="set-input" id="ofield-\${name}-json" placeholder='{"installed":{"client_id":"…","client_secret":"…",...}}' spellcheck="false" rows="3"></textarea>
+          </div>
+          \${extraHtml}
         </div>
         <div class="set-foot">
           <button class="btn btn-save" onclick="saveKey('\${name}')">Save</button>
@@ -449,68 +453,63 @@ function toggleSet(name) {
 
 async function saveKey(name) {
   const msg = document.getElementById("set-msg-" + name);
-  const fields = OAUTH_FIELDS[name];
-
-  if (fields) {
-    // Validate required fields first
-    for (const f of fields) {
-      if (!f.required) continue;
-      const el = document.getElementById("ofield-" + name + "-" + f.key);
-      if (!el || !el.value.trim()) {
-        msg.className = "set-msg fail"; msg.textContent = f.label + " is required."; return;
-      }
+  const imp = OAUTH_IMPORT[name];
+  let value;
+
+  if (imp) {
+    const jsonEl = document.getElementById("ofield-" + name + "-json");
+    const raw = jsonEl ? jsonEl.value.trim() : "";
+    if (!raw) { msg.className = "set-msg fail"; msg.textContent = "Paste the OAuth JSON first."; return; }
+    let parsed;
+    try { parsed = JSON.parse(raw); } catch { msg.className = "set-msg fail"; msg.textContent = "Invalid JSON — copy the full file content."; return; }
+    // Google wraps fields under "installed" or "web"
+    const src = parsed.installed || parsed.web || parsed;
+    const obj = {};
+    for (const k of imp.jsonFields) {
+      if (!src[k]) { msg.className = "set-msg fail"; msg.textContent = k + " not found in JSON."; return; }
+      obj[k] = src[k];
     }
-    // Save each field as an atomic vault key: clauth.<service>.<key>
-    msg.className = "set-msg"; msg.textContent = "Saving…";
-    try {
-      for (const f of fields) {
-        const el = document.getElementById("ofield-" + name + "-" + f.key);
-        const v = el ? el.value.trim() : "";
-        if (!v) continue; // skip optional empty fields
-        const r = await fetch(BASE + "/set/" + name + "." + f.key, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ value: v })
-        }).then(r => r.json());
-        if (r.locked) { showLockScreen(); return; }
-        if (r.error) throw new Error(r.error);
-      }
-      msg.className = "set-msg ok"; msg.textContent = "✓ Saved";
-      fields.forEach(f => { const el = document.getElementById("ofield-" + name + "-" + f.key); if (el) el.value = ""; });
-    } catch (e) {
-      msg.className = "set-msg fail"; msg.textContent = e.message || "Save failed";
-      return;
+    for (const f of imp.extra) {
+      const el = document.getElementById("ofield-" + name + "-" + f.key);
+      const v = el ? el.value.trim() : "";
+      if (!v) { msg.className = "set-msg fail"; msg.textContent = f.label + " is required."; return; }
+      obj[f.key] = v;
     }
+    value = JSON.stringify(obj);
   } else {
     const input = document.getElementById("set-input-" + name);
-    const value = input ? input.value.trim() : "";
+    value = input ? input.value.trim() : "";
     if (!value) { msg.className = "set-msg fail"; msg.textContent = "Value is empty."; return; }
+  }
 
-    msg.className = "set-msg"; msg.textContent = "Saving…";
-    try {
-      const r = await fetch(BASE + "/set/" + name, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ value })
-      }).then(r => r.json());
-
-      if (r.locked) { showLockScreen(); return; }
-      if (r.error) throw new Error(r.error);
-      msg.className = "set-msg ok"; msg.textContent = "✓ Saved";
+  msg.className = "set-msg"; msg.textContent = "Saving…";
+  try {
+    const r = await fetch(BASE + "/set/" + name, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ value })
+    }).then(r => r.json());
+
+    if (r.locked) { showLockScreen(); return; }
+    if (r.error) throw new Error(r.error);
+    msg.className = "set-msg ok"; msg.textContent = "✓ Saved";
+    if (imp) {
+      const jsonEl = document.getElementById("ofield-" + name + "-json");
+      if (jsonEl) jsonEl.value = "";
+      imp.extra.forEach(f => { const el = document.getElementById("ofield-" + name + "-" + f.key); if (el) el.value = ""; });
+    } else {
       const inp = document.getElementById("set-input-" + name);
       if (inp) inp.value = "";
-    } catch (e) {
-      msg.className = "set-msg fail"; msg.textContent = e.message || "Save failed";
-      return;
     }
+    const dot = document.getElementById("sdot-" + name);
+    if (dot) { dot.className = "status-dot"; dot.title = ""; }
+    setTimeout(() => {
+      document.getElementById("set-panel-" + name).style.display = "none";
+      msg.textContent = "";
+    }, 1800);
+  } catch (e) {
+    msg.className = "set-msg fail"; msg.textContent = "✗ " + e.message;
   }
-
-  const dot = document.getElementById("sdot-" + name);
-  if (dot) { dot.className = "status-dot"; dot.title = ""; }
-  setTimeout(() => {
-    document.getElementById("set-panel-" + name).style.display = "none";
-    msg.textContent = "";
-  }, 1800);
 }
 
 // ── Enable / Disable service ────────────────
@@ -772,7 +771,7 @@ function createServer(initPassword, whitelist, port) {
     }
 
     // GET /get/:service
-    const getMatch = reqPath.match(/^\/get\/([a-zA-Z0-9_.-]+)$/);
+    const getMatch = reqPath.match(/^\/get\/([a-zA-Z0-9_-]+)$/);
     if (method === "GET" && getMatch) {
       if (lockedGuard(res)) return;
       const service = getMatch[1].toLowerCase();
@@ -918,7 +917,7 @@ function createServer(initPassword, whitelist, port) {
     }
 
     // POST /set/:service — write a new key value into vault
-    const setMatch = reqPath.match(/^\/set\/([a-zA-Z0-9_.-]+)$/);
+    const setMatch = reqPath.match(/^\/set\/([a-zA-Z0-9_-]+)$/);
     if (method === "POST" && setMatch) {
       if (lockedGuard(res)) return;
       const service = setMatch[1].toLowerCase();
@@ -1195,19 +1194,460 @@ async function actionForeground(opts) {
   });
 }
 
+// ── MCP stdio server ──────────────────────────────────────────
+// JSON-RPC 2.0 over stdin/stdout for Claude Code integration.
+// Reuses the same auth model as the HTTP daemon.
+// Secrets are delivered via temp files — never in the MCP response.
+
+import { createInterface } from "readline";
+import { execSync } from "child_process";
+
+const ENV_MAP = {
+  "github":           "GITHUB_TOKEN",
+  "supabase-anon":    "NEXT_PUBLIC_SUPABASE_ANON_KEY",
+  "supabase-service": "SUPABASE_SERVICE_ROLE_KEY",
+  "supabase-db":      "SUPABASE_DB_URL",
+  "vercel":           "VERCEL_TOKEN",
+  "anthropic":        "ANTHROPIC_API_KEY",
+  "cloudflare":       "CLOUDFLARE_API_TOKEN",
+  "r2":               "R2_ACCESS_KEY_ID",
+  "r2-bucket":        "R2_BUCKET_NAME",
+  "neo4j":            "NEO4J_URI",
+  "rocketreach":      "ROCKETREACH_API_KEY",
+  "npm":              "NPM_TOKEN",
+  "namecheap":        "NAMECHEAP_API_KEY",
+  "gmail":            "GMAIL_CREDENTIALS",
+};
+
+const MCP_TOOLS = [
+  {
+    name: "clauth_ping",
+    description: "Check if the vault is locked or unlocked, show failure count",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false }
+  },
+  {
+    name: "clauth_unlock",
+    description: "Unlock the vault with the master password (password stays in MCP server memory only)",
+    inputSchema: { type: "object", properties: { password: { type: "string", description: "clauth master password" } }, required: ["password"], additionalProperties: false }
+  },
+  {
+    name: "clauth_lock",
+    description: "Lock the vault — clears password from memory",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false }
+  },
+  {
+    name: "clauth_status",
+    description: "List all services with type, enabled state, key presence, and last retrieval time",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false }
+  },
+  {
+    name: "clauth_list",
+    description: "List registered service names",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false }
+  },
+  {
+    name: "clauth_get",
+    description: "Retrieve a secret and deliver to a temp file (default), clipboard, or stdout. Temp files auto-delete after 30 seconds.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        service: { type: "string", description: "Service name (e.g. github, anthropic, vercel)" },
+        target: { type: "string", enum: ["file", "clipboard", "stdout"], default: "file", description: "Where to deliver the secret. 'file' writes a temp file, 'clipboard' copies to clipboard, 'stdout' returns the value in the response (DANGEROUS — enters transcript)" }
+      },
+      required: ["service"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "clauth_inject",
+    description: "Bulk retrieve multiple services into a single sourceable env file. Usage: source the returned file path before running commands.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        services: { type: "array", items: { type: "string" }, description: "Service names to inject (e.g. ['github', 'vercel', 'anthropic'])" }
+      },
+      required: ["services"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "clauth_enable",
+    description: "Enable a service in the vault",
+    inputSchema: { type: "object", properties: { service: { type: "string" } }, required: ["service"], additionalProperties: false }
+  },
+  {
+    name: "clauth_disable",
+    description: "Disable a service in the vault",
+    inputSchema: { type: "object", properties: { service: { type: "string" } }, required: ["service"], additionalProperties: false }
+  },
+  {
+    name: "clauth_test",
+    description: "Test the HMAC handshake without retrieving any keys",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false }
+  },
+  {
+    name: "clauth_scrub",
+    description: "Scrub secrets from Claude Code transcript .jsonl files",
+    inputSchema: {
+      type: "object",
+      properties: {
+        target: { type: "string", enum: ["latest", "all"], default: "latest", description: "Scrub the most recent transcript or all transcripts" }
+      },
+      additionalProperties: false
+    }
+  },
+];
+
+function writeTempSecret(service, value) {
+  const filePath = path.join(os.tmpdir(), `.clauth-${service}`);
+  fs.writeFileSync(filePath, value, { mode: 0o600 });
+  setTimeout(() => { try { fs.unlinkSync(filePath); } catch {} }, 30_000);
+  return filePath;
+}
+
+function copyToClipboard(value) {
+  const platform = os.platform();
+  if (platform === "win32") {
+    execSync("clip", { input: value, stdio: ["pipe", "pipe", "pipe"] });
+  } else if (platform === "darwin") {
+    execSync("pbcopy", { input: value, stdio: ["pipe", "pipe", "pipe"] });
+  } else {
+    execSync("xclip -selection clipboard", { input: value, stdio: ["pipe", "pipe", "pipe"] });
+  }
+}
+
+function mcpResult(text) {
+  return { content: [{ type: "text", text }] };
+}
+
+function mcpError(text) {
+  return { content: [{ type: "text", text }], isError: true };
+}
+
+async function handleMcpTool(vault, name, args) {
+  switch (name) {
+    case "clauth_ping": {
+      return mcpResult(
+        vault.password
+          ? `unlocked | pid: ${process.pid} | failures: ${vault.failCount}/${vault.MAX_FAILS}`
+          : `locked | pid: ${process.pid} | failures: ${vault.failCount}/${vault.MAX_FAILS}`
+      );
+    }
+
+    case "clauth_unlock": {
+      const pw = args.password;
+      if (!pw) return mcpError("password is required");
+      try {
+        const { token, timestamp } = deriveToken(pw, vault.machineHash);
+        const result = await api.test(pw, vault.machineHash, token, timestamp);
+        if (result.error) return mcpError(`Unlock failed: ${result.error}`);
+        vault.password = pw;
+        return mcpResult("Vault unlocked");
+      } catch (err) {
+        return mcpError(`Unlock failed: ${err.message}`);
+      }
+    }
+
+    case "clauth_lock": {
+      vault.password = null;
+      return mcpResult("Vault locked — password cleared from memory");
+    }
+
+    case "clauth_status": {
+      if (!vault.password) return mcpError("Vault is locked — call clauth_unlock first");
+      try {
+        const { token, timestamp } = deriveToken(vault.password, vault.machineHash);
+        const result = await api.status(vault.password, vault.machineHash, token, timestamp);
+        if (result.error) return mcpError(result.error);
+        let services = result.services || [];
+        if (vault.whitelist) {
+          services = services.filter(s => vault.whitelist.includes(s.name.toLowerCase()));
+        }
+        const lines = ["SERVICE              TYPE         STATUS       KEY    LAST RETRIEVED",
+                        "---              ----         ------       ---    --------------"];
+        for (const s of services) {
+          const status = s.enabled ? "ACTIVE" : (s.vault_key ? "SUSPENDED" : "NO KEY");
+          const hasKey = s.vault_key ? "yes" : "—";
+          const lastGet = s.last_retrieved ? new Date(s.last_retrieved).toLocaleDateString() : "never";
+          lines.push(`${s.name.padEnd(20)} ${(s.key_type || "").padEnd(12)} ${status.padEnd(12)} ${hasKey.padEnd(6)} ${lastGet}`);
+        }
+        return mcpResult(lines.join("\n"));
+      } catch (err) {
+        return mcpError(err.message);
+      }
+    }
+
+    case "clauth_list": {
+      if (!vault.password) return mcpError("Vault is locked — call clauth_unlock first");
+      try {
+        const { token, timestamp } = deriveToken(vault.password, vault.machineHash);
+        const result = await api.status(vault.password, vault.machineHash, token, timestamp);
+        if (result.error) return mcpError(result.error);
+        let services = result.services || [];
+        if (vault.whitelist) {
+          services = services.filter(s => vault.whitelist.includes(s.name.toLowerCase()));
+        }
+        return mcpResult(services.map(s => s.name).join(", "));
+      } catch (err) {
+        return mcpError(err.message);
+      }
+    }
+
+    case "clauth_get": {
+      if (!vault.password) return mcpError("Vault is locked — call clauth_unlock first");
+      const service = (args.service || "").toLowerCase();
+      const target = args.target || "file";
+      if (!service) return mcpError("service is required");
+      if (vault.whitelist && !vault.whitelist.includes(service)) {
+        return mcpError(`Service '${service}' not in whitelist`);
+      }
+      try {
+        const { token, timestamp } = deriveToken(vault.password, vault.machineHash);
+        const result = await api.retrieve(vault.password, vault.machineHash, token, timestamp, service);
+        if (result.error) return mcpError(result.error);
+        const value = typeof result.value === "string" ? result.value : JSON.stringify(result.value);
+
+        if (target === "clipboard") {
+          try {
+            copyToClipboard(value);
+            return mcpResult(`${service} copied to clipboard`);
+          } catch (err) {
+            return mcpError(`Clipboard failed: ${err.message}. Use target 'file' instead.`);
+          }
+        }
+
+        if (target === "stdout") {
+          return {
+            content: [{ type: "text", text: `WARNING: secret in response — will appear in transcript. Use 'file' or 'clipboard' mode instead.\n\n${value}` }],
+            isError: true
+          };
+        }
+
+        // Default: file
+        const envVar = ENV_MAP[service] || service.toUpperCase().replace(/-/g, "_");
+        const filePath = writeTempSecret(service, value);
+        return mcpResult(`${service} → ${filePath} (auto-deletes in 30s)\nEnv var: ${envVar}\nUsage: export ${envVar}=$(cat ${filePath.replace(/\\/g, "/")})`);
+      } catch (err) {
+        return mcpError(err.message);
+      }
+    }
+
+    case "clauth_inject": {
+      if (!vault.password) return mcpError("Vault is locked — call clauth_unlock first");
+      const services = args.services || [];
+      if (!services.length) return mcpError("services array is required");
+
+      const lines = [];
+      const errors = [];
+      for (const svc of services) {
+        const service = svc.toLowerCase();
+        if (vault.whitelist && !vault.whitelist.includes(service)) {
+          errors.push(`${service}: not in whitelist`);
+          continue;
+        }
+        try {
+          const { token, timestamp } = deriveToken(vault.password, vault.machineHash);
+          const result = await api.retrieve(vault.password, vault.machineHash, token, timestamp, service);
+          if (result.error) { errors.push(`${service}: ${result.error}`); continue; }
+          const value = typeof result.value === "string" ? result.value : JSON.stringify(result.value);
+          const envVar = ENV_MAP[service] || service.toUpperCase().replace(/-/g, "_");
+          lines.push(`export ${envVar}="${value.replace(/"/g, '\\"')}"`);
+        } catch (err) {
+          errors.push(`${service}: ${err.message}`);
+        }
+      }
+
+      if (!lines.length) return mcpError(`No services retrieved:\n${errors.join("\n")}`);
+
+      const envFilePath = path.join(os.tmpdir(), ".clauth-env");
+      fs.writeFileSync(envFilePath, lines.join("\n") + "\n", { mode: 0o600 });
+      setTimeout(() => { try { fs.unlinkSync(envFilePath); } catch {} }, 30_000);
+
+      let msg = `${lines.length} service(s) → ${envFilePath.replace(/\\/g, "/")} (auto-deletes in 30s)\nUsage: source ${envFilePath.replace(/\\/g, "/")}`;
+      if (errors.length) msg += `\n\nErrors:\n${errors.join("\n")}`;
+      return mcpResult(msg);
+    }
+
+    case "clauth_enable": {
+      if (!vault.password) return mcpError("Vault is locked — call clauth_unlock first");
+      const service = (args.service || "").toLowerCase();
+      if (!service) return mcpError("service is required");
+      try {
+        const { token, timestamp } = deriveToken(vault.password, vault.machineHash);
+        const result = await api.enable(vault.password, vault.machineHash, token, timestamp, service, true);
+        if (result.error) return mcpError(result.error);
+        return mcpResult(`${service} enabled`);
+      } catch (err) {
+        return mcpError(err.message);
+      }
+    }
+
+    case "clauth_disable": {
+      if (!vault.password) return mcpError("Vault is locked — call clauth_unlock first");
+      const service = (args.service || "").toLowerCase();
+      if (!service) return mcpError("service is required");
+      try {
+        const { token, timestamp } = deriveToken(vault.password, vault.machineHash);
+        const result = await api.enable(vault.password, vault.machineHash, token, timestamp, service, false);
+        if (result.error) return mcpError(result.error);
+        return mcpResult(`${service} disabled`);
+      } catch (err) {
+        return mcpError(err.message);
+      }
+    }
+
+    case "clauth_test": {
+      if (!vault.password) return mcpError("Vault is locked — call clauth_unlock first");
+      try {
+        const { token, timestamp } = deriveToken(vault.password, vault.machineHash);
+        const result = await api.test(vault.password, vault.machineHash, token, timestamp);
+        if (result.error) return mcpError(`FAIL: ${result.error}`);
+        return mcpResult(`PASS — machine: ${vault.machineHash.slice(0, 16)}... | window: ${new Date(result.timestamp).toISOString()}`);
+      } catch (err) {
+        return mcpError(`FAIL: ${err.message}`);
+      }
+    }
+
+    case "clauth_scrub": {
+      const target = args.target || "latest";
+      try {
+        const { runScrub: doScrub } = await import("./scrub.js");
+        // runScrub writes to stdout via chalk — capture isn't clean in MCP mode.
+        // Call it and trust it works; report success.
+        await doScrub(target === "all" ? "all" : undefined, {});
+        return mcpResult(`Scrub complete (target: ${target})`);
+      } catch (err) {
+        return mcpError(`Scrub failed: ${err.message}`);
+      }
+    }
+
+    default:
+      return mcpError(`Unknown tool: ${name}`);
+  }
+}
+
+function createMcpServer(initPassword, whitelist) {
+  // Ensure wmic is reachable — bash shells on Windows may not have
+  // C:\Windows\System32\Wbem on PATH, which getMachineHash() needs.
+  if (os.platform() === "win32" && !process.env.PATH?.includes("Wbem")) {
+    process.env.PATH = (process.env.PATH || "") + ";C:\\Windows\\System32\\Wbem";
+  }
+
+  // Lazy-init machineHash — defer to first tool call that needs auth.
+  let _machineHash = null;
+  function ensureMachineHash() {
+    if (!_machineHash) _machineHash = getMachineHash();
+    return _machineHash;
+  }
+
+  const vault = {
+    password: initPassword || null,
+    get machineHash() { return ensureMachineHash(); },
+    whitelist,
+    failCount: 0,
+    MAX_FAILS: 3,
+  };
+
+  const rl = createInterface({ input: process.stdin, terminal: false });
+
+  function send(msg) {
+    process.stdout.write(JSON.stringify(msg) + "\n");
+  }
+
+  rl.on("line", async (line) => {
+    let msg;
+    try {
+      msg = JSON.parse(line);
+    } catch {
+      send({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "Parse error" } });
+      return;
+    }
+
+    const id = msg.id;
+
+    // notifications (no id) — handle initialized, etc.
+    if (msg.method === "notifications/initialized" || msg.method === "initialized") {
+      return; // no response needed for notifications
+    }
+
+    if (msg.method === "initialize") {
+      return send({
+        jsonrpc: "2.0", id,
+        result: {
+          protocolVersion: "2024-11-05",
+          serverInfo: { name: "clauth", version: VERSION },
+          capabilities: { tools: {} }
+        }
+      });
+    }
+
+    if (msg.method === "tools/list") {
+      return send({
+        jsonrpc: "2.0", id,
+        result: { tools: MCP_TOOLS }
+      });
+    }
+
+    if (msg.method === "tools/call") {
+      const { name, arguments: args } = msg.params || {};
+      try {
+        const result = await handleMcpTool(vault, name, args || {});
+        return send({ jsonrpc: "2.0", id, result });
+      } catch (err) {
+        return send({ jsonrpc: "2.0", id, result: mcpError(`Internal error: ${err.message}`) });
+      }
+    }
+
+    // Unknown method
+    send({ jsonrpc: "2.0", id, error: { code: -32601, message: `Unknown method: ${msg.method}` } });
+  });
+
+  rl.on("close", () => {
+    process.exit(0);
+  });
+
+  // Prevent unhandled errors from crashing the MCP server
+  process.on("uncaughtException", (err) => {
+    const msg = `[${new Date().toISOString()}] MCP uncaught: ${err.message}\n`;
+    try { fs.appendFileSync(LOG_FILE, msg); } catch {}
+  });
+}
+
+async function actionMcp(opts) {
+  const password  = opts.pw || null;
+  const whitelist = opts.services
+    ? opts.services.split(",").map(s => s.trim().toLowerCase())
+    : null;
+
+  if (password) {
+    try {
+      await verifyAuth(password);
+    } catch (err) {
+      // Can't use stderr for errors in MCP mode without careful framing
+      // Write to log file instead
+      const msg = `[${new Date().toISOString()}] MCP auth failed: ${err.message}\n`;
+      try { fs.appendFileSync(LOG_FILE, msg); } catch {}
+      process.exit(1);
+    }
+  }
+
+  createMcpServer(password, whitelist);
+}
+
 // ── Export ────────────────────────────────────────────────────
 export async function runServe(opts) {
   const action = opts.action || "foreground";
 
   switch (action) {
-    case "start":     return actionStart(opts);
-    case "stop":      return actionStop();
-    case "restart":   return actionRestart(opts);
-    case "ping":      return actionPing();
+    case "start":      return actionStart(opts);
+    case "stop":       return actionStop();
+    case "restart":    return actionRestart(opts);
+    case "ping":       return actionPing();
     case "foreground": return actionForeground(opts);
+    case "mcp":        return actionMcp(opts);
     default:
       console.log(chalk.red(`\n  Unknown serve action: ${action}`));
-      console.log(chalk.gray("  Actions: start | stop | restart | ping | foreground\n"));
+      console.log(chalk.gray("  Actions: start | stop | restart | ping | foreground | mcp\n"));
       process.exit(1);
   }
 }