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

package/dist/components/statusChecker.js

@@ -1,7 +1,9 @@
-import { execa } from 'execa';
-import { checkCommandExists } from '../lib/commands.js';
-import { arkServices } from '../arkServices.js';
-import { isArkReady } from '../lib/arkStatus.js';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { KubernetesConfigManager } from '../lib/kubernetes.js';
+import * as k8s from '@kubernetes/client-node';
+import axios from 'axios';
+const execAsync = promisify(exec);
 export const getNodeVersion = () => ({
     command: 'node',
     versionArgs: '--version',
@@ -38,20 +40,6 @@ export const getHelmVersion = () => ({
     versionArgs: 'version --short',
     versionExtract: (output) => output.trim(),
 });
-export const getMinikubeVersion = () => ({
-    command: 'minikube',
-    versionArgs: 'version --short',
-    versionExtract: (output) => output.trim(),
-});
-export const getKindVersion = () => ({
-    command: 'kind',
-    versionArgs: 'version',
-    versionExtract: (output) => {
-        // kind version output is like "kind v0.20.0 go1.21.0 linux/amd64"
-        const match = output.match(/kind (v[\d.]+)/);
-        return match ? match[1] : output.trim();
-    },
-});
 function createErrorServiceStatus(name, url, error, defaultStatus = 'unhealthy', defaultDetails) {
     const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
     return {
@@ -62,13 +50,32 @@ function createErrorServiceStatus(name, url, error, defaultStatus = 'unhealthy',
     };
 }
 export class StatusChecker {
+    constructor(arkClient) {
+        this.arkClient = arkClient;
+        this.kubernetesManager = new KubernetesConfigManager();
+    }
+    /**
+     * Check if a command is available in the system
+     */
+    async isCommandAvailable(command) {
+        try {
+            const checkCommand = process.platform === 'win32'
+                ? `where ${command}`
+                : `command -v ${command}`;
+            await execAsync(checkCommand);
+            return true;
+        }
+        catch (_error) {
+            return false;
+        }
+    }
     /**
      * Get version of a command
      */
     async getCommandVersion(config) {
         try {
-            const args = config.versionArgs.split(' ');
-            const { stdout } = await execa(config.command, args);
+            const cmd = `${config.command} ${config.versionArgs}`;
+            const { stdout } = await execAsync(cmd);
             return config.versionExtract(stdout);
         }
         catch (error) {
@@ -76,219 +83,91 @@ export class StatusChecker {
         }
     }
     /**
-     * Check combined deployment and helm status
-     * Gets health from deployment, version/revision from Helm
+     * Check health of a service by URL
      */
-    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, devDeploymentName) {
+    async checkServiceHealth(serviceName, serviceUrl, successMessage, healthPath = '') {
+        const fullUrl = `${serviceUrl}${healthPath}`;
         try {
-            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;
-            const availableReplicas = deployment.status?.availableReplicas || 0;
-            // Check Kubernetes 'Available' condition - only 'available' deployments are healthy
-            const availableCondition = deployment.status?.conditions?.find((condition) => condition.type === 'Available');
-            const isAvailable = availableCondition?.status === 'True';
-            const allReplicasReady = readyReplicas === replicas && availableReplicas === replicas;
-            // Determine status: not ready if 0 replicas, healthy if available and all ready, warning otherwise
-            let status;
-            if (replicas === 0 || readyReplicas === 0) {
-                status = 'not ready';
-            }
-            else if (isAvailable && allReplicasReady) {
-                status = 'healthy';
-            }
-            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
-                }
-            }
+            await axios.get(fullUrl, { timeout: 5000 });
             return {
                 name: serviceName,
-                status,
-                details: `${readyReplicas}/${replicas} replicas ready`,
-                namespace,
+                status: 'healthy',
+                url: serviceUrl,
+                details: successMessage,
             };
         }
         catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            // 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`,
-                    namespace,
-                };
-            }
-            return createErrorServiceStatus(serviceName, '', error, 'unhealthy', `Failed to check deployment: ${errorMessage}`);
+            return createErrorServiceStatus(serviceName, serviceUrl, error, 'unhealthy', `${serviceName} is not running or not accessible`);
         }
     }
     /**
-     * Check helm release status (fallback for services without deployments)
+     * Check if ark-api is running and healthy
      */
-    async checkHelmStatus(serviceName, helmReleaseName, namespace) {
+    async checkArkApi(customUrl) {
+        const url = customUrl || this.arkClient.getBaseURL();
+        return this.checkServiceHealth('ark-api', url, 'ARK API is running', '/health');
+    }
+    /**
+     * 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 {
-            const { stdout } = await execa('helm', [
-                'list',
-                '--filter',
-                helmReleaseName,
-                '--namespace',
+            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,
-                '--output',
-                'json',
-            ]);
-            const helmList = JSON.parse(stdout);
-            if (helmList.length === 0) {
+            });
+            // 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: 'not installed',
-                    details: `Helm release '${helmReleaseName}' not found`,
-                    namespace,
+                    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`,
                 };
             }
-            const release = helmList[0];
-            const status = release.status?.toLowerCase() || 'unknown';
-            const revision = release.revision || 'unknown';
-            const appVersion = release.app_version || 'unknown';
-            const isHealthy = status === 'deployed';
-            return {
-                name: serviceName,
-                status: isHealthy ? 'healthy' : 'unhealthy',
-                version: appVersion,
-                revision: revision,
-                details: `Status: ${status}`,
-                namespace,
-            };
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            return createErrorServiceStatus(serviceName, '', error, 'unhealthy', `Failed to check helm status: ${errorMessage}`);
+            // 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}`,
+            };
         }
     }
     /**
@@ -301,13 +180,10 @@ export class StatusChecker {
             { name: 'kubectl', ...getKubectlVersion() },
             { name: 'docker', ...getDockerVersion() },
             { name: 'helm', ...getHelmVersion() },
-            { name: 'minikube', ...getMinikubeVersion() },
-            { name: 'kind', ...getKindVersion() },
         ];
         const results = [];
         for (const dep of dependencies) {
-            const args = dep.versionArgs.split(' ');
-            const installed = await checkCommandExists(dep.command, args);
+            const installed = await this.isCommandAvailable(dep.command);
             const version = installed
                 ? await this.getCommandVersion({
                     command: dep.command,
@@ -329,89 +205,47 @@ export class StatusChecker {
     /**
      * Run all checks and return results
      */
-    async checkAll() {
-        // Check dependencies first
-        const dependencies = await this.checkDependencies();
-        // Test cluster access
-        let clusterAccess = false;
-        try {
-            await execa('kubectl', ['get', 'namespaces', '-o', 'name'], {
-                timeout: 5000,
-            });
-            clusterAccess = true;
+    async checkAll(serviceUrls = {}, arkApiUrl) {
+        // Always check ark-api if provided
+        const serviceChecks = [];
+        if (arkApiUrl) {
+            serviceChecks.push(this.checkArkApi(arkApiUrl));
         }
-        catch {
-            clusterAccess = false;
-        }
-        // Get cluster info if accessible
-        let clusterInfo;
-        if (clusterAccess) {
-            const { getClusterInfo } = await import('../lib/cluster.js');
-            clusterInfo = await getClusterInfo();
-        }
-        let services = [];
-        // Only check ARK services if we have cluster access
-        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) {
-                    // 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, namespace));
-                }
-            }
-            services = await Promise.all(serviceChecks);
-        }
-        // 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 with detailed status
-            if (arkReady) {
-                try {
-                    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,
-                    };
-                }
+        // Dynamically check all discovered services
+        for (const [serviceName, serviceUrl] of Object.entries(serviceUrls)) {
+            if (serviceName === 'ark-api' && arkApiUrl) {
+                // Skip if we already added ark-api above
+                continue;
             }
+            serviceChecks.push(this.checkServiceHealth(serviceName, serviceUrl, `${serviceName} is running`, this.getHealthPath(serviceName)));
         }
+        // Always check dependencies
+        const dependenciesCheck = this.checkDependencies();
+        const [dependencies, ...serviceStatuses] = await Promise.all([
+            dependenciesCheck,
+            ...serviceChecks,
+        ]);
         return {
-            services,
+            services: serviceStatuses,
             dependencies,
-            clusterAccess,
-            clusterInfo,
-            arkReady,
-            defaultModelExists,
-            defaultModel,
         };
     }
+    /**
+     * Get appropriate health check path for different service types
+     */
+    getHealthPath(serviceName) {
+        // Some services might need specific health check paths
+        switch (serviceName) {
+            case 'ark-api':
+                return '/health';
+            case 'ark-api-a2a':
+                return '/health'; // ark-api-a2a has a working /health endpoint
+            case 'ark-dashboard':
+                return ''; // Dashboard typically responds to root
+            case 'langfuse':
+                return ''; // Langfuse responds to root path
+            default:
+                return ''; // Default to root path
+        }
+    }
 }

package/dist/config.d.ts

@@ -1,14 +1,27 @@
+import { ArkConfig, KubernetesConfig } from './lib/types.js';
 /**
- * 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 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
@@ -19,5 +32,11 @@ 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>>;
 }