toolcraft 0.0.12 → 0.0.14

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

@@ -0,0 +1,359 @@
+import { strict as assert } from "node:assert";
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { createDockerRunner, createHostRunner } from "../index.js";
+const dockerPortHost = 18923;
+async function verifyHostPiped() {
+    const runner = createHostRunner();
+    const handle = runner.exec({
+        command: "echo",
+        args: ["hello"],
+        stdout: "pipe",
+        stderr: "pipe"
+    });
+    const stdoutPromise = readStream(handle.stdout, "host piped stdout");
+    const { exitCode } = await handle.result;
+    const stdout = await stdoutPromise;
+    assert.equal(exitCode, 0, "host piped: exit code 0");
+    assert.equal(stdout.trim(), "hello", "host piped: stdout captured");
+    console.log("✓ host runner — piped mode");
+}
+async function verifyHostStdin() {
+    const runner = createHostRunner();
+    const handle = runner.exec({
+        command: "cat",
+        stdin: "pipe",
+        stdout: "pipe"
+    });
+    const stdoutPromise = readStream(handle.stdout, "host stdin stdout");
+    const stdin = assertWritable(handle.stdin, "host stdin: stdin available");
+    stdin.write("ping");
+    stdin.end();
+    const { exitCode } = await handle.result;
+    const stdout = await stdoutPromise;
+    assert.equal(exitCode, 0, "host stdin: exit code 0");
+    assert.equal(stdout, "ping", "host stdin: stdin echoed to stdout");
+    console.log("✓ host runner — stdin pipe");
+}
+async function verifyHostKill() {
+    const runner = createHostRunner();
+    const handle = runner.exec({
+        command: "sleep",
+        args: ["60"],
+        stdout: "pipe",
+        stderr: "pipe"
+    });
+    await delay(100);
+    handle.kill("SIGTERM");
+    const { exitCode } = await handle.result;
+    assert.notEqual(exitCode, 0, "host kill: non-zero exit after SIGTERM");
+    console.log("✓ host runner — kill");
+}
+async function verifyHostAbort() {
+    const runner = createHostRunner();
+    const controller = new AbortController();
+    const handle = runner.exec({
+        command: "sleep",
+        args: ["60"],
+        stdout: "pipe",
+        stderr: "pipe",
+        signal: controller.signal
+    });
+    await delay(100);
+    controller.abort();
+    const { exitCode } = await handle.result;
+    assert.notEqual(exitCode, 0, "host abort: non-zero exit after abort");
+    console.log("✓ host runner — abort signal");
+}
+async function verifyHostInherit() {
+    const runner = createHostRunner();
+    const handle = runner.exec({
+        command: "echo",
+        args: ["inherit-mode-output"],
+        stdin: "inherit",
+        stdout: "inherit",
+        stderr: "inherit"
+    });
+    assert.equal(handle.stdout, null, "host inherit: stdout is null");
+    assert.equal(handle.stderr, null, "host inherit: stderr is null");
+    assert.equal(handle.stdin, null, "host inherit: stdin is null");
+    const { exitCode } = await handle.result;
+    assert.equal(exitCode, 0, "host inherit: exit code 0");
+    console.log("✓ host runner — inherit mode");
+}
+async function verifyHostExitCode() {
+    const runner = createHostRunner();
+    const handle = runner.exec({
+        command: "sh",
+        args: ["-c", "exit 42"],
+        stdout: "pipe",
+        stderr: "pipe"
+    });
+    const { exitCode } = await handle.result;
+    assert.equal(exitCode, 42, "host exit code: 42");
+    console.log("✓ host runner — non-zero exit code");
+}
+async function verifyHostEnv() {
+    const runner = createHostRunner();
+    const handle = runner.exec({
+        command: "sh",
+        args: ["-c", "printf %s \"$MY_TEST_VAR\""],
+        stdout: "pipe",
+        env: { ...process.env, MY_TEST_VAR: "runner-works" }
+    });
+    const stdoutPromise = readStream(handle.stdout, "host env stdout");
+    const { exitCode } = await handle.result;
+    const stdout = await stdoutPromise;
+    assert.equal(exitCode, 0, "host env: exit code 0");
+    assert.equal(stdout, "runner-works", "host env: env var passed");
+    console.log("✓ host runner — env vars");
+}
+async function verifyDockerPiped(engine) {
+    const runner = createDockerRunner({ image: "alpine:latest", engine, context: "" });
+    const handle = runner.exec({
+        command: "echo",
+        args: ["hello from docker"],
+        stdout: "pipe",
+        stderr: "pipe"
+    });
+    const stdoutPromise = readStream(handle.stdout, "docker piped stdout");
+    const { exitCode } = await handle.result;
+    const stdout = await stdoutPromise;
+    assert.equal(exitCode, 0, "docker piped: exit code 0");
+    assert.equal(stdout.trim(), "hello from docker", "docker piped: stdout captured");
+    console.log("✓ docker runner — piped mode");
+}
+async function verifyDockerStdin(engine) {
+    const runner = createDockerRunner({ image: "alpine:latest", engine, context: "" });
+    const handle = runner.exec({
+        command: "cat",
+        stdin: "pipe",
+        stdout: "pipe"
+    });
+    const stdoutPromise = readStream(handle.stdout, "docker stdin stdout");
+    const stdin = assertWritable(handle.stdin, "docker stdin: stdin available");
+    stdin.write("docker-ping");
+    stdin.end();
+    const { exitCode } = await handle.result;
+    const stdout = await stdoutPromise;
+    assert.equal(exitCode, 0, "docker stdin: exit code 0");
+    assert.equal(stdout, "docker-ping", "docker stdin: stdin echoed to stdout");
+    console.log("✓ docker runner — stdin pipe");
+}
+async function verifyDockerKill(engine) {
+    const runner = createDockerRunner({ image: "alpine:latest", engine, context: "" });
+    const handle = runner.exec({
+        command: "sleep",
+        args: ["60"],
+        stdout: "pipe",
+        stderr: "pipe"
+    });
+    await delay(1000);
+    handle.kill("SIGTERM");
+    const { exitCode } = await handle.result;
+    assert.notEqual(exitCode, 0, "docker kill: non-zero exit after SIGTERM");
+    console.log("✓ docker runner — kill");
+}
+async function verifyDockerExitCode(engine) {
+    const runner = createDockerRunner({ image: "alpine:latest", engine, context: "" });
+    const handle = runner.exec({
+        command: "sh",
+        args: ["-c", "exit 42"],
+        stdout: "pipe",
+        stderr: "pipe"
+    });
+    const { exitCode } = await handle.result;
+    assert.equal(exitCode, 42, "docker exit code: 42");
+    console.log("✓ docker runner — non-zero exit code");
+}
+async function verifyDockerEnv(engine) {
+    const runner = createDockerRunner({ image: "alpine:latest", engine, context: "" });
+    const handle = runner.exec({
+        command: "sh",
+        args: ["-c", "printf %s \"$MY_TEST_VAR\""],
+        stdout: "pipe",
+        env: { MY_TEST_VAR: "docker-runner-works" }
+    });
+    const stdoutPromise = readStream(handle.stdout, "docker env stdout");
+    const { exitCode } = await handle.result;
+    const stdout = await stdoutPromise;
+    assert.equal(exitCode, 0, "docker env: exit code 0");
+    assert.equal(stdout, "docker-runner-works", "docker env: env var passed");
+    console.log("✓ docker runner — env vars");
+}
+async function verifyDockerMount(engine) {
+    const mountRoot = mkdtempSync(path.join(tmpdir(), "process-runner-verify-"));
+    const mountFile = path.join(mountRoot, "mounted.txt");
+    writeFileSync(mountFile, "mounted-ok\n", "utf8");
+    try {
+        const runner = createDockerRunner({
+            image: "alpine:latest",
+            engine,
+            context: "",
+            mounts: [{ source: mountRoot, target: "/host-data", readonly: true }]
+        });
+        const handle = runner.exec({
+            command: "cat",
+            args: ["/host-data/mounted.txt"],
+            stdout: "pipe",
+            stderr: "pipe"
+        });
+        const stdoutPromise = readStream(handle.stdout, "docker mount stdout");
+        const { exitCode } = await handle.result;
+        const stdout = await stdoutPromise;
+        assert.equal(exitCode, 0, "docker mount: exit code 0");
+        assert.equal(stdout.trim(), "mounted-ok", "docker mount: mounted file available");
+        console.log("✓ docker runner — bind mount");
+    }
+    finally {
+        rmSync(mountRoot, { recursive: true, force: true });
+    }
+}
+async function verifyDockerPort(engine) {
+    const runner = createDockerRunner({
+        image: "alpine:latest",
+        engine,
+        context: "",
+        ports: [{ host: dockerPortHost, container: 8080 }]
+    });
+    const handle = runner.exec({
+        command: "sh",
+        args: [
+            "-c",
+            "mkdir -p /srv/http && printf ok > /srv/http/index.html && exec busybox httpd -f -p 8080 -h /srv/http"
+        ],
+        stdout: "pipe",
+        stderr: "pipe"
+    });
+    try {
+        await waitForHttpOk(`http://127.0.0.1:${dockerPortHost}`);
+        console.log("✓ docker runner — port mapping");
+    }
+    finally {
+        handle.kill("SIGTERM");
+        await handle.result;
+    }
+}
+async function verifyDockerInteractiveContract(engine) {
+    const runner = createDockerRunner({ image: "alpine:latest", engine, context: "" });
+    const handle = runner.exec({
+        command: "sh",
+        args: [
+            "-c",
+            "if [ -t 0 ]; then printf stdin-is-tty; else printf stdin-not-tty; fi; printf '\\n'; if [ -t 1 ]; then printf stdout-is-tty; else printf stdout-not-tty; fi"
+        ],
+        stdin: "pipe",
+        stdout: "pipe",
+        tty: true
+    });
+    const stdoutPromise = readStream(handle.stdout, "docker interactive stdout");
+    const stdin = assertWritable(handle.stdin, "docker interactive: stdin available");
+    stdin.end();
+    const { exitCode } = await handle.result;
+    const stdout = await stdoutPromise;
+    assert.equal(exitCode, 0, "docker interactive: exit code 0");
+    assert.ok(stdout.includes("stdin-is-tty"), "docker interactive: stdin is tty");
+    assert.ok(stdout.includes("stdout-is-tty"), "docker interactive: stdout is tty");
+    console.log("✓ docker runner — tty contract");
+}
+async function main() {
+    console.log("\n=== Host Runner ===\n");
+    await verifyHostPiped();
+    await verifyHostStdin();
+    await verifyHostKill();
+    await verifyHostAbort();
+    await verifyHostInherit();
+    await verifyHostExitCode();
+    await verifyHostEnv();
+    console.log("\n=== Docker Runner ===\n");
+    const engine = resolveAvailableEngine();
+    if (engine !== null) {
+        await verifyDockerPiped(engine);
+        await verifyDockerStdin(engine);
+        await verifyDockerKill(engine);
+        await verifyDockerExitCode(engine);
+        await verifyDockerEnv(engine);
+        await verifyDockerMount(engine);
+        await verifyDockerPort(engine);
+        await verifyDockerInteractiveContract(engine);
+    }
+    else {
+        console.log("⏭ Docker not available — skipping docker runner tests");
+    }
+    console.log("\n=== All verifications passed ===\n");
+}
+async function readStream(stream, label) {
+    const readable = assertReadable(stream, `${label}: stream is available`);
+    return await new Promise((resolve, reject) => {
+        let output = "";
+        readable.setEncoding("utf8");
+        readable.on("data", (chunk) => {
+            output += chunk;
+        });
+        readable.once("end", () => {
+            resolve(output);
+        });
+        readable.once("error", reject);
+    });
+}
+function assertReadable(stream, message) {
+    if (stream === null) {
+        assert.fail(message);
+    }
+    return stream;
+}
+function assertWritable(stream, message) {
+    if (stream === null) {
+        assert.fail(message);
+    }
+    return stream;
+}
+function resolveAvailableEngine() {
+    for (const engine of ["docker", "podman"]) {
+        if (!isEngineResponsive(engine, ["--version"])) {
+            continue;
+        }
+        if (isEngineResponsive(engine, ["info"])) {
+            return engine;
+        }
+    }
+    return null;
+}
+function isEngineResponsive(engine, args) {
+    const result = spawnSync(engine, args, {
+        stdio: "ignore",
+        timeout: 2000
+    });
+    if (result.error !== undefined) {
+        return false;
+    }
+    return result.status === 0;
+}
+async function waitForHttpOk(url) {
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < 15000) {
+        try {
+            const response = await fetch(url);
+            const body = await response.text();
+            if (response.ok && body.includes("ok")) {
+                return;
+            }
+        }
+        catch (error) {
+            void error;
+        }
+        await delay(250);
+    }
+    throw new Error(`Timed out waiting for ${url}`);
+}
+function delay(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

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

@@ -0,0 +1,180 @@
+import type { Readable, Writable } from "node:stream";
+export interface RunHandle {
+    readonly pid: number | null;
+    readonly stdout: Readable | null;
+    readonly stderr: Readable | null;
+    readonly stdin: Writable | null;
+    readonly result: Promise<RunResult>;
+    kill(signal?: NodeJS.Signals): void;
+}
+export interface RunResult {
+    exitCode: number;
+}
+export interface RunSpec {
+    command: string;
+    args?: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+    stdin?: "pipe" | "inherit" | "ignore";
+    stdout?: "pipe" | "inherit";
+    stderr?: "pipe" | "inherit";
+    tty?: boolean;
+    signal?: AbortSignal;
+}
+export interface Runner {
+    exec(spec: RunSpec): RunHandle;
+    readonly name: string;
+}
+export interface HostRunnerOptions {
+    detached?: boolean;
+}
+export type ExecutionEnvType = "host" | "docker" | "e2b";
+export type JobStatus = "running" | "exited" | "killed" | "lost";
+export interface ExecutionEnvFactory {
+    readonly type: ExecutionEnvType;
+    readonly supportsDetach?: boolean;
+    open(spec: OpenSpec): Promise<OpenedEnv>;
+    attach(envId: string, context?: AttachedJobContext): Promise<OpenedEnv>;
+}
+export interface OpenSpec {
+    cwd: string;
+    runtime: unknown;
+    runner?: unknown;
+    state?: ExecutionState;
+    hostRunner?: Runner;
+    env: Record<string, string>;
+    uploadIgnoreFiles: string[];
+    jobLabel: {
+        tool: string;
+        argv: string[];
+    };
+    execution?: {
+        wrapForLogTee?: boolean;
+        stdin?: RunSpec["stdin"];
+        stdout?: RunSpec["stdout"];
+        stderr?: RunSpec["stderr"];
+        env?: RunSpec["env"];
+        tty?: boolean;
+        input?: string | Buffer;
+        captureOutput?: boolean;
+        activityTimeoutMs?: number;
+        onStdout?(chunk: string): void;
+        onStderr?(chunk: string): void;
+    };
+    shellSpec?: RunSpec;
+}
+export interface ExecutionState {
+    templates: {
+        get(backend: "docker" | "e2b", hash: string): Promise<TemplateEntry | null>;
+        put(backend: "docker" | "e2b", entry: TemplateEntry): Promise<void>;
+    };
+}
+export interface TemplateEntry {
+    hash: string;
+    template_id?: string;
+    image?: string;
+    runtime_type: string;
+    dockerfile_path: string;
+    built_at: string;
+}
+export interface UploadResult {
+    files: number;
+    bytes: number;
+    skipped: {
+        path: string;
+        bytes: number;
+        reason: "max_size";
+    }[];
+}
+export interface DownloadResult {
+    files: number;
+    bytes: number;
+    conflicts: {
+        path: string;
+        reason: "local_modified";
+    }[];
+}
+export interface LogChunk {
+    byteOffset: number;
+    data: string;
+}
+export interface AttachedJobContext {
+    jobId: string;
+    tool: string;
+    argv: string[];
+    cwd: string;
+}
+export interface OpenedEnv {
+    readonly id: string;
+    readonly job: JobHandle | null;
+    uploadWorkspace(): Promise<UploadResult>;
+    downloadWorkspace(opts: {
+        conflictPolicy: "refuse" | "overwrite";
+    }): Promise<DownloadResult>;
+    exec(spec: RunSpec): RunHandle;
+    detach(): Promise<JobHandle>;
+    shell(): RunHandle;
+    close(): Promise<void>;
+}
+export interface JobHandle {
+    readonly id: string;
+    readonly envId: string;
+    readonly tool: string;
+    readonly argv: string[];
+    status(): Promise<JobStatus>;
+    stream(opts?: {
+        sinceByte?: number;
+        since?: Date;
+    }): AsyncIterable<LogChunk>;
+    wait(): Promise<{
+        exitCode: number;
+    }>;
+    kill(signal?: NodeJS.Signals): Promise<void>;
+}
+export type Engine = "docker" | "podman";
+export interface DockerMount {
+    source: string;
+    target: string;
+    readonly?: boolean;
+}
+export interface DockerPortMapping {
+    host: number;
+    container: number;
+    protocol?: "tcp" | "udp";
+}
+export interface DockerRunnerOptions {
+    image: string;
+    engine?: Engine;
+    context?: string;
+    mounts?: DockerMount[];
+    ports?: DockerPortMapping[];
+    network?: string;
+    extraArgs?: string[];
+    containerName?: string;
+}
+export interface DockerRunArgs {
+    engine: Engine;
+    context: string | null;
+    image: string;
+    command: string;
+    args: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+    mounts: DockerMount[];
+    ports: DockerPortMapping[];
+    network?: string;
+    containerName: string;
+    detached: boolean;
+    interactive: boolean;
+    tty: boolean;
+    rm: boolean;
+    extraArgs: string[];
+}
+export interface MockRunBehavior {
+    pid?: number;
+    exitCode: number;
+    exitAfterMs?: number;
+    stdout?: string[];
+    stderr?: string[];
+    stdoutInterval?: number;
+}

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

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

package/node_modules/@poe-code/process-runner/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@poe-code/process-runner",
+  "version": "0.0.1",
+  "private": true,
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./testing": {
+      "types": "./dist/testing/index.d.ts",
+      "import": "./dist/testing/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "cd ../.. && vitest run --config vitest.config.ts packages/process-runner/src/**/*.test.ts",
+    "test:unit": "cd ../.. && vitest run --config vitest.config.ts packages/process-runner/src/**/*.test.ts",
+    "lint": "cd ../.. && eslint packages/process-runner/src --ext ts && tsc -p packages/process-runner/tsconfig.json --noEmit"
+  },
+  "files": [
+    "dist"
+  ]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolcraft",
-  "version": "0.0.12",
+  "version": "0.0.14",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -35,8 +35,8 @@
     "test": "cd ../.. && vitest run packages/toolcraft/src",
     "test:unit": "cd ../.. && vitest run packages/toolcraft/src",
     "lint": "cd ../.. && eslint packages/toolcraft/src --ext ts && tsc -p packages/toolcraft/tsconfig.json --noEmit",
-    "prepack": "node ../../scripts/manage-bundled-workspace-deps.mjs prepare . @poe-code/design-system @poe-code/agent-mcp-config @poe-code/agent-human-in-loop @poe-code/task-list @poe-code/file-lock @poe-code/agent-defs @poe-code/config-mutations tiny-mcp-client mcp-oauth auth-store",
-    "postpack": "node ../../scripts/manage-bundled-workspace-deps.mjs cleanup . @poe-code/design-system @poe-code/agent-mcp-config @poe-code/agent-human-in-loop @poe-code/task-list @poe-code/file-lock @poe-code/agent-defs @poe-code/config-mutations tiny-mcp-client mcp-oauth auth-store"
+    "prepack": "node ../../scripts/manage-bundled-workspace-deps.mjs prepare . @poe-code/design-system @poe-code/agent-mcp-config @poe-code/agent-human-in-loop @poe-code/task-list @poe-code/file-lock @poe-code/agent-defs @poe-code/config-mutations @poe-code/process-runner tiny-mcp-client mcp-oauth auth-store",
+    "postpack": "node ../../scripts/manage-bundled-workspace-deps.mjs cleanup . @poe-code/design-system @poe-code/agent-mcp-config @poe-code/agent-human-in-loop @poe-code/task-list @poe-code/file-lock @poe-code/agent-defs @poe-code/config-mutations @poe-code/process-runner tiny-mcp-client mcp-oauth auth-store"
   },
   "dependencies": {
     "@clack/core": "^1.0.0",
@@ -44,8 +44,12 @@
     "chalk": "^5.6.2",
     "commander": "^14.0.3",
     "console-table-printer": "^2.15.0",
+    "jose": "^6.1.2",
+    "jsonc-parser": "^3.3.1",
+    "mustache": "^4.2.0",
+    "smol-toml": "^1.3.0",
     "tiny-stdio-mcp-server": "^0.1.0",
-    "toolcraft-schema": "^0.0.12",
+    "toolcraft-schema": "^0.0.14",
     "yaml": "^2.8.2"
   },
   "files": [
@@ -67,6 +71,7 @@
     "@poe-code/file-lock",
     "@poe-code/agent-defs",
     "@poe-code/config-mutations",
+    "@poe-code/process-runner",
     "tiny-mcp-client",
     "mcp-oauth",
     "auth-store"
@@ -78,6 +83,7 @@
     "@poe-code/config-mutations": "*",
     "@poe-code/design-system": "^0.0.1",
     "@poe-code/file-lock": "*",
+    "@poe-code/process-runner": "*",
     "@poe-code/task-list": "*",
     "auth-store": "*",
     "mcp-oauth": "*",