chainlesschain 0.162.188 → 0.162.193

package/src/repl/btw-command.js

@@ -1,30 +1,113 @@
 /**
- * Pure helpers for the REPL `/btw` aside (Claude-Code parity, one-shot variant).
+ * Pure helpers for ephemeral REPL side questions.
  *
- * `/btw <note>` queues a side note that rides ONLY the next message: it is sent
- * to the model for that one turn (so it can steer the answer) and then removed,
- * so it is never persisted to the session history and never carried into later
- * turns — i.e. context without bloat. vscode/readline-free → unit-testable; the
- * REPL owns the queue + the inject/restore around the agentLoop call.
+ * `/btw <question>` immediately asks a tool-free, single-response question
+ * against a snapshot of the current conversation. The snapshot and answer are
+ * never added to the parent conversation. `/btw --fork <question>` persists the
+ * side thread into an independent child session when the caller has a durable
+ * session store.
  *
- *   /btw I'm on Windows, use PowerShell   → queued, applied to the next turn only
- *   /btw                                  → usage error (nothing queued)
+ * The former "inject a note into the next turn" behavior remains available as
+ * `/note-next <note>` so `/btw` can keep the same contract as Claude Code.
  */
 
 /** Parse a `/btw …` line. Returns { text } | { error } | null (not a /btw). */
 export function parseBtwCommand(trimmed) {
   const t = String(trimmed == null ? "" : trimmed).trim();
   if (t !== "/btw" && !t.startsWith("/btw ")) return null;
-  const text = t.slice("/btw".length).trim();
+  let text = t.slice("/btw".length).trim();
+  let fork = false;
+  if (text === "--fork" || text.startsWith("--fork ")) {
+    fork = true;
+    text = text.slice("--fork".length).trim();
+  }
+  if (!text) {
+    return {
+      error:
+        "usage: /btw [--fork] <question> — ask an immediate tool-free side question without changing parent history",
+    };
+  }
+  return fork ? { text, fork: true } : { text };
+}
+
+/** Parse the legacy next-turn guidance command. */
+export function parseNoteNextCommand(trimmed) {
+  const t = String(trimmed == null ? "" : trimmed).trim();
+  if (t !== "/note-next" && !t.startsWith("/note-next ")) return null;
+  const text = t.slice("/note-next".length).trim();
   if (!text) {
     return {
       error:
-        "usage: /btw <note> — a one-off aside for your next message (sent to the model, not saved to history)",
+        "usage: /note-next <note> — apply ephemeral guidance to the next main turn",
     };
   }
   return { text };
 }
 
+function textContent(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return content == null ? "" : String(content);
+  return content
+    .map((part) => {
+      if (typeof part === "string") return part;
+      if (part?.type === "text") return String(part.text || "");
+      if (part?.type === "image_url" || part?.image_url) return "[image]";
+      return "";
+    })
+    .filter(Boolean)
+    .join("\n");
+}
+
+/**
+ * Build a provider-neutral, tool-free snapshot for a side question. Tool
+ * results are retained as quoted user context, but tool-call protocol fields
+ * are deliberately removed so the side call cannot continue a tool exchange.
+ */
+export function buildBtwMessages(messages, question) {
+  const out = [];
+  for (const message of Array.isArray(messages) ? messages : []) {
+    if (!message || typeof message !== "object") continue;
+    const content = textContent(message.content);
+    if (!content) continue;
+    if (message.role === "system") out.push({ role: "system", content });
+    else if (message.role === "assistant")
+      out.push({ role: "assistant", content });
+    else if (message.role === "tool")
+      out.push({ role: "user", content: `[Tool result]\n${content}` });
+    else if (message.role === "user") out.push({ role: "user", content });
+  }
+  out.push({
+    role: "system",
+    content:
+      "Answer the final side question from the supplied conversation context. " +
+      "This is an ephemeral, single-response exchange. Do not call or request tools, " +
+      "do not change the main task, and answer concisely.",
+  });
+  out.push({ role: "user", content: String(question || "").trim() });
+  return out;
+}
+
+/** Run a single tool-free side question through an injected chat function. */
+export async function runBtwQuestion({
+  messages,
+  question,
+  chatFn,
+  model,
+  maxTokens = 1024,
+} = {}) {
+  if (typeof chatFn !== "function") {
+    throw new TypeError("/btw requires a chat function");
+  }
+  const text = String(question || "").trim();
+  if (!text) throw new TypeError("/btw requires a question");
+  const snapshot = buildBtwMessages(messages, text);
+  const answer = await chatFn(snapshot, { model, maxTokens });
+  return {
+    answer: String(answer == null ? "" : answer),
+    snapshot,
+  };
+}
+
 /**
  * Render queued asides into a single tagged block, or null when there is
  * nothing to add. The note tells the model this is ephemeral user guidance.

package/src/repl/clipboard-image.js

@@ -0,0 +1,119 @@
+/**
+ * Clipboard-image capability boundary for terminal REPL hosts.
+ *
+ * Plain Node readline receives pasted text only; it has no portable clipboard
+ * image event. We therefore enable image chips solely when an embedding host
+ * supplies an explicit, testable `readImage()` binding. Standard terminals get
+ * a truthful path-attachment fallback instead of a fake "paste succeeded".
+ */
+
+export const CLIPBOARD_IMAGE_MEDIA_TYPES = Object.freeze([
+  "image/png",
+  "image/jpeg",
+  "image/gif",
+  "image/webp",
+]);
+export const MAX_CLIPBOARD_IMAGE_BYTES = 20 * 1024 * 1024;
+
+export function detectClipboardImageCapability(binding) {
+  if (
+    binding?.supportsImagePaste === true &&
+    typeof binding.readImage === "function"
+  ) {
+    return {
+      supported: true,
+      mode: "host-binding",
+      reason: "The terminal host exposes clipboard image bytes.",
+    };
+  }
+  return {
+    supported: false,
+    mode: "path-fallback",
+    reason:
+      "This terminal exposes pasted text only, not clipboard image bytes. Save the image and paste its png/jpg/gif/webp path to attach it.",
+  };
+}
+
+function decodeImageData(value) {
+  if (Buffer.isBuffer(value)) return value;
+  if (value instanceof Uint8Array) return Buffer.from(value);
+  if (typeof value !== "string") return null;
+  const base64 = value.replace(/^data:[^;,]+;base64,/i, "").trim();
+  if (!base64 || !/^[A-Za-z0-9+/]*={0,2}$/.test(base64)) return null;
+  try {
+    return Buffer.from(base64, "base64");
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Read one image from a trusted host binding and return an OpenAI-shaped image
+ * content part (the CLI's provider-neutral internal multimodal shape).
+ */
+export async function readClipboardImageChip(binding, options = {}) {
+  const capability = detectClipboardImageCapability(binding);
+  if (!capability.supported) return { ok: false, ...capability };
+  let image;
+  try {
+    image = await binding.readImage();
+  } catch (error) {
+    return {
+      ok: false,
+      supported: true,
+      mode: "host-binding",
+      reason: `Clipboard image read failed: ${error.message}`,
+    };
+  }
+  if (!image) {
+    return {
+      ok: false,
+      supported: true,
+      mode: "host-binding",
+      reason: "The clipboard does not currently contain an image.",
+    };
+  }
+  const mediaType = String(image.mediaType || image.type || "").toLowerCase();
+  if (!CLIPBOARD_IMAGE_MEDIA_TYPES.includes(mediaType)) {
+    return {
+      ok: false,
+      supported: true,
+      mode: "host-binding",
+      reason: `Unsupported clipboard image type: ${mediaType || "unknown"}.`,
+    };
+  }
+  const data = decodeImageData(image.data);
+  if (!data?.length) {
+    return {
+      ok: false,
+      supported: true,
+      mode: "host-binding",
+      reason: "The clipboard image payload is empty or invalid.",
+    };
+  }
+  const maxBytes = Math.max(
+    1,
+    Number(options.maxBytes) || MAX_CLIPBOARD_IMAGE_BYTES,
+  );
+  if (data.length > maxBytes) {
+    return {
+      ok: false,
+      supported: true,
+      mode: "host-binding",
+      reason: `Clipboard image exceeds ${maxBytes} bytes.`,
+    };
+  }
+  return {
+    ok: true,
+    supported: true,
+    mode: "host-binding",
+    bytes: data.length,
+    mediaType,
+    chip: {
+      type: "image_url",
+      image_url: {
+        url: `data:${mediaType};base64,${data.toString("base64")}`,
+      },
+    },
+  };
+}

package/src/repl/config-summary.js

@@ -1,141 +1,93 @@
-/**
- * `/config` REPL command (Claude-Code parity) — show the effective
- * configuration in a readable, SECRET-SAFE form: the LLM provider/model/baseURL
- * actually in effect, whether an API key is set (never the key itself), the
- * web-search backend, and the config-file path. Also surfaces the session's
- * active provider/model, which can differ from the file (a --provider flag or
- * .claude/settings.json overrides it).
- *
- * Pure: takes the loaded config + context, returns plain text. The REPL does
- * the I/O. NEVER prints a secret — only "set (…1234)" / "not set".
- */
+/** Secret-safe rendering and parsing for the interactive `/config` command. */
+import {
+  isSecretConfigKey,
+  redactConfigValue,
+} from "../lib/config-redaction.js";
 
-/** Mask a secret: presence + last 4 chars only, or "not set". */
-export function maskSecret(v) {
-  if (v == null || v === "") return "not set";
-  const s = String(v);
-  return s.length <= 4 ? "set (hidden)" : `set (…${s.slice(-4)})`;
-}
+export { isSecretConfigKey } from "../lib/config-redaction.js";
 
-/**
- * A config key whose value must never be echoed in plaintext in the
- * (shoulder-surfable) interactive REPL — apiKey / secret / token / password.
- * Matched on the last dotted segment (e.g. `llm.apiKey`, `webSearch.apiKey`).
- */
-const SECRET_KEY_RE = /(api[_-]?key|secret|token|password|passwd)$/i;
-export function isSecretConfigKey(key) {
-  if (!key) return false;
-  const last = String(key).split(".").pop();
-  return SECRET_KEY_RE.test(last);
+/** Report only presence; never retain a suffix from a credential. */
+export function maskSecret(value) {
+  return value == null || value === "" ? "not set" : "set (hidden)";
 }
 
-/**
- * Parse the argument string after `/config` into an action.
- * Mirrors Claude Code's `/config key=value` syntax, and also accepts the
- * `/config key value` form. Returns one of:
- *   { action: "show" }                       // `/config`
- *   { action: "get", key }                   // `/config llm.model`
- *   { action: "set", key, value }            // `/config llm.model=opus` | `/config llm.model opus`
- *   { action: "error", message }
- * `value` is the raw string; the caller coerces (true/false/null/number) via
- * config-manager's setConfigValue.
- *
- * @param {string} argStr  everything after the literal `/config`
- */
 export function parseConfigCommand(argStr) {
-  const s = (argStr || "").trim();
-  if (s === "") return { action: "show" };
-
-  // `/config --help` | `-h` | `help` | `?` (Claude-Code 2.1.183 parity) — list
-  // the common config keys. Checked before `=` / `key value` so `help` isn't
-  // mistaken for a key read.
-  if (/^(--help|-h|help|\?)$/i.test(s)) return { action: "help" };
-
-  const eq = s.indexOf("=");
-  if (eq !== -1) {
-    const key = s.slice(0, eq).trim();
-    const value = s.slice(eq + 1).trim();
+  const input = (argStr || "").trim();
+  if (input === "") return { action: "show" };
+  if (/^(--help|-h|help|\?)$/i.test(input)) return { action: "help" };
+
+  const equals = input.indexOf("=");
+  if (equals !== -1) {
+    const key = input.slice(0, equals).trim();
+    const value = input.slice(equals + 1).trim();
     if (!key) return { action: "error", message: "missing key before '='" };
     return { action: "set", key, value };
   }
 
-  // `key value` — split on the first run of whitespace.
-  const m = s.match(/^(\S+)\s+([\s\S]+)$/);
-  if (m) return { action: "set", key: m[1], value: m[2].trim() };
-
-  // Bare token → read that key.
-  return { action: "get", key: s };
+  const spaced = input.match(/^(\S+)\s+([\s\S]+)$/);
+  if (spaced) {
+    return { action: "set", key: spaced[1], value: spaced[2].trim() };
+  }
+  return { action: "get", key: input };
 }
 
-/**
- * The common config keys, surfaced by `/config --help`. cc's `/config` accepts
- * any dotted key (free-form), so this is a curated quick-reference of the keys
- * the CLI actually reads — not an exhaustive schema.
- */
 export const COMMON_CONFIG_KEYS = Object.freeze([
-  [
-    "llm.provider",
-    "LLM provider (ollama | volcengine | anthropic | openai | …)",
-  ],
+  ["llm.provider", "LLM provider id"],
   ["llm.model", "default text model id"],
-  ["llm.visionModel", "model used for image turns (falls back to a default)"],
+  ["llm.visionModel", "model used for image turns"],
   ["llm.baseUrl", "provider API base URL"],
-  ["llm.apiKey", "provider API key (stored masked; env *_API_KEY overrides)"],
-  [
-    "webSearch.provider",
-    "web_search backend (auto | tavily | brave | duckduckgo | …)",
-  ],
-  ["webSearch.apiKey", "web-search API key"],
+  ["llm.apiKey", "provider API key (use cc config set-secret)"],
+  ["webSearch.provider", "web-search backend"],
+  ["webSearch.apiKey", "web-search API key (use cc config set-secret)"],
   ["cli.theme", "REPL color theme (auto | dark | light | mono)"],
 ]);
 
-/** Render `/config --help`: usage + the common config keys. */
 export function renderConfigHelp() {
   const lines = [
-    "/config — show or edit configuration:",
+    "/config — show or edit non-secret configuration:",
     "  /config                 show effective config (secret-safe)",
-    "  /config <key>           read a value     (e.g. /config llm.model)",
-    "  /config <key>=<value>   set a value      (e.g. /config llm.model=opus)",
-    "  /config <key> <value>   set a value      (space form)",
+    "  /config <key>           read a value",
+    "  /config <key>=<value>   set a non-secret value",
+    "  /config <key> <value>   set a non-secret value",
     "  /config --help          this list",
     "",
     "Common keys:",
   ];
-  const width = Math.max(...COMMON_CONFIG_KEYS.map(([k]) => k.length));
-  for (const [key, desc] of COMMON_CONFIG_KEYS) {
-    lines.push(`  ${key.padEnd(width)}  ${desc}`);
+  const width = Math.max(...COMMON_CONFIG_KEYS.map(([key]) => key.length));
+  for (const [key, description] of COMMON_CONFIG_KEYS) {
+    lines.push(`  ${key.padEnd(width)}  ${description}`);
   }
   lines.push("");
-  lines.push("  (any dotted key is accepted; keys are stored in config.json)");
+  lines.push(
+    "  Unknown keys are rejected; use `cc config set --allow-unknown` only for extension development.",
+  );
+  lines.push(
+    "  Secrets cannot be set here; use the hidden `cc config set-secret <key>` input.",
+  );
   return lines.join("\n");
 }
 
-/** Render a single config value for `/config <key>`, masking secrets. */
 export function renderConfigGet(key, value) {
   if (value === undefined) return `${key} = (unset)`;
   if (isSecretConfigKey(key)) return `${key} = ${maskSecret(value)}`;
+  const safe = redactConfigValue(key, value);
   const shown =
-    value !== null && typeof value === "object"
-      ? JSON.stringify(value)
-      : String(value);
+    safe !== null && typeof safe === "object"
+      ? JSON.stringify(safe)
+      : String(safe);
   return `${key} = ${shown}`;
 }
 
-/** Render the confirmation line after `/config <key>=<value>`. */
 export function renderConfigSet(key, storedValue) {
   if (isSecretConfigKey(key)) return `set ${key} = ${maskSecret(storedValue)}`;
+  const safe = redactConfigValue(key, storedValue);
   const shown =
-    storedValue !== null && typeof storedValue === "object"
-      ? JSON.stringify(storedValue)
-      : String(storedValue);
+    safe !== null && typeof safe === "object"
+      ? JSON.stringify(safe)
+      : String(safe);
   return `set ${key} = ${shown}`;
 }
 
-/**
- * @param {object|null} config  loaded config.json
- * @param {object} [opts]  { path, activeProvider, activeModel }
- * @returns {string}
- */
 export function renderConfigSummary(config, opts = {}) {
   const cfg = config || {};
   const llm = cfg.llm || {};
@@ -143,31 +95,35 @@ export function renderConfigSummary(config, opts = {}) {
   if (opts.path) lines.push(`  config file: ${opts.path}`);
 
   lines.push("  llm:");
-  lines.push(`    provider: ${llm.provider || "(unset → defaults to ollama)"}`);
+  lines.push(`    provider: ${llm.provider || "(unset; defaults to ollama)"}`);
   lines.push(`    model:    ${llm.model || "(unset)"}`);
   if (llm.visionModel) lines.push(`    vision:   ${llm.visionModel}`);
-  if (llm.baseUrl) lines.push(`    baseUrl:  ${llm.baseUrl}`);
+  if (llm.baseUrl)
+    lines.push(
+      `    baseUrl:  ${redactConfigValue("llm.baseUrl", llm.baseUrl)}`,
+    );
   lines.push(`    apiKey:   ${maskSecret(llm.apiKey)}`);
 
-  const ws = cfg.webSearch || {};
-  if (ws.provider || ws.apiKey) {
+  const webSearch = cfg.webSearch || {};
+  if (webSearch.provider || webSearch.apiKey) {
     lines.push("  webSearch:");
-    lines.push(`    provider: ${ws.provider || "(unset → auto)"}`);
-    lines.push(`    apiKey:   ${maskSecret(ws.apiKey)}`);
+    lines.push(`    provider: ${webSearch.provider || "(unset; auto)"}`);
+    lines.push(`    apiKey:   ${maskSecret(webSearch.apiKey)}`);
   }
 
   if (opts.activeProvider || opts.activeModel) {
-    const ap = opts.activeProvider || "?";
-    const am = opts.activeModel || "?";
-    const differs = !!llm.provider && (ap !== llm.provider || am !== llm.model);
+    const provider = opts.activeProvider || "?";
+    const model = opts.activeModel || "?";
+    const differs =
+      Boolean(llm.provider) &&
+      (provider !== llm.provider || model !== llm.model);
     lines.push(
-      `  active this session: ${ap} · ${am}` +
-        (differs ? "  (overrides config)" : ""),
+      `  active this session: ${provider} · ${model}${differs ? "  (overrides config)" : ""}`,
     );
   }
 
   lines.push(
-    "  note: keys are hidden; env vars (e.g. *_API_KEY) can override config at runtime.",
+    "  note: secret values are hidden; environment variables can override config at runtime.",
   );
   return lines.join("\n");
 }