@agents-at-scale/ark 0.1.35-rc2 → 0.1.35

package/dist/config.js

@@ -1,22 +1,118 @@
+import { promises as fs } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
 import axios from 'axios';
 import Debug from 'debug';
-import { DEFAULT_ADDRESS_ARK_API } from './lib/consts.js';
+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 { KubernetesConfigManager } from './lib/kubernetes.js';
-import { getStatusCheckableServices } from './arkServices.js';
 const debug = Debug('ark:config');
 /**
- * ConfigManager handles API URL discovery and cluster access testing.
- * Complex discovery logic can be debugged by setting 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.
  *
  * Example usage:
- *   DEBUG=ark:config ark status
+ *   DEBUG=ark:config ark check status
+ *   DEBUG=ark:* ark dashboard
  */
 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();
@@ -30,7 +126,7 @@ export class ConfigManager {
         await this.initKubernetesConfig();
         if (this.kubeConfig) {
             try {
-                const namespace = 'default';
+                const namespace = config.kubeNamespace || config.defaultNamespace || 'default';
                 const discoveredUrl = await this.kubernetesManager.getArkApiUrl(namespace);
                 debug('kubernetes discovery successful in %s: %s', namespace, discoveredUrl);
                 return discoveredUrl;
@@ -40,8 +136,9 @@ export class ConfigManager {
                 // Fall back to default if discovery fails
             }
         }
-        debug('falling back to default: %s', DEFAULT_ADDRESS_ARK_API);
-        return DEFAULT_ADDRESS_ARK_API;
+        const fallbackUrl = config.apiBaseUrl || DEFAULT_ADDRESS_ARK_API;
+        debug('falling back to default: %s', fallbackUrl);
+        return fallbackUrl;
     }
     /**
      * Check if localhost-gateway is running by testing port 8080
@@ -66,8 +163,16 @@ export class ConfigManager {
      * Construct standard localhost-gateway URLs for known ARK services
      */
     getLocalhostGatewayUrls() {
-        // Use centralized service definitions from arkServices
-        return getStatusCheckableServices();
+        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;
     }
     async initKubernetesConfig() {
         if (!this.kubeConfig) {
@@ -82,6 +187,10 @@ export class ConfigManager {
             }
         }
     }
+    async getKubernetesConfig() {
+        await this.initKubernetesConfig();
+        return this.kubeConfig;
+    }
     async testClusterAccess() {
         await this.initKubernetesConfig();
         if (!this.kubeConfig) {
@@ -89,4 +198,46 @@ 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_NO_WARNINGS=1 node
+#!/usr/bin/env node
 export {};

package/dist/index.js

@@ -1,69 +1,67 @@
-#!/usr/bin/env NODE_NO_WARNINGS=1 node
+#!/usr/bin/env 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/index.js';
-import { createDashboardCommand } from './commands/dashboard/index.js';
-import { createDocsCommand } from './commands/docs/index.js';
-import { createDevCommand } from './commands/dev/index.js';
+import { createCompletionCommand } from './commands/completion.js';
 import { createGenerateCommand } from './commands/generate/index.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 { createConfigCommand } from './commands/config.js';
+import { StatusChecker } from './components/statusChecker.js';
+import { ConfigManager } from './config.js';
+import { ArkClient } from './lib/arkClient.js';
 import MainMenu from './ui/MainMenu.js';
-function showMainMenu(config) {
-    const app = render(_jsx(MainMenu, { config: config }));
-    globalThis.inkApp = app;
+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);
+    }
 }
 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(createAgentsCommand(config));
-    program.addCommand(createChatCommand(config));
-    program.addCommand(createClusterCommand(config));
-    program.addCommand(createCompletionCommand(config));
-    program.addCommand(createDashboardCommand(config));
-    program.addCommand(createDocsCommand(config));
-    program.addCommand(createDevCommand(config));
-    program.addCommand(createGenerateCommand(config));
-    program.addCommand(createInstallCommand(config));
-    program.addCommand(createModelsCommand(config));
-    program.addCommand(createQueryCommand(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));
+    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);
     // If no args provided, show interactive menu
     if (process.argv.length === 2) {
-        showMainMenu(config);
+        console.log();
+        showMainMenu();
         return;
     }
     await program.parseAsync(process.argv);
 }
 main().catch((error) => {
-    output.error('failed to start ark cli: ', error);
+    console.error(chalk.red('Failed to start ARK CLI:'), error);
     process.exit(1);
 });

package/dist/lib/cluster.d.ts

@@ -2,8 +2,7 @@ export interface ClusterInfo {
     type: 'minikube' | 'kind' | 'k3s' | 'docker-desktop' | 'cloud' | 'unknown';
     ip?: string;
     context?: string;
-    namespace?: string;
     error?: string;
 }
 export declare function detectClusterType(): Promise<ClusterInfo>;
-export declare function getClusterInfo(context?: string): Promise<ClusterInfo>;
+export declare function getClusterIp(_context?: string): Promise<ClusterInfo>;

package/dist/lib/cluster.js

@@ -1,7 +1,10 @@
-import { execa } from 'execa';
+import { executeCommand } from './exec.js';
 export async function detectClusterType() {
     try {
-        const { stdout } = await execa('kubectl', ['config', 'current-context']);
+        const { stdout } = await executeCommand('kubectl', [
+            'config',
+            'current-context',
+        ]);
         const context = stdout.trim();
         if (context.includes('minikube')) {
             return { type: 'minikube', context };
@@ -25,33 +28,12 @@ export async function detectClusterType() {
         }
     }
     catch (error) {
-        return {
-            type: 'unknown',
-            error: error instanceof Error ? error.message : 'Unknown error',
-        };
+        return { type: 'unknown', error: error.message };
     }
 }
-export async function getClusterInfo(context) {
+export async function getClusterIp(_context) {
     try {
-        // If context is provided, use it
-        const contextArgs = context ? ['--context', context] : [];
-        // Get all config info in one command
-        const { stdout: configJson } = await execa('kubectl', [
-            'config',
-            'view',
-            '--minify',
-            '-o',
-            'json',
-            ...contextArgs,
-        ]);
-        const config = JSON.parse(configJson);
-        const currentContext = config['current-context'] || '';
-        const contextData = config.contexts?.find((c) => c.name === currentContext);
-        const namespace = contextData?.context?.namespace || 'default';
-        // Detect cluster type from context name
         const clusterInfo = await detectClusterType();
-        clusterInfo.context = currentContext;
-        clusterInfo.namespace = namespace;
         if (clusterInfo.error) {
             return clusterInfo;
         }
@@ -59,12 +41,12 @@ export async function getClusterInfo(context) {
         switch (clusterInfo.type) {
             case 'minikube':
                 try {
-                    const { stdout } = await execa('minikube', ['ip']);
+                    const { stdout } = await executeCommand('minikube', ['ip']);
                     ip = stdout.trim();
                 }
                 catch {
                     // Fallback to kubectl if minikube command fails
-                    const { stdout } = await execa('kubectl', [
+                    const { stdout } = await executeCommand('kubectl', [
                         'get',
                         'nodes',
                         '-o',
@@ -74,7 +56,7 @@ export async function getClusterInfo(context) {
                 }
                 break;
             case 'kind': {
-                const { stdout: kindOutput } = await execa('kubectl', [
+                const { stdout: kindOutput } = await executeCommand('kubectl', [
                     'get',
                     'nodes',
                     '-o',
@@ -87,7 +69,7 @@ export async function getClusterInfo(context) {
                 ip = 'localhost';
                 break;
             case 'k3s': {
-                const { stdout: k3sOutput } = await execa('kubectl', [
+                const { stdout: k3sOutput } = await executeCommand('kubectl', [
                     'get',
                     'nodes',
                     '-o',
@@ -99,7 +81,7 @@ export async function getClusterInfo(context) {
             case 'cloud':
                 // For cloud clusters, try to get the external IP or load balancer IP
                 try {
-                    const { stdout: lbOutput } = await execa('kubectl', [
+                    const { stdout: lbOutput } = await executeCommand('kubectl', [
                         'get',
                         'svc',
                         '-n',
@@ -110,7 +92,7 @@ export async function getClusterInfo(context) {
                     ]);
                     ip = lbOutput.trim();
                     if (!ip) {
-                        const { stdout: hostnameOutput } = await execa('kubectl', [
+                        const { stdout: hostnameOutput } = await executeCommand('kubectl', [
                             'get',
                             'svc',
                             '-n',
@@ -124,7 +106,7 @@ export async function getClusterInfo(context) {
                 }
                 catch {
                     // Fallback to node IP
-                    const { stdout: nodeOutput } = await execa('kubectl', [
+                    const { stdout: nodeOutput } = await executeCommand('kubectl', [
                         'get',
                         'nodes',
                         '-o',
@@ -134,7 +116,7 @@ export async function getClusterInfo(context) {
                 }
                 break;
             default: {
-                const { stdout: defaultOutput } = await execa('kubectl', [
+                const { stdout: defaultOutput } = await executeCommand('kubectl', [
                     'get',
                     'nodes',
                     '-o',
@@ -147,9 +129,6 @@ export async function getClusterInfo(context) {
         return { ...clusterInfo, ip };
     }
     catch (error) {
-        return {
-            type: 'unknown',
-            error: error instanceof Error ? error.message : 'Unknown error',
-        };
+        return { type: 'unknown', error: error.message };
     }
 }

package/dist/lib/config.d.ts

@@ -1,30 +1,82 @@
-import type { ClusterInfo } from './cluster.js';
-export interface ChatConfig {
-    streaming?: boolean;
-    outputFormat?: 'text' | 'markdown';
-}
-export interface ArkConfig {
-    chat?: ChatConfig;
-    latestVersion?: string;
-    currentVersion?: string;
-    clusterInfo?: ClusterInfo;
-}
-/**
- * Load configuration from multiple sources with proper precedence:
- * 1. Defaults
- * 2. ~/.arkrc.yaml (user config)
- * 3. .arkrc.yaml (project config)
- * 4. Environment variables (override all)
- */
-export declare function loadConfig(): ArkConfig;
 /**
- * Get the paths checked for config files
+ * Configuration management for ARK CLI
  */
-export declare function getConfigPaths(): {
-    user: string;
-    project: string;
-};
-/**
- * Format config as YAML for display
- */
-export declare function formatConfig(config: ArkConfig): string;
+export interface ArkConfig {
+    defaultProjectType: 'empty' | 'with-samples';
+    defaultDestination: string;
+    skipGitByDefault: boolean;
+    skipModelsbyDefault: boolean;
+    preferredEditor: string;
+    colorOutput: boolean;
+    verboseOutput: boolean;
+    defaultModelProvider: 'azure' | 'openai' | 'claude' | 'gemini' | 'custom';
+    templateDirectory?: string;
+    customTemplates: Record<string, string>;
+    parallelOperations: boolean;
+    maxConcurrentFiles: number;
+    fileWatchingEnabled: boolean;
+    telemetryEnabled: boolean;
+    errorReporting: boolean;
+}
+export declare const DEFAULT_CONFIG: ArkConfig;
+export declare class ConfigManager {
+    private configPath;
+    private config;
+    constructor();
+    /**
+     * Get the path to the configuration file
+     */
+    private getConfigPath;
+    /**
+     * Load configuration from file or create with defaults
+     */
+    private loadConfig;
+    /**
+     * Save configuration to file
+     */
+    private saveConfig;
+    /**
+     * Get the current configuration
+     */
+    getConfig(): ArkConfig;
+    /**
+     * Update configuration
+     */
+    updateConfig(updates: Partial<ArkConfig>): void;
+    /**
+     * Reset configuration to defaults
+     */
+    resetConfig(): void;
+    /**
+     * Get a specific configuration value
+     */
+    get<K extends keyof ArkConfig>(key: K): ArkConfig[K];
+    /**
+     * Set a specific configuration value
+     */
+    set<K extends keyof ArkConfig>(key: K, value: ArkConfig[K]): void;
+    /**
+     * Validate configuration values
+     */
+    validateConfig(): void;
+    /**
+     * Get environment variable overrides
+     */
+    getEnvironmentOverrides(): Partial<ArkConfig>;
+    /**
+     * Get merged configuration with environment overrides
+     */
+    getMergedConfig(): ArkConfig;
+    /**
+     * Export configuration for backup
+     */
+    exportConfig(): string;
+    /**
+     * Import configuration from backup
+     */
+    importConfig(configJson: string): void;
+    /**
+     * Get configuration file path for CLI display
+     */
+    getConfigFilePath(): string;
+}