@workbench-ai/workbench 0.0.75 → 0.0.77

package/dist/index.js

@@ -914,10 +914,7 @@ async function handleInstall(parsed, io) {
         next: next,
         ...(parsed.flags["dry-run"] === true ? { dryRun: true } : {}),
     }, parsed, io, () => [
-        parsed.flags["dry-run"] === true
-            ? `Would install ${result.directoryName} to ${result.destination}: filesCopied=${result.filesCopied}`
-            : `Installed ${result.directoryName}: ${result.result}`,
-        `  machine\t${result.previous}\t${result.destination}`,
+        formatInstallOutcome(result, parsed.flags["dry-run"] === true),
         formatFanOut(fanout),
         ...(next ? [`next: ${next}`] : []),
     ].join("\n"));
@@ -1013,6 +1010,21 @@ function installNextCommand(fanout) {
         ? fanout.command
         : null;
 }
+function formatInstallOutcome(result, dryRun) {
+    if (dryRun) {
+        return `Would install ${result.directoryName} to ${result.destination} (${formatFileCount(result.filesCopied)}).`;
+    }
+    if (result.result === "unchanged") {
+        return `Already installed ${result.directoryName} at ${result.destination} (unchanged).`;
+    }
+    const detail = result.previous === "overwritten"
+        ? `overwrote existing copy, ${formatFileCount(result.filesCopied)}`
+        : formatFileCount(result.filesCopied);
+    return `Installed ${result.directoryName} to ${result.destination} (${detail}).`;
+}
+function formatFileCount(count) {
+    return `${count} ${count === 1 ? "file" : "files"}`;
+}
 function fanOutToJson(fanout) {
     return {
         status: fanout.status,
@@ -1035,8 +1047,8 @@ function formatFanOut(fanout) {
     if (fanout.linkedAgents.length === 0) {
         return "fanout: completed";
     }
-    const suffix = fanout.additionalAgents ? ` and ${fanout.additionalAgents} more` : "";
-    return `fanned out to: ${fanout.linkedAgents.join(", ")}${suffix}`;
+    const count = fanout.linkedAgents.length + (fanout.additionalAgents ?? 0);
+    return `fanout: linked ${count} ${count === 1 ? "agent" : "agents"}`;
 }
 async function latestInstallVersion(record) {
     const handle = normalizedOwnerSkillHandle(record.handle);
@@ -1065,79 +1077,139 @@ function withTimeout(promise, timeoutMs) {
 async function startCloudExecution(command, parsed, io) {
     const root = dirFlag(parsed) ?? process.cwd();
     const showProgress = parsed.flags.json !== true;
-    const remote = await ensureCloudRemoteForExecution(root, parsed);
-    const source = parseWorkbenchInstallSource(remote.url);
-    if (!source) {
-        throw new WorkbenchCodedError("remote_invalid_url", `Workbench remote is not a Cloud skill URL: ${remote.url}`, {
-            remediation: "Run workbench publish to recreate the Workbench Cloud link.",
-            subject: { remote: remote.name, url: remote.url },
-            exitCode: 2,
-        });
-    }
-    const token = await workbenchCloudToken({ baseUrl: source.baseUrl });
-    if (!token) {
-        throw new WorkbenchCodedError("auth_required", `workbench ${command} --cloud requires Workbench Cloud auth.`, {
-            remediation: `Run workbench login --base-url ${source.baseUrl}.`,
-            exitCode: 1,
+    const interrupt = createCloudInterruptController(command, io, showProgress);
+    try {
+        writeCloudProgress(io, `workbench cloud: preparing hosted ${command}.`, showProgress);
+        const remote = await cloudPreScheduleStep(command, interrupt, ensureCloudRemoteForExecution(root, parsed));
+        const source = parseWorkbenchInstallSource(remote.url);
+        if (!source) {
+            throw new WorkbenchCodedError("remote_invalid_url", `Workbench remote is not a Cloud skill URL: ${remote.url}`, {
+                remediation: "Run workbench publish to recreate the Workbench Cloud link.",
+                subject: { remote: remote.name, url: remote.url },
+                exitCode: 2,
+            });
+        }
+        const token = await workbenchCloudToken({ baseUrl: source.baseUrl });
+        if (!token) {
+            throw new WorkbenchCodedError("auth_required", `workbench ${command} --cloud requires Workbench Cloud auth.`, {
+                remediation: `Run workbench login --base-url ${source.baseUrl}.`,
+                exitCode: 1,
+            });
+        }
+        const core = { dir: root, authToken: token };
+        writeCloudProgress(io, "workbench cloud: preparing current source.", showProgress);
+        const request = command === "eval"
+            ? await cloudPreScheduleStep(command, interrupt, prepareWorkbenchCloudEvalRequest({
+                ...core,
+                skill: stringFlag(parsed, "skills"),
+                agent: stringFlag(parsed, "agents"),
+                samples: intFlag(parsed, "samples"),
+            }))
+            : await cloudPreScheduleStep(command, interrupt, prepareWorkbenchCloudImproveRequest({
+                ...core,
+                skill: stringFlag(parsed, "skills"),
+                agent: stringFlag(parsed, "agents"),
+                samples: intFlag(parsed, "samples"),
+                budget: intFlag(parsed, "budget"),
+            }));
+        writeCloudProgress(io, "workbench cloud: syncing source to cloud.", showProgress);
+        const syncBefore = await cloudPreScheduleStep(command, interrupt, syncWorkbenchRemote({ ...core, remote: remote.name }));
+        writeCloudProgress(io, `workbench cloud: scheduling hosted ${command}.`, showProgress);
+        const skillId = await cloudPreScheduleStep(command, interrupt, resolveCloudSkillId(source));
+        const response = await cloudPreScheduleStep(command, interrupt, apiRequest(`/api/workbench/skills/${encodeURIComponent(skillId)}${command === "improve" ? "/improve" : "/runs"}`, { method: "POST", body: cloudExecutionRequestBody(command, request) }, source.baseUrl));
+        const runs = response.runs ?? [];
+        if (runs.length === 0) {
+            throw new WorkbenchCodedError("cloud_run_missing", `Workbench Cloud did not return a run for ${command}.`, {
+                retryable: true,
+                remediation: "Run workbench log --runs.",
+                subject: { remote: remote.name, skillId },
+                exitCode: 1,
+            });
+        }
+        const initialRunIds = runs.map((run) => run.id);
+        interrupt.setRunIds(initialRunIds);
+        const syncAfterSchedule = await syncWorkbenchRemote({ ...core, remote: remote.name });
+        writeCloudProgress(io, `workbench cloud: scheduled hosted ${command} on ${remote.url} (${formatCloudRunStatuses(runs)}).`, showProgress);
+        writeCloudProgress(io, `workbench cloud: waiting for terminal status; press Ctrl-C to detach and resume with workbench show ${displayRef(initialRunIds[0] ?? "run")}.`, showProgress);
+        const completed = await waitForCloudRuns({
+            command,
+            core,
+            interrupt,
+            io,
+            progress: showProgress,
+            remote,
+            runs,
+            source,
+            skillId,
+            initialSync: syncAfterSchedule,
         });
+        return {
+            core,
+            remote,
+            skillId,
+            initialRunIds,
+            runs: completed.runs,
+            ...(completed.detached ? { detached: true } : {}),
+            startVersionId: request.versionId,
+            source,
+            sync: {
+                before: { pushed: syncBefore.pushed, pulled: syncBefore.pulled, upToDate: syncBefore.upToDate },
+                after: { pushed: completed.sync.pushed, pulled: completed.sync.pulled, upToDate: completed.sync.upToDate },
+            },
+        };
     }
-    const core = { dir: root, authToken: token };
-    const request = command === "eval"
-        ? await prepareWorkbenchCloudEvalRequest({
-            ...core,
-            skill: stringFlag(parsed, "skills"),
-            agent: stringFlag(parsed, "agents"),
-            samples: intFlag(parsed, "samples"),
-        })
-        : await prepareWorkbenchCloudImproveRequest({
-            ...core,
-            skill: stringFlag(parsed, "skills"),
-            agent: stringFlag(parsed, "agents"),
-            samples: intFlag(parsed, "samples"),
-            budget: intFlag(parsed, "budget"),
-        });
-    const syncBefore = await syncWorkbenchRemote({ ...core, remote: remote.name });
-    const skillId = await resolveCloudSkillId(source);
-    const response = await apiRequest(`/api/workbench/skills/${encodeURIComponent(skillId)}${command === "improve" ? "/improve" : "/runs"}`, { method: "POST", body: cloudExecutionRequestBody(command, request) }, source.baseUrl);
-    const runs = response.runs ?? [];
-    if (runs.length === 0) {
-        throw new WorkbenchCodedError("cloud_run_missing", `Workbench Cloud did not return a run for ${command}.`, {
-            retryable: true,
-            remediation: "Run workbench log --runs.",
-            subject: { remote: remote.name, skillId },
-            exitCode: 1,
-        });
+    finally {
+        interrupt.dispose();
     }
-    const syncAfterSchedule = await syncWorkbenchRemote({ ...core, remote: remote.name });
-    const initialRunIds = runs.map((run) => run.id);
-    writeCloudProgress(io, `workbench cloud: scheduled hosted ${command} on ${remote.url} (${formatCloudRunStatuses(runs)}).`, showProgress);
-    writeCloudProgress(io, `workbench cloud: waiting for terminal status; press Ctrl-C to detach and resume with workbench show ${displayRef(initialRunIds[0] ?? "run")}.`, showProgress);
-    const completed = await waitForCloudRuns({
-        command,
-        core,
-        io,
-        progress: showProgress,
-        remote,
-        runs,
-        source,
-        skillId,
-        initialSync: syncAfterSchedule,
+}
+function createCloudInterruptController(command, io, progress) {
+    let interrupted = false;
+    let runIds = [];
+    let resolveSignal = () => undefined;
+    const signal = new Promise((resolve) => {
+        resolveSignal = resolve;
     });
+    const onSigint = () => {
+        interrupted = true;
+        if (runIds.length > 0) {
+            writeCloudProgress(io, `workbench cloud: detaching from hosted ${command} (${runIds.map(displayRef).join(", ")}).`, progress);
+        }
+        resolveSignal();
+    };
+    process.once("SIGINT", onSigint);
     return {
-        core,
-        remote,
-        skillId,
-        initialRunIds,
-        runs: completed.runs,
-        ...(completed.detached ? { detached: true } : {}),
-        startVersionId: request.versionId,
-        source,
-        sync: {
-            before: { pushed: syncBefore.pushed, pulled: syncBefore.pulled, upToDate: syncBefore.upToDate },
-            after: { pushed: completed.sync.pushed, pulled: completed.sync.pulled, upToDate: completed.sync.upToDate },
+        signal,
+        get interrupted() {
+            return interrupted;
+        },
+        get runIds() {
+            return runIds;
+        },
+        setRunIds(nextRunIds) {
+            runIds = [...nextRunIds];
+        },
+        dispose() {
+            process.off("SIGINT", onSigint);
         },
     };
 }
+async function cloudPreScheduleStep(command, interrupt, step) {
+    if (interrupt.interrupted) {
+        throw cloudCanceledBeforeRunIdError(command);
+    }
+    return await Promise.race([
+        step,
+        interrupt.signal.then(() => {
+            throw cloudCanceledBeforeRunIdError(command);
+        }),
+    ]);
+}
+function cloudCanceledBeforeRunIdError(command) {
+    return new WorkbenchCodedError("cloud_canceled", `Hosted ${command} was canceled before Workbench Cloud returned a run id.`, {
+        remediation: `Run workbench ${command} --cloud.`,
+        exitCode: 130,
+    });
+}
 async function waitForCloudRuns(input) {
     const runIds = input.runs
         .map((run) => run.id)
@@ -1154,61 +1226,50 @@ async function waitForCloudRuns(input) {
     const pollIntervalMs = positiveIntEnv("WORKBENCH_CLOUD_RUN_POLL_INTERVAL_MS") ?? CLOUD_RUN_POLL_INTERVAL_MS;
     const deadline = Date.now() + timeoutMs;
     let runs = [...input.runs];
-    let interrupted = false;
     const startedAtMs = Date.now();
     let lastProgressAtMs = startedAtMs;
-    const onSigint = () => {
-        interrupted = true;
-        writeCloudProgress(input.io, `workbench cloud: detaching from hosted ${input.command} (${runIds.map(displayRef).join(", ")}).`, input.progress);
-    };
-    process.once("SIGINT", onSigint);
     const seenStatuses = new Map();
-    try {
-        while (true) {
-            runs = await fetchCloudRuns(input.source.baseUrl, input.skillId, runIds, runs);
-            let wroteProgress = false;
-            const nowMs = Date.now();
-            for (const run of runs) {
-                const previous = seenStatuses.get(run.id);
-                if (previous !== run.status) {
-                    seenStatuses.set(run.id, run.status);
-                    writeCloudProgress(input.io, `workbench cloud: ${formatCloudRunState(run, startedAtMs, nowMs)}.`, input.progress);
-                    wroteProgress = input.progress || wroteProgress;
-                }
-            }
-            if (runs.length === runIds.length && runs.every(isTerminalRun)) {
-                sync = await syncWorkbenchRemote({ ...input.core, remote: input.remote.name });
-                return { runs, sync };
-            }
-            if (wroteProgress) {
-                lastProgressAtMs = nowMs;
-            }
-            else if (input.progress && nowMs - lastProgressAtMs >= 60_000) {
-                writeCloudProgress(input.io, `workbench cloud: still waiting (${formatCloudRunStates(runs, startedAtMs, nowMs)}).`);
-                lastProgressAtMs = nowMs;
-            }
-            if (interrupted) {
-                return { runs, sync, detached: true };
-            }
-            if (Date.now() >= deadline) {
-                throw new WorkbenchCodedError("cloud_run_pending", "Hosted Workbench run is still running.", {
-                    retryable: true,
-                    remediation: runIds[0] ? `Run workbench show ${runIds[0]}.` : "Run workbench log --runs.",
-                    subject: {
-                        runIds,
-                        statuses: Object.fromEntries(runs.map((run) => [run.id, run.status])),
-                    },
-                    exitCode: 1,
-                });
-            }
-            await sleep(pollIntervalMs);
-            if (interrupted) {
-                return { runs, sync, detached: true };
+    while (true) {
+        runs = await fetchCloudRuns(input.source.baseUrl, input.skillId, runIds, runs);
+        let wroteProgress = false;
+        const nowMs = Date.now();
+        for (const run of runs) {
+            const previous = seenStatuses.get(run.id);
+            if (previous !== run.status) {
+                seenStatuses.set(run.id, run.status);
+                writeCloudProgress(input.io, `workbench cloud: ${formatCloudRunState(run, startedAtMs, nowMs)}.`, input.progress);
+                wroteProgress = input.progress || wroteProgress;
             }
         }
-    }
-    finally {
-        process.off("SIGINT", onSigint);
+        if (runs.length === runIds.length && runs.every(isTerminalRun)) {
+            sync = await syncWorkbenchRemote({ ...input.core, remote: input.remote.name });
+            return { runs, sync };
+        }
+        if (wroteProgress) {
+            lastProgressAtMs = nowMs;
+        }
+        else if (input.progress && nowMs - lastProgressAtMs >= 60_000) {
+            writeCloudProgress(input.io, `workbench cloud: still waiting (${formatCloudRunStates(runs, startedAtMs, nowMs)}).`);
+            lastProgressAtMs = nowMs;
+        }
+        if (input.interrupt.interrupted) {
+            return { runs, sync, detached: true };
+        }
+        if (Date.now() >= deadline) {
+            throw new WorkbenchCodedError("cloud_run_pending", "Hosted Workbench run is still running.", {
+                retryable: true,
+                remediation: runIds[0] ? `Run workbench show ${runIds[0]}.` : "Run workbench log --runs.",
+                subject: {
+                    runIds,
+                    statuses: Object.fromEntries(runs.map((run) => [run.id, run.status])),
+                },
+                exitCode: 1,
+            });
+        }
+        await Promise.race([sleep(pollIntervalMs), input.interrupt.signal]);
+        if (input.interrupt.interrupted) {
+            return { runs, sync, detached: true };
+        }
     }
 }
 async function fetchCloudRuns(baseUrl, skillId, runIds, fallback) {
@@ -1352,7 +1413,7 @@ function cloudExecutionNextCommand(runs, successCommand) {
     if (!first) {
         return "workbench log --runs";
     }
-    if (first.status === "running" || first.status === "failed" || first.status === "canceled") {
+    if (first.status === "queued" || first.status === "running" || first.status === "failed" || first.status === "canceled") {
         return `workbench show ${displayRef(first.id)}`;
     }
     return successCommand;
@@ -2703,7 +2764,7 @@ async function statusWithCausalNext(status, auth, core, machine) {
     const lastRun = snapshot?.runs
         .slice()
         .sort((left, right) => right.createdAt.localeCompare(left.createdAt))[0];
-    if ((lastRun?.status === "running" || lastRun?.status === "failed" || lastRun?.status === "canceled") && lastRun.id) {
+    if ((lastRun?.status === "queued" || lastRun?.status === "running" || lastRun?.status === "failed" || lastRun?.status === "canceled") && lastRun.id) {
         return { ...status, next: `workbench show ${displayRef(lastRun.id)}` };
     }
     const failedRemote = status.remotes.find((remote) => remote.sync.status === "error");
@@ -2735,6 +2796,15 @@ async function statusWithCausalNext(status, auth, core, machine) {
     if (unpublishedCloudRemote) {
         return { ...status, next: "workbench publish" };
     }
+    const currentVersionId = status.project.currentVersionId ?? snapshot?.status.currentVersionId ?? snapshot?.refs.current;
+    const stalePublishedCloudRemote = status.remotes.find((remote) => remote.kind === "workbench-cloud" &&
+        remote.publication.status === "published" &&
+        remote.sync.status === "up_to_date" &&
+        currentVersionId !== undefined &&
+        remote.publication.versionId !== currentVersionId);
+    if (canPublish && stalePublishedCloudRemote) {
+        return { ...status, next: "workbench publish" };
+    }
     const publishedCloudRemote = status.remotes.find((remote) => remote.kind === "workbench-cloud" &&
         remote.publication.status === "published" &&
         Boolean(remote.publication.installUrl));

package/dist/workbench.js

@@ -1,4 +1,12 @@
 #!/usr/bin/env node
 import { runCli } from "./index.js";
+for (const stream of [process.stdout, process.stderr]) {
+    stream.on("error", (error) => {
+        if (error.code === "EPIPE") {
+            process.exit(0);
+        }
+        throw error;
+    });
+}
 const exitCode = await runCli(process.argv.slice(2));
 process.exitCode = exitCode;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workbench-ai/workbench",
-  "version": "0.0.75",
+  "version": "0.0.77",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/workbench-ai/workbench.git",
@@ -22,10 +22,10 @@
   "dependencies": {
     "skills": "1.5.11",
     "yaml": "^2.8.2",
-    "@workbench-ai/workbench-built-in-adapters": "0.0.75",
-    "@workbench-ai/workbench-contract": "0.0.75",
-    "@workbench-ai/workbench-core": "0.0.75",
-    "@workbench-ai/workbench-protocol": "0.0.75"
+    "@workbench-ai/workbench-built-in-adapters": "0.0.77",
+    "@workbench-ai/workbench-core": "0.0.77",
+    "@workbench-ai/workbench-contract": "0.0.77",
+    "@workbench-ai/workbench-protocol": "0.0.77"
   },
   "devDependencies": {
     "@tailwindcss/postcss": "^4.2.2",
@@ -36,7 +36,7 @@
     "react-dom": "^19.2.0",
     "typescript": "^5.9.2",
     "vitest": "^3.2.4",
-    "@workbench-ai/workbench-ui": "0.0.75"
+    "@workbench-ai/workbench-ui": "0.0.77"
   },
   "scripts": {
     "build": "rm -rf dist && tsc -p tsconfig.json && chmod 755 dist/workbench.js && node ./scripts/build-dev-open-assets.mjs",