toolcraft 0.0.23 → 0.0.25

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

@@ -1,12 +1,14 @@
 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 { buildDockerEnvArgs, buildDockerRunArgs } from "./args.js";
 import { buildContextArgs, detectContext } from "./context.js";
 import { detectEngine } from "./engine.js";
+import { createDockerEnvFile } from "./env-file.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,144 +55,98 @@ 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");
+            const sync = readRunnerSync(input.spec.runner);
+            if (sync === "upload" || sync === "none") {
+                return { files: 0, bytes: 0, conflicts: [] };
+            }
+            return downloadTransferredWorkspace(workspaceTransferEnv, opts);
+        },
+        exec(spec) {
+            const envFile = createDockerEnvFile(spec.env);
             try {
-                await runOrThrow(input.runner, {
+                return cleanUpEnvFileAfterRun(input.runner.exec({
                     command: input.engine,
                     args: [
                         ...buildContextArgs(input.engine, input.context),
                         "exec",
+                        ...(spec.stdin === "pipe" || spec.stdin === "inherit" ? ["-i"] : []),
+                        ...(spec.tty === true ? ["-t"] : []),
+                        ...(spec.cwd !== undefined ? ["-w", spec.cwd] : []),
+                        ...buildDockerEnvArgs({ env: spec.env, envFilePath: envFile?.path }),
                         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
+                        spec.command,
+                        ...(spec.args ?? [])
                     ],
-                    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"
-                });
-                return { files: 0, bytes: 0, conflicts: [] };
+                    stdin: spec.stdin,
+                    stdout: spec.stdout,
+                    stderr: spec.stderr,
+                    tty: spec.tty,
+                    signal: spec.signal,
+                    killProcessGroup: spec.killProcessGroup
+                }), envFile?.cleanup);
             }
-            finally {
-                rmSync(tempDir, { recursive: true, force: true });
+            catch (error) {
+                envFile?.cleanup();
+                throw error;
             }
         },
-        exec(spec) {
-            return input.runner.exec({
-                command: input.engine,
-                args: [
-                    ...buildContextArgs(input.engine, input.context),
-                    "exec",
-                    ...(spec.stdin === "pipe" || spec.stdin === "inherit" ? ["-i"] : []),
-                    ...(spec.tty === true ? ["-t"] : []),
-                    ...(spec.cwd !== undefined ? ["-w", spec.cwd] : []),
-                    ...buildEnvArgs(spec.env),
-                    containerRef,
-                    spec.command,
-                    ...(spec.args ?? [])
-                ],
-                stdin: spec.stdin,
-                stdout: spec.stdout,
-                stderr: spec.stderr,
-                tty: spec.tty
-            });
-        },
         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",
                 stderr: "inherit",
-                tty: true
+                tty: true,
+                signal: shellSpec?.signal
             });
         },
         async close() {
@@ -203,6 +159,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 +186,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 +221,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 +241,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,
@@ -310,9 +316,49 @@ async function runAndRead(runner, spec) {
     }
     return output;
 }
+async function runAndReadBytes(runner, spec) {
+    const handle = runner.exec(spec);
+    const stdout = readStreamBytes(handle.stdout);
+    const stderr = readStream(handle.stderr);
+    const result = await handle.result;
+    const output = await stdout;
+    if (result.exitCode !== 0) {
+        const errorOutput = await stderr;
+        throw new Error(`Command failed with exit code ${result.exitCode}: ${spec.command} ${(spec.args ?? []).join(" ")}${errorOutput ? `\n${errorOutput}` : ""}`);
+    }
+    return output;
+}
 async function runOrThrow(runner, spec) {
     await runAndRead(runner, spec);
 }
+function cleanUpEnvFileAfterRun(handle, cleanup) {
+    if (cleanup === undefined) {
+        return handle;
+    }
+    let cleanedUp = false;
+    const cleanupOnce = () => {
+        if (cleanedUp) {
+            return;
+        }
+        cleanedUp = true;
+        try {
+            cleanup();
+        }
+        catch {
+            // Cleanup is best effort; preserve the command result.
+        }
+    };
+    return {
+        pid: handle.pid,
+        stdin: handle.stdin,
+        stdout: handle.stdout,
+        stderr: handle.stderr,
+        result: handle.result.finally(cleanupOnce),
+        kill(signal) {
+            handle.kill(signal);
+        }
+    };
+}
 async function readStream(stream) {
     if (stream === null) {
         return "";
@@ -324,25 +370,139 @@ async function readStream(stream) {
     }
     return chunks.join("");
 }
+async function readStreamBytes(stream) {
+    if (stream === null) {
+        return Buffer.alloc(0);
+    }
+    const chunks = [];
+    for await (const chunk of stream) {
+        chunks.push(typeof chunk === "string" ? Buffer.from(chunk, "utf8") : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks);
+}
 function sortedBuildArgs(buildArgs) {
     return Object.entries(buildArgs).sort(([left], [right]) => left.localeCompare(right));
 }
-function buildEnvArgs(env) {
-    if (env === undefined) {
-        return [];
-    }
-    return Object.entries(env).flatMap(([key, value]) => ["-e", `${key}=${value}`]);
-}
 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 quotedTargetPath = shellQuote(targetPath);
+            const output = await execShell([
+                `for item in ${quotedTargetPath}/* ${quotedTargetPath}/.[!.]* ${quotedTargetPath}/..?*; do`,
+                `[ -e "$item" ] || [ -L "$item" ] || continue;`,
+                `if [ -L "$item" ]; then kind=l; size=0;`,
+                `elif [ -d "$item" ]; then kind=d; size=0;`,
+                `elif [ -f "$item" ]; then kind=f; size=$(wc -c < "$item");`,
+                `else continue; fi;`,
+                `printf '%s\\t%s\\t%s\\n' "\${item##*/}" "$kind" "$size";`,
+                `done`
+            ].join(" "));
+            return output.split("\n").filter(Boolean).map((line) => {
+                const [name = "", kind = "f"] = line.split("\t");
+                return {
+                    name,
+                    isFile: () => kind === "f",
+                    isDirectory: () => kind === "d",
+                    isSymbolicLink: () => kind === "l"
+                };
+            });
+        },
+        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 +520,59 @@ 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;
+            let pendingBytes = Buffer.alloc(0);
+            let pendingByteOffset = byteOffset;
+            while (true) {
+                const stdout = await runAndReadBytes(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.byteLength > 0) {
+                    const combined = pendingBytes.byteLength === 0
+                        ? stdout
+                        : Buffer.concat([pendingBytes, stdout]);
+                    const completeLength = completeUtf8PrefixLength(combined);
+                    byteOffset += stdout.byteLength;
+                    pendingBytes = combined.subarray(completeLength);
+                    const data = combined.subarray(0, completeLength).toString("utf8");
+                    if (data.length > 0) {
+                        yield { byteOffset: pendingByteOffset, data };
+                        pendingByteOffset += completeLength;
+                    }
+                }
+                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 +581,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 +597,62 @@ function createContainerJob(containerId, runner, engine, context, jobId = contai
         }
     };
 }
+function completeUtf8PrefixLength(contents) {
+    if (contents.length === 0) {
+        return 0;
+    }
+    let leadIndex = contents.length - 1;
+    while (leadIndex >= 0 && isUtf8ContinuationByte(contents[leadIndex])) {
+        leadIndex -= 1;
+    }
+    if (leadIndex < 0) {
+        return contents.length;
+    }
+    const expectedLength = utf8SequenceLength(contents[leadIndex]);
+    if (expectedLength === 0) {
+        return contents.length;
+    }
+    const availableLength = contents.length - leadIndex;
+    return availableLength < expectedLength ? leadIndex : contents.length;
+}
+function isUtf8ContinuationByte(byte) {
+    return byte >= 0x80 && byte <= 0xbf;
+}
+function utf8SequenceLength(byte) {
+    if (byte >= 0xc2 && byte <= 0xdf) {
+        return 2;
+    }
+    if (byte >= 0xe0 && byte <= 0xef) {
+        return 3;
+    }
+    if (byte >= 0xf0 && byte <= 0xf4) {
+        return 4;
+    }
+    return 0;
+}
+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,