@agents-at-scale/ark 0.1.39 → 0.1.41

package/dist/arkServices.js

@@ -128,6 +128,18 @@ const defaultArkServices = {
         k8sDeploymentName: 'ark-mcp',
         k8sDevDeploymentName: 'ark-mcp-devspace',
     },
+    'mcp-filesystem': {
+        name: 'mcp-filesystem',
+        helmReleaseName: 'mcp-filesystem',
+        description: 'Stateful filesystem MCP server with workspace isolation',
+        enabled: false,
+        category: 'service',
+        // namespace: undefined - uses current context namespace
+        chartPath: `${REGISTRY_BASE}/mcp-filesystem`,
+        installArgs: [],
+        k8sDeploymentName: 'mcp-filesystem',
+        k8sDevDeploymentName: 'mcp-filesystem-devspace',
+    },
     'agents-at-scale': {
         name: 'agents-at-scale',
         helmReleaseName: 'agents-at-scale',

package/dist/commands/query/index.js

@@ -1,6 +1,7 @@
 import { Command } from 'commander';
-import output from '../../lib/output.js';
+import chalk from 'chalk';
 import { executeQuery, parseTarget } from '../../lib/executeQuery.js';
+import { ExitCodes } from '../../lib/errors.js';
 export function createQueryCommand(_) {
     const queryCommand = new Command('query');
     queryCommand
@@ -8,11 +9,10 @@ export function createQueryCommand(_) {
         .argument('<target>', 'Query target (e.g., model/default, agent/my-agent)')
         .argument('<message>', 'Message to send')
         .action(async (target, message) => {
-        // Parse and validate target format
         const parsed = parseTarget(target);
         if (!parsed) {
-            output.error('Invalid target format. Use: model/name or agent/name etc');
-            process.exit(1);
+            console.error(chalk.red('Invalid target format. Use: model/name or agent/name etc'));
+            process.exit(ExitCodes.CliError);
         }
         await executeQuery({
             targetType: parsed.type,

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

@@ -15,6 +15,9 @@ jest.unstable_mockModule('../../lib/output.js', () => ({
 const mockExit = jest.spyOn(process, 'exit').mockImplementation((() => {
     throw new Error('process.exit called');
 }));
+const mockConsoleError = jest
+    .spyOn(console, 'error')
+    .mockImplementation(() => { });
 const { createQueryCommand } = await import('./index.js');
 describe('createQueryCommand', () => {
     beforeEach(() => {
@@ -47,7 +50,7 @@ describe('createQueryCommand', () => {
         await expect(command.parseAsync(['node', 'test', 'invalid-target', 'Hello'])).rejects.toThrow('process.exit called');
         expect(mockParseTarget).toHaveBeenCalledWith('invalid-target');
         expect(mockExecuteQuery).not.toHaveBeenCalled();
-        expect(mockOutput.error).toHaveBeenCalledWith('Invalid target format. Use: model/name or agent/name etc');
+        expect(mockConsoleError).toHaveBeenCalledWith(expect.stringContaining('Invalid target format'));
         expect(mockExit).toHaveBeenCalledWith(1);
     });
 });

package/dist/components/ChatUI.js

@@ -7,10 +7,7 @@ import { marked } from 'marked';
 // @ts-ignore - no types available
 import TerminalRenderer from 'marked-terminal';
 import { APIError } from 'openai';
-import { AgentSelector } from '../ui/AgentSelector.js';
-import { ModelSelector } from '../ui/ModelSelector.js';
-import { TeamSelector } from '../ui/TeamSelector.js';
-import { ToolSelector } from '../ui/ToolSelector.js';
+import { TargetSelector } from '../ui/TargetSelector.js';
 import { useAsyncOperation, AsyncOperationStatus } from './AsyncOperation.js';
 import { createConnectingToArkOperation } from '../ui/asyncOperations/connectingToArk.js';
 // Generate a unique ID for messages
@@ -48,6 +45,12 @@ const ChatUI = ({ initialTargetId, arkApiClient, arkApiProxy, config, }) => {
     const [showModelSelector, setShowModelSelector] = React.useState(false);
     const [showTeamSelector, setShowTeamSelector] = React.useState(false);
     const [showToolSelector, setShowToolSelector] = React.useState(false);
+    const [agents, setAgents] = React.useState([]);
+    const [models, setModels] = React.useState([]);
+    const [teams, setTeams] = React.useState([]);
+    const [tools, setTools] = React.useState([]);
+    const [selectorLoading, setSelectorLoading] = React.useState(false);
+    const [selectorError, setSelectorError] = React.useState(undefined);
     // Message history navigation
     const [messageHistory, setMessageHistory] = React.useState([]);
     const [historyIndex, setHistoryIndex] = React.useState(-1);
@@ -56,6 +59,50 @@ const ChatUI = ({ initialTargetId, arkApiClient, arkApiProxy, config, }) => {
         streamingEnabled: config?.chat?.streaming ?? true,
         currentTarget: undefined,
     });
+    React.useEffect(() => {
+        if (showAgentSelector && agents.length === 0) {
+            setSelectorLoading(true);
+            setSelectorError(undefined);
+            arkApiClient
+                .getAgents()
+                .then(setAgents)
+                .catch((err) => setSelectorError(err.message))
+                .finally(() => setSelectorLoading(false));
+        }
+    }, [showAgentSelector, arkApiClient, agents.length]);
+    React.useEffect(() => {
+        if (showModelSelector && models.length === 0) {
+            setSelectorLoading(true);
+            setSelectorError(undefined);
+            arkApiClient
+                .getModels()
+                .then(setModels)
+                .catch((err) => setSelectorError(err.message))
+                .finally(() => setSelectorLoading(false));
+        }
+    }, [showModelSelector, arkApiClient, models.length]);
+    React.useEffect(() => {
+        if (showTeamSelector && teams.length === 0) {
+            setSelectorLoading(true);
+            setSelectorError(undefined);
+            arkApiClient
+                .getTeams()
+                .then(setTeams)
+                .catch((err) => setSelectorError(err.message))
+                .finally(() => setSelectorLoading(false));
+        }
+    }, [showTeamSelector, arkApiClient, teams.length]);
+    React.useEffect(() => {
+        if (showToolSelector && tools.length === 0) {
+            setSelectorLoading(true);
+            setSelectorError(undefined);
+            arkApiClient
+                .getTools()
+                .then(setTools)
+                .catch((err) => setSelectorError(err.message))
+                .finally(() => setSelectorLoading(false));
+        }
+    }, [showToolSelector, arkApiClient, tools.length]);
     const chatClientRef = React.useRef(undefined);
     // Configure markdown when output format changes
     React.useEffect(() => {
@@ -608,8 +655,10 @@ const ChatUI = ({ initialTargetId, arkApiClient, arkApiProxy, config, }) => {
     }
     // Show agent selector if requested
     if (showAgentSelector) {
-        return (_jsx(AgentSelector, { arkApiClient: arkApiClient, onSelect: (agent) => {
-                // Update the target to the selected agent
+        return (_jsx(TargetSelector, { targets: agents, title: "Select Agent", subtitle: "Choose an agent to start a conversation with", loading: selectorLoading, error: selectorError, formatInlineDetail: (t) => t.description, showDetailPanel: true, onSelect: (target) => {
+                const agent = agents.find((a) => a.name === target.name);
+                if (!agent)
+                    return;
                 const agentTarget = {
                     id: `agent/${agent.name}`,
                     name: agent.name,
@@ -620,7 +669,6 @@ const ChatUI = ({ initialTargetId, arkApiClient, arkApiProxy, config, }) => {
                 setChatConfig((prev) => ({ ...prev, currentTarget: agentTarget }));
                 setMessages([]);
                 setShowAgentSelector(false);
-                // Add system message about the selection
                 const systemMessage = {
                     id: generateMessageId(),
                     type: 'system',
@@ -633,8 +681,18 @@ const ChatUI = ({ initialTargetId, arkApiClient, arkApiProxy, config, }) => {
     }
     // Show model selector if requested
     if (showModelSelector) {
-        return (_jsx(ModelSelector, { arkApiClient: arkApiClient, onSelect: (model) => {
-                // Update the target to the selected model
+        return (_jsx(TargetSelector, { targets: models, title: "Select Model", subtitle: "Choose a model to start a conversation with", loading: selectorLoading, error: selectorError, formatLabel: (t) => {
+                const model = models.find((m) => m.name === t.name);
+                return model
+                    ? `${model.name}${model.type ? ` (${model.type})` : ''}`
+                    : t.name;
+            }, formatInlineDetail: (t) => {
+                const model = models.find((m) => m.name === t.name);
+                return model?.model;
+            }, showDetailPanel: false, onSelect: (target) => {
+                const model = models.find((m) => m.name === target.name);
+                if (!model)
+                    return;
                 const modelTarget = {
                     id: `model/${model.name}`,
                     name: model.name,
@@ -645,7 +703,6 @@ const ChatUI = ({ initialTargetId, arkApiClient, arkApiProxy, config, }) => {
                 setChatConfig((prev) => ({ ...prev, currentTarget: modelTarget }));
                 setMessages([]);
                 setShowModelSelector(false);
-                // Add system message about the selection
                 const systemMessage = {
                     id: generateMessageId(),
                     type: 'system',
@@ -658,8 +715,15 @@ const ChatUI = ({ initialTargetId, arkApiClient, arkApiProxy, config, }) => {
     }
     // Show team selector if requested
     if (showTeamSelector) {
-        return (_jsx(TeamSelector, { arkApiClient: arkApiClient, onSelect: (team) => {
-                // Update the target to the selected team
+        return (_jsx(TargetSelector, { targets: teams, title: "Select Team", subtitle: "Choose a team to start a conversation with", loading: selectorLoading, error: selectorError, formatLabel: (t) => {
+                const team = teams.find((tm) => tm.name === t.name);
+                return team
+                    ? `${team.name}${team.strategy ? ` (${team.strategy})` : ''}`
+                    : t.name;
+            }, formatInlineDetail: (t) => t.description, showDetailPanel: true, onSelect: (target) => {
+                const team = teams.find((tm) => tm.name === target.name);
+                if (!team)
+                    return;
                 const teamTarget = {
                     id: `team/${team.name}`,
                     name: team.name,
@@ -670,7 +734,6 @@ const ChatUI = ({ initialTargetId, arkApiClient, arkApiProxy, config, }) => {
                 setChatConfig((prev) => ({ ...prev, currentTarget: teamTarget }));
                 setMessages([]);
                 setShowTeamSelector(false);
-                // Add system message about the selection
                 const systemMessage = {
                     id: generateMessageId(),
                     type: 'system',
@@ -683,8 +746,10 @@ const ChatUI = ({ initialTargetId, arkApiClient, arkApiProxy, config, }) => {
     }
     // Show tool selector if requested
     if (showToolSelector) {
-        return (_jsx(ToolSelector, { arkApiClient: arkApiClient, onSelect: (tool) => {
-                // Update the target to the selected tool
+        return (_jsx(TargetSelector, { targets: tools, title: "Select Tool", subtitle: "Choose a tool to start a conversation with", loading: selectorLoading, error: selectorError, formatInlineDetail: (t) => t.description, showDetailPanel: true, onSelect: (target) => {
+                const tool = tools.find((tl) => tl.name === target.name);
+                if (!tool)
+                    return;
                 const toolTarget = {
                     id: `tool/${tool.name}`,
                     name: tool.name,
@@ -695,7 +760,6 @@ const ChatUI = ({ initialTargetId, arkApiClient, arkApiProxy, config, }) => {
                 setChatConfig((prev) => ({ ...prev, currentTarget: toolTarget }));
                 setMessages([]);
                 setShowToolSelector(false);
-                // Add system message about the selection
                 const systemMessage = {
                     id: generateMessageId(),
                     type: 'system',

package/dist/lib/arkApiClient.js

@@ -6,6 +6,7 @@ export class ArkApiClient {
             baseURL: `${arkApiUrl}/openai/v1`,
             apiKey: 'dummy', // ark-api doesn't require an API key
             dangerouslyAllowBrowser: false,
+            maxRetries: 0, // Disable automatic retries for query errors
         });
     }
     getBaseUrl() {

package/dist/lib/duration.d.ts

@@ -0,0 +1 @@
+export declare function parseDuration(duration: string): number;

package/dist/lib/duration.js

@@ -0,0 +1,20 @@
+export function parseDuration(duration) {
+    const match = duration.match(/^(\d+(?:\.\d+)?)(ms|s|m|h)$/);
+    if (!match) {
+        throw new Error(`Invalid duration format: ${duration}`);
+    }
+    const value = parseFloat(match[1]);
+    const unit = match[2];
+    switch (unit) {
+        case 'ms':
+            return value;
+        case 's':
+            return value * 1000;
+        case 'm':
+            return value * 60 * 1000;
+        case 'h':
+            return value * 60 * 60 * 1000;
+        default:
+            throw new Error(`Unknown duration unit: ${unit}`);
+    }
+}

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

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

package/dist/lib/duration.spec.js

@@ -0,0 +1,13 @@
+import { parseDuration } from './duration.js';
+describe('parseDuration', () => {
+    it('should parse durations correctly', () => {
+        expect(parseDuration('100ms')).toBe(100);
+        expect(parseDuration('30s')).toBe(30000);
+        expect(parseDuration('5m')).toBe(300000);
+        expect(parseDuration('1h')).toBe(3600000);
+    });
+    it('should throw on invalid format', () => {
+        expect(() => parseDuration('invalid')).toThrow('Invalid duration format');
+        expect(() => parseDuration('10')).toThrow('Invalid duration format');
+    });
+});

package/dist/lib/errors.d.ts

@@ -1,6 +1,12 @@
 /**
  * Centralized error handling for ARK CLI
  */
+export declare const ExitCodes: {
+    readonly Success: 0;
+    readonly CliError: 1;
+    readonly OperationError: 2;
+    readonly Timeout: 3;
+};
 export declare enum ErrorCode {
     INVALID_INPUT = "INVALID_INPUT",
     FILE_NOT_FOUND = "FILE_NOT_FOUND",

package/dist/lib/errors.js

@@ -3,6 +3,12 @@
  */
 import chalk from 'chalk';
 import fs from 'fs';
+export const ExitCodes = {
+    Success: 0,
+    CliError: 1,
+    OperationError: 2,
+    Timeout: 3,
+};
 export var ErrorCode;
 (function (ErrorCode) {
     ErrorCode["INVALID_INPUT"] = "INVALID_INPUT";

package/dist/lib/executeQuery.d.ts

@@ -6,6 +6,8 @@ export interface QueryOptions {
     targetType: string;
     targetName: string;
     message: string;
+    timeout?: string;
+    watchTimeout?: string;
     verbose?: boolean;
 }
 /**

package/dist/lib/executeQuery.js

@@ -3,17 +3,24 @@
  */
 import { execa } from 'execa';
 import ora from 'ora';
+import chalk from 'chalk';
 import output from './output.js';
+import { ExitCodes } from './errors.js';
+import { parseDuration } from './duration.js';
 /**
  * Execute a query against any ARK target (model, agent, team)
  * This is the shared implementation used by all query commands
  */
 export async function executeQuery(options) {
     const spinner = ora('Creating query...').start();
-    // Generate a unique query name
+    const queryTimeoutMs = options.timeout
+        ? parseDuration(options.timeout)
+        : parseDuration('5m');
+    const watchTimeoutMs = options.watchTimeout
+        ? parseDuration(options.watchTimeout)
+        : queryTimeoutMs + 60000;
     const timestamp = Date.now();
     const queryName = `cli-query-${timestamp}`;
-    // Create the Query resource
     const queryManifest = {
         apiVersion: 'ark.mckinsey.com/v1alpha1',
         kind: 'Query',
@@ -22,6 +29,7 @@ export async function executeQuery(options) {
         },
         spec: {
             input: options.message,
+            ...(options.timeout && { timeout: options.timeout }),
             targets: [
                 {
                     type: options.targetType,
@@ -37,86 +45,67 @@ export async function executeQuery(options) {
             input: JSON.stringify(queryManifest),
             stdio: ['pipe', 'pipe', 'pipe'],
         });
-        // Watch for query completion
-        spinner.text = 'Query status: initializing';
-        let queryComplete = false;
-        let attempts = 0;
-        const maxAttempts = 300; // 5 minutes with 1 second intervals
-        while (!queryComplete && attempts < maxAttempts) {
-            attempts++;
-            try {
-                const { stdout } = await execa('kubectl', ['get', 'query', queryName, '-o', 'json'], { stdio: 'pipe' });
-                const query = JSON.parse(stdout);
-                const phase = query.status?.phase;
-                // Update spinner with current phase
-                if (phase) {
-                    spinner.text = `Query status: ${phase}`;
-                }
-                // Check if query is complete based on phase
-                if (phase === 'done') {
-                    queryComplete = true;
-                    spinner.succeed('Query completed');
-                    // Extract and display the response from responses array
-                    if (query.status?.responses && query.status.responses.length > 0) {
-                        const response = query.status.responses[0];
-                        console.log('\n' + (response.content || response));
-                    }
-                    else {
-                        output.warning('No response received');
-                    }
-                }
-                else if (phase === 'error') {
-                    queryComplete = true;
-                    spinner.fail('Query failed');
-                    // Try to get error message from conditions or status
-                    const errorCondition = query.status?.conditions?.find((c) => {
-                        return c.type === 'Complete' && c.status === 'False';
-                    });
-                    if (errorCondition?.message) {
-                        output.error(errorCondition.message);
-                    }
-                    else if (query.status?.error) {
-                        output.error(query.status.error);
-                    }
-                    else {
-                        output.error('Query failed with unknown error');
-                    }
+        // Watch for query completion using kubectl wait
+        spinner.text = 'Waiting for query completion...';
+        try {
+            await execa('kubectl', [
+                'wait',
+                '--for=condition=Completed',
+                `query/${queryName}`,
+                `--timeout=${Math.floor(watchTimeoutMs / 1000)}s`,
+            ], { timeout: watchTimeoutMs });
+        }
+        catch (error) {
+            spinner.stop();
+            // Check if it's a timeout or other error
+            if (error instanceof Error &&
+                error.message.includes('timed out waiting')) {
+                console.error(chalk.red(`Query did not complete within ${options.watchTimeout ?? `${Math.floor(watchTimeoutMs / 1000)}s`}`));
+                process.exit(ExitCodes.Timeout);
+            }
+            // For other errors, fetch the query to check status
+        }
+        spinner.stop();
+        // Fetch final query state
+        try {
+            const { stdout } = await execa('kubectl', ['get', 'query', queryName, '-o', 'json'], { stdio: 'pipe' });
+            const query = JSON.parse(stdout);
+            const phase = query.status?.phase;
+            // Check if query completed successfully or with error
+            if (phase === 'done') {
+                // Extract and display the response from responses array
+                if (query.status?.responses && query.status.responses.length > 0) {
+                    const response = query.status.responses[0];
+                    console.log(response.content || response);
                 }
-                else if (phase === 'canceled') {
-                    queryComplete = true;
-                    spinner.warn('Query canceled');
-                    // Try to get cancellation reason if available
-                    if (query.status?.message) {
-                        output.warning(query.status.message);
-                    }
+                else {
+                    output.warning('No response received');
                 }
             }
-            catch {
-                // Query might not exist yet, continue waiting
-                spinner.text = 'Query status: waiting for query to be created';
+            else if (phase === 'error') {
+                const response = query.status?.responses?.[0];
+                console.error(chalk.red(response?.content || 'Query failed with unknown error'));
+                process.exit(ExitCodes.OperationError);
             }
-            if (!queryComplete) {
-                await new Promise((resolve) => setTimeout(resolve, 1000)); // Wait 1 second
+            else if (phase === 'canceled') {
+                spinner.warn('Query canceled');
+                if (query.status?.message) {
+                    output.warning(query.status.message);
+                }
+                process.exit(ExitCodes.OperationError);
             }
         }
-        if (!queryComplete) {
-            spinner.fail('Query timed out');
-            output.error('Query did not complete within 5 minutes');
+        catch (error) {
+            console.error(chalk.red(error instanceof Error
+                ? error.message
+                : 'Failed to fetch query result'));
+            process.exit(ExitCodes.CliError);
         }
     }
     catch (error) {
-        spinner.fail('Query failed');
-        output.error(error instanceof Error ? error.message : 'Unknown error');
-        process.exit(1);
-    }
-    finally {
-        // Clean up the query resource
-        try {
-            await execa('kubectl', ['delete', 'query', queryName], { stdio: 'pipe' });
-        }
-        catch {
-            // Ignore cleanup errors
-        }
+        spinner.stop();
+        console.error(chalk.red(error instanceof Error ? error.message : 'Unknown error'));
+        process.exit(ExitCodes.CliError);
     }
 }
 /**

package/dist/lib/executeQuery.spec.js

@@ -8,6 +8,7 @@ const mockSpinner = {
     succeed: jest.fn(),
     fail: jest.fn(),
     warn: jest.fn(),
+    stop: jest.fn(),
     text: '',
 };
 const mockOra = jest.fn(() => mockSpinner);
@@ -25,7 +26,11 @@ const mockExit = jest.spyOn(process, 'exit').mockImplementation((() => {
     throw new Error('process.exit called');
 }));
 const mockConsoleLog = jest.spyOn(console, 'log').mockImplementation(() => { });
+const mockConsoleError = jest
+    .spyOn(console, 'error')
+    .mockImplementation(() => { });
 const { executeQuery, parseTarget } = await import('./executeQuery.js');
+const { ExitCodes } = await import('./errors.js');
 describe('executeQuery', () => {
     beforeEach(() => {
         jest.clearAllMocks();
@@ -71,9 +76,6 @@ describe('executeQuery', () => {
                         exitCode: 0,
                     };
                 }
-                if (args.includes('delete')) {
-                    return { stdout: '', stderr: '', exitCode: 0 };
-                }
                 return { stdout: '', stderr: '', exitCode: 0 };
             });
             await executeQuery({
@@ -82,14 +84,14 @@ describe('executeQuery', () => {
                 message: 'Hello',
             });
             expect(mockSpinner.start).toHaveBeenCalled();
-            expect(mockSpinner.succeed).toHaveBeenCalledWith('Query completed');
-            expect(mockConsoleLog).toHaveBeenCalledWith('\nTest response');
+            expect(mockSpinner.stop).toHaveBeenCalled();
+            expect(mockConsoleLog).toHaveBeenCalledWith('Test response');
         });
-        it('should handle query error phase', async () => {
+        it('should handle query error phase and exit with code 2', async () => {
             const mockQueryResponse = {
                 status: {
                     phase: 'error',
-                    error: 'Query failed with test error',
+                    responses: [{ content: 'Query failed with test error' }],
                 },
             };
             mockExeca.mockImplementation(async (command, args) => {
@@ -103,20 +105,23 @@ describe('executeQuery', () => {
                         exitCode: 0,
                     };
                 }
-                if (args.includes('delete')) {
-                    return { stdout: '', stderr: '', exitCode: 0 };
-                }
                 return { stdout: '', stderr: '', exitCode: 0 };
             });
-            await executeQuery({
-                targetType: 'model',
-                targetName: 'default',
-                message: 'Hello',
-            });
-            expect(mockSpinner.fail).toHaveBeenCalledWith('Query failed');
-            expect(mockOutput.error).toHaveBeenCalledWith('Query failed with test error');
+            try {
+                await executeQuery({
+                    targetType: 'model',
+                    targetName: 'default',
+                    message: 'Hello',
+                });
+            }
+            catch (error) {
+                expect(error.message).toBe('process.exit called');
+            }
+            expect(mockSpinner.stop).toHaveBeenCalled();
+            expect(mockConsoleError).toHaveBeenCalledWith(expect.stringContaining('Query failed with test error'));
+            expect(mockExit).toHaveBeenCalledWith(ExitCodes.OperationError);
         });
-        it('should handle query canceled phase', async () => {
+        it('should handle query canceled phase and exit with code 2', async () => {
             const mockQueryResponse = {
                 status: {
                     phase: 'canceled',
@@ -134,27 +139,27 @@ describe('executeQuery', () => {
                         exitCode: 0,
                     };
                 }
-                if (args.includes('delete')) {
-                    return { stdout: '', stderr: '', exitCode: 0 };
-                }
                 return { stdout: '', stderr: '', exitCode: 0 };
             });
-            await executeQuery({
-                targetType: 'agent',
-                targetName: 'test-agent',
-                message: 'Hello',
-            });
+            try {
+                await executeQuery({
+                    targetType: 'agent',
+                    targetName: 'test-agent',
+                    message: 'Hello',
+                });
+            }
+            catch (error) {
+                expect(error.message).toBe('process.exit called');
+            }
             expect(mockSpinner.warn).toHaveBeenCalledWith('Query canceled');
             expect(mockOutput.warning).toHaveBeenCalledWith('Query was canceled');
+            expect(mockExit).toHaveBeenCalledWith(ExitCodes.OperationError);
         });
-        it('should clean up query resource even on failure', async () => {
+        it('should handle kubectl apply failures with exit code 1', async () => {
             mockExeca.mockImplementation(async (command, args) => {
                 if (args.includes('apply')) {
                     throw new Error('Failed to apply');
                 }
-                if (args.includes('delete')) {
-                    return { stdout: '', stderr: '', exitCode: 0 };
-                }
                 return { stdout: '', stderr: '', exitCode: 0 };
             });
             await expect(executeQuery({
@@ -162,9 +167,37 @@ describe('executeQuery', () => {
                 targetName: 'default',
                 message: 'Hello',
             })).rejects.toThrow('process.exit called');
-            expect(mockSpinner.fail).toHaveBeenCalledWith('Query failed');
-            expect(mockOutput.error).toHaveBeenCalledWith('Failed to apply');
-            expect(mockExit).toHaveBeenCalledWith(1);
+            expect(mockSpinner.stop).toHaveBeenCalled();
+            expect(mockConsoleError).toHaveBeenCalledWith(expect.stringContaining('Failed to apply'));
+            expect(mockExit).toHaveBeenCalledWith(ExitCodes.CliError);
+        });
+        it('should handle query timeout and exit with code 3', async () => {
+            mockExeca.mockImplementation(async (command, args) => {
+                if (args.includes('apply')) {
+                    return { stdout: '', stderr: '', exitCode: 0 };
+                }
+                if (args.includes('wait')) {
+                    // Simulate kubectl wait timeout
+                    const error = new Error('timed out waiting for the condition');
+                    throw error;
+                }
+                return { stdout: '', stderr: '', exitCode: 0 };
+            });
+            try {
+                await executeQuery({
+                    targetType: 'model',
+                    targetName: 'default',
+                    message: 'Hello',
+                    timeout: '100ms',
+                    watchTimeout: '200ms',
+                });
+            }
+            catch (error) {
+                expect(error.message).toBe('process.exit called');
+            }
+            expect(mockSpinner.stop).toHaveBeenCalled();
+            expect(mockConsoleError).toHaveBeenCalledWith(expect.stringContaining('Query did not complete within 200ms'));
+            expect(mockExit).toHaveBeenCalledWith(ExitCodes.Timeout);
         });
     });
 });

package/dist/ui/TargetSelector.d.ts

@@ -0,0 +1,19 @@
+export interface Target {
+    name: string;
+    namespace: string;
+    description?: string;
+}
+interface TargetSelectorProps {
+    targets: Target[];
+    title: string;
+    subtitle: string;
+    onSelect: (target: Target) => void;
+    onExit: () => void;
+    formatLabel?: (target: Target) => string;
+    formatInlineDetail?: (target: Target) => string | undefined;
+    showDetailPanel?: boolean;
+    loading?: boolean;
+    error?: string;
+}
+export declare function TargetSelector({ targets, title, subtitle, onSelect, onExit, formatLabel, formatInlineDetail, showDetailPanel, loading, error, }: TargetSelectorProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/ui/TargetSelector.js

@@ -0,0 +1,48 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+export function TargetSelector({ targets, title, subtitle, onSelect, onExit, formatLabel = (target) => target.name, formatInlineDetail, showDetailPanel = false, loading = false, error, }) {
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    useInput((input, key) => {
+        if (key.escape) {
+            onExit();
+        }
+        else if (key.upArrow || input === 'k') {
+            setSelectedIndex((prev) => (prev === 0 ? targets.length - 1 : prev - 1));
+        }
+        else if (key.downArrow || input === 'j') {
+            setSelectedIndex((prev) => (prev === targets.length - 1 ? 0 : prev + 1));
+        }
+        else if (key.return) {
+            onSelect(targets[selectedIndex]);
+        }
+        else {
+            const num = parseInt(input, 10);
+            if (!isNaN(num) && num >= 1 && num <= targets.length) {
+                onSelect(targets[num - 1]);
+            }
+        }
+    });
+    const truncate = (text, maxLength) => {
+        if (text.length <= maxLength)
+            return text;
+        return text.substring(0, maxLength - 3) + '...';
+    };
+    if (loading) {
+        return (_jsx(Box, { children: _jsxs(Text, { children: ["Loading ", title.toLowerCase(), "..."] }) }));
+    }
+    if (error) {
+        return (_jsx(Box, { children: _jsxs(Text, { color: "red", children: ["Error: ", error] }) }));
+    }
+    if (targets.length === 0) {
+        return (_jsx(Box, { children: _jsxs(Text, { children: ["No ", title.toLowerCase(), " available"] }) }));
+    }
+    const selectedTarget = targets[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: title }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: subtitle }) }), _jsx(Box, { flexDirection: "column", children: targets.map((target, index) => {
+                    const label = formatLabel(target);
+                    const prefix = `${index === selectedIndex ? '❯ ' : '  '}${index + 1}. ${label}`;
+                    const inlineDetail = formatInlineDetail?.(target);
+                    const maxDetailLength = 80 - prefix.length;
+                    return (_jsxs(Box, { marginBottom: 0, children: [_jsx(Text, { color: index === selectedIndex ? 'green' : undefined, children: prefix }), inlineDetail && (_jsxs(Text, { color: "gray", dimColor: true, children: [' ', truncate(inlineDetail, maxDetailLength)] }))] }, `${target.namespace}-${target.name}`));
+                }) }), showDetailPanel && selectedTarget.description && (_jsx(Box, { marginTop: 1, paddingLeft: 2, children: _jsx(Text, { dimColor: true, wrap: "wrap", children: selectedTarget.description }) })), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Enter to confirm \u00B7 Number to select \u00B7 Esc to exit" }) })] }));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agents-at-scale/ark",
-  "version": "0.1.39",
+  "version": "0.1.41",
   "description": "Ark CLI - Interactive terminal interface for ARK agents",
   "main": "dist/index.js",
   "type": "module",

package/templates/mcp-server/README.md

@@ -62,6 +62,7 @@ kubectl get queries
 | `image.repository` | string | `"{{ .Values.mcpServerName }}"` | Image repository   |
 | `image.tag`        | string | `"latest"`                      | Image tag          |
 | `service.port`     | int    | `8080`                          | Service port       |
+| `mcpServer.timeout` | string | `"30s"`                        | Timeout for MCP tool calls (e.g., "5m", "10m") |
 
 {{- if .Values.requiresAuth }}
 | `auth.token` | string | `""` | Authentication token |

package/templates/mcp-server/chart/templates/mcpserver.yaml

@@ -15,6 +15,9 @@ spec:
         path: {{ .Values.mcpServer.path }}
         {{- end }}
   transport: sse
+  {{- if .Values.mcpServer.timeout }}
+  timeout: {{ .Values.mcpServer.timeout | quote }}
+  {{- end }}
   {{- if .Values.mcpServer.description }}
   description: {{ .Values.mcpServer.description | quote }}
   {{- end }}

package/templates/mcp-server/chart/values.yaml

@@ -81,4 +81,5 @@ mcpServer:
   create: true
   name: ""
   description: "{{ .Values.description }}"
-  path: "/mcp"
+  path: "/mcp"
+  # timeout: "30s"  # Uncomment and adjust for long-running operations (e.g., "5m", "10m")

package/dist/ui/AgentSelector.d.ts

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

@@ -1,53 +0,0 @@
-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/ModelSelector.d.ts

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

package/dist/ui/ModelSelector.js

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

package/dist/ui/TeamSelector.d.ts

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

package/dist/ui/TeamSelector.js

@@ -1,55 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useState, useEffect } from 'react';
-import { Box, Text, useInput } from 'ink';
-export function TeamSelector({ arkApiClient, onSelect, onExit, }) {
-    const [selectedIndex, setSelectedIndex] = useState(0);
-    const [teams, setTeams] = useState([]);
-    const [loading, setLoading] = useState(true);
-    const [error, setError] = useState(null);
-    useEffect(() => {
-        arkApiClient
-            .getTeams()
-            .then((fetchedTeams) => {
-            setTeams(fetchedTeams);
-            setLoading(false);
-        })
-            .catch((err) => {
-            setError(err.message || 'Failed to fetch teams');
-            setLoading(false);
-        });
-    }, [arkApiClient]);
-    useInput((input, key) => {
-        if (key.escape) {
-            onExit();
-        }
-        else if (key.upArrow || input === 'k') {
-            setSelectedIndex((prev) => (prev === 0 ? teams.length - 1 : prev - 1));
-        }
-        else if (key.downArrow || input === 'j') {
-            setSelectedIndex((prev) => (prev === teams.length - 1 ? 0 : prev + 1));
-        }
-        else if (key.return) {
-            onSelect(teams[selectedIndex]);
-        }
-        else {
-            // Handle number keys for quick selection
-            const num = parseInt(input, 10);
-            if (!isNaN(num) && num >= 1 && num <= teams.length) {
-                onSelect(teams[num - 1]);
-            }
-        }
-    });
-    if (loading) {
-        return (_jsx(Box, { children: _jsx(Text, { children: "Loading teams..." }) }));
-    }
-    if (error) {
-        return (_jsx(Box, { children: _jsxs(Text, { color: "red", children: ["Error: ", error] }) }));
-    }
-    if (teams.length === 0) {
-        return (_jsx(Box, { children: _jsx(Text, { children: "No teams available" }) }));
-    }
-    const selectedTeam = teams[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 Team" }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: "Choose a team to start a conversation with" }) }), _jsx(Box, { flexDirection: "column", children: teams.map((team, index) => (_jsx(Box, { marginBottom: 0, children: _jsxs(Text, { color: index === selectedIndex ? 'green' : undefined, children: [index === selectedIndex ? '❯ ' : '  ', index + 1, ". ", team.name, team.strategy ? ` (${team.strategy})` : ''] }) }, team.name))) }), selectedTeam &&
-                (selectedTeam.description || selectedTeam.members_count) && (_jsx(Box, { marginTop: 1, paddingLeft: 2, children: _jsx(Text, { dimColor: true, wrap: "wrap", children: selectedTeam.description ||
-                        `Members: ${selectedTeam.members_count}` }) })), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Enter to confirm \u00B7 Number to select \u00B7 Esc to exit" }) })] }));
-}

package/dist/ui/ToolSelector.d.ts

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

package/dist/ui/ToolSelector.js

@@ -1,53 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useState, useEffect } from 'react';
-import { Box, Text, useInput } from 'ink';
-export function ToolSelector({ arkApiClient, onSelect, onExit, }) {
-    const [selectedIndex, setSelectedIndex] = useState(0);
-    const [tools, setTools] = useState([]);
-    const [loading, setLoading] = useState(true);
-    const [error, setError] = useState(null);
-    useEffect(() => {
-        arkApiClient
-            .getTools()
-            .then((fetchedTools) => {
-            setTools(fetchedTools);
-            setLoading(false);
-        })
-            .catch((err) => {
-            setError(err.message || 'Failed to fetch tools');
-            setLoading(false);
-        });
-    }, [arkApiClient]);
-    useInput((input, key) => {
-        if (key.escape) {
-            onExit();
-        }
-        else if (key.upArrow || input === 'k') {
-            setSelectedIndex((prev) => (prev === 0 ? tools.length - 1 : prev - 1));
-        }
-        else if (key.downArrow || input === 'j') {
-            setSelectedIndex((prev) => (prev === tools.length - 1 ? 0 : prev + 1));
-        }
-        else if (key.return) {
-            onSelect(tools[selectedIndex]);
-        }
-        else {
-            // Handle number keys for quick selection
-            const num = parseInt(input, 10);
-            if (!isNaN(num) && num >= 1 && num <= tools.length) {
-                onSelect(tools[num - 1]);
-            }
-        }
-    });
-    if (loading) {
-        return (_jsx(Box, { children: _jsx(Text, { children: "Loading tools..." }) }));
-    }
-    if (error) {
-        return (_jsx(Box, { children: _jsxs(Text, { color: "red", children: ["Error: ", error] }) }));
-    }
-    if (tools.length === 0) {
-        return (_jsx(Box, { children: _jsx(Text, { children: "No tools available" }) }));
-    }
-    const selectedTool = tools[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 Tool" }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: "Choose a tool to start a conversation with" }) }), _jsx(Box, { flexDirection: "column", children: tools.map((tool, index) => (_jsx(Box, { marginBottom: 0, children: _jsxs(Text, { color: index === selectedIndex ? 'green' : undefined, children: [index === selectedIndex ? '❯ ' : '  ', index + 1, ". ", tool.name] }) }, tool.name))) }), selectedTool && selectedTool.description && (_jsx(Box, { marginTop: 1, paddingLeft: 2, children: _jsx(Text, { dimColor: true, wrap: "wrap", children: selectedTool.description }) })), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Enter to confirm \u00B7 Number to select \u00B7 Esc to exit" }) })] }));
-}