chainlesschain 0.162.34 → 0.162.36

package/src/lib/image-input.js

@@ -0,0 +1,156 @@
+/**
+ * image-input — multimodal (vision) input for `cc agent`.
+ *
+ * cc's internal message format is OpenAI-shaped, so the internal multimodal
+ * representation is OpenAI's: a user message whose `content` is an array of
+ * `{type:"text"}` / `{type:"image_url", image_url:{url:"data:<media>;base64,..."}}`
+ * parts. The OpenAI-compatible providers (openai/volcengine/deepseek/…) accept
+ * that verbatim, so their branch needs no conversion. ollama and anthropic use
+ * different shapes — `toOllamaMessages` and `imageUrlBlockToAnthropic` convert.
+ *
+ * All functions are pure (except `resolveImages`, which reads files via the
+ * injectable `_deps.fs`).
+ */
+
+import fs from "fs";
+import path from "path";
+
+const EXT_MEDIA = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+};
+
+/**
+ * Read `--image <path>` values into `[{ mediaType, data(base64) }]`.
+ * Throws on an unsupported extension so a typo fails loudly instead of sending
+ * a broken request.
+ */
+export function resolveImages(paths, deps = {}) {
+  const _fs = deps.fs || fs;
+  if (!Array.isArray(paths) || paths.length === 0) return [];
+  return paths.map((p) => {
+    const ext = path.extname(String(p)).toLowerCase();
+    const mediaType = EXT_MEDIA[ext];
+    if (!mediaType) {
+      throw new Error(
+        `Unsupported image type "${ext || p}" — use png/jpg/jpeg/gif/webp.`,
+      );
+    }
+    const data = _fs.readFileSync(p).toString("base64");
+    return { mediaType, data };
+  });
+}
+
+/**
+ * Build a user-message `content`: the plain string when there are no images,
+ * else an OpenAI-style multimodal array (the internal representation).
+ */
+export function buildUserContent(text, images) {
+  if (!Array.isArray(images) || images.length === 0) return text;
+  const parts = [];
+  if (text) parts.push({ type: "text", text });
+  for (const img of images) {
+    parts.push({
+      type: "image_url",
+      image_url: { url: `data:${img.mediaType};base64,${img.data}` },
+    });
+  }
+  return parts;
+}
+
+/** Parse a `data:<media>;base64,<data>` URL into `{ mediaType, data }` or null. */
+export function parseDataUrl(url) {
+  const m = /^data:([^;,]+);base64,(.*)$/s.exec(String(url || ""));
+  return m ? { mediaType: m[1], data: m[2] } : null;
+}
+
+/** True when a message carries any image_url part (i.e. needs provider conversion). */
+export function hasImageContent(messages) {
+  return (messages || []).some(
+    (m) =>
+      Array.isArray(m?.content) &&
+      m.content.some((p) => p?.type === "image_url"),
+  );
+}
+
+/**
+ * Convert OpenAI-shaped multimodal messages for the ollama `/api/chat` body:
+ * ollama wants `{ content: "<text>", images: ["<base64>", …] }` (bare base64,
+ * no `data:` prefix). Non-multimodal messages pass through untouched.
+ */
+export function toOllamaMessages(messages) {
+  return (messages || []).map((m) => {
+    if (!m || !Array.isArray(m.content)) return m;
+    let text = "";
+    const images = [];
+    for (const part of m.content) {
+      if (part?.type === "text") {
+        text += (text ? "\n" : "") + (part.text || "");
+      } else if (part?.type === "image_url") {
+        const parsed = parseDataUrl(part.image_url?.url);
+        if (parsed) images.push(parsed.data);
+        else if (part.image_url?.url) images.push(part.image_url.url);
+      }
+    }
+    const out = { ...m, content: text };
+    if (images.length) out.images = images;
+    return out;
+  });
+}
+
+/**
+ * Convert one OpenAI `image_url` content block into an Anthropic `image` block,
+ * or null when it isn't an image_url block / has no usable data URL.
+ */
+export function imageUrlBlockToAnthropic(block) {
+  if (!block || block.type !== "image_url") return null;
+  const parsed = parseDataUrl(block.image_url?.url);
+  if (!parsed) return null;
+  return {
+    type: "image",
+    source: { type: "base64", media_type: parsed.mediaType, data: parsed.data },
+  };
+}
+
+/** Default vision model (Volcengine Ark Doubao-Seed-1.6 Vision) when none configured. */
+export const DEFAULT_VISION_MODEL = "doubao-seed-1-6-vision-250815";
+
+/**
+ * Resolve the effective LLM config for a run. When an image is attached, default
+ * the provider/model/baseUrl/apiKey to the configured vision LLM so
+ * `cc agent --image foo.png` works without extra flags — using `llm.visionModel`
+ * (a separate, configurable vision model) and falling back to DEFAULT_VISION_MODEL.
+ * Explicit flags always win; with no image, behaviour is unchanged (vision config
+ * is ignored). `--vision-model` overrides the configured/default vision model.
+ *
+ * @param {object} p
+ * @param {boolean} p.hasImage  true when the run carries an attached image
+ * @param {object}  p.flags     { provider, model, baseUrl, apiKey, visionModel }
+ * @param {object}  p.llm       config.llm ({ provider, model, baseUrl, apiKey, visionModel })
+ * @returns {{provider, model, baseUrl, apiKey}}
+ */
+export function resolveVisionLlm({ hasImage, flags = {}, llm = {} } = {}) {
+  // No image → no vision override; the caller falls back to its normal LLM
+  // config (`visionLlm.x || options.x`).
+  if (!hasImage) {
+    return {
+      provider: undefined,
+      model: undefined,
+      baseUrl: undefined,
+      apiKey: undefined,
+    };
+  }
+  const visionModel =
+    flags.visionModel || llm.visionModel || DEFAULT_VISION_MODEL;
+  // `flags.model` must be the EXPLICIT `--model` (not a settings/default), so an
+  // attached image uses the vision model unless the user deliberately picked one.
+  return {
+    provider: flags.provider || llm.provider,
+    model: flags.model || visionModel,
+    baseUrl: flags.baseUrl || llm.baseUrl,
+    apiKey: flags.apiKey || llm.apiKey,
+  };
+}

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,
+    },
+  });
+}