@sanity/workflow-cli 0.9.0 → 0.11.0

package/dist/commands/list.js

@@ -1,27 +1,34 @@
-import { styleText } from 'node:util';
-import { Command, Flags } from '@oclif/core';
-import { WORKFLOW_INSTANCE_TYPE, tagScopeFilter } from '@sanity/workflow-engine';
-import { Table } from 'console-table-printer';
+import { Flags } from '@oclif/core';
+import { WORKFLOW_INSTANCE_TYPE, documentPrefilter, inFlightFilter, instanceWatchesDocument, tagScopeFilter, terminalState, } from '@sanity/workflow-engine';
 import logSymbols from 'log-symbols';
-import { resolveReadContext } from "../lib/context.js";
+import { WorkflowCommand } from "../lib/base-command.js";
+import { resolveReadTargets } from "../lib/context.js";
+import { failOnThrow } from "../lib/fail.js";
 import { tagFlags } from "../lib/flags.js";
-import { formatAge } from "../lib/ui.js";
-/**
- * Build the GROQ query + params for `list` from its flags. Pure so the
- * filter combinations can be asserted without a live dataset. `--tag` is an
- * optional filter: omit it and the listing spans every partition.
- */
+import { runReadAcrossTargets } from "../lib/read-fanout.js";
+import { clipToLimit, formatAge, formatTable } from "../lib/ui.js";
 export function buildListQuery(flags) {
     const filters = [`_type == "${WORKFLOW_INSTANCE_TYPE}"`];
-    if (flags['in-flight'])
-        filters.push('!defined(completedAt)');
-    if (flags.definition)
+    const params = {};
+    if (!flags['include-completed'])
+        filters.push(inFlightFilter());
+    if (flags.definition) {
         filters.push('definition == $definition');
-    // Cheap approximation of --failed: any activity in any stage with status "failed".
+        params['definition'] = flags.definition;
+    }
     if (flags.failed)
         filters.push('count(stages[].activities[status == "failed"]) > 0');
-    if (flags.tag)
+    if (flags.tag) {
         filters.push(tagScopeFilter());
+        params['tag'] = flags.tag;
+    }
+    if (flags.document) {
+        const armParams = {};
+        filters.push(`(${documentPrefilter([flags.document], armParams)})`);
+        Object.assign(params, armParams);
+        return { groq: `*[${filters.join(' && ')}] | order(lastChangedAt desc)`, params };
+    }
+    params['limit'] = flags.limit + 1;
     const groq = `*[${filters.join(' && ')}] | order(lastChangedAt desc) [0...$limit]{
       _id,
       definition,
@@ -31,50 +38,34 @@ export function buildListQuery(flags) {
       abortedAt,
       lastChangedAt
     }`;
-    const params = { limit: flags.limit };
-    if (flags.definition)
-        params['definition'] = flags.definition;
-    if (flags.tag)
-        params['tag'] = flags.tag;
     return { groq, params };
 }
-/** Aborted instances also carry `completedAt`, so check `abortedAt` first. */
-function deriveStatus(r) {
-    if (r.abortedAt)
-        return 'aborted';
-    if (r.completedAt)
-        return 'completed';
-    return 'in-flight';
-}
-/** Map a queried instance to its display row (derives the status column).
- *  Pure — status is the semantic value; the table colors it at render. */
 export function instanceRow(r) {
     return {
         _id: r._id,
         definition: r.definition,
         tag: r.tag,
         currentStage: r.currentStage,
-        status: deriveStatus(r),
+        status: terminalState({
+            ...(r.completedAt != null ? { completedAt: r.completedAt } : {}),
+            ...(r.abortedAt != null ? { abortedAt: r.abortedAt } : {}),
+        }),
         lastChangedAt: r.lastChangedAt,
     };
 }
-const STATUS_COLOR = {
-    completed: 'green',
-    aborted: 'dim',
-    'in-flight': 'cyan',
-};
-export default class List extends Command {
-    static description = 'List workflow instances in the configured dataset.';
+export default class List extends WorkflowCommand {
+    static description = 'List workflow instances in the configured dataset (in-flight by default).';
     static examples = [
         '<%= config.bin %> list',
-        '<%= config.bin %> list --in-flight',
+        '<%= config.bin %> list --include-completed',
         '<%= config.bin %> list --definition productLaunch',
+        '<%= config.bin %> list --document dataset:proj:ds:article-1',
         '<%= config.bin %> list --tag prod',
     ];
     static flags = {
         ...tagFlags,
-        'in-flight': Flags.boolean({
-            description: 'Only instances that have not completed.',
+        'include-completed': Flags.boolean({
+            description: 'Include completed/aborted instances (default: in-flight only).',
             default: false,
         }),
         failed: Flags.boolean({
@@ -84,6 +75,10 @@ export default class List extends Command {
         definition: Flags.string({
             description: "Only instances of this workflow definition (its `name`; the instance's `definition` field).",
         }),
+        document: Flags.string({
+            description: 'Only instances that reference this document (resource-qualified GDR URI, ' +
+                'e.g. "dataset:proj:ds:article-1").',
+        }),
         limit: Flags.integer({
             description: 'Maximum rows to return.',
             default: 50,
@@ -91,34 +86,47 @@ export default class List extends Command {
     };
     async run() {
         const { flags } = await this.parse(List);
-        const { client } = await resolveReadContext(flags);
-        const { groq, params } = buildListQuery(flags);
-        const rows = await client.fetch(groq, params);
-        if (rows.length === 0) {
-            this.log(`${logSymbols.info} no instances match`);
-            return;
-        }
-        const table = new Table({
-            columns: [
-                { name: '_id', title: 'Instance', alignment: 'left' },
-                { name: 'definition', title: 'Workflow', alignment: 'left' },
-                { name: 'tag', title: 'Tag', alignment: 'left' },
-                { name: 'currentStage', title: 'Stage', alignment: 'left' },
-                { name: 'status', title: 'Status', alignment: 'left' },
-                { name: 'updated', title: 'Updated', alignment: 'left' },
-            ],
+        const targets = await resolveReadTargets(flags);
+        const { groq, params } = failOnThrow('Invalid --document:', () => buildListQuery(flags));
+        const document = flags.document;
+        const failures = await runReadAcrossTargets({
+            targets,
+            log: (line) => this.log(line),
+            run: async ({ client }) => {
+                const fetched = await fetchRows({ client, groq, params, document });
+                if (fetched.length === 0) {
+                    this.log(`${logSymbols.info} no instances match`);
+                    return;
+                }
+                const { rows, note } = clipToLimit(fetched, flags.limit);
+                const lines = formatTable(['instance', 'workflow', 'tag', 'stage', 'status', 'updated'], rows.map((r) => {
+                    const row = instanceRow(r);
+                    return [
+                        row._id,
+                        row.definition,
+                        row.tag,
+                        row.currentStage,
+                        row.status,
+                        formatAge(row.lastChangedAt),
+                    ];
+                }));
+                for (const line of lines) {
+                    this.log(line);
+                }
+                if (note) {
+                    this.log(note);
+                }
+            },
         });
-        for (const r of rows) {
-            const row = instanceRow(r);
-            table.addRow({
-                _id: row._id,
-                definition: row.definition,
-                tag: row.tag,
-                currentStage: row.currentStage,
-                status: styleText(STATUS_COLOR[row.status], row.status),
-                updated: formatAge(row.lastChangedAt),
-            });
+        if (failures.length > 0) {
+            this.exit(1);
         }
-        table.printTable();
     }
 }
+async function fetchRows({ client, groq, params, document, }) {
+    if (document === undefined) {
+        return client.fetch(groq, params, { tag: 'list' });
+    }
+    const candidates = await client.fetch(groq, params, { tag: 'list' });
+    return candidates.filter((instance) => instanceWatchesDocument(instance, document));
+}

package/dist/commands/reset-activity.js

@@ -1,7 +1,6 @@
 import { Args } from '@oclif/core';
 import { StubCommand } from "../lib/stub.js";
 export default class ResetActivity extends StubCommand {
-    // Stubbed, so kept off the help + published surface until it's wired.
     static hidden = true;
     static description = 'Reset a failed activity on an in-flight instance — back to pending (re-run) or to skipped (bypass).';
     static args = {

package/dist/commands/set-stage.d.ts

@@ -1,8 +1,8 @@
-import { Command } from '@oclif/core';
 import { type SetStageArgs, type WorkflowInstance } from '@sanity/workflow-engine';
+import { WorkflowCommand } from '../lib/base-command.ts';
 import { type EngineScope } from '../lib/operation-args.ts';
 import { type WriteOutcome, type WriteReport } from '../lib/ops-report.ts';
-export default class SetStage extends Command {
+export default class SetStage extends WorkflowCommand {
     static description: string;
     static examples: string[];
     static args: {

package/dist/commands/set-stage.js

@@ -1,13 +1,12 @@
 import { styleText } from 'node:util';
-import { Args, Command, Flags } from '@oclif/core';
+import { Args, Flags } from '@oclif/core';
 import { workflow } from '@sanity/workflow-engine';
-import ora from 'ora';
+import { WorkflowCommand } from "../lib/base-command.js";
 import { resolveInstanceContext } from "../lib/context.js";
-import { errorMessage, fail } from "../lib/fail.js";
 import { tagFlags } from "../lib/flags.js";
 import { buildOperationArgs } from "../lib/operation-args.js";
-import { emitWriteReport, opsAppliedLines, } from "../lib/ops-report.js";
-export default class SetStage extends Command {
+import { cascadeTail, opsAppliedLines, runWriteVerb, } from "../lib/ops-report.js";
+export default class SetStage extends WorkflowCommand {
     static description = "Force an instance into a stage, regardless of its declared transitions and filters — the engine's setStage admin override. The target stage's enter lifecycle still runs (auto-activities start, stage guards reconcile), and the post-move cascade can immediately auto-transition the instance onward.";
     static examples = [
         '<%= config.bin %> set-stage wf-instance.abc123 --to ready',
@@ -32,9 +31,11 @@ export default class SetStage extends Command {
     async run() {
         const { args, flags } = await this.parse(SetStage);
         const { client, scope } = await resolveInstanceContext(flags, args.instanceId);
-        const spinner = ora(`Setting ${args.instanceId} → ${flags.to}…`).start();
-        try {
-            const result = await workflow.setStage({
+        await runWriteVerb({
+            startLabel: `Setting ${args.instanceId} → ${flags.to}…`,
+            failLabel: 'Stage move rejected',
+            failHeadline: 'set-stage error:',
+            run: () => workflow.setStage({
                 client,
                 ...buildSetStageArgs({
                     scope,
@@ -42,44 +43,27 @@ export default class SetStage extends Command {
                     targetStage: flags.to,
                     reason: flags.reason,
                 }),
-            });
-            emitWriteReport({
-                spinner,
-                report: setStageReport(result, flags.to),
-                log: (line) => this.log(line),
-            });
-        }
-        catch (error) {
-            spinner.fail('Stage move rejected');
-            fail('set-stage error:', errorMessage(error));
-        }
+            }),
+            report: (result) => setStageReport(result, flags.to),
+            log: (line) => this.log(line),
+        });
     }
 }
-/** The shared operation args ({@link buildOperationArgs}) plus the
- *  setStage-specific target. */
 export function buildSetStageArgs({ scope, instanceId, targetStage, reason, }) {
     return { ...buildOperationArgs({ scope, instanceId, reason }), targetStage };
 }
-/**
- * Turn a `setStage` result into the spinner message + ops block. Pure so
- * the changed / terminal / already-at-target / cascaded / ops permutations
- * can be asserted without driving a real move.
- */
 export function setStageReport(result, to) {
     const stage = styleText('bold', result.instance.currentStage);
     if (!result.changed) {
-        // The engine no-ops in two distinct cases: a terminal instance never
-        // moves again, and a same-stage move has nothing to do.
         const { completedAt } = result.instance;
         const message = completedAt !== undefined
             ? `setStage changed nothing — instance is terminal (at ${stage} since ${completedAt})`
             : `setStage changed nothing — instance is already at ${stage}`;
         return { changed: false, message, opsLines: [] };
     }
-    const tail = result.cascaded > 0 ? `, then cascaded ${result.cascaded} auto-transition(s)` : '';
     return {
         changed: true,
-        message: `Now at ${stage} (was → ${to}${tail})`,
+        message: `Now at ${stage} (was → ${to}${cascadeTail(result.cascaded)})`,
         opsLines: opsAppliedLines(result.ranOps),
     };
 }

package/dist/commands/show.d.ts

@@ -1,6 +1,6 @@
-import { Command } from '@oclif/core';
 import { type WorkflowInstance } from '@sanity/workflow-engine';
-export default class Show extends Command {
+import { WorkflowCommand } from '../lib/base-command.ts';
+export default class Show extends WorkflowCommand {
     static description: string;
     static examples: string[];
     static args: {

package/dist/commands/show.js

@@ -1,11 +1,12 @@
 import { styleText } from 'node:util';
-import { Args, Command, Flags } from '@oclif/core';
-import { abortReason } from '@sanity/workflow-engine';
+import { Args, Flags } from '@oclif/core';
+import { abortReason, displayTitle, terminalState, } from '@sanity/workflow-engine';
 import logSymbols from 'log-symbols';
-import { resolveReadContext } from "../lib/context.js";
+import { WorkflowCommand } from "../lib/base-command.js";
+import { findInstance, resolveReadTargets } from "../lib/context.js";
 import { tagFlags } from "../lib/flags.js";
 import { formatKeyValue, formatTimestamp, sectionHeader, activityIcon } from "../lib/ui.js";
-export default class Show extends Command {
+export default class Show extends WorkflowCommand {
     static description = 'Show the state, activities, and effects of a workflow instance.';
     static examples = [
         '<%= config.bin %> show wf-instance.abc123',
@@ -28,11 +29,12 @@ export default class Show extends Command {
     };
     async run() {
         const { args, flags } = await this.parse(Show);
-        const { client } = await resolveReadContext(flags);
-        const instance = await client.getDocument(args.instanceId);
-        if (!instance) {
+        const targets = await resolveReadTargets(flags);
+        const hit = await findInstance({ targets, instanceId: args.instanceId, requestTag: 'show' });
+        if (!hit) {
             this.error(`${logSymbols.error} no instance with id "${args.instanceId}"`, { exit: 1 });
         }
+        const { instance } = hit;
         this.log(instanceHeader(instance));
         this.log('');
         for (const line of describeInstance(instance, {
@@ -42,19 +44,14 @@ export default class Show extends Command {
         }
     }
 }
-const HEADER_PAD = 9; // "Completed" — the longest label in the block
-/** The summary block at the top of `show` (and reused by `diagnose` /
- *  `fire-action`): a bold workflow + id title, then aligned detail rows. */
+const HEADER_PAD = 9;
 export function instanceHeader(instance) {
     const title = `${styleText('bold', `${instance.definition} v${instance.pinnedVersion}`)}  ${styleText('cyan', instance._id)}`;
     const rows = [
         formatKeyValue({ key: 'Stage', value: instance.currentStage, padTo: HEADER_PAD }),
         formatKeyValue({ key: 'Started', value: formatTimestamp(instance.startedAt), padTo: HEADER_PAD }),
     ];
-    // Aborted instances also carry a completedAt stamped at the abort, so the
-    // abort line stands in for completion — showing a green "Completed" too would
-    // misread as success.
-    if (instance.abortedAt) {
+    if (terminalState(instance) === 'aborted' && instance.abortedAt !== undefined) {
         const reason = abortReason(instance);
         const tail = reason ? ` — ${reason}` : '';
         const value = styleText('yellow', `${formatTimestamp(instance.abortedAt)}${tail}`);
@@ -69,11 +66,6 @@ export function instanceHeader(instance) {
     rows.push(formatKeyValue({ key: 'Tag', value: instance.tag, padTo: HEADER_PAD }));
     return [title, ...rows].join('\n');
 }
-/**
- * The per-instance body lines: every stage with its activities, any pending
- * effects, and (optionally) the history log. Pure so it can be asserted
- * without driving the oclif command.
- */
 export function describeInstance(instance, options) {
     const lines = [sectionHeader('Stages')];
     for (const stage of instance.stages) {
@@ -81,10 +73,6 @@ export function describeInstance(instance, options) {
             ? styleText('dim', ` (exited ${formatTimestamp(stage.exitedAt)})`)
             : styleText('cyan', ' (current)');
         lines.push(`  • ${stage.name}${marker}`);
-        // A persisted stage may carry no activities array — an activity-less stage,
-        // or an older-shape document — so treat an absent list as none rather than
-        // crash. This renders whatever is in the lake, not only freshly-stamped
-        // instances; it does not reconstruct activity state from history.
         for (const activity of stage.activities ?? []) {
             lines.push(`      ${activityIcon[activity.status]} ${activity.name}  ${styleText('dim', `[${activity.status}]`)}`);
         }
@@ -98,7 +86,7 @@ export function describeInstance(instance, options) {
     if (options.includeHistory) {
         lines.push('', sectionHeader('History'));
         for (const entry of instance.history) {
-            lines.push(`  ${styleText('dim', `[${formatTimestamp(entry.at)}]`)} ${entry._type}`);
+            lines.push(`  ${styleText('dim', `[${formatTimestamp(entry.at)}]`)} ${displayTitle(entry._type)}`);
         }
     }
     return lines;

package/dist/commands/start.d.ts

@@ -1,7 +1,7 @@
-import { Command } from '@oclif/core';
-import { type Actor, type FieldEntry, type InitialFieldValue, type StartInstanceArgs, type WorkflowInstance, type WorkflowLifecycle } from '@sanity/workflow-engine';
+import { type InitialFieldValue, type StartInstanceArgs, type WorkflowInstance } from '@sanity/workflow-engine';
+import { WorkflowCommand } from '../lib/base-command.ts';
 import { type EngineScope } from '../lib/operation-args.ts';
-export default class Start extends Command {
+export default class Start extends WorkflowCommand {
     static description: string;
     static examples: string[];
     static args: {
@@ -9,46 +9,22 @@ export default class Start extends Command {
     };
     static flags: {
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        as: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        'as-role': import("@oclif/core/interfaces").OptionFlag<string[], import("@oclif/core/interfaces").CustomOptions>;
         version: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
         field: import("@oclif/core/interfaces").OptionFlag<string[], import("@oclif/core/interfaces").CustomOptions>;
         tag: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
 }
-/**
- * Why a definition can't be started standalone, or `undefined` when it can.
- * Advisory, mirroring the Startable column in `definition list` — the engine
- * itself does not refuse ({@link isStartableDefinition}), but the CLI has no
- * way to supply the parent context a spawn-only child expects.
- */
-export declare function startRefusal(definition: {
-    lifecycle?: WorkflowLifecycle | undefined;
-}): string | undefined;
-/**
- * Type each `--field name=value` against the workflow's declared field
- * entries — the engine takes typed {@link InitialFieldValue}s, and a value's
- * type IS its declared entry's kind. Only `input`-sourced entries read
- * caller values (the engine silently ignores the rest), so anything else
- * fails here, naming the fields that ARE settable; value validation stays
- * in the engine.
- */
-export declare function buildInitialFields({ declared, values, }: {
-    declared: Pick<FieldEntry, 'type' | 'name' | 'initialValue'>[];
-    values: Record<string, unknown>;
-}): InitialFieldValue[];
 /**
  * The shared engine args ({@link baseEngineArgs}) plus the start-specific
  * fields. Optionals spread conditionally because the engine's optional args
  * reject an explicit `undefined` under `exactOptionalPropertyTypes`.
  */
-export declare function buildStartArgs({ scope, name, version, initialFields, actor, }: {
+export declare function buildStartArgs({ scope, name, version, initialFields, }: {
     scope: EngineScope;
     name: string;
     version: number | undefined;
     initialFields: InitialFieldValue[];
-    actor: Actor;
 }): StartInstanceArgs & EngineScope;
 /** The success spinner message. Pure so the in-flight / immediately-terminal
  *  permutations can be asserted without driving a real start. */

package/dist/commands/start.js

@@ -1,20 +1,20 @@
 import { styleText } from 'node:util';
-import { Args, Command, Flags } from '@oclif/core';
-import { isStartableDefinition, workflow, } from '@sanity/workflow-engine';
-import ora from 'ora';
+import { Args, Flags } from '@oclif/core';
+import { buildInitialFields, startRefusal, workflow, } from '@sanity/workflow-engine';
+import { WorkflowCommand } from "../lib/base-command.js";
 import { resolveContext } from "../lib/context.js";
 import { fetchDeployedDefinition } from "../lib/definitions.js";
-import { errorMessage, fail, failOnThrow } from "../lib/fail.js";
-import { actorFlags, jsonFlags, tagFlags } from "../lib/flags.js";
-import { baseEngineArgs, resolveActor } from "../lib/operation-args.js";
+import { fail, failOnThrow, failureDetail } from "../lib/fail.js";
+import { jsonFlags, tagFlags } from "../lib/flags.js";
+import { baseEngineArgs } from "../lib/operation-args.js";
+import { runWriteVerb } from "../lib/ops-report.js";
 import { parseParams } from "../lib/params.js";
-export default class Start extends Command {
+export default class Start extends WorkflowCommand {
     static description = 'Start a workflow instance from a deployed definition. Supply values for the ' +
         "workflow's input-sourced fields with --field (e.g. the subject document ref).";
     static examples = [
         '<%= config.bin %> start productLaunch',
         '<%= config.bin %> start article-review --field subject=\'{"id":"dataset:proj:ds:article-1","type":"article"}\'',
-        '<%= config.bin %> start article-review --as user.xyz --as-role editor',
         '<%= config.bin %> start productLaunch --version 2 --tag prod',
     ];
     static args = {
@@ -32,13 +32,11 @@ export default class Start extends Command {
             multiple: true,
             default: [],
         }),
-        ...actorFlags,
         ...jsonFlags,
     };
     async run() {
         const { args, flags } = await this.parse(Start);
         const { deployment, client } = await resolveContext(flags);
-        const actor = failOnThrow('start usage error:', () => resolveActor(flags.as, flags['as-role']));
         const values = failOnThrow('Invalid --field:', () => parseParams(flags.field));
         const initialFields = await resolveStartInputs({
             client,
@@ -54,33 +52,25 @@ export default class Start extends Command {
                 name: args.name,
                 version: flags.version,
                 initialFields,
-                actor,
             }),
         };
         if (flags.json) {
             const result = await workflow
                 .startInstance(startArgs)
-                .catch((error) => fail('start error:', errorMessage(error)));
+                .catch((error) => fail('start error:', failureDetail(error)));
             this.log(JSON.stringify(startResultJson(result.instance), null, 2));
             return;
         }
-        const spinner = ora(`Starting ${args.name}…`).start();
-        try {
-            const result = await workflow.startInstance(startArgs);
-            spinner.succeed(startReport(result.instance));
-        }
-        catch (error) {
-            spinner.fail('Start rejected');
-            fail('start error:', errorMessage(error));
-        }
+        await runWriteVerb({
+            startLabel: `Starting ${args.name}…`,
+            failLabel: 'Start rejected',
+            failHeadline: 'start error:',
+            run: () => workflow.startInstance(startArgs),
+            report: (result) => ({ changed: true, message: startReport(result.instance) }),
+            log: (line) => this.log(line),
+        });
     }
 }
-/**
- * Everything `start` must resolve before the engine call: fetch the deployed
- * definition (failing when nothing is deployed under the name), refuse
- * non-startable ones, and type the operator's `--field` values against the
- * declared entries.
- */
 async function resolveStartInputs({ client, name, tag, version, values, }) {
     const deployed = await fetchDeployedDefinition({ client, name, tag, version });
     if (deployed === undefined) {
@@ -92,62 +82,14 @@ async function resolveStartInputs({ client, name, tag, version, values, }) {
     }
     return failOnThrow('start usage error:', () => buildInitialFields({ declared: deployed.fields ?? [], values }));
 }
-/**
- * Why a definition can't be started standalone, or `undefined` when it can.
- * Advisory, mirroring the Startable column in `definition list` — the engine
- * itself does not refuse ({@link isStartableDefinition}), but the CLI has no
- * way to supply the parent context a spawn-only child expects.
- */
-export function startRefusal(definition) {
-    if (isStartableDefinition(definition)) {
-        return undefined;
-    }
-    return "definition is spawn-only (lifecycle: 'child') — instances of it are spawned by a parent workflow's activity, not started standalone";
-}
-/**
- * Type each `--field name=value` against the workflow's declared field
- * entries — the engine takes typed {@link InitialFieldValue}s, and a value's
- * type IS its declared entry's kind. Only `input`-sourced entries read
- * caller values (the engine silently ignores the rest), so anything else
- * fails here, naming the fields that ARE settable; value validation stays
- * in the engine.
- */
-export function buildInitialFields({ declared, values, }) {
-    const settable = declared.filter((f) => f.initialValue?.type === 'input');
-    const settableNames = settable.map((f) => f.name).join(', ');
-    return Object.entries(values).map(([name, value]) => {
-        const entry = declared.find((f) => f.name === name);
-        if (entry === undefined) {
-            throw new Error(settable.length > 0
-                ? `workflow declares no field "${name}" — input fields: ${settableNames}`
-                : `workflow declares no field "${name}" — it declares no input fields at all`);
-        }
-        if (entry.initialValue?.type !== 'input') {
-            throw new Error(`field "${name}" is not input-sourced — the engine would silently ignore the value. ` +
-                (settable.length > 0
-                    ? `Input fields: ${settableNames}`
-                    : 'This workflow has no input fields.'));
-        }
-        // Operator-supplied JSON; the engine validates the value against the
-        // declared kind at start, so this cast is the CLI/engine boundary.
-        return { type: entry.type, name, value };
-    });
-}
-/**
- * The shared engine args ({@link baseEngineArgs}) plus the start-specific
- * fields. Optionals spread conditionally because the engine's optional args
- * reject an explicit `undefined` under `exactOptionalPropertyTypes`.
- */
-export function buildStartArgs({ scope, name, version, initialFields, actor, }) {
+export function buildStartArgs({ scope, name, version, initialFields, }) {
     return {
-        ...baseEngineArgs(scope, actor),
+        ...baseEngineArgs(scope),
         definition: name,
         ...(version !== undefined ? { version } : {}),
         ...(initialFields.length > 0 ? { initialFields } : {}),
     };
 }
-/** The success spinner message. Pure so the in-flight / immediately-terminal
- *  permutations can be asserted without driving a real start. */
 export function startReport(instance) {
     const id = styleText('bold', instance._id);
     const stage = styleText('bold', instance.currentStage);
@@ -155,9 +97,6 @@ export function startReport(instance) {
         ? `Started ${id} — completed immediately at ${stage}`
         : `Started ${id} — now at ${stage}`;
 }
-/** The `--json` payload. Keys follow the CLI's `--json` vocabulary (matching
- *  `fire-action`): `instanceId` carries the document `_id`, `version` the
- *  pinned definition version; the rest mirror the instance fields. */
 export function startResultJson(instance) {
     return {
         instanceId: instance._id,

package/dist/commands/tail.d.ts

@@ -1,5 +1,5 @@
-import { Command } from '@oclif/core';
-export default class Tail extends Command {
+import { WorkflowCommand } from '../lib/base-command.ts';
+export default class Tail extends WorkflowCommand {
     static description: string;
     static examples: string[];
     static args: {