@outputai/cli 0.10.1-dev.b7b2fbe.0 → 0.10.1-next.1070949.0

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

@@ -59,12 +59,26 @@ describe('workflow run command', () => {
             const { cmd, postWorkflowRun, resolveInput } = await createCommand();
             resolveInput.mockResolvedValue({ key: 'value' });
             postWorkflowRun.mockResolvedValue({
-                data: { status: 'completed', result: { output: 'ok' } },
+                data: {
+                    v: '2',
+                    workflowId: 'wf-1',
+                    runId: 'run-1',
+                    status: 'completed',
+                    input: { key: 'value' },
+                    output: 'ok',
+                    trace: null,
+                    error: null
+                },
                 status: 200,
                 headers: new Headers()
             });
             await cmd.run();
-            expect(resolveInput).toHaveBeenCalledWith('my_workflow', undefined, undefined, 'run', undefined);
+            expect(resolveInput).toHaveBeenCalledWith(expect.objectContaining({
+                workflowName: 'my_workflow',
+                commandName: 'run',
+                catalog: undefined,
+                json: false
+            }));
             expect(postWorkflowRun).toHaveBeenCalledTimes(1);
             expect(postWorkflowRun).toHaveBeenCalledWith({ workflowName: 'my_workflow', input: { key: 'value' }, catalog: undefined }, expect.objectContaining({ config: { timeout: 600000 } }));
             expect(cmd.log).toHaveBeenCalledWith('Executing workflow: my_workflow...');
@@ -78,12 +92,26 @@ describe('workflow run command', () => {
             });
             resolveInput.mockResolvedValue({ key: 'value' });
             postWorkflowRun.mockResolvedValue({
-                data: { status: 'completed', result: {} },
+                data: {
+                    v: '2',
+                    workflowId: 'wf-1',
+                    runId: 'run-1',
+                    status: 'completed',
+                    input: { key: 'value' },
+                    output: {},
+                    trace: null,
+                    error: null
+                },
                 status: 200,
                 headers: new Headers()
             });
             await cmd.run();
-            expect(resolveInput).toHaveBeenCalledWith('my_workflow', 'basic', undefined, 'run', 'my-catalog');
+            expect(resolveInput).toHaveBeenCalledWith(expect.objectContaining({
+                workflowName: 'my_workflow',
+                scenario: 'basic',
+                commandName: 'run',
+                catalog: 'my-catalog'
+            }));
             expect(postWorkflowRun).toHaveBeenCalledWith(expect.objectContaining({ catalog: 'my-catalog' }), expect.anything());
         });
         it('retries when response has Retry-After and succeeds on second attempt', async () => {
@@ -93,7 +121,16 @@ describe('workflow run command', () => {
             postWorkflowRun
                 .mockRejectedValueOnce(new HttpError('Unavailable', { status: 503, headers }))
                 .mockResolvedValueOnce({
-                data: { status: 'completed', result: {} },
+                data: {
+                    v: '2',
+                    workflowId: 'wf-1',
+                    runId: 'run-1',
+                    status: 'completed',
+                    input: {},
+                    output: {},
+                    trace: null,
+                    error: null
+                },
                 status: 200,
                 headers: new Headers()
             });

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

@@ -1,6 +1,8 @@
 import { Command } from '@oclif/core';
+import { type PostWorkflowStart200 } from '#api/generated/api.js';
 export default class WorkflowStart extends Command {
     static description: string;
+    static enableJsonFlag: boolean;
     static examples: string[];
     static args: {
         workflowName: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
@@ -10,6 +12,6 @@ export default class WorkflowStart extends Command {
         input: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         catalog: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
-    run(): Promise<void>;
+    run(): Promise<PostWorkflowStart200>;
     catch(error: Error): Promise<void>;
 }

package/dist/commands/workflow/start.js

@@ -4,11 +4,13 @@ import { handleApiError } from '#utils/error_handler.js';
 import { resolveInput } from '#utils/resolve_input.js';
 export default class WorkflowStart extends Command {
     static description = 'Start a workflow asynchronously without waiting for completion';
+    static enableJsonFlag = true;
     static examples = [
         '<%= config.bin %> <%= command.id %> simple basic_input',
         '<%= config.bin %> <%= command.id %> simple --input \'{"values":[1,2,3]}\'',
         '<%= config.bin %> <%= command.id %> simple --input input.json',
-        '<%= config.bin %> <%= command.id %> simple --input \'{"key":"value"}\' --catalog my-catalog'
+        '<%= config.bin %> <%= command.id %> simple --input \'{"key":"value"}\' --catalog my-catalog',
+        '<%= config.bin %> <%= command.id %> simple --json'
     ];
     static args = {
         workflowName: Args.string({
@@ -37,7 +39,14 @@ export default class WorkflowStart extends Command {
     };
     async run() {
         const { args, flags } = await this.parse(WorkflowStart);
-        const input = await resolveInput(args.workflowName, args.scenario, flags.input, 'start', flags.catalog);
+        const input = await resolveInput({
+            workflowName: args.workflowName,
+            scenario: args.scenario,
+            inputFlag: flags.input,
+            commandName: 'start',
+            catalog: flags.catalog,
+            json: this.jsonEnabled()
+        });
         this.log(`Starting workflow: ${args.workflowName}...`);
         const response = await postWorkflowStart({
             workflowName: args.workflowName,
@@ -57,6 +66,7 @@ export default class WorkflowStart extends Command {
             `Use "workflow result ${result.workflowId || '<workflow-id>'}" to get the workflow result when complete`
         ].join('\n');
         this.log(`\n${output}`);
+        return result;
     }
     async catch(error) {
         return handleApiError(error, (...args) => this.error(...args), {

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

@@ -36,13 +36,17 @@ describe('workflow start command', () => {
             expect(WorkflowStart.flags.catalog.env).toBe('OUTPUT_CATALOG_ID');
             expect(WorkflowStart.flags.catalog.char).toBe('c');
         });
+        it('enables the built-in --json flag', async () => {
+            const WorkflowStart = (await import('./start.js')).default;
+            expect(WorkflowStart.enableJsonFlag).toBe(true);
+        });
     });
     describe('run()', () => {
-        const createCommand = async (flagOverrides = {}) => {
+        const createCommand = async (flagOverrides = {}, argv = ['my_workflow']) => {
             const WorkflowStart = (await import('./start.js')).default;
             const { postWorkflowStart } = await import('#api/generated/api.js');
             const { resolveInput } = await import('#utils/resolve_input.js');
-            const cmd = new WorkflowStart(['my_workflow'], {});
+            const cmd = new WorkflowStart(argv, {});
             cmd.log = vi.fn();
             cmd.error = vi.fn(() => {
                 throw new Error('error called');
@@ -61,9 +65,15 @@ describe('workflow start command', () => {
                 status: 200,
                 headers: new Headers()
             });
-            await cmd.run();
-            expect(resolveInput).toHaveBeenCalledWith('my_workflow', undefined, undefined, 'start', 'my-catalog');
+            const result = await cmd.run();
+            expect(resolveInput).toHaveBeenCalledWith(expect.objectContaining({
+                workflowName: 'my_workflow',
+                commandName: 'start',
+                catalog: 'my-catalog',
+                json: false
+            }));
             expect(postWorkflowStart).toHaveBeenCalledWith(expect.objectContaining({ workflowName: 'my_workflow', catalog: 'my-catalog' }));
+            expect(result).toEqual({ workflowId: 'wf-123' });
         });
         it('passes undefined catalog through when none is set', async () => {
             const { cmd, postWorkflowStart, resolveInput } = await createCommand();
@@ -74,7 +84,22 @@ describe('workflow start command', () => {
                 headers: new Headers()
             });
             await cmd.run();
-            expect(resolveInput).toHaveBeenCalledWith('my_workflow', undefined, undefined, 'start', undefined);
+            expect(resolveInput).toHaveBeenCalledWith(expect.objectContaining({
+                workflowName: 'my_workflow',
+                commandName: 'start',
+                catalog: undefined
+            }));
+        });
+        it('tells resolveInput to stay quiet when --json is set', async () => {
+            const { cmd, postWorkflowStart, resolveInput } = await createCommand({}, ['my_workflow', 'basic', '--json']);
+            resolveInput.mockResolvedValue({});
+            postWorkflowStart.mockResolvedValue({
+                data: { workflowId: 'wf-123' },
+                status: 200,
+                headers: new Headers()
+            });
+            await cmd.run();
+            expect(resolveInput).toHaveBeenCalledWith(expect.objectContaining({ json: true }));
         });
     });
 });

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

@@ -2,7 +2,7 @@ import { describe, it, expect, vi, beforeEach } from 'vitest';
 vi.mock('../../api/generated/api.js', () => ({
     getWorkflowIdStatus: vi.fn(),
     GetWorkflowIdStatus200Status: {
-        canceled: 'canceled',
+        cancelled: 'cancelled',
         completed: 'completed',
         continued_as_new: 'continued_as_new',
         failed: 'failed',

package/dist/commands/workflow/{test_eval.d.ts → test.d.ts}

@@ -1,7 +1,6 @@
 import { Command } from '@oclif/core';
 import type { EvalOutput } from '@outputai/evals';
 export default class WorkflowTest extends Command {
-    static aliases: string[];
     static description: string;
     static enableJsonFlag: boolean;
     static examples: string[];

package/dist/commands/workflow/{test_eval.js → test.js}

@@ -7,7 +7,6 @@ import { diagnoseMissingEvalWorkflow } from '#utils/eval_diagnostics.js';
 import { handleApiError } from '#utils/error_handler.js';
 import { getEvalWorkflowName, renderEvalOutput, computeExitCode, EvalOutputSchema } from '@outputai/evals';
 export default class WorkflowTest extends Command {
-    static aliases = ['workflow:test'];
     static description = 'Run evaluations against a workflow using its datasets';
     static enableJsonFlag = true;
     static examples = [

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

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

package/dist/commands/workflow/{test_eval.spec.js → test.spec.js}

@@ -45,11 +45,11 @@ describe('workflow test command', () => {
     });
     describe('command definition', () => {
         it('enables the built-in --json flag', async () => {
-            const WorkflowTest = (await import('./test_eval.js')).default;
+            const WorkflowTest = (await import('./test.js')).default;
             expect(WorkflowTest.enableJsonFlag).toBe(true);
         });
         it('binds the catalog flag to OUTPUT_CATALOG_ID', async () => {
-            const WorkflowTest = (await import('./test_eval.js')).default;
+            const WorkflowTest = (await import('./test.js')).default;
             expect(WorkflowTest.flags).toHaveProperty('catalog');
             expect(WorkflowTest.flags.catalog.env).toBe('OUTPUT_CATALOG_ID');
             expect(WorkflowTest.flags.catalog.char).toBe('c');
@@ -57,7 +57,7 @@ describe('workflow test command', () => {
     });
     describe('run()', () => {
         const createCommand = async (jsonEnabled) => {
-            const WorkflowTest = (await import('./test_eval.js')).default;
+            const WorkflowTest = (await import('./test.js')).default;
             const { postWorkflowRun } = await import('#api/generated/api.js');
             const cmd = new WorkflowTest(['simple'], {});
             cmd.log = vi.fn();
@@ -99,7 +99,7 @@ describe('workflow test command', () => {
             expect(process.exitCode).toBe(1);
         });
         it('routes registration, dataset runs, and the eval run to the resolved catalog', async () => {
-            const WorkflowTest = (await import('./test_eval.js')).default;
+            const WorkflowTest = (await import('./test.js')).default;
             const { postWorkflowRun } = await import('#api/generated/api.js');
             const { fetchWorkflowCatalog } = await import('#api/workflow_catalog.js');
             const cmd = new WorkflowTest(['my_workflow'], {});

package/dist/generated/framework_version.json

@@ -1,3 +1,3 @@
 {
-    "framework": "0.10.1-dev.b7b2fbe.0"
+    "framework": "0.10.1-next.1070949.0"
 }

package/dist/services/docker.d.ts

@@ -24,10 +24,32 @@ export declare class DockerComposeConfigNotFoundError extends Error {
 declare const isDockerInstalled: () => boolean;
 export declare function validateDockerEnvironment(): void;
 export declare function getDefaultDockerComposePath(): string;
+export declare function resolveDockerComposePath(customPath?: string): Promise<string>;
 export declare function parseServiceStatus(jsonOutput: string): ServiceStatus[];
 export declare function getServiceStatus(dockerComposePath: string): Promise<ServiceStatus[]>;
 export declare function isServiceHealthy(service: ServiceStatus): boolean;
 export declare function isServiceFailed(service: ServiceStatus): boolean;
+export declare const STACK_STATE: {
+    /** Nothing live for this project — a fresh start we own. */
+    readonly NONE: "none";
+    /** Every container found is running and healthy (or has no healthcheck). */
+    readonly RUNNING: "running";
+    /** Something is live but not everything is healthy — reconcile. */
+    readonly PARTIAL: "partial";
+};
+export type StackState = typeof STACK_STATE[keyof typeof STACK_STATE];
+/**
+ * Classify the current state of a project's stack from `docker compose ps`.
+ *
+ * This is the detection signal `output dev` branches on: nothing live means a
+ * fresh start; an all-healthy result means we can attach and monitor without
+ * touching the stack; anything in between is reconciled with `up -d`.
+ *
+ * Scoped to the shared `output-sdk` compose project, which distinguishes our
+ * containers from unrelated processes — but not one Output checkout from
+ * another, since the project name defaults to a machine-global constant.
+ */
+export declare function classifyStackState(services: ServiceStatus[]): StackState;
 export declare function waitForServicesHealthy(dockerComposePath: string, timeoutMs?: number, pollIntervalMs?: number): Promise<void>;
 export interface DockerComposeHandlers {
     onError?: (error: Error, output: string) => void;
@@ -39,6 +61,11 @@ export interface StartDockerComposeOptions extends DockerComposeHandlers {
     pullPolicy?: PullPolicy;
 }
 export declare function startDockerCompose({ dockerComposePath, pullPolicy, onError, onExit }: StartDockerComposeOptions): Promise<ChildProcess>;
-export declare function startDockerComposeDetached(dockerComposePath: string, pullPolicy?: PullPolicy): void;
+export interface DetachedUpResult {
+    code: number | null;
+    signal: NodeJS.Signals | null;
+    output: string;
+}
+export declare function runDockerComposeUpDetached(dockerComposePath: string, pullPolicy?: PullPolicy): Promise<DetachedUpResult>;
 export declare function stopDockerCompose(dockerComposePath: string): Promise<void>;
 export { isDockerInstalled, DockerValidationError };

package/dist/services/docker.js

@@ -1,9 +1,12 @@
 import { execFileSync, execSync, spawn } from 'node:child_process';
+import fs from 'node:fs/promises';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { ux } from '@oclif/core';
 import semver from 'semver';
 import { config } from '#config.js';
+import { getErrorMessage } from '#utils/error_utils.js';
+import { formatComposeFailure } from '#utils/port_collision.js';
 const DEFAULT_COMPOSE_PATH = '../assets/docker/docker-compose-dev.yml';
 export const SERVICE_HEALTH = {
     HEALTHY: 'healthy',
@@ -83,6 +86,22 @@ export function validateDockerEnvironment() {
 export function getDefaultDockerComposePath() {
     return path.resolve(path.dirname(fileURLToPath(import.meta.url)), DEFAULT_COMPOSE_PATH);
 }
+// Resolve the compose file a `dev` command should act on — a caller-supplied
+// path (relative to cwd) or the bundled default — and verify it exists. Shared
+// by `dev` and `dev down` so the resolution rule and not-found error stay in
+// one place.
+export async function resolveDockerComposePath(customPath) {
+    const dockerComposePath = customPath ?
+        path.resolve(process.cwd(), customPath) :
+        getDefaultDockerComposePath();
+    try {
+        await fs.access(dockerComposePath);
+    }
+    catch {
+        throw new DockerComposeConfigNotFoundError(dockerComposePath);
+    }
+    return dockerComposePath;
+}
 export function parseServiceStatus(jsonOutput) {
     if (!jsonOutput.trim()) {
         return [];
@@ -118,6 +137,37 @@ export function isServiceHealthy(service) {
 export function isServiceFailed(service) {
     return service.state === SERVICE_STATE.EXITED || service.health === SERVICE_HEALTH.UNHEALTHY;
 }
+export const STACK_STATE = {
+    /** Nothing live for this project — a fresh start we own. */
+    NONE: 'none',
+    /** Every container found is running and healthy (or has no healthcheck). */
+    RUNNING: 'running',
+    /** Something is live but not everything is healthy — reconcile. */
+    PARTIAL: 'partial'
+};
+/**
+ * Classify the current state of a project's stack from `docker compose ps`.
+ *
+ * This is the detection signal `output dev` branches on: nothing live means a
+ * fresh start; an all-healthy result means we can attach and monitor without
+ * touching the stack; anything in between is reconciled with `up -d`.
+ *
+ * Scoped to the shared `output-sdk` compose project, which distinguishes our
+ * containers from unrelated processes — but not one Output checkout from
+ * another, since the project name defaults to a machine-global constant.
+ */
+export function classifyStackState(services) {
+    // No container is live. `ps --all` also reports exited ones, so a stack left
+    // behind by a reboot, a `docker compose stop`, or a failed teardown lands
+    // here — that's an owned fresh start, not something to attach to.
+    if (!services.some(service => service.state === SERVICE_STATE.RUNNING)) {
+        return STACK_STATE.NONE;
+    }
+    if (services.every(isServiceHealthy)) {
+        return STACK_STATE.RUNNING;
+    }
+    return STACK_STATE.PARTIAL;
+}
 export async function waitForServicesHealthy(dockerComposePath, timeoutMs = 120000, pollIntervalMs = 2000) {
     const startTime = Date.now();
     while (Date.now() - startTime < timeoutMs) {
@@ -129,6 +179,18 @@ export async function waitForServicesHealthy(dockerComposePath, timeoutMs = 1200
     }
     throw new Error('Timeout waiting for services to become healthy');
 }
+// A rolling buffer that retains the last ~20k chars of a spawned process's
+// combined output, so a startup failure can surface recent Docker logs without
+// holding the whole stream. Shared by the two compose spawn sites.
+function createOutputBuffer() {
+    const buffer = { value: '' };
+    return {
+        append: (chunk) => {
+            buffer.value = `${buffer.value}${chunk.toString()}`.slice(-20000).trimStart();
+        },
+        read: () => buffer.value.trimEnd()
+    };
+}
 export async function startDockerCompose({ dockerComposePath, pullPolicy, onError, onExit }) {
     const args = [
         'compose',
@@ -140,29 +202,34 @@ export async function startDockerCompose({ dockerComposePath, pullPolicy, onErro
     if (pullPolicy) {
         args.push('--pull', pullPolicy);
     }
-    const output = {
-        value: ''
-    };
-    const appendOutput = (chunk) => {
-        output.value = `${output.value}${chunk.toString()}`.slice(-20000).trimStart();
-    };
+    const output = createOutputBuffer();
     const dockerProcess = spawn('docker', args, {
         cwd: process.cwd(),
         // The Ink dev UI owns the terminal. Drain compose output so Docker cannot
         // block on a full pipe, while keeping recent output for startup failures.
         stdio: ['ignore', 'pipe', 'pipe']
     });
-    dockerProcess.stdout?.on('data', appendOutput);
-    dockerProcess.stderr?.on('data', appendOutput);
+    dockerProcess.stdout?.on('data', output.append);
+    dockerProcess.stderr?.on('data', output.append);
     if (onError) {
-        dockerProcess.on('error', error => onError(error, output.value.trimEnd()));
+        dockerProcess.on('error', error => onError(error, output.read()));
     }
     if (onExit) {
-        dockerProcess.on('exit', (code, signal) => onExit(code, signal, output.value.trimEnd()));
+        // `close` rather than `exit` so stdio has drained — the buffered output is
+        // what formatComposeFailure greps for a bind failure.
+        dockerProcess.on('close', (code, signal) => onExit(code, signal, output.read()));
     }
     return dockerProcess;
 }
-export function startDockerComposeDetached(dockerComposePath, pullPolicy) {
+// Run `docker compose up -d` to completion, teeing Docker's progress to the
+// user's terminal while retaining recent output. The predecessor used
+// execFileSync with inherited stdio, which threw a raw compose error the caller
+// couldn't inspect; returning the exit code and output lets it surface a
+// port-collision hint instead. Async so image pulls don't block the event loop.
+//
+// Trade-off: piping means Docker sees a non-TTY and drops its redrawing
+// progress bars for plain scrolling lines.
+export function runDockerComposeUpDetached(dockerComposePath, pullPolicy) {
     const args = [
         'compose',
         '-f', dockerComposePath,
@@ -173,7 +240,34 @@ export function startDockerComposeDetached(dockerComposePath, pullPolicy) {
     if (pullPolicy) {
         args.push('--pull', pullPolicy);
     }
-    execFileSync('docker', args, { stdio: 'inherit', cwd: process.cwd() });
+    const output = createOutputBuffer();
+    return new Promise((resolve, reject) => {
+        // Pipe rather than inherit so we can both echo Docker's progress and keep
+        // recent output for a startup-failure hint.
+        const child = spawn('docker', args, {
+            cwd: process.cwd(),
+            stdio: ['ignore', 'pipe', 'pipe']
+        });
+        child.stdout?.on('data', (chunk) => {
+            process.stdout.write(chunk);
+            output.append(chunk);
+        });
+        child.stderr?.on('data', (chunk) => {
+            process.stderr.write(chunk);
+            output.append(chunk);
+        });
+        // `error` fires when the spawn itself failed (docker missing, EACCES).
+        // Reject with the buffered output attached so the caller keeps the context
+        // rather than surfacing a bare `spawn docker ENOENT`.
+        child.on('error', error => {
+            reject(new Error(formatComposeFailure(getErrorMessage(error), output.read(), config.ports)));
+        });
+        // `close`, not `exit`: exit fires while stdio may still be draining, and on
+        // a fast-failing `up -d` — exactly the bind-collision case — the stderr
+        // chunk carrying the bind error can land after it. Resolving early makes
+        // the port-collision hint disappear intermittently.
+        child.on('close', (code, signal) => resolve({ code, signal, output: output.read() }));
+    });
 }
 export async function stopDockerCompose(dockerComposePath) {
     ux.stdout('⏹️  Stopping services...\n');