@agents-at-scale/ark 0.1.35-rc.1 → 0.1.35-rc2

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

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

package/dist/commands/teams/index.js

@@ -24,16 +24,11 @@ async function listTeams(options) {
         }
     }
     catch (error) {
-        if (error instanceof Error && error.message.includes('the server doesn\'t have a resource type')) {
-            output.error('Team CRDs not installed. Is the ARK controller running?');
-        }
-        else {
-            output.error(`Failed to list teams: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        }
+        output.error('fetching teams:', error instanceof Error ? error.message : error);
         process.exit(1);
     }
 }
-export function createTeamsCommand() {
+export function createTeamsCommand(_) {
     const teamsCommand = new Command('teams');
     teamsCommand
         .description('List available teams')

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

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

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

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

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

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

package/dist/commands/tools/index.js

@@ -24,16 +24,11 @@ async function listTools(options) {
         }
     }
     catch (error) {
-        if (error instanceof Error && error.message.includes('the server doesn\'t have a resource type')) {
-            output.error('MCPServer CRDs not installed. Is the ARK controller running?');
-        }
-        else {
-            output.error(`Failed to list tools: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        }
+        output.error('fetching tools:', error instanceof Error ? error.message : error);
         process.exit(1);
     }
 }
-export function createToolsCommand() {
+export function createToolsCommand(_) {
     const toolsCommand = new Command('tools');
     toolsCommand
         .description('List available tools')

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

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

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

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

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

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

package/dist/commands/uninstall/index.js

@@ -1,33 +1,25 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
-import { execa } from 'execa';
+import { execute } from '../../lib/commands.js';
 import inquirer from 'inquirer';
-import { isCommandAvailable } from '../../lib/commandUtils.js';
-import { getClusterInfo } from '../../lib/cluster.js';
+import { showNoClusterError } from '../../lib/startup.js';
 import output from '../../lib/output.js';
 import { getInstallableServices } from '../../arkServices.js';
-async function uninstallArk(options = {}) {
-    // Check if helm is installed
-    const helmInstalled = await isCommandAvailable('helm');
-    if (!helmInstalled) {
-        output.error('helm is not installed. please install helm first:');
-        output.info('https://helm.sh/docs/intro/install/');
-        process.exit(1);
-    }
-    // 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);
+async function uninstallService(service, verbose = false) {
+    const helmArgs = ['uninstall', service.helmReleaseName, '--ignore-not-found'];
+    // Only add namespace flag if service has explicit namespace
+    if (service.namespace) {
+        helmArgs.push('--namespace', service.namespace);
     }
-    // Check cluster connectivity
-    const clusterInfo = await getClusterInfo();
-    if (clusterInfo.error) {
-        output.error('no kubernetes cluster detected');
-        output.info('please ensure you have a running cluster and kubectl is configured.');
+    await execute('helm', helmArgs, { stdio: 'inherit' }, { verbose });
+}
+async function uninstallArk(config, serviceName, options = {}) {
+    // Check cluster connectivity from config
+    if (!config.clusterInfo) {
+        showNoClusterError();
         process.exit(1);
     }
+    const clusterInfo = config.clusterInfo;
     // Show cluster info
     output.success(`connected to cluster: ${chalk.bold(clusterInfo.context)}`);
     output.info(`type: ${clusterInfo.type}`);
@@ -36,34 +28,62 @@ async function uninstallArk(options = {}) {
         output.info(`ip: ${clusterInfo.ip}`);
     }
     console.log(); // Add blank line after cluster info
+    // If a specific service is requested, uninstall only that service
+    if (serviceName) {
+        const services = getInstallableServices();
+        const service = Object.values(services).find((s) => s.name === serviceName);
+        if (!service) {
+            output.error(`service '${serviceName}' not found`);
+            output.info('available services:');
+            for (const s of Object.values(services)) {
+                output.info(`  ${s.name}`);
+            }
+            process.exit(1);
+        }
+        output.info(`uninstalling ${service.name}...`);
+        try {
+            await uninstallService(service, options.verbose);
+            output.success(`${service.name} uninstalled successfully`);
+        }
+        catch (error) {
+            output.error(`failed to uninstall ${service.name}`);
+            console.error(error);
+            process.exit(1);
+        }
+        return;
+    }
     // Get installable services and iterate through them in reverse order for clean uninstall
     const services = getInstallableServices();
     const serviceEntries = Object.entries(services).reverse();
     for (const [, service] of serviceEntries) {
-        // Ask for confirmation
-        const shouldUninstall = options.yes || (await inquirer.prompt([
-            {
-                type: 'confirm',
-                name: 'shouldUninstall',
-                message: `uninstall ${chalk.bold(service.name)}? ${service.description ? chalk.gray(`(${service.description.toLowerCase()})`) : ''}`,
-                default: true,
-            },
-        ])).shouldUninstall;
+        let shouldUninstall = false;
+        try {
+            // Ask for confirmation
+            shouldUninstall =
+                options.yes ||
+                    (await inquirer.prompt([
+                        {
+                            type: 'confirm',
+                            name: 'shouldUninstall',
+                            message: `uninstall ${chalk.bold(service.name)}? ${service.description ? chalk.gray(`(${service.description.toLowerCase()})`) : ''}`,
+                            default: true,
+                        },
+                    ])).shouldUninstall;
+        }
+        catch (error) {
+            // Handle Ctrl-C gracefully
+            if (error && error.name === 'ExitPromptError') {
+                console.log('\nUninstallation cancelled');
+                process.exit(130); // Standard exit code for SIGINT
+            }
+            throw error;
+        }
         if (!shouldUninstall) {
             output.warning(`skipping ${service.name}`);
             continue;
         }
         try {
-            // Uninstall the release
-            await execa('helm', [
-                'uninstall',
-                service.helmReleaseName,
-                '--namespace',
-                service.namespace,
-                '--ignore-not-found',
-            ], {
-                stdio: 'inherit',
-            });
+            await uninstallService(service, options.verbose);
             console.log(); // Add blank line after command output
         }
         catch {
@@ -72,13 +92,15 @@ async function uninstallArk(options = {}) {
         }
     }
 }
-export function createUninstallCommand() {
+export function createUninstallCommand(config) {
     const command = new Command('uninstall');
     command
         .description('Uninstall ARK components using Helm')
+        .argument('[service]', 'specific service to uninstall, or all if omitted')
         .option('-y, --yes', 'automatically confirm all uninstallations')
-        .action(async (options) => {
-        await uninstallArk(options);
+        .option('-v, --verbose', 'show commands being executed')
+        .action(async (service, options) => {
+        await uninstallArk(config, service, options);
     });
     return command;
 }

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

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

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

@@ -0,0 +1,125 @@
+import { jest } from '@jest/globals';
+import { Command } from 'commander';
+const mockExeca = jest.fn(() => Promise.resolve());
+jest.unstable_mockModule('execa', () => ({
+    execa: mockExeca,
+}));
+const mockGetClusterInfo = jest.fn();
+jest.unstable_mockModule('../../lib/cluster.js', () => ({
+    getClusterInfo: mockGetClusterInfo,
+}));
+const mockGetInstallableServices = jest.fn();
+const mockArkServices = {};
+jest.unstable_mockModule('../../arkServices.js', () => ({
+    getInstallableServices: mockGetInstallableServices,
+    arkServices: mockArkServices,
+}));
+const mockOutput = {
+    error: jest.fn(),
+    info: jest.fn(),
+    success: jest.fn(),
+    warning: jest.fn(),
+};
+jest.unstable_mockModule('../../lib/output.js', () => ({
+    default: mockOutput,
+}));
+const mockExit = jest.spyOn(process, 'exit').mockImplementation((() => {
+    throw new Error('process.exit called');
+}));
+jest.spyOn(console, 'log').mockImplementation(() => { });
+jest.spyOn(console, 'error').mockImplementation(() => { });
+const { createUninstallCommand } = await import('./index.js');
+describe('uninstall command', () => {
+    const mockConfig = {
+        clusterInfo: {
+            context: 'test-cluster',
+            type: 'minikube',
+            namespace: 'default',
+        },
+    };
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockGetClusterInfo.mockResolvedValue({
+            context: 'test-cluster',
+            type: 'minikube',
+            namespace: 'default',
+        });
+    });
+    it('creates command with correct structure', () => {
+        const command = createUninstallCommand(mockConfig);
+        expect(command).toBeInstanceOf(Command);
+        expect(command.name()).toBe('uninstall');
+    });
+    it('uninstalls single service with correct helm parameters', async () => {
+        const mockService = {
+            name: 'ark-api',
+            helmReleaseName: 'ark-api',
+            namespace: 'ark-system',
+        };
+        mockGetInstallableServices.mockReturnValue({
+            'ark-api': mockService,
+        });
+        const command = createUninstallCommand(mockConfig);
+        await command.parseAsync(['node', 'test', 'ark-api']);
+        expect(mockExeca).toHaveBeenCalledWith('helm', [
+            'uninstall',
+            'ark-api',
+            '--ignore-not-found',
+            '--namespace',
+            'ark-system',
+        ], {
+            stdio: 'inherit',
+        });
+        expect(mockOutput.success).toHaveBeenCalledWith('ark-api uninstalled successfully');
+    });
+    it('shows error when service not found', async () => {
+        mockGetInstallableServices.mockReturnValue({
+            'ark-api': { name: 'ark-api' },
+            'ark-controller': { name: 'ark-controller' },
+        });
+        const command = createUninstallCommand(mockConfig);
+        await expect(command.parseAsync(['node', 'test', 'invalid-service'])).rejects.toThrow('process.exit called');
+        expect(mockOutput.error).toHaveBeenCalledWith("service 'invalid-service' not found");
+        expect(mockOutput.info).toHaveBeenCalledWith('available services:');
+        expect(mockOutput.info).toHaveBeenCalledWith('  ark-api');
+        expect(mockOutput.info).toHaveBeenCalledWith('  ark-controller');
+        expect(mockExit).toHaveBeenCalledWith(1);
+    });
+    it('handles service without namespace (uses current context)', async () => {
+        const mockService = {
+            name: 'ark-dashboard',
+            helmReleaseName: 'ark-dashboard',
+            // namespace is undefined - should use current context
+        };
+        mockGetInstallableServices.mockReturnValue({
+            'ark-dashboard': mockService,
+        });
+        const command = createUninstallCommand(mockConfig);
+        await command.parseAsync(['node', 'test', 'ark-dashboard']);
+        // Should NOT include --namespace flag
+        expect(mockExeca).toHaveBeenCalledWith('helm', ['uninstall', 'ark-dashboard', '--ignore-not-found'], {
+            stdio: 'inherit',
+        });
+    });
+    it('handles helm uninstall error gracefully', async () => {
+        const mockService = {
+            name: 'ark-api',
+            helmReleaseName: 'ark-api',
+            namespace: 'ark-system',
+        };
+        mockGetInstallableServices.mockReturnValue({
+            'ark-api': mockService,
+        });
+        mockExeca.mockRejectedValue(new Error('helm failed'));
+        const command = createUninstallCommand(mockConfig);
+        await expect(command.parseAsync(['node', 'test', 'ark-api'])).rejects.toThrow('process.exit called');
+        expect(mockOutput.error).toHaveBeenCalledWith('failed to uninstall ark-api');
+        expect(mockExit).toHaveBeenCalledWith(1);
+    });
+    it('exits when cluster not connected', async () => {
+        mockGetClusterInfo.mockResolvedValue({ error: true });
+        const command = createUninstallCommand({});
+        await expect(command.parseAsync(['node', 'test', 'ark-api'])).rejects.toThrow('process.exit called');
+        expect(mockExit).toHaveBeenCalledWith(1);
+    });
+});

package/dist/components/ChatUI.js

@@ -8,10 +8,10 @@ import { marked } from 'marked';
 // @ts-ignore - no types available
 import TerminalRenderer from 'marked-terminal';
 import { ChatClient, } from '../lib/chatClient.js';
-import { AgentSelector } from '../commands/agents/selector.js';
-import { ModelSelector } from '../commands/models/selector.js';
-import { TeamSelector } from '../commands/teams/selector.js';
-import { ToolSelector } from '../commands/tools/selector.js';
+import { AgentSelector } from '../ui/AgentSelector.js';
+import { ModelSelector } from '../ui/ModelSelector.js';
+import { TeamSelector } from '../ui/TeamSelector.js';
+import { ToolSelector } from '../ui/ToolSelector.js';
 // Generate a unique ID for messages
 let messageIdCounter = 0;
 const generateMessageId = () => {

package/dist/components/statusChecker.d.ts

@@ -1,5 +1,4 @@
 import { StatusData, CommandVersionConfig } from '../lib/types.js';
-import { ArkClient } from '../lib/arkClient.js';
 export declare const getNodeVersion: () => CommandVersionConfig;
 export declare const getNpmVersion: () => CommandVersionConfig;
 export declare const getKubectlVersion: () => CommandVersionConfig;
@@ -8,13 +7,15 @@ export declare const getHelmVersion: () => CommandVersionConfig;
 export declare const getMinikubeVersion: () => CommandVersionConfig;
 export declare const getKindVersion: () => CommandVersionConfig;
 export declare class StatusChecker {
-    private arkClient;
-    private kubernetesManager;
-    constructor(arkClient: ArkClient);
     /**
      * Get version of a command
      */
     private getCommandVersion;
+    /**
+     * Check combined deployment and helm status
+     * Gets health from deployment, version/revision from Helm
+     */
+    private checkCombinedStatus;
     /**
      * Check deployment status
      */
@@ -23,14 +24,6 @@ export declare class StatusChecker {
      * Check helm release status (fallback for services without deployments)
      */
     private checkHelmStatus;
-    /**
-     * Return a "not installed" status for a service
-     */
-    private createNotInstalledStatus;
-    /**
-     * Check Kubernetes service health via pods and endpoints
-     */
-    private checkKubernetesService;
     /**
      * Check system dependencies
      */