chainlesschain 0.162.155 → 0.162.157

package/src/lib/chrome-connector.js

@@ -0,0 +1,314 @@
+/**
+ * Chrome connector — attach to the USER'S real Chrome over the DevTools
+ * protocol (CDP) so page state (DOM / console / network / screenshot) can be
+ * captured WITH the user's login sessions, unlike `cc browse fetch/scrape`
+ * which cold-launches a blank headless browser.
+ *
+ * Three layers:
+ *   discoverCdp()       GET http://127.0.0.1:<port>/json/version — is a
+ *                       debuggable Chrome listening?
+ *   launch helpers      find the Chrome executable + build the argv to start
+ *                       one with --remote-debugging-port. By default a
+ *                       DEDICATED profile dir is used (~/.chainlesschain/
+ *                       chrome-profile) — sign in once there and the state
+ *                       persists. Reusing the DEFAULT profile is opt-in
+ *                       (defaultProfile: true) and requires every Chrome
+ *                       window to be closed first (Chrome refuses the debug
+ *                       port otherwise).
+ *   captureState()      playwright connectOverCDP → pick a tab → observe for
+ *                       watchMs (console messages, failed/4xx-5xx network),
+ *                       snapshot url/title/DOM (capped), optional screenshot.
+ *                       Disconnects without killing the browser.
+ *
+ * SECURITY: the CDP port is an unauthenticated local control channel for the
+ * whole browser — anything on the machine can drive it while it is open.
+ * Loopback-only is enforced here; the docs tell users to close the connected
+ * Chrome when done. This is the same trade Claude-Code's Chrome connector
+ * makes.
+ */
+import { spawn } from "child_process";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import http from "http";
+
+export const DEFAULT_CDP_PORT = 9222;
+export const DEFAULT_DOM_CAP = 150000;
+
+const _deps = {
+  fs,
+  spawn,
+  homedir: () => os.homedir(),
+  platform: () => process.platform,
+  env: () => process.env,
+  httpGet,
+  importPlaywright: () => import("playwright"),
+};
+
+function httpGet(url, timeoutMs = 3000) {
+  return new Promise((resolve) => {
+    const req = http.get(url, { timeout: timeoutMs }, (res) => {
+      let data = "";
+      res.on("data", (d) => (data += d));
+      res.on("end", () => resolve({ status: res.statusCode, body: data }));
+    });
+    req.on("timeout", () => {
+      req.destroy();
+      resolve({ status: 0, body: "" });
+    });
+    req.on("error", () => resolve({ status: 0, body: "" }));
+  });
+}
+
+/** Is a debuggable Chrome listening on the port? → {ok, browser?, wsUrl?} */
+export async function discoverCdp({
+  port = DEFAULT_CDP_PORT,
+  deps = _deps,
+} = {}) {
+  const res = await deps.httpGet(`http://127.0.0.1:${port}/json/version`);
+  if (res.status !== 200) return { ok: false, port };
+  try {
+    const info = JSON.parse(res.body);
+    return {
+      ok: true,
+      port,
+      browser: info.Browser || "",
+      wsUrl: info.webSocketDebuggerUrl || "",
+    };
+  } catch {
+    return { ok: false, port };
+  }
+}
+
+/** Well-known Chrome/Edge/Chromium install paths per platform. */
+export function chromeCandidates({ deps = _deps } = {}) {
+  const env = deps.env();
+  const custom = env.CHROME_PATH ? [env.CHROME_PATH] : [];
+  if (deps.platform() === "win32") {
+    const bases = [
+      env["PROGRAMFILES"],
+      env["PROGRAMFILES(X86)"],
+      env["LOCALAPPDATA"],
+    ].filter(Boolean);
+    // path.win32, not host path: platform() is injectable, so this branch
+    // must build Windows paths even when the host (e.g. Linux CI) is not.
+    return [
+      ...custom,
+      ...bases.map((b) =>
+        path.win32.join(b, "Google", "Chrome", "Application", "chrome.exe"),
+      ),
+      ...bases.map((b) =>
+        path.win32.join(b, "Microsoft", "Edge", "Application", "msedge.exe"),
+      ),
+    ];
+  }
+  if (deps.platform() === "darwin") {
+    return [
+      ...custom,
+      "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+      "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+    ];
+  }
+  return [
+    ...custom,
+    "/usr/bin/google-chrome",
+    "/usr/bin/google-chrome-stable",
+    "/usr/bin/chromium",
+    "/usr/bin/chromium-browser",
+    "/usr/bin/microsoft-edge",
+  ];
+}
+
+/** First existing Chrome-family executable, or null. */
+export function findChromeExecutable({ deps = _deps } = {}) {
+  for (const candidate of chromeCandidates({ deps })) {
+    try {
+      if (deps.fs.existsSync(candidate)) return candidate;
+    } catch {
+      /* inaccessible — keep looking */
+    }
+  }
+  return null;
+}
+
+/** The dedicated connector profile dir (login once there; state persists). */
+export function connectorProfileDir({ deps = _deps } = {}) {
+  return path.join(deps.homedir(), ".chainlesschain", "chrome-profile");
+}
+
+/**
+ * Argv for launching a debuggable Chrome. Dedicated profile by default;
+ * `defaultProfile: true` drops --user-data-dir to reuse the user's real
+ * profile (requires ALL Chrome windows closed — callers must check
+ * discoverCdp/refusal and say so).
+ */
+export function buildChromeLaunchArgs({
+  port = DEFAULT_CDP_PORT,
+  url,
+  defaultProfile = false,
+  profileDir,
+  deps = _deps,
+} = {}) {
+  const args = [
+    `--remote-debugging-port=${port}`,
+    // No first-run wizards in the dedicated profile.
+    "--no-first-run",
+    "--no-default-browser-check",
+  ];
+  if (!defaultProfile) {
+    args.push(`--user-data-dir=${profileDir || connectorProfileDir({ deps })}`);
+  }
+  if (url) args.push(String(url));
+  return args;
+}
+
+/** Spawn the (detached) debuggable Chrome. Returns {ok, executable, args, error?}. */
+export function launchChrome(opts = {}) {
+  const deps = opts.deps || _deps;
+  const executable = opts.executable || findChromeExecutable({ deps });
+  if (!executable) {
+    return {
+      ok: false,
+      error:
+        "no Chrome/Edge executable found — install Chrome or set CHROME_PATH",
+    };
+  }
+  const args = buildChromeLaunchArgs({ ...opts, deps });
+  try {
+    const child = deps.spawn(executable, args, {
+      detached: true,
+      stdio: "ignore",
+      windowsHide: false,
+    });
+    child.unref();
+    return { ok: true, executable, args, pid: child.pid };
+  } catch (err) {
+    return { ok: false, executable, args, error: err.message };
+  }
+}
+
+/**
+ * Attach over CDP, observe the chosen tab for `watchMs`, and return its
+ * state: {url, title, tabs, console[], network[], html, htmlTruncated,
+ * screenshotPath?}. Console/network are collected FROM ATTACH TIME (CDP has
+ * no retroactive console history) — reload or interact during the watch
+ * window to capture activity. Disconnects without killing the browser.
+ */
+export async function captureState({
+  port = DEFAULT_CDP_PORT,
+  tab = 0,
+  watchMs = 3000,
+  domCap = DEFAULT_DOM_CAP,
+  includeDom = true,
+  screenshotPath = null,
+  reload = false,
+  deps = _deps,
+} = {}) {
+  let playwright;
+  try {
+    playwright = await deps.importPlaywright();
+  } catch {
+    return {
+      ok: false,
+      error: "playwright is not installed — npm install playwright",
+    };
+  }
+  let browser;
+  try {
+    browser = await playwright.chromium.connectOverCDP(
+      `http://127.0.0.1:${port}`,
+    );
+  } catch (err) {
+    return {
+      ok: false,
+      error:
+        `cannot attach to CDP on port ${port} (${err.message.split("\n")[0]}) — ` +
+        "launch a debuggable Chrome first (cc browse chrome launch)",
+    };
+  }
+  try {
+    // Right after connectOverCDP the page targets may not have attached yet
+    // (an attach immediately after `chrome launch` reliably hits this) —
+    // poll briefly before concluding the browser has no tabs.
+    let pages = [];
+    for (let i = 0; i < 20; i++) {
+      pages = browser.contexts().flatMap((c) => c.pages());
+      if (pages.length > 0) break;
+      await new Promise((r) => setTimeout(r, 150));
+    }
+    if (pages.length === 0) {
+      return { ok: false, error: "the connected Chrome has no open tabs" };
+    }
+    const index = Math.min(Math.max(0, Number(tab) || 0), pages.length - 1);
+    const page = pages[index];
+
+    const consoleEntries = [];
+    const networkEntries = [];
+    const onConsole = (m) => {
+      if (consoleEntries.length < 200) {
+        consoleEntries.push({ type: m.type(), text: m.text().slice(0, 500) });
+      }
+    };
+    const onRequestFailed = (r) => {
+      if (networkEntries.length < 200) {
+        networkEntries.push({
+          kind: "failed",
+          url: r.url().slice(0, 300),
+          error: r.failure()?.errorText || "",
+        });
+      }
+    };
+    const onResponse = (res) => {
+      if (res.status() >= 400 && networkEntries.length < 200) {
+        networkEntries.push({
+          kind: "http-error",
+          url: res.url().slice(0, 300),
+          status: res.status(),
+        });
+      }
+    };
+    page.on("console", onConsole);
+    page.on("requestfailed", onRequestFailed);
+    page.on("response", onResponse);
+    try {
+      if (reload) {
+        await page
+          .reload({ waitUntil: "domcontentloaded", timeout: watchMs + 15000 })
+          .catch(() => {});
+      }
+      await page.waitForTimeout(Math.max(0, Number(watchMs) || 0));
+
+      const state = {
+        ok: true,
+        port,
+        tab: index,
+        url: page.url(),
+        title: await page.title().catch(() => ""),
+        tabs: pages.map((p, i) => ({ index: i, url: p.url() })),
+        console: consoleEntries,
+        network: networkEntries,
+      };
+      if (includeDom) {
+        const html = await page.content().catch(() => "");
+        state.html = html.slice(0, domCap);
+        state.htmlTruncated = html.length > domCap;
+      }
+      if (screenshotPath) {
+        await page.screenshot({ path: screenshotPath }).catch((err) => {
+          state.screenshotError = err.message.split("\n")[0];
+        });
+        if (!state.screenshotError) state.screenshotPath = screenshotPath;
+      }
+      return state;
+    } finally {
+      page.off("console", onConsole);
+      page.off("requestfailed", onRequestFailed);
+      page.off("response", onResponse);
+    }
+  } finally {
+    // connectOverCDP close() disconnects the client; the browser lives on.
+    await browser.close().catch(() => {});
+  }
+}
+
+export { _deps };

package/src/lib/hook-runner.cjs

@@ -21,6 +21,11 @@
  */
 
 const cpDefault = require("node:child_process");
+const {
+  normalizeShellKind,
+  buildPowershellArgv,
+  loadShellConfig,
+} = require("./shell-selector.cjs");
 
 const _deps = { spawnSync: cpDefault.spawnSync };
 
@@ -101,7 +106,12 @@ function tryParseDecision(stdout) {
  *
  * @param {string} command
  * @param {object} [input]   the hook event payload (tool_name, tool_input, …)
- * @param {object} [opts]    { timeout=60000, cwd, event }
+ * @param {object} [opts]    { timeout=60000, cwd, event, shell }
+ *                           `shell: "powershell"|"pwsh"` runs the hook through
+ *                           PowerShell via explicit argv (P1 #8 — per-hook
+ *                           opt-in from the settings hook entry; the shell is
+ *                           taken literally, so a missing executable surfaces
+ *                           as the usual non-blocking spawn error)
  * @returns {{ decision:string, reason:string|null, exitCode:number|null,
  *            stdout?:string, stderr?:string, additionalContext?:string,
  *            nonBlockingError?:boolean, error?:string }}
@@ -121,20 +131,33 @@ function runCommandHook(command, input = {}, opts = {}) {
   if (!command) {
     return { decision: HOOK_DECISIONS.CONTINUE, reason: null, exitCode: 0 };
   }
+  const shellKind = normalizeShellKind(opts.shell);
+  const usePowershell = shellKind === "powershell" || shellKind === "pwsh";
   let res;
   try {
-    res = _deps.spawnSync(command, {
+    const common = {
       input: JSON.stringify(input),
       cwd: cwd || process.cwd(),
       encoding: "utf-8",
       timeout,
-      shell: true,
       maxBuffer: 8 * 1024 * 1024,
       env: {
         ...process.env,
         CLAUDE_HOOK_EVENT: event || input.hook_event_name || "",
       },
-    });
+    };
+    if (usePowershell) {
+      // Per-hook `shell: powershell|pwsh` (settings hook entry): explicit argv
+      // instead of the default shell; the enterprise ExecutionPolicy override
+      // (settings shell.powershell.executionPolicy) applies here too.
+      const { executionPolicy } = loadShellConfig({
+        cwd: common.cwd,
+      });
+      const inv = buildPowershellArgv(command, shellKind, { executionPolicy });
+      res = _deps.spawnSync(inv.file, inv.argv, common);
+    } else {
+      res = _deps.spawnSync(command, { ...common, shell: true });
+    }
   } catch (err) {
     return {
       decision: HOOK_DECISIONS.CONTINUE,
@@ -210,13 +233,30 @@ function runHooks(commandHooks, input = {}, opts = {}) {
     const r = runCommandHook(h.command, input, {
       ...opts,
       timeout: h.timeout != null ? h.timeout * 1000 : opts.timeout,
+      // per-hook shell selection (P1 #8): `{ "type":"command", "command":…,
+      // "shell":"powershell" }` in the settings hook entry
+      shell: h.shell != null ? h.shell : opts.shell,
     });
     results.push({ command: h.command, ...r });
-    if (r.decision === HOOK_DECISIONS.BLOCK || r.decision === HOOK_DECISIONS.ASK) {
-      return { decision: r.decision, reason: r.reason, hook: h.command, results };
+    if (
+      r.decision === HOOK_DECISIONS.BLOCK ||
+      r.decision === HOOK_DECISIONS.ASK
+    ) {
+      return {
+        decision: r.decision,
+        reason: r.reason,
+        hook: h.command,
+        results,
+      };
     }
   }
   return { decision: HOOK_DECISIONS.CONTINUE, reason: null, results };
 }
 
-module.exports = { runCommandHook, runHooks, tryParseDecision, HOOK_DECISIONS, _deps };
+module.exports = {
+  runCommandHook,
+  runHooks,
+  tryParseDecision,
+  HOOK_DECISIONS,
+  _deps,
+};

package/src/lib/ide-context.js

@@ -17,6 +17,8 @@
  * disconnecting the IDE tools themselves.
  */
 
+import { simpleDiff } from "./note-versioning.js";
+
 /** Hard cap on the selected text we inline into the prompt. */
 const SELECTION_TEXT_CAP = 2000;
 /** At most this many open-editor entries are listed. */
@@ -420,6 +422,88 @@ export function formatReviewComments(comments, { path: filePath } = {}) {
   return `${header}\n${lines.join("\n")}`;
 }
 
+/**
+ * Render what the reviewer changed when they edited the proposal inside the
+ * IDE diff before accepting: a compact -/+ line summary of proposal → final,
+ * so the agent SEES the amendments instead of just a `userEdited` flag (its
+ * mental model of the file would otherwise be its own rejected proposal).
+ * Returns null when the texts are equal or not both strings. Pure.
+ */
+export function summarizeUserAmendments(
+  proposedText,
+  finalText,
+  { maxLines = 30, maxChars = 2400 } = {},
+) {
+  if (typeof proposedText !== "string" || typeof finalText !== "string") {
+    return null;
+  }
+  if (proposedText === finalText) return null;
+  const a = proposedText.split("\n");
+  const b = finalText.split("\n");
+
+  // Common prefix/suffix trim — cheap, and bounds the LCS below.
+  let pre = 0;
+  while (pre < a.length && pre < b.length && a[pre] === b[pre]) pre++;
+  let endA = a.length;
+  let endB = b.length;
+  while (endA > pre && endB > pre && a[endA - 1] === b[endB - 1]) {
+    endA--;
+    endB--;
+  }
+  const midA = a.slice(pre, endA);
+  const midB = b.slice(pre, endB);
+
+  const out = [];
+  const MAX_DP_CELLS = 1_000_000; // simpleDiff is a full-matrix LCS — guard it
+  if (
+    midA.length === 0 ||
+    midB.length === 0 ||
+    (midA.length + 1) * (midB.length + 1) > MAX_DP_CELLS
+  ) {
+    // Pure insertion/deletion (an empty side would round-trip through
+    // join/split as one phantom "" line) or a pathological diff: one direct
+    // block (still tells the agent WHERE and WHAT).
+    out.push(`  @ line ${pre + 1}:`);
+    for (const l of midA) out.push(`  - ${l}`);
+    for (const l of midB) out.push(`  + ${l}`);
+  } else {
+    let lineB = pre; // 1-based final-file line = lineB + 1
+    let inBlock = false;
+    for (const d of simpleDiff(midA.join("\n"), midB.join("\n"))) {
+      if (d.type === "same") {
+        inBlock = false;
+        lineB++;
+        continue;
+      }
+      if (!inBlock) {
+        out.push(`  @ line ${lineB + 1}:`);
+        inBlock = true;
+      }
+      if (d.type === "remove") {
+        out.push(`  - ${d.line}`);
+      } else {
+        out.push(`  + ${d.line}`);
+        lineB++;
+      }
+    }
+  }
+
+  const header =
+    "The user edited the proposal in the IDE diff before accepting — the " +
+    "file was written with THEIR version. Their changes relative to your " +
+    "proposal (-, proposed → +, applied):";
+  let body = out;
+  if (out.length > maxLines) {
+    body = out.slice(0, maxLines);
+    body.push(`  … (${out.length - maxLines} more lines changed)`);
+  }
+  let text = `${header}\n${body.join("\n")}`;
+  if (text.length > maxChars) {
+    text = `${text.slice(0, maxChars)}\n  … (truncated)`;
+  }
+  return text;
+}
+
 // ─── Explicit @selection / @diagnostics at-mentions (Claude-Code parity) ────
 //
 // The ambient `<ide-context>` block above shares the selection on every turn.

package/src/lib/permission-rules.cjs

@@ -51,6 +51,12 @@ const DECISIONS = Object.freeze({
  */
 const TOOL_GROUPS = Object.freeze({
   bash: ["run_shell"],
+  // Claude-Code registers PowerShell as its own tool; cc runs every shell
+  // through run_shell (with an optional per-call `shell` arg), so
+  // `PowerShell(...)` rules map to the same family — a Claude-Code
+  // settings.json with PowerShell rules works unchanged. Shell-specific
+  // scoping is expressible as `PowerShell(shell:pwsh)` (param-rule form).
+  powershell: ["run_shell"],
   read: ["read_file", "list_dir"],
   grep: ["search_files"],
   glob: ["search_files"],
@@ -358,8 +364,23 @@ const SUGGEST_UMBRELLA = Object.freeze({
 
 /** Commands whose first token is a dispatcher — keep 2 tokens in the prefix. */
 const MULTI_VERB = new Set([
-  "git", "npm", "npx", "yarn", "pnpm", "docker", "kubectl", "cargo",
-  "go", "pip", "pip3", "python", "python3", "node", "dotnet", "gh", "brew",
+  "git",
+  "npm",
+  "npx",
+  "yarn",
+  "pnpm",
+  "docker",
+  "kubectl",
+  "cargo",
+  "go",
+  "pip",
+  "pip3",
+  "python",
+  "python3",
+  "node",
+  "dotnet",
+  "gh",
+  "brew",
 ]);
 
 /**
@@ -382,7 +403,9 @@ function suggestAllowRule(tool, args = {}) {
     const raw = args.path || args.file_path || args.dir || args.directory || "";
     if (!raw) return umbrella;
     const slash = String(raw).replace(/\\/g, "/");
-    const dir = slash.includes("/") ? slash.slice(0, slash.lastIndexOf("/")) : ".";
+    const dir = slash.includes("/")
+      ? slash.slice(0, slash.lastIndexOf("/"))
+      : ".";
     const base = dir === "" ? "/" : dir;
     const norm = /^(\.|\/|~)/.test(base) ? base : `./${base}`;
     return `${umbrella}(${norm}/**)`;

package/src/lib/plugin-runtime/scopes.js

@@ -117,6 +117,18 @@ export function activeVersion(scope, name, opts = {}) {
  * @returns {Array<{scope, name, version, root, manifest}>}
  */
 export function discoverPlugins(opts = {}) {
+  // `cc agent --bare` (CC_PLUGINS=0): the plugin runtime is fully off. Every
+  // component collector (hooks/monitors/MCP/LSP/bin/settings-env/skills/
+  // agents) funnels through this discovery, so one gate disables them all.
+  // Other processes (`cc plugin installed` …) don't inherit the agent's env,
+  // so plugin management tooling is unaffected.
+  const rawPlugins = (opts.env || process.env).CC_PLUGINS;
+  if (
+    rawPlugins != null &&
+    /^(0|false|no|off)$/i.test(String(rawPlugins).trim())
+  ) {
+    return [];
+  }
   const scopes = opts.scopes || SCOPES;
   const byName = new Map(); // name → record (later scope overrides earlier)
   for (const scope of scopes) {

package/src/lib/safe-mode.js

@@ -43,3 +43,43 @@ export function safeModeRequested(opts = {}, env = process.env) {
   const raw = env.CC_SAFE_MODE || env.CLAUDE_CODE_SAFE_MODE;
   return raw != null && /^(1|true|yes|on)$/i.test(String(raw).trim());
 }
+
+/**
+ * `cc agent --bare` — everything --safe-mode disables PLUS skills, plugins and
+ * MCP auto-connect: a minimal, fast agent surface for scripted invocations.
+ * The two extra env switches are consumed at the single chokepoints all
+ * loading funnels through (skill-loader `loadAll`, plugin-runtime
+ * `discoverPlugins`); MCP/IDE/PDH/JetBrains auto-connect are flipped off on
+ * the parsed options by the agent command itself (an explicit --mcp-config
+ * still loads — bare kills ambient auto-connects, not explicit input).
+ * Permission rules stay active, same as safe mode.
+ */
+export const BARE_MODE_EXTRA_SWITCHES = Object.freeze({
+  CC_SKILLS: "0", // every skill layer (list_skills/run_skill surface empties)
+  CC_PLUGINS: "0", // plugin runtime (hooks/monitors/MCP/LSP/bin/env/skills/agents)
+});
+
+/**
+ * Apply bare mode to an env: all safe-mode switches + the bare extras.
+ * @returns {string[]} the switch names applied (for the startup notice)
+ */
+export function applyBareMode(env = process.env) {
+  const applied = applySafeMode(env);
+  for (const [k, v] of Object.entries(BARE_MODE_EXTRA_SWITCHES)) {
+    env[k] = v;
+  }
+  return [...applied, ...Object.keys(BARE_MODE_EXTRA_SWITCHES)];
+}
+
+/**
+ * Whether bare mode is requested — the explicit `--bare` flag or the ambient
+ * `CC_BARE` env var (truthy values: 1 / true / yes / on).
+ * @param {{ bare?: boolean }} [opts]
+ * @param {object} [env=process.env]
+ * @returns {boolean}
+ */
+export function bareModeRequested(opts = {}, env = process.env) {
+  if (opts && opts.bare === true) return true;
+  const raw = env.CC_BARE;
+  return raw != null && /^(1|true|yes|on)$/i.test(String(raw).trim());
+}