chainlesschain 0.162.160 → 0.162.161

package/src/lib/remote-path-mapping.js

@@ -0,0 +1,229 @@
+/**
+ * Remote URI ↔ filesystem path mapping for the IDE bridge.
+ *
+ * A local IDE (VS Code / JetBrains) can report a file in a representation that
+ * does not exist on the host `cc` runs on, so inlining it into the prompt makes
+ * the agent's read_file/edit_file target a path the CLI host can't see:
+ *   - a URI:  file:///c:/code/my%20proj/文件.ts
+ *             vscode-remote://wsl+Ubuntu/home/u/x
+ *             vscode-remote://ssh-remote+host/home/u/x
+ *             vscode-remote://dev-container+<hex>/workspaces/x
+ *   - a WSL UNC path from a Windows host: \\wsl.localhost\Ubuntu\home\u\x
+ *     (older Windows builds: \\wsl$\Ubuntu\home\u\x)
+ *   - a Windows drive path while cc runs INSIDE WSL: C:\code\x  ==  /mnt/c/code/x
+ *
+ * normalizeIdePathForCli() folds these foreign forms into the CLI's native fs
+ * path; anything already native (or unrecognized) passes through byte-for-byte.
+ * cliPathToIdeUri() is the reverse, for surfaces that must hand a URI back to
+ * the editor.
+ *
+ * Pure: string transforms only (no fs / process). Percent-decoding preserves
+ * spaces and non-ASCII (中文) exactly, so round-trips are lossless.
+ */
+
+/** decodeURIComponent that never throws on a malformed % sequence. */
+function decodeSafe(s) {
+  if (typeof s !== "string") return s;
+  try {
+    return decodeURIComponent(s);
+  } catch {
+    return s; // leave a malformed sequence as-is rather than lose the value
+  }
+}
+
+/** Has a `scheme://` prefix (a URI, not a bare path). */
+export function looksLikeUri(value) {
+  return typeof value === "string" && /^[a-z][a-z0-9.+-]*:\/\//i.test(value);
+}
+
+/** `C:\…` or `C:/…` — a Windows drive-absolute path. */
+export function looksLikeWindowsPath(value) {
+  return typeof value === "string" && /^[a-zA-Z]:[\\/]/.test(value);
+}
+
+/** `\\host\…` or `//host/…` — a UNC path. */
+function looksLikeUnc(value) {
+  return typeof value === "string" && /^(\\\\|\/\/)[^\\/]/.test(value);
+}
+
+const WSL_UNC_RE =
+  /^(?:\\\\|\/\/)(?:wsl\.localhost|wsl\$)[\\/]([^\\/]+)[\\/]?(.*)$/i;
+
+/**
+ * `\\wsl.localhost\Ubuntu\home\u\x` (or `\\wsl$\…`, forward-slash variants) →
+ * `{ distro:"Ubuntu", posix:"/home/u/x" }`, or null when not a WSL UNC path.
+ */
+export function wslUncToPosix(value) {
+  if (typeof value !== "string") return null;
+  const m = value.match(WSL_UNC_RE);
+  if (!m) return null;
+  const distro = m[1];
+  const rest = (m[2] || "").replace(/\\/g, "/");
+  return { distro, posix: "/" + rest.replace(/^\/+/, "") };
+}
+
+/** `/home/u/x` + distro → `\\wsl.localhost\Ubuntu\home\u\x` (host overridable). */
+export function posixToWslUnc(posix, distro, { host = "wsl.localhost" } = {}) {
+  if (typeof posix !== "string" || !distro) return null;
+  const win = posix.replace(/^\/+/, "").replace(/\//g, "\\");
+  return `\\\\${host}\\${distro}\\${win}`;
+}
+
+/** `C:\code\x` → `/mnt/c/code/x`, or null when not a drive path. */
+export function winDriveToWslMount(value) {
+  if (!looksLikeWindowsPath(value)) return null;
+  const drive = value[0].toLowerCase();
+  const rest = value.slice(2).replace(/\\/g, "/").replace(/^\/+/, "");
+  return `/mnt/${drive}${rest ? "/" + rest : ""}`;
+}
+
+const WSL_MOUNT_RE = /^\/mnt\/([a-zA-Z])(?:\/(.*))?$/;
+
+/** `/mnt/c/code/x` → `C:\code\x`, or null when not a /mnt/<drive> path. */
+export function wslMountToWinDrive(value) {
+  if (typeof value !== "string") return null;
+  const m = value.match(WSL_MOUNT_RE);
+  if (!m) return null;
+  const drive = m[1].toUpperCase();
+  const rest = (m[2] || "").replace(/\//g, "\\");
+  return `${drive}:\\${rest}`;
+}
+
+/**
+ * Parse an IDE URI into its parts. Returns null for a non-URI or an unknown
+ * scheme (so the caller leaves it untouched).
+ *   { scheme, remoteKind, remoteParam, fsPath }
+ * `fsPath` is the decoded on-host path: a Windows drive path for a `file://`
+ * drive URI, else POSIX. `remoteKind`/`remoteParam` are set for vscode-remote.
+ */
+export function parseRemoteUri(uri) {
+  if (!looksLikeUri(uri)) return null;
+  const m = uri.match(/^([a-z][a-z0-9.+-]*):\/\/([^/]*)((?:\/[^?#]*)?)/i);
+  if (!m) return null;
+  const scheme = m[1].toLowerCase();
+  const authority = m[2] || "";
+  const rawPath = m[3] || "";
+
+  if (scheme === "file") {
+    if (authority) {
+      // file://server/share/… → UNC \\server\share\…
+      const unc = "\\\\" + authority + rawPath.replace(/\//g, "\\");
+      return {
+        scheme,
+        remoteKind: null,
+        remoteParam: null,
+        fsPath: decodeSafe(unc),
+      };
+    }
+    const decoded = decodeSafe(rawPath);
+    // /c:/code/x → c:\code\x  (Windows drive URI); else a POSIX path.
+    if (/^\/[a-zA-Z]:/.test(decoded)) {
+      return {
+        scheme,
+        remoteKind: null,
+        remoteParam: null,
+        fsPath: decoded.slice(1).replace(/\//g, "\\"),
+      };
+    }
+    return {
+      scheme,
+      remoteKind: null,
+      remoteParam: null,
+      fsPath: decoded || "/",
+    };
+  }
+
+  if (scheme === "vscode-remote" || scheme === "vscode-vfs") {
+    // authority = "<kind>+<param>", where `+` may be percent-encoded (%2B).
+    const auth = decodeSafe(authority);
+    const plus = auth.indexOf("+");
+    const remoteKind = plus >= 0 ? auth.slice(0, plus) : auth;
+    const remoteParam = plus >= 0 ? auth.slice(plus + 1) : null;
+    return {
+      scheme,
+      remoteKind: remoteKind || null,
+      remoteParam: remoteParam || null,
+      fsPath: decodeSafe(rawPath) || "/",
+    };
+  }
+
+  return null; // unknown scheme — don't guess
+}
+
+/**
+ * Detect the running CLI's WSL context from env (best-effort). Returns
+ * `{ isWsl, distro }`. Injected in tests; ide-context passes process.env.
+ */
+export function detectWsl(env = {}) {
+  const distro = env.WSL_DISTRO_NAME || null;
+  const isWsl = Boolean(distro || env.WSL_INTEROP);
+  return { isWsl, distro };
+}
+
+/**
+ * Fold an IDE-reported file value into the path `cc` can actually open on THIS
+ * host. Only recognized foreign forms are rewritten; a native or unrecognized
+ * value is returned unchanged (byte-for-byte).
+ *
+ * @param {string} value  URI or path as the IDE reported it
+ * @param {object} [opts]
+ * @param {string} [opts.platform=process.platform]  the CLI host platform
+ * @param {{isWsl?:boolean, distro?:string}} [opts.wsl]  WSL context (see detectWsl)
+ * @returns {string}
+ */
+export function normalizeIdePathForCli(value, opts = {}) {
+  if (typeof value !== "string" || value.length === 0) return value;
+  const platform = opts.platform || process.platform;
+  const wsl = opts.wsl || {};
+  const onWindows = platform === "win32";
+
+  // 1) Resolve a URI down to its on-host fsPath first.
+  let base = value;
+  let remoteKind = null;
+  let remoteParam = null;
+  if (looksLikeUri(value)) {
+    const parsed = parseRemoteUri(value);
+    if (!parsed) return value; // unknown scheme → leave untouched
+    base = parsed.fsPath;
+    remoteKind = parsed.remoteKind;
+    remoteParam = parsed.remoteParam;
+  }
+
+  if (onWindows) {
+    // Native form is a Windows path. A POSIX path from a wsl-remote URI is
+    // reachable from Windows as a \\wsl.localhost\<distro>\… UNC.
+    if (remoteKind === "wsl" && remoteParam && base.startsWith("/")) {
+      return posixToWslUnc(base, remoteParam) || base;
+    }
+    return base;
+  }
+
+  // Native form is POSIX (Linux remote-host or inside WSL).
+  const wslUnc = wslUncToPosix(base);
+  if (wslUnc) return wslUnc.posix;
+  if (looksLikeWindowsPath(base) && wsl.isWsl) {
+    return winDriveToWslMount(base) || base;
+  }
+  return base;
+}
+
+/**
+ * Reverse: a CLI-native fs path → a URI the editor can open. `remoteAuthority`
+ * (e.g. "wsl+Ubuntu", "ssh-remote+host") produces a vscode-remote URI; without
+ * it, a `file://` URI. Percent-encodes spaces / non-ASCII per component.
+ */
+export function cliPathToIdeUri(fsPath, { remoteAuthority } = {}) {
+  if (typeof fsPath !== "string" || fsPath.length === 0) return fsPath;
+  const isWinDrive = looksLikeWindowsPath(fsPath);
+  const posixish = fsPath.replace(/\\/g, "/");
+  const encoded = posixish
+    .split("/")
+    .map((seg) => (/^[a-zA-Z]:$/.test(seg) ? seg : encodeURIComponent(seg)))
+    .join("/");
+  if (remoteAuthority) {
+    const path = encoded.startsWith("/") ? encoded : "/" + encoded;
+    return `vscode-remote://${remoteAuthority}${path}`;
+  }
+  const path = isWinDrive ? "/" + encoded : encoded;
+  return `file://${path.startsWith("/") ? "" : "/"}${path}`;
+}

package/src/lib/schedule-planner.js

@@ -0,0 +1,136 @@
+/**
+ * Pure scheduling planner for the agent Scheduler / Monitor (P1 §"统一持久
+ * Scheduler、Monitor 和 Channel").
+ *
+ * The persisted store ([[agent-schedule-store.js]]) already guarantees the
+ * catch-up invariant — a cron down for N periods fires ONCE, not N times,
+ * because `advanceCron` jumps to `nextCronTime(now)` rather than stepping
+ * through every miss. This module adds the pieces a unified daemon event
+ * runtime still needs, all as PURE, clock-injected functions (no timers, no
+ * RNG, deterministic across restarts):
+ *
+ *   - **deterministic jitter** — spread tasks that share a cron minute (e.g.
+ *     every `0 * * * *`) by a STABLE per-task offset, so a shared tick is not a
+ *     thundering herd. The offset is a hash of the task id, so it never moves
+ *     across a restart (an RNG offset would, defeating the point).
+ *   - **adaptive next-wakeup** — the earliest future fire time, so a daemon
+ *     sleeps until then instead of polling.
+ *   - **expiry** — a task past `expiresAt` retires without a final fire.
+ *
+ * A daemon uses `partitionSchedule` (retire expired, fire due) then
+ * `msUntilNextWakeup` (sleep precisely). `jitterMs = 0` (the default) makes the
+ * due set byte-identical to the store's existing `due()`.
+ */
+
+// FNV-1a → a stable 32-bit hash. Deterministic and dependency-free, so the same
+// task always draws the same jitter offset (across processes and restarts).
+function hash32(str) {
+  let h = 0x811c9dc5;
+  const s = String(str ?? "");
+  for (let i = 0; i < s.length; i += 1) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 0x01000193);
+  }
+  return h >>> 0;
+}
+
+/**
+ * A stable jitter offset in `[0, jitterMs)` derived from the task id. Same id +
+ * same jitterMs → same offset, every time. `jitterMs <= 0` → no jitter (0).
+ */
+export function jitterOffsetMs(id, jitterMs) {
+  const j = Math.floor(Number(jitterMs) || 0);
+  if (j <= 0) return 0;
+  return hash32(id) % j;
+}
+
+/** The entry's base fire time: `dueAt` for a wakeup, `nextAt` otherwise. */
+export function baseFireAt(entry) {
+  if (!entry) return null;
+  const raw = entry.kind === "wakeup" ? entry.dueAt : entry.nextAt;
+  const n = Number(raw);
+  return Number.isFinite(n) ? n : null;
+}
+
+/** Base fire time with the entry's deterministic jitter applied. */
+export function effectiveFireAt(entry, jitterMs = 0) {
+  const base = baseFireAt(entry);
+  if (base == null) return null;
+  return base + jitterOffsetMs(entry?.id, jitterMs);
+}
+
+/** Is an entry still pending/active (not in a terminal state)? */
+export function isSchedulable(entry) {
+  if (!entry) return false;
+  if (entry.kind === "wakeup") return entry.status === "pending";
+  return entry.status === "active";
+}
+
+/**
+ * Expiry: a task with an `expiresAt` at or before `now` is retired regardless
+ * of its schedule. A missing / non-positive `expiresAt` never expires.
+ */
+export function isEntryExpired(entry, now) {
+  const exp = Number(entry?.expiresAt);
+  return Number.isFinite(exp) && exp > 0 && exp <= Number(now);
+}
+
+/**
+ * Partition schedulable entries at `now` into what a daemon should do:
+ *   - `expired` — retire (status → expired). Checked BEFORE due so an expired
+ *     task never gets a final fire.
+ *   - `due` — fire now (jittered fire time has arrived).
+ *   - `waiting` — still pending.
+ * Terminal entries are skipped entirely.
+ */
+export function partitionSchedule(entries, { now, jitterMs = 0 } = {}) {
+  const t = Number(now);
+  const expired = [];
+  const due = [];
+  const waiting = [];
+  for (const entry of entries || []) {
+    if (!isSchedulable(entry)) continue;
+    if (isEntryExpired(entry, t)) {
+      expired.push(entry);
+      continue;
+    }
+    const fireAt = effectiveFireAt(entry, jitterMs);
+    if (fireAt != null && fireAt <= t) due.push(entry);
+    else waiting.push(entry);
+  }
+  return { expired, due, waiting };
+}
+
+/**
+ * The earliest future jittered fire time among schedulable, non-expired
+ * entries — what a daemon sleeps until (adaptive wakeup). An already-due entry
+ * contributes `now` (fire immediately). Returns null when nothing is scheduled.
+ */
+export function nextWakeupAt(entries, { now, jitterMs = 0 } = {}) {
+  const t = Number(now);
+  let min = null;
+  for (const entry of entries || []) {
+    if (!isSchedulable(entry) || isEntryExpired(entry, t)) continue;
+    const fireAt = effectiveFireAt(entry, jitterMs);
+    if (fireAt == null) continue;
+    const at = fireAt <= t ? t : fireAt;
+    if (min == null || at < min) min = at;
+  }
+  return min;
+}
+
+/**
+ * Milliseconds until the next wakeup, clamped to `[0, maxMs]` (a cap keeps a
+ * far-future task from parking the daemon forever — it re-checks by `maxMs`).
+ * null when nothing is scheduled.
+ */
+export function msUntilNextWakeup(
+  entries,
+  { now, jitterMs = 0, maxMs = null } = {},
+) {
+  const at = nextWakeupAt(entries, { now, jitterMs });
+  if (at == null) return null;
+  let ms = Math.max(0, at - Number(now));
+  if (maxMs != null && Number.isFinite(maxMs)) ms = Math.min(ms, Number(maxMs));
+  return ms;
+}

package/src/repl/bg-dashboard.js

@@ -1,9 +1,11 @@
 /**
  * Background-agent dashboard — the interactive agent view behind
  * `cc daemon view` (no id). Claude-Code `claude agents` parity: one live panel
- * over every background session with grouping (Needs input / Working /
+ * over every background session with grouping (Needs input / Working / Idle /
  * Completed / Failed / Stopped), peek + reply, attach hand-off, stop, rename,
- * pin, filter, and new-task dispatch.
+ * pin, filter, and new-task dispatch. Phase→group classification is the shared
+ * `background-agent-phase.js` contract, so `idle` (parked, nothing blocking)
+ * is kept distinct from a genuine `needs-input` (a human decision blocks it).
  *
  * Design:
  * - Pure model/render layer (`groupKey`, `buildDashboardModel`,
@@ -17,10 +19,12 @@
  */
 
 import chalk from "chalk";
+import { phaseGroupKey } from "../lib/background-agent-phase.js";
 
 export const GROUP_ORDER = [
   "needs-input",
   "working",
+  "idle",
   "completed",
   "failed",
   "stopped",
@@ -29,24 +33,21 @@ export const GROUP_ORDER = [
 export const GROUP_TITLES = {
   "needs-input": "Needs input",
   working: "Working",
+  idle: "Idle",
   completed: "Completed",
   failed: "Failed",
   stopped: "Stopped",
 };
 
 /**
- * Group a session: running+idle phase = waiting for a follow-up (the closest
- * analog of "needs input" — the worker finished a turn and a client can
- * reply); running+turn = working; lost workers count as failed.
+ * Group a session into a dashboard bucket. Delegates to the shared
+ * `background-agent-phase.js` contract so the worker/supervisor and this panel
+ * agree on phase semantics: running + pending approval / blocking phase →
+ * "needs-input"; running + idle (parked, nothing blocking) → "idle"; running +
+ * working/turn/starting → "working"; lost/unknown → "failed".
  */
 export function groupKey(session) {
-  const status = session?.status;
-  if (status === "running") {
-    return session.phase === "idle" ? "needs-input" : "working";
-  }
-  if (status === "completed") return "completed";
-  if (status === "stopped") return "stopped";
-  return "failed"; // failed | lost | unknown
+  return phaseGroupKey(session);
 }
 
 function formatAge(ms) {

package/src/runtime/agent-core.js

@@ -25,6 +25,7 @@ import sharedSettingsHooks from "../lib/settings-hooks.cjs";
 import sharedHookRunner from "../lib/hook-runner.cjs";
 import sharedHookEvents from "../lib/settings-hook-events.cjs";
 import { mergeProviderOptions } from "../lib/provider-options.js";
+import { applyCredentialProxy } from "../lib/credential-proxy.js";
 import { getPlanModeManager } from "../lib/plan-mode.js";
 import { CLISkillLoader } from "../lib/skill-loader.js";
 import { executeHooks, HookEvents } from "../lib/hook-manager.js";
@@ -2540,7 +2541,10 @@ async function executeToolInner(
             // Same agent-identity env as the foreground path: CLAUDECODE marks
             // "running under the agent"; the session id correlates work to the
             // run (CC_SESSION_ID + CLAUDE_CODE_SESSION_ID for Claude-Code parity).
-            env: {
+            // Credential proxy (opt-in, CC_CREDENTIAL_PROXY): keeps the agent's
+            // real long-lived secrets out of the spawned command's env — a
+            // no-op (same object) when disabled. See credential-proxy.js.
+            env: applyCredentialProxy({
               ...process.env,
               CLAUDECODE: "1",
               ...(sessionId
@@ -2549,7 +2553,7 @@ async function executeToolInner(
                     CLAUDE_CODE_SESSION_ID: String(sessionId),
                   }
                 : {}),
-            },
+            }).env,
             // POSIX: own process group so check_shell{kill}/teardown can signal
             // the whole tree (shell + its grandchild command). No-op on Windows
             // where the tree is killed via taskkill /T instead.
@@ -2715,7 +2719,10 @@ async function executeToolInner(
           // parity): CLAUDECODE=1 marks "running under the agent"; CC_SESSION_ID
           // + its CLAUDE_CODE_SESSION_ID mirror let scripts/hooks correlate work
           // to the agent session (the mirror is what CC-targeting tools expect).
-          env: {
+          // Credential proxy (opt-in, CC_CREDENTIAL_PROXY): keeps the agent's
+          // real long-lived secrets out of the shell's env — a no-op (same
+          // object) when disabled. See credential-proxy.js.
+          env: applyCredentialProxy({
             ...process.env,
             CLAUDECODE: "1",
             ...(sessionId
@@ -2724,7 +2731,7 @@ async function executeToolInner(
                   CLAUDE_CODE_SESSION_ID: String(sessionId),
                 }
               : {}),
-          },
+          }).env,
         };
         let output;
         if (shellInv.useDefaultShell) {