@outputai/cli 0.1.13-dev.01b8dea.0 → 0.1.13-dev.59a1b6d.0

package/dist/api/generated/api.js

@@ -24,11 +24,7 @@ export const WorkflowRunInfoStatus = {
     timed_out: 'timed_out',
     continued: 'continued',
 };
-export const PostWorkflowRun200Status = {
-    completed: 'completed',
-    failed: 'failed',
-};
-export const GetWorkflowIdStatus200Status = {
+export const WorkflowStatusResponseStatus = {
     canceled: 'canceled',
     completed: 'completed',
     continued_as_new: 'continued_as_new',
@@ -38,7 +34,7 @@ export const GetWorkflowIdStatus200Status = {
     timed_out: 'timed_out',
     unspecified: 'unspecified',
 };
-export const GetWorkflowIdResult200Status = {
+export const WorkflowResultResponseStatus = {
     completed: 'completed',
     failed: 'failed',
     canceled: 'canceled',
@@ -46,6 +42,10 @@ export const GetWorkflowIdResult200Status = {
     timed_out: 'timed_out',
     continued: 'continued',
 };
+export const PostWorkflowRun200Status = {
+    completed: 'completed',
+    failed: 'failed',
+};
 ;
 export const getGetHealthUrl = () => {
     return `/health`;
@@ -87,6 +87,24 @@ export const getWorkflowIdStatus = async (id, options) => {
         method: 'GET'
     });
 };
+export const getGetWorkflowIdRunsRidStatusUrl = (id, rid) => {
+    return `/workflow/${id}/runs/${rid}/status`;
+};
+export const getWorkflowIdRunsRidStatus = async (id, rid, options) => {
+    return customFetchInstance(getGetWorkflowIdRunsRidStatusUrl(id, rid), {
+        ...options,
+        method: 'GET'
+    });
+};
+export const getPatchWorkflowIdRunsRidStopUrl = (id, rid) => {
+    return `/workflow/${id}/runs/${rid}/stop`;
+};
+export const patchWorkflowIdRunsRidStop = async (id, rid, options) => {
+    return customFetchInstance(getPatchWorkflowIdRunsRidStopUrl(id, rid), {
+        ...options,
+        method: 'PATCH'
+    });
+};
 export const getPatchWorkflowIdStopUrl = (id) => {
     return `/workflow/${id}/stop`;
 };
@@ -96,6 +114,17 @@ export const patchWorkflowIdStop = async (id, options) => {
         method: 'PATCH'
     });
 };
+export const getPostWorkflowIdRunsRidTerminateUrl = (id, rid) => {
+    return `/workflow/${id}/runs/${rid}/terminate`;
+};
+export const postWorkflowIdRunsRidTerminate = async (id, rid, postWorkflowIdRunsRidTerminateBody, options) => {
+    return customFetchInstance(getPostWorkflowIdRunsRidTerminateUrl(id, rid), {
+        ...options,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(postWorkflowIdRunsRidTerminateBody)
+    });
+};
 export const getPostWorkflowIdTerminateUrl = (id) => {
     return `/workflow/${id}/terminate`;
 };
@@ -107,15 +136,26 @@ export const postWorkflowIdTerminate = async (id, postWorkflowIdTerminateBody, o
         body: JSON.stringify(postWorkflowIdTerminateBody)
     });
 };
+export const getPostWorkflowIdRunsRidResetUrl = (id, rid) => {
+    return `/workflow/${id}/runs/${rid}/reset`;
+};
+export const postWorkflowIdRunsRidReset = async (id, rid, resetWorkflowRequest, options) => {
+    return customFetchInstance(getPostWorkflowIdRunsRidResetUrl(id, rid), {
+        ...options,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(resetWorkflowRequest)
+    });
+};
 export const getPostWorkflowIdResetUrl = (id) => {
     return `/workflow/${id}/reset`;
 };
-export const postWorkflowIdReset = async (id, postWorkflowIdResetBody, options) => {
+export const postWorkflowIdReset = async (id, resetWorkflowRequest, options) => {
     return customFetchInstance(getPostWorkflowIdResetUrl(id), {
         ...options,
         method: 'POST',
         headers: { 'Content-Type': 'application/json', ...options?.headers },
-        body: JSON.stringify(postWorkflowIdResetBody)
+        body: JSON.stringify(resetWorkflowRequest)
     });
 };
 export const getGetWorkflowIdResultUrl = (id) => {
@@ -127,6 +167,15 @@ export const getWorkflowIdResult = async (id, options) => {
         method: 'GET'
     });
 };
+export const getGetWorkflowIdRunsRidResultUrl = (id, rid) => {
+    return `/workflow/${id}/runs/${rid}/result`;
+};
+export const getWorkflowIdRunsRidResult = async (id, rid, options) => {
+    return customFetchInstance(getGetWorkflowIdRunsRidResultUrl(id, rid), {
+        ...options,
+        method: 'GET'
+    });
+};
 export const getGetWorkflowIdTraceLogUrl = (id) => {
     return `/workflow/${id}/trace-log`;
 };
@@ -136,6 +185,15 @@ export const getWorkflowIdTraceLog = async (id, options) => {
         method: 'GET'
     });
 };
+export const getGetWorkflowIdRunsRidTraceLogUrl = (id, rid) => {
+    return `/workflow/${id}/runs/${rid}/trace-log`;
+};
+export const getWorkflowIdRunsRidTraceLog = async (id, rid, options) => {
+    return customFetchInstance(getGetWorkflowIdRunsRidTraceLogUrl(id, rid), {
+        ...options,
+        method: 'GET'
+    });
+};
 export const getGetWorkflowCatalogIdUrl = (id) => {
     return `/workflow/catalog/${id}`;
 };

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

@@ -81,7 +81,7 @@ services:
         condition: service_healthy
       worker:
         condition: service_healthy
-    image: outputai/api:${OUTPUT_API_VERSION:-0.1.13-dev.01b8dea.0}
+    image: outputai/api:${OUTPUT_API_VERSION:-0.1.13-dev.59a1b6d.0}
     init: true
     networks:
       - main

package/dist/commands/credentials/set.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '@oclif/core';
+export default class CredentialsSet extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        path: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        value: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        environment: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        workflow: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/credentials/set.js

@@ -0,0 +1,57 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { load as parseYaml, dump as stringifyYaml } from 'js-yaml';
+import { decryptCredentials, credentialsExist, writeEncrypted, resolveCredentialsPath } from '#services/credentials_service.js';
+const setNestedValue = (obj, dotPath, value) => {
+    const parts = dotPath.split('.');
+    const parent = parts.slice(0, -1).reduce((current, key) => {
+        if (!current[key] || typeof current[key] !== 'object') {
+            current[key] = {};
+        }
+        return current[key];
+    }, obj);
+    parent[parts[parts.length - 1]] = value;
+};
+export default class CredentialsSet extends Command {
+    static description = 'Set a credential value by dot-notation path';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> anthropic.api_key sk-ant-...',
+        '<%= config.bin %> <%= command.id %> openai.api_key sk-... --environment production',
+        '<%= config.bin %> <%= command.id %> stripe.key sk_live_... --workflow my_workflow'
+    ];
+    static args = {
+        path: Args.string({
+            description: 'Dot-notation path to the credential (e.g. anthropic.api_key)',
+            required: true
+        }),
+        value: Args.string({
+            description: 'Value to set',
+            required: true
+        })
+    };
+    static flags = {
+        environment: Flags.string({
+            char: 'e',
+            description: 'Target environment (e.g. production, development)'
+        }),
+        workflow: Flags.string({
+            char: 'w',
+            description: 'Target a specific workflow directory'
+        })
+    };
+    async run() {
+        const { args, flags } = await this.parse(CredentialsSet);
+        const environment = flags.environment;
+        const workflow = flags.workflow;
+        if (environment && workflow) {
+            this.error('Cannot specify both --environment and --workflow.');
+        }
+        if (!credentialsExist(environment, workflow)) {
+            this.error(`No credentials file found at ${resolveCredentialsPath(environment, workflow)}. Run "output credentials init" first.`);
+        }
+        const plaintext = decryptCredentials(environment, workflow);
+        const data = (parseYaml(plaintext) || {});
+        setNestedValue(data, args.path, args.value);
+        writeEncrypted(environment, stringifyYaml(data), workflow);
+        this.log(`Set ${args.path}`);
+    }
+}

package/dist/commands/credentials/set.spec.d.ts

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

package/dist/commands/credentials/set.spec.js

@@ -0,0 +1,95 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import * as credentialsService from '#services/credentials_service.js';
+import CredentialsSet from './set.js';
+vi.mock('#services/credentials_service.js');
+vi.mock('js-yaml', () => ({
+    load: vi.fn((yaml) => {
+        if (yaml.includes('sk-existing')) {
+            return { anthropic: { api_key: 'sk-existing' } };
+        }
+        return {};
+    }),
+    dump: vi.fn((obj) => JSON.stringify(obj))
+}));
+describe('credentials set command', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.mocked(credentialsService.credentialsExist).mockReturnValue(true);
+        vi.mocked(credentialsService.decryptCredentials).mockReturnValue('anthropic:\n  api_key: sk-existing\n');
+        vi.mocked(credentialsService.writeEncrypted).mockImplementation(() => { });
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    const createTestCommand = (parsedArgs = {}, flags = {}) => {
+        const cmd = new CredentialsSet([], {});
+        cmd.log = vi.fn();
+        cmd.error = vi.fn((msg) => {
+            throw new Error(msg);
+        });
+        Object.defineProperty(cmd, 'parse', {
+            value: vi.fn().mockResolvedValue({
+                args: { path: 'anthropic.api_key', value: 'sk-new-key', ...parsedArgs },
+                flags: { environment: undefined, workflow: undefined, ...flags }
+            }),
+            configurable: true
+        });
+        return cmd;
+    };
+    describe('command structure', () => {
+        it('should have correct description', () => {
+            expect(CredentialsSet.description).toContain('credential value');
+        });
+        it('should have required path and value arguments', () => {
+            expect(CredentialsSet.args.path).toBeDefined();
+            expect(CredentialsSet.args.path.required).toBe(true);
+            expect(CredentialsSet.args.value).toBeDefined();
+            expect(CredentialsSet.args.value.required).toBe(true);
+        });
+        it('should have environment and workflow flags', () => {
+            expect(CredentialsSet.flags.environment).toBeDefined();
+            expect(CredentialsSet.flags.workflow).toBeDefined();
+        });
+    });
+    describe('command execution', () => {
+        it('should decrypt, update, and re-encrypt credentials', async () => {
+            const cmd = createTestCommand();
+            await cmd.run();
+            expect(credentialsService.decryptCredentials).toHaveBeenCalledWith(undefined, undefined);
+            expect(credentialsService.writeEncrypted).toHaveBeenCalledWith(undefined, expect.any(String), undefined);
+            expect(cmd.log).toHaveBeenCalledWith('Set anthropic.api_key');
+        });
+        it('should create nested keys that do not exist', async () => {
+            vi.mocked(credentialsService.decryptCredentials).mockReturnValue('');
+            const cmd = createTestCommand({ path: 'new.nested.key', value: 'my-value' });
+            await cmd.run();
+            expect(credentialsService.writeEncrypted).toHaveBeenCalledTimes(1);
+            expect(cmd.log).toHaveBeenCalledWith('Set new.nested.key');
+        });
+        it('should pass environment flag to service functions', async () => {
+            const cmd = createTestCommand({}, { environment: 'production' });
+            await cmd.run();
+            expect(credentialsService.credentialsExist).toHaveBeenCalledWith('production', undefined);
+            expect(credentialsService.decryptCredentials).toHaveBeenCalledWith('production', undefined);
+            expect(credentialsService.writeEncrypted).toHaveBeenCalledWith('production', expect.any(String), undefined);
+        });
+        it('should pass workflow flag to service functions', async () => {
+            const cmd = createTestCommand({}, { workflow: 'my_workflow' });
+            await cmd.run();
+            expect(credentialsService.credentialsExist).toHaveBeenCalledWith(undefined, 'my_workflow');
+            expect(credentialsService.decryptCredentials).toHaveBeenCalledWith(undefined, 'my_workflow');
+            expect(credentialsService.writeEncrypted).toHaveBeenCalledWith(undefined, expect.any(String), 'my_workflow');
+        });
+        it('should error when both environment and workflow are specified', async () => {
+            const cmd = createTestCommand({}, { environment: 'production', workflow: 'my_workflow' });
+            await expect(cmd.run()).rejects.toThrow('Cannot specify both');
+        });
+        it('should error when credentials file does not exist', async () => {
+            vi.mocked(credentialsService.credentialsExist).mockReturnValue(false);
+            vi.mocked(credentialsService.resolveCredentialsPath).mockReturnValue('/project/config/credentials.yml.enc');
+            const cmd = createTestCommand();
+            await expect(cmd.run()).rejects.toThrow('No credentials file found');
+        });
+    });
+});

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

@@ -6,6 +6,7 @@ export default class WorkflowRunsList extends Command {
         workflowName: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
     };
     static flags: {
+        'task-queue': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         limit: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
         format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
     };

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

@@ -65,6 +65,11 @@ export default class WorkflowRunsList extends Command {
         })
     };
     static flags = {
+        'task-queue': Flags.string({
+            char: 'q',
+            description: 'Filter runs by task queue (defaults to OUTPUT_CATALOG_ID)',
+            env: 'OUTPUT_CATALOG_ID'
+        }),
         limit: Flags.integer({
             char: 'l',
             description: 'Maximum number of runs to return',
@@ -81,6 +86,7 @@ export default class WorkflowRunsList extends Command {
         const { args, flags } = await this.parse(WorkflowRunsList);
         const { runs, count } = await fetchWorkflowRuns({
             workflowType: args.workflowName,
+            taskQueue: flags['task-queue'],
             limit: flags.limit
         });
         if (runs.length === 0) {

package/dist/commands/workflow/test_eval.js

@@ -114,7 +114,7 @@ export default class WorkflowTest extends Command {
                 }
             };
             if (save) {
-                const filePath = join(dir, `${dataset.name}.yml`);
+                const filePath = dataset._source ?? join(dir, `${dataset.name}.yml`);
                 await writeDataset(updated, filePath);
                 this.log(`    Saved output to ${filePath}`);
             }
@@ -137,7 +137,7 @@ export default class WorkflowTest extends Command {
                     date: now
                 }
             };
-            const filePath = join(dir, `${dataset.name}.yml`);
+            const filePath = dataset._source ?? join(dir, `${dataset.name}.yml`);
             await writeDataset(updated, filePath);
             this.log(`  Saved eval result to ${filePath}`);
         }

package/dist/generated/framework_version.json

@@ -1,3 +1,3 @@
 {
-    "framework": "0.1.13-dev.01b8dea.0"
+    "framework": "0.1.13-dev.59a1b6d.0"
 }

package/dist/services/datasets.d.ts

@@ -8,7 +8,7 @@ export interface DatasetInfo {
 }
 export declare function resolveDatasetsDir(workflowName: string, basePath?: string): string | null;
 export declare function resolveDefaultDatasetsDir(workflowName: string, basePath?: string): string;
-export declare function readDataset(filePath: string): Promise<Dataset>;
+export declare function readDatasetFile(filePath: string): Promise<Dataset[]>;
 export declare function readAllDatasets(workflowName: string, filterNames?: string[], basePath?: string): Promise<{
     datasets: Dataset[];
     dir: string;

package/dist/services/datasets.js

@@ -24,10 +24,19 @@ export function resolveDefaultDatasetsDir(workflowName, basePath = process.cwd()
     // Default to first workflows path
     return resolve(basePath, WORKFLOWS_PATHS[0], workflowName, DATASETS_DIR);
 }
-export async function readDataset(filePath) {
-    const content = await readFile(filePath, 'utf-8');
-    const raw = yaml.load(content);
-    return DatasetSchema.parse(raw);
+export async function readDatasetFile(filePath) {
+    const raw = yaml.load(await readFile(filePath, 'utf-8'));
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        throw new Error(`Invalid dataset file: ${filePath}`);
+    }
+    return Object.entries(raw).map(([name, body]) => {
+        if (!body || typeof body !== 'object' || !('input' in body)) {
+            throw new Error(`Dataset case "${name}" in ${filePath} is missing required "input" field`);
+        }
+        const dataset = DatasetSchema.parse({ name, ...body });
+        dataset._source = filePath;
+        return dataset;
+    });
 }
 export async function readAllDatasets(workflowName, filterNames, basePath) {
     const dir = resolveDatasetsDir(workflowName, basePath);
@@ -36,42 +45,35 @@ export async function readAllDatasets(workflowName, filterNames, basePath) {
     }
     const files = await readdir(dir);
     const ymlFiles = files.filter(f => f.endsWith('.yml') || f.endsWith('.yaml'));
+    const seen = new Set();
     const datasets = [];
     for (const file of ymlFiles) {
-        const dataset = await readDataset(join(dir, file));
-        if (filterNames && !filterNames.includes(dataset.name)) {
-            continue;
+        const cases = await readDatasetFile(join(dir, file));
+        for (const dataset of cases) {
+            if (seen.has(dataset.name)) {
+                throw new Error(`Duplicate dataset case name "${dataset.name}" found in ${file}`);
+            }
+            seen.add(dataset.name);
+            if (filterNames && !filterNames.includes(dataset.name)) {
+                continue;
+            }
+            datasets.push(dataset);
         }
-        datasets.push(dataset);
     }
     return { datasets, dir };
 }
-async function mergeWithExisting(dataset, filePath) {
-    if (!existsSync(filePath)) {
-        return dataset;
-    }
-    try {
-        const existing = await readDataset(filePath);
-        return {
-            ...existing,
-            ...dataset,
-            ground_truth: dataset.ground_truth ?? existing.ground_truth,
-            last_output: dataset.last_output ?? existing.last_output,
-            last_eval: dataset.last_eval ?? existing.last_eval
-        };
-    }
-    catch {
-        return dataset;
-    }
-}
 export async function writeDataset(dataset, filePath) {
-    const merged = await mergeWithExisting(dataset, filePath);
     const dir = resolve(filePath, '..');
     if (!existsSync(dir)) {
         await mkdir(dir, { recursive: true });
     }
-    const content = yaml.dump(merged, { lineWidth: 120, noRefs: true, sortKeys: false });
-    await writeFile(filePath, content, 'utf-8');
+    const loaded = existsSync(filePath) ? yaml.load(await readFile(filePath, 'utf-8')) : null;
+    const fileObj = (loaded && typeof loaded === 'object' && !Array.isArray(loaded)) ?
+        loaded :
+        {};
+    const { name, _source, ...caseBody } = dataset;
+    fileObj[name] = { ...fileObj[name], ...caseBody };
+    await writeFile(filePath, yaml.dump(fileObj, { lineWidth: 120, noRefs: true, sortKeys: false }), 'utf-8');
 }
 export async function listDatasets(workflowName, basePath) {
     const dir = resolveDatasetsDir(workflowName, basePath);
@@ -84,14 +86,16 @@ export async function listDatasets(workflowName, basePath) {
     for (const file of ymlFiles) {
         const filePath = join(dir, file);
         try {
-            const dataset = await readDataset(filePath);
-            results.push({
-                name: dataset.name,
-                path: filePath,
-                hasLastOutput: dataset.last_output?.output !== undefined,
-                lastOutputDate: dataset.last_output?.date,
-                lastEvalDate: dataset.last_eval?.date
-            });
+            const cases = await readDatasetFile(filePath);
+            for (const dataset of cases) {
+                results.push({
+                    name: dataset.name,
+                    path: filePath,
+                    hasLastOutput: dataset.last_output?.output !== undefined,
+                    lastOutputDate: dataset.last_output?.date,
+                    lastEvalDate: dataset.last_eval?.date
+                });
+            }
         }
         catch {
             results.push({

package/dist/services/datasets.test.d.ts

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