@lifeaitools/clauth 2.10.1 → 2.15.2

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

@@ -1,7 +1,7 @@
 // cli/http/components/supervisor-component.js
-// The Supervisor-write component: plugin rescan/enable/disable/test/
-// promote, surface health probe + surface actions, and tunnel-route
-// CRUD -- all gated by hasSupervisorWrite() (the supervisor's own
+// The Supervisor-write component: plugin rescan/test/promote, surface
+// health probe + surface actions, and tunnel-route CRUD -- all gated by
+// hasSupervisorWrite() (the supervisor's own
 // write-token, a THIRD distinct guard from lockedGuard/writeGuard and
 // from the ops plane's bearer token), except /v1/surfaces/health which
 // is deliberately guard-free (read-only health sweep, run whenever the
@@ -16,10 +16,10 @@
 // every other component this session.
 import {
   discoverPlugins,
-  setPluginEnabled,
   runPluginAction,
   probeAllSurfaceHealth,
   runSurfaceAction,
+  runSurfacePromotion,
   addTunnelRoute,
   removeTunnelRoute,
   supervisorHealth,
@@ -40,16 +40,17 @@ export function registerSupervisorRoutes(ctx) {
       return ctx.ok(res, discoverPlugins());
     }
 
-    const pluginEnableMatch = reqPath.match(/^\/v1\/plugins\/([^/]+)\/(enable|disable|test|promote)$/);
-    if (method === "POST" && pluginEnableMatch) {
+    // enable/disable were removed 2026-08-31: the flag they set was pure
+    // metadata (no process spawn) and never implied a running process --
+    // starting/stopping a surface always required a separate, unrelated
+    // action (runSurfaceAction "start"/"restart"). That disconnect made the
+    // flag actively misleading rather than a real lifecycle control.
+    const pluginActionMatch = reqPath.match(/^\/v1\/plugins\/([^/]+)\/(test|promote)$/);
+    if (method === "POST" && pluginActionMatch) {
       if (!ctx.hasSupervisorWrite(req)) return ctx.rejectSupervisorWrite(res);
-      const pluginId = decodeURIComponent(pluginEnableMatch[1]);
-      const op = pluginEnableMatch[2];
-      const result = op === "enable"
-        ? setPluginEnabled(pluginId, true)
-        : op === "disable"
-          ? setPluginEnabled(pluginId, false)
-          : runPluginAction(pluginId, op);
+      const pluginId = decodeURIComponent(pluginActionMatch[1]);
+      const op = pluginActionMatch[2];
+      const result = runPluginAction(pluginId, op);
       res.writeHead(result.error ? 400 : 200, { "Content-Type": "application/json", ...ctx.CORS });
       return res.end(JSON.stringify(result));
     }
@@ -72,7 +73,10 @@ export function registerSupervisorRoutes(ctx) {
         res.writeHead(400, { "Content-Type": "application/json", ...ctx.CORS });
         return res.end(JSON.stringify({ error: "Invalid JSON" }));
       }
-      const result = runSurfaceAction(decodeURIComponent(surfaceActionMatch[1]), body?.action || "reconcile");
+      const action = body?.action || "reconcile";
+      const result = action === "promote"
+        ? await runSurfacePromotion(decodeURIComponent(surfaceActionMatch[1]))
+        : runSurfaceAction(decodeURIComponent(surfaceActionMatch[1]), action);
       res.writeHead(result.error ? 400 : 200, { "Content-Type": "application/json", ...ctx.CORS });
       return res.end(JSON.stringify(result));
     }

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

@@ -0,0 +1,233 @@
+// cli/http/components/test-static-oauth-component.js
+// TEST-ONLY, entirely additive: a minimal static-client OAuth 2.0 provider
+// (client_id + client_secret, authorization_code + refresh_token grants)
+// fronting one dummy MCP tool at /test/mcp. Built to test claude.ai's
+// BUILT-IN custom-connector OAuth support (manual client_id/secret entry —
+// no Dynamic Client Registration) side-by-side with the existing DCR+PKCE+
+// attestation stack in oauth-component.js / mcp-transport-component.js.
+// This file does not import from, call into, or modify either of those —
+// separate Maps, separate routes, separate discovery paths.
+//
+// Static credentials come from env so nothing is hardcoded/committed. If
+// unset, a random pair is generated at daemon start and logged once — read
+// it from clauth-serve.log to configure the claude.ai connector.
+//   CLAUTH_TEST_OAUTH_CLIENT_ID / CLAUTH_TEST_OAUTH_CLIENT_SECRET
+//
+// Access tokens are deliberately short-lived (10 min) so refresh_token
+// behavior is observable within a normal test session rather than needing
+// to wait 24h like the real flow.
+
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { readRawBody } from "../request-utils.js";
+
+const LOG_FILE = path.join(os.tmpdir(), "clauth-serve.log");
+const ACCESS_TTL_MS = 10 * 60 * 1000;
+const REFRESH_TTL_MS = 30 * 24 * 60 * 60 * 1000;
+
+function log(msg) {
+  try { fs.appendFileSync(LOG_FILE, `[${new Date().toISOString()}] test-oauth: ${msg}\n`); } catch {}
+}
+
+// Constant-time string compare, safe for unequal lengths (timingSafeEqual
+// throws rather than returning false when buffers differ in length).
+function safeEqual(a, b) {
+  const bufA = Buffer.from(String(a ?? ""), "utf8");
+  const bufB = Buffer.from(String(b ?? ""), "utf8");
+  if (bufA.length !== bufB.length) return false;
+  return crypto.timingSafeEqual(bufA, bufB);
+}
+
+export function registerTestStaticOAuthRoutes(ctx) {
+  const CLIENT_ID = process.env.CLAUTH_TEST_OAUTH_CLIENT_ID || crypto.randomBytes(8).toString("hex");
+  const CLIENT_SECRET = process.env.CLAUTH_TEST_OAUTH_CLIENT_SECRET || crypto.randomBytes(24).toString("hex");
+  log(`static client ready — client_id=${CLIENT_ID} client_secret=${CLIENT_SECRET}`);
+  // No Dynamic Client Registration in this static-client model, so there is
+  // no per-client redirect_uris list to validate against by default — the
+  // real oauth-component.js has one (client.redirect_uris); this needs its
+  // own. Fails closed: unset means no redirect_uri is accepted, not "accept
+  // anything", matching this whole surface's opt-in-only posture.
+  const ALLOWED_REDIRECT_URIS = (process.env.CLAUTH_TEST_OAUTH_REDIRECT_URIS || "")
+    .split(",").map((s) => s.trim()).filter(Boolean);
+
+  const codes = new Map();         // code -> { redirect_uri, expires }
+  const accessTokens = new Map();  // token -> { expires }
+  const refreshTokens = new Map(); // token -> { expires }
+
+  function issueTokenPair() {
+    const access_token = crypto.randomBytes(32).toString("hex");
+    const refresh_token = crypto.randomBytes(32).toString("hex");
+    accessTokens.set(access_token, { expires: Date.now() + ACCESS_TTL_MS });
+    refreshTokens.set(refresh_token, { expires: Date.now() + REFRESH_TTL_MS });
+    return { access_token, refresh_token };
+  }
+
+  // ── Discovery ──
+  // Namespaced entirely under /test/ — mcp-transport-component.js registers
+  // a broad /^\/\.well-known\// catch-all BEFORE this component runs, and
+  // registerPatternRoute matches in registration order (first match wins,
+  // confirmed serve.js:2523), so a bare /.well-known/... path here would be
+  // silently swallowed by that existing route rather than reaching this one.
+  ctx.registerPatternRoute("GET", /^\/test\/\.well-known\/oauth-protected-resource$/, async (req, res) => {
+    const base = ctx.oauthBase();
+    res.writeHead(200, { "Content-Type": "application/json", "Cache-Control": "no-store" });
+    return res.end(JSON.stringify({
+      resource: `${base}/test/mcp`,
+      authorization_servers: [`${base}/test`],
+      scopes_supported: ["test:tools"],
+      bearer_methods_supported: ["header"],
+    }));
+  });
+  function authServerMetadata(base) {
+    return {
+      issuer: `${base}/test`,
+      authorization_endpoint: `${base}/test/authorize`,
+      token_endpoint: `${base}/test/token`,
+      response_types_supported: ["code"],
+      grant_types_supported: ["authorization_code", "refresh_token"],
+      token_endpoint_auth_methods_supported: ["client_secret_post", "client_secret_basic"],
+      code_challenge_methods_supported: ["S256"],
+      scopes_supported: ["test:tools"],
+    };
+  }
+  function serveAuthServerMetadata(req, res) {
+    const base = ctx.oauthBase();
+    res.writeHead(200, { "Content-Type": "application/json", "Cache-Control": "no-store" });
+    return res.end(JSON.stringify(authServerMetadata(base)));
+  }
+  // Observed via live claude.ai request log (2026-08-31): it tries several
+  // conventional discovery URL shapes before falling back to guessing
+  // <origin>/authorize directly. RFC 8414's actual spec puts .well-known
+  // BEFORE the issuer's path (/.well-known/oauth-authorization-server/test),
+  // not after -- that was the original bug here. Serving every shape it was
+  // observed trying, rather than guessing which one it "should" use.
+  ctx.registerPatternRoute("GET", /^\/\.well-known\/oauth-authorization-server\/test$/, serveAuthServerMetadata);
+  ctx.registerPatternRoute("GET", /^\/\.well-known\/openid-configuration\/test$/, serveAuthServerMetadata);
+  ctx.registerPatternRoute("GET", /^\/test\/\.well-known\/openid-configuration$/, serveAuthServerMetadata);
+  ctx.registerPatternRoute("GET", /^\/test\/\.well-known\/oauth-authorization-server$/, serveAuthServerMetadata);
+
+  // ── Authorize — static client, auto-approve (test only), PKCE optional
+  // since this exists specifically to test claude.ai's own client behavior,
+  // not to enforce our own policy on it. ──
+  ctx.registerWriteRoute("GET", "/test/authorize", async (req, res, url) => {
+    const clientId = url.searchParams.get("client_id");
+    const redirectUri = url.searchParams.get("redirect_uri");
+    const state = url.searchParams.get("state");
+    if (clientId !== CLIENT_ID || !redirectUri || !ALLOWED_REDIRECT_URIS.includes(redirectUri)) {
+      res.writeHead(400, { "Content-Type": "text/plain" });
+      return res.end("invalid client_id or unregistered redirect_uri");
+    }
+    const code = crypto.randomBytes(24).toString("hex");
+    codes.set(code, { redirect_uri: redirectUri, expires: Date.now() + 300_000 });
+    const redirect = new URL(redirectUri);
+    redirect.searchParams.set("code", code);
+    if (state) redirect.searchParams.set("state", state);
+    log(`authorize -> code issued for client ${clientId}`);
+    res.writeHead(302, { Location: redirect.toString(), "Cache-Control": "no-store" });
+    return res.end();
+  });
+
+  // ── Token — authorization_code AND refresh_token grants ──
+  ctx.registerWriteRoute("POST", "/test/token", async (req, res) => {
+    const raw = await readRawBody(req);
+    const ct = req.headers["content-type"] || "";
+    const body = ct.includes("application/json") ? JSON.parse(raw || "{}") : Object.fromEntries(new URLSearchParams(raw));
+
+    // Client auth: client_secret_post (body) or client_secret_basic (header)
+    let clientId = body.client_id, clientSecret = body.client_secret;
+    const authHeader = req.headers.authorization;
+    if (!clientSecret && authHeader?.startsWith("Basic ")) {
+      const [u, p] = Buffer.from(authHeader.slice(6), "base64").toString().split(":");
+      clientId = clientId || u; clientSecret = p;
+    }
+    if (clientId !== CLIENT_ID || !safeEqual(clientSecret, CLIENT_SECRET)) {
+      log(`token: client auth failed (client_id=${clientId})`);
+      res.writeHead(401, { "Content-Type": "application/json" });
+      return res.end(JSON.stringify({ error: "invalid_client" }));
+    }
+
+    if (body.grant_type === "authorization_code") {
+      const stored = codes.get(body.code);
+      codes.delete(body.code);
+      if (!stored || stored.expires < Date.now() || stored.redirect_uri !== body.redirect_uri) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        return res.end(JSON.stringify({ error: "invalid_grant" }));
+      }
+      const pair = issueTokenPair();
+      log(`token: issued via authorization_code`);
+      res.writeHead(200, { "Content-Type": "application/json", "Cache-Control": "no-store" });
+      return res.end(JSON.stringify({ ...pair, token_type: "Bearer", scope: "test:tools", expires_in: ACCESS_TTL_MS / 1000 }));
+    }
+
+    if (body.grant_type === "refresh_token") {
+      const stored = refreshTokens.get(body.refresh_token);
+      if (!stored || stored.expires < Date.now()) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        return res.end(JSON.stringify({ error: "invalid_grant" }));
+      }
+      refreshTokens.delete(body.refresh_token); // rotate — old refresh token is one-time use
+      const pair = issueTokenPair();
+      log(`token: rotated via refresh_token`);
+      res.writeHead(200, { "Content-Type": "application/json", "Cache-Control": "no-store" });
+      return res.end(JSON.stringify({ ...pair, token_type: "Bearer", scope: "test:tools", expires_in: ACCESS_TTL_MS / 1000 }));
+    }
+
+    res.writeHead(400, { "Content-Type": "application/json" });
+    return res.end(JSON.stringify({ error: "unsupported_grant_type" }));
+  });
+
+  // ── MCP endpoint — self-contained, one dummy tool, no dependency on the
+  // real vault/tool surface. 401 gate mirrors the real transport's shape. ──
+  ctx.registerWriteRoute("POST", "/test/mcp", async (req, res) => {
+    const authHeader = req.headers.authorization;
+    const token = authHeader?.startsWith("Bearer ") ? authHeader.slice(7) : null;
+    const stored = token && accessTokens.get(token);
+    if (!stored || stored.expires < Date.now()) {
+      const base = ctx.oauthBase();
+      res.writeHead(401, {
+        "Content-Type": "application/json",
+        "WWW-Authenticate": `Bearer realm="test-MCP", resource_metadata="${base}/test/.well-known/oauth-protected-resource"`,
+        "Cache-Control": "no-store",
+      });
+      return res.end(JSON.stringify({ error: "unauthorized", error_description: "Bearer token required or expired" }));
+    }
+    let body;
+    try { body = JSON.parse(await readRawBody(req)); } catch {
+      res.writeHead(400, { "Content-Type": "application/json" });
+      return res.end(JSON.stringify({ error: "Invalid JSON" }));
+    }
+    const { id, method, params } = body;
+    if (method === "notifications/initialized" || method === "initialized") { res.writeHead(202); return res.end(); }
+    if (method === "initialize") {
+      return respond(res, req, { jsonrpc: "2.0", id, result: {
+        protocolVersion: "2025-03-26",
+        serverInfo: { name: "test-mcp", version: "0.1.0" },
+        capabilities: { tools: { listChanged: true } },
+      } });
+    }
+    if (method === "tools/list") {
+      return respond(res, req, { jsonrpc: "2.0", id, result: { tools: [{
+        name: "test_ping",
+        description: "Returns a fixed value — used only to confirm the static-client OAuth token grants tool access.",
+        inputSchema: { type: "object", properties: {} },
+      }] } });
+    }
+    if (method === "tools/call" && params?.name === "test_ping") {
+      log(`tools/call test_ping invoked`);
+      return respond(res, req, { jsonrpc: "2.0", id, result: { content: [{ type: "text", text: "pong from test-mcp" }] } });
+    }
+    return respond(res, req, { jsonrpc: "2.0", id, error: { code: -32601, message: `Unknown method: ${method}` } });
+  });
+
+  function respond(res, req, payload) {
+    if ((req.headers.accept || "").includes("text/event-stream")) {
+      const buf = Buffer.from(`event: message\ndata: ${JSON.stringify(payload)}\n\n`, "utf8");
+      res.writeHead(200, { "Content-Type": "text/event-stream", "Content-Length": buf.length, "Cache-Control": "no-cache" });
+      return res.end(buf);
+    }
+    res.writeHead(200, { "Content-Type": "application/json" });
+    return res.end(JSON.stringify(payload));
+  }
+}

package/cli/index.js

@@ -150,7 +150,7 @@ import { runInstall } from './commands/install.js';
 import { runUninstall } from './commands/uninstall.js';
 import { runScrub } from './commands/scrub.js';
 import { runServe, MCP_TOOLS } from './commands/serve.js';
-import { deregisterPlugin, listPlugins, registerPlugin, syncPluginsFromRepos, SYNC_REPO_NAMES, SYNC_SKIP_STATES } from './supervisor-registry.js';
+import { deregisterPlugin, isMcpServerPlugin, listPlugins, registerPlugin, syncPluginsFromRepos, SYNC_REPO_NAMES, SYNC_SKIP_STATES } from './supervisor-registry.js';
 import { runOps } from './commands/ops.js';
 import { runOpsInstall } from './commands/ops-install.js';
 import { runNpm, runPublish } from './commands/npm.js';
@@ -927,20 +927,6 @@ tunnelCmd
 // ──────────────────────────────────────────────
 // clauth mcp list
 // ──────────────────────────────────────────────
-// Known MCP-server plugin ids in the managed fleet. Positive allowlist
-// rather than a naming heuristic (credential-name conventions and health
-// route "kind" vary across these) — dev-center and any future non-MCP
-// pm2-managed surface stay excluded by construction. Deliberately distinct
-// from `clauth list` (vault credential services); this never touches those.
-const MCP_SERVER_PLUGIN_IDS = new Set([
-  "fs-mcp",
-  "web-research",
-  "regen-media",
-  "regen-media-local",
-  "codeflow-mcp",
-  "rdc-skills",
-]);
-
 const mcpCmd = program.command("mcp").description("Inspect clauth's own MCP tool catalog and managed MCP-server surfaces");
 
 mcpCmd
@@ -951,7 +937,7 @@ mcpCmd
     for (const tool of MCP_TOOLS) {
       console.log(`  ${chalk.white(tool.name)}  ${chalk.gray(tool.description || "")}`);
     }
-    const mcpPlugins = listPlugins().filter((p) => MCP_SERVER_PLUGIN_IDS.has(p.id));
+    const mcpPlugins = listPlugins().filter(isMcpServerPlugin);
     console.log(chalk.cyan(`\n  Managed MCP-server surfaces (${mcpPlugins.length}):\n`));
     if (!mcpPlugins.length) {
       console.log(chalk.gray("  none discovered — is the daemon running? clauth serve"));
@@ -1047,10 +1033,16 @@ pluginCmd
   .command('deregister <id>')
   .description('Remove one managed plugin directory by id and re-run discovery. Removing an unregistered id is a safe no-op.')
   .option('--dry-run', 'Resolve and print the directory that would be deleted, without deleting it')
+  .option('--expected-root <path>', 'Refuse unless the registered plugin originated from this package root')
+  .option('--force', 'Recovery only: remove managed metadata even when process cleanup fails; receipt records the bypass')
   .action((id, opts) => {
     let receipt;
     try {
-      receipt = deregisterPlugin(id, 'cli', { dryRun: Boolean(opts.dryRun) });
+      receipt = deregisterPlugin(id, 'cli', {
+        dryRun: Boolean(opts.dryRun),
+        expectedRoot: opts.expectedRoot,
+        force: Boolean(opts.force),
+      });
     } catch (error) {
       console.error(`  ✗ deregister_failed: ${error instanceof Error ? error.message : String(error)}`);
       process.exitCode = 1;

package/cli/services/file-io.js

@@ -4,6 +4,7 @@
 // git-exec.js/fs-upload-sessions.js — these are file-content concerns, not
 // mount-resolution concerns.
 
+import fsSync from "node:fs";
 import path from "node:path";
 import crypto from "node:crypto";
 import { mkdir, writeFile, rename, stat, readFile } from "node:fs/promises";
@@ -12,16 +13,33 @@ export function sha256Hex(value) {
   return crypto.createHash("sha256").update(value).digest("hex");
 }
 
-export async function atomicWriteText(filePath, content) {
-  await mkdir(path.dirname(filePath), { recursive: true });
-  const tempPath = path.join(
+function atomicTempPath(filePath) {
+  return path.join(
     path.dirname(filePath),
     `.${path.basename(filePath)}.tmp-${process.pid}-${Date.now()}-${crypto.randomBytes(4).toString("hex")}`
   );
+}
+
+export async function atomicWriteText(filePath, content) {
+  await mkdir(path.dirname(filePath), { recursive: true });
+  const tempPath = atomicTempPath(filePath);
   await writeFile(tempPath, content, "utf8");
   await rename(tempPath, filePath);
 }
 
+// Sync twin of atomicWriteText -- same mkdir+temp+write+rename contract, for
+// callers that can't be async (e.g. cli/supervisor-registry.js's mutators,
+// all currently synchronous). Identified as a needed pairing rather than a
+// fourth independent reimplementation of this pattern (also hand-rolled in
+// cli/ops/job-store.js and standalone/fs-mcp/lib/webdav-config.js) by a peer
+// review of the commit that first needed it.
+export function atomicWriteTextSync(filePath, content) {
+  fsSync.mkdirSync(path.dirname(filePath), { recursive: true });
+  const tempPath = atomicTempPath(filePath);
+  fsSync.writeFileSync(tempPath, content, "utf8");
+  fsSync.renameSync(tempPath, filePath);
+}
+
 export async function fileInfo(filePath, requestedPath) {
   const s = await stat(filePath);
   const info = {

package/cli/services/file-io.test.js

@@ -1,10 +1,42 @@
 import test from "node:test";
 import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
 
-import { sha256Hex } from "./file-io.js";
+import { sha256Hex, atomicWriteTextSync } from "./file-io.js";
 
 test("sha256Hex hashes deterministically", () => {
   assert.equal(sha256Hex("hello"), sha256Hex("hello"));
   assert.notEqual(sha256Hex("hello"), sha256Hex("world"));
   assert.match(sha256Hex("hello"), /^[0-9a-f]{64}$/);
 });
+
+// atomicWriteTextSync is the sync twin of atomicWriteText, added so
+// cli/supervisor-registry.js's (synchronous) writeJson could reuse this
+// module's atomic-write contract instead of hand-rolling a fourth
+// independent copy of it (peer-review finding, 2026-09-02).
+test("atomicWriteTextSync creates the target file with the given content, creating parent dirs as needed", () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "clauth-atomic-write-"));
+  try {
+    const target = path.join(root, "nested", "dir", "file.txt");
+    atomicWriteTextSync(target, "hello world");
+    assert.equal(fs.readFileSync(target, "utf8"), "hello world");
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("atomicWriteTextSync replaces existing content and leaves no temp file behind", () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "clauth-atomic-write-"));
+  try {
+    const target = path.join(root, "file.txt");
+    atomicWriteTextSync(target, "first");
+    atomicWriteTextSync(target, "second");
+    assert.equal(fs.readFileSync(target, "utf8"), "second");
+    const leftovers = fs.readdirSync(root).filter((name) => name !== "file.txt");
+    assert.deepEqual(leftovers, [], `expected no stray temp files, found: ${JSON.stringify(leftovers)}`);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});