@agents-at-scale/ark 0.1.38 → 0.1.40

package/dist/arkServices.js

@@ -69,6 +69,15 @@ const defaultArkServices = {
         k8sDeploymentName: 'ark-controller',
         k8sDevDeploymentName: 'ark-controller-devspace',
     },
+    'ark-tenant': {
+        name: 'ark-tenant',
+        helmReleaseName: 'ark-tenant',
+        description: 'Tenant provisioning with RBAC and resource quotas',
+        enabled: true,
+        category: 'core',
+        chartPath: `${REGISTRY_BASE}/ark-tenant`,
+        installArgs: [],
+    },
     'ark-api': {
         name: 'ark-api',
         helmReleaseName: 'ark-api',

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/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,65 @@ 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agents-at-scale/ark",
-  "version": "0.1.38",
+  "version": "0.1.40",
   "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")