toolcraft 0.0.11 → 0.0.13

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

@@ -0,0 +1,28 @@
+import type { DockerMount, Engine, ExecutionState, ExecutionEnvFactory, Runner } from "../types.js";
+interface DockerRuntime {
+    type: "docker";
+    image?: string;
+    dockerfile?: string;
+    build_context?: string;
+    build_args?: Record<string, string>;
+    mounts?: DockerMount[];
+    engine?: Engine;
+    network?: string;
+    extra_args?: string[];
+}
+export interface BuildDockerRuntimeTemplateInput {
+    cwd: string;
+    runtime: DockerRuntime;
+    state?: ExecutionState;
+    runner?: Runner;
+    force?: boolean;
+}
+export interface BuildDockerRuntimeTemplateResult {
+    backend: "docker";
+    hash: string;
+    image: string;
+    cached: boolean;
+}
+export declare const dockerExecutionEnvFactory: ExecutionEnvFactory;
+export declare function buildDockerRuntimeTemplate(input: BuildDockerRuntimeTemplateInput): Promise<BuildDockerRuntimeTemplateResult>;
+export {};

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

@@ -0,0 +1,428 @@
+import { createHash, randomBytes } from "node:crypto";
+import { mkdtempSync, rmSync } from "node:fs";
+import { readFile } 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";
+const containerCommand = ["sh", "-c", "while :; do sleep 3600; done"];
+export const dockerExecutionEnvFactory = {
+    type: "docker",
+    supportsDetach: true,
+    async open(spec) {
+        const runtime = parseDockerRuntime(spec.runtime);
+        const runner = spec.hostRunner ?? createHostRunner();
+        const engine = runtime.engine ?? detectEngine();
+        const context = detectContext();
+        const image = await resolveImage({
+            spec,
+            runtime,
+            runner,
+            engine,
+            context
+        });
+        const containerName = createContainerName();
+        const runArgs = buildDockerRunArgs({
+            engine,
+            context,
+            image,
+            command: containerCommand[0],
+            args: containerCommand.slice(1),
+            cwd: undefined,
+            env: undefined,
+            mounts: runtime.mounts ?? [],
+            ports: [],
+            network: runtime.network,
+            containerName,
+            detached: true,
+            interactive: true,
+            tty: false,
+            rm: false,
+            extraArgs: runtime.extra_args ?? []
+        });
+        const [command, ...args] = runArgs;
+        const id = (await runAndRead(runner, { command, args, stdout: "pipe", stderr: "pipe" })).trim();
+        return createDockerEnv({
+            id,
+            spec,
+            runner,
+            engine,
+            context
+        });
+    },
+    async attach(envId, context) {
+        const engine = detectEngine();
+        return createDockerEnv({
+            id: envId,
+            spec: createAttachedSpec(context?.cwd),
+            runner: createHostRunner(),
+            engine,
+            context: detectContext(),
+            attachedJobId: context?.jobId
+        });
+    }
+};
+function createDockerEnv(input) {
+    const containerRef = input.id;
+    return {
+        id: containerRef,
+        job: input.attachedJobId === undefined
+            ? null
+            : createContainerJob(containerRef, input.runner, input.engine, input.context, input.attachedJobId),
+        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"
+                });
+                return { files: 0, bytes: 0, skipped: [] };
+            }
+            finally {
+                rmSync(tempDir, { recursive: true, force: true });
+            }
+        },
+        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"
+                });
+                return { files: 0, bytes: 0, conflicts: [] };
+            }
+            finally {
+                rmSync(tempDir, { recursive: true, force: true });
+            }
+        },
+        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);
+        },
+        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,
+                env: shellSpec && "env" in shellSpec ? shellSpec.env : input.spec.env,
+                stdin: "inherit",
+                stdout: "inherit",
+                stderr: "inherit",
+                tty: true
+            });
+        },
+        async close() {
+            await runOrThrow(input.runner, {
+                command: input.engine,
+                args: [...buildContextArgs(input.engine, input.context), "rm", "-f", containerRef],
+                stdout: "pipe",
+                stderr: "pipe"
+            });
+        }
+    };
+}
+async function resolveImage(input) {
+    if (input.runtime.image !== undefined) {
+        return input.runtime.image;
+    }
+    const result = await buildDockerRuntimeTemplate({
+        cwd: input.spec.cwd,
+        runtime: input.runtime,
+        state: input.spec.state,
+        runner: input.runner
+    });
+    return result.image;
+}
+export async function buildDockerRuntimeTemplate(input) {
+    const runner = input.runner ?? createHostRunner();
+    const engine = input.runtime.engine ?? detectEngine();
+    const context = detectContext();
+    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 cached = input.force ? null : await input.state?.templates.get("docker", hash);
+    if (cached?.image !== undefined) {
+        return {
+            backend: "docker",
+            hash,
+            image: cached.image,
+            cached: true
+        };
+    }
+    const image = `poe-code/local:${hash}`;
+    await buildImage({
+        runner,
+        engine,
+        context,
+        image,
+        dockerfilePath,
+        buildContext,
+        buildArgs: input.runtime.build_args ?? {}
+    });
+    await input.state?.templates.put("docker", {
+        hash,
+        image,
+        runtime_type: "docker",
+        dockerfile_path: dockerfilePath,
+        built_at: new Date().toISOString()
+    });
+    return {
+        backend: "docker",
+        hash,
+        image,
+        cached: false
+    };
+}
+function hashDockerTemplate(dockerfileBytes, buildArgs) {
+    const hash = createHash("sha256");
+    hash.update(dockerfileBytes);
+    hash.update("\0");
+    for (const [key, value] of sortedBuildArgs(buildArgs)) {
+        hash.update(key);
+        hash.update("=");
+        hash.update(value);
+        hash.update("\0");
+    }
+    return hash.digest("hex");
+}
+async function buildImage(input) {
+    await runOrThrow(input.runner, {
+        command: input.engine,
+        args: [
+            ...buildContextArgs(input.engine, input.context),
+            "build",
+            "--tag",
+            input.image,
+            "-f",
+            input.dockerfilePath,
+            ...sortedBuildArgs(input.buildArgs).flatMap(([key, value]) => [
+                "--build-arg",
+                `${key}=${value}`
+            ]),
+            input.buildContext
+        ],
+        stdout: "pipe",
+        stderr: "pipe"
+    });
+}
+function parseDockerRuntime(runtime) {
+    if (!runtime || typeof runtime !== "object" || Array.isArray(runtime)) {
+        throw new Error("docker runtime must be an object");
+    }
+    const record = runtime;
+    if (record.type !== "docker") {
+        throw new Error('docker runtime type must be "docker"');
+    }
+    return record;
+}
+async function runAndRead(runner, spec) {
+    const handle = runner.exec(spec);
+    const stdout = readStream(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);
+}
+async function readStream(stream) {
+    if (stream === null) {
+        return "";
+    }
+    stream.setEncoding("utf8");
+    const chunks = [];
+    for await (const chunk of stream) {
+        chunks.push(String(chunk));
+    }
+    return chunks.join("");
+}
+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) {
+    return {
+        id: jobId,
+        envId: containerId,
+        tool: "docker",
+        argv: ["attach", containerId],
+        async status() {
+            const handle = runner.exec({
+                command: engine,
+                args: [
+                    ...buildContextArgs(engine, context),
+                    "inspect",
+                    "-f",
+                    "{{.State.Status}}",
+                    containerId
+                ],
+                stdout: "pipe",
+                stderr: "pipe"
+            });
+            const stdout = await readStream(handle.stdout);
+            const result = await handle.result;
+            if (result.exitCode !== 0) {
+                return "lost";
+            }
+            return stdout.trim() === "running" ? "running" : "exited";
+        },
+        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 };
+            }
+        },
+        async wait() {
+            const handle = runner.exec({
+                command: engine,
+                args: [...buildContextArgs(engine, context), "wait", containerId],
+                stdout: "pipe",
+                stderr: "pipe"
+            });
+            const stdout = await readStream(handle.stdout);
+            const result = await handle.result;
+            return { exitCode: Number.parseInt(stdout.trim(), 10) || result.exitCode };
+        },
+        async kill(signal) {
+            const args = signal === undefined || signal === "SIGTERM"
+                ? ["stop", containerId]
+                : ["kill", ...(signal === "SIGKILL" ? [] : [`--signal=${signal}`]), containerId];
+            await runOrThrow(runner, {
+                command: engine,
+                args: [...buildContextArgs(engine, context), ...args],
+                stdout: "pipe",
+                stderr: "pipe"
+            });
+        }
+    };
+}
+function createAttachedSpec(cwd = "/workspace") {
+    return {
+        cwd,
+        runtime: {
+            type: "docker",
+            image: "attached",
+            build_args: {},
+            mounts: []
+        },
+        env: {},
+        uploadIgnoreFiles: [],
+        jobLabel: {
+            tool: "docker",
+            argv: []
+        }
+    };
+}
+function shellQuote(value) {
+    return `'${value.replaceAll("'", "'\\''")}'`;
+}

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

@@ -0,0 +1,2 @@
+import type { DockerRunnerOptions, Runner } from "../types.js";
+export declare function createDockerRunner(options: DockerRunnerOptions): Runner;

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;