chainlesschain 0.163.7 → 0.164.0

package/src/lib/background-interaction-resolver.js

@@ -109,6 +109,11 @@ export function createBackgroundInteractionClient(options = {}) {
   let sequence = 0;
   let closed = false;
 
+  const refChannel = () => processLike?.channel?.ref?.();
+  const unrefIdleChannel = () => {
+    if (pending.size === 0) processLike?.channel?.unref?.();
+  };
+
   const removeMessageListener = () => {
     if (typeof processLike?.off === "function") {
       processLike.off("message", onMessage);
@@ -122,6 +127,7 @@ export function createBackgroundInteractionClient(options = {}) {
     entry.settled = true;
     clearTimeout(entry.timer);
     pending.delete(entry.requestId);
+    unrefIdleChannel();
     action(value);
   }
 
@@ -204,6 +210,11 @@ export function createBackgroundInteractionClient(options = {}) {
         }, timeoutMs);
         entry.timer.unref?.();
         pending.set(requestId, entry);
+        // The bootstrap channel is unref'd after Agent main is released so a
+        // naturally completed turn can exit. A suspended interaction is live
+        // work, however, and must keep that channel/process alive until its
+        // exact response, timeout, or close settles it.
+        refChannel();
 
         const sent = sendIpc(
           processLike,
@@ -262,6 +273,7 @@ export function createBackgroundInteractionClient(options = {}) {
           protocolError(reason, "INTERACTION_CHANNEL_CLOSED"),
         );
       }
+      unrefIdleChannel();
     },
   };
 }

package/src/lib/background-turn-bootstrap-protocol.js

@@ -0,0 +1,126 @@
+/**
+ * Private worker <-> turn bootstrap protocol.
+ *
+ * The nonce is deliberately confined to the inherited environment and the
+ * dedicated Node IPC channel. It must never be copied into background-agent
+ * state or the attach transport.
+ */
+
+export const BACKGROUND_TURN_BOOTSTRAP_PROTOCOL_VERSION = 1;
+export const BACKGROUND_TURN_BOOTSTRAP_READY =
+  "background-turn-bootstrap-ready";
+export const BACKGROUND_TURN_BOOTSTRAP_RELEASE =
+  "background-turn-bootstrap-release";
+
+export const BACKGROUND_TURN_BOOTSTRAP_ENV = Object.freeze({
+  nonce: "CC_BACKGROUND_TURN_BOOTSTRAP_NONCE",
+  workerGeneration: "CC_BACKGROUND_TURN_BOOTSTRAP_GENERATION",
+  attempt: "CC_BACKGROUND_TURN_BOOTSTRAP_ATTEMPT",
+  testTimeoutMs: "CC_BACKGROUND_TURN_BOOTSTRAP_TEST_TIMEOUT_MS",
+});
+
+const SAFE_BINDING = /^[A-Za-z0-9_-]+$/u;
+
+function requiredBindingString(value, label) {
+  const normalized = typeof value === "string" ? value.trim() : "";
+  if (
+    normalized.length < 1 ||
+    normalized.length > 256 ||
+    !SAFE_BINDING.test(normalized)
+  ) {
+    throw new TypeError(`invalid background turn bootstrap ${label}`);
+  }
+  return normalized;
+}
+
+function requiredPositiveInteger(value, label) {
+  const normalized = Number(value);
+  if (!Number.isSafeInteger(normalized) || normalized < 1) {
+    throw new TypeError(`invalid background turn bootstrap ${label}`);
+  }
+  return normalized;
+}
+
+export function normalizeBackgroundTurnBootstrapAuthority(binding = {}) {
+  return Object.freeze({
+    nonce: requiredBindingString(binding.nonce, "nonce"),
+    workerGeneration: requiredBindingString(
+      binding.workerGeneration,
+      "worker generation",
+    ),
+    attempt: requiredPositiveInteger(binding.attempt, "attempt"),
+  });
+}
+
+export function normalizeBackgroundTurnBootstrapBinding(binding = {}) {
+  return Object.freeze({
+    ...normalizeBackgroundTurnBootstrapAuthority(binding),
+    pid: requiredPositiveInteger(binding.pid, "pid"),
+  });
+}
+
+export function backgroundTurnBootstrapBindingFromEnvironment(
+  environment,
+  pid,
+) {
+  return normalizeBackgroundTurnBootstrapBinding({
+    nonce: environment?.[BACKGROUND_TURN_BOOTSTRAP_ENV.nonce],
+    workerGeneration:
+      environment?.[BACKGROUND_TURN_BOOTSTRAP_ENV.workerGeneration],
+    attempt: environment?.[BACKGROUND_TURN_BOOTSTRAP_ENV.attempt],
+    pid,
+  });
+}
+
+export function createBackgroundTurnBootstrapMessage(type, binding) {
+  if (
+    type !== BACKGROUND_TURN_BOOTSTRAP_READY &&
+    type !== BACKGROUND_TURN_BOOTSTRAP_RELEASE
+  ) {
+    throw new TypeError("invalid background turn bootstrap message type");
+  }
+  return Object.freeze({
+    type,
+    protocolVersion: BACKGROUND_TURN_BOOTSTRAP_PROTOCOL_VERSION,
+    ...normalizeBackgroundTurnBootstrapBinding(binding),
+  });
+}
+
+export function matchesBackgroundTurnBootstrapMessage(
+  message,
+  type,
+  authority,
+) {
+  let expected;
+  let actual;
+  try {
+    expected = normalizeBackgroundTurnBootstrapAuthority(authority);
+    actual = normalizeBackgroundTurnBootstrapBinding(message);
+  } catch {
+    return false;
+  }
+  return (
+    message?.type === type &&
+    message.protocolVersion === BACKGROUND_TURN_BOOTSTRAP_PROTOCOL_VERSION &&
+    actual.nonce === expected.nonce &&
+    actual.workerGeneration === expected.workerGeneration &&
+    actual.attempt === expected.attempt &&
+    (authority.pid === undefined || Number(authority.pid) === actual.pid)
+  );
+}
+
+export function removeBackgroundTurnBootstrapImport(execArgv, moduleUrl) {
+  const expected = `--import=${moduleUrl}`;
+  const values = Array.isArray(execArgv) ? [...execArgv] : [];
+  if (values.filter((value) => value === expected).length !== 1) {
+    throw new Error("background turn bootstrap preload identity is ambiguous");
+  }
+  return values.filter((value) => value !== expected);
+}
+
+export function clearBackgroundTurnBootstrapEnvironment(environment) {
+  if (!environment || typeof environment !== "object") return;
+  for (const key of Object.values(BACKGROUND_TURN_BOOTSTRAP_ENV)) {
+    delete environment[key];
+  }
+}

package/src/lib/cowork-cron.js

@@ -31,12 +31,14 @@
 
 import crypto from "node:crypto";
 import {
-  existsSync,
+  closeSync,
+  fsyncSync,
   mkdirSync,
+  openSync,
   readFileSync,
   renameSync,
   unlinkSync,
-  writeFileSync,
+  writeSync,
 } from "node:fs";
 import { join } from "node:path";
 import {
@@ -47,12 +49,14 @@ import {
 import { withFileLock } from "./with-file-lock.js";
 
 export const _deps = {
-  existsSync,
+  closeSync,
+  fsyncSync,
   mkdirSync,
+  openSync,
   readFileSync,
   renameSync,
   unlinkSync,
-  writeFileSync,
+  writeSync,
   withFileLock,
   now: () => new Date(),
   runTask: null, // injected at runtime to avoid circular import
@@ -543,14 +547,33 @@ function _scheduleFile(cwd) {
 /** Load all schedules from disk. Returns [] if the file doesn't exist. */
 export function loadSchedules(cwd, { failOnMalformed = false } = {}) {
   const file = _scheduleFile(cwd);
-  if (!_deps.existsSync(file)) return [];
-  const raw = _deps.readFileSync(file, "utf-8");
+  let raw;
+  try {
+    raw = _deps.readFileSync(file, "utf-8");
+  } catch (cause) {
+    if (cause?.code === "ENOENT") return [];
+    const error = new Error(`cowork schedule store read failed: ${file}`, {
+      cause,
+    });
+    error.code = "COWORK_SCHEDULE_STORE_READ_FAILED";
+    error.filePath = file;
+    if (typeof cause?.code === "string") error.fsCode = cause.code;
+    throw error;
+  }
   const out = [];
   for (const line of raw.split("\n")) {
     const trimmed = line.trim();
     if (!trimmed) continue;
     try {
-      out.push(JSON.parse(trimmed));
+      const schedule = JSON.parse(trimmed);
+      if (
+        !schedule ||
+        typeof schedule !== "object" ||
+        Array.isArray(schedule)
+      ) {
+        throw new TypeError("schedule entry must be an object");
+      }
+      out.push(schedule);
     } catch (cause) {
       if (failOnMalformed) {
         const error = new Error(
@@ -573,20 +596,68 @@ function _prepareScheduleDir(cwd) {
 }
 
 function _saveSchedulesUnlocked(cwd, schedules) {
-  _prepareScheduleDir(cwd);
+  const directory = _prepareScheduleDir(cwd);
   const file = _scheduleFile(cwd);
   const body = schedules.map((s) => JSON.stringify(s)).join("\n");
+  const contents = Buffer.from(body ? `${body}\n` : "", "utf8");
   const tmp = `${file}.${process.pid}.${crypto.randomUUID()}.tmp`;
+  let descriptor = null;
+  let renamed = false;
   try {
-    _deps.writeFileSync(tmp, body ? body + "\n" : "", "utf-8");
+    descriptor = _deps.openSync(tmp, "wx", 0o600);
+    let offset = 0;
+    while (offset < contents.length) {
+      const written = _deps.writeSync(
+        descriptor,
+        contents,
+        offset,
+        contents.length - offset,
+        null,
+      );
+      if (!Number.isSafeInteger(written) || written <= 0) {
+        const cause = new Error("write returned no progress");
+        cause.code = "EIO";
+        throw cause;
+      }
+      offset += written;
+    }
+    _deps.fsyncSync(descriptor);
+    _deps.closeSync(descriptor);
+    descriptor = null;
     _deps.renameSync(tmp, file);
+    renamed = true;
+
+    if (process.platform !== "win32") {
+      const directoryDescriptor = _deps.openSync(directory, "r");
+      try {
+        _deps.fsyncSync(directoryDescriptor);
+      } finally {
+        _deps.closeSync(directoryDescriptor);
+      }
+    }
   } catch (error) {
-    try {
-      _deps.unlinkSync(tmp);
-    } catch {
-      // Preserve the original persistence error.
+    if (descriptor !== null) {
+      try {
+        _deps.closeSync(descriptor);
+      } catch {
+        // Preserve the original persistence error.
+      }
     }
-    throw error;
+    if (!renamed) {
+      try {
+        _deps.unlinkSync(tmp);
+      } catch {
+        // Best-effort orphan cleanup; the authoritative file is unchanged.
+      }
+    }
+    const persistenceError =
+      error && (typeof error === "object" || typeof error === "function")
+        ? error
+        : new Error(`Cowork schedule persistence failed: ${String(error)}`, {
+            cause: error,
+          });
+    persistenceError.commitState = renamed ? "unknown" : "not-committed";
+    throw persistenceError;
   }
 }