@outputai/cli 0.9.2 → 0.9.3-next.14a0cfc.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.2}
+    image: outputai/api:${OUTPUT_API_VERSION:-0.9.3-next.14a0cfc.0}
     init: true
     networks:
       - main

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/generated/framework_version.json

@@ -1,3 +1,3 @@
 {
-    "framework": "0.9.2"
+    "framework": "0.9.3-next.14a0cfc.0"
 }

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/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": {},
@@ -1303,6 +1366,81 @@
         "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": {
@@ -1457,82 +1595,7 @@
         "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.2"
+  "version": "0.9.3-next.14a0cfc.0"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/cli",
-  "version": "0.9.2",
+  "version": "0.9.3-next.14a0cfc.0",
   "description": "CLI for Output.ai workflow generation",
   "type": "module",
   "main": "dist/index.js",
@@ -39,9 +39,9 @@
     "semver": "7.7.4",
     "undici": "8.5.0",
     "yaml": "^2.8.3",
-    "@outputai/credentials": "0.9.2",
-    "@outputai/llm": "0.9.2",
-    "@outputai/evals": "0.9.2"
+    "@outputai/credentials": "0.9.3-next.14a0cfc.0",
+    "@outputai/evals": "0.9.3-next.14a0cfc.0",
+    "@outputai/llm": "0.9.3-next.14a0cfc.0"
   },
   "devDependencies": {
     "@types/cli-progress": "3.11.6",