@metrio-ai/cli 1.1.0 → 1.3.0

package/README.md

@@ -48,3 +48,49 @@ For CI set `METRIO_TOKEN` (and `METRIO_CONSOLE_URL` if not `https://app.metrio.a
 Exit codes: `0` ok, `1` failure, `2` usage or validation error, `3` not logged in / not allowed. Codes 2 and 3 apply to the account and resource-management commands (`login`, `logout`, `whoami`, `tools`, `call`, and every `metrio <group> ...` command); the run commands (`chat`, `workflow run` / `run-batch`, `prompt run-batch` / `create-version`) keep their original behavior (errors exit 1). A workflow DAG the console rejects exits 2; a partially failed `version create-batch` exits 1.
 
 Migrating from `@metrio-ai/client`'s bundled CLI: if the old CLI was installed globally, run `npm rm -g @metrio-ai/client` before `npm i -g @metrio-ai/cli` (both install a `metrio` bin). Every command and flag is unchanged. Bare `metrio --messages …` still works but is deprecated in favor of `metrio chat --messages …`.
+
+## Sync a project as files
+
+```bash
+mkdir my-project && cd my-project
+metrio pull --project my-project      # metrio.yaml, prompts/, skills/, workflows/, .metrio/state.json
+$EDITOR prompts/pick-products/system.md
+metrio diff                           # modified / remote-changed / conflict / new … with unified diffs
+metrio push -m "tighter wording"      # new prompt version (not live)
+metrio push --activate                # …or make it live right away
+metrio version list pick-products     # prompt directories work wherever a prompt id is expected
+```
+
+`push` creates new versions and never overwrites changes made in the console since your last `pull` (use `--force` deliberately: local wins, bindings and MCP lists are replaced, and resources changed in the console may be pruned). Workflow pushes create draft versions (`--publish`, `--activate`). Deleting files deletes nothing remotely unless you pass `--prune --yes`. Commit `.metrio/state.json` with the files. Run `metrio pull --help` for every option.
+
+- A second plain `metrio push` does not create duplicates ("already pushed as version N"); `metrio push --activate` (prompts) or `--publish` / `--activate` (workflows) makes the pending pushed version live.
+- `pull` adopts untracked local files that are identical to the console. `pull` and `push` report per-resource failures, exit 1, and still save state for the resources that succeeded.
+- Renaming a prompt or skill directory is detected by content (status `renamed`); pull/push move the state entry. Workflow directories are named by workflow id and cannot be renamed locally; push refuses it.
+- Known limitation: renaming AND editing a prompt/skill directory in one go looks like a delete plus a new resource (push would create a second one; `--prune --yes` would delete the old one). Rename first, sync, then edit.
+
+## Verify prompts and workflows
+
+Put a `cases.yaml` next to a synced resource (`prompts/<name>/cases.yaml`, `workflows/<id>/cases.yaml`) and run it with the project API key (`METRIOAI_API_KEY` in `.env`, or `--api-key`; it must belong to the workspace's project):
+
+```yaml
+defaults:
+  variables: { region: TW }
+cases:
+  - name: regular order
+    message: "我要訂 3 箱蘋果"            # or messages: [...] or messages_file: path
+    expect:
+      contains: ["蘋果"]                  # not_contains, regex, equals read the reply text
+      json:
+        "$.state.order.qty": { equals: 3 }   # $.content $.structContent $.state $.tags $.json
+      path_includes: [classify, create_order]   # workflows only (also terminal_node,
+      max_latency_ms: 8000                      #   response_type, max_llm_calls)
+```
+
+```bash
+metrio push -m "new wording"          # creates a version that is not live yet
+metrio verify --version pushed        # run every cases.yaml against what you just pushed
+metrio push --activate                # make it live once the cases pass
+metrio verify -p 12 --cases cases.yaml --junit report.xml   # outside a workspace
+```
+
+Every `cases.yaml` is validated before the first request (a typo in an assertion is exit 2). A failed case prints each failing assertion with expected vs actual and exits 1. `--json` prints machine-readable results, `--junit <file>` writes JUnit XML, `--fail-fast` stops starting new cases after the first failure. Run `metrio verify --help` for the full format.

package/dist/commands/sync.js

@@ -0,0 +1,489 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SYNC_HELP = void 0;
+exports.parseSyncArgs = parseSyncArgs;
+exports.openWorkspace = openWorkspace;
+exports.filterEntries = filterEntries;
+exports.loadEntries = loadEntries;
+exports.safe = safe;
+exports.runDiffCommand = runDiffCommand;
+exports.runPullCommand = runPullCommand;
+exports.runPushCommand = runPushCommand;
+const path = __importStar(require("path"));
+const diff_1 = require("diff");
+const client_1 = require("../console/client");
+const errors_1 = require("../errors");
+const push_1 = require("../sync/push");
+const remote_1 = require("../sync/remote");
+const status_1 = require("../sync/status");
+const workspace_1 = require("../sync/workspace");
+const ONLY = { prompts: 'prompt', skills: 'skill', workflows: 'workflow' };
+function parseSyncArgs(argv) {
+    const o = {
+        paths: [], kinds: ['prompt', 'skill', 'workflow'], force: false, activate: false, publish: false,
+        prune: false, yes: false, dryRun: false, json: false,
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        const value = () => {
+            const v = argv[i + 1];
+            if (v === undefined)
+                throw new errors_1.CliError(`${arg} needs a value`);
+            i += 1;
+            return v;
+        };
+        if (arg === '--only') {
+            const kind = ONLY[value()];
+            if (!kind)
+                throw new errors_1.CliError('--only must be prompts, skills or workflows');
+            o.kinds = [kind];
+        }
+        else if (arg === '-m' || arg === '--message')
+            o.message = value();
+        else if (arg === '--project')
+            o.project = value();
+        else if (arg === '--force')
+            o.force = true;
+        else if (arg === '--activate')
+            o.activate = true;
+        else if (arg === '--publish')
+            o.publish = true;
+        else if (arg === '--prune')
+            o.prune = true;
+        else if (arg === '--yes')
+            o.yes = true;
+        else if (arg === '--dry-run')
+            o.dryRun = true;
+        else if (arg === '--json')
+            o.json = true;
+        else if (arg.startsWith('-'))
+            throw new errors_1.CliError(`Unknown option ${arg}`);
+        else
+            o.paths.push(arg);
+    }
+    return o;
+}
+async function openWorkspace() {
+    const root = (0, workspace_1.findRoot)();
+    if (!root)
+        throw new errors_1.CliError('Not in a metrio workspace (no metrio.yaml). Run "metrio pull --project <slug>" first.');
+    return { root, project: (0, workspace_1.readProject)(root), client: new client_1.ConsoleClient(await (0, client_1.resolveConsoleAuth)()) };
+}
+/** Entries whose key equals or sits under one of the given paths (relative to the workspace root). */
+function filterEntries(entries, root, paths) {
+    if (!paths.length)
+        return entries;
+    const wanted = paths.map((p) => {
+        const rel = path.relative(root, path.resolve(p));
+        if (rel === '..' || rel.startsWith(`..${path.sep}`) || path.isAbsolute(rel)) {
+            throw new errors_1.CliError(`${p} is outside the metrio workspace`);
+        }
+        return rel.split(path.sep).join('/').replace(/\/+$/, '');
+    });
+    const matches = (e, w) => w === '' || e.key === w || e.key.startsWith(`${w}/`) || w.startsWith(`${e.key}/`);
+    wanted.forEach((w, i) => {
+        if (!entries.some((e) => matches(e, w)))
+            throw new errors_1.CliError(`${paths[i]} matches nothing in this workspace`);
+    });
+    return entries.filter((e) => wanted.some((w) => matches(e, w)));
+}
+async function loadEntries(ctx, opts) {
+    const state = (0, workspace_1.readState)(ctx.root, ctx.project);
+    const remote = await (0, remote_1.fetchRemote)(ctx.client, ctx.project, opts.kinds);
+    return filterEntries((0, status_1.computeEntries)(ctx.root, state, remote, opts.kinds), ctx.root, opts.paths);
+}
+/** Console-sourced text must not carry terminal control sequences. */
+function safe(text) {
+    return text.replace(/[\x00-\x08\x0b-\x1f\x7f-\x9f]/g, (c) => `\\x${c.charCodeAt(0).toString(16).padStart(2, '0')}`);
+}
+exports.SYNC_HELP = `metrio pull | diff | push - sync prompts, skills and workflows with local files
+
+  metrio pull --project <slug>   First pull: creates metrio.yaml here and writes:
+                                   prompts/<name>/prompt.yaml + system.md
+                                   skills/<name>.md
+                                   workflows/<id>/workflow.yaml + definition.json
+  metrio pull [paths…]           Update files from the console (keeps local edits unless --force)
+  metrio diff [paths…]           Show what differs: modified, remote-changed, conflict, new, …
+  metrio push [paths…]           Send local edits: new prompt version (not live unless --activate),
+                                 skill update, workflow version (draft; --publish / --activate)
+
+Options:
+  --only prompts|skills|workflows   Limit to one kind
+  --force                           pull: overwrite local edits; push: push over console changes
+                                    (local wins — bindings and MCP list are replaced), allow
+                                    pruning resources changed in the console, and allow a prompt
+                                    version that drops the live messages/agent_description
+  -m, --message <text>              push: description of the new versions
+  --activate                        push: make new prompt versions head / workflow versions live
+  --publish                         push: publish new workflow versions without activating
+  --prune --yes                     push: delete console resources whose local files were removed
+  --dry-run                         Print the plan without changing anything
+  --json                            diff: machine-readable statuses
+
+State lives in .metrio/state.json (commit it with the files).
+`;
+const wantsHelp = (argv) => argv.includes('-h') || argv.includes('--help');
+function patch(e) {
+    const local = e.local ?? {};
+    const remote = e.remote?.files ?? {};
+    return [...new Set([...Object.keys(local), ...Object.keys(remote)])]
+        .sort()
+        .filter((f) => local[f] !== remote[f])
+        .map((f) => (0, diff_1.createTwoFilesPatch)(`remote/${e.key}/${f}`, `local/${e.key}/${f}`, remote[f] ?? '', local[f] ?? ''))
+        .join('');
+}
+async function runDiffCommand(argv) {
+    if (wantsHelp(argv)) {
+        process.stdout.write(exports.SYNC_HELP);
+        return;
+    }
+    const opts = parseSyncArgs(argv);
+    const ctx = await openWorkspace();
+    const entries = await loadEntries(ctx, opts);
+    if (opts.json) {
+        const rows = entries.map((e) => ({ key: e.key, kind: e.kind, status: e.status, ...(e.from ? { from: e.from } : {}) }));
+        process.stdout.write(`${JSON.stringify(rows, null, 2)}\n`);
+        return;
+    }
+    let unchanged = 0;
+    for (const e of entries) {
+        if (e.status === 'unchanged') {
+            unchanged += 1;
+            continue;
+        }
+        process.stdout.write(safe(`${e.status.padEnd(15)}${e.key}${e.from ? ` (from ${e.from})` : ''}\n`));
+        if (e.status === 'modified' || e.status === 'conflict' || e.status === 'remote-changed')
+            process.stdout.write(safe(patch(e)));
+    }
+    process.stdout.write(`${unchanged} unchanged\n`);
+}
+async function runPullCommand(argv) {
+    if (wantsHelp(argv)) {
+        process.stdout.write(exports.SYNC_HELP);
+        return;
+    }
+    const opts = parseSyncArgs(argv);
+    const found = (0, workspace_1.findRoot)();
+    let root = found;
+    if (!root) {
+        if (!opts.project)
+            throw new errors_1.CliError('Not in a metrio workspace. Run "metrio pull --project <slug>" to start one here.');
+        root = process.cwd(); // metrio.yaml is only created once the console fetch succeeded
+    }
+    else if (opts.project && opts.project !== (0, workspace_1.readProject)(root)) {
+        (0, workspace_1.initRoot)(root, opts.project); // throws: metrio.yaml names another project
+    }
+    const ctx = { root, project: found ? (0, workspace_1.readProject)(root) : opts.project, client: new client_1.ConsoleClient(await (0, client_1.resolveConsoleAuth)()) };
+    // A fresh workspace is locked once metrio.yaml exists (below).
+    let release = found && !opts.dryRun ? (0, workspace_1.acquireLock)(root) : undefined;
+    try {
+        const state = (0, workspace_1.readState)(ctx.root, ctx.project);
+        const entries = await loadEntries(ctx, opts);
+        if (!found && !opts.dryRun) {
+            (0, workspace_1.initRoot)(root, ctx.project);
+            release = (0, workspace_1.acquireLock)(root);
+        }
+        let unchanged = 0;
+        let failed = 0;
+        const record = (e, files) => {
+            const h = (0, workspace_1.hashFiles)(files);
+            state.resources[e.key] = { ...(state.resources[e.key] ?? {}), kind: e.kind, id: e.remote.id, base: h, remote: h };
+        };
+        const take = (e, verb) => {
+            if (!opts.dryRun) {
+                (0, workspace_1.writeLocal)(ctx.root, e.key, e.kind, e.remote.files);
+                record(e, e.remote.files);
+            }
+            process.stdout.write(safe(`${opts.dryRun ? 'would pull' : verb} ${e.key}\n`));
+        };
+        for (const e of entries) {
+            try {
+                switch (e.status) {
+                    case 'unchanged':
+                        if (e.refresh && !opts.dryRun)
+                            record(e, e.remote.files);
+                        if (e.refresh && !e.state)
+                            process.stdout.write(safe(`${opts.dryRun ? 'would track' : 'tracked'} ${e.key}\n`));
+                        else
+                            unchanged += 1;
+                        break;
+                    case 'remote-new':
+                    case 'remote-changed':
+                        take(e, 'pulled');
+                        break;
+                    case 'deleted':
+                        take(e, 'restored');
+                        break;
+                    case 'modified':
+                        if (opts.force)
+                            take(e, 'pulled');
+                        else
+                            process.stderr.write(safe(`skipped ${e.key}: local changes (use --force to overwrite)\n`));
+                        break;
+                    case 'conflict':
+                        if (!e.state && e.kind === 'prompt' && e.remote.data.version === null) {
+                            // A console prompt without a version has nothing to pull: track it as if its empty render
+                            // had been pulled, so the local files show as edits and push creates the first version.
+                            if (!opts.dryRun) {
+                                const h = (0, workspace_1.hashFiles)(e.remote.files);
+                                state.resources[e.key] = { kind: e.kind, id: e.remote.id, base: h, remote: h };
+                            }
+                            process.stdout.write(safe(`${opts.dryRun ? 'would track' : 'tracked'} ${e.key} (the console prompt has no version yet; push to create one)\n`));
+                        }
+                        else if (opts.force)
+                            take(e, 'pulled');
+                        else
+                            process.stderr.write(safe(`skipped ${e.key}: local changes (use --force to overwrite)\n`));
+                        break;
+                    case 'renamed': {
+                        const old = state.resources[e.from];
+                        if (!opts.dryRun) {
+                            state.resources[e.key] = old;
+                            delete state.resources[e.from];
+                        }
+                        process.stdout.write(safe(`${opts.dryRun ? 'would rename' : 'renamed'} ${e.from} -> ${e.key}\n`));
+                        if ((0, workspace_1.hashFiles)(e.remote.files) !== old.remote)
+                            take(e, 'pulled');
+                        break;
+                    }
+                    case 'remote-deleted':
+                        if (!opts.dryRun)
+                            delete state.resources[e.key];
+                        process.stderr.write(safe(`${e.key}: deleted in the console; local files kept (push to recreate, or delete them)\n`));
+                        break;
+                    case 'new':
+                        break;
+                }
+            }
+            catch (error) {
+                failed += 1;
+                process.stderr.write(safe(`failed ${e.key}: ${error instanceof Error ? error.message : String(error)}\n`));
+            }
+        }
+        if (!opts.dryRun)
+            (0, workspace_1.writeState)(ctx.root, state);
+        process.stdout.write(`${unchanged} unchanged\n`);
+        if (failed > 0)
+            throw new errors_1.CliError(`${failed} resources failed`, 1);
+    }
+    finally {
+        release?.();
+    }
+}
+function remoteContent(r) {
+    try {
+        return (0, push_1.versionContent)(r.kind, r.files, r.kind);
+    }
+    catch {
+        return undefined;
+    }
+}
+const remoteMoved = (e) => (0, workspace_1.hashFiles)(e.remote.files) !== e.state.remote;
+function planPush(entries, opts, options) {
+    const actions = [];
+    for (const entry of entries) {
+        switch (entry.status) {
+            case 'unchanged':
+                if ((0, push_1.hasPendingVersion)(entry, options))
+                    actions.push({ entry, op: 'update' });
+                break;
+            case 'modified':
+                actions.push({ entry, op: 'update' });
+                break;
+            case 'new':
+                actions.push({ entry, op: 'create' });
+                break;
+            case 'renamed':
+                if (entry.kind === 'workflow') {
+                    actions.push({ entry, skip: 'workflow directories are named by workflow_id; rename it in the console instead', failure: true });
+                }
+                else if (remoteMoved(entry))
+                    actions.push({ entry, skip: 'remote changed; run "metrio pull" first', failure: true });
+                else
+                    actions.push({ entry, op: 'rename' });
+                break;
+            case 'conflict':
+                if (!entry.state) {
+                    const reason = `exists in the console but is not tracked here. "metrio pull --force ${entry.key}" would OVERWRITE your local files; ` +
+                        'to keep them, rename the local directory (it will be pushed as new) or delete the console copy first';
+                    actions.push({ entry, skip: reason, failure: true });
+                }
+                else if (opts.force)
+                    actions.push({ entry, op: 'update' });
+                else
+                    actions.push({ entry, skip: 'conflict: changed locally and in the console (pull, merge, then push; or --force)', failure: true });
+                break;
+            case 'remote-changed':
+                actions.push({ entry, skip: 'remote changed; run "metrio pull" first', failure: true });
+                break;
+            case 'remote-deleted':
+                actions.push({ entry, skip: 'deleted in the console; run "metrio pull" to drop it, then push to recreate', failure: true });
+                break;
+            case 'deleted':
+                if (opts.prune && opts.yes) {
+                    if (remoteMoved(entry) && !opts.force) {
+                        actions.push({ entry, skip: 'changed in the console since your last pull; use --force to delete anyway', failure: true });
+                    }
+                    else
+                        actions.push({ entry, op: 'delete' });
+                }
+                else if (opts.prune)
+                    actions.push({ entry, skip: 'use --prune --yes to delete it in the console', failure: true });
+                else
+                    actions.push({ entry, skip: 'deleted locally (use --prune --yes to delete it in the console)', failure: false });
+                break;
+            default:
+                break;
+        }
+    }
+    return sortForExecution(actions);
+}
+const KIND_RANK = { skill: 0, prompt: 1, workflow: 2 };
+const DELETE_RANK = { prompt: 3, workflow: 3, skill: 4 };
+/** Skills first (prompts may name new ones), then prompts, workflows; deletes last, skills after what uses them. */
+function sortForExecution(actions) {
+    const rank = (a) => ('op' in a && a.op === 'delete' ? DELETE_RANK : KIND_RANK)[a.entry.kind];
+    return [...actions].sort((a, b) => rank(a) - rank(b));
+}
+const PAST = { create: 'created', update: 'updated', delete: 'deleted', rename: 'renamed' };
+const describeOp = (op, e) => (op === 'rename' ? `${e.from} -> ${e.key}` : e.key);
+async function runPushCommand(argv) {
+    if (wantsHelp(argv)) {
+        process.stdout.write(exports.SYNC_HELP);
+        return;
+    }
+    const opts = parseSyncArgs(argv);
+    const ctx = await openWorkspace();
+    const release = opts.dryRun ? undefined : (0, workspace_1.acquireLock)(ctx.root);
+    try {
+        const state = (0, workspace_1.readState)(ctx.root, ctx.project);
+        const options = { activate: opts.activate, publish: opts.publish, message: opts.message, force: opts.force };
+        const entries = await loadEntries(ctx, opts);
+        const actions = planPush(entries, opts, options);
+        if (opts.dryRun) {
+            for (const a of actions) {
+                process.stdout.write(safe('op' in a ? `would ${a.op} ${describeOp(a.op, a.entry)}\n` : `skip ${a.entry.key}: ${a.skip}\n`));
+            }
+            return;
+        }
+        const pushCtx = { client: ctx.client, project: ctx.project, options };
+        const done = [];
+        let failed = 0;
+        for (const a of actions) {
+            if (!('op' in a)) {
+                if (a.failure) {
+                    failed += 1;
+                    process.stderr.write(safe(`skip ${a.entry.key}: ${a.skip}\n`));
+                }
+                else
+                    process.stderr.write(safe(`${a.entry.key}: ${a.skip}\n`));
+                continue;
+            }
+            try {
+                let result;
+                if (a.op === 'delete')
+                    await (0, push_1.deleteEntry)(pushCtx, a.entry);
+                else if (a.op !== 'rename')
+                    result = await (0, push_1.pushEntry)(pushCtx, a.entry);
+                done.push({ entry: a.entry, op: a.op, result });
+                process.stdout.write(safe(`${PAST[a.op]} ${describeOp(a.op, a.entry)}${result ? ` (${result.summary})` : ''}\n`));
+            }
+            catch (error) {
+                failed += 1;
+                process.stderr.write(safe(`failed ${a.entry.key}: ${error instanceof Error ? error.message : String(error)}\n`));
+            }
+        }
+        // Converged resources (same content on both sides, stale state): record them as synced.
+        const converged = entries.filter((e) => e.refresh && !done.some((d) => d.entry === e));
+        for (const e of converged) {
+            const h = (0, workspace_1.hashFiles)(e.local);
+            state.resources[e.key] = { ...(state.resources[e.key] ?? {}), kind: e.kind, id: e.remote.id, base: h, remote: h };
+        }
+        if (converged.length && !done.length)
+            (0, workspace_1.writeState)(ctx.root, state);
+        let refetchFailed = false;
+        if (done.length) {
+            const pushed = done.filter((d) => d.result);
+            let refreshed;
+            if (pushed.length) {
+                try {
+                    refreshed = await (0, remote_1.fetchRemote)(ctx.client, ctx.project, [...new Set(pushed.map((d) => d.entry.kind))]);
+                }
+                catch (error) {
+                    refetchFailed = true;
+                    process.stderr.write(safe(`could not re-read the console after pushing: ${error instanceof Error ? error.message : String(error)}; run "metrio diff" to check\n`));
+                }
+            }
+            for (const d of done) {
+                const key = d.entry.key;
+                if (d.op === 'delete') {
+                    delete state.resources[key];
+                }
+                else if (d.op === 'rename') {
+                    state.resources[key] = state.resources[d.entry.from];
+                    delete state.resources[d.entry.from];
+                }
+                else {
+                    const r = d.result;
+                    const previous = state.resources[key];
+                    const remote = refreshed?.find((x) => x.kind === d.entry.kind && x.id === r.id);
+                    state.resources[key] = {
+                        ...(previous ?? {}),
+                        kind: d.entry.kind,
+                        id: r.id,
+                        base: (0, workspace_1.hashFiles)(d.entry.local),
+                        // Without a re-read, keep the last known remote hash: the next diff then shows what really changed.
+                        remote: refreshed ? (remote ? (0, workspace_1.hashFiles)(remote.files) : '') : (previous?.remote ?? ''),
+                        ...(r.pushed_version_id !== undefined ? { pushed_version_id: r.pushed_version_id, pushed_serial: r.pushed_serial } : {}),
+                        ...(r.pushed_workflow_version !== undefined ? { pushed_workflow_version: r.pushed_workflow_version } : {}),
+                        ...(r.pushed_content !== undefined ? { pushed_content: r.pushed_content } : {}),
+                        // What the console made of a new/activated version (defaults filled, prompt_refs pinned): see push.ts.
+                        ...(refreshed && r.versioned ? { remote_content: remote ? remoteContent(remote) : undefined } : {}),
+                    };
+                }
+            }
+            (0, workspace_1.writeState)(ctx.root, state);
+        }
+        process.stdout.write(`${done.length} pushed, ${failed} failed\n`);
+        if (failed)
+            throw new errors_1.CliError(`${failed} of ${done.length + failed} resources failed`, 1);
+        if (refetchFailed)
+            throw new errors_1.CliError('pushed, but could not re-read the console; run "metrio diff" to check', 1);
+    }
+    finally {
+        release?.();
+    }
+}