chainlesschain 0.163.4 → 0.163.5

package/src/lib/cowork-cron.js

@@ -53,6 +53,33 @@ export const _deps = {
   runTask: null, // injected at runtime to avoid circular import
 };
 
+export const COWORK_SCHEDULER_UNKNOWN_LEASE_EXPIRES_AT =
+  "9999-12-31T23:59:59.999Z";
+
+function coworkSchedulerError(
+  code,
+  message,
+  { retryable = false, retryAt } = {},
+) {
+  const error = new Error(message);
+  error.code = code;
+  error.retryable = retryable;
+  if (retryAt !== undefined) error.retryAt = retryAt;
+  return error;
+}
+
+function normalizedDate(value, label) {
+  const date =
+    value instanceof Date ? new Date(value.getTime()) : new Date(value);
+  if (!Number.isFinite(date.getTime())) {
+    throw coworkSchedulerError(
+      "COWORK_SCHEDULER_TIME_INVALID",
+      `${label} must be a valid date`,
+    );
+  }
+  return date;
+}
+
 // ─── Cron parser ─────────────────────────────────────────────────────────────
 
 const FIELD_RANGES = [
@@ -293,9 +320,7 @@ function _withScheduleLock(cwd, body) {
 
 /** Atomically replace the full schedule list under a fail-closed lock. */
 export function saveSchedules(cwd, schedules) {
-  return _withScheduleLock(cwd, () =>
-    _saveSchedulesUnlocked(cwd, schedules),
-  );
+  return _withScheduleLock(cwd, () => _saveSchedulesUnlocked(cwd, schedules));
 }
 
 // ─── CRUD ────────────────────────────────────────────────────────────────────
@@ -363,6 +388,191 @@ export function updateScheduleRunState(cwd, id, { lastRunAt, lastStatus }) {
   });
 }
 
+/** Return one schedule by id, or null when it does not exist. */
+export function getSchedule(cwd, id) {
+  if (typeof id !== "string" || id.length === 0) return null;
+  return (
+    loadSchedules(cwd, { failOnMalformed: true }).find(
+      (schedule) => schedule.id === id,
+    ) || null
+  );
+}
+
+/**
+ * Bind a scheduler-kernel occurrence before starting the Cowork task.
+ * The same JSONL lock used by the legacy driver closes both old-first and
+ * new-first claim races during migration.
+ */
+export function bindSchedulerScheduleFire(
+  cwd,
+  id,
+  { deliveryId, occurrenceId, snapshotDigest, attempt, at = _deps.now() } = {},
+) {
+  if (
+    typeof deliveryId !== "string" ||
+    typeof occurrenceId !== "string" ||
+    typeof snapshotDigest !== "string" ||
+    deliveryId.length === 0 ||
+    occurrenceId.length === 0 ||
+    snapshotDigest.length === 0 ||
+    !Number.isSafeInteger(attempt) ||
+    attempt < 1
+  ) {
+    throw coworkSchedulerError(
+      "COWORK_SCHEDULER_BINDING_INVALID",
+      "Cowork scheduler binding requires deliveryId, occurrenceId, snapshotDigest, and a positive attempt",
+    );
+  }
+  const now = normalizedDate(at, "cowork scheduler binding time");
+  const nowMs = now.getTime();
+  return _withScheduleLock(cwd, () => {
+    const schedules = loadSchedules(cwd, { failOnMalformed: true });
+    const schedule = schedules.find((entry) => entry.id === id);
+    if (!schedule) {
+      throw coworkSchedulerError(
+        "COWORK_SCHEDULER_SCHEDULE_NOT_FOUND",
+        `Cowork schedule does not exist: ${id}`,
+      );
+    }
+    const prior = schedule.schedulerExecution;
+    if (prior?.status === "running") {
+      throw coworkSchedulerError(
+        "COWORK_SCHEDULER_OUTCOME_UNKNOWN",
+        `Cowork schedule outcome is unknown: ${id}`,
+      );
+    }
+    if (
+      prior?.status === "succeeded" &&
+      prior.occurrenceId === occurrenceId &&
+      prior.snapshotDigest === snapshotDigest
+    ) {
+      return schedule;
+    }
+    // A legacy runner may have completed after the kernel enqueued this fire
+    // but before it acquired the JSONL lock. Its durable delivery id is
+    // terminal evidence for the same logical fire, so never overwrite it with
+    // a new scheduler claim.
+    if (schedule.lastDeliveryId === deliveryId) return schedule;
+
+    const active = schedule.activeDelivery;
+    const activeExpiresAt = Date.parse(active?.leaseExpiresAt || "");
+    if (active && Number.isFinite(activeExpiresAt) && activeExpiresAt > nowMs) {
+      throw coworkSchedulerError(
+        "COWORK_SCHEDULER_LEGACY_CLAIM_ACTIVE",
+        `Cowork schedule is already claimed: ${id}`,
+        { retryable: true, retryAt: activeExpiresAt },
+      );
+    }
+
+    const fence =
+      Math.max(
+        Number(schedule.deliveryFence) || 0,
+        Number(active?.fence) || 0,
+      ) + 1;
+    schedule.deliveryFence = fence;
+    schedule.activeDelivery = {
+      deliveryId,
+      ownerId: `scheduler:${occurrenceId}:${attempt}`,
+      fence,
+      claimedAt: now.toISOString(),
+      leaseExpiresAt: COWORK_SCHEDULER_UNKNOWN_LEASE_EXPIRES_AT,
+    };
+    schedule.schedulerExecution = {
+      deliveryId,
+      occurrenceId,
+      snapshotDigest,
+      attempt,
+      status: "running",
+      startedAt: now.toISOString(),
+    };
+    _saveSchedulesUnlocked(cwd, schedules);
+    return schedule;
+  });
+}
+
+/**
+ * Atomically settle scheduler evidence and the legacy Cowork delivery state.
+ * A known failure may keep a short legacy-visible fence until retryAt; an
+ * unknown outcome never calls this function and therefore remains fenced.
+ */
+export function completeSchedulerScheduleFire(
+  cwd,
+  id,
+  {
+    deliveryId,
+    occurrenceId,
+    snapshotDigest,
+    attempt,
+    outcome,
+    result = null,
+    error = null,
+    retryAt,
+    at = _deps.now(),
+  } = {},
+) {
+  if (!["succeeded", "failed"].includes(outcome)) {
+    throw coworkSchedulerError(
+      "COWORK_SCHEDULER_OUTCOME_INVALID",
+      "Cowork scheduler outcome must be succeeded or failed",
+    );
+  }
+  const now = normalizedDate(at, "cowork scheduler completion time");
+  const retryAtMs =
+    retryAt === undefined || retryAt === null ? null : Number(retryAt);
+  if (retryAtMs !== null && !Number.isSafeInteger(retryAtMs)) {
+    throw coworkSchedulerError(
+      "COWORK_SCHEDULER_RETRY_TIME_INVALID",
+      "Cowork scheduler retryAt must be a safe epoch millisecond",
+    );
+  }
+  return _withScheduleLock(cwd, () => {
+    const schedules = loadSchedules(cwd, { failOnMalformed: true });
+    const schedule = schedules.find((entry) => entry.id === id);
+    if (!schedule) {
+      throw coworkSchedulerError(
+        "COWORK_SCHEDULER_SCHEDULE_NOT_FOUND",
+        `Cowork schedule does not exist: ${id}`,
+      );
+    }
+    const evidence = schedule.schedulerExecution;
+    if (
+      !evidence ||
+      evidence.deliveryId !== deliveryId ||
+      evidence.occurrenceId !== occurrenceId ||
+      evidence.snapshotDigest !== snapshotDigest ||
+      evidence.attempt !== attempt ||
+      evidence.status !== "running"
+    ) {
+      throw coworkSchedulerError(
+        "COWORK_SCHEDULER_BINDING_MISMATCH",
+        `Cowork scheduler evidence does not match the active claim: ${id}`,
+      );
+    }
+
+    schedule.schedulerExecution = {
+      ...evidence,
+      status: outcome,
+      endedAt: now.toISOString(),
+      ...(outcome === "succeeded" ? { result } : { error }),
+    };
+    if (outcome === "succeeded") {
+      schedule.lastDeliveryId = deliveryId;
+      schedule.lastRunAt = now.toISOString();
+      schedule.lastStatus = result?.status || "completed";
+      schedule.activeDelivery = null;
+    } else if (retryAtMs !== null && retryAtMs > now.getTime()) {
+      schedule.activeDelivery = {
+        ...schedule.activeDelivery,
+        leaseExpiresAt: new Date(retryAtMs).toISOString(),
+      };
+    } else {
+      schedule.activeDelivery = null;
+    }
+    _saveSchedulesUnlocked(cwd, schedules);
+    return schedule;
+  });
+}
+
 /**
  * Claim one concrete cron fire before launching its side effect. The persisted
  * delivery id prevents two scheduler processes from running the same fire; an
@@ -564,9 +774,7 @@ export class CoworkCronScheduler {
         this._emit({ type: "invalid-cron", id: s.id, error: err.message });
         continue;
       }
-      const fireKey = `${s.id}:${
-        matcher.hasSeconds ? _secondKey(now) : _minuteKey(now)
-      }`;
+      const fireKey = coworkCronFireKey(s, now);
       if (this._firedKeys.has(fireKey)) continue;
       if (this._running.has(s.id)) continue;
       const isDue = matcher(now);
@@ -634,27 +842,30 @@ export class CoworkCronScheduler {
       deliveryId: claim.deliveryId,
     });
 
-    const renewal = setInterval(() => {
-      try {
-        const renewed = renewScheduleFire(this.cwd, schedule.id, claim, {
-          leaseMs: this.leaseMs,
-        });
-        if (!renewed) {
+    const renewal = setInterval(
+      () => {
+        try {
+          const renewed = renewScheduleFire(this.cwd, schedule.id, claim, {
+            leaseMs: this.leaseMs,
+          });
+          if (!renewed) {
+            this._emit({
+              type: "schedule-lease-lost",
+              id: schedule.id,
+              deliveryId: claim.deliveryId,
+            });
+          }
+        } catch (err) {
           this._emit({
-            type: "schedule-lease-lost",
+            type: "schedule-lease-renewal-failed",
             id: schedule.id,
             deliveryId: claim.deliveryId,
+            error: err.message,
           });
         }
-      } catch (err) {
-        this._emit({
-          type: "schedule-lease-renewal-failed",
-          id: schedule.id,
-          deliveryId: claim.deliveryId,
-          error: err.message,
-        });
-      }
-    }, Math.max(1000, Math.floor(this.leaseMs / 3)));
+      },
+      Math.max(1000, Math.floor(this.leaseMs / 3)),
+    );
     renewal.unref?.();
 
     let result = null;
@@ -718,12 +929,19 @@ export class CoworkCronScheduler {
   }
 }
 
-function _minuteKey(date) {
+export function coworkCronMinuteKey(date) {
   return `${date.getFullYear()}-${date.getMonth()}-${date.getDate()}-${date.getHours()}-${date.getMinutes()}`;
 }
 
-function _secondKey(date) {
-  return `${_minuteKey(date)}-${date.getSeconds()}`;
+export function coworkCronSecondKey(date) {
+  return `${coworkCronMinuteKey(date)}-${date.getSeconds()}`;
+}
+
+export function coworkCronFireKey(schedule, date) {
+  const matcher = parseCron(schedule.cron);
+  return `${schedule.id}:${
+    matcher.hasSeconds ? coworkCronSecondKey(date) : coworkCronMinuteKey(date)
+  }`;
 }
 
 // =====================================================================

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/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/routine-store.js

@@ -204,13 +204,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 +274,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 +306,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 +377,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;
 }
 
 /**