@agents-at-scale/ark 0.1.35 → 0.1.36

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: 'API layer 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: 'Ark Dashboard',
+        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: 'Ark Model Context Protocol server',
+        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 development clusters',
+        enabled: false, // Disabled - not needed for most users
+        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/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,65 @@
+import { Command } from 'commander';
+import { execa } from 'execa';
+import output from '../../lib/output.js';
+import { executeQuery } from '../../lib/executeQuery.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);
+    });
+    // Add query subcommand
+    agentsCommand
+        .command('query')
+        .description('Query an agent')
+        .argument('<name>', 'Agent name')
+        .argument('<message>', 'Message to send')
+        .action(async (name, message) => {
+        await executeQuery({
+            targetType: 'agent',
+            targetName: name,
+            message,
+        });
+    });
+    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/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/cluster/get.d.ts

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

package/dist/commands/cluster/get.js

@@ -0,0 +1,39 @@
+import { Command } from 'commander';
+import output from '../../lib/output.js';
+import { getClusterInfo } from '../../lib/cluster.js';
+export function createGetCommand() {
+    const get = new Command('get');
+    get
+        .description('get current kubernetes cluster information')
+        .option('-c, --context <context>', 'kubernetes context to use')
+        .option('-o, --output <format>', 'output format (text|json)', 'text')
+        .action(async (options) => {
+        try {
+            const clusterInfo = await getClusterInfo(options.context);
+            if (clusterInfo.error) {
+                output.error('getting cluster info:', clusterInfo.error);
+                process.exit(1);
+            }
+            if (options.output === 'json') {
+                console.log(JSON.stringify({
+                    context: clusterInfo.context,
+                    namespace: clusterInfo.namespace,
+                    type: clusterInfo.type,
+                    ip: clusterInfo.ip,
+                }, null, 2));
+            }
+            else {
+                // Text format (default)
+                console.log(`context: ${clusterInfo.context}`);
+                console.log(`namespace: ${clusterInfo.namespace}`);
+                console.log(`type: ${clusterInfo.type}`);
+                console.log(`ip: ${clusterInfo.ip || 'unknown'}`);
+            }
+        }
+        catch (error) {
+            output.error('failed to get cluster info:', error instanceof Error ? error.message : 'Unknown error');
+            process.exit(1);
+        }
+    });
+    return get;
+}

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

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

package/dist/commands/cluster/get.spec.js

@@ -0,0 +1,92 @@
+import { jest } from '@jest/globals';
+import { Command } from 'commander';
+const mockGetClusterInfo = jest.fn();
+jest.unstable_mockModule('../../lib/cluster.js', () => ({
+    getClusterInfo: mockGetClusterInfo,
+}));
+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 mockConsoleLog = jest.spyOn(console, 'log').mockImplementation(() => { });
+const { createGetCommand } = await import('./get.js');
+describe('cluster get command', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('creates command with correct structure', () => {
+        const command = createGetCommand();
+        expect(command).toBeInstanceOf(Command);
+        expect(command.name()).toBe('get');
+    });
+    it('displays cluster info in text format by default', async () => {
+        mockGetClusterInfo.mockResolvedValue({
+            context: 'test-cluster',
+            namespace: 'default',
+            type: 'minikube',
+            ip: '192.168.1.1',
+        });
+        const command = createGetCommand();
+        await command.parseAsync(['node', 'test']);
+        expect(mockGetClusterInfo).toHaveBeenCalledWith(undefined);
+        expect(mockConsoleLog).toHaveBeenCalledWith('context: test-cluster');
+        expect(mockConsoleLog).toHaveBeenCalledWith('namespace: default');
+        expect(mockConsoleLog).toHaveBeenCalledWith('type: minikube');
+        expect(mockConsoleLog).toHaveBeenCalledWith('ip: 192.168.1.1');
+    });
+    it('displays cluster info in json format when requested', async () => {
+        const clusterInfo = {
+            context: 'prod-cluster',
+            namespace: 'production',
+            type: 'eks',
+            ip: '10.0.0.1',
+        };
+        mockGetClusterInfo.mockResolvedValue(clusterInfo);
+        const command = createGetCommand();
+        await command.parseAsync(['node', 'test', '-o', 'json']);
+        expect(mockConsoleLog).toHaveBeenCalledWith(JSON.stringify(clusterInfo, null, 2));
+    });
+    it('uses specified context when provided', async () => {
+        mockGetClusterInfo.mockResolvedValue({
+            context: 'custom-context',
+            namespace: 'custom',
+            type: 'kind',
+            ip: '127.0.0.1',
+        });
+        const command = createGetCommand();
+        await command.parseAsync(['node', 'test', '-c', 'custom-context']);
+        expect(mockGetClusterInfo).toHaveBeenCalledWith('custom-context');
+    });
+    it('handles missing ip gracefully', async () => {
+        mockGetClusterInfo.mockResolvedValue({
+            context: 'test-cluster',
+            namespace: 'default',
+            type: 'unknown',
+            ip: undefined,
+        });
+        const command = createGetCommand();
+        await command.parseAsync(['node', 'test']);
+        expect(mockConsoleLog).toHaveBeenCalledWith('ip: unknown');
+    });
+    it('exits with error when cluster info has error', async () => {
+        mockGetClusterInfo.mockResolvedValue({
+            error: 'No cluster found',
+        });
+        const command = createGetCommand();
+        await expect(command.parseAsync(['node', 'test'])).rejects.toThrow('process.exit called');
+        expect(mockOutput.error).toHaveBeenCalledWith('getting cluster info:', 'No cluster found');
+        expect(mockExit).toHaveBeenCalledWith(1);
+    });
+    it('handles exceptions gracefully', async () => {
+        mockGetClusterInfo.mockRejectedValue(new Error('Connection failed'));
+        const command = createGetCommand();
+        await expect(command.parseAsync(['node', 'test'])).rejects.toThrow('process.exit called');
+        expect(mockOutput.error).toHaveBeenCalledWith('failed to get cluster info:', 'Connection failed');
+        expect(mockExit).toHaveBeenCalledWith(1);
+    });
+});

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

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

package/dist/commands/cluster/index.js

@@ -1,10 +1,8 @@
 import { Command } from 'commander';
-import { createGetIpCommand } from './get-ip.js';
-import { createGetTypeCommand } from './get-type.js';
-export function createClusterCommand() {
+import { createGetCommand } from './get.js';
+export function createClusterCommand(_) {
     const cluster = new Command('cluster');
     cluster.description('Cluster management commands');
-    cluster.addCommand(createGetTypeCommand());
-    cluster.addCommand(createGetIpCommand());
+    cluster.addCommand(createGetCommand());
     return cluster;
 }

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

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

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

@@ -0,0 +1,24 @@
+import { jest } from '@jest/globals';
+import { Command } from 'commander';
+const mockCreateGetCommand = jest.fn();
+jest.unstable_mockModule('./get.js', () => ({
+    createGetCommand: mockCreateGetCommand,
+}));
+const { createClusterCommand } = await import('./index.js');
+describe('cluster command', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockCreateGetCommand.mockReturnValue(new Command('get'));
+    });
+    it('creates command with correct structure', () => {
+        const command = createClusterCommand({});
+        expect(command).toBeInstanceOf(Command);
+        expect(command.name()).toBe('cluster');
+    });
+    it('adds get subcommand', () => {
+        const command = createClusterCommand({});
+        expect(mockCreateGetCommand).toHaveBeenCalled();
+        const getCommand = command.commands.find((cmd) => cmd.name() === 'get');
+        expect(getCommand).toBeDefined();
+    });
+});

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

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