@agents-at-scale/ark 0.1.34 → 0.1.35-rc.1

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

@@ -0,0 +1,6 @@
+import { Command } from 'commander';
+export declare function installArk(options?: {
+    yes?: boolean;
+    waitForReady?: string;
+}): Promise<void>;
+export declare function createInstallCommand(): Command;

package/dist/commands/install/index.js

@@ -0,0 +1,165 @@
+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 { isArkReady } from '../../lib/arkStatus.js';
+import ora from 'ora';
+export async function installArk(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 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 = options.yes || (await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'shouldInstallDeps',
+            message: 'install required dependencies (cert-manager, gateway api)?',
+            default: true,
+        },
+    ])).shouldInstallDeps;
+    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 = options.yes || (await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'shouldInstall',
+                message: `install ${chalk.bold(service.name)}? ${service.description ? chalk.gray(`(${service.description.toLowerCase()})`) : ''}`,
+                default: true,
+            },
+        ])).shouldInstall;
+        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
+        }
+    }
+    // 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() {
+    const command = new Command('install');
+    command
+        .description('Install ARK components using Helm')
+        .option('-y, --yes', 'automatically confirm all installations')
+        .option('--wait-for-ready <timeout>', 'wait for ARK to be ready after installation (e.g., 30s, 2m)')
+        .action(async (options) => {
+        await installArk(options);
+    });
+    return command;
+}

package/dist/commands/install.d.ts

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

package/dist/commands/install.js

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

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

package/dist/commands/models/create.js

@@ -0,0 +1,213 @@
+import { execa } from 'execa';
+import inquirer from 'inquirer';
+import output from '../../lib/output.js';
+export async function createModel(modelName) {
+    // Step 1: Get model name if not provided
+    if (!modelName) {
+        const nameAnswer = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'modelName',
+                message: 'model name:',
+                default: 'default',
+                validate: (input) => {
+                    if (!input)
+                        return 'model name is required';
+                    // Kubernetes name validation
+                    if (!/^[a-z0-9]([-a-z0-9]*[a-z0-9])?$/.test(input)) {
+                        return 'model name must be a valid Kubernetes resource name';
+                    }
+                    return true;
+                },
+            },
+        ]);
+        modelName = nameAnswer.modelName;
+    }
+    // Check if model already exists
+    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;
+        }
+    }
+    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';
+                }
+            },
+        },
+    ]);
+    // 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([
+            {
+                type: 'input',
+                name: 'apiVersion',
+                message: 'Azure API version:',
+                default: '2024-12-01-preview',
+            },
+        ]);
+        apiVersion = azureAnswers.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: 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',
+            'generic',
+            secretName,
+            `--from-literal=api-key=${apiKey}`,
+        ], { stdio: 'pipe' });
+        output.success(`secret ${secretName} created`);
+    }
+    catch (error) {
+        output.error('failed to create secret');
+        console.error(error);
+        return false;
+    }
+    // Step 7: Create the Model resource
+    output.info(`creating model ${modelName}...`);
+    const modelManifest = {
+        apiVersion: 'ark.mckinsey.com/v1alpha1',
+        kind: 'Model',
+        metadata: {
+            name: modelName,
+        },
+        spec: {
+            type: modelType,
+            model: {
+                value: commonAnswers.modelVersion,
+            },
+            config: {},
+        },
+    };
+    // Add provider-specific config
+    if (modelType === 'azure') {
+        modelManifest.spec.config.azure = {
+            apiKey: {
+                valueFrom: {
+                    secretKeyRef: {
+                        name: secretName,
+                        key: 'api-key',
+                    },
+                },
+            },
+            baseUrl: {
+                value: baseUrl,
+            },
+            apiVersion: {
+                value: apiVersion,
+            },
+        };
+    }
+    else {
+        modelManifest.spec.config.openai = {
+            apiKey: {
+                valueFrom: {
+                    secretKeyRef: {
+                        name: secretName,
+                        key: 'api-key',
+                    },
+                },
+            },
+            baseUrl: {
+                value: baseUrl,
+            },
+        };
+    }
+    try {
+        // Apply the model manifest using kubectl
+        const manifestJson = JSON.stringify(modelManifest);
+        await execa('kubectl', ['apply', '-f', '-'], {
+            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');
+        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/index.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function createModelsCommand(): Command;

package/dist/commands/models/index.js

@@ -0,0 +1,65 @@
+import { Command } from 'commander';
+import { execa } from 'execa';
+import output from '../../lib/output.js';
+import { createModel } from './create.js';
+async function listModels(options) {
+    try {
+        // Use kubectl to get models
+        const result = await execa('kubectl', ['get', 'models', '-o', 'json'], {
+            stdio: 'pipe',
+        });
+        const data = JSON.parse(result.stdout);
+        const models = data.items || [];
+        if (options.output === 'json') {
+            // Output the raw items for JSON format
+            console.log(JSON.stringify(models, null, 2));
+        }
+        else {
+            if (models.length === 0) {
+                output.info('No models found');
+                return;
+            }
+            // Just output the model names
+            models.forEach((model) => {
+                console.log(model.metadata.name);
+            });
+        }
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.includes('the server doesn\'t have a resource type')) {
+            output.error('Model CRDs not installed. Is the ARK controller running?');
+        }
+        else {
+            output.error(`Failed to list models: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+        process.exit(1);
+    }
+}
+export function createModelsCommand() {
+    const modelsCommand = new Command('models');
+    modelsCommand
+        .description('List available models')
+        .option('-o, --output <format>', 'Output format (json)', 'text')
+        .action(async (options) => {
+        await listModels(options);
+    });
+    const listCommand = new Command('list');
+    listCommand
+        .alias('ls')
+        .description('List available models')
+        .option('-o, --output <format>', 'Output format (json)', 'text')
+        .action(async (options) => {
+        await listModels(options);
+    });
+    modelsCommand.addCommand(listCommand);
+    // Add create command
+    const createCommand = new Command('create');
+    createCommand
+        .description('Create a new model')
+        .argument('[name]', 'Model name (optional)')
+        .action(async (name) => {
+        await createModel(name);
+    });
+    modelsCommand.addCommand(createCommand);
+    return modelsCommand;
+}

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

@@ -0,0 +1,8 @@
+import { Model, ArkApiClient } from '../../lib/arkApiClient.js';
+interface ModelSelectorProps {
+    arkApiClient: ArkApiClient;
+    onSelect: (model: Model) => void;
+    onExit: () => void;
+}
+export declare function ModelSelector({ arkApiClient, onSelect, onExit, }: ModelSelectorProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/commands/models/selector.js

@@ -0,0 +1,53 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect } from 'react';
+import { Box, Text, useInput } from 'ink';
+export function ModelSelector({ arkApiClient, onSelect, onExit, }) {
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    const [models, setModels] = useState([]);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    useEffect(() => {
+        arkApiClient
+            .getModels()
+            .then((fetchedModels) => {
+            setModels(fetchedModels);
+            setLoading(false);
+        })
+            .catch((err) => {
+            setError(err.message || 'Failed to fetch models');
+            setLoading(false);
+        });
+    }, [arkApiClient]);
+    useInput((input, key) => {
+        if (key.escape) {
+            onExit();
+        }
+        else if (key.upArrow || input === 'k') {
+            setSelectedIndex((prev) => (prev === 0 ? models.length - 1 : prev - 1));
+        }
+        else if (key.downArrow || input === 'j') {
+            setSelectedIndex((prev) => (prev === models.length - 1 ? 0 : prev + 1));
+        }
+        else if (key.return) {
+            onSelect(models[selectedIndex]);
+        }
+        else {
+            // Handle number keys for quick selection
+            const num = parseInt(input, 10);
+            if (!isNaN(num) && num >= 1 && num <= models.length) {
+                onSelect(models[num - 1]);
+            }
+        }
+    });
+    if (loading) {
+        return (_jsx(Box, { children: _jsx(Text, { children: "Loading models..." }) }));
+    }
+    if (error) {
+        return (_jsx(Box, { children: _jsxs(Text, { color: "red", children: ["Error: ", error] }) }));
+    }
+    if (models.length === 0) {
+        return (_jsx(Box, { children: _jsx(Text, { children: "No models available" }) }));
+    }
+    const selectedModel = models[selectedIndex];
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 2, paddingY: 1, children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, children: "Select Model" }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: "Choose a model to start a conversation with" }) }), _jsx(Box, { flexDirection: "column", children: models.map((model, index) => (_jsx(Box, { marginBottom: 0, children: _jsxs(Text, { color: index === selectedIndex ? 'green' : undefined, children: [index === selectedIndex ? '❯ ' : '  ', index + 1, ". ", model.name, model.type ? ` (${model.type})` : ''] }) }, model.name))) }), selectedModel && selectedModel.model && (_jsx(Box, { marginTop: 1, paddingLeft: 2, children: _jsxs(Text, { dimColor: true, wrap: "wrap", children: ["Model: ", selectedModel.model] }) })), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Enter to confirm \u00B7 Number to select \u00B7 Esc to exit" }) })] }));
+}

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

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function createRoutesCommand(): Command;