@agents-at-scale/ark 0.1.35 → 0.1.36

package/dist/components/statusChecker.d.ts

@@ -1,38 +1,29 @@
-import { StatusData, CommandVersionConfig } from '../lib/types.js';
-import { ArkClient } from '../lib/arkClient.js';
+import { StatusData, CommandVersionConfig, ClusterInfo } from '../lib/types.js';
 export declare const getNodeVersion: () => CommandVersionConfig;
 export declare const getNpmVersion: () => CommandVersionConfig;
 export declare const getKubectlVersion: () => CommandVersionConfig;
 export declare const getDockerVersion: () => CommandVersionConfig;
 export declare const getHelmVersion: () => CommandVersionConfig;
+export declare const getMinikubeVersion: () => CommandVersionConfig;
+export declare const getKindVersion: () => CommandVersionConfig;
 export declare class StatusChecker {
-    private arkClient;
-    private kubernetesManager;
-    constructor(arkClient: ArkClient);
-    /**
-     * Check if a command is available in the system
-     */
-    private isCommandAvailable;
     /**
      * Get version of a command
      */
     private getCommandVersion;
     /**
-     * Check health of a service by URL
-     */
-    private checkServiceHealth;
-    /**
-     * Check if ark-api is running and healthy
+     * Check combined deployment and helm status
+     * Gets health from deployment, version/revision from Helm
      */
-    private checkArkApi;
+    private checkCombinedStatus;
     /**
-     * Return a "not installed" status for a service
+     * Check deployment status
      */
-    private createNotInstalledStatus;
+    private checkDeploymentStatus;
     /**
-     * Check Kubernetes service health via pods and endpoints
+     * Check helm release status (fallback for services without deployments)
      */
-    private checkKubernetesService;
+    private checkHelmStatus;
     /**
      * Check system dependencies
      */
@@ -40,9 +31,8 @@ export declare class StatusChecker {
     /**
      * Run all checks and return results
      */
-    checkAll(serviceUrls?: Record<string, string>, arkApiUrl?: string): Promise<StatusData>;
-    /**
-     * Get appropriate health check path for different service types
-     */
-    private getHealthPath;
+    checkAll(): Promise<StatusData & {
+        clusterAccess: boolean;
+        clusterInfo?: ClusterInfo;
+    }>;
 }

package/dist/components/statusChecker.js

@@ -1,9 +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 axios from 'axios';
-const execAsync = promisify(exec);
+import { execa } from 'execa';
+import { checkCommandExists } from '../lib/commands.js';
+import { arkServices } from '../arkServices.js';
+import { isArkReady } from '../lib/arkStatus.js';
 export const getNodeVersion = () => ({
     command: 'node',
     versionArgs: '--version',
@@ -40,6 +38,20 @@ 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 {
@@ -50,32 +62,13 @@ 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 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) {
@@ -83,92 +76,220 @@ export class StatusChecker {
         }
     }
     /**
-     * Check health of a service by URL
+     * Check combined deployment and helm status
+     * Gets health from deployment, version/revision from Helm
      */
-    async checkServiceHealth(serviceName, serviceUrl, successMessage, healthPath = '') {
-        const fullUrl = `${serviceUrl}${healthPath}`;
+    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) {
         try {
-            await axios.get(fullUrl, { timeout: 5000 });
+            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
+                }
+            }
             return {
                 name: serviceName,
-                status: 'healthy',
-                url: serviceUrl,
-                details: successMessage,
+                status,
+                details: `${readyReplicas}/${replicas} replicas ready`,
+                namespace,
             };
         }
         catch (error) {
-            return createErrorServiceStatus(serviceName, serviceUrl, error, 'unhealthy', `${serviceName} is not running or not accessible`);
+            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}`);
         }
     }
     /**
-     * Check if ark-api is running and healthy
+     * Check helm release status (fallback for services without deployments)
      */
-    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') {
+    async checkHelmStatus(serviceName, helmReleaseName, namespace) {
         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,
+            const { stdout } = await execa('helm', [
+                'list',
+                '--filter',
+                helmReleaseName,
+                '--namespace',
                 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 {
+                '--output',
+                'json',
+            ]);
+            const helmList = JSON.parse(stdout);
+            if (helmList.length === 0) {
                 return {
                     name: serviceName,
-                    status: 'unhealthy',
-                    details: `${serviceName} service exists but has no ready endpoints`,
+                    status: 'not installed',
+                    details: `Helm release '${helmReleaseName}' not found`,
+                    namespace,
                 };
             }
-        }
-        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
+            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: 'unhealthy',
-                details: `Failed to check ${serviceName}: ${errorMessage}`,
+                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}`);
+        }
     }
     /**
      * Check system dependencies
@@ -180,10 +301,13 @@ 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 installed = await this.isCommandAvailable(dep.command);
+            const args = dep.versionArgs.split(' ');
+            const installed = await checkCommandExists(dep.command, args);
             const version = installed
                 ? await this.getCommandVersion({
                     command: dep.command,
@@ -205,47 +329,89 @@ export class StatusChecker {
     /**
      * Run all checks and return results
      */
-    async checkAll(serviceUrls = {}, arkApiUrl) {
-        // Always check ark-api if provided
-        const serviceChecks = [];
-        if (arkApiUrl) {
-            serviceChecks.push(this.checkArkApi(arkApiUrl));
+    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;
         }
-        // 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;
+        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,
+                    };
+                }
             }
-            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: serviceStatuses,
+            services,
             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/index.d.ts

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