chainlesschain 0.162.35 → 0.162.37

package/src/lib/mcp-oauth.js

@@ -0,0 +1,415 @@
+/**
+ * mcp-oauth — OAuth 2.0 (Authorization Code + PKCE) for remote MCP servers,
+ * Claude-Code parity. A remote HTTP/SSE MCP server that requires OAuth is
+ * authorized once via `cc mcp login <url>`; the access token is stored and
+ * injected as `Authorization: Bearer …` on every connect (refreshed when it
+ * expires). Static `-H "Authorization: Bearer …"` headers still work for
+ * servers where you already hold a token.
+ *
+ * The flow (RFC 8414 metadata discovery + RFC 7591 dynamic registration +
+ * RFC 7636 PKCE):
+ *   1. discover the protected-resource / authorization-server metadata;
+ *   2. register a public client (or use a configured client_id);
+ *   3. open the browser to the authorize URL, catch the code on a localhost
+ *      callback, exchange it (with the PKCE verifier) for tokens;
+ *   4. persist { access_token, refresh_token, expires_at, client_id, endpoints }.
+ *
+ * The pure pieces (PKCE, discovery, URL building, token exchange, the store)
+ * are `_deps`-injected (fetch / fs / homedir / crypto / http / spawn) so they
+ * unit-test without a network, browser, or real OAuth server. The interactive
+ * `authorizeInteractive` orchestrator is the thin glue over them.
+ */
+
+import fsDefault from "node:fs";
+import pathDefault from "node:path";
+import { homedir as homedirDefault } from "node:os";
+import crypto from "node:crypto";
+import http from "node:http";
+import { spawn } from "node:child_process";
+
+export const _deps = {
+  fetch: (...a) => globalThis.fetch(...a),
+  fs: fsDefault,
+  homedir: homedirDefault,
+  randomBytes: (n) => crypto.randomBytes(n),
+  sha256: (s) => crypto.createHash("sha256").update(s).digest(),
+  createServer: (h) => http.createServer(h),
+  openBrowser: defaultOpenBrowser,
+  now: () => Date.now(),
+};
+
+const base64url = (buf) =>
+  Buffer.from(buf).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+
+/** RFC 7636 PKCE pair (S256). */
+export function generatePkce() {
+  const verifier = base64url(_deps.randomBytes(32));
+  const challenge = base64url(_deps.sha256(verifier));
+  return { verifier, challenge, method: "S256" };
+}
+
+/** A random URL-safe state / nonce. */
+export function randomState(bytes = 16) {
+  return base64url(_deps.randomBytes(bytes));
+}
+
+async function fetchJson(url, opts) {
+  const res = await _deps.fetch(url, opts);
+  if (!res || !res.ok) {
+    const status = res ? res.status : "no-response";
+    let body = "";
+    try {
+      body = res ? await res.text() : "";
+    } catch {
+      /* ignore */
+    }
+    const err = new Error(`HTTP ${status}${body ? `: ${body.slice(0, 200)}` : ""}`);
+    err.status = res ? res.status : null;
+    throw err;
+  }
+  return res.json();
+}
+
+/**
+ * Discover the authorization-server metadata for a remote MCP server. Tries the
+ * protected-resource doc first (which points at its authorization server), then
+ * the authorization-server doc directly at the origin.
+ * @returns {Promise<{issuer?,authorization_endpoint,token_endpoint,registration_endpoint?,scopes_supported?}>}
+ */
+export async function discoverAuthMetadata(serverUrl, { resourceMetadataUrl } = {}) {
+  const origin = new URL(serverUrl).origin;
+  // 1. protected-resource metadata (RFC 9728) → authorization_servers[]
+  let authServer = origin;
+  try {
+    const prUrl =
+      resourceMetadataUrl || `${origin}/.well-known/oauth-protected-resource`;
+    const pr = await fetchJson(prUrl);
+    if (Array.isArray(pr.authorization_servers) && pr.authorization_servers[0]) {
+      authServer = String(pr.authorization_servers[0]).replace(/\/$/, "");
+    }
+  } catch {
+    // no protected-resource doc → assume the origin is its own auth server
+  }
+  // 2. authorization-server metadata (RFC 8414)
+  const candidates = [
+    `${authServer}/.well-known/oauth-authorization-server`,
+    `${authServer}/.well-known/openid-configuration`,
+  ];
+  let lastErr = null;
+  for (const url of candidates) {
+    try {
+      const md = await fetchJson(url);
+      if (md && md.authorization_endpoint && md.token_endpoint) {
+        return {
+          issuer: md.issuer || authServer,
+          authorization_endpoint: md.authorization_endpoint,
+          token_endpoint: md.token_endpoint,
+          registration_endpoint: md.registration_endpoint || null,
+          scopes_supported: md.scopes_supported || null,
+        };
+      }
+    } catch (err) {
+      lastErr = err;
+    }
+  }
+  throw new Error(
+    `could not discover OAuth metadata for ${serverUrl}${lastErr ? ` (${lastErr.message})` : ""}`,
+  );
+}
+
+/** RFC 7591 dynamic client registration → client_id (public client). */
+export async function registerClient(metadata, { redirectUri, clientName = "chainlesschain-cli" } = {}) {
+  if (!metadata.registration_endpoint) {
+    throw new Error("server has no registration_endpoint and no --client-id was given");
+  }
+  const reg = await fetchJson(metadata.registration_endpoint, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      client_name: clientName,
+      redirect_uris: [redirectUri],
+      grant_types: ["authorization_code", "refresh_token"],
+      response_types: ["code"],
+      token_endpoint_auth_method: "none",
+    }),
+  });
+  if (!reg.client_id) throw new Error("registration did not return a client_id");
+  return { clientId: reg.client_id, clientSecret: reg.client_secret || null };
+}
+
+/** Build the authorize URL (Authorization Code + PKCE). */
+export function buildAuthorizeUrl(metadata, { clientId, redirectUri, scope, codeChallenge, state, resource }) {
+  const u = new URL(metadata.authorization_endpoint);
+  u.searchParams.set("response_type", "code");
+  u.searchParams.set("client_id", clientId);
+  u.searchParams.set("redirect_uri", redirectUri);
+  u.searchParams.set("code_challenge", codeChallenge);
+  u.searchParams.set("code_challenge_method", "S256");
+  u.searchParams.set("state", state);
+  if (scope) u.searchParams.set("scope", scope);
+  if (resource) u.searchParams.set("resource", resource);
+  return u.toString();
+}
+
+function _tokenExpiresAt(tok) {
+  const ttl = Number(tok.expires_in);
+  return Number.isFinite(ttl) && ttl > 0 ? _deps.now() + ttl * 1000 : null;
+}
+
+/** Exchange an authorization code for tokens. */
+export async function exchangeCodeForToken(metadata, { code, codeVerifier, clientId, clientSecret, redirectUri, resource }) {
+  const body = new URLSearchParams({
+    grant_type: "authorization_code",
+    code,
+    redirect_uri: redirectUri,
+    client_id: clientId,
+    code_verifier: codeVerifier,
+  });
+  if (clientSecret) body.set("client_secret", clientSecret);
+  if (resource) body.set("resource", resource);
+  const tok = await fetchJson(metadata.token_endpoint, {
+    method: "POST",
+    headers: { "content-type": "application/x-www-form-urlencoded" },
+    body: body.toString(),
+  });
+  return {
+    access_token: tok.access_token,
+    refresh_token: tok.refresh_token || null,
+    token_type: tok.token_type || "Bearer",
+    expires_at: _tokenExpiresAt(tok),
+    scope: tok.scope || undefined,
+  };
+}
+
+/** Refresh an access token. */
+export async function refreshAccessToken(metadata, { refreshToken, clientId, clientSecret, resource }) {
+  const body = new URLSearchParams({
+    grant_type: "refresh_token",
+    refresh_token: refreshToken,
+    client_id: clientId,
+  });
+  if (clientSecret) body.set("client_secret", clientSecret);
+  if (resource) body.set("resource", resource);
+  const tok = await fetchJson(metadata.token_endpoint, {
+    method: "POST",
+    headers: { "content-type": "application/x-www-form-urlencoded" },
+    body: body.toString(),
+  });
+  return {
+    access_token: tok.access_token,
+    refresh_token: tok.refresh_token || refreshToken,
+    token_type: tok.token_type || "Bearer",
+    expires_at: _tokenExpiresAt(tok),
+  };
+}
+
+// ── token store (~/.chainlesschain/mcp-oauth.json) ────────────────────────
+
+/** Stable key for a server (origin) so http/https/path variants share a token. */
+export function serverKey(serverUrl) {
+  try {
+    return new URL(serverUrl).origin;
+  } catch {
+    return String(serverUrl || "").trim();
+  }
+}
+
+export function tokenStorePath() {
+  return pathDefault.join(_deps.homedir(), ".chainlesschain", "mcp-oauth.json");
+}
+
+export function loadTokenStore() {
+  const file = tokenStorePath();
+  try {
+    if (!_deps.fs.existsSync(file)) return {};
+    const data = JSON.parse(_deps.fs.readFileSync(file, "utf-8"));
+    return data && typeof data === "object" ? data : {};
+  } catch {
+    return {};
+  }
+}
+
+export function getStoredToken(serverUrl) {
+  return loadTokenStore()[serverKey(serverUrl)] || null;
+}
+
+export function saveStoredToken(serverUrl, record) {
+  const file = tokenStorePath();
+  const store = loadTokenStore();
+  store[serverKey(serverUrl)] = { server: serverKey(serverUrl), ...record };
+  _deps.fs.mkdirSync(pathDefault.dirname(file), { recursive: true });
+  _deps.fs.writeFileSync(file, JSON.stringify(store, null, 2) + "\n", "utf-8");
+  return store[serverKey(serverUrl)];
+}
+
+export function deleteStoredToken(serverUrl) {
+  const file = tokenStorePath();
+  const store = loadTokenStore();
+  const key = serverKey(serverUrl);
+  if (!(key in store)) return false;
+  delete store[key];
+  try {
+    _deps.fs.writeFileSync(file, JSON.stringify(store, null, 2) + "\n", "utf-8");
+  } catch {
+    /* best-effort */
+  }
+  return true;
+}
+
+/** True when a record's access token is missing or within `skewMs` of expiry. */
+export function isTokenExpired(record, { skewMs = 60_000 } = {}) {
+  if (!record || !record.access_token) return true;
+  if (!record.expires_at) return false; // no expiry info → assume valid
+  return _deps.now() >= record.expires_at - skewMs;
+}
+
+/**
+ * Return a valid bearer token for a server, refreshing if expired. Returns the
+ * access_token string, or null if there's no stored token / refresh failed.
+ */
+export async function ensureValidToken(serverUrl) {
+  const record = getStoredToken(serverUrl);
+  if (!record) return null;
+  if (!isTokenExpired(record)) return record.access_token;
+  if (!record.refresh_token || !record.endpoints?.token_endpoint) {
+    return record.access_token || null; // can't refresh → use what we have
+  }
+  try {
+    const tok = await refreshAccessToken(
+      { token_endpoint: record.endpoints.token_endpoint },
+      { refreshToken: record.refresh_token, clientId: record.client_id },
+    );
+    const updated = saveStoredToken(serverUrl, { ...record, ...tok });
+    return updated.access_token;
+  } catch {
+    return record.access_token || null;
+  }
+}
+
+// ── interactive orchestrator ──────────────────────────────────────────────
+
+function defaultOpenBrowser(url) {
+  const platform = process.platform;
+  const cmd =
+    platform === "win32" ? "cmd" : platform === "darwin" ? "open" : "xdg-open";
+  const args =
+    platform === "win32" ? ["/c", "start", "", url] : [url];
+  try {
+    const child = spawn(cmd, args, { stdio: "ignore", detached: true });
+    child.unref?.();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** Wait for the OAuth redirect on a localhost callback server; resolve {code,state}. */
+function waitForCallback({ port, host = "127.0.0.1", path = "/callback", timeout = 300_000 }) {
+  return new Promise((resolve, reject) => {
+    const server = _deps.createServer((req, res) => {
+      let u;
+      try {
+        u = new URL(req.url, `http://${host}:${port}`);
+      } catch {
+        res.writeHead(400);
+        res.end("bad request");
+        return;
+      }
+      if (u.pathname !== path) {
+        res.writeHead(404);
+        res.end("not found");
+        return;
+      }
+      const code = u.searchParams.get("code");
+      const state = u.searchParams.get("state");
+      const error = u.searchParams.get("error");
+      res.writeHead(200, { "content-type": "text/html" });
+      res.end(
+        `<html><body style="font-family:sans-serif"><h3>${error ? "Authorization failed" : "Authorized — you can close this tab."}</h3></body></html>`,
+      );
+      server.close();
+      clearTimeout(timer);
+      if (error) reject(new Error(`authorization error: ${error}`));
+      else if (!code) reject(new Error("no authorization code in callback"));
+      else resolve({ code, state });
+    });
+    const timer = setTimeout(() => {
+      server.close();
+      reject(new Error("timed out waiting for the OAuth callback"));
+    }, timeout);
+    server.on("error", reject);
+    server.listen(port, host);
+  });
+}
+
+/**
+ * Run the full interactive Authorization Code + PKCE flow and persist the token.
+ *
+ * @param {string} serverUrl
+ * @param {object} [opts] { scope, clientId, port=53682, host, redirectPath,
+ *                          timeout, writeOut }
+ * @returns {Promise<{server, access_token, ...}>}  the stored record
+ */
+export async function authorizeInteractive(serverUrl, opts = {}) {
+  const {
+    scope,
+    clientId: cfgClientId,
+    port = 53682,
+    host = "127.0.0.1",
+    redirectPath = "/callback",
+    timeout = 300_000,
+    writeOut = (s) => process.stdout.write(s),
+  } = opts;
+
+  const metadata = await discoverAuthMetadata(serverUrl);
+  const redirectUri = `http://${host}:${port}${redirectPath}`;
+
+  let clientId = cfgClientId;
+  let clientSecret = null;
+  if (!clientId) {
+    const reg = await registerClient(metadata, { redirectUri });
+    clientId = reg.clientId;
+    clientSecret = reg.clientSecret;
+  }
+
+  const pkce = generatePkce();
+  const state = randomState();
+  const authorizeUrl = buildAuthorizeUrl(metadata, {
+    clientId,
+    redirectUri,
+    scope: scope || (metadata.scopes_supported ? metadata.scopes_supported.join(" ") : undefined),
+    codeChallenge: pkce.challenge,
+    state,
+    resource: serverUrl,
+  });
+
+  const callbackPromise = waitForCallback({ port, host, path: redirectPath, timeout });
+  const opened = _deps.openBrowser(authorizeUrl);
+  writeOut(
+    (opened
+      ? "Opened your browser to authorize.\n"
+      : "Open this URL in your browser to authorize:\n") +
+      `  ${authorizeUrl}\n`,
+  );
+
+  const { code, state: returnedState } = await callbackPromise;
+  if (returnedState !== state) throw new Error("OAuth state mismatch (possible CSRF)");
+
+  const tok = await exchangeCodeForToken(metadata, {
+    code,
+    codeVerifier: pkce.verifier,
+    clientId,
+    clientSecret,
+    redirectUri,
+    resource: serverUrl,
+  });
+
+  return saveStoredToken(serverUrl, {
+    ...tok,
+    client_id: clientId,
+    endpoints: {
+      authorization_endpoint: metadata.authorization_endpoint,
+      token_endpoint: metadata.token_endpoint,
+    },
+  });
+}

package/src/lib/output-styles.js

@@ -0,0 +1,179 @@
+/**
+ * output-styles — Claude-Code `/output-style` parity. A named, reusable persona
+ * layered onto the agent's system prompt, so `cc agent` can act as a different
+ * kind of assistant while keeping its core coding capabilities.
+ *
+ * Styles are markdown files with frontmatter (`name`, `description`); the body
+ * is appended to the system prompt (after the base + `--append-system-prompt`).
+ * Discovered from `.chainlesschain/output-styles/` and `.claude/output-styles/`
+ * (project) + `~/.claude/output-styles/` (personal); a couple of built-ins ship
+ * so it works with no files. The active style comes from `--output-style`, then
+ * the `outputStyle` field in `.claude/settings.json`.
+ *
+ * Pure + zero-dep frontmatter parse (mirrors slash-commands — no js-yaml).
+ * `_deps` injection (fs / homedir) for tests.
+ */
+
+import fsDefault from "node:fs";
+import pathDefault from "node:path";
+import { homedir as homedirDefault } from "node:os";
+
+export const _deps = {
+  fs: fsDefault,
+  path: pathDefault,
+  homedir: homedirDefault,
+};
+
+/** Built-in styles (shadowed by a same-named file). `default` = no-op. */
+export const BUILTIN_OUTPUT_STYLES = Object.freeze({
+  default: {
+    name: "default",
+    description: "Standard coding assistant (no persona overlay).",
+    body: "",
+    builtin: true,
+  },
+  explanatory: {
+    name: "explanatory",
+    description: "Explains the reasoning and trade-offs behind changes.",
+    body: [
+      "## Output style: Explanatory",
+      "As you work, weave in brief `★ Insight` notes that explain *why* you chose",
+      "an approach and any non-obvious trade-offs, so the user learns from the",
+      "changes. Keep insights short (1–2 sentences) and tied to what you just did;",
+      "do not pad routine steps.",
+    ].join("\n"),
+    builtin: true,
+  },
+  learning: {
+    name: "learning",
+    description: "Collaborative — leaves small instructive pieces for the user.",
+    body: [
+      "## Output style: Learning",
+      "Work collaboratively. When a small, well-scoped piece of the task would be",
+      "instructive for the user to write themselves, pause and insert a",
+      "`TODO(you):` marker with a one-line explanation of what to do and why,",
+      "instead of writing that piece — then continue with the rest. Reserve this",
+      "for genuinely educational spots, not boilerplate.",
+    ].join("\n"),
+    builtin: true,
+  },
+});
+
+/** Parse `--- ... ---` frontmatter (zero-dep, camelCases keys). */
+function parseFrontmatter(content) {
+  const text = String(content || "");
+  const m = text.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+  if (!m) return { data: {}, body: text.trim() };
+  const data = {};
+  for (const line of m[1].split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const colon = trimmed.indexOf(":");
+    if (colon <= 0) continue;
+    const key = trimmed.slice(0, colon).trim();
+    let value = trimmed.slice(colon + 1).trim();
+    value = value.replace(/^(['"])([\s\S]*)\1$/, "$2");
+    const camel = key.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+    data[camel] = value;
+  }
+  return { data, body: (m[2] || "").trim() };
+}
+
+/** Directories scanned for style files (project first, then personal). */
+function styleDirs(cwd, home) {
+  const { path } = _deps;
+  return [
+    { dir: path.join(cwd, ".chainlesschain", "output-styles"), scope: "project" },
+    { dir: path.join(cwd, ".claude", "output-styles"), scope: "project" },
+    { dir: path.join(home, ".claude", "output-styles"), scope: "personal" },
+  ];
+}
+
+/** Discover all styles: built-ins + files (a file shadows a built-in by name). */
+export function discoverOutputStyles(cwd = process.cwd(), opts = {}) {
+  const { fs, path } = _deps;
+  const home = opts.home || _deps.homedir();
+  const byName = new Map();
+  for (const b of Object.values(BUILTIN_OUTPUT_STYLES)) {
+    byName.set(b.name, { ...b });
+  }
+  // Files win over built-ins; project wins over personal (scan personal first).
+  for (const { dir, scope } of styleDirs(cwd, home).reverse()) {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const e of entries) {
+      if (!e.isFile() || !e.name.endsWith(".md")) continue;
+      const file = path.join(dir, e.name);
+      let content;
+      try {
+        content = fs.readFileSync(file, "utf-8");
+      } catch {
+        continue;
+      }
+      const { data, body } = parseFrontmatter(content);
+      const name = (data.name || e.name.replace(/\.md$/, "")).trim();
+      if (!name) continue;
+      byName.set(name, {
+        name,
+        description: data.description || "",
+        body,
+        scope,
+        file,
+        builtin: false,
+      });
+    }
+  }
+  return [...byName.values()];
+}
+
+/** Get one style by name (case-insensitive), or null. */
+export function getOutputStyle(name, cwd = process.cwd(), opts = {}) {
+  if (!name) return null;
+  const target = String(name).trim().toLowerCase();
+  return (
+    discoverOutputStyles(cwd, opts).find(
+      (s) => s.name.toLowerCase() === target,
+    ) || null
+  );
+}
+
+/** Read the `outputStyle` default from the settings.json hierarchy (last wins). */
+export function settingsDefaultOutputStyle(cwd = process.cwd(), opts = {}) {
+  const { fs, path } = _deps;
+  const home = opts.home || _deps.homedir();
+  const files = [
+    path.join(home, ".claude", "settings.json"),
+    path.join(cwd, ".claude", "settings.json"),
+    path.join(cwd, ".claude", "settings.local.json"),
+  ];
+  let value = null;
+  for (const f of files) {
+    try {
+      if (!fs.existsSync(f)) continue;
+      const data = JSON.parse(fs.readFileSync(f, "utf-8"));
+      if (data && typeof data.outputStyle === "string" && data.outputStyle.trim()) {
+        value = data.outputStyle.trim();
+      }
+    } catch {
+      // ignore malformed
+    }
+  }
+  return value;
+}
+
+/**
+ * Resolve the active style's body to append to the system prompt.
+ * Precedence: explicit name → settings.json `outputStyle` → none.
+ * Returns `{ name, body }` (body may be "" for `default`) or null if unresolved.
+ */
+export function resolveOutputStyle(explicitName, cwd = process.cwd(), opts = {}) {
+  const name = (explicitName || settingsDefaultOutputStyle(cwd, opts) || "").trim();
+  if (!name) return null;
+  const style = getOutputStyle(name, cwd, opts);
+  if (!style) return { name, body: "", missing: true };
+  return { name: style.name, body: style.body || "" };
+}