chainlesschain 0.162.180 → 0.162.181

package/src/lib/channels/channel-manager.js

@@ -21,6 +21,7 @@ import {
   describeAuthorityChain,
 } from "../agent-authority.js";
 import { EventRuntimeStore } from "../event-runtime-store.js";
+import { getDefaultEventRuntimeHost } from "../event-runtime-host.js";
 
 export const CHANNEL_KINDS = ["webhook", "telegram"];
 
@@ -128,8 +129,31 @@ export async function startChannels(specsInput, opts = {}) {
   // `approve`) before the caller's handler sees it — so a channel message can
   // never be mistaken for a user approval no matter what it contains.
   const onEvent = stampChannelAuthority(opts.onEvent);
+  const eventRuntimeHost =
+    opts.eventRuntimeHost ||
+    (eventRuntimeStore && process.env.CC_EVENT_RUNTIME_DURABLE === "1"
+      ? getDefaultEventRuntimeHost({ store: eventRuntimeStore })
+      : null);
 
   const started = [];
+  const unregisterRuntimeHandlers = [];
+  if (eventRuntimeHost) {
+    for (const origin of new Set(specs.map((spec) => spec.kind))) {
+      unregisterRuntimeHandlers.push(
+        eventRuntimeHost.registerHandler(
+          (event) =>
+            onEvent({
+              channel: event.channel || origin,
+              sender: event.sender,
+              text: event.text,
+              ...(event.meta == null ? {} : { meta: event.meta }),
+              eventId: event.event_id || event.eventId || event.id || null,
+            }),
+          { queue: "inbox", type: "channel.event", origin },
+        ),
+      );
+    }
+  }
   const stopAll = () => {
     for (const c of started) {
       try {
@@ -138,6 +162,13 @@ export async function startChannels(specsInput, opts = {}) {
         /* best-effort */
       }
     }
+    for (const unregister of unregisterRuntimeHandlers.splice(0)) {
+      try {
+        unregister();
+      } catch {
+        /* best-effort */
+      }
+    }
   };
 
   try {
@@ -154,6 +185,7 @@ export async function startChannels(specsInput, opts = {}) {
           onEvent,
           log,
           eventRuntimeStore,
+          eventRuntimeHost,
         });
         started.push({ kind: "webhook", describe: handle.describe, ...handle });
       } else if (spec.kind === "telegram") {
@@ -167,6 +199,7 @@ export async function startChannels(specsInput, opts = {}) {
           onEvent,
           log,
           eventRuntimeStore,
+          eventRuntimeHost,
         });
         started.push({
           kind: "telegram",

package/src/lib/channels/telegram-channel.js

@@ -29,6 +29,7 @@ export async function startTelegramChannel(options = {}) {
     // the event loop (timers, stop()) entirely.
     pollPauseMs = 50,
     eventRuntimeStore = null,
+    eventRuntimeHost = null,
   } = options;
   const runtimeProducer = eventRuntimeStore
     ? new EventRuntimeProducer({ store: eventRuntimeStore })
@@ -74,13 +75,30 @@ export async function startTelegramChannel(options = {}) {
               channel: "telegram",
               sender: String(chatId),
               text,
+              eventId: `telegram:${update.update_id}`,
               meta: { updateId: update.update_id },
             };
-            runtimeProducer?.publish(event, {
-              origin: "telegram",
-              id: `telegram:${update.update_id}`,
-            });
-            onEvent?.(event);
+            if (runtimeProducer) {
+              const record = runtimeProducer.publish(
+                {
+                  ...event,
+                  type: "channel.event",
+                  requiresHandler: true,
+                },
+                {
+                  origin: "telegram",
+                  id: `telegram:${update.update_id}`,
+                },
+              );
+              if (eventRuntimeHost) {
+                await eventRuntimeHost.runOnce();
+              } else {
+                const result = await onEvent?.(event);
+                eventRuntimeStore.acknowledgeInbox?.(record.id, result);
+              }
+            } else {
+              await onEvent?.(event);
+            }
           } catch {
             /* downstream owns its failures */
           }

package/src/lib/channels/webhook-channel.js

@@ -36,6 +36,7 @@ export async function startWebhookChannel(options = {}) {
     onEvent,
     log = () => {},
     eventRuntimeStore = null,
+    eventRuntimeHost = null,
   } = options;
   const runtimeProducer = eventRuntimeStore
     ? new EventRuntimeProducer({ store: eventRuntimeStore })
@@ -80,7 +81,7 @@ export async function startWebhookChannel(options = {}) {
       }
       chunks.push(chunk);
     });
-    req.on("end", () => {
+    req.on("end", async () => {
       if (aborted) return;
       let payload;
       try {
@@ -92,30 +93,52 @@ export async function startWebhookChannel(options = {}) {
       if (!text) return respond(400, { error: "missing text" });
       const sender =
         typeof payload.sender === "string" ? payload.sender : "webhook";
+      const eventId = payload.event_id || payload.eventId || null;
       if (Array.isArray(allowlist) && allowlist.length > 0) {
         if (!allowlist.includes(sender)) {
           return respond(403, { error: "sender not in allowlist" });
         }
       }
       const event = {
-          channel: "webhook",
-          sender,
-          text,
-          meta:
-            payload.meta && typeof payload.meta === "object"
-              ? payload.meta
-              : undefined,
-        };
+        channel: "webhook",
+        sender,
+        text,
+        ...(eventId == null ? {} : { eventId: String(eventId) }),
+        meta:
+          payload.meta && typeof payload.meta === "object"
+            ? payload.meta
+            : undefined,
+      };
       try {
-        runtimeProducer?.publish(event, {
-          origin: "webhook",
-          id: payload.event_id || payload.eventId || null,
-        });
-        onEvent?.(event);
+        if (runtimeProducer) {
+          const record = runtimeProducer.publish(
+            {
+              ...event,
+              type: "channel.event",
+              requiresHandler: true,
+            },
+            {
+              origin: "webhook",
+              id: eventId,
+            },
+          );
+          if (eventRuntimeHost) {
+            const stats = await eventRuntimeHost.runOnce();
+            if (Number(stats?.inboxFailed || 0) > 0) {
+              throw new Error("durable event delivery failed");
+            }
+          } else {
+            const result = await onEvent?.(event);
+            eventRuntimeStore.acknowledgeInbox?.(record.id, result);
+          }
+        } else {
+          await onEvent?.(event);
+        }
       } catch {
         // A configured durable runtime is the recovery boundary. Refuse the
         // request rather than acknowledging an event that was not persisted.
-        if (runtimeProducer) return respond(503, { error: "event persistence unavailable" });
+        if (runtimeProducer)
+          return respond(503, { error: "event persistence unavailable" });
       }
       respond(202, { ok: true });
     });

package/src/lib/chrome-connector.js

@@ -31,6 +31,7 @@ import os from "os";
 import path from "path";
 import http from "http";
 import executionBroker from "./process-execution-broker/index.js";
+import { redactSecrets } from "./secret-scan.js";
 
 export const DEFAULT_CDP_PORT = 9222;
 
@@ -67,6 +68,122 @@ export function normalizeLaunchUrl(url) {
 }
 export const DEFAULT_DOM_CAP = 150000;
 
+/** Secret-safe text carried from a browser into transcripts or audit logs. */
+export function redactBrowserText(value, cap = 500) {
+  if (value == null) return "";
+  const text = redactSecrets(String(value));
+  return text.length > cap ? `${text.slice(0, cap)}…` : text;
+}
+
+/**
+ * Preserve the page origin/path and query KEY names while removing credentials,
+ * fragments, and every query value. Query values often contain opaque sessions
+ * that a generic secret scanner cannot recognize.
+ */
+export function redactBrowserUrl(value, cap = 500) {
+  const raw = String(value || "");
+  if (!raw) return "";
+  try {
+    const parsed = new URL(raw);
+    if (!["http:", "https:"].includes(parsed.protocol)) {
+      return redactBrowserText(raw, cap);
+    }
+    const keys = [...new Set(parsed.searchParams.keys())].slice(0, 64);
+    const query =
+      keys.length > 0
+        ? `?${keys
+            .map((key) => `${encodeURIComponent(key)}=[REDACTED]`)
+            .join("&")}`
+        : "";
+    return redactBrowserText(
+      `${parsed.protocol}//${parsed.host}${parsed.pathname}${query}`,
+      cap,
+    );
+  } catch {
+    return redactBrowserText(raw, cap);
+  }
+}
+
+function redactBrowserDomUrl(value, cap = 1000) {
+  const raw = String(value || "");
+  if (!raw) return "";
+  if (/^https?:\/\//i.test(raw)) return redactBrowserUrl(raw, cap);
+  if (raw.startsWith("//")) {
+    const safe = redactBrowserUrl(`https:${raw}`, cap + 6);
+    return safe.startsWith("https:")
+      ? redactBrowserText(safe.slice(6), cap)
+      : redactBrowserText(safe, cap);
+  }
+
+  const withoutFragment = raw.split("#", 1)[0];
+  const queryIndex = withoutFragment.indexOf("?");
+  if (queryIndex < 0) return redactBrowserText(withoutFragment, cap);
+  const prefix = withoutFragment.slice(0, queryIndex);
+  const keys = [
+    ...new Set(
+      withoutFragment
+        .slice(queryIndex + 1)
+        .split(/&(?:amp;)?/i)
+        .map((part) => part.split("=", 1)[0].trim())
+        .filter(Boolean)
+        .slice(0, 64),
+    ),
+  ];
+  const query =
+    keys.length > 0
+      ? `?${keys
+          .map((key) => `${encodeURIComponent(key.slice(0, 128))}=[REDACTED]`)
+          .join("&")}`
+      : "";
+  return redactBrowserText(`${prefix}${query}`, cap);
+}
+
+/**
+ * Redact secret-shaped text, sensitive form values, and DOM URL query values
+ * from the bounded snapshot before it crosses the tool boundary.
+ */
+export function redactBrowserDom(value, cap = DEFAULT_DOM_CAP) {
+  let html = redactSecrets(String(value || ""));
+  html = html.replace(/<input\b[^>]*>/gi, (tag) => {
+    const sensitive =
+      /\btype\s*=\s*["']?password\b/i.test(tag) ||
+      /\b(?:name|id)\s*=\s*["'][^"']*(?:password|passwd|token|secret|api[-_]?key)[^"']*["']/i.test(
+        tag,
+      );
+    if (!sensitive) return tag;
+    return tag.replace(/\bvalue\s*=\s*(["'])[^"']*\1/i, 'value="[REDACTED]"');
+  });
+  html = html.replace(
+    /(<textarea\b[^>]*(?:name|id)\s*=\s*["'][^"']*(?:password|passwd|token|secret|api[-_]?key)[^"']*["'][^>]*>)[\s\S]*?(<\/textarea>)/gi,
+    "$1[REDACTED]$2",
+  );
+  html = html.replace(
+    /\b(href|src|action)\s*=\s*(["'])([^"']+)\2/gi,
+    (_match, attr, quote, url) =>
+      `${attr}=${quote}${redactBrowserDomUrl(url, 1000)}${quote}`,
+  );
+  return html.slice(0, Math.max(0, Number(cap) || 0));
+}
+
+function redactScreenshotFailure(error, generatedPath, cap = 300) {
+  let message = String(error && error.message ? error.message : error);
+  if (generatedPath) {
+    message = message
+      .split(String(generatedPath))
+      .join("[SCREENSHOT_PATH]");
+  }
+  return redactBrowserText(message.split("\n")[0], cap);
+}
+
+function cleanupFailedScreenshot(generatedPath, deps) {
+  if (!generatedPath) return;
+  try {
+    deps.fs.rmSync(generatedPath, { force: true });
+  } catch {
+    // Failure cleanup is best-effort; never mask the browser action error.
+  }
+}
+
 const _deps = {
   fs,
   spawn: executionBroker.spawn.bind(executionBroker),
@@ -286,15 +403,18 @@ export async function captureState({
     const networkEntries = [];
     const onConsole = (m) => {
       if (consoleEntries.length < 200) {
-        consoleEntries.push({ type: m.type(), text: m.text().slice(0, 500) });
+        consoleEntries.push({
+          type: redactBrowserText(m.type(), 40),
+          text: redactBrowserText(m.text(), 500),
+        });
       }
     };
     const onRequestFailed = (r) => {
       if (networkEntries.length < 200) {
         networkEntries.push({
           kind: "failed",
-          url: r.url().slice(0, 300),
-          error: r.failure()?.errorText || "",
+          url: redactBrowserUrl(r.url(), 300),
+          error: redactBrowserText(r.failure()?.errorText || "", 300),
         });
       }
     };
@@ -302,7 +422,7 @@ export async function captureState({
       if (res.status() >= 400 && networkEntries.length < 200) {
         networkEntries.push({
           kind: "http-error",
-          url: res.url().slice(0, 300),
+          url: redactBrowserUrl(res.url(), 300),
           status: res.status(),
         });
       }
@@ -322,22 +442,33 @@ export async function captureState({
         ok: true,
         port,
         tab: index,
-        url: page.url(),
-        title: await page.title().catch(() => ""),
-        tabs: pages.map((p, i) => ({ index: i, url: p.url() })),
+        url: redactBrowserUrl(page.url()),
+        title: redactBrowserText(await page.title().catch(() => ""), 500),
+        tabs: pages.map((p, i) => ({
+          index: i,
+          url: redactBrowserUrl(p.url()),
+        })),
         console: consoleEntries,
         network: networkEntries,
       };
       if (includeDom) {
         const html = await page.content().catch(() => "");
-        state.html = html.slice(0, domCap);
+        state.html = redactBrowserDom(html, domCap);
         state.htmlTruncated = html.length > domCap;
       }
       if (screenshotPath) {
         await page.screenshot({ path: screenshotPath }).catch((err) => {
-          state.screenshotError = err.message.split("\n")[0];
+          cleanupFailedScreenshot(screenshotPath, deps);
+          state.screenshotError = redactScreenshotFailure(
+            err,
+            screenshotPath,
+            300,
+          );
         });
-        if (!state.screenshotError) state.screenshotPath = screenshotPath;
+        if (!state.screenshotError) {
+          state.screenshotPath = screenshotPath;
+          state.screenshotRef = path.basename(screenshotPath);
+        }
       }
       return state;
     } finally {
@@ -417,8 +548,7 @@ export function resolveLoopbackCdpPort(
 }
 
 function truncateForAudit(value, cap = 200) {
-  const s = String(value);
-  return s.length > cap ? `${s.slice(0, cap)}…` : s;
+  return redactBrowserText(value, cap);
 }
 
 /**
@@ -592,7 +722,7 @@ async function runOneAction(page, act, timeoutMs) {
       return `selector appeared: ${act.selector}`;
     case "screenshot":
       await page.screenshot({ path: act.screenshotPath });
-      return `screenshot saved: ${act.screenshotPath}`;
+      return "screenshot captured";
     case "assertText": {
       const text = await page.textContent(act.selector, {
         timeout: timeoutMs,
@@ -693,16 +823,24 @@ export async function performActions(
     for (const act of normalized) {
       const started = Date.now();
       const step = { ok: false, action: act.type, detail: "", durationMs: 0 };
+      const pageBefore = redactBrowserUrl(page.url());
       try {
-        step.detail = await runOneAction(page, act, stepTimeout);
+        const detail = await runOneAction(page, act, stepTimeout);
+        step.detail =
+          act.type === "navigate"
+            ? `navigated to ${redactBrowserUrl(act.url)}`
+            : redactBrowserText(detail, 500);
         step.ok = true;
-        if (act.screenshotPath) step.screenshotPath = act.screenshotPath;
+        if (act.screenshotPath) {
+          step.screenshotPath = act.screenshotPath;
+          step.screenshotRef = path.basename(act.screenshotPath);
+        }
       } catch (err) {
-        step.detail = String(err && err.message ? err.message : err).split(
-          "\n",
-        )[0];
+        cleanupFailedScreenshot(act.screenshotPath, deps);
+        step.detail = redactScreenshotFailure(err, act.screenshotPath, 500);
       }
       step.durationMs = Date.now() - started;
+      const pageAfter = redactBrowserUrl(page.url());
       result.steps.push(step);
       try {
         const entry = {
@@ -710,14 +848,22 @@ export async function performActions(
           action: act.type,
           ok: step.ok,
           durationMs: step.durationMs,
+          pageBefore,
+          pageAfter,
+          result: step.detail,
         };
-        if (sessionId) entry.sessionId = String(sessionId);
+        if (sessionId) {
+          entry.sessionId = redactBrowserText(sessionId, 160);
+        }
         if (act.selector) entry.selector = truncateForAudit(act.selector);
-        if (act.url) entry.url = truncateForAudit(act.url);
+        if (act.url) entry.url = redactBrowserUrl(act.url);
         if (act.key) entry.key = truncateForAudit(act.key, 50);
+        if (step.ok && act.screenshotPath) {
+          entry.screenshotRef = path.basename(act.screenshotPath);
+        }
         appendActionAudit(entry, deps);
       } catch (err) {
-        auditError = err.message;
+        auditError = redactBrowserText(err.message, 300);
       }
       if (!step.ok && !continueOnError) break;
     }
@@ -727,8 +873,8 @@ export async function performActions(
       result.steps.length === normalized.length &&
       result.steps.every((s) => s.ok);
     if (auditError) result.auditError = auditError;
-    result.url = page.url();
-    result.title = await page.title().catch(() => "");
+    result.url = redactBrowserUrl(page.url());
+    result.title = redactBrowserText(await page.title().catch(() => ""), 500);
     return result;
   } finally {
     // connectOverCDP close() disconnects the client; the browser lives on.

package/src/lib/config-manager.js

@@ -22,7 +22,7 @@ export const _deps = {
   },
 };
 
-export function loadConfig() {
+export function loadConfig({ failIfUnavailable = false } = {}) {
   const configPath = getConfigPath();
   if (!existsSync(configPath)) {
     return { ...structuredClone(DEFAULT_CONFIG) };
@@ -32,6 +32,14 @@ export function loadConfig() {
     const parsed = JSON.parse(raw);
     return deepMerge(structuredClone(DEFAULT_CONFIG), parsed);
   } catch (err) {
+    if (failIfUnavailable) {
+      const error = new Error(
+        `Could not read durable config at ${configPath}: ${err.message}`,
+        { cause: err },
+      );
+      error.code = "CONFIG_STORE_UNAVAILABLE";
+      throw error;
+    }
     // The file EXISTS but couldn't be read/parsed (a typo, trailing comma, or
     // truncated write). Silently returning defaults drops the user's entire
     // config — provider, model, baseUrl, API key — and falls back to the
@@ -134,14 +142,20 @@ export function getConfigValue(key) {
 export function setConfigValue(key, value) {
   // Serialize the read-modify-write across processes: two concurrent
   // `cc config set` invocations would otherwise each load, mutate, and write
-  // back, silently losing one update. Best-effort lock (see with-file-lock):
-  // on contention timeout it proceeds anyway, so the CLI never hangs.
-  return withFileLock(getConfigPath(), () => {
-    const config = loadConfig();
-    setNestedValue(config, key, parseValue(value));
-    saveConfig(config);
-    return config;
-  });
+  // back, silently losing one update. Configuration can carry credentials and
+  // permission policy, so bounded lock failure must never write unlocked.
+  const configPath = getConfigPath();
+  mkdirSync(dirname(configPath), { recursive: true });
+  return withFileLock(
+    configPath,
+    () => {
+      const config = loadConfig({ failIfUnavailable: true });
+      setNestedValue(config, key, parseValue(value));
+      saveConfig(config);
+      return config;
+    },
+    { failIfUnavailable: true },
+  );
 }
 
 export function resetConfig() {

package/src/lib/context-breakdown.js

@@ -105,11 +105,32 @@ export function breakdownSkillCache(cache) {
       scans: Number(descriptors.scans) || 0,
       cacheHits: Number(descriptors.cacheHits) || 0,
       estimatedTokens: Number(descriptors.estimatedTokens) || 0,
+      contextLoads: Number(descriptors.contextLoads) || 0,
+      contextTokens: Number(descriptors.contextTokens) || 0,
+      entries: Array.isArray(descriptors.entries)
+        ? descriptors.entries.map((entry) => ({
+            id: String(entry?.id || "skill"),
+            source: String(entry?.source || "skill"),
+            estimatedTokens: Number(entry?.estimatedTokens) || 0,
+            contextLoads: Number(entry?.contextLoads) || 0,
+            contextTokens: Number(entry?.contextTokens) || 0,
+            loadedBecause: Array.isArray(entry?.loadedBecause)
+              ? entry.loadedBecause.map(String)
+              : [],
+          }))
+        : [],
     },
     bodies: {
       resident: Number(bodies.resident) || 0,
       cacheHits: Number(bodies.cacheHits) || 0,
       cacheMisses: Number(bodies.cacheMisses) || 0,
+      estimatedTokensResident:
+        Number(bodies.estimatedTokensResident) || 0,
+      estimatedTokensServed: Number(bodies.estimatedTokensServed) || 0,
+      estimatedTokensAvoidedByCache:
+        Number(bodies.estimatedTokensAvoidedByCache) || 0,
+      contextLoads: Number(bodies.contextLoads) || 0,
+      contextTokens: Number(bodies.contextTokens) || 0,
       entries: Array.isArray(bodies.entries)
         ? bodies.entries.map((entry) => ({
             id: String(entry?.id || "skill"),
@@ -117,6 +138,16 @@ export function breakdownSkillCache(cache) {
             estimatedTokens: Number(entry?.estimatedTokens) || 0,
             loads: Number(entry?.loads) || 0,
             cacheHits: Number(entry?.cacheHits) || 0,
+            cacheMisses:
+              Number(entry?.cacheMisses) ||
+              Math.max(
+                0,
+                (Number(entry?.loads) || 0) -
+                  (Number(entry?.cacheHits) || 0),
+              ),
+            contextLoads: Number(entry?.contextLoads) || 0,
+            contextCacheHits: Number(entry?.contextCacheHits) || 0,
+            contextTokens: Number(entry?.contextTokens) || 0,
             loadedBecause: Array.isArray(entry?.loadedBecause)
               ? entry.loadedBecause.map(String)
               : [],