@agents-at-scale/ark 0.1.36 → 0.1.38

package/dist/commands/install/index.js

@@ -4,10 +4,11 @@ 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 { getInstallableServices, arkDependencies, arkServices, } from '../../arkServices.js';
 import { printNextSteps } from '../../lib/nextSteps.js';
 import ora from 'ora';
+import { waitForServicesReady, } from '../../lib/waitForReady.js';
+import { parseTimeoutToSeconds } from '../../lib/timeout.js';
 async function installService(service, verbose = false) {
     const helmArgs = [
         'upgrade',
@@ -67,6 +68,12 @@ export async function installArk(config, serviceName, options = {}) {
         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 coreServices = Object.values(arkServices)
+            .filter((s) => s.category === 'core')
+            .sort((a, b) => a.name.localeCompare(b.name));
+        const otherServices = Object.values(arkServices)
+            .filter((s) => s.category === 'service')
+            .sort((a, b) => a.name.localeCompare(b.name));
         const allChoices = [
             new inquirer.Separator(chalk.bold('──── Dependencies ────')),
             {
@@ -80,32 +87,17 @@ export async function installArk(config, serviceName, options = {}) {
                 checked: true,
             },
             new inquirer.Separator(chalk.bold('──── Ark Core ────')),
-            {
-                name: `ark-controller ${chalk.gray('- Core Ark controller')}`,
-                value: 'ark-controller',
-                checked: true,
-            },
+            ...coreServices.map((service) => ({
+                name: `${service.name} ${chalk.gray(`- ${service.description}`)}`,
+                value: service.helmReleaseName,
+                checked: Boolean(service.enabled),
+            })),
             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,
-            },
+            ...otherServices.map((service) => ({
+                name: `${service.name} ${chalk.gray(`- ${service.description}`)}`,
+                value: service.helmReleaseName,
+                checked: Boolean(service.enabled),
+            })),
         ];
         let selectedComponents = [];
         try {
@@ -190,11 +182,9 @@ export async function installArk(config, serviceName, options = {}) {
             }
         }
         // 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)) {
+        for (const serviceName of selectedComponents) {
+            const service = Object.values(arkServices).find((s) => s.helmReleaseName === serviceName);
+            if (!service || !service.chartPath) {
                 continue;
             }
             output.info(`installing ${service.name}...`);
@@ -203,8 +193,8 @@ export async function installArk(config, serviceName, options = {}) {
                 console.log(); // Add blank line after command output
             }
             catch {
-                // Continue with remaining services on error
                 console.log(); // Add blank line after error output
+                process.exit(1);
             }
         }
     }
@@ -234,8 +224,8 @@ export async function installArk(config, serviceName, options = {}) {
                 console.log(); // Add blank line after command output
             }
             catch {
-                // Continue with remaining services on error
                 console.log(); // Add blank line after error output
+                process.exit(1);
             }
         }
     }
@@ -245,34 +235,35 @@ export async function installArk(config, serviceName, options = {}) {
     }
     // 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 timeoutSeconds = parseTimeoutToSeconds(options.waitForReady);
+            const servicesToWait = Object.values(arkServices).filter((s) => s.enabled &&
+                s.category === 'core' &&
+                s.k8sDeploymentName &&
+                s.namespace);
             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 statusMap = new Map();
+            servicesToWait.forEach((s) => statusMap.set(s.name, false));
+            const startTime = Date.now();
+            const result = await waitForServicesReady(servicesToWait, timeoutSeconds, (progress) => {
+                statusMap.set(progress.serviceName, progress.ready);
                 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));
+                const lines = servicesToWait.map((s) => {
+                    const ready = statusMap.get(s.name);
+                    const icon = ready ? '✓' : '⋯';
+                    const status = ready ? 'ready' : 'waiting...';
+                    const color = ready ? chalk.green : chalk.yellow;
+                    return `  ${color(icon)} ${chalk.bold(s.name)} ${chalk.blue(`(${s.namespace})`)} - ${status}`;
+                });
+                spinner.text = `Waiting for Ark to be ready (${elapsed}/${timeoutSeconds}s)...\n${lines.join('\n')}`;
+            });
+            if (result) {
+                spinner.succeed('Ark is ready');
+            }
+            else {
+                spinner.fail(`Ark did not become ready within ${timeoutSeconds} seconds`);
+                process.exit(1);
             }
-            // 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'}`);

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

@@ -1 +1,9 @@
-export declare function createModel(modelName?: string): Promise<boolean>;
+export interface CreateModelOptions {
+    type?: string;
+    model?: string;
+    baseUrl?: string;
+    apiKey?: string;
+    apiVersion?: string;
+    yes?: boolean;
+}
+export declare function createModel(modelName?: string, options?: CreateModelOptions): Promise<boolean>;

package/dist/commands/models/create.js

@@ -1,7 +1,7 @@
 import { execa } from 'execa';
 import inquirer from 'inquirer';
 import output from '../../lib/output.js';
-export async function createModel(modelName) {
+export async function createModel(modelName, options = {}) {
     // Step 1: Get model name if not provided
     if (!modelName) {
         const nameAnswer = await inquirer.prompt([
@@ -27,66 +27,87 @@ export async function createModel(modelName) {
     try {
         await execa('kubectl', ['get', 'model', modelName], { stdio: 'pipe' });
         output.warning(`model ${modelName} already exists`);
-        const { overwrite } = await inquirer.prompt([
-            {
-                type: 'confirm',
-                name: 'overwrite',
-                message: `overwrite existing model ${modelName}?`,
-                default: false,
-            },
-        ]);
-        if (!overwrite) {
-            output.info('model creation cancelled');
-            return false;
+        if (!options.yes) {
+            const { overwrite } = await inquirer.prompt([
+                {
+                    type: 'confirm',
+                    name: 'overwrite',
+                    message: `overwrite existing model ${modelName}?`,
+                    default: false,
+                },
+            ]);
+            if (!overwrite) {
+                output.info('model creation cancelled');
+                return false;
+            }
         }
     }
     catch {
         // Model doesn't exist, continue
     }
-    // Step 2: Choose model type
-    const { modelType } = await inquirer.prompt([
-        {
-            type: 'list',
-            name: 'modelType',
-            message: 'select model provider:',
-            choices: [
-                { name: 'Azure OpenAI', value: 'azure' },
-                { name: 'OpenAI', value: 'openai' },
-            ],
-            default: 'azure',
-        },
-    ]);
-    // Step 3: Get common parameters
-    const commonAnswers = await inquirer.prompt([
-        {
-            type: 'input',
-            name: 'modelVersion',
-            message: 'model version:',
-            default: 'gpt-4o-mini',
-        },
-        {
-            type: 'input',
-            name: 'baseUrl',
-            message: 'base URL:',
-            validate: (input) => {
-                if (!input)
-                    return 'base URL is required';
-                try {
-                    new URL(input);
-                    return true;
-                }
-                catch {
-                    return 'please enter a valid URL';
-                }
+    // Step 2: Get model type
+    let modelType = options.type;
+    if (!modelType) {
+        const answer = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'modelType',
+                message: 'select model provider:',
+                choices: [
+                    { name: 'Azure OpenAI', value: 'azure' },
+                    { name: 'OpenAI', value: 'openai' },
+                ],
+                default: 'azure',
             },
-        },
-    ]);
-    // Remove trailing slash from base URL
-    const baseUrl = commonAnswers.baseUrl.replace(/\/$/, '');
-    // Step 4: Get provider-specific parameters
-    let apiVersion = '';
-    if (modelType === 'azure') {
-        const azureAnswers = await inquirer.prompt([
+        ]);
+        modelType = answer.modelType;
+    }
+    // Step 3: Get model name
+    let model = options.model;
+    if (!model) {
+        const answer = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'model',
+                message: 'model:',
+                default: 'gpt-4o-mini',
+            },
+        ]);
+        model = answer.model;
+    }
+    // Step 4: Get base URL
+    let baseUrl = options.baseUrl;
+    if (!baseUrl) {
+        const answer = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'baseUrl',
+                message: 'base URL:',
+                validate: (input) => {
+                    if (!input)
+                        return 'base URL is required';
+                    try {
+                        new URL(input);
+                        return true;
+                    }
+                    catch {
+                        return 'please enter a valid URL';
+                    }
+                },
+            },
+        ]);
+        baseUrl = answer.baseUrl;
+    }
+    // Validate and clean base URL
+    if (!baseUrl) {
+        output.error('base URL is required');
+        return false;
+    }
+    baseUrl = baseUrl.replace(/\/$/, '');
+    // Step 5: Get API version (Azure only)
+    let apiVersion = options.apiVersion || '';
+    if (modelType === 'azure' && !options.apiVersion) {
+        const answer = await inquirer.prompt([
             {
                 type: 'input',
                 name: 'apiVersion',
@@ -94,33 +115,29 @@ export async function createModel(modelName) {
                 default: '2024-12-01-preview',
             },
         ]);
-        apiVersion = azureAnswers.apiVersion;
+        apiVersion = answer.apiVersion;
     }
-    // Step 5: Get API key (password input)
-    const { apiKey } = await inquirer.prompt([
-        {
-            type: 'password',
-            name: 'apiKey',
-            message: 'API key:',
-            mask: '*',
-            validate: (input) => {
-                if (!input)
-                    return 'API key is required';
-                return true;
+    // Step 6: Get API key
+    let apiKey = options.apiKey;
+    if (!apiKey) {
+        const answer = await inquirer.prompt([
+            {
+                type: 'password',
+                name: 'apiKey',
+                message: 'API key:',
+                mask: '*',
+                validate: (input) => {
+                    if (!input)
+                        return 'API key is required';
+                    return true;
+                },
             },
-        },
-    ]);
+        ]);
+        apiKey = answer.apiKey;
+    }
     // Step 6: Create the Kubernetes secret
     const secretName = `${modelName}-model-api-key`;
-    output.info(`creating secret ${secretName}...`);
     try {
-        // Delete existing secret if it exists (update scenario)
-        await execa('kubectl', ['delete', 'secret', secretName], {
-            stdio: 'pipe',
-        }).catch(() => {
-            // Ignore error if secret doesn't exist
-        });
-        // Create the secret
         await execa('kubectl', [
             'create',
             'secret',
@@ -128,7 +145,7 @@ export async function createModel(modelName) {
             secretName,
             `--from-literal=api-key=${apiKey}`,
         ], { stdio: 'pipe' });
-        output.success(`secret ${secretName} created`);
+        output.success(`created secret ${secretName}`);
     }
     catch (error) {
         output.error('failed to create secret');
@@ -146,7 +163,7 @@ export async function createModel(modelName) {
         spec: {
             type: modelType,
             model: {
-                value: commonAnswers.modelVersion,
+                value: model,
             },
             config: {},
         },
@@ -192,22 +209,12 @@ export async function createModel(modelName) {
             input: manifestJson,
             stdio: ['pipe', 'pipe', 'pipe'],
         });
-        output.success(`model ${modelName} created successfully`);
-        console.log();
-        output.info('you can now use this model with ARK agents and queries');
+        output.success(`model ${modelName} created`);
         return true;
     }
     catch (error) {
         output.error('failed to create model');
         console.error(error);
-        // Try to clean up the secret if model creation failed
-        try {
-            await execa('kubectl', ['delete', 'secret', secretName], { stdio: 'pipe' });
-            output.info(`cleaned up secret ${secretName}`);
-        }
-        catch {
-            // Ignore cleanup errors
-        }
         return false;
     }
 }

package/dist/commands/models/create.spec.js

@@ -31,28 +31,23 @@ describe('createModel', () => {
         // Prompts for model details
         mockInquirer.prompt
             .mockResolvedValueOnce({ modelType: 'openai' })
-            .mockResolvedValueOnce({
-            modelVersion: 'gpt-4',
-            baseUrl: 'https://api.openai.com/',
-        })
+            .mockResolvedValueOnce({ model: 'gpt-4' })
+            .mockResolvedValueOnce({ baseUrl: 'https://api.openai.com/' })
             .mockResolvedValueOnce({ apiKey: 'secret-key' });
         // Secret operations succeed
-        mockExeca.mockResolvedValueOnce({}); // delete secret (may not exist)
         mockExeca.mockResolvedValueOnce({}); // create secret
         mockExeca.mockResolvedValueOnce({}); // apply model
         const result = await createModel('test-model');
         expect(result).toBe(true);
         expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'model', 'test-model'], { stdio: 'pipe' });
-        expect(mockOutput.success).toHaveBeenCalledWith('model test-model created successfully');
+        expect(mockOutput.success).toHaveBeenCalledWith('model test-model created');
     });
     it('prompts for name when not provided', async () => {
         mockInquirer.prompt
             .mockResolvedValueOnce({ modelName: 'prompted-model' })
             .mockResolvedValueOnce({ modelType: 'azure' })
-            .mockResolvedValueOnce({
-            modelVersion: 'gpt-4',
-            baseUrl: 'https://azure.com',
-        })
+            .mockResolvedValueOnce({ model: 'gpt-4' })
+            .mockResolvedValueOnce({ baseUrl: 'https://azure.com' })
             .mockResolvedValueOnce({ apiVersion: '2024-12-01' })
             .mockResolvedValueOnce({ apiKey: 'secret' });
         mockExeca.mockRejectedValueOnce(new Error('not found')); // model doesn't exist
@@ -72,10 +67,8 @@ describe('createModel', () => {
         mockInquirer.prompt
             .mockResolvedValueOnce({ overwrite: true })
             .mockResolvedValueOnce({ modelType: 'openai' })
-            .mockResolvedValueOnce({
-            modelVersion: 'gpt-4',
-            baseUrl: 'https://api.openai.com',
-        })
+            .mockResolvedValueOnce({ model: 'gpt-4' })
+            .mockResolvedValueOnce({ baseUrl: 'https://api.openai.com' })
             .mockResolvedValueOnce({ apiKey: 'secret' });
         mockExeca.mockResolvedValue({}); // remaining kubectl ops
         const result = await createModel('existing-model');
@@ -93,33 +86,12 @@ describe('createModel', () => {
         mockExeca.mockRejectedValueOnce(new Error('not found')); // model doesn't exist
         mockInquirer.prompt
             .mockResolvedValueOnce({ modelType: 'openai' })
-            .mockResolvedValueOnce({
-            modelVersion: 'gpt-4',
-            baseUrl: 'https://api.openai.com',
-        })
+            .mockResolvedValueOnce({ model: 'gpt-4' })
+            .mockResolvedValueOnce({ baseUrl: 'https://api.openai.com' })
             .mockResolvedValueOnce({ apiKey: 'secret' });
-        mockExeca.mockRejectedValueOnce(new Error('delete failed')); // delete secret may fail
         mockExeca.mockRejectedValueOnce(new Error('secret creation failed')); // create secret fails
         const result = await createModel('test-model');
         expect(result).toBe(false);
         expect(mockOutput.error).toHaveBeenCalledWith('failed to create secret');
     });
-    it('cleans up secret if model creation fails', async () => {
-        mockExeca.mockRejectedValueOnce(new Error('not found')); // model doesn't exist
-        mockInquirer.prompt
-            .mockResolvedValueOnce({ modelType: 'openai' })
-            .mockResolvedValueOnce({
-            modelVersion: 'gpt-4',
-            baseUrl: 'https://api.openai.com',
-        })
-            .mockResolvedValueOnce({ apiKey: 'secret' });
-        mockExeca.mockResolvedValueOnce({}); // delete secret
-        mockExeca.mockResolvedValueOnce({}); // create secret
-        mockExeca.mockRejectedValueOnce(new Error('apply failed')); // apply model fails
-        mockExeca.mockResolvedValueOnce({}); // cleanup secret
-        const result = await createModel('test-model');
-        expect(result).toBe(false);
-        expect(mockOutput.error).toHaveBeenCalledWith('failed to create model');
-        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['delete', 'secret', 'test-model-model-api-key'], { stdio: 'pipe' });
-    });
 });

package/dist/commands/models/index.js

@@ -53,8 +53,14 @@ export function createModelsCommand(_) {
     createCommand
         .description('Create a new model')
         .argument('[name]', 'Model name (optional)')
-        .action(async (name) => {
-        await createModel(name);
+        .option('--type <type>', 'Model provider type (azure, openai, bedrock)')
+        .option('--model <model>', 'Model name (e.g., gpt-4o-mini)')
+        .option('--base-url <url>', 'Base URL for the model API')
+        .option('--api-key <key>', 'API key for authentication')
+        .option('--api-version <version>', 'API version (Azure only)')
+        .option('--yes', 'Skip confirmation prompts')
+        .action(async (name, options) => {
+        await createModel(name, options);
     });
     modelsCommand.addCommand(createCommand);
     // Add query command

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

@@ -76,7 +76,7 @@ describe('models command', () => {
     it('create subcommand works', async () => {
         const command = createModelsCommand({});
         await command.parseAsync(['node', 'test', 'create', 'my-model']);
-        expect(mockCreateModel).toHaveBeenCalledWith('my-model');
+        expect(mockCreateModel).toHaveBeenCalledWith('my-model', expect.objectContaining({}));
     });
     it('query subcommand works', async () => {
         const command = createModelsCommand({});

package/dist/commands/status/index.d.ts

@@ -1,3 +1,5 @@
 import { Command } from 'commander';
-export declare function checkStatus(): Promise<void>;
+export declare function checkStatus(serviceNames?: string[], options?: {
+    waitForReady?: string;
+}): Promise<void>;
 export declare function createStatusCommand(): Command;

package/dist/commands/status/index.js

@@ -4,6 +4,10 @@ import ora from 'ora';
 import { StatusChecker } from '../../components/statusChecker.js';
 import { StatusFormatter, } from '../../ui/statusFormatter.js';
 import { fetchVersionInfo } from '../../lib/versions.js';
+import { waitForServicesReady, } from '../../lib/waitForReady.js';
+import { arkServices } from '../../arkServices.js';
+import output from '../../lib/output.js';
+import { parseTimeoutToSeconds } from '../../lib/timeout.js';
 /**
  * Enrich service with formatted details including version/revision
  */
@@ -249,7 +253,7 @@ function buildStatusSections(data, versionInfo) {
     sections.push({ title: 'ark status:', lines: arkStatusLines });
     return sections;
 }
-export async function checkStatus() {
+export async function checkStatus(serviceNames, options) {
     const spinner = ora('Checking system status').start();
     try {
         spinner.text = 'Checking system dependencies';
@@ -264,6 +268,52 @@ export async function checkStatus() {
         spinner.stop();
         const sections = buildStatusSections(statusData, versionInfo);
         StatusFormatter.printSections(sections);
+        if (options?.waitForReady) {
+            const timeoutSeconds = parseTimeoutToSeconds(options.waitForReady);
+            let servicesToWait = [];
+            if (serviceNames && serviceNames.length > 0) {
+                servicesToWait = serviceNames
+                    .map((name) => Object.values(arkServices).find((s) => s.name === name))
+                    .filter((s) => s !== undefined &&
+                    s.k8sDeploymentName !== undefined &&
+                    s.namespace !== undefined);
+                if (servicesToWait.length === 0) {
+                    output.error(`No valid services found matching: ${serviceNames.join(', ')}`);
+                    process.exit(1);
+                }
+            }
+            else {
+                servicesToWait = Object.values(arkServices).filter((s) => s.enabled &&
+                    s.category === 'core' &&
+                    s.k8sDeploymentName &&
+                    s.namespace);
+            }
+            console.log();
+            const waitSpinner = ora(`Waiting for services to be ready (timeout: ${timeoutSeconds}s)...`).start();
+            const statusMap = new Map();
+            servicesToWait.forEach((s) => statusMap.set(s.name, false));
+            const startTime = Date.now();
+            const result = await waitForServicesReady(servicesToWait, timeoutSeconds, (progress) => {
+                statusMap.set(progress.serviceName, progress.ready);
+                const elapsed = Math.floor((Date.now() - startTime) / 1000);
+                const lines = servicesToWait.map((s) => {
+                    const ready = statusMap.get(s.name);
+                    const icon = ready ? '✓' : '⋯';
+                    const status = ready ? 'ready' : 'waiting...';
+                    const color = ready ? chalk.green : chalk.yellow;
+                    return `  ${color(icon)} ${chalk.bold(s.name)} ${chalk.blue(`(${s.namespace})`)} - ${status}`;
+                });
+                waitSpinner.text = `Waiting for services to be ready (${elapsed}/${timeoutSeconds}s)...\n${lines.join('\n')}`;
+            });
+            if (result) {
+                waitSpinner.succeed('All services are ready');
+                process.exit(0);
+            }
+            else {
+                waitSpinner.fail(`Services did not become ready within ${timeoutSeconds} seconds`);
+                process.exit(1);
+            }
+        }
         process.exit(0);
     }
     catch (error) {
@@ -276,6 +326,8 @@ export function createStatusCommand() {
     const statusCommand = new Command('status');
     statusCommand
         .description('Check ARK system status')
-        .action(() => checkStatus());
+        .argument('[services...]', 'specific services to check (optional)')
+        .option('--wait-for-ready <timeout>', 'wait for services to be ready (e.g., 30s, 2m, 1h)')
+        .action((services, options) => checkStatus(services, options));
     return statusCommand;
 }