toolcraft 0.0.23 → 0.0.24

package/node_modules/@poe-code/design-system/dist/static/menu.js

@@ -2,13 +2,19 @@ import { color } from "../components/color.js";
 import { symbols } from "../components/symbols.js";
 import { resolveOutputFormat } from "../internal/output-format.js";
 import { getTheme } from "../internal/theme-detect.js";
+function renderMarkdownInline(value) {
+    return value.replaceAll("\r\n", " ").replaceAll("\n", " ").replaceAll("\r", " ");
+}
 export function renderMenu(opts) {
     const format = resolveOutputFormat();
     const selectedIndex = opts.selectedIndex ?? 0;
+    if (!Number.isInteger(selectedIndex) || !Number.isFinite(selectedIndex)) {
+        throw new Error("selectedIndex must be a finite integer.");
+    }
     if (format === "markdown") {
         return [
-            `**${opts.message}**`,
-            ...opts.options.map((option, index) => `- [${index === selectedIndex ? "x" : " "}] ${option.label}`)
+            `**${renderMarkdownInline(opts.message)}**`,
+            ...opts.options.map((option, index) => `- [${index === selectedIndex ? "x" : " "}] ${renderMarkdownInline(option.label)}`)
         ].join("\n");
     }
     if (format === "json") {

package/node_modules/@poe-code/design-system/dist/static/spinner.js

@@ -1,7 +1,7 @@
 import { color } from "../components/color.js";
 import { symbols } from "../components/symbols.js";
 import { resolveOutputFormat } from "../internal/output-format.js";
-export const SPINNER_FRAMES = ["◒", "◐", "◓", "◑"];
+export const SPINNER_FRAMES = Object.freeze(["◒", "◐", "◓", "◑"]);
 export function renderSpinnerFrame(options) {
     const format = resolveOutputFormat();
     if (format === "markdown") {
@@ -16,22 +16,28 @@ export function renderSpinnerFrame(options) {
         })}\n`;
     }
     const frame = options.frame ?? 0;
-    const spinnerChar = color.magenta(SPINNER_FRAMES[frame % SPINNER_FRAMES.length]);
+    const index = ((frame % SPINNER_FRAMES.length) + SPINNER_FRAMES.length) % SPINNER_FRAMES.length;
+    const spinnerChar = color.magenta(SPINNER_FRAMES[index]);
     const timerSuffix = options.timer ? color.dim(` [${options.timer}]`) : "";
     const bar = color.gray(symbols.bar);
     return `${spinnerChar}  ${options.message}${timerSuffix}\n${bar}`;
 }
+function renderMarkdownInline(value) {
+    return value.replaceAll("\r\n", " ").replaceAll("\n", " ").replaceAll("\r", " ");
+}
 export function renderSpinnerStopped(options) {
     const format = resolveOutputFormat();
     if (format === "markdown") {
-        return `- ${options.message}${options.timer ? ` [${options.timer}]` : ""}\n`;
+        return `- ${renderMarkdownInline(options.message)}${options.timer ? ` [${renderMarkdownInline(options.timer)}]` : ""}\n`;
     }
     if (format === "json") {
         return `${JSON.stringify({
             type: "spinner",
             state: "stopped",
             message: options.message,
-            ...(options.timer ? { timer: options.timer } : {})
+            code: options.code ?? 0,
+            ...(options.timer ? { timer: options.timer } : {}),
+            ...(options.subtext ? { subtext: options.subtext } : {})
         })}\n`;
     }
     const code = options.code ?? 0;

package/node_modules/@poe-code/design-system/dist/terminal-markdown/parser/frontmatter.js

@@ -32,7 +32,12 @@ class YamlSubsetParser {
                 throw new FrontmatterParseError("Invalid mapping entry.");
             }
             this.position += 1;
-            result[entry.key] = this.readEntryValue(entry, expectedIndent);
+            Object.defineProperty(result, entry.key, {
+                configurable: true,
+                enumerable: true,
+                value: this.readEntryValue(entry, expectedIndent),
+                writable: true
+            });
         }
         return result;
     }
@@ -345,8 +350,10 @@ function sliceFrontmatterBlock(content, start, end) {
 function startsWithFrontmatterFence(value) {
     return (value.startsWith("---\n") ||
         value.startsWith("---\r\n") ||
+        value.startsWith("---\r") ||
         value.startsWith("\uFEFF---\n") ||
-        value.startsWith("\uFEFF---\r\n"));
+        value.startsWith("\uFEFF---\r\n") ||
+        value.startsWith("\uFEFF---\r"));
 }
 function stripBom(value) {
     return value.startsWith("\uFEFF") ? value.slice(1) : value;

package/node_modules/@poe-code/design-system/dist/terminal-markdown/renderer.js

@@ -6,7 +6,11 @@ import { typography } from "../tokens/typography.js";
 import { widths } from "../tokens/widths.js";
 const lineChar = "─";
 export function render(ast, options = {}) {
-    const width = Math.max(1, options.width ?? process.stdout.columns ?? widths.maxLine);
+    const requestedWidth = options.width ?? process.stdout.columns ?? widths.maxLine;
+    if (!Number.isFinite(requestedWidth) || requestedWidth <= 0) {
+        throw new Error("width must be a positive finite number.");
+    }
+    const width = Math.max(1, requestedWidth);
     const context = {
         width,
         showFrontmatter: options.showFrontmatter ?? false,
@@ -215,7 +219,20 @@ function formatFrontmatterValue(value) {
     if (typeof value === "number" || typeof value === "boolean") {
         return String(value);
     }
-    return JSON.stringify(value);
+    const ancestors = [];
+    return JSON.stringify(value, function (_key, nestedValue) {
+        if (typeof nestedValue !== "object" || nestedValue === null) {
+            return nestedValue;
+        }
+        while (ancestors.length > 0 && ancestors[ancestors.length - 1] !== this) {
+            ancestors.pop();
+        }
+        if (ancestors.includes(nestedValue)) {
+            return "[Circular]";
+        }
+        ancestors.push(nestedValue);
+        return nestedValue;
+    });
 }
 function renderHtml(node, context) {
     const value = stripHtmlTags(node.value).trim();

package/node_modules/@poe-code/design-system/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@poe-code/design-system",
   "version": "0.0.2",
+  "private": true,
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
-    "build": "tsc",
+    "build": "node ../../scripts/guard-package-dist.mjs && tsc",
     "postbuild": "node scripts/smoke-built-exports.cjs",
     "lint": "cd ../.. && eslint packages/design-system --ext ts && tsc -p packages/design-system/tsconfig.json --noEmit",
     "test": "cd ../.. && vitest run $(rg --files packages/design-system/src -g '*.test.ts' | sort | tr '\\n' ' ')",

package/node_modules/@poe-code/process-runner/dist/docker/docker-execution-env.js

@@ -1,12 +1,13 @@
 import { createHash, randomBytes } from "node:crypto";
 import { mkdtempSync, rmSync } from "node:fs";
-import { readFile } from "node:fs/promises";
+import { readdir, readFile, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import { buildDockerRunArgs } from "./args.js";
 import { buildContextArgs, detectContext } from "./context.js";
 import { detectEngine } from "./engine.js";
 import { createHostRunner } from "../host/host-runner.js";
+import { downloadWorkspace as downloadTransferredWorkspace, uploadWorkspace as uploadTransferredWorkspace } from "../workspace-transfer.js";
 const containerCommand = ["sh", "-c", "while :; do sleep 3600; done"];
 export const dockerExecutionEnvFactory = {
     type: "docker",
@@ -53,109 +54,53 @@ export const dockerExecutionEnvFactory = {
         });
     },
     async attach(envId, context) {
-        const engine = detectEngine();
+        const reattachContext = parseDockerReattachContext(context?.reattachContext);
+        const engine = reattachContext?.engine ?? detectEngine();
         return createDockerEnv({
             id: envId,
             spec: createAttachedSpec(context?.cwd),
             runner: createHostRunner(),
             engine,
-            context: detectContext(),
+            context: reattachContext === undefined ? detectContext() : reattachContext.context,
             attachedJobId: context?.jobId
         });
     }
 };
 function createDockerEnv(input) {
     const containerRef = input.id;
+    const workspaceTransferEnv = {
+        cwd: input.spec.cwd,
+        uploadDir: "/tmp/poe-workspace-transfer",
+        workspaceDir: input.spec.cwd,
+        remoteFs: createContainerWorkspaceFileSystem(input)
+    };
+    let detachedJobContext = input.attachedJobId === undefined
+        ? null
+        : { id: input.attachedJobId, tool: input.spec.jobLabel.tool, argv: input.spec.jobLabel.argv };
     return {
         id: containerRef,
+        reattachContext: { engine: input.engine, context: input.context },
         job: input.attachedJobId === undefined
             ? null
-            : createContainerJob(containerRef, input.runner, input.engine, input.context, input.attachedJobId),
+            : createContainerJob(containerRef, input.runner, input.engine, input.context, detachedJobContext),
+        setDetachedJobContext(context) {
+            detachedJobContext = context;
+        },
         async uploadWorkspace() {
-            const tempDir = mkdtempSync(path.join(tmpdir(), "poe-docker-upload-"));
-            const archivePath = path.join(tempDir, "workspace.tar");
-            try {
-                const excludeArgs = input.spec.uploadIgnoreFiles.flatMap((ignored) => [
-                    "--exclude",
-                    ignored
-                ]);
-                const tarArgs = [...excludeArgs, "-cf", archivePath, "-C", input.spec.cwd, "."];
-                await runOrThrow(input.runner, {
-                    command: "tar",
-                    args: tarArgs,
-                    stdout: "pipe",
-                    stderr: "pipe"
-                });
-                await runOrThrow(input.runner, {
-                    command: input.engine,
-                    args: [
-                        ...buildContextArgs(input.engine, input.context),
-                        "cp",
-                        archivePath,
-                        `${containerRef}:/tmp/poe-workspace-upload.tar`
-                    ],
-                    stdout: "pipe",
-                    stderr: "pipe"
-                });
-                await runOrThrow(input.runner, {
-                    command: input.engine,
-                    args: [
-                        ...buildContextArgs(input.engine, input.context),
-                        "exec",
-                        containerRef,
-                        "sh",
-                        "-c",
-                        `mkdir -p ${shellQuote(input.spec.cwd)} && tar -xf /tmp/poe-workspace-upload.tar -C ${shellQuote(input.spec.cwd)}`
-                    ],
-                    stdout: "pipe",
-                    stderr: "pipe"
-                });
+            if (readRunnerSync(input.spec.runner) === "none") {
                 return { files: 0, bytes: 0, skipped: [] };
             }
-            finally {
-                rmSync(tempDir, { recursive: true, force: true });
-            }
+            return uploadTransferredWorkspace(workspaceTransferEnv, {
+                runner: readWorkspaceTransferRunner(input.spec.runner),
+                workspaceExclude: input.spec.uploadIgnoreFiles
+            });
         },
         async downloadWorkspace(opts) {
-            const tempDir = mkdtempSync(path.join(tmpdir(), "poe-docker-download-"));
-            const archivePath = path.join(tempDir, "workspace.tar");
-            try {
-                await runOrThrow(input.runner, {
-                    command: input.engine,
-                    args: [
-                        ...buildContextArgs(input.engine, input.context),
-                        "exec",
-                        containerRef,
-                        "sh",
-                        "-c",
-                        `tar -cf /tmp/poe-workspace-download.tar -C ${shellQuote(input.spec.cwd)} .`
-                    ],
-                    stdout: "pipe",
-                    stderr: "pipe"
-                });
-                await runOrThrow(input.runner, {
-                    command: input.engine,
-                    args: [
-                        ...buildContextArgs(input.engine, input.context),
-                        "cp",
-                        `${containerRef}:/tmp/poe-workspace-download.tar`,
-                        archivePath
-                    ],
-                    stdout: "pipe",
-                    stderr: "pipe"
-                });
-                const extractMode = opts.conflictPolicy === "refuse" ? "-xkf" : "-xf";
-                await runOrThrow(input.runner, {
-                    command: "tar",
-                    args: [extractMode, archivePath, "-C", input.spec.cwd],
-                    stdout: "pipe",
-                    stderr: "pipe"
-                });
+            const sync = readRunnerSync(input.spec.runner);
+            if (sync === "upload" || sync === "none") {
                 return { files: 0, bytes: 0, conflicts: [] };
             }
-            finally {
-                rmSync(tempDir, { recursive: true, force: true });
-            }
+            return downloadTransferredWorkspace(workspaceTransferEnv, opts);
         },
         exec(spec) {
             return input.runner.exec({
@@ -174,18 +119,19 @@ function createDockerEnv(input) {
                 stdin: spec.stdin,
                 stdout: spec.stdout,
                 stderr: spec.stderr,
-                tty: spec.tty
+                tty: spec.tty,
+                signal: spec.signal
             });
         },
         async detach() {
-            return createContainerJob(containerRef, input.runner, input.engine, input.context);
+            return createContainerJob(containerRef, input.runner, input.engine, input.context, detachedJobContext);
         },
         shell() {
             const shellSpec = input.spec.shellSpec;
             return this.exec({
                 command: shellSpec?.command ?? input.spec.env.SHELL ?? "sh",
                 ...(shellSpec?.args ? { args: shellSpec.args } : {}),
-                cwd: input.spec.cwd,
+                cwd: shellSpec?.cwd ?? input.spec.cwd,
                 env: shellSpec && "env" in shellSpec ? shellSpec.env : input.spec.env,
                 stdin: "inherit",
                 stdout: "inherit",
@@ -203,6 +149,14 @@ function createDockerEnv(input) {
         }
     };
 }
+function parseDockerReattachContext(value) {
+    if (value !== undefined &&
+        (value.engine === "docker" || value.engine === "podman") &&
+        (value.context === null || typeof value.context === "string")) {
+        return { engine: value.engine, context: value.context };
+    }
+    return undefined;
+}
 async function resolveImage(input) {
     if (input.runtime.image !== undefined) {
         return input.runtime.image;
@@ -222,9 +176,10 @@ export async function buildDockerRuntimeTemplate(input) {
     const dockerfilePath = path.resolve(input.cwd, input.runtime.dockerfile ?? path.join(".poe-code", "Dockerfile"));
     const buildContext = path.resolve(input.cwd, input.runtime.build_context ?? ".");
     const dockerfileBytes = await readFile(dockerfilePath);
-    const hash = hashDockerTemplate(dockerfileBytes, input.runtime.build_args ?? {});
+    const buildContextFiles = await readBuildContextFiles(buildContext);
+    const hash = hashDockerTemplate(dockerfileBytes, buildContextFiles, input.runtime.build_args ?? {}, engine);
     const cached = input.force ? null : await input.state?.templates.get("docker", hash);
-    if (cached?.image !== undefined) {
+    if (cached?.image !== undefined && (await imageExists(runner, engine, context, cached.image))) {
         return {
             backend: "docker",
             hash,
@@ -256,10 +211,18 @@ export async function buildDockerRuntimeTemplate(input) {
         cached: false
     };
 }
-function hashDockerTemplate(dockerfileBytes, buildArgs) {
+function hashDockerTemplate(dockerfileBytes, buildContextFiles, buildArgs, engine) {
     const hash = createHash("sha256");
     hash.update(dockerfileBytes);
     hash.update("\0");
+    hash.update(engine);
+    hash.update("\0");
+    for (const file of buildContextFiles) {
+        hash.update(file.relativePath);
+        hash.update("\0");
+        hash.update(file.bytes);
+        hash.update("\0");
+    }
     for (const [key, value] of sortedBuildArgs(buildArgs)) {
         hash.update(key);
         hash.update("=");
@@ -268,6 +231,39 @@ function hashDockerTemplate(dockerfileBytes, buildArgs) {
     }
     return hash.digest("hex");
 }
+async function readBuildContextFiles(buildContext) {
+    const files = [];
+    await collectBuildContextFiles(buildContext, "", files);
+    return files.sort((left, right) => left.relativePath.localeCompare(right.relativePath));
+}
+async function collectBuildContextFiles(buildContext, relativeDir, files) {
+    const absoluteDir = path.join(buildContext, relativeDir);
+    const entries = await readdir(absoluteDir, { withFileTypes: true });
+    for (const entry of entries) {
+        const relativePath = path.join(relativeDir, entry.name);
+        if (entry.isDirectory()) {
+            await collectBuildContextFiles(buildContext, relativePath, files);
+            continue;
+        }
+        if (!entry.isFile()) {
+            continue;
+        }
+        files.push({
+            relativePath: relativePath.split(path.sep).join("/"),
+            bytes: await readFile(path.join(buildContext, relativePath))
+        });
+    }
+}
+async function imageExists(runner, engine, context, image) {
+    const handle = runner.exec({
+        command: engine,
+        args: [...buildContextArgs(engine, context), "image", "inspect", image],
+        stdout: "pipe",
+        stderr: "pipe"
+    });
+    const result = await handle.result;
+    return result.exitCode === 0;
+}
 async function buildImage(input) {
     await runOrThrow(input.runner, {
         command: input.engine,
@@ -336,13 +332,108 @@ function buildEnvArgs(env) {
 function createContainerName() {
     return `poe-env-${randomBytes(6).toString("hex")}`;
 }
-function createContainerJob(containerId, runner, engine, context, jobId = containerId) {
+function readRunnerSync(runner) {
+    if (typeof runner !== "object" || runner === null || !("sync" in runner)) {
+        return undefined;
+    }
+    const sync = runner.sync;
+    return sync === "both" || sync === "upload" || sync === "none" ? sync : undefined;
+}
+function readWorkspaceTransferRunner(runner) {
+    if (typeof runner !== "object" || runner === null) {
+        return undefined;
+    }
+    const record = runner;
+    const uploadMaxFileMb = typeof record.upload_max_file_mb === "number" ? record.upload_max_file_mb : undefined;
+    const workspace = typeof record.workspace === "object" && record.workspace !== null
+        && Array.isArray(record.workspace.exclude)
+        ? { exclude: record.workspace.exclude.filter((value) => typeof value === "string") }
+        : undefined;
+    return { ...(uploadMaxFileMb === undefined ? {} : { upload_max_file_mb: uploadMaxFileMb }), ...(workspace === undefined ? {} : { workspace }) };
+}
+function createContainerWorkspaceFileSystem(input) {
+    const execShell = (command) => runAndRead(input.runner, {
+        command: input.engine,
+        args: [...buildContextArgs(input.engine, input.context), "exec", input.id, "sh", "-c", command],
+        stdout: "pipe",
+        stderr: "pipe"
+    });
+    async function readRemoteFile(targetPath) {
+        const tempDir = mkdtempSync(path.join(tmpdir(), "poe-docker-read-"));
+        const destinationPath = path.join(tempDir, "content");
+        try {
+            await runOrThrow(input.runner, {
+                command: input.engine,
+                args: [...buildContextArgs(input.engine, input.context), "cp", `${input.id}:${targetPath}`, destinationPath],
+                stdout: "pipe",
+                stderr: "pipe"
+            });
+            return await readFile(destinationPath);
+        }
+        finally {
+            rmSync(tempDir, { recursive: true, force: true });
+        }
+    }
+    async function readFileFromContainer(targetPath, encoding) {
+        const contents = await readRemoteFile(targetPath);
+        return encoding === undefined ? contents : contents.toString(encoding);
+    }
+    return {
+        async mkdir(targetPath) {
+            await execShell(`mkdir -p ${shellQuote(targetPath)}`);
+        },
+        async readdir(targetPath) {
+            const output = await execShell(`for item in ${shellQuote(targetPath)}/* ${shellQuote(targetPath)}/.[!.]* ${shellQuote(targetPath)}/..?*; do [ -e "$item" ] || continue; if [ -d "$item" ]; then kind=d; size=0; else kind=f; size=$(wc -c < "$item"); fi; printf '%s\\t%s\\t%s\\n' "\${item##*/}" "$kind" "$size"; done`);
+            return output.split("\n").filter(Boolean).map((line) => {
+                const [name = "", kind = "f"] = line.split("\t");
+                return { name, isFile: () => kind === "f", isDirectory: () => kind === "d" };
+            });
+        },
+        readFile: readFileFromContainer,
+        async writeFile(targetPath, data) {
+            const tempDir = mkdtempSync(path.join(tmpdir(), "poe-docker-write-"));
+            const sourcePath = path.join(tempDir, "content");
+            try {
+                await writeFile(sourcePath, data);
+                await runOrThrow(input.runner, {
+                    command: input.engine,
+                    args: [...buildContextArgs(input.engine, input.context), "cp", sourcePath, `${input.id}:${targetPath}`],
+                    stdout: "pipe",
+                    stderr: "pipe"
+                });
+            }
+            finally {
+                rmSync(tempDir, { recursive: true, force: true });
+            }
+        },
+        async stat(targetPath) {
+            const output = await execShell(`if [ -d ${shellQuote(targetPath)} ]; then printf 'd\\t0'; elif [ -f ${shellQuote(targetPath)} ]; then printf 'f\\t'; wc -c < ${shellQuote(targetPath)}; else printf 'missing'; fi`);
+            if (output.trim() === "missing") {
+                throw Object.assign(new Error(`ENOENT: ${targetPath}`), { code: "ENOENT" });
+            }
+            const [kind = "f", rawSize = "0"] = output.trim().split("\t");
+            return { size: Number(rawSize.trim()), isFile: () => kind === "f", isDirectory: () => kind === "d" };
+        },
+        async rename(oldPath, newPath) {
+            await execShell(`mv ${shellQuote(oldPath)} ${shellQuote(newPath)}`);
+        },
+        async rm(targetPath) {
+            await execShell(`rm -rf ${shellQuote(targetPath)}`);
+        }
+    };
+}
+function createContainerJob(containerId, runner, engine, context, detachedJobContext = null) {
+    const jobId = detachedJobContext?.id ?? containerId;
     return {
         id: jobId,
         envId: containerId,
-        tool: "docker",
-        argv: ["attach", containerId],
+        tool: detachedJobContext?.tool ?? "docker",
+        argv: detachedJobContext?.argv ?? ["attach", containerId],
         async status() {
+            if (detachedJobContext !== null) {
+                const exitCode = await readDetachedExitCode(containerId, jobId, runner, engine, context);
+                return exitCode === null ? "running" : "exited";
+            }
             const handle = runner.exec({
                 command: engine,
                 args: [
@@ -360,29 +451,48 @@ function createContainerJob(containerId, runner, engine, context, jobId = contai
             if (result.exitCode !== 0) {
                 return "lost";
             }
-            return stdout.trim() === "running" ? "running" : "exited";
+            return stdout.trim() === "exited" ? "exited" : "running";
         },
         async *stream(opts) {
-            const handle = runner.exec({
-                command: engine,
-                args: [
-                    ...buildContextArgs(engine, context),
-                    "exec",
-                    containerId,
-                    "sh",
-                    "-c",
-                    `test -f ${shellQuote(`/tmp/poe-jobs/${jobId}.log`)} && tail -c +${(opts?.sinceByte ?? 0) + 1} ${shellQuote(`/tmp/poe-jobs/${jobId}.log`)} || true`
-                ],
-                stdout: "pipe",
-                stderr: "pipe"
-            });
-            const stdout = await readStream(handle.stdout);
-            await handle.result;
-            if (stdout.length > 0) {
-                yield { byteOffset: opts?.sinceByte ?? 0, data: stdout };
+            const logFile = shellQuote(`/tmp/poe-jobs/${jobId}.log`);
+            const sinceCondition = opts?.since === undefined
+                ? ""
+                : ` && test $(stat -c %Y ${logFile} 2>/dev/null || stat -f %m ${logFile}) -ge ${Math.ceil(opts.since.getTime() / 1000)}`;
+            let byteOffset = opts?.sinceByte ?? 0;
+            while (true) {
+                const stdout = await runAndRead(runner, {
+                    command: engine,
+                    args: [
+                        ...buildContextArgs(engine, context),
+                        "exec",
+                        containerId,
+                        "sh",
+                        "-c",
+                        `test -f ${logFile}${sinceCondition} && tail -c +${byteOffset + 1} ${logFile} || true`
+                    ],
+                    stdout: "pipe",
+                    stderr: "pipe"
+                });
+                if (stdout.length > 0) {
+                    yield { byteOffset, data: stdout };
+                    byteOffset += Buffer.byteLength(stdout);
+                }
+                if (opts?.follow !== true || (await this.status()) !== "running") {
+                    return;
+                }
+                await new Promise((resolve) => setTimeout(resolve, 250));
             }
         },
         async wait() {
+            if (detachedJobContext !== null) {
+                while (true) {
+                    const exitCode = await readDetachedExitCode(containerId, jobId, runner, engine, context);
+                    if (exitCode !== null) {
+                        return { exitCode };
+                    }
+                    await new Promise((resolve) => setTimeout(resolve, 25));
+                }
+            }
             const handle = runner.exec({
                 command: engine,
                 args: [...buildContextArgs(engine, context), "wait", containerId],
@@ -391,7 +501,8 @@ function createContainerJob(containerId, runner, engine, context, jobId = contai
             });
             const stdout = await readStream(handle.stdout);
             const result = await handle.result;
-            return { exitCode: Number.parseInt(stdout.trim(), 10) || result.exitCode };
+            const exitCode = Number.parseInt(stdout.trim(), 10);
+            return { exitCode: Number.isNaN(exitCode) ? result.exitCode : exitCode };
         },
         async kill(signal) {
             const args = signal === undefined || signal === "SIGTERM"
@@ -406,6 +517,29 @@ function createContainerJob(containerId, runner, engine, context, jobId = contai
         }
     };
 }
+async function readDetachedExitCode(containerId, jobId, runner, engine, context) {
+    const exitFile = shellQuote(`/tmp/poe-jobs/${jobId}.exit`);
+    const handle = runner.exec({
+        command: engine,
+        args: [
+            ...buildContextArgs(engine, context),
+            "exec",
+            containerId,
+            "sh",
+            "-c",
+            `test -f ${exitFile} && cat ${exitFile} || true`
+        ],
+        stdout: "pipe",
+        stderr: "pipe"
+    });
+    const stdout = await readStream(handle.stdout);
+    const result = await handle.result;
+    if (result.exitCode !== 0) {
+        return null;
+    }
+    const exitCode = Number.parseInt(stdout.trim(), 10);
+    return Number.isNaN(exitCode) ? null : exitCode;
+}
 function createAttachedSpec(cwd = "/workspace") {
     return {
         cwd,

package/node_modules/@poe-code/process-runner/dist/docker/docker-runner.js

@@ -9,6 +9,16 @@ export function createDockerRunner(options) {
     return {
         name: "docker",
         exec(spec) {
+            if (spec.signal?.aborted === true) {
+                return {
+                    pid: null,
+                    stdin: null,
+                    stdout: null,
+                    stderr: null,
+                    result: Promise.resolve({ exitCode: 1 }),
+                    kill() { }
+                };
+            }
             const stdinMode = spec.stdin ?? "ignore";
             const stdoutMode = spec.stdout ?? "pipe";
             const stderrMode = spec.stderr ?? "pipe";
@@ -44,9 +54,6 @@ export function createDockerRunner(options) {
             const result = new Promise((resolve) => {
                 resolveResult = resolve;
             });
-            const cleanupAbort = bindAbortSignal(spec.signal, () => {
-                spawnControlCommand(engine, context, ["stop", containerName]);
-            });
             const settleResult = (exitCode) => {
                 if (isResultSettled) {
                     return;
@@ -55,6 +62,10 @@ export function createDockerRunner(options) {
                 cleanupAbort();
                 resolveResult?.({ exitCode });
             };
+            const cleanupAbort = bindAbortSignal(spec.signal, () => {
+                settleResult(1);
+                spawnControlCommand(engine, context, ["stop", containerName]);
+            });
             child.once("error", () => {
                 settleResult(1);
             });
@@ -112,9 +123,10 @@ function isContainerNameCharacter(char) {
     return char === "." || char === "_" || char === "-";
 }
 function spawnControlCommand(engine, context, args) {
-    childProcess.spawn(engine, [...buildContextArgs(engine, context), ...args], {
+    const child = childProcess.spawn(engine, [...buildContextArgs(engine, context), ...args], {
         stdio: "ignore"
     });
+    child.once("error", () => undefined);
 }
 function bindAbortSignal(signal, onAbort) {
     if (signal === undefined) {