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

package/dist/arkServices.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Centralized ARK service definitions used by both install and status commands
+ */
+export interface ArkService {
+    name: string;
+    helmReleaseName: string;
+    description: string;
+    enabled: boolean;
+    namespace?: string;
+    chartPath?: string;
+    installArgs?: string[];
+    k8sServiceName?: string;
+    k8sServicePort?: number;
+    k8sPortForwardLocalPort?: number;
+    k8sDeploymentName?: string;
+    k8sDevDeploymentName?: string;
+}
+export interface ServiceCollection {
+    [key: string]: ArkService;
+}
+export interface ArkDependency {
+    name: string;
+    command: string;
+    args: string[];
+    description: string;
+}
+export interface DependencyCollection {
+    [key: string]: ArkDependency;
+}
+/**
+ * Dependencies that should be installed before ARK services
+ * Note: Dependencies will be installed in the order they are defined here
+ */
+export declare const arkDependencies: DependencyCollection;
+/**
+ * Core ARK services with their installation and status check configurations
+ */
+export declare const arkServices: ServiceCollection;
+/**
+ * Get services that can be installed via Helm charts (only enabled services)
+ */
+export declare function getInstallableServices(): ServiceCollection;

package/dist/arkServices.js

@@ -0,0 +1,138 @@
+/**
+ * Centralized ARK service definitions used by both install and status commands
+ */
+const REGISTRY_BASE = 'oci://ghcr.io/mckinsey/agents-at-scale-ark/charts';
+/**
+ * Dependencies that should be installed before ARK services
+ * Note: Dependencies will be installed in the order they are defined here
+ */
+export const arkDependencies = {
+    'cert-manager-repo': {
+        name: 'cert-manager-repo',
+        command: 'helm',
+        args: [
+            'repo',
+            'add',
+            'jetstack',
+            'https://charts.jetstack.io',
+            '--force-update',
+        ],
+        description: 'Add Jetstack Helm repository',
+    },
+    'helm-repo-update': {
+        name: 'helm-repo-update',
+        command: 'helm',
+        args: ['repo', 'update'],
+        description: 'Update Helm repositories',
+    },
+    'cert-manager': {
+        name: 'cert-manager',
+        command: 'helm',
+        args: [
+            'upgrade',
+            '--install',
+            'cert-manager',
+            'jetstack/cert-manager',
+            '--namespace',
+            'cert-manager',
+            '--create-namespace',
+            '--set',
+            'crds.enabled=true',
+        ],
+        description: 'Certificate management for Kubernetes',
+    },
+    'gateway-api-crds': {
+        name: 'gateway-api-crds',
+        command: 'kubectl',
+        args: [
+            'apply',
+            '-f',
+            'https://github.com/kubernetes-sigs/gateway-api/releases/download/v1.3.0/standard-install.yaml',
+        ],
+        description: 'Gateway API CRDs',
+    },
+};
+/**
+ * Core ARK services with their installation and status check configurations
+ */
+export const arkServices = {
+    'ark-controller': {
+        name: 'ark-controller',
+        helmReleaseName: 'ark-controller',
+        description: 'Core ARK controller for managing AI resources',
+        enabled: true,
+        namespace: 'ark-system',
+        chartPath: `${REGISTRY_BASE}/ark-controller`,
+        installArgs: ['--create-namespace', '--set', 'rbac.enable=true'],
+        k8sDeploymentName: 'ark-controller',
+        k8sDevDeploymentName: 'ark-controller-devspace',
+    },
+    'ark-api': {
+        name: 'ark-api',
+        helmReleaseName: 'ark-api',
+        description: 'ARK API service for interacting with ARK resources',
+        enabled: true,
+        // namespace: undefined - uses current context namespace
+        chartPath: `${REGISTRY_BASE}/ark-api`,
+        installArgs: [],
+        k8sServiceName: 'ark-api',
+        k8sServicePort: 80,
+        k8sDeploymentName: 'ark-api',
+        k8sDevDeploymentName: 'ark-api-devspace',
+        k8sPortForwardLocalPort: 34780,
+    },
+    'ark-dashboard': {
+        name: 'ark-dashboard',
+        helmReleaseName: 'ark-dashboard',
+        description: 'Web-based dashboard for ARK',
+        enabled: true,
+        // namespace: undefined - uses current context namespace
+        chartPath: `${REGISTRY_BASE}/ark-dashboard`,
+        installArgs: [],
+        k8sServiceName: 'ark-dashboard',
+        k8sServicePort: 3000,
+        k8sDeploymentName: 'ark-dashboard',
+        k8sDevDeploymentName: 'ark-dashboard-devspace',
+        k8sPortForwardLocalPort: 3274,
+    },
+    'ark-api-a2a': {
+        name: 'ark-api-a2a',
+        helmReleaseName: 'ark-api-a2a',
+        description: 'ARK API agent-to-agent communication service',
+        enabled: false, // Disabled - not currently used
+        // namespace: undefined - uses current context namespace
+        // Note: This service might be installed as part of ark-api or separately
+    },
+    'ark-mcp': {
+        name: 'ark-mcp',
+        helmReleaseName: 'ark-mcp',
+        description: 'MCP (Model Context Protocol) services for ARK',
+        enabled: true,
+        // namespace: undefined - uses current context namespace
+        chartPath: `${REGISTRY_BASE}/ark-mcp`,
+        installArgs: [],
+        k8sDeploymentName: 'ark-mcp',
+        k8sDevDeploymentName: 'ark-mcp-devspace',
+    },
+    'localhost-gateway': {
+        name: 'localhost-gateway',
+        helmReleaseName: 'localhost-gateway',
+        description: 'Gateway for local cluster access',
+        enabled: true,
+        namespace: 'ark-system',
+        chartPath: `${REGISTRY_BASE}/localhost-gateway`,
+        installArgs: [],
+    },
+};
+/**
+ * Get services that can be installed via Helm charts (only enabled services)
+ */
+export function getInstallableServices() {
+    const installable = {};
+    for (const [key, service] of Object.entries(arkServices)) {
+        if (service.enabled && service.chartPath) {
+            installable[key] = service;
+        }
+    }
+    return installable;
+}

package/dist/arkServices.spec.d.ts

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

package/dist/arkServices.spec.js

@@ -0,0 +1,24 @@
+import { arkDependencies, arkServices, getInstallableServices, } from './arkServices.js';
+describe('arkServices', () => {
+    it('exports arkDependencies with expected structure', () => {
+        expect(arkDependencies).toBeDefined();
+        expect(arkDependencies['cert-manager']).toBeDefined();
+        expect(arkDependencies['cert-manager'].command).toBe('helm');
+    });
+    it('exports arkServices with expected structure', () => {
+        expect(arkServices).toBeDefined();
+        expect(arkServices['ark-controller']).toBeDefined();
+        expect(arkServices['ark-controller'].namespace).toBe('ark-system');
+        // User services should have undefined namespace (use current context)
+        expect(arkServices['ark-api'].namespace).toBeUndefined();
+        expect(arkServices['ark-dashboard'].namespace).toBeUndefined();
+        // System services should have explicit namespace
+        expect(arkServices['localhost-gateway'].namespace).toBe('ark-system');
+    });
+    it('getInstallableServices returns services with chartPath', () => {
+        const installable = getInstallableServices();
+        expect(installable['ark-controller']).toBeDefined();
+        expect(installable['ark-api']).toBeDefined();
+        expect(installable['ark-api-a2a']).toBeUndefined(); // no chartPath
+    });
+});

package/dist/charts/charts.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @deprecated Use arkServices.ts instead. This file is kept for backward compatibility.
+ * Charts are now defined in arkServices.ts with comprehensive service definitions.
+ */
+export declare const charts: import("../arkServices.js").ServiceCollection;

package/dist/charts/charts.js

@@ -0,0 +1,6 @@
+import { getInstallableServices } from '../arkServices.js';
+/**
+ * @deprecated Use arkServices.ts instead. This file is kept for backward compatibility.
+ * Charts are now defined in arkServices.ts with comprehensive service definitions.
+ */
+export const charts = getInstallableServices();

package/dist/charts/dependencies.d.ts

@@ -0,0 +1,6 @@
+import { DependencyCollection } from './types.js';
+/**
+ * Dependencies that should be installed before ARK charts
+ * Note: Dependencies will be installed in the order they are defined here
+ */
+export declare const dependencies: DependencyCollection;

package/dist/charts/dependencies.js

@@ -0,0 +1,50 @@
+/**
+ * Dependencies that should be installed before ARK charts
+ * Note: Dependencies will be installed in the order they are defined here
+ */
+export const dependencies = {
+    'cert-manager-repo': {
+        name: 'cert-manager-repo',
+        command: 'helm',
+        args: [
+            'repo',
+            'add',
+            'jetstack',
+            'https://charts.jetstack.io',
+            '--force-update',
+        ],
+        description: 'Add Jetstack Helm repository',
+    },
+    'helm-repo-update': {
+        name: 'helm-repo-update',
+        command: 'helm',
+        args: ['repo', 'update'],
+        description: 'Update Helm repositories',
+    },
+    'cert-manager': {
+        name: 'cert-manager',
+        command: 'helm',
+        args: [
+            'upgrade',
+            '--install',
+            'cert-manager',
+            'jetstack/cert-manager',
+            '--namespace',
+            'cert-manager',
+            '--create-namespace',
+            '--set',
+            'crds.enabled=true',
+        ],
+        description: 'Certificate management for Kubernetes',
+    },
+    'gateway-api-crds': {
+        name: 'gateway-api-crds',
+        command: 'kubectl',
+        args: [
+            'apply',
+            '-f',
+            'https://github.com/kubernetes-sigs/gateway-api/releases/download/v1.3.0/standard-install.yaml',
+        ],
+        description: 'Gateway API CRDs',
+    },
+};

package/dist/charts/types.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Represents a Helm chart configuration for ARK components
+ */
+export interface ArkChart {
+    /** Name of the chart (used as release name) */
+    name: string;
+    /** Full chart path (OCI registry or local path) */
+    chartPath: string;
+    /** Kubernetes namespace to install into */
+    namespace: string;
+    /** Additional arguments to pass to helm (e.g., --create-namespace, --wait, --timeout 300s, --set key=value) */
+    args?: string[];
+    /** Description of what this chart provides */
+    description?: string;
+}
+/**
+ * Collection of ARK charts
+ */
+export interface ChartCollection {
+    [key: string]: ArkChart;
+}
+/**
+ * Represents a dependency that needs to be installed
+ */
+export interface Dependency {
+    /** Name of the dependency */
+    name: string;
+    /** Command to execute (helm, kubectl, etc.) */
+    command: string;
+    /** Arguments to pass to the command */
+    args: string[];
+    /** Description of what this dependency provides */
+    description?: string;
+}
+/**
+ * Collection of dependencies
+ */
+export interface DependencyCollection {
+    [key: string]: Dependency;
+}

package/dist/charts/types.js

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

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

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

package/dist/commands/agents/index.js

@@ -0,0 +1,51 @@
+import { Command } from 'commander';
+import { execa } from 'execa';
+import output from '../../lib/output.js';
+async function listAgents(options) {
+    try {
+        // Use kubectl to get agents
+        const result = await execa('kubectl', ['get', 'agents', '-o', 'json'], {
+            stdio: 'pipe',
+        });
+        const data = JSON.parse(result.stdout);
+        const agents = data.items || [];
+        if (options.output === 'json') {
+            // Output the raw items for JSON format
+            console.log(JSON.stringify(agents, null, 2));
+        }
+        else {
+            if (agents.length === 0) {
+                output.warning('no agents available');
+                return;
+            }
+            // Simple list output - just agent names
+            agents.forEach((agent) => {
+                console.log(agent.metadata.name);
+            });
+        }
+    }
+    catch (error) {
+        output.error('fetching agents:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+}
+export function createAgentsCommand(_) {
+    const agentsCommand = new Command('agents');
+    agentsCommand
+        .description('list available agents')
+        .alias('agent')
+        .option('-o, --output <format>', 'output format (json or text)', 'text')
+        .action(async (options) => {
+        await listAgents(options);
+    });
+    // Add list subcommand (same as default action)
+    agentsCommand
+        .command('list')
+        .alias('ls')
+        .description('list all available agents')
+        .option('-o, --output <format>', 'output format (json or text)', 'text')
+        .action(async (options) => {
+        await listAgents(options);
+    });
+    return agentsCommand;
+}

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

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

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

@@ -0,0 +1,67 @@
+import { jest } from '@jest/globals';
+import { Command } from 'commander';
+const mockExeca = jest.fn();
+jest.unstable_mockModule('execa', () => ({
+    execa: mockExeca,
+}));
+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 { createAgentsCommand } = await import('./index.js');
+describe('agents command', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('creates command with correct structure', () => {
+        const command = createAgentsCommand({});
+        expect(command).toBeInstanceOf(Command);
+        expect(command.name()).toBe('agents');
+    });
+    it('lists agents in text format', async () => {
+        const mockAgents = {
+            items: [{ metadata: { name: 'agent1' } }, { metadata: { name: 'agent2' } }],
+        };
+        mockExeca.mockResolvedValue({ stdout: JSON.stringify(mockAgents) });
+        const command = createAgentsCommand({});
+        await command.parseAsync(['node', 'test']);
+        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'agents', '-o', 'json'], { stdio: 'pipe' });
+        expect(mockConsoleLog).toHaveBeenCalledWith('agent1');
+        expect(mockConsoleLog).toHaveBeenCalledWith('agent2');
+    });
+    it('lists agents in json format', async () => {
+        const mockAgents = {
+            items: [{ metadata: { name: 'agent1' } }],
+        };
+        mockExeca.mockResolvedValue({ stdout: JSON.stringify(mockAgents) });
+        const command = createAgentsCommand({});
+        await command.parseAsync(['node', 'test', '-o', 'json']);
+        expect(mockConsoleLog).toHaveBeenCalledWith(JSON.stringify(mockAgents.items, null, 2));
+    });
+    it('shows warning when no agents', async () => {
+        mockExeca.mockResolvedValue({ stdout: JSON.stringify({ items: [] }) });
+        const command = createAgentsCommand({});
+        await command.parseAsync(['node', 'test']);
+        expect(mockOutput.warning).toHaveBeenCalledWith('no agents available');
+    });
+    it('handles errors', async () => {
+        mockExeca.mockRejectedValue(new Error('kubectl failed'));
+        const command = createAgentsCommand({});
+        await expect(command.parseAsync(['node', 'test'])).rejects.toThrow('process.exit called');
+        expect(mockOutput.error).toHaveBeenCalledWith('fetching agents:', 'kubectl failed');
+        expect(mockExit).toHaveBeenCalledWith(1);
+    });
+    it('list subcommand works', async () => {
+        mockExeca.mockResolvedValue({ stdout: JSON.stringify({ items: [] }) });
+        const command = createAgentsCommand({});
+        await command.parseAsync(['node', 'test', 'list']);
+        expect(mockExeca).toHaveBeenCalled();
+    });
+});

package/dist/commands/agents/selector.d.ts

@@ -0,0 +1,8 @@
+import { Agent, ArkApiClient } from '../../lib/arkApiClient.js';
+interface AgentSelectorProps {
+    arkApiClient: ArkApiClient;
+    onSelect: (agent: Agent) => void;
+    onExit: () => void;
+}
+export declare function AgentSelector({ arkApiClient, onSelect, onExit, }: AgentSelectorProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/commands/agents/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 AgentSelector({ arkApiClient, onSelect, onExit, }) {
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    const [agents, setAgents] = useState([]);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    useEffect(() => {
+        arkApiClient
+            .getAgents()
+            .then((fetchedAgents) => {
+            setAgents(fetchedAgents);
+            setLoading(false);
+        })
+            .catch((err) => {
+            setError(err.message || 'Failed to fetch agents');
+            setLoading(false);
+        });
+    }, [arkApiClient]);
+    useInput((input, key) => {
+        if (key.escape) {
+            onExit();
+        }
+        else if (key.upArrow || input === 'k') {
+            setSelectedIndex((prev) => (prev === 0 ? agents.length - 1 : prev - 1));
+        }
+        else if (key.downArrow || input === 'j') {
+            setSelectedIndex((prev) => (prev === agents.length - 1 ? 0 : prev + 1));
+        }
+        else if (key.return) {
+            onSelect(agents[selectedIndex]);
+        }
+        else {
+            // Handle number keys for quick selection
+            const num = parseInt(input, 10);
+            if (!isNaN(num) && num >= 1 && num <= agents.length) {
+                onSelect(agents[num - 1]);
+            }
+        }
+    });
+    if (loading) {
+        return (_jsx(Box, { children: _jsx(Text, { children: "Loading agents..." }) }));
+    }
+    if (error) {
+        return (_jsx(Box, { children: _jsxs(Text, { color: "red", children: ["Error: ", error] }) }));
+    }
+    if (agents.length === 0) {
+        return (_jsx(Box, { children: _jsx(Text, { children: "No agents available" }) }));
+    }
+    const selectedAgent = agents[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 Agent" }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: "Choose an agent to start a conversation with" }) }), _jsx(Box, { flexDirection: "column", children: agents.map((agent, index) => (_jsx(Box, { marginBottom: 0, children: _jsxs(Text, { color: index === selectedIndex ? 'green' : undefined, children: [index === selectedIndex ? '❯ ' : '  ', index + 1, ". ", agent.name] }) }, agent.name))) }), selectedAgent.description && (_jsx(Box, { marginTop: 1, paddingLeft: 2, children: _jsx(Text, { dimColor: true, wrap: "wrap", children: selectedAgent.description }) })), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Enter to confirm \u00B7 Number to select \u00B7 Esc to exit" }) })] }));
+}

package/dist/commands/agents.d.ts

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

package/dist/commands/agents.js

@@ -0,0 +1,53 @@
+import { Command } from 'commander';
+import { ArkApiProxy } from '../lib/arkApiProxy.js';
+import output from '../lib/output.js';
+async function listAgents(options) {
+    let proxy;
+    try {
+        proxy = new ArkApiProxy();
+        const arkApiClient = await proxy.start();
+        const agents = await arkApiClient.getAgents();
+        if (options.output === 'json') {
+            console.log(JSON.stringify(agents, null, 2));
+        }
+        else {
+            if (agents.length === 0) {
+                output.warning('no agents available');
+                return;
+            }
+            // Simple list output - just agent names with namespace prefix
+            agents.forEach(agent => {
+                console.log(`agent/${agent.name}`);
+            });
+        }
+    }
+    catch (error) {
+        output.error('fetching agents:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+    finally {
+        if (proxy) {
+            proxy.stop();
+        }
+    }
+}
+export function createAgentsCommand() {
+    const agentsCommand = new Command('agents');
+    agentsCommand
+        .description('list available agents')
+        .alias('agent')
+        .option('-o, --output <format>', 'output format (json or text)', 'text')
+        .action(async (options) => {
+        await listAgents(options);
+    });
+    // Add list subcommand (same as default action)
+    agentsCommand
+        .command('list')
+        .alias('ls')
+        .description('list all available agents')
+        .option('-o, --output <format>', 'output format (json or text)', 'text')
+        .action(async (options) => {
+        await listAgents(options);
+    });
+    return agentsCommand;
+}

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

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

package/dist/commands/chat/index.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Command } from 'commander';
+import { render } from 'ink';
+import ChatUI from '../../components/ChatUI.js';
+import { ArkApiProxy } from '../../lib/arkApiProxy.js';
+import output from '../../lib/output.js';
+export function createChatCommand(config) {
+    const chatCommand = new Command('chat');
+    chatCommand
+        .description('Start an interactive chat session with ARK agents or models')
+        .argument('[target]', 'Target to connect to (e.g., agent/sample-agent, model/default)')
+        .action(async (targetArg) => {
+        // Direct target argument (e.g., "agent/sample-agent")
+        const initialTargetId = targetArg;
+        // Config is passed from main
+        // Initialize proxy first - no spinner, just let ChatUI handle loading state
+        try {
+            const proxy = new ArkApiProxy();
+            const arkApiClient = await proxy.start();
+            // Pass the initialized client and config to ChatUI
+            render(_jsx(ChatUI, { initialTargetId: initialTargetId, arkApiClient: arkApiClient, arkApiProxy: proxy, config: config }));
+        }
+        catch (error) {
+            output.error(error instanceof Error ? error.message : 'ARK API connection failed');
+            process.exit(1);
+        }
+    });
+    return chatCommand;
+}

package/dist/commands/chat.d.ts

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

package/dist/commands/chat.js

@@ -0,0 +1,45 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Command } from 'commander';
+import { render } from 'ink';
+import ChatUI from '../components/ChatUI.js';
+import { ArkApiProxy } from '../lib/arkApiProxy.js';
+import { loadConfig } from '../lib/config.js';
+import output from '../lib/output.js';
+export function createChatCommand() {
+    const chatCommand = new Command('chat');
+    chatCommand
+        .description('Start an interactive chat session with ARK agents or models')
+        .argument('[target]', 'Target to connect to (e.g., agent/sample-agent, model/default)')
+        .option('-a, --agent <name>', 'Connect directly to a specific agent')
+        .option('-m, --model <name>', 'Connect directly to a specific model')
+        .action(async (targetArg, options) => {
+        // Determine initial target from argument or options
+        let initialTargetId;
+        if (targetArg) {
+            // Direct target argument (e.g., "agent/sample-agent")
+            initialTargetId = targetArg;
+        }
+        else if (options.agent) {
+            // Agent option
+            initialTargetId = `agent/${options.agent}`;
+        }
+        else if (options.model) {
+            // Model option
+            initialTargetId = `model/${options.model}`;
+        }
+        // Load config
+        const config = loadConfig();
+        // Initialize proxy first - no spinner, just let ChatUI handle loading state
+        try {
+            const proxy = new ArkApiProxy();
+            const arkApiClient = await proxy.start();
+            // Pass the initialized client and config to ChatUI
+            render(_jsx(ChatUI, { initialTargetId: initialTargetId, arkApiClient: arkApiClient, arkApiProxy: proxy, config: config }));
+        }
+        catch (error) {
+            output.error(error instanceof Error ? error.message : 'ARK API connection failed');
+            process.exit(1);
+        }
+    });
+    return chatCommand;
+}

package/dist/commands/cluster/get.d.ts

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