@outputai/cli 0.2.1-next.fd72d95.0 → 0.3.1-next.00e0047.0

package/dist/services/docker.js

@@ -3,6 +3,7 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { ux } from '@oclif/core';
 import semver from 'semver';
+import { config } from '#config.js';
 const DEFAULT_COMPOSE_PATH = '../assets/docker/docker-compose-dev.yml';
 export const SERVICE_HEALTH = {
     HEALTHY: 'healthy',
@@ -100,7 +101,7 @@ export function parseServiceStatus(jsonOutput) {
     });
 }
 export async function getServiceStatus(dockerComposePath) {
-    const result = execFileSync('docker', ['compose', '-f', dockerComposePath, 'ps', '--all', '--format', 'json'], { encoding: 'utf-8', cwd: process.cwd() });
+    const result = execFileSync('docker', ['compose', '-f', dockerComposePath, '--project-name', config.dockerServiceName, 'ps', '--all', '--format', 'json'], { encoding: 'utf-8', cwd: process.cwd() });
     return parseServiceStatus(result);
 }
 export function isServiceHealthy(service) {
@@ -126,6 +127,7 @@ export async function startDockerCompose(dockerComposePath, pullPolicy) {
         'compose',
         '-f', dockerComposePath,
         '--project-directory', process.cwd(),
+        '--project-name', config.dockerServiceName,
         'up'
     ];
     if (pullPolicy) {
@@ -143,6 +145,7 @@ export function startDockerComposeDetached(dockerComposePath, pullPolicy) {
         'compose',
         '-f', dockerComposePath,
         '--project-directory', process.cwd(),
+        '--project-name', config.dockerServiceName,
         'up', '-d'
     ];
     if (pullPolicy) {
@@ -152,6 +155,6 @@ export function startDockerComposeDetached(dockerComposePath, pullPolicy) {
 }
 export async function stopDockerCompose(dockerComposePath) {
     ux.stdout('⏹️  Stopping services...\n');
-    execFileSync('docker', ['compose', '-f', dockerComposePath, 'down'], { stdio: 'inherit', cwd: process.cwd() });
+    execFileSync('docker', ['compose', '-f', dockerComposePath, '--project-directory', process.cwd(), '--project-name', config.dockerServiceName, 'down'], { stdio: 'inherit', cwd: process.cwd() });
 }
 export { isDockerInstalled, DockerValidationError };

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, isServiceHealthy, isServiceFailed } from './docker.js';
+import { execFileSync, spawn } from 'node:child_process';
+import { parseServiceStatus, getServiceStatus, startDockerCompose, startDockerComposeDetached, stopDockerCompose, waitForServicesHealthy, isServiceHealthy, isServiceFailed } from './docker.js';
 vi.mock('node:child_process', () => ({
     execSync: vi.fn(),
     execFileSync: vi.fn(),
@@ -73,7 +73,7 @@ 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', 'ps', '--all', '--format', 'json'], expect.objectContaining({ encoding: 'utf-8' }));
+            expect(execFileSync).toHaveBeenCalledWith('docker', ['compose', '-f', '/path/to/docker-compose.yml', '--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}]}';
@@ -89,6 +89,77 @@ describe('docker service', () => {
             await expect(getServiceStatus('/path/to/docker-compose.yml')).rejects.toThrow();
         });
     });
+    describe('startDockerCompose', () => {
+        it('should pass --project-name to docker compose up', async () => {
+            await startDockerCompose('/path/to/docker-compose.yml');
+            expect(spawn).toHaveBeenCalledWith('docker', [
+                'compose', '-f', '/path/to/docker-compose.yml',
+                '--project-directory', process.cwd(),
+                '--project-name', 'output-sdk',
+                'up'
+            ], 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');
+            expect(spawn).toHaveBeenCalledWith('docker', [
+                'compose', '-f', '/path/to/docker-compose.yml',
+                '--project-directory', process.cwd(),
+                '--project-name', 'output-sdk',
+                'up', '--pull', 'always'
+            ], expect.objectContaining({ stdio: ['ignore', 'pipe', 'pipe'], cwd: process.cwd() }));
+        });
+    });
+    describe('startDockerComposeDetached', () => {
+        it('should pass --project-name and -d to docker compose up', () => {
+            vi.mocked(execFileSync).mockReturnValue('');
+            startDockerComposeDetached('/path/to/docker-compose.yml');
+            expect(execFileSync).toHaveBeenCalledWith('docker', [
+                'compose', '-f', '/path/to/docker-compose.yml',
+                '--project-directory', process.cwd(),
+                '--project-name', 'output-sdk',
+                'up', '-d'
+            ], expect.objectContaining({ stdio: 'inherit', cwd: process.cwd() }));
+        });
+        it('should append --pull when pullPolicy is provided', () => {
+            vi.mocked(execFileSync).mockReturnValue('');
+            startDockerComposeDetached('/path/to/docker-compose.yml', 'missing');
+            expect(execFileSync).toHaveBeenCalledWith('docker', [
+                'compose', '-f', '/path/to/docker-compose.yml',
+                '--project-directory', process.cwd(),
+                '--project-name', 'output-sdk',
+                'up', '-d', '--pull', 'missing'
+            ], expect.objectContaining({ stdio: 'inherit', cwd: process.cwd() }));
+        });
+    });
+    describe('DOCKER_SERVICE_NAME wiring', () => {
+        const saved = process.env.DOCKER_SERVICE_NAME;
+        afterEach(() => {
+            if (saved === undefined) {
+                delete process.env.DOCKER_SERVICE_NAME;
+            }
+            else {
+                process.env.DOCKER_SERVICE_NAME = saved;
+            }
+        });
+        it('threads DOCKER_SERVICE_NAME through to --project-name (not hardcoded output-sdk)', async () => {
+            process.env.DOCKER_SERVICE_NAME = 'custom-project';
+            vi.mocked(execFileSync).mockReturnValue('');
+            await stopDockerCompose('/path/to/docker-compose.yml');
+            expect(execFileSync).toHaveBeenCalledWith('docker', [
+                'compose', '-f', '/path/to/docker-compose.yml',
+                '--project-directory', process.cwd(),
+                '--project-name', 'custom-project',
+                'down'
+            ], expect.objectContaining({ stdio: 'inherit' }));
+        });
+    });
+    describe('stopDockerCompose', () => {
+        it('should pass --project-name and --project-directory to docker compose down', async () => {
+            vi.mocked(execFileSync).mockReturnValue('');
+            await stopDockerCompose('/path/to/docker-compose.yml');
+            expect(execFileSync).toHaveBeenCalledWith('docker', ['compose', '-f', '/path/to/docker-compose.yml', '--project-directory', process.cwd(), '--project-name', 'output-sdk', 'down'], expect.objectContaining({ stdio: 'inherit' }));
+        });
+    });
     describe('isServiceHealthy', () => {
         it('should return true for a running service with health: healthy', () => {
             expect(isServiceHealthy({ name: 'redis', state: 'running', health: 'healthy', ports: [] })).toBe(true);

package/dist/services/env_configurator.js

@@ -1,4 +1,4 @@
-import { input, confirm, password } from '@inquirer/prompts';
+import { input, confirm, password } from '#utils/prompt.js';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { ux } from '@oclif/core';

package/dist/services/env_configurator.spec.js

@@ -3,7 +3,7 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { configureEnvironmentVariables } from './env_configurator.js';
 // Mock inquirer prompts
-vi.mock('@inquirer/prompts', () => ({
+vi.mock('#utils/prompt.js', () => ({
     input: vi.fn(),
     confirm: vi.fn(),
     password: vi.fn()
@@ -45,7 +45,7 @@ describe('configureEnvironmentVariables', () => {
         expect(result).toBe(false);
     });
     it('should return false if user declines configuration', async () => {
-        const { confirm } = await import('@inquirer/prompts');
+        const { confirm } = await import('#utils/prompt.js');
         vi.mocked(confirm).mockResolvedValue(false);
         await fs.writeFile(testState.envExamplePath, '# API key\nAPIKEY=');
         const result = await configureEnvironmentVariables(testState.tempDir, false);
@@ -53,14 +53,14 @@ describe('configureEnvironmentVariables', () => {
         expect(vi.mocked(confirm)).toHaveBeenCalled();
     });
     it('should return false if no empty variables exist', async () => {
-        const { confirm } = await import('@inquirer/prompts');
+        const { confirm } = await import('#utils/prompt.js');
         vi.mocked(confirm).mockResolvedValue(true);
         await fs.writeFile(testState.envExamplePath, 'APIKEY=my-secret-key');
         const result = await configureEnvironmentVariables(testState.tempDir, false);
         expect(result).toBe(false);
     });
     it('should copy .env.example to .env when user confirms configuration', async () => {
-        const { input, confirm } = await import('@inquirer/prompts');
+        const { input, confirm } = await import('#utils/prompt.js');
         vi.mocked(confirm).mockResolvedValue(true);
         vi.mocked(input).mockResolvedValueOnce('sk-proj-123');
         const originalContent = `# API key
@@ -72,7 +72,7 @@ APIKEY=`;
         await expect(fs.access(testState.envPath)).resolves.toBeUndefined();
     });
     it('should write configured values to .env while leaving .env.example unchanged', async () => {
-        const { input, confirm } = await import('@inquirer/prompts');
+        const { input, confirm } = await import('#utils/prompt.js');
         vi.mocked(confirm).mockResolvedValue(true);
         vi.mocked(input).mockResolvedValueOnce('sk-proj-123');
         const originalContent = `# API key
@@ -88,7 +88,7 @@ APIKEY=`;
         expect(envExampleContent).toBe(originalContent);
     });
     it('should prompt for empty variables and update .env', async () => {
-        const { input, confirm } = await import('@inquirer/prompts');
+        const { input, confirm } = await import('#utils/prompt.js');
         vi.mocked(confirm).mockResolvedValue(true);
         vi.mocked(input).mockResolvedValueOnce('sk-proj-123');
         vi.mocked(input).mockResolvedValueOnce('');
@@ -105,7 +105,7 @@ OPENAI_API_KEY=`);
         expect(content).toContain('OPENAI_API_KEY=');
     });
     it('should preserve comments in .env file', async () => {
-        const { input, confirm } = await import('@inquirer/prompts');
+        const { input, confirm } = await import('#utils/prompt.js');
         vi.mocked(confirm).mockResolvedValue(true);
         vi.mocked(input).mockResolvedValueOnce('test-key');
         const originalContent = `# This is a comment
@@ -123,7 +123,7 @@ OTHER=value`;
         expect(content).toContain('OTHER=value');
     });
     it('should skip placeholder values and only prompt for truly empty variables', async () => {
-        const { input, confirm } = await import('@inquirer/prompts');
+        const { input, confirm } = await import('#utils/prompt.js');
         vi.mocked(confirm).mockResolvedValue(true);
         vi.mocked(input).mockResolvedValueOnce('new-key');
         await fs.writeFile(testState.envExamplePath, `APIKEY=your_api_key_here
@@ -136,7 +136,7 @@ EMPTY_KEY=`);
         }));
     });
     it('should skip variables with existing values', async () => {
-        const { input, confirm } = await import('@inquirer/prompts');
+        const { input, confirm } = await import('#utils/prompt.js');
         vi.mocked(confirm).mockResolvedValue(true);
         vi.mocked(input).mockResolvedValueOnce('new-key');
         await fs.writeFile(testState.envExamplePath, `EXISTING_KEY=existing-value
@@ -147,7 +147,7 @@ EMPTY_KEY=`);
         expect(vi.mocked(input)).toHaveBeenCalledTimes(1);
     });
     it('should handle case where .env already exists (overwrite with copy)', async () => {
-        const { input, confirm } = await import('@inquirer/prompts');
+        const { input, confirm } = await import('#utils/prompt.js');
         vi.mocked(confirm).mockResolvedValue(true);
         vi.mocked(input).mockResolvedValueOnce('new-configured-value');
         // Create existing .env with old content
@@ -162,7 +162,7 @@ EMPTY_KEY=`);
         expect(envContent).not.toContain('OLD_KEY');
     });
     it('should return false if an error occurs during parsing', async () => {
-        const { confirm } = await import('@inquirer/prompts');
+        const { confirm } = await import('#utils/prompt.js');
         vi.mocked(confirm).mockResolvedValue(true);
         await fs.writeFile(testState.envExamplePath, 'KEY=');
         // Delete the .env.example file after access check but before parsing would happen
@@ -178,7 +178,7 @@ EMPTY_KEY=`);
         vi.mocked(fs.copyFile).mockImplementation(originalCopyFile);
     });
     it('should prompt for SECRET marker values with password input', async () => {
-        const { password, confirm } = await import('@inquirer/prompts');
+        const { password, confirm } = await import('#utils/prompt.js');
         vi.mocked(confirm).mockResolvedValue(true);
         vi.mocked(password).mockResolvedValueOnce('my-secret-api-key');
         await fs.writeFile(testState.envExamplePath, `# API Key

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
  */
@@ -180,7 +181,7 @@ export const getProjectSuccessMessage = (folderName, installSuccess, credentials
         note: 'Execute in a new terminal after services are running'
     }, {
         step: 'Monitor workflows',
-        command: 'open http://localhost:8080',
+        command: `open ${config.temporalUiUrl}`,
         note: 'Access Temporal UI for workflow visualization'
     });
     // Format each step with proper indentation and colors

package/dist/services/project_scaffold.d.ts

@@ -27,5 +27,5 @@ export declare function createSigintHandler(projectPath: string, folderCreated:
  * @param skipEnv - Whether to skip environment configuration prompts
  * @param folderName - Optional folder name to skip folder name prompt
  */
-export declare function runInit(skipEnv?: boolean, folderName?: string): Promise<void>;
+export declare function runInit(skipEnv?: boolean, skipGit?: boolean, folderName?: string): Promise<void>;
 export {};

package/dist/services/project_scaffold.js

@@ -1,4 +1,4 @@
-import { input, confirm } from '@inquirer/prompts';
+import { input, confirm } from '#utils/prompt.js';
 import { ux } from '@oclif/core';
 import { kebabCase, pascalCase } from 'change-case';
 import fs from 'node:fs/promises';
@@ -119,6 +119,18 @@ async function executeNpmInstall(projectPath) {
 async function initializeAgents(projectPath) {
     await initializeAgentConfig({ projectRoot: projectPath, force: false });
 }
+async function maybeInitializeGit(projectPath) {
+    const shouldInit = await confirm({
+        message: 'Initialize a git repository?',
+        default: true
+    });
+    if (!shouldInit) {
+        return false;
+    }
+    return executeCommandWithMessages(async () => {
+        await executeCommand('git', ['init'], projectPath);
+    }, 'Initializing git repository...', 'Git repository initialized');
+}
 /**
  * Format error message for init errors
  * Single responsibility: only format error messages, no cleanup logic
@@ -172,7 +184,7 @@ function handleRunInitError(error, projectPath, projectFolderCreated) {
  * @param skipEnv - Whether to skip environment configuration prompts
  * @param folderName - Optional folder name to skip folder name prompt
  */
-export async function runInit(skipEnv = false, folderName) {
+export async function runInit(skipEnv = false, skipGit = false, folderName) {
     // Track state for SIGINT cleanup using an object to avoid let
     const state = {
         projectFolderCreated: false,
@@ -210,6 +222,9 @@ export async function runInit(skipEnv = false, folderName) {
         await fs.copyFile(path.join(config.projectPath, '.env.example'), path.join(config.projectPath, '.env'));
         await executeCommandWithMessages(() => initializeAgents(config.projectPath), 'Initializing agent system...', 'Agent system initialized');
         const installSuccess = await executeCommandWithMessages(() => executeNpmInstall(config.projectPath), 'Installing dependencies...', 'Dependencies installed');
+        if (!skipGit) {
+            await maybeInitializeGit(config.projectPath);
+        }
         const nextSteps = getProjectSuccessMessage(config.folderName, installSuccess, credentialsConfigured);
         ux.stdout('Project created successfully!');
         ux.stdout(nextSteps);

package/dist/services/project_scaffold.spec.js

@@ -8,7 +8,7 @@ vi.mock('#utils/framework_version.js', () => ({
     })
 }));
 // Mock other dependencies
-vi.mock('@inquirer/prompts', () => ({
+vi.mock('#utils/prompt.js', () => ({
     input: vi.fn(),
     confirm: vi.fn()
 }));
@@ -47,7 +47,7 @@ describe('project_scaffold', () => {
     });
     describe('getProjectConfig', () => {
         it('should skip all prompts when folderName is provided', async () => {
-            const { input } = await import('@inquirer/prompts');
+            const { input } = await import('#utils/prompt.js');
             const config = await getProjectConfig('my-project');
             expect(config.folderName).toBe('my-project');
             expect(config.projectName).toBe('my-project');
@@ -58,7 +58,7 @@ describe('project_scaffold', () => {
             expect(config.description).toBe('AI Agents & Workflows built with Output.ai for test-folder');
         });
         it('should prompt for project name and folder name when not provided', async () => {
-            const { input } = await import('@inquirer/prompts');
+            const { input } = await import('#utils/prompt.js');
             vi.mocked(input)
                 .mockResolvedValueOnce('Test Project')
                 .mockResolvedValueOnce('test-project');
@@ -73,7 +73,7 @@ describe('project_scaffold', () => {
         it('should not prompt when all dependencies are available', async () => {
             const { isDockerInstalled } = await import('#services/docker.js');
             const { isClaudeCliAvailable } = await import('#utils/claude.js');
-            const { confirm } = await import('@inquirer/prompts');
+            const { confirm } = await import('#utils/prompt.js');
             vi.mocked(isDockerInstalled).mockReturnValue(true);
             vi.mocked(isClaudeCliAvailable).mockReturnValue(true);
             await checkDependencies();
@@ -82,7 +82,7 @@ describe('project_scaffold', () => {
         it('should prompt user when docker is missing', async () => {
             const { isDockerInstalled } = await import('#services/docker.js');
             const { isClaudeCliAvailable } = await import('#utils/claude.js');
-            const { confirm } = await import('@inquirer/prompts');
+            const { confirm } = await import('#utils/prompt.js');
             vi.mocked(isDockerInstalled).mockReturnValue(false);
             vi.mocked(isClaudeCliAvailable).mockReturnValue(true);
             vi.mocked(confirm).mockResolvedValue(true);
@@ -94,7 +94,7 @@ describe('project_scaffold', () => {
         it('should throw UserCancelledError when user declines to proceed', async () => {
             const { isDockerInstalled } = await import('#services/docker.js');
             const { isClaudeCliAvailable } = await import('#utils/claude.js');
-            const { confirm } = await import('@inquirer/prompts');
+            const { confirm } = await import('#utils/prompt.js');
             vi.mocked(isDockerInstalled).mockReturnValue(false);
             vi.mocked(isClaudeCliAvailable).mockReturnValue(true);
             vi.mocked(confirm).mockResolvedValue(false);

package/dist/services/workflow_builder.js

@@ -2,7 +2,8 @@
  * Workflow builder service for implementing workflows from plan files
  */
 import { ADDITIONAL_INSTRUCTIONS, BUILD_COMMAND_OPTIONS, invokeBuildWorkflow as invokeBuildWorkflowFromClient, replyToClaude } from './claude_client.js';
-import { input } from '@inquirer/prompts';
+import { input } from '#utils/prompt.js';
+import { isInteractive } from '#utils/interactive.js';
 import { ux } from '@oclif/core';
 import fs from 'node:fs/promises';
 import path from 'node:path';
@@ -70,6 +71,9 @@ async function processModification(modification, currentOutput) {
     }
 }
 async function interactiveRefinementLoop(currentOutput) {
+    if (!isInteractive()) {
+        return currentOutput;
+    }
     const modification = await promptForModification();
     if (isAcceptCommand(modification)) {
         return currentOutput;

package/dist/services/workflow_builder.spec.js

@@ -1,11 +1,12 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest';
 import { buildWorkflow, buildWorkflowInteractiveLoop } from './workflow_builder.js';
 import { ADDITIONAL_INSTRUCTIONS, BUILD_COMMAND_OPTIONS, invokeBuildWorkflow, replyToClaude } from './claude_client.js';
-import { input } from '@inquirer/prompts';
+import { input } from '#utils/prompt.js';
 import { ux } from '@oclif/core';
 import fs from 'node:fs/promises';
 vi.mock('./claude_client.js');
-vi.mock('@inquirer/prompts');
+vi.mock('#utils/prompt.js');
+vi.mock('#utils/interactive.js', () => ({ isInteractive: () => true }));
 vi.mock('@oclif/core', () => ({
     ux: {
         stdout: vi.fn(),

package/dist/services/workflow_runs.d.ts

@@ -9,6 +9,7 @@ export interface WorkflowRunsResult {
 }
 export interface FetchWorkflowRunsOptions {
     workflowType?: string;
+    catalog?: string;
     limit?: number;
 }
 export declare function fetchWorkflowRuns(options?: FetchWorkflowRunsOptions): Promise<WorkflowRunsResult>;

package/dist/services/workflow_runs.js

@@ -10,6 +10,9 @@ export async function fetchWorkflowRuns(options = {}) {
     if (options.workflowType) {
         params.workflowType = options.workflowType;
     }
+    if (options.catalog) {
+        params.catalog = options.catalog;
+    }
     const response = await getWorkflowRuns(params);
     if (!response) {
         throw new Error('Failed to connect to API server. Is it running?');

package/dist/templates/project/.env.example.template

@@ -7,3 +7,20 @@ ANTHROPIC_API_KEY=credential:anthropic.api_key
 # Configure if you plan to use OpenAI in your LLM prompts
 OPENAI_API_KEY=credential:openai.api_key
 
+# --- Host port overrides (for running multiple dev stacks) ---
+# Only the host-side port changes; inter-service traffic (e.g. worker -> Temporal
+# at temporal:7233) is unaffected.
+# OUTPUT_API_HOST_PORT=3001
+# OUTPUT_TEMPORAL_UI_HOST_PORT=8080
+
+# --- API connection ---
+# If OUTPUT_API_URL is set, it overrides OUTPUT_API_HOST_PORT.
+# Use OUTPUT_API_URL for remote/staging servers; use OUTPUT_API_HOST_PORT for local port shifts.
+# OUTPUT_API_URL=http://localhost:3001
+
+# --- Project isolation ---
+# Compose prefixes named volumes with the project name, so changing
+# DOCKER_SERVICE_NAME creates fresh volumes and leaves the previous ones behind.
+# Run `docker volume ls --filter name=<old-project-name>` to find orphaned
+# volumes and `docker volume rm` to remove them.
+

package/dist/utils/credentials_loader.d.ts

@@ -0,0 +1 @@
+export declare const loadCredentialRefs: () => void;

package/dist/utils/credentials_loader.js

@@ -0,0 +1,18 @@
+import { InvalidCredentialsKeyError, MalformedCredentialsKeyError, MissingKeyError, resolveCredentialRefs } from '@outputai/credentials';
+const isCredentialsConfigError = (error) => error instanceof MissingKeyError ||
+    error instanceof InvalidCredentialsKeyError ||
+    error instanceof MalformedCredentialsKeyError;
+export const loadCredentialRefs = () => {
+    try {
+        resolveCredentialRefs();
+    }
+    catch (error) {
+        if (isCredentialsConfigError(error)) {
+            console.error(`Error: ${error.message}`);
+            process.exit(1);
+        }
+        else {
+            throw error;
+        }
+    }
+};

package/dist/utils/credentials_loader.spec.d.ts

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

package/dist/utils/credentials_loader.spec.js

@@ -0,0 +1,84 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import * as credentials from '@outputai/credentials';
+import { loadCredentialRefs } from './credentials_loader.js';
+vi.mock('@outputai/credentials', async () => {
+    const actual = await vi.importActual('@outputai/credentials');
+    return {
+        ...actual,
+        resolveCredentialRefs: vi.fn()
+    };
+});
+describe('loadCredentialRefs', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('should call resolveCredentialRefs without errors when no credentials are misconfigured', () => {
+        vi.mocked(credentials.resolveCredentialRefs).mockReturnValue([]);
+        expect(() => loadCredentialRefs()).not.toThrow();
+        expect(credentials.resolveCredentialRefs).toHaveBeenCalledTimes(1);
+    });
+    it('should print a clean error message and exit on MissingKeyError without dumping a stack trace', () => {
+        vi.mocked(credentials.resolveCredentialRefs).mockImplementation(() => {
+            throw new credentials.MissingKeyError();
+        });
+        const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined));
+        loadCredentialRefs();
+        expect(consoleErrorSpy).toHaveBeenCalledTimes(1);
+        const printedMessage = consoleErrorSpy.mock.calls[0]?.[0];
+        expect(printedMessage).toContain('No credentials key found');
+        expect(printedMessage).toContain('OUTPUT_CREDENTIALS_KEY');
+        expect(printedMessage).toContain('config/credentials.key');
+        expect(printedMessage).not.toContain('    at ');
+        expect(exitSpy).toHaveBeenCalledWith(1);
+    });
+    it('should include the environment-specific hints in the printed message when an environment is set', () => {
+        vi.mocked(credentials.resolveCredentialRefs).mockImplementation(() => {
+            throw new credentials.MissingKeyError('production');
+        });
+        const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined));
+        loadCredentialRefs();
+        const printedMessage = consoleErrorSpy.mock.calls[0]?.[0];
+        expect(printedMessage).toContain('OUTPUT_CREDENTIALS_KEY_PRODUCTION');
+        expect(printedMessage).toContain('config/credentials/production.key');
+        expect(exitSpy).toHaveBeenCalledWith(1);
+    });
+    it('should print a clean error message and exit on InvalidCredentialsKeyError', () => {
+        vi.mocked(credentials.resolveCredentialRefs).mockImplementation(() => {
+            throw new credentials.InvalidCredentialsKeyError('config/credentials.yml.enc');
+        });
+        const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined));
+        loadCredentialRefs();
+        expect(consoleErrorSpy).toHaveBeenCalledTimes(1);
+        const printedMessage = consoleErrorSpy.mock.calls[0]?.[0];
+        expect(printedMessage).toContain('Failed to decrypt config/credentials.yml.enc');
+        expect(printedMessage).toContain('does not match');
+        expect(printedMessage).not.toContain('    at ');
+        expect(exitSpy).toHaveBeenCalledWith(1);
+    });
+    it('should print a clean error message and exit on MalformedCredentialsKeyError', () => {
+        vi.mocked(credentials.resolveCredentialRefs).mockImplementation(() => {
+            throw new credentials.MalformedCredentialsKeyError('config/credentials.yml.enc', 'hex string expected, got unpadded hex of length 55');
+        });
+        const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined));
+        loadCredentialRefs();
+        const printedMessage = consoleErrorSpy.mock.calls[0]?.[0];
+        expect(printedMessage).toContain('is malformed');
+        expect(printedMessage).toContain('must be exactly 64 hex characters');
+        expect(printedMessage).toContain('unpadded hex of length 55');
+        expect(printedMessage).not.toContain('    at ');
+        expect(exitSpy).toHaveBeenCalledWith(1);
+    });
+    it('should rethrow unexpected errors so they are not silently swallowed', () => {
+        vi.mocked(credentials.resolveCredentialRefs).mockImplementation(() => {
+            throw new Error('something else broke');
+        });
+        expect(() => loadCredentialRefs()).toThrow('something else broke');
+    });
+});

package/dist/utils/env_loader.js

@@ -7,11 +7,10 @@ import { existsSync } from 'node:fs';
 import { resolve } from 'node:path';
 import * as dotenv from 'dotenv';
 import debugFactory from 'debug';
-import { config } from '#config.js';
 const debug = debugFactory('output-cli:env-loader');
 export function loadEnvironment() {
     const cwd = process.cwd();
-    const envFile = config.envFile;
+    const envFile = process.env.OUTPUT_CLI_ENV || '.env';
     const envPath = resolve(cwd, envFile);
     if (!existsSync(envPath)) {
         debug(`Warning: Env file not found: ${envPath}`);

package/dist/utils/error_handler.js

@@ -1,11 +1,13 @@
 import { config } from '#config.js';
-const DEFAULT_MESSAGES = {
-    ECONNREFUSED: `Connection refused to ${config.apiUrl}. Is the API server running?`,
-    401: 'Authentication failed. Check your OUTPUT_API_AUTH_TOKEN.',
-    404: 'Resource not found.',
-    500: 'Server error.',
-    UNKNOWN: 'An unknown error occurred.'
-};
+function getDefaultMessages() {
+    return {
+        ECONNREFUSED: `Connection refused to ${config.apiUrl}. Is the API server running?`,
+        401: 'Authentication failed. Check your OUTPUT_API_AUTH_TOKEN.',
+        404: 'Resource not found.',
+        500: 'Server error.',
+        UNKNOWN: 'An unknown error occurred.'
+    };
+}
 /**
  * Extract error type and message from API response data
  */
@@ -49,7 +51,7 @@ function getDetailedErrorMessage(error) {
 }
 export function handleApiError(error, errorFn, overrides = {}) {
     const apiError = error;
-    const errorMessages = { ...DEFAULT_MESSAGES, ...overrides };
+    const errorMessages = { ...getDefaultMessages(), ...overrides };
     if (apiError.code === 'ECONNREFUSED' || apiError.cause?.code === 'ECONNREFUSED') {
         errorFn(errorMessages.ECONNREFUSED, { exit: 1 });
     }

package/dist/utils/interactive.d.ts

@@ -0,0 +1,2 @@
+export declare const setNonInteractive: (value: boolean) => void;
+export declare const isInteractive: () => boolean;

package/dist/utils/interactive.js

@@ -0,0 +1,5 @@
+const state = { nonInteractive: false };
+export const setNonInteractive = (value) => {
+    state.nonInteractive = value;
+};
+export const isInteractive = () => !state.nonInteractive && !!process.stdin.isTTY;

package/dist/utils/interactive.spec.d.ts

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