@sanity/workflow-cli 0.5.1

package/dist/commands/definition/show.js

@@ -0,0 +1,118 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { isTerminalStage, WORKFLOW_DEFINITION_TYPE, tagScopeFilter, } from '@sanity/workflow-engine';
+import boxen from 'boxen';
+import logSymbols from 'log-symbols';
+import { loadClient } from "../../lib/client.js";
+import { tagFlags } from "../../lib/flags.js";
+export function buildDefinitionShowQuery(flags) {
+    const params = { name: flags.name };
+    const filters = [`_type == "${WORKFLOW_DEFINITION_TYPE}"`, 'name == $name'];
+    if (flags.version !== undefined) {
+        params.version = flags.version;
+        filters.push('version == $version');
+    }
+    if (flags.tag) {
+        params.tag = flags.tag;
+        filters.push(tagScopeFilter());
+    }
+    const groq = `*[${filters.join(' && ')}] | order(version desc) [0]`;
+    return { groq, params };
+}
+export default class DefinitionShow extends Command {
+    static description = 'Show a deployed workflow definition.';
+    static args = {
+        name: Args.string({ required: true, description: 'Workflow definition name.' }),
+    };
+    static flags = {
+        ...tagFlags,
+        version: Flags.integer({ description: 'Specific version (default: latest).' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(DefinitionShow);
+        const { groq, params } = buildDefinitionShowQuery({
+            name: args.name,
+            tag: flags.tag,
+            version: flags.version,
+        });
+        const client = loadClient();
+        const def = await client.fetch(groq, params);
+        if (!def) {
+            const at = flags.version ? `v${flags.version}` : 'latest';
+            this.error(`${logSymbols.error} no definition "${args.name}" (${at})`, { exit: 1 });
+        }
+        this.log(boxen(definitionHeader(def, process.stdout.columns), {
+            padding: 1,
+            borderStyle: 'round',
+            title: 'definition',
+        }));
+        this.log('');
+        for (const line of describeDefinition(def)) {
+            this.log(line);
+        }
+    }
+}
+const LABEL_WIDTH = 19;
+/**
+ * One `label  value` row, wrapping the value to `valueWidth` columns and
+ * hanging-indenting continuation lines under the value column — so a long
+ * value (the description) stays right of the label instead of bleeding back
+ * to the left edge of the box.
+ */
+function wrapField(label, value, valueWidth) {
+    const lines = value.split(/\s+/).reduce((acc, word) => {
+        const last = acc[acc.length - 1];
+        if (last !== undefined && last.length + 1 + word.length <= valueWidth) {
+            acc[acc.length - 1] = `${last} ${word}`;
+        }
+        else {
+            acc.push(word);
+        }
+        return acc;
+    }, []);
+    const indent = ' '.repeat(LABEL_WIDTH);
+    return lines
+        .map((text, i) => (i === 0 ? `${label.padEnd(LABEL_WIDTH)}${text}` : `${indent}${text}`))
+        .join('\n');
+}
+/**
+ * The boxed summary block at the top of `definition show` output. `columns`
+ * is the terminal width; values wrap to fit it so `boxen` never re-wraps them.
+ */
+export function definitionHeader(def, columns = 80) {
+    const valueWidth = Math.max(columns - LABEL_WIDTH - 8, 24);
+    const field = (label, value) => wrapField(label, value, valueWidth);
+    return [
+        `${logSymbols.info} ${def.name}`,
+        field('workflow:', `${def.name} v${def.version}`),
+        field('title:', def.title),
+        field('description:', def.description ?? '—'),
+    ].join('\n');
+}
+/** One `· action` line, annotated with the terminal status its `status.set` op sets, if any. */
+function actionLine(action) {
+    const statusOp = (action.ops ?? []).find((op) => op.type === 'status.set');
+    const status = statusOp ? ` → ${statusOp.status}` : '';
+    return `          · ${action.name}${status}`;
+}
+/** A `- task` line followed by one line per action it exposes. */
+function taskBlock(task) {
+    const title = task.title ? ` — ${task.title}` : '';
+    return [`      - ${task.name}${title}`, ...(task.actions ?? []).map(actionLine)];
+}
+/** A `• stage` line (with initial/terminal markers) followed by its task blocks. */
+function stageBlock(stage, initialStage) {
+    const title = stage.title ? ` — ${stage.title}` : '';
+    const terminal = isTerminalStage(stage) ? ' (terminal)' : '';
+    const initial = stage.name === initialStage ? '  [initial]' : '';
+    return [
+        `  • ${stage.name}${title}${terminal}${initial}`,
+        ...(stage.tasks ?? []).flatMap(taskBlock),
+    ];
+}
+/**
+ * The body lines for `definition show`: every stage with its tasks and each
+ * task's actions. Pure so it can be asserted without driving the oclif command.
+ */
+export function describeDefinition(def) {
+    return ['stages:', ...def.stages.flatMap((stage) => stageBlock(stage, def.initialStage))];
+}

package/dist/commands/deploy.d.ts

@@ -0,0 +1,22 @@
+import { Command } from '@oclif/core';
+export default class Deploy extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        check: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        only: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        tag: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    private executeDeploy;
+    private runDryRun;
+}
+/** Reject the contradictory `--check --dry-run` combination. */
+export declare function validateModeFlags(check: boolean, dryRun: boolean): void;
+/** One line per deployed definition, symbol-tagged by its result status. */
+export declare function deployResultLines(results: {
+    status: string;
+    definition: string;
+    version: number;
+}[]): string[];

package/dist/commands/deploy.js

@@ -0,0 +1,97 @@
+import { Command, Flags } from '@oclif/core';
+import { computeDiffEntries, workflow } from '@sanity/workflow-engine';
+import logSymbols from 'log-symbols';
+import ora from 'ora';
+import { buildClient, loadClient } from "../lib/client.js";
+import { loadWorkflowConfig } from "../lib/config.js";
+import { loadValidatedDefinitions } from "../lib/definitions.js";
+import { diffReport } from "../lib/diff.js";
+import { fail } from "../lib/fail.js";
+import { tagFlags } from "../lib/flags.js";
+export default class Deploy extends Command {
+    static description = 'Validate, diff, and deploy workflow definitions to the configured dataset.';
+    static examples = [
+        '<%= config.bin %> deploy',
+        '<%= config.bin %> deploy --check',
+        '<%= config.bin %> deploy --dry-run',
+        '<%= config.bin %> deploy --only productLaunch',
+    ];
+    static flags = {
+        ...tagFlags,
+        'dry-run': Flags.boolean({
+            description: 'Validate + diff against the deployed version; do not write.',
+            default: false,
+        }),
+        check: Flags.boolean({
+            description: 'Validate definitions only; do not contact the dataset.',
+            default: false,
+        }),
+        only: Flags.string({
+            description: 'Limit deploy/check/diff to a single workflow definition by name.',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Deploy);
+        validateModeFlags(flags.check, flags['dry-run']);
+        const config = loadWorkflowConfig(flags.tag);
+        const selected = await loadValidatedDefinitions(flags.only);
+        if (flags.check) {
+            this.log(`${logSymbols.success} ${selected.length} definition(s) passed validation (check only — dataset not contacted).`);
+            return;
+        }
+        const client = loadClient();
+        if (flags['dry-run']) {
+            await this.runDryRun(client, selected, config);
+            return;
+        }
+        await this.executeDeploy(client, selected, config);
+    }
+    async executeDeploy(client, defs, config) {
+        const spinner = ora(`Deploying ${defs.length} definition(s)…`).start();
+        try {
+            const { results } = await workflow.deployDefinitions({
+                workflowResource: config.workflowResource,
+                tag: config.tag,
+                client,
+                definitions: defs,
+            });
+            spinner.succeed(`Processed ${results.length} definition(s)`);
+            for (const line of deployResultLines(results))
+                this.log(line);
+        }
+        catch (error) {
+            spinner.fail('Deploy failed');
+            throw error;
+        }
+    }
+    async runDryRun(client, defs, config) {
+        const spinner = ora(`Diffing ${defs.length} definition(s) against dataset…`).start();
+        try {
+            const entries = await computeDiffEntries(client, defs, config);
+            spinner.succeed(`Diffed ${defs.length} definition(s)`);
+            for (const line of diffReport(entries))
+                this.log(line);
+        }
+        catch (error) {
+            spinner.fail('Diff failed');
+            throw error;
+        }
+    }
+}
+/** Reject the contradictory `--check --dry-run` combination. */
+export function validateModeFlags(check, dryRun) {
+    if (check && dryRun) {
+        fail('Pass either --check or --dry-run, not both.');
+    }
+}
+/** One line per deployed definition, symbol-tagged by its result status. */
+export function deployResultLines(results) {
+    const symbols = {
+        created: logSymbols.success,
+        updated: logSymbols.info,
+    };
+    return results.map((r) => {
+        const symbol = symbols[r.status] ?? logSymbols.warning;
+        return `  ${symbol} ${r.status.padEnd(9)} ${r.definition} v${r.version}`;
+    });
+}

package/dist/commands/diagnose.d.ts

@@ -0,0 +1,23 @@
+import { Command } from '@oclif/core';
+import { type Diagnosis, type DiagnoseInput, type SuggestedRemediation } from '@sanity/workflow-engine';
+/**
+ * The diagnosis body: the verdict line, the current stage's tasks +
+ * transitions as evidence (for any in-flight state), and the cause block with
+ * the engine's suggested fix when stuck. Pure so every verdict permutation is
+ * assertable without driving a live evaluation. Takes the engine's
+ * {@link SuggestedRemediation}s rather than re-deriving them, so the rendered
+ * fix block and the `--json` output stay one computation.
+ */
+export declare function renderDiagnosis(diagnosis: Diagnosis, input: DiagnoseInput, remediations: SuggestedRemediation[]): string[];
+export default class Diagnose extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        instanceId: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        tag: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/diagnose.js

@@ -0,0 +1,269 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { diagnoseInputFromEvaluation, workflow, } from '@sanity/workflow-engine';
+import boxen from 'boxen';
+import logSymbols from 'log-symbols';
+import pc from 'picocolors';
+import { loadClient } from "../lib/client.js";
+import { loadWorkflowConfig } from "../lib/config.js";
+import { fail } from "../lib/fail.js";
+import { tagFlags } from "../lib/flags.js";
+import { instanceHeader } from "./show.js";
+const TASK_ICON = {
+    done: pc.green(logSymbols.success),
+    active: pc.cyan('●'),
+    pending: pc.dim('○'),
+    failed: pc.red(logSymbols.error),
+    skipped: pc.dim('⊘'),
+};
+function formatAssignee(a) {
+    return a.type === 'user' ? `user:${a.id}` : `role:${a.role}`;
+}
+function taskLine(t, assignees) {
+    const who = assignees.length > 0 ? pc.dim(`  assigned → ${assignees.map(formatAssignee).join(', ')}`) : '';
+    return `  ${TASK_ICON[t.status]} ${t.task.name} ${pc.dim(`[${t.status}]`)}${who}`;
+}
+function transitionLine(tr) {
+    const mark = tr.filterSatisfied ? pc.green('ready') : pc.red('false');
+    return `  → ${tr.transition.to}  ${pc.dim(tr.transition.filter ?? 'true')}  ${mark}`;
+}
+function currentStageLines(input) {
+    const lines = [pc.bold(`stage: ${input.instance.currentStage}`), 'tasks:'];
+    for (const t of input.tasks) {
+        lines.push(taskLine(t, input.assignees[t.task.name] ?? []));
+    }
+    if (input.transitions.length > 0) {
+        lines.push('', 'exit transitions:');
+        for (const tr of input.transitions) {
+            lines.push(transitionLine(tr));
+        }
+    }
+    return lines;
+}
+function failedEffectDetail(effect) {
+    const ran = effect.durationMs !== undefined ? ` (after ${effect.durationMs}ms)` : '';
+    return {
+        headline: `a failed effect is blocking task '${effect.origin.name}'`,
+        why: [
+            pc.red(`${logSymbols.error} failed effect: ${effect.name}`),
+            `  queued by task '${effect.origin.name}', failed ${effect.ranAt}${ran}`,
+            ...(effect.error !== undefined ? [`  error: ${effect.error.message}`] : []),
+            '',
+            `Task '${effect.origin.name}' is waiting on this effect. It failed against an`,
+            `external system, so the task never completes and the stage can't advance.`,
+        ],
+    };
+}
+function hungEffectDetail(effect) {
+    return {
+        headline: `effect '${effect.name}' was claimed but never completed`,
+        why: [
+            pc.yellow(`${logSymbols.warning} hung effect: ${effect.name}`),
+            `  claimed ${effect.claim?.claimedAt ?? '?'} but never reported back — the`,
+            `  drainer likely died mid-dispatch, so it won't drain on its own.`,
+        ],
+    };
+}
+function failedTaskDetail(task) {
+    return {
+        headline: `task '${task}' failed`,
+        why: [
+            pc.red(`${logSymbols.error} task '${task}' is in a terminal failed state.`),
+            `Any exit transition gated on '${task}' being done can never fire.`,
+        ],
+    };
+}
+function waitingHeadline(w) {
+    const who = w.assignees.length > 0 ? ` on ${w.assignees.map(formatAssignee).join(', ')}` : '';
+    return `waiting${who} for action: ${w.actions.join(' or ')}`;
+}
+function waitingLines(w) {
+    const who = w.assignees.length > 0
+        ? `assigned to ${w.assignees.map(formatAssignee).join(', ')}`
+        : 'unassigned — anyone with permission can act';
+    return [
+        `${logSymbols.info} task '${w.task}' is active (${who}),`,
+        `waiting for action: ${w.actions.join(' or ')}. This is the normal in-flight`,
+        `state — it advances when someone acts.`,
+    ];
+}
+function blockedHeadline(b) {
+    const who = b.assignees.length > 0 ? ` for ${b.assignees.map(formatAssignee).join(', ')}` : '';
+    return `task '${b.task}'${who} is not yet ready — unmet requirement(s): ${b.requirements.join(', ')}`;
+}
+function blockedLines(b) {
+    const who = b.assignees.length > 0
+        ? `assigned to ${b.assignees.map(formatAssignee).join(', ')}`
+        : 'unassigned';
+    return [
+        `${logSymbols.info} task '${b.task}' is visible but not yet executable (${who}).`,
+        `Unmet requirement(s): ${b.requirements.join(', ')}. It can't be acted on until`,
+        `those preconditions are met — check what would satisfy them (a prerequisite`,
+        `task completing, required content landing). It will not advance on its own.`,
+    ];
+}
+function noTransitionDetail() {
+    return {
+        headline: `no exit transition's filter is satisfied`,
+        why: [
+            `${logSymbols.info} every task is resolved, but no exit transition's filter is true.`,
+            `Likely a routing state value a filter reads never got written.`,
+        ],
+    };
+}
+/** An unevaluable exit filter is a *recoverable* hold, not a dead end: it
+ *  clears itself once the operand becomes readable, and no engine verb
+ *  unsticks it (so the engine emits no remediation). The "what to do" —
+ *  make the operand readable — lives here in the why, since there is no
+ *  runnable fix to render. */
+function transitionUnevaluableDetail(transitions) {
+    return {
+        headline: `an exit transition's filter could not be evaluated`,
+        why: [
+            `${logSymbols.info} every task is resolved, but ${transitions.join(', ')} reads an operand`,
+            `that is missing or unreadable (GROQ null), so routing is held rather than`,
+            `falling through. Make the data the filter reads readable — publish the`,
+            `subject (or fill the field) — and the instance advances on its own; no`,
+            `move-stage needed.`,
+        ],
+    };
+}
+const REMEDIATION_LABEL = {
+    'retry-effect': 'retry-effect',
+    'drain-effects': 're-run the effect drainer',
+    'reset-task': 'reset-task',
+    'set-stage': 'move-stage',
+    abort: 'abort',
+};
+/** Render the engine's structured remediations as the "suggested fix" block.
+ *  An unavailable verb is dimmed and marked `(planned)` — describable but not
+ *  yet runnable from the CLI. */
+function remediationLines(remediations) {
+    return remediations.map((r) => {
+        const planned = r.available ? '' : pc.dim(' (planned)');
+        return `  • ${REMEDIATION_LABEL[r.verb]}${planned} — ${r.rationale}`;
+    });
+}
+function causeDetail(cause) {
+    switch (cause.kind) {
+        case 'failed-effect':
+            return failedEffectDetail(cause.effect);
+        case 'hung-effect':
+            return hungEffectDetail(cause.effect);
+        case 'failed-task':
+            return failedTaskDetail(cause.task);
+        case 'no-transition-fires':
+            return noTransitionDetail();
+        case 'transition-unevaluable':
+            return transitionUnevaluableDetail(cause.transitions);
+    }
+}
+function statusLine(diagnosis) {
+    switch (diagnosis.state) {
+        case 'progressing':
+            return `${logSymbols.success} ${pc.green('progressing')} — this instance will advance on its own.`;
+        case 'waiting':
+            return `${logSymbols.info} ${pc.cyan('waiting')} — ${waitingHeadline(diagnosis)}`;
+        case 'blocked':
+            return `${logSymbols.info} ${pc.cyan('blocked')} — ${blockedHeadline(diagnosis)}`;
+        case 'completed':
+            return `${logSymbols.success} ${pc.green('completed')} at ${diagnosis.at}.`;
+        case 'aborted': {
+            const tail = diagnosis.reason !== undefined ? ` — ${diagnosis.reason}` : '';
+            return `${logSymbols.info} ${pc.dim('aborted')} at ${diagnosis.at}${tail}.`;
+        }
+        case 'stuck':
+            return `${logSymbols.warning} ${pc.yellow('STUCK')} — ${causeDetail(diagnosis.cause).headline}`;
+    }
+}
+/**
+ * The diagnosis body: the verdict line, the current stage's tasks +
+ * transitions as evidence (for any in-flight state), and the cause block with
+ * the engine's suggested fix when stuck. Pure so every verdict permutation is
+ * assertable without driving a live evaluation. Takes the engine's
+ * {@link SuggestedRemediation}s rather than re-deriving them, so the rendered
+ * fix block and the `--json` output stay one computation.
+ */
+export function renderDiagnosis(diagnosis, input, remediations) {
+    const lines = [statusLine(diagnosis)];
+    const inFlight = diagnosis.state === 'progressing' ||
+        diagnosis.state === 'waiting' ||
+        diagnosis.state === 'blocked' ||
+        diagnosis.state === 'stuck';
+    if (inFlight) {
+        lines.push('', ...currentStageLines(input));
+    }
+    if (diagnosis.state === 'waiting') {
+        lines.push('', ...waitingLines(diagnosis));
+    }
+    if (diagnosis.state === 'blocked') {
+        lines.push('', ...blockedLines(diagnosis));
+    }
+    if (diagnosis.state === 'stuck') {
+        const detail = causeDetail(diagnosis.cause);
+        lines.push('', "why it's stuck:", ...detail.why);
+        // A recoverable hold (e.g. an unevaluable transition filter) has no
+        // runnable remediation — its "what to do" is in the why above, so skip
+        // the empty fix header rather than dangle it.
+        if (remediations.length > 0) {
+            lines.push('', 'suggested fix:', ...remediationLines(remediations));
+        }
+    }
+    return lines;
+}
+export default class Diagnose extends Command {
+    static description = "Explain why a workflow instance is or isn't progressing, and what would unstick it.";
+    static examples = [
+        '<%= config.bin %> diagnose wf-instance.abc123',
+        '<%= config.bin %> diagnose wf-instance.abc123 --tag prod',
+        '<%= config.bin %> diagnose wf-instance.abc123 --json',
+    ];
+    static args = {
+        instanceId: Args.string({ required: true, description: 'Workflow instance id.' }),
+    };
+    static flags = {
+        ...tagFlags,
+        json: Flags.boolean({
+            description: 'Emit the structured diagnosis as JSON instead of rendered output.',
+            default: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Diagnose);
+        const config = loadWorkflowConfig(flags.tag);
+        const client = loadClient();
+        const { evaluation, diagnosis, remediations } = await workflow
+            .diagnose({
+            client,
+            tag: config.tag,
+            workflowResource: config.workflowResource,
+            instanceId: args.instanceId,
+            // Token-auth CLI can't hit /users/me; pin the same system actor the
+            // write verbs use. Transition filters and task status are actor-
+            // independent. A requirement that reads $actor/$assigned/$can is the
+            // exception — it's evaluated against this system actor, so a `blocked`
+            // verdict on such a requirement reflects the engine's view, not a
+            // specific assignee's.
+            access: { actor: { kind: 'system', id: 'workflow-cli' } },
+        })
+            .catch((error) => fail('diagnose failed:', error instanceof Error ? error.message : String(error)));
+        const input = diagnoseInputFromEvaluation(evaluation);
+        if (flags.json) {
+            this.log(JSON.stringify({
+                instanceId: evaluation.instance._id,
+                stage: evaluation.instance.currentStage,
+                diagnosis,
+                remediations,
+            }, null, 2));
+            return;
+        }
+        this.log(boxen(instanceHeader(evaluation.instance), {
+            padding: 1,
+            borderStyle: 'round',
+            title: 'diagnose',
+        }));
+        this.log('');
+        for (const line of renderDiagnosis(diagnosis, input, remediations)) {
+            this.log(line);
+        }
+    }
+}

package/dist/commands/fire-action.d.ts

@@ -0,0 +1,63 @@
+import { Command } from '@oclif/core';
+import { type AvailableAction } from '@sanity/workflow-engine';
+import { type RanOp } from '../lib/ops-report.ts';
+/**
+ * Parse repeated `--param key=value` flags into a params object. Each
+ * value is JSON-parsed so numbers/booleans/objects type correctly,
+ * falling back to the raw string. The engine validates the result against
+ * the action's declared param types.
+ */
+export declare function parseParams(pairs: string[]): Record<string, unknown>;
+/**
+ * The list-mode body: every action on the current stage's tasks, marked
+ * fireable or not (with the disabling reason), plus a hint showing the
+ * flags to fire one. Pure so the populated/empty permutations assert
+ * without a live evaluation.
+ */
+export declare function renderAvailableActions(actions: AvailableAction[], stage: string, instanceId: string): string[];
+interface FireOutcome {
+    fired: boolean;
+    cascaded: number;
+    instance: {
+        currentStage: string;
+    };
+    ranOps?: RanOp[];
+}
+/** The `--json` payload for a fired action — the structured counterpart of
+ *  {@link fireActionReport}. Pure so its shape is asserted directly. */
+export declare function fireResultJson(result: FireOutcome, ids: {
+    instanceId: string;
+    task: string;
+    action: string;
+}): Record<string, unknown>;
+export interface FireActionReport {
+    fired: boolean;
+    message: string;
+    opsLines: string[];
+}
+/**
+ * Turn a `fireAction` result into the spinner message + ops block. Pure so
+ * the fired / no-op / cascaded / ops permutations assert without a live
+ * fire.
+ */
+export declare function fireActionReport(result: FireOutcome, task: string, action: string): FireActionReport;
+export default class FireAction extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        instanceId: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        task: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        action: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        param: import("@oclif/core/interfaces").OptionFlag<string[], import("@oclif/core/interfaces").CustomOptions>;
+        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>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        tag: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    private listActions;
+    private fireOne;
+}
+export {};