@output.ai/cli 0.0.8 → 0.2.3

package/dist/commands/dev/index.js

@@ -0,0 +1,54 @@
+import { Command, Flags } from '@oclif/core';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { validateDockerEnvironment, startDockerCompose, DockerComposeConfigNotFoundError, getDefaultDockerComposePath } from '#services/docker.js';
+import { getErrorMessage } from '#utils/error_utils.js';
+export default class Dev extends Command {
+    static description = 'Start Output development services (auto-restarts worker on file changes)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --no-watch',
+        '<%= config.bin %> <%= command.id %> --compose-file ./custom-docker-compose.yml'
+    ];
+    static args = {};
+    static flags = {
+        'compose-file': Flags.string({
+            description: 'Path to a custom docker-compose file',
+            required: false,
+            char: 'f'
+        }),
+        'no-watch': Flags.boolean({
+            description: 'Disable automatic container restart on file changes',
+            default: false
+        })
+    };
+    async run() {
+        const { flags } = await this.parse(Dev);
+        validateDockerEnvironment();
+        const dockerComposePath = flags['compose-file'] ?
+            path.resolve(process.cwd(), flags['compose-file']) :
+            getDefaultDockerComposePath();
+        try {
+            await fs.access(dockerComposePath);
+        }
+        catch {
+            throw new DockerComposeConfigNotFoundError(dockerComposePath);
+        }
+        this.log('\n🚀 Starting Output development services...\n');
+        if (flags['compose-file']) {
+            this.log(`Using custom docker-compose file: ${flags['compose-file']}\n`);
+        }
+        if (!flags['no-watch']) {
+            this.log('👀 File watching enabled - worker will restart automatically on changes\n');
+        }
+        else {
+            this.log('ℹ️  File watching disabled (--no-watch flag used)\n');
+        }
+        try {
+            await startDockerCompose(dockerComposePath, !flags['no-watch']);
+        }
+        catch (error) {
+            this.error(getErrorMessage(error), { exit: 1 });
+        }
+    }
+}

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

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

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

@@ -0,0 +1,150 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import fs from 'node:fs/promises';
+import * as dockerService from '#services/docker.js';
+import Dev from './index.js';
+vi.mock('#services/docker.js', () => ({
+    validateDockerEnvironment: vi.fn(),
+    startDockerCompose: vi.fn().mockResolvedValue(undefined),
+    DockerComposeConfigNotFoundError: Error,
+    DockerValidationError: Error,
+    getDefaultDockerComposePath: vi.fn(() => '/path/to/docker-compose-dev.yml')
+}));
+vi.mock('node:fs/promises', () => ({
+    default: {
+        access: vi.fn()
+    }
+}));
+describe('dev command', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // By default, docker validation succeeds
+        vi.mocked(dockerService.validateDockerEnvironment).mockResolvedValue(undefined);
+        // By default, fs.access succeeds (file exists)
+        vi.mocked(fs).access.mockResolvedValue(undefined);
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    describe('command structure', () => {
+        it('should have correct description', () => {
+            expect(Dev.description).toBeDefined();
+            expect(Dev.description).toContain('development services');
+        });
+        it('should have examples', () => {
+            expect(Dev.examples).toBeDefined();
+            expect(Array.isArray(Dev.examples)).toBe(true);
+            expect(Dev.examples.length).toBeGreaterThan(0);
+        });
+        it('should have no required arguments', () => {
+            expect(Dev.args).toBeDefined();
+            expect(Object.keys(Dev.args)).toHaveLength(0);
+        });
+        it('should have no-watch flag defined', () => {
+            expect(Dev.flags).toBeDefined();
+            expect(Dev.flags['no-watch']).toBeDefined();
+            expect(Dev.flags['no-watch'].description).toContain('Disable automatic container restart');
+        });
+        it('should have compose-file flag defined', () => {
+            expect(Dev.flags).toBeDefined();
+            expect(Dev.flags['compose-file']).toBeDefined();
+            expect(Dev.flags['compose-file'].description).toContain('custom docker-compose');
+            expect(Dev.flags['compose-file'].required).toBe(false);
+            expect(Dev.flags['compose-file'].char).toBe('f');
+        });
+    });
+    describe('command instantiation', () => {
+        it('should be instantiable', () => {
+            const cmd = new Dev([], {});
+            expect(cmd).toBeInstanceOf(Dev);
+        });
+        it('should have a run method', () => {
+            const cmd = new Dev([], {});
+            expect(cmd.run).toBeDefined();
+            expect(typeof cmd.run).toBe('function');
+        });
+    });
+    describe('Docker validation', () => {
+        it('should error if Docker validation fails', async () => {
+            const config = {
+                runHook: vi.fn().mockResolvedValue({ failures: [], successes: [] })
+            };
+            const cmd = new Dev([], config);
+            cmd.log = vi.fn();
+            // Mock parse to return flags
+            Object.defineProperty(cmd, 'parse', {
+                value: vi.fn().mockResolvedValue({ flags: { 'no-watch': false, 'compose-file': undefined }, args: {} }),
+                configurable: true
+            });
+            const validationError = new Error('Docker is not installed');
+            vi.mocked(dockerService.validateDockerEnvironment).mockImplementation(() => {
+                throw validationError;
+            });
+            await expect(cmd.run()).rejects.toThrow('Docker is not installed');
+        });
+        it('should call validateDockerEnvironment', async () => {
+            const cmd = new Dev([], {});
+            cmd.log = vi.fn();
+            cmd.error = vi.fn();
+            // Mock the subprocess spawn to prevent actual execution
+            vi.doMock('node:child_process', () => ({
+                spawn: vi.fn().mockReturnValue({
+                    on: vi.fn(),
+                    kill: vi.fn()
+                })
+            }));
+            // This test just verifies the function is called
+            expect(vi.mocked(dockerService.validateDockerEnvironment)).toBeDefined();
+        });
+    });
+    describe('watch functionality', () => {
+        it('should enable watch by default', async () => {
+            const cmd = new Dev([], {});
+            cmd.log = vi.fn();
+            cmd.error = vi.fn();
+            // Mock parse to return flags
+            Object.defineProperty(cmd, 'parse', {
+                value: vi.fn().mockResolvedValue({ flags: { 'no-watch': false, 'compose-file': undefined }, args: {} }),
+                configurable: true
+            });
+            await cmd.run();
+            expect(dockerService.startDockerCompose).toHaveBeenCalledWith('/path/to/docker-compose-dev.yml', true // enableWatch should be true
+            );
+            expect(cmd.log).toHaveBeenCalledWith(expect.stringContaining('File watching enabled'));
+        });
+        it('should disable watch with --no-watch flag', async () => {
+            const cmd = new Dev(['--no-watch'], {});
+            cmd.log = vi.fn();
+            cmd.error = vi.fn();
+            // Mock parse to return flags
+            Object.defineProperty(cmd, 'parse', {
+                value: vi.fn().mockResolvedValue({ flags: { 'no-watch': true, 'compose-file': undefined }, args: {} }),
+                configurable: true
+            });
+            await cmd.run();
+            expect(dockerService.startDockerCompose).toHaveBeenCalledWith('/path/to/docker-compose-dev.yml', false // enableWatch should be false
+            );
+            expect(cmd.log).toHaveBeenCalledWith(expect.stringContaining('File watching disabled'));
+        });
+        it('should handle docker compose configuration not found', async () => {
+            vi.mocked(fs).access.mockRejectedValue(new Error('File not found'));
+            const cmd = new Dev([], {});
+            cmd.log = vi.fn();
+            cmd.error = vi.fn();
+            await expect(cmd.run()).rejects.toThrow();
+        });
+        it('should handle startDockerCompose errors', async () => {
+            vi.mocked(dockerService.startDockerCompose).mockRejectedValue(new Error('Docker error'));
+            const cmd = new Dev([], {});
+            cmd.log = vi.fn();
+            cmd.error = vi.fn();
+            // Mock parse to return flags
+            Object.defineProperty(cmd, 'parse', {
+                value: vi.fn().mockResolvedValue({ flags: { 'no-watch': false, 'compose-file': undefined }, args: {} }),
+                configurable: true
+            });
+            await cmd.run();
+            expect(cmd.error).toHaveBeenCalledWith('Docker error', { exit: 1 });
+        });
+    });
+});

package/dist/commands/init.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export default class Init extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {};
+    static flags: {
+        'skip-env': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/init.js

@@ -0,0 +1,30 @@
+import { Command, Flags } from '@oclif/core';
+import { UserCancelledError } from '#types/errors.js';
+import { runInit, handleRunInitError } from '#services/project_scaffold.js';
+export default class Init extends Command {
+    static description = 'Initialize a new Output SDK workflow project by scaffolding the complete project structure';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>'
+    ];
+    static args = {};
+    static flags = {
+        'skip-env': Flags.boolean({
+            description: 'Skip interactive environment variable configuration',
+            default: false
+        })
+    };
+    async run() {
+        try {
+            const { flags } = await this.parse(Init);
+            await runInit((msg) => this.log(msg), (msg) => this.warn(msg), flags['skip-env']);
+        }
+        catch (error) {
+            if (error instanceof UserCancelledError) {
+                this.log(error.message);
+                return;
+            }
+            const { errorMessage } = await handleRunInitError(error, (msg) => this.warn(msg));
+            this.error(errorMessage);
+        }
+    }
+}

package/dist/commands/init.spec.d.ts

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

package/dist/commands/init.spec.js

@@ -0,0 +1,109 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import * as projectScaffold from '#services/project_scaffold.js';
+import { UserCancelledError } from '#types/errors.js';
+import Init from './init.js';
+vi.mock('#services/project_scaffold.js');
+describe('init command', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.mocked(projectScaffold.runInit).mockResolvedValue(undefined);
+        vi.mocked(projectScaffold.handleRunInitError).mockResolvedValue({
+            shouldCleanup: false,
+            errorMessage: 'Failed to create project',
+            projectPath: null
+        });
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    describe('command structure', () => {
+        it('should have correct description', () => {
+            expect(Init.description).toBeDefined();
+            expect(Init.description).toContain('scaffold');
+        });
+        it('should have correct examples', () => {
+            expect(Init.examples).toBeDefined();
+            expect(Array.isArray(Init.examples)).toBe(true);
+            expect(Init.examples.length).toBeGreaterThan(0);
+        });
+        it('should have no required arguments', () => {
+            expect(Init.args).toBeDefined();
+            expect(Object.keys(Init.args)).toHaveLength(0);
+        });
+    });
+    describe('command execution', () => {
+        const createTestCommand = (args = [], flags = {}) => {
+            const cmd = new Init(args, {});
+            cmd.log = vi.fn();
+            cmd.warn = vi.fn();
+            cmd.error = vi.fn();
+            Object.defineProperty(cmd, 'parse', {
+                value: vi.fn().mockResolvedValue({
+                    args: {},
+                    flags: { 'skip-env': false, ...flags }
+                }),
+                configurable: true
+            });
+            return cmd;
+        };
+        it('should be instantiable', () => {
+            const cmd = createTestCommand();
+            expect(cmd).toBeInstanceOf(Init);
+        });
+        it('should have a run method', () => {
+            const cmd = createTestCommand();
+            expect(cmd.run).toBeDefined();
+            expect(typeof cmd.run).toBe('function');
+        });
+        it('should call runInit with log, warn callbacks, and skip-env flag', async () => {
+            const cmd = createTestCommand();
+            await cmd.run();
+            expect(projectScaffold.runInit).toHaveBeenCalledWith(expect.any(Function), expect.any(Function), false);
+        });
+        it('should handle UserCancelledError', async () => {
+            const error = new UserCancelledError();
+            vi.mocked(projectScaffold.runInit).mockRejectedValue(error);
+            const cmd = createTestCommand();
+            await cmd.run();
+            expect(cmd.log).toHaveBeenCalledWith('Init cancelled by user.');
+            expect(cmd.error).not.toHaveBeenCalled();
+        });
+        it('should handle other errors with error handler', async () => {
+            const testError = new Error('Test error');
+            vi.mocked(projectScaffold.runInit).mockRejectedValue(testError);
+            vi.mocked(projectScaffold.handleRunInitError).mockResolvedValue({
+                shouldCleanup: true,
+                errorMessage: 'Failed to create project',
+                projectPath: '/some/path'
+            });
+            const cmd = createTestCommand();
+            await cmd.run();
+            expect(projectScaffold.handleRunInitError).toHaveBeenCalledWith(testError, expect.any(Function));
+            expect(cmd.error).toHaveBeenCalledWith('Failed to create project');
+        });
+        it('should pass error message from handler to error', async () => {
+            const testError = new Error('Custom error');
+            vi.mocked(projectScaffold.runInit).mockRejectedValue(testError);
+            vi.mocked(projectScaffold.handleRunInitError).mockResolvedValue({
+                shouldCleanup: false,
+                errorMessage: 'Folder already exists',
+                projectPath: null
+            });
+            const cmd = createTestCommand();
+            await cmd.run();
+            expect(cmd.error).toHaveBeenCalledWith('Folder already exists');
+        });
+        it('should successfully complete project creation', async () => {
+            const cmd = createTestCommand();
+            await cmd.run();
+            expect(projectScaffold.runInit).toHaveBeenCalled();
+            expect(cmd.error).not.toHaveBeenCalled();
+        });
+        it('should pass skip-env flag to runInit when --skip-env is provided', async () => {
+            const cmd = createTestCommand([], { 'skip-env': true });
+            await cmd.run();
+            expect(projectScaffold.runInit).toHaveBeenCalledWith(expect.any(Function), expect.any(Function), true);
+        });
+    });
+});

package/dist/commands/workflow/run.js

@@ -43,6 +43,11 @@ export default class WorkflowRun extends Command {
             workflowName: args.workflowName,
             input,
             taskQueue: flags['task-queue']
+        }, {
+            // Set a 10-minute timeout for workflow execution
+            config: {
+                timeout: 600000
+            }
         });
         if (!response || !response.data) {
             this.error('API returned invalid response', { exit: 1 });

package/dist/services/claude_client.js

@@ -4,6 +4,7 @@
 import { query } from '@anthropic-ai/claude-agent-sdk';
 import { ux } from '@oclif/core';
 import * as cliProgress from 'cli-progress';
+import { getErrorMessage, toError } from '#utils/error_utils.js';
 const ADDITIONAL_INSTRUCTIONS = `
 ! IMPORTANT !
 1. Use TodoWrite to track your progress through plan creation.
@@ -53,7 +54,19 @@ export class ClaudeInvocationError extends Error {
 }
 function validateEnvironment() {
     if (!process.env.ANTHROPIC_API_KEY) {
-        throw new Error('ANTHROPIC_API_KEY environment variable is required');
+        throw new Error('ANTHROPIC_API_KEY environment variable is required.\n' +
+            '\n' +
+            'Please set it using one of these methods:\n' +
+            '1. Add it to a .env file in your project root:\n' +
+            '   ANTHROPIC_API_KEY=your-api-key\n' +
+            '\n' +
+            '2. Export it in your shell:\n' +
+            '   export ANTHROPIC_API_KEY=your-api-key\n' +
+            '\n' +
+            '3. Set it when running the command:\n' +
+            '   ANTHROPIC_API_KEY=your-api-key output workflow plan\n' +
+            '\n' +
+            'Get your API key from: https://console.anthropic.com/');
     }
 }
 function validateSystem(systemMessage) {
@@ -166,7 +179,7 @@ async function singleQuery(prompt, options = {}) {
     }
     catch (error) {
         progressBar.stop();
-        throw new ClaudeInvocationError(`Failed to invoke claude-code: ${error.message}`, error);
+        throw new ClaudeInvocationError(`Failed to invoke claude-code: ${getErrorMessage(error)}`, toError(error));
     }
 }
 export async function replyToClaude(message, options = {}) {

package/dist/services/claude_client.spec.js

@@ -1,5 +1,6 @@
 import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
 import { invokePlanWorkflow, ClaudeInvocationError } from './claude_client.js';
+import { isError } from '#utils/error_utils.js';
 // Mock Claude SDK
 vi.mock('@anthropic-ai/claude-agent-sdk', () => ({
     query: vi.fn()
@@ -108,7 +109,10 @@ describe('invokePlanWorkflow', () => {
                 await invokePlanWorkflow('Test');
             }
             catch (error) {
-                expect(error.message).toMatch(/Failed to invoke/i);
+                expect(isError(error)).toBe(true);
+                if (isError(error)) {
+                    expect(error.message).toMatch(/Failed to invoke/i);
+                }
             }
         });
         it('should throw error when no result received', async () => {

package/dist/services/coding_agents.js

@@ -177,12 +177,17 @@ async function createFromTemplate(template, output, variables) {
 /**
  * Create a symlink, falling back to copying if symlinks are not supported
  */
-async function createSymlink(source, target) {
+async function createSymlink(source, target, projectRoot) {
     try {
         if (await fileExists(target)) {
             await fs.unlink(target);
         }
-        const relativePath = path.relative(path.dirname(target), source);
+        // Resolve source path relative to project root if it's relative
+        const resolvedSource = path.isAbsolute(source) ?
+            source :
+            path.join(projectRoot, source);
+        // Calculate relative path from target directory to resolved source
+        const relativePath = path.relative(path.dirname(target), resolvedSource);
         await fs.symlink(relativePath, target);
         ux.stdout(ux.colorize('gray', `Created symlink: ${target} -> ${source}`));
     }
@@ -190,7 +195,11 @@ async function createSymlink(source, target) {
         const code = error.code;
         if (code === 'ENOTSUP' || code === 'EPERM') {
             ux.stdout(ux.colorize('gray', `Symlinks not supported, creating copy: ${target}`));
-            const content = await fs.readFile(source, 'utf-8');
+            // Use resolved source path for copying
+            const resolvedSource = path.isAbsolute(source) ?
+                source :
+                path.join(projectRoot, source);
+            const content = await fs.readFile(resolvedSource, 'utf-8');
             await fs.writeFile(target, content, 'utf-8');
             return;
         }
@@ -224,7 +233,7 @@ async function processMappings(config, variables, force, projectRoot) {
                 await createFromTemplate(mapping.from, fullPath, variables);
                 break;
             case 'symlink':
-                await createSymlink(mapping.from, fullPath);
+                await createSymlink(mapping.from, fullPath, projectRoot);
                 break;
             case 'copy':
                 await copyFile(mapping.from, fullPath);

package/dist/services/coding_agents.spec.js

@@ -2,6 +2,7 @@ import { describe, it, expect, beforeEach, vi } from 'vitest';
 import { getRequiredFiles, checkAgentConfigDirExists, checkAgentStructure, getAgentConfigDir, prepareTemplateVariables, initializeAgentConfig, ensureOutputAIStructure, AGENT_CONFIGS } from './coding_agents.js';
 import { access } from 'node:fs/promises';
 import fs from 'node:fs/promises';
+import { getErrorMessage } from '#utils/error_utils.js';
 vi.mock('node:fs/promises');
 vi.mock('../utils/paths.js', () => ({
     getTemplateDir: vi.fn().mockReturnValue('/templates')
@@ -362,7 +363,7 @@ describe('coding_agents service', () => {
                 expect.fail('Should have thrown an error');
             }
             catch (error) {
-                const message = error.message;
+                const message = getErrorMessage(error);
                 expect(message).toContain('.outputai/AGENTS.md');
                 expect(message).toContain('.outputai/agents/workflow_planner.md');
                 expect(message).toContain('Run "output-cli agents init --force"');

package/dist/services/docker.d.ts

@@ -0,0 +1,12 @@
+declare class DockerValidationError extends Error {
+}
+export declare class DockerComposeConfigNotFoundError extends Error {
+    constructor(dockerComposePath: string);
+}
+declare const isDockerInstalled: () => boolean;
+declare const isDockerComposeAvailable: () => boolean;
+declare const isDockerDaemonRunning: () => boolean;
+export declare function validateDockerEnvironment(): void;
+export declare function startDockerCompose(dockerComposePath: string, enableWatch?: boolean): Promise<void>;
+export declare function getDefaultDockerComposePath(): string;
+export { isDockerInstalled, isDockerComposeAvailable, isDockerDaemonRunning, DockerValidationError };

package/dist/services/docker.js

@@ -0,0 +1,79 @@
+import { execSync, spawn } from 'node:child_process';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { ux } from '@oclif/core';
+class DockerValidationError extends Error {
+}
+export class DockerComposeConfigNotFoundError extends Error {
+    constructor(dockerComposePath) {
+        super(`Docker Compose configuration not found at: ${dockerComposePath}\n\
+This may indicate a problem with the CLI installation.`);
+    }
+}
+const checkDockerCommand = (command) => {
+    try {
+        execSync(command, { stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const isDockerInstalled = () => checkDockerCommand('docker --version');
+const isDockerComposeAvailable = () => checkDockerCommand('docker compose version');
+const isDockerDaemonRunning = () => checkDockerCommand('docker ps');
+const DOCKER_VALIDATIONS = [
+    {
+        check: isDockerInstalled,
+        error: 'Docker is not installed. Please install Docker to use the dev command.\nVisit: https://docs.docker.com/get-docker/'
+    },
+    {
+        check: isDockerComposeAvailable,
+        error: 'Docker Compose is not installed. Please install Docker Compose to use the dev command.\nVisit: https://docs.docker.com/compose/install/'
+    },
+    {
+        check: isDockerDaemonRunning,
+        error: 'Docker daemon is not running. Please start Docker and try again.'
+    }
+];
+export function validateDockerEnvironment() {
+    const failedValidation = DOCKER_VALIDATIONS.find(v => !v.check());
+    if (failedValidation) {
+        throw new DockerValidationError(failedValidation.error);
+    }
+}
+export async function startDockerCompose(dockerComposePath, enableWatch = false) {
+    const args = [
+        'compose',
+        '-f', dockerComposePath,
+        '--project-directory', process.cwd(),
+        'up'
+    ];
+    if (enableWatch) {
+        args.push('--watch');
+    }
+    const childProcess = spawn('docker', args, {
+        stdio: 'inherit',
+        cwd: process.cwd()
+    });
+    const cleanup = () => {
+        ux.stdout('⏹️  Stopping services...\n');
+        childProcess.kill('SIGTERM');
+    };
+    process.on('SIGINT', cleanup);
+    process.on('SIGTERM', cleanup);
+    return new Promise((resolve, reject) => {
+        childProcess.on('exit', _code => {
+            process.removeListener('SIGINT', cleanup);
+            process.removeListener('SIGTERM', cleanup);
+            resolve();
+        });
+        childProcess.on('error', error => {
+            reject(new Error(`Failed to start services: ${error.message}`));
+        });
+    });
+}
+export function getDefaultDockerComposePath() {
+    return path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../assets/docker/docker-compose-dev.yml');
+}
+export { isDockerInstalled, isDockerComposeAvailable, isDockerDaemonRunning, DockerValidationError };

package/dist/services/env_configurator.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Interactively configures environment variables for a project by prompting the user
+ * to provide values for empty variables or variables marked as secrets.
+ *
+ * @param projectPath - The absolute path to the project directory containing the .env file
+ * @param skipPrompt - If true, skips the configuration prompt and returns false immediately
+ * @returns A promise that resolves to true if environment variables were successfully configured,
+ *          false if configuration was skipped (no .env file, user declined, no variables to configure,
+ *          or an error occurred)
+ */
+export declare function configureEnvironmentVariables(projectPath: string, skipPrompt?: boolean): Promise<boolean>;