@outputai/cli 0.1.2 → 0.1.3-dev.0

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

@@ -0,0 +1,23 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+vi.mock('../../api/generated/api.js', () => ({
+    getWorkflowIdResult: vi.fn()
+}));
+describe('workflow result command', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('command definition', () => {
+        it('should export a valid OCLIF command', async () => {
+            const WorkflowResult = (await import('./result.js')).default;
+            expect(WorkflowResult).toBeDefined();
+            expect(WorkflowResult.description).toContain('Get workflow execution result');
+            expect(WorkflowResult.args).toHaveProperty('workflowId');
+            expect(WorkflowResult.flags).toHaveProperty('format');
+        });
+        it('should have correct flag configuration', async () => {
+            const WorkflowResult = (await import('./result.js')).default;
+            expect(WorkflowResult.flags.format.options).toEqual(['json', 'text']);
+            expect(WorkflowResult.flags.format.default).toBe('text');
+        });
+    });
+});

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

@@ -0,0 +1,16 @@
+import { Command } from '@oclif/core';
+export default class WorkflowRun extends Command {
+    static description: string;
+    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: {
+        input: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'task-queue': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    catch(error: Error): Promise<void>;
+}

package/dist/commands/workflow/run.js

@@ -0,0 +1,97 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { postWorkflowRun } from '#api/generated/api.js';
+import { OUTPUT_FORMAT } from '#utils/constants.js';
+import { formatOutput } from '#utils/output_formatter.js';
+import { formatWorkflowResult, ERROR_STATUSES } 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';
+import { sleep } from '#utils/sleep.js';
+import { HttpError } from '#api/http_client.js';
+const MAX_RETRIES = 3;
+async function executeWorkflow(args) {
+    const { body, options, log, attempt = 0 } = args;
+    try {
+        return await postWorkflowRun(body, options);
+    }
+    catch (error) {
+        if (!(error instanceof HttpError) || attempt >= MAX_RETRIES) {
+            throw error;
+        }
+        const { response } = error;
+        const delay = getRetryDelayFromResponse(response);
+        if (delay === null) {
+            throw error;
+        }
+        log(`Server returned ${response.status} with header "Retry-After". Retrying in ${delay / 1000}s...`);
+        await sleep(delay);
+        return executeWorkflow({ body, options, log, attempt: attempt + 1 });
+    }
+}
+export default class WorkflowRun extends Command {
+    static description = 'Execute a workflow synchronously and wait for completion';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> simple basic_input',
+        '<%= config.bin %> <%= command.id %> simple my_scenario --format json',
+        '<%= 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"}\' --task-queue my-queue'
+    ];
+    static args = {
+        workflowName: Args.string({
+            description: 'Name of the workflow to execute',
+            required: true
+        }),
+        scenario: Args.string({
+            description: 'Scenario name (resolved from the workflow\'s scenarios/ directory)',
+            required: false
+        })
+    };
+    static flags = {
+        input: Flags.string({
+            char: 'i',
+            description: 'Workflow input as JSON string or file path (overrides scenario)',
+            required: false
+        }),
+        'task-queue': Flags.string({
+            char: 'q',
+            description: 'Task queue name for workflow execution'
+        }),
+        format: Flags.string({
+            char: 'f',
+            description: 'Output format',
+            options: [OUTPUT_FORMAT.JSON, OUTPUT_FORMAT.TEXT],
+            default: OUTPUT_FORMAT.TEXT
+        })
+    };
+    async run() {
+        const { args, flags } = await this.parse(WorkflowRun);
+        const input = await resolveInput(args.workflowName, args.scenario, flags.input, 'run');
+        this.log(`Executing workflow: ${args.workflowName}...`);
+        const response = await executeWorkflow({
+            body: {
+                workflowName: args.workflowName,
+                input,
+                taskQueue: flags['task-queue']
+            },
+            options: { config: { timeout: 600000 } },
+            log: msg => this.log(msg)
+        });
+        if (!response || !response.data) {
+            this.error('API returned invalid response', { exit: 1 });
+        }
+        const data = response.data;
+        const output = formatOutput(data, flags.format, formatWorkflowResult);
+        this.log(`\n${output}`);
+        if (ERROR_STATUSES.has(data.status)) {
+            process.exitCode = 1;
+        }
+    }
+    async catch(error) {
+        return handleApiError(error, (...args) => this.error(...args), {
+            404: 'Workflow not found. Check the workflow name.',
+            500: 'Workflow execution failed.',
+            503: 'Workflow service temporarily unavailable.'
+        });
+    }
+}

package/dist/commands/workflow/run.spec.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,110 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { HttpError } from '#api/http_client.js';
+vi.mock('#api/generated/api.js', () => ({
+    postWorkflowRun: vi.fn()
+}));
+vi.mock('#utils/resolve_input.js', () => ({
+    resolveInput: vi.fn()
+}));
+vi.mock('#utils/sleep.js', () => ({
+    sleep: vi.fn().mockResolvedValue(undefined)
+}));
+describe('workflow run command', () => {
+    beforeEach(async () => {
+        vi.clearAllMocks();
+        const { resolveInput } = await import('#utils/resolve_input.js');
+        const { sleep } = await import('#utils/sleep.js');
+        vi.mocked(resolveInput).mockResolvedValue({});
+        vi.mocked(sleep).mockResolvedValue(undefined);
+    });
+    describe('command definition', () => {
+        it('should export a valid OCLIF command', async () => {
+            const WorkflowRun = (await import('./run.js')).default;
+            expect(WorkflowRun).toBeDefined();
+            expect(WorkflowRun.description).toContain('Execute a workflow');
+            expect(WorkflowRun.args).toHaveProperty('workflowName');
+            expect(WorkflowRun.flags).toHaveProperty('input');
+            expect(WorkflowRun.flags).toHaveProperty('format');
+            expect(WorkflowRun.flags).toHaveProperty('task-queue');
+        });
+        it('should have correct flag configuration', async () => {
+            const WorkflowRun = (await import('./run.js')).default;
+            expect(WorkflowRun.flags.format.options).toEqual(['json', 'text']);
+            expect(WorkflowRun.flags.format.default).toBe('text');
+            expect(WorkflowRun.flags.input.required).toBe(false);
+        });
+        it('should have optional scenario argument', async () => {
+            const WorkflowRun = (await import('./run.js')).default;
+            expect(WorkflowRun.args).toHaveProperty('scenario');
+            expect(WorkflowRun.args.scenario.required).toBe(false);
+        });
+    });
+    describe('run()', () => {
+        const createCommand = async () => {
+            const WorkflowRun = (await import('./run.js')).default;
+            const { postWorkflowRun } = await import('#api/generated/api.js');
+            const { resolveInput } = await import('#utils/resolve_input.js');
+            const cmd = new WorkflowRun(['my_workflow'], {});
+            cmd.log = vi.fn();
+            cmd.error = vi.fn(() => {
+                throw new Error('error called');
+            });
+            cmd.parse = vi.fn().mockResolvedValue({
+                args: { workflowName: 'my_workflow', scenario: undefined },
+                flags: { input: undefined, 'task-queue': undefined, format: 'text' }
+            });
+            return { cmd, postWorkflowRun: vi.mocked(postWorkflowRun), resolveInput: vi.mocked(resolveInput) };
+        };
+        it('calls postWorkflowRun and logs output on success', async () => {
+            const { cmd, postWorkflowRun, resolveInput } = await createCommand();
+            resolveInput.mockResolvedValue({ key: 'value' });
+            postWorkflowRun.mockResolvedValue({
+                data: { status: 'completed', result: { output: 'ok' } },
+                status: 200,
+                headers: new Headers()
+            });
+            await cmd.run();
+            expect(postWorkflowRun).toHaveBeenCalledTimes(1);
+            expect(postWorkflowRun).toHaveBeenCalledWith({ workflowName: 'my_workflow', input: { key: 'value' }, taskQueue: undefined }, expect.objectContaining({ config: { timeout: 600000 } }));
+            expect(cmd.log).toHaveBeenCalledWith('Executing workflow: my_workflow...');
+            expect(cmd.log).toHaveBeenCalledWith(expect.stringMatching(/\n/));
+        });
+        it('retries when response has Retry-After and succeeds on second attempt', async () => {
+            const { cmd, postWorkflowRun, resolveInput } = await createCommand();
+            resolveInput.mockResolvedValue({});
+            const headers = new Headers({ 'Retry-After': '1' });
+            postWorkflowRun
+                .mockRejectedValueOnce(new HttpError('Unavailable', { status: 503, headers }))
+                .mockResolvedValueOnce({
+                data: { status: 'completed', result: {} },
+                status: 200,
+                headers: new Headers()
+            });
+            await cmd.run();
+            expect(postWorkflowRun).toHaveBeenCalledTimes(2);
+            expect(cmd.log).toHaveBeenCalledWith(expect.stringMatching(/Retry-After.*Retrying in/));
+        });
+        it('does not retry when response has no Retry-After and throws', async () => {
+            const { cmd, postWorkflowRun, resolveInput } = await createCommand();
+            resolveInput.mockResolvedValue({});
+            postWorkflowRun.mockRejectedValue(new HttpError('Unavailable', { status: 503, headers: new Headers() }));
+            await expect(cmd.run()).rejects.toThrow(HttpError);
+            expect(postWorkflowRun).toHaveBeenCalledTimes(1);
+        });
+        it('does not retry on non-503 error and throws', async () => {
+            const { cmd, postWorkflowRun, resolveInput } = await createCommand();
+            resolveInput.mockResolvedValue({});
+            postWorkflowRun.mockRejectedValue(new HttpError('Not found', { status: 404 }));
+            await expect(cmd.run()).rejects.toThrow(HttpError);
+            expect(postWorkflowRun).toHaveBeenCalledTimes(1);
+        });
+        it('calls error when API returns no data', async () => {
+            const { cmd, postWorkflowRun, resolveInput } = await createCommand();
+            resolveInput.mockResolvedValue({});
+            postWorkflowRun.mockResolvedValue({ data: undefined, status: 200, headers: new Headers() });
+            await expect(cmd.run()).rejects.toThrow('error called');
+            expect(cmd.error).toHaveBeenCalledWith('API returned invalid response', { exit: 1 });
+        });
+    });
+});

package/dist/commands/workflow/runs/list.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '@oclif/core';
+export default class WorkflowRunsList extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        workflowName: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        limit: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    catch(error: Error): Promise<void>;
+}

package/dist/commands/workflow/runs/list.js

@@ -0,0 +1,104 @@
+import { Args, Command, Flags } from '@oclif/core';
+import Table from 'cli-table3';
+import { fetchWorkflowRuns } from '#services/workflow_runs.js';
+import { formatDate, formatDurationFromTimestamps } from '#utils/date_formatter.js';
+import { handleApiError } from '#utils/error_handler.js';
+const OUTPUT_FORMAT = {
+    TABLE: 'table',
+    JSON: 'json',
+    TEXT: 'text'
+};
+function createRunsTable(runs) {
+    const table = new Table({
+        head: ['Workflow ID', 'Type', 'Status', 'Started', 'Duration'],
+        colWidths: [null, 20, 12, 22, 10],
+        wordWrap: true,
+        style: {
+            head: ['cyan']
+        }
+    });
+    runs.forEach(run => {
+        table.push([
+            run.workflowId || '-',
+            run.workflowType || '-',
+            run.status || '-',
+            formatDate(run.startedAt),
+            formatDurationFromTimestamps(run.startedAt || '', run.completedAt)
+        ]);
+    });
+    return table.toString();
+}
+function formatRunsAsText(runs) {
+    if (runs.length === 0) {
+        return 'No workflow runs found.';
+    }
+    return runs.map(run => {
+        const duration = formatDurationFromTimestamps(run.startedAt || '', run.completedAt);
+        return `${run.workflowId} (${run.workflowType}) - ${run.status} [${duration}]`;
+    }).join('\n');
+}
+function formatRunsAsJson(runs) {
+    return JSON.stringify(runs, null, 2);
+}
+function formatRuns(runs, format) {
+    if (format === OUTPUT_FORMAT.JSON) {
+        return formatRunsAsJson(runs);
+    }
+    if (format === OUTPUT_FORMAT.TABLE) {
+        return createRunsTable(runs);
+    }
+    return formatRunsAsText(runs);
+}
+export default class WorkflowRunsList extends Command {
+    static description = 'List workflow runs with optional filtering by workflow type';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> simple',
+        '<%= config.bin %> <%= command.id %> simple --limit 10',
+        '<%= config.bin %> <%= command.id %> --format json',
+        '<%= config.bin %> <%= command.id %> --format table'
+    ];
+    static args = {
+        workflowName: Args.string({
+            description: 'Filter by workflow type/name',
+            required: false
+        })
+    };
+    static flags = {
+        limit: Flags.integer({
+            char: 'l',
+            description: 'Maximum number of runs to return',
+            default: 100
+        }),
+        format: Flags.string({
+            char: 'f',
+            description: 'Output format',
+            options: [OUTPUT_FORMAT.TABLE, OUTPUT_FORMAT.JSON, OUTPUT_FORMAT.TEXT],
+            default: OUTPUT_FORMAT.TABLE
+        })
+    };
+    async run() {
+        const { args, flags } = await this.parse(WorkflowRunsList);
+        const { runs, count } = await fetchWorkflowRuns({
+            workflowType: args.workflowName,
+            limit: flags.limit
+        });
+        if (runs.length === 0) {
+            const filterMsg = args.workflowName ? ` for workflow type "${args.workflowName}"` : '';
+            this.log(`No workflow runs found${filterMsg}.`);
+            return;
+        }
+        const output = formatRuns(runs, flags.format);
+        this.log(output);
+        if (flags.format !== OUTPUT_FORMAT.JSON) {
+            const filterMsg = args.workflowName ? ` of type "${args.workflowName}"` : '';
+            this.log(`\nFound ${count} run(s)${filterMsg}`);
+        }
+    }
+    async catch(error) {
+        return handleApiError(error, (...args) => this.error(...args), {
+            400: 'Invalid parameters provided.',
+            503: 'Workflow service temporarily unavailable.'
+        });
+    }
+}

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

@@ -0,0 +1,15 @@
+import { Command } from '@oclif/core';
+export default class WorkflowStart extends Command {
+    static description: string;
+    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: {
+        input: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'task-queue': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    catch(error: Error): Promise<void>;
+}

package/dist/commands/workflow/start.js

@@ -0,0 +1,62 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { postWorkflowStart } from '#api/generated/api.js';
+import { handleApiError } from '#utils/error_handler.js';
+import { resolveInput } from '#utils/resolve_input.js';
+export default class WorkflowStart extends Command {
+    static description = 'Start a workflow asynchronously without waiting for completion';
+    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"}\' --task-queue my-queue'
+    ];
+    static args = {
+        workflowName: Args.string({
+            description: 'Name of the workflow to start',
+            required: true
+        }),
+        scenario: Args.string({
+            description: 'Scenario name (resolved from the workflow\'s scenarios/ directory)',
+            required: false
+        })
+    };
+    static flags = {
+        input: Flags.string({
+            char: 'i',
+            description: 'Workflow input as JSON string or file path (overrides scenario)',
+            required: false
+        }),
+        'task-queue': Flags.string({
+            char: 'q',
+            description: 'Task queue name for workflow execution'
+        })
+    };
+    async run() {
+        const { args, flags } = await this.parse(WorkflowStart);
+        const input = await resolveInput(args.workflowName, args.scenario, flags.input, 'start');
+        this.log(`Starting workflow: ${args.workflowName}...`);
+        const response = await postWorkflowStart({
+            workflowName: args.workflowName,
+            input,
+            taskQueue: flags['task-queue']
+        });
+        if (!response || !response.data) {
+            this.error('API returned invalid response', { exit: 1 });
+        }
+        const result = response.data;
+        const output = [
+            '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}`);
+    }
+    async catch(error) {
+        return handleApiError(error, (...args) => this.error(...args), {
+            404: 'Workflow not found. Check the workflow name.'
+        });
+    }
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,28 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+vi.mock('../../api/generated/api.js', () => ({
+    postWorkflowStart: vi.fn()
+}));
+describe('workflow start command', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('command definition', () => {
+        it('should export a valid OCLIF command', async () => {
+            const WorkflowStart = (await import('./start.js')).default;
+            expect(WorkflowStart).toBeDefined();
+            expect(WorkflowStart.description).toContain('Start a workflow');
+            expect(WorkflowStart.args).toHaveProperty('workflowName');
+            expect(WorkflowStart.flags).toHaveProperty('input');
+            expect(WorkflowStart.flags).toHaveProperty('task-queue');
+        });
+        it('should have correct flag configuration', async () => {
+            const WorkflowStart = (await import('./start.js')).default;
+            expect(WorkflowStart.flags.input.required).toBe(false);
+        });
+        it('should have optional scenario argument', async () => {
+            const WorkflowStart = (await import('./start.js')).default;
+            expect(WorkflowStart.args).toHaveProperty('scenario');
+            expect(WorkflowStart.args.scenario.required).toBe(false);
+        });
+    });
+});

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

@@ -0,0 +1,13 @@
+import { Command } from '@oclif/core';
+export default class WorkflowStatus extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        workflowId: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    catch(error: Error): Promise<void>;
+}

package/dist/commands/workflow/status.js

@@ -0,0 +1,57 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { getWorkflowIdStatus } from '#api/generated/api.js';
+import { OUTPUT_FORMAT } from '#utils/constants.js';
+import { formatOutput } from '#utils/output_formatter.js';
+import { handleApiError } from '#utils/error_handler.js';
+export default class WorkflowStatus extends Command {
+    static description = 'Get workflow execution status';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> wf-12345',
+        '<%= config.bin %> <%= command.id %> wf-12345 --format json'
+    ];
+    static args = {
+        workflowId: Args.string({
+            description: 'The workflow ID to check status for',
+            required: true
+        })
+    };
+    static flags = {
+        format: Flags.string({
+            char: 'f',
+            description: 'Output format',
+            options: [OUTPUT_FORMAT.JSON, OUTPUT_FORMAT.TEXT],
+            default: OUTPUT_FORMAT.TEXT
+        })
+    };
+    async run() {
+        const { args, flags } = await this.parse(WorkflowStatus);
+        this.log(`Fetching status for workflow: ${args.workflowId}...`);
+        const response = await getWorkflowIdStatus(args.workflowId);
+        if (!response || !response.data) {
+            this.error('API returned invalid response', { exit: 1 });
+        }
+        const data = response.data;
+        const output = formatOutput(data, flags.format, (result) => {
+            const lines = [
+                `Workflow ID: ${result.workflowId || 'unknown'}`,
+                `Status: ${result.status || 'unknown'}`,
+                ''
+            ];
+            if (result.startedAt) {
+                const startDate = new Date(result.startedAt);
+                lines.push(`Started At: ${startDate.toISOString()}`);
+            }
+            if (result.completedAt) {
+                const completedDate = new Date(result.completedAt);
+                lines.push(`Completed At: ${completedDate.toISOString()}`);
+            }
+            return lines.join('\n');
+        });
+        this.log(`\n${output}`);
+    }
+    async catch(error) {
+        return handleApiError(error, (...args) => this.error(...args), {
+            404: 'Workflow not found. Check the workflow ID.'
+        });
+    }
+}

package/dist/commands/workflow/status.spec.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,33 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+vi.mock('../../api/generated/api.js', () => ({
+    getWorkflowIdStatus: vi.fn(),
+    GetWorkflowIdStatus200Status: {
+        canceled: 'canceled',
+        completed: 'completed',
+        continued_as_new: 'continued_as_new',
+        failed: 'failed',
+        running: 'running',
+        terminated: 'terminated',
+        timed_out: 'timed_out',
+        unspecified: 'unspecified'
+    }
+}));
+describe('workflow status command', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('command definition', () => {
+        it('should export a valid OCLIF command', async () => {
+            const WorkflowStatus = (await import('./status.js')).default;
+            expect(WorkflowStatus).toBeDefined();
+            expect(WorkflowStatus.description).toContain('Get workflow execution status');
+            expect(WorkflowStatus.args).toHaveProperty('workflowId');
+            expect(WorkflowStatus.flags).toHaveProperty('format');
+        });
+        it('should have correct flag configuration', async () => {
+            const WorkflowStatus = (await import('./status.js')).default;
+            expect(WorkflowStatus.flags.format.options).toEqual(['json', 'text']);
+            expect(WorkflowStatus.flags.format.default).toBe('text');
+        });
+    });
+});

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

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export default class WorkflowStop extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        workflowId: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+    catch(error: Error): Promise<void>;
+}

package/dist/commands/workflow/stop.js

@@ -0,0 +1,31 @@
+import { Args, Command } from '@oclif/core';
+import { patchWorkflowIdStop } from '#api/generated/api.js';
+import { handleApiError } from '#utils/error_handler.js';
+export default class WorkflowStop extends Command {
+    static description = 'Stop a workflow execution';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> wf-12345'
+    ];
+    static args = {
+        workflowId: Args.string({
+            description: 'The workflow ID to stop',
+            required: true
+        })
+    };
+    async run() {
+        const { args } = await this.parse(WorkflowStop);
+        this.log(`Stopping workflow: ${args.workflowId}...`);
+        await patchWorkflowIdStop(args.workflowId);
+        const output = [
+            'Workflow stopped successfully',
+            '',
+            `Workflow ID: ${args.workflowId}`
+        ].join('\n');
+        this.log(`\n${output}`);
+    }
+    async catch(error) {
+        return handleApiError(error, (...args) => this.error(...args), {
+            404: 'Workflow not found. Check the workflow ID.'
+        });
+    }
+}

package/dist/commands/workflow/stop.spec.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,17 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+vi.mock('../../api/generated/api.js', () => ({
+    patchWorkflowIdStop: vi.fn()
+}));
+describe('workflow stop command', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('command definition', () => {
+        it('should export a valid OCLIF command', async () => {
+            const WorkflowStop = (await import('./stop.js')).default;
+            expect(WorkflowStop).toBeDefined();
+            expect(WorkflowStop.description).toContain('Stop a workflow execution');
+            expect(WorkflowStop.args).toHaveProperty('workflowId');
+        });
+    });
+});