@sanity/workflow-cli 0.14.0 → 0.20.0

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # @sanity/workflow-cli
 
+## 0.20.0
+
+### Minor Changes
+
+- 6e2a066: Ambiguous deployment/resource selection now prompts on an interactive terminal instead of only erroring. When a config has several deployments and no selector is given, `start`, `definition diff`, and `definition delete` show the same deployment picker `deploy` already offered. The instance-targeted commands (`abort`, `set-stage`, `fire-action`, `diagnose`) show that picker too when the config spans several resources — the interactive counterpart to their `--deployment` selector, reading from the chosen deployment's resource. Non-interactive runs (CI, piped output) keep the existing errors asking for `--deployment`/`--tag`, and `nuke` still requires an explicit selector — for a destructive command, naming exactly what is swept is the right friction.
+- 7c4dd86: Reduce guard lifecycle request volume and chunk orphan cleanup transactions.
+- e860898: **BREAKING:** Published Editorial Workflows packages now ship as one fixed release stack and require exact-version peers for every shared runtime package. Install the matching stack so the engine, reactive core, adapters, tools, and UI cannot silently load private or version-skewed copies.
+
+### Patch Changes
+
+- efb4cd9: Error detail below the ✖ headline is no longer dimmed. Validation output, auth hints, and errors caught by command wrappers now render in legible red so the information users need to act on remains readable.
+- Updated dependencies [bce09fc]
+- Updated dependencies [efb4cd9]
+- Updated dependencies [46b0285]
+- Updated dependencies [ab5e454]
+- Updated dependencies [8a76c67]
+- Updated dependencies [e3122cc]
+- Updated dependencies [7e8f459]
+- Updated dependencies [98e488e]
+- Updated dependencies [7c4dd86]
+  - @sanity/workflow-engine@0.20.0
+
 ## 0.14.0
 
 ### Minor Changes

package/README.md

@@ -87,9 +87,12 @@ Pick a deployment with `--deployment <name>`; with a single deployment configure
 can omit it. `--tag <tag>` also works on single-deployment commands while the
 tag names exactly one deployment — on `deploy` it targets every deployment
 carrying the tag (a tag is an environment group). With several configured, a
-bare interactive `deploy` presents a keyboard-driven deployment selector (by
-name, tag alongside). In CI or another non-interactive shell, it fails asking
-for `--deployment`, `--tag`, or `--all-tags` instead of blocking for input.
+bare interactive run presents a keyboard-driven deployment selector (by name,
+tag alongside) — on `deploy`, `start`, and `definition diff`/`delete`, and on
+the instance-targeted commands (`abort`, `set-stage`, `fire-action`,
+`diagnose`) when the config spans several resources. In CI or another
+non-interactive shell, the command fails asking for `--deployment` or `--tag`
+(`deploy` also suggests `--all-tags`) instead of blocking for input.
 `--all-tags` deploys every deployment in the config in one run: a failure in one doesn't
 stop the rest — the run continues, prints a summary of what failed, and exits
 non-zero. The client's project + dataset are derived from the deployment's

package/dist/commands/editorial-workflows/nuke.js

@@ -39,7 +39,7 @@ export default class Nuke extends WorkflowCommand {
     async run() {
         const { flags } = await this.parse(Nuke);
         const config = await loadWorkflowConfig();
-        const deployment = selectDeployment(config, { name: flags.deployment, tag: flags.tag });
+        const deployment = await selectDeployment(config, { name: flags.deployment, tag: flags.tag });
         refuseOverlappingNuke(config.deployments, deployment);
         const targets = buildTargets(deployment, await resolveTokenOrFail());
         const plan = await resolveNukePlan({ tag: deployment.tag, targets });

package/dist/lib/context.d.ts

@@ -1,6 +1,7 @@
 import type { SanityClient } from '@sanity/client';
 import { type WorkflowConfig, type WorkflowDeployment, type WorkflowInstance, type WorkflowResource } from '@sanity/workflow-engine';
 import type { EngineScope } from './operation-args.ts';
+import { type ChooseDeploymentName } from './select-deployment.ts';
 export interface DeploymentContext {
     deployment: WorkflowDeployment;
     client: SanityClient;
@@ -50,10 +51,11 @@ export declare function dedupeResources(resources: WorkflowResource[]): Workflow
  *  tag (tags may repeat across deployments), or — untagged — every distinct
  *  one the config's deployments mention ({@link dedupeResources}). */
 export declare function resolveReadResources(config: WorkflowConfig, tag: string | undefined): WorkflowResource[];
-/** The single resource a read should target, or fail asking which when the
- *  config spans more than one. For the paths that need one definite dataset
- *  (the instance-targeted verbs); listings fan out via
- *  {@link resolveReadResources} instead. */
+/** The single resource an instance-keyed command reads from when it isn't
+ *  disambiguated interactively: the sole resource, the `--tag`-narrowed one, or
+ *  a `fail` asking for `--deployment`/`--tag` when the config spans several. The
+ *  interactive picker lives in {@link resolveInstanceResource}; listings fan out
+ *  via {@link resolveReadResources} instead. */
 export declare function resolveReadResource(config: WorkflowConfig, tag: string | undefined): WorkflowResource;
 /**
  * The resolution an instance-id-targeted command shares, read or write: an
@@ -74,16 +76,22 @@ export declare function resolveInstanceContext(flags: {
 }, instanceId: string): Promise<InstanceContext>;
 /**
  * Which resource an instance-keyed command reads from: the one `--deployment`
- * names (resolved by its unique deployment name), else the sole or
- * `--tag`-narrowed resource ({@link resolveReadResource}). The instance id is
- * globally unique, so this only locates the resource to look in — never the
- * instance's `tag` partition, which the caller takes from the loaded instance.
- * The shared path behind all four instance-keyed commands.
+ * names (resolved by its unique deployment name); otherwise, when the config
+ * spans several resources, an interactive terminal is prompted to pick a
+ * deployment ({@link canPromptOnStderr}) — its resource is the read source, the
+ * interactive counterpart to `--deployment`. A run that can't prompt falls to
+ * the sole or `--tag`-narrowed resource, or the ambiguity error
+ * ({@link resolveReadResource}). The instance id is globally unique, so this
+ * only locates the resource to look in — never the instance's `tag` partition,
+ * which the caller takes from the loaded instance. The shared path behind all
+ * four instance-keyed commands.
  */
-export declare function resolveInstanceResource(config: WorkflowConfig, { deployment, tag }: {
+export declare function resolveInstanceResource(config: WorkflowConfig, { deployment, tag, interactive, chooseDeployment, }: {
     deployment?: string | undefined;
     tag?: string | undefined;
-}): WorkflowResource;
+    interactive?: boolean | undefined;
+    chooseDeployment?: ChooseDeploymentName | undefined;
+}): Promise<WorkflowResource>;
 /** Fetch an instance by id, exiting cleanly when the resource has no such
  *  document — the diagnostic an operator sees on a mistyped id. Split out from
  *  {@link resolveInstanceContext} so the not-found path is unit-testable

package/dist/lib/context.js

@@ -2,11 +2,12 @@ import { assertReadableModel, resourceGdr, } from '@sanity/workflow-engine';
 import { clientFor, resolveTokenOrFail } from "./client.js";
 import { fail } from "./fail.js";
 import { loadWorkflowConfig } from "./load-config.js";
-import { availableDeployments, deploymentsForTag, selectDeployment } from "./select-deployment.js";
+import { canPromptOnStderr } from "./prompt.js";
+import { availableDeployments, deploymentsForTag, selectDeployment, } from "./select-deployment.js";
 import { resourceLabel } from "./ui.js";
 export async function resolveContext(flags) {
     const config = await loadWorkflowConfig();
-    const deployment = selectDeployment(config, { name: flags.deployment, tag: flags.tag });
+    const deployment = await selectDeployment(config, { name: flags.deployment, tag: flags.tag });
     return { deployment, client: clientFor(deployment.workflowResource, await resolveTokenOrFail()) };
 }
 export async function resolveReadTargets(flags) {
@@ -42,14 +43,25 @@ export function resolveReadResource(config, tag) {
 }
 export async function resolveInstanceContext(flags, instanceId) {
     const config = await loadWorkflowConfig();
-    const workflowResource = resolveInstanceResource(config, flags);
+    const workflowResource = await resolveInstanceResource(config, flags);
     const client = clientFor(workflowResource, await resolveTokenOrFail());
     const instance = await loadInstanceOrFail(client, instanceId);
     return { client, scope: { tag: instance.tag, workflowResource } };
 }
-export function resolveInstanceResource(config, { deployment, tag }) {
+export async function resolveInstanceResource(config, { deployment, tag, interactive, chooseDeployment, }) {
     if (deployment !== undefined) {
-        return selectDeployment(config, { name: deployment, tag: undefined }).workflowResource;
+        return (await selectDeployment(config, { name: deployment, tag: undefined })).workflowResource;
+    }
+    if (tag === undefined &&
+        (interactive ?? canPromptOnStderr()) &&
+        resolveReadResources(config, undefined).length > 1) {
+        const chosen = await selectDeployment(config, {
+            name: undefined,
+            tag: undefined,
+            interactive: true,
+            chooseName: chooseDeployment,
+        });
+        return chosen.workflowResource;
     }
     return resolveReadResource(config, tag);
 }

package/dist/lib/fail.js

@@ -8,7 +8,7 @@ export function fail(headline, detail) {
     process.stderr.write(`${styleText('red', `${logSymbols.error} ${headline}`)}\n`);
     if (detail !== undefined && detail !== '') {
         for (const line of detail.split('\n')) {
-            process.stderr.write(`  ${styleText(['dim', 'red'], line)}\n`);
+            process.stderr.write(`  ${styleText('red', line)}\n`);
         }
     }
     return Errors.exit(1);

package/dist/lib/nuke.d.ts

@@ -59,19 +59,6 @@ export declare function resolveNukePlan(args: {
     tag: string;
     targets: NukeTarget[];
 }): Promise<NukePlan>;
-/**
- * Does a guard doc belong to `tag`? A guard's `sourceInstanceId` is the id of
- * the instance that registered it (`<tag>.wf-instance.<random>`), and its own
- * `_id` embeds that same instance id
- * (`temp.system.guard.<tag>.wf-instance.<random>.<name>`). Matching on either —
- * with the trailing `.` so `prod` never matches `prod-eu` — catches guards
- * whose `sourceInstanceId` was never written as well as guards whose instance
- * is already gone.
- */
-export declare function guardMatchesTag(guard: {
-    _id: string;
-    sourceInstanceId?: string;
-}, tag: string): boolean;
 /** The `project.dataset` labels of resources the plan actually deletes from —
  *  the exact set the operator must type back to confirm. A resource with
  *  nothing to delete is not "involved" and is omitted. */

package/dist/lib/nuke.js

@@ -52,14 +52,12 @@ function engineDocIds(args) {
     return args.client.fetch(`*[_type == $type && ${tagScopeFilter()}]._id`, { type: args.type, tag: args.tag }, { perspective: 'raw', tag: REQUEST_TAG });
 }
 async function tagGuardIds(args) {
-    const guards = await args.client.fetch(`*[_type == $type]{_id, sourceInstanceId}`, { type: GUARD_DOC_TYPE }, { perspective: 'raw', tag: REQUEST_TAG });
-    return guards.filter((guard) => guardMatchesTag(guard, args.tag)).map((guard) => guard._id);
-}
-export function guardMatchesTag(guard, tag) {
-    const instancePrefix = `${tag}.wf-instance.`;
+    const instancePrefix = `${args.tag}.wf-instance.`;
     const guardIdPrefix = `${GUARD_DOC_TYPE}.${instancePrefix}`;
-    return ((guard.sourceInstanceId?.startsWith(instancePrefix) ?? false) ||
-        guard._id.startsWith(guardIdPrefix));
+    return args.client.fetch(`*[_type == $type && (
+      string::startsWith(sourceInstanceId, $instancePrefix) ||
+      string::startsWith(_id, $guardIdPrefix)
+    )]._id`, { type: GUARD_DOC_TYPE, instancePrefix, guardIdPrefix }, { perspective: 'raw', tag: REQUEST_TAG });
 }
 export function involvedTargets(plan) {
     return plan.resources

package/dist/lib/prompt.d.ts

@@ -9,3 +9,17 @@
  * prompts such as nuke's confirmation.
  */
 export declare function canPromptOnStderr(): boolean;
+/**
+ * Ask a `select` question on stderr — the channel this package renders prompts
+ * on so a redirected stdout can't swallow the question (the display side of the
+ * {@link canPromptOnStderr} gate). The single site that routes a `select` to
+ * stderr, so no `select` prompt can silently regress to stdout.
+ */
+export declare function selectOnStderr(config: {
+    message: string;
+    choices: readonly {
+        name: string;
+        value: string;
+        description?: string;
+    }[];
+}): Promise<string>;

package/dist/lib/prompt.js

@@ -1,4 +1,8 @@
 import { isInteractive } from '@sanity/cli-core';
+import { select } from '@sanity/cli-core/ux';
 export function canPromptOnStderr() {
     return isInteractive() && process.stderr.isTTY === true;
 }
+export function selectOnStderr(config) {
+    return select(config, { output: process.stderr });
+}

package/dist/lib/select-deployment.d.ts

@@ -1,5 +1,5 @@
 import { type DeployTarget, type WorkflowConfig, type WorkflowDeployment } from '@sanity/workflow-engine';
-type ChooseDeploymentName = (deployments: WorkflowDeployment[]) => Promise<string>;
+export type ChooseDeploymentName = (deployments: WorkflowDeployment[]) => Promise<string>;
 interface DeploymentSelectionOptions {
     name: string | undefined;
     tag: string | undefined;
@@ -19,17 +19,20 @@ export declare function deploymentLabel({ name, tag }: Pick<WorkflowDeployment,
  * so `--deployment` can disambiguate.
  *
  * With no selector: fall back to the sole deployment when there's exactly one
- * (the common single-environment case), otherwise fail asking for
- * `--deployment` or `--tag` — a multi-deployment config is ambiguous without
- * one. `orAlternative`
- * extends that ambiguity message for callers with another way out (deploy's
+ * (the common single-environment case). When several are configured, an
+ * interactive terminal is prompted to pick one ({@link canPromptOnStderr}); a
+ * run that cannot prompt fails asking for `--deployment` or `--tag` — a
+ * multi-deployment config is ambiguous without one. `orAlternative` extends
+ * that ambiguity message for callers with another way out (deploy's
  * `--all-tags`).
  */
-export declare function selectDeployment(config: WorkflowConfig, { name, tag, orAlternative, }: {
+export declare function selectDeployment(config: WorkflowConfig, { name, tag, orAlternative, interactive, chooseName, }: {
     name: string | undefined;
     tag: string | undefined;
     orAlternative?: string;
-}): WorkflowDeployment;
+    interactive?: boolean | undefined;
+    chooseName?: ChooseDeploymentName | undefined;
+}): Promise<WorkflowDeployment>;
 /**
  * Every deployment carrying `tag`, failing when the tag matches none — the
  * shared resolution for the callers that accept a whole tag group (deploy's

package/dist/lib/select-deployment.js

@@ -1,11 +1,10 @@
-import { select } from '@sanity/cli-core/ux';
 import { resourceAliasesToMap, } from '@sanity/workflow-engine';
 import { fail } from "./fail.js";
-import { canPromptOnStderr } from "./prompt.js";
+import { canPromptOnStderr, selectOnStderr } from "./prompt.js";
 export function deploymentLabel({ name, tag }) {
     return `${name} (${tag})`;
 }
-export function selectDeployment(config, { name, tag, orAlternative = '', }) {
+export async function selectDeployment(config, { name, tag, orAlternative = '', interactive, chooseName = chooseDeploymentName, }) {
     if (name !== undefined) {
         const deployment = config.deployments.find((candidate) => candidate.name === name);
         if (deployment === undefined) {
@@ -21,7 +20,14 @@ export function selectDeployment(config, { name, tag, orAlternative = '', }) {
         }
         return sole;
     }
+    return selectDefaultDeployment(config, { orAlternative, interactive, chooseName });
+}
+async function selectDefaultDeployment(config, { orAlternative, interactive, chooseName, }) {
     if (config.deployments.length > 1) {
+        if (interactive ?? canPromptOnStderr()) {
+            const selectedName = await chooseName(config.deployments);
+            return selectDeployment(config, { name: selectedName, tag: undefined });
+        }
         fail(`Multiple deployments configured — pass --deployment or --tag${orAlternative}.`, availableDeployments(config));
     }
     const [sole] = config.deployments;
@@ -37,43 +43,28 @@ export function deploymentsForTag(config, tag) {
     }
     return matches;
 }
-export async function selectDeployments(config, { name, tag, allTags, interactive, chooseName = chooseDeploymentName }) {
+export async function selectDeployments(config, { name, tag, allTags, interactive, chooseName }) {
     if (allTags) {
         return config.deployments;
     }
     if (tag !== undefined) {
         return deploymentsForTag(config, tag);
     }
-    if (name === undefined && config.deployments.length > 1) {
-        if (!(interactive ?? canPromptOnStderr())) {
-            return [
-                selectDeployment(config, {
-                    name,
-                    tag,
-                    orAlternative: ', or --all-tags to deploy every deployment',
-                }),
-            ];
-        }
-        const selectedName = await chooseName(config.deployments);
-        return [selectDeployment(config, { name: selectedName, tag: undefined })];
-    }
     return [
-        selectDeployment(config, {
+        await selectDeployment(config, {
             name,
             tag,
             orAlternative: ', or --all-tags to deploy every deployment',
+            interactive,
+            chooseName,
         }),
     ];
 }
 async function chooseDeploymentName(deployments) {
-    return select({
+    return selectOnStderr({
         message: 'Select a deployment',
-        choices: deployments.map(({ name, tag }) => ({
-            name,
-            value: name,
-            description: `tag: ${tag}`,
-        })),
-    }, { output: process.stderr });
+        choices: deployments.map(({ name, tag }) => ({ name, value: name, description: `tag: ${tag}` })),
+    });
 }
 export function availableDeployments(config, deployments = config.deployments) {
     return `Available deployments: ${deployments.map(deploymentLabel).join(', ')}`;

package/oclif.manifest.json

@@ -913,5 +913,5 @@
       ]
     }
   },
-  "version": "0.14.0"
+  "version": "0.20.0"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/workflow-cli",
-  "version": "0.14.0",
+  "version": "0.20.0",
   "description": "Command-line tool for deploying, inspecting, and administering Sanity workflow definitions and instances.",
   "keywords": [
     "cli",
@@ -55,16 +55,19 @@
     "diff": "^9.0.0",
     "jiti": "^2.7.0",
     "log-symbols": "^7.0.1",
-    "ora": "^9.4.0",
-    "@sanity/workflow-engine": "0.19.0"
+    "ora": "^9.4.0"
   },
   "devDependencies": {
     "@types/diff": "^8.0.0",
     "@types/node": "^24.12.4",
     "oclif": "^4.23.16",
     "vitest": "^4.1.8",
-    "@sanity/workflow-engine-test": "0.13.1",
-    "@sanity/workflow-examples": "0.8.1"
+    "@sanity/workflow-engine": "0.20.0",
+    "@sanity/workflow-engine-test": "0.20.0",
+    "@sanity/workflow-examples": "0.9.0"
+  },
+  "peerDependencies": {
+    "@sanity/workflow-engine": "0.20.0"
   },
   "oclif": {
     "bin": "sanity-workflows",