@agents-at-scale/ark 0.1.35-rc.1 → 0.1.35-rc2

package/dist/components/statusChecker.js

@@ -1,11 +1,7 @@
-import { exec } from 'child_process';
-import { promisify } from 'util';
-import { KubernetesConfigManager } from '../lib/kubernetes.js';
-import * as k8s from '@kubernetes/client-node';
-import { isCommandAvailable } from '../lib/commandUtils.js';
+import { execa } from 'execa';
+import { checkCommandExists } from '../lib/commands.js';
 import { arkServices } from '../arkServices.js';
 import { isArkReady } from '../lib/arkStatus.js';
-const execAsync = promisify(exec);
 export const getNodeVersion = () => ({
     command: 'node',
     versionArgs: '--version',
@@ -66,30 +62,62 @@ function createErrorServiceStatus(name, url, error, defaultStatus = 'unhealthy',
     };
 }
 export class StatusChecker {
-    constructor(arkClient) {
-        this.arkClient = arkClient;
-        this.kubernetesManager = new KubernetesConfigManager();
-    }
     /**
      * Get version of a command
      */
     async getCommandVersion(config) {
         try {
-            const cmd = `${config.command} ${config.versionArgs}`;
-            const { stdout } = await execAsync(cmd);
+            const args = config.versionArgs.split(' ');
+            const { stdout } = await execa(config.command, args);
             return config.versionExtract(stdout);
         }
         catch (error) {
             throw new Error(`Failed to get ${config.command} version: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
+    /**
+     * Check combined deployment and helm status
+     * Gets health from deployment, version/revision from Helm
+     */
+    async checkCombinedStatus(serviceName, deploymentName, helmReleaseName, namespace, devDeploymentName) {
+        // Get deployment status for health
+        const deploymentStatus = await this.checkDeploymentStatus(serviceName, deploymentName, namespace, devDeploymentName);
+        // Try to get version info from Helm if it's a healthy deployment
+        if (deploymentStatus.status === 'healthy' ||
+            deploymentStatus.status === 'warning') {
+            try {
+                const { stdout } = await execa('helm', ['list', '-n', namespace, '-o', 'json'], { timeout: 5000 });
+                const releases = JSON.parse(stdout);
+                const release = releases.find((r) => r.name === helmReleaseName);
+                if (release) {
+                    // Merge Helm version info into deployment status
+                    return {
+                        ...deploymentStatus,
+                        version: release.app_version,
+                        revision: release.revision,
+                    };
+                }
+            }
+            catch {
+                // If Helm check fails, return deployment status as-is
+            }
+        }
+        return deploymentStatus;
+    }
     /**
      * Check deployment status
      */
-    async checkDeploymentStatus(serviceName, deploymentName, namespace) {
+    async checkDeploymentStatus(serviceName, deploymentName, namespace, devDeploymentName) {
         try {
-            const cmd = `kubectl get deployment ${deploymentName} --namespace ${namespace} -o json`;
-            const { stdout } = await execAsync(cmd);
+            const { stdout } = await execa('kubectl', [
+                'get',
+                'deployment',
+                deploymentName,
+                '--namespace',
+                namespace,
+                '-o',
+                'json',
+            ]);
             const deployment = JSON.parse(stdout);
             const replicas = deployment.spec?.replicas || 0;
             const readyReplicas = deployment.status?.readyReplicas || 0;
@@ -109,19 +137,113 @@ export class StatusChecker {
             else {
                 status = 'warning';
             }
+            // If main deployment has 0 replicas and we have a dev deployment, check it
+            if (replicas === 0 && devDeploymentName) {
+                try {
+                    const { stdout: devStdout } = await execa('kubectl', [
+                        'get',
+                        'deployment',
+                        devDeploymentName,
+                        '--namespace',
+                        namespace,
+                        '-o',
+                        'json',
+                    ]);
+                    const devDeployment = JSON.parse(devStdout);
+                    const devReplicas = devDeployment.spec?.replicas || 0;
+                    const devReadyReplicas = devDeployment.status?.readyReplicas || 0;
+                    const devAvailableReplicas = devDeployment.status?.availableReplicas || 0;
+                    if (devReplicas > 0) {
+                        const devAvailableCondition = devDeployment.status?.conditions?.find((condition) => condition.type === 'Available');
+                        const devIsAvailable = devAvailableCondition?.status === 'True';
+                        const devAllReplicasReady = devReadyReplicas === devReplicas &&
+                            devAvailableReplicas === devReplicas;
+                        let devStatus;
+                        if (devReplicas === 0 || devReadyReplicas === 0) {
+                            devStatus = 'not ready';
+                        }
+                        else if (devIsAvailable && devAllReplicasReady) {
+                            devStatus = 'healthy';
+                        }
+                        else {
+                            devStatus = 'warning';
+                        }
+                        return {
+                            name: serviceName,
+                            status: devStatus,
+                            details: `${devReadyReplicas}/${devReplicas} replicas ready`,
+                            isDev: true,
+                            namespace,
+                        };
+                    }
+                }
+                catch {
+                    // If dev deployment check fails, return the original status
+                }
+            }
             return {
                 name: serviceName,
                 status,
                 details: `${readyReplicas}/${replicas} replicas ready`,
+                namespace,
             };
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            if (errorMessage.includes('not found')) {
+            // If main deployment not found or not healthy, try dev deployment
+            if (errorMessage.includes('not found') ||
+                errorMessage.includes('NotFound')) {
+                if (devDeploymentName) {
+                    try {
+                        const { stdout } = await execa('kubectl', [
+                            'get',
+                            'deployment',
+                            devDeploymentName,
+                            '--namespace',
+                            namespace,
+                            '-o',
+                            'json',
+                        ]);
+                        const devDeployment = JSON.parse(stdout);
+                        const replicas = devDeployment.spec?.replicas || 0;
+                        const readyReplicas = devDeployment.status?.readyReplicas || 0;
+                        const availableReplicas = devDeployment.status?.availableReplicas || 0;
+                        const availableCondition = devDeployment.status?.conditions?.find((condition) => condition.type === 'Available');
+                        const isAvailable = availableCondition?.status === 'True';
+                        const allReplicasReady = readyReplicas === replicas && availableReplicas === replicas;
+                        let status;
+                        if (replicas === 0 || readyReplicas === 0) {
+                            status = 'not ready';
+                        }
+                        else if (isAvailable && allReplicasReady) {
+                            status = 'healthy';
+                        }
+                        else {
+                            status = 'warning';
+                        }
+                        return {
+                            name: serviceName,
+                            status,
+                            details: `${readyReplicas}/${replicas} replicas ready`,
+                            isDev: true,
+                            namespace,
+                        };
+                    }
+                    catch {
+                        // If dev deployment also not found, return not installed
+                        return {
+                            name: serviceName,
+                            status: 'not installed',
+                            details: `Deployment '${deploymentName}' not found`,
+                            namespace,
+                        };
+                    }
+                }
                 return {
                     name: serviceName,
                     status: 'not installed',
-                    details: `Deployment '${deploymentName}' not found in namespace '${namespace}'`,
+                    details: `Deployment '${deploymentName}' not found`,
+                    namespace,
                 };
             }
             return createErrorServiceStatus(serviceName, '', error, 'unhealthy', `Failed to check deployment: ${errorMessage}`);
@@ -132,14 +254,22 @@ export class StatusChecker {
      */
     async checkHelmStatus(serviceName, helmReleaseName, namespace) {
         try {
-            const cmd = `helm list --filter ${helmReleaseName} --namespace ${namespace} --output json`;
-            const { stdout } = await execAsync(cmd);
+            const { stdout } = await execa('helm', [
+                'list',
+                '--filter',
+                helmReleaseName,
+                '--namespace',
+                namespace,
+                '--output',
+                'json',
+            ]);
             const helmList = JSON.parse(stdout);
             if (helmList.length === 0) {
                 return {
                     name: serviceName,
                     status: 'not installed',
-                    details: `Helm release '${helmReleaseName}' not found in namespace '${namespace}'`,
+                    details: `Helm release '${helmReleaseName}' not found`,
+                    namespace,
                 };
             }
             const release = helmList[0];
@@ -153,6 +283,7 @@ export class StatusChecker {
                 version: appVersion,
                 revision: revision,
                 details: `Status: ${status}`,
+                namespace,
             };
         }
         catch (error) {
@@ -160,69 +291,6 @@ export class StatusChecker {
             return createErrorServiceStatus(serviceName, '', error, 'unhealthy', `Failed to check helm status: ${errorMessage}`);
         }
     }
-    /**
-     * Return a "not installed" status for a service
-     */
-    createNotInstalledStatus(serviceName) {
-        return {
-            name: serviceName,
-            status: 'not installed',
-            details: `${serviceName} is not configured or not part of this deployment`,
-        };
-    }
-    /**
-     * Check Kubernetes service health via pods and endpoints
-     */
-    async checkKubernetesService(serviceName, kubernetesServiceName, namespace = 'default') {
-        try {
-            await this.kubernetesManager.initializeConfig();
-            const kc = this.kubernetesManager.getKubeConfig();
-            const k8sApi = kc.makeApiClient(k8s.CoreV1Api);
-            // Check if service exists and has endpoints
-            const service = await k8sApi.readNamespacedService({
-                name: kubernetesServiceName,
-                namespace,
-            });
-            const endpoints = await k8sApi.readNamespacedEndpoints({
-                name: kubernetesServiceName,
-                namespace,
-            });
-            // Check if service has ready endpoints
-            const readyAddresses = endpoints.subsets?.reduce((total, subset) => {
-                return total + (subset.addresses?.length || 0);
-            }, 0) || 0;
-            if (readyAddresses > 0) {
-                const serviceIP = service.spec?.clusterIP;
-                const servicePort = service.spec?.ports?.[0]?.port;
-                return {
-                    name: serviceName,
-                    status: 'healthy',
-                    url: `cluster://${serviceIP}:${servicePort}`,
-                    details: `${serviceName} running in cluster (${readyAddresses} ready endpoints)`,
-                };
-            }
-            else {
-                return {
-                    name: serviceName,
-                    status: 'unhealthy',
-                    details: `${serviceName} service exists but has no ready endpoints`,
-                };
-            }
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            // If service not found, it's not installed
-            if (errorMessage.includes('not found')) {
-                return this.createNotInstalledStatus(serviceName);
-            }
-            // Other errors indicate unhealthy
-            return {
-                name: serviceName,
-                status: 'unhealthy',
-                details: `Failed to check ${serviceName}: ${errorMessage}`,
-            };
-        }
-    }
     /**
      * Check system dependencies
      */
@@ -238,7 +306,8 @@ export class StatusChecker {
         ];
         const results = [];
         for (const dep of dependencies) {
-            const installed = await isCommandAvailable(dep.command);
+            const args = dep.versionArgs.split(' ');
+            const installed = await checkCommandExists(dep.command, args);
             const version = installed
                 ? await this.getCommandVersion({
                     command: dep.command,
@@ -264,8 +333,16 @@ export class StatusChecker {
         // Check dependencies first
         const dependencies = await this.checkDependencies();
         // Test cluster access
-        const configManager = new (await import('../config.js')).ConfigManager();
-        const clusterAccess = await configManager.testClusterAccess();
+        let clusterAccess = false;
+        try {
+            await execa('kubectl', ['get', 'namespaces', '-o', 'name'], {
+                timeout: 5000,
+            });
+            clusterAccess = true;
+        }
+        catch {
+            clusterAccess = false;
+        }
         // Get cluster info if accessible
         let clusterInfo;
         if (clusterAccess) {
@@ -277,11 +354,17 @@ export class StatusChecker {
         if (clusterAccess) {
             const serviceChecks = [];
             for (const [serviceName, service] of Object.entries(arkServices)) {
+                // Skip disabled services
+                if (!service.enabled)
+                    continue;
+                // Use service namespace if defined, otherwise use current namespace from clusterInfo
+                const namespace = service.namespace || clusterInfo?.namespace || 'default';
                 if (service.k8sDeploymentName) {
-                    serviceChecks.push(this.checkDeploymentStatus(serviceName, service.k8sDeploymentName, service.namespace));
+                    // For deployments, get health from deployment and version from Helm
+                    serviceChecks.push(this.checkCombinedStatus(serviceName, service.k8sDeploymentName, service.helmReleaseName, namespace, service.k8sDevDeploymentName));
                 }
                 else {
-                    serviceChecks.push(this.checkHelmStatus(serviceName, service.helmReleaseName, service.namespace));
+                    serviceChecks.push(this.checkHelmStatus(serviceName, service.helmReleaseName, namespace));
                 }
             }
             services = await Promise.all(serviceChecks);
@@ -289,16 +372,35 @@ export class StatusChecker {
         // Check if ARK is ready (controller is running)
         let arkReady = false;
         let defaultModelExists = false;
+        let defaultModel;
         if (clusterAccess) {
             arkReady = await isArkReady();
-            // Check for default model
+            // Check for default model with detailed status
             if (arkReady) {
                 try {
-                    await execAsync('kubectl get model default -o name');
+                    const { stdout } = await execa('kubectl', [
+                        'get',
+                        'model',
+                        'default',
+                        '-o',
+                        'json',
+                    ]);
+                    const model = JSON.parse(stdout);
                     defaultModelExists = true;
+                    // Extract model details
+                    const available = model.status?.conditions?.find((c) => c.type === 'Available')?.status === 'True';
+                    defaultModel = {
+                        exists: true,
+                        available,
+                        provider: model.spec?.provider,
+                        details: model.spec?.model || model.spec?.apiEndpoint,
+                    };
                 }
                 catch {
                     defaultModelExists = false;
+                    defaultModel = {
+                        exists: false,
+                    };
                 }
             }
         }
@@ -309,6 +411,7 @@ export class StatusChecker {
             clusterInfo,
             arkReady,
             defaultModelExists,
+            defaultModel,
         };
     }
 }

package/dist/config.d.ts

@@ -1,27 +1,14 @@
-import { ArkConfig, KubernetesConfig } from './lib/types.js';
 /**
- * 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 declare class ConfigManager {
-    private configDir;
-    private configFile;
     private kubernetesManager;
-    private gatewayManager;
     private kubeConfig;
     constructor();
-    ensureConfigDir(): Promise<void>;
-    loadConfig(): Promise<ArkConfig>;
-    saveConfig(config: ArkConfig): Promise<void>;
-    updateConfig(updates: Partial<ArkConfig>): Promise<ArkConfig>;
-    private getDefaultConfig;
-    initializeConfig(): Promise<ArkConfig>;
-    getConfigPath(): string;
     getApiBaseUrl(): Promise<string>;
     /**
      * Check if localhost-gateway is running by testing port 8080
@@ -32,11 +19,5 @@ export declare class ConfigManager {
      */
     private getLocalhostGatewayUrls;
     private initKubernetesConfig;
-    getKubernetesConfig(): Promise<KubernetesConfig | null>;
     testClusterAccess(): Promise<boolean>;
-    /**
-     * Discover service URLs from ark-api service discovery
-     */
-    private discoverServicesFromApi;
-    getServiceUrls(): Promise<Record<string, string>>;
 }

package/dist/config.js

@@ -1,119 +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();
@@ -127,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;
@@ -137,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
@@ -180,10 +82,6 @@ export class ConfigManager {
             }
         }
     }
-    async getKubernetesConfig() {
-        await this.initKubernetesConfig();
-        return this.kubeConfig;
-    }
     async testClusterAccess() {
         await this.initKubernetesConfig();
         if (!this.kubeConfig) {
@@ -191,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;
-    }
 }