@outputai/cli 0.1.2-dev.0 → 0.1.2

package/dist/commands/dev/index.js

@@ -1,162 +0,0 @@
-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, 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'
-        })
-    };
-    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`);
-        }
-        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);
-        const pullPolicy = flags['image-pull-policy'];
-        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

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

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

@@ -1,239 +0,0 @@
-/* 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

@@ -1,12 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

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

package/dist/commands/init.spec.js

@@ -1,100 +0,0 @@
-/* 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

@@ -1,14 +0,0 @@
-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;
-}