@outputai/cli 0.1.10 → 0.1.11-next.42e84b1.0

package/bin/run.js

@@ -2,8 +2,10 @@
 
 import { execute } from '@oclif/core';
 import { loadEnvironment } from '../dist/utils/env_loader.js';
+import { resolveCredentialRefs } from '@outputai/credentials';
 
 // Load environment variables from .env files before executing CLI
 loadEnvironment();
+resolveCredentialRefs();
 
 await execute( { dir: import.meta.url } );

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

@@ -81,7 +81,7 @@ services:
         condition: service_healthy
       worker:
         condition: service_healthy
-    image: outputai/api:${OUTPUT_API_VERSION:-0.1.10}
+    image: outputai/api:${OUTPUT_API_VERSION:-0.1.11-next.42e84b1.0}
     init: true
     networks:
       - main
@@ -105,11 +105,11 @@ services:
         condition: service_healthy
     image: node:24.13.0-slim
     healthcheck:
-      test: [ 'CMD', 'npx', '--yes', 'output-healthcheck' ]
+      test: [ 'CMD-SHELL', 'npx output-healthcheck' ]
       interval: 3s
-      timeout: 10s
-      retries: 20
-      start_period: 30s
+      timeout: 3s
+      retries: 2
+      start_period: 60s
     init: true
     networks:
       - main
@@ -118,6 +118,7 @@ services:
         required: false
     environment:
       - NODE_ENV=development
+      - COREPACK_ENABLE_DOWNLOAD_PROMPT=0
       - OUTPUT_CATALOG_ID=${OUTPUT_CATALOG_ID:-main}
       - OUTPUT_REDIS_URL=redis://redis:6379
       - OUTPUT_TRACE_LOCAL_ON=${OUTPUT_TRACE_LOCAL_ON:-true}
@@ -127,6 +128,7 @@ services:
       - NODE_OPTIONS=${NODE_OPTIONS:---max-old-space-size=4096}
     command: >
       sh -c "
+        corepack enable &&
         npm run output:worker:install &&
         echo 'Installed dependencies' &&
         npx nodemon --watch src --watch package.json --ext ts,js,json,prompt --ignore 'dist/**' --ignore '**/*.test.ts' --ignore '**/*.spec.ts' --exec 'npm run output:worker:install && npm run output:worker:build && npm run output:worker:start'

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

@@ -10,5 +10,4 @@ export default class Dev extends Command {
     };
     private dockerProcess;
     run(): Promise<void>;
-    private pollServiceStatus;
 }

package/dist/commands/dev/index.js

@@ -1,74 +1,12 @@
 import { Command, Flags } from '@oclif/core';
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import logUpdate from 'log-update';
-import { validateDockerEnvironment, startDockerCompose, startDockerComposeDetached, stopDockerCompose, getServiceStatus, DockerComposeConfigNotFoundError, getDefaultDockerComposePath, SERVICE_HEALTH, SERVICE_STATE } from '#services/docker.js';
+import { render } from 'ink';
+import React from 'react';
+import { validateDockerEnvironment, startDockerCompose, startDockerComposeDetached, stopDockerCompose, DockerComposeConfigNotFoundError, getDefaultDockerComposePath } from '#services/docker.js';
 import { getErrorMessage } from '#utils/error_utils.js';
-import { getDevSuccessMessage } from '#services/messages.js';
 import { ensureClaudePlugin } from '#services/coding_agents.js';
-const ANSI = {
-    RESET: '\x1b[0m',
-    DIM: '\x1b[2m',
-    BOLD: '\x1b[1m',
-    CYAN: '\x1b[36m',
-    RED: '\x1b[31m',
-    YELLOW: '\x1b[33m',
-    BG_RED: '\x1b[41m',
-    WHITE: '\x1b[37m'
-};
-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[34m',
-    [SERVICE_STATE.RUNNING]: '\x1b[34m',
-    [SERVICE_STATE.EXITED]: '\x1b[31m'
-};
-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 getFailedServicesWarning = (services) => {
-    const failedServices = services.filter(s => s.state === SERVICE_STATE.EXITED);
-    if (failedServices.length === 0) {
-        return [];
-    }
-    const failedNames = failedServices.map(s => s.name);
-    const hasWorkerFailed = failedNames.some(name => name.toLowerCase().includes('worker'));
-    const warningLines = [
-        '',
-        `${ANSI.BG_RED}${ANSI.WHITE}${ANSI.BOLD} ⚠️  SERVICE FAILURE DETECTED ${ANSI.RESET}`,
-        '',
-        `${ANSI.RED}${ANSI.BOLD}Failed services:${ANSI.RESET} ${failedNames.join(', ')}`
-    ];
-    if (hasWorkerFailed) {
-        warningLines.push('', `${ANSI.YELLOW}${ANSI.BOLD}⚡ The worker is not running!${ANSI.RESET}`, `${ANSI.YELLOW}   Workflows will fail until the worker is restarted.${ANSI.RESET}`, '', `${ANSI.DIM}Check the logs with: docker compose logs worker${ANSI.RESET}`);
-    }
-    else {
-        warningLines.push('', `${ANSI.DIM}Check the logs with: docker compose logs <service-name>${ANSI.RESET}`);
-    }
-    return warningLines;
-};
-const poll = async (fn, intervalMs) => {
-    for (;;) {
-        await fn();
-        await new Promise(resolve => setTimeout(resolve, intervalMs));
-    }
-};
+import { DevApp } from '#views/dev.js';
 export default class Dev extends Command {
     static description = 'Start Output development services (auto-restarts worker on file changes)';
     static examples = [
@@ -127,47 +65,24 @@ export default class Dev extends Command {
                 this.dockerProcess.kill('SIGTERM');
             }
             await stopDockerCompose(dockerComposePath);
-            process.exit(0);
         };
-        process.on('SIGINT', cleanup);
-        process.on('SIGTERM', cleanup);
         try {
-            const { process: dockerProc, waitForHealthy } = await startDockerCompose(dockerComposePath, pullPolicy);
+            const { process: dockerProc } = await startDockerCompose(dockerComposePath, pullPolicy);
             this.dockerProcess = dockerProc;
+            const instance = render(React.createElement(DevApp, { dockerComposePath, onCleanup: cleanup }), { exitOnCtrlC: false });
             dockerProc.on('error', error => {
-                this.error(`Docker process error: ${getErrorMessage(error)}`, { exit: 1 });
+                instance.unmount(new Error(`Docker process error: ${getErrorMessage(error)}`));
             });
-            this.log('⏳ Waiting for services to become healthy...\n');
-            await waitForHealthy();
-            const services = await getServiceStatus(dockerComposePath);
-            this.log(getDevSuccessMessage(services));
-            await this.pollServiceStatus(dockerComposePath);
+            const handleSignal = async () => {
+                await cleanup();
+                instance.unmount();
+            };
+            process.on('SIGINT', handleSignal);
+            process.on('SIGTERM', handleSignal);
+            await instance.waitUntilExit();
         }
         catch (error) {
             this.error(getErrorMessage(error), { exit: 1 });
         }
     }
-    async pollServiceStatus(dockerComposePath) {
-        const outputServiceStatus = async () => {
-            try {
-                const services = await getServiceStatus(dockerComposePath);
-                const failureWarning = getFailedServicesWarning(services);
-                const lines = [
-                    `${ANSI.BOLD}📊 Service Status${ANSI.RESET}`,
-                    '',
-                    ...services.map(formatService),
-                    ...failureWarning,
-                    '',
-                    `${ANSI.CYAN}🌐 Temporal UI:${ANSI.RESET} ${ANSI.BOLD}http://localhost:8080${ANSI.RESET}`,
-                    '',
-                    `${ANSI.DIM}Press Ctrl+C to stop services${ANSI.RESET}`
-                ];
-                logUpdate(lines.join('\n'));
-            }
-            catch {
-                // silent retry on next poll
-            }
-        };
-        await poll(outputServiceStatus, 2000);
-    }
 }

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

@@ -15,6 +15,7 @@ vi.mock('#services/docker.js', () => ({
         { name: 'redis', state: 'running', health: 'healthy', ports: ['6379:6379'] },
         { name: 'temporal', state: 'running', health: 'healthy', ports: ['7233:7233'] }
     ]),
+    isServiceFailed: vi.fn((s) => s.state === 'exited' || s.health === 'unhealthy'),
     DockerComposeConfigNotFoundError: Error,
     DockerValidationError: Error,
     getDefaultDockerComposePath: vi.fn(() => '/path/to/docker-compose-dev.yml'),
@@ -34,14 +35,22 @@ vi.mock('node:fs/promises', () => ({
         access: vi.fn()
     }
 }));
+vi.mock('ink', () => ({
+    render: vi.fn().mockReturnValue({
+        waitUntilExit: vi.fn().mockResolvedValue(undefined),
+        unmount: vi.fn()
+    })
+}));
+vi.mock('#views/dev.js', () => ({
+    DevApp: () => null
+}));
 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(() => {

package/dist/commands/init.js

@@ -1,6 +1,7 @@
 import { Args, Command, Flags } from '@oclif/core';
 import { UserCancelledError } from '#types/errors.js';
 import { runInit } from '#services/project_scaffold.js';
+import { getErrorMessage } from '#utils/error_utils.js';
 export default class Init extends Command {
     static description = 'Initialize a new Output project by scaffolding the complete project structure';
     static examples = [
@@ -30,8 +31,7 @@ export default class Init extends Command {
                 return;
             }
             // runInit handles cleanup internally and throws Error with message
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            this.error(errorMessage);
+            this.error(getErrorMessage(error));
         }
     }
 }

package/dist/commands/workflow/generate.js

@@ -5,6 +5,8 @@ import { ensureOutputAISystem } from '#services/coding_agents.js';
 import { getWorkflowGenerateSuccessMessage } from '#services/messages.js';
 import { DEFAULT_OUTPUT_DIRS } from '#utils/paths.js';
 import path from 'node:path';
+import * as fsSync from 'node:fs';
+import { getErrorMessage } from '#utils/error_utils.js';
 export default class Generate extends Command {
     static description = 'Generate a new Output workflow from a skeleton or plan file';
     static examples = [
@@ -52,31 +54,33 @@ export default class Generate extends Command {
         if (!flags.skeleton && !planFile) {
             this.error('Full workflow generation not implemented yet. Please use --skeleton flag or --plan-file');
         }
-        try {
-            const result = await generateWorkflow({
-                name: args.name,
-                description: flags.description,
-                outputDir: flags['output-dir'],
-                skeleton: flags.skeleton,
-                force: flags.force
-            });
-            if (planFile) {
-                this.log('\nStarting AI-assisted workflow implementation...\n');
-                const projectRoot = process.cwd();
-                await ensureOutputAISystem(projectRoot);
-                const absolutePlanPath = path.resolve(projectRoot, planFile);
-                const buildOutput = await buildWorkflow(absolutePlanPath, result.targetDir, args.name);
-                await buildWorkflowInteractiveLoop(buildOutput);
-                this.log(ux.colorize('green', '\nWorkflow implementation complete!\n'));
-            }
-            this.displaySuccess(result);
+        const projectRoot = process.cwd();
+        const absolutePlanPath = planFile ? path.resolve(projectRoot, planFile) : '';
+        if (planFile && !fsSync.existsSync(absolutePlanPath)) {
+            this.error(`Plan file not found: ${absolutePlanPath}`);
         }
-        catch (error) {
-            if (error instanceof Error) {
-                this.error(error.message);
-            }
-            throw error;
+        const result = await generateWorkflow({
+            name: args.name,
+            description: flags.description,
+            outputDir: flags['output-dir'],
+            skeleton: flags.skeleton,
+            force: flags.force
+        }).catch((error) => {
+            this.error(getErrorMessage(error));
+        });
+        if (planFile) {
+            this.log('\nStarting AI-assisted workflow implementation...\n');
+            await ensureOutputAISystem(projectRoot);
+            const buildOutput = await buildWorkflow(absolutePlanPath, result.targetDir, args.name)
+                .catch((error) => {
+                fsSync.rmSync(result.targetDir, { recursive: true, force: true });
+                const message = getErrorMessage(error);
+                this.error(`Workflow implementation failed, created files have been rolled back: ${message}`);
+            });
+            await buildWorkflowInteractiveLoop(buildOutput);
+            this.log(ux.colorize('green', '\nWorkflow implementation complete!\n'));
         }
+        this.displaySuccess(result);
     }
     displaySuccess(result) {
         const message = getWorkflowGenerateSuccessMessage(result.workflowName, result.targetDir, result.filesCreated);

package/dist/commands/workflow/plan.js

@@ -52,7 +52,7 @@ export default class WorkflowPlan extends Command {
         if (modifications === acceptKey) {
             return originalPlanContent;
         }
-        const modifiedPlanContent = await replyToClaude(modifications, PLAN_COMMAND_OPTIONS);
+        const modifiedPlanContent = await replyToClaude(modifications, { anthropicOpts: PLAN_COMMAND_OPTIONS });
         return this.planModificationLoop(modifiedPlanContent);
     }
     async planGenerationLoop(promptDescription, planName, projectRoot) {
@@ -62,5 +62,7 @@ export default class WorkflowPlan extends Command {
         const modifiedPlanContent = await this.planModificationLoop(planContent);
         const modifiedSavedPath = await writePlanFile(planName, modifiedPlanContent, projectRoot);
         this.log(`✅ Plan saved to: ${modifiedSavedPath}\n`);
+        const generateCmd = ux.colorize('cyan', `npx output workflow generate <WORKFLOW_NAME> --plan-file=${modifiedSavedPath}`);
+        this.log(`⏭️  To execute this plan run: ${generateCmd}\n`);
     }
 }

package/dist/generated/framework_version.json

@@ -1,3 +1,3 @@
 {
-    "framework": "0.1.10"
+    "framework": "0.1.11-next.42e84b1.0"
 }

package/dist/services/claude_client.d.ts

@@ -2,13 +2,21 @@
  * Claude Agent SDK client for workflow planning
  */
 import { Options } from '@anthropic-ai/claude-agent-sdk';
+export declare const ADDITIONAL_INSTRUCTIONS: {
+    readonly PLAN: "\n! IMPORTANT !\n1. Use TodoWrite to track your progress through plan creation.\n\n2. Please respond with only the final version of the plan content.\n\n3. Respond in a markdown format with these metadata headers:\n\n---\ntitle: <plan-title>\ndescription: <plan-description>\ndate: <plan-date>\n---\n\n<plan-content>\n\n4. After you mark all todos as complete, you must respond with the final version of the plan.\n\n5. DO NOT write the plan to disk — the CLI will handle saving the file to the plans directory.\n\n6. DO NOT suggest any next steps, follow-up commands, or instructions for the user — the CLI will inform the user of next steps after saving.\n";
+    readonly BUILD: "\n! IMPORTANT !\n1. Use TodoWrite to track your progress through workflow implementation.\n\n2. Follow the implementation plan exactly as specified in the plan file.\n\n3. Implement all workflow files following Output.ai patterns and best practices.\n\n4. After you mark all todos as complete, provide a summary of what was implemented.\n";
+};
 export declare const PLAN_COMMAND_OPTIONS: Options;
+interface ReplyToClaudeOptions {
+    anthropicOpts?: Options;
+    applyAdditionalInstructions?: string;
+}
 export declare const BUILD_COMMAND_OPTIONS: Options;
 export declare class ClaudeInvocationError extends Error {
     cause?: Error | undefined;
     constructor(message: string, cause?: Error | undefined);
 }
-export declare function replyToClaude(message: string, options?: Options): Promise<string>;
+export declare function replyToClaude(message: string, { anthropicOpts, applyAdditionalInstructions }?: ReplyToClaudeOptions): Promise<string>;
 /**
  * Invoke claude-code with /outputai:plan_workflow slash command
  * The SDK loads custom commands from .claude/commands/ when settingSources includes 'project'.
@@ -28,3 +36,4 @@ export declare function invokePlanWorkflow(description: string): Promise<string>
  * @returns Implementation output from claude-code
  */
 export declare function invokeBuildWorkflow(planFilePath: string, workflowDir: string, workflowName: string, additionalInstructions?: string): Promise<string>;
+export {};

package/dist/services/claude_client.js

@@ -6,13 +6,14 @@ import { ux } from '@oclif/core';
 import * as cliProgress from 'cli-progress';
 import { getErrorMessage, toError } from '#utils/error_utils.js';
 import { config } from '#config.js';
-const ADDITIONAL_INSTRUCTIONS = `
+export const ADDITIONAL_INSTRUCTIONS = {
+    PLAN: `
 ! IMPORTANT !
 1. Use TodoWrite to track your progress through plan creation.
 
-2. Please response with only the final version of the plan.
+2. Please respond with only the final version of the plan content.
 
-3. Response in a markdown format with these metadata headers:
+3. Respond in a markdown format with these metadata headers:
 
 ---
 title: <plan-title>
@@ -23,8 +24,12 @@ date: <plan-date>
 <plan-content>
 
 4. After you mark all todos as complete, you must respond with the final version of the plan.
-`;
-const ADDITIONAL_INSTRUCTIONS_BUILD = `
+
+5. DO NOT write the plan to disk — the CLI will handle saving the file to the plans directory.
+
+6. DO NOT suggest any next steps, follow-up commands, or instructions for the user — the CLI will inform the user of next steps after saving.
+`,
+    BUILD: `
 ! IMPORTANT !
 1. Use TodoWrite to track your progress through workflow implementation.
 
@@ -33,7 +38,8 @@ const ADDITIONAL_INSTRUCTIONS_BUILD = `
 3. Implement all workflow files following Output.ai patterns and best practices.
 
 4. After you mark all todos as complete, provide a summary of what was implemented.
-`;
+`
+};
 const PLAN_COMMAND = 'outputai:plan_workflow';
 const BUILD_COMMAND = 'outputai:build_workflow';
 const GLOBAL_CLAUDE_OPTIONS = {
@@ -102,11 +108,8 @@ function getTodoWriteMessage(message) {
     const todoWriteMessage = message.message.content.find((c) => c?.type === 'tool_use' && c.name === 'TodoWrite');
     return todoWriteMessage ?? null;
 }
-function applyInstructions(initialMessage, instructionsType = 'plan') {
-    const instructions = instructionsType === 'build' ?
-        ADDITIONAL_INSTRUCTIONS_BUILD :
-        ADDITIONAL_INSTRUCTIONS;
-    return `${initialMessage}\n\n${instructions}`;
+function applyInstructions(message, instructions) {
+    return `${message}\n\n${instructions}`;
 }
 function createProgressBar() {
     return new cliProgress.SingleBar({
@@ -183,8 +186,8 @@ async function singleQuery(prompt, options = {}) {
         throw new ClaudeInvocationError(`Failed to invoke claude-code: ${getErrorMessage(error)}`, toError(error));
     }
 }
-export async function replyToClaude(message, options = {}) {
-    return singleQuery(applyInstructions(message), { continue: true, ...options });
+export async function replyToClaude(message, { anthropicOpts, applyAdditionalInstructions = ADDITIONAL_INSTRUCTIONS.PLAN } = {}) {
+    return singleQuery(applyInstructions(message, applyAdditionalInstructions), { continue: true, ...anthropicOpts });
 }
 /**
  * Invoke claude-code with /outputai:plan_workflow slash command
@@ -194,7 +197,7 @@ export async function replyToClaude(message, options = {}) {
  * @returns Plan output from claude-code
  */
 export async function invokePlanWorkflow(description) {
-    return singleQuery(applyInstructions(`/${PLAN_COMMAND} ${description}`), PLAN_COMMAND_OPTIONS);
+    return singleQuery(applyInstructions(`/${PLAN_COMMAND} ${description}`, ADDITIONAL_INSTRUCTIONS.PLAN), PLAN_COMMAND_OPTIONS);
 }
 /**
  * Invoke claude-code with /outputai:build_workflow slash command
@@ -211,5 +214,5 @@ export async function invokeBuildWorkflow(planFilePath, workflowDir, workflowNam
     const fullCommand = additionalInstructions ?
         `/${BUILD_COMMAND} ${commandArgs} ${additionalInstructions}` :
         `/${BUILD_COMMAND} ${commandArgs}`;
-    return singleQuery(applyInstructions(fullCommand, 'build'), BUILD_COMMAND_OPTIONS);
+    return singleQuery(applyInstructions(fullCommand, ADDITIONAL_INSTRUCTIONS.BUILD), BUILD_COMMAND_OPTIONS);
 }

package/dist/services/docker.d.ts

@@ -27,10 +27,11 @@ export declare function validateDockerEnvironment(): void;
 export declare function getDefaultDockerComposePath(): 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 function waitForServicesHealthy(dockerComposePath: string, timeoutMs?: number, pollIntervalMs?: number): Promise<void>;
 export interface DockerComposeProcess {
     process: ChildProcess;
-    waitForHealthy: () => Promise<void>;
 }
 export type PullPolicy = 'always' | 'missing' | 'never';
 export declare function startDockerCompose(dockerComposePath: string, pullPolicy?: PullPolicy): Promise<DockerComposeProcess>;

package/dist/services/docker.js

@@ -2,7 +2,6 @@ import { execFileSync, execSync, spawn } from 'node:child_process';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { ux } from '@oclif/core';
-import logUpdate from 'log-update';
 const DEFAULT_COMPOSE_PATH = '../assets/docker/docker-compose-dev.yml';
 export const SERVICE_HEALTH = {
     HEALTHY: 'healthy',
@@ -79,46 +78,22 @@ export async function getServiceStatus(dockerComposePath) {
     const result = execFileSync('docker', ['compose', '-f', dockerComposePath, 'ps', '--all', '--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 function isServiceHealthy(service) {
+    return service.state !== SERVICE_STATE.EXITED &&
+        (service.health === SERVICE_HEALTH.HEALTHY || service.health === SERVICE_HEALTH.NONE);
+}
+export function isServiceFailed(service) {
+    return service.state === SERVICE_STATE.EXITED || service.health === SERVICE_HEALTH.UNHEALTHY;
+}
 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 statusLines = formatServiceStatus(services);
-            logUpdate(`⏳ Waiting for services to become healthy...\n${statusLines}`);
-        }
-        if (allHealthy && services.length > 0) {
-            logUpdate.done();
+        if (services.length > 0 && services.every(isServiceHealthy)) {
             return;
         }
         await new Promise(resolve => setTimeout(resolve, pollIntervalMs));
     }
-    logUpdate.done();
     throw new Error('Timeout waiting for services to become healthy');
 }
 export async function startDockerCompose(dockerComposePath, pullPolicy) {
@@ -136,10 +111,7 @@ export async function startDockerCompose(dockerComposePath, pullPolicy) {
         cwd: process.cwd(),
         stdio: ['ignore', 'pipe', 'pipe']
     });
-    return {
-        process: dockerProcess,
-        waitForHealthy: () => waitForServicesHealthy(dockerComposePath)
-    };
+    return { process: dockerProcess };
 }
 export function startDockerComposeDetached(dockerComposePath, pullPolicy) {
     const args = [

package/dist/services/docker.spec.js

@@ -1,6 +1,6 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { execFileSync } from 'node:child_process';
-import { parseServiceStatus, getServiceStatus, waitForServicesHealthy } from './docker.js';
+import { parseServiceStatus, getServiceStatus, waitForServicesHealthy, isServiceHealthy, isServiceFailed } from './docker.js';
 vi.mock('node:child_process', () => ({
     execSync: vi.fn(),
     execFileSync: vi.fn(),
@@ -89,6 +89,46 @@ describe('docker service', () => {
             await expect(getServiceStatus('/path/to/docker-compose.yml')).rejects.toThrow();
         });
     });
+    describe('isServiceHealthy', () => {
+        it('should return true for a running service with health: healthy', () => {
+            expect(isServiceHealthy({ name: 'redis', state: 'running', health: 'healthy', ports: [] })).toBe(true);
+        });
+        it('should return true for a running service with no health check (health: none)', () => {
+            expect(isServiceHealthy({ name: 'api', state: 'running', health: 'none', ports: [] })).toBe(true);
+        });
+        it('should return false for a running service with health: unhealthy', () => {
+            expect(isServiceHealthy({ name: 'worker', state: 'running', health: 'unhealthy', ports: [] })).toBe(false);
+        });
+        it('should return false for an exited service with health: none', () => {
+            expect(isServiceHealthy({ name: 'worker', state: 'exited', health: 'none', ports: [] })).toBe(false);
+        });
+        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 service with health: starting', () => {
+            expect(isServiceHealthy({ name: 'temporal', state: 'running', health: 'starting', ports: [] })).toBe(false);
+        });
+    });
+    describe('isServiceFailed', () => {
+        it('should return true for an exited service with health: none', () => {
+            expect(isServiceFailed({ name: 'worker', state: 'exited', health: 'none', ports: [] })).toBe(true);
+        });
+        it('should return true for a running service with health: unhealthy', () => {
+            expect(isServiceFailed({ name: 'worker', state: 'running', health: 'unhealthy', ports: [] })).toBe(true);
+        });
+        it('should return true for an exited service with health: unhealthy', () => {
+            expect(isServiceFailed({ name: 'worker', state: 'exited', health: 'unhealthy', ports: [] })).toBe(true);
+        });
+        it('should return false for a running service with health: healthy', () => {
+            expect(isServiceFailed({ name: 'redis', state: 'running', health: 'healthy', ports: [] })).toBe(false);
+        });
+        it('should return false for a running service with health: none', () => {
+            expect(isServiceFailed({ name: 'api', state: 'running', health: 'none', ports: [] })).toBe(false);
+        });
+        it('should return false for a service with health: starting — not a failure, just in progress', () => {
+            expect(isServiceFailed({ name: 'temporal', state: 'running', health: 'starting', ports: [] })).toBe(false);
+        });
+    });
     describe('waitForServicesHealthy', () => {
         it('should resolve when all services are healthy', async () => {
             const mockOutput = `{"Service":"redis","State":"running","Health":"healthy","Publishers":[]}
@@ -108,6 +148,24 @@ describe('docker service', () => {
             const promise = waitForServicesHealthy('/path/to/docker-compose.yml', 100);
             await expect(promise).rejects.toThrow('Timeout waiting for services to become healthy');
         }, 10000);
+        it('should not resolve when a service has exited with no health check — regression OUT-334', async () => {
+            // Exited containers have empty Health which parses to 'none'.
+            // Previously, state:exited + health:none was incorrectly treated as healthy.
+            const mockOutput = `{"Service":"redis","State":"running","Health":"healthy","Publishers":[]}
+{"Service":"worker","State":"exited","Health":"","Publishers":[]}`;
+            vi.mocked(execFileSync).mockReturnValue(mockOutput);
+            const promise = waitForServicesHealthy('/path/to/docker-compose.yml', 100, 50);
+            await expect(promise).rejects.toThrow('Timeout waiting for services to become healthy');
+        }, 10000);
+        it('should not resolve when a service is running but unhealthy — regression OUT-334', async () => {
+            // Nodemon keeps the container running even when the exec'd command fails,
+            // so the unhealthy case is state:running + health:unhealthy.
+            const mockOutput = `{"Service":"redis","State":"running","Health":"healthy","Publishers":[]}
+{"Service":"worker","State":"running","Health":"unhealthy","Publishers":[]}`;
+            vi.mocked(execFileSync).mockReturnValue(mockOutput);
+            const promise = waitForServicesHealthy('/path/to/docker-compose.yml', 100, 50);
+            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(() => {

package/dist/services/messages.d.ts

@@ -4,6 +4,3 @@
 export declare const getEjectSuccessMessage: (destPath: string, outputFile: string, binName: string) => string;
 export declare const getProjectSuccessMessage: (folderName: string, installSuccess: boolean, credentialsConfigured?: 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,7 +2,6 @@
  * 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
  */
@@ -299,43 +298,3 @@ ${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('npx output workflow run blog_evaluator paulgraham_hwh')}
-
-${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/project_scaffold.js

@@ -139,8 +139,7 @@ function formatInitError(error, projectPath) {
         case 'EPERM': return `Operation not permitted${pathSuffix}`;
         case 'ENOENT': return `Required file or directory not found${pathSuffix}`;
         default: {
-            const originalMessage = error instanceof Error ? error.message : String(error);
-            return `Failed to create project${pathSuffix}: ${originalMessage}`;
+            return `Failed to create project${pathSuffix}: ${getErrorMessage(error)}`;
         }
     }
 }

package/dist/services/workflow_builder.js

@@ -1,7 +1,7 @@
 /**
  * Workflow builder service for implementing workflows from plan files
  */
-import { BUILD_COMMAND_OPTIONS, invokeBuildWorkflow as invokeBuildWorkflowFromClient, replyToClaude } from './claude_client.js';
+import { ADDITIONAL_INSTRUCTIONS, BUILD_COMMAND_OPTIONS, invokeBuildWorkflow as invokeBuildWorkflowFromClient, replyToClaude } from './claude_client.js';
 import { input } from '@inquirer/prompts';
 import { ux } from '@oclif/core';
 import fs from 'node:fs/promises';
@@ -56,12 +56,15 @@ async function processModification(modification, currentOutput) {
         return currentOutput;
     }
     try {
-        const updatedOutput = await replyToClaude(modification, BUILD_COMMAND_OPTIONS);
+        const updatedOutput = await replyToClaude(modification, {
+            anthropicOpts: BUILD_COMMAND_OPTIONS,
+            applyAdditionalInstructions: ADDITIONAL_INSTRUCTIONS.BUILD
+        });
         displayImplementationOutput(updatedOutput, '✓ Implementation updated!');
         return updatedOutput;
     }
     catch (error) {
-        ux.error(`Failed to apply modifications: ${getErrorMessage(error)}`);
+        ux.stdout(ux.colorize('red', `Failed to apply modifications: ${getErrorMessage(error)}`));
         ux.stdout('Continuing with previous version...\n');
         return currentOutput;
     }

package/dist/services/workflow_builder.spec.js

@@ -1,6 +1,6 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest';
 import { buildWorkflow, buildWorkflowInteractiveLoop } from './workflow_builder.js';
-import { BUILD_COMMAND_OPTIONS, invokeBuildWorkflow, replyToClaude } from './claude_client.js';
+import { ADDITIONAL_INSTRUCTIONS, BUILD_COMMAND_OPTIONS, invokeBuildWorkflow, replyToClaude } from './claude_client.js';
 import { input } from '@inquirer/prompts';
 import { ux } from '@oclif/core';
 import fs from 'node:fs/promises';
@@ -97,7 +97,10 @@ describe('workflow-builder service', () => {
                 .mockResolvedValueOnce('ACCEPT');
             vi.mocked(replyToClaude).mockResolvedValue('Updated implementation with error handling');
             const result = await buildWorkflowInteractiveLoop('Initial implementation');
-            expect(replyToClaude).toHaveBeenCalledWith('Add error handling', BUILD_COMMAND_OPTIONS);
+            expect(replyToClaude).toHaveBeenCalledWith('Add error handling', {
+                anthropicOpts: BUILD_COMMAND_OPTIONS,
+                applyAdditionalInstructions: ADDITIONAL_INSTRUCTIONS.BUILD
+            });
             expect(result).toBe('Updated implementation with error handling');
             expect(input).toHaveBeenCalledTimes(2);
         });
@@ -111,8 +114,14 @@ describe('workflow-builder service', () => {
                 .mockResolvedValueOnce('Implementation with logging and validation');
             const result = await buildWorkflowInteractiveLoop('Initial implementation');
             expect(replyToClaude).toHaveBeenCalledTimes(2);
-            expect(replyToClaude).toHaveBeenNthCalledWith(1, 'Add logging', BUILD_COMMAND_OPTIONS);
-            expect(replyToClaude).toHaveBeenNthCalledWith(2, 'Add validation', BUILD_COMMAND_OPTIONS);
+            expect(replyToClaude).toHaveBeenNthCalledWith(1, 'Add logging', {
+                anthropicOpts: BUILD_COMMAND_OPTIONS,
+                applyAdditionalInstructions: ADDITIONAL_INSTRUCTIONS.BUILD
+            });
+            expect(replyToClaude).toHaveBeenNthCalledWith(2, 'Add validation', {
+                anthropicOpts: BUILD_COMMAND_OPTIONS,
+                applyAdditionalInstructions: ADDITIONAL_INSTRUCTIONS.BUILD
+            });
             expect(result).toBe('Implementation with logging and validation');
         });
         it('should prompt again when user provides empty input', async () => {
@@ -146,7 +155,7 @@ describe('workflow-builder service', () => {
             const result = await buildWorkflowInteractiveLoop('Original implementation');
             // Should return original implementation after error
             expect(result).toBe('Original implementation');
-            expect(ux.error).toHaveBeenCalledWith(expect.stringContaining('Failed to apply modifications'));
+            expect(ux.stdout).toHaveBeenCalledWith(expect.stringContaining('Failed to apply modifications'));
             expect(ux.stdout).toHaveBeenCalledWith(expect.stringContaining('Continuing with previous version'));
         });
         it('should continue looping after handling error', async () => {

package/dist/services/workflow_generator.js

@@ -15,9 +15,9 @@ function validateConfig(config) {
  * Check if target directory exists and handle accordingly
  */
 import * as fsSync from 'node:fs';
-async function checkTargetDirectory(targetDir, force) {
+async function checkTargetDirectory(name, targetDir, force) {
     if (fsSync.existsSync(targetDir) && !force) {
-        throw new WorkflowExistsError('', targetDir);
+        throw new WorkflowExistsError(name, targetDir);
     }
 }
 /**
@@ -27,7 +27,7 @@ export async function generateWorkflow(config) {
     validateConfig(config);
     const targetDir = createTargetDir(config.outputDir, config.name);
     const templatesDir = getTemplateDir('workflow');
-    await checkTargetDirectory(targetDir, config.force);
+    await checkTargetDirectory(config.name, targetDir, config.force);
     await fs.mkdir(targetDir, { recursive: true });
     const variables = prepareTemplateVariables(config.name, config.description || '');
     const templateFiles = await getTemplateFiles(templatesDir);

package/dist/types/domain.d.ts

@@ -3,7 +3,6 @@
  */
 export type TodoStatus = 'pending' | 'in_progress' | 'completed';
 export type FileMappingType = 'template' | 'symlink' | 'copy';
-export type InstructionsType = 'plan' | 'build';
 export interface Todo {
     content: string;
     activeForm: string;

package/dist/views/dev.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+export declare const DevApp: React.FC<{
+    dockerComposePath: string;
+    onCleanup: () => Promise<void>;
+}>;

package/dist/views/dev.js

@@ -0,0 +1,144 @@
+import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { useState, useEffect, useRef } from 'react';
+import { Box, Text, Static, useApp, useInput } from 'ink';
+import Spinner from 'ink-spinner';
+import { getServiceStatus, isServiceHealthy, isServiceFailed, SERVICE_HEALTH, SERVICE_STATE } from '#services/docker.js';
+import { config } from '#config.js';
+const POLL_INTERVAL_MS = 2000;
+const HEALTH_TIMEOUT_MS = 120_000;
+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]: 'green',
+    [SERVICE_HEALTH.UNHEALTHY]: 'red',
+    [SERVICE_HEALTH.STARTING]: 'yellow',
+    [SERVICE_HEALTH.NONE]: 'blue',
+    [SERVICE_STATE.RUNNING]: 'blue',
+    [SERVICE_STATE.EXITED]: 'red'
+};
+const resolveServiceDisplay = (service) => {
+    const key = service.health === SERVICE_HEALTH.NONE ? service.state : service.health;
+    return { icon: STATUS_ICONS[key] ?? '?', color: STATUS_COLORS[key] ?? 'white', status: key };
+};
+const fetchServices = async (dockerComposePath) => {
+    try {
+        return await getServiceStatus(dockerComposePath);
+    }
+    catch {
+        return null;
+    }
+};
+const usePoll = (enabled, onTick) => {
+    const onTickRef = useRef(onTick);
+    onTickRef.current = onTick;
+    useEffect(() => {
+        const state = {
+            active: true,
+            timeout: undefined
+        };
+        const run = async () => {
+            if (!state.active) {
+                return;
+            }
+            const result = await onTickRef.current();
+            if (!state.active || result === 'done') {
+                return;
+            }
+            state.timeout = setTimeout(run, POLL_INTERVAL_MS);
+        };
+        if (enabled) {
+            void run();
+        }
+        return () => {
+            state.active = false;
+            clearTimeout(state.timeout);
+        };
+    }, [enabled]);
+};
+const useHealthPolling = (dockerComposePath, enabled, callbacks) => {
+    const callbacksRef = useRef(callbacks);
+    callbacksRef.current = callbacks;
+    const startTimeRef = useRef(Date.now());
+    usePoll(enabled, async () => {
+        if (Date.now() - startTimeRef.current > HEALTH_TIMEOUT_MS) {
+            callbacksRef.current.onTimeout();
+            return 'done';
+        }
+        const svcs = await fetchServices(dockerComposePath);
+        if (svcs === null) {
+            return 'continue';
+        }
+        callbacksRef.current.onServices(svcs);
+        if (svcs.length > 0 && svcs.every(isServiceHealthy)) {
+            callbacksRef.current.onAllHealthy(svcs);
+            return 'done';
+        }
+        return 'continue';
+    });
+};
+const useStatusRefresh = (dockerComposePath, enabled, onServices) => {
+    const onServicesRef = useRef(onServices);
+    onServicesRef.current = onServices;
+    usePoll(enabled, async () => {
+        const svcs = await fetchServices(dockerComposePath);
+        if (svcs !== null) {
+            onServicesRef.current(svcs);
+        }
+        return 'continue';
+    });
+};
+const useCtrlC = (onCleanup) => {
+    const { exit } = useApp();
+    const isExitingRef = useRef(false);
+    useInput((input, key) => {
+        if (key.ctrl && input === 'c' && !isExitingRef.current) {
+            isExitingRef.current = true;
+            void onCleanup().then(() => exit()).catch(err => exit(err instanceof Error ? err : new Error(String(err))));
+        }
+    });
+};
+const ServiceRow = ({ service }) => {
+    const { icon, color, status } = resolveServiceDisplay(service);
+    const ports = service.ports.length ? service.ports.join(', ') : '-';
+    return (_jsxs(Box, { children: [_jsxs(Text, { color: color, children: [icon, " "] }), _jsx(Box, { width: 16, children: _jsx(Text, { children: service.name }) }), _jsx(Text, { dimColor: true, children: status.padEnd(10) }), _jsx(Text, { dimColor: true, children: ports })] }));
+};
+const FailureWarning = ({ services }) => {
+    const failed = services.filter(isServiceFailed);
+    if (failed.length === 0) {
+        return null;
+    }
+    const failedNames = failed.map(s => s.name).join(', ');
+    const hasWorker = failed.some(s => s.name.toLowerCase().includes('worker'));
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Box, { children: _jsx(Text, { backgroundColor: "red", color: "white", bold: true, children: " \u26A0\uFE0F  SERVICE FAILURE DETECTED " }) }), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: "red", bold: true, children: "Failed services: " }), _jsx(Text, { children: failedNames })] }), hasWorker ? (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { color: "yellow", bold: true, children: "\u26A1 The worker is not running!" }), _jsx(Text, { color: "yellow", children: '   Workflows will fail until the worker is restarted.' }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Check the logs with: docker compose logs worker" }) })] })) : (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: 'Check the logs with: docker compose logs <service-name>' }) }))] }));
+};
+const DevSuccessMessage = ({ services }) => {
+    const divider = '─'.repeat(80);
+    const sortedNames = services.map(s => s.name).sort().join('|');
+    const logsCommand = `docker compose -p ${config.dockerServiceName} logs -f <${sortedNames}>`;
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Box, { marginTop: 1, marginBottom: 1, children: _jsx(Text, { dimColor: true, children: divider }) }), _jsxs(Box, { children: [_jsx(Text, { color: "green", bold: true, children: '✅ SUCCESS! ' }), _jsx(Text, { bold: true, children: "Development services are running" })] }), _jsx(Box, { marginTop: 1, marginBottom: 1, children: _jsx(Text, { dimColor: true, children: divider }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, children: "\uD83D\uDC33 SERVICES" }) }), _jsxs(Box, { flexDirection: "column", marginLeft: 2, children: [_jsxs(Box, { children: [_jsx(Text, { color: "white", children: 'Temporal:    ' }), _jsx(Text, { color: "yellow", children: "localhost:7233" })] }), _jsxs(Box, { children: [_jsx(Text, { color: "white", children: 'Temporal UI: ' }), _jsx(Text, { color: "cyan", children: "http://localhost:8080" })] }), _jsxs(Box, { children: [_jsx(Text, { color: "white", children: 'API Server:  ' }), _jsx(Text, { color: "yellow", children: "localhost:3001" })] }), _jsxs(Box, { children: [_jsx(Text, { color: "white", children: 'Redis:       ' }), _jsx(Text, { color: "yellow", children: "localhost:6379" })] })] }), _jsx(Box, { marginTop: 1, marginBottom: 1, children: _jsx(Text, { dimColor: true, children: divider }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, children: "\uD83D\uDE80 RUN A WORKFLOW" }) }), _jsxs(Box, { flexDirection: "column", marginLeft: 2, children: [_jsx(Text, { color: "white", children: "In a new terminal, execute:" }), _jsx(Box, { marginLeft: 2, children: _jsx(Text, { color: "cyan", children: "npx output workflow run blog_evaluator paulgraham_hwh" }) })] }), _jsx(Box, { marginTop: 1, marginBottom: 1, children: _jsx(Text, { dimColor: true, children: divider }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, children: "\u26A1 USEFUL COMMANDS" }) }), _jsxs(Box, { flexDirection: "column", marginLeft: 2, children: [_jsxs(Box, { children: [_jsx(Text, { color: "white", children: 'Open Temporal UI: ' }), _jsx(Text, { color: "cyan", children: "open http://localhost:8080" })] }), _jsxs(Box, { children: [_jsx(Text, { color: "white", children: 'View logs:        ' }), _jsx(Text, { color: "cyan", children: logsCommand })] }), _jsxs(Box, { children: [_jsx(Text, { color: "white", children: 'Stop services:    ' }), _jsx(Text, { color: "cyan", children: "Press Ctrl+C" })] })] }), _jsx(Box, { marginTop: 1, marginBottom: 1, children: _jsx(Text, { dimColor: true, children: divider }) }), _jsx(Text, { dimColor: true, children: "\uD83D\uDCA1 Tip: The Temporal UI lets you monitor workflow executions in real-time" })] }));
+};
+const WaitingView = ({ services }) => (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: "yellow", children: _jsx(Spinner, { type: "dots" }) }), _jsx(Text, { children: " Waiting for services to become healthy..." })] }), services.length > 0 && (_jsx(Box, { flexDirection: "column", marginTop: 1, children: services.map(s => _jsx(ServiceRow, { service: s }, s.name)) }))] }));
+const RunningView = ({ services }) => (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: "\uD83D\uDCCA Service Status" }), _jsx(Box, { flexDirection: "column", marginTop: 1, children: services.map(s => _jsx(ServiceRow, { service: s }, s.name)) }), _jsx(FailureWarning, { services: services }), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: "cyan", children: '🌐 Temporal UI: ' }), _jsx(Text, { bold: true, children: "http://localhost:8080" })] }), _jsx(Text, { dimColor: true, children: "Press Ctrl+C to stop services" })] }));
+export const DevApp = ({ dockerComposePath, onCleanup }) => {
+    const { exit } = useApp();
+    const [phase, setPhase] = useState('waiting');
+    const [services, setServices] = useState([]);
+    const [successItems, setSuccessItems] = useState([]);
+    useHealthPolling(dockerComposePath, phase === 'waiting', {
+        onServices: setServices,
+        onAllHealthy: svcs => {
+            setSuccessItems([{ id: 'success', services: svcs }]);
+            setPhase('running');
+        },
+        onTimeout: () => exit(new Error('Timeout waiting for services to become healthy'))
+    });
+    useStatusRefresh(dockerComposePath, phase === 'running', setServices);
+    useCtrlC(onCleanup);
+    return (_jsxs(_Fragment, { children: [_jsx(Static, { items: successItems, children: item => _jsx(DevSuccessMessage, { services: item.services }, item.id) }), phase === 'waiting' && _jsx(WaitingView, { services: services }), phase === 'running' && _jsx(RunningView, { services: services })] }));
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/cli",
-  "version": "0.1.10",
+  "version": "0.1.11-next.42e84b1.0",
   "description": "CLI for Output.ai workflow generation",
   "type": "module",
   "main": "dist/index.js",
@@ -28,19 +28,22 @@
     "dotenv": "17.3.1",
     "handlebars": "4.7.9",
     "js-yaml": "4.1.1",
+    "ink": "6.8.0",
+    "ink-spinner": "5.0.0",
     "json-schema-library": "11.0.5",
     "ky": "1.14.3",
-    "log-update": "7.2.0",
+    "react": "19.2.4",
     "semver": "7.7.4",
     "yaml": "^2.8.3",
-    "@outputai/credentials": "0.1.10",
-    "@outputai/llm": "0.1.10",
-    "@outputai/evals": "0.1.10"
+    "@outputai/credentials": "0.1.11-next.42e84b1.0",
+    "@outputai/evals": "0.1.11-next.42e84b1.0",
+    "@outputai/llm": "0.1.11-next.42e84b1.0"
   },
   "devDependencies": {
     "@types/cli-progress": "3.11.6",
     "@types/debug": "4.1.13",
     "@types/js-yaml": "4.0.9",
+    "@types/react": "19.2.14",
     "@types/semver": "7.7.1",
     "orval": "8.6.2"
   },

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

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

package/dist/services/messages.spec.js

@@ -1,55 +0,0 @@
-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');
-        });
-    });
-});