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

package/dist/commands/routes.js

@@ -1,101 +0,0 @@
-import { Command } from 'commander';
-import chalk from 'chalk';
-import { execa } from 'execa';
-import output from '../lib/output.js';
-import { isCommandAvailable } from '../lib/commandUtils.js';
-async function listRoutes() {
-    // Check if kubectl is installed
-    const kubectlInstalled = await isCommandAvailable('kubectl');
-    if (!kubectlInstalled) {
-        output.error('kubectl is not installed. please install kubectl first:');
-        output.info('https://kubernetes.io/docs/tasks/tools/');
-        process.exit(1);
-    }
-    const namespace = 'ark-system';
-    const port = 8080;
-    const portSuffix = `:${port}`;
-    try {
-        // Check if localhost-gateway is installed
-        const { stdout: gatewayCheck } = await execa('kubectl', ['get', 'gateway', 'localhost-gateway', '-n', namespace], { reject: false });
-        if (!gatewayCheck) {
-            output.error("localhost-gateway not installed in namespace 'ark-system'");
-            output.info("run 'ark install' first");
-            process.exit(1);
-        }
-        // Get HTTPRoutes
-        const { stdout: routeOutput } = await execa('kubectl', [
-            'get',
-            'httproutes',
-            '-A',
-            '-o',
-            'custom-columns=NAMESPACE:.metadata.namespace,NAME:.metadata.name,HOSTNAMES:.spec.hostnames',
-            '--no-headers',
-        ], { reject: false });
-        if (!routeOutput || routeOutput.trim() === '') {
-            console.log(chalk.white('available localhost gateway routes: 0'));
-            output.info('no httproutes found. install services to see routes here.');
-            return;
-        }
-        // Parse routes
-        const lines = routeOutput.trim().split('\n');
-        const routes = [];
-        lines.forEach((line) => {
-            const parts = line.split(/\s+/);
-            if (parts.length >= 3) {
-                const name = parts[1];
-                // Remove brackets and split hostnames
-                const hostnamesStr = parts.slice(2).join(' ').replace(/\[|\]/g, '');
-                const hostnames = hostnamesStr
-                    .split(',')
-                    .map((h) => h.trim())
-                    .filter((h) => h && h !== '<none>');
-                if (hostnames.length > 0) {
-                    routes.push({ name, hostnames });
-                }
-            }
-        });
-        // Count total routes (each hostname counts as a route)
-        const routeCount = routes.reduce((count, r) => count + r.hostnames.length, 0);
-        console.log(chalk.white(`available localhost gateway routes: ${routeCount}`));
-        // Check port-forward status
-        const { stdout: psOutput } = await execa('pgrep', ['-f', `kubectl.*port-forward.*${port}:80`], { reject: false });
-        const portForwardActive = !!psOutput;
-        if (portForwardActive) {
-            output.info(`port-forward active on localhost${portSuffix}`);
-        }
-        else {
-            output.error(`port-forward not running on localhost${portSuffix} - routes are not exposed`);
-            console.log(chalk.blue('run:'), `kubectl port-forward -n ${namespace} service/localhost-gateway-nginx ${port}:80 > /dev/null 2>&1 &`);
-        }
-        console.log();
-        // Display routes
-        if (routes.length > 0) {
-            const maxLength = Math.max(...routes.map((r) => r.name.length));
-            routes.forEach((route) => {
-                route.hostnames.forEach((hostname) => {
-                    const url = `http://${hostname}${portSuffix}/`;
-                    const padding = ' '.repeat(maxLength - route.name.length);
-                    if (portForwardActive) {
-                        console.log(`  ${route.name}${padding}: ${chalk.blue(url)}`);
-                    }
-                    else {
-                        console.log(`  ${route.name}${padding}: ${chalk.blue(url)} ${chalk.red('(unavailable)')}`);
-                    }
-                });
-            });
-        }
-    }
-    catch (error) {
-        output.error('failed to fetch routes:', error instanceof Error ? error.message : 'Unknown error');
-        process.exit(1);
-    }
-}
-export function createRoutesCommand() {
-    const command = new Command('routes');
-    command
-        .description('show available gateway routes and their urls')
-        .action(async () => {
-        await listRoutes();
-    });
-    return command;
-}

package/dist/commands/status/index.d.ts

@@ -1,4 +0,0 @@
-import { Command } from 'commander';
-import type { ArkConfig } from '../../lib/config.js';
-export declare function checkStatus(config: ArkConfig): Promise<void>;
-export declare function createStatusCommand(config: ArkConfig): Command;

package/dist/commands/status/index.js

@@ -1,232 +0,0 @@
-import { Command } from 'commander';
-import chalk from 'chalk';
-import ora from 'ora';
-import { StatusChecker } from '../../components/statusChecker.js';
-import { StatusFormatter, } from '../../ui/statusFormatter.js';
-/**
- * Enrich service with formatted details including version/revision
- */
-function enrichServiceDetails(service, _) {
-    const statusMap = {
-        healthy: { icon: '✓', text: 'healthy', color: 'green' },
-        unhealthy: { icon: '✗', text: 'unhealthy', color: 'red' },
-        warning: { icon: '⚠', text: 'warning', color: 'yellow' },
-        'not ready': { icon: '○', text: 'not ready', color: 'yellow' },
-        'not installed': { icon: '?', text: 'not installed', color: 'yellow' },
-    };
-    const statusInfo = statusMap[service.status] || {
-        icon: '?',
-        text: service.status,
-        color: 'yellow',
-    };
-    // Build details array
-    const details = [];
-    if (service.status === 'healthy') {
-        if (service.version)
-            details.push(service.version);
-        if (service.revision)
-            details.push(`revision ${service.revision}`);
-    }
-    if (service.details)
-        details.push(service.details);
-    // Build display name with formatting
-    let displayName = chalk.bold(service.name);
-    if (service.namespace) {
-        displayName += ` ${chalk.blue(service.namespace)}`;
-    }
-    if (service.isDev) {
-        displayName += ' (dev)';
-    }
-    return {
-        statusInfo,
-        displayName,
-        details: details.join(', '),
-    };
-}
-function buildStatusSections(data, config) {
-    const sections = [];
-    // Dependencies section
-    sections.push({
-        title: 'system dependencies:',
-        lines: data.dependencies.map((dep) => ({
-            icon: dep.installed ? '✓' : '✗',
-            iconColor: (dep.installed ? 'green' : 'red'),
-            status: dep.installed ? 'installed' : 'missing',
-            statusColor: (dep.installed ? 'green' : 'red'),
-            name: chalk.bold(dep.name),
-            details: dep.version || '',
-            subtext: dep.installed ? undefined : dep.details,
-        })),
-    });
-    // Cluster access section
-    const clusterLines = [];
-    if (data.clusterAccess) {
-        const contextName = data.clusterInfo?.context || 'kubernetes cluster';
-        const namespace = data.clusterInfo?.namespace || 'default';
-        // Add bold context name with blue namespace
-        const name = `${chalk.bold(contextName)} ${chalk.blue(namespace)}`;
-        const details = [];
-        if (data.clusterInfo?.type && data.clusterInfo.type !== 'unknown') {
-            details.push(data.clusterInfo.type);
-        }
-        if (data.clusterInfo?.ip) {
-            details.push(data.clusterInfo.ip);
-        }
-        clusterLines.push({
-            icon: '✓',
-            iconColor: 'green',
-            status: 'accessible',
-            statusColor: 'green',
-            name,
-            details: details.join(', '),
-        });
-    }
-    else {
-        clusterLines.push({
-            icon: '✗',
-            iconColor: 'red',
-            status: 'unreachable',
-            statusColor: 'red',
-            name: 'kubernetes cluster',
-            subtext: 'Install minikube: https://minikube.sigs.k8s.io/docs/start',
-        });
-    }
-    sections.push({ title: 'cluster access:', lines: clusterLines });
-    // Ark services section
-    if (data.clusterAccess) {
-        const serviceLines = data.services
-            .filter((s) => s.name !== 'ark-controller')
-            .map((service) => {
-            const { statusInfo, displayName, details } = enrichServiceDetails(service, config);
-            return {
-                icon: statusInfo.icon,
-                iconColor: statusInfo.color,
-                status: statusInfo.text,
-                statusColor: statusInfo.color,
-                name: displayName,
-                details: details,
-            };
-        });
-        sections.push({ title: 'ark services:', lines: serviceLines });
-    }
-    else {
-        sections.push({
-            title: 'ark services:',
-            lines: [
-                {
-                    icon: '',
-                    status: '',
-                    name: 'Cannot check ARK services - cluster not accessible',
-                },
-            ],
-        });
-    }
-    // Ark status section
-    const arkStatusLines = [];
-    if (!data.clusterAccess) {
-        arkStatusLines.push({
-            icon: '✗',
-            iconColor: 'red',
-            status: 'no cluster access',
-            statusColor: 'red',
-            name: '',
-        });
-    }
-    else {
-        const controller = data.services?.find((s) => s.name === 'ark-controller');
-        if (!controller) {
-            arkStatusLines.push({
-                icon: '○',
-                iconColor: 'yellow',
-                status: 'not ready',
-                statusColor: 'yellow',
-                name: 'ark-controller',
-            });
-        }
-        else {
-            const { statusInfo, displayName, details } = enrichServiceDetails(controller, config);
-            // Map service status to ark status display
-            const statusText = controller.status === 'healthy'
-                ? 'ready'
-                : controller.status === 'not installed'
-                    ? 'not ready'
-                    : controller.status;
-            arkStatusLines.push({
-                icon: statusInfo.icon,
-                iconColor: statusInfo.color,
-                status: statusText,
-                statusColor: statusInfo.color,
-                name: displayName,
-                details: details,
-                subtext: controller.status === 'healthy' && !data.defaultModelExists
-                    ? '(no default model configured)'
-                    : undefined,
-            });
-            // Add version update status as separate line
-            if (controller.status === 'healthy' && controller.version && config) {
-                if (config.latestVersion === undefined) {
-                    arkStatusLines.push({
-                        icon: '?',
-                        iconColor: 'yellow',
-                        status: 'version check',
-                        statusColor: 'yellow',
-                        name: '',
-                        details: 'unable to check for updates',
-                    });
-                }
-                else {
-                    // Use currentVersion from config if available, otherwise use controller.version
-                    const currentVersion = config.currentVersion || controller.version;
-                    if (currentVersion === config.latestVersion) {
-                        arkStatusLines.push({
-                            icon: '✓',
-                            iconColor: 'green',
-                            status: 'up to date',
-                            statusColor: 'green',
-                            name: '',
-                            details: config.latestVersion,
-                        });
-                    }
-                    else {
-                        arkStatusLines.push({
-                            icon: '↑',
-                            iconColor: 'yellow',
-                            status: 'update available',
-                            statusColor: 'yellow',
-                            name: '',
-                            details: config.latestVersion,
-                        });
-                    }
-                }
-            }
-        }
-    }
-    sections.push({ title: 'ark status:', lines: arkStatusLines });
-    return sections;
-}
-export async function checkStatus(config) {
-    const spinner = ora('Checking system status').start();
-    try {
-        spinner.text = 'Checking system dependencies';
-        const statusChecker = new StatusChecker();
-        spinner.text = 'Testing cluster access';
-        spinner.text = 'Checking ARK services';
-        const statusData = await statusChecker.checkAll();
-        spinner.stop();
-        const sections = buildStatusSections(statusData, config);
-        StatusFormatter.printSections(sections);
-        process.exit(0);
-    }
-    catch (error) {
-        spinner.fail('Failed to check status');
-        console.error(chalk.red('Error:'), error);
-        process.exit(1);
-    }
-}
-export function createStatusCommand(config) {
-    const statusCommand = new Command('status');
-    statusCommand
-        .description('Check ARK system status')
-        .action(() => checkStatus(config));
-    return statusCommand;
-}

package/dist/commands/status.d.ts

@@ -1,3 +0,0 @@
-import { Command } from 'commander';
-export declare function checkStatus(): Promise<void>;
-export declare function createStatusCommand(): Command;

package/dist/commands/status.js

@@ -1,33 +0,0 @@
-import { Command } from 'commander';
-import chalk from 'chalk';
-import ora from 'ora';
-import { StatusChecker } from '../components/statusChecker.js';
-import { ConfigManager } from '../config.js';
-import { ArkClient } from '../lib/arkClient.js';
-import { StatusFormatter } from '../ui/statusFormatter.js';
-export async function checkStatus() {
-    const spinner = ora('Checking system status').start();
-    try {
-        const configManager = new ConfigManager();
-        spinner.text = 'Checking system dependencies';
-        const apiBaseUrl = await configManager.getApiBaseUrl();
-        const arkClient = new ArkClient(apiBaseUrl);
-        const statusChecker = new StatusChecker(arkClient);
-        spinner.text = 'Testing cluster access';
-        spinner.text = 'Checking ARK services';
-        const statusData = await statusChecker.checkAll();
-        spinner.stop();
-        StatusFormatter.printStatus(statusData);
-        process.exit(0);
-    }
-    catch (error) {
-        spinner.fail('Failed to check status');
-        console.error(chalk.red('Error:'), error);
-        process.exit(1);
-    }
-}
-export function createStatusCommand() {
-    const statusCommand = new Command('status');
-    statusCommand.description('Check ARK system status').action(checkStatus);
-    return statusCommand;
-}

package/dist/commands/targets/index.d.ts

@@ -1,3 +0,0 @@
-import { Command } from 'commander';
-import type { ArkConfig } from '../../lib/config.js';
-export declare function createTargetsCommand(_: ArkConfig): Command;

package/dist/commands/targets/index.js

@@ -1,65 +0,0 @@
-import { Command } from 'commander';
-import output from '../../lib/output.js';
-import { ArkApiProxy } from '../../lib/arkApiProxy.js';
-async function listTargets(options) {
-    let proxy;
-    try {
-        proxy = new ArkApiProxy();
-        const arkApiClient = await proxy.start();
-        const allTargets = await arkApiClient.getQueryTargets();
-        // Filter by type if specified
-        let filteredTargets = allTargets;
-        if (options.type) {
-            filteredTargets = allTargets.filter((t) => t.type === options.type);
-        }
-        // Sort targets by type and name
-        filteredTargets.sort((a, b) => {
-            if (a.type !== b.type) {
-                return a.type.localeCompare(b.type);
-            }
-            return a.name.localeCompare(b.name);
-        });
-        if (options.output === 'json') {
-            console.log(JSON.stringify(filteredTargets, null, 2));
-        }
-        else {
-            if (filteredTargets.length === 0) {
-                output.warning('no targets available');
-                return;
-            }
-            // Simple list output with type/name format
-            for (const target of filteredTargets) {
-                console.log(target.id);
-            }
-        }
-    }
-    catch (error) {
-        output.error('fetching targets:', error instanceof Error ? error.message : error);
-        process.exit(1);
-    }
-    finally {
-        if (proxy) {
-            proxy.stop();
-        }
-    }
-}
-export function createTargetsCommand(_) {
-    const targets = new Command('targets');
-    targets
-        .description('list available query targets (agents, teams, models, tools)')
-        .option('-o, --output <format>', 'output format (json or text)', 'text')
-        .option('-t, --type <type>', 'filter by type (agent, team, model, tool)')
-        .action(async (options) => {
-        await listTargets(options);
-    });
-    targets
-        .command('list')
-        .alias('ls')
-        .description('list all available query targets')
-        .option('-o, --output <format>', 'output format (json or text)', 'text')
-        .option('-t, --type <type>', 'filter by type (agent, team, model, tool)')
-        .action(async (options) => {
-        await listTargets(options);
-    });
-    return targets;
-}

package/dist/commands/targets/index.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/commands/targets/index.spec.js

@@ -1,105 +0,0 @@
-import { jest } from '@jest/globals';
-import { Command } from 'commander';
-const mockArkApiClient = {
-    getQueryTargets: jest.fn(),
-};
-const mockStart = jest.fn();
-mockStart.mockResolvedValue(mockArkApiClient);
-const mockArkApiProxy = jest.fn();
-mockArkApiProxy.prototype = {
-    start: mockStart,
-    stop: jest.fn(),
-};
-jest.unstable_mockModule('../../lib/arkApiProxy.js', () => ({
-    ArkApiProxy: mockArkApiProxy,
-}));
-const mockOutput = {
-    warning: jest.fn(),
-    error: jest.fn(),
-};
-jest.unstable_mockModule('../../lib/output.js', () => ({
-    default: mockOutput,
-}));
-const mockExit = jest.spyOn(process, 'exit').mockImplementation((() => {
-    throw new Error('process.exit called');
-}));
-const mockConsoleLog = jest.spyOn(console, 'log').mockImplementation(() => { });
-const { createTargetsCommand } = await import('./index.js');
-describe('targets command', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    it('creates command with correct structure', () => {
-        const command = createTargetsCommand({});
-        expect(command).toBeInstanceOf(Command);
-        expect(command.name()).toBe('targets');
-    });
-    it('lists targets in text format', async () => {
-        const mockTargets = [
-            { id: 'agent/gpt-assistant', type: 'agent', name: 'gpt-assistant' },
-            { id: 'model/gpt-4', type: 'model', name: 'gpt-4' },
-        ];
-        mockArkApiClient.getQueryTargets.mockResolvedValue(mockTargets);
-        const command = createTargetsCommand({});
-        await command.parseAsync(['node', 'test']);
-        expect(mockArkApiProxy.prototype.start).toHaveBeenCalled();
-        expect(mockArkApiClient.getQueryTargets).toHaveBeenCalled();
-        expect(mockConsoleLog).toHaveBeenCalledWith('agent/gpt-assistant');
-        expect(mockConsoleLog).toHaveBeenCalledWith('model/gpt-4');
-        expect(mockArkApiProxy.prototype.stop).toHaveBeenCalled();
-    });
-    it('lists targets in json format', async () => {
-        const mockTargets = [{ id: 'agent/gpt', type: 'agent', name: 'gpt' }];
-        mockArkApiClient.getQueryTargets.mockResolvedValue(mockTargets);
-        const command = createTargetsCommand({});
-        await command.parseAsync(['node', 'test', '-o', 'json']);
-        expect(mockConsoleLog).toHaveBeenCalledWith(JSON.stringify(mockTargets, null, 2));
-    });
-    it('filters targets by type', async () => {
-        const mockTargets = [
-            { id: 'agent/gpt', type: 'agent', name: 'gpt' },
-            { id: 'model/claude', type: 'model', name: 'claude' },
-            { id: 'agent/helper', type: 'agent', name: 'helper' },
-        ];
-        mockArkApiClient.getQueryTargets.mockResolvedValue(mockTargets);
-        const command = createTargetsCommand({});
-        await command.parseAsync(['node', 'test', '-t', 'agent']);
-        expect(mockConsoleLog).toHaveBeenCalledWith('agent/gpt');
-        expect(mockConsoleLog).toHaveBeenCalledWith('agent/helper');
-        expect(mockConsoleLog).not.toHaveBeenCalledWith('model/claude');
-    });
-    it('sorts targets by type then name', async () => {
-        const mockTargets = [
-            { id: 'model/b', type: 'model', name: 'b' },
-            { id: 'agent/z', type: 'agent', name: 'z' },
-            { id: 'agent/a', type: 'agent', name: 'a' },
-            { id: 'model/a', type: 'model', name: 'a' },
-        ];
-        mockArkApiClient.getQueryTargets.mockResolvedValue(mockTargets);
-        const command = createTargetsCommand({});
-        await command.parseAsync(['node', 'test']);
-        // Check order of calls
-        const calls = mockConsoleLog.mock.calls.map((call) => call[0]);
-        expect(calls).toEqual(['agent/a', 'agent/z', 'model/a', 'model/b']);
-    });
-    it('shows warning when no targets', async () => {
-        mockArkApiClient.getQueryTargets.mockResolvedValue([]);
-        const command = createTargetsCommand({});
-        await command.parseAsync(['node', 'test']);
-        expect(mockOutput.warning).toHaveBeenCalledWith('no targets available');
-    });
-    it('handles errors and stops proxy', async () => {
-        mockArkApiClient.getQueryTargets.mockRejectedValue(new Error('API failed'));
-        const command = createTargetsCommand({});
-        await expect(command.parseAsync(['node', 'test'])).rejects.toThrow('process.exit called');
-        expect(mockOutput.error).toHaveBeenCalledWith('fetching targets:', 'API failed');
-        expect(mockExit).toHaveBeenCalledWith(1);
-        expect(mockArkApiProxy.prototype.stop).toHaveBeenCalled();
-    });
-    it('list subcommand works', async () => {
-        mockArkApiClient.getQueryTargets.mockResolvedValue([]);
-        const command = createTargetsCommand({});
-        await command.parseAsync(['node', 'test', 'list']);
-        expect(mockArkApiClient.getQueryTargets).toHaveBeenCalled();
-    });
-});

package/dist/commands/targets.d.ts

@@ -1,2 +0,0 @@
-import { Command } from 'commander';
-export declare function createTargetsCommand(): Command;

package/dist/commands/targets.js

@@ -1,65 +0,0 @@
-import { Command } from 'commander';
-import output from '../lib/output.js';
-import { ArkApiProxy } from '../lib/arkApiProxy.js';
-async function listTargets(options) {
-    let proxy;
-    try {
-        proxy = new ArkApiProxy();
-        const arkApiClient = await proxy.start();
-        const allTargets = await arkApiClient.getQueryTargets();
-        // Filter by type if specified
-        let filteredTargets = allTargets;
-        if (options.type) {
-            filteredTargets = allTargets.filter((t) => t.type === options.type);
-        }
-        // Sort targets by type and name
-        filteredTargets.sort((a, b) => {
-            if (a.type !== b.type) {
-                return a.type.localeCompare(b.type);
-            }
-            return a.name.localeCompare(b.name);
-        });
-        if (options.output === 'json') {
-            console.log(JSON.stringify(filteredTargets, null, 2));
-        }
-        else {
-            if (filteredTargets.length === 0) {
-                output.warning('no targets available');
-                return;
-            }
-            // Simple list output with type/name format
-            for (const target of filteredTargets) {
-                console.log(target.id);
-            }
-        }
-    }
-    catch (error) {
-        output.error('fetching targets:', error instanceof Error ? error.message : error);
-        process.exit(1);
-    }
-    finally {
-        if (proxy) {
-            proxy.stop();
-        }
-    }
-}
-export function createTargetsCommand() {
-    const targets = new Command('targets');
-    targets
-        .description('list available query targets (agents, teams, models, tools)')
-        .option('-o, --output <format>', 'output format (json or text)', 'text')
-        .option('-t, --type <type>', 'filter by type (agent, team, model, tool)')
-        .action(async (options) => {
-        await listTargets(options);
-    });
-    targets
-        .command('list')
-        .alias('ls')
-        .description('list all available query targets')
-        .option('-o, --output <format>', 'output format (json or text)', 'text')
-        .option('-t, --type <type>', 'filter by type (agent, team, model, tool)')
-        .action(async (options) => {
-        await listTargets(options);
-    });
-    return targets;
-}

package/dist/commands/teams/index.d.ts

@@ -1,3 +0,0 @@
-import { Command } from 'commander';
-import type { ArkConfig } from '../../lib/config.js';
-export declare function createTeamsCommand(_: ArkConfig): Command;