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

package/dist/lib/portUtils.js

@@ -0,0 +1,39 @@
+import net from 'net';
+/**
+ * Check if a port is available
+ */
+export async function isPortAvailable(port) {
+    return new Promise((resolve) => {
+        const server = net.createServer();
+        server.once('error', (err) => {
+            if (err.code === 'EADDRINUSE') {
+                resolve(false);
+            }
+            else {
+                resolve(false);
+            }
+        });
+        server.once('listening', () => {
+            server.close();
+            resolve(true);
+        });
+        server.listen(port, '127.0.0.1');
+    });
+}
+/**
+ * Find an available port, starting from the preferred port
+ */
+export async function findAvailablePort(preferredPort, maxAttempts = 10) {
+    // First try the preferred port
+    if (await isPortAvailable(preferredPort)) {
+        return preferredPort;
+    }
+    // Try random ports
+    for (let i = 0; i < maxAttempts; i++) {
+        const randomPort = Math.floor(Math.random() * (65535 - 1024) + 1024);
+        if (await isPortAvailable(randomPort)) {
+            return randomPort;
+        }
+    }
+    throw new Error(`Could not find an available port after ${maxAttempts} attempts`);
+}

package/dist/lib/startup.d.ts

@@ -0,0 +1,9 @@
+import type { ArkConfig } from './config.js';
+/**
+ * Show error message when no cluster is detected
+ */
+export declare function showNoClusterError(): void;
+/**
+ * Initialize the CLI by checking requirements and loading config
+ */
+export declare function startup(): Promise<ArkConfig>;

package/dist/lib/startup.js

@@ -0,0 +1,93 @@
+import chalk from 'chalk';
+import { checkCommandExists } from './commands.js';
+import { loadConfig } from './config.js';
+import { getArkVersion } from './arkStatus.js';
+import { getClusterInfo } from './cluster.js';
+const REQUIRED_COMMANDS = [
+    {
+        name: 'kubectl',
+        command: 'kubectl',
+        args: ['version', '--client'],
+        installUrl: 'https://kubernetes.io/docs/tasks/tools/',
+    },
+    {
+        name: 'helm',
+        command: 'helm',
+        args: ['version', '--short'],
+        installUrl: 'https://helm.sh/docs/intro/install/',
+    },
+];
+async function checkRequirements() {
+    const missing = [];
+    for (const cmd of REQUIRED_COMMANDS) {
+        const exists = await checkCommandExists(cmd.command, cmd.args);
+        if (!exists) {
+            missing.push(cmd);
+        }
+    }
+    if (missing.length > 0) {
+        for (const cmd of missing) {
+            console.error(chalk.red('error:') + ` ${cmd.name} is required`);
+            console.error('  ' + chalk.blue(cmd.installUrl));
+        }
+        process.exit(1);
+    }
+}
+/**
+ * Show error message when no cluster is detected
+ */
+export function showNoClusterError() {
+    console.log(chalk.red.bold('\n✗ No Kubernetes cluster detected\n'));
+    console.log('Please ensure you have configured a connection to a Kubernetes cluster.');
+    console.log('For local development, you can use:');
+    console.log(`  • Minikube: ${chalk.blue('https://minikube.sigs.k8s.io/docs/start')}`);
+    console.log(`  • Docker Desktop: ${chalk.blue('https://docs.docker.com/desktop/kubernetes/')}`);
+    console.log(`  • Kind: ${chalk.blue('https://kind.sigs.k8s.io/docs/user/quick-start/')}`);
+    console.log('');
+    console.log('And more. For help, check the Quickstart guide:');
+    console.log(chalk.blue('  https://mckinsey.github.io/agents-at-scale-ark/quickstart/'));
+}
+/**
+ * Fetch version information (non-blocking)
+ */
+async function fetchVersionInfo(config) {
+    // Fetch latest version from GitHub
+    try {
+        const response = await fetch('https://api.github.com/repos/mckinsey/agents-at-scale-ark/releases/latest');
+        if (response.ok) {
+            const data = (await response.json());
+            // Remove 'v' prefix if present for consistent comparison
+            config.latestVersion = data.tag_name.replace(/^v/, '');
+        }
+    }
+    catch {
+        // Silently fail - latestVersion will remain undefined
+    }
+    // Fetch current installed version (already without 'v' from helm)
+    try {
+        const currentVersion = await getArkVersion();
+        if (currentVersion) {
+            config.currentVersion = currentVersion;
+        }
+    }
+    catch {
+        // Silently fail - currentVersion will remain undefined
+    }
+}
+/**
+ * Initialize the CLI by checking requirements and loading config
+ */
+export async function startup() {
+    // Check required commands
+    await checkRequirements();
+    // Load config
+    const config = loadConfig();
+    // Get cluster info - if no error, we have cluster access
+    const clusterInfo = await getClusterInfo();
+    if (!clusterInfo.error) {
+        config.clusterInfo = clusterInfo;
+    }
+    // Fetch version info synchronously so it's available immediately
+    await fetchVersionInfo(config);
+    return config;
+}

package/dist/lib/startup.spec.d.ts

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

package/dist/lib/startup.spec.js

@@ -0,0 +1,168 @@
+import { describe, it, expect, jest, beforeEach, afterEach } from '@jest/globals';
+// Mock chalk to avoid ANSI codes in tests
+jest.unstable_mockModule('chalk', () => ({
+    default: {
+        red: (str) => str,
+        yellow: (str) => str,
+        gray: (str) => str,
+        blue: (str) => str,
+    },
+}));
+// Mock commands module
+jest.unstable_mockModule('./commands.js', () => ({
+    checkCommandExists: jest.fn(),
+}));
+// Mock config module
+jest.unstable_mockModule('./config.js', () => ({
+    loadConfig: jest.fn(),
+}));
+// Dynamic imports after mocks
+const { checkCommandExists } = await import('./commands.js');
+const { loadConfig } = await import('./config.js');
+const { startup } = await import('./startup.js');
+// Type the mocks
+const mockCheckCommandExists = checkCommandExists;
+const mockLoadConfig = loadConfig;
+// Mock fetch globally
+globalThis.fetch = jest.fn();
+describe('startup', () => {
+    let mockExit;
+    let mockConsoleError;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        globalThis.fetch.mockClear();
+        mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {
+            throw new Error('process.exit');
+        });
+        mockConsoleError = jest
+            .spyOn(console, 'error')
+            .mockImplementation(() => { });
+    });
+    afterEach(() => {
+        mockExit.mockRestore();
+        mockConsoleError.mockRestore();
+    });
+    it('returns config when all required commands are installed', async () => {
+        const expectedConfig = {
+            chat: {
+                streaming: true,
+                outputFormat: 'text',
+            },
+        };
+        // Mock all commands as available
+        mockCheckCommandExists.mockResolvedValue(true);
+        mockLoadConfig.mockReturnValue(expectedConfig);
+        const config = await startup();
+        expect(config).toEqual(expectedConfig);
+        expect(mockCheckCommandExists).toHaveBeenCalledWith('kubectl', [
+            'version',
+            '--client',
+        ]);
+        expect(mockCheckCommandExists).toHaveBeenCalledWith('helm', [
+            'version',
+            '--short',
+        ]);
+        expect(mockLoadConfig).toHaveBeenCalledTimes(1);
+        expect(mockExit).not.toHaveBeenCalled();
+    });
+    it('exits with error when kubectl is missing', async () => {
+        // Mock kubectl as missing, helm as available
+        mockCheckCommandExists
+            .mockResolvedValueOnce(false) // kubectl
+            .mockResolvedValueOnce(true); // helm
+        await expect(startup()).rejects.toThrow('process.exit');
+        expect(mockConsoleError).toHaveBeenCalledWith('error: kubectl is required');
+        expect(mockConsoleError).toHaveBeenCalledWith('  https://kubernetes.io/docs/tasks/tools/');
+        expect(mockExit).toHaveBeenCalledWith(1);
+    });
+    it('exits with error when helm is missing', async () => {
+        // Mock kubectl as available, helm as missing
+        mockCheckCommandExists
+            .mockResolvedValueOnce(true) // kubectl
+            .mockResolvedValueOnce(false); // helm
+        await expect(startup()).rejects.toThrow('process.exit');
+        expect(mockConsoleError).toHaveBeenCalledWith('error: helm is required');
+        expect(mockConsoleError).toHaveBeenCalledWith('  https://helm.sh/docs/intro/install/');
+        expect(mockExit).toHaveBeenCalledWith(1);
+    });
+    it('exits with error when both commands are missing', async () => {
+        // Mock both commands as missing
+        mockCheckCommandExists.mockResolvedValue(false);
+        await expect(startup()).rejects.toThrow('process.exit');
+        expect(mockConsoleError).toHaveBeenCalledWith('error: kubectl is required');
+        expect(mockConsoleError).toHaveBeenCalledWith('  https://kubernetes.io/docs/tasks/tools/');
+        expect(mockConsoleError).toHaveBeenCalledWith('error: helm is required');
+        expect(mockConsoleError).toHaveBeenCalledWith('  https://helm.sh/docs/intro/install/');
+        expect(mockExit).toHaveBeenCalledWith(1);
+    });
+    it('checks commands with correct arguments', async () => {
+        mockCheckCommandExists.mockResolvedValue(true);
+        mockLoadConfig.mockReturnValue({ chat: {} });
+        await startup();
+        expect(mockCheckCommandExists).toHaveBeenCalledTimes(2);
+        expect(mockCheckCommandExists).toHaveBeenNthCalledWith(1, 'kubectl', [
+            'version',
+            '--client',
+        ]);
+        expect(mockCheckCommandExists).toHaveBeenNthCalledWith(2, 'helm', [
+            'version',
+            '--short',
+        ]);
+    });
+    it('loads config after checking requirements', async () => {
+        mockCheckCommandExists.mockResolvedValue(true);
+        const expectedConfig = { chat: { streaming: false } };
+        mockLoadConfig.mockReturnValue(expectedConfig);
+        const config = await startup();
+        // Verify order - checkCommandExists should be called before loadConfig
+        const checkCallOrder = mockCheckCommandExists.mock.invocationCallOrder[0];
+        const loadCallOrder = mockLoadConfig.mock.invocationCallOrder[0];
+        expect(checkCallOrder).toBeLessThan(loadCallOrder);
+        expect(config).toEqual(expectedConfig);
+    });
+    describe('version fetching', () => {
+        beforeEach(() => {
+            // Setup successful requirements check and config
+            mockCheckCommandExists.mockResolvedValue(true);
+            mockLoadConfig.mockReturnValue({ chat: { streaming: true } });
+        });
+        it('fetches latest version from GitHub API', async () => {
+            globalThis.fetch.mockResolvedValue({
+                ok: true,
+                json: async () => ({ tag_name: 'v0.1.35' }),
+            });
+            const config = await startup();
+            expect(globalThis.fetch).toHaveBeenCalledWith('https://api.github.com/repos/mckinsey/agents-at-scale-ark/releases/latest');
+            // Wait for async fetch to complete
+            await new Promise((resolve) => setTimeout(resolve, 50));
+            expect(config.latestVersion).toBe('0.1.35');
+        });
+        it('handles GitHub API failure gracefully', async () => {
+            globalThis.fetch.mockRejectedValue(new Error('Network error'));
+            const config = await startup();
+            // Wait for async fetch attempt
+            await new Promise((resolve) => setTimeout(resolve, 50));
+            // Should not have latestVersion set
+            expect(config.latestVersion).toBeUndefined();
+        });
+        it('handles non-OK response from GitHub API', async () => {
+            globalThis.fetch.mockResolvedValue({
+                ok: false,
+                status: 403,
+            });
+            const config = await startup();
+            // Wait for async fetch to complete
+            await new Promise((resolve) => setTimeout(resolve, 50));
+            // Should not have latestVersion set
+            expect(config.latestVersion).toBeUndefined();
+        });
+        it('continues startup even if version fetch fails', async () => {
+            globalThis.fetch.mockRejectedValue(new Error('API Error'));
+            const config = await startup();
+            // Startup should complete successfully
+            expect(config).toBeDefined();
+            expect(config.chat).toBeDefined();
+            expect(mockExit).not.toHaveBeenCalled();
+        });
+    });
+});

package/dist/lib/types.d.ts

@@ -22,6 +22,8 @@ export type ServiceStatus = {
     version?: string;
     revision?: string;
     details?: string;
+    isDev?: boolean;
+    namespace?: string;
 };
 export interface DependencyStatus {
     name: string;
@@ -29,11 +31,18 @@ export interface DependencyStatus {
     version?: string;
     details?: string;
 }
+export interface ModelStatus {
+    exists: boolean;
+    available?: boolean;
+    provider?: string;
+    details?: string;
+}
 export interface StatusData {
     services: ServiceStatus[];
     dependencies: DependencyStatus[];
     arkReady?: boolean;
     defaultModelExists?: boolean;
+    defaultModel?: ModelStatus;
 }
 export interface CommandVersionConfig {
     command: string;

package/dist/ui/AgentSelector.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/ui/AgentSelector.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/ui/MainMenu.d.ts

@@ -1,3 +1,7 @@
 import * as React from 'react';
-declare const MainMenu: React.FC;
+import type { ArkConfig } from '../lib/config.js';
+interface MainMenuProps {
+    config: ArkConfig;
+}
+declare const MainMenu: React.FC<MainMenuProps>;
 export default MainMenu;

package/dist/ui/MainMenu.js

@@ -1,38 +1,68 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { Text, Box, render, useInput } from 'ink';
+import Spinner from 'ink-spinner';
 import * as React from 'react';
+import { isArkReady } from '../lib/arkStatus.js';
 //  Helper function to unmount the main ink app - used when we move from a
 //  React TUI app to basic input/output.
 async function unmountInkApp() {
     const app = globalThis.inkApp;
     if (app) {
+        // Unmount the Ink app
         app.unmount();
-        // Remove all existing signal listeners that might interfere with inquirer
-        process.removeAllListeners('SIGINT');
-        process.removeAllListeners('SIGTERM');
-        process.removeAllListeners('SIGQUIT');
-        process.removeAllListeners('exit');
-        // Reset stdin completely
+        // Clear the global reference
+        delete globalThis.inkApp;
+        // Reset terminal to normal mode
         if (process.stdin.isTTY) {
             process.stdin.setRawMode(false);
             process.stdin.pause();
-            process.stdin.removeAllListeners();
-            process.stdin.resume();
         }
-        // Reset stdout/stderr
-        process.stdout.removeAllListeners();
-        process.stderr.removeAllListeners();
+        // Clear screen
         console.clear();
-        // Give terminal more time to fully reset
-        await new Promise((resolve) => setTimeout(resolve, 200));
+        // Small delay to ensure everything is flushed
+        await new Promise((resolve) => setTimeout(resolve, 50));
     }
 }
-const MainMenu = () => {
+const MainMenu = ({ config }) => {
     const [selectedIndex, setSelectedIndex] = React.useState(0);
-    const choices = [
+    const [arkReady, setArkReady] = React.useState(null);
+    const [isChecking, setIsChecking] = React.useState(true);
+    React.useEffect(() => {
+        const checkArkStatus = async () => {
+            setIsChecking(true);
+            const ready = await isArkReady();
+            setArkReady(ready);
+            setIsChecking(false);
+            // Reset selected index to 0 after status check
+            setSelectedIndex(0);
+        };
+        checkArkStatus();
+    }, []);
+    // Handle Ctrl+C to properly unmount Ink and restore terminal
+    React.useEffect(() => {
+        const handleExit = () => {
+            const app = globalThis.inkApp;
+            if (app) {
+                app.unmount();
+            }
+            process.exit(0);
+        };
+        process.on('SIGINT', handleExit);
+        return () => {
+            process.removeListener('SIGINT', handleExit);
+        };
+    }, []);
+    // Check if upgrade is available
+    const hasUpgrade = React.useMemo(() => {
+        if (!config.currentVersion || !config.latestVersion)
+            return false;
+        // Simple version comparison
+        return config.currentVersion !== config.latestVersion;
+    }, [config.currentVersion, config.latestVersion]);
+    const allChoices = [
         {
             label: 'Chat',
-            description: 'Interactive chat with ARK agents',
+            description: 'Interactive chat with Ark agents',
             value: 'chat',
             command: 'ark chat',
         },
@@ -42,27 +72,57 @@ const MainMenu = () => {
             value: 'install',
             command: 'ark install',
         },
+        {
+            label: 'Upgrade',
+            description: `Upgrade Ark from ${config.currentVersion} to ${config.latestVersion}`,
+            value: 'upgrade',
+            command: 'ark install -y',
+        },
         {
             label: 'Dashboard',
-            description: 'Open ARK dashboard in browser',
+            description: 'Open Ark dashboard in browser',
             value: 'dashboard',
             command: 'ark dashboard',
         },
         {
-            label: 'Status Check',
-            description: 'Check ARK services status',
+            label: 'Status',
+            description: 'Check Ark services status',
             value: 'status',
             command: 'ark status',
         },
         {
             label: 'Generate',
-            description: 'Generate new ARK components',
+            description: 'Generate new Ark components',
             value: 'generate',
             command: 'ark generate',
         },
-        { label: 'Exit', description: 'Exit ARK CLI', value: 'exit' },
+        { label: 'Exit', description: 'Exit Ark CLI', value: 'exit' },
     ];
+    // Filter choices based on Ark readiness
+    const choices = React.useMemo(() => {
+        // Don't return any choices while checking
+        if (isChecking)
+            return [];
+        if (!arkReady) {
+            // Only show Install, Status, and Exit when Ark is not ready
+            return allChoices.filter((choice) => ['install', 'status', 'exit'].includes(choice.value));
+        }
+        // Ark is ready - filter out install (already installed) and conditionally show upgrade
+        const filteredChoices = allChoices.filter((choice) => {
+            // Never show install when Ark is ready (it's already installed)
+            if (choice.value === 'install')
+                return false;
+            // Only show upgrade if there's actually an upgrade available
+            if (choice.value === 'upgrade' && !hasUpgrade)
+                return false;
+            return true;
+        });
+        return filteredChoices;
+    }, [arkReady, isChecking, hasUpgrade, allChoices]);
     useInput((input, key) => {
+        // Don't process input while checking status
+        if (isChecking)
+            return;
         if (key.upArrow || input === 'k') {
             setSelectedIndex((prev) => (prev > 0 ? prev - 1 : choices.length - 1));
         }
@@ -102,7 +162,7 @@ const MainMenu = () => {
                     const output = (await import('../lib/output.js')).default;
                     output.error(error instanceof Error
                         ? error.message
-                        : 'Failed to connect to ARK API');
+                        : 'Failed to connect to Ark API');
                     process.exit(1);
                 }
                 break;
@@ -110,36 +170,38 @@ const MainMenu = () => {
             case 'install': {
                 //  Unmount fullscreen app and clear screen.
                 await unmountInkApp();
-                // NOTE: We spawn the install command as a separate process to avoid
-                // signal handling conflicts between Ink's useInput and inquirer's prompts.
-                // The signal-exit library used by inquirer conflicts with Ink's signal handlers,
-                // causing ExitPromptError even after proper cleanup. Spawning ensures
-                // a clean process environment for inquirer to work correctly.
-                const { spawn } = await import('child_process');
-                const child = spawn(process.execPath, [process.argv[1], 'install'], {
-                    stdio: 'inherit',
-                });
-                await new Promise((resolve, reject) => {
-                    child.on('close', (code) => {
-                        if (code === 0) {
-                            resolve();
-                        }
-                        else if (code === 130) {
-                            // 130 is the exit code for SIGINT (Ctrl+C)
-                            process.exit(130);
-                        }
-                        else {
-                            reject(new Error(`Install command failed with code ${code}`));
-                        }
+                // Spawn as a new process to avoid Ink/inquirer signal conflicts
+                const { execFileSync } = await import('child_process');
+                try {
+                    execFileSync(process.execPath, [process.argv[1], 'install'], {
+                        stdio: 'inherit',
+                        env: { ...process.env, FORCE_COLOR: '1' },
                     });
-                    child.on('error', reject);
-                    // Forward SIGINT to child and exit
-                    process.on('SIGINT', () => {
-                        child.kill('SIGINT');
-                        process.exit(130);
+                }
+                catch (error) {
+                    // execFileSync throws if the process exits with non-zero
+                    process.exit(error.status || 1);
+                }
+                process.exit(0);
+                break; // Add break even though process.exit prevents reaching here
+            }
+            case 'upgrade': {
+                //  Unmount fullscreen app and clear screen.
+                await unmountInkApp();
+                // Spawn as a new process with -y flag for automatic upgrade
+                const { execFileSync } = await import('child_process');
+                try {
+                    execFileSync(process.execPath, [process.argv[1], 'install', '-y'], {
+                        stdio: 'inherit',
+                        env: { ...process.env, FORCE_COLOR: '1' },
                     });
-                });
-                break;
+                }
+                catch (error) {
+                    // execFileSync throws if the process exits with non-zero
+                    process.exit(error.status || 1);
+                }
+                process.exit(0);
+                break; // Add break even though process.exit prevents reaching here
             }
             case 'dashboard': {
                 //  Unmount fullscreen app and clear screen.
@@ -152,8 +214,9 @@ const MainMenu = () => {
                 //  Unmount fullscreen app and clear screen.
                 await unmountInkApp();
                 const { checkStatus } = await import('../commands/status/index.js');
-                await checkStatus();
-                break;
+                await checkStatus(config);
+                process.exit(0);
+                break; // Add break even though process.exit prevents reaching here
             }
             case 'generate': {
                 const GeneratorUI = (await import('../components/GeneratorUI.js'))
@@ -176,9 +239,9 @@ const MainMenu = () => {
     ║        Agents at Scale Platform       ║
     ║                                       ║
     ╚═══════════════════════════════════════╝
-        ` }), _jsx(Text, { color: "green", bold: true, children: "Welcome to ARK! \uD83D\uDE80" }), _jsx(Text, { color: "gray", children: "Interactive terminal interface for ARK agents" })] }), _jsx(Box, { flexDirection: "column", paddingX: 4, marginTop: 1, children: choices.map((choice, index) => {
+        ` }), isChecking ? (_jsxs(Text, { color: "gray", children: [_jsx(Spinner, { type: "dots" }), " Checking Ark status..."] })) : arkReady ? (_jsxs(Box, { children: [_jsx(Text, { color: "green", bold: true, children: "\u25CF Ark is ready" }), config.currentVersion && (_jsxs(Text, { color: "gray", children: [" (", config.currentVersion, ")"] }))] })) : (_jsx(Text, { color: "yellow", bold: true, children: "\u25CF Ark is not installed" })), config.clusterInfo?.context ? (_jsxs(Text, { children: [_jsx(Text, { color: "gray", children: "Current context: " }), _jsx(Text, { color: "white", bold: true, children: config.clusterInfo.context })] })) : (_jsx(Text, { color: "gray", children: "No Kubernetes context configured" }))] }), !isChecking && (_jsx(Box, { flexDirection: "column", paddingX: 4, marginTop: 1, children: choices.map((choice, index) => {
                     const isSelected = index === selectedIndex;
                     return (_jsxs(Box, { flexDirection: "row", paddingY: 0, children: [_jsx(Text, { color: "gray", dimColor: true, children: isSelected ? '❯ ' : '  ' }), _jsxs(Text, { color: "gray", dimColor: true, children: [index + 1, "."] }), _jsx(Box, { marginLeft: 1, width: 20, children: _jsx(Text, { color: isSelected ? 'green' : 'white', bold: isSelected, children: choice.label }) }), _jsx(Text, { color: "gray", children: choice.description })] }, choice.value));
-                }) })] }));
+                }) }))] }));
 };
 export default MainMenu;