toolcraft 0.0.12 → 0.0.13

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

@@ -0,0 +1,131 @@
+import * as childProcess from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { buildDockerRunArgs } from "./args.js";
+import { buildContextArgs, detectContext } from "./context.js";
+import { detectEngine } from "./engine.js";
+export function createDockerRunner(options) {
+    const engine = options.engine ?? detectEngine();
+    const context = options.context ?? detectContext();
+    return {
+        name: "docker",
+        exec(spec) {
+            const stdinMode = spec.stdin ?? "ignore";
+            const stdoutMode = spec.stdout ?? "pipe";
+            const stderrMode = spec.stderr ?? "pipe";
+            const interactiveMode = stdinMode === "inherit" &&
+                stdoutMode === "inherit" &&
+                stderrMode === "inherit" &&
+                spec.tty === true;
+            const containerName = buildContainerName(options.containerName ?? spec.command);
+            const runArgs = buildDockerRunArgs({
+                engine,
+                context,
+                image: options.image,
+                command: spec.command,
+                args: spec.args ?? [],
+                cwd: spec.cwd,
+                env: spec.env,
+                mounts: options.mounts ?? [],
+                ports: options.ports ?? [],
+                network: options.network,
+                containerName,
+                detached: false,
+                interactive: stdinMode === "pipe" || stdinMode === "inherit",
+                tty: spec.tty ?? false,
+                rm: true,
+                extraArgs: options.extraArgs ?? []
+            });
+            const [command, ...args] = runArgs;
+            const child = childProcess.spawn(command, args, {
+                stdio: interactiveMode ? "inherit" : [stdinMode, stdoutMode, stderrMode]
+            });
+            let isResultSettled = false;
+            let resolveResult = null;
+            const result = new Promise((resolve) => {
+                resolveResult = resolve;
+            });
+            const cleanupAbort = bindAbortSignal(spec.signal, () => {
+                spawnControlCommand(engine, context, ["stop", containerName]);
+            });
+            const settleResult = (exitCode) => {
+                if (isResultSettled) {
+                    return;
+                }
+                isResultSettled = true;
+                cleanupAbort();
+                resolveResult?.({ exitCode });
+            };
+            child.once("error", () => {
+                settleResult(1);
+            });
+            child.once("close", (code) => {
+                settleResult(code ?? 1);
+            });
+            return {
+                pid: null,
+                stdin: interactiveMode ? null : child.stdin,
+                stdout: interactiveMode ? null : child.stdout,
+                stderr: interactiveMode ? null : child.stderr,
+                result,
+                kill(signal) {
+                    if (signal === "SIGKILL") {
+                        spawnControlCommand(engine, context, ["kill", containerName]);
+                        return;
+                    }
+                    if (signal === undefined || signal === "SIGTERM") {
+                        spawnControlCommand(engine, context, ["stop", containerName]);
+                        return;
+                    }
+                    spawnControlCommand(engine, context, ["kill", `--signal=${signal}`, containerName]);
+                }
+            };
+        }
+    };
+}
+function buildContainerName(name) {
+    const suffix = randomBytes(3).toString("hex").slice(0, 6);
+    const sanitizedName = sanitizeContainerName(name);
+    return `poe-run-${sanitizedName}-${suffix}`;
+}
+function sanitizeContainerName(name) {
+    let sanitized = "";
+    for (const char of name) {
+        if (isContainerNameCharacter(char)) {
+            sanitized += char;
+            continue;
+        }
+        sanitized += "-";
+    }
+    return sanitized.length > 0 ? sanitized : "command";
+}
+function isContainerNameCharacter(char) {
+    const code = char.charCodeAt(0);
+    if (code >= 48 && code <= 57) {
+        return true;
+    }
+    if (code >= 65 && code <= 90) {
+        return true;
+    }
+    if (code >= 97 && code <= 122) {
+        return true;
+    }
+    return char === "." || char === "_" || char === "-";
+}
+function spawnControlCommand(engine, context, args) {
+    childProcess.spawn(engine, [...buildContextArgs(engine, context), ...args], {
+        stdio: "ignore"
+    });
+}
+function bindAbortSignal(signal, onAbort) {
+    if (signal === undefined) {
+        return () => { };
+    }
+    if (signal.aborted) {
+        onAbort();
+        return () => { };
+    }
+    signal.addEventListener("abort", onAbort, { once: true });
+    return () => {
+        signal.removeEventListener("abort", onAbort);
+    };
+}

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

@@ -0,0 +1,3 @@
+import type { Engine } from "../types.js";
+export declare function detectEngine(): Engine;
+export declare function isEngineAvailable(engine: Engine): boolean;

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

@@ -0,0 +1,24 @@
+import { execSync } from "node:child_process";
+export function detectEngine() {
+    if (isEngineAvailable("docker")) {
+        return "docker";
+    }
+    if (isEngineAvailable("podman")) {
+        return "podman";
+    }
+    throw new Error("No container engine found. Please install Docker or Podman:\n" +
+        "  - Docker Desktop: https://www.docker.com/products/docker-desktop\n" +
+        "  - Colima (macOS): brew install colima && colima start\n" +
+        "  - Podman: https://podman.io/docs/installation");
+}
+export function isEngineAvailable(engine) {
+    try {
+        execSync(`${engine} --version`, {
+            stdio: "ignore"
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

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

@@ -0,0 +1,2 @@
+import type { ExecutionEnvFactory } from "../types.js";
+export declare const hostExecutionEnvFactory: ExecutionEnvFactory;

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

@@ -0,0 +1,48 @@
+import { createHostRunner } from "./host-runner.js";
+export const hostExecutionEnvFactory = {
+    type: "host",
+    supportsDetach: false,
+    async open(openSpec) {
+        return {
+            id: "host",
+            job: null,
+            async uploadWorkspace() {
+                return {
+                    files: 0,
+                    bytes: 0,
+                    skipped: []
+                };
+            },
+            async downloadWorkspace() {
+                return {
+                    files: 0,
+                    bytes: 0,
+                    conflicts: []
+                };
+            },
+            exec(spec) {
+                return createHostRunner().exec(spec);
+            },
+            async detach() {
+                throw new Error("host runtime does not support detach because host has no addressable env");
+            },
+            shell() {
+                const shellSpec = openSpec.shellSpec;
+                return createHostRunner().exec({
+                    command: shellSpec?.command ?? openSpec.env.SHELL ?? process.env.SHELL ?? "sh",
+                    ...(shellSpec?.args ? { args: shellSpec.args } : {}),
+                    cwd: openSpec.cwd,
+                    env: shellSpec && "env" in shellSpec ? shellSpec.env : openSpec.env,
+                    stdin: "inherit",
+                    stdout: "inherit",
+                    stderr: "inherit",
+                    tty: true
+                });
+            },
+            async close() { }
+        };
+    },
+    async attach() {
+        throw new Error("host runtime does not support reattach");
+    }
+};

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

@@ -0,0 +1,3 @@
+import type { Runner } from "../types.js";
+import type { HostRunnerOptions } from "../types.js";
+export declare function createHostRunner(options?: HostRunnerOptions): Runner;

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

@@ -0,0 +1,74 @@
+import { spawn as spawnChildProcess } from "node:child_process";
+export function createHostRunner(options = {}) {
+    const detached = options.detached === true;
+    return {
+        name: "host",
+        exec(spec) {
+            const stdinMode = spec.stdin ?? "ignore";
+            const stdoutMode = spec.stdout ?? "pipe";
+            const stderrMode = spec.stderr ?? "pipe";
+            const stdio = stdinMode === "inherit" && stdoutMode === "inherit" && stderrMode === "inherit"
+                ? "inherit"
+                : [stdinMode, stdoutMode, stderrMode];
+            const child = spawnChildProcess(spec.command, spec.args ?? [], {
+                cwd: spec.cwd,
+                env: spec.env,
+                stdio,
+                ...(detached ? { detached: true } : {})
+            });
+            if (detached) {
+                child.unref();
+            }
+            const kill = (signal) => {
+                if (detached && process.platform !== "win32" && child.pid !== undefined) {
+                    process.kill(-child.pid, signal);
+                    return;
+                }
+                child.kill(signal);
+            };
+            let settled = false;
+            let resolveResult = null;
+            const result = new Promise((resolve) => {
+                resolveResult = resolve;
+            });
+            const cleanupAbort = bindAbortSignal(spec.signal, () => {
+                kill("SIGTERM");
+            });
+            child.once("close", (code) => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanupAbort();
+                resolveResult?.({ exitCode: code ?? 1 });
+            });
+            child.once("error", () => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanupAbort();
+                resolveResult?.({ exitCode: 1 });
+            });
+            return {
+                pid: child.pid ?? null,
+                stdin: child.stdin,
+                stdout: child.stdout,
+                stderr: child.stderr,
+                result,
+                kill
+            };
+        }
+    };
+}
+function bindAbortSignal(signal, onAbort) {
+    if (signal === undefined) {
+        return () => { };
+    }
+    if (signal.aborted) {
+        onAbort();
+        return () => { };
+    }
+    signal.addEventListener("abort", onAbort, { once: true });
+    return () => {
+        signal.removeEventListener("abort", onAbort);
+    };
+}

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

@@ -0,0 +1,8 @@
+export { buildContextArgs, detectContext } from "./docker/context.js";
+export { detectEngine, isEngineAvailable } from "./docker/engine.js";
+export { createDockerRunner } from "./docker/docker-runner.js";
+export { buildDockerRuntimeTemplate, dockerExecutionEnvFactory } from "./docker/docker-execution-env.js";
+export { hostExecutionEnvFactory } from "./host/host-execution-env.js";
+export { createHostRunner } from "./host/host-runner.js";
+export { createMockRunner, createMockRunnerByCommand } from "./testing/index.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

@@ -0,0 +1,7 @@
+export { buildContextArgs, detectContext } from "./docker/context.js";
+export { detectEngine, isEngineAvailable } from "./docker/engine.js";
+export { createDockerRunner } from "./docker/docker-runner.js";
+export { buildDockerRuntimeTemplate, dockerExecutionEnvFactory } from "./docker/docker-execution-env.js";
+export { hostExecutionEnvFactory } from "./host/host-execution-env.js";
+export { createHostRunner } from "./host/host-runner.js";
+export { createMockRunner, createMockRunnerByCommand } from "./testing/index.js";

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

@@ -0,0 +1,2 @@
+export { createMockRunner, createMockRunnerByCommand } from "./mock-runner.js";
+export type { MockRunBehavior } from "../types.js";

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

@@ -0,0 +1 @@
+export { createMockRunner, createMockRunnerByCommand } from "./mock-runner.js";

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

@@ -0,0 +1,3 @@
+import type { MockRunBehavior, Runner } from "../types.js";
+export declare function createMockRunner(behaviors: MockRunBehavior[]): Runner;
+export declare function createMockRunnerByCommand(behaviorsByCommand: Record<string, MockRunBehavior>): Runner;

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

@@ -0,0 +1,115 @@
+import { Readable, Writable } from "node:stream";
+export function createMockRunner(behaviors) {
+    const remaining = [...behaviors];
+    return {
+        name: "mock",
+        exec(spec) {
+            const behavior = remaining.shift();
+            if (behavior === undefined) {
+                throw new Error("No mock run behaviors left");
+            }
+            return createRunHandle(spec, behavior);
+        }
+    };
+}
+export function createMockRunnerByCommand(behaviorsByCommand) {
+    return {
+        name: "mock",
+        exec(spec) {
+            const behavior = behaviorsByCommand[spec.command];
+            if (behavior === undefined) {
+                throw new Error(`No mock run behavior found for command "${spec.command}"`);
+            }
+            return createRunHandle(spec, behavior);
+        }
+    };
+}
+function createRunHandle(spec, behavior) {
+    const stdoutMode = spec.stdout ?? "pipe";
+    const stderrMode = spec.stderr ?? "pipe";
+    const stdinMode = spec.stdin ?? "ignore";
+    const interval = behavior.stdoutInterval ?? 10;
+    const stdoutController = stdoutMode === "pipe" && behavior.stdout !== undefined
+        ? createReadableStream(behavior.stdout, interval)
+        : null;
+    const stderrController = stderrMode === "pipe" && behavior.stderr !== undefined
+        ? createReadableStream(behavior.stderr, interval)
+        : null;
+    let resolveResult = null;
+    const result = new Promise((resolve) => {
+        resolveResult = resolve;
+    });
+    let finished = false;
+    const complete = () => {
+        if (finished || resolveResult === null) {
+            return;
+        }
+        finished = true;
+        resolveResult({ exitCode: behavior.exitCode });
+    };
+    const stopStreams = () => {
+        stdoutController?.stop();
+        stderrController?.stop();
+    };
+    const exitAfterMs = behavior.exitAfterMs ?? 0;
+    const exitTimer = exitAfterMs > 0
+        ? setTimeout(complete, exitAfterMs)
+        : queueMicrotask(complete);
+    return {
+        pid: behavior.pid ?? null,
+        stdout: stdoutController?.stream ?? null,
+        stderr: stderrController?.stream ?? null,
+        stdin: stdinMode === "pipe" ? createWritableStream() : null,
+        result,
+        kill() {
+            if (typeof exitTimer === "object" && exitTimer !== null && "hasRef" in exitTimer) {
+                clearTimeout(exitTimer);
+            }
+            stopStreams();
+            complete();
+        }
+    };
+}
+function createReadableStream(lines, interval) {
+    const stream = new Readable({
+        read() { }
+    });
+    const timers = new Set();
+    let stopped = false;
+    const stop = () => {
+        if (stopped) {
+            return;
+        }
+        stopped = true;
+        for (const timer of timers) {
+            clearTimeout(timer);
+        }
+        timers.clear();
+        stream.push(null);
+    };
+    if (lines.length === 0) {
+        queueMicrotask(stop);
+        return { stream, stop };
+    }
+    for (const [index, line] of lines.entries()) {
+        const timer = setTimeout(() => {
+            timers.delete(timer);
+            if (stopped) {
+                return;
+            }
+            stream.push(line);
+            if (index === lines.length - 1) {
+                stop();
+            }
+        }, interval * (index + 1));
+        timers.add(timer);
+    }
+    return { stream, stop };
+}
+function createWritableStream() {
+    return new Writable({
+        write(_chunk, _encoding, callback) {
+            callback();
+        }
+    });
+}

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

@@ -0,0 +1 @@
+export {};