@agents-at-scale/ark 0.1.35 → 0.1.36

package/dist/config.js

@@ -1,243 +0,0 @@
-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/lib/arkClient.d.ts

@@ -1,32 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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/consts.d.ts

@@ -1,10 +0,0 @@
-export declare const DEFAULT_ADDRESS_ARK_API = "http://localhost:8000";
-export declare const DEFAULT_TIMEOUT_MS = 30000;
-export declare const DEFAULT_CONNECTION_TEST_TIMEOUT_MS = 5000;
-export declare const CONFIG_DIR_NAME = "ark";
-export declare const CONFIG_FILE_NAME = "ark-cli.json";
-export declare const DEFAULT_ARK_DASHBOARD_URL = "http://localhost:3000";
-export declare const DEFAULT_ARK_A2A_URL = "http://localhost:8080";
-export declare const DEFAULT_ARK_MEMORY_URL = "http://localhost:8081";
-export declare const DEFAULT_ARK_OTEL_URL = "http://localhost:4318";
-export declare const ARK_REPO_ERROR_MESSAGE = "Error: This command must be run inside the ARK repository.";

package/dist/lib/consts.js

@@ -1,15 +0,0 @@
-// Default ARK API server address
-export const DEFAULT_ADDRESS_ARK_API = 'http://localhost:8000';
-// Default timeout values
-export const DEFAULT_TIMEOUT_MS = 30000;
-export const DEFAULT_CONNECTION_TEST_TIMEOUT_MS = 5000;
-// Configuration paths
-export const CONFIG_DIR_NAME = 'ark';
-export const CONFIG_FILE_NAME = 'ark-cli.json';
-// Default service URLs
-export const DEFAULT_ARK_DASHBOARD_URL = 'http://localhost:3000';
-export const DEFAULT_ARK_A2A_URL = 'http://localhost:8080';
-export const DEFAULT_ARK_MEMORY_URL = 'http://localhost:8081';
-export const DEFAULT_ARK_OTEL_URL = 'http://localhost:4318';
-// Error message for different ARK repo
-export const ARK_REPO_ERROR_MESSAGE = 'Error: This command must be run inside the ARK repository.';

package/dist/lib/exec.d.ts

@@ -1,5 +0,0 @@
-export declare function executeCommand(command: string, args?: string[]): Promise<{
-    stdout: string;
-    stderr: string;
-}>;
-export declare function fileExists(path: string): boolean;

package/dist/lib/exec.js

@@ -1,20 +0,0 @@
-import fs from 'fs';
-import { execa } from 'execa';
-export async function executeCommand(command, args = []) {
-    try {
-        const result = await execa(command, args);
-        return { stdout: result.stdout, stderr: result.stderr };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        throw new Error(`Command failed: ${command} ${args.join(' ')}\n${errorMessage}`);
-    }
-}
-export function fileExists(path) {
-    try {
-        return fs.existsSync(path);
-    }
-    catch {
-        return false;
-    }
-}

package/dist/lib/gatewayManager.d.ts

@@ -1,24 +0,0 @@
-export declare class GatewayManager {
-    private kubernetesManager;
-    constructor();
-    /**
-     * Check if localhost-gateway port-forward is running by testing the endpoint
-     */
-    isPortForwardRunning(port?: number): Promise<boolean>;
-    /**
-     * Check if localhost-gateway service is deployed in cluster
-     */
-    isGatewayDeployed(): Promise<boolean>;
-    /**
-     * Check if port-forward is needed and provide setup instructions
-     */
-    checkPortForwardStatus(port?: number): Promise<{
-        isRunning: boolean;
-        needsSetup: boolean;
-        instructions?: string;
-    }>;
-    /**
-     * Get setup instructions for fresh installations
-     */
-    getSetupInstructions(): string;
-}

package/dist/lib/gatewayManager.js

@@ -1,85 +0,0 @@
-import * as k8s from '@kubernetes/client-node';
-import { KubernetesConfigManager } from './kubernetes.js';
-export class GatewayManager {
-    constructor() {
-        this.kubernetesManager = new KubernetesConfigManager();
-    }
-    /**
-     * Check if localhost-gateway port-forward is running by testing the endpoint
-     */
-    async isPortForwardRunning(port = 8080) {
-        try {
-            const axios = (await import('axios')).default;
-            await axios.get(`http://127.0.0.1:${port}`, {
-                timeout: 2000,
-                validateStatus: () => true,
-            });
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * Check if localhost-gateway service is deployed in cluster
-     */
-    async isGatewayDeployed() {
-        try {
-            await this.kubernetesManager.initializeConfig();
-            const kc = this.kubernetesManager.getKubeConfig();
-            const k8sApi = kc.makeApiClient(k8s.CoreV1Api);
-            await k8sApi.readNamespacedService({
-                name: 'localhost-gateway-nginx',
-                namespace: 'ark-system',
-            });
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * Check if port-forward is needed and provide setup instructions
-     */
-    async checkPortForwardStatus(port = 8080) {
-        const isRunning = await this.isPortForwardRunning(port);
-        if (isRunning) {
-            return { isRunning: true, needsSetup: false };
-        }
-        const isDeployed = await this.isGatewayDeployed();
-        if (!isDeployed) {
-            return {
-                isRunning: false,
-                needsSetup: true,
-                instructions: this.getSetupInstructions(),
-            };
-        }
-        return {
-            isRunning: false,
-            needsSetup: true,
-            instructions: `Gateway is deployed but port-forward not running. Start it with:\nkubectl port-forward -n ark-system service/localhost-gateway-nginx ${port}:80`,
-        };
-    }
-    /**
-     * Get setup instructions for fresh installations
-     */
-    getSetupInstructions() {
-        return `
-🔧 ARK Gateway Setup Required:
-
-To enable service discovery, you need to install the localhost-gateway:
-
-1. From your agents-at-scale project root, run:
-   make localhost-gateway-install
-
-2. This will:
-   - Install Gateway API CRDs
-   - Deploy NGINX Gateway Fabric
-   - Set up port-forwarding to localhost:8080
-
-3. Then run 'ark check status' again
-
-For more info: docs/content/ark-101/ark-gateway.mdx
-`;
-    }
-}

package/dist/lib/kubernetes.d.ts

@@ -1,28 +0,0 @@
-import * as k8s from '@kubernetes/client-node';
-import { KubernetesConfig } from './types.js';
-export declare class KubernetesConfigManager {
-    private kc;
-    constructor();
-    /**
-     * Get the KubeConfig instance for API client creation
-     */
-    getKubeConfig(): k8s.KubeConfig;
-    /**
-     * Initialize Kubernetes configuration similar to fark's approach
-     * Priority: in-cluster config > KUBECONFIG env > ~/.kube/config
-     */
-    initializeConfig(): Promise<KubernetesConfig>;
-    /**
-     * Get the API server URL for the current cluster
-     */
-    getClusterApiUrl(): string;
-    /**
-     * Detect ark-api service URL in the cluster
-     * This mimics how fark discovers services
-     */
-    getArkApiUrl(namespace?: string): Promise<string>;
-    /**
-     * Check if we can access the cluster
-     */
-    testClusterAccess(): Promise<boolean>;
-}

package/dist/lib/kubernetes.js

@@ -1,122 +0,0 @@
-import { promises as fs } from 'fs';
-import { homedir } from 'os';
-import { join } from 'path';
-import * as k8s from '@kubernetes/client-node';
-export class KubernetesConfigManager {
-    constructor() {
-        this.kc = new k8s.KubeConfig();
-    }
-    /**
-     * Get the KubeConfig instance for API client creation
-     */
-    getKubeConfig() {
-        return this.kc;
-    }
-    /**
-     * Initialize Kubernetes configuration similar to fark's approach
-     * Priority: in-cluster config > KUBECONFIG env > ~/.kube/config
-     */
-    async initializeConfig() {
-        let kubeconfig;
-        let currentContext;
-        let namespace;
-        let inCluster = false;
-        // Check if we're explicitly in a Kubernetes pod environment
-        const isInPod = process.env.KUBERNETES_SERVICE_HOST &&
-            process.env.KUBERNETES_SERVICE_PORT &&
-            process.env.POD_NAMESPACE;
-        if (isInPod) {
-            try {
-                // Try in-cluster config only if we're definitely in a pod
-                this.kc.loadFromCluster();
-                inCluster = true;
-                kubeconfig = '/var/run/secrets/kubernetes.io/serviceaccount';
-                namespace = process.env.POD_NAMESPACE || 'default';
-            }
-            catch (error) {
-                throw new Error(`Failed to load in-cluster Kubernetes configuration: ${error}`);
-            }
-        }
-        else {
-            // Use kubeconfig file for local development
-            try {
-                kubeconfig =
-                    process.env.KUBECONFIG || join(homedir(), '.kube', 'config');
-                // Check if kubeconfig file exists
-                await fs.access(kubeconfig);
-                this.kc.loadFromFile(kubeconfig);
-                // Get current context and namespace
-                currentContext = this.kc.currentContext;
-                // Simplified namespace detection - just use default for now
-                // Complex namespace detection can be added later if needed
-                namespace = 'default';
-            }
-            catch (error) {
-                throw new Error(`Failed to load Kubernetes configuration: ${error}`);
-            }
-        }
-        return {
-            kubeconfig,
-            currentContext,
-            namespace,
-            inCluster,
-        };
-    }
-    /**
-     * Get the API server URL for the current cluster
-     */
-    getClusterApiUrl() {
-        const cluster = this.kc.getCurrentCluster();
-        if (!cluster) {
-            throw new Error('No current cluster found in kubeconfig');
-        }
-        return cluster.server;
-    }
-    /**
-     * Detect ark-api service URL in the cluster
-     * This mimics how fark discovers services
-     */
-    async getArkApiUrl(namespace = 'default') {
-        const k8sApi = this.kc.makeApiClient(k8s.CoreV1Api);
-        try {
-            // Try to find ark-api service
-            const service = await k8sApi.readNamespacedService({
-                name: 'ark-api',
-                namespace,
-            });
-            if (service.spec?.type === 'LoadBalancer' &&
-                service.status?.loadBalancer?.ingress?.[0]) {
-                const ingress = service.status.loadBalancer.ingress[0];
-                const host = ingress.ip || ingress.hostname;
-                const port = service.spec.ports?.[0]?.port || 8080;
-                return `http://${host}:${port}`;
-            }
-            if (service.spec?.type === 'NodePort' && service.spec.ports?.[0]) {
-                const nodePort = service.spec.ports[0].nodePort;
-                const clusterUrl = this.getClusterApiUrl();
-                const clusterHost = new URL(clusterUrl).hostname;
-                return `http://${clusterHost}:${nodePort}`;
-            }
-            // Default to port-forward style access
-            const port = service.spec?.ports?.[0]?.port || 8080;
-            return `http://localhost:${port}`;
-        }
-        catch (error) {
-            // Service not found or not accessible
-            throw new Error(`ark-api service not found or not accessible in namespace '${namespace}': ${error instanceof Error ? error.message : error}`);
-        }
-    }
-    /**
-     * Check if we can access the cluster
-     */
-    async testClusterAccess() {
-        try {
-            const k8sApi = this.kc.makeApiClient(k8s.CoreV1Api);
-            await k8sApi.listNamespace();
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-}