@fusionkit/cli 0.1.4 → 0.1.6

package/dist/gateway.d.ts

@@ -16,7 +16,6 @@ export type GatewayRunnerConfig = {
     command?: string;
     timeoutMs?: number;
     judgeModel?: string;
-    cursorKitDir?: string;
     fusionApiKey?: string;
     modelEndpoints?: Record<string, string>;
 };
@@ -53,7 +52,6 @@ export type GatewayAcceptanceInput = {
     sentinel: string;
     host: string;
     outPath: string;
-    cursorKitUrl?: string;
 };
 export declare function runGatewayAcceptance(input: GatewayAcceptanceInput): Promise<{
     reportPath: string;

package/dist/gateway.js

@@ -10,6 +10,7 @@ import { join, resolve } from "node:path";
 import { runFusionPanels, runUnifiedHarnessE2E } from "@fusionkit/ensemble";
 import { emitTrace, newSpanId, newTraceId } from "@fusionkit/protocol";
 import { FusionBackend, installAcpAdapters, runAcpAgent, runFrontDoorAcceptance, startFusionGateway, startGateway } from "@fusionkit/model-gateway";
+import { buildCursorAcpProducer } from "./cursor-acp.js";
 // Once an interactive coding agent owns the terminal, the per-turn panel chatter
 // would corrupt its full-screen TUI. The launcher flips this off before handing
 // over; trace events (for --observe) keep flowing regardless.
@@ -90,7 +91,6 @@ export function buildFrontDoorRunner(config) {
                 ...(config.command !== undefined ? { command: config.command } : {}),
                 ...(config.timeoutMs !== undefined ? { timeoutMs: config.timeoutMs } : {}),
                 ...(config.judgeModel !== undefined ? { judgeModel: config.judgeModel } : {}),
-                ...(config.cursorKitDir !== undefined ? { cursorKitDir: config.cursorKitDir } : {}),
                 ...(config.fusionApiKey !== undefined ? { fusionApiKey: config.fusionApiKey } : {}),
                 ...(config.modelEndpoints !== undefined ? { modelEndpoints: config.modelEndpoints } : {})
             });
@@ -293,10 +293,20 @@ export async function runGatewayAcceptance(input) {
         port: 0
     });
     try {
+        const cursorAcp = buildCursorAcpProducer({
+            gatewayUrl: gateway.url(),
+            sentinel: input.sentinel,
+            repo: input.config.repo,
+            ...(input.config.models[0]?.id !== undefined
+                ? { modelName: input.config.models[0].id }
+                : {}),
+            ...(input.config.timeoutMs !== undefined ? { timeoutMs: input.config.timeoutMs } : {})
+        });
         const report = await runFrontDoorAcceptance({
             gatewayUrl: gateway.url(),
             sentinel: input.sentinel,
-            acpRunner: buildAcpRunner(input.config)
+            acpRunner: buildAcpRunner(input.config),
+            ...(cursorAcp !== undefined ? { cursorAcp } : {})
         });
         mkdirSync(resolve(input.outPath, ".."), { recursive: true });
         writeFileSync(input.outPath, JSON.stringify(report, null, 2) + "\n");

package/dist/local.d.ts

@@ -6,26 +6,19 @@ import type { BackendConfig } from "@fusionkit/model-gateway";
  * (environment, config file, or — for Cursor — IDE settings + a public
  * tunnel), then execs the real binary with the user's own arguments.
  *
- * The shim builders below are pure so they can be unit-tested; the dispatcher
- * (`runLocal`) wires them to a started gateway and the real child process.
+ * The per-tool launch + shim logic now lives in the `@fusionkit/tool-*`
+ * packages; this dispatcher wires a started gateway into a ToolLaunchContext.
  */
-export type LocalTool = "claude" | "codex" | "opencode" | "cursor" | "serve";
+/** A launchable local tool id from the registry, or the `serve` pseudo-tool. */
+export type LocalTool = string;
+/** Launchable local tools (registry-derived) plus the `serve` pseudo-tool. */
 export declare const LOCAL_TOOLS: readonly LocalTool[];
-/** Environment for Claude Code: point it at the gateway's Anthropic surface. */
-export declare function claudeEnv(gatewayUrl: string, authToken?: string): Record<string, string>;
-/**
- * Codex config.toml fragment defining the gateway as a Responses provider.
- * Written into an ephemeral CODEX_HOME so the user's own config is untouched.
- */
-export declare function codexConfigToml(gatewayUrl: string, model: string): string;
-/** opencode config registering the gateway as an OpenAI-compatible provider. */
-export declare function opencodeConfig(gatewayUrl: string, model: string): Record<string, unknown>;
-/** The opencode `--model provider/model` argument for the gateway provider. */
-export declare function opencodeModelArg(model: string): string;
-/** Human-facing setup for Cursor (IDE plan/chat panel only; needs a public URL). */
-export declare function cursorInstructions(publicUrl: string, model: string): string;
+export { claudeEnv } from "@fusionkit/tool-claude";
+export { codexLaunchConfigToml as codexConfigToml } from "@fusionkit/tool-codex";
+export { opencodeConfig, opencodeModelArg } from "@fusionkit/tool-opencode";
+export { cursorInstructions } from "@fusionkit/tool-cursor";
 export type RunLocalOptions = {
-    /** Public URL for Cursor's tunnel (or WARRANT_PUBLIC_URL). */
+    /** Public URL for Cursor's tunnel (or FUSIONKIT_PUBLIC_URL). */
     publicUrl?: string;
     /** Bearer token to require on the gateway. */
     authToken?: string;

package/dist/local.js

@@ -1,74 +1,19 @@
-import { mkdtempSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
 import { createBackend, resolveBackendConfig, startGateway } from "@fusionkit/model-gateway";
-import { spawnTool } from "./shared/proc.js";
-export const LOCAL_TOOLS = ["claude", "codex", "opencode", "cursor", "serve"];
-/** The label a tool uses for the local model in its own UI. */
-const LOCAL_MODEL_LABEL = "warrant-local";
+import { LOCAL_MODEL_LABEL, readEnv } from "@fusionkit/tools";
+import { toolRegistry } from "./tools.js";
+/** Launchable local tools (registry-derived) plus the `serve` pseudo-tool. */
+export const LOCAL_TOOLS = [
+    ...toolRegistry.launchableLocal().map((tool) => tool.id),
+    "serve"
+];
 function backendModel(config) {
     return config.kind === "mlx" ? config.model : config.defaultModel ?? LOCAL_MODEL_LABEL;
 }
-// ---- pure shim builders (unit-tested) ----
-/** Environment for Claude Code: point it at the gateway's Anthropic surface. */
-export function claudeEnv(gatewayUrl, authToken) {
-    return {
-        ANTHROPIC_BASE_URL: gatewayUrl,
-        ANTHROPIC_AUTH_TOKEN: authToken ?? "warrant-local",
-        // Surface the local model in the /model picker (Anthropic discovery).
-        CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY: "1"
-    };
-}
-/**
- * Codex config.toml fragment defining the gateway as a Responses provider.
- * Written into an ephemeral CODEX_HOME so the user's own config is untouched.
- */
-export function codexConfigToml(gatewayUrl, model) {
-    return [
-        `model = "${model}"`,
-        `model_provider = "${LOCAL_MODEL_LABEL}"`,
-        "",
-        `[model_providers.${LOCAL_MODEL_LABEL}]`,
-        `name = "Warrant local"`,
-        `base_url = "${gatewayUrl}/v1"`,
-        `wire_api = "responses"`,
-        `requires_openai_auth = false`,
-        ""
-    ].join("\n");
-}
-/** opencode config registering the gateway as an OpenAI-compatible provider. */
-export function opencodeConfig(gatewayUrl, model) {
-    return {
-        $schema: "https://opencode.ai/config.json",
-        provider: {
-            [LOCAL_MODEL_LABEL]: {
-                npm: "@ai-sdk/openai-compatible",
-                name: "Warrant local",
-                options: { baseURL: `${gatewayUrl}/v1` },
-                models: { [model]: { name: model } }
-            }
-        }
-    };
-}
-/** The opencode `--model provider/model` argument for the gateway provider. */
-export function opencodeModelArg(model) {
-    return `${LOCAL_MODEL_LABEL}/${model}`;
-}
-/** Human-facing setup for Cursor (IDE plan/chat panel only; needs a public URL). */
-export function cursorInstructions(publicUrl, model) {
-    return [
-        "Cursor backs only its plan/chat panel with a custom model, and cannot reach",
-        "localhost — so this uses a public tunnel. In Cursor: Settings -> Models ->",
-        "enable 'Override OpenAI Base URL', then set:",
-        "",
-        `  Override OpenAI Base URL : ${publicUrl}/v1`,
-        `  Model name               : ${model}`,
-        `  OpenAI API Key           : warrant-local (any non-empty value)`,
-        "",
-        "Use the chat/plan panel (Cmd/Ctrl+L). Composer, inline edit, apply, and",
-        "autocomplete remain on Cursor's own backend and are not affected."
-    ].join("\n");
-}
+// ---- pure shim builders (re-exported from the per-tool packages) ----
+export { claudeEnv } from "@fusionkit/tool-claude";
+export { codexLaunchConfigToml as codexConfigToml } from "@fusionkit/tool-codex";
+export { opencodeConfig, opencodeModelArg } from "@fusionkit/tool-opencode";
+export { cursorInstructions } from "@fusionkit/tool-cursor";
 async function startLocalGateway(config, authToken) {
     const backend = createBackend(config);
     const gateway = await startGateway({
@@ -85,60 +30,49 @@ export async function runLocal(tool, toolArgs, options = {}) {
     const log = options.log ?? ((line) => console.error(line));
     const config = options.config ?? resolveBackendConfig();
     const model = backendModel(config);
+    const publicUrl = options.publicUrl ?? readEnv(process.env, "FUSIONKIT_PUBLIC_URL");
     const gateway = await startLocalGateway(config, options.authToken);
-    log(`warrant local: gateway on ${gateway.url} (model: ${model})`);
+    log(`fusionkit local: gateway on ${gateway.url} (model: ${model})`);
+    const disposers = [];
     try {
-        switch (tool) {
-            case "serve": {
-                log(`OpenAI:    ${gateway.url}/v1`);
-                log(`Anthropic: ${gateway.url}/v1/messages`);
-                log(`Responses: ${gateway.url}/v1/responses`);
-                log("Press Ctrl+C to stop.");
-                await new Promise(() => {
-                    /* run until interrupted */
-                });
-                return 0;
-            }
-            case "claude":
-                return await spawnTool("claude", toolArgs, claudeEnv(gateway.url, options.authToken));
-            case "codex": {
-                const home = mkdtempSync(join(tmpdir(), "warrant-codex-"));
-                writeFileSync(join(home, "config.toml"), codexConfigToml(gateway.url, model));
-                return await spawnTool("codex", toolArgs, { CODEX_HOME: home });
-            }
-            case "opencode": {
-                const dir = mkdtempSync(join(tmpdir(), "warrant-opencode-"));
-                const configPath = join(dir, "opencode.json");
-                writeFileSync(configPath, JSON.stringify(opencodeConfig(gateway.url, model), null, 2));
-                const args = toolArgs.includes("--model") ? toolArgs : ["--model", opencodeModelArg(model), ...toolArgs];
-                return await spawnTool("opencode", args, { OPENCODE_CONFIG: configPath });
-            }
-            case "cursor": {
-                const publicUrl = options.publicUrl ?? process.env.WARRANT_PUBLIC_URL;
-                if (publicUrl === undefined || publicUrl.length === 0) {
-                    log("");
-                    log("Cursor needs a public URL (it cannot reach localhost). Start a tunnel to");
-                    log(`${gateway.url} (e.g. 'cloudflared tunnel --url ${gateway.url}' or 'ngrok http`);
-                    log(`${gateway.url.replace(/^https?:\/\//, "")}'), then re-run with --public-url <url>`);
-                    log("or set WARRANT_PUBLIC_URL.");
-                    return 1;
-                }
-                log("");
-                log(cursorInstructions(publicUrl, model));
-                log("");
-                log("Gateway is running; leave this process up while you use Cursor. Ctrl+C to stop.");
-                await new Promise(() => {
-                    /* keep the gateway (and tunnel target) alive */
-                });
-                return 0;
-            }
-            default: {
-                const unreachable = tool;
-                throw new Error(`unknown local tool: ${String(unreachable)}`);
-            }
+        if (tool === "serve") {
+            log(`OpenAI:    ${gateway.url}/v1`);
+            log(`Anthropic: ${gateway.url}/v1/messages`);
+            log(`Responses: ${gateway.url}/v1/responses`);
+            log("Press Ctrl+C to stop.");
+            await new Promise(() => {
+                /* run until interrupted */
+            });
+            return 0;
         }
+        const integration = toolRegistry.get(tool);
+        if (integration === undefined || !integration.modes.includes("local")) {
+            throw new Error(`unknown local tool: ${String(tool)}`);
+        }
+        const ctx = {
+            mode: "local",
+            gatewayUrl: gateway.url,
+            modelLabel: model,
+            toolArgs,
+            ...(options.authToken !== undefined ? { authToken: options.authToken } : {}),
+            ...(publicUrl !== undefined ? { publicUrl } : {}),
+            log,
+            prepareForPassthrough: () => undefined,
+            registerPort: (_name, port) => `http://127.0.0.1:${port}`,
+            unregisterPort: () => undefined,
+            registerDisposer: (dispose) => disposers.push(dispose)
+        };
+        return await integration.launch(ctx);
     }
     finally {
+        for (const dispose of disposers.reverse()) {
+            try {
+                await dispose();
+            }
+            catch {
+                // best-effort teardown
+            }
+        }
         await gateway.close();
     }
 }

package/dist/shared/options.d.ts

@@ -1,5 +1,6 @@
-import type { EnsembleModel, HarnessLiveSmokeTarget, UnifiedHarnessKind } from "@fusionkit/ensemble";
+import type { EnsembleModel, UnifiedHarnessKind } from "@fusionkit/ensemble";
 import type { SessionIsolation } from "@fusionkit/protocol";
+import type { HarnessLiveSmokeTarget } from "../dashboard.js";
 import type { FusionTool, PanelModelSpec, PanelProvider } from "../fusion-quickstart.js";
 /** Commander reducer for repeatable string options (`--flag a --flag b`). */
 export declare function collect(value: string, previous?: string[]): string[];

package/dist/shared/options.js

@@ -1,4 +1,5 @@
 import { SESSION_ISOLATIONS } from "@fusionkit/protocol";
+import { toolRegistry } from "../tools.js";
 import { FUSION_TOOLS } from "../fusion-quickstart.js";
 import { fail } from "./errors.js";
 /** Commander reducer for repeatable string options (`--flag a --flag b`). */
@@ -28,32 +29,25 @@ export function ensembleModels(model, harness) {
     });
 }
 export function liveSmokeTargets(targets) {
+    const valid = new Set(toolRegistry
+        .dashboardTools()
+        .filter((tool) => tool.liveSmoke !== undefined)
+        .map((tool) => tool.id));
     return (targets ?? []).map((target) => {
-        switch (target) {
-            case "claude-code":
-            case "codex":
-                return target;
-            default:
-                fail('--live-smoke must be "claude-code" or "codex"');
-        }
+        if (valid.has(target))
+            return target;
+        return fail(`--live-smoke must be one of ${[...valid].join(", ")}`);
     });
 }
 export function unifiedHarnessKinds(targets) {
+    const generic = ["mock", "command", "agent"];
+    const valid = new Set([...generic, ...toolRegistry.harnessKinds()]);
     return (targets ?? ["mock", "command"])
         .flatMap((target) => target.split(","))
         .map((target) => {
-        switch (target) {
-            case "mock":
-            case "command":
-            case "agent":
-            case "codex":
-            case "claude-code":
-            case "cursor-acp":
-            case "cursor-desktop":
-                return target;
-            default:
-                fail(`--harness must be mock, command, agent, codex, claude-code, cursor-acp, or cursor-desktop; got "${target}"`);
-        }
+        if (valid.has(target))
+            return target;
+        return fail(`--harness must be one of ${[...valid].join(", ")}; got "${target}"`);
     });
 }
 export function parseTimeoutMs(raw, fallback) {

package/dist/shared/proc.d.ts

@@ -1,72 +1,6 @@
-import type { ChildProcess, SpawnOptions } from "node:child_process";
-/** Shared process helpers for the CLI's launcher/gateway flows. */
-export declare function sleep(ms: number): Promise<void>;
 /**
- * Reserve an ephemeral loopback port and return it. The probe socket is closed
- * before returning (children bind it themselves), but the number is held out of
- * circulation briefly so concurrent callers do not collide. Retries a bounded
- * number of times if the OS hands back a number we just reserved.
+ * Process helpers live in `@fusionkit/tools` so tool packages and the CLI share
+ * one implementation. Re-exported here to keep the CLI's existing import paths.
  */
-export declare function freePort(): Promise<number>;
-/**
- * Spawn a foreground tool with inherited stdio and resolve with its exit code.
- * A spawn failure (e.g. binary not on PATH) rejects rather than emitting an
- * unhandled `error` event.
- */
-export declare function spawnTool(command: string, args: string[], env: Record<string, string>, cwd?: string): Promise<number>;
-export type LoggedSpawnOptions = SpawnOptions & {
-    /** Tee the child's full stdout+stderr to this path for post-mortem. */
-    logFile?: string;
-    /** Cap the in-memory ring buffer (default 256 KiB). */
-    maxLogBytes?: number;
-};
-/**
- * A spawned background child with captured output and a recorded spawn error.
- * Always attaches an `'error'` listener so a missing binary surfaces as a clear
- * message via {@link waitForHttp} instead of crashing the process. The captured
- * log is a bounded ring buffer (so long sessions cannot leak memory); the full,
- * untruncated output is written to `logFile` when one is provided.
- */
-export type LoggedChild = {
-    child: ChildProcess;
-    /** The most recent captured stdout+stderr, up to the ring-buffer cap. */
-    log: () => string;
-    /** The spawn `'error'` (e.g. ENOENT), if one was emitted. */
-    spawnError: () => Error | undefined;
-    /** The full log file path, when teeing was requested. */
-    logFile: () => string | undefined;
-    /** Flush and close the log file stream (best-effort). */
-    closeLog: () => void;
-};
-export declare function spawnLogged(command: string, args: string[], options?: LoggedSpawnOptions): LoggedChild;
-/**
- * Distill the most useful slice of captured output for an error message. Prefers
- * lines that look like errors (so the root cause is not buried under `uvx`
- * resolve/build noise), then falls back to the head and tail of the log. The
- * full log lives in the child's `logFile` when one was provided.
- */
-export declare function distillLog(raw: string, options?: {
-    maxLines?: number;
-}): string;
-/**
- * Poll `probeUrl` until it answers (optionally requiring a 2xx), the child fails
- * to spawn, the child exits, or the timeout elapses. Distinguishes a failed
- * spawn ("uv: not found") from a slow start.
- */
-export declare function waitForHttp(probeUrl: string, proc: LoggedChild, options: {
-    timeoutMs: number;
-    label: string;
-    requireOk?: boolean;
-}): Promise<void>;
-/** Resolve once `pattern` is seen on the child's output, or reject on exit/timeout. */
-export declare function waitForOutput(proc: LoggedChild, pattern: RegExp, options: {
-    timeoutMs: number;
-    label: string;
-}): Promise<void>;
-/**
- * SIGTERM a child's whole process group, escalating to SIGKILL if it ignores the
- * grace period. Killing the group (`process.kill(-pid, ...)`) tears down wrapper
- * trees like `uvx -> uv -> python`; if the child was not spawned detached (no
- * group), it falls back to signalling the child directly.
- */
-export declare function terminate(child: ChildProcess, graceMs?: number): void;
+export { distillLog, freePort, sleep, spawnLogged, spawnTool, terminate, waitForHttp, waitForOutput } from "@fusionkit/tools";
+export type { LoggedChild, LoggedSpawnOptions } from "@fusionkit/tools";

package/dist/shared/proc.js

@@ -1,230 +1,5 @@
-import { spawn } from "node:child_process";
-import { createWriteStream } from "node:fs";
-import { createServer } from "node:net";
-/** Shared process helpers for the CLI's launcher/gateway flows. */
-export function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-// Ports we have handed out very recently but whose child may not have bound
-// yet. Holding them out of circulation for a short window closes the race where
-// two concurrent `freePort()` callers (parallel server startup) receive the
-// same number between the probe socket closing and the child binding.
-const recentlyReserved = new Map();
-const RESERVATION_MS = 5000;
-function reserve(port) {
-    const existing = recentlyReserved.get(port);
-    if (existing !== undefined)
-        clearTimeout(existing);
-    const timer = setTimeout(() => recentlyReserved.delete(port), RESERVATION_MS);
-    timer.unref();
-    recentlyReserved.set(port, timer);
-}
 /**
- * Reserve an ephemeral loopback port and return it. The probe socket is closed
- * before returning (children bind it themselves), but the number is held out of
- * circulation briefly so concurrent callers do not collide. Retries a bounded
- * number of times if the OS hands back a number we just reserved.
+ * Process helpers live in `@fusionkit/tools` so tool packages and the CLI share
+ * one implementation. Re-exported here to keep the CLI's existing import paths.
  */
-export async function freePort() {
-    for (let attempt = 0; attempt < 20; attempt++) {
-        const port = await probeEphemeralPort();
-        if (!recentlyReserved.has(port)) {
-            reserve(port);
-            return port;
-        }
-    }
-    // Extremely unlikely; fall back to whatever the OS last offered.
-    const port = await probeEphemeralPort();
-    reserve(port);
-    return port;
-}
-function probeEphemeralPort() {
-    return new Promise((resolve, reject) => {
-        const server = createServer();
-        server.on("error", reject);
-        server.listen(0, "127.0.0.1", () => {
-            const address = server.address();
-            const port = typeof address === "object" && address !== null ? address.port : 0;
-            server.close(() => resolve(port));
-        });
-    });
-}
-/**
- * Spawn a foreground tool with inherited stdio and resolve with its exit code.
- * A spawn failure (e.g. binary not on PATH) rejects rather than emitting an
- * unhandled `error` event.
- */
-export function spawnTool(command, args, env, cwd) {
-    return new Promise((resolveExit, reject) => {
-        const child = spawn(command, args, {
-            stdio: "inherit",
-            env: { ...process.env, ...env },
-            ...(cwd !== undefined ? { cwd } : {})
-        });
-        child.on("error", reject);
-        child.on("exit", (code) => resolveExit(code ?? 0));
-    });
-}
-/** Keep at most this many bytes of a child's captured output in memory. */
-const DEFAULT_MAX_LOG_BYTES = 256 * 1024;
-export function spawnLogged(command, args, options = {}) {
-    const { logFile, maxLogBytes, ...spawnOptions } = options;
-    const cap = maxLogBytes ?? DEFAULT_MAX_LOG_BYTES;
-    // `detached: true` makes the child its own process-group leader so that
-    // `terminate()` can signal the whole tree. This matters for wrappers like
-    // `uvx` (uvx -> uv -> python): signalling only the immediate child would
-    // orphan the grandchildren. Output is still piped; we never `unref()`, so the
-    // parent keeps managing the child's lifecycle.
-    const child = spawn(command, args, { ...spawnOptions, detached: true, stdio: ["ignore", "pipe", "pipe"] });
-    let buffer = "";
-    let spawnError;
-    let file;
-    if (logFile !== undefined) {
-        try {
-            file = createWriteStream(logFile, { flags: "a" });
-            // A broken log sink must never crash the run.
-            file.on("error", () => { });
-        }
-        catch {
-            file = undefined;
-        }
-    }
-    const onChunk = (chunk) => {
-        const text = chunk.toString("utf8");
-        file?.write(text);
-        buffer += text;
-        if (buffer.length > cap)
-            buffer = buffer.slice(buffer.length - cap);
-    };
-    child.stdout?.on("data", onChunk);
-    child.stderr?.on("data", onChunk);
-    child.on("error", (error) => (spawnError = error));
-    return {
-        child,
-        log: () => buffer,
-        spawnError: () => spawnError,
-        logFile: () => logFile,
-        closeLog: () => {
-            try {
-                file?.end();
-            }
-            catch {
-                // already closed
-            }
-        }
-    };
-}
-/**
- * Distill the most useful slice of captured output for an error message. Prefers
- * lines that look like errors (so the root cause is not buried under `uvx`
- * resolve/build noise), then falls back to the head and tail of the log. The
- * full log lives in the child's `logFile` when one was provided.
- */
-export function distillLog(raw, options = {}) {
-    const maxLines = options.maxLines ?? 16;
-    const lines = raw.split("\n").filter((line) => line.trim().length > 0);
-    if (lines.length === 0)
-        return "";
-    const errorPattern = /error|exception|traceback|fatal|denied|unauthorized|forbidden|invalid|not found|refused|timed? ?out|missing|failed|panic|429|401|403|500/i;
-    const errorLines = lines.filter((line) => errorPattern.test(line));
-    if (errorLines.length > 0) {
-        return errorLines.slice(-maxLines).join("\n");
-    }
-    if (lines.length <= maxLines)
-        return lines.join("\n");
-    const head = lines.slice(0, Math.ceil(maxLines / 2));
-    const tail = lines.slice(-Math.floor(maxLines / 2));
-    return [...head, "...", ...tail].join("\n");
-}
-function failureDetail(proc) {
-    const distilled = distillLog(proc.log());
-    const logPath = proc.logFile();
-    const pathNote = logPath !== undefined ? `\n(full log: ${logPath})` : "";
-    return `${distilled}${pathNote}`;
-}
-/**
- * Poll `probeUrl` until it answers (optionally requiring a 2xx), the child fails
- * to spawn, the child exits, or the timeout elapses. Distinguishes a failed
- * spawn ("uv: not found") from a slow start.
- */
-export async function waitForHttp(probeUrl, proc, options) {
-    const deadline = Date.now() + options.timeoutMs;
-    let lastError = "";
-    while (Date.now() < deadline) {
-        const spawnError = proc.spawnError();
-        if (spawnError !== undefined) {
-            throw new Error(`${options.label} failed to start: ${spawnError.message}\n${failureDetail(proc)}`);
-        }
-        if (proc.child.exitCode !== null) {
-            throw new Error(`${options.label} exited (code ${proc.child.exitCode}) before becoming ready\n${failureDetail(proc)}`);
-        }
-        try {
-            const response = await fetch(probeUrl);
-            if (options.requireOk !== true || response.ok)
-                return;
-            lastError = `status ${response.status}`;
-        }
-        catch (error) {
-            lastError = error instanceof Error ? error.message : String(error);
-        }
-        await sleep(400);
-    }
-    throw new Error(`${options.label} did not become ready within ${options.timeoutMs}ms (${lastError})\n${failureDetail(proc)}`);
-}
-/** Resolve once `pattern` is seen on the child's output, or reject on exit/timeout. */
-export function waitForOutput(proc, pattern, options) {
-    return new Promise((resolve, reject) => {
-        const deadline = setTimeout(() => {
-            cleanup();
-            reject(new Error(`${options.label} did not start within ${options.timeoutMs}ms:\n${failureDetail(proc)}`));
-        }, options.timeoutMs);
-        const poll = setInterval(() => {
-            if (proc.spawnError() !== undefined) {
-                cleanup();
-                reject(new Error(`${options.label} failed to start: ${proc.spawnError()?.message}\n${failureDetail(proc)}`));
-            }
-            else if (pattern.test(proc.log())) {
-                cleanup();
-                resolve();
-            }
-        }, 100);
-        const onExit = () => {
-            cleanup();
-            reject(new Error(`${options.label} exited before becoming ready:\n${failureDetail(proc)}`));
-        };
-        proc.child.once("exit", onExit);
-        function cleanup() {
-            clearTimeout(deadline);
-            clearInterval(poll);
-            proc.child.off("exit", onExit);
-        }
-    });
-}
-/**
- * SIGTERM a child's whole process group, escalating to SIGKILL if it ignores the
- * grace period. Killing the group (`process.kill(-pid, ...)`) tears down wrapper
- * trees like `uvx -> uv -> python`; if the child was not spawned detached (no
- * group), it falls back to signalling the child directly.
- */
-export function terminate(child, graceMs = 5000) {
-    if (child.pid === undefined || child.exitCode !== null || child.signalCode !== null)
-        return;
-    const pid = child.pid;
-    const signal = (sig) => {
-        try {
-            process.kill(-pid, sig);
-        }
-        catch {
-            try {
-                child.kill(sig);
-            }
-            catch {
-                // already gone
-            }
-        }
-    };
-    signal("SIGTERM");
-    const timer = setTimeout(() => signal("SIGKILL"), graceMs);
-    timer.unref();
-    child.once("exit", () => clearTimeout(timer));
-}
+export { distillLog, freePort, sleep, spawnLogged, spawnTool, terminate, waitForHttp, waitForOutput } from "@fusionkit/tools";