@outputai/cli 0.2.1-next.af8a069.0 → 0.2.1-next.bd54540.0

package/bin/run.js

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

package/dist/api/generated/api.d.ts

@@ -257,9 +257,9 @@ export interface ResetWorkflowResponse {
     runId?: string;
 }
 /**
- * Invalid request body or query (validation failed)
+ * Invalid request body, query, or pagination token
  */
-export type BadRequestResponse = ValidationErrorResponse;
+export type BadRequestResponse = ValidationErrorResponse | ErrorResponse;
 /**
  * Workflow execution, workflow type, or catalog not found
  */
@@ -344,6 +344,86 @@ export type PostWorkflowIdRunsRidTerminateBody = {
 export type PostWorkflowIdTerminateBody = {
     reason?: string;
 };
+export type GetWorkflowIdHistoryParams = {
+    /**
+     * Specific run ID. Required when using pageToken.
+     */
+    runId?: string;
+    /**
+     * Number of events per page
+     * @minimum 1
+     * @maximum 50
+     */
+    pageSize?: number;
+    /**
+     * Base64 pagination token from previous response
+     */
+    pageToken?: string;
+    /**
+     * Include decoded input/output payloads in events
+     */
+    includePayloads?: boolean;
+};
+/**
+ * Workflow metadata (null on subsequent pages)
+ * @nullable
+ */
+export type GetWorkflowIdHistory200Workflow = {
+    [key: string]: unknown;
+} | null;
+export type GetWorkflowIdHistory200EventsItem = {
+    [key: string]: unknown;
+};
+export type GetWorkflowIdHistory200 = {
+    /**
+       * Workflow metadata (null on subsequent pages)
+       * @nullable
+       */
+    workflow?: GetWorkflowIdHistory200Workflow;
+    events?: GetWorkflowIdHistory200EventsItem[];
+    /** Resolved run ID. Echo this value as the runId query parameter when fetching subsequent pages. */
+    runId?: string;
+    /** @nullable */
+    nextPageToken?: string | null;
+};
+export type GetWorkflowIdRunsRidHistoryParams = {
+    /**
+     * Number of events per page
+     * @minimum 1
+     * @maximum 50
+     */
+    pageSize?: number;
+    /**
+     * Base64 pagination token from previous response
+     */
+    pageToken?: string;
+    /**
+     * Include decoded input/output payloads in events
+     */
+    includePayloads?: boolean;
+};
+/**
+ * Workflow metadata (null on subsequent pages)
+ * @nullable
+ */
+export type GetWorkflowIdRunsRidHistory200Workflow = {
+    [key: string]: unknown;
+} | null;
+export type GetWorkflowIdRunsRidHistory200EventsItem = {
+    [key: string]: unknown;
+};
+export type GetWorkflowIdRunsRidHistory200 = {
+    /**
+       * Workflow metadata (null on subsequent pages)
+       * @nullable
+       */
+    workflow?: GetWorkflowIdRunsRidHistory200Workflow;
+    events?: GetWorkflowIdRunsRidHistory200EventsItem[];
+    /** The pinned run ID */
+    runId?: string;
+    /** @nullable */
+    nextPageToken?: string | null;
+};
 export type GetWorkflowCatalogId200 = {
     /** Each workflow available in this catalog */
     workflows?: Workflow[];
@@ -854,6 +934,63 @@ export type getWorkflowIdRunsRidTraceLogResponseError = (getWorkflowIdRunsRidTra
 export type getWorkflowIdRunsRidTraceLogResponse = (getWorkflowIdRunsRidTraceLogResponseSuccess | getWorkflowIdRunsRidTraceLogResponseError);
 export declare const getGetWorkflowIdRunsRidTraceLogUrl: (id: string, rid: string) => string;
 export declare const getWorkflowIdRunsRidTraceLog: (id: string, rid: string, options?: ApiRequestOptions) => Promise<getWorkflowIdRunsRidTraceLogResponse>;
+/**
+ * Returns decoded Temporal history events with optional payload inclusion. First page includes workflow metadata; subsequent pages return events only.
+ * @summary Get paginated workflow execution history
+ */
+export type getWorkflowIdHistoryResponse200 = {
+    data: GetWorkflowIdHistory200;
+    status: 200;
+};
+export type getWorkflowIdHistoryResponse400 = {
+    data: BadRequestResponse;
+    status: 400;
+};
+export type getWorkflowIdHistoryResponse404 = {
+    data: NotFoundResponse;
+    status: 404;
+};
+export type getWorkflowIdHistoryResponse500 = {
+    data: InternalServerErrorResponse;
+    status: 500;
+};
+export type getWorkflowIdHistoryResponseSuccess = (getWorkflowIdHistoryResponse200) & {
+    headers: Headers;
+};
+export type getWorkflowIdHistoryResponseError = (getWorkflowIdHistoryResponse400 | getWorkflowIdHistoryResponse404 | getWorkflowIdHistoryResponse500) & {
+    headers: Headers;
+};
+export type getWorkflowIdHistoryResponse = (getWorkflowIdHistoryResponseSuccess | getWorkflowIdHistoryResponseError);
+export declare const getGetWorkflowIdHistoryUrl: (id: string, params?: GetWorkflowIdHistoryParams) => string;
+export declare const getWorkflowIdHistory: (id: string, params?: GetWorkflowIdHistoryParams, options?: ApiRequestOptions) => Promise<getWorkflowIdHistoryResponse>;
+/**
+ * @summary Get paginated workflow execution history for a specific run
+ */
+export type getWorkflowIdRunsRidHistoryResponse200 = {
+    data: GetWorkflowIdRunsRidHistory200;
+    status: 200;
+};
+export type getWorkflowIdRunsRidHistoryResponse400 = {
+    data: BadRequestResponse;
+    status: 400;
+};
+export type getWorkflowIdRunsRidHistoryResponse404 = {
+    data: NotFoundResponse;
+    status: 404;
+};
+export type getWorkflowIdRunsRidHistoryResponse500 = {
+    data: InternalServerErrorResponse;
+    status: 500;
+};
+export type getWorkflowIdRunsRidHistoryResponseSuccess = (getWorkflowIdRunsRidHistoryResponse200) & {
+    headers: Headers;
+};
+export type getWorkflowIdRunsRidHistoryResponseError = (getWorkflowIdRunsRidHistoryResponse400 | getWorkflowIdRunsRidHistoryResponse404 | getWorkflowIdRunsRidHistoryResponse500) & {
+    headers: Headers;
+};
+export type getWorkflowIdRunsRidHistoryResponse = (getWorkflowIdRunsRidHistoryResponseSuccess | getWorkflowIdRunsRidHistoryResponseError);
+export declare const getGetWorkflowIdRunsRidHistoryUrl: (id: string, rid: string, params?: GetWorkflowIdRunsRidHistoryParams) => string;
+export declare const getWorkflowIdRunsRidHistory: (id: string, rid: string, params?: GetWorkflowIdRunsRidHistoryParams, options?: ApiRequestOptions) => Promise<getWorkflowIdRunsRidHistoryResponse>;
 /**
  * @summary Get a specific workflow catalog by ID
  */

package/dist/api/generated/api.js

@@ -194,6 +194,38 @@ export const getWorkflowIdRunsRidTraceLog = async (id, rid, options) => {
         method: 'GET'
     });
 };
+export const getGetWorkflowIdHistoryUrl = (id, params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? 'null' : value.toString());
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0 ? `/workflow/${id}/history?${stringifiedParams}` : `/workflow/${id}/history`;
+};
+export const getWorkflowIdHistory = async (id, params, options) => {
+    return customFetchInstance(getGetWorkflowIdHistoryUrl(id, params), {
+        ...options,
+        method: 'GET'
+    });
+};
+export const getGetWorkflowIdRunsRidHistoryUrl = (id, rid, params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? 'null' : value.toString());
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0 ? `/workflow/${id}/runs/${rid}/history?${stringifiedParams}` : `/workflow/${id}/runs/${rid}/history`;
+};
+export const getWorkflowIdRunsRidHistory = async (id, rid, params, options) => {
+    return customFetchInstance(getGetWorkflowIdRunsRidHistoryUrl(id, rid, params), {
+        ...options,
+        method: 'GET'
+    });
+};
 export const getGetWorkflowCatalogIdUrl = (id) => {
     return `/workflow/catalog/${id}`;
 };

package/dist/api/http_client.js

@@ -14,26 +14,31 @@ export class HttpError extends Error {
         this.name = 'HttpError';
     }
 }
-const api = ky.create({
-    prefixUrl: config.apiUrl,
-    timeout: config.requestTimeout,
-    retry: {
-        limit: 2,
-        methods: ['get', 'put', 'head', 'delete', 'options', 'trace'],
-        statusCodes: [408, 413, 429, 502, 503, 504]
-    },
-    throwHttpErrors: false,
-    hooks: {
-        beforeRequest: [
-            request => {
-                // Add auth token if available
-                if (config.apiToken) {
-                    request.headers.set('Authorization', `Basic ${config.apiToken}`);
-                }
+const apiState = {};
+function getApi() {
+    if (!apiState.api) {
+        apiState.api = ky.create({
+            prefixUrl: config.apiUrl,
+            timeout: config.requestTimeout,
+            retry: {
+                limit: 2,
+                methods: ['get', 'put', 'head', 'delete', 'options', 'trace'],
+                statusCodes: [408, 413, 429, 502, 503, 504]
+            },
+            throwHttpErrors: false,
+            hooks: {
+                beforeRequest: [
+                    request => {
+                        if (config.apiToken) {
+                            request.headers.set('Authorization', `Basic ${config.apiToken}`);
+                        }
+                    }
+                ]
             }
-        ]
+        });
     }
-});
+    return apiState.api;
+}
 const stripLeadingSlash = (url) => url.startsWith('/') ? url.slice(1) : url;
 const buildKyOptions = (options) => {
     // Extract params, config, and body for special handling
@@ -55,7 +60,7 @@ const wrapResponse = (response, data) => ({
     headers: response.headers
 });
 export const customFetchInstance = async (url, options) => {
-    const response = await api(stripLeadingSlash(url), buildKyOptions(options));
+    const response = await getApi()(stripLeadingSlash(url), buildKyOptions(options));
     const data = await response.json().catch(() => undefined);
     // Throw for non-2xx responses so catch handlers can process errors
     if (!response.ok) {

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.2.1-next.af8a069.0}
+    image: outputai/api:${OUTPUT_API_VERSION:-0.2.1-next.bd54540.0}
     init: true
     networks:
       - main

package/dist/commands/fix.js

@@ -1,5 +1,5 @@
 import { Command } from '@oclif/core';
-import { confirm } from '@inquirer/prompts';
+import { confirm } from '#utils/prompt.js';
 import { applyFix, planFix } from '#services/fix_package.js';
 import { getErrorMessage } from '#utils/error_utils.js';
 const Ansi = {

package/dist/commands/fix.spec.js

@@ -2,12 +2,12 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest';
 import Fix from './fix.js';
 import * as fixService from '#services/fix_package.js';
-import { confirm } from '@inquirer/prompts';
+import { confirm } from '#utils/prompt.js';
 vi.mock('#services/fix_package.js', () => ({
     planFix: vi.fn(),
     applyFix: vi.fn()
 }));
-vi.mock('@inquirer/prompts', () => ({
+vi.mock('#utils/prompt.js', () => ({
     confirm: vi.fn()
 }));
 const basePlan = () => ({

package/dist/commands/update.js

@@ -1,5 +1,5 @@
 import { Command, Flags } from '@oclif/core';
-import { confirm } from '@inquirer/prompts';
+import { confirm } from '#utils/prompt.js';
 import { fetchLatestVersion, getGlobalInstalledVersion, getLocalInstalledVersion, updateGlobal, updateLocal, isOutdated } from '#services/npm_update_service.js';
 import { ensureClaudePlugin } from '#services/coding_agents.js';
 import { getErrorMessage } from '#utils/error_utils.js';

package/dist/commands/update.spec.js

@@ -3,7 +3,7 @@ import { describe, it, expect, beforeEach, vi } from 'vitest';
 import Update from './update.js';
 import { fetchLatestVersion, getGlobalInstalledVersion, getLocalInstalledVersion, updateGlobal, updateLocal, isOutdated } from '#services/npm_update_service.js';
 import { ensureClaudePlugin } from '#services/coding_agents.js';
-import { confirm } from '@inquirer/prompts';
+import { confirm } from '#utils/prompt.js';
 vi.mock('#services/npm_update_service.js', () => ({
     fetchLatestVersion: vi.fn(),
     getGlobalInstalledVersion: vi.fn(),
@@ -15,7 +15,7 @@ vi.mock('#services/npm_update_service.js', () => ({
 vi.mock('#services/coding_agents.js', () => ({
     ensureClaudePlugin: vi.fn()
 }));
-vi.mock('@inquirer/prompts', () => ({
+vi.mock('#utils/prompt.js', () => ({
     confirm: vi.fn()
 }));
 describe('update command', () => {

package/dist/commands/workflow/plan.js

@@ -1,5 +1,6 @@
 import { Command, Flags, ux } from '@oclif/core';
-import { input } from '@inquirer/prompts';
+import { input } from '#utils/prompt.js';
+import { isInteractive } from '#utils/interactive.js';
 import { generatePlanName, updateAgentTemplates, writePlanFile } from '#services/workflow_planner.js';
 import { ensureOutputAISystem } from '#services/coding_agents.js';
 import { invokePlanWorkflow, PLAN_COMMAND_OPTIONS, replyToClaude } from '#services/claude_client.js';
@@ -45,6 +46,9 @@ export default class WorkflowPlan extends Command {
         this.log('=========');
         this.log(originalPlanContent);
         this.log('=========');
+        if (!isInteractive()) {
+            return originalPlanContent;
+        }
         const modifications = await input({
             message: ux.colorize('gray', `Reply or type ${acceptKey} to accept the plan as is: `),
             validate: (value) => value.length >= 10 || value === acceptKey

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

@@ -3,11 +3,12 @@ import WorkflowPlan from './plan.js';
 import { generatePlanName, writePlanFile, updateAgentTemplates } from '#services/workflow_planner.js';
 import { ensureOutputAISystem } from '#services/coding_agents.js';
 import { invokePlanWorkflow, replyToClaude, ClaudeInvocationError } from '#services/claude_client.js';
-import { input } from '@inquirer/prompts';
+import { input } from '#utils/prompt.js';
 vi.mock('#services/workflow_planner.js');
 vi.mock('#services/coding_agents.js');
 vi.mock('#services/claude_client.js');
-vi.mock('@inquirer/prompts');
+vi.mock('#utils/prompt.js');
+vi.mock('#utils/interactive.js', () => ({ isInteractive: () => true }));
 describe('WorkflowPlan Command', () => {
     const createCommand = () => {
         const cmd = new WorkflowPlan([], {});

package/dist/config.d.ts

@@ -1,44 +1,12 @@
-/**
- * CLI configuration
- */
 export declare const config: {
-    /**
-     * Base URL for the Output.ai API server
-     * Can be overridden with OUTPUT_API_URL environment variable
-     */
-    apiUrl: string;
-    /**
-     * API authentication token
-     * Set via OUTPUT_API_AUTH_TOKEN environment variable
-     */
-    apiToken: string | undefined;
-    /**
-     * Default timeout for API requests (in milliseconds)
-     */
+    readonly apiUrl: string;
+    readonly apiToken: string | undefined;
     requestTimeout: number;
-    /**
-     * Docker Compose project name
-     * Can be overridden with DOCKER_SERVICE_NAME environment variable
-     */
-    dockerServiceName: string;
-    /**
-     * Set the debug mode
-     */
-    debugMode: boolean;
-    /**
-     * Where the env vars are stored, defaults to `.env`
-     */
-    envFile: string;
-    /**
-     * Agent configuration directory name
-     */
+    readonly dockerServiceName: string;
+    readonly debugMode: boolean;
+    readonly envFile: string;
     agentConfigDir: string;
-    /**
-     * S3 configuration for remote trace storage
-     * Set via OUTPUT_TRACE_REMOTE_S3_BUCKET, OUTPUT_AWS_REGION,
-     * OUTPUT_AWS_ACCESS_KEY_ID, and OUTPUT_AWS_SECRET_ACCESS_KEY environment variables
-     */
-    s3: {
+    readonly s3: {
         bucket: string | undefined;
         region: string | undefined;
         accessKeyId: string | undefined;

package/dist/config.js

@@ -1,47 +1,27 @@
-/**
- * CLI configuration
- */
 export const config = {
-    /**
-     * Base URL for the Output.ai API server
-     * Can be overridden with OUTPUT_API_URL environment variable
-     */
-    apiUrl: process.env.OUTPUT_API_URL || 'http://localhost:3001',
-    /**
-     * API authentication token
-     * Set via OUTPUT_API_AUTH_TOKEN environment variable
-     */
-    apiToken: process.env.OUTPUT_API_AUTH_TOKEN,
-    /**
-     * Default timeout for API requests (in milliseconds)
-     */
+    get apiUrl() {
+        return process.env.OUTPUT_API_URL || 'http://localhost:3001';
+    },
+    get apiToken() {
+        return process.env.OUTPUT_API_AUTH_TOKEN;
+    },
     requestTimeout: 30000,
-    /**
-     * Docker Compose project name
-     * Can be overridden with DOCKER_SERVICE_NAME environment variable
-     */
-    dockerServiceName: process.env.DOCKER_SERVICE_NAME || 'output-sdk',
-    /**
-     * Set the debug mode
-     */
-    debugMode: process.env.OUTPUT_DEBUG === 'true',
-    /**
-     * Where the env vars are stored, defaults to `.env`
-     */
-    envFile: process.env.OUTPUT_CLI_ENV || '.env',
-    /**
-     * Agent configuration directory name
-     */
+    get dockerServiceName() {
+        return process.env.DOCKER_SERVICE_NAME || 'output-sdk';
+    },
+    get debugMode() {
+        return process.env.OUTPUT_DEBUG === 'true';
+    },
+    get envFile() {
+        return process.env.OUTPUT_CLI_ENV || '.env';
+    },
     agentConfigDir: '.outputai',
-    /**
-     * S3 configuration for remote trace storage
-     * Set via OUTPUT_TRACE_REMOTE_S3_BUCKET, OUTPUT_AWS_REGION,
-     * OUTPUT_AWS_ACCESS_KEY_ID, and OUTPUT_AWS_SECRET_ACCESS_KEY environment variables
-     */
-    s3: {
-        bucket: process.env.OUTPUT_TRACE_REMOTE_S3_BUCKET,
-        region: process.env.OUTPUT_AWS_REGION,
-        accessKeyId: process.env.OUTPUT_AWS_ACCESS_KEY_ID,
-        secretAccessKey: process.env.OUTPUT_AWS_SECRET_ACCESS_KEY
+    get s3() {
+        return {
+            bucket: process.env.OUTPUT_TRACE_REMOTE_S3_BUCKET,
+            region: process.env.OUTPUT_AWS_REGION,
+            accessKeyId: process.env.OUTPUT_AWS_ACCESS_KEY_ID,
+            secretAccessKey: process.env.OUTPUT_AWS_SECRET_ACCESS_KEY
+        };
     }
 };

package/dist/config.spec.d.ts

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

package/dist/config.spec.js

@@ -0,0 +1,75 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { config } from '#config.js';
+describe('config', () => {
+    const envVars = [
+        'OUTPUT_API_URL',
+        'OUTPUT_API_AUTH_TOKEN',
+        'DOCKER_SERVICE_NAME',
+        'OUTPUT_DEBUG',
+        'OUTPUT_CLI_ENV',
+        'OUTPUT_TRACE_REMOTE_S3_BUCKET',
+        'OUTPUT_AWS_REGION',
+        'OUTPUT_AWS_ACCESS_KEY_ID',
+        'OUTPUT_AWS_SECRET_ACCESS_KEY'
+    ];
+    const saved = {};
+    beforeEach(() => {
+        for (const key of envVars) {
+            saved[key] = process.env[key];
+        }
+    });
+    afterEach(() => {
+        for (const key of envVars) {
+            if (saved[key] === undefined) {
+                delete process.env[key];
+            }
+            else {
+                process.env[key] = saved[key];
+            }
+        }
+    });
+    it('reads env vars lazily, not at module evaluation time', () => {
+        process.env.OUTPUT_API_URL = 'https://lazy-test.example.com';
+        expect(config.apiUrl).toBe('https://lazy-test.example.com');
+        process.env.OUTPUT_API_URL = 'https://changed.example.com';
+        expect(config.apiUrl).toBe('https://changed.example.com');
+    });
+    it('falls back to defaults when env vars are unset', () => {
+        delete process.env.OUTPUT_API_URL;
+        delete process.env.DOCKER_SERVICE_NAME;
+        delete process.env.OUTPUT_DEBUG;
+        delete process.env.OUTPUT_CLI_ENV;
+        expect(config.apiUrl).toBe('http://localhost:3001');
+        expect(config.dockerServiceName).toBe('output-sdk');
+        expect(config.debugMode).toBe(false);
+        expect(config.envFile).toBe('.env');
+    });
+    it('reads apiToken from env', () => {
+        process.env.OUTPUT_API_AUTH_TOKEN = 'test-token-123';
+        expect(config.apiToken).toBe('test-token-123');
+        delete process.env.OUTPUT_API_AUTH_TOKEN;
+        expect(config.apiToken).toBeUndefined();
+    });
+    it('reads debugMode as boolean', () => {
+        process.env.OUTPUT_DEBUG = 'true';
+        expect(config.debugMode).toBe(true);
+        process.env.OUTPUT_DEBUG = 'false';
+        expect(config.debugMode).toBe(false);
+    });
+    it('reads s3 config lazily', () => {
+        process.env.OUTPUT_TRACE_REMOTE_S3_BUCKET = 'my-bucket';
+        process.env.OUTPUT_AWS_REGION = 'us-west-2';
+        process.env.OUTPUT_AWS_ACCESS_KEY_ID = 'AKIA123';
+        process.env.OUTPUT_AWS_SECRET_ACCESS_KEY = 'secret123';
+        expect(config.s3).toEqual({
+            bucket: 'my-bucket',
+            region: 'us-west-2',
+            accessKeyId: 'AKIA123',
+            secretAccessKey: 'secret123'
+        });
+    });
+    it('has static properties that are not env-derived', () => {
+        expect(config.requestTimeout).toBe(30000);
+        expect(config.agentConfigDir).toBe('.outputai');
+    });
+});

package/dist/generated/framework_version.json

@@ -1,3 +1,3 @@
 {
-    "framework": "0.2.1-next.af8a069.0"
+    "framework": "0.2.1-next.bd54540.0"
 }

package/dist/hooks/init.js

@@ -1,6 +1,10 @@
 import { ux } from '@oclif/core';
 import { checkForUpdate } from '#services/version_check.js';
+import { setNonInteractive } from '#utils/interactive.js';
 const hook = async function () {
+    if (process.argv.includes('--yes') || process.argv.includes('--non-interactive')) {
+        setNonInteractive(true);
+    }
     try {
         const result = await checkForUpdate(this.config.version, this.config.cacheDir);
         if (!result.updateAvailable) {

package/dist/services/coding_agents.js

@@ -7,7 +7,8 @@ import { access } from 'node:fs/promises';
 import path from 'node:path';
 import { join } from 'node:path';
 import { ux } from '@oclif/core';
-import { confirm } from '@inquirer/prompts';
+import { confirm } from '#utils/prompt.js';
+import { isInteractive } from '#utils/interactive.js';
 import debugFactory from 'debug';
 import { getTemplateDir } from '#utils/paths.js';
 import { executeClaudeCommand } from '#utils/claude.js';
@@ -142,6 +143,9 @@ async function handlePluginError(error, commandName, silent = false) {
         debug('Plugin error: %s', pluginError.message);
         throw error;
     }
+    if (!isInteractive()) {
+        throw pluginError;
+    }
     ux.warn(pluginError.message);
     try {
         const shouldProceed = await confirm({

package/dist/services/coding_agents.spec.js

@@ -19,9 +19,12 @@ vi.mock('@oclif/core', () => ({
         colorize: vi.fn().mockImplementation((_color, text) => text)
     }
 }));
-vi.mock('@inquirer/prompts', () => ({
+vi.mock('#utils/prompt.js', () => ({
     confirm: vi.fn()
 }));
+vi.mock('#utils/interactive.js', () => ({
+    isInteractive: vi.fn(() => true)
+}));
 describe('coding_agents service', () => {
     beforeEach(() => {
         vi.clearAllMocks();
@@ -157,7 +160,7 @@ describe('coding_agents service', () => {
         });
         it('should show error and prompt user when plugin commands fail', async () => {
             const { executeClaudeCommand } = await import('../utils/claude.js');
-            const { confirm } = await import('@inquirer/prompts');
+            const { confirm } = await import('#utils/prompt.js');
             vi.mocked(executeClaudeCommand)
                 .mockResolvedValueOnce(undefined) // marketplace add
                 .mockRejectedValueOnce(new Error('Plugin update failed')); // marketplace update
@@ -169,7 +172,7 @@ describe('coding_agents service', () => {
         });
         it('should allow user to proceed without plugin setup if they confirm', async () => {
             const { executeClaudeCommand } = await import('../utils/claude.js');
-            const { confirm } = await import('@inquirer/prompts');
+            const { confirm } = await import('#utils/prompt.js');
             vi.mocked(executeClaudeCommand)
                 .mockRejectedValue(new Error('All plugin commands fail'));
             vi.mocked(confirm).mockResolvedValue(true);
@@ -219,7 +222,7 @@ describe('coding_agents service', () => {
         });
         it('should show error and prompt user when registerPluginMarketplace fails', async () => {
             const { executeClaudeCommand } = await import('../utils/claude.js');
-            const { confirm } = await import('@inquirer/prompts');
+            const { confirm } = await import('#utils/prompt.js');
             vi.mocked(executeClaudeCommand)
                 .mockResolvedValueOnce(undefined) // marketplace add
                 .mockRejectedValueOnce(new Error('Plugin update failed')); // marketplace update
@@ -231,7 +234,7 @@ describe('coding_agents service', () => {
         });
         it('should show error and prompt user when installOutputAIPlugin fails', async () => {
             const { executeClaudeCommand } = await import('../utils/claude.js');
-            const { confirm } = await import('@inquirer/prompts');
+            const { confirm } = await import('#utils/prompt.js');
             vi.mocked(executeClaudeCommand)
                 .mockResolvedValueOnce(undefined) // marketplace add
                 .mockResolvedValueOnce(undefined) // marketplace update
@@ -244,7 +247,7 @@ describe('coding_agents service', () => {
         });
         it('should allow user to proceed without plugin setup if they confirm', async () => {
             const { executeClaudeCommand } = await import('../utils/claude.js');
-            const { confirm } = await import('@inquirer/prompts');
+            const { confirm } = await import('#utils/prompt.js');
             vi.mocked(executeClaudeCommand)
                 .mockRejectedValue(new Error('All plugin commands fail'));
             vi.mocked(confirm).mockResolvedValue(true);
@@ -252,5 +255,15 @@ describe('coding_agents service', () => {
             // File operations should still complete
             expect(fs.mkdir).toHaveBeenCalled();
         });
+        it('should rethrow plugin error in non-interactive mode without prompting', async () => {
+            const { executeClaudeCommand } = await import('../utils/claude.js');
+            const { confirm } = await import('#utils/prompt.js');
+            const { isInteractive } = await import('#utils/interactive.js');
+            vi.mocked(isInteractive).mockReturnValueOnce(false);
+            vi.mocked(executeClaudeCommand)
+                .mockRejectedValueOnce(new Error('Plugin marketplace add failed'));
+            await expect(initializeAgentConfig({ projectRoot: '/test/project', force: true })).rejects.toThrow(/plugin marketplace add/i);
+            expect(confirm).not.toHaveBeenCalled();
+        });
     });
 });

package/dist/services/credentials_configurator.js

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

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/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';

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/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 {};

package/dist/utils/interactive.spec.js

@@ -0,0 +1,40 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+describe('interactive', () => {
+    beforeEach(async () => {
+        // Re-import to reset singleton state
+        const mod = await import('./interactive.js');
+        mod.setNonInteractive(false);
+    });
+    it('isInteractive returns true by default when TTY is available', async () => {
+        const originalIsTTY = process.stdin.isTTY;
+        Object.defineProperty(process.stdin, 'isTTY', { value: true, configurable: true });
+        const { isInteractive } = await import('./interactive.js');
+        expect(isInteractive()).toBe(true);
+        Object.defineProperty(process.stdin, 'isTTY', { value: originalIsTTY, configurable: true });
+    });
+    it('isInteractive returns false when no TTY', async () => {
+        const originalIsTTY = process.stdin.isTTY;
+        Object.defineProperty(process.stdin, 'isTTY', { value: undefined, configurable: true });
+        const { isInteractive } = await import('./interactive.js');
+        expect(isInteractive()).toBe(false);
+        Object.defineProperty(process.stdin, 'isTTY', { value: originalIsTTY, configurable: true });
+    });
+    it('isInteractive returns false after setNonInteractive(true)', async () => {
+        const originalIsTTY = process.stdin.isTTY;
+        Object.defineProperty(process.stdin, 'isTTY', { value: true, configurable: true });
+        const { isInteractive, setNonInteractive } = await import('./interactive.js');
+        setNonInteractive(true);
+        expect(isInteractive()).toBe(false);
+        Object.defineProperty(process.stdin, 'isTTY', { value: originalIsTTY, configurable: true });
+    });
+    it('setNonInteractive(false) restores interactive mode', async () => {
+        const originalIsTTY = process.stdin.isTTY;
+        Object.defineProperty(process.stdin, 'isTTY', { value: true, configurable: true });
+        const { isInteractive, setNonInteractive } = await import('./interactive.js');
+        setNonInteractive(true);
+        expect(isInteractive()).toBe(false);
+        setNonInteractive(false);
+        expect(isInteractive()).toBe(true);
+        Object.defineProperty(process.stdin, 'isTTY', { value: originalIsTTY, configurable: true });
+    });
+});

package/dist/utils/prompt.d.ts

@@ -0,0 +1,17 @@
+type ConfirmOptions = {
+    message: string;
+    default?: boolean;
+};
+type InputOptions = {
+    message: string;
+    default?: string;
+    validate?: (value: string) => boolean | string;
+};
+type PasswordOptions = {
+    message: string;
+    mask?: boolean;
+};
+export declare const confirm: (options: ConfirmOptions) => Promise<boolean>;
+export declare const input: (options: InputOptions) => Promise<string>;
+export declare const password: (options: PasswordOptions) => Promise<string>;
+export {};

package/dist/utils/prompt.js

@@ -0,0 +1,20 @@
+import { confirm as inquirerConfirm, input as inquirerInput, password as inquirerPassword } from '@inquirer/prompts';
+import { isInteractive } from './interactive.js';
+export const confirm = async (options) => {
+    if (!isInteractive()) {
+        return true;
+    }
+    return inquirerConfirm(options);
+};
+export const input = async (options) => {
+    if (!isInteractive()) {
+        return options.default ?? '';
+    }
+    return inquirerInput(options);
+};
+export const password = async (options) => {
+    if (!isInteractive()) {
+        return '';
+    }
+    return inquirerPassword(options);
+};

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

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

package/dist/utils/prompt.spec.js

@@ -0,0 +1,70 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { confirm as inquirerConfirm, input as inquirerInput, password as inquirerPassword } from '@inquirer/prompts';
+vi.mock('@inquirer/prompts', () => ({
+    confirm: vi.fn(),
+    input: vi.fn(),
+    password: vi.fn()
+}));
+vi.mock('./interactive.js', () => ({
+    isInteractive: vi.fn()
+}));
+describe('prompt wrapper', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('when interactive', () => {
+        beforeEach(async () => {
+            const { isInteractive } = await import('./interactive.js');
+            vi.mocked(isInteractive).mockReturnValue(true);
+        });
+        it('confirm delegates to inquirer', async () => {
+            vi.mocked(inquirerConfirm).mockResolvedValue(false);
+            const { confirm } = await import('./prompt.js');
+            const result = await confirm({ message: 'Continue?', default: true });
+            expect(inquirerConfirm).toHaveBeenCalledWith({ message: 'Continue?', default: true });
+            expect(result).toBe(false);
+        });
+        it('input delegates to inquirer', async () => {
+            vi.mocked(inquirerInput).mockResolvedValue('user input');
+            const { input } = await import('./prompt.js');
+            const result = await input({ message: 'Name?', default: 'default' });
+            expect(inquirerInput).toHaveBeenCalledWith({ message: 'Name?', default: 'default' });
+            expect(result).toBe('user input');
+        });
+        it('password delegates to inquirer', async () => {
+            vi.mocked(inquirerPassword).mockResolvedValue('secret');
+            const { password } = await import('./prompt.js');
+            const result = await password({ message: 'Token?' });
+            expect(inquirerPassword).toHaveBeenCalledWith({ message: 'Token?' });
+            expect(result).toBe('secret');
+        });
+    });
+    describe('when non-interactive', () => {
+        beforeEach(async () => {
+            const { isInteractive } = await import('./interactive.js');
+            vi.mocked(isInteractive).mockReturnValue(false);
+        });
+        it('confirm always returns true regardless of default', async () => {
+            const { confirm } = await import('./prompt.js');
+            expect(await confirm({ message: 'Continue?', default: false })).toBe(true);
+            expect(await confirm({ message: 'Continue?', default: true })).toBe(true);
+            expect(await confirm({ message: 'Continue?' })).toBe(true);
+            expect(inquirerConfirm).not.toHaveBeenCalled();
+        });
+        it('input returns default value', async () => {
+            const { input } = await import('./prompt.js');
+            expect(await input({ message: 'Name?', default: 'fallback' })).toBe('fallback');
+            expect(inquirerInput).not.toHaveBeenCalled();
+        });
+        it('input returns empty string when no default', async () => {
+            const { input } = await import('./prompt.js');
+            expect(await input({ message: 'Name?' })).toBe('');
+            expect(inquirerInput).not.toHaveBeenCalled();
+        });
+        it('password returns empty string', async () => {
+            const { password } = await import('./prompt.js');
+            expect(await password({ message: 'Token?' })).toBe('');
+            expect(inquirerPassword).not.toHaveBeenCalled();
+        });
+    });
+});

package/dist/utils/proxy.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Routes all `fetch()` calls through an HTTP/HTTPS proxy when standard
+ * proxy env vars are set (`HTTPS_PROXY`, `https_proxy`, `HTTP_PROXY`,
+ * `http_proxy`). No-op when none are set. Invalid URLs are logged and
+ * skipped so the CLI keeps running.
+ *
+ * Call once at CLI startup, before any network activity.
+ */
+export declare const bootstrapProxy: () => void;

package/dist/utils/proxy.js

@@ -0,0 +1,24 @@
+import { EnvHttpProxyAgent, setGlobalDispatcher } from 'undici';
+/**
+ * Routes all `fetch()` calls through an HTTP/HTTPS proxy when standard
+ * proxy env vars are set (`HTTPS_PROXY`, `https_proxy`, `HTTP_PROXY`,
+ * `http_proxy`). No-op when none are set. Invalid URLs are logged and
+ * skipped so the CLI keeps running.
+ *
+ * Call once at CLI startup, before any network activity.
+ */
+export const bootstrapProxy = () => {
+    const proxyUrl = process.env.HTTPS_PROXY || process.env.https_proxy ||
+        process.env.HTTP_PROXY || process.env.http_proxy;
+    if (!proxyUrl) {
+        return;
+    }
+    try {
+        new URL(proxyUrl);
+    }
+    catch {
+        console.warn(`[proxy] Ignoring invalid proxy URL: ${proxyUrl}`);
+        return;
+    }
+    setGlobalDispatcher(new EnvHttpProxyAgent());
+};

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

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

package/dist/utils/proxy.spec.js

@@ -0,0 +1,48 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+const mockSetGlobalDispatcher = vi.fn();
+const MockEnvHttpProxyAgent = vi.fn();
+vi.mock('undici', () => ({
+    EnvHttpProxyAgent: MockEnvHttpProxyAgent,
+    setGlobalDispatcher: mockSetGlobalDispatcher
+}));
+describe('proxy bootstrap', () => {
+    const originalEnv = { ...process.env };
+    beforeEach(() => {
+        vi.clearAllMocks();
+        delete process.env.HTTPS_PROXY;
+        delete process.env.https_proxy;
+        delete process.env.HTTP_PROXY;
+        delete process.env.http_proxy;
+    });
+    afterEach(() => {
+        process.env = { ...originalEnv };
+    });
+    it('does nothing when no proxy env vars are set', async () => {
+        const { bootstrapProxy } = await import('./proxy.js');
+        bootstrapProxy();
+        expect(mockSetGlobalDispatcher).not.toHaveBeenCalled();
+    });
+    it('sets global dispatcher when HTTPS_PROXY is set', async () => {
+        process.env.HTTPS_PROXY = 'http://proxy:8080';
+        const { bootstrapProxy } = await import('./proxy.js');
+        bootstrapProxy();
+        expect(MockEnvHttpProxyAgent).toHaveBeenCalled();
+        expect(mockSetGlobalDispatcher).toHaveBeenCalledTimes(1);
+    });
+    it('sets global dispatcher when HTTP_PROXY is set', async () => {
+        process.env.HTTP_PROXY = 'http://proxy:8080';
+        const { bootstrapProxy } = await import('./proxy.js');
+        bootstrapProxy();
+        expect(MockEnvHttpProxyAgent).toHaveBeenCalled();
+        expect(mockSetGlobalDispatcher).toHaveBeenCalledTimes(1);
+    });
+    it('does not set global dispatcher when proxy URL is malformed', async () => {
+        process.env.HTTPS_PROXY = 'not a url';
+        const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+        const { bootstrapProxy } = await import('./proxy.js');
+        bootstrapProxy();
+        expect(mockSetGlobalDispatcher).not.toHaveBeenCalled();
+        expect(warnSpy).toHaveBeenCalled();
+        warnSpy.mockRestore();
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/cli",
-  "version": "0.2.1-next.af8a069.0",
+  "version": "0.2.1-next.bd54540.0",
   "description": "CLI for Output.ai workflow generation",
   "type": "module",
   "main": "dist/index.js",
@@ -34,10 +34,11 @@
     "ky": "1.14.3",
     "react": "19.2.5",
     "semver": "7.7.4",
+    "undici": "8.0.2",
     "yaml": "^2.8.3",
-    "@outputai/credentials": "0.2.1-next.af8a069.0",
-    "@outputai/evals": "0.2.1-next.af8a069.0",
-    "@outputai/llm": "0.2.1-next.af8a069.0"
+    "@outputai/credentials": "0.2.1-next.bd54540.0",
+    "@outputai/evals": "0.2.1-next.bd54540.0",
+    "@outputai/llm": "0.2.1-next.bd54540.0"
   },
   "devDependencies": {
     "@types/cli-progress": "3.11.6",