toolcraft 0.0.23 → 0.0.25

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

@@ -3,12 +3,25 @@ import { randomBytes } from "node:crypto";
 import { buildDockerRunArgs } from "./args.js";
 import { buildContextArgs, detectContext } from "./context.js";
 import { detectEngine } from "./engine.js";
+import { createDockerEnvFile } from "./env-file.js";
+const DOCKER_ABORT_GRACE_MS = 10_000;
+const DOCKER_ABORT_FORCE_GRACE_MS = 5_000;
 export function createDockerRunner(options) {
     const engine = options.engine ?? detectEngine();
     const context = options.context ?? detectContext();
     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";
@@ -17,6 +30,7 @@ export function createDockerRunner(options) {
                 stderrMode === "inherit" &&
                 spec.tty === true;
             const containerName = buildContainerName(options.containerName ?? spec.command);
+            const envFile = createDockerEnvFile(spec.env);
             const runArgs = buildDockerRunArgs({
                 engine,
                 context,
@@ -25,6 +39,7 @@ export function createDockerRunner(options) {
                 args: spec.args ?? [],
                 cwd: spec.cwd,
                 env: spec.env,
+                envFilePath: envFile?.path,
                 mounts: options.mounts ?? [],
                 ports: options.ports ?? [],
                 network: options.network,
@@ -36,25 +51,56 @@ export function createDockerRunner(options) {
                 extraArgs: options.extraArgs ?? []
             });
             const [command, ...args] = runArgs;
-            const child = childProcess.spawn(command, args, {
-                stdio: interactiveMode ? "inherit" : [stdinMode, stdoutMode, stderrMode]
-            });
+            let child;
+            try {
+                child = childProcess.spawn(command, args, {
+                    stdio: interactiveMode ? "inherit" : [stdinMode, stdoutMode, stderrMode]
+                });
+            }
+            catch (error) {
+                envFile?.cleanup();
+                throw error;
+            }
             let isResultSettled = false;
+            let exitCodeOverride = null;
             let resolveResult = null;
+            let abortEscalationTimers = [];
             const result = new Promise((resolve) => {
                 resolveResult = resolve;
             });
-            const cleanupAbort = bindAbortSignal(spec.signal, () => {
-                spawnControlCommand(engine, context, ["stop", containerName]);
-            });
+            const clearAbortEscalation = () => {
+                for (const timer of abortEscalationTimers) {
+                    clearTimeout(timer);
+                }
+                abortEscalationTimers = [];
+            };
             const settleResult = (exitCode) => {
                 if (isResultSettled) {
                     return;
                 }
                 isResultSettled = true;
                 cleanupAbort();
-                resolveResult?.({ exitCode });
+                clearAbortEscalation();
+                envFile?.cleanup();
+                resolveResult?.({ exitCode: exitCodeOverride ?? exitCode });
+            };
+            const scheduleAbortEscalation = () => {
+                const terminateTimer = setTimeout(() => {
+                    killHostDockerChild(child, "SIGTERM");
+                    const forceTimer = setTimeout(() => {
+                        killHostDockerChild(child, "SIGKILL");
+                    }, DOCKER_ABORT_FORCE_GRACE_MS);
+                    unrefTimer(forceTimer);
+                    abortEscalationTimers.push(forceTimer);
+                }, DOCKER_ABORT_GRACE_MS);
+                unrefTimer(terminateTimer);
+                abortEscalationTimers.push(terminateTimer);
             };
+            const cleanupAbort = bindAbortSignal(spec.signal, () => {
+                exitCodeOverride = 1;
+                spawnControlCommand(engine, context, ["stop", containerName]);
+                scheduleAbortEscalation();
+            });
             child.once("error", () => {
                 settleResult(1);
             });
@@ -82,6 +128,14 @@ export function createDockerRunner(options) {
         }
     };
 }
+function killHostDockerChild(child, signal) {
+    try {
+        child.kill(signal);
+    }
+    catch {
+        return;
+    }
+}
 function buildContainerName(name) {
     const suffix = randomBytes(3).toString("hex").slice(0, 6);
     const sanitizedName = sanitizeContainerName(name);
@@ -112,9 +166,15 @@ function isContainerNameCharacter(char) {
     return char === "." || char === "_" || char === "-";
 }
 function spawnControlCommand(engine, context, args) {
-    childProcess.spawn(engine, [...buildContextArgs(engine, context), ...args], {
-        stdio: "ignore"
-    });
+    try {
+        const child = childProcess.spawn(engine, [...buildContextArgs(engine, context), ...args], {
+            stdio: "ignore"
+        });
+        child.once("error", () => undefined);
+    }
+    catch {
+        return;
+    }
 }
 function bindAbortSignal(signal, onAbort) {
     if (signal === undefined) {
@@ -129,3 +189,11 @@ function bindAbortSignal(signal, onAbort) {
         signal.removeEventListener("abort", onAbort);
     };
 }
+function unrefTimer(timer) {
+    if (typeof timer === "object" &&
+        timer !== null &&
+        "unref" in timer &&
+        typeof timer.unref === "function") {
+        timer.unref();
+    }
+}

package/node_modules/@poe-code/process-runner/dist/docker/env-file.d.ts

@@ -0,0 +1,6 @@
+export interface DockerEnvFile {
+    path: string;
+    cleanup(): void;
+}
+export declare function createDockerEnvFile(env: Record<string, string> | undefined): DockerEnvFile | null;
+export declare function serializeDockerEnvFile(entries: Array<[string, string]>): string;

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

@@ -0,0 +1,49 @@
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+export function createDockerEnvFile(env) {
+    const entries = Object.entries(env ?? {});
+    if (entries.length === 0) {
+        return null;
+    }
+    const directory = mkdtempSync(path.join(tmpdir(), "poe-docker-env-"));
+    const filePath = path.join(directory, "env");
+    let active = true;
+    try {
+        writeFileSync(filePath, serializeDockerEnvFile(entries), {
+            encoding: "utf8",
+            flag: "wx",
+            mode: 0o600
+        });
+    }
+    catch (error) {
+        rmSync(directory, { recursive: true, force: true });
+        throw error;
+    }
+    return {
+        path: filePath,
+        cleanup() {
+            if (!active) {
+                return;
+            }
+            active = false;
+            rmSync(directory, { recursive: true, force: true });
+        }
+    };
+}
+export function serializeDockerEnvFile(entries) {
+    return (entries.map(([key, value]) => `${formatDockerEnvKey(key)}=${formatDockerEnvValue(value)}`).join("\n") +
+        "\n");
+}
+function formatDockerEnvKey(key) {
+    if (key.length === 0 || key.includes("=") || key.includes("\n") || key.includes("\r")) {
+        throw new Error(`Invalid Docker environment variable name: ${JSON.stringify(key)}`);
+    }
+    return key;
+}
+function formatDockerEnvValue(value) {
+    if (value.includes("\n") || value.includes("\r")) {
+        throw new Error("Docker env-file values cannot contain newline characters.");
+    }
+    return value;
+}

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

@@ -31,12 +31,13 @@ export const hostExecutionEnvFactory = {
                 return createHostRunner().exec({
                     command: shellSpec?.command ?? openSpec.env.SHELL ?? process.env.SHELL ?? "sh",
                     ...(shellSpec?.args ? { args: shellSpec.args } : {}),
-                    cwd: openSpec.cwd,
+                    cwd: shellSpec?.cwd ?? openSpec.cwd,
                     env: shellSpec && "env" in shellSpec ? shellSpec.env : openSpec.env,
                     stdin: "inherit",
                     stdout: "inherit",
                     stderr: "inherit",
-                    tty: true
+                    tty: true,
+                    signal: shellSpec?.signal
                 });
             },
             async close() { }

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

@@ -1,12 +1,23 @@
 import { spawn as spawnChildProcess } from "node:child_process";
 export function createHostRunner(options = {}) {
-    const detached = options.detached === true;
+    const detachedByDefault = options.detached === true;
     return {
         name: "host",
         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";
+            const killProcessGroup = detachedByDefault || spec.killProcessGroup === true;
             const stdio = stdinMode === "inherit" && stdoutMode === "inherit" && stderrMode === "inherit"
                 ? "inherit"
                 : [stdinMode, stdoutMode, stderrMode];
@@ -14,13 +25,13 @@ export function createHostRunner(options = {}) {
                 cwd: spec.cwd,
                 env: spec.env,
                 stdio,
-                ...(detached ? { detached: true } : {})
+                ...(killProcessGroup ? { detached: true } : {})
             });
-            if (detached) {
+            if (killProcessGroup) {
                 child.unref();
             }
             const kill = (signal) => {
-                if (detached && process.platform !== "win32" && child.pid !== undefined) {
+                if (killProcessGroup && process.platform !== "win32" && child.pid !== undefined) {
                     process.kill(-child.pid, signal);
                     return;
                 }
@@ -32,7 +43,12 @@ export function createHostRunner(options = {}) {
                 resolveResult = resolve;
             });
             const cleanupAbort = bindAbortSignal(spec.signal, () => {
-                kill("SIGTERM");
+                try {
+                    kill("SIGTERM");
+                }
+                catch {
+                    return;
+                }
             });
             child.once("close", (code) => {
                 if (settled)

package/node_modules/@poe-code/process-runner/dist/index.d.ts

@@ -5,4 +5,5 @@ export { buildDockerRuntimeTemplate, dockerExecutionEnvFactory } from "./docker/
 export { hostExecutionEnvFactory } from "./host/host-execution-env.js";
 export { createHostRunner } from "./host/host-runner.js";
 export { createMockRunner, createMockRunnerByCommand } from "./testing/index.js";
+export { downloadWorkspace, uploadWorkspace, type WorkspaceDownloadOptions, type WorkspaceTransferDirent, type WorkspaceTransferEnv, type WorkspaceTransferFileSystem, type WorkspaceTransferOptions, type WorkspaceTransferRunnerOptions, type WorkspaceTransferStats } from "./workspace-transfer.js";
 export type { DownloadResult, DockerMount, DockerPortMapping, DockerRunArgs, DockerRunnerOptions, Engine, ExecutionState, ExecutionEnvFactory, ExecutionEnvType, HostRunnerOptions, JobHandle, JobStatus, LogChunk, MockRunBehavior, OpenedEnv, OpenSpec, RunHandle, RunResult, Runner, RunSpec, TemplateEntry, UploadResult } from "./types.js";

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

@@ -5,3 +5,4 @@ export { buildDockerRuntimeTemplate, dockerExecutionEnvFactory } from "./docker/
 export { hostExecutionEnvFactory } from "./host/host-execution-env.js";
 export { createHostRunner } from "./host/host-runner.js";
 export { createMockRunner, createMockRunnerByCommand } from "./testing/index.js";
+export { downloadWorkspace, uploadWorkspace } from "./workspace-transfer.js";

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

@@ -16,7 +16,9 @@ export function createMockRunnerByCommand(behaviorsByCommand) {
     return {
         name: "mock",
         exec(spec) {
-            const behavior = behaviorsByCommand[spec.command];
+            const behavior = Object.prototype.hasOwnProperty.call(behaviorsByCommand, spec.command)
+                ? behaviorsByCommand[spec.command]
+                : undefined;
             if (behavior === undefined) {
                 throw new Error(`No mock run behavior found for command "${spec.command}"`);
             }
@@ -29,12 +31,19 @@ function createRunHandle(spec, behavior) {
     const stderrMode = spec.stderr ?? "pipe";
     const stdinMode = spec.stdin ?? "ignore";
     const interval = behavior.stdoutInterval ?? 10;
+    if (behavior.exitAfterMs !== undefined && (!Number.isFinite(behavior.exitAfterMs) || behavior.exitAfterMs < 0)) {
+        throw new Error("Mock run exitAfterMs must be a finite non-negative number.");
+    }
     const stdoutController = stdoutMode === "pipe" && behavior.stdout !== undefined
         ? createReadableStream(behavior.stdout, interval)
         : null;
     const stderrController = stderrMode === "pipe" && behavior.stderr !== undefined
         ? createReadableStream(behavior.stderr, interval)
         : null;
+    const outputDone = Promise.all([
+        ...(stdoutController === null ? [] : [stdoutController.done]),
+        ...(stderrController === null ? [] : [stderrController.done])
+    ]);
     let resolveResult = null;
     const result = new Promise((resolve) => {
         resolveResult = resolve;
@@ -51,10 +60,18 @@ function createRunHandle(spec, behavior) {
         stdoutController?.stop();
         stderrController?.stop();
     };
-    const exitAfterMs = behavior.exitAfterMs ?? 0;
-    const exitTimer = exitAfterMs > 0
-        ? setTimeout(complete, exitAfterMs)
-        : queueMicrotask(complete);
+    const exitAfterMs = behavior.exitAfterMs;
+    const exitTimer = exitAfterMs === undefined
+        ? undefined
+        : exitAfterMs > 0
+            ? setTimeout(complete, exitAfterMs)
+            : undefined;
+    if (exitAfterMs === undefined) {
+        void outputDone.then(complete);
+    }
+    else if (exitAfterMs === 0) {
+        queueMicrotask(complete);
+    }
     return {
         pid: behavior.pid ?? null,
         stdout: stdoutController?.stream ?? null,
@@ -62,7 +79,7 @@ function createRunHandle(spec, behavior) {
         stdin: stdinMode === "pipe" ? createWritableStream() : null,
         result,
         kill() {
-            if (typeof exitTimer === "object" && exitTimer !== null && "hasRef" in exitTimer) {
+            if (exitTimer !== undefined) {
                 clearTimeout(exitTimer);
             }
             stopStreams();
@@ -76,6 +93,10 @@ function createReadableStream(lines, interval) {
     });
     const timers = new Set();
     let stopped = false;
+    let resolveDone;
+    const done = new Promise((resolve) => {
+        resolveDone = resolve;
+    });
     const stop = () => {
         if (stopped) {
             return;
@@ -86,10 +107,11 @@ function createReadableStream(lines, interval) {
         }
         timers.clear();
         stream.push(null);
+        resolveDone?.();
     };
     if (lines.length === 0) {
         queueMicrotask(stop);
-        return { stream, stop };
+        return { done, stream, stop };
     }
     for (const [index, line] of lines.entries()) {
         const timer = setTimeout(() => {
@@ -104,7 +126,7 @@ function createReadableStream(lines, interval) {
         }, interval * (index + 1));
         timers.add(timer);
     }
-    return { stream, stop };
+    return { done, stream, stop };
 }
 function createWritableStream() {
     return new Writable({

package/node_modules/@poe-code/process-runner/dist/types.d.ts

@@ -20,6 +20,8 @@ export interface RunSpec {
     stderr?: "pipe" | "inherit";
     tty?: boolean;
     signal?: AbortSignal;
+    /** Start in a separate process group so kill() can signal the full group where supported. */
+    killProcessGroup?: boolean;
 }
 export interface Runner {
     exec(spec: RunSpec): RunHandle;
@@ -103,10 +105,12 @@ export interface AttachedJobContext {
     tool: string;
     argv: string[];
     cwd: string;
+    reattachContext?: Record<string, unknown>;
 }
 export interface OpenedEnv {
     readonly id: string;
     readonly job: JobHandle | null;
+    readonly reattachContext?: Record<string, unknown>;
     uploadWorkspace(): Promise<UploadResult>;
     downloadWorkspace(opts: {
         conflictPolicy: "refuse" | "overwrite";
@@ -125,6 +129,7 @@ export interface JobHandle {
     stream(opts?: {
         sinceByte?: number;
         since?: Date;
+        follow?: boolean;
     }): AsyncIterable<LogChunk>;
     wait(): Promise<{
         exitCode: number;
@@ -160,6 +165,7 @@ export interface DockerRunArgs {
     args: string[];
     cwd?: string;
     env?: Record<string, string>;
+    envFilePath?: string;
     mounts: DockerMount[];
     ports: DockerPortMapping[];
     network?: string;

package/node_modules/@poe-code/process-runner/dist/workspace-transfer.d.ts

@@ -0,0 +1,61 @@
+import type { DownloadResult, UploadResult } from "./types.js";
+export type { DownloadResult, UploadResult } from "./types.js";
+export interface WorkspaceTransferDirent {
+    name: string;
+    isFile(): boolean;
+    isDirectory(): boolean;
+    isSymbolicLink?(): boolean;
+}
+export interface WorkspaceTransferStats {
+    isFile(): boolean;
+    isDirectory(): boolean;
+    isSymbolicLink?(): boolean;
+    size: number;
+}
+export interface WorkspaceTransferFileSystem {
+    mkdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    readdir(path: string, options: {
+        withFileTypes: true;
+    }): Promise<WorkspaceTransferDirent[]>;
+    readFile(path: string): Promise<Buffer>;
+    readFile(path: string, encoding: BufferEncoding): Promise<string>;
+    writeFile(path: string, data: string | Buffer, options?: {
+        flag?: string;
+        mode?: number;
+    }): Promise<void>;
+    stat(path: string): Promise<WorkspaceTransferStats>;
+    lstat?(path: string): Promise<WorkspaceTransferStats>;
+    rename?(oldPath: string, newPath: string): Promise<void>;
+    rm?(path: string, options?: {
+        recursive?: boolean;
+        force?: boolean;
+    }): Promise<void>;
+    unlink?(path: string): Promise<void>;
+    rmdir?(path: string): Promise<void>;
+}
+export interface WorkspaceTransferEnv {
+    cwd: string;
+    uploadDir: string;
+    workspaceDir?: string;
+    fs?: WorkspaceTransferFileSystem;
+    remoteFs?: WorkspaceTransferFileSystem;
+}
+export interface WorkspaceTransferOptions {
+    runner?: WorkspaceTransferRunnerOptions;
+    uploadMaxFileMb?: number;
+    workspaceExclude?: string[];
+    warn?: (message: string) => void;
+}
+export interface WorkspaceTransferRunnerOptions {
+    upload_max_file_mb?: number;
+    workspace?: {
+        exclude?: string[];
+    };
+}
+export interface WorkspaceDownloadOptions {
+    conflictPolicy: "refuse" | "overwrite";
+}
+export declare function uploadWorkspace(env: WorkspaceTransferEnv, opts: WorkspaceTransferOptions): Promise<UploadResult>;
+export declare function downloadWorkspace(env: WorkspaceTransferEnv, opts: WorkspaceDownloadOptions): Promise<DownloadResult>;