@agents-at-scale/ark 0.1.35-rc2 → 0.1.35

package/dist/commands/install/index.js

@@ -1,300 +0,0 @@
-import { Command } from 'commander';
-import chalk from 'chalk';
-import { execute } from '../../lib/commands.js';
-import inquirer from 'inquirer';
-import { showNoClusterError } from '../../lib/startup.js';
-import output from '../../lib/output.js';
-import { getInstallableServices, arkDependencies } from '../../arkServices.js';
-import { isArkReady } from '../../lib/arkStatus.js';
-import { printNextSteps } from '../../lib/nextSteps.js';
-import ora from 'ora';
-async function installService(service, verbose = false) {
-    const helmArgs = [
-        'upgrade',
-        '--install',
-        service.helmReleaseName,
-        service.chartPath,
-    ];
-    // Only add namespace flag if service has explicit namespace
-    if (service.namespace) {
-        helmArgs.push('--namespace', service.namespace);
-    }
-    // Add any additional install args
-    helmArgs.push(...(service.installArgs || []));
-    await execute('helm', helmArgs, { stdio: 'inherit' }, { verbose });
-}
-export async function installArk(config, serviceName, options = {}) {
-    // Validate that --wait-for-ready requires -y
-    if (options.waitForReady && !options.yes) {
-        output.error('--wait-for-ready requires -y flag for non-interactive mode');
-        process.exit(1);
-    }
-    // Check cluster connectivity from config
-    if (!config.clusterInfo) {
-        showNoClusterError();
-        process.exit(1);
-    }
-    const clusterInfo = config.clusterInfo;
-    // Show cluster info
-    output.success(`connected to cluster: ${chalk.bold(clusterInfo.context)}`);
-    output.info(`type: ${clusterInfo.type}`);
-    output.info(`namespace: ${clusterInfo.namespace}`);
-    if (clusterInfo.ip) {
-        output.info(`ip: ${clusterInfo.ip}`);
-    }
-    console.log(); // Add blank line after cluster info
-    // If a specific service is requested, install only that service
-    if (serviceName) {
-        const services = getInstallableServices();
-        const service = Object.values(services).find((s) => s.name === serviceName);
-        if (!service) {
-            output.error(`service '${serviceName}' not found`);
-            output.info('available services:');
-            for (const s of Object.values(services)) {
-                output.info(`  ${s.name}`);
-            }
-            process.exit(1);
-        }
-        output.info(`installing ${service.name}...`);
-        try {
-            await installService(service, options.verbose);
-            output.success(`${service.name} installed successfully`);
-        }
-        catch (error) {
-            output.error(`failed to install ${service.name}`);
-            console.error(error);
-            process.exit(1);
-        }
-        return;
-    }
-    // If not using -y flag, show checklist interface
-    if (!options.yes) {
-        console.log(chalk.cyan.bold('\nSelect components to install:'));
-        console.log(chalk.gray('Use arrow keys to navigate, space to toggle, enter to confirm\n'));
-        // Build choices for the checkbox prompt
-        const allChoices = [
-            new inquirer.Separator(chalk.bold('──── Dependencies ────')),
-            {
-                name: `cert-manager ${chalk.gray('- Certificate management')}`,
-                value: 'cert-manager',
-                checked: true,
-            },
-            {
-                name: `gateway-api ${chalk.gray('- Gateway API CRDs')}`,
-                value: 'gateway-api',
-                checked: true,
-            },
-            new inquirer.Separator(chalk.bold('──── Ark Core ────')),
-            {
-                name: `ark-controller ${chalk.gray('- Core Ark controller')}`,
-                value: 'ark-controller',
-                checked: true,
-            },
-            new inquirer.Separator(chalk.bold('──── Ark Services ────')),
-            {
-                name: `ark-api ${chalk.gray('- API service')}`,
-                value: 'ark-api',
-                checked: true,
-            },
-            {
-                name: `ark-dashboard ${chalk.gray('- Web dashboard')}`,
-                value: 'ark-dashboard',
-                checked: true,
-            },
-            {
-                name: `ark-mcp ${chalk.gray('- MCP services')}`,
-                value: 'ark-mcp',
-                checked: true,
-            },
-            {
-                name: `localhost-gateway ${chalk.gray('- Gateway for local access')}`,
-                value: 'localhost-gateway',
-                checked: true,
-            },
-        ];
-        let selectedComponents = [];
-        try {
-            const answers = await inquirer.prompt([
-                {
-                    type: 'checkbox',
-                    name: 'components',
-                    message: 'Components to install:',
-                    choices: allChoices,
-                    pageSize: 15,
-                },
-            ]);
-            selectedComponents = answers.components;
-            if (selectedComponents.length === 0) {
-                output.warning('No components selected. Exiting.');
-                process.exit(0);
-            }
-        }
-        catch (error) {
-            // Handle Ctrl-C gracefully
-            if (error && error.name === 'ExitPromptError') {
-                console.log('\nInstallation cancelled');
-                process.exit(130);
-            }
-            throw error;
-        }
-        // Install dependencies if selected
-        const shouldInstallDeps = selectedComponents.includes('cert-manager') ||
-            selectedComponents.includes('gateway-api');
-        // Install selected dependencies
-        if (shouldInstallDeps) {
-            // Always install cert-manager repo and update if installing any dependency
-            if (selectedComponents.includes('cert-manager') ||
-                selectedComponents.includes('gateway-api')) {
-                for (const depKey of ['cert-manager-repo', 'helm-repo-update']) {
-                    const dep = arkDependencies[depKey];
-                    output.info(`installing ${dep.description || dep.name}...`);
-                    try {
-                        await execute(dep.command, dep.args, {
-                            stdio: 'inherit',
-                        }, { verbose: options.verbose });
-                        output.success(`${dep.name} completed`);
-                        console.log();
-                    }
-                    catch {
-                        console.log();
-                        process.exit(1);
-                    }
-                }
-            }
-            // Install cert-manager if selected
-            if (selectedComponents.includes('cert-manager')) {
-                const dep = arkDependencies['cert-manager'];
-                output.info(`installing ${dep.description || dep.name}...`);
-                try {
-                    await execute(dep.command, dep.args, {
-                        stdio: 'inherit',
-                    }, { verbose: options.verbose });
-                    output.success(`${dep.name} completed`);
-                    console.log();
-                }
-                catch {
-                    console.log();
-                    process.exit(1);
-                }
-            }
-            // Install gateway-api if selected
-            if (selectedComponents.includes('gateway-api')) {
-                const dep = arkDependencies['gateway-api-crds'];
-                output.info(`installing ${dep.description || dep.name}...`);
-                try {
-                    await execute(dep.command, dep.args, {
-                        stdio: 'inherit',
-                    }, { verbose: options.verbose });
-                    output.success(`${dep.name} completed`);
-                    console.log();
-                }
-                catch {
-                    console.log();
-                    process.exit(1);
-                }
-            }
-        }
-        // Install selected services
-        const services = getInstallableServices();
-        for (const service of Object.values(services)) {
-            // Check if this service was selected
-            const serviceKey = service.helmReleaseName;
-            if (!selectedComponents.includes(serviceKey)) {
-                continue;
-            }
-            output.info(`installing ${service.name}...`);
-            try {
-                await installService(service, options.verbose);
-                console.log(); // Add blank line after command output
-            }
-            catch {
-                // Continue with remaining services on error
-                console.log(); // Add blank line after error output
-            }
-        }
-    }
-    else {
-        // -y flag was used, install everything
-        // Install all dependencies
-        for (const dep of Object.values(arkDependencies)) {
-            output.info(`installing ${dep.description || dep.name}...`);
-            try {
-                await execute(dep.command, dep.args, {
-                    stdio: 'inherit',
-                }, { verbose: options.verbose });
-                output.success(`${dep.name} completed`);
-                console.log(); // Add blank line after dependency
-            }
-            catch {
-                console.log(); // Add blank line after error
-                process.exit(1);
-            }
-        }
-        // Install all services
-        const services = getInstallableServices();
-        for (const service of Object.values(services)) {
-            output.info(`installing ${service.name}...`);
-            try {
-                await installService(service, options.verbose);
-                console.log(); // Add blank line after command output
-            }
-            catch {
-                // Continue with remaining services on error
-                console.log(); // Add blank line after error output
-            }
-        }
-    }
-    // Show next steps after successful installation
-    if (!serviceName || serviceName === 'all') {
-        printNextSteps();
-    }
-    // Wait for Ark to be ready if requested
-    if (options.waitForReady) {
-        // Parse timeout value (e.g., '30s', '2m', '60')
-        const parseTimeout = (value) => {
-            const match = value.match(/^(\d+)([sm])?$/);
-            if (!match) {
-                throw new Error('Invalid timeout format. Use format like 30s or 2m');
-            }
-            const num = parseInt(match[1], 10);
-            const unit = match[2] || 's';
-            return unit === 'm' ? num * 60 : num;
-        };
-        try {
-            const timeoutSeconds = parseTimeout(options.waitForReady);
-            const startTime = Date.now();
-            const endTime = startTime + timeoutSeconds * 1000;
-            const spinner = ora(`Waiting for Ark to be ready (timeout: ${timeoutSeconds}s)...`).start();
-            while (Date.now() < endTime) {
-                if (await isArkReady()) {
-                    spinner.succeed('Ark is ready!');
-                    return;
-                }
-                const elapsed = Math.floor((Date.now() - startTime) / 1000);
-                spinner.text = `Waiting for Ark to be ready (${elapsed}/${timeoutSeconds}s)...`;
-                // Wait 2 seconds before checking again
-                await new Promise((resolve) => setTimeout(resolve, 2000));
-            }
-            // Timeout reached
-            spinner.fail(`Ark did not become ready within ${timeoutSeconds} seconds`);
-            process.exit(1);
-        }
-        catch (error) {
-            output.error(`Failed to wait for ready: ${error instanceof Error ? error.message : 'Unknown error'}`);
-            process.exit(1);
-        }
-    }
-}
-export function createInstallCommand(config) {
-    const command = new Command('install');
-    command
-        .description('Install ARK components using Helm')
-        .argument('[service]', 'specific service to install, or all if omitted')
-        .option('-y, --yes', 'automatically confirm all installations')
-        .option('--wait-for-ready <timeout>', 'wait for Ark to be ready after installation (e.g., 30s, 2m)')
-        .option('-v, --verbose', 'show commands being executed')
-        .action(async (service, options) => {
-        await installArk(config, service, options);
-    });
-    return command;
-}

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

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

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

@@ -1,143 +0,0 @@
-import { jest } from '@jest/globals';
-import { Command } from 'commander';
-const mockExeca = jest.fn(() => Promise.resolve());
-jest.unstable_mockModule('execa', () => ({
-    execa: mockExeca,
-}));
-const mockGetClusterInfo = jest.fn();
-jest.unstable_mockModule('../../lib/cluster.js', () => ({
-    getClusterInfo: mockGetClusterInfo,
-}));
-const mockGetInstallableServices = jest.fn();
-const mockArkServices = {};
-const mockArkDependencies = {};
-jest.unstable_mockModule('../../arkServices.js', () => ({
-    getInstallableServices: mockGetInstallableServices,
-    arkServices: mockArkServices,
-    arkDependencies: mockArkDependencies,
-}));
-const mockOutput = {
-    error: jest.fn(),
-    info: jest.fn(),
-    success: jest.fn(),
-    warning: jest.fn(),
-};
-jest.unstable_mockModule('../../lib/output.js', () => ({
-    default: mockOutput,
-}));
-const mockExit = jest.spyOn(process, 'exit').mockImplementation((() => {
-    throw new Error('process.exit called');
-}));
-jest.spyOn(console, 'log').mockImplementation(() => { });
-jest.spyOn(console, 'error').mockImplementation(() => { });
-const { createInstallCommand } = await import('./index.js');
-describe('install command', () => {
-    const mockConfig = {
-        clusterInfo: {
-            context: 'test-cluster',
-            type: 'minikube',
-            namespace: 'default',
-        },
-    };
-    beforeEach(() => {
-        jest.clearAllMocks();
-        mockGetClusterInfo.mockResolvedValue({
-            context: 'test-cluster',
-            type: 'minikube',
-            namespace: 'default',
-        });
-    });
-    it('creates command with correct structure', () => {
-        const command = createInstallCommand(mockConfig);
-        expect(command).toBeInstanceOf(Command);
-        expect(command.name()).toBe('install');
-    });
-    it('installs single service with correct helm parameters', async () => {
-        const mockService = {
-            name: 'ark-api',
-            helmReleaseName: 'ark-api',
-            chartPath: './charts/ark-api',
-            namespace: 'ark-system',
-            installArgs: ['--set', 'image.tag=latest'],
-        };
-        mockGetInstallableServices.mockReturnValue({
-            'ark-api': mockService,
-        });
-        const command = createInstallCommand(mockConfig);
-        await command.parseAsync(['node', 'test', 'ark-api']);
-        expect(mockExeca).toHaveBeenCalledWith('helm', [
-            'upgrade',
-            '--install',
-            'ark-api',
-            './charts/ark-api',
-            '--namespace',
-            'ark-system',
-            '--set',
-            'image.tag=latest',
-        ], { stdio: 'inherit' });
-        expect(mockOutput.success).toHaveBeenCalledWith('ark-api installed successfully');
-    });
-    it('shows error when service not found', async () => {
-        mockGetInstallableServices.mockReturnValue({
-            'ark-api': { name: 'ark-api' },
-            'ark-controller': { name: 'ark-controller' },
-        });
-        const command = createInstallCommand(mockConfig);
-        await expect(command.parseAsync(['node', 'test', 'invalid-service'])).rejects.toThrow('process.exit called');
-        expect(mockOutput.error).toHaveBeenCalledWith("service 'invalid-service' not found");
-        expect(mockOutput.info).toHaveBeenCalledWith('available services:');
-        expect(mockOutput.info).toHaveBeenCalledWith('  ark-api');
-        expect(mockOutput.info).toHaveBeenCalledWith('  ark-controller');
-        expect(mockExit).toHaveBeenCalledWith(1);
-    });
-    it('handles service without namespace (uses current context)', async () => {
-        const mockService = {
-            name: 'ark-dashboard',
-            helmReleaseName: 'ark-dashboard',
-            chartPath: './charts/ark-dashboard',
-            // namespace is undefined - should use current context
-            installArgs: ['--set', 'replicas=2'],
-        };
-        mockGetInstallableServices.mockReturnValue({
-            'ark-dashboard': mockService,
-        });
-        const command = createInstallCommand(mockConfig);
-        await command.parseAsync(['node', 'test', 'ark-dashboard']);
-        // Should NOT include --namespace flag
-        expect(mockExeca).toHaveBeenCalledWith('helm', [
-            'upgrade',
-            '--install',
-            'ark-dashboard',
-            './charts/ark-dashboard',
-            '--set',
-            'replicas=2',
-        ], { stdio: 'inherit' });
-    });
-    it('handles service without installArgs', async () => {
-        const mockService = {
-            name: 'simple-service',
-            helmReleaseName: 'simple-service',
-            chartPath: './charts/simple',
-            namespace: 'default',
-        };
-        mockGetInstallableServices.mockReturnValue({
-            'simple-service': mockService,
-        });
-        const command = createInstallCommand(mockConfig);
-        await command.parseAsync(['node', 'test', 'simple-service']);
-        expect(mockExeca).toHaveBeenCalledWith('helm', [
-            'upgrade',
-            '--install',
-            'simple-service',
-            './charts/simple',
-            '--namespace',
-            'default',
-        ], { stdio: 'inherit' });
-    });
-    it('exits when cluster not connected', async () => {
-        mockGetClusterInfo.mockResolvedValue({ error: true });
-        const command = createInstallCommand({});
-        await expect(command.parseAsync(['node', 'test', 'ark-api'])).rejects.toThrow('process.exit called');
-        expect(mockExit).toHaveBeenCalledWith(1);
-    });
-});

package/dist/commands/install.d.ts

@@ -1,3 +0,0 @@
-import { Command } from 'commander';
-export declare function installArk(): Promise<void>;
-export declare function createInstallCommand(): Command;

package/dist/commands/install.js

@@ -1,147 +0,0 @@
-import { Command } from 'commander';
-import chalk from 'chalk';
-import { execa } from 'execa';
-import inquirer from 'inquirer';
-import { isCommandAvailable } from '../lib/commandUtils.js';
-import { getClusterInfo } from '../lib/cluster.js';
-import output from '../lib/output.js';
-import { getInstallableServices, arkDependencies } from '../arkServices.js';
-import { createModel } from './models/create.js';
-export async function installArk() {
-    // Check if helm is installed
-    const helmInstalled = await isCommandAvailable('helm');
-    if (!helmInstalled) {
-        output.error('helm is not installed. please install helm first:');
-        output.info('https://helm.sh/docs/intro/install/');
-        process.exit(1);
-    }
-    // Check if kubectl is installed (needed for some dependencies)
-    const kubectlInstalled = await isCommandAvailable('kubectl');
-    if (!kubectlInstalled) {
-        output.error('kubectl is not installed. please install kubectl first:');
-        output.info('https://kubernetes.io/docs/tasks/tools/');
-        process.exit(1);
-    }
-    // Check cluster connectivity
-    const clusterInfo = await getClusterInfo();
-    if (clusterInfo.error) {
-        output.error('no kubernetes cluster detected');
-        output.info('please ensure you have a running cluster and kubectl is configured.');
-        output.info('');
-        output.info('for local development, we recommend minikube:');
-        output.info('• install: https://minikube.sigs.k8s.io/docs/start');
-        output.info('• start cluster: minikube start');
-        output.info('');
-        output.info('alternatively, you can use kind or docker desktop.');
-        process.exit(1);
-    }
-    // Show cluster info
-    output.success(`connected to cluster: ${chalk.bold(clusterInfo.context)}`);
-    output.info(`type: ${clusterInfo.type}`);
-    output.info(`namespace: ${clusterInfo.namespace}`);
-    if (clusterInfo.ip) {
-        output.info(`ip: ${clusterInfo.ip}`);
-    }
-    console.log(); // Add blank line after cluster info
-    // Ask about installing dependencies
-    const { shouldInstallDeps } = await inquirer.prompt([
-        {
-            type: 'confirm',
-            name: 'shouldInstallDeps',
-            message: 'install required dependencies (cert-manager, gateway api)?',
-            default: true,
-        },
-    ]);
-    if (shouldInstallDeps) {
-        for (const dep of Object.values(arkDependencies)) {
-            output.info(`installing ${dep.description || dep.name}...`);
-            try {
-                await execa(dep.command, dep.args, {
-                    stdio: 'inherit',
-                });
-                output.success(`${dep.name} completed`);
-                console.log(); // Add blank line after dependency
-            }
-            catch {
-                console.log(); // Add blank line after error
-                process.exit(1);
-            }
-        }
-    }
-    // Get installable services and iterate through them
-    const services = getInstallableServices();
-    for (const service of Object.values(services)) {
-        // Ask for confirmation
-        const { shouldInstall } = await inquirer.prompt([
-            {
-                type: 'confirm',
-                name: 'shouldInstall',
-                message: `install ${chalk.bold(service.name)}? ${service.description ? chalk.gray(`(${service.description.toLowerCase()})`) : ''}`,
-                default: true,
-            },
-        ]);
-        if (!shouldInstall) {
-            output.warning(`skipping ${service.name}`);
-            continue;
-        }
-        try {
-            // Build helm arguments
-            const helmArgs = [
-                'upgrade',
-                '--install',
-                service.helmReleaseName,
-                service.chartPath,
-                '--namespace',
-                service.namespace,
-            ];
-            // Add any additional args from the service definition
-            if (service.installArgs) {
-                helmArgs.push(...service.installArgs);
-            }
-            // Run helm upgrade --install with streaming output
-            await execa('helm', helmArgs, {
-                stdio: 'inherit',
-            });
-            console.log(); // Add blank line after command output
-        }
-        catch {
-            // Continue with remaining services on error
-            console.log(); // Add blank line after error output
-        }
-    }
-    // Check for default model after installing services
-    output.info('checking for default model...');
-    let modelExists = false;
-    try {
-        await execa('kubectl', ['get', 'model', 'default'], { stdio: 'pipe' });
-        modelExists = true;
-        output.success('default model already configured');
-    }
-    catch {
-        output.warning('no default model found');
-    }
-    if (!modelExists) {
-        const { shouldCreateModel } = await inquirer.prompt([
-            {
-                type: 'confirm',
-                name: 'shouldCreateModel',
-                message: 'would you like to create a default model?',
-                default: true,
-            },
-        ]);
-        if (shouldCreateModel) {
-            await createModel('default');
-        }
-        else {
-            output.warning('skipping model creation');
-            output.info('you can create a model later using ark models create or the dashboard');
-        }
-    }
-}
-export function createInstallCommand() {
-    const command = new Command('install');
-    command.description('Install ARK components using Helm').action(async () => {
-        await installArk();
-    });
-    return command;
-}

package/dist/commands/models/create.d.ts

@@ -1 +0,0 @@
-export declare function createModel(modelName?: string): Promise<boolean>;