@agents-at-scale/ark 0.1.31

package/dist/config.js

@@ -0,0 +1,243 @@
+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 { KubernetesConfigManager } from './lib/kubernetes.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.
+ *
+ * Example usage:
+ *   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();
+            const arkApiUrl = gatewayUrls['ark-api'];
+            if (arkApiUrl) {
+                debug('localhost-gateway detected, using: %s', arkApiUrl);
+                return arkApiUrl;
+            }
+        }
+        // Try to discover ark-api service via Kubernetes (requires kubeconfig)
+        await this.initKubernetesConfig();
+        if (this.kubeConfig) {
+            try {
+                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;
+            }
+            catch (error) {
+                debug('kubernetes discovery failed: %s', error instanceof Error ? error.message : error);
+                // Fall back to default if discovery fails
+            }
+        }
+        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
+     */
+    async isLocalhostGatewayRunning() {
+        try {
+            // Try to connect to the localhost gateway port
+            const response = await axios.get('http://127.0.0.1:8080', {
+                timeout: 2000,
+                validateStatus: () => true, // Accept any status code, we just want to know if it's reachable
+            });
+            debug('localhost-gateway check: available (status %d)', response.status);
+            return true;
+        }
+        catch (error) {
+            debug('localhost-gateway check: unavailable (%s)', error instanceof Error ? error.message : error);
+            // Gateway not responding - fall back to other discovery methods
+            return false;
+        }
+    }
+    /**
+     * 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;
+    }
+    async initKubernetesConfig() {
+        if (!this.kubeConfig) {
+            try {
+                this.kubeConfig = await this.kubernetesManager.initializeConfig();
+                debug('kubernetes config loaded: context=%s namespace=%s', this.kubeConfig?.currentContext, this.kubeConfig?.namespace);
+            }
+            catch (error) {
+                debug('kubernetes config unavailable: %s', error instanceof Error ? error.message : error);
+                // Kubernetes config not available - that's okay for some use cases
+                this.kubeConfig = null;
+            }
+        }
+    }
+    async getKubernetesConfig() {
+        await this.initKubernetesConfig();
+        return this.kubeConfig;
+    }
+    async testClusterAccess() {
+        await this.initKubernetesConfig();
+        if (!this.kubeConfig) {
+            return false;
+        }
+        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

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

package/dist/index.js

@@ -0,0 +1,67 @@
+#!/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 { createClusterCommand } from './commands/cluster/index.js';
+import { createCompletionCommand } from './commands/completion.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 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);
+    }
+}
+async function main() {
+    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);
+    // If no args provided, show interactive menu
+    if (process.argv.length === 2) {
+        console.log();
+        showMainMenu();
+        return;
+    }
+    await program.parseAsync(process.argv);
+}
+main().catch((error) => {
+    console.error(chalk.red('Failed to start ARK CLI:'), error);
+    process.exit(1);
+});

package/dist/lib/arkClient.d.ts

@@ -0,0 +1,32 @@
+export interface ArkService {
+    name: string;
+    namespace: string;
+    release_name: string;
+    chart_name: string;
+    chart_version: string;
+    description?: string;
+    routes?: HTTPRouteInfo[];
+    httproutes?: HTTPRouteInfo[];
+}
+export interface HTTPRouteInfo {
+    name: string;
+    namespace: string;
+    url: string;
+    rules: number;
+}
+export interface ArkServiceListResponse {
+    items: ArkService[];
+}
+export declare class ArkClient {
+    private client;
+    constructor(baseURL: string);
+    getBaseURL(): string;
+    /**
+     * Get ARK services and their discovered URLs from gateway routes
+     */
+    getArkServices(namespace?: string): Promise<ArkService[]>;
+    /**
+     * Test if the API is reachable
+     */
+    testConnection(): Promise<boolean>;
+}

package/dist/lib/arkClient.js

@@ -0,0 +1,43 @@
+import axios from 'axios';
+import { DEFAULT_TIMEOUT_MS, DEFAULT_CONNECTION_TEST_TIMEOUT_MS, } from './consts.js';
+export class ArkClient {
+    constructor(baseURL) {
+        this.client = axios.create({
+            baseURL,
+            timeout: DEFAULT_TIMEOUT_MS,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+    getBaseURL() {
+        return this.client.defaults.baseURL || '';
+    }
+    /**
+     * Get ARK services and their discovered URLs from gateway routes
+     */
+    async getArkServices(namespace = 'default') {
+        try {
+            const response = await this.client.get(`/v1/namespaces/${namespace}/ark-services`);
+            return response.data.items;
+        }
+        catch (_error) {
+            // If service discovery fails, return empty array to fall back to defaults
+            return [];
+        }
+    }
+    /**
+     * Test if the API is reachable
+     */
+    async testConnection() {
+        try {
+            await this.client.get('/health', {
+                timeout: DEFAULT_CONNECTION_TEST_TIMEOUT_MS,
+            });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}

package/dist/lib/cluster.d.ts

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

package/dist/lib/cluster.js

@@ -0,0 +1,134 @@
+import { executeCommand } from './exec.js';
+export async function detectClusterType() {
+    try {
+        const { stdout } = await executeCommand('kubectl', [
+            'config',
+            'current-context',
+        ]);
+        const context = stdout.trim();
+        if (context.includes('minikube')) {
+            return { type: 'minikube', context };
+        }
+        else if (context.includes('kind')) {
+            return { type: 'kind', context };
+        }
+        else if (context.includes('k3s')) {
+            return { type: 'k3s', context };
+        }
+        else if (context.includes('docker-desktop')) {
+            return { type: 'docker-desktop', context };
+        }
+        else if (context.includes('gke') ||
+            context.includes('eks') ||
+            context.includes('aks')) {
+            return { type: 'cloud', context };
+        }
+        else {
+            return { type: 'unknown', context };
+        }
+    }
+    catch (error) {
+        return { type: 'unknown', error: error.message };
+    }
+}
+export async function getClusterIp(_context) {
+    try {
+        const clusterInfo = await detectClusterType();
+        if (clusterInfo.error) {
+            return clusterInfo;
+        }
+        let ip;
+        switch (clusterInfo.type) {
+            case 'minikube':
+                try {
+                    const { stdout } = await executeCommand('minikube', ['ip']);
+                    ip = stdout.trim();
+                }
+                catch {
+                    // Fallback to kubectl if minikube command fails
+                    const { stdout } = await executeCommand('kubectl', [
+                        'get',
+                        'nodes',
+                        '-o',
+                        'jsonpath={.items[0].status.addresses[?(@.type=="InternalIP")].address}',
+                    ]);
+                    ip = stdout.trim();
+                }
+                break;
+            case 'kind': {
+                const { stdout: kindOutput } = await executeCommand('kubectl', [
+                    'get',
+                    'nodes',
+                    '-o',
+                    'jsonpath={.items[0].status.addresses[?(@.type=="InternalIP")].address}',
+                ]);
+                ip = kindOutput.trim();
+                break;
+            }
+            case 'docker-desktop':
+                ip = 'localhost';
+                break;
+            case 'k3s': {
+                const { stdout: k3sOutput } = await executeCommand('kubectl', [
+                    'get',
+                    'nodes',
+                    '-o',
+                    'jsonpath={.items[0].status.addresses[?(@.type=="InternalIP")].address}',
+                ]);
+                ip = k3sOutput.trim();
+                break;
+            }
+            case 'cloud':
+                // For cloud clusters, try to get the external IP or load balancer IP
+                try {
+                    const { stdout: lbOutput } = await executeCommand('kubectl', [
+                        'get',
+                        'svc',
+                        '-n',
+                        'istio-system',
+                        'istio-ingressgateway',
+                        '-o',
+                        'jsonpath={.status.loadBalancer.ingress[0].ip}',
+                    ]);
+                    ip = lbOutput.trim();
+                    if (!ip) {
+                        const { stdout: hostnameOutput } = await executeCommand('kubectl', [
+                            'get',
+                            'svc',
+                            '-n',
+                            'istio-system',
+                            'istio-ingressgateway',
+                            '-o',
+                            'jsonpath={.status.loadBalancer.ingress[0].hostname}',
+                        ]);
+                        ip = hostnameOutput.trim();
+                    }
+                }
+                catch {
+                    // Fallback to node IP
+                    const { stdout: nodeOutput } = await executeCommand('kubectl', [
+                        'get',
+                        'nodes',
+                        '-o',
+                        'jsonpath={.items[0].status.addresses[?(@.type=="ExternalIP")].address}',
+                    ]);
+                    ip = nodeOutput.trim();
+                }
+                break;
+            default: {
+                const { stdout: defaultOutput } = await executeCommand('kubectl', [
+                    'get',
+                    'nodes',
+                    '-o',
+                    'jsonpath={.items[0].status.addresses[?(@.type=="InternalIP")].address}',
+                ]);
+                ip = defaultOutput.trim();
+                break;
+            }
+        }
+        return { ...clusterInfo, ip };
+    }
+    catch (error) {
+        return { type: 'unknown', error: error.message };
+    }
+}

package/dist/lib/config.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Configuration management for ARK CLI
+ */
+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;
+}