@outputai/cli 0.9.3-next.14a0cfc.0 → 0.9.3-next.5289bca.0

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.14a0cfc.0}
+    image: outputai/api:${OUTPUT_API_VERSION:-0.9.3-next.5289bca.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/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.14a0cfc.0"
+    "framework": "0.9.3-next.5289bca.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/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

@@ -1366,81 +1366,6 @@
         "test_eval.js"
       ]
     },
-    "workflow:runs:list": {
-      "aliases": [],
-      "args": {
-        "workflowName": {
-          "description": "Filter by workflow type/name",
-          "name": "workflowName",
-          "required": false
-        }
-      },
-      "description": "List workflow runs with optional filtering by workflow type",
-      "examples": [
-        "<%= config.bin %> <%= command.id %>",
-        "<%= config.bin %> <%= command.id %> simple",
-        "<%= config.bin %> <%= command.id %> simple --limit 10",
-        "<%= config.bin %> <%= command.id %> --catalog my-catalog",
-        "<%= config.bin %> <%= command.id %> --json",
-        "<%= config.bin %> <%= command.id %> --format table"
-      ],
-      "flags": {
-        "json": {
-          "description": "Format output as json.",
-          "helpGroup": "GLOBAL",
-          "name": "json",
-          "allowNo": false,
-          "type": "boolean"
-        },
-        "catalog": {
-          "char": "c",
-          "description": "Filter runs by catalog (defaults to OUTPUT_CATALOG_ID)",
-          "env": "OUTPUT_CATALOG_ID",
-          "name": "catalog",
-          "hasDynamicHelp": false,
-          "multiple": false,
-          "type": "option"
-        },
-        "limit": {
-          "char": "l",
-          "description": "Maximum number of runs to return",
-          "name": "limit",
-          "default": 100,
-          "hasDynamicHelp": false,
-          "multiple": false,
-          "type": "option"
-        },
-        "format": {
-          "char": "f",
-          "description": "Output format (use --json for JSON output)",
-          "name": "format",
-          "default": "table",
-          "hasDynamicHelp": false,
-          "multiple": false,
-          "options": [
-            "table",
-            "text"
-          ],
-          "type": "option"
-        }
-      },
-      "hasDynamicHelp": false,
-      "hiddenAliases": [],
-      "id": "workflow:runs:list",
-      "pluginAlias": "@outputai/cli",
-      "pluginName": "@outputai/cli",
-      "pluginType": "core",
-      "strict": true,
-      "enableJsonFlag": true,
-      "isESM": true,
-      "relativePath": [
-        "dist",
-        "commands",
-        "workflow",
-        "runs",
-        "list.js"
-      ]
-    },
     "workflow:dataset:generate": {
       "aliases": [],
       "args": {
@@ -1455,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",
@@ -1499,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"
           ],
@@ -1509,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,
@@ -1595,7 +1520,82 @@
         "dataset",
         "list.js"
       ]
+    },
+    "workflow:runs:list": {
+      "aliases": [],
+      "args": {
+        "workflowName": {
+          "description": "Filter by workflow type/name",
+          "name": "workflowName",
+          "required": false
+        }
+      },
+      "description": "List workflow runs with optional filtering by workflow type",
+      "examples": [
+        "<%= config.bin %> <%= command.id %>",
+        "<%= config.bin %> <%= command.id %> simple",
+        "<%= config.bin %> <%= command.id %> simple --limit 10",
+        "<%= config.bin %> <%= command.id %> --catalog my-catalog",
+        "<%= config.bin %> <%= command.id %> --json",
+        "<%= config.bin %> <%= command.id %> --format table"
+      ],
+      "flags": {
+        "json": {
+          "description": "Format output as json.",
+          "helpGroup": "GLOBAL",
+          "name": "json",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "catalog": {
+          "char": "c",
+          "description": "Filter runs by catalog (defaults to OUTPUT_CATALOG_ID)",
+          "env": "OUTPUT_CATALOG_ID",
+          "name": "catalog",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "limit": {
+          "char": "l",
+          "description": "Maximum number of runs to return",
+          "name": "limit",
+          "default": 100,
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "format": {
+          "char": "f",
+          "description": "Output format (use --json for JSON output)",
+          "name": "format",
+          "default": "table",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "options": [
+            "table",
+            "text"
+          ],
+          "type": "option"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "workflow:runs:list",
+      "pluginAlias": "@outputai/cli",
+      "pluginName": "@outputai/cli",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": true,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "workflow",
+        "runs",
+        "list.js"
+      ]
     }
   },
-  "version": "0.9.3-next.14a0cfc.0"
+  "version": "0.9.3-next.5289bca.0"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/cli",
-  "version": "0.9.3-next.14a0cfc.0",
+  "version": "0.9.3-next.5289bca.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/credentials": "0.9.3-next.14a0cfc.0",
-    "@outputai/evals": "0.9.3-next.14a0cfc.0",
-    "@outputai/llm": "0.9.3-next.14a0cfc.0"
+    "@outputai/evals": "0.9.3-next.5289bca.0",
+    "@outputai/llm": "0.9.3-next.5289bca.0",
+    "@outputai/credentials": "0.9.3-next.5289bca.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);
-}