@outputai/cli 0.9.3-next.01f20d3.0 → 0.9.3-next.105840b.0

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

@@ -275,6 +275,14 @@ export interface WorkflowResultResponse {
        */
     errorDetails?: WorkflowResultResponseErrorDetails;
 }
+export interface WorkflowInputResponse {
+    /** The workflow execution id */
+    workflowId: string;
+    /** The specific run id the input was read from */
+    runId: string;
+    /** The first input argument the workflow was started with, null if unavailable */
+    input: unknown;
+}
 export interface StopWorkflowResponse {
     workflowId?: string;
     runId?: string;
@@ -956,6 +964,59 @@ export type getWorkflowIdRunsRidResultResponseError = (getWorkflowIdRunsRidResul
 export type getWorkflowIdRunsRidResultResponse = (getWorkflowIdRunsRidResultResponseSuccess | getWorkflowIdRunsRidResultResponseError);
 export declare const getGetWorkflowIdRunsRidResultUrl: (id: string, rid: string) => string;
 export declare const getWorkflowIdRunsRidResult: (id: string, rid: string, options?: ApiRequestOptions) => Promise<getWorkflowIdRunsRidResultResponse>;
+/**
+ * Returns the original input passed to the latest run of the given workflow. Works for workflows in any state, including running. To pin a specific run, use `/workflow/{id}/runs/{rid}/input`.
+ * @summary Return the original input of a workflow (latest run)
+ */
+export type getWorkflowIdInputResponse200 = {
+    data: WorkflowInputResponse;
+    status: 200;
+};
+export type getWorkflowIdInputResponse404 = {
+    data: NotFoundResponse;
+    status: 404;
+};
+export type getWorkflowIdInputResponse500 = {
+    data: InternalServerErrorResponse;
+    status: 500;
+};
+export type getWorkflowIdInputResponseSuccess = (getWorkflowIdInputResponse200) & {
+    headers: Headers;
+};
+export type getWorkflowIdInputResponseError = (getWorkflowIdInputResponse404 | getWorkflowIdInputResponse500) & {
+    headers: Headers;
+};
+export type getWorkflowIdInputResponse = (getWorkflowIdInputResponseSuccess | getWorkflowIdInputResponseError);
+export declare const getGetWorkflowIdInputUrl: (id: string) => string;
+export declare const getWorkflowIdInput: (id: string, options?: ApiRequestOptions) => Promise<getWorkflowIdInputResponse>;
+/**
+ * @summary Return the original input of a specific workflow run
+ */
+export type getWorkflowIdRunsRidInputResponse200 = {
+    data: WorkflowInputResponse;
+    status: 200;
+};
+export type getWorkflowIdRunsRidInputResponse400 = {
+    data: BadRequestResponse;
+    status: 400;
+};
+export type getWorkflowIdRunsRidInputResponse404 = {
+    data: NotFoundResponse;
+    status: 404;
+};
+export type getWorkflowIdRunsRidInputResponse500 = {
+    data: InternalServerErrorResponse;
+    status: 500;
+};
+export type getWorkflowIdRunsRidInputResponseSuccess = (getWorkflowIdRunsRidInputResponse200) & {
+    headers: Headers;
+};
+export type getWorkflowIdRunsRidInputResponseError = (getWorkflowIdRunsRidInputResponse400 | getWorkflowIdRunsRidInputResponse404 | getWorkflowIdRunsRidInputResponse500) & {
+    headers: Headers;
+};
+export type getWorkflowIdRunsRidInputResponse = (getWorkflowIdRunsRidInputResponseSuccess | getWorkflowIdRunsRidInputResponseError);
+export declare const getGetWorkflowIdRunsRidInputUrl: (id: string, rid: string) => string;
+export declare const getWorkflowIdRunsRidInput: (id: string, rid: string, options?: ApiRequestOptions) => Promise<getWorkflowIdRunsRidInputResponse>;
 /**
  * Returns trace data for the latest run of the given workflow. If trace is stored remotely (S3), fetches and returns the data inline. If trace is local only, returns the local path. To pin a specific run, use `/workflow/{id}/runs/{rid}/trace-log`.
  * @summary Get workflow trace log data (latest run)

package/dist/api/generated/api.js

@@ -181,6 +181,24 @@ export const getWorkflowIdRunsRidResult = async (id, rid, options) => {
         method: 'GET'
     });
 };
+export const getGetWorkflowIdInputUrl = (id) => {
+    return `/workflow/${id}/input`;
+};
+export const getWorkflowIdInput = async (id, options) => {
+    return customFetchInstance(getGetWorkflowIdInputUrl(id), {
+        ...options,
+        method: 'GET'
+    });
+};
+export const getGetWorkflowIdRunsRidInputUrl = (id, rid) => {
+    return `/workflow/${id}/runs/${rid}/input`;
+};
+export const getWorkflowIdRunsRidInput = async (id, rid, options) => {
+    return customFetchInstance(getGetWorkflowIdRunsRidInputUrl(id, rid), {
+        ...options,
+        method: 'GET'
+    });
+};
 export const getGetWorkflowIdTraceLogUrl = (id) => {
     return `/workflow/${id}/trace-log`;
 };

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.9.3-next.01f20d3.0}
+    image: outputai/api:${OUTPUT_API_VERSION:-0.9.3-next.105840b.0}
     init: true
     networks:
       - main

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

@@ -17,7 +17,8 @@ export default class DatasetGenerate extends Command {
     run(): Promise<void>;
     private generateFromScenario;
     private generateFromTrace;
-    private generateFromS3;
+    private generateFromRuns;
+    private generateFromRun;
     private resolveScenarioInput;
     catch(error: Error): Promise<void>;
 }

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

@@ -1,15 +1,15 @@
 import { readFile } from 'node:fs/promises';
-import { join } from 'node:path';
 import { Args, Command, Flags, ux } from '@oclif/core';
 import { postWorkflowRun } from '#api/generated/api.js';
-import { writeDataset, resolveDefaultDatasetsDir, buildDataset, getExecutionTime, extractDatasetName } from '#services/datasets.js';
-import { listRemoteTraces, downloadRemoteTrace } from '#services/s3_trace_downloader.js';
+import { writeDataset, resolveDefaultDatasetsDir, buildDataset, getExecutionTime, extractDatasetName, datasetFilePath } from '#services/datasets.js';
+import { fetchWorkflowRuns } from '#services/workflow_runs.js';
+import { getTrace } from '#services/trace_reader.js';
 import { extractDatasetFromTrace } from '#utils/trace_extractor.js';
 import { resolveScenarioPath, getScenarioNotFoundMessage } from '#utils/scenario_resolver.js';
 import { parseInputFlag } from '#utils/input_parser.js';
 import { handleApiError } from '#utils/error_handler.js';
 export default class DatasetGenerate extends Command {
-    static description = 'Generate a dataset for a workflow from a scenario, trace file, or S3';
+    static description = 'Generate a dataset for a workflow from a scenario, trace file, or recent runs';
     static examples = [
         '<%= config.bin %> <%= command.id %> simple basic_input',
         '<%= config.bin %> <%= command.id %> simple --trace logs/runs/simple/trace.json --name edge_case',
@@ -45,13 +45,13 @@ export default class DatasetGenerate extends Command {
         }),
         download: Flags.boolean({
             char: 'd',
-            description: 'Download traces from S3 and create datasets',
+            description: 'Generate datasets from recent workflow runs fetched via the Output API',
             default: false,
             exclusive: ['trace']
         }),
         limit: Flags.integer({
             char: 'l',
-            description: 'Maximum number of traces to download from S3',
+            description: 'Maximum number of recent runs to fetch',
             default: 5
         }),
         input: Flags.string({
@@ -62,7 +62,7 @@ export default class DatasetGenerate extends Command {
     async run() {
         const { args, flags } = await this.parse(DatasetGenerate);
         if (flags.download) {
-            await this.generateFromS3(args.workflowName, flags.limit);
+            await this.generateFromRuns(args.workflowName, flags.limit, flags.catalog);
             return;
         }
         if (flags.trace) {
@@ -89,7 +89,7 @@ export default class DatasetGenerate extends Command {
         const executionTimeMs = await getExecutionTime(workflowId);
         const dataset = buildDataset(datasetName, resolvedInput, output, executionTimeMs);
         const dir = await resolveDefaultDatasetsDir(workflowName);
-        const filePath = join(dir, `${datasetName}.yml`);
+        const filePath = datasetFilePath(dir, datasetName);
         await writeDataset(dataset, filePath);
         this.log(`Dataset saved: ${filePath}`);
     }
@@ -101,29 +101,50 @@ export default class DatasetGenerate extends Command {
         const datasetName = nameOverride ?? extractDatasetName(tracePath);
         const dataset = buildDataset(datasetName, extracted.input, extracted.output, extracted.executionTimeMs);
         const dir = await resolveDefaultDatasetsDir(workflowName);
-        const filePath = join(dir, `${datasetName}.yml`);
+        const filePath = datasetFilePath(dir, datasetName);
         await writeDataset(dataset, filePath);
         this.log(`Dataset saved: ${filePath}`);
     }
-    async generateFromS3(workflowName, limit) {
-        this.log(`Listing remote traces for "${workflowName}"...`);
-        const traces = await listRemoteTraces(workflowName, { limit });
-        if (traces.length === 0) {
-            this.log('No remote traces found.');
+    async generateFromRuns(workflowName, limit, catalog) {
+        this.log(`Fetching recent runs for "${workflowName}"...`);
+        const { runs, skipped } = await fetchWorkflowRuns({ workflowType: workflowName, catalog, limit });
+        if (runs.length === 0) {
+            if (skipped > 0) {
+                this.error(`Found ${skipped} run(s) but none had a workflow ID.`, { exit: 1 });
+            }
+            this.log('No recent runs found.');
             return;
         }
-        this.log(`Found ${traces.length} trace(s). Downloading...`);
+        if (skipped > 0) {
+            this.warn(`Skipping ${skipped} run(s) with no workflow ID.`);
+        }
+        // The trace-log endpoint always targets a workflow's latest run, so distinct
+        // runIds sharing one workflowId (continue-as-new, reset) collapse to one dataset.
+        const workflowIds = [...new Set(runs.map(run => run.workflowId))];
+        this.log(`Found ${workflowIds.length} run(s). Fetching traces...`);
         const dir = await resolveDefaultDatasetsDir(workflowName);
-        for (const trace of traces) {
-            const traceData = await downloadRemoteTrace(trace.key);
+        const generated = (await Promise.all(workflowIds.map(id => this.generateFromRun(id, dir))))
+            .filter(Boolean).length;
+        this.log(`\nGenerated ${generated} dataset(s)`);
+        if (generated === 0) {
+            this.error(`Failed to generate any datasets from ${workflowIds.length} run(s).`, { exit: 1 });
+        }
+    }
+    async generateFromRun(workflowId, dir) {
+        try {
+            const { data: traceData } = await getTrace(workflowId);
             const extracted = extractDatasetFromTrace(traceData);
-            const datasetName = extractDatasetName(trace.key);
-            const dataset = buildDataset(datasetName, extracted.input, extracted.output, extracted.executionTimeMs);
-            const filePath = join(dir, `${datasetName}.yml`);
+            const dataset = buildDataset(workflowId, extracted.input, extracted.output, extracted.executionTimeMs);
+            const filePath = datasetFilePath(dir, workflowId);
             await writeDataset(dataset, filePath);
             this.log(`  Saved: ${filePath}`);
+            return true;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.warn(`  Skipped ${workflowId}: ${message}`);
+            return false;
         }
-        this.log(`\nGenerated ${traces.length} dataset(s)`);
     }
     async resolveScenarioInput(workflowName, scenario, inputFlag, catalog) {
         if (inputFlag && scenario) {

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

@@ -3,6 +3,15 @@ import { describe, it, expect, vi, beforeEach } from 'vitest';
 vi.mock('#api/generated/api.js', () => ({
     postWorkflowRun: vi.fn()
 }));
+vi.mock('#services/workflow_runs.js', () => ({
+    fetchWorkflowRuns: vi.fn()
+}));
+vi.mock('#services/trace_reader.js', () => ({
+    getTrace: vi.fn()
+}));
+vi.mock('#utils/trace_extractor.js', () => ({
+    extractDatasetFromTrace: vi.fn().mockReturnValue({ input: { a: 1 }, output: { ok: true }, executionTimeMs: 5 })
+}));
 vi.mock('#utils/scenario_resolver.js', () => ({
     resolveScenarioPath: vi.fn(),
     getScenarioNotFoundMessage: vi.fn().mockReturnValue('not found')
@@ -15,13 +24,25 @@ vi.mock('#services/datasets.js', () => ({
     resolveDefaultDatasetsDir: vi.fn().mockResolvedValue('/datasets'),
     buildDataset: vi.fn().mockReturnValue({ name: 'basic' }),
     getExecutionTime: vi.fn().mockResolvedValue(100),
-    extractDatasetName: vi.fn()
+    extractDatasetName: vi.fn(),
+    datasetFilePath: vi.fn((dir, name) => `${dir}/${name.replace(/[^a-zA-Z0-9._-]/g, '_')}.yml`)
 }));
 describe('workflow dataset generate command', () => {
     beforeEach(() => {
         vi.clearAllMocks();
         delete process.env.OUTPUT_CATALOG_ID;
     });
+    const makeCmd = async (args, flags) => {
+        const DatasetGenerate = (await import('./generate.js')).default;
+        const cmd = new DatasetGenerate(['my_workflow'], {});
+        cmd.log = vi.fn();
+        cmd.warn = vi.fn();
+        cmd.error = vi.fn(() => {
+            throw new Error('error called');
+        });
+        cmd.parse = vi.fn().mockResolvedValue({ args, flags });
+        return cmd;
+    };
     describe('command definition', () => {
         it('binds the catalog flag to OUTPUT_CATALOG_ID', async () => {
             const DatasetGenerate = (await import('./generate.js')).default;
@@ -32,19 +53,10 @@ describe('workflow dataset generate command', () => {
     });
     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 }
-            });
+            const cmd = await makeCmd({ workflowName: 'my_workflow', scenario: 'basic' }, { catalog: undefined, trace: undefined, name: undefined, download: false, limit: 5, input: undefined, ...flagOverrides });
             return {
                 cmd,
                 postWorkflowRun: vi.mocked(postWorkflowRun),
@@ -66,4 +78,97 @@ describe('workflow dataset generate command', () => {
             expect(postWorkflowRun).toHaveBeenCalledWith(expect.objectContaining({ workflowName: 'my_workflow', catalog: 'my-catalog' }), expect.anything());
         });
     });
+    describe('run() --download', () => {
+        const createDownloadCommand = async (flagOverrides = {}) => {
+            const { fetchWorkflowRuns } = await import('#services/workflow_runs.js');
+            const { getTrace } = await import('#services/trace_reader.js');
+            const { writeDataset } = await import('#services/datasets.js');
+            const cmd = await makeCmd({ workflowName: 'my_workflow', scenario: undefined }, { catalog: 'my-catalog', trace: undefined, name: undefined, download: true, limit: 5, input: undefined, ...flagOverrides });
+            return {
+                cmd,
+                fetchWorkflowRuns: vi.mocked(fetchWorkflowRuns),
+                getTrace: vi.mocked(getTrace),
+                writeDataset: vi.mocked(writeDataset)
+            };
+        };
+        it('fetches recent runs scoped to the catalog and writes a dataset per run', async () => {
+            const { cmd, fetchWorkflowRuns, getTrace, writeDataset } = await createDownloadCommand();
+            fetchWorkflowRuns.mockResolvedValue({
+                runs: [{ workflowId: 'wf-1' }, { workflowId: 'wf-2' }],
+                skipped: 0,
+                count: 2
+            });
+            getTrace.mockResolvedValue({ data: {}, location: { path: 'remote', isRemote: true } });
+            await cmd.run();
+            expect(fetchWorkflowRuns).toHaveBeenCalledWith({ workflowType: 'my_workflow', catalog: 'my-catalog', limit: 5 });
+            expect(getTrace).toHaveBeenCalledTimes(2);
+            expect(getTrace).toHaveBeenCalledWith('wf-1');
+            expect(getTrace).toHaveBeenCalledWith('wf-2');
+            expect(writeDataset).toHaveBeenCalledTimes(2);
+        });
+        it('skips runs whose trace cannot be fetched and continues', async () => {
+            const { cmd, fetchWorkflowRuns, getTrace, writeDataset } = await createDownloadCommand();
+            fetchWorkflowRuns.mockResolvedValue({
+                runs: [{ workflowId: 'wf-1' }, { workflowId: 'wf-2' }],
+                skipped: 0,
+                count: 2
+            });
+            getTrace
+                .mockRejectedValueOnce(new Error('no trace available'))
+                .mockResolvedValueOnce({ data: {}, location: { path: 'remote', isRemote: true } });
+            await cmd.run();
+            expect(cmd.warn).toHaveBeenCalledWith(expect.stringContaining('wf-1'));
+            expect(writeDataset).toHaveBeenCalledTimes(1);
+        });
+        it('reports when no recent runs are found', async () => {
+            const { cmd, fetchWorkflowRuns, getTrace, writeDataset } = await createDownloadCommand();
+            fetchWorkflowRuns.mockResolvedValue({ runs: [], skipped: 0, count: 0 });
+            await cmd.run();
+            expect(getTrace).not.toHaveBeenCalled();
+            expect(writeDataset).not.toHaveBeenCalled();
+        });
+        it('exits non-zero when every run fails to produce a dataset', async () => {
+            const { cmd, fetchWorkflowRuns, getTrace } = await createDownloadCommand();
+            fetchWorkflowRuns.mockResolvedValue({ runs: [{ workflowId: 'wf-1' }], skipped: 0, count: 1 });
+            getTrace.mockRejectedValue(new Error('no trace available'));
+            await expect(cmd.run()).rejects.toThrow('error called');
+            expect(cmd.error).toHaveBeenCalledWith(expect.stringContaining('Failed to generate'), { exit: 1 });
+        });
+        it('warns about runs the service skipped for missing a workflow ID', async () => {
+            const { cmd, fetchWorkflowRuns, getTrace, writeDataset } = await createDownloadCommand();
+            fetchWorkflowRuns.mockResolvedValue({ runs: [{ workflowId: 'wf-1' }], skipped: 1, count: 2 });
+            getTrace.mockResolvedValue({ data: {}, location: { path: 'remote', isRemote: true } });
+            await cmd.run();
+            expect(cmd.warn).toHaveBeenCalledWith(expect.stringContaining('no workflow ID'));
+            expect(getTrace).toHaveBeenCalledTimes(1);
+            expect(writeDataset).toHaveBeenCalledTimes(1);
+        });
+        it('exits non-zero when every run was skipped for missing a workflow ID', async () => {
+            const { cmd, fetchWorkflowRuns, getTrace } = await createDownloadCommand();
+            fetchWorkflowRuns.mockResolvedValue({ runs: [], skipped: 2, count: 2 });
+            await expect(cmd.run()).rejects.toThrow('error called');
+            expect(getTrace).not.toHaveBeenCalled();
+            expect(cmd.error).toHaveBeenCalledWith(expect.stringContaining('none had a workflow ID'), { exit: 1 });
+        });
+        it('deduplicates runs that share a workflow ID', async () => {
+            const { cmd, fetchWorkflowRuns, getTrace, writeDataset } = await createDownloadCommand();
+            fetchWorkflowRuns.mockResolvedValue({
+                runs: [{ workflowId: 'wf-1' }, { workflowId: 'wf-1' }],
+                skipped: 0,
+                count: 2
+            });
+            getTrace.mockResolvedValue({ data: {}, location: { path: 'remote', isRemote: true } });
+            await cmd.run();
+            expect(getTrace).toHaveBeenCalledTimes(1);
+            expect(writeDataset).toHaveBeenCalledTimes(1);
+        });
+        it('sanitizes path separators in the workflow ID used for the filename', async () => {
+            const { cmd, fetchWorkflowRuns, getTrace, writeDataset } = await createDownloadCommand();
+            fetchWorkflowRuns.mockResolvedValue({ runs: [{ workflowId: '../../escape' }], skipped: 0, count: 1 });
+            getTrace.mockResolvedValue({ data: {}, location: { path: 'remote', isRemote: true } });
+            await cmd.run();
+            const writtenPath = writeDataset.mock.calls[0][1];
+            expect(writtenPath).toBe('/datasets/.._.._escape.yml');
+        });
+    });
 });

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

@@ -0,0 +1,16 @@
+import { Command } from '@oclif/core';
+export default class WorkflowInput 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: {
+        'run-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'output-file': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<unknown>;
+    catch(error: Error): Promise<void>;
+}

package/dist/commands/workflow/input.js

@@ -0,0 +1,74 @@
+import { Args, Command, Flags } from '@oclif/core';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { getWorkflowIdInput, getWorkflowIdRunsRidInput } from '#api/generated/api.js';
+import { handleApiError } from '#utils/error_handler.js';
+export default class WorkflowInput extends Command {
+    static description = 'Get the original input a workflow run was started with';
+    static enableJsonFlag = true;
+    static examples = [
+        '<%= config.bin %> <%= command.id %> wf-12345',
+        '<%= config.bin %> <%= command.id %> wf-12345 --run-id 11111111-2222-4333-8444-555555555555',
+        '<%= config.bin %> <%= command.id %> wf-12345 -o w_input.json',
+        '<%= config.bin %> <%= command.id %> wf-12345 --output-file w_input.json --force'
+    ];
+    static args = {
+        workflowId: Args.string({
+            description: 'The workflow ID to get the input for',
+            required: true
+        })
+    };
+    static flags = {
+        'run-id': Flags.string({
+            description: 'Specific run id to target (defaults to the latest run)'
+        }),
+        'output-file': Flags.string({
+            char: 'o',
+            description: 'Write the input JSON to this file instead of stdout'
+        }),
+        force: Flags.boolean({
+            char: 'f',
+            default: false,
+            description: 'Overwrite the output file if it already exists'
+        })
+    };
+    async run() {
+        const { args, flags } = await this.parse(WorkflowInput);
+        const runId = flags['run-id'];
+        const outputFile = flags['output-file'];
+        const response = runId ?
+            await getWorkflowIdRunsRidInput(args.workflowId, runId) :
+            await getWorkflowIdInput(args.workflowId);
+        if (!response || !response.data) {
+            this.error('API returned invalid response', { exit: 1 });
+        }
+        const data = response.data;
+        const input = data.input;
+        const json = JSON.stringify(input, null, 2);
+        if (outputFile) {
+            const destPath = path.resolve(process.cwd(), outputFile);
+            const fileExists = await fs.access(destPath).then(() => true).catch(() => false);
+            if (fileExists && !flags.force) {
+                this.error(`File already exists at ${destPath}. Use --force to overwrite or choose a different --output-file.`, { exit: 1 });
+            }
+            await fs.writeFile(destPath, `${json}\n`, 'utf-8');
+            this.logToStderr(`Wrote workflow input to ${destPath}`);
+            // Don't return the bare input here: under --json oclif serializes run()'s return value to
+            // stdout, which would duplicate the input we just wrote to the file. Return a status object
+            // so --json emits a confirmation instead, and non-json mode keeps stdout empty.
+            return { outputFile: destPath };
+        }
+        // Emit only the bare input (never the response envelope) so every mode yields the same
+        // pipeable value (e.g. `output workflow input <id> | jq .`). Under --json oclif serializes
+        // run()'s return value, which is also the bare input, so skip the manual log here.
+        if (!this.jsonEnabled()) {
+            this.log(json);
+        }
+        return input;
+    }
+    async catch(error) {
+        return handleApiError(error, (...args) => this.error(...args), {
+            404: 'Workflow not found. Check the workflow ID.'
+        });
+    }
+}

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

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

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

@@ -0,0 +1,119 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import fs from 'node:fs/promises';
+import { getWorkflowIdInput, getWorkflowIdRunsRidInput } from '#api/generated/api.js';
+import WorkflowInput from './input.js';
+vi.mock('node:fs/promises');
+vi.mock('#api/generated/api.js', () => ({
+    getWorkflowIdInput: vi.fn(),
+    getWorkflowIdRunsRidInput: vi.fn()
+}));
+const RID = '11111111-2222-4333-8444-555555555555';
+const INPUT = { values: [1, 2, 3] };
+const makeCmd = (argv) => {
+    const config = { runHook: vi.fn().mockResolvedValue({ failures: [], successes: [] }) };
+    const cmd = new WorkflowInput(argv, config);
+    cmd.log = vi.fn();
+    cmd.logToStderr = vi.fn();
+    cmd.error = vi.fn().mockImplementation((msg) => {
+        throw new Error(msg);
+    });
+    cmd.jsonEnabled = vi.fn().mockReturnValue(false);
+    return cmd;
+};
+describe('workflow input command', () => {
+    beforeEach(() => vi.clearAllMocks());
+    afterEach(() => vi.restoreAllMocks());
+    describe('command definition', () => {
+        it('exports a valid OCLIF command', () => {
+            expect(WorkflowInput.description).toContain('input');
+            expect(WorkflowInput.args).toHaveProperty('workflowId');
+            expect(WorkflowInput.enableJsonFlag).toBe(true);
+        });
+    });
+    describe('fetching input', () => {
+        it('prints the bare input JSON to stdout and returns it for the latest run', async () => {
+            vi.mocked(getWorkflowIdInput).mockResolvedValue({ data: { workflowId: 'wf-1', runId: RID, input: INPUT } });
+            const cmd = makeCmd(['wf-1']);
+            const result = await cmd.run();
+            expect(getWorkflowIdInput).toHaveBeenCalledWith('wf-1');
+            expect(getWorkflowIdRunsRidInput).not.toHaveBeenCalled();
+            expect(cmd.log).toHaveBeenCalledWith(JSON.stringify(INPUT, null, 2));
+            // run() returns the bare input (not the envelope), so --json emits the same shape.
+            expect(result).toEqual(INPUT);
+        });
+        it('returns the bare input and skips manual logging in --json mode', async () => {
+            vi.mocked(getWorkflowIdInput).mockResolvedValue({ data: { workflowId: 'wf-1', runId: RID, input: INPUT } });
+            const cmd = makeCmd(['wf-1', '--json']);
+            cmd.jsonEnabled.mockReturnValue(true);
+            const result = await cmd.run();
+            expect(cmd.log).not.toHaveBeenCalled();
+            expect(result).toEqual(INPUT);
+        });
+        it('uses the run-pinned endpoint when --run-id is given', async () => {
+            vi.mocked(getWorkflowIdRunsRidInput).mockResolvedValue({ data: { workflowId: 'wf-1', runId: RID, input: INPUT } });
+            const cmd = makeCmd(['wf-1', '--run-id', RID]);
+            await cmd.run();
+            expect(getWorkflowIdRunsRidInput).toHaveBeenCalledWith('wf-1', RID);
+            expect(getWorkflowIdInput).not.toHaveBeenCalled();
+        });
+        it('prints null when no input is available', async () => {
+            vi.mocked(getWorkflowIdInput).mockResolvedValue({ data: { workflowId: 'wf-1', runId: RID, input: null } });
+            const cmd = makeCmd(['wf-1']);
+            await cmd.run();
+            expect(cmd.log).toHaveBeenCalledWith('null');
+        });
+    });
+    describe('writing to a file', () => {
+        beforeEach(() => {
+            vi.mocked(getWorkflowIdInput).mockResolvedValue({ data: { workflowId: 'wf-1', runId: RID, input: INPUT } });
+        });
+        it('writes the input JSON to the output file', async () => {
+            vi.mocked(fs.access).mockRejectedValue(new Error('not found'));
+            vi.mocked(fs.writeFile).mockResolvedValue();
+            const cmd = makeCmd(['wf-1', '-o', 'out.json']);
+            await cmd.run();
+            expect(fs.writeFile).toHaveBeenCalledWith(expect.stringContaining('out.json'), `${JSON.stringify(INPUT, null, 2)}\n`, 'utf-8');
+            expect(cmd.log).not.toHaveBeenCalled();
+            expect(cmd.logToStderr).toHaveBeenCalledWith(expect.stringContaining('out.json'));
+        });
+        it('does not return the bare input in file mode, so --json never duplicates it to stdout', async () => {
+            vi.mocked(fs.access).mockRejectedValue(new Error('not found'));
+            vi.mocked(fs.writeFile).mockResolvedValue();
+            const cmd = makeCmd(['wf-1', '-o', 'out.json', '--json']);
+            cmd.jsonEnabled.mockReturnValue(true);
+            const result = await cmd.run();
+            // The input went to the file; --json must emit a confirmation, not the input again.
+            expect(result).not.toEqual(INPUT);
+            expect(result).toMatchObject({ outputFile: expect.stringContaining('out.json') });
+        });
+        it('refuses to overwrite an existing file without --force', async () => {
+            vi.mocked(fs.access).mockResolvedValue();
+            const cmd = makeCmd(['wf-1', '-o', 'out.json']);
+            await expect(cmd.run()).rejects.toThrow('File already exists');
+            expect(fs.writeFile).not.toHaveBeenCalled();
+        });
+        it('overwrites an existing file when --force is set', async () => {
+            vi.mocked(fs.access).mockResolvedValue();
+            vi.mocked(fs.writeFile).mockResolvedValue();
+            const cmd = makeCmd(['wf-1', '-o', 'out.json', '--force']);
+            await cmd.run();
+            expect(fs.writeFile).toHaveBeenCalled();
+        });
+    });
+    describe('error handling', () => {
+        it('maps a 404 to a friendly message', async () => {
+            const cmd = makeCmd(['wf-1']);
+            const apiError = Object.assign(new Error('Not Found'), { response: { status: 404 } });
+            await expect(cmd.catch(apiError)).rejects.toThrow('Workflow not found');
+        });
+        it('shows the friendly 404 even when the API body carries error/message', async () => {
+            const cmd = makeCmd(['wf-1']);
+            // Real API 404 shape: the override must win over this body, not be shadowed by it.
+            const apiError = Object.assign(new Error('Not Found'), {
+                response: { status: 404, data: { error: 'WorkflowNotFoundError', message: 'Workflow "wf-1" not found' } }
+            });
+            await expect(cmd.catch(apiError)).rejects.toThrow('Workflow not found. Check the workflow ID.');
+        });
+    });
+});

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

@@ -18,7 +18,7 @@ function createRunsTable(runs) {
     });
     runs.forEach(run => {
         table.push([
-            run.workflowId || '-',
+            run.workflowId,
             run.workflowType || '-',
             run.status || '-',
             formatDate(run.startedAt),
@@ -79,11 +79,14 @@ export default class WorkflowRunsList extends Command {
     };
     async run() {
         const { args, flags } = await this.parse(WorkflowRunsList);
-        const { runs, count } = await fetchWorkflowRuns({
+        const { runs, skipped } = await fetchWorkflowRuns({
             workflowType: args.workflowName,
             catalog: flags.catalog,
             limit: flags.limit
         });
+        if (skipped > 0) {
+            this.warn(`Skipping ${skipped} run(s) with no workflow ID.`);
+        }
         if (this.jsonEnabled()) {
             return runs;
         }
@@ -95,7 +98,7 @@ export default class WorkflowRunsList extends Command {
         const output = formatRuns(runs, flags.format);
         this.log(output);
         const filterMsg = args.workflowName ? ` of type "${args.workflowName}"` : '';
-        this.log(`\nFound ${count} run(s)${filterMsg}`);
+        this.log(`\nFound ${runs.length} run(s)${filterMsg}`);
         return runs;
     }
     async catch(error) {

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

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

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

@@ -0,0 +1,45 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+vi.mock('#services/workflow_runs.js', () => ({
+    fetchWorkflowRuns: vi.fn()
+}));
+describe('workflow runs list command', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    const createCommand = async (flagOverrides = {}) => {
+        const WorkflowRunsList = (await import('./list.js')).default;
+        const { fetchWorkflowRuns } = await import('#services/workflow_runs.js');
+        const cmd = new WorkflowRunsList([], {});
+        cmd.log = vi.fn();
+        cmd.warn = vi.fn();
+        cmd.jsonEnabled = vi.fn().mockReturnValue(false);
+        cmd.parse = vi.fn().mockResolvedValue({
+            args: { workflowName: undefined },
+            flags: { catalog: undefined, limit: 100, format: 'table', ...flagOverrides }
+        });
+        return { cmd, fetchWorkflowRuns: vi.mocked(fetchWorkflowRuns) };
+    };
+    it('reports the actual number of returned runs, not the API\'s pre-filter count', async () => {
+        const { cmd, fetchWorkflowRuns } = await createCommand();
+        fetchWorkflowRuns.mockResolvedValue({
+            runs: [{ workflowId: 'wf-1', workflowType: 'demo', status: 'completed', startedAt: '2026-01-01T00:00:00Z', completedAt: null }],
+            skipped: 1,
+            count: 2
+        });
+        await cmd.run();
+        expect(cmd.log).toHaveBeenCalledWith(expect.stringContaining('Found 1 run(s)'));
+    });
+    it('warns when runs were skipped for missing a workflow ID', async () => {
+        const { cmd, fetchWorkflowRuns } = await createCommand();
+        fetchWorkflowRuns.mockResolvedValue({ runs: [], skipped: 2, count: 2 });
+        await cmd.run();
+        expect(cmd.warn).toHaveBeenCalledWith(expect.stringContaining('no workflow ID'));
+    });
+    it('does not warn when no runs were skipped', async () => {
+        const { cmd, fetchWorkflowRuns } = await createCommand();
+        fetchWorkflowRuns.mockResolvedValue({ runs: [], skipped: 0, count: 0 });
+        await cmd.run();
+        expect(cmd.warn).not.toHaveBeenCalled();
+    });
+});

package/dist/config.d.ts

@@ -12,10 +12,4 @@ export declare const config: {
     readonly debugMode: boolean;
     readonly envFile: string;
     agentConfigDir: string;
-    readonly s3: {
-        bucket: string | undefined;
-        region: string | undefined;
-        accessKeyId: string | undefined;
-        secretAccessKey: string | undefined;
-    };
 };

package/dist/config.js

@@ -29,13 +29,5 @@ export const config = {
     get envFile() {
         return process.env.OUTPUT_CLI_ENV || '.env';
     },
-    agentConfigDir: '.outputai',
-    get s3() {
-        return {
-            bucket: process.env.OUTPUT_TRACE_REMOTE_S3_BUCKET,
-            region: process.env.OUTPUT_AWS_REGION,
-            accessKeyId: process.env.OUTPUT_AWS_ACCESS_KEY_ID,
-            secretAccessKey: process.env.OUTPUT_AWS_SECRET_ACCESS_KEY
-        };
-    }
+    agentConfigDir: '.outputai'
 };

package/dist/config.spec.js

@@ -10,11 +10,7 @@ describe('config', () => {
         'OUTPUT_API_AUTH_TOKEN',
         'DOCKER_SERVICE_NAME',
         'OUTPUT_DEBUG',
-        'OUTPUT_CLI_ENV',
-        'OUTPUT_TRACE_REMOTE_S3_BUCKET',
-        'OUTPUT_AWS_REGION',
-        'OUTPUT_AWS_ACCESS_KEY_ID',
-        'OUTPUT_AWS_SECRET_ACCESS_KEY'
+        'OUTPUT_CLI_ENV'
     ];
     const saved = {};
     beforeEach(() => {
@@ -118,18 +114,6 @@ describe('config', () => {
         process.env.OUTPUT_DEBUG = 'false';
         expect(config.debugMode).toBe(false);
     });
-    it('reads s3 config lazily', () => {
-        process.env.OUTPUT_TRACE_REMOTE_S3_BUCKET = 'my-bucket';
-        process.env.OUTPUT_AWS_REGION = 'us-west-2';
-        process.env.OUTPUT_AWS_ACCESS_KEY_ID = 'AKIA123';
-        process.env.OUTPUT_AWS_SECRET_ACCESS_KEY = 'secret123';
-        expect(config.s3).toEqual({
-            bucket: 'my-bucket',
-            region: 'us-west-2',
-            accessKeyId: 'AKIA123',
-            secretAccessKey: 'secret123'
-        });
-    });
     it('has static properties that are not env-derived', () => {
         expect(config.requestTimeout).toBe(30000);
         expect(config.agentConfigDir).toBe('.outputai');

package/dist/generated/framework_version.json

@@ -1,3 +1,3 @@
 {
-    "framework": "0.9.3-next.01f20d3.0"
+    "framework": "0.9.3-next.105840b.0"
 }

package/dist/services/datasets.d.ts

@@ -17,4 +17,5 @@ export declare function writeDataset(dataset: Dataset, filePath: string): Promis
 export declare function listDatasets(workflowName: string, basePath?: string): Promise<DatasetInfo[]>;
 export declare function buildDataset(name: string, input: Record<string, unknown>, output: unknown, executionTimeMs?: number): Dataset;
 export declare function extractDatasetName(tracePathOrKey: string): string;
+export declare function datasetFilePath(dir: string, name: string): string;
 export declare function getExecutionTime(workflowId: string | undefined): Promise<number | undefined>;

package/dist/services/datasets.js

@@ -123,6 +123,13 @@ export function buildDataset(name, input, output, executionTimeMs) {
 export function extractDatasetName(tracePathOrKey) {
     return tracePathOrKey.replace(/^.*\//, '').replace(/\.json$/, '');
 }
+// Resolve the .yml path for a dataset case, sanitizing the name so it can never
+// escape the datasets directory regardless of where the name came from
+// (scenario arg, --name flag, or a workflow ID).
+export function datasetFilePath(dir, name) {
+    const safeName = name.replace(/[^a-zA-Z0-9._-]/g, '_');
+    return join(dir, `${safeName}.yml`);
+}
 export function getExecutionTime(workflowId) {
     if (!workflowId) {
         return Promise.resolve(undefined);

package/dist/services/datasets.test.js

@@ -3,7 +3,7 @@ import { mkdtemp, rm, writeFile, readFile, mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 import yaml from 'js-yaml';
-import { readDatasetFile, readAllDatasets, writeDataset, listDatasets, resolveDefaultDatasetsDir } from './datasets.js';
+import { readDatasetFile, readAllDatasets, writeDataset, listDatasets, resolveDefaultDatasetsDir, datasetFilePath } from './datasets.js';
 import * as catalog from '#api/workflow_catalog.js';
 vi.mock('#api/workflow_catalog.js', () => ({
     fetchWorkflowCatalog: vi.fn()
@@ -235,3 +235,12 @@ describe('resolveDefaultDatasetsDir', () => {
         expect(dir).toBe(join(ctx.tmpDir, 'src', 'workflows', 'unknown_flow', 'tests', 'datasets'));
     });
 });
+describe('datasetFilePath', () => {
+    it('joins the directory with a .yml file named after the case', () => {
+        expect(datasetFilePath('/datasets', 'basic_input')).toBe(join('/datasets', 'basic_input.yml'));
+    });
+    it('replaces path separators and other unsafe characters so the name cannot escape the directory', () => {
+        expect(datasetFilePath('/datasets', '../../escape')).toBe(join('/datasets', '.._.._escape.yml'));
+        expect(datasetFilePath('/datasets', 'a/b c')).toBe(join('/datasets', 'a_b_c.yml'));
+    });
+});

package/dist/services/workflow_runs.d.ts

@@ -2,9 +2,12 @@
  * Workflow runs service for fetching workflow run data from the API
  */
 import { type WorkflowRunInfo } from '#api/generated/api.js';
-export type WorkflowRun = WorkflowRunInfo;
+export type WorkflowRun = Omit<WorkflowRunInfo, 'workflowId'> & {
+    workflowId: string;
+};
 export interface WorkflowRunsResult {
     runs: WorkflowRun[];
+    skipped: number;
     count: number;
 }
 export interface FetchWorkflowRunsOptions {

package/dist/services/workflow_runs.js

@@ -22,12 +22,14 @@ export async function fetchWorkflowRuns(options = {}) {
         throw new Error('API returned invalid response (missing data)');
     }
     const data = response.data;
-    const runs = (data.runs || []).map(run => ({
+    const allRuns = (data.runs || []).map(run => ({
         ...run,
         status: normalizeWorkflowStatus(run.status)
     }));
+    const runs = allRuns.filter(run => Boolean(run.workflowId));
     return {
         runs,
+        skipped: allRuns.length - runs.length,
         count: data.count || 0
     };
 }

package/dist/services/workflow_runs.spec.d.ts

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

package/dist/services/workflow_runs.spec.js

@@ -0,0 +1,39 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+vi.mock('#api/generated/api.js', () => ({
+    getWorkflowRuns: vi.fn()
+}));
+import { getWorkflowRuns } from '#api/generated/api.js';
+import { fetchWorkflowRuns } from '#services/workflow_runs.js';
+describe('fetchWorkflowRuns', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('filters out runs with no workflow ID and reports how many were skipped', async () => {
+        vi.mocked(getWorkflowRuns).mockResolvedValue({
+            data: {
+                runs: [{ workflowId: 'wf-1' }, { workflowId: undefined }, { workflowId: 'wf-2' }],
+                count: 3
+            },
+            status: 200,
+            headers: new Headers()
+        });
+        const result = await fetchWorkflowRuns();
+        expect(result.runs.map(run => run.workflowId)).toEqual(['wf-1', 'wf-2']);
+        expect(result.skipped).toBe(1);
+        expect(result.count).toBe(3);
+    });
+    it('reports zero skipped when every run has a workflow ID', async () => {
+        vi.mocked(getWorkflowRuns).mockResolvedValue({
+            data: { runs: [{ workflowId: 'wf-1' }], count: 1 },
+            status: 200,
+            headers: new Headers()
+        });
+        const result = await fetchWorkflowRuns();
+        expect(result.skipped).toBe(0);
+        expect(result.runs).toHaveLength(1);
+    });
+    it('throws when the API server cannot be reached', async () => {
+        vi.mocked(getWorkflowRuns).mockResolvedValue(undefined);
+        await expect(fetchWorkflowRuns()).rejects.toThrow('Failed to connect to API server');
+    });
+});

package/dist/utils/error_handler.js

@@ -57,6 +57,14 @@ export function handleApiError(error, errorFn, overrides = {}) {
     }
     if (apiError.response?.status) {
         const status = apiError.response.status;
+        // A caller-supplied override for this exact status wins over the raw server body. The API's
+        // 404 body is a bare "WorkflowNotFoundError: ..." that the friendly override is meant to
+        // replace; without this, extractApiErrorDetails consumes the body first and every command's
+        // per-status override is dead code. Defaults are not consulted here, so commands that pass no
+        // override still get the rich server detail below.
+        if (status in overrides) {
+            errorFn(overrides[status], { exit: 1 });
+        }
         // Extract error details from response body
         const apiErrorDetails = extractApiErrorDetails(apiError.response.data);
         if (apiErrorDetails) {

package/dist/views/dev/components/run_info_sidebar.js

@@ -9,7 +9,7 @@ export const RunInfoSidebar = ({ run, resultStatus, maxRows }) => {
     const rows = [
         _jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: "RUN STATUS\u00A0" }), _jsx(WorkflowStatusIcon, { status: status }), _jsx(Text, { children: "\u00A0" }), _jsx(Text, { bold: true, color: workflowStatusColor(status), children: status.toUpperCase() })] }, "status"),
         _jsx(SidebarKV, { label: "RUN ID", value: run.runId ?? '-' }, "run-id"),
-        _jsx(SidebarKV, { label: "WORKFLOW ID", value: run.workflowId ?? '-' }, "workflow-id"),
+        _jsx(SidebarKV, { label: "WORKFLOW ID", value: run.workflowId }, "workflow-id"),
         _jsx(SidebarKV, { label: "TYPE", value: run.workflowType ?? '-' }, "type"),
         _jsx(SidebarKV, { label: "DURATION", value: duration }, "duration"),
         _jsx(SidebarKV, { label: "START", value: formatDate(run.startedAt) }, "start"),

package/dist/views/dev/panels/runs_panel.js

@@ -40,7 +40,7 @@ const matchesFilter = (run, query) => {
     }
     const q = query.toLowerCase();
     return (run.workflowType ?? '').toLowerCase().includes(q) ||
-        (run.workflowId ?? '').toLowerCase().includes(q) ||
+        run.workflowId.toLowerCase().includes(q) ||
         (run.status ?? '').toLowerCase().includes(q);
 };
 export const buildVisibleRuns = (runs, query) => {
@@ -68,7 +68,7 @@ const RunRow = ({ run, selected }) => {
     const status = run.status ?? 'running';
     const color = workflowStatusColor(status);
     const duration = run.startedAt ? formatDurationCompact(elapsedMs(run.startedAt, run.completedAt)) : '-';
-    return (_jsxs(Box, { children: [_jsx(Box, { width: COL.indicator, children: _jsx(SelectionIndicator, { selected: selected }) }), _jsx(Box, { width: COL.icon, children: _jsx(WorkflowStatusIcon, { status: status }) }), _jsx(Box, { width: COL.status, children: _jsx(Text, { color: color, children: status }) }), _jsx(Box, { width: COL.type, children: _jsx(Text, { bold: selected, children: truncate(run.workflowType ?? '-', COL.type - 1) }) }), _jsx(Box, { width: COL.id, children: _jsx(Text, { dimColor: !selected, children: truncate(run.workflowId ?? '-', COL.id - 1) }) }), _jsx(Box, { width: COL.duration, justifyContent: "flex-end", children: _jsx(Text, { dimColor: !selected, children: duration }) }), _jsx(Box, { width: COL.started, marginLeft: 2, children: _jsx(Text, { dimColor: !selected, children: formatStartedShort(run.startedAt) }) })] }));
+    return (_jsxs(Box, { children: [_jsx(Box, { width: COL.indicator, children: _jsx(SelectionIndicator, { selected: selected }) }), _jsx(Box, { width: COL.icon, children: _jsx(WorkflowStatusIcon, { status: status }) }), _jsx(Box, { width: COL.status, children: _jsx(Text, { color: color, children: status }) }), _jsx(Box, { width: COL.type, children: _jsx(Text, { bold: selected, children: truncate(run.workflowType ?? '-', COL.type - 1) }) }), _jsx(Box, { width: COL.id, children: _jsx(Text, { dimColor: !selected, children: truncate(run.workflowId, COL.id - 1) }) }), _jsx(Box, { width: COL.duration, justifyContent: "flex-end", children: _jsx(Text, { dimColor: !selected, children: duration }) }), _jsx(Box, { width: COL.started, marginLeft: 2, children: _jsx(Text, { dimColor: !selected, children: formatStartedShort(run.startedAt) }) })] }));
 };
 const statusPaneValue = (run, pane) => ({
     status: pane.status,

package/oclif.manifest.json

@@ -762,6 +762,69 @@
         "history.js"
       ]
     },
+    "workflow:input": {
+      "aliases": [],
+      "args": {
+        "workflowId": {
+          "description": "The workflow ID to get the input for",
+          "name": "workflowId",
+          "required": true
+        }
+      },
+      "description": "Get the original input a workflow run was started with",
+      "examples": [
+        "<%= config.bin %> <%= command.id %> wf-12345",
+        "<%= config.bin %> <%= command.id %> wf-12345 --run-id 11111111-2222-4333-8444-555555555555",
+        "<%= config.bin %> <%= command.id %> wf-12345 -o w_input.json",
+        "<%= config.bin %> <%= command.id %> wf-12345 --output-file w_input.json --force"
+      ],
+      "flags": {
+        "json": {
+          "description": "Format output as json.",
+          "helpGroup": "GLOBAL",
+          "name": "json",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "run-id": {
+          "description": "Specific run id to target (defaults to the latest run)",
+          "name": "run-id",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "output-file": {
+          "char": "o",
+          "description": "Write the input JSON to this file instead of stdout",
+          "name": "output-file",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "force": {
+          "char": "f",
+          "description": "Overwrite the output file if it already exists",
+          "name": "force",
+          "allowNo": false,
+          "type": "boolean"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "workflow:input",
+      "pluginAlias": "@outputai/cli",
+      "pluginName": "@outputai/cli",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": true,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "workflow",
+        "input.js"
+      ]
+    },
     "workflow:list": {
       "aliases": [],
       "args": {},
@@ -1317,7 +1380,7 @@
           "required": false
         }
       },
-      "description": "Generate a dataset for a workflow from a scenario, trace file, or S3",
+      "description": "Generate a dataset for a workflow from a scenario, trace file, or recent runs",
       "examples": [
         "<%= config.bin %> <%= command.id %> simple basic_input",
         "<%= config.bin %> <%= command.id %> simple --trace logs/runs/simple/trace.json --name edge_case",
@@ -1361,7 +1424,7 @@
         },
         "download": {
           "char": "d",
-          "description": "Download traces from S3 and create datasets",
+          "description": "Generate datasets from recent workflow runs fetched via the Output API",
           "exclusive": [
             "trace"
           ],
@@ -1371,7 +1434,7 @@
         },
         "limit": {
           "char": "l",
-          "description": "Maximum number of traces to download from S3",
+          "description": "Maximum number of recent runs to fetch",
           "name": "limit",
           "default": 5,
           "hasDynamicHelp": false,
@@ -1534,5 +1597,5 @@
       ]
     }
   },
-  "version": "0.9.3-next.01f20d3.0"
+  "version": "0.9.3-next.105840b.0"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/cli",
-  "version": "0.9.3-next.01f20d3.0",
+  "version": "0.9.3-next.105840b.0",
   "description": "CLI for Output.ai workflow generation",
   "type": "module",
   "main": "dist/index.js",
@@ -18,7 +18,6 @@
   },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "0.2.92",
-    "@aws-sdk/client-s3": "3.1038.0",
     "@hackylabs/deep-redact": "3.0.5",
     "@inquirer/prompts": "8.4.2",
     "@oclif/core": "4.10.6",
@@ -39,9 +38,9 @@
     "semver": "7.7.4",
     "undici": "8.5.0",
     "yaml": "^2.8.3",
-    "@outputai/evals": "0.9.3-next.01f20d3.0",
-    "@outputai/credentials": "0.9.3-next.01f20d3.0",
-    "@outputai/llm": "0.9.3-next.01f20d3.0"
+    "@outputai/credentials": "0.9.3-next.105840b.0",
+    "@outputai/evals": "0.9.3-next.105840b.0",
+    "@outputai/llm": "0.9.3-next.105840b.0"
   },
   "devDependencies": {
     "@types/cli-progress": "3.11.6",

package/dist/services/s3_trace_downloader.d.ts

@@ -1,12 +0,0 @@
-import type { TraceData } from '#types/trace.js';
-interface RemoteTraceInfo {
-    key: string;
-    lastModified?: Date;
-    size?: number;
-}
-export declare function listRemoteTraces(workflowName: string, options?: {
-    limit?: number;
-    since?: Date;
-}): Promise<RemoteTraceInfo[]>;
-export declare function downloadRemoteTrace(key: string): Promise<TraceData>;
-export {};

package/dist/services/s3_trace_downloader.js

@@ -1,57 +0,0 @@
-import { S3Client, ListObjectsV2Command, GetObjectCommand } from '@aws-sdk/client-s3';
-import { config } from '#config.js';
-function getS3Config() {
-    const { bucket, region, accessKeyId, secretAccessKey } = config.s3;
-    if (!bucket || !region || !accessKeyId || !secretAccessKey) {
-        throw new Error('Missing S3 configuration. Set OUTPUT_TRACE_REMOTE_S3_BUCKET, OUTPUT_AWS_REGION, ' +
-            'OUTPUT_AWS_ACCESS_KEY_ID, and OUTPUT_AWS_SECRET_ACCESS_KEY environment variables.');
-    }
-    return { bucket, region, accessKeyId, secretAccessKey };
-}
-function createS3Client(s3Config) {
-    return new S3Client({
-        region: s3Config.region,
-        credentials: {
-            accessKeyId: s3Config.accessKeyId,
-            secretAccessKey: s3Config.secretAccessKey
-        }
-    });
-}
-export async function listRemoteTraces(workflowName, options = {}) {
-    const s3Config = getS3Config();
-    const client = createS3Client(s3Config);
-    const limit = options.limit ?? 20;
-    const command = new ListObjectsV2Command({
-        Bucket: s3Config.bucket,
-        Prefix: `${workflowName}/`,
-        MaxKeys: limit
-    });
-    const response = await client.send(command);
-    const contents = response.Contents ?? [];
-    return contents
-        .filter(obj => {
-        if (!obj.Key) {
-            return false;
-        }
-        if (options.since && obj.LastModified && obj.LastModified < options.since) {
-            return false;
-        }
-        return true;
-    })
-        .map(obj => ({
-        key: obj.Key,
-        lastModified: obj.LastModified,
-        size: obj.Size
-    }));
-}
-export async function downloadRemoteTrace(key) {
-    const s3Config = getS3Config();
-    const client = createS3Client(s3Config);
-    const command = new GetObjectCommand({ Bucket: s3Config.bucket, Key: key });
-    const response = await client.send(command);
-    const body = await response.Body?.transformToString();
-    if (!body) {
-        throw new Error(`Empty response for S3 object: ${key}`);
-    }
-    return JSON.parse(body);
-}