@agents-at-scale/ark 0.1.34 → 0.1.35-rc1

package/dist/config.js

@@ -1,118 +1,22 @@
-import { promises as fs } from 'fs';
-import { homedir } from 'os';
-import { join } from 'path';
 import axios from 'axios';
 import Debug from 'debug';
-import { ArkClient } from './lib/arkClient.js';
-import { DEFAULT_ADDRESS_ARK_API, CONFIG_DIR_NAME, CONFIG_FILE_NAME, } from './lib/consts.js';
-import { GatewayManager } from './lib/gatewayManager.js';
+import { DEFAULT_ADDRESS_ARK_API } from './lib/consts.js';
 import { KubernetesConfigManager } from './lib/kubernetes.js';
+import { getStatusCheckableServices } from './arkServices.js';
 const debug = Debug('ark:config');
 /**
- * ConfigManager handles ARK CLI configuration with automatic service discovery
- * and multiple fallback mechanisms. Complex discovery logic can be debugged by
- * setting DEBUG=ark:config or DEBUG=ark:* environment variable.
+ * ConfigManager handles API URL discovery and cluster access testing.
+ * Complex discovery logic can be debugged by setting DEBUG=ark:config
  *
  * Example usage:
- *   DEBUG=ark:config ark check status
- *   DEBUG=ark:* ark dashboard
+ *   DEBUG=ark:config ark status
  */
 export class ConfigManager {
     constructor() {
         this.kubeConfig = null;
-        this.configDir = join(homedir(), '.config', CONFIG_DIR_NAME);
-        this.configFile = join(this.configDir, CONFIG_FILE_NAME);
         this.kubernetesManager = new KubernetesConfigManager();
-        this.gatewayManager = new GatewayManager();
-    }
-    async ensureConfigDir() {
-        try {
-            await fs.mkdir(this.configDir, { recursive: true });
-        }
-        catch (_error) {
-            // Directory might already exist
-        }
-    }
-    async loadConfig() {
-        await this.ensureConfigDir();
-        try {
-            // Check if config file exists
-            await fs.access(this.configFile);
-        }
-        catch (error) {
-            // Config file doesn't exist - start with default config and enrich with kube config
-            if (error &&
-                typeof error === 'object' &&
-                'code' in error &&
-                error.code === 'ENOENT') {
-                return await this.getDefaultConfig();
-            }
-            // Other access errors (permissions, etc.) should be thrown
-            throw error;
-        }
-        try {
-            // Config file exists - try to read and parse it
-            const data = await fs.readFile(this.configFile, 'utf-8');
-            const config = JSON.parse(data);
-            // Merge with current Kubernetes config if not present
-            await this.initKubernetesConfig();
-            return {
-                ...config,
-                kubeconfig: config.kubeconfig || this.kubeConfig?.kubeconfig,
-                currentContext: config.currentContext || this.kubeConfig?.currentContext,
-                kubeNamespace: config.kubeNamespace || this.kubeConfig?.namespace,
-            };
-        }
-        catch (error) {
-            // If it's a JSON parsing error, throw a clear error message
-            if (error instanceof SyntaxError) {
-                throw new Error(`Invalid JSON in config file ${this.configFile}: ${error.message}`);
-            }
-            // Other errors (read errors, etc.) should be thrown as-is
-            throw error;
-        }
-    }
-    async saveConfig(config) {
-        await this.ensureConfigDir();
-        const jsonData = JSON.stringify(config, null, 2);
-        await fs.writeFile(this.configFile, jsonData);
-    }
-    async updateConfig(updates) {
-        const currentConfig = await this.loadConfig();
-        const newConfig = { ...currentConfig, ...updates };
-        await this.saveConfig(newConfig);
-        return newConfig;
-    }
-    async getDefaultConfig() {
-        // Initialize Kubernetes config to get defaults
-        await this.initKubernetesConfig();
-        return {
-            defaultAgent: 'default',
-            defaultModel: 'default',
-            defaultNamespace: this.kubeConfig?.namespace || 'default',
-            apiBaseUrl: DEFAULT_ADDRESS_ARK_API,
-            kubeconfig: this.kubeConfig?.kubeconfig,
-            currentContext: this.kubeConfig?.currentContext,
-            kubeNamespace: this.kubeConfig?.namespace,
-        };
-    }
-    async initializeConfig() {
-        const config = await this.loadConfig();
-        const defaultConfig = await this.getDefaultConfig();
-        const mergedConfig = { ...defaultConfig, ...config };
-        await this.saveConfig(mergedConfig);
-        return mergedConfig;
-    }
-    getConfigPath() {
-        return this.configFile;
     }
     async getApiBaseUrl() {
-        const config = await this.loadConfig();
-        // If apiBaseUrl is explicitly set in config, use it
-        if (config.apiBaseUrl && config.apiBaseUrl !== DEFAULT_ADDRESS_ARK_API) {
-            debug('using explicit config apiBaseUrl: %s', config.apiBaseUrl);
-            return config.apiBaseUrl;
-        }
         // First try to detect localhost-gateway (works for everyone with standard setup)
         if (await this.isLocalhostGatewayRunning()) {
             const gatewayUrls = this.getLocalhostGatewayUrls();
@@ -126,7 +30,7 @@ export class ConfigManager {
         await this.initKubernetesConfig();
         if (this.kubeConfig) {
             try {
-                const namespace = config.kubeNamespace || config.defaultNamespace || 'default';
+                const namespace = 'default';
                 const discoveredUrl = await this.kubernetesManager.getArkApiUrl(namespace);
                 debug('kubernetes discovery successful in %s: %s', namespace, discoveredUrl);
                 return discoveredUrl;
@@ -136,9 +40,8 @@ export class ConfigManager {
                 // Fall back to default if discovery fails
             }
         }
-        const fallbackUrl = config.apiBaseUrl || DEFAULT_ADDRESS_ARK_API;
-        debug('falling back to default: %s', fallbackUrl);
-        return fallbackUrl;
+        debug('falling back to default: %s', DEFAULT_ADDRESS_ARK_API);
+        return DEFAULT_ADDRESS_ARK_API;
     }
     /**
      * Check if localhost-gateway is running by testing port 8080
@@ -163,16 +66,8 @@ export class ConfigManager {
      * Construct standard localhost-gateway URLs for known ARK services
      */
     getLocalhostGatewayUrls() {
-        const port = 8080;
-        // Known services that are typically exposed via localhost-gateway
-        const knownServices = {
-            'ark-api': `http://ark-api.127.0.0.1.nip.io:${port}`,
-            'ark-dashboard': `http://dashboard.127.0.0.1.nip.io:${port}`,
-            'ark-api-a2a': `http://ark-api-a2a.127.0.0.1.nip.io:${port}`,
-            langfuse: `http://langfuse.telemetry.127.0.0.1.nip.io:${port}`, // Fixed URL to match HTTPRoute
-            // Add other services as they become available via gateway
-        };
-        return knownServices;
+        // Use centralized service definitions from arkServices
+        return getStatusCheckableServices();
     }
     async initKubernetesConfig() {
         if (!this.kubeConfig) {
@@ -187,10 +82,6 @@ export class ConfigManager {
             }
         }
     }
-    async getKubernetesConfig() {
-        await this.initKubernetesConfig();
-        return this.kubeConfig;
-    }
     async testClusterAccess() {
         await this.initKubernetesConfig();
         if (!this.kubeConfig) {
@@ -198,46 +89,4 @@ export class ConfigManager {
         }
         return await this.kubernetesManager.testClusterAccess();
     }
-    /**
-     * Discover service URLs from ark-api service discovery
-     */
-    async discoverServicesFromApi() {
-        try {
-            const apiBaseUrl = await this.getApiBaseUrl();
-            const arkClient = new ArkClient(apiBaseUrl);
-            const config = await this.loadConfig();
-            const namespace = config.kubeNamespace || config.defaultNamespace || 'default';
-            debug('service discovery: querying ark-api at %s (namespace: %s)', apiBaseUrl, namespace);
-            const services = await arkClient.getArkServices(namespace);
-            const serviceUrls = {};
-            // Dynamically map all discovered services with HTTP routes
-            for (const service of services) {
-                if (service.httproutes && service.httproutes.length > 0) {
-                    const serviceName = service.release_name || service.name;
-                    const serviceUrl = service.httproutes[0].url; // Use first route URL
-                    serviceUrls[serviceName] = serviceUrl;
-                }
-            }
-            const discoveredServices = Object.entries(serviceUrls).map(([key, url]) => `${key}: ${url}`);
-            debug('service discovery: found %d services - %s', discoveredServices.length, discoveredServices.join(', ') || 'none');
-            return serviceUrls;
-        }
-        catch (error) {
-            debug('service discovery failed: %s', error instanceof Error ? error.message : error);
-            // Return empty object if discovery fails - will fall back to config/defaults
-            return {};
-        }
-    }
-    async getServiceUrls() {
-        // Try localhost-gateway detection (works for everyone with standard setup)
-        if (await this.isLocalhostGatewayRunning()) {
-            const gatewayUrls = this.getLocalhostGatewayUrls();
-            debug('localhost-gateway detected, using: %o', gatewayUrls);
-            return gatewayUrls;
-        }
-        // Try to discover services from ark-api (requires kubeconfig)
-        const discoveredUrls = await this.discoverServicesFromApi();
-        debug('discovered services: %o', discoveredUrls);
-        return discoveredUrls;
-    }
 }

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,67 +1,65 @@
-#!/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 { createDevCommand } from './commands/dev/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 { 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(createDevCommand(config));
+    program.addCommand(createGenerateCommand(config));
+    program.addCommand(createInstallCommand(config));
+    program.addCommand(createModelsCommand(config));
+    program.addCommand(createUninstallCommand(config));
+    program.addCommand(createStatusCommand(config));
+    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>;