@dynamicagents/plugins 0.13.0 → 0.14.0

package/dist/claude-code/cards.d.ts

@@ -50,4 +50,6 @@ export declare function thinkingCard(durationMs: number | undefined, messageId:
 export declare function initCard(event: InitEvent): Card;
 /** A session's end, with what its `result` line says about it. */
 export declare function resultCard(result: ClaudeCodeResult): Card;
+/** A session its run gave up on before reading its end, and why. */
+export declare function lostCard(why: string): Card;
 export {};

package/dist/claude-code/cards.js

@@ -261,6 +261,17 @@ export function resultCard(result) {
         }
     };
 }
+/** A session its run gave up on before reading its end, and why. */
+export function lostCard(why) {
+    return {
+        text: "Session ended before its run read it to the end",
+        detail: {
+            title: "Session",
+            status: "error",
+            sections: [section("Why", why, "text")]
+        }
+    };
+}
 function duration(ms) {
     const s = Math.round(ms / 1000);
     if (s < 60)

package/dist/claude-code/model.js

@@ -51,8 +51,9 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
 import { isPlatformTransientError } from "agents";
+import { lostCard } from "./cards.js";
 import { claudeCodeSession, requireCredentials } from "./session.js";
-import { execIdFor, followUpExecIdFor } from "./run.js";
+import { AttachGivenUpError, execIdFor, followUpExecIdFor } from "./run.js";
 /** Zeroed: the session's tokens are the CLI's context, not this conversation's. */
 const USAGE = {
     inputTokens: {
@@ -138,6 +139,25 @@ export function claudeCodeModel(options) {
                 },
                 ...(signal ? { signal } : {})
             };
+            /**
+             * The session's end card, filed where the run gives up on a session it will
+             * never read to its end: a re-attach given up on, or a cancel that stops it.
+             * Without it the transcript shows a session that never ended, and a retry's
+             * start reads as more of it.
+             *
+             * Not on any other throw: a transient one is retried by re-entering this
+             * turn, which reads on from the stored cursor. Keyed on the exec, so a card
+             * filed twice is filed once.
+             */
+            const fileLost = async (execId, reason) => {
+                const card = lostCard(reason instanceof Error ? reason.message : String(reason));
+                await options
+                    .note(`${execId}:lost`, card.text, card.detail)
+                    .catch((err) => console.warn("[claude-code] a lost session's end was not filed", {
+                    execId,
+                    err: String(err)
+                }));
+            };
             /**
              * Drain one exec to its end, starting it or re-attaching from the cursor.
              *
@@ -164,6 +184,8 @@ export function claudeCodeModel(options) {
                         const after = await storage.get(KEYS.cursor);
                         const moved = after?.execId === execId &&
                             (cursor?.execId !== execId || after.seq > cursor.seq);
+                        if (err instanceof AttachGivenUpError)
+                            await fileLost(execId, err);
                         if (!isStreamCut(err) || signal?.aborted || (stalled && !moved))
                             throw err;
                         stalled = !moved;
@@ -184,7 +206,9 @@ export function claudeCodeModel(options) {
                         runId,
                         err: String(err)
                     }));
-                    throw signal?.reason ?? new Error("the session was stopped");
+                    const reason = signal?.reason ?? new Error("the session was stopped");
+                    await fileLost(execId, reason);
+                    throw reason;
                 }
                 return {
                     exitCode: outcome.exitCode,

package/dist/claude-code/run.d.ts

@@ -403,6 +403,14 @@ export declare function isExecBusy(err: unknown): boolean;
  * nothing to recover and retrying only discovers that again.
  */
 export declare function isExecLost(err: unknown): boolean;
+/**
+ * {@link attachRun} giving up on a subscriber that was never released. Unlike
+ * a transient failure, nothing retries it: the run fails, and its host stops
+ * the session.
+ */
+export declare class AttachGivenUpError extends Error {
+    name: string;
+}
 /**
  * Start a session, detached.
  *
@@ -426,8 +434,18 @@ export declare function startRun(runtime: SessionRuntime, options: LaunchOptions
     /** Stops the fallback's wait — see {@link AttachOptions.signal}. */
     signal?: AbortSignal;
 }): Promise<WorkspaceRuntimeExecHandle<"utf8">>;
-/** The clock and the wait, injectable so a spec can drive the bound. */
 export interface AttachOptions {
+    /**
+     * How long to wait out a subscriber that has not been released: the
+     * session's own `timeoutMs`.
+     *
+     * Giving up fails the run, and a failed run is stopped by its host — so a
+     * shorter bound kills a healthy session, and past this one the session is
+     * over anyway. How long a release actually took is logged when the attach
+     * lands.
+     */
+    maxWaitMs: number;
+    /** The clock and the wait, injectable so a spec can drive the bound. */
     now?: () => number;
     wait?: (ms: number) => Promise<void>;
     /** Stops the wait — see `DrainOptions.signal`. */
@@ -447,10 +465,9 @@ export interface AttachOptions {
  *
  * Everything else is rethrown on the first look, `EEXEC_LOST` above all: it is
  * the runtime saying the container was replaced, `resume` turns it into a report
- * for the model, and a retry loop would sit on it for {@link ATTACH_MAX_MS}
- * learning nothing.
+ * for the model, and a retry loop would sit on it learning nothing.
  */
-export declare function attachRun(runtime: SessionRuntime, cursor: DrainCursor, options?: AttachOptions): Promise<WorkspaceRuntimeExecHandle<"utf8">>;
+export declare function attachRun(runtime: SessionRuntime, cursor: DrainCursor, options: AttachOptions): Promise<WorkspaceRuntimeExecHandle<"utf8">>;
 /**
  * Drain a session to its end.
  *

package/dist/claude-code/run.js

@@ -334,6 +334,10 @@ export function isExecLost(err) {
  * caller can await to know the attachment is gone. {@link attachRun} answers by
  * waiting rather than by failing.
  *
+ * A workspace object reset by the platform leaves its dead connection's
+ * attachment held far longer: past thirty seconds, with the session mid-call
+ * and printing nothing.
+ *
  * **Matched on the message, not on a code, and that is not laziness.** This one
  * is raised inside the container image rather than by the runtime client: the
  * string appears nowhere in the Worker bundle, and it arrives here as a plain
@@ -350,29 +354,18 @@ function isExecSubscribed(err) {
         e.message.includes("already has a live subscriber"));
 }
 /**
- * How long {@link attachRun} waits out a subscriber that has not been released.
- *
- * Bounded, because what it is waiting on may not be a teardown at all: an
- * isolate that is genuinely wedged holding the stream releases it when it dies,
- * and nothing here can tell that apart from one that is a moment from
- * finishing. Exceeding this rethrows, so the turn fails and Think's recovery
- * retries it on a fresh isolate — which is the right escalation, and the one
- * this whole mechanism exists to stop being the *first* resort.
- *
- * Sized well above what the race costs in practice. The race normally clears
- * on the first or second look, and a deployment where it took fifteen seconds is
- * what this is sized to outlast.
+ * {@link attachRun} giving up on a subscriber that was never released. Unlike
+ * a transient failure, nothing retries it: the run fails, and its host stops
+ * the session.
  */
-const ATTACH_MAX_MS = 30_000;
+export class AttachGivenUpError extends Error {
+    name = "AttachGivenUpError";
+}
 /** The first gap between attach attempts, doubled up to {@link ATTACH_CAP_MS}. */
 const ATTACH_BACKOFF_MS = 250;
 /**
- * The ceiling on that doubling.
- *
- * Without it the last gap before {@link ATTACH_MAX_MS} would be most of the
- * budget, so a subscriber released early in it would still be waited out to the
- * end. What this buys is that the wait ends soon after the release, rather than
- * at the next power of two.
+ * The ceiling on that doubling, so the wait ends soon after the release rather
+ * than at the next power of two.
  */
 const ATTACH_CAP_MS = 2_000;
 /**
@@ -408,7 +401,8 @@ export async function startRun(runtime, options) {
             throw err;
         console.info("[claude-code] a session is already running under this id — attaching", { execId: options.execId });
         return await attachRun(runtime, freshCursor(options.execId), {
-            signal: options.signal
+            signal: options.signal,
+            maxWaitMs: options.timeoutMs
         });
     }
 }
@@ -426,17 +420,19 @@ export async function startRun(runtime, options) {
  *
  * Everything else is rethrown on the first look, `EEXEC_LOST` above all: it is
  * the runtime saying the container was replaced, `resume` turns it into a report
- * for the model, and a retry loop would sit on it for {@link ATTACH_MAX_MS}
- * learning nothing.
+ * for the model, and a retry loop would sit on it learning nothing.
  */
-export async function attachRun(runtime, cursor, options = {}) {
+export async function attachRun(runtime, cursor, options) {
     const now = options.now ?? Date.now;
     const wait = options.wait ?? sleep;
-    const deadline = now() + ATTACH_MAX_MS;
+    const started = now();
+    const deadline = started + options.maxWaitMs;
     let backoff = ATTACH_BACKOFF_MS;
+    let waited = false;
     for (;;) {
+        let handle;
         try {
-            return await runtime.getExec(cursor.execId, {
+            handle = await runtime.getExec(cursor.execId, {
                 encoding: "utf8",
                 // `0` is a legal seq and also the beginning, so a fresh cursor resumes
                 // from the start either way. A stored cursor names its own place.
@@ -444,24 +440,40 @@ export async function attachRun(runtime, cursor, options = {}) {
             });
         }
         catch (err) {
-            // Rethrown rather than retried once the budget is gone, so the step still
-            // fails on a subscriber that is never coming back — just not first.
-            if (!isExecSubscribed(err) ||
-                now() >= deadline ||
-                options.signal?.aborted)
+            if (!isExecSubscribed(err) || options.signal?.aborted)
                 throw err;
+            if (now() >= deadline) {
+                const waitedMs = now() - started;
+                console.warn("[claude-code] gave up waiting out the previous drain", {
+                    execId: cursor.execId,
+                    waitedMs
+                });
+                throw new AttachGivenUpError("claude-code: the session's stream to its container was cut, and the " +
+                    "container held on to the old connection for the whole of the " +
+                    "session's time limit, so it could not be re-attached. The cut is " +
+                    "the platform's, not the session's; what the session did so far is " +
+                    "in its workspace and on the transcript.", { cause: err });
+            }
+            // Logged once each way rather than per look: how long a release takes
+            // is the number worth reading, and over a session-long bound a line per
+            // look would bury it.
+            if (!waited) {
+                waited = true;
+                console.info("[claude-code] the previous drain is still attached — waiting", { execId: cursor.execId, maxWaitMs: options.maxWaitMs });
+            }
             // Clamped to what is left, so the last gap lands *on* the deadline rather
-            // than past it. Uncapped, a schedule whose final doubling straddles the
-            // bound would take one more look on the far side of it — and the bound
-            // would be a number in a comment rather than one the code keeps.
-            const waitMs = Math.min(backoff, deadline - now());
-            // One line per wait, not per attempt: this is the condition whose
-            // frequency is worth watching, and it went unnamed in the logs for as
-            // long as retries were absorbing it one at a time.
-            console.info("[claude-code] the previous drain is still attached — waiting", { execId: cursor.execId, waitMs });
-            await wait(waitMs);
+            // than past it, and the bound is one the code keeps.
+            await wait(Math.min(backoff, deadline - now()));
             backoff = Math.min(backoff * 2, ATTACH_CAP_MS);
+            continue;
+        }
+        if (waited) {
+            console.info("[claude-code] attached after waiting out the previous drain", {
+                execId: cursor.execId,
+                waitedMs: now() - started
+            });
         }
+        return handle;
     }
 }
 /**

package/dist/claude-code/session.js

@@ -186,7 +186,10 @@ export function claudeCodeSession(config) {
             try {
                 let handle;
                 try {
-                    handle = await attachRun(runtime, cursor, { signal: sinks.signal });
+                    handle = await attachRun(runtime, cursor, {
+                        signal: sinks.signal,
+                        maxWaitMs: timeoutMs
+                    });
                 }
                 catch (err) {
                     if (!isExecLost(err))

package/dist/claude-code/verified.d.ts

@@ -12,4 +12,4 @@
  * and the capture move together. AGENTS.md's "Updating Claude Code" is the
  * procedure.
  */
-export declare const VERIFIED_CLAUDE_CODE_VERSION = "2.1.289";
+export declare const VERIFIED_CLAUDE_CODE_VERSION = "2.1.296";

package/dist/claude-code/verified.js

@@ -12,4 +12,4 @@
  * and the capture move together. AGENTS.md's "Updating Claude Code" is the
  * procedure.
  */
-export const VERIFIED_CLAUDE_CODE_VERSION = "2.1.289";
+export const VERIFIED_CLAUDE_CODE_VERSION = "2.1.296";

package/dist/workspace/container-deps.d.ts

@@ -1,6 +1,10 @@
 import { type Workspace } from "@cloudflare/computer";
 /** Written into the tree by a successful host install; see `./install-job.ts`. */
 export declare const INSTALLED_MARKER = ".da-installed";
+/** Every package root with a tree on this container's disk, one per line. */
+export declare const DEPS_ROOTS_COMMAND = "for f in /var/lib/workspace-deps/*.root; do [ -f \"$f\" ] && { cat \"$f\"; echo; }; done; true";
+/** {@link DEPS_ROOTS_COMMAND}'s output as paths, each once. */
+export declare function parseDepsRoots(stdout: string): string[];
 /**
  * The per-container setup, and a read of the marker under `dir`.
  *

package/dist/workspace/container-deps.js

@@ -65,6 +65,11 @@ import { deploymentFault } from "./container-fault.js";
  * this installs ahead of the real binaries on `PATH`. Mounting earlier cannot
  * work: a bootstrap that initialises submodules and installs each of them in one
  * command creates the directories the mounts belong in.
+ *
+ * A container restored from a snapshot (see `./deps-snapshot.ts`) has the trees
+ * on its disk and none of the mounts, which are kernel state. So each mount
+ * records its package root beside its tree, and the setup mounts every recorded
+ * root again before it reads the marker through one.
  */
 /** Where the trees live on the container's disk. */
 const DEPS_DISK = "/var/lib/workspace-deps";
@@ -86,6 +91,23 @@ const WRAPPED = [
 ];
 /** Written into the tree by a successful host install; see `./install-job.ts`. */
 export const INSTALLED_MARKER = ".da-installed";
+/**
+ * The package root a tree belongs to, written beside it as `<tree>.root`.
+ *
+ * Beside rather than inside: `npm ci` empties the tree it installs into, and the
+ * hash a tree is named by cannot be turned back into the path.
+ */
+const ROOT_SUFFIX = ".root";
+/** Every package root with a tree on this container's disk, one per line. */
+export const DEPS_ROOTS_COMMAND = `for f in ${DEPS_DISK}/*${ROOT_SUFFIX}; do [ -f "$f" ] && { cat "$f"; echo; }; done; true`;
+/** {@link DEPS_ROOTS_COMMAND}'s output as paths, each once. */
+export function parseDepsRoots(stdout) {
+    const roots = stdout
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.startsWith("/"));
+    return [...new Set(roots)];
+}
 /**
  * The per-container setup, and a read of the marker under `dir`.
  *
@@ -118,7 +140,7 @@ export function depsSetupCommand(workspaceDir, dir) {
         'nm="$dir/node_modules"',
         'mountpoint -q "$nm" && exit 0',
         `disk="${DEPS_DISK}/$(printf %s "$dir" | sha256sum | cut -c1-16)"`,
-        'mkdir -p "$disk" "$nm" && mount --bind "$disk" "$nm" && exit 0',
+        `mkdir -p "$disk" "$nm" && mount --bind "$disk" "$nm" && { printf %s "$dir" > "$disk${ROOT_SUFFIX}"; exit 0; }`,
         `echo "workspace-deps: could not put $nm on the container's disk" >&2`,
         "exit 1"
     ].join("\n");
@@ -139,6 +161,9 @@ export function depsSetupCommand(workspaceDir, dir) {
         `install -m 755 /tmp/workspace-deps-mount ${MOUNT_HELPER} || exit 1`,
         `printf '%s\\n' ${shellQuote(wrapper)} > /tmp/workspace-deps-wrap`,
         `for tool in ${WRAPPED.join(" ")}; do install -m 755 /tmp/workspace-deps-wrap "${WRAPPER_DIR}/$tool" || exit 1; done`,
+        // A root that is not in this checkout is left alone by the helper, and one
+        // that cannot be mounted reads as no marker below — an install, not a fault.
+        `for f in ${DEPS_DISK}/*${ROOT_SUFFIX}; do [ -f "$f" ] && ${MOUNT_HELPER} "$(cat "$f")"; done`,
         ...(dir
             ? [
                 `echo "MARKER $(cat ${shellQuote(`${dir}/node_modules/${INSTALLED_MARKER}`)} 2>/dev/null || echo -)"`

package/dist/workspace/deps-snapshot.d.ts

@@ -0,0 +1,110 @@
+import type { Workspace } from "@cloudflare/computer";
+export interface DepsSnapshotRecord {
+    /** The platform's snapshot id. */
+    id: string;
+    /** In bytes, as the platform reported it. */
+    size: number;
+    /** The image reference it was taken on — see the file comment. */
+    image: string;
+    /** Where the install ran. */
+    dir: string;
+    /** The install fingerprint its marker holds. */
+    fingerprint: string;
+    /** Every package root with a tree on the disk, and its inputs' digest then. */
+    roots: {
+        dir: string;
+        fingerprint: string | null;
+    }[];
+    /** {@link packageRootSet} of the checkout then. */
+    rootSet: string;
+    at: number;
+}
+/** What a restore is checked against: the install a cold start would run. */
+export interface ExpectedTree {
+    dir: string;
+    fingerprint: string;
+}
+/** A tree an install finished, as its record names it — `at` tells two apart. */
+export interface InstalledTree extends ExpectedTree {
+    at: number;
+}
+export interface DepsSnapshotDeps {
+    storage: DurableObjectStorage;
+    container: () => Container | undefined;
+    /** The image a start from no snapshot would boot. */
+    image: () => string | undefined;
+    workspace: () => Workspace;
+    rootFingerprint: (dir: string) => Promise<string | null>;
+    /** The tree the install record says this container holds. */
+    tree: () => Promise<{
+        dir: string;
+        fingerprint: string | null;
+        at: number;
+    } | undefined>;
+    tag: () => string;
+    id: () => string;
+}
+/**
+ * Which package roots a checkout has, as one digest: every directory under
+ * `dir` with a `package.json`, and the submodules `.gitmodules` declares — one a
+ * bootstrap clones in the container has no `package.json` here until then.
+ */
+export declare function packageRootSet(fs: Workspace["fs"], dir: string): Promise<string>;
+export declare class DepsSnapshot {
+    #private;
+    private readonly deps;
+    readonly launch: {
+        readonly containerSnapshot: ContainerSnapshotRestoreParams | undefined;
+    };
+    constructor(deps: DepsSnapshotDeps);
+    /**
+     * Restore with the next start if the record fits it, and say which record.
+     *
+     * `expected` is a thunk because it reads the checkout, and a workspace with no
+     * snapshot or one from another image should not pay for that.
+     */
+    arm(expected: () => Promise<ExpectedTree | undefined>): Promise<DepsSnapshotRecord | undefined>;
+    /** Forget an armed restore, taken or not. */
+    disarm(): void;
+    /**
+     * Whether the container that came up holds `record`'s tree, judged by the
+     * marker the setup read in it.
+     *
+     * Drops the record when a start took it and the tree is not there; leaves it
+     * when no start did, since nothing was learned about it.
+     */
+    restored(record: DepsSnapshotRecord, marker: string | null | undefined): Promise<boolean>;
+    /**
+     * Snapshot the running container, which has just installed `tree`, after any
+     * snapshot already in flight — a later install's request is never dropped for
+     * an earlier one's.
+     *
+     * Never throws: a container that cannot be snapshotted installs again next
+     * time, which is today's cost and no worse.
+     */
+    take(tree: InstalledTree): Promise<void>;
+    /** Snapshots in flight, finished — for whatever is about to stop the container. */
+    settled(): Promise<void>;
+    /**
+     * The entries that ask for `tree`'s snapshot, for the install to write with
+     * its verdict — see the file comment, and {@link takeDue}.
+     */
+    dueEntries(tree: InstalledTree): Record<string, unknown>;
+    /** Take the snapshot an install asked for, if one is waiting. */
+    takeDue(): Promise<void>;
+    /** The container went, and the disk an asked-for snapshot was of with it. */
+    forgetDue(): Promise<void>;
+    get(): Promise<DepsSnapshotRecord | undefined>;
+    /**
+     * Start from another workspace's snapshot — one taken for the same checkout
+     * path on the same image, as a worktree shares with the checkout it was cut
+     * from.
+     *
+     * Kept out when this workspace's own snapshot already fits, and refused when
+     * the offered one does not.
+     */
+    seed(record: DepsSnapshotRecord, expected: () => Promise<ExpectedTree | undefined>): Promise<{
+        seeded: boolean;
+        reason?: string;
+    }>;
+}