@wingman-ai/gateway 0.4.2 → 0.4.3

package/dist/tests/terminal-bench-adapters-helpers.test.d.ts

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

package/dist/tests/terminal-bench-adapters-helpers.test.js

@@ -0,0 +1,58 @@
+import { describe, expect, it } from "vitest";
+import { detectAssistantFailureMessage, parseWingmanJsonOutput } from "../bench/adapters/helpers.js";
+describe("parseWingmanJsonOutput", ()=>{
+    it("extracts assistant text from ai-role messages", ()=>{
+        const output = JSON.stringify({
+            type: "agent-complete",
+            result: {
+                messages: [
+                    {
+                        role: "user",
+                        content: "ignore"
+                    },
+                    {
+                        role: "ai",
+                        content: "hello from ai role"
+                    }
+                ]
+            }
+        });
+        const parsed = parseWingmanJsonOutput(output);
+        expect(parsed.assistantText).toBe("hello from ai role");
+    });
+    it("extracts assistant text from serialized AIMessage payloads", ()=>{
+        const output = JSON.stringify({
+            type: "agent-complete",
+            result: {
+                messages: [
+                    {
+                        id: [
+                            "langchain_core",
+                            "messages",
+                            "AIMessage"
+                        ],
+                        kwargs: {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: "hello from kwargs content"
+                                }
+                            ]
+                        }
+                    }
+                ]
+            }
+        });
+        const parsed = parseWingmanJsonOutput(output);
+        expect(parsed.assistantText).toBe("hello from kwargs content");
+    });
+});
+describe("detectAssistantFailureMessage", ()=>{
+    it("detects provider bad request failures", ()=>{
+        const error = detectAssistantFailureMessage("Model call failed after 3 attempts with BadRequestError: 400 status code (no body)");
+        expect(error).toContain("BadRequestError");
+    });
+    it("ignores normal assistant content", ()=>{
+        expect(detectAssistantFailureMessage('{"state_analysis":"ok","commands":[],"is_task_complete":false}')).toBeUndefined();
+    });
+});

package/dist/tests/terminal-bench-cleanup.test.cjs

@@ -0,0 +1,93 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_node_fs_namespaceObject = require("node:fs");
+const promises_namespaceObject = require("node:fs/promises");
+const external_node_os_namespaceObject = require("node:os");
+const external_node_path_namespaceObject = require("node:path");
+const external_vitest_namespaceObject = require("vitest");
+const cleanup_cjs_namespaceObject = require("../bench/cleanup.cjs");
+const tempDirs = [];
+async function pathExists(path) {
+    try {
+        await (0, promises_namespaceObject.access)(path);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+(0, external_vitest_namespaceObject.describe)("terminal bench cleanup", ()=>{
+    (0, external_vitest_namespaceObject.afterEach)(async ()=>{
+        for (const dir of tempDirs)await (0, promises_namespaceObject.rm)(dir, {
+            recursive: true,
+            force: true
+        });
+        tempDirs.length = 0;
+    });
+    (0, external_vitest_namespaceObject.it)("targets generated bench artifacts only", async ()=>{
+        const root = await (0, promises_namespaceObject.mkdtemp)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-bench-cleanup-"));
+        tempDirs.push(root);
+        const jobsRun = (0, external_node_path_namespaceObject.join)(root, "jobs", "2026-01-01__00-00-00");
+        const officialRun = (0, external_node_path_namespaceObject.join)(root, "bench", "results", "official", "2026-01-01__00-00-00");
+        const wrapperRun = (0, external_node_path_namespaceObject.join)(root, "bench", "results", "official-wrapper", "2026-01-01T00-00-00-000Z");
+        const pycacheDir = (0, external_node_path_namespaceObject.join)(root, "bench", "harbor_agents", "__pycache__");
+        const configPath = (0, external_node_path_namespaceObject.join)(root, "bench", "config.tb2-wingman.json");
+        (0, external_node_fs_namespaceObject.mkdirSync)(jobsRun, {
+            recursive: true
+        });
+        (0, external_node_fs_namespaceObject.mkdirSync)(officialRun, {
+            recursive: true
+        });
+        (0, external_node_fs_namespaceObject.mkdirSync)(wrapperRun, {
+            recursive: true
+        });
+        (0, external_node_fs_namespaceObject.mkdirSync)(pycacheDir, {
+            recursive: true
+        });
+        (0, external_node_fs_namespaceObject.writeFileSync)((0, external_node_path_namespaceObject.join)(jobsRun, "result.json"), "{}");
+        (0, external_node_fs_namespaceObject.writeFileSync)((0, external_node_path_namespaceObject.join)(officialRun, "result.json"), "{}");
+        (0, external_node_fs_namespaceObject.writeFileSync)((0, external_node_path_namespaceObject.join)(wrapperRun, "summary.json"), "{}");
+        (0, external_node_fs_namespaceObject.writeFileSync)((0, external_node_path_namespaceObject.join)(pycacheDir, "cache.pyc"), "x");
+        (0, external_node_fs_namespaceObject.writeFileSync)(configPath, "{}");
+        const targets = await (0, cleanup_cjs_namespaceObject.getBenchCleanupTargets)(root);
+        (0, external_vitest_namespaceObject.expect)(targets).toContain(jobsRun);
+        (0, external_vitest_namespaceObject.expect)(targets).toContain(officialRun);
+        (0, external_vitest_namespaceObject.expect)(targets).toContain(wrapperRun);
+        (0, external_vitest_namespaceObject.expect)(targets).toContain(pycacheDir);
+        (0, external_vitest_namespaceObject.expect)(targets).not.toContain(configPath);
+    });
+    (0, external_vitest_namespaceObject.it)("removes generated artifacts and keeps config files", async ()=>{
+        const root = await (0, promises_namespaceObject.mkdtemp)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-bench-cleanup-"));
+        tempDirs.push(root);
+        const jobsRun = (0, external_node_path_namespaceObject.join)(root, "jobs", "2026-01-01__00-00-00");
+        const officialRun = (0, external_node_path_namespaceObject.join)(root, "bench", "results", "official", "2026-01-01__00-00-00");
+        const wrapperRun = (0, external_node_path_namespaceObject.join)(root, "bench", "results", "official-wrapper", "2026-01-01T00-00-00-000Z");
+        const pycacheDir = (0, external_node_path_namespaceObject.join)(root, "bench", "harbor_agents", "__pycache__");
+        const configPath = (0, external_node_path_namespaceObject.join)(root, "bench", "config.tb2-wingman.json");
+        (0, external_node_fs_namespaceObject.mkdirSync)(jobsRun, {
+            recursive: true
+        });
+        (0, external_node_fs_namespaceObject.mkdirSync)(officialRun, {
+            recursive: true
+        });
+        (0, external_node_fs_namespaceObject.mkdirSync)(wrapperRun, {
+            recursive: true
+        });
+        (0, external_node_fs_namespaceObject.mkdirSync)(pycacheDir, {
+            recursive: true
+        });
+        (0, external_node_fs_namespaceObject.writeFileSync)(configPath, '{"dataset":"terminal-bench@2.0"}');
+        const result = await (0, cleanup_cjs_namespaceObject.cleanBenchArtifacts)(root);
+        (0, external_vitest_namespaceObject.expect)(result.missingPaths).toHaveLength(0);
+        (0, external_vitest_namespaceObject.expect)(result.removedPaths.length).toBeGreaterThanOrEqual(4);
+        (0, external_vitest_namespaceObject.expect)(await pathExists(jobsRun)).toBe(false);
+        (0, external_vitest_namespaceObject.expect)(await pathExists(officialRun)).toBe(false);
+        (0, external_vitest_namespaceObject.expect)(await pathExists(wrapperRun)).toBe(false);
+        (0, external_vitest_namespaceObject.expect)(await pathExists(pycacheDir)).toBe(false);
+        (0, external_vitest_namespaceObject.expect)(await pathExists(configPath)).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(await (0, promises_namespaceObject.readFile)(configPath, "utf-8")).toContain("terminal-bench@2.0");
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/tests/terminal-bench-cleanup.test.d.ts

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

package/dist/tests/terminal-bench-cleanup.test.js

@@ -0,0 +1,87 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { access, mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { cleanBenchArtifacts, getBenchCleanupTargets } from "../bench/cleanup.js";
+const tempDirs = [];
+async function pathExists(path) {
+    try {
+        await access(path);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+describe("terminal bench cleanup", ()=>{
+    afterEach(async ()=>{
+        for (const dir of tempDirs)await rm(dir, {
+            recursive: true,
+            force: true
+        });
+        tempDirs.length = 0;
+    });
+    it("targets generated bench artifacts only", async ()=>{
+        const root = await mkdtemp(join(tmpdir(), "wingman-bench-cleanup-"));
+        tempDirs.push(root);
+        const jobsRun = join(root, "jobs", "2026-01-01__00-00-00");
+        const officialRun = join(root, "bench", "results", "official", "2026-01-01__00-00-00");
+        const wrapperRun = join(root, "bench", "results", "official-wrapper", "2026-01-01T00-00-00-000Z");
+        const pycacheDir = join(root, "bench", "harbor_agents", "__pycache__");
+        const configPath = join(root, "bench", "config.tb2-wingman.json");
+        mkdirSync(jobsRun, {
+            recursive: true
+        });
+        mkdirSync(officialRun, {
+            recursive: true
+        });
+        mkdirSync(wrapperRun, {
+            recursive: true
+        });
+        mkdirSync(pycacheDir, {
+            recursive: true
+        });
+        writeFileSync(join(jobsRun, "result.json"), "{}");
+        writeFileSync(join(officialRun, "result.json"), "{}");
+        writeFileSync(join(wrapperRun, "summary.json"), "{}");
+        writeFileSync(join(pycacheDir, "cache.pyc"), "x");
+        writeFileSync(configPath, "{}");
+        const targets = await getBenchCleanupTargets(root);
+        expect(targets).toContain(jobsRun);
+        expect(targets).toContain(officialRun);
+        expect(targets).toContain(wrapperRun);
+        expect(targets).toContain(pycacheDir);
+        expect(targets).not.toContain(configPath);
+    });
+    it("removes generated artifacts and keeps config files", async ()=>{
+        const root = await mkdtemp(join(tmpdir(), "wingman-bench-cleanup-"));
+        tempDirs.push(root);
+        const jobsRun = join(root, "jobs", "2026-01-01__00-00-00");
+        const officialRun = join(root, "bench", "results", "official", "2026-01-01__00-00-00");
+        const wrapperRun = join(root, "bench", "results", "official-wrapper", "2026-01-01T00-00-00-000Z");
+        const pycacheDir = join(root, "bench", "harbor_agents", "__pycache__");
+        const configPath = join(root, "bench", "config.tb2-wingman.json");
+        mkdirSync(jobsRun, {
+            recursive: true
+        });
+        mkdirSync(officialRun, {
+            recursive: true
+        });
+        mkdirSync(wrapperRun, {
+            recursive: true
+        });
+        mkdirSync(pycacheDir, {
+            recursive: true
+        });
+        writeFileSync(configPath, '{"dataset":"terminal-bench@2.0"}');
+        const result = await cleanBenchArtifacts(root);
+        expect(result.missingPaths).toHaveLength(0);
+        expect(result.removedPaths.length).toBeGreaterThanOrEqual(4);
+        expect(await pathExists(jobsRun)).toBe(false);
+        expect(await pathExists(officialRun)).toBe(false);
+        expect(await pathExists(wrapperRun)).toBe(false);
+        expect(await pathExists(pycacheDir)).toBe(false);
+        expect(await pathExists(configPath)).toBe(true);
+        expect(await readFile(configPath, "utf-8")).toContain("terminal-bench@2.0");
+    });
+});

package/dist/tests/terminal-bench-config.test.cjs

@@ -0,0 +1,62 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_os_namespaceObject = require("node:os");
+const external_node_path_namespaceObject = require("node:path");
+const external_vitest_namespaceObject = require("vitest");
+const config_cjs_namespaceObject = require("../bench/config.cjs");
+(0, external_vitest_namespaceObject.describe)("terminal bench config", ()=>{
+    const workdirs = [];
+    (0, external_vitest_namespaceObject.afterEach)(()=>{
+        for (const workdir of workdirs)(0, external_node_fs_namespaceObject.rmSync)(workdir, {
+            recursive: true,
+            force: true
+        });
+        workdirs.length = 0;
+    });
+    (0, external_vitest_namespaceObject.it)("loads config/tasks with defaults and resolves relative paths", async ()=>{
+        const workdir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-bench-config-"));
+        workdirs.push(workdir);
+        const taskFilePath = (0, external_node_path_namespaceObject.join)(workdir, "tasks.json");
+        (0, external_node_fs_namespaceObject.writeFileSync)(taskFilePath, JSON.stringify({
+            tasks: [
+                {
+                    id: "t1",
+                    prompt: "hello",
+                    validator: {
+                        type: "assistant_contains",
+                        includes: "ok"
+                    }
+                }
+            ]
+        }, null, 2));
+        const configPath = (0, external_node_path_namespaceObject.join)(workdir, "config.json");
+        (0, external_node_fs_namespaceObject.writeFileSync)(configPath, JSON.stringify({
+            taskFile: "./tasks.json",
+            adapter: {
+                type: "command",
+                command: {
+                    command: "echo",
+                    args: [
+                        "ok"
+                    ]
+                }
+            }
+        }, null, 2));
+        const config = await (0, config_cjs_namespaceObject.loadTerminalBenchConfig)(configPath);
+        (0, external_vitest_namespaceObject.expect)(config.version).toBe(1);
+        (0, external_vitest_namespaceObject.expect)(config.taskFilePath).toBe(taskFilePath);
+        (0, external_vitest_namespaceObject.expect)(config.resultsDir).toBe((0, external_node_path_namespaceObject.join)(workdir, "bench/results"));
+        (0, external_vitest_namespaceObject.expect)(config.run.defaultTimeoutMs).toBe(300000);
+        (0, external_vitest_namespaceObject.expect)(config.tasks).toHaveLength(1);
+        (0, external_vitest_namespaceObject.expect)(config.tasks[0].validator.type).toBe("assistant_contains");
+        if ("assistant_contains" !== config.tasks[0].validator.type) throw new Error("Unexpected validator type");
+        (0, external_vitest_namespaceObject.expect)(config.tasks[0].validator.includes).toEqual([
+            "ok"
+        ]);
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/tests/terminal-bench-config.test.d.ts

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

package/dist/tests/terminal-bench-config.test.js

@@ -0,0 +1,56 @@
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { loadTerminalBenchConfig } from "../bench/config.js";
+describe("terminal bench config", ()=>{
+    const workdirs = [];
+    afterEach(()=>{
+        for (const workdir of workdirs)rmSync(workdir, {
+            recursive: true,
+            force: true
+        });
+        workdirs.length = 0;
+    });
+    it("loads config/tasks with defaults and resolves relative paths", async ()=>{
+        const workdir = mkdtempSync(join(tmpdir(), "wingman-bench-config-"));
+        workdirs.push(workdir);
+        const taskFilePath = join(workdir, "tasks.json");
+        writeFileSync(taskFilePath, JSON.stringify({
+            tasks: [
+                {
+                    id: "t1",
+                    prompt: "hello",
+                    validator: {
+                        type: "assistant_contains",
+                        includes: "ok"
+                    }
+                }
+            ]
+        }, null, 2));
+        const configPath = join(workdir, "config.json");
+        writeFileSync(configPath, JSON.stringify({
+            taskFile: "./tasks.json",
+            adapter: {
+                type: "command",
+                command: {
+                    command: "echo",
+                    args: [
+                        "ok"
+                    ]
+                }
+            }
+        }, null, 2));
+        const config = await loadTerminalBenchConfig(configPath);
+        expect(config.version).toBe(1);
+        expect(config.taskFilePath).toBe(taskFilePath);
+        expect(config.resultsDir).toBe(join(workdir, "bench/results"));
+        expect(config.run.defaultTimeoutMs).toBe(300000);
+        expect(config.tasks).toHaveLength(1);
+        expect(config.tasks[0].validator.type).toBe("assistant_contains");
+        if ("assistant_contains" !== config.tasks[0].validator.type) throw new Error("Unexpected validator type");
+        expect(config.tasks[0].validator.includes).toEqual([
+            "ok"
+        ]);
+    });
+});

package/dist/tests/terminal-bench-official.test.cjs

@@ -0,0 +1,194 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const official_cjs_namespaceObject = require("../bench/official.cjs");
+(0, external_vitest_namespaceObject.describe)("terminal bench official runner (harbor tb2)", ()=>{
+    (0, external_vitest_namespaceObject.it)("builds harbor args with overrides", ()=>{
+        const args = (0, official_cjs_namespaceObject.buildHarborRunArgs)({
+            dataset: "terminal-bench@2.0",
+            taskNames: [
+                "a",
+                "b"
+            ],
+            agent: "oracle",
+            nConcurrent: 1,
+            nAttempts: 1
+        }, {
+            taskNames: [
+                "single"
+            ],
+            agent: "codex",
+            nConcurrent: 2,
+            nAttempts: 3,
+            nTasks: 2,
+            model: "openai/gpt-4.1-mini",
+            agentKwargs: {
+                foo: "bar"
+            }
+        });
+        (0, external_vitest_namespaceObject.expect)(args).toEqual([
+            "run",
+            "--dataset",
+            "terminal-bench@2.0",
+            "--agent",
+            "codex",
+            "--model",
+            "openai/gpt-4.1-mini",
+            "--n-concurrent",
+            "2",
+            "--n-attempts",
+            "3",
+            "--n-tasks",
+            "2",
+            "--agent-kwarg",
+            "foo=bar",
+            "--task-name",
+            "single"
+        ]);
+    });
+    (0, external_vitest_namespaceObject.it)("builds harbor args with explicit registry url", ()=>{
+        const args = (0, official_cjs_namespaceObject.buildHarborRunArgs)({
+            dataset: "terminal-bench@2.0",
+            registryUrl: "https://raw.githubusercontent.com/laude-institute/harbor/main/registry.json?source=wingman",
+            agent: "oracle"
+        }, {});
+        (0, external_vitest_namespaceObject.expect)(args).toEqual([
+            "run",
+            "--dataset",
+            "terminal-bench@2.0",
+            "--registry-url",
+            "https://raw.githubusercontent.com/laude-institute/harbor/main/registry.json?source=wingman",
+            "--agent",
+            "oracle"
+        ]);
+    });
+    (0, external_vitest_namespaceObject.it)("builds harbor args without task names when running all dataset tasks", ()=>{
+        const args = (0, official_cjs_namespaceObject.buildHarborRunArgs)({
+            dataset: "terminal-bench@2.0",
+            agent: "oracle",
+            nConcurrent: 1
+        }, {
+            taskNames: []
+        });
+        (0, external_vitest_namespaceObject.expect)(args).toEqual([
+            "run",
+            "--dataset",
+            "terminal-bench@2.0",
+            "--agent",
+            "oracle",
+            "--n-concurrent",
+            "1"
+        ]);
+    });
+    (0, external_vitest_namespaceObject.it)("builds harbor args with custom import-path agent", ()=>{
+        const args = (0, official_cjs_namespaceObject.buildHarborRunArgs)({
+            dataset: "terminal-bench@2.0",
+            taskNames: [
+                "hello-world"
+            ],
+            agent: "oracle",
+            agentImportPath: "my_pkg.my_agent:MyAgent",
+            agentKwargs: {
+                wingman_agent: "coding",
+                model_name: "should-not-pass"
+            },
+            nConcurrent: 1
+        }, {
+            agentKwargs: {
+                wingman_cli_path: "./bin/wingman"
+            }
+        });
+        (0, external_vitest_namespaceObject.expect)(args).toEqual([
+            "run",
+            "--dataset",
+            "terminal-bench@2.0",
+            "--agent-import-path",
+            "my_pkg.my_agent:MyAgent",
+            "--n-concurrent",
+            "1",
+            "--agent-kwarg",
+            "wingman_agent=coding",
+            "--agent-kwarg",
+            "wingman_cli_path=./bin/wingman",
+            "--task-name",
+            "hello-world"
+        ]);
+    });
+    (0, external_vitest_namespaceObject.it)("parses resolved/unresolved/accuracy and pass@k", ()=>{
+        const parsed = (0, official_cjs_namespaceObject.parseHarborRunOutput)(`
+│ Resolved Trials   │ 1        │
+│ Unresolved Trials │ 1        │
+│ Accuracy          │ 50.00%   │
+│ Pass@1            │ 50.00%   │
+Results saved to /tmp/harbor/runs/run-1
+`);
+        (0, external_vitest_namespaceObject.expect)(parsed.resolvedTrials).toBe(1);
+        (0, external_vitest_namespaceObject.expect)(parsed.unresolvedTrials).toBe(1);
+        (0, external_vitest_namespaceObject.expect)(parsed.accuracyPercent).toBe(50);
+        (0, external_vitest_namespaceObject.expect)(parsed.passAtK["1"]).toBe(50);
+        (0, external_vitest_namespaceObject.expect)(parsed.runOutputPath).toBe("/tmp/harbor/runs/run-1");
+    });
+    (0, external_vitest_namespaceObject.it)("builds a docker shim script and path for podman fallback", ()=>{
+        const script = (0, official_cjs_namespaceObject.createDockerShimScript)("/usr/local/bin/podman");
+        (0, external_vitest_namespaceObject.expect)(script).toContain("TARGET_BINARY='/usr/local/bin/podman'");
+        (0, external_vitest_namespaceObject.expect)(script).toContain("exec podman-compose");
+        (0, external_vitest_namespaceObject.expect)(script).toContain("exec podman cp");
+        (0, external_vitest_namespaceObject.expect)(script).toContain("exec podman exec");
+        (0, external_vitest_namespaceObject.expect)(script).toContain("label=com.docker.compose.project");
+        (0, external_vitest_namespaceObject.expect)(script).toContain("--project-directory");
+        (0, external_vitest_namespaceObject.expect)(script.startsWith("#!/bin/bash")).toBe(true);
+        (0, external_vitest_namespaceObject.expect)((0, official_cjs_namespaceObject.buildRuntimePathEnv)("/tmp/runtime-bin", "/usr/bin")).toBe("/tmp/runtime-bin:/usr/bin");
+        (0, external_vitest_namespaceObject.expect)((0, official_cjs_namespaceObject.buildPythonPathEnv)("/tmp/repo", "/usr/lib/python")).toBe("/tmp/repo:/usr/lib/python");
+    });
+    (0, external_vitest_namespaceObject.it)("extracts a concise harbor error message", ()=>{
+        const message = (0, official_cjs_namespaceObject.extractHarborErrorMessage)(`
+Traceback...
+ValueError: No tasks found matching pattern: jq-data-processing
+`);
+        (0, external_vitest_namespaceObject.expect)(message).toBe("ValueError: No tasks found matching pattern: jq-data-processing");
+    });
+    (0, external_vitest_namespaceObject.it)("extracts a specific dataset resolution error over generic fallback", ()=>{
+        const message = (0, official_cjs_namespaceObject.extractHarborErrorMessage)(`
+Traceback...
+ValueError: Error getting dataset terminal-bench@2.0
+ValueError: Either datasets or tasks must be provided.
+`);
+        (0, external_vitest_namespaceObject.expect)(message).toBe("ValueError: Error getting dataset terminal-bench@2.0");
+    });
+    (0, external_vitest_namespaceObject.it)("rewrites generic empty-task selection error", ()=>{
+        const message = (0, official_cjs_namespaceObject.normalizeHarborFailureMessage)({
+            rawMessage: "ValueError: Either datasets or tasks must be provided.",
+            args: [
+                "run",
+                "--dataset",
+                "terminal-bench@2.0",
+                "--task-name",
+                "heterogeneous-dates"
+            ],
+            dataset: "terminal-bench@2.0"
+        });
+        (0, external_vitest_namespaceObject.expect)(message).toBe('No tasks matched "heterogeneous-dates" in dataset "terminal-bench@2.0". Verify task ids for Terminal-Bench 2.0.');
+    });
+    (0, external_vitest_namespaceObject.it)("normalizes podman docker host candidates", ()=>{
+        (0, external_vitest_namespaceObject.expect)((0, official_cjs_namespaceObject.parseDockerHostCandidate)("unix:///tmp/podman.sock")).toBe("unix:///tmp/podman.sock");
+        (0, external_vitest_namespaceObject.expect)((0, official_cjs_namespaceObject.parseDockerHostCandidate)("/tmp/podman.sock")).toBe("unix:///tmp/podman.sock");
+        (0, external_vitest_namespaceObject.expect)((0, official_cjs_namespaceObject.parseDockerHostCandidate)("'unix:///tmp/podman.sock'")).toBe("unix:///tmp/podman.sock");
+        (0, external_vitest_namespaceObject.expect)((0, official_cjs_namespaceObject.parseDockerHostCandidate)("<nil>")).toBeUndefined();
+        (0, external_vitest_namespaceObject.expect)((0, official_cjs_namespaceObject.parseDockerHostCandidate)(void 0)).toBeUndefined();
+    });
+    (0, external_vitest_namespaceObject.it)("detects missing compose provider errors", ()=>{
+        (0, external_vitest_namespaceObject.expect)((0, official_cjs_namespaceObject.isMissingComposeProviderError)(`
+Error: looking up compose provider failed
+* exec: "podman-compose": executable file not found in $PATH
+`)).toBe(true);
+        (0, external_vitest_namespaceObject.expect)((0, official_cjs_namespaceObject.isMissingComposeProviderError)("some other error")).toBe(false);
+    });
+    (0, external_vitest_namespaceObject.it)("detects podman-backed docker version output", ()=>{
+        (0, external_vitest_namespaceObject.expect)((0, official_cjs_namespaceObject.isPodmanBackedDockerVersionOutput)("Emulate Docker CLI using podman")).toBe(true);
+        (0, external_vitest_namespaceObject.expect)((0, official_cjs_namespaceObject.isPodmanBackedDockerVersionOutput)("Docker version 27.0.0")).toBe(false);
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/tests/terminal-bench-official.test.d.ts

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