@workbench-ai/workbench 0.0.67 → 0.0.69

package/dist/install-targets.d.ts

@@ -0,0 +1,35 @@
+import { type Json, type SurfaceSnapshotFile } from "@workbench-ai/workbench-core";
+export type WorkbenchInstallAgentTarget = "codex" | "claude";
+export type WorkbenchInstallTargetName = WorkbenchInstallAgentTarget | "local";
+export interface WorkbenchInstallSnapshot {
+    name: string;
+    files: SurfaceSnapshotFile[];
+}
+export interface WorkbenchInstallTarget {
+    agent: WorkbenchInstallTargetName;
+    mode: "copy";
+    destination: string;
+}
+export interface WorkbenchInstallTargetResult extends WorkbenchInstallTarget {
+    previous: "none" | "overwritten" | "unchanged";
+}
+export interface WorkbenchInstallResult {
+    result: "installed" | "unchanged";
+    targets: WorkbenchInstallTargetResult[];
+    filesCopied: number;
+}
+export declare function supportedInstallTargets(): WorkbenchInstallTarget[];
+export declare function resolveInstallTargets(options: {
+    agents: readonly string[];
+    local: boolean;
+    skillName: string;
+}): WorkbenchInstallTarget[];
+export declare function installSnapshotToTargets(options: {
+    snapshot: WorkbenchInstallSnapshot;
+    targets: readonly WorkbenchInstallTarget[];
+    overwrite: boolean;
+    dryRun: boolean;
+}): Promise<WorkbenchInstallResult>;
+export declare function normalizeInstallSnapshotPath(filePath: string): string;
+export declare function installTargetsToJson(targets: readonly WorkbenchInstallTarget[]): Json[];
+//# sourceMappingURL=install-targets.d.ts.map

package/dist/install-targets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"install-targets.d.ts","sourceRoot":"","sources":["../src/install-targets.ts"],"names":[],"mappings":"AAIA,OAAO,EAAuB,KAAK,IAAI,EAAE,KAAK,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AAExG,MAAM,MAAM,2BAA2B,GAAG,OAAO,GAAG,QAAQ,CAAC;AAC7D,MAAM,MAAM,0BAA0B,GAAG,2BAA2B,GAAG,OAAO,CAAC;AAE/E,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,mBAAmB,EAAE,CAAC;CAC9B;AAED,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,0BAA0B,CAAC;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,4BAA6B,SAAQ,sBAAsB;IAC1E,QAAQ,EAAE,MAAM,GAAG,aAAa,GAAG,WAAW,CAAC;CAChD;AAED,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,WAAW,GAAG,WAAW,CAAC;IAClC,OAAO,EAAE,4BAA4B,EAAE,CAAC;IACxC,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,wBAAgB,uBAAuB,IAAI,sBAAsB,EAAE,CAMlE;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE;IAC7C,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B,KAAK,EAAE,OAAO,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,GAAG,sBAAsB,EAAE,CA8B3B;AAED,wBAAsB,wBAAwB,CAAC,OAAO,EAAE;IACtD,QAAQ,EAAE,wBAAwB,CAAC;IACnC,OAAO,EAAE,SAAS,sBAAsB,EAAE,CAAC;IAC3C,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,EAAE,OAAO,CAAC;CACjB,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAyDlC;AAiBD,wBAAgB,4BAA4B,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAgBrE;AAyDD,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,SAAS,sBAAsB,EAAE,GAAG,IAAI,EAAE,CAMvF"}

package/dist/install-targets.js

@@ -0,0 +1,188 @@
+import { promises as fs } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { WorkbenchCodedError } from "@workbench-ai/workbench-core";
+export function supportedInstallTargets() {
+    return [
+        { agent: "codex", mode: "copy", destination: path.join(workbenchAgentHome("codex"), "skills", "<skill>") },
+        { agent: "claude", mode: "copy", destination: path.join(workbenchAgentHome("claude"), "skills", "<skill>") },
+        { agent: "local", mode: "copy", destination: path.join(process.cwd(), ".agents", "skills", "<skill>") },
+    ];
+}
+export function resolveInstallTargets(options) {
+    const targets = [];
+    for (const rawAgent of options.agents) {
+        const agent = rawAgent.trim().toLowerCase();
+        if (agent !== "codex" && agent !== "claude") {
+            throw new WorkbenchCodedError("usage", `Unsupported install agent: ${rawAgent}`, {
+                remediation: "Use --agent codex, --agent claude, or --local.",
+                exitCode: 2,
+            });
+        }
+        targets.push({
+            agent,
+            mode: "copy",
+            destination: path.join(workbenchAgentHome(agent), "skills", options.skillName),
+        });
+    }
+    if (options.local) {
+        targets.push({
+            agent: "local",
+            mode: "copy",
+            destination: path.join(process.cwd(), ".agents", "skills", options.skillName),
+        });
+    }
+    if (targets.length === 0) {
+        throw new WorkbenchCodedError("install_target_required", "workbench install requires an explicit target.", {
+            remediation: "Run workbench install --source SOURCE --agent codex, workbench install --source SOURCE --agent claude, or workbench install --source SOURCE --local.",
+            exitCode: 2,
+        });
+    }
+    return dedupeTargets(targets);
+}
+export async function installSnapshotToTargets(options) {
+    const normalizedFiles = options.snapshot.files.map((file) => ({
+        ...file,
+        path: normalizeInstallSnapshotPath(file.path),
+    }));
+    const next = new Map(normalizedFiles.map((file) => [file.path, installFileContent(file)]));
+    // Pre-validate every target before mutating any destination so a conflict
+    // on a later target cannot leave an earlier target partially installed.
+    const plan = [];
+    for (const target of options.targets) {
+        const existing = await readExistingTree(target.destination).catch((error) => {
+            const code = error.code;
+            if (code === "ENOENT") {
+                return null;
+            }
+            if (code === "ENOTDIR") {
+                const conflictPath = error.path ?? target.destination;
+                throw new WorkbenchCodedError("install_failed", `Install target path is blocked by an existing file: ${conflictPath}`, {
+                    remediation: `Remove the conflicting file ${conflictPath} and rerun the install.`,
+                    subject: { destination: target.destination, conflictPath },
+                    exitCode: 1,
+                });
+            }
+            throw error;
+        });
+        const identical = existing ? fileMapsEqual(existing, next) : false;
+        if (identical) {
+            plan.push({ target, previous: "unchanged" });
+            continue;
+        }
+        if (existing && !options.overwrite) {
+            throw new WorkbenchCodedError("install_failed", `Install target already exists: ${target.destination}`, {
+                remediation: "Pass --yes to overwrite the existing target.",
+                subject: { destination: target.destination },
+                exitCode: 1,
+            });
+        }
+        plan.push({ target, previous: existing ? "overwritten" : "none" });
+    }
+    let filesCopied = 0;
+    const results = [];
+    for (const entry of plan) {
+        results.push({ ...entry.target, previous: entry.previous });
+        if (entry.previous === "unchanged") {
+            continue;
+        }
+        filesCopied += normalizedFiles.length;
+        if (!options.dryRun) {
+            await fs.rm(entry.target.destination, { recursive: true, force: true });
+            await writeSnapshotFiles(entry.target.destination, normalizedFiles);
+        }
+    }
+    return {
+        result: plan.some((entry) => entry.previous !== "unchanged") ? "installed" : "unchanged",
+        targets: results,
+        filesCopied,
+    };
+}
+function workbenchAgentHome(agent) {
+    if (agent === "codex") {
+        return process.env.CODEX_HOME?.trim() || path.join(os.homedir(), ".codex");
+    }
+    return process.env.CLAUDE_HOME?.trim() || path.join(os.homedir(), ".claude");
+}
+function dedupeTargets(targets) {
+    const byDestination = new Map();
+    for (const target of targets) {
+        byDestination.set(target.destination, target);
+    }
+    return [...byDestination.values()];
+}
+export function normalizeInstallSnapshotPath(filePath) {
+    const normalized = filePath.replace(/\\/gu, "/");
+    if (!normalized || normalized.includes("\0") || normalized.startsWith("/")) {
+        throw new WorkbenchCodedError("install_failed", `Invalid source file path: ${filePath}`, {
+            subject: { path: filePath },
+            exitCode: 1,
+        });
+    }
+    const parts = normalized.split("/");
+    if (parts.some((part) => part === "" || part === "." || part === "..")) {
+        throw new WorkbenchCodedError("install_failed", `Invalid source file path: ${filePath}`, {
+            subject: { path: filePath },
+            exitCode: 1,
+        });
+    }
+    return normalized;
+}
+function installFileContent(file) {
+    if (file.encoding === "base64") {
+        return Buffer.from(file.content, "base64");
+    }
+    return file.content;
+}
+async function writeSnapshotFiles(root, files) {
+    for (const file of files) {
+        const filePath = path.join(root, file.path);
+        await fs.mkdir(path.dirname(filePath), { recursive: true });
+        await fs.writeFile(filePath, installFileContent(file));
+        if (file.executable) {
+            await fs.chmod(filePath, 0o755);
+        }
+    }
+}
+async function readExistingTree(root) {
+    const result = new Map();
+    await readExistingTreeInto(root, "", result);
+    return result;
+}
+async function readExistingTreeInto(root, relativeDir, result) {
+    const dir = path.join(root, relativeDir);
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const relativePath = relativeDir ? path.join(relativeDir, entry.name) : entry.name;
+        const fullPath = path.join(root, relativePath);
+        if (entry.isDirectory()) {
+            await readExistingTreeInto(root, relativePath, result);
+        }
+        else if (entry.isFile()) {
+            result.set(relativePath.replace(/\\/gu, "/"), await fs.readFile(fullPath));
+        }
+    }
+}
+function fileMapsEqual(left, right) {
+    if (left.size !== right.size) {
+        return false;
+    }
+    for (const [key, rightValue] of right) {
+        const leftValue = left.get(key);
+        if (!leftValue) {
+            return false;
+        }
+        const rightBuffer = Buffer.isBuffer(rightValue) ? rightValue : Buffer.from(rightValue);
+        if (!leftValue.equals(rightBuffer)) {
+            return false;
+        }
+    }
+    return true;
+}
+export function installTargetsToJson(targets) {
+    return targets.map((target) => ({
+        agent: target.agent,
+        mode: target.mode,
+        destination: target.destination,
+    }));
+}

package/dist/open-server.d.ts

@@ -0,0 +1,12 @@
+export interface StartWorkbenchOpenServerOptions {
+    dir?: string;
+    authToken?: string;
+    host?: string;
+    port?: number;
+}
+export interface StartedWorkbenchOpenServer {
+    url: string;
+    close(): Promise<void>;
+}
+export declare function startWorkbenchOpenServer(options?: StartWorkbenchOpenServerOptions): Promise<StartedWorkbenchOpenServer>;
+//# sourceMappingURL=open-server.d.ts.map

package/dist/open-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"open-server.d.ts","sourceRoot":"","sources":["../src/open-server.ts"],"names":[],"mappings":"AAoBA,MAAM,WAAW,+BAA+B;IAC9C,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,0BAA0B;IACzC,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED,wBAAsB,wBAAwB,CAC5C,OAAO,GAAE,+BAAoC,GAC5C,OAAO,CAAC,0BAA0B,CAAC,CA+BrC"}

package/dist/open-server.js

@@ -0,0 +1,248 @@
+import { createServer } from "node:http";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { createWorkbenchReadOnlyInspectionSnapshot, workbenchJobEvidenceForSnapshot, workbenchInspectionFileContent, workbenchInspectionFileManifest, WorkbenchUserError, } from "@workbench-ai/workbench-core";
+export async function startWorkbenchOpenServer(options = {}) {
+    const host = options.host ?? "127.0.0.1";
+    const port = options.port ?? 0;
+    const assetRoot = await resolveDevOpenAssetRoot();
+    const server = createServer((request, response) => {
+        void handleRequest({ request, response, assetRoot, dir: options.dir, authToken: options.authToken });
+    });
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(port, host, () => {
+            server.off("error", reject);
+            resolve();
+        });
+    });
+    const address = server.address();
+    if (!address || typeof address === "string") {
+        throw new WorkbenchUserError("Could not determine Workbench open server address.");
+    }
+    const display = displayHost(host);
+    return {
+        url: `http://${display}:${address.port}/`,
+        close: () => new Promise((resolve, reject) => {
+            server.close((error) => {
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    resolve();
+                }
+            });
+        }),
+    };
+}
+async function resolveDevOpenAssetRoot() {
+    const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+        path.join(moduleDir, "dev-open"),
+        path.join(moduleDir, "..", "dist", "dev-open"),
+    ];
+    for (const candidate of candidates) {
+        try {
+            await fs.access(path.join(candidate, "client.js"));
+            return candidate;
+        }
+        catch {
+            // Try the next source/build layout.
+        }
+    }
+    return candidates[0];
+}
+async function handleRequest({ request, response, assetRoot, dir, authToken, }) {
+    try {
+        const url = new URL(request.url ?? "/", "http://workbench.local");
+        if (url.pathname === "/api/snapshot") {
+            const snapshot = await createWorkbenchReadOnlyInspectionSnapshot({ dir, authToken });
+            sendText(response, 200, `${JSON.stringify(inspectionSnapshotManifest(snapshot), null, 2)}\n`, "application/json; charset=utf-8");
+            return;
+        }
+        const jobEvidenceRoute = parseJobEvidenceApiPath(url.pathname);
+        if (jobEvidenceRoute) {
+            const runId = url.searchParams.get("run")?.trim();
+            if (!runId) {
+                sendText(response, 400, `${JSON.stringify({ message: "run is required" })}\n`, "application/json; charset=utf-8");
+                return;
+            }
+            const snapshot = await createWorkbenchReadOnlyInspectionSnapshot({ dir, authToken });
+            const detail = workbenchJobEvidenceForSnapshot(snapshot, {
+                runId,
+                jobId: jobEvidenceRoute.jobId,
+            });
+            if (!detail) {
+                sendText(response, 404, `${JSON.stringify({ message: "Job evidence not found" })}\n`, "application/json; charset=utf-8");
+                return;
+            }
+            sendText(response, 200, `${JSON.stringify(detail, null, 2)}\n`, "application/json; charset=utf-8");
+            return;
+        }
+        const fileRoute = parseInspectionFileApiPath(url.pathname);
+        if (fileRoute) {
+            const snapshot = await createWorkbenchReadOnlyInspectionSnapshot({ dir, authToken });
+            const content = inspectionFileContentForSnapshot(snapshot, fileRoute);
+            if (!content) {
+                sendText(response, 404, `${JSON.stringify({ message: "File not found" })}\n`, "application/json; charset=utf-8");
+                return;
+            }
+            sendText(response, 200, `${JSON.stringify(content, null, 2)}\n`, "application/json; charset=utf-8");
+            return;
+        }
+        if (url.pathname.startsWith("/api/")) {
+            sendText(response, 404, `${JSON.stringify({ message: "Not found" })}\n`, "application/json; charset=utf-8");
+            return;
+        }
+        if (url.pathname === "/" || url.pathname === "/index.html") {
+            sendText(response, 200, html(), "text/html; charset=utf-8");
+            return;
+        }
+        if (url.pathname === "/client.js" || url.pathname === "/client.css" || url.pathname.startsWith("/fonts/")) {
+            await sendAsset(response, assetRoot, url.pathname.slice(1));
+            return;
+        }
+        sendText(response, 200, html(), "text/html; charset=utf-8");
+    }
+    catch (error) {
+        sendText(response, 500, `${error instanceof Error ? error.message : String(error)}\n`, "text/plain; charset=utf-8");
+    }
+}
+function inspectionSnapshotManifest(snapshot) {
+    return {
+        ...snapshot,
+        versions: snapshot.versions.map((version) => ({
+            ...version,
+            files: inspectionFileManifests(version.files),
+        })),
+        skillBundles: snapshot.skillBundles.map((bundle) => ({
+            ...bundle,
+            files: inspectionFileManifests(bundle.files),
+        })),
+        evals: snapshot.evals.map((evalSnapshot) => ({
+            ...evalSnapshot,
+            files: inspectionFileManifests(evalSnapshot.files),
+        })),
+        ...(snapshot.comparison ? {
+            comparison: {
+                ...snapshot.comparison,
+                versions: snapshot.comparison.versions.map((version) => ({
+                    ...version,
+                    files: inspectionFileManifests(version.files),
+                })),
+                skills: snapshot.comparison.skills.map((bundle) => ({
+                    ...bundle,
+                    files: inspectionFileManifests(bundle.files),
+                })),
+            },
+        } : {}),
+        traces: snapshot.traces.map((trace) => ({
+            ...trace,
+            files: inspectionFileManifests(trace.files),
+        })),
+        artifacts: snapshot.artifacts.map((artifact) => ({
+            ...artifact,
+            files: inspectionFileManifests(artifact.files),
+        })),
+    };
+}
+function inspectionFileManifests(files) {
+    return files.map(workbenchInspectionFileManifest);
+}
+function parseJobEvidenceApiPath(pathname) {
+    const segments = pathname.split("/").filter(Boolean).map((segment) => decodeURIComponent(segment));
+    const [api, jobs, jobId, evidence] = segments;
+    if (api !== "api" || jobs !== "jobs" || evidence !== "evidence" || !jobId || segments.length !== 4) {
+        return null;
+    }
+    return { jobId };
+}
+function parseInspectionFileApiPath(pathname) {
+    const segments = pathname.split("/").filter(Boolean).map((segment) => decodeURIComponent(segment));
+    const [api, ownerKind, ownerId, files, ...filePath] = segments;
+    if (api !== "api" || files !== "files" || !ownerId || filePath.length === 0) {
+        return null;
+    }
+    if (ownerKind !== "versions" && ownerKind !== "traces" && ownerKind !== "artifacts") {
+        return null;
+    }
+    return {
+        ownerKind: ownerKind.slice(0, -1),
+        ownerId,
+        path: filePath.join("/"),
+    };
+}
+function inspectionFileContentForSnapshot(snapshot, route) {
+    const owner = findInspectionFileOwner(snapshot, route.ownerKind, route.ownerId);
+    const file = owner?.files.find((entry) => entry.path === route.path);
+    return file ? workbenchInspectionFileContent(file) : null;
+}
+function findInspectionFileOwner(snapshot, ownerKind, ownerId) {
+    if (ownerKind === "version") {
+        return snapshot.versions.find((entry) => entry.id === ownerId);
+    }
+    if (ownerKind === "trace") {
+        return snapshot.traces.find((entry) => entry.id === ownerId);
+    }
+    return snapshot.artifacts.find((entry) => entry.id === ownerId);
+}
+async function sendAsset(response, assetRoot, relativePath) {
+    const normalized = path.normalize(relativePath);
+    if (normalized.startsWith("..") || path.isAbsolute(normalized)) {
+        sendText(response, 404, "Not found\n", "text/plain; charset=utf-8");
+        return;
+    }
+    const content = await fs.readFile(path.join(assetRoot, normalized)).catch(() => null);
+    if (!content) {
+        sendText(response, 404, "Not found\n", "text/plain; charset=utf-8");
+        return;
+    }
+    response.statusCode = 200;
+    response.setHeader("content-type", contentType(normalized));
+    response.end(content);
+}
+function sendText(response, status, content, type) {
+    response.statusCode = status;
+    response.setHeader("content-type", type);
+    response.end(content);
+}
+function html() {
+    return [
+        "<!doctype html>",
+        "<html lang=\"en\">",
+        "<head>",
+        "<meta charset=\"utf-8\">",
+        "<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">",
+        "<title>Workbench</title>",
+        "<link rel=\"stylesheet\" href=\"/client.css\">",
+        "</head>",
+        "<body>",
+        "<div id=\"root\"></div>",
+        "<script type=\"module\" src=\"/client.js\"></script>",
+        "</body>",
+        "</html>",
+        "",
+    ].join("\n");
+}
+function contentType(filePath) {
+    if (filePath.endsWith(".js")) {
+        return "text/javascript; charset=utf-8";
+    }
+    if (filePath.endsWith(".css")) {
+        return "text/css; charset=utf-8";
+    }
+    if (filePath.endsWith(".woff2")) {
+        return "font/woff2";
+    }
+    if (filePath.endsWith(".woff")) {
+        return "font/woff";
+    }
+    return "application/octet-stream";
+}
+function displayHost(host) {
+    if (host === "0.0.0.0" || host === "::") {
+        return "127.0.0.1";
+    }
+    return host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;
+}

package/dist/output.d.ts

@@ -0,0 +1,22 @@
+import { type Json } from "@workbench-ai/workbench-core";
+import type { CliIo } from "./index.js";
+export interface ParsedCliFlags {
+    flags: Record<string, string | boolean | string[]>;
+}
+export interface WorkbenchCliSuccessEnvelope {
+    schema: string;
+    ok: true;
+    [key: string]: Json | undefined;
+}
+export interface WorkbenchCliErrorEnvelope {
+    schema: "workbench.cli.error.v1";
+    ok: false;
+    code: string;
+    message: string;
+    retryable: boolean;
+    remediation?: string;
+    subject?: Record<string, Json>;
+}
+export declare function emitResult(schema: string, body: Record<string, Json | undefined>, parsed: ParsedCliFlags, io: CliIo, text: () => string): number;
+export declare function emitError(error: unknown, parsed: ParsedCliFlags, io: CliIo): number;
+//# sourceMappingURL=output.d.ts.map

package/dist/output.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"output.d.ts","sourceRoot":"","sources":["../src/output.ts"],"names":[],"mappings":"AAAA,OAAO,EAAyB,KAAK,IAAI,EAAE,MAAM,8BAA8B,CAAC;AAEhF,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAExC,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,EAAE,CAAC,CAAC;CACpD;AAED,MAAM,WAAW,2BAA2B;IAC1C,MAAM,EAAE,MAAM,CAAC;IACf,EAAE,EAAE,IAAI,CAAC;IACT,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;CACjC;AAED,MAAM,WAAW,yBAAyB;IACxC,MAAM,EAAE,wBAAwB,CAAC;IACjC,EAAE,EAAE,KAAK,CAAC;IACV,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,OAAO,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;CAChC;AAED,wBAAgB,UAAU,CACxB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,GAAG,SAAS,CAAC,EACtC,MAAM,EAAE,cAAc,EACtB,EAAE,EAAE,KAAK,EACT,IAAI,EAAE,MAAM,MAAM,GACjB,MAAM,CAaR;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,EAAE,EAAE,KAAK,GAAG,MAAM,CAoBnF"}

package/dist/output.js

@@ -0,0 +1,38 @@
+import { codedErrorFromUnknown } from "@workbench-ai/workbench-core";
+export function emitResult(schema, body, parsed, io, text) {
+    if (parsed.flags.json === true) {
+        const envelope = { schema, ok: true };
+        for (const [key, value] of Object.entries(body)) {
+            if (value !== undefined) {
+                envelope[key] = value;
+            }
+        }
+        io.stdout.write(`${JSON.stringify(envelope, null, 2)}\n`);
+    }
+    else {
+        io.stdout.write(`${text()}\n`);
+    }
+    return 0;
+}
+export function emitError(error, parsed, io) {
+    const coded = codedErrorFromUnknown(error);
+    const envelope = {
+        schema: "workbench.cli.error.v1",
+        ok: false,
+        code: coded.code,
+        message: coded.message,
+        retryable: coded.retryable,
+        ...(coded.remediation ? { remediation: coded.remediation } : {}),
+        ...(coded.subject ? { subject: coded.subject } : {}),
+    };
+    if (parsed.flags.json === true) {
+        io.stdout.write(`${JSON.stringify(envelope, null, 2)}\n`);
+    }
+    else {
+        io.stderr.write(`error[${envelope.code}]: ${envelope.message}\n`);
+        if (envelope.remediation) {
+            io.stderr.write(`next: ${envelope.remediation}\n`);
+        }
+    }
+    return coded.exitCode;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workbench-ai/workbench",
-  "version": "0.0.67",
+  "version": "0.0.69",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/workbench-ai/workbench.git",
@@ -21,9 +21,9 @@
   ],
   "dependencies": {
     "yaml": "^2.8.2",
-    "@workbench-ai/workbench-built-in-adapters": "0.0.67",
-    "@workbench-ai/workbench-core": "0.0.67",
-    "@workbench-ai/workbench-protocol": "0.0.67"
+    "@workbench-ai/workbench-built-in-adapters": "0.0.69",
+    "@workbench-ai/workbench-protocol": "0.0.69",
+    "@workbench-ai/workbench-core": "0.0.69"
   },
   "devDependencies": {
     "@tailwindcss/postcss": "^4.2.2",
@@ -40,6 +40,6 @@
     "build": "rm -rf dist && tsc -p tsconfig.json && chmod 755 dist/workbench.js && node ./scripts/build-dev-open-assets.mjs",
     "lint": "tsc -p tsconfig.lint.json",
     "test": "vitest run --config vitest.config.ts",
-    "test:e2e": "WORKBENCH_PACKAGING_TEST=1 vitest run --config vitest.config.ts tests/packaging.test.ts"
+    "test:e2e": "vitest run --config vitest.config.ts tests/cli.test.ts"
   }
 }

package/dist/adapter-command-env.d.ts

@@ -1,8 +0,0 @@
-export interface AdapterCommandEnvOptions {
-    workspaceRoot?: string;
-    adapterRoot?: string;
-    env?: NodeJS.ProcessEnv;
-    extraEnv?: Record<string, string | undefined>;
-}
-export declare function createAdapterCommandEnv(options?: AdapterCommandEnvOptions): NodeJS.ProcessEnv;
-//# sourceMappingURL=adapter-command-env.d.ts.map

package/dist/adapter-command-env.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"adapter-command-env.d.ts","sourceRoot":"","sources":["../src/adapter-command-env.ts"],"names":[],"mappings":"AAYA,MAAM,WAAW,wBAAwB;IACvC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;CAC/C;AAED,wBAAgB,uBAAuB,CAAC,OAAO,GAAE,wBAA6B,GAAG,MAAM,CAAC,UAAU,CAmBjG"}