@agents-at-scale/ark 0.1.35 → 0.1.36

package/dist/index.js

@@ -1,67 +1,67 @@
-#!/usr/bin/env node
+#!/usr/bin/env NODE_NO_WARNINGS=1 node
 import { jsx as _jsx } from "react/jsx-runtime";
-import chalk from 'chalk';
 import { Command } from 'commander';
 import { render } from 'ink';
 import { createRequire } from 'module';
 const require = createRequire(import.meta.url);
 const packageJson = require('../package.json');
+import output from './lib/output.js';
+import { startup } from './lib/startup.js';
+import { createAgentsCommand } from './commands/agents/index.js';
+import { createChatCommand } from './commands/chat/index.js';
 import { createClusterCommand } from './commands/cluster/index.js';
-import { createCompletionCommand } from './commands/completion.js';
+import { createCompletionCommand } from './commands/completion/index.js';
+import { createDashboardCommand } from './commands/dashboard/index.js';
+import { createDocsCommand } from './commands/docs/index.js';
 import { createGenerateCommand } from './commands/generate/index.js';
-import { createConfigCommand } from './commands/config.js';
-import { StatusChecker } from './components/statusChecker.js';
-import { ConfigManager } from './config.js';
-import { ArkClient } from './lib/arkClient.js';
+import { createInstallCommand } from './commands/install/index.js';
+import { createModelsCommand } from './commands/models/index.js';
+import { createQueryCommand } from './commands/query/index.js';
+import { createUninstallCommand } from './commands/uninstall/index.js';
+import { createStatusCommand } from './commands/status/index.js';
+import { createConfigCommand } from './commands/config/index.js';
+import { createTargetsCommand } from './commands/targets/index.js';
+import { createTeamsCommand } from './commands/teams/index.js';
+import { createToolsCommand } from './commands/tools/index.js';
+import { createRoutesCommand } from './commands/routes/index.js';
 import MainMenu from './ui/MainMenu.js';
-import { StatusFormatter } from './ui/statusFormatter.js';
-function showMainMenu() {
-    console.clear();
-    render(_jsx(MainMenu, {}));
-}
-async function handleStatusCheck() {
-    try {
-        const configManager = new ConfigManager();
-        const apiBaseUrl = await configManager.getApiBaseUrl();
-        const serviceUrls = await configManager.getServiceUrls();
-        const arkClient = new ArkClient(apiBaseUrl);
-        const statusChecker = new StatusChecker(arkClient);
-        const statusData = await statusChecker.checkAll(serviceUrls, apiBaseUrl);
-        StatusFormatter.printStatus(statusData);
-        process.exit(0); // Exit cleanly after showing status
-    }
-    catch (error) {
-        console.error(chalk.red('Failed to check status:'), error);
-        process.exit(1);
-    }
+function showMainMenu(config) {
+    const app = render(_jsx(MainMenu, { config: config }));
+    globalThis.inkApp = app;
 }
 async function main() {
+    // Initialize CLI - check requirements and load config
+    const config = await startup();
     const program = new Command();
     program
         .name(packageJson.name)
         .description(packageJson.description)
         .version(packageJson.version);
-    program.addCommand(createClusterCommand());
-    program.addCommand(createCompletionCommand());
-    program.addCommand(createGenerateCommand());
-    program.addCommand(createConfigCommand());
-    // Add check status command
-    const checkCommand = new Command('check');
-    checkCommand.description('Check various ARK system components');
-    checkCommand
-        .command('status')
-        .description('Check system status')
-        .action(handleStatusCheck);
-    program.addCommand(checkCommand);
+    program.addCommand(createAgentsCommand(config));
+    program.addCommand(createChatCommand(config));
+    program.addCommand(createClusterCommand(config));
+    program.addCommand(createCompletionCommand(config));
+    program.addCommand(createDashboardCommand(config));
+    program.addCommand(createDocsCommand(config));
+    program.addCommand(createGenerateCommand(config));
+    program.addCommand(createInstallCommand(config));
+    program.addCommand(createModelsCommand(config));
+    program.addCommand(createQueryCommand(config));
+    program.addCommand(createUninstallCommand(config));
+    program.addCommand(createStatusCommand());
+    program.addCommand(createConfigCommand(config));
+    program.addCommand(createTargetsCommand(config));
+    program.addCommand(createTeamsCommand(config));
+    program.addCommand(createToolsCommand(config));
+    program.addCommand(createRoutesCommand(config));
     // If no args provided, show interactive menu
     if (process.argv.length === 2) {
-        console.log();
-        showMainMenu();
+        showMainMenu(config);
         return;
     }
     await program.parseAsync(process.argv);
 }
 main().catch((error) => {
-    console.error(chalk.red('Failed to start ARK CLI:'), error);
+    output.error('failed to start ark cli: ', error);
     process.exit(1);
 });

package/dist/lib/arkApiClient.d.ts

@@ -0,0 +1,53 @@
+import OpenAI from 'openai';
+export interface QueryTarget {
+    id: string;
+    name: string;
+    type: 'agent' | 'model' | 'tool' | string;
+    description?: string;
+}
+export interface Agent {
+    name: string;
+    namespace: string;
+    description?: string;
+    model_ref?: string;
+    prompt?: string;
+    status?: string;
+    annotations?: Record<string, string>;
+}
+export interface Model {
+    name: string;
+    namespace: string;
+    type: string;
+    model: string;
+    status: string;
+    annotations?: Record<string, string>;
+}
+export interface Tool {
+    name: string;
+    namespace: string;
+    description?: string;
+    labels?: Record<string, string>;
+    annotations?: Record<string, string>;
+}
+export interface Team {
+    name: string;
+    namespace: string;
+    description?: string;
+    strategy?: string;
+    members_count?: number;
+    status?: string;
+}
+export declare class ArkApiClient {
+    private openai;
+    private baseUrl;
+    private namespace;
+    constructor(arkApiUrl: string, namespace?: string);
+    getBaseUrl(): string;
+    getQueryTargets(): Promise<QueryTarget[]>;
+    getAgents(): Promise<Agent[]>;
+    getModels(): Promise<Model[]>;
+    getTools(): Promise<Tool[]>;
+    getTeams(): Promise<Team[]>;
+    createChatCompletion(params: OpenAI.Chat.Completions.ChatCompletionCreateParams): Promise<OpenAI.Chat.Completions.ChatCompletion>;
+    createChatCompletionStream(params: OpenAI.Chat.Completions.ChatCompletionCreateParams): AsyncIterable<OpenAI.Chat.Completions.ChatCompletionChunk>;
+}

package/dist/lib/arkApiClient.js

@@ -0,0 +1,102 @@
+import OpenAI from 'openai';
+export class ArkApiClient {
+    constructor(arkApiUrl, namespace = 'default') {
+        this.baseUrl = arkApiUrl;
+        this.namespace = namespace;
+        this.openai = new OpenAI({
+            baseURL: `${arkApiUrl}/openai/v1`,
+            apiKey: 'dummy', // ark-api doesn't require an API key
+            dangerouslyAllowBrowser: false,
+        });
+    }
+    getBaseUrl() {
+        return this.baseUrl;
+    }
+    async getQueryTargets() {
+        try {
+            const models = await this.openai.models.list();
+            const targets = models.data.map((model) => {
+                const parts = model.id.split('/');
+                const type = parts[0] || 'model';
+                const name = parts.slice(1).join('/') || model.id;
+                return {
+                    id: model.id,
+                    name,
+                    type,
+                    description: model.id,
+                };
+            });
+            return targets;
+        }
+        catch (error) {
+            throw new Error(`Failed to get query targets: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    async getAgents() {
+        try {
+            const response = await fetch(`${this.baseUrl}/v1/namespaces/${this.namespace}/agents`);
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            const data = (await response.json());
+            return data.items || [];
+        }
+        catch (error) {
+            throw new Error(`Failed to get agents: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    async getModels() {
+        try {
+            const response = await fetch(`${this.baseUrl}/v1/namespaces/${this.namespace}/models`);
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            const data = (await response.json());
+            return data.items || [];
+        }
+        catch (error) {
+            throw new Error(`Failed to get models: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    async getTools() {
+        try {
+            const response = await fetch(`${this.baseUrl}/v1/namespaces/${this.namespace}/tools`);
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            const data = (await response.json());
+            return data.items || [];
+        }
+        catch (error) {
+            throw new Error(`Failed to get tools: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    async getTeams() {
+        try {
+            const response = await fetch(`${this.baseUrl}/v1/namespaces/${this.namespace}/teams`);
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            const data = (await response.json());
+            return data.items || [];
+        }
+        catch (error) {
+            throw new Error(`Failed to get teams: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    async createChatCompletion(params) {
+        return (await this.openai.chat.completions.create({
+            ...params,
+            stream: false,
+        }));
+    }
+    async *createChatCompletionStream(params) {
+        const stream = await this.openai.chat.completions.create({
+            ...params,
+            stream: true,
+        });
+        for await (const chunk of stream) {
+            yield chunk;
+        }
+    }
+}

package/dist/lib/arkApiProxy.d.ts

@@ -0,0 +1,9 @@
+import { ArkApiClient } from './arkApiClient.js';
+export declare class ArkApiProxy {
+    private serviceProxy;
+    constructor(localPort?: number);
+    start(): Promise<ArkApiClient>;
+    stop(): void;
+    isRunning(): boolean;
+    getLocalUrl(): string;
+}

package/dist/lib/arkApiProxy.js

@@ -0,0 +1,22 @@
+import { ArkApiClient } from './arkApiClient.js';
+import { ArkServiceProxy } from './arkServiceProxy.js';
+import { arkServices } from '../arkServices.js';
+export class ArkApiProxy {
+    constructor(localPort) {
+        const arkApiService = arkServices['ark-api'];
+        this.serviceProxy = new ArkServiceProxy(arkApiService, localPort);
+    }
+    async start() {
+        const arkApiUrl = await this.serviceProxy.start();
+        return new ArkApiClient(arkApiUrl);
+    }
+    stop() {
+        this.serviceProxy.stop();
+    }
+    isRunning() {
+        return this.serviceProxy.isRunning();
+    }
+    getLocalUrl() {
+        return this.serviceProxy.getLocalUrl();
+    }
+}

package/dist/lib/arkServiceProxy.d.ts

@@ -0,0 +1,14 @@
+import { ArkService } from '../arkServices.js';
+export declare class ArkServiceProxy {
+    private kubectlProcess?;
+    private localPort;
+    private isReady;
+    private service;
+    constructor(service: ArkService, localPort?: number);
+    private getRandomPort;
+    start(): Promise<string>;
+    stop(): void;
+    isRunning(): boolean;
+    getLocalUrl(): string;
+    getService(): ArkService;
+}

package/dist/lib/arkServiceProxy.js

@@ -0,0 +1,95 @@
+import { spawn } from 'child_process';
+export class ArkServiceProxy {
+    constructor(service, localPort) {
+        this.isReady = false;
+        this.service = service;
+        this.localPort =
+            localPort || service.k8sPortForwardLocalPort || this.getRandomPort();
+    }
+    getRandomPort() {
+        return Math.floor(Math.random() * (65535 - 1024) + 1024);
+    }
+    async start() {
+        if (!this.service.k8sServiceName || !this.service.k8sServicePort) {
+            throw new Error(`${this.service.name} service configuration missing k8sServiceName or k8sServicePort`);
+        }
+        return new Promise((resolve, reject) => {
+            const args = [
+                'port-forward',
+                `service/${this.service.k8sServiceName}`,
+                `${this.localPort}:${this.service.k8sServicePort}`,
+            ];
+            // Add namespace flag only if namespace is defined
+            if (this.service.namespace) {
+                args.push('--namespace', this.service.namespace);
+            }
+            this.kubectlProcess = spawn('kubectl', args, {
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+            let setupComplete = false;
+            const setupTimeout = setTimeout(() => {
+                if (!setupComplete) {
+                    this.stop();
+                    reject(new Error(`${this.service.name} port forward setup timeout`));
+                }
+            }, 10000);
+            this.kubectlProcess.stdout?.on('data', (data) => {
+                const output = data.toString();
+                if (output.includes('Forwarding from') && !setupComplete) {
+                    setupComplete = true;
+                    clearTimeout(setupTimeout);
+                    this.isReady = true;
+                    const localUrl = `http://localhost:${this.localPort}`;
+                    resolve(localUrl);
+                }
+            });
+            this.kubectlProcess.stderr?.on('data', (data) => {
+                const errorOutput = data.toString();
+                if (!setupComplete) {
+                    setupComplete = true;
+                    clearTimeout(setupTimeout);
+                    this.stop();
+                    reject(new Error(`${this.service.name} port forward failed: ${errorOutput.trim()}`));
+                }
+            });
+            this.kubectlProcess.on('error', (error) => {
+                if (!setupComplete) {
+                    setupComplete = true;
+                    clearTimeout(setupTimeout);
+                    reject(new Error(`Failed to start ${this.service.name} port forward: ${error.message}`));
+                }
+            });
+            this.kubectlProcess.on('exit', (code) => {
+                this.isReady = false;
+                if (!setupComplete && code !== 0) {
+                    setupComplete = true;
+                    clearTimeout(setupTimeout);
+                    reject(new Error(`${this.service.name} port forward exited with code ${code}`));
+                }
+            });
+        });
+    }
+    stop() {
+        if (this.kubectlProcess) {
+            // Use SIGTERM for graceful shutdown
+            this.kubectlProcess.kill('SIGTERM');
+            // Give it a second to clean up, then force kill if needed
+            setTimeout(() => {
+                if (this.kubectlProcess && !this.kubectlProcess.killed) {
+                    this.kubectlProcess.kill('SIGKILL');
+                }
+            }, 1000);
+            this.kubectlProcess = undefined;
+        }
+        this.isReady = false;
+    }
+    isRunning() {
+        return this.isReady && this.kubectlProcess !== undefined;
+    }
+    getLocalUrl() {
+        return `http://localhost:${this.localPort}`;
+    }
+    getService() {
+        return this.service;
+    }
+}

package/dist/lib/arkStatus.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Get current installed ARK version
+ * @returns version string if found, undefined otherwise
+ */
+export declare function getArkVersion(): Promise<string | undefined>;
+/**
+ * Check if ARK is ready by verifying the ark-controller is running
+ * @returns true if ark-controller deployment exists and has ready replicas
+ */
+export declare function isArkReady(): Promise<boolean>;

package/dist/lib/arkStatus.js

@@ -0,0 +1,79 @@
+import { execa } from 'execa';
+import { arkServices } from '../arkServices.js';
+/**
+ * Get current installed ARK version
+ * @returns version string if found, undefined otherwise
+ */
+export async function getArkVersion() {
+    try {
+        const controller = arkServices['ark-controller'];
+        const { stdout } = await execa('helm', ['list', '-n', controller.namespace, '-o', 'json'], { stdio: 'pipe' });
+        const releases = JSON.parse(stdout);
+        const arkController = releases.find((r) => r.name === controller.helmReleaseName);
+        return arkController?.app_version;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Check if ARK is ready by verifying the ark-controller is running
+ * @returns true if ark-controller deployment exists and has ready replicas
+ */
+export async function isArkReady() {
+    try {
+        // Check if ark-controller deployment exists and get its status
+        const result = await execa('kubectl', ['get', 'deployment', 'ark-controller', '-n', 'ark-system', '-o', 'json'], { stdio: 'pipe' });
+        const deployment = JSON.parse(result.stdout);
+        const readyReplicas = deployment.status?.readyReplicas || 0;
+        const replicas = deployment.spec?.replicas || 0;
+        // If main deployment has 0 replicas, check devspace deployment
+        if (replicas === 0) {
+            try {
+                const devResult = await execa('kubectl', [
+                    'get',
+                    'deployment',
+                    'ark-controller-devspace',
+                    '-n',
+                    'ark-system',
+                    '-o',
+                    'json',
+                ], { stdio: 'pipe' });
+                const devDeployment = JSON.parse(devResult.stdout);
+                const devReadyReplicas = devDeployment.status?.readyReplicas || 0;
+                const devReplicas = devDeployment.spec?.replicas || 0;
+                // ARK is ready if devspace deployment has ready replicas
+                return devReadyReplicas > 0 && devReadyReplicas === devReplicas;
+            }
+            catch {
+                // Devspace deployment doesn't exist
+                return false;
+            }
+        }
+        // ARK is ready if deployment exists and has at least one ready replica
+        return readyReplicas > 0 && readyReplicas === replicas;
+    }
+    catch {
+        // Main deployment doesn't exist, try devspace deployment
+        try {
+            const devResult = await execa('kubectl', [
+                'get',
+                'deployment',
+                'ark-controller-devspace',
+                '-n',
+                'ark-system',
+                '-o',
+                'json',
+            ], { stdio: 'pipe' });
+            const devDeployment = JSON.parse(devResult.stdout);
+            const devReadyReplicas = devDeployment.status?.readyReplicas || 0;
+            const devReplicas = devDeployment.spec?.replicas || 0;
+            // ARK is ready if devspace deployment has ready replicas
+            return devReadyReplicas > 0 && devReadyReplicas === devReplicas;
+        }
+        catch {
+            // Neither deployment exists or kubectl failed
+            return false;
+        }
+    }
+}

package/dist/lib/arkStatus.spec.d.ts

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

package/dist/lib/arkStatus.spec.js

@@ -0,0 +1,49 @@
+import { describe, it, expect, jest, beforeEach } from '@jest/globals';
+// Mock execa using unstable_mockModule
+jest.unstable_mockModule('execa', () => ({
+    execa: jest.fn(),
+}));
+// Dynamic imports after mock
+const { execa } = await import('execa');
+const { isArkReady } = await import('./arkStatus.js');
+describe('arkStatus with __mocks__', () => {
+    describe('isArkReady', () => {
+        beforeEach(() => {
+            jest.clearAllMocks();
+        });
+        it('should return true when ark-controller is deployed and ready', async () => {
+            // Mock successful kubectl response with ready deployment
+            const mockDeployment = {
+                metadata: { name: 'ark-controller' },
+                spec: { replicas: 3 },
+                status: {
+                    readyReplicas: 3,
+                    availableReplicas: 3,
+                },
+            };
+            execa.mockResolvedValue({
+                stdout: JSON.stringify(mockDeployment),
+                stderr: '',
+                exitCode: 0,
+                failed: false,
+            });
+            const result = await isArkReady();
+            expect(result).toBe(true);
+            expect(execa).toHaveBeenCalledWith('kubectl', [
+                'get',
+                'deployment',
+                'ark-controller',
+                '-n',
+                'ark-system',
+                '-o',
+                'json',
+            ], { stdio: 'pipe' });
+        });
+        it('should return false when kubectl fails', async () => {
+            // Mock kubectl failure
+            execa.mockRejectedValue(new Error('kubectl not found'));
+            const result = await isArkReady();
+            expect(result).toBe(false);
+        });
+    });
+});

package/dist/lib/chatClient.d.ts

@@ -0,0 +1,33 @@
+import { ArkApiClient, QueryTarget } from './arkApiClient.js';
+export { QueryTarget };
+export interface ChatConfig {
+    streamingEnabled: boolean;
+    currentTarget?: QueryTarget;
+}
+export interface ToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+export interface ArkMetadata {
+    agent?: string;
+    team?: string;
+    model?: string;
+    query?: string;
+    target?: string;
+}
+export declare class ChatClient {
+    private arkApiClient;
+    constructor(arkApiClient: ArkApiClient);
+    getQueryTargets(): Promise<QueryTarget[]>;
+    /**
+     * Send a chat completion request
+     */
+    sendMessage(targetId: string, messages: Array<{
+        role: 'user' | 'assistant' | 'system';
+        content: string;
+    }>, config: ChatConfig, onChunk?: (chunk: string, toolCalls?: ToolCall[], arkMetadata?: ArkMetadata) => void, signal?: AbortSignal): Promise<string>;
+}