@output.ai/cli 0.5.2 → 0.5.3

package/dist/commands/dev/index.d.ts

@@ -7,5 +7,7 @@ export default class Dev extends Command {
         'compose-file': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'no-watch': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
+    private dockerProcess;
     run(): Promise<void>;
+    private pollServiceStatus;
 }

package/dist/commands/dev/index.js

@@ -1,8 +1,45 @@
 import { Command, Flags } from '@oclif/core';
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { validateDockerEnvironment, startDockerCompose, DockerComposeConfigNotFoundError, getDefaultDockerComposePath } from '#services/docker.js';
+import { validateDockerEnvironment, startDockerCompose, stopDockerCompose, getServiceStatus, DockerComposeConfigNotFoundError, getDefaultDockerComposePath, SERVICE_HEALTH, SERVICE_STATE } from '#services/docker.js';
 import { getErrorMessage } from '#utils/error_utils.js';
+import { getDevSuccessMessage } from '#services/messages.js';
+const ANSI = {
+    RESET: '\x1b[0m',
+    DIM: '\x1b[2m',
+    BOLD: '\x1b[1m',
+    CYAN: '\x1b[36m'
+};
+const STATUS_ICONS = {
+    [SERVICE_HEALTH.HEALTHY]: '●',
+    [SERVICE_HEALTH.UNHEALTHY]: '○',
+    [SERVICE_HEALTH.STARTING]: '◐',
+    [SERVICE_HEALTH.NONE]: '●',
+    [SERVICE_STATE.RUNNING]: '●'
+};
+const STATUS_COLORS = {
+    [SERVICE_HEALTH.HEALTHY]: '\x1b[32m',
+    [SERVICE_HEALTH.UNHEALTHY]: '\x1b[31m',
+    [SERVICE_HEALTH.STARTING]: '\x1b[33m',
+    [SERVICE_HEALTH.NONE]: '\x1b[34m',
+    [SERVICE_STATE.RUNNING]: '\x1b[34m'
+};
+const formatService = (service) => {
+    const healthKey = service.health === SERVICE_HEALTH.NONE ? service.state : service.health;
+    const icon = STATUS_ICONS[healthKey] || '?';
+    const color = STATUS_COLORS[healthKey] || '';
+    const ports = service.ports.length ? service.ports.join(', ') : '-';
+    const status = service.health === SERVICE_HEALTH.NONE ? service.state : service.health;
+    const name = service.name.padEnd(15);
+    const statusPadded = status.padEnd(10);
+    return `  ${color}${icon}${ANSI.RESET} ${name} ${ANSI.DIM}${statusPadded}${ANSI.RESET} ${ANSI.DIM}${ports}${ANSI.RESET}`;
+};
+const poll = async (fn, intervalMs) => {
+    for (;;) {
+        await fn();
+        await new Promise(resolve => setTimeout(resolve, intervalMs));
+    }
+};
 export default class Dev extends Command {
     static description = 'Start Output development services (auto-restarts worker on file changes)';
     static examples = [
@@ -22,6 +59,7 @@ export default class Dev extends Command {
             default: false
         })
     };
+    dockerProcess = null;
     async run() {
         const { flags } = await this.parse(Dev);
         validateDockerEnvironment();
@@ -44,11 +82,56 @@ export default class Dev extends Command {
         else {
             this.log('ℹ️  File watching disabled (--no-watch flag used)\n');
         }
+        const cleanup = async () => {
+            this.log('\n');
+            if (this.dockerProcess) {
+                this.dockerProcess.kill('SIGTERM');
+            }
+            await stopDockerCompose(dockerComposePath);
+            process.exit(0);
+        };
+        process.on('SIGINT', cleanup);
+        process.on('SIGTERM', cleanup);
         try {
-            await startDockerCompose(dockerComposePath, !flags['no-watch']);
+            const { process: dockerProc, waitForHealthy } = await startDockerCompose(dockerComposePath, !flags['no-watch']);
+            this.dockerProcess = dockerProc;
+            dockerProc.on('error', error => {
+                this.error(`Docker process error: ${getErrorMessage(error)}`, { exit: 1 });
+            });
+            this.log('⏳ Waiting for services to become healthy...\n');
+            await waitForHealthy();
+            const services = await getServiceStatus(dockerComposePath);
+            this.log(getDevSuccessMessage(services));
+            await this.pollServiceStatus(dockerComposePath);
         }
         catch (error) {
             this.error(getErrorMessage(error), { exit: 1 });
         }
     }
+    async pollServiceStatus(dockerComposePath) {
+        const state = { lastLineCount: 0 };
+        const outputServiceStatus = async () => {
+            try {
+                const services = await getServiceStatus(dockerComposePath);
+                const lines = [
+                    `${ANSI.BOLD}📊 Service Status${ANSI.RESET}`,
+                    '',
+                    ...services.map(formatService),
+                    '',
+                    `${ANSI.CYAN}🌐 Temporal UI:${ANSI.RESET} ${ANSI.BOLD}http://localhost:8080${ANSI.RESET}`,
+                    '',
+                    `${ANSI.DIM}Press Ctrl+C to stop services${ANSI.RESET}`
+                ];
+                if (state.lastLineCount > 0) {
+                    process.stdout.write(`\x1b[${state.lastLineCount}A\x1b[J`);
+                }
+                process.stdout.write(lines.join('\n') + '\n');
+                state.lastLineCount = lines.length;
+            }
+            catch {
+                // silent retry on next poll
+            }
+        };
+        await poll(outputServiceStatus, 2000);
+    }
 }

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

@@ -5,21 +5,47 @@ import * as dockerService from '#services/docker.js';
 import Dev from './index.js';
 vi.mock('#services/docker.js', () => ({
     validateDockerEnvironment: vi.fn(),
-    startDockerCompose: vi.fn().mockResolvedValue(undefined),
+    startDockerCompose: vi.fn(),
+    stopDockerCompose: vi.fn().mockResolvedValue(undefined),
+    getServiceStatus: vi.fn().mockResolvedValue([
+        { name: 'redis', state: 'running', health: 'healthy', ports: ['6379:6379'] },
+        { name: 'temporal', state: 'running', health: 'healthy', ports: ['7233:7233'] }
+    ]),
     DockerComposeConfigNotFoundError: Error,
     DockerValidationError: Error,
-    getDefaultDockerComposePath: vi.fn(() => '/path/to/docker-compose-dev.yml')
+    getDefaultDockerComposePath: vi.fn(() => '/path/to/docker-compose-dev.yml'),
+    SERVICE_HEALTH: {
+        HEALTHY: 'healthy',
+        UNHEALTHY: 'unhealthy',
+        STARTING: 'starting',
+        NONE: 'none'
+    },
+    SERVICE_STATE: {
+        RUNNING: 'running',
+        EXITED: 'exited'
+    }
 }));
 vi.mock('node:fs/promises', () => ({
     default: {
         access: vi.fn()
     }
 }));
+const createMockDockerProcess = () => ({
+    process: {
+        on: vi.fn(),
+        kill: vi.fn(),
+        stdout: { on: vi.fn() },
+        stderr: { on: vi.fn() }
+    },
+    waitForHealthy: vi.fn().mockResolvedValue(undefined)
+});
 describe('dev command', () => {
     beforeEach(() => {
         vi.clearAllMocks();
         // By default, docker validation succeeds
         vi.mocked(dockerService.validateDockerEnvironment).mockResolvedValue(undefined);
+        // By default, startDockerCompose returns a mock process
+        vi.mocked(dockerService.startDockerCompose).mockResolvedValue(createMockDockerProcess());
         // By default, fs.access succeeds (file exists)
         vi.mocked(fs).access.mockResolvedValue(undefined);
     });
@@ -107,10 +133,15 @@ describe('dev command', () => {
                 value: vi.fn().mockResolvedValue({ flags: { 'no-watch': false, 'compose-file': undefined }, args: {} }),
                 configurable: true
             });
-            await cmd.run();
+            // Run the command but don't await it since it waits forever after startup
+            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', true // enableWatch should be true
             );
             expect(cmd.log).toHaveBeenCalledWith(expect.stringContaining('File watching enabled'));
+            // Cancel the promise (it will be rejected but we don't care)
+            runPromise.catch(() => { });
         });
         it('should disable watch with --no-watch flag', async () => {
             const cmd = new Dev(['--no-watch'], {});
@@ -121,10 +152,15 @@ describe('dev command', () => {
                 value: vi.fn().mockResolvedValue({ flags: { 'no-watch': true, 'compose-file': undefined }, args: {} }),
                 configurable: true
             });
-            await cmd.run();
+            // Run the command but don't await it since it waits forever after startup
+            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', false // enableWatch should be false
             );
             expect(cmd.log).toHaveBeenCalledWith(expect.stringContaining('File watching disabled'));
+            // Cancel the promise (it will be rejected but we don't care)
+            runPromise.catch(() => { });
         });
         it('should handle docker compose configuration not found', async () => {
             vi.mocked(fs).access.mockRejectedValue(new Error('File not found'));

package/dist/config.d.ts

@@ -16,6 +16,11 @@ export declare const config: {
      * Default timeout for API requests (in milliseconds)
      */
     requestTimeout: number;
+    /**
+     * Docker Compose project name
+     * Can be overridden with DOCKER_SERVICE_NAME environment variable
+     */
+    dockerServiceName: string;
 };
 /**
  * Agent configuration directory name

package/dist/config.js

@@ -15,7 +15,12 @@ export const config = {
     /**
      * Default timeout for API requests (in milliseconds)
      */
-    requestTimeout: 30000
+    requestTimeout: 30000,
+    /**
+     * Docker Compose project name
+     * Can be overridden with DOCKER_SERVICE_NAME environment variable
+     */
+    dockerServiceName: process.env.DOCKER_SERVICE_NAME || 'output-sdk'
 };
 /**
  * Agent configuration directory name

package/dist/services/docker.d.ts

@@ -1,5 +1,22 @@
+import { type ChildProcess } from 'node:child_process';
+export declare const SERVICE_HEALTH: {
+    readonly HEALTHY: "healthy";
+    readonly UNHEALTHY: "unhealthy";
+    readonly STARTING: "starting";
+    readonly NONE: "none";
+};
+export declare const SERVICE_STATE: {
+    readonly RUNNING: "running";
+    readonly EXITED: "exited";
+};
 declare class DockerValidationError extends Error {
 }
+export interface ServiceStatus {
+    name: string;
+    state: string;
+    health: string;
+    ports: string[];
+}
 export declare class DockerComposeConfigNotFoundError extends Error {
     constructor(dockerComposePath: string);
 }
@@ -7,6 +24,14 @@ declare const isDockerInstalled: () => boolean;
 declare const isDockerComposeAvailable: () => boolean;
 declare const isDockerDaemonRunning: () => boolean;
 export declare function validateDockerEnvironment(): void;
-export declare function startDockerCompose(dockerComposePath: string, enableWatch?: boolean): Promise<void>;
 export declare function getDefaultDockerComposePath(): string;
+export declare function parseServiceStatus(jsonOutput: string): ServiceStatus[];
+export declare function getServiceStatus(dockerComposePath: string): Promise<ServiceStatus[]>;
+export declare function waitForServicesHealthy(dockerComposePath: string, timeoutMs?: number, pollIntervalMs?: number): Promise<void>;
+export interface DockerComposeProcess {
+    process: ChildProcess;
+    waitForHealthy: () => Promise<void>;
+}
+export declare function startDockerCompose(dockerComposePath: string, enableWatch?: boolean): Promise<DockerComposeProcess>;
+export declare function stopDockerCompose(dockerComposePath: string): Promise<void>;
 export { isDockerInstalled, isDockerComposeAvailable, isDockerDaemonRunning, DockerValidationError };

package/dist/services/docker.js

@@ -1,7 +1,18 @@
-import { execSync, spawn } from 'node:child_process';
+import { execFileSync, execSync, spawn } from 'node:child_process';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { ux } from '@oclif/core';
+const DEFAULT_COMPOSE_PATH = '../assets/docker/docker-compose-dev.yml';
+export const SERVICE_HEALTH = {
+    HEALTHY: 'healthy',
+    UNHEALTHY: 'unhealthy',
+    STARTING: 'starting',
+    NONE: 'none'
+};
+export const SERVICE_STATE = {
+    RUNNING: 'running',
+    EXITED: 'exited'
+};
 class DockerValidationError extends Error {
 }
 export class DockerComposeConfigNotFoundError extends Error {
@@ -42,6 +53,73 @@ export function validateDockerEnvironment() {
         throw new DockerValidationError(failedValidation.error);
     }
 }
+export function getDefaultDockerComposePath() {
+    return path.resolve(path.dirname(fileURLToPath(import.meta.url)), DEFAULT_COMPOSE_PATH);
+}
+export function parseServiceStatus(jsonOutput) {
+    if (!jsonOutput.trim()) {
+        return [];
+    }
+    return jsonOutput
+        .trim()
+        .split('\n')
+        .filter(Boolean)
+        .map(line => {
+        const data = JSON.parse(line);
+        return {
+            name: data.Service || data.Name || 'unknown',
+            state: data.State,
+            health: data.Health || SERVICE_HEALTH.NONE,
+            ports: data.Publishers?.map(p => `${p.PublishedPort}:${p.TargetPort}`) || []
+        };
+    });
+}
+export async function getServiceStatus(dockerComposePath) {
+    const result = execFileSync('docker', ['compose', '-f', dockerComposePath, 'ps', '--format', 'json'], { encoding: 'utf-8', cwd: process.cwd() });
+    return parseServiceStatus(result);
+}
+const STATUS_ICONS = {
+    [SERVICE_HEALTH.HEALTHY]: '✓',
+    [SERVICE_HEALTH.UNHEALTHY]: '✗',
+    [SERVICE_HEALTH.STARTING]: '◐',
+    [SERVICE_HEALTH.NONE]: '✓',
+    [SERVICE_STATE.RUNNING]: '●',
+    [SERVICE_STATE.EXITED]: '✗'
+};
+const STATUS_COLORS = {
+    [SERVICE_HEALTH.HEALTHY]: '\x1b[32m',
+    [SERVICE_HEALTH.UNHEALTHY]: '\x1b[31m',
+    [SERVICE_HEALTH.STARTING]: '\x1b[33m',
+    [SERVICE_HEALTH.NONE]: '\x1b[32m',
+    [SERVICE_STATE.RUNNING]: '\x1b[34m',
+    [SERVICE_STATE.EXITED]: '\x1b[31m'
+};
+const ANSI_RESET = '\x1b[0m';
+const formatServiceStatus = (services) => services.map(s => {
+    const healthKey = s.health === SERVICE_HEALTH.NONE ? s.state : s.health;
+    const icon = STATUS_ICONS[healthKey] || '?';
+    const color = STATUS_COLORS[healthKey] || '';
+    const status = s.health === SERVICE_HEALTH.NONE ? s.state : s.health;
+    return `  ${color}${icon}${ANSI_RESET} ${s.name}: ${status}`;
+}).join('\n');
+export async function waitForServicesHealthy(dockerComposePath, timeoutMs = 120000, pollIntervalMs = 2000) {
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeoutMs) {
+        const services = await getServiceStatus(dockerComposePath);
+        const allHealthy = services.every(s => s.health === SERVICE_HEALTH.HEALTHY || s.health === SERVICE_HEALTH.NONE);
+        if (services.length > 0) {
+            const lineCount = services.length + 1;
+            process.stdout.write(`\x1b[${lineCount}A\x1b[J`);
+            ux.stdout('⏳ Waiting for services to become healthy...\n');
+            ux.stdout(formatServiceStatus(services) + '\n');
+        }
+        if (allHealthy && services.length > 0) {
+            return;
+        }
+        await new Promise(resolve => setTimeout(resolve, pollIntervalMs));
+    }
+    throw new Error('Timeout waiting for services to become healthy');
+}
 export async function startDockerCompose(dockerComposePath, enableWatch = false) {
     const args = [
         'compose',
@@ -52,28 +130,18 @@ export async function startDockerCompose(dockerComposePath, enableWatch = false)
     if (enableWatch) {
         args.push('--watch');
     }
-    const childProcess = spawn('docker', args, {
-        stdio: 'inherit',
-        cwd: process.cwd()
+    ux.stdout('🐳 Starting Docker services...\n');
+    const dockerProcess = spawn('docker', args, {
+        cwd: process.cwd(),
+        stdio: ['ignore', 'pipe', 'pipe']
     });
-    const cleanup = () => {
-        ux.stdout('⏹️  Stopping services...\n');
-        childProcess.kill('SIGTERM');
+    return {
+        process: dockerProcess,
+        waitForHealthy: () => waitForServicesHealthy(dockerComposePath)
     };
-    process.on('SIGINT', cleanup);
-    process.on('SIGTERM', cleanup);
-    return new Promise((resolve, reject) => {
-        childProcess.on('exit', _code => {
-            process.removeListener('SIGINT', cleanup);
-            process.removeListener('SIGTERM', cleanup);
-            resolve();
-        });
-        childProcess.on('error', error => {
-            reject(new Error(`Failed to start services: ${error.message}`));
-        });
-    });
 }
-export function getDefaultDockerComposePath() {
-    return path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../assets/docker/docker-compose-dev.yml');
+export async function stopDockerCompose(dockerComposePath) {
+    ux.stdout('⏹️  Stopping services...\n');
+    execFileSync('docker', ['compose', '-f', dockerComposePath, 'down'], { stdio: 'inherit', cwd: process.cwd() });
 }
 export { isDockerInstalled, isDockerComposeAvailable, isDockerDaemonRunning, DockerValidationError };

package/dist/services/docker.spec.d.ts

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

package/dist/services/docker.spec.js

@@ -0,0 +1,119 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { execFileSync } from 'node:child_process';
+import { parseServiceStatus, getServiceStatus, waitForServicesHealthy } from './docker.js';
+vi.mock('node:child_process', () => ({
+    execSync: vi.fn(),
+    execFileSync: vi.fn(),
+    spawn: vi.fn()
+}));
+describe('docker service', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    describe('parseServiceStatus', () => {
+        it('should parse single service JSON output', () => {
+            const jsonOutput = '{"Service":"redis","State":"running","Health":"healthy","Publishers":[{"PublishedPort":6379,"TargetPort":6379}]}';
+            const result = parseServiceStatus(jsonOutput);
+            expect(result).toHaveLength(1);
+            expect(result[0]).toEqual({
+                name: 'redis',
+                state: 'running',
+                health: 'healthy',
+                ports: ['6379:6379']
+            });
+        });
+        it('should parse multiple services from JSON lines output', () => {
+            const jsonOutput = `{"Service":"redis","State":"running","Health":"healthy","Publishers":[{"PublishedPort":6379,"TargetPort":6379}]}
+{"Service":"temporal","State":"running","Health":"healthy","Publishers":[{"PublishedPort":7233,"TargetPort":7233}]}
+{"Service":"temporal-ui","State":"running","Health":"","Publishers":[{"PublishedPort":8080,"TargetPort":8080}]}`;
+            const result = parseServiceStatus(jsonOutput);
+            expect(result).toHaveLength(3);
+            expect(result[0].name).toBe('redis');
+            expect(result[1].name).toBe('temporal');
+            expect(result[2].name).toBe('temporal-ui');
+        });
+        it('should handle empty health status', () => {
+            const jsonOutput = '{"Service":"api","State":"running","Health":"","Publishers":[]}';
+            const result = parseServiceStatus(jsonOutput);
+            expect(result[0].health).toBe('none');
+        });
+        it('should handle missing Publishers array', () => {
+            const jsonOutput = '{"Service":"worker","State":"running","Health":"healthy"}';
+            const result = parseServiceStatus(jsonOutput);
+            expect(result[0].ports).toEqual([]);
+        });
+        it('should handle empty output', () => {
+            const result = parseServiceStatus('');
+            expect(result).toEqual([]);
+        });
+        it('should filter out empty lines', () => {
+            const jsonOutput = `{"Service":"redis","State":"running","Health":"healthy","Publishers":[]}
+
+{"Service":"api","State":"running","Health":"","Publishers":[]}
+`;
+            const result = parseServiceStatus(jsonOutput);
+            expect(result).toHaveLength(2);
+        });
+        it('should use Name field as fallback when Service is missing', () => {
+            const jsonOutput = '{"Name":"output-sdk-redis-1","State":"running","Health":"healthy","Publishers":[]}';
+            const result = parseServiceStatus(jsonOutput);
+            expect(result[0].name).toBe('output-sdk-redis-1');
+        });
+    });
+    describe('getServiceStatus', () => {
+        it('should call docker compose ps with correct arguments', async () => {
+            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', 'ps', '--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}]}';
+            vi.mocked(execFileSync).mockReturnValue(mockOutput);
+            const result = await getServiceStatus('/path/to/docker-compose.yml');
+            expect(result).toHaveLength(1);
+            expect(result[0].name).toBe('redis');
+        });
+        it('should throw error when docker compose command fails', async () => {
+            vi.mocked(execFileSync).mockImplementation(() => {
+                throw new Error('Docker command failed');
+            });
+            await expect(getServiceStatus('/path/to/docker-compose.yml')).rejects.toThrow();
+        });
+    });
+    describe('waitForServicesHealthy', () => {
+        it('should resolve when all services are healthy', async () => {
+            const mockOutput = `{"Service":"redis","State":"running","Health":"healthy","Publishers":[]}
+{"Service":"temporal","State":"running","Health":"healthy","Publishers":[]}`;
+            vi.mocked(execFileSync).mockReturnValue(mockOutput);
+            await expect(waitForServicesHealthy('/path/to/docker-compose.yml', 5000)).resolves.toBeUndefined();
+        });
+        it('should resolve when services have no health check (health: none)', async () => {
+            const mockOutput = `{"Service":"redis","State":"running","Health":"healthy","Publishers":[]}
+{"Service":"api","State":"running","Health":"","Publishers":[]}`;
+            vi.mocked(execFileSync).mockReturnValue(mockOutput);
+            await expect(waitForServicesHealthy('/path/to/docker-compose.yml', 5000)).resolves.toBeUndefined();
+        });
+        it('should timeout when services remain unhealthy', async () => {
+            const mockOutput = '{"Service":"redis","State":"running","Health":"starting","Publishers":[]}';
+            vi.mocked(execFileSync).mockReturnValue(mockOutput);
+            const promise = waitForServicesHealthy('/path/to/docker-compose.yml', 100);
+            await expect(promise).rejects.toThrow('Timeout waiting for services to become healthy');
+        }, 10000);
+        it('should poll multiple times until healthy', async () => {
+            const callTracker = { count: 0 };
+            vi.mocked(execFileSync).mockImplementation(() => {
+                callTracker.count++;
+                if (callTracker.count < 3) {
+                    return '{"Service":"redis","State":"running","Health":"starting","Publishers":[]}';
+                }
+                return '{"Service":"redis","State":"running","Health":"healthy","Publishers":[]}';
+            });
+            await waitForServicesHealthy('/path/to/docker-compose.yml', 10000, 50);
+            expect(callTracker.count).toBeGreaterThanOrEqual(3);
+        });
+    });
+});

package/dist/services/messages.d.ts

@@ -4,3 +4,6 @@
 export declare const getEjectSuccessMessage: (destPath: string, outputFile: string, binName: string) => string;
 export declare const getProjectSuccessMessage: (folderName: string, installSuccess: boolean, envConfigured?: boolean) => string;
 export declare const getWorkflowGenerateSuccessMessage: (workflowName: string, targetDir: string, filesCreated: string[]) => string;
+export declare const getDevSuccessMessage: (services: Array<{
+    name: string;
+}>) => string;

package/dist/services/messages.js

@@ -2,6 +2,7 @@
  * Success and informational messages for project initialization
  */
 import { ux } from '@oclif/core';
+import { config } from '#config.js';
 /**
  * Creates a colored ASCII art banner for Output.ai
  */
@@ -295,3 +296,43 @@ ${ux.colorize('dim', '💡 Tip: Check the README.md in your workflow directory f
 ${ux.colorize('green', ux.colorize('bold', 'Happy building! 🛠️'))}
 `;
 };
+export const getDevSuccessMessage = (services) => {
+    const divider = ux.colorize('dim', '─'.repeat(80));
+    const bulletPoint = ux.colorize('green', '▸');
+    const serviceNames = services.map(s => s.name).sort().join('|');
+    const logsCommand = `docker compose -p ${config.dockerServiceName} logs -f <${serviceNames}>`;
+    return `
+${divider}
+
+${ux.colorize('bold', ux.colorize('green', '✅ SUCCESS!'))} ${ux.colorize('bold', 'Development services are running')}
+
+${divider}
+
+${createSectionHeader('SERVICES', '🐳')}
+
+  ${bulletPoint} ${ux.colorize('white', 'Temporal:')}     ${formatPath('localhost:7233')}
+  ${bulletPoint} ${ux.colorize('white', 'Temporal UI:')} ${formatCommand('http://localhost:8080')}
+  ${bulletPoint} ${ux.colorize('white', 'API Server:')}  ${formatPath('localhost:3001')}
+  ${bulletPoint} ${ux.colorize('white', 'Redis:')}       ${formatPath('localhost:6379')}
+
+${divider}
+
+${createSectionHeader('RUN A WORKFLOW', '🚀')}
+
+  ${ux.colorize('white', 'In a new terminal, execute:')}
+
+    ${formatCommand('output workflow run simple --input \'{"question": "Hello!"}\'')}
+
+${divider}
+
+${createSectionHeader('USEFUL COMMANDS', '⚡')}
+
+  ${bulletPoint} ${ux.colorize('white', 'Open Temporal UI:')} ${formatCommand('open http://localhost:8080')}
+  ${bulletPoint} ${ux.colorize('white', 'View logs:')}        ${formatCommand(logsCommand)}
+  ${bulletPoint} ${ux.colorize('white', 'Stop services:')}    ${formatCommand('Press Ctrl+C')}
+
+${divider}
+
+${ux.colorize('dim', '💡 Tip: The Temporal UI lets you monitor workflow executions in real-time')}
+`;
+};

package/dist/services/messages.spec.d.ts

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

package/dist/services/messages.spec.js

@@ -0,0 +1,55 @@
+import { describe, it, expect } from 'vitest';
+import { getDevSuccessMessage } from './messages.js';
+const mockServices = [
+    { name: 'api' },
+    { name: 'postgresql' },
+    { name: 'redis' },
+    { name: 'temporal' },
+    { name: 'temporal-ui' },
+    { name: 'worker' }
+];
+describe('messages', () => {
+    describe('getDevSuccessMessage', () => {
+        it('should return a string', () => {
+            const message = getDevSuccessMessage(mockServices);
+            expect(typeof message).toBe('string');
+        });
+        it('should include the Temporal UI URL', () => {
+            const message = getDevSuccessMessage(mockServices);
+            expect(message).toContain('http://localhost:8080');
+        });
+        it('should include the Temporal server address', () => {
+            const message = getDevSuccessMessage(mockServices);
+            expect(message).toContain('localhost:7233');
+        });
+        it('should include the API server address', () => {
+            const message = getDevSuccessMessage(mockServices);
+            expect(message).toContain('localhost:3001');
+        });
+        it('should include workflow run example', () => {
+            const message = getDevSuccessMessage(mockServices);
+            expect(message).toContain('output workflow run');
+        });
+        it('should include success indicator', () => {
+            const message = getDevSuccessMessage(mockServices);
+            expect(message).toContain('SUCCESS');
+        });
+        it('should include services section', () => {
+            const message = getDevSuccessMessage(mockServices);
+            expect(message).toContain('Temporal UI');
+            expect(message).toContain('API Server');
+            expect(message).toContain('Redis');
+        });
+        it('should include helpful tip about Temporal UI', () => {
+            const message = getDevSuccessMessage(mockServices);
+            expect(message).toContain('Temporal UI');
+            expect(message).toContain('workflow');
+        });
+        it('should include dynamic docker logs command with service names', () => {
+            const message = getDevSuccessMessage(mockServices);
+            expect(message).toContain('docker compose -p');
+            expect(message).toContain('logs -f');
+            expect(message).toContain('api|postgresql|redis|temporal|temporal-ui|worker');
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@output.ai/cli",
-  "version": "0.5.2",
+  "version": "0.5.3",
   "description": "CLI for Output.ai workflow generation",
   "type": "module",
   "main": "dist/index.js",