chainlesschain 0.163.4 → 0.163.6

package/src/lib/cowork-observe.js

@@ -70,7 +70,11 @@ export function _computeNextTriggers(schedules, from, limit = 5) {
   const matchers = [];
   for (const s of enabled) {
     try {
-      matchers.push({ id: s.id, cron: s.cron, match: parseCron(s.cron) });
+      matchers.push({
+        id: s.id,
+        cron: s.cron,
+        match: parseCron(s.cron, { timeZone: s.timeZone }),
+      });
     } catch (_e) {
       // skip invalid cron
     }

package/src/lib/loop.js

@@ -86,17 +86,49 @@ export function summarizeLoopEvents(events) {
   let config = null;
   let completedIterations = 0;
   let lastExitCode = null;
+  const scheduled = new Map();
+  const completed = new Set();
   for (const e of events || []) {
     if (e?.type === "loop_config") {
       config = e.data || null;
+    } else if (
+      e?.type === "loop_iteration_scheduled" &&
+      Number.isSafeInteger(e.data?.n) &&
+      e.data.n > 0 &&
+      Number.isSafeInteger(e.data?.scheduledFor) &&
+      e.data.scheduledFor >= 0
+    ) {
+      scheduled.set(e.data.n, {
+        n: e.data.n,
+        scheduledFor: e.data.scheduledFor,
+      });
     } else if (e?.type === "loop_iteration") {
       completedIterations += 1;
+      if (Number.isSafeInteger(e.data?.n) && e.data.n > 0) {
+        completed.add(e.data.n);
+      }
       if (e.data && typeof e.data.exitCode !== "undefined") {
         lastExitCode = e.data.exitCode;
       }
     }
   }
-  return { config, completedIterations, lastExitCode };
+  const pendingIteration =
+    [...scheduled.values()]
+      .filter((entry) => !completed.has(entry.n))
+      .sort((a, b) => a.n - b.n)[0] || null;
+  return { config, completedIterations, lastExitCode, pendingIteration };
+}
+
+/** Return durable terminal data for one loop iteration, if already recorded. */
+export function findLoopIterationResult(events, iteration) {
+  if (!Number.isSafeInteger(iteration) || iteration < 1) return null;
+  for (let index = (events || []).length - 1; index >= 0; index -= 1) {
+    const event = events[index];
+    if (event?.type === "loop_iteration" && event.data?.n === iteration) {
+      return event.data || null;
+    }
+  }
+  return null;
 }
 
 /** Default abortable sleep — resolves early if the signal aborts. */
@@ -187,7 +219,10 @@ export async function runLoop({
     if (untilExitZero && res.exitCode === 0) {
       return { iterations: i, stoppedBy: "exit-zero", results };
     }
-    if (untilRegex && untilRegex.test(res.output || "")) {
+    if (
+      untilRegex &&
+      (res.matchedUntil === true || untilRegex.test(res.output || ""))
+    ) {
       return { iterations: i, stoppedBy: "match", results };
     }
     if (maxIterations && i >= maxIterations) {

package/src/lib/micro-compact.js

@@ -23,10 +23,10 @@ export function microCompact(messages, opts = {}) {
     return { messages, stats: { trimmed: 0, saved: 0, kept: 0 } };
   }
   const keepRecent = Number.isFinite(opts.keepRecent)
-    ? opts.keepRecent
+    ? Math.max(0, Math.trunc(opts.keepRecent))
     : DEFAULT_KEEP_RECENT;
   const maxChars = Number.isFinite(opts.maxToolChars)
-    ? opts.maxToolChars
+    ? Math.max(0, Math.trunc(opts.maxToolChars))
     : DEFAULT_MAX_TOOL_CHARS;
   // messages at index >= cutoff are "recent" and never touched.
   const cutoff = Math.max(0, messages.length - keepRecent);
@@ -38,12 +38,18 @@ export function microCompact(messages, opts = {}) {
     if (!m || m.role !== "tool") return m; // only old tool results
     const content = typeof m.content === "string" ? m.content : "";
     if (content.length <= maxChars) return m; // small enough already
+    const fullMarker = `\n… [tool result trimmed — ${content.length} chars]`;
+    const marker =
+      fullMarker.length <= maxChars
+        ? fullMarker
+        : "…[trimmed]".slice(0, maxChars);
+    const head = content.slice(0, Math.max(0, maxChars - marker.length));
+    const compactedContent = `${head}${marker}`;
     trimmed += 1;
-    saved += content.length - maxChars;
-    const head = content.slice(0, maxChars);
+    saved += content.length - compactedContent.length;
     return {
       ...m,
-      content: `${head}\n… [tool result trimmed — ${content.length} chars; older context dropped to save space]`,
+      content: compactedContent,
       _microCompacted: true,
     };
   });

package/src/lib/permission-engine.js

@@ -91,6 +91,8 @@ export const PERMISSION_SCOPES = [
   "audit:write",
   "config:read",
   "config:write",
+  "automation:execute",
+  "automation:connector:*",
   "system:admin",
 ];
 
@@ -296,7 +298,7 @@ function _grantActive(expiresAt, nowMs) {
 /**
  * Get all roles and direct permissions for a user.
  */
-export function getUserPermissions(db, userDid) {
+export function getUserPermissions(db, userDid, { nowMs = Date.now() } = {}) {
   ensurePermissionTables(db);
 
   // Get active role grants
@@ -305,7 +307,6 @@ export function getUserPermissions(db, userDid) {
     .all(userDid);
 
   // Filter out expired grants
-  const nowMs = Date.now();
   const grants = allGrants.filter((g) => _grantActive(g.expires_at, nowMs));
 
   // Get direct permissions (not expired)
@@ -347,8 +348,8 @@ export function getUserPermissions(db, userDid) {
 /**
  * Check if a user has a specific permission.
  */
-export function checkPermission(db, userDid, permission) {
-  const userPerms = getUserPermissions(db, userDid);
+export function checkPermission(db, userDid, permission, options) {
+  const userPerms = getUserPermissions(db, userDid, options);
 
   // Admin wildcard
   if (userPerms.isAdmin) return true;
@@ -356,9 +357,15 @@ export function checkPermission(db, userDid, permission) {
   // Exact match
   if (userPerms.effectivePermissions.includes(permission)) return true;
 
-  // Wildcard match (e.g., "note:*" matches "note:read")
-  const [scope] = permission.split(":");
-  if (userPerms.effectivePermissions.includes(`${scope}:*`)) return true;
+  // Hierarchical wildcard match. In addition to `note:*`, this allows an
+  // explicitly narrow grant such as `automation:connector:*` to authorize
+  // `automation:connector:slack` without granting unrelated automation
+  // capabilities.
+  const segments = permission.split(":");
+  for (let length = segments.length - 1; length >= 1; length -= 1) {
+    const wildcard = `${segments.slice(0, length).join(":")}:*`;
+    if (userPerms.effectivePermissions.includes(wildcard)) return true;
+  }
 
   return false;
 }

package/src/lib/process-execution-broker/index.js

@@ -66,7 +66,8 @@ const SUPPORTED_SANDBOX_PROFILES = new Set([
 // evidence, not authority to invoke a privileged post-spawn closure.
 const admittedWindowsMcpCodeSnapshotPlans = new WeakSet();
 
-// 延迟导入避免循环依赖
+// Keep the broker on the shared CommonJS trace singleton so CommonJS and ESM
+// consumers observe the same AsyncLocalStorage without loader warnings.
 let _traceCtx = null;
 const _ipcBus = null;
 
@@ -3354,7 +3355,12 @@ class ProcessExecutionBroker extends EventEmitter {
     delete spawnOpts.mcpStdioExecutableIdentityDigest;
     if (traceCtx) {
       spawnOpts.env = { ...(spawnOpts.env || process.env) };
-      spawnOpts.env.TRACEPARENT = traceCtx.traceparent;
+      Object.assign(
+        spawnOpts.env,
+        getTraceCtx()?.traceContext?.getPropagationEnv?.() || {
+          TRACEPARENT: traceCtx.traceparent,
+        },
+      );
     }
 
     // P0-1: Credential filtering (default-on) — strip secrets from env/args
@@ -3658,7 +3664,12 @@ class ProcessExecutionBroker extends EventEmitter {
     this._stripAuditControlOptions(spawnOpts);
     if (traceCtx) {
       spawnOpts.env = { ...(spawnOpts.env || process.env) };
-      spawnOpts.env.TRACEPARENT = traceCtx.traceparent;
+      Object.assign(
+        spawnOpts.env,
+        getTraceCtx()?.traceContext?.getPropagationEnv?.() || {
+          TRACEPARENT: traceCtx.traceparent,
+        },
+      );
     }
 
     // P0-1: Credential filtering agent — strip secrets from env/args before spawn

package/src/lib/public-ide-capability-manifest.js

@@ -50,6 +50,7 @@ const VSCODE_COMMANDS = [
   "chainlesschain.session.prStatus",
   "chainlesschain.background.agents",
   "chainlesschain.sessions.workbench",
+  "chainlesschain.automation.center",
   "chainlesschain.remote.control",
   "chainlesschain.usage.show",
   "chainlesschain.plugins.manage",
@@ -101,6 +102,7 @@ const JETBRAINS_ACTIONS = [
   "chainlesschain.bg.Agents",
   "chainlesschain.remote.Control",
   "chainlesschain.sessions.Workbench",
+  "chainlesschain.automation.Center",
   "chainlesschain.usage.Show",
   "chainlesschain.artifacts.Browse",
   "chainlesschain.policy.Viewer",

package/src/lib/routine-store.js

@@ -27,6 +27,11 @@ import path from "node:path";
 import os from "node:os";
 import { randomBytes } from "node:crypto";
 import { parseCron, nextCronTime } from "./agent-schedule-store.js";
+import {
+  readSecurityStore,
+  writeSecurityStore,
+} from "./durable-security-store.js";
+import { withFileLock } from "./with-file-lock.js";
 
 export const ROUTINE_TRIGGER_KINDS = Object.freeze([
   "cron",
@@ -45,11 +50,75 @@ function shortId() {
 
 function parseWhen(value) {
   if (value == null) return NaN;
+  if (typeof value === "string" && value.trim() === "") return NaN;
+  if (typeof value !== "string" && typeof value !== "number") return NaN;
   const n = Number(value);
   if (Number.isFinite(n)) return n;
   return Date.parse(String(value));
 }
 
+function boundedDefinitionText(value, field, maximum) {
+  const text = String(value || "").trim();
+  if (!text) throw new Error(`routine needs a ${field}`);
+  if (Buffer.byteLength(text, "utf8") > maximum) {
+    throw new Error(`routine ${field} exceeds ${maximum} UTF-8 bytes`);
+  }
+  return text;
+}
+
+export function normalizeRoutineDefinition(def = {}) {
+  const name = boundedDefinitionText(def.name, "name", 512);
+  const prompt = boundedDefinitionText(def.prompt, "prompt", 64 * 1024);
+  const raw = def.trigger;
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    throw new Error("routine trigger is required");
+  }
+  if (!ROUTINE_TRIGGER_KINDS.includes(raw.kind)) {
+    throw new Error(
+      `routine trigger kind must be one of: ${ROUTINE_TRIGGER_KINDS.join(", ")}`,
+    );
+  }
+  let trigger;
+  if (raw.kind === "cron") {
+    const cron = String(raw.cron || "").trim();
+    if (!parseCron(cron)) throw new Error(`invalid cron expression: ${cron}`);
+    trigger = { kind: "cron", cron };
+  } else if (raw.kind === "once") {
+    const at = parseWhen(raw.at);
+    if (!Number.isFinite(at) || !Number.isSafeInteger(at) || at < 0) {
+      throw new Error(`invalid --at time: ${raw.at}`);
+    }
+    trigger = { kind: "once", at };
+  } else if (raw.kind === "github") {
+    const repo = String(raw.repo || "").trim();
+    const parts = repo.split("/");
+    if (
+      !/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/u.test(repo) ||
+      parts.some((part) => part === "." || part === "..")
+    ) {
+      throw new Error("github trigger needs --repo <owner/name>");
+    }
+    const events = Array.isArray(raw.events)
+      ? [...new Set(raw.events.map((value) => String(value || "").trim()))]
+          .filter(Boolean)
+          .sort()
+      : [];
+    if (
+      events.length > 64 ||
+      events.some(
+        (event) =>
+          event.length > 128 || !/^[A-Za-z][A-Za-z0-9_.-]*$/u.test(event),
+      )
+    ) {
+      throw new Error("github trigger events are invalid");
+    }
+    trigger = { kind: "github", repo, events };
+  } else {
+    trigger = { kind: "webhook" };
+  }
+  return { name, prompt, trigger };
+}
+
 export class RoutineStore {
   constructor({ dir = null, now = () => Date.now() } = {}) {
     this.dir = dir || routinesDir();
@@ -70,68 +139,58 @@ export class RoutineStore {
   }
 
   _readRoutines() {
-    try {
-      const parsed = JSON.parse(fs.readFileSync(this._routinesFile(), "utf-8"));
-      return parsed && typeof parsed === "object" ? parsed : {};
-    } catch {
-      return {};
-    }
+    return readSecurityStore(this._routinesFile(), "routine definitions");
   }
   _writeRoutines(map) {
+    writeSecurityStore(this._routinesFile(), "routine definitions", map);
+  }
+
+  _withDefinitionLock(callback) {
     this._ensureDir();
-    fs.writeFileSync(
+    return withFileLock(
       this._routinesFile(),
-      JSON.stringify(map, null, 2),
-      "utf-8",
+      () => callback(this._readRoutines()),
+      { failIfUnavailable: true },
     );
   }
 
-  /**
-   * @param {object} def { name, prompt, trigger: {kind, cron?, at?, repo?, events?} }
-   */
-  create(def = {}) {
-    const name = String(def.name || "").trim();
-    const prompt = String(def.prompt || "").trim();
-    const trigger = def.trigger || {};
-    if (!name) throw new Error("routine needs a name");
-    if (!prompt) throw new Error("routine needs a prompt");
-    if (!ROUTINE_TRIGGER_KINDS.includes(trigger.kind)) {
-      throw new Error(
-        `routine trigger kind must be one of: ${ROUTINE_TRIGGER_KINDS.join(", ")}`,
-      );
-    }
-    if (trigger.kind === "cron") {
-      if (!parseCron(trigger.cron || "")) {
-        throw new Error(`invalid cron expression: ${trigger.cron}`);
-      }
-    }
-    if (trigger.kind === "once") {
-      const at = parseWhen(trigger.at);
-      if (!Number.isFinite(at)) {
-        throw new Error(`invalid --at time: ${trigger.at}`);
-      }
-      trigger.at = at;
-    }
-    if (trigger.kind === "github" && !trigger.repo) {
-      throw new Error("github trigger needs --repo <owner/name>");
+  _resolveFromMap(map, id) {
+    if (map[id]) return map[id];
+    const matches = Object.values(map).filter(
+      (routine) => routine.id.startsWith(id) || routine.name === id,
+    );
+    if (matches.length === 1) return matches[0];
+    if (matches.length > 1) {
+      throw new Error(`routine "${id}" is ambiguous (${matches.length} match)`);
     }
+    return null;
+  }
 
+  _createInMap(map, def) {
+    const definition = normalizeRoutineDefinition(def);
     const routine = {
       id: shortId(),
-      name,
-      prompt,
-      trigger,
+      ...definition,
       enabled: true,
       createdAt: this._now(),
       lastFiredAt: null,
       lastSeenGithubEventId: null,
     };
-    const map = this._readRoutines();
     map[routine.id] = routine;
-    this._writeRoutines(map);
     return routine;
   }
 
+  /**
+   * @param {object} def { name, prompt, trigger: {kind, cron?, at?, repo?, events?} }
+   */
+  create(def = {}) {
+    return this._withDefinitionLock((map) => {
+      const routine = this._createInMap(map, def);
+      this._writeRoutines(map);
+      return routine;
+    });
+  }
+
   list() {
     return Object.values(this._readRoutines()).sort(
       (a, b) => (b.createdAt || 0) - (a.createdAt || 0),
@@ -140,26 +199,26 @@ export class RoutineStore {
 
   get(id) {
     const map = this._readRoutines();
-    if (map[id]) return map[id];
-    // prefix / name match for CLI ergonomics
-    const matches = Object.values(map).filter(
-      (r) => r.id.startsWith(id) || r.name === id,
-    );
-    if (matches.length === 1) return matches[0];
-    if (matches.length > 1) {
-      throw new Error(`routine "${id}" is ambiguous (${matches.length} match)`);
-    }
-    return null;
+    return this._resolveFromMap(map, id);
   }
 
   update(id, patch) {
-    const map = this._readRoutines();
-    const routine = this.get(id);
-    if (!routine) throw new Error(`routine not found: ${id}`);
-    const next = { ...routine, ...patch, id: routine.id };
-    map[routine.id] = next;
-    this._writeRoutines(map);
-    return next;
+    return this._withDefinitionLock((map) => {
+      const routine = this._resolveFromMap(map, id);
+      if (!routine) throw new Error(`routine not found: ${id}`);
+      const next = { ...routine, ...patch, id: routine.id };
+      map[routine.id] = next;
+      this._writeRoutines(map);
+      return next;
+    });
+  }
+
+  updateDefinition(id, definition) {
+    const normalized = normalizeRoutineDefinition(definition);
+    return this.update(id, {
+      ...normalized,
+      lastSeenGithubEventId: null,
+    });
   }
 
   setEnabled(id, enabled) {
@@ -167,12 +226,54 @@ export class RoutineStore {
   }
 
   remove(id) {
-    const map = this._readRoutines();
-    const routine = this.get(id);
-    if (!routine) throw new Error(`routine not found: ${id}`);
-    delete map[routine.id];
-    this._writeRoutines(map);
-    return routine;
+    return this._withDefinitionLock((map) => {
+      const routine = this._resolveFromMap(map, id);
+      if (!routine) throw new Error(`routine not found: ${id}`);
+      delete map[routine.id];
+      this._writeRoutines(map);
+      return routine;
+    });
+  }
+
+  createIfRevision(expectedRevision, revisionOfMap, definition) {
+    return this._withDefinitionLock((map) => {
+      if (revisionOfMap(map) !== expectedRevision) {
+        const error = new Error("routine collection changed before create");
+        error.code = "ROUTINE_REVISION_CONFLICT";
+        throw error;
+      }
+      const routine = this._createInMap(map, definition);
+      this._writeRoutines(map);
+      return routine;
+    });
+  }
+
+  readIfRevision(id, expectedRevision, revisionOfRoutine) {
+    return this._withDefinitionLock((map) => {
+      const routine = map[id];
+      if (!routine) throw new Error(`routine not found: ${id}`);
+      if (revisionOfRoutine(routine) !== expectedRevision) {
+        const error = new Error(`routine changed before action: ${id}`);
+        error.code = "ROUTINE_REVISION_CONFLICT";
+        throw error;
+      }
+      return structuredClone(routine);
+    });
+  }
+
+  mutateIfRevision(id, expectedRevision, revisionOfRoutine, mutation) {
+    return this._withDefinitionLock((map) => {
+      const routine = map[id];
+      if (!routine) throw new Error(`routine not found: ${id}`);
+      if (revisionOfRoutine(routine) !== expectedRevision) {
+        const error = new Error(`routine changed before mutation: ${id}`);
+        error.code = "ROUTINE_REVISION_CONFLICT";
+        throw error;
+      }
+      const result = mutation(routine, map);
+      this._writeRoutines(map);
+      return result;
+    });
   }
 
   /** Routines the driver should fire now (cron due / once reached). */
@@ -204,13 +305,24 @@ export class RoutineStore {
   }
 
   recordRunStart(routineId, meta = {}) {
-    const runId = `run-${Date.now().toString(36)}-${randomBytes(3).toString("hex")}`;
+    const runId =
+      typeof meta.runId === "string" && meta.runId.trim()
+        ? meta.runId.trim()
+        : `run-${Date.now().toString(36)}-${randomBytes(3).toString("hex")}`;
+    if (
+      runId.length > 512 ||
+      [...runId].some((char) => char.codePointAt(0) < 32)
+    ) {
+      throw new Error("routine runId is invalid");
+    }
     this._appendRun({
       type: "start",
       runId,
       routineId,
       trigger: meta.trigger || null,
       pid: meta.pid || null,
+      schedulerOccurrenceId: meta.schedulerOccurrenceId || null,
+      schedulerSnapshotDigest: meta.schedulerSnapshotDigest || null,
       startedAt: this._now(),
     });
     return runId;
@@ -263,6 +375,15 @@ export class RoutineStore {
       .map(({ type: _t, ...rest }) => rest);
   }
 
+  getRun(runId) {
+    if (typeof runId !== "string" || runId.length === 0) return null;
+    return (
+      this.listRuns({ limit: Number.MAX_SAFE_INTEGER }).find(
+        (run) => run.runId === runId,
+      ) || null
+    );
+  }
+
   /** Per-routine aggregate for `cc routine list`: runs, ok/failed, cost. */
   summarize(routineId) {
     const runs = this.listRuns({ routineId, limit: 1000 });
@@ -286,10 +407,51 @@ export class RoutineStore {
  * lastFiredAt (and disable a fired `once`). `runAgent({prompt})` must resolve
  * `{ exitCode, output, usage?, costUsd?, pid? }`.
  */
-export async function fireRoutine(store, routine, runAgent, meta = {}) {
+export async function executeRoutine(store, routine, runAgent, meta = {}) {
+  const requestedRunId =
+    typeof meta.runId === "string" && meta.runId.trim()
+      ? meta.runId.trim()
+      : null;
+  const existing = requestedRunId ? store.getRun(requestedRunId) : null;
+  if (existing) {
+    if (existing.routineId !== routine.id) {
+      const error = new Error("routine runId is bound to another routine");
+      error.code = "ROUTINE_RUN_ID_CONFLICT";
+      error.retryable = false;
+      throw error;
+    }
+    if (existing.status === "running") {
+      const error = new Error(
+        "routine run outcome is unknown; refusing duplicate execution",
+      );
+      error.code = "ROUTINE_RUN_OUTCOME_UNKNOWN";
+      error.retryable = false;
+      throw error;
+    }
+    const current = store.get(routine.id);
+    if (current) {
+      store.update(routine.id, {
+        lastFiredAt: existing.startedAt,
+        ...(current.trigger.kind === "once" ? { enabled: false } : {}),
+      });
+    }
+    return {
+      runId: existing.runId,
+      status: existing.status,
+      exitCode: existing.exitCode,
+      usage: existing.usage || null,
+      costUsd: Number.isFinite(existing.costUsd) ? existing.costUsd : null,
+      durationMs: existing.durationMs ?? null,
+      recovered: true,
+    };
+  }
+
   const startedAt = store._now();
   const runId = store.recordRunStart(routine.id, {
     trigger: meta.trigger || routine.trigger.kind,
+    ...(requestedRunId ? { runId: requestedRunId } : {}),
+    schedulerOccurrenceId: meta.schedulerOccurrenceId || null,
+    schedulerSnapshotDigest: meta.schedulerSnapshotDigest || null,
   });
   let result;
   try {
@@ -316,7 +478,19 @@ export async function fireRoutine(store, routine, runAgent, meta = {}) {
     lastFiredAt: startedAt,
     ...(routine.trigger.kind === "once" ? { enabled: false } : {}),
   });
-  return runId;
+  return {
+    runId,
+    status: result.exitCode === 0 ? "ok" : "failed",
+    exitCode: result.exitCode,
+    usage: result.usage || null,
+    costUsd: Number.isFinite(result.costUsd) ? result.costUsd : null,
+    durationMs: store._now() - startedAt,
+  };
+}
+
+export async function fireRoutine(store, routine, runAgent, meta = {}) {
+  const execution = await executeRoutine(store, routine, runAgent, meta);
+  return execution.runId;
 }
 
 /**