@outputai/cli 0.1.3 → 0.1.4-dev.0

package/dist/commands/dev/index.js

@@ -0,0 +1,173 @@
+import { Command, Flags } from '@oclif/core';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import logUpdate from 'log-update';
+import { validateDockerEnvironment, startDockerCompose, startDockerComposeDetached, stopDockerCompose, getServiceStatus, DockerComposeConfigNotFoundError, getDefaultDockerComposePath, SERVICE_HEALTH, SERVICE_STATE } from '#services/docker.js';
+import { getErrorMessage } from '#utils/error_utils.js';
+import { getDevSuccessMessage } from '#services/messages.js';
+import { ensureClaudePlugin } from '#services/coding_agents.js';
+const ANSI = {
+    RESET: '\x1b[0m',
+    DIM: '\x1b[2m',
+    BOLD: '\x1b[1m',
+    CYAN: '\x1b[36m',
+    RED: '\x1b[31m',
+    YELLOW: '\x1b[33m',
+    BG_RED: '\x1b[41m',
+    WHITE: '\x1b[37m'
+};
+const STATUS_ICONS = {
+    [SERVICE_HEALTH.HEALTHY]: '●',
+    [SERVICE_HEALTH.UNHEALTHY]: '○',
+    [SERVICE_HEALTH.STARTING]: '◐',
+    [SERVICE_HEALTH.NONE]: '●',
+    [SERVICE_STATE.RUNNING]: '●',
+    [SERVICE_STATE.EXITED]: '✗'
+};
+const STATUS_COLORS = {
+    [SERVICE_HEALTH.HEALTHY]: '\x1b[32m',
+    [SERVICE_HEALTH.UNHEALTHY]: '\x1b[31m',
+    [SERVICE_HEALTH.STARTING]: '\x1b[33m',
+    [SERVICE_HEALTH.NONE]: '\x1b[34m',
+    [SERVICE_STATE.RUNNING]: '\x1b[34m',
+    [SERVICE_STATE.EXITED]: '\x1b[31m'
+};
+const formatService = (service) => {
+    const healthKey = service.health === SERVICE_HEALTH.NONE ? service.state : service.health;
+    const icon = STATUS_ICONS[healthKey] || '?';
+    const color = STATUS_COLORS[healthKey] || '';
+    const ports = service.ports.length ? service.ports.join(', ') : '-';
+    const status = service.health === SERVICE_HEALTH.NONE ? service.state : service.health;
+    const name = service.name.padEnd(15);
+    const statusPadded = status.padEnd(10);
+    return `  ${color}${icon}${ANSI.RESET} ${name} ${ANSI.DIM}${statusPadded}${ANSI.RESET} ${ANSI.DIM}${ports}${ANSI.RESET}`;
+};
+const getFailedServicesWarning = (services) => {
+    const failedServices = services.filter(s => s.state === SERVICE_STATE.EXITED);
+    if (failedServices.length === 0) {
+        return [];
+    }
+    const failedNames = failedServices.map(s => s.name);
+    const hasWorkerFailed = failedNames.some(name => name.toLowerCase().includes('worker'));
+    const warningLines = [
+        '',
+        `${ANSI.BG_RED}${ANSI.WHITE}${ANSI.BOLD} ⚠️  SERVICE FAILURE DETECTED ${ANSI.RESET}`,
+        '',
+        `${ANSI.RED}${ANSI.BOLD}Failed services:${ANSI.RESET} ${failedNames.join(', ')}`
+    ];
+    if (hasWorkerFailed) {
+        warningLines.push('', `${ANSI.YELLOW}${ANSI.BOLD}⚡ The worker is not running!${ANSI.RESET}`, `${ANSI.YELLOW}   Workflows will fail until the worker is restarted.${ANSI.RESET}`, '', `${ANSI.DIM}Check the logs with: docker compose logs worker${ANSI.RESET}`);
+    }
+    else {
+        warningLines.push('', `${ANSI.DIM}Check the logs with: docker compose logs <service-name>${ANSI.RESET}`);
+    }
+    return warningLines;
+};
+const poll = async (fn, intervalMs) => {
+    for (;;) {
+        await fn();
+        await new Promise(resolve => setTimeout(resolve, intervalMs));
+    }
+};
+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 %> --compose-file ./custom-docker-compose.yml',
+        '<%= config.bin %> <%= command.id %> --image-pull-policy missing'
+    ];
+    static args = {};
+    static flags = {
+        'compose-file': Flags.string({
+            description: 'Path to a custom docker-compose file',
+            required: false,
+            char: 'f'
+        }),
+        'image-pull-policy': Flags.string({
+            description: 'Image pull policy for docker compose (always, missing, never)',
+            options: ['always', 'missing', 'never'],
+            default: 'always'
+        }),
+        detached: Flags.boolean({
+            description: 'Start services in detached (background) mode and exit immediately',
+            default: false,
+            char: 'd'
+        })
+    };
+    dockerProcess = null;
+    async run() {
+        const { flags } = await this.parse(Dev);
+        // Ensure Claude plugin is configured (fire-and-forget, silent)
+        ensureClaudePlugin(process.cwd(), { silent: true }).catch(() => { });
+        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`);
+        }
+        const pullPolicy = flags['image-pull-policy'];
+        if (flags.detached) {
+            this.log('🐳 Starting services in detached mode...\n');
+            startDockerComposeDetached(dockerComposePath, pullPolicy);
+            this.log('✅ Services started. Run `output dev` without --detached to monitor status.\n');
+            return;
+        }
+        this.log('File watching enabled - worker will restart automatically on changes\n');
+        const cleanup = async () => {
+            this.log('\n');
+            if (this.dockerProcess) {
+                this.dockerProcess.kill('SIGTERM');
+            }
+            await stopDockerCompose(dockerComposePath);
+            process.exit(0);
+        };
+        process.on('SIGINT', cleanup);
+        process.on('SIGTERM', cleanup);
+        try {
+            const { process: dockerProc, waitForHealthy } = await startDockerCompose(dockerComposePath, pullPolicy);
+            this.dockerProcess = dockerProc;
+            dockerProc.on('error', error => {
+                this.error(`Docker process error: ${getErrorMessage(error)}`, { exit: 1 });
+            });
+            this.log('⏳ Waiting for services to become healthy...\n');
+            await waitForHealthy();
+            const services = await getServiceStatus(dockerComposePath);
+            this.log(getDevSuccessMessage(services));
+            await this.pollServiceStatus(dockerComposePath);
+        }
+        catch (error) {
+            this.error(getErrorMessage(error), { exit: 1 });
+        }
+    }
+    async pollServiceStatus(dockerComposePath) {
+        const outputServiceStatus = async () => {
+            try {
+                const services = await getServiceStatus(dockerComposePath);
+                const failureWarning = getFailedServicesWarning(services);
+                const lines = [
+                    `${ANSI.BOLD}📊 Service Status${ANSI.RESET}`,
+                    '',
+                    ...services.map(formatService),
+                    ...failureWarning,
+                    '',
+                    `${ANSI.CYAN}🌐 Temporal UI:${ANSI.RESET} ${ANSI.BOLD}http://localhost:8080${ANSI.RESET}`,
+                    '',
+                    `${ANSI.DIM}Press Ctrl+C to stop services${ANSI.RESET}`
+                ];
+                logUpdate(lines.join('\n'));
+            }
+            catch {
+                // silent retry on next poll
+            }
+        };
+        await poll(outputServiceStatus, 2000);
+    }
+}

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

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

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

@@ -0,0 +1,239 @@
+/* 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 * as codingAgentsService from '#services/coding_agents.js';
+import Dev from './index.js';
+vi.mock('#services/coding_agents.js', () => ({
+    ensureClaudePlugin: vi.fn().mockResolvedValue(undefined)
+}));
+vi.mock('#services/docker.js', () => ({
+    validateDockerEnvironment: vi.fn(),
+    startDockerCompose: vi.fn(),
+    stopDockerCompose: vi.fn().mockResolvedValue(undefined),
+    getServiceStatus: vi.fn().mockResolvedValue([
+        { name: 'redis', state: 'running', health: 'healthy', ports: ['6379:6379'] },
+        { name: 'temporal', state: 'running', health: 'healthy', ports: ['7233:7233'] }
+    ]),
+    DockerComposeConfigNotFoundError: Error,
+    DockerValidationError: Error,
+    getDefaultDockerComposePath: vi.fn(() => '/path/to/docker-compose-dev.yml'),
+    SERVICE_HEALTH: {
+        HEALTHY: 'healthy',
+        UNHEALTHY: 'unhealthy',
+        STARTING: 'starting',
+        NONE: 'none'
+    },
+    SERVICE_STATE: {
+        RUNNING: 'running',
+        EXITED: 'exited'
+    }
+}));
+vi.mock('node:fs/promises', () => ({
+    default: {
+        access: vi.fn()
+    }
+}));
+const createMockDockerProcess = () => ({
+    process: {
+        on: vi.fn(),
+        kill: vi.fn(),
+        stdout: { on: vi.fn() },
+        stderr: { on: vi.fn() }
+    },
+    waitForHealthy: vi.fn().mockResolvedValue(undefined)
+});
+describe('dev command', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // By default, docker validation succeeds
+        vi.mocked(dockerService.validateDockerEnvironment).mockResolvedValue(undefined);
+        // By default, startDockerCompose returns a mock process
+        vi.mocked(dockerService.startDockerCompose).mockResolvedValue(createMockDockerProcess());
+        // By default, fs.access succeeds (file exists)
+        vi.mocked(fs).access.mockResolvedValue(undefined);
+        // By default, ensureClaudePlugin succeeds
+        vi.mocked(codingAgentsService.ensureClaudePlugin).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 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');
+        });
+        it('should have image-pull-policy flag defined', () => {
+            expect(Dev.flags).toBeDefined();
+            expect(Dev.flags['image-pull-policy']).toBeDefined();
+            expect(Dev.flags['image-pull-policy'].description).toContain('pull policy');
+        });
+    });
+    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: { '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('Claude plugin update', () => {
+        it('should call ensureClaudePlugin on startup', async () => {
+            const cmd = new Dev([], {});
+            cmd.log = vi.fn();
+            cmd.error = vi.fn();
+            Object.defineProperty(cmd, 'parse', {
+                value: vi.fn().mockResolvedValue({ flags: { 'compose-file': undefined, 'image-pull-policy': 'always' }, args: {} }),
+                configurable: true
+            });
+            const runPromise = cmd.run();
+            await new Promise(resolve => setImmediate(resolve));
+            expect(codingAgentsService.ensureClaudePlugin).toHaveBeenCalledWith(process.cwd(), { silent: true });
+            runPromise.catch(() => { });
+        });
+        it('should not block dev if ensureClaudePlugin fails', async () => {
+            vi.mocked(codingAgentsService.ensureClaudePlugin).mockRejectedValue(new Error('Plugin update failed'));
+            const cmd = new Dev([], {});
+            cmd.log = vi.fn();
+            cmd.error = vi.fn();
+            Object.defineProperty(cmd, 'parse', {
+                value: vi.fn().mockResolvedValue({ flags: { 'compose-file': undefined, 'image-pull-policy': 'always' }, args: {} }),
+                configurable: true
+            });
+            const runPromise = cmd.run();
+            await new Promise(resolve => setImmediate(resolve));
+            // Docker compose should still be called even if plugin update fails
+            expect(dockerService.startDockerCompose).toHaveBeenCalled();
+            runPromise.catch(() => { });
+        });
+    });
+    describe('watch functionality', () => {
+        it('should start docker compose', 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: { 'compose-file': undefined, 'image-pull-policy': 'always' }, args: {} }),
+                configurable: true
+            });
+            // Run the command but don't await it since it waits forever after startup
+            const runPromise = cmd.run();
+            // Wait a tick for startDockerCompose to be called
+            await new Promise(resolve => setImmediate(resolve));
+            expect(dockerService.startDockerCompose).toHaveBeenCalledWith('/path/to/docker-compose-dev.yml', 'always' // default pull policy
+            );
+            expect(cmd.log).toHaveBeenCalledWith(expect.stringContaining('File watching enabled'));
+            // Cancel the promise (it will be rejected but we don't care)
+            runPromise.catch(() => { });
+        });
+        it('should 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: { 'compose-file': undefined, 'image-pull-policy': 'always' }, args: {} }),
+                configurable: true
+            });
+            await cmd.run();
+            expect(cmd.error).toHaveBeenCalledWith('Docker error', { exit: 1 });
+        });
+    });
+    describe('image pull policy', () => {
+        it('should pass pull policy to startDockerCompose', async () => {
+            const cmd = new Dev([], {});
+            cmd.log = vi.fn();
+            cmd.error = vi.fn();
+            // Mock parse to return flags with missing pull policy
+            Object.defineProperty(cmd, 'parse', {
+                value: vi.fn().mockResolvedValue({ flags: { 'compose-file': undefined, 'image-pull-policy': 'missing' }, args: {} }),
+                configurable: true
+            });
+            // Run the command but don't await it since it waits forever after startup
+            const runPromise = cmd.run();
+            // Wait a tick for startDockerCompose to be called
+            await new Promise(resolve => setImmediate(resolve));
+            expect(dockerService.startDockerCompose).toHaveBeenCalledWith('/path/to/docker-compose-dev.yml', 'missing');
+            // Cancel the promise (it will be rejected but we don't care)
+            runPromise.catch(() => { });
+        });
+        it('should use never pull policy when specified', async () => {
+            const cmd = new Dev([], {});
+            cmd.log = vi.fn();
+            cmd.error = vi.fn();
+            // Mock parse to return flags with never pull policy
+            Object.defineProperty(cmd, 'parse', {
+                value: vi.fn().mockResolvedValue({ flags: { 'compose-file': undefined, 'image-pull-policy': 'never' }, args: {} }),
+                configurable: true
+            });
+            // Run the command but don't await it since it waits forever after startup
+            const runPromise = cmd.run();
+            // Wait a tick for startDockerCompose to be called
+            await new Promise(resolve => setImmediate(resolve));
+            expect(dockerService.startDockerCompose).toHaveBeenCalledWith('/path/to/docker-compose-dev.yml', 'never');
+            // Cancel the promise (it will be rejected but we don't care)
+            runPromise.catch(() => { });
+        });
+    });
+});

package/dist/commands/init.d.ts

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

package/dist/commands/init.js

@@ -0,0 +1,37 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { UserCancelledError } from '#types/errors.js';
+import { runInit } from '#services/project_scaffold.js';
+export default class Init extends Command {
+    static description = 'Initialize a new Output project by scaffolding the complete project structure';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> my-workflow-project'
+    ];
+    static args = {
+        folderName: Args.string({
+            description: 'Optional folder name for the project (skips folder name prompt)',
+            required: false
+        })
+    };
+    static flags = {
+        'skip-env': Flags.boolean({
+            description: 'Skip interactive environment variable configuration',
+            default: false
+        })
+    };
+    async run() {
+        try {
+            const { args, flags } = await this.parse(Init);
+            await runInit(flags['skip-env'], args.folderName);
+        }
+        catch (error) {
+            if (error instanceof UserCancelledError) {
+                this.log(error.message);
+                return;
+            }
+            // runInit handles cleanup internally and throws Error with message
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.error(errorMessage);
+        }
+    }
+}

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

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

package/dist/commands/init.spec.js

@@ -0,0 +1,100 @@
+/* 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);
+    });
+    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 an optional folderName argument', () => {
+            expect(Init.args).toBeDefined();
+            expect(Init.args.folderName).toBeDefined();
+            expect(Init.args.folderName.required).toBe(false);
+        });
+    });
+    describe('command execution', () => {
+        const createTestCommand = (args = [], flags = {}, parsedArgs = {}) => {
+            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: { folderName: undefined, ...parsedArgs },
+                    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 skip-env flag and folder name', async () => {
+            const cmd = createTestCommand();
+            await cmd.run();
+            expect(projectScaffold.runInit).toHaveBeenCalledWith(false, undefined);
+        });
+        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 by passing error message', async () => {
+            // runInit now handles cleanup internally and throws Error with message
+            const testError = new Error('Failed to create project');
+            vi.mocked(projectScaffold.runInit).mockRejectedValue(testError);
+            const cmd = createTestCommand();
+            await cmd.run();
+            expect(cmd.error).toHaveBeenCalledWith('Failed to create project');
+        });
+        it('should pass error message to this.error', async () => {
+            const testError = new Error('Folder already exists');
+            vi.mocked(projectScaffold.runInit).mockRejectedValue(testError);
+            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(true, undefined);
+        });
+        it('should pass folder name to runInit when provided', async () => {
+            const cmd = createTestCommand([], {}, { folderName: 'my-project' });
+            await cmd.run();
+            expect(projectScaffold.runInit).toHaveBeenCalledWith(false, 'my-project');
+        });
+    });
+});

package/dist/commands/update.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '@oclif/core';
+export default class Update extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        cli: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        agents: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private updateCli;
+    private updateAgents;
+    private handleGlobalUpdate;
+    private handleLocalUpdate;
+}