toolcraft 0.0.23 → 0.0.24

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

@@ -4,6 +4,16 @@ export function createHostRunner(options = {}) {
     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";
@@ -32,7 +42,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

@@ -103,10 +103,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 +127,7 @@ export interface JobHandle {
     stream(opts?: {
         sinceByte?: number;
         since?: Date;
+        follow?: boolean;
     }): AsyncIterable<LogChunk>;
     wait(): Promise<{
         exitCode: number;

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

@@ -0,0 +1,57 @@
+import type { DownloadResult, UploadResult } from "./types.js";
+export type { DownloadResult, UploadResult } from "./types.js";
+export interface WorkspaceTransferDirent {
+    name: string;
+    isFile(): boolean;
+    isDirectory(): 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): 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>;