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

package/dist/commands/models/selector.js

@@ -0,0 +1,53 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect } from 'react';
+import { Box, Text, useInput } from 'ink';
+export function ModelSelector({ arkApiClient, onSelect, onExit, }) {
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    const [models, setModels] = useState([]);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    useEffect(() => {
+        arkApiClient
+            .getModels()
+            .then((fetchedModels) => {
+            setModels(fetchedModels);
+            setLoading(false);
+        })
+            .catch((err) => {
+            setError(err.message || 'Failed to fetch models');
+            setLoading(false);
+        });
+    }, [arkApiClient]);
+    useInput((input, key) => {
+        if (key.escape) {
+            onExit();
+        }
+        else if (key.upArrow || input === 'k') {
+            setSelectedIndex((prev) => (prev === 0 ? models.length - 1 : prev - 1));
+        }
+        else if (key.downArrow || input === 'j') {
+            setSelectedIndex((prev) => (prev === models.length - 1 ? 0 : prev + 1));
+        }
+        else if (key.return) {
+            onSelect(models[selectedIndex]);
+        }
+        else {
+            // Handle number keys for quick selection
+            const num = parseInt(input, 10);
+            if (!isNaN(num) && num >= 1 && num <= models.length) {
+                onSelect(models[num - 1]);
+            }
+        }
+    });
+    if (loading) {
+        return (_jsx(Box, { children: _jsx(Text, { children: "Loading models..." }) }));
+    }
+    if (error) {
+        return (_jsx(Box, { children: _jsxs(Text, { color: "red", children: ["Error: ", error] }) }));
+    }
+    if (models.length === 0) {
+        return (_jsx(Box, { children: _jsx(Text, { children: "No models available" }) }));
+    }
+    const selectedModel = models[selectedIndex];
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 2, paddingY: 1, children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, children: "Select Model" }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: "Choose a model to start a conversation with" }) }), _jsx(Box, { flexDirection: "column", children: models.map((model, index) => (_jsx(Box, { marginBottom: 0, children: _jsxs(Text, { color: index === selectedIndex ? 'green' : undefined, children: [index === selectedIndex ? '❯ ' : '  ', index + 1, ". ", model.name, model.type ? ` (${model.type})` : ''] }) }, model.name))) }), selectedModel && selectedModel.model && (_jsx(Box, { marginTop: 1, paddingLeft: 2, children: _jsxs(Text, { dimColor: true, wrap: "wrap", children: ["Model: ", selectedModel.model] }) })), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Enter to confirm \u00B7 Number to select \u00B7 Esc to exit" }) })] }));
+}

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

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

package/dist/commands/query/index.js

@@ -0,0 +1,24 @@
+import { Command } from 'commander';
+import output from '../../lib/output.js';
+import { executeQuery, parseTarget } from '../../lib/executeQuery.js';
+export function createQueryCommand(_) {
+    const queryCommand = new Command('query');
+    queryCommand
+        .description('Execute a single query against a model or agent')
+        .argument('<target>', 'Query target (e.g., model/default, agent/my-agent)')
+        .argument('<message>', 'Message to send')
+        .action(async (target, message) => {
+        // Parse and validate target format
+        const parsed = parseTarget(target);
+        if (!parsed) {
+            output.error('Invalid target format. Use: model/name or agent/name etc');
+            process.exit(1);
+        }
+        await executeQuery({
+            targetType: parsed.type,
+            targetName: parsed.name,
+            message,
+        });
+    });
+    return queryCommand;
+}

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

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

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

@@ -0,0 +1,53 @@
+import { jest } from '@jest/globals';
+import { Command } from 'commander';
+const mockExecuteQuery = jest.fn();
+const mockParseTarget = jest.fn();
+jest.unstable_mockModule('../../lib/executeQuery.js', () => ({
+    executeQuery: mockExecuteQuery,
+    parseTarget: mockParseTarget,
+}));
+const mockOutput = {
+    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 { createQueryCommand } = await import('./index.js');
+describe('createQueryCommand', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('should create a query command', () => {
+        const command = createQueryCommand({});
+        expect(command).toBeInstanceOf(Command);
+        expect(command.name()).toBe('query');
+        expect(command.description()).toBe('Execute a single query against a model or agent');
+    });
+    it('should parse and execute query with valid target', async () => {
+        mockParseTarget.mockReturnValue({
+            type: 'model',
+            name: 'default',
+        });
+        mockExecuteQuery.mockResolvedValue(undefined);
+        const command = createQueryCommand({});
+        await command.parseAsync(['node', 'test', 'model/default', 'Hello world']);
+        expect(mockParseTarget).toHaveBeenCalledWith('model/default');
+        expect(mockExecuteQuery).toHaveBeenCalledWith({
+            targetType: 'model',
+            targetName: 'default',
+            message: 'Hello world',
+        });
+    });
+    it('should error on invalid target format', async () => {
+        mockParseTarget.mockReturnValue(null);
+        const command = createQueryCommand({});
+        await expect(command.parseAsync(['node', 'test', 'invalid-target', 'Hello'])).rejects.toThrow('process.exit called');
+        expect(mockParseTarget).toHaveBeenCalledWith('invalid-target');
+        expect(mockExecuteQuery).not.toHaveBeenCalled();
+        expect(mockOutput.error).toHaveBeenCalledWith('Invalid target format. Use: model/name or agent/name etc');
+        expect(mockExit).toHaveBeenCalledWith(1);
+    });
+});

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

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

package/dist/commands/routes/index.js

@@ -0,0 +1,93 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { execa } from 'execa';
+import output from '../../lib/output.js';
+async function listRoutes() {
+    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/routes.d.ts

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

package/dist/commands/routes.js

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

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

package/dist/commands/status/index.js

@@ -0,0 +1,281 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { StatusChecker } from '../../components/statusChecker.js';
+import { StatusFormatter, } from '../../ui/statusFormatter.js';
+import { fetchVersionInfo } from '../../lib/versions.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, versionInfo) {
+    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);
+            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);
+            // 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,
+            });
+            // Add version update status as separate line
+            if (controller.status === 'healthy' && versionInfo) {
+                const currentVersion = versionInfo.current || controller.version;
+                if (!currentVersion) {
+                    // Version is unknown
+                    arkStatusLines.push({
+                        icon: '?',
+                        iconColor: 'yellow',
+                        status: 'version unknown',
+                        statusColor: 'yellow',
+                        name: '',
+                        details: versionInfo.latest
+                            ? `latest: ${versionInfo.latest}`
+                            : 'unable to determine version',
+                    });
+                }
+                else if (versionInfo.latest === undefined) {
+                    // Have current version but couldn't check for updates
+                    arkStatusLines.push({
+                        icon: '?',
+                        iconColor: 'yellow',
+                        status: `version ${currentVersion}`,
+                        statusColor: 'yellow',
+                        name: '',
+                        details: 'unable to check for updates',
+                    });
+                }
+                else {
+                    // Have both current and latest versions
+                    if (currentVersion === versionInfo.latest) {
+                        arkStatusLines.push({
+                            icon: '✓',
+                            iconColor: 'green',
+                            status: 'up to date',
+                            statusColor: 'green',
+                            name: '',
+                            details: versionInfo.latest,
+                        });
+                    }
+                    else {
+                        arkStatusLines.push({
+                            icon: '↑',
+                            iconColor: 'yellow',
+                            status: 'update available',
+                            statusColor: 'yellow',
+                            name: '',
+                            details: `${currentVersion} → ${versionInfo.latest}`,
+                        });
+                    }
+                }
+            }
+            // Add default model status
+            if (data.defaultModel) {
+                if (!data.defaultModel.exists) {
+                    arkStatusLines.push({
+                        icon: '○',
+                        iconColor: 'yellow',
+                        status: 'default model',
+                        statusColor: 'yellow',
+                        name: '',
+                        details: 'not configured',
+                    });
+                }
+                else if (data.defaultModel.available) {
+                    arkStatusLines.push({
+                        icon: '●',
+                        iconColor: 'green',
+                        status: 'default model',
+                        statusColor: 'green',
+                        name: '',
+                        details: data.defaultModel.provider || 'configured',
+                    });
+                }
+                else {
+                    arkStatusLines.push({
+                        icon: '●',
+                        iconColor: 'yellow',
+                        status: 'default model',
+                        statusColor: 'yellow',
+                        name: '',
+                        details: 'not available',
+                    });
+                }
+            }
+        }
+    }
+    sections.push({ title: 'ark status:', lines: arkStatusLines });
+    return sections;
+}
+export async function checkStatus() {
+    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';
+        // Run status check and version fetch in parallel
+        const [statusData, versionInfo] = await Promise.all([
+            statusChecker.checkAll(),
+            fetchVersionInfo(),
+        ]);
+        spinner.stop();
+        const sections = buildStatusSections(statusData, versionInfo);
+        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() {
+    const statusCommand = new Command('status');
+    statusCommand
+        .description('Check ARK system status')
+        .action(() => checkStatus());
+    return statusCommand;
+}

package/dist/commands/status.d.ts

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

package/dist/commands/status.js

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

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