@agents-at-scale/ark 0.1.36-rc1 → 0.1.37

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;
 }

package/dist/components/ChatUI.js

@@ -7,6 +7,7 @@ import * as React from 'react';
 import { marked } from 'marked';
 // @ts-ignore - no types available
 import TerminalRenderer from 'marked-terminal';
+import { APIError } from 'openai';
 import { ChatClient, } from '../lib/chatClient.js';
 import { AgentSelector } from '../ui/AgentSelector.js';
 import { ModelSelector } from '../ui/ModelSelector.js';
@@ -548,7 +549,24 @@ const ChatUI = ({ initialTargetId, arkApiClient, arkApiProxy, config, }) => {
                 // Request was cancelled, message already updated by Esc handler
                 return;
             }
-            const errorMessage = err instanceof Error ? err.message : 'Failed to send message';
+            let errorMessage = 'Failed to send message';
+            // OpenAI SDK errors include response body in .error property
+            if (err instanceof APIError) {
+                if (err.error && typeof err.error === 'object') {
+                    errorMessage = JSON.stringify(err.error, null, 2);
+                }
+                else {
+                    errorMessage = err.message;
+                }
+            }
+            // Standard JavaScript errors
+            else if (err instanceof Error) {
+                errorMessage = err.message;
+            }
+            // String errors from throw statements
+            else if (typeof err === 'string') {
+                errorMessage = err;
+            }
             setError(errorMessage);
             setIsTyping(false);
             setAbortController(null);

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-#!/usr/bin/env NODE_NO_WARNINGS=1 node
+#!/usr/bin/env node
 export {};

package/dist/index.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env NODE_NO_WARNINGS=1 node
+#!/usr/bin/env node
 import { jsx as _jsx } from "react/jsx-runtime";
 import { Command } from 'commander';
 import { render } from 'ink';

package/dist/lib/arkApiClient.d.ts

@@ -40,8 +40,7 @@ export interface Team {
 export declare class ArkApiClient {
     private openai;
     private baseUrl;
-    private namespace;
-    constructor(arkApiUrl: string, namespace?: string);
+    constructor(arkApiUrl: string);
     getBaseUrl(): string;
     getQueryTargets(): Promise<QueryTarget[]>;
     getAgents(): Promise<Agent[]>;

package/dist/lib/arkApiClient.js

@@ -1,8 +1,7 @@
 import OpenAI from 'openai';
 export class ArkApiClient {
-    constructor(arkApiUrl, namespace = 'default') {
+    constructor(arkApiUrl) {
         this.baseUrl = arkApiUrl;
-        this.namespace = namespace;
         this.openai = new OpenAI({
             baseURL: `${arkApiUrl}/openai/v1`,
             apiKey: 'dummy', // ark-api doesn't require an API key
@@ -34,7 +33,7 @@ export class ArkApiClient {
     }
     async getAgents() {
         try {
-            const response = await fetch(`${this.baseUrl}/v1/namespaces/${this.namespace}/agents`);
+            const response = await fetch(`${this.baseUrl}/v1/agents`);
             if (!response.ok) {
                 throw new Error(`HTTP error! status: ${response.status}`);
             }
@@ -47,7 +46,7 @@ export class ArkApiClient {
     }
     async getModels() {
         try {
-            const response = await fetch(`${this.baseUrl}/v1/namespaces/${this.namespace}/models`);
+            const response = await fetch(`${this.baseUrl}/v1/models`);
             if (!response.ok) {
                 throw new Error(`HTTP error! status: ${response.status}`);
             }
@@ -60,7 +59,7 @@ export class ArkApiClient {
     }
     async getTools() {
         try {
-            const response = await fetch(`${this.baseUrl}/v1/namespaces/${this.namespace}/tools`);
+            const response = await fetch(`${this.baseUrl}/v1/tools`);
             if (!response.ok) {
                 throw new Error(`HTTP error! status: ${response.status}`);
             }
@@ -73,7 +72,7 @@ export class ArkApiClient {
     }
     async getTeams() {
         try {
-            const response = await fetch(`${this.baseUrl}/v1/namespaces/${this.namespace}/teams`);
+            const response = await fetch(`${this.baseUrl}/v1/teams`);
             if (!response.ok) {
                 throw new Error(`HTTP error! status: ${response.status}`);
             }

package/dist/lib/config.d.ts

@@ -1,10 +1,14 @@
 import type { ClusterInfo } from './cluster.js';
+import type { ArkService } from '../types/arkService.js';
 export interface ChatConfig {
     streaming?: boolean;
     outputFormat?: 'text' | 'markdown';
 }
 export interface ArkConfig {
     chat?: ChatConfig;
+    services?: {
+        [serviceName: string]: Partial<ArkService>;
+    };
     clusterInfo?: ClusterInfo;
 }
 /**

package/dist/lib/config.js

@@ -70,6 +70,15 @@ function mergeConfig(target, source) {
             target.chat.outputFormat = source.chat.outputFormat;
         }
     }
+    if (source.services) {
+        target.services = target.services || {};
+        for (const [serviceName, overrides] of Object.entries(source.services)) {
+            target.services[serviceName] = {
+                ...target.services[serviceName],
+                ...overrides,
+            };
+        }
+    }
 }
 /**
  * Get the paths checked for config files

package/dist/lib/nextSteps.js

@@ -4,7 +4,7 @@ import chalk from 'chalk';
  */
 export function printNextSteps() {
     console.log();
-    console.log(chalk.green.bold('✓ ARK installed successfully!'));
+    console.log(chalk.green.bold('✓ Installation complete'));
     console.log();
     console.log(chalk.gray('Next steps:'));
     console.log();

package/dist/lib/nextSteps.spec.js

@@ -15,7 +15,7 @@ describe('printNextSteps', () => {
     it('prints successful installation message', () => {
         printNextSteps();
         const fullOutput = output.join('\n');
-        expect(fullOutput).toContain('ARK installed successfully!');
+        expect(fullOutput).toContain('✓ Installation complete');
     });
     it('includes all required commands', () => {
         printNextSteps();

package/dist/lib/security.js

@@ -9,6 +9,10 @@ export class SecurityUtils {
      * Validate that a path is safe and doesn't contain directory traversal attempts
      */
     static validatePath(filePath, context = 'path') {
+        // Skip validation for internal template paths - they're always safe
+        if (context === 'template path') {
+            return;
+        }
         if (!filePath || typeof filePath !== 'string') {
             throw new ValidationError(`Invalid ${context}: path must be a non-empty string`, 'path', ['Provide a valid file path']);
         }

package/dist/lib/startup.js

@@ -52,7 +52,9 @@ export function showNoClusterError() {
  */
 async function hasKubernetesContext() {
     try {
-        const { stdout } = await execa('kubectl', ['config', 'current-context']);
+        const { stdout } = await execa('kubectl', ['config', 'current-context'], {
+            timeout: 5000,
+        });
         return stdout.trim().length > 0;
     }
     catch {
@@ -72,7 +74,9 @@ export async function startup() {
     const hasContext = await hasKubernetesContext();
     if (hasContext) {
         try {
-            const { stdout } = await execa('kubectl', ['config', 'current-context']);
+            const { stdout } = await execa('kubectl', ['config', 'current-context'], {
+                timeout: 5000,
+            });
             config.clusterInfo = {
                 type: 'unknown', // We don't detect cluster type here - too slow
                 context: stdout.trim(),

package/dist/lib/startup.spec.js

@@ -138,7 +138,7 @@ describe('startup', () => {
             type: 'unknown',
             context: 'minikube',
         });
-        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['config', 'current-context']);
+        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['config', 'current-context'], { timeout: 5000 });
     });
     it('handles missing kubectl context gracefully', async () => {
         mockCheckCommandExists.mockResolvedValue(true);

package/dist/lib/timeout.d.ts

@@ -0,0 +1 @@
+export declare function parseTimeoutToSeconds(value: string): number;