@outputai/cli 0.3.3-next.2650161.0 → 0.3.3-next.33928d3.0

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

@@ -77,7 +77,7 @@ services:
         condition: service_healthy
       worker:
         condition: service_healthy
-    image: outputai/api:${OUTPUT_API_VERSION:-0.3.3-next.2650161.0}
+    image: outputai/api:${OUTPUT_API_VERSION:-0.3.3-next.33928d3.0}
     init: true
     networks:
       - main

package/dist/commands/dev/index.js

@@ -64,7 +64,11 @@ export default class Dev extends Command {
             this.log('✅ Services started. Run `output dev` without --detached to monitor status.\n');
             return;
         }
+        const state = {
+            cleaningUp: false
+        };
         const cleanup = async () => {
+            state.cleaningUp = true;
             this.log('\n');
             if (this.dockerProcess) {
                 this.dockerProcess.kill('SIGTERM');
@@ -115,18 +119,34 @@ export default class Dev extends Command {
         process.on('SIGINT', handleSignal);
         process.on('SIGTERM', handleSignal);
         try {
-            const { process: dockerProc } = await startDockerCompose(dockerComposePath, pullPolicy);
-            this.dockerProcess = dockerProc;
             enterAltScreen();
             const instance = render(React.createElement(DevApp, { dockerComposePath, onCleanup: cleanup }), { exitOnCtrlC: false });
             instanceRef.current = instance;
-            dockerProc.on('error', error => {
-                instance.unmount(new Error(`Docker process error: ${getErrorMessage(error)}`));
+            const dockerProc = await startDockerCompose({
+                dockerComposePath,
+                pullPolicy,
+                onError: error => {
+                    instance.unmount(new Error(`Docker process error: ${getErrorMessage(error)}`));
+                },
+                onExit: (code, signal, output) => {
+                    if (state.cleaningUp) {
+                        return;
+                    }
+                    if (code === 0) {
+                        instance.unmount();
+                        return;
+                    }
+                    const exitReason = signal ? `signal ${signal}` : `code ${code ?? 'unknown'}`;
+                    const detail = output ? `\n\nRecent Docker output:\n${output}` : '';
+                    instance.unmount(new Error(`Docker compose exited with ${exitReason}.${detail}`));
+                }
             });
+            this.dockerProcess = dockerProc;
             await instance.waitUntilExit();
             exitAltScreenOnce();
         }
         catch (error) {
+            instanceRef.current?.unmount();
             exitAltScreenOnce();
             this.error(getErrorMessage(error), { exit: 1 });
         }

package/dist/commands/dev/index.spec.js

@@ -1,6 +1,8 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
+import React from 'react';
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import fs from 'node:fs/promises';
+import { render } from 'ink';
 import * as dockerService from '#services/docker.js';
 import * as codingAgentsService from '#services/coding_agents.js';
 import Dev from './index.js';
@@ -45,13 +47,36 @@ vi.mock('#views/dev/dev_app.js', () => ({
     DevApp: () => null
 }));
 const createMockDockerProcess = () => ({
-    process: {
-        on: vi.fn(),
-        kill: vi.fn(),
-        stdout: { on: vi.fn() },
-        stderr: { on: vi.fn() }
-    }
+    on: vi.fn(),
+    kill: vi.fn(),
+    stdout: { on: vi.fn() },
+    stderr: { on: vi.fn() }
 });
+const getStartDockerComposeOptions = () => {
+    const options = vi.mocked(dockerService.startDockerCompose).mock.calls.at(-1)?.[0];
+    if (!options) {
+        throw new Error('Expected startDockerCompose to receive options');
+    }
+    return options;
+};
+const createControllableInkInstance = () => {
+    const deferred = {};
+    deferred.promise = new Promise((resolve, reject) => {
+        deferred.resolve = resolve;
+        deferred.reject = reject;
+    });
+    const instance = {
+        waitUntilExit: vi.fn(() => deferred.promise),
+        unmount: vi.fn((error) => {
+            if (error) {
+                deferred.reject(error);
+                return;
+            }
+            deferred.resolve();
+        })
+    };
+    return instance;
+};
 describe('dev command', () => {
     beforeEach(() => {
         vi.clearAllMocks();
@@ -182,8 +207,12 @@ describe('dev command', () => {
             const runPromise = cmd.run();
             // Wait a tick for startDockerCompose to be called
             await new Promise(resolve => setImmediate(resolve));
-            expect(dockerService.startDockerCompose).toHaveBeenCalledWith('/path/to/docker-compose-dev.yml', 'always' // default pull policy
-            );
+            expect(dockerService.startDockerCompose).toHaveBeenCalledWith(expect.objectContaining({
+                dockerComposePath: '/path/to/docker-compose-dev.yml',
+                pullPolicy: 'always',
+                onError: expect.any(Function),
+                onExit: expect.any(Function)
+            }));
             // Cancel the promise (it will be rejected but we don't care)
             runPromise.catch(() => { });
         });
@@ -207,6 +236,53 @@ describe('dev command', () => {
             await cmd.run();
             expect(cmd.error).toHaveBeenCalledWith('Docker error', { exit: 1 });
         });
+        it('should surface docker compose exit failures with recent output', async () => {
+            const dockerProcess = createMockDockerProcess();
+            vi.mocked(dockerService.startDockerCompose).mockResolvedValue(dockerProcess);
+            const inkInstance = createControllableInkInstance();
+            vi.mocked(render).mockReturnValue(inkInstance);
+            const cmd = new Dev([], {});
+            cmd.log = vi.fn();
+            cmd.error = vi.fn();
+            Object.defineProperty(cmd, 'parse', {
+                value: vi.fn().mockResolvedValue({ flags: { 'compose-file': undefined, 'image-pull-policy': 'always' }, args: {} }),
+                configurable: true
+            });
+            const runPromise = cmd.run();
+            await new Promise(resolve => setImmediate(resolve));
+            getStartDockerComposeOptions().onExit?.(1, null, 'failed to bind host port');
+            await runPromise;
+            expect(inkInstance.unmount).toHaveBeenCalledWith(expect.objectContaining({
+                message: expect.stringContaining('Docker compose exited with code 1')
+            }));
+            expect(cmd.error).toHaveBeenCalledWith(expect.stringContaining('Recent Docker output:\nfailed to bind host port'), { exit: 1 });
+        });
+        it('should ignore docker compose exits triggered by cleanup', async () => {
+            const dockerProcess = createMockDockerProcess();
+            vi.mocked(dockerService.startDockerCompose).mockResolvedValue(dockerProcess);
+            const inkInstance = createControllableInkInstance();
+            vi.mocked(render).mockReturnValue(inkInstance);
+            const cmd = new Dev([], {});
+            cmd.log = vi.fn();
+            cmd.error = vi.fn();
+            Object.defineProperty(cmd, 'parse', {
+                value: vi.fn().mockResolvedValue({ flags: { 'compose-file': undefined, 'image-pull-policy': 'always' }, args: {} }),
+                configurable: true
+            });
+            const runPromise = cmd.run();
+            await new Promise(resolve => setImmediate(resolve));
+            const appElement = vi.mocked(render).mock.calls[0]?.[0];
+            if (!React.isValidElement(appElement)) {
+                throw new Error('Expected render to receive a React element');
+            }
+            const appProps = appElement.props;
+            await appProps.onCleanup();
+            getStartDockerComposeOptions().onExit?.(null, 'SIGTERM', 'compose stopped');
+            inkInstance.unmount();
+            await runPromise;
+            expect(inkInstance.unmount).not.toHaveBeenCalledWith(expect.any(Error));
+            expect(cmd.error).not.toHaveBeenCalled();
+        });
     });
     describe('image pull policy', () => {
         it('should pass pull policy to startDockerCompose', async () => {
@@ -222,7 +298,12 @@ describe('dev command', () => {
             const runPromise = cmd.run();
             // Wait a tick for startDockerCompose to be called
             await new Promise(resolve => setImmediate(resolve));
-            expect(dockerService.startDockerCompose).toHaveBeenCalledWith('/path/to/docker-compose-dev.yml', 'missing');
+            expect(dockerService.startDockerCompose).toHaveBeenCalledWith(expect.objectContaining({
+                dockerComposePath: '/path/to/docker-compose-dev.yml',
+                pullPolicy: 'missing',
+                onError: expect.any(Function),
+                onExit: expect.any(Function)
+            }));
             // Cancel the promise (it will be rejected but we don't care)
             runPromise.catch(() => { });
         });
@@ -239,7 +320,12 @@ describe('dev command', () => {
             const runPromise = cmd.run();
             // Wait a tick for startDockerCompose to be called
             await new Promise(resolve => setImmediate(resolve));
-            expect(dockerService.startDockerCompose).toHaveBeenCalledWith('/path/to/docker-compose-dev.yml', 'never');
+            expect(dockerService.startDockerCompose).toHaveBeenCalledWith(expect.objectContaining({
+                dockerComposePath: '/path/to/docker-compose-dev.yml',
+                pullPolicy: 'never',
+                onError: expect.any(Function),
+                onExit: expect.any(Function)
+            }));
             // Cancel the promise (it will be rejected but we don't care)
             runPromise.catch(() => { });
         });

package/dist/generated/framework_version.json

@@ -1,3 +1,3 @@
 {
-    "framework": "0.3.3-next.2650161.0"
+    "framework": "0.3.3-next.33928d3.0"
 }

package/dist/services/docker.d.ts

@@ -7,6 +7,7 @@ export declare const SERVICE_HEALTH: {
 };
 export declare const SERVICE_STATE: {
     readonly RUNNING: "running";
+    readonly CREATED: "created";
     readonly EXITED: "exited";
 };
 declare class DockerValidationError extends Error {
@@ -28,11 +29,16 @@ export declare function getServiceStatus(dockerComposePath: string): Promise<Ser
 export declare function isServiceHealthy(service: ServiceStatus): boolean;
 export declare function isServiceFailed(service: ServiceStatus): boolean;
 export declare function waitForServicesHealthy(dockerComposePath: string, timeoutMs?: number, pollIntervalMs?: number): Promise<void>;
-export interface DockerComposeProcess {
-    process: ChildProcess;
+export interface DockerComposeHandlers {
+    onError?: (error: Error, output: string) => void;
+    onExit?: (code: number | null, signal: NodeJS.Signals | null, output: string) => void;
 }
 export type PullPolicy = 'always' | 'missing' | 'never';
-export declare function startDockerCompose(dockerComposePath: string, pullPolicy?: PullPolicy): Promise<DockerComposeProcess>;
+export interface StartDockerComposeOptions extends DockerComposeHandlers {
+    dockerComposePath: string;
+    pullPolicy?: PullPolicy;
+}
+export declare function startDockerCompose({ dockerComposePath, pullPolicy, onError, onExit }: StartDockerComposeOptions): Promise<ChildProcess>;
 export declare function startDockerComposeDetached(dockerComposePath: string, pullPolicy?: PullPolicy): void;
 export declare function stopDockerCompose(dockerComposePath: string): Promise<void>;
 export { isDockerInstalled, DockerValidationError };

package/dist/services/docker.js

@@ -13,6 +13,7 @@ export const SERVICE_HEALTH = {
 };
 export const SERVICE_STATE = {
     RUNNING: 'running',
+    CREATED: 'created',
     EXITED: 'exited'
 };
 class DockerValidationError extends Error {
@@ -101,11 +102,17 @@ export function parseServiceStatus(jsonOutput) {
     });
 }
 export async function getServiceStatus(dockerComposePath) {
-    const result = execFileSync('docker', ['compose', '-f', dockerComposePath, '--project-name', config.dockerServiceName, 'ps', '--all', '--format', 'json'], { encoding: 'utf-8', cwd: process.cwd() });
+    const result = execFileSync('docker', [
+        'compose',
+        '-f', dockerComposePath,
+        '--project-directory', process.cwd(),
+        '--project-name', config.dockerServiceName,
+        'ps', '--all', '--format', 'json'
+    ], { encoding: 'utf-8', cwd: process.cwd() });
     return parseServiceStatus(result);
 }
 export function isServiceHealthy(service) {
-    return service.state !== SERVICE_STATE.EXITED &&
+    return service.state === SERVICE_STATE.RUNNING &&
         (service.health === SERVICE_HEALTH.HEALTHY || service.health === SERVICE_HEALTH.NONE);
 }
 export function isServiceFailed(service) {
@@ -122,7 +129,7 @@ export async function waitForServicesHealthy(dockerComposePath, timeoutMs = 1200
     }
     throw new Error('Timeout waiting for services to become healthy');
 }
-export async function startDockerCompose(dockerComposePath, pullPolicy) {
+export async function startDockerCompose({ dockerComposePath, pullPolicy, onError, onExit }) {
     const args = [
         'compose',
         '-f', dockerComposePath,
@@ -133,11 +140,27 @@ export async function startDockerCompose(dockerComposePath, pullPolicy) {
     if (pullPolicy) {
         args.push('--pull', pullPolicy);
     }
+    const output = {
+        value: ''
+    };
+    const appendOutput = (chunk) => {
+        output.value = `${output.value}${chunk.toString()}`.slice(-20000).trimStart();
+    };
     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']
     });
-    return { process: dockerProcess };
+    dockerProcess.stdout?.on('data', appendOutput);
+    dockerProcess.stderr?.on('data', appendOutput);
+    if (onError) {
+        dockerProcess.on('error', error => onError(error, output.value.trimEnd()));
+    }
+    if (onExit) {
+        dockerProcess.on('exit', (code, signal) => onExit(code, signal, output.value.trimEnd()));
+    }
+    return dockerProcess;
 }
 export function startDockerComposeDetached(dockerComposePath, pullPolicy) {
     const args = [

package/dist/services/docker.spec.js

@@ -6,6 +6,7 @@ vi.mock('node:child_process', () => ({
     execFileSync: vi.fn(),
     spawn: vi.fn()
 }));
+const mockChildProcess = (process) => process;
 vi.mock('log-update', () => {
     const fn = vi.fn();
     fn.done = vi.fn();
@@ -14,6 +15,11 @@ vi.mock('log-update', () => {
 describe('docker service', () => {
     beforeEach(() => {
         vi.clearAllMocks();
+        vi.mocked(spawn).mockReturnValue(mockChildProcess({
+            on: vi.fn(),
+            stdout: { on: vi.fn() },
+            stderr: { on: vi.fn() }
+        }));
     });
     afterEach(() => {
         vi.restoreAllMocks();
@@ -73,7 +79,12 @@ describe('docker service', () => {
             const mockOutput = '{"Service":"redis","State":"running","Health":"healthy","Publishers":[]}';
             vi.mocked(execFileSync).mockReturnValue(mockOutput);
             await getServiceStatus('/path/to/docker-compose.yml');
-            expect(execFileSync).toHaveBeenCalledWith('docker', ['compose', '-f', '/path/to/docker-compose.yml', '--project-name', 'output-sdk', 'ps', '--all', '--format', 'json'], expect.objectContaining({ encoding: 'utf-8' }));
+            expect(execFileSync).toHaveBeenCalledWith('docker', [
+                'compose', '-f', '/path/to/docker-compose.yml',
+                '--project-directory', process.cwd(),
+                '--project-name', 'output-sdk',
+                'ps', '--all', '--format', 'json'
+            ], expect.objectContaining({ encoding: 'utf-8' }));
         });
         it('should return parsed service status', async () => {
             const mockOutput = '{"Service":"redis","State":"running","Health":"healthy","Publishers":[{"PublishedPort":6379,"TargetPort":6379}]}';
@@ -91,7 +102,7 @@ describe('docker service', () => {
     });
     describe('startDockerCompose', () => {
         it('should pass --project-name to docker compose up', async () => {
-            await startDockerCompose('/path/to/docker-compose.yml');
+            await startDockerCompose({ dockerComposePath: '/path/to/docker-compose.yml' });
             expect(spawn).toHaveBeenCalledWith('docker', [
                 'compose', '-f', '/path/to/docker-compose.yml',
                 '--project-directory', process.cwd(),
@@ -100,7 +111,7 @@ describe('docker service', () => {
             ], expect.objectContaining({ stdio: ['ignore', 'pipe', 'pipe'], cwd: process.cwd() }));
         });
         it('should append --pull when pullPolicy is provided', async () => {
-            await startDockerCompose('/path/to/docker-compose.yml', 'always');
+            await startDockerCompose({ dockerComposePath: '/path/to/docker-compose.yml', pullPolicy: 'always' });
             expect(spawn).toHaveBeenCalledWith('docker', [
                 'compose', '-f', '/path/to/docker-compose.yml',
                 '--project-directory', process.cwd(),
@@ -108,6 +119,51 @@ describe('docker service', () => {
                 'up', '--pull', 'always'
             ], expect.objectContaining({ stdio: ['ignore', 'pipe', 'pipe'], cwd: process.cwd() }));
         });
+        it('should attach docker process handlers and pass captured output', async () => {
+            const onError = vi.fn();
+            const onExit = vi.fn();
+            const processHandlers = {};
+            const streamHandlers = {};
+            const process = {
+                on: vi.fn((event, handler) => {
+                    if (event === 'error') {
+                        processHandlers.error = handler;
+                    }
+                    else {
+                        processHandlers.exit = handler;
+                    }
+                    return process;
+                }),
+                stdout: {
+                    on: vi.fn((event, handler) => {
+                        streamHandlers.stdout = handler;
+                        return process.stdout;
+                    })
+                },
+                stderr: {
+                    on: vi.fn((event, handler) => {
+                        streamHandlers.stderr = handler;
+                        return process.stderr;
+                    })
+                }
+            };
+            vi.mocked(spawn).mockReturnValue(mockChildProcess(process));
+            const dockerProcess = await startDockerCompose({
+                dockerComposePath: '/path/to/docker-compose.yml',
+                pullPolicy: 'always',
+                onError,
+                onExit
+            });
+            expect(dockerProcess.on).toHaveBeenCalledWith('error', expect.any(Function));
+            expect(dockerProcess.on).toHaveBeenCalledWith('exit', expect.any(Function));
+            streamHandlers.stdout?.(Buffer.from('starting services\n'));
+            streamHandlers.stderr?.(Buffer.from('compose failed\n'));
+            const error = new Error('Docker failed');
+            processHandlers.error?.(error);
+            processHandlers.exit?.(1, null);
+            expect(onError).toHaveBeenCalledWith(error, 'starting services\ncompose failed');
+            expect(onExit).toHaveBeenCalledWith(1, null, 'starting services\ncompose failed');
+        });
     });
     describe('startDockerComposeDetached', () => {
         it('should pass --project-name and -d to docker compose up', () => {
@@ -176,6 +232,9 @@ describe('docker service', () => {
         it('should return false for an exited service with health: unhealthy', () => {
             expect(isServiceHealthy({ name: 'worker', state: 'exited', health: 'unhealthy', ports: [] })).toBe(false);
         });
+        it('should return false for a created service with no health check', () => {
+            expect(isServiceHealthy({ name: 'api', state: 'created', health: 'none', ports: [] })).toBe(false);
+        });
         it('should return false for a service with health: starting', () => {
             expect(isServiceHealthy({ name: 'temporal', state: 'running', health: 'starting', ports: [] })).toBe(false);
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/cli",
-  "version": "0.3.3-next.2650161.0",
+  "version": "0.3.3-next.33928d3.0",
   "description": "CLI for Output.ai workflow generation",
   "type": "module",
   "main": "dist/index.js",
@@ -36,9 +36,9 @@
     "semver": "7.7.4",
     "undici": "8.1.0",
     "yaml": "^2.8.3",
-    "@outputai/llm": "0.3.3-next.2650161.0",
-    "@outputai/evals": "0.3.3-next.2650161.0",
-    "@outputai/credentials": "0.3.3-next.2650161.0"
+    "@outputai/credentials": "0.3.3-next.33928d3.0",
+    "@outputai/evals": "0.3.3-next.33928d3.0",
+    "@outputai/llm": "0.3.3-next.33928d3.0"
   },
   "devDependencies": {
     "@types/cli-progress": "3.11.6",