@outputai/cli 0.8.2-next.e1cd79b.0 → 0.8.2-next.e658cc2.0

package/dist/api/generated/api.d.ts

@@ -452,6 +452,26 @@ export type GetWorkflowIdRunsRidHistory200 = {
     /** @nullable */
     nextPageToken?: string | null;
 };
+export type GetWorkflowIdHistoryStreamParams = {
+    /**
+     * Include decoded input/output payloads in events
+     */
+    includePayloads?: boolean;
+    /**
+     * Resume from this event ID (alternative to Last-Event-ID header)
+     */
+    lastEventId?: number;
+};
+export type GetWorkflowIdRunsRidHistoryStreamParams = {
+    /**
+     * Include decoded input/output payloads in events
+     */
+    includePayloads?: boolean;
+    /**
+     * Resume from this event ID (alternative to Last-Event-ID header)
+     */
+    lastEventId?: number;
+};
 export type GetWorkflowCatalogId200 = {
     /** Each workflow available in this catalog */
     workflows?: Workflow[];
@@ -1043,6 +1063,65 @@ export type getWorkflowIdRunsRidHistoryResponseError = (getWorkflowIdRunsRidHist
 export type getWorkflowIdRunsRidHistoryResponse = (getWorkflowIdRunsRidHistoryResponseSuccess | getWorkflowIdRunsRidHistoryResponseError);
 export declare const getGetWorkflowIdRunsRidHistoryUrl: (id: string, rid: string, params?: GetWorkflowIdRunsRidHistoryParams) => string;
 export declare const getWorkflowIdRunsRidHistory: (id: string, rid: string, params?: GetWorkflowIdRunsRidHistoryParams, options?: ApiRequestOptions) => Promise<getWorkflowIdRunsRidHistoryResponse>;
+/**
+ * Opens a persistent SSE connection that delivers Temporal workflow history events in real time. Emits named events: `workflow` (metadata, once), `history` (event batches), `done` (terminal state), `server_error` (post-flush errors). The `done` event carries `{ reason, newRunId? }` where `reason` is the terminal Temporal event type (`WORKFLOW_EXECUTION_COMPLETED`, `WORKFLOW_EXECUTION_FAILED`, `WORKFLOW_EXECUTION_TIMED_OUT`, `WORKFLOW_EXECUTION_CANCELED`, `WORKFLOW_EXECUTION_TERMINATED`, `WORKFLOW_EXECUTION_CONTINUED_AS_NEW`) and `newRunId` is present only when the terminal event chains a follow-on run. `server_error` carries `{ error, message, workflowId, runId }`. Errors before the stream opens are returned as JSON HTTP responses (400/404); once open, failures arrive as a `server_error` event. Supports reconnect via `Last-Event-ID` header or `lastEventId` query param.
+
+ * @summary Stream workflow history events via Server-Sent Events
+ */
+export type getWorkflowIdHistoryStreamResponse200 = {
+    data: string;
+    status: 200;
+};
+export type getWorkflowIdHistoryStreamResponse400 = {
+    data: BadRequestResponse;
+    status: 400;
+};
+export type getWorkflowIdHistoryStreamResponse404 = {
+    data: NotFoundResponse;
+    status: 404;
+};
+export type getWorkflowIdHistoryStreamResponse500 = {
+    data: InternalServerErrorResponse;
+    status: 500;
+};
+export type getWorkflowIdHistoryStreamResponseSuccess = (getWorkflowIdHistoryStreamResponse200) & {
+    headers: Headers;
+};
+export type getWorkflowIdHistoryStreamResponseError = (getWorkflowIdHistoryStreamResponse400 | getWorkflowIdHistoryStreamResponse404 | getWorkflowIdHistoryStreamResponse500) & {
+    headers: Headers;
+};
+export type getWorkflowIdHistoryStreamResponse = (getWorkflowIdHistoryStreamResponseSuccess | getWorkflowIdHistoryStreamResponseError);
+export declare const getGetWorkflowIdHistoryStreamUrl: (id: string, params?: GetWorkflowIdHistoryStreamParams) => string;
+export declare const getWorkflowIdHistoryStream: (id: string, params?: GetWorkflowIdHistoryStreamParams, options?: ApiRequestOptions) => Promise<getWorkflowIdHistoryStreamResponse>;
+/**
+ * Same as /workflow/{id}/history/stream but targets a specific run ID.
+ * @summary Stream pinned-run workflow history events via Server-Sent Events
+ */
+export type getWorkflowIdRunsRidHistoryStreamResponse200 = {
+    data: string;
+    status: 200;
+};
+export type getWorkflowIdRunsRidHistoryStreamResponse400 = {
+    data: BadRequestResponse;
+    status: 400;
+};
+export type getWorkflowIdRunsRidHistoryStreamResponse404 = {
+    data: NotFoundResponse;
+    status: 404;
+};
+export type getWorkflowIdRunsRidHistoryStreamResponse500 = {
+    data: InternalServerErrorResponse;
+    status: 500;
+};
+export type getWorkflowIdRunsRidHistoryStreamResponseSuccess = (getWorkflowIdRunsRidHistoryStreamResponse200) & {
+    headers: Headers;
+};
+export type getWorkflowIdRunsRidHistoryStreamResponseError = (getWorkflowIdRunsRidHistoryStreamResponse400 | getWorkflowIdRunsRidHistoryStreamResponse404 | getWorkflowIdRunsRidHistoryStreamResponse500) & {
+    headers: Headers;
+};
+export type getWorkflowIdRunsRidHistoryStreamResponse = (getWorkflowIdRunsRidHistoryStreamResponseSuccess | getWorkflowIdRunsRidHistoryStreamResponseError);
+export declare const getGetWorkflowIdRunsRidHistoryStreamUrl: (id: string, rid: string, params?: GetWorkflowIdRunsRidHistoryStreamParams) => string;
+export declare const getWorkflowIdRunsRidHistoryStream: (id: string, rid: string, params?: GetWorkflowIdRunsRidHistoryStreamParams, options?: ApiRequestOptions) => Promise<getWorkflowIdRunsRidHistoryStreamResponse>;
 /**
  * @summary Get a specific workflow catalog by ID
  */

package/dist/api/generated/api.js

@@ -231,6 +231,38 @@ export const getWorkflowIdRunsRidHistory = async (id, rid, params, options) => {
         method: 'GET'
     });
 };
+export const getGetWorkflowIdHistoryStreamUrl = (id, params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? 'null' : value.toString());
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0 ? `/workflow/${id}/history/stream?${stringifiedParams}` : `/workflow/${id}/history/stream`;
+};
+export const getWorkflowIdHistoryStream = async (id, params, options) => {
+    return customFetchInstance(getGetWorkflowIdHistoryStreamUrl(id, params), {
+        ...options,
+        method: 'GET'
+    });
+};
+export const getGetWorkflowIdRunsRidHistoryStreamUrl = (id, rid, params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? 'null' : value.toString());
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0 ? `/workflow/${id}/runs/${rid}/history/stream?${stringifiedParams}` : `/workflow/${id}/runs/${rid}/history/stream`;
+};
+export const getWorkflowIdRunsRidHistoryStream = async (id, rid, params, options) => {
+    return customFetchInstance(getGetWorkflowIdRunsRidHistoryStreamUrl(id, rid, params), {
+        ...options,
+        method: 'GET'
+    });
+};
 export const getGetWorkflowCatalogIdUrl = (id) => {
     return `/workflow/catalog/${id}`;
 };

package/dist/assets/docker/docker-compose-dev.yml

@@ -80,7 +80,7 @@ services:
         condition: service_healthy
       worker:
         condition: service_healthy
-    image: outputai/api:${OUTPUT_API_VERSION:-0.8.2-next.e1cd79b.0}
+    image: outputai/api:${OUTPUT_API_VERSION:-0.8.2-next.e658cc2.0}
     init: true
     networks:
       - main

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

@@ -1,16 +1,17 @@
 import { Command } from '@oclif/core';
+import type { CostReport } from '#types/cost.js';
 export default class WorkflowCost extends Command {
     static description: string;
+    static enableJsonFlag: boolean;
     static examples: string[];
     static args: {
         workflowId: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
         tracePath: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
     };
     static flags: {
-        format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
-    run(): Promise<void>;
+    run(): Promise<CostReport>;
     private loadLocalTrace;
     catch(error: Error): Promise<void>;
 }

package/dist/commands/workflow/cost.js

@@ -2,18 +2,17 @@ import { Args, Command, Flags } from '@oclif/core';
 import { readFile } from 'node:fs/promises';
 import { calculateCost, loadPricingConfig } from '#services/cost_calculator.js';
 import { getTrace } from '#services/trace_reader.js';
-import { OUTPUT_FORMAT } from '#utils/constants.js';
 import { formatCostReport } from '#utils/cost_formatter.js';
 import { getErrorCode } from '#utils/error_utils.js';
 import { handleApiError } from '#utils/error_handler.js';
-import { formatOutput } from '#utils/output_formatter.js';
 export default class WorkflowCost extends Command {
     static description = 'Calculate the cost of a workflow execution';
+    static enableJsonFlag = true;
     static examples = [
         '<%= config.bin %> <%= command.id %> my_workflow_id',
         '<%= config.bin %> <%= command.id %> my_workflow_id --verbose',
         '<%= config.bin %> <%= command.id %> my_workflow_id path/to/trace.json',
-        '<%= config.bin %> <%= command.id %> my_workflow_id --format json'
+        '<%= config.bin %> <%= command.id %> my_workflow_id --json'
     ];
     static args = {
         workflowId: Args.string({
@@ -26,12 +25,6 @@ export default class WorkflowCost extends Command {
         })
     };
     static flags = {
-        format: Flags.string({
-            char: 'f',
-            description: 'Output format',
-            options: [OUTPUT_FORMAT.JSON, OUTPUT_FORMAT.TEXT],
-            default: OUTPUT_FORMAT.TEXT
-        }),
         verbose: Flags.boolean({
             description: 'Show detailed per-call breakdown',
             default: false
@@ -45,8 +38,8 @@ export default class WorkflowCost extends Command {
         const config = loadPricingConfig();
         const traceNode = traceData;
         const report = calculateCost(traceNode, config, traceFile);
-        const formatted = formatOutput(report, flags.format, r => formatCostReport(r, { verbose: flags.verbose }));
-        this.log(formatted);
+        this.log(formatCostReport(report, { verbose: flags.verbose }));
+        return report;
     }
     async loadLocalTrace(tracePath) {
         try {

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

@@ -20,7 +20,6 @@ describe('workflow cost command', () => {
             expect(WorkflowCost).toBeDefined();
             expect(WorkflowCost.description).toBeDefined();
             expect(WorkflowCost.args).toHaveProperty('workflowId');
-            expect(WorkflowCost.flags).toHaveProperty('format');
             expect(WorkflowCost.flags).toHaveProperty('verbose');
         });
         it('should have workflowId as required arg', async () => {
@@ -34,8 +33,7 @@ describe('workflow cost command', () => {
         });
         it('should have correct flag configuration', async () => {
             const WorkflowCost = (await import('./cost.js')).default;
-            expect(WorkflowCost.flags.format.options).toEqual(['json', 'text']);
-            expect(WorkflowCost.flags.format.default).toBe('text');
+            expect(WorkflowCost.enableJsonFlag).toBe(true);
             expect(WorkflowCost.flags.verbose.default).toBe(false);
         });
         it('should have correct examples', async () => {

package/dist/commands/workflow/dataset/generate.d.ts

@@ -7,6 +7,7 @@ export default class DatasetGenerate extends Command {
         scenario: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
     };
     static flags: {
+        catalog: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         trace: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         download: import("@oclif/core/interfaces").BooleanFlag<boolean>;

package/dist/commands/workflow/dataset/generate.js

@@ -26,6 +26,14 @@ export default class DatasetGenerate extends Command {
         })
     };
     static flags = {
+        catalog: Flags.string({
+            char: 'c',
+            aliases: ['task-queue'],
+            charAliases: ['q'],
+            deprecateAliases: true,
+            description: 'Catalog name for workflow execution (defaults to OUTPUT_CATALOG_ID)',
+            env: 'OUTPUT_CATALOG_ID'
+        }),
         trace: Flags.string({
             char: 't',
             description: 'Path to a local trace file to extract dataset from',
@@ -61,15 +69,16 @@ export default class DatasetGenerate extends Command {
             await this.generateFromTrace(args.workflowName, flags.trace, flags.name);
             return;
         }
-        await this.generateFromScenario(args.workflowName, args.scenario, flags.input, flags.name);
+        await this.generateFromScenario(args.workflowName, args.scenario, flags.input, flags.name, flags.catalog);
     }
-    async generateFromScenario(workflowName, scenario, inputFlag, nameOverride) {
-        const resolvedInput = await this.resolveScenarioInput(workflowName, scenario, inputFlag);
+    async generateFromScenario(workflowName, scenario, inputFlag, nameOverride, catalog) {
+        const resolvedInput = await this.resolveScenarioInput(workflowName, scenario, inputFlag, catalog);
         const datasetName = nameOverride ?? scenario ?? 'dataset';
         this.log(`Running workflow "${workflowName}"...`);
         const response = await postWorkflowRun({
             workflowName,
-            input: resolvedInput
+            input: resolvedInput,
+            catalog
         }, {
             config: { timeout: 600000 }
         });
@@ -116,7 +125,7 @@ export default class DatasetGenerate extends Command {
         }
         this.log(`\nGenerated ${traces.length} dataset(s)`);
     }
-    async resolveScenarioInput(workflowName, scenario, inputFlag) {
+    async resolveScenarioInput(workflowName, scenario, inputFlag, catalog) {
         if (inputFlag && scenario) {
             return ux.error('Cannot use both scenario argument and --input flag. Choose one.', { exit: 1 });
         }
@@ -124,7 +133,7 @@ export default class DatasetGenerate extends Command {
             return parseInputFlag(inputFlag);
         }
         if (scenario) {
-            const resolution = await resolveScenarioPath(workflowName, scenario);
+            const resolution = await resolveScenarioPath(workflowName, scenario, undefined, undefined, catalog);
             if (!resolution.found) {
                 return ux.error(getScenarioNotFoundMessage(workflowName, scenario, resolution.searchedPaths), { exit: 1 });
             }

package/dist/commands/workflow/dataset/generate.spec.d.ts

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

package/dist/commands/workflow/dataset/generate.spec.js

@@ -0,0 +1,69 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+vi.mock('#api/generated/api.js', () => ({
+    postWorkflowRun: vi.fn()
+}));
+vi.mock('#utils/scenario_resolver.js', () => ({
+    resolveScenarioPath: vi.fn(),
+    getScenarioNotFoundMessage: vi.fn().mockReturnValue('not found')
+}));
+vi.mock('#utils/input_parser.js', () => ({
+    parseInputFlag: vi.fn()
+}));
+vi.mock('#services/datasets.js', () => ({
+    writeDataset: vi.fn(),
+    resolveDefaultDatasetsDir: vi.fn().mockResolvedValue('/datasets'),
+    buildDataset: vi.fn().mockReturnValue({ name: 'basic' }),
+    getExecutionTime: vi.fn().mockResolvedValue(100),
+    extractDatasetName: vi.fn()
+}));
+describe('workflow dataset generate command', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        delete process.env.OUTPUT_CATALOG_ID;
+    });
+    describe('command definition', () => {
+        it('binds the catalog flag to OUTPUT_CATALOG_ID', async () => {
+            const DatasetGenerate = (await import('./generate.js')).default;
+            expect(DatasetGenerate.flags).toHaveProperty('catalog');
+            expect(DatasetGenerate.flags.catalog.env).toBe('OUTPUT_CATALOG_ID');
+            expect(DatasetGenerate.flags.catalog.char).toBe('c');
+        });
+    });
+    describe('run()', () => {
+        const createCommand = async (flagOverrides = {}) => {
+            const DatasetGenerate = (await import('./generate.js')).default;
+            const { postWorkflowRun } = await import('#api/generated/api.js');
+            const { resolveScenarioPath } = await import('#utils/scenario_resolver.js');
+            const { parseInputFlag } = await import('#utils/input_parser.js');
+            const cmd = new DatasetGenerate(['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: 'basic' },
+                flags: { catalog: undefined, trace: undefined, name: undefined, download: false, limit: 5, input: undefined, ...flagOverrides }
+            });
+            return {
+                cmd,
+                postWorkflowRun: vi.mocked(postWorkflowRun),
+                resolveScenarioPath: vi.mocked(resolveScenarioPath),
+                parseInputFlag: vi.mocked(parseInputFlag)
+            };
+        };
+        it('resolves the scenario and runs the workflow against the resolved catalog', async () => {
+            const { cmd, postWorkflowRun, resolveScenarioPath, parseInputFlag } = await createCommand({ catalog: 'my-catalog' });
+            resolveScenarioPath.mockResolvedValue({ found: true, path: '/scenarios/basic.json', searchedPaths: [] });
+            parseInputFlag.mockResolvedValue({ foo: 'bar' });
+            postWorkflowRun.mockResolvedValue({
+                data: { workflowId: 'wf-1', output: { ok: true } },
+                status: 200,
+                headers: new Headers()
+            });
+            await cmd.run();
+            expect(resolveScenarioPath).toHaveBeenCalledWith('my_workflow', 'basic', undefined, undefined, 'my-catalog');
+            expect(postWorkflowRun).toHaveBeenCalledWith(expect.objectContaining({ workflowName: 'my_workflow', catalog: 'my-catalog' }), expect.anything());
+        });
+    });
+});

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

@@ -1,6 +1,8 @@
 import { Command } from '@oclif/core';
+import type { DatasetInfo } from '#services/datasets.js';
 export default class DatasetList extends Command {
     static description: string;
+    static enableJsonFlag: boolean;
     static examples: string[];
     static args: {
         workflowName: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
@@ -8,5 +10,5 @@ export default class DatasetList extends Command {
     static flags: {
         format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
     };
-    run(): Promise<void>;
+    run(): Promise<DatasetInfo[]>;
 }

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

@@ -3,7 +3,6 @@ import Table from 'cli-table3';
 import { listDatasets } from '#services/datasets.js';
 const OutputFormat = {
     TABLE: 'table',
-    JSON: 'json',
     TEXT: 'text'
 };
 function createDatasetsTable(datasets) {
@@ -37,13 +36,7 @@ function formatDatasetsAsText(datasets) {
         return `${dataset.name} ${cached}${outputDate}${evalDate}`;
     }).join('\n');
 }
-function formatDatasetsAsJson(datasets) {
-    return JSON.stringify(datasets, null, 2);
-}
 function formatDatasets(datasets, format) {
-    if (format === OutputFormat.JSON) {
-        return formatDatasetsAsJson(datasets);
-    }
     if (format === OutputFormat.TABLE) {
         return createDatasetsTable(datasets);
     }
@@ -51,9 +44,10 @@ function formatDatasets(datasets, format) {
 }
 export default class DatasetList extends Command {
     static description = 'List datasets for a workflow';
+    static enableJsonFlag = true;
     static examples = [
         '<%= config.bin %> <%= command.id %> simple',
-        '<%= config.bin %> <%= command.id %> simple --format json',
+        '<%= config.bin %> <%= command.id %> simple --json',
         '<%= config.bin %> <%= command.id %> simple --format table'
     ];
     static args = {
@@ -65,23 +59,25 @@ export default class DatasetList extends Command {
     static flags = {
         format: Flags.string({
             char: 'f',
-            description: 'Output format',
-            options: [OutputFormat.TABLE, OutputFormat.JSON, OutputFormat.TEXT],
+            description: 'Output format (use --json for JSON output)',
+            options: [OutputFormat.TABLE, OutputFormat.TEXT],
             default: OutputFormat.TABLE
         })
     };
     async run() {
         const { args, flags } = await this.parse(DatasetList);
         const datasets = await listDatasets(args.workflowName);
+        if (this.jsonEnabled()) {
+            return datasets;
+        }
         if (datasets.length === 0) {
             this.log(`No datasets found for workflow "${args.workflowName}".`);
             this.log('Generate datasets with: output workflow dataset generate');
-            return;
+            return datasets;
         }
         const output = formatDatasets(datasets, flags.format);
         this.log(output);
-        if (flags.format !== OutputFormat.JSON) {
-            this.log(`\nFound ${datasets.length} dataset(s) for "${args.workflowName}"`);
-        }
+        this.log(`\nFound ${datasets.length} dataset(s) for "${args.workflowName}"`);
+        return datasets;
     }
 }

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

@@ -1,16 +1,12 @@
 import { Command } from '@oclif/core';
 export default class WorkflowDebug extends Command {
     static description: string;
+    static enableJsonFlag: boolean;
     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>;
-    private conditionalLog;
-    private outputJson;
+    run(): Promise<unknown>;
     private displayTextTrace;
     catch(error: Error): Promise<void>;
 }

package/dist/commands/workflow/debug.js

@@ -1,14 +1,13 @@
-import { Args, Command, Flags } from '@oclif/core';
-import { OUTPUT_FORMAT } from '#utils/constants.js';
+import { Args, Command } from '@oclif/core';
 import { displayDebugTree } from '#utils/trace_formatter.js';
 import { getTrace } from '#services/trace_reader.js';
 import { handleApiError } from '#utils/error_handler.js';
 export default class WorkflowDebug extends Command {
     static description = 'Get and display workflow execution trace for debugging';
+    static enableJsonFlag = true;
     static examples = [
         '<%= config.bin %> <%= command.id %> wf-12345',
-        '<%= config.bin %> <%= command.id %> wf-12345 --format json',
-        '<%= config.bin %> <%= command.id %> wf-12345 --format text'
+        '<%= config.bin %> <%= command.id %> wf-12345 --json'
     ];
     static args = {
         workflowId: Args.string({
@@ -16,41 +15,23 @@ export default class WorkflowDebug extends Command {
             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(WorkflowDebug);
-        const isJsonFormat = flags.format === OUTPUT_FORMAT.JSON;
-        this.conditionalLog(`Fetching debug information for workflow: ${args.workflowId}...`, isJsonFormat);
+        const { args } = await this.parse(WorkflowDebug);
+        this.log(`Fetching debug information for workflow: ${args.workflowId}...`);
         const { data: traceData, location } = await getTrace(args.workflowId);
         const source = location.isRemote ? 'remote' : 'local';
-        this.conditionalLog(`Trace source: ${source}${!location.isRemote ? ` (${location.path})` : ''}`, isJsonFormat);
-        if (isJsonFormat) {
-            this.outputJson(traceData);
-            return;
+        this.log(`Trace source: ${source}${!location.isRemote ? ` (${location.path})` : ''}`);
+        if (!this.jsonEnabled()) {
+            this.displayTextTrace(traceData);
         }
-        this.displayTextTrace(traceData);
-    }
-    conditionalLog(message, disabled) {
-        if (!disabled) {
-            this.log(message);
-        }
-    }
-    outputJson(data) {
-        this.log(JSON.stringify(data, null, 2));
+        return traceData;
     }
     displayTextTrace(traceData) {
         this.log('\nTrace Log:');
         this.log('─'.repeat(80));
         this.log(displayDebugTree(traceData));
         this.log('\n' + '─'.repeat(80));
-        this.log('Tip: Use --format json for the full untruncated trace');
+        this.log('Tip: Use --json for the full untruncated trace');
     }
     async catch(error) {
         return handleApiError(error, (...args) => this.error(...args), {

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

@@ -17,13 +17,10 @@ describe('workflow debug command', () => {
             expect(WorkflowDebug).toBeDefined();
             expect(WorkflowDebug.description).toContain('Get and display workflow execution trace for debugging');
             expect(WorkflowDebug.args).toHaveProperty('workflowId');
-            expect(WorkflowDebug.flags).toHaveProperty('format');
         });
-        it('should have correct flag configuration', async () => {
+        it('enables the built-in --json flag', async () => {
             const WorkflowDebug = (await import('./debug.js')).default;
-            // Format flag
-            expect(WorkflowDebug.flags.format.options).toEqual(['json', 'text']);
-            expect(WorkflowDebug.flags.format.default).toBe('text');
+            expect(WorkflowDebug.enableJsonFlag).toBe(true);
         });
         it('should have correct examples', async () => {
             const WorkflowDebug = (await import('./debug.js')).default;

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

@@ -4,8 +4,8 @@ import Generate from './generate.js';
 import { generateWorkflow } from '#services/workflow_generator.js';
 import { parseWorkflowDir } from '#utils/workflow_dir_parser.js';
 import { InvalidNameError, WorkflowExistsError } from '#types/errors.js';
-vi.mock('../../services/workflow_generator.js');
-vi.mock('../../utils/workflow_dir_parser.js');
+vi.mock('#services/workflow_generator.js');
+vi.mock('#utils/workflow_dir_parser.js');
 describe('Generate Command', () => {
     let mockGenerateWorkflow;
     let mockParseWorkflowDir;

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

@@ -12,6 +12,7 @@ export declare function parseWorkflowForDisplay(workflow: Workflow): WorkflowDis
 export declare function formatWorkflowsAsList(workflows: Workflow[]): string;
 export default class WorkflowList extends Command {
     static description: string;
+    static enableJsonFlag: boolean;
     static examples: string[];
     static flags: {
         catalog: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
@@ -19,7 +20,9 @@ export default class WorkflowList extends Command {
         detailed: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         filter: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
-    run(): Promise<void>;
+    run(): Promise<{
+        workflows: unknown[];
+    }>;
     catch(error: Error): Promise<void>;
 }
 export {};