@outputai/cli 0.10.1-next.3d1f9bd.0 → 0.10.1-next.442c500.0

package/dist/commands/workflow/result.spec.js

@@ -1,10 +1,12 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-vi.mock('../../api/generated/api.js', () => ({
+vi.mock('#api/generated/api.js', () => ({
     getWorkflowIdResult: vi.fn()
 }));
 describe('workflow result command', () => {
     beforeEach(() => {
         vi.clearAllMocks();
+        process.exitCode = undefined;
     });
     describe('command definition', () => {
         it('should export a valid OCLIF command', async () => {
@@ -18,4 +20,66 @@ describe('workflow result command', () => {
             expect(WorkflowResult.enableJsonFlag).toBe(true);
         });
     });
+    describe('run()', () => {
+        const runCommand = async (data) => {
+            const WorkflowResult = (await import('./result.js')).default;
+            const { getWorkflowIdResult } = await import('#api/generated/api.js');
+            const cmd = new WorkflowResult(['wf-1'], {});
+            cmd.log = vi.fn();
+            cmd.parse = vi.fn().mockResolvedValue({ args: { workflowId: 'wf-1' } });
+            vi.mocked(getWorkflowIdResult).mockResolvedValue({
+                data,
+                status: 200,
+                headers: new Headers()
+            });
+            const result = await cmd.run();
+            return { cmd, result, getWorkflowIdResult };
+        };
+        it('returns and formats a legacy result', async () => {
+            const data = {
+                workflowId: 'wf-1',
+                runId: 'run-1',
+                status: 'failed',
+                input: {},
+                output: null,
+                trace: null,
+                error: 'Legacy failure',
+                errorDetails: null
+            };
+            const { cmd, result, getWorkflowIdResult } = await runCommand(data);
+            expect(getWorkflowIdResult).toHaveBeenCalledWith('wf-1');
+            expect(cmd.log).toHaveBeenCalledWith(expect.stringContaining('Error: Legacy failure'));
+            expect(result).toEqual(data);
+            expect(process.exitCode).toBe(1);
+        });
+        it('returns and formats a current result', async () => {
+            const data = {
+                v: '2',
+                workflowId: 'wf-1',
+                runId: 'run-1',
+                status: 'failed',
+                input: {},
+                output: null,
+                trace: null,
+                error: { name: 'ValidationError', message: 'Invalid input' }
+            };
+            const { result } = await runCommand(data);
+            expect(result).toEqual(data);
+            expect(process.exitCode).toBe(1);
+        });
+        it('sets a failure exit code for the previous canceled spelling', async () => {
+            const data = {
+                workflowId: 'wf-1',
+                runId: 'run-1',
+                status: 'canceled',
+                input: {},
+                output: null,
+                trace: null,
+                error: 'Workflow was canceled',
+                errorDetails: null
+            };
+            await runCommand(data);
+            expect(process.exitCode).toBe(1);
+        });
+    });
 });

package/dist/commands/workflow/run.js

@@ -1,6 +1,6 @@
 import { Args, Command, Flags } from '@oclif/core';
 import { postWorkflowRun } from '#api/generated/api.js';
-import { formatWorkflowResult, ERROR_STATUSES } from '#utils/format_workflow_result.js';
+import { formatWorkflowResult, isErrorStatus } from '#utils/format_workflow_result.js';
 import { handleApiError } from '#utils/error_handler.js';
 import { resolveInput } from '#utils/resolve_input.js';
 import { getRetryDelayFromResponse } from '#utils/header_utils.js';
@@ -63,7 +63,14 @@ export default class WorkflowRun extends Command {
     };
     async run() {
         const { args, flags } = await this.parse(WorkflowRun);
-        const input = await resolveInput(args.workflowName, args.scenario, flags.input, 'run', flags.catalog);
+        const input = await resolveInput({
+            workflowName: args.workflowName,
+            scenario: args.scenario,
+            inputFlag: flags.input,
+            commandName: 'run',
+            catalog: flags.catalog,
+            json: this.jsonEnabled()
+        });
         this.log(`Executing workflow: ${args.workflowName}...`);
         const response = await executeWorkflow({
             body: {
@@ -79,7 +86,7 @@ export default class WorkflowRun extends Command {
         }
         const data = response.data;
         this.log(`\n${formatWorkflowResult(data)}`);
-        if (ERROR_STATUSES.has(data.status)) {
+        if (isErrorStatus(data.status)) {
             process.exitCode = 1;
         }
         return data;

package/dist/commands/workflow/run.spec.js

@@ -59,12 +59,26 @@ describe('workflow run command', () => {
             const { cmd, postWorkflowRun, resolveInput } = await createCommand();
             resolveInput.mockResolvedValue({ key: 'value' });
             postWorkflowRun.mockResolvedValue({
-                data: { status: 'completed', result: { output: 'ok' } },
+                data: {
+                    v: '2',
+                    workflowId: 'wf-1',
+                    runId: 'run-1',
+                    status: 'completed',
+                    input: { key: 'value' },
+                    output: 'ok',
+                    trace: null,
+                    error: null
+                },
                 status: 200,
                 headers: new Headers()
             });
             await cmd.run();
-            expect(resolveInput).toHaveBeenCalledWith('my_workflow', undefined, undefined, 'run', undefined);
+            expect(resolveInput).toHaveBeenCalledWith(expect.objectContaining({
+                workflowName: 'my_workflow',
+                commandName: 'run',
+                catalog: undefined,
+                json: false
+            }));
             expect(postWorkflowRun).toHaveBeenCalledTimes(1);
             expect(postWorkflowRun).toHaveBeenCalledWith({ workflowName: 'my_workflow', input: { key: 'value' }, catalog: undefined }, expect.objectContaining({ config: { timeout: 600000 } }));
             expect(cmd.log).toHaveBeenCalledWith('Executing workflow: my_workflow...');
@@ -78,12 +92,26 @@ describe('workflow run command', () => {
             });
             resolveInput.mockResolvedValue({ key: 'value' });
             postWorkflowRun.mockResolvedValue({
-                data: { status: 'completed', result: {} },
+                data: {
+                    v: '2',
+                    workflowId: 'wf-1',
+                    runId: 'run-1',
+                    status: 'completed',
+                    input: { key: 'value' },
+                    output: {},
+                    trace: null,
+                    error: null
+                },
                 status: 200,
                 headers: new Headers()
             });
             await cmd.run();
-            expect(resolveInput).toHaveBeenCalledWith('my_workflow', 'basic', undefined, 'run', 'my-catalog');
+            expect(resolveInput).toHaveBeenCalledWith(expect.objectContaining({
+                workflowName: 'my_workflow',
+                scenario: 'basic',
+                commandName: 'run',
+                catalog: 'my-catalog'
+            }));
             expect(postWorkflowRun).toHaveBeenCalledWith(expect.objectContaining({ catalog: 'my-catalog' }), expect.anything());
         });
         it('retries when response has Retry-After and succeeds on second attempt', async () => {
@@ -93,7 +121,16 @@ describe('workflow run command', () => {
             postWorkflowRun
                 .mockRejectedValueOnce(new HttpError('Unavailable', { status: 503, headers }))
                 .mockResolvedValueOnce({
-                data: { status: 'completed', result: {} },
+                data: {
+                    v: '2',
+                    workflowId: 'wf-1',
+                    runId: 'run-1',
+                    status: 'completed',
+                    input: {},
+                    output: {},
+                    trace: null,
+                    error: null
+                },
                 status: 200,
                 headers: new Headers()
             });

package/dist/commands/workflow/start.d.ts

@@ -1,15 +1,21 @@
 import { Command } from '@oclif/core';
+import { type PostWorkflowStart200 } from '#api/generated/api.js';
 export default class WorkflowStart extends Command {
     static description: string;
+    static enableJsonFlag: boolean;
     static examples: string[];
     static args: {
         workflowName: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
         scenario: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
     };
     static flags: {
+        'include-payloads': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        interval: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        color: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         input: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         catalog: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        monitor: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
-    run(): Promise<void>;
+    run(): Promise<PostWorkflowStart200>;
     catch(error: Error): Promise<void>;
 }

package/dist/commands/workflow/start.js

@@ -1,14 +1,26 @@
 import { Args, Command, Flags } from '@oclif/core';
 import { postWorkflowStart } from '#api/generated/api.js';
-import { handleApiError } from '#utils/error_handler.js';
+import { commandStreamIo, monitorErrorOverrides, streamWorkflowUpdates } from '#services/monitor_stream.js';
+import { handleApiError, handleCommandError } from '#utils/error_handler.js';
+import { isErrorStatus } from '#utils/format_workflow_result.js';
+import { gatedMonitorStreamFlags, MONITOR_DEFAULTS } from '#utils/monitor_flags.js';
 import { resolveInput } from '#utils/resolve_input.js';
+/**
+ * Distinct from 1 (the workflow itself failed) and 2 (usage): the workflow was
+ * started and is still running, only the attached stream gave up. A caller that
+ * retries on exit 1 would otherwise re-submit a workflow that is already running.
+ */
+const MONITOR_FAILED_EXIT_CODE = 3;
 export default class WorkflowStart extends Command {
     static description = 'Start a workflow asynchronously without waiting for completion';
+    static enableJsonFlag = true;
     static examples = [
         '<%= config.bin %> <%= command.id %> simple basic_input',
         '<%= config.bin %> <%= command.id %> simple --input \'{"values":[1,2,3]}\'',
         '<%= config.bin %> <%= command.id %> simple --input input.json',
-        '<%= config.bin %> <%= command.id %> simple --input \'{"key":"value"}\' --catalog my-catalog'
+        '<%= config.bin %> <%= command.id %> simple --input input.json --monitor',
+        '<%= config.bin %> <%= command.id %> simple --input \'{"key":"value"}\' --catalog my-catalog',
+        '<%= config.bin %> <%= command.id %> simple --json'
     ];
     static args = {
         workflowName: Args.string({
@@ -33,11 +45,45 @@ export default class WorkflowStart extends Command {
             deprecateAliases: true,
             description: 'Catalog name for workflow execution (defaults to OUTPUT_CATALOG_ID)',
             env: 'OUTPUT_CATALOG_ID'
-        })
+        }),
+        // No `default: false`: a defaulted flag counts as present, so it would
+        // satisfy the `dependsOn` guard the three flags in `gatedMonitorStreamFlags`
+        // point at, letting `--interval` and friends be accepted (and then ignored)
+        // on a plain `workflow start`. Those three omit their own defaults for a
+        // different reason — see `gatedMonitorStreamFlags`.
+        //
+        // No `exclusive: [ 'json' ]` either: oclif's own rejection would fire first
+        // and print a bare "--json=true cannot also be provided", pre-empting the
+        // guard in `run()` that explains what to use instead. That guard covers both
+        // triggers (`--json` on argv, and `CONTENT_TYPE=json`) with one message.
+        monitor: Flags.boolean({
+            char: 'm',
+            description: 'After starting, attach and stream status updates until the workflow ends ' +
+                '(Ctrl+C detaches; the workflow keeps running). Cannot be combined with --json'
+        }),
+        ...gatedMonitorStreamFlags('monitor')
     };
     async run() {
         const { args, flags } = await this.parse(WorkflowStart);
-        const input = await resolveInput(args.workflowName, args.scenario, flags.input, 'start', flags.catalog);
+        // The built-in `--json` flag is injected by `enableJsonFlag`, and
+        // `CONTENT_TYPE=json` turns it on without it appearing on argv at all, so
+        // this runtime check — not an oclif flag relationship — is what catches
+        // every route into json mode. Streaming under `--json` is worse than
+        // useless: `Command.log()` is a no-op while json is enabled, so every update
+        // would be swallowed and the command would simply hang until the workflow
+        // ended.
+        if (flags.monitor && this.jsonEnabled()) {
+            this.error('Cannot combine --monitor with --json. Use "workflow run --json" to wait for the result, ' +
+                'or "workflow monitor <id> --format json" to stream newline-delimited JSON.', { exit: 2 });
+        }
+        const input = await resolveInput({
+            workflowName: args.workflowName,
+            scenario: args.scenario,
+            inputFlag: flags.input,
+            commandName: 'start',
+            catalog: flags.catalog,
+            json: this.jsonEnabled()
+        });
         this.log(`Starting workflow: ${args.workflowName}...`);
         const response = await postWorkflowStart({
             workflowName: args.workflowName,
@@ -48,18 +94,67 @@ export default class WorkflowStart extends Command {
             this.error('API returned invalid response', { exit: 1 });
         }
         const result = response.data;
-        const output = [
+        const started = [
             'Workflow started successfully',
             '',
-            `Workflow ID: ${result.workflowId || 'unknown'}`,
-            '',
-            `Use "workflow status ${result.workflowId || '<workflow-id>'}" to check the workflow status`,
-            `Use "workflow result ${result.workflowId || '<workflow-id>'}" to get the workflow result when complete`
-        ].join('\n');
-        this.log(`\n${output}`);
+            `Workflow ID: ${result.workflowId || 'unknown'}`
+        ];
+        if (!flags.monitor) {
+            this.log(`\n${[
+                ...started,
+                '',
+                `Use "workflow status ${result.workflowId || '<workflow-id>'}" to check the workflow status`,
+                `Use "workflow result ${result.workflowId || '<workflow-id>'}" to get the workflow result when complete`
+            ].join('\n')}`);
+            return result;
+        }
+        // Checked before the banner prints: "Workflow started successfully" followed
+        // immediately by a failure contradicts itself, and the `unknown` placeholder
+        // id it would show is not something the user can act on. Exit 3, not 1 — the
+        // start itself succeeded, so this is the "started but unmonitorable" case.
+        if (!result.workflowId) {
+            this.error('The workflow was started, but the API did not return a workflow ID, so it cannot be monitored. ' +
+                'Use "workflow runs list" to find it.', { exit: MONITOR_FAILED_EXIT_CODE });
+        }
+        this.log(`\n${started.join('\n')}`);
+        this.log('');
+        try {
+            const status = await streamWorkflowUpdates({
+                workflowId: result.workflowId,
+                // Pin to the run just started rather than letting the monitor resolve
+                // "latest run" — with a retry or a rapid re-start those can differ.
+                runId: result.runId ?? undefined,
+                includePayloads: flags['include-payloads'] ?? MONITOR_DEFAULTS.includePayloads,
+                interval: flags.interval ?? MONITOR_DEFAULTS.interval,
+                // Always text: monitoring under json mode is rejected above, so the
+                // NDJSON path is `workflow monitor --format json`.
+                json: false,
+                color: flags.color ?? MONITOR_DEFAULTS.color
+            }, commandStreamIo(this));
+            // Monitoring reports the workflow's *progress*; the return value still has
+            // to be fetched separately, so name the command that does it. A failed run
+            // has no result to fetch, so point at the one that explains the failure.
+            if (status) {
+                this.log(isErrorStatus(status) ?
+                    `\nUse "workflow debug ${result.workflowId}" to inspect the failure` :
+                    `\nUse "workflow result ${result.workflowId}" to get the workflow result`);
+            }
+        }
+        catch (error) {
+            // The workflow was started and is still running — only the stream gave up.
+            // Say so explicitly and exit on a code of its own, so this can't be read
+            // (by a human or by a CI job retrying on exit 1) as a failed start.
+            //
+            // `handleApiError`, not `handleCommandError`: an error the stream raised
+            // through `io.error` is already a CLIError, and passing it through would
+            // report it as a plain exit-1 failure rather than a live workflow.
+            handleApiError(error, message => this.error(`Workflow ${result.workflowId} started, but monitoring stopped:\n${message}\n` +
+                `The workflow is still running. Use "workflow status ${result.workflowId}" to check on it.`, { exit: MONITOR_FAILED_EXIT_CODE }), monitorErrorOverrides(error));
+        }
+        return result;
     }
     async catch(error) {
-        return handleApiError(error, (...args) => this.error(...args), {
+        return handleCommandError(error, (...args) => this.error(...args), {
             404: 'Workflow not found. Check the workflow name.'
         });
     }