@lifeaitools/clauth 2.1.1 → 2.10.1

package/cli/http/components/dashboard-component.js

@@ -0,0 +1,123 @@
+// cli/http/components/dashboard-component.js
+// The Dashboard (Site/Website) component: GET / -- the built-in web
+// dashboard's HTML shell -- plus POST /message, the legacy SSE-transport
+// JSON-RPC endpoint a GET /sse session's client POSTs its calls to (the
+// Streamable-HTTP transport's own POST handling lives in the MCP-transport
+// component; this is only the older two-leg SSE-session sibling).
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+import { fileURLToPath } from "node:url";
+import { readBody } from "../request-utils.js";
+import { MCP_TOOLS, filterMcpToolsForWriteMode } from "../../mcp/tool-schemas.js";
+import { mcpError } from "../../mcp/tool-registry.js";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, "../../../package.json"), "utf8"));
+const VERSION = pkg.version;
+
+const WRITE_TOKEN_BYTES = 32;
+const WRITE_TOKEN_TTL_MS = 10 * 60 * 1000;
+function makeWriteToken() {
+  return {
+    token: crypto.randomBytes(WRITE_TOKEN_BYTES).toString("base64url"),
+    expiresAt: Date.now() + WRITE_TOKEN_TTL_MS,
+  };
+}
+
+function sseSend(sessionRes, event, data) {
+  sessionRes.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+}
+
+export function registerDashboardRoutes(ctx) {
+  // POST /message?sessionId=xxx — JSON-RPC over SSE
+  ctx.registerWriteRoute("POST", "/message", async (req, res, url) => {
+      const sessionId = url.searchParams.get("sessionId");
+      const session = sessionId ? ctx.sseSessions.get(sessionId) : null;
+
+      if (!session) {
+        res.writeHead(404, { "Content-Type": "application/json", ...ctx.CORS });
+        return res.end(JSON.stringify({ error: "Unknown or expired session" }));
+      }
+
+      let body;
+      try { body = await readBody(req); } catch {
+        res.writeHead(400, { "Content-Type": "application/json", ...ctx.CORS });
+        return res.end(JSON.stringify({ error: "Invalid JSON" }));
+      }
+
+      const id = body.id;
+      const rpcMethod = body.method;
+
+      // Acknowledge the POST immediately
+      res.writeHead(202, { "Content-Type": "application/json", ...ctx.CORS });
+      res.end(JSON.stringify({ ok: true }));
+
+      // Handle JSON-RPC methods
+      if (rpcMethod === "notifications/initialized" || rpcMethod === "initialized") {
+        session.initialized = true;
+        return;
+      }
+
+      if (rpcMethod === "initialize") {
+        sseSend(session.res, "message", {
+          jsonrpc: "2.0", id,
+          result: {
+            protocolVersion: "2024-11-05",
+            serverInfo: { name: "clauth", version: VERSION },
+            capabilities: { tools: {} }
+          }
+        });
+        return;
+      }
+
+      if (rpcMethod === "tools/list") {
+        sseSend(session.res, "message", {
+          jsonrpc: "2.0", id,
+          result: { tools: filterMcpToolsForWriteMode(MCP_TOOLS) }
+        });
+        return;
+      }
+
+      if (rpcMethod === "tools/call") {
+        const { name, arguments: args } = body.params || {};
+        const vault = ctx.sseVault();
+        try {
+          const result = await ctx.handleMcpTool(vault, name, args || {});
+          // Sync vault mutations back (e.g. unlock sets password)
+          ctx.password = vault.password;
+          sseSend(session.res, "message", { jsonrpc: "2.0", id, result });
+        } catch (err) {
+          sseSend(session.res, "message", {
+            jsonrpc: "2.0", id,
+            result: mcpError(`Internal error: ${err.message}`)
+          });
+        }
+        return;
+      }
+
+      // Unknown method
+      sseSend(session.res, "message", {
+        jsonrpc: "2.0", id,
+        error: { code: -32601, message: `Unknown method: ${rpcMethod}` }
+      });
+      return;
+  });
+
+  // GET / — built-in web dashboard
+  ctx.registerWriteRoute("GET", "/", async (req, res) => {
+      // When unlocked, ensure a non-expired write session exists and hand its
+      // token to the page so the dashboard is write-ready on load — fixes the
+      // --pw/boot.key auto-unlock case where the page never saw the unlock
+      // screen and so held no write token. (Consistent with the existing trust
+      // model: /v/<service> already serves raw credentials to localhost when
+      // unlocked, so a same-origin write token is no broader.)
+      let initWriteToken = null;
+      if (ctx.password) {
+        if (!ctx.writeSession || Date.now() > ctx.writeSession.expiresAt) ctx.writeSession = makeWriteToken();
+        initWriteToken = ctx.writeSession.token;
+      }
+      res.writeHead(200, { "Content-Type": "text/html", ...ctx.CORS });
+      return res.end(ctx.dashboardHtml(ctx.port, ctx.whitelist, ctx.isStaged, initWriteToken));
+  });
+}

package/cli/http/components/inbox-component.js

@@ -0,0 +1,41 @@
+// cli/http/components/inbox-component.js
+// The Inbox component: GET /inbox/:sessionKey/peek -- convergence layer 5
+// messaging probe. Returns { pending, sources, max_priority } from
+// collab.inbox_messages via the public.inbox_peek Supabase RPC. An unlocked
+// daemon reads Supabase creds from its own vault; a locked isolated TEST
+// daemon borrows them from the upstream live daemon (CLAUTH_UPSTREAM,
+// default :52437) so regression harnesses need no manual unlock.
+import { deriveToken } from "../../fingerprint.js";
+import * as api from "../../api.js";
+
+export function registerInboxRoutes(ctx) {
+  ctx.registerPatternRoute("GET", /^\/inbox\/([^/]+)\/peek$/, async (req, res, match) => {
+      const sessionKey = decodeURIComponent(match[1]);
+      try {
+        let key = null;
+        let ref = null;
+        if (ctx.password) {
+          const { token, timestamp } = deriveToken(ctx.password, ctx.machineHash);
+          const svc   = await api.retrieve(ctx.password, ctx.machineHash, token, timestamp, "supabase-service");
+          const dbRaw = await api.retrieve(ctx.password, ctx.machineHash, token, timestamp, "supabase-db");
+          if (svc.error || dbRaw.error) return ctx.noBrowserJson(res, 503, { error: svc.error || dbRaw.error });
+          key = svc.value;
+          try { ref = JSON.parse(dbRaw.value).ref; } catch { /* below */ }
+        } else {
+          const up = process.env.CLAUTH_UPSTREAM || "http://127.0.0.1:52437";
+          key = (await (await fetch(`${up}/v/supabase-service`)).text()).trim();
+          try { ref = JSON.parse(await (await fetch(`${up}/v/supabase-db`)).text()).ref; } catch { /* below */ }
+        }
+        if (!key || !ref) return ctx.noBrowserJson(res, 503, { error: "supabase creds unavailable" });
+        const resp = await fetch(`https://${ref}.supabase.co/rest/v1/rpc/inbox_peek`, {
+          method: "POST",
+          headers: { apikey: key, Authorization: `Bearer ${key}`, "Content-Type": "application/json" },
+          body: JSON.stringify({ p_session_key: sessionKey }),
+        });
+        if (!resp.ok) return ctx.noBrowserJson(res, 502, { error: `supabase rpc ${resp.status}` });
+        return ctx.noBrowserJson(res, 200, await resp.json());
+      } catch (err) {
+        return ctx.noBrowserJson(res, 503, { error: err.message });
+      }
+  });
+}

package/cli/http/components/mcp-transport-component.js

@@ -0,0 +1,275 @@
+// cli/http/components/mcp-transport-component.js
+// The MCP-transport component: OAuth 2.1 discovery (.well-known/* -- RFC 9728
+// + RFC 8414), the Bearer-token gate that fronts every MCP endpoint, the
+// Streamable HTTP JSON-RPC transport (POST /sse, /mcp, /gws, /clauth, /fs),
+// and the legacy SSE session-open handshake (GET /sse and namespaced paths).
+// This is the live transport claude.ai's Custom Connector and every local
+// MCP client actually talk to -- the most sensitive extraction this session,
+// handled last and verified against the isolated instance only.
+//
+// noAuthHost/localTrustedHost/requestHost are derived fresh from req.headers.host
+// on every request -- pure per-request logic, duplicated locally rather than
+// passed via ctx (there's nothing closure-scoped about them). MCP_PATHS/
+// toolsForPath/serverNameForPath are likewise pure and self-contained.
+//
+// oauthBase, sseVault, handleMcpTool stay defined in serve.js as closure
+// functions and are passed via ctx as references, matching every other
+// extraction this session (dashboard-component.js's dashboardHtml/sseVault/
+// handleMcpTool trio is the direct precedent). oauthTokens (a Set, mutated
+// only via .has()) and sseSessions (a Map, mutated via .set()/.delete()) are
+// passed by reference -- no accessor wrapping needed. password needs a
+// setter (tools/call syncs vault mutations back) and sseCounter needs both
+// getter and setter since it's incremented in place (ctx.sseCounter++ invokes
+// both transparently, same as any other JS accessor pair).
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { fileURLToPath } from "node:url";
+import { readBody } from "../request-utils.js";
+import { MCP_TOOLS, filterMcpToolsForWriteMode } from "../../mcp/tool-schemas.js";
+import { mcpError } from "../../mcp/tool-registry.js";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, "../../../package.json"), "utf8"));
+const VERSION = pkg.version;
+const LOG_FILE = path.join(os.tmpdir(), "clauth-serve.log");
+
+// Hosts that bypass OAuth (fresh domains for claude.ai compatibility) —
+// those domains use the tunnel URL itself as a shared secret (like regen-media).
+const NOAUTH_HOSTS = ["fs.regendevcorp.com", "clauth.regendevcorp.com", "chitchat.regendevcorp.com"];
+const MCP_PATHS = ["/mcp", "/gws", "/clauth", "/fs"];
+
+function hostFlags(req) {
+  const requestHost = (req.headers.host || "").split(":")[0].toLowerCase();
+  return {
+    noAuthHost: NOAUTH_HOSTS.includes(requestHost),
+    localTrustedHost: ["127.0.0.1", "localhost", "::1", "[::1]"].includes(requestHost),
+  };
+}
+
+function toolsForPath(p) {
+  const tools = filterMcpToolsForWriteMode(MCP_TOOLS);
+  if (p === "/gws")      return tools.filter(t => t.name.startsWith("gws_"));
+  if (p === "/clauth")   return tools.filter(t => t.name.startsWith("clauth_") || t.name === "call_agent" || t.name.startsWith("terminal_") || t.name.startsWith("channel_"));
+  if (p === "/fs")       return tools.filter(t => t.name.startsWith("fs_"));
+  return tools; // /mcp — all tools
+}
+function serverNameForPath(p) {
+  if (p === "/gws")      return "gws";
+  if (p === "/clauth")   return "clauth";
+  if (p === "/fs")       return "fs";
+  return "clauth";
+}
+
+export function registerMcpTransportRoutes(ctx) {
+  // ── OAuth Discovery (RFC 9728 + RFC 8414) — any /.well-known/* path ──
+  ctx.registerPatternRoute("GET", /^\/\.well-known\//, async (req, res, match, url) => {
+      const reqPath = url.pathname;
+      const { noAuthHost } = hostFlags(req);
+
+      // Suppress OAuth discovery on noauth hosts — prevents claude.ai from entering OAuth flow
+      if (noAuthHost) {
+        res.writeHead(404, { "Content-Type": "application/json", ...ctx.CORS });
+        return res.end(JSON.stringify({ error: "not_found" }));
+      }
+
+      // Restore full well-known + OAuth so custom setup with client_id/secret works.
+      if (reqPath.startsWith("/.well-known/oauth-protected-resource")) {
+        const base = ctx.oauthBase();
+        const suffix = reqPath.replace("/.well-known/oauth-protected-resource", "").replace(/^\//, "");
+        const resourcePath = suffix && ["/gws", "/clauth", "/mcp", "/fs", "/sse"].includes("/" + suffix) ? "/" + suffix : "/sse";
+        res.writeHead(200, { "Content-Type": "application/json", "Cache-Control": "no-store", ...ctx.CORS });
+        return res.end(JSON.stringify({
+          resource: `${base}${resourcePath}`,
+          authorization_servers: [base],
+          scopes_supported: ["mcp:tools"],
+          bearer_methods_supported: ["header"],
+        }));
+      }
+
+      if (reqPath === "/.well-known/oauth-authorization-server") {
+        const base = ctx.oauthBase();
+        res.writeHead(200, { "Content-Type": "application/json", "Cache-Control": "no-store", ...ctx.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"],
+          token_endpoint_auth_methods_supported: ["none"],
+          code_challenge_methods_supported: ["S256"],
+          scopes_supported: ["mcp:tools"],
+        }));
+      }
+
+      // No known well-known sub-path matched — same generic 404 shape as the
+      // real terminal fallback in serve.js, since this pattern-route's regex
+      // has already claimed every /.well-known/* request.
+      try { fs.appendFileSync(LOG_FILE, `[${new Date().toISOString()}] 404 GET ${reqPath}\n`); } catch {}
+      res.writeHead(404, { "Content-Type": "application/json", ...ctx.CORS });
+      return res.end(JSON.stringify({ error: `Unknown endpoint: ${reqPath}` }));
+  });
+
+  // ── MCP endpoint auth (401 gate) + Streamable HTTP transport + SSE open ──
+  // Registered once per literal path (POST and GET) rather than a pattern
+  // route — these are five fixed strings, not a dynamic segment.
+  const ALL_MCP_POST_PATHS = ["/sse", ...MCP_PATHS];
+  for (const reqPath of ALL_MCP_POST_PATHS) {
+    ctx.registerWriteRoute("POST", reqPath, (req, res, url) => handleMcpPost(ctx, req, res, url, reqPath));
+    ctx.registerWriteRoute("GET", reqPath, (req, res, url) => handleMcpGet(ctx, req, res, url, reqPath));
+  }
+}
+
+async function handleMcpPost(ctx, req, res, url, reqPath) {
+  const isMcpPath = MCP_PATHS.includes(reqPath);
+  const { noAuthHost, localTrustedHost } = hostFlags(req);
+
+  // ── MCP endpoint auth — 401 gate (OAuth 2.1 protocol) ──
+  // Skipped for noauth hosts — those domains use tunnel URL as shared secret (like regen-media)
+  const authHeader = req.headers.authorization;
+  const token = authHeader?.startsWith("Bearer ") ? authHeader.slice(7) : null;
+
+  if (!noAuthHost && !localTrustedHost && (!token || !ctx.oauthTokens.has(token))) {
+    // No valid Bearer token → return 401 with discovery hint
+    const base = ctx.oauthBase();
+    const resourcePath = isMcpPath ? reqPath.slice(1) : "sse"; // "mcp", "gws", "clauth", or "sse"
+    const resourceMeta = `${base}/.well-known/oauth-protected-resource/${resourcePath}`;
+    res.writeHead(401, {
+      "Content-Type": "application/json",
+      "WWW-Authenticate": `Bearer realm="MCP", resource_metadata="${resourceMeta}"`,
+      "Cache-Control": "no-store",
+      ...ctx.CORS,
+    });
+    return res.end(JSON.stringify({
+      error: "unauthorized",
+      error_description: "Bearer token required",
+    }));
+  }
+
+  // Valid token or trusted localhost — mark remote status and fall through to MCP handling
+  req._clauthRemote = !localTrustedHost;
+
+  // ── MCP Streamable HTTP transport ──
+  // claude.ai requires text/event-stream SSE format (like regen-media/Express).
+  let body;
+  try { body = await readBody(req); } catch {
+    res.writeHead(400, { "Content-Type": "application/json", ...ctx.CORS });
+    return res.end(JSON.stringify({ error: "Invalid JSON" }));
+  }
+
+  const id = body.id;
+  const rpcMethod = body.method;
+  const logMsg = `[${new Date().toISOString()}] Streamable HTTP [${reqPath}]: ${rpcMethod} id=${id}\n`;
+  try { fs.appendFileSync(LOG_FILE, logMsg); } catch {}
+
+  // Check if client accepts SSE — claude.ai sends Accept: application/json, text/event-stream
+  const acceptsSSE = (req.headers.accept || "").includes("text/event-stream");
+
+  // Helper: respond in SSE or JSON format based on client preference
+  // SSE response matches regen-media/Express exactly: no CORS, Content-Length, x-powered-by
+  function mcpRespond(res, jsonRpcResponse) {
+    if (acceptsSSE) {
+      const ssePayload = `event: message\ndata: ${JSON.stringify(jsonRpcResponse)}\n\n`;
+      const buf = Buffer.from(ssePayload, "utf8");
+      res.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Content-Length": buf.length,
+        "Cache-Control": "no-cache",
+        "vary": "Accept-Encoding",
+        "x-powered-by": "Express",
+      });
+      return res.end(buf);
+    }
+    res.writeHead(200, { "Content-Type": "application/json", ...ctx.CORS });
+    return res.end(JSON.stringify(jsonRpcResponse));
+  }
+
+  // Notifications — no response needed
+  if (rpcMethod === "notifications/initialized" || rpcMethod === "initialized") {
+    res.writeHead(202, ctx.CORS);
+    return res.end();
+  }
+
+  if (rpcMethod === "initialize") {
+    const result = {
+      protocolVersion: "2025-03-26",
+      serverInfo: { name: serverNameForPath(reqPath), version: VERSION },
+      capabilities: { tools: { listChanged: true } }
+    };
+    return mcpRespond(res, { jsonrpc: "2.0", id, result });
+  }
+
+  if (rpcMethod === "tools/list") {
+    return mcpRespond(res, { jsonrpc: "2.0", id, result: { tools: toolsForPath(reqPath) } });
+  }
+
+  if (rpcMethod === "tools/call") {
+    const { name, arguments: args } = body.params || {};
+    const vault = ctx.sseVault();
+    vault.remote = !!req._clauthRemote;
+    try {
+      const result = await ctx.handleMcpTool(vault, name, args || {});
+      ctx.password = vault.password;
+      return mcpRespond(res, { jsonrpc: "2.0", id, result });
+    } catch (err) {
+      return mcpRespond(res, { jsonrpc: "2.0", id, result: mcpError(`Internal error: ${err.message}`) });
+    }
+  }
+
+  // Unknown method
+  return mcpRespond(res, { jsonrpc: "2.0", id, error: { code: -32601, message: `Unknown method: ${rpcMethod}` } });
+}
+
+function handleMcpGet(ctx, req, res, url, reqPath) {
+  const { noAuthHost } = hostFlags(req);
+
+  // ── MCP SSE transport — /sse and namespaced paths ────
+  // Remote clients (claude.ai) arrive with a Bearer token via OAuth.
+  // They use Streamable HTTP (POST only) — return 405 on GET so claude.ai
+  // knows to POST directly. Local clients have no Bearer token and use SSE.
+  const isMcpPath = MCP_PATHS.includes(reqPath);
+  if (isMcpPath) {
+    const getAuthHeader = req.headers.authorization;
+    const getToken = getAuthHeader?.startsWith("Bearer ") ? getAuthHeader.slice(7) : null;
+    if (!noAuthHost && getToken && ctx.oauthTokens.has(getToken)) {
+      res.writeHead(405, { "Content-Type": "application/json", "Allow": "POST", ...ctx.CORS });
+      return res.end(JSON.stringify({ error: "Method Not Allowed", detail: "Use POST for Streamable HTTP transport" }));
+    }
+  }
+
+  // GET /sse|/clauth — open SSE stream, receive endpoint event
+  const sessionId = `ses_${++ctx.sseCounter}_${Date.now()}`;
+
+  res.writeHead(200, {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    "Connection": "keep-alive",
+    ...ctx.CORS,
+  });
+
+  ctx.sseSessions.set(sessionId, { res, initialized: false });
+
+  // Send the endpoint URI the client should POST to
+  // Use absolute URL when tunnel is active so remote clients can resolve it
+  const basePath = ctx.tunnelUrl || `http://127.0.0.1:${ctx.port}`;
+  const endpoint = `${basePath}/message?sessionId=${sessionId}`;
+  res.write(`event: endpoint\ndata: ${endpoint}\n\n`);
+
+  // Keepalive every 15s
+  const keepalive = setInterval(() => {
+    try { res.write(": keepalive\n\n"); } catch {}
+  }, 15_000);
+
+  // Cleanup on disconnect
+  req.on("close", () => {
+    clearInterval(keepalive);
+    ctx.sseSessions.delete(sessionId);
+    const logLine = `[${new Date().toISOString()}] SSE session closed: ${sessionId}\n`;
+    try { fs.appendFileSync(LOG_FILE, logLine); } catch {}
+  });
+
+  const logLine = `[${new Date().toISOString()}] SSE session opened: ${sessionId}\n`;
+  try { fs.appendFileSync(LOG_FILE, logLine); } catch {}
+  return;
+}

package/cli/http/components/oauth-component.js

@@ -0,0 +1,207 @@
+// cli/http/components/oauth-component.js
+// The OAuth component: OAuth 2.1 dynamic client registration
+// (POST /register), the auto-approving authorization endpoint (GET
+// /authorize -- PKCE mandatory, no user interaction since clauth is a
+// personal vault), and the token endpoint (POST /token -- exchanges an
+// authorization code + PKCE verifier for a bearer access token). This
+// is the auth flow claude.ai's Custom Connector uses to reach the MCP
+// transport, distinct from the vault password gate.
+//
+// /authorize is a GET that MUTATES state (issues a one-time code into
+// oauthCodes) -- registered via ctx.registerWriteRoute despite the verb,
+// same "mutation decides the registry, not the HTTP method" principle
+// used for /tunnel/setup-state earlier this session.
+//
+// oauthClients/oauthCodes/oauthTokens are Map/Set instances that stay
+// defined in serve.js and are passed via ctx as plain object
+// references -- calling .get()/.set()/.delete()/.add() on the SAME
+// instance needs no accessor wrapping, unlike a primitive "let" that
+// gets reassigned (contrast with vault-auth-component.js's password/
+// writeSession get/set pairs). saveClients/saveTokens (persist-to-disk)
+// stay in serve.js too, passed as plain function references.
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { operation } from "../../supervisor-registry.js";
+import { readBody, readRawBody } from "../request-utils.js";
+
+const LOG_FILE = path.join(os.tmpdir(), "clauth-serve.log");
+
+// Hosts that bypass OAuth entirely (fresh domains for claude.ai compatibility
+// -- those domains use the tunnel URL itself as a shared secret, like
+// regen-media). Dynamic Client Registration (RFC 7591) must not be reachable
+// on them. This check used to live as a raw if-block in serve.js's if-chain,
+// but the exact-match write-route Map (where these 3 routes now live) is
+// checked BEFORE that if-chain -- so the block never actually ran once these
+// routes moved to the registry, silently exposing /register, /authorize, and
+// /token on the noauth hosts. Restored here, at the point the Map actually
+// intercepts the request.
+const NOAUTH_HOSTS = ["fs.regendevcorp.com", "clauth.regendevcorp.com", "chitchat.regendevcorp.com"];
+function isNoAuthHost(req) {
+  const requestHost = (req.headers.host || "").split(":")[0].toLowerCase();
+  return NOAUTH_HOSTS.includes(requestHost);
+}
+
+function sha256base64url(str) {
+  return crypto.createHash("sha256").update(str).digest("base64url");
+}
+
+export function registerOAuthRoutes(ctx) {
+  ctx.registerWriteRoute("POST", "/register", async (req, res, url) => {
+      if (isNoAuthHost(req)) {
+        res.writeHead(404, { "Content-Type": "application/json", ...ctx.CORS });
+        return res.end(JSON.stringify({ error: "not_found" }));
+      }
+      let body;
+      try { body = await readBody(req); } catch {
+        res.writeHead(400, { "Content-Type": "application/json", ...ctx.CORS });
+        return res.end(JSON.stringify({ error: "invalid_request" }));
+      }
+      const clientId = crypto.randomBytes(16).toString("hex");
+      const client = {
+        client_id: clientId,
+        // NO client_secret — public client (OAuth 2.1)
+        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: "none",  // PUBLIC CLIENT
+      };
+      ctx.oauthClients.set(clientId, client);
+      ctx.saveClients(ctx.oauthClients);
+      const logMsg = `[${new Date().toISOString()}] OAuth: registered public client ${clientId} (${client.client_name})\n`;
+      try { fs.appendFileSync(LOG_FILE, logMsg); } catch {}
+      operation("oauth.client_register", { client_id: clientId, client_name: client.client_name }, null, { ok: true });
+      res.writeHead(201, { "Content-Type": "application/json", "Cache-Control": "no-store", ...ctx.CORS });
+      return res.end(JSON.stringify(client));
+  });
+  ctx.registerWriteRoute("GET", "/authorize", async (req, res, url) => {
+      if (isNoAuthHost(req)) {
+        res.writeHead(404, { "Content-Type": "application/json", ...ctx.CORS });
+        return res.end(JSON.stringify({ error: "not_found" }));
+      }
+      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");
+
+      // Validate required params
+      if (!clientId || !redirectUri) {
+        res.writeHead(400, { "Content-Type": "text/plain", ...ctx.CORS });
+        return res.end("Missing client_id or redirect_uri");
+      }
+
+      // PKCE is MANDATORY — reject if missing
+      if (!codeChallenge || codeChallengeMethod !== "S256") {
+        res.writeHead(400, { "Content-Type": "text/plain", ...ctx.CORS });
+        return res.end("PKCE required: code_challenge with S256 method");
+      }
+
+      // Validate client exists
+      if (!ctx.oauthClients.has(clientId)) {
+        res.writeHead(400, { "Content-Type": "text/plain", ...ctx.CORS });
+        return res.end("Unknown client_id");
+      }
+
+      // Validate redirect_uri matches registered URIs
+      const client = ctx.oauthClients.get(clientId);
+      if (client.redirect_uris.length > 0 && !client.redirect_uris.includes(redirectUri)) {
+        res.writeHead(400, { "Content-Type": "text/plain", ...ctx.CORS });
+        return res.end("redirect_uri mismatch");
+      }
+
+      // Auto-approve (no user interaction — clauth is a personal vault)
+      const code = crypto.randomBytes(32).toString("hex");
+      ctx.oauthCodes.set(code, {
+        client_id: clientId,
+        redirect_uri: redirectUri,
+        code_challenge: codeChallenge,
+        expires: Date.now() + 300_000,  // 5 minutes
+      });
+
+      const redirect = new URL(redirectUri);
+      redirect.searchParams.set("code", code);
+      if (state) redirect.searchParams.set("state", state);
+
+      const logMsg = `[${new Date().toISOString()}] OAuth: authorize → code for ${clientId}, redirect to ${redirect.origin}\n`;
+      try { fs.appendFileSync(LOG_FILE, logMsg); } catch {}
+      res.writeHead(302, { Location: redirect.toString(), "Cache-Control": "no-store", ...ctx.CORS });
+      return res.end();
+  });
+  ctx.registerWriteRoute("POST", "/token", async (req, res, url) => {
+      if (isNoAuthHost(req)) {
+        res.writeHead(404, { "Content-Type": "application/json", ...ctx.CORS });
+        return res.end(JSON.stringify({ error: "not_found" }));
+      }
+      let body;
+      const ct = req.headers["content-type"] || "";
+      try {
+        if (ct.includes("application/json")) {
+          body = await readBody(req);
+        } else {
+          // application/x-www-form-urlencoded (Claude uses this)
+          const raw = await readRawBody(req);
+          body = Object.fromEntries(new URLSearchParams(raw));
+        }
+      } catch {
+        res.writeHead(400, { "Content-Type": "application/json", ...ctx.CORS });
+        return res.end(JSON.stringify({ error: "invalid_request" }));
+      }
+
+      // Validate grant_type
+      if (body.grant_type !== "authorization_code") {
+        res.writeHead(400, { "Content-Type": "application/json", ...ctx.CORS });
+        return res.end(JSON.stringify({ error: "unsupported_grant_type" }));
+      }
+
+      // Validate authorization code exists and is not expired
+      const stored = ctx.oauthCodes.get(body.code);
+      if (!stored || stored.expires < Date.now()) {
+        ctx.oauthCodes.delete(body.code);
+        res.writeHead(400, { "Content-Type": "application/json", ...ctx.CORS });
+        return res.end(JSON.stringify({ error: "invalid_grant", error_description: "Code expired or invalid" }));
+      }
+
+      // Validate client_id matches
+      if (body.client_id !== stored.client_id) {
+        ctx.oauthCodes.delete(body.code);
+        res.writeHead(400, { "Content-Type": "application/json", ...ctx.CORS });
+        return res.end(JSON.stringify({ error: "invalid_grant", error_description: "client_id mismatch" }));
+      }
+
+      // Validate redirect_uri matches
+      if (body.redirect_uri !== stored.redirect_uri) {
+        ctx.oauthCodes.delete(body.code);
+        res.writeHead(400, { "Content-Type": "application/json", ...ctx.CORS });
+        return res.end(JSON.stringify({ error: "invalid_grant", error_description: "redirect_uri mismatch" }));
+      }
+
+      // PKCE verification — MANDATORY (not optional)
+      if (!body.code_verifier) {
+        ctx.oauthCodes.delete(body.code);
+        res.writeHead(400, { "Content-Type": "application/json", ...ctx.CORS });
+        return res.end(JSON.stringify({ error: "invalid_grant", error_description: "code_verifier required" }));
+      }
+
+      const computed = sha256base64url(body.code_verifier);
+      if (computed !== stored.code_challenge) {
+        ctx.oauthCodes.delete(body.code);
+        res.writeHead(400, { "Content-Type": "application/json", ...ctx.CORS });
+        return res.end(JSON.stringify({ error: "invalid_grant", error_description: "PKCE verification failed" }));
+      }
+
+      // All checks passed — delete code (one-time use) and issue token
+      ctx.oauthCodes.delete(body.code);
+      const accessToken = crypto.randomBytes(32).toString("hex");
+      ctx.oauthTokens.add(accessToken);
+      ctx.saveTokens(ctx.oauthTokens);
+
+      const logMsg = `[${new Date().toISOString()}] OAuth: token issued for ${stored.client_id} (token=${accessToken.slice(0,8)}…)\n`;
+      try { fs.appendFileSync(LOG_FILE, logMsg); } catch {}
+      operation("oauth.token_issue", { client_id: stored.client_id }, null, { ok: true });
+      res.writeHead(200, { "Content-Type": "application/json", "Cache-Control": "no-store", ...ctx.CORS });
+      return res.end(JSON.stringify({ access_token: accessToken, token_type: "Bearer", scope: "mcp:tools", expires_in: 86400 }));
+  });
+}