@lifeaitools/clauth 0.5.1 → 0.7.0

package/cli/commands/serve.js

@@ -5,6 +5,7 @@
 // Supports: start (background daemon), stop, restart, ping, foreground
 
 import http from "http";
+import crypto from "crypto";
 import fs from "fs";
 import os from "os";
 import path from "path";
@@ -153,6 +154,18 @@ function dashboardHtml(port, whitelist) {
   .btn-tunnel-stop{background:#1e293b;color:#f87171;border:1px solid #334155;padding:6px 12px;font-size:.8rem;border-radius:6px;cursor:pointer;font-weight:500}
   .btn-tunnel-stop:hover{background:#2d1f1f;border-color:#f87171}
   .tunnel-err{font-size:.78rem;color:#f87171;width:100%;margin-top:4px}
+  .mcp-setup{background:#0f1d2d;border:1px solid #1e3a5f;border-radius:8px;padding:1rem 1.25rem;margin-bottom:1.25rem;display:none}
+  .mcp-setup.open{display:block}
+  .mcp-setup-title{font-size:.85rem;font-weight:600;color:#e2e8f0;margin-bottom:.75rem}
+  .mcp-row{display:flex;align-items:center;gap:8px;margin-bottom:8px}
+  .mcp-label{font-size:.72rem;color:#64748b;min-width:80px;text-transform:uppercase;letter-spacing:.5px;font-weight:600}
+  .mcp-val{flex:1;font-family:'Courier New',monospace;font-size:.82rem;color:#60a5fa;background:#0a0f1a;border:1px solid #1e3a5f;border-radius:4px;padding:6px 10px;word-break:break-all;user-select:all}
+  .mcp-copy{background:none;border:1px solid #334155;color:#94a3b8;border-radius:4px;padding:4px 8px;cursor:pointer;font-size:.75rem;font-family:'Courier New',monospace;transition:all .15s;flex-shrink:0}
+  .mcp-copy:hover{border-color:#60a5fa;color:#60a5fa}
+  .mcp-copy.ok{border-color:#4ade80;color:#4ade80}
+  .btn-mcp-setup{background:#1e293b;color:#94a3b8;border:1px solid #334155;padding:6px 12px;font-size:.8rem;border-radius:6px;cursor:pointer;font-weight:500;transition:all .15s}
+  .btn-mcp-setup:hover{border-color:#60a5fa;color:#60a5fa}
+  .btn-mcp-setup:disabled{opacity:.4;cursor:not-allowed}
   .footer{margin-top:2rem;font-size:.75rem;color:#475569;text-align:center}
   .oauth-fields{display:flex;flex-direction:column;gap:8px;margin-bottom:8px}
   .oauth-field{display:flex;flex-direction:column;gap:3px}
@@ -223,11 +236,34 @@ function dashboardHtml(port, whitelist) {
     <button class="btn-check" id="btn-tunnel-test" style="display:none;padding:6px 12px;font-size:.8rem" onclick="testTunnel()">Test</button>
     <button class="btn-claude" id="btn-claude" disabled onclick="openClaude()">Connect claude.ai</button>
     <button class="btn-tunnel-stop" id="btn-tunnel-toggle" style="display:none" onclick="toggleTunnel()">Stop</button>
+    <button class="btn-mcp-setup" id="btn-mcp-setup" style="display:none" onclick="toggleMcpSetup()">Setup MCP</button>
     <div class="tunnel-err" id="tunnel-err" style="display:none"></div>
   </div>
 
+  <div class="mcp-setup" id="mcp-setup-panel">
+    <div class="mcp-setup-title">claude.ai MCP Integration</div>
+    <div class="oauth-fields">
+      <div class="mcp-row">
+        <span class="mcp-label">URL</span>
+        <span class="mcp-val" id="mcp-url">—</span>
+        <button class="mcp-copy" onclick="copyMcp('mcp-url')">copy</button>
+      </div>
+      <div class="mcp-row">
+        <span class="mcp-label">Client ID</span>
+        <span class="mcp-val" id="mcp-client-id">—</span>
+        <button class="mcp-copy" onclick="copyMcp('mcp-client-id')">copy</button>
+      </div>
+      <div class="mcp-row">
+        <span class="mcp-label">Secret</span>
+        <span class="mcp-val" id="mcp-client-secret">—</span>
+        <button class="mcp-copy" onclick="copyMcp('mcp-client-secret')">copy</button>
+      </div>
+    </div>
+    <div style="font-size:.72rem;color:#64748b;margin-top:4px">Paste these into <a href="https://claude.ai/settings/integrations" target="_blank" style="color:#60a5fa">claude.ai Settings → Integrations</a></div>
+  </div>
+
   <div id="grid" class="grid"><p class="loading">Loading services…</p></div>
-  <div class="footer">localhost:${port} · 127.0.0.1 only · 3-strike lockout</div>
+  <div class="footer">localhost:${port} · 127.0.0.1 only · 10-strike lockout</div>
 </div>
 
 <script>
@@ -714,6 +750,7 @@ async function updateTunnelUI() {
   const label = document.getElementById("tunnel-label");
   const btn   = document.getElementById("btn-claude");
   const togBtn = document.getElementById("btn-tunnel-toggle");
+  const mcpBtn = document.getElementById("btn-mcp-setup");
   const errEl = document.getElementById("tunnel-err");
 
   try {
@@ -725,10 +762,12 @@ async function updateTunnelUI() {
       dot.className = "tunnel-dot err";
       label.innerHTML = '<strong>claude.ai MCP</strong> — ' + t.error;
       btn.disabled = true;
+      mcpBtn.style.display = "none";
       togBtn.style.display = "none";
       togBtn.textContent = "Start Tunnel";
       togBtn.onclick = () => toggleTunnel("start");
       togBtn.style.display = "inline-block";
+      document.getElementById("mcp-setup-panel").classList.remove("open");
       return "error";
     }
 
@@ -740,6 +779,7 @@ async function updateTunnelUI() {
       togBtn.textContent = "Stop Tunnel";
       togBtn.onclick = () => toggleTunnel("stop");
       togBtn.style.display = "inline-block";
+      mcpBtn.style.display = "inline-block";
       return "connected";
     }
 
@@ -747,6 +787,7 @@ async function updateTunnelUI() {
       dot.className = "tunnel-dot starting";
       label.innerHTML = '<strong>claude.ai MCP</strong> — starting tunnel…';
       btn.disabled = true;
+      mcpBtn.style.display = "none";
       togBtn.textContent = "Stop Tunnel";
       togBtn.onclick = () => toggleTunnel("stop");
       togBtn.style.display = "inline-block";
@@ -757,16 +798,20 @@ async function updateTunnelUI() {
     dot.className = "tunnel-dot off";
     label.innerHTML = '<strong>claude.ai MCP</strong> — tunnel not running';
     btn.disabled = true;
+    mcpBtn.style.display = "none";
     togBtn.textContent = "Start Tunnel";
     togBtn.onclick = () => toggleTunnel("start");
     togBtn.style.display = "inline-block";
+    document.getElementById("mcp-setup-panel").classList.remove("open");
     return "stopped";
 
   } catch {
     dot.className = "tunnel-dot off";
     label.innerHTML = '<strong>claude.ai MCP</strong> — unable to reach daemon';
     btn.disabled = true;
+    mcpBtn.style.display = "none";
     togBtn.style.display = "none";
+    document.getElementById("mcp-setup-panel").classList.remove("open");
     return "error";
   }
 }
@@ -827,6 +872,32 @@ function openClaude() {
   });
 }
 
+async function toggleMcpSetup() {
+  const panel = document.getElementById("mcp-setup-panel");
+  const isOpen = panel.classList.toggle("open");
+  if (isOpen) {
+    try {
+      const m = await fetch(BASE + "/mcp-setup").then(r => r.json());
+      document.getElementById("mcp-url").textContent = m.url || "(tunnel not running)";
+      document.getElementById("mcp-client-id").textContent = m.clientId || "—";
+      document.getElementById("mcp-client-secret").textContent = m.clientSecret || "—";
+    } catch {
+      document.getElementById("mcp-url").textContent = "(error fetching)";
+    }
+  }
+}
+
+function copyMcp(elId) {
+  const val = document.getElementById(elId).textContent;
+  if (!val || val === "—" || val.startsWith("(")) return;
+  const btn = document.getElementById(elId).nextElementSibling;
+  navigator.clipboard.writeText(val).then(() => {
+    btn.textContent = "ok";
+    btn.classList.add("ok");
+    setTimeout(() => { btn.textContent = "copy"; btn.classList.remove("ok"); }, 1500);
+  }).catch(() => {});
+}
+
 boot();
 </script>
 </body>
@@ -844,7 +915,7 @@ function readBody(req) {
 }
 
 // ── Server logic (shared by foreground + daemon) ─────────────
-function createServer(initPassword, whitelist, port) {
+function createServer(initPassword, whitelist, port, tunnelHostname = null) {
   // Ensure Windows system tools are reachable (bash shells may lack these on PATH)
   if (os.platform() === "win32") {
     const sys32 = "C:\\Windows\\System32";
@@ -855,7 +926,7 @@ function createServer(initPassword, whitelist, port) {
       process.env.PATH = (process.env.PATH || "") + ";" + sys32;
     }
   }
-  const MAX_FAILS = 3;
+  const MAX_FAILS = 10;
   let failCount = 0;
   let password = initPassword || null;   // null = locked; set via POST /auth
   const machineHash = getMachineHash();
@@ -863,7 +934,7 @@ function createServer(initPassword, whitelist, port) {
   const CORS = {
     "Access-Control-Allow-Origin": "*",
     "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
-    "Access-Control-Allow-Headers": "Content-Type",
+    "Access-Control-Allow-Headers": "Content-Type, Authorization, Mcp-Session-Id",
   };
 
   // ── MCP SSE session tracking ──────────────────────────────
@@ -891,15 +962,39 @@ function createServer(initPassword, whitelist, port) {
   let tunnelUrl = null;
   let tunnelError = null;
 
+  // ── OAuth provider (self-contained for claude.ai MCP) ──────
+  const oauthClients = new Map();   // client_id → { client_secret, redirect_uris, client_name }
+  const oauthCodes = new Map();     // code → { client_id, redirect_uri, code_challenge, expires }
+  const oauthTokens = new Set();    // active access tokens
+
+  // Pre-generate a stable client for claude.ai (shown at startup)
+  const OAUTH_CLIENT_ID = crypto.randomBytes(16).toString("hex");
+  const OAUTH_CLIENT_SECRET = crypto.randomBytes(32).toString("hex");
+  oauthClients.set(OAUTH_CLIENT_ID, {
+    client_id: OAUTH_CLIENT_ID, client_secret: OAUTH_CLIENT_SECRET,
+    client_name: "claude.ai", redirect_uris: ["https://claude.ai/api/mcp/auth_callback"],
+    grant_types: ["authorization_code"], response_types: ["code"],
+    token_endpoint_auth_method: "client_secret_post",
+  });
+
+  function oauthBase() { return tunnelUrl || `http://127.0.0.1:${port}`; }
+  function sha256base64url(str) { return crypto.createHash("sha256").update(str).digest("base64url"); }
+
+  function readRawBody(req) {
+    return new Promise((resolve, reject) => {
+      let data = "";
+      req.on("data", chunk => { data += chunk; if (data.length > 65536) reject(new Error("Body too large")); });
+      req.on("end", () => resolve(data));
+      req.on("error", reject);
+    });
+  }
+
   async function startTunnel() {
     if (tunnelProc) return; // already running
     tunnelUrl = null;
     tunnelError = null;
 
     try {
-      // Named tunnel "clauth" — ingress configured in ~/.cloudflared/config.yml
-      const tunnelName = "clauth";
-
       // Resolve cloudflared binary — may not be on PATH in bash shells
       let cfBin = "cloudflared";
       if (os.platform() === "win32") {
@@ -915,40 +1010,33 @@ function createServer(initPassword, whitelist, port) {
         }
       }
 
-      const proc = spawnProc(cfBin, ["tunnel", "run", tunnelName], {
+      // Named tunnel (fixed subdomain) or quick tunnel (random URL)
+      let args;
+      if (tunnelHostname) {
+        // Named tunnel: cloudflared tunnel run (uses ~/.cloudflared/config.yml)
+        // Config maps hostname → local service, so no --url needed
+        args = ["tunnel", "run"];
+        tunnelUrl = `https://${tunnelHostname}`;
+      } else {
+        // Quick tunnel — random URL each session
+        args = ["tunnel", "--url", `http://127.0.0.1:${port}`];
+      }
+
+      const proc = spawnProc(cfBin, args, {
         stdio: ["ignore", "pipe", "pipe"],
       });
 
       tunnelProc = proc;
 
-      // cloudflared logs to stderr — parse for connection info
+      // cloudflared prints output to stderr
       let stderrBuf = "";
       proc.stderr.on("data", (chunk) => {
-        const text = chunk.toString();
-        stderrBuf += text;
-
-        // Detect connection registered (named tunnel is live)
-        if (!tunnelUrl && stderrBuf.includes("Registered tunnel connection")) {
-          // Named tunnel URL comes from config, not stderr.
-          // Read it from cloudflared config if available.
-          try {
-            const cfgPath = path.join(os.homedir(), ".cloudflared", "config.yml");
-            const cfgText = fs.readFileSync(cfgPath, "utf8");
-            const hostnameMatch = cfgText.match(/hostname:\s*(\S+)/);
-            if (hostnameMatch) {
-              tunnelUrl = hostnameMatch[1].startsWith("http") ? hostnameMatch[1] : `https://${hostnameMatch[1]}`;
-            }
-          } catch {}
-          if (!tunnelUrl) tunnelUrl = `(named tunnel "${tunnelName}" connected — check DNS)`;
-          const logLine = `[${new Date().toISOString()}] Tunnel started: ${tunnelUrl}\n`;
-          try { fs.appendFileSync(LOG_FILE, logLine); } catch {}
-        }
-
-        // Quick tunnel fallback: trycloudflare.com URL
-        if (!tunnelUrl) {
-          const quickMatch = stderrBuf.match(/https:\/\/[a-z0-9-]+\.trycloudflare\.com/);
-          if (quickMatch) {
-            tunnelUrl = quickMatch[0];
+        stderrBuf += chunk.toString();
+        // For quick tunnels, capture the random URL from stderr
+        if (!tunnelHostname && !tunnelUrl) {
+          const match = stderrBuf.match(/https:\/\/[a-z0-9-]+\.trycloudflare\.com/);
+          if (match) {
+            tunnelUrl = match[0];
             const logLine = `[${new Date().toISOString()}] Tunnel started: ${tunnelUrl}\n`;
             try { fs.appendFileSync(LOG_FILE, logLine); } catch {}
           }
@@ -976,6 +1064,11 @@ function createServer(initPassword, whitelist, port) {
       // Give it a moment to start
       await new Promise(r => setTimeout(r, 4000));
 
+      if (tunnelHostname && tunnelProc) {
+        const logLine = `[${new Date().toISOString()}] Named tunnel started: ${tunnelUrl}\n`;
+        try { fs.appendFileSync(LOG_FILE, logLine); } catch {}
+      }
+
     } catch (err) {
       tunnelError = err.message;
       tunnelProc = null;
@@ -1028,9 +1121,18 @@ function createServer(initPassword, whitelist, port) {
   }
 
   const server = http.createServer(async (req, res) => {
-    // Hard reject anything not from loopback
     const remote = req.socket.remoteAddress;
     const isLocal = remote === "127.0.0.1" || remote === "::1" || remote === "::ffff:127.0.0.1";
+
+    const url    = new URL(req.url, `http://127.0.0.1:${port}`);
+    const reqPath = url.pathname;
+    const method = req.method;
+
+    // Log every request
+    const logLine = `[${new Date().toISOString()}] ${method} ${reqPath} from=${remote} local=${isLocal}\n`;
+    try { fs.appendFileSync(LOG_FILE, logLine); } catch {}
+
+    // Hard reject anything not from loopback
     if (!isLocal) {
       return strike(res, 403, `Rejected non-local address: ${remote}`);
     }
@@ -1041,11 +1143,213 @@ function createServer(initPassword, whitelist, port) {
       return res.end();
     }
 
-    const url    = new URL(req.url, `http://127.0.0.1:${port}`);
-    const reqPath = url.pathname;
-    const method = req.method;
+    // ── OAuth Discovery (RFC 9728 + RFC 8414) ──────────────
+    if (reqPath === "/.well-known/oauth-protected-resource" ||
+        reqPath === "/.well-known/oauth-protected-resource/mcp" ||
+        reqPath === "/.well-known/oauth-protected-resource/sse") {
+      const base = oauthBase();
+      res.writeHead(200, { "Content-Type": "application/json", ...CORS });
+      return res.end(JSON.stringify({
+        resource: `${base}/mcp`,
+        authorization_servers: [base],
+        scopes_supported: ["mcp:tools"],
+        bearer_methods_supported: ["header"],
+      }));
+    }
+
+    if (reqPath === "/.well-known/oauth-authorization-server") {
+      const base = oauthBase();
+      res.writeHead(200, { "Content-Type": "application/json", ...CORS });
+      return res.end(JSON.stringify({
+        issuer: base,
+        authorization_endpoint: `${base}/authorize`,
+        token_endpoint: `${base}/token`,
+        registration_endpoint: `${base}/register`,
+        response_types_supported: ["code"],
+        grant_types_supported: ["authorization_code"],
+        code_challenge_methods_supported: ["S256"],
+        scopes_supported: ["mcp:tools"],
+      }));
+    }
+
+    // ── Dynamic Client Registration (RFC 7591) ──────────────
+    if (method === "POST" && reqPath === "/register") {
+      let body;
+      try { body = await readBody(req); } catch {
+        res.writeHead(400, { "Content-Type": "application/json", ...CORS });
+        return res.end(JSON.stringify({ error: "invalid_request" }));
+      }
+      const clientId = crypto.randomBytes(16).toString("hex");
+      const clientSecret = crypto.randomBytes(32).toString("hex");
+      const client = {
+        client_id: clientId, client_secret: clientSecret,
+        client_name: body.client_name || "unknown",
+        redirect_uris: body.redirect_uris || [],
+        grant_types: body.grant_types || ["authorization_code"],
+        response_types: body.response_types || ["code"],
+        token_endpoint_auth_method: body.token_endpoint_auth_method || "client_secret_post",
+      };
+      oauthClients.set(clientId, client);
+      const logMsg = `[${new Date().toISOString()}] OAuth: registered client ${clientId} (${client.client_name})\n`;
+      try { fs.appendFileSync(LOG_FILE, logMsg); } catch {}
+      res.writeHead(201, { "Content-Type": "application/json", ...CORS });
+      return res.end(JSON.stringify(client));
+    }
+
+    // ── Authorization endpoint — auto-approve ──────────────
+    if (method === "GET" && reqPath === "/authorize") {
+      const clientId = url.searchParams.get("client_id");
+      const redirectUri = url.searchParams.get("redirect_uri");
+      const state = url.searchParams.get("state");
+      const codeChallenge = url.searchParams.get("code_challenge");
+      const codeChallengeMethod = url.searchParams.get("code_challenge_method");
+
+      if (!clientId || !redirectUri) {
+        res.writeHead(400, { "Content-Type": "text/plain", ...CORS });
+        return res.end("Missing client_id or redirect_uri");
+      }
+
+      const code = crypto.randomBytes(32).toString("hex");
+      oauthCodes.set(code, {
+        client_id: clientId, redirect_uri: redirectUri,
+        code_challenge: codeChallenge, code_challenge_method: codeChallengeMethod,
+        expires: Date.now() + 300_000,
+      });
+
+      const redirect = new URL(redirectUri);
+      redirect.searchParams.set("code", code);
+      if (state) redirect.searchParams.set("state", state);
 
-    // ── MCP SSE transport ─────────────────────────────────
+      const logMsg = `[${new Date().toISOString()}] OAuth: authorize → code issued for ${clientId}, redirecting to ${redirect.origin}\n`;
+      try { fs.appendFileSync(LOG_FILE, logMsg); } catch {}
+      res.writeHead(302, { Location: redirect.toString(), ...CORS });
+      return res.end();
+    }
+
+    // ── Token endpoint ──────────────────────────────────────
+    if (method === "POST" && reqPath === "/token") {
+      let body;
+      const ct = req.headers["content-type"] || "";
+      try {
+        if (ct.includes("application/json")) {
+          body = await readBody(req);
+        } else {
+          const raw = await readRawBody(req);
+          body = Object.fromEntries(new URLSearchParams(raw));
+        }
+      } catch {
+        res.writeHead(400, { "Content-Type": "application/json", ...CORS });
+        return res.end(JSON.stringify({ error: "invalid_request" }));
+      }
+
+      if (body.grant_type !== "authorization_code") {
+        res.writeHead(400, { "Content-Type": "application/json", ...CORS });
+        return res.end(JSON.stringify({ error: "unsupported_grant_type" }));
+      }
+
+      const stored = oauthCodes.get(body.code);
+      if (!stored || stored.expires < Date.now()) {
+        oauthCodes.delete(body.code);
+        res.writeHead(400, { "Content-Type": "application/json", ...CORS });
+        return res.end(JSON.stringify({ error: "invalid_grant" }));
+      }
+
+      // PKCE verification
+      if (stored.code_challenge && body.code_verifier) {
+        const computed = sha256base64url(body.code_verifier);
+        if (computed !== stored.code_challenge) {
+          oauthCodes.delete(body.code);
+          res.writeHead(400, { "Content-Type": "application/json", ...CORS });
+          return res.end(JSON.stringify({ error: "invalid_grant", error_description: "PKCE verification failed" }));
+        }
+      }
+
+      oauthCodes.delete(body.code);
+      const accessToken = crypto.randomBytes(32).toString("hex");
+      oauthTokens.add(accessToken);
+
+      const logMsg = `[${new Date().toISOString()}] OAuth: token issued for client ${stored.client_id}\n`;
+      try { fs.appendFileSync(LOG_FILE, logMsg); } catch {}
+      res.writeHead(200, { "Content-Type": "application/json", ...CORS });
+      return res.end(JSON.stringify({ access_token: accessToken, token_type: "Bearer", expires_in: 86400 }));
+    }
+
+    // ── MCP OAuth-protected endpoint (for claude.ai web) ──
+    // POST /mcp — requires Bearer token; returns 401 to trigger OAuth flow
+    if (method === "POST" && reqPath === "/mcp") {
+      const authHeader = req.headers.authorization;
+      if (!authHeader || !authHeader.startsWith("Bearer ")) {
+        const base = oauthBase();
+        res.writeHead(401, {
+          "Content-Type": "application/json",
+          "WWW-Authenticate": `Bearer resource_metadata="${base}/.well-known/oauth-protected-resource"`,
+          ...CORS,
+        });
+        return res.end(JSON.stringify({ error: "unauthorized" }));
+      }
+      const token = authHeader.slice(7);
+      if (!oauthTokens.has(token)) {
+        res.writeHead(401, { "Content-Type": "application/json", ...CORS });
+        return res.end(JSON.stringify({ error: "invalid_token" }));
+      }
+      // Token valid — fall through to MCP handling below
+    }
+
+    // ── MCP Streamable HTTP transport (2025-03-26 spec) ──
+    // POST /sse or POST /mcp — JSON-RPC over HTTP
+    if (method === "POST" && (reqPath === "/sse" || reqPath === "/mcp")) {
+      let body;
+      try { body = await readBody(req); } catch {
+        res.writeHead(400, { "Content-Type": "application/json", ...CORS });
+        return res.end(JSON.stringify({ error: "Invalid JSON" }));
+      }
+
+      const id = body.id;
+      const rpcMethod = body.method;
+      const logMsg = `[${new Date().toISOString()}] Streamable HTTP: ${rpcMethod} id=${id}\n`;
+      try { fs.appendFileSync(LOG_FILE, logMsg); } catch {}
+
+      // Notifications — no response needed
+      if (rpcMethod === "notifications/initialized" || rpcMethod === "initialized") {
+        res.writeHead(204, CORS);
+        return res.end();
+      }
+
+      if (rpcMethod === "initialize") {
+        const result = {
+          protocolVersion: "2025-03-26",
+          serverInfo: { name: "clauth", version: VERSION },
+          capabilities: { tools: {} }
+        };
+        res.writeHead(200, { "Content-Type": "application/json", ...CORS });
+        return res.end(JSON.stringify({ jsonrpc: "2.0", id, result }));
+      }
+
+      if (rpcMethod === "tools/list") {
+        res.writeHead(200, { "Content-Type": "application/json", ...CORS });
+        return res.end(JSON.stringify({ jsonrpc: "2.0", id, result: { tools: MCP_TOOLS } }));
+      }
+
+      if (rpcMethod === "tools/call") {
+        const { name, arguments: args } = body.params || {};
+        const vault = sseVault();
+        try {
+          const result = await handleMcpTool(vault, name, args || {});
+          password = vault.password;
+          res.writeHead(200, { "Content-Type": "application/json", ...CORS });
+          return res.end(JSON.stringify({ jsonrpc: "2.0", id, result }));
+        } catch (err) {
+          res.writeHead(200, { "Content-Type": "application/json", ...CORS });
+          return res.end(JSON.stringify({ jsonrpc: "2.0", id, result: mcpError(`Internal error: ${err.message}`) }));
+        }
+      }
+
+      // Unknown method
+      res.writeHead(200, { "Content-Type": "application/json", ...CORS });
+      return res.end(JSON.stringify({ jsonrpc: "2.0", id, error: { code: -32601, message: `Unknown method: ${rpcMethod}` } }));
+    }
+
+    // ── MCP SSE transport (legacy) ───────────────────────
     // GET /sse — open SSE stream, receive endpoint event
     if (method === "GET" && reqPath === "/sse") {
       const sessionId = `ses_${++sseCounter}_${Date.now()}`;
@@ -1060,7 +1364,9 @@ function createServer(initPassword, whitelist, port) {
       sseSessions.set(sessionId, { res, initialized: false });
 
       // Send the endpoint URI the client should POST to
-      const endpoint = `/message?sessionId=${sessionId}`;
+      // Use absolute URL when tunnel is active so remote clients can resolve it
+      const basePath = tunnelUrl || `http://127.0.0.1:${port}`;
+      const endpoint = `${basePath}/message?sessionId=${sessionId}`;
       res.write(`event: endpoint\ndata: ${endpoint}\n\n`);
 
       // Keepalive every 15s
@@ -1184,6 +1490,15 @@ function createServer(initPassword, whitelist, port) {
       });
     }
 
+    // GET /mcp-setup — OAuth credentials for claude.ai MCP setup (localhost only)
+    if (method === "GET" && reqPath === "/mcp-setup") {
+      return ok(res, {
+        url: tunnelUrl && tunnelUrl.startsWith("http") ? `${tunnelUrl}/mcp` : null,
+        clientId: OAUTH_CLIENT_ID,
+        clientSecret: OAUTH_CLIENT_SECRET,
+      });
+    }
+
     // POST /tunnel — start or stop tunnel manually
     if (method === "POST" && reqPath === "/tunnel") {
       if (lockedGuard(res)) return;
@@ -1468,10 +1783,21 @@ function createServer(initPassword, whitelist, port) {
       }
     }
 
-    // Unknown route
+    // Unknown route — don't count browser/MCP noise as auth failures
+    // Don't count browser noise, MCP discovery probes, or OAuth probes as auth failures
+    const isBenign = reqPath.startsWith("/.well-known/") || [
+      "/favicon.ico", "/robots.txt", "/apple-touch-icon.png", "/apple-touch-icon-precomposed.png",
+      "/sse", "/mcp", "/message", "/register", "/authorize", "/token",
+    ].includes(reqPath);
+    if (isBenign) {
+      res.writeHead(404, { "Content-Type": "application/json", ...CORS });
+      return res.end(JSON.stringify({ error: "Not found" }));
+    }
     return strike(res, 404, `Unknown endpoint: ${reqPath}`);
   });
 
+  server.__oauthClientId = OAUTH_CLIENT_ID;
+  server.__oauthClientSecret = OAUTH_CLIENT_SECRET;
   return server;
 }
 
@@ -1487,6 +1813,7 @@ async function verifyAuth(password) {
 async function actionStart(opts) {
   const port     = parseInt(opts.port || "52437", 10);
   const password = opts.pw;
+  const tunnelHostname = opts.tunnel || null;
   const whitelist = opts.services
     ? opts.services.split(",").map(s => s.trim().toLowerCase())
     : null;
@@ -1512,7 +1839,7 @@ async function actionStart(opts) {
       }
     }
 
-    const server = createServer(password, whitelist, port);
+    const server = createServer(password, whitelist, port, tunnelHostname);
     server.listen(port, "127.0.0.1", () => {
       writePid(process.pid, port);
       const msg = `[${new Date().toISOString()}] clauth serve started — PID ${process.pid}, port ${port}, services: ${whitelist ? whitelist.join(",") : "all"}\n`;
@@ -1556,6 +1883,7 @@ async function actionStart(opts) {
   const childArgs = [cliEntry, "serve", "start", "--port", String(port)];
   if (password) childArgs.push("--pw", password);
   if (opts.services) childArgs.push("--services", opts.services);
+  if (tunnelHostname) childArgs.push("--tunnel", tunnelHostname);
 
   const out = fs.openSync(LOG_FILE, "a");
   const child = spawn(process.execPath, childArgs, {
@@ -1672,6 +2000,7 @@ async function actionRestart(opts) {
 async function actionForeground(opts) {
   const port      = parseInt(opts.port || "52437", 10);
   const password  = opts.pw || null;
+  const tunnelHostname = opts.tunnel || null;
   const whitelist = opts.services
     ? opts.services.split(",").map(s => s.trim().toLowerCase())
     : null;
@@ -1693,10 +2022,19 @@ async function actionForeground(opts) {
   console.log(chalk.gray(`  Services: ${whitelist ? whitelist.join(", ") : "all"}`));
   console.log(chalk.gray(`  Lockout:  3 failures → exit\n`));
 
-  const server = createServer(password, whitelist, port);
+  const server = createServer(password, whitelist, port, tunnelHostname);
   server.listen(port, "127.0.0.1", () => {
     writePid(process.pid, port);
     console.log(chalk.green(`  clauth serve → http://127.0.0.1:${port}`));
+    if (tunnelHostname) {
+      console.log(chalk.cyan(`  Tunnel:   https://${tunnelHostname}/sse`));
+      console.log("");
+      console.log(chalk.yellow("  ── claude.ai Custom Connector ──"));
+      console.log(chalk.white(`  URL:            https://${tunnelHostname}/mcp`));
+      console.log(chalk.white(`  Client ID:      ${server.__oauthClientId}`));
+      console.log(chalk.white(`  Client Secret:  ${server.__oauthClientSecret}`));
+      console.log(chalk.gray("  (paste these into Advanced Settings when adding the connector)"));
+    }
     if (!password) console.log(chalk.cyan(`  👉 Open http://127.0.0.1:${port} to unlock`));
     console.log(chalk.gray("  Ctrl+C to stop\n"));
     // Auto-open browser
@@ -2070,7 +2408,7 @@ function createMcpServer(initPassword, whitelist) {
     get machineHash() { return ensureMachineHash(); },
     whitelist,
     failCount: 0,
-    MAX_FAILS: 3,
+    MAX_FAILS: 10,
   };
 
   const rl = createInterface({ input: process.stdin, terminal: false });

package/cli/index.js

@@ -12,7 +12,7 @@ import * as api from "./api.js";
 import os from "os";
 
 const config = new Conf(getConfOptions());
-const VERSION = "0.5.1";
+const VERSION = "0.7.0";
 
 // ============================================================
 // Password prompt helper
@@ -468,6 +468,7 @@ program
   .option("--port <n>", "Port (default: 52437)")
   .option("-p, --pw <password>", "clauth password (optional — omit to start locked, unlock in browser)")
   .option("--services <list>", "Comma-separated service whitelist (default: all)")
+  .option("--tunnel <hostname>", "Fixed tunnel hostname (e.g. clauth.prtrust.fund) — uses named Cloudflare Tunnel instead of random URL")
   .option("--action <action>", "Internal: action override for daemon child")
   .addHelpText("after", `
 Actions:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lifeaitools/clauth",
-  "version": "0.5.1",
+  "version": "0.7.0",
   "description": "Hardware-bound credential vault for the LIFEAI infrastructure stack",
   "type": "module",
   "bin": {