@agents-at-scale/ark 0.1.31

package/dist/components/DashboardCLI.js

@@ -0,0 +1,149 @@
+#!/usr/bin/env node
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import fs from 'fs';
+import path, { dirname } from 'path';
+import { fileURLToPath } from 'url';
+import axios from 'axios';
+import { execa } from 'execa';
+import { Text } from 'ink';
+import open from 'open';
+import { useState, useEffect } from 'react';
+import YAML from 'yaml';
+import { DEFAULT_ADDRESS_ARK_API, DEFAULT_ARK_DASHBOARD_URL, } from '../lib/consts.js';
+const DashboardCLI = () => {
+    const [currentStep, setCurrentStep] = useState(0);
+    const [status, setStatus] = useState('Running');
+    const [dotsIndex, setDotsIndex] = useState(0);
+    const dotFrames = ['.', '..', '...'];
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    const rootDir = path.resolve(__dirname, '../../../');
+    const steps = [
+        {
+            label: 'Building backend',
+            path: `${rootDir}/ark-api`,
+            checkUrl: `${DEFAULT_ADDRESS_ARK_API}/health`,
+        },
+        {
+            label: 'Starting frontend',
+            path: `${rootDir}/ark-dashboard`,
+            checkUrl: DEFAULT_ARK_DASHBOARD_URL,
+        },
+    ];
+    async function isServiceUp(url) {
+        try {
+            const res = await axios.get(url);
+            return res.status >= 200 && res.status < 400;
+        }
+        catch {
+            return false;
+        }
+    }
+    async function runCommands(commands, cwd) {
+        for (const cmd of commands) {
+            // Run each command in the specified working directory
+            await execa(cmd, {
+                cwd: cwd,
+                stdio: ['ignore', 'pipe', 'pipe'],
+                shell: true,
+            });
+        }
+    }
+    function loadServiceManifest(servicePath) {
+        const manifestPath = path.join(servicePath, 'manifest.yaml');
+        const raw = fs.readFileSync(manifestPath, 'utf-8');
+        return YAML.parse(raw);
+    }
+    async function runStep(stepIndex) {
+        const step = steps[stepIndex];
+        const manifest = loadServiceManifest(step.path);
+        // 1. Check if service is already up
+        const alreadyUp = await isServiceUp(step.checkUrl);
+        if (alreadyUp) {
+            setCurrentStep((prev) => prev + 1);
+            return;
+        }
+        // 2. Install the dependencies
+        if (manifest.commands?.install) {
+            try {
+                await runCommands(manifest.commands.install, step.path);
+            }
+            catch (err) {
+                setStatus('Failed');
+                console.error(`Error running install commands for ${step.label}`, err);
+                process.exit(1);
+            }
+        }
+        // 3. Start the service
+        const startCommand = manifest.commands?.dev;
+        if (startCommand) {
+            const devCommandStr = Array.isArray(startCommand)
+                ? startCommand.join(' && ')
+                : startCommand;
+            const serviceProcess = execa(devCommandStr, {
+                cwd: step.path,
+                stdio: ['ignore', 'pipe', 'pipe'],
+                shell: true,
+            });
+            // 4. Poll until service is ready
+            return new Promise((resolve, reject) => {
+                let attempts = 0;
+                const maxAttempts = 30;
+                const interval = 3000;
+                const poll = async () => {
+                    attempts++;
+                    if (await isServiceUp(step.checkUrl)) {
+                        setCurrentStep((prev) => prev + 1);
+                        resolve();
+                        return;
+                    }
+                    if (attempts >= maxAttempts) {
+                        reject(new Error(`${step.label} did not start in time.`));
+                        return;
+                    }
+                    setTimeout(poll, interval);
+                };
+                poll();
+                serviceProcess.catch((err) => reject(err));
+            });
+        }
+    }
+    async function startDashboardServices() {
+        try {
+            for (let i = 0; i < steps.length; i++) {
+                await runStep(i);
+            }
+            setStatus('Done');
+            await open(steps[steps.length - 1].checkUrl);
+        }
+        catch (err) {
+            setStatus('Failed');
+            console.error('Error:', err);
+            process.exit(1);
+        }
+    }
+    useEffect(() => {
+        startDashboardServices();
+    }, []);
+    useEffect(() => {
+        if (status !== 'Running') {
+            return;
+        }
+        const interval = setInterval(() => {
+            setDotsIndex((prev) => (prev + 1) % dotFrames.length);
+        }, 300);
+        return () => clearInterval(interval);
+    }, [status]);
+    return (_jsxs(_Fragment, { children: [_jsx(Text, { color: "yellow", children: "\u23F3 Starting Dashboard" }), steps.map((step, i) => {
+                if (i < currentStep) {
+                    return (_jsxs(Text, { color: "green", children: ["\u2705 Step ", i + 1, ": ", step.label] }, i));
+                }
+                else if (i === currentStep && status === 'Running') {
+                    return (_jsxs(Text, { children: ["Step ", i + 1, ": ", step.label, dotFrames[dotsIndex]] }, i));
+                }
+                else {
+                    return null;
+                }
+            }), status === 'Done' && (_jsx(Text, { color: "green", children: "\uD83C\uDF89 Dashboard is up and running!" })), status === 'Failed' && (_jsx(Text, { color: "red", children: "\u274C Failed to start Dashboard" }))] }));
+};
+export default DashboardCLI;

package/dist/components/GeneratorUI.d.ts

@@ -0,0 +1,3 @@
+import * as React from 'react';
+declare const GeneratorUI: React.FC;
+export default GeneratorUI;

package/dist/components/GeneratorUI.js

@@ -0,0 +1,167 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Text, Box, useInput, useApp } from 'ink';
+import SelectInput from 'ink-select-input';
+import * as React from 'react';
+import { execa } from 'execa';
+import { getUIGeneratorChoices, UI_CONFIG } from '../commands/generate/config.js';
+const GeneratorUI = () => {
+    const [state, setState] = React.useState({
+        error: null,
+    });
+    const { exit } = useApp();
+    const generatorChoices = getUIGeneratorChoices();
+    useInput((input, key) => {
+        if (key.escape || input === 'q') {
+            // Exit the UI
+            exit();
+        }
+    });
+    const handleGeneratorTypeSelect = async (choice) => {
+        if (choice.value === 'back') {
+            // Exit the UI
+            exit();
+            return;
+        }
+        if (choice.value === 'project') {
+            try {
+                // Exit the UI and run the CLI command
+                exit();
+                // Run the CLI command
+                // We need to spawn this in a way that doesn't interfere with the current process
+                setTimeout(() => {
+                    execa('ark', ['generate', 'project'], {
+                        stdio: 'inherit',
+                        cwd: process.cwd(),
+                    }).catch((error) => {
+                        console.error('Failed to run generator:', error.message);
+                        process.exit(1);
+                    });
+                }, 100); // Small delay to let UI exit cleanly
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Failed to launch generator';
+                setState((prev) => ({
+                    ...prev,
+                    error: errorMessage,
+                }));
+            }
+        }
+        if (choice.value === 'agent') {
+            try {
+                // Exit the UI and run the CLI command
+                exit();
+                // Run the CLI command
+                setTimeout(() => {
+                    execa('ark', ['generate', 'agent'], {
+                        stdio: 'inherit',
+                        cwd: process.cwd(),
+                    }).catch((error) => {
+                        console.error('Failed to run generator:', error.message);
+                        process.exit(1);
+                    });
+                }, 100); // Small delay to let UI exit cleanly
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Failed to launch generator';
+                setState((prev) => ({
+                    ...prev,
+                    error: errorMessage,
+                }));
+            }
+        }
+        if (choice.value === 'team') {
+            try {
+                // Exit the UI and run the CLI command
+                exit();
+                // Run the CLI command
+                setTimeout(() => {
+                    execa('ark', ['generate', 'team'], {
+                        stdio: 'inherit',
+                        cwd: process.cwd(),
+                    }).catch((error) => {
+                        console.error('Failed to run generator:', error.message);
+                        process.exit(1);
+                    });
+                }, 100); // Small delay to let UI exit cleanly
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Failed to launch generator';
+                setState((prev) => ({
+                    ...prev,
+                    error: errorMessage,
+                }));
+            }
+        }
+        if (choice.value === 'query') {
+            try {
+                // Exit the UI and run the CLI command
+                exit();
+                // Run the CLI command
+                setTimeout(() => {
+                    execa('ark', ['generate', 'query'], {
+                        stdio: 'inherit',
+                        cwd: process.cwd(),
+                    }).catch((error) => {
+                        console.error('Failed to run generator:', error.message);
+                        process.exit(1);
+                    });
+                }, 100); // Small delay to let UI exit cleanly
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Failed to launch generator';
+                setState((prev) => ({
+                    ...prev,
+                    error: errorMessage,
+                }));
+            }
+        }
+        if (choice.value === 'mcp-server') {
+            try {
+                // Exit the UI and run the CLI command
+                exit();
+                // Run the CLI command
+                setTimeout(() => {
+                    execa('ark', ['generate', 'mcp-server'], {
+                        stdio: 'inherit',
+                        cwd: process.cwd(),
+                    }).catch((error) => {
+                        console.error('Failed to run generator:', error.message);
+                        process.exit(1);
+                    });
+                }, 100); // Small delay to let UI exit cleanly
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Failed to launch generator';
+                setState((prev) => ({
+                    ...prev,
+                    error: errorMessage,
+                }));
+            }
+        }
+        if (choice.value === 'marketplace') {
+            try {
+                // Exit the UI and run the CLI command
+                exit();
+                // Run the CLI command
+                setTimeout(() => {
+                    execa('ark', ['generate', 'marketplace'], {
+                        stdio: 'inherit',
+                        cwd: process.cwd(),
+                    }).catch((error) => {
+                        console.error('Failed to run generator:', error.message);
+                        process.exit(1);
+                    });
+                }, 100); // Small delay to let UI exit cleanly
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Failed to launch generator';
+                setState((prev) => ({
+                    ...prev,
+                    error: errorMessage,
+                }));
+            }
+        }
+    };
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: UI_CONFIG.colors.primary, bold: true, children: [UI_CONFIG.icons.generator, " Generator - Create new ARK resources"] }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: UI_CONFIG.colors.secondary, children: UI_CONFIG.messages.generatorTypePrompt }) }), state.error && (_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { color: UI_CONFIG.colors.error, children: [UI_CONFIG.icons.error, " ", state.error] }) })), _jsx(SelectInput, { items: generatorChoices, onSelect: handleGeneratorTypeSelect }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "gray", children: "Press ESC or 'q' to exit" }) })] }));
+};
+export default GeneratorUI;

package/dist/components/statusChecker.d.ts

@@ -0,0 +1,48 @@
+import { StatusData, CommandVersionConfig } from '../lib/types.js';
+import { ArkClient } from '../lib/arkClient.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 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
+     */
+    private checkArkApi;
+    /**
+     * Return a "not installed" status for a service
+     */
+    private createNotInstalledStatus;
+    /**
+     * Check Kubernetes service health via pods and endpoints
+     */
+    private checkKubernetesService;
+    /**
+     * Check system dependencies
+     */
+    private checkDependencies;
+    /**
+     * 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;
+}

package/dist/components/statusChecker.js

@@ -0,0 +1,251 @@
+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',
+    versionExtract: (output) => output.trim(),
+});
+export const getNpmVersion = () => ({
+    command: 'npm',
+    versionArgs: '--version',
+    versionExtract: (output) => output.trim(),
+});
+export const getKubectlVersion = () => ({
+    command: 'kubectl',
+    versionArgs: 'version --client --output=json',
+    versionExtract: (output) => {
+        try {
+            const versionInfo = JSON.parse(output);
+            if (versionInfo.clientVersion) {
+                return `v${versionInfo.clientVersion.major}.${versionInfo.clientVersion.minor}`;
+            }
+            throw new Error('kubectl version output missing clientVersion field');
+        }
+        catch (e) {
+            throw new Error(`Failed to parse kubectl version JSON: ${e instanceof Error ? e.message : 'Unknown error'}`);
+        }
+    },
+});
+export const getDockerVersion = () => ({
+    command: 'docker',
+    versionArgs: '--version',
+    versionExtract: (output) => output.trim(),
+});
+export const getHelmVersion = () => ({
+    command: 'helm',
+    versionArgs: 'version --short',
+    versionExtract: (output) => output.trim(),
+});
+function createErrorServiceStatus(name, url, error, defaultStatus = 'unhealthy', defaultDetails) {
+    const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+    return {
+        name,
+        status: defaultStatus,
+        url,
+        details: defaultDetails || `Error: ${errorMessage}`,
+    };
+}
+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);
+            return config.versionExtract(stdout);
+        }
+        catch (error) {
+            throw new Error(`Failed to get ${config.command} version: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Check health of a service by URL
+     */
+    async checkServiceHealth(serviceName, serviceUrl, successMessage, healthPath = '') {
+        const fullUrl = `${serviceUrl}${healthPath}`;
+        try {
+            await axios.get(fullUrl, { timeout: 5000 });
+            return {
+                name: serviceName,
+                status: 'healthy',
+                url: serviceUrl,
+                details: successMessage,
+            };
+        }
+        catch (error) {
+            return createErrorServiceStatus(serviceName, serviceUrl, error, 'unhealthy', `${serviceName} is not running or not accessible`);
+        }
+    }
+    /**
+     * Check if ark-api is running and healthy
+     */
+    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 {
+            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
+     */
+    async checkDependencies() {
+        const dependencies = [
+            { name: 'node', ...getNodeVersion() },
+            { name: 'npm', ...getNpmVersion() },
+            { name: 'kubectl', ...getKubectlVersion() },
+            { name: 'docker', ...getDockerVersion() },
+            { name: 'helm', ...getHelmVersion() },
+        ];
+        const results = [];
+        for (const dep of dependencies) {
+            const installed = await this.isCommandAvailable(dep.command);
+            const version = installed
+                ? await this.getCommandVersion({
+                    command: dep.command,
+                    versionArgs: dep.versionArgs,
+                    versionExtract: dep.versionExtract,
+                })
+                : undefined;
+            results.push({
+                name: dep.name,
+                installed,
+                version,
+                details: installed
+                    ? `Found ${dep.name} ${version}`
+                    : `${dep.name} not found in PATH`,
+            });
+        }
+        return results;
+    }
+    /**
+     * 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));
+        }
+        // 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: serviceStatuses,
+            dependencies,
+        };
+    }
+    /**
+     * 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

@@ -0,0 +1,42 @@
+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.
+ *
+ * Example usage:
+ *   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
+     */
+    private isLocalhostGatewayRunning;
+    /**
+     * Construct standard localhost-gateway URLs for known ARK services
+     */
+    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>>;
+}