@sanity/workflow-cli 0.26.0 → 0.28.0

package/dist/help.js

@@ -1,7 +1,28 @@
 import { Help } from '@oclif/core';
-export const isBareSurface = (idOrName) => !idOrName.startsWith('editorial-workflows');
-export const keepCommandAtRoot = (id) => id !== '' && isBareSurface(id);
+import { WORKFLOWS_TOPIC } from "./command-ids.js";
+const TOPIC_PREFIX = `${WORKFLOWS_TOPIC}:`;
+const CANONICAL_EXAMPLE_PREFIX = `<%= config.bin %> ${WORKFLOWS_TOPIC} `;
+const STANDALONE_EXAMPLE_PREFIX = '<%= config.bin %> ';
+const HELP_COMMAND_ID = 'help';
+export const standaloneSurfaceId = (id) => {
+    if (!id.startsWith(TOPIC_PREFIX))
+        return undefined;
+    return id.slice(TOPIC_PREFIX.length);
+};
+export const keepCommandAtRoot = (id) => id === HELP_COMMAND_ID || standaloneSurfaceId(id) !== undefined;
+export const standaloneExample = (example) => {
+    if (typeof example === 'string') {
+        return example.replace(CANONICAL_EXAMPLE_PREFIX, STANDALONE_EXAMPLE_PREFIX);
+    }
+    return {
+        ...example,
+        command: example.command.replace(CANONICAL_EXAMPLE_PREFIX, STANDALONE_EXAMPLE_PREFIX),
+    };
+};
 export default class WorkflowHelp extends Help {
+    async showCommandHelp(command) {
+        await super.showCommandHelp(withStandaloneSurface(command));
+    }
     async showRootHelp() {
         if (this.opts.all) {
             await super.showRootHelp();
@@ -9,15 +30,22 @@ export default class WorkflowHelp extends Help {
         }
         this.log(this.formatRoot());
         this.log('');
-        const topics = this.sortedTopics.filter((topic) => isBareSurface(topic.name));
-        if (topics.length > 0) {
-            this.log(this.formatTopics(topics));
-            this.log('');
-        }
-        const commands = this.sortedCommands.filter((command) => keepCommandAtRoot(command.id));
+        const commands = this.sortedCommands
+            .filter((command) => keepCommandAtRoot(command.id))
+            .map((command) => withStandaloneSurface(command));
         if (commands.length > 0) {
             this.log(this.formatCommands(commands));
             this.log('');
         }
     }
 }
+function withStandaloneSurface(command) {
+    const shortId = standaloneSurfaceId(command.id);
+    if (shortId === undefined)
+        return command;
+    return {
+        ...command,
+        id: shortId,
+        examples: command.examples?.map((example) => standaloneExample(example)),
+    };
+}

package/dist/lib/base-command.d.ts

@@ -1,9 +1,9 @@
 import { Command } from '@oclif/core';
 /**
  * Base for workflow commands: prompt interrupts exit with the conventional
- * SIGINT code and no stack, while an auth rejection escaping `run` renders
- * through the clean {@link fail} path with {@link failureDetail}'s recovery
- * hint. Every other error propagates to oclif unchanged.
+ * SIGINT code and no stack; an auth rejection and a reader-floor
+ * acknowledgement failure — both expected, user-fixable — render through the
+ * clean {@link fail} path. Every other error propagates to oclif unchanged.
  */
 export declare abstract class WorkflowCommand extends Command {
     protected catch(err: Error & {

package/dist/lib/base-command.js

@@ -1,6 +1,7 @@
 import { styleText } from 'node:util';
 import { Command } from '@oclif/core';
 import { exitCodes } from '@sanity/cli-core';
+import { ReaderModelAcknowledgementError } from '@sanity/workflow-engine';
 import { fail, failureDetail, isAuthRejection } from "./fail.js";
 export class WorkflowCommand extends Command {
     async catch(err) {
@@ -11,6 +12,9 @@ export class WorkflowCommand extends Command {
         if (isAuthRejection(err)) {
             fail('Authentication failed:', failureDetail(err));
         }
+        if (err instanceof ReaderModelAcknowledgementError) {
+            fail('Reader-floor acknowledgement:', err.message);
+        }
         return super.catch(err);
     }
 }

package/dist/lib/context.d.ts

@@ -17,10 +17,11 @@ export interface InstanceContext {
     instance: WorkflowInstance;
 }
 /**
- * The resolution a WRITE shares: discover the config, pick the deployment for
- * `--deployment` or `--tag` (or the sole one), and build an authenticated
- * client for that deployment's resource. A write acts on one specific
- * deployment, so a single, definite target is exactly what it needs.
+ * The resolution a deployment-scoped command shares (`start`, `definition
+ * delete`, `definition diff`): discover the config, pick the deployment for
+ * `--deployment` or `--tag` (or the sole one), assert that deployment's
+ * reader-floor acknowledgement, and build an authenticated client for its
+ * resource. Instance-id commands resolve elsewhere and do not gate here.
  */
 export declare function resolveContext(flags: {
     deployment?: string | undefined;

package/dist/lib/context.js

@@ -1,4 +1,4 @@
-import { assertReadableModel, resourceGdr, } from '@sanity/workflow-engine';
+import { assertReadableModel, assertReaderModelAcknowledgement, resourceGdr, } from '@sanity/workflow-engine';
 import { clientFor, resolveTokenOrFail } from "./client.js";
 import { fail } from "./fail.js";
 import { loadWorkflowConfig } from "./load-config.js";
@@ -7,6 +7,7 @@ import { resourceLabel } from "./ui.js";
 export async function resolveContext(flags) {
     const config = await loadWorkflowConfig();
     const deployment = await selectDeployment(config, { name: flags.deployment, tag: flags.tag });
+    assertReaderModelAcknowledgement(deployment.expectedMinReaderModel, `Deployment ${deployment.name}`);
     return { deployment, client: clientFor(deployment.workflowResource, await resolveTokenOrFail()) };
 }
 function targetsFor(resources, token) {

package/dist/lib/select-deployment.js

@@ -1,4 +1,4 @@
-import { resourceAliasesToMap, } from '@sanity/workflow-engine';
+import { assertReaderModelAcknowledgement, resourceAliasesToMap, } from '@sanity/workflow-engine';
 import { fail } from "./fail.js";
 import { canPromptOnStderr, selectOnStderr } from "./prompt.js";
 export function deploymentLabel({ name, tag }) {
@@ -70,6 +70,7 @@ function availableDeployments(config, deployments = config.deployments) {
     return `Available deployments: ${deployments.map(deploymentLabel).join(', ')}`;
 }
 export function deploymentToTarget(deployment) {
+    assertReaderModelAcknowledgement(deployment.expectedMinReaderModel, `Deployment ${deployment.name}`);
     return {
         expectedMinReaderModel: deployment.expectedMinReaderModel,
         tag: deployment.tag,

package/dist/lib/share-definitions.js

@@ -1,6 +1,7 @@
 import { styleText } from 'node:util';
 import { getUserConfig } from '@sanity/cli-core';
 import { assertReadableModel, definitionDeployedData, errorMessage, } from '@sanity/workflow-engine';
+import { WORKFLOWS_DEPLOY_COMMAND_ID } from "../command-ids.js";
 import { buildDefinitionShowQuery } from "./definitions.js";
 import { canPromptOnStderr } from "./prompt.js";
 import { cliTelemetry, WorkflowDefinitionShared, WorkflowDefinitionSharingDecided, } from "./telemetry.js";
@@ -28,7 +29,7 @@ export function definitionShareMarker(args) {
 }
 export function shouldForceShareTelemetry(args) {
     const { commandId, argv } = args;
-    if (commandId !== 'editorial-workflows:deploy') {
+    if (commandId !== WORKFLOWS_DEPLOY_COMMAND_ID) {
         return false;
     }
     const terminator = argv.indexOf('--');

package/dist/lib/telemetry.d.ts

@@ -117,9 +117,7 @@ export declare function raceWithDeadline<T>(work: Promise<T>, deadlineMs: number
 export declare function finishCliTelemetry(data: WorkflowCliCommandData): Promise<void>;
 /**
  * The command id a trace reports: the resolved class's canonical id when
- * oclif supplies it, else the id as typed. An alias invocation must report
- * under the same name as the canonical form — one command, one telemetry
- * identity.
+ * oclif supplies it, else the unresolved id from the hook.
  */
 export declare function traceCommandId(options: {
     id: string;

package/dist/standalone-argv.d.ts

@@ -0,0 +1,14 @@
+/**
+ * First argv tokens that belong under {@link WORKFLOWS_TOPIC}.
+ * Keep in sync with `src/commands/workflows/` (top-level command
+ * files plus the `definition` subtopic directory).
+ */
+export declare const STANDALONE_ROOT_COMMANDS: readonly ["abort", "definition", "deploy", "diagnose", "fire-action", "list", "nuke", "reset-activity", "set-stage", "show", "start", "tail"];
+/** Index of the first argv token that is not a flag (and not `--`). */
+export declare function firstPositionalIndex(args: string[]): number;
+/**
+ * Rewrite standalone CLI args so short forms resolve to topic-scoped command
+ * ids. Idempotent when the topic is already present. Unknown first tokens are
+ * left alone so oclif's own "command not found" path still runs.
+ */
+export declare function rewriteStandaloneArgv(args: string[]): string[];

package/dist/standalone-argv.js

@@ -0,0 +1,54 @@
+import { WORKFLOWS_TOPIC } from "./command-ids.js";
+export const STANDALONE_ROOT_COMMANDS = [
+    'abort',
+    'definition',
+    'deploy',
+    'diagnose',
+    'fire-action',
+    'list',
+    'nuke',
+    'reset-activity',
+    'set-stage',
+    'show',
+    'start',
+    'tail',
+];
+const rootCommandSet = new Set(STANDALONE_ROOT_COMMANDS);
+export function firstPositionalIndex(args) {
+    for (let i = 0; i < args.length; i++) {
+        const token = args[i];
+        if (token === undefined)
+            continue;
+        if (token === '--')
+            return i + 1 < args.length ? i + 1 : -1;
+        if (!token.startsWith('-'))
+            return i;
+    }
+    return -1;
+}
+function stripScriptArgSeparator(args) {
+    return args[0] === '--' ? args.slice(1) : args;
+}
+export function rewriteStandaloneArgv(args) {
+    const normalized = stripScriptArgSeparator(args);
+    const i = firstPositionalIndex(normalized);
+    if (i === -1)
+        return normalized;
+    const first = normalized[i];
+    if (first === undefined || first === WORKFLOWS_TOPIC)
+        return normalized;
+    if (first === 'help') {
+        const commandIndex = firstPositionalIndex(normalized.slice(i + 1));
+        if (commandIndex === -1)
+            return normalized;
+        const absolute = i + 1 + commandIndex;
+        const command = normalized[absolute];
+        if (command === undefined || command === WORKFLOWS_TOPIC || !rootCommandSet.has(command)) {
+            return normalized;
+        }
+        return [...normalized.slice(0, absolute), WORKFLOWS_TOPIC, ...normalized.slice(absolute)];
+    }
+    if (!rootCommandSet.has(first))
+        return normalized;
+    return [...normalized.slice(0, i), WORKFLOWS_TOPIC, ...normalized.slice(i)];
+}