@agents-at-scale/ark 0.1.49 → 0.1.51

package/dist/arkServices.js

@@ -119,29 +119,35 @@ const defaultArkServices = {
         k8sDeploymentName: 'ark-mcp',
         k8sDevDeploymentName: 'ark-mcp-devspace',
     },
+    // ark-broker replaces ark-cluster-memory (renamed in v0.1.49). The old release
+    // must be uninstalled first to avoid Helm ownership conflicts on shared
+    // resources like the ark-config-streaming ConfigMap.
     'ark-broker': {
         name: 'ark-broker',
         helmReleaseName: 'ark-broker',
         description: 'In-memory storage service with streaming support for Ark queries',
         enabled: true,
         category: 'service',
-        // namespace: undefined - uses current context namespace
         chartPath: `${REGISTRY_BASE}/ark-broker`,
         installArgs: [],
+        prerequisiteUninstalls: [{ releaseName: 'ark-cluster-memory' }],
         k8sDeploymentName: 'ark-broker',
         k8sDevDeploymentName: 'ark-broker-devspace',
     },
-    'mcp-filesystem': {
-        name: 'mcp-filesystem',
-        helmReleaseName: 'mcp-filesystem',
-        description: 'Stateful filesystem MCP server with workspace isolation',
-        enabled: false,
+    'file-gateway': {
+        name: 'file-gateway',
+        helmReleaseName: 'file-gateway',
+        description: 'S3-compatible file storage gateway with REST API for shared storage access',
+        enabled: true,
         category: 'service',
-        // namespace: undefined - uses current context namespace
-        chartPath: `${REGISTRY_BASE}/mcp-filesystem`,
-        installArgs: [],
-        k8sDeploymentName: 'mcp-filesystem',
-        k8sDevDeploymentName: 'mcp-filesystem-devspace',
+        namespace: 'default',
+        chartPath: `${getMarketplaceRegistry()}/file-gateway`,
+        installArgs: ['--create-namespace'],
+        k8sServiceName: 'file-gateway-file-api',
+        k8sServicePort: 8080,
+        k8sPortForwardLocalPort: undefined,
+        k8sDeploymentName: 'file-gateway-file-api',
+        k8sDevDeploymentName: undefined,
     },
     'localhost-gateway': {
         name: 'localhost-gateway',
@@ -153,7 +159,7 @@ const defaultArkServices = {
         chartPath: `${REGISTRY_BASE}/localhost-gateway`,
         installArgs: [],
     },
-    'noah': {
+    noah: {
         name: 'noah',
         helmReleaseName: 'noah',
         description: 'Runtime administration agent with cluster privileges',
@@ -173,7 +179,9 @@ function applyConfigOverrides(defaults) {
     for (const [key, service] of Object.entries(defaults)) {
         const override = overrides[key];
         result[key] =
-            override && typeof override === 'object' ? { ...service, ...override } : service;
+            override && typeof override === 'object'
+                ? { ...service, ...override }
+                : service;
     }
     return result;
 }

package/dist/commands/generate/generators/project.js

@@ -727,7 +727,7 @@ Generated with ARK CLI generator`;
             },
         ];
         if (config.projectType === 'empty') {
-            steps.push({ desc: 'Add YAML files to agents/, teams/, queries/ directories' }, { desc: 'Copy model configurations from samples/models/' }, { desc: 'Edit .env file to set your API keys' }, { desc: 'Deploy your project', cmd: 'devspace dev' });
+            steps.push({ desc: 'Add YAML files to agents/, teams/, queries/ directories' }, { desc: 'Use either the default model already in models/ or a configuration template from samples/models/ of ARK repository' }, { desc: 'Edit .env file to set your API keys' }, { desc: 'Deploy your project', cmd: 'devspace dev' });
         }
         else if (config.selectedModels && config.selectedModels !== 'none') {
             steps.push({ desc: 'Edit .env file to set your API keys' }, { desc: 'Load environment variables', cmd: 'source .env' }, { desc: 'Deploy your project', cmd: 'devspace dev' }, {
@@ -736,7 +736,7 @@ Generated with ARK CLI generator`;
             });
         }
         else {
-            steps.push({ desc: 'Copy model configurations from samples/models/' }, { desc: 'Edit .env file to set your API keys' }, { desc: 'Deploy your project', cmd: 'devspace dev' });
+            steps.push({ desc: 'Use either the default model already in models/ or a configuration template from samples/models/ of ARK repository' }, { desc: 'Edit .env file to set your API keys' }, { desc: 'Deploy your project', cmd: 'devspace dev' });
         }
         console.log(chalk.magenta.bold('🚀 NEXT STEPS:\n'));
         let stepNumber = 1;

package/dist/commands/install/index.js

@@ -10,7 +10,41 @@ import { printNextSteps } from '../../lib/nextSteps.js';
 import ora from 'ora';
 import { waitForServicesReady, } from '../../lib/waitForReady.js';
 import { parseTimeoutToSeconds } from '../../lib/timeout.js';
+async function uninstallPrerequisites(service, verbose = false) {
+    if (!service.prerequisiteUninstalls?.length)
+        return;
+    for (const prereq of service.prerequisiteUninstalls) {
+        const helmArgs = ['uninstall', prereq.releaseName, '--ignore-not-found'];
+        if (prereq.namespace) {
+            helmArgs.push('--namespace', prereq.namespace);
+        }
+        await execute('helm', helmArgs, { stdio: 'inherit' }, { verbose });
+    }
+}
+async function checkAndCleanFailedRelease(releaseName, namespace, verbose = false) {
+    const statusArgs = ['status', releaseName];
+    if (namespace) {
+        statusArgs.push('--namespace', namespace);
+    }
+    try {
+        const result = await execute('helm', statusArgs, {}, { verbose: false });
+        const stdout = String(result.stdout || '');
+        if (stdout.includes('STATUS: pending-install') ||
+            stdout.includes('STATUS: failed') ||
+            stdout.includes('STATUS: uninstalling')) {
+            const uninstallArgs = ['uninstall', releaseName];
+            if (namespace) {
+                uninstallArgs.push('--namespace', namespace);
+            }
+            await execute('helm', uninstallArgs, { stdio: 'inherit' }, { verbose });
+        }
+    }
+    catch {
+    }
+}
 async function installService(service, verbose = false) {
+    await uninstallPrerequisites(service, verbose);
+    await checkAndCleanFailedRelease(service.helmReleaseName, service.namespace, verbose);
     const helmArgs = [
         'upgrade',
         '--install',

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

@@ -140,4 +140,147 @@ describe('install command', () => {
         await expect(command.parseAsync(['node', 'test', 'ark-api'])).rejects.toThrow('process.exit called');
         expect(mockExit).toHaveBeenCalledWith(1);
     });
+    describe('checkAndCleanFailedRelease', () => {
+        it('uninstalls release in pending-install state', async () => {
+            const mockService = {
+                name: 'ark-api',
+                helmReleaseName: 'ark-api',
+                chartPath: './charts/ark-api',
+                namespace: 'ark-system',
+            };
+            mockGetInstallableServices.mockReturnValue({
+                'ark-api': mockService,
+            });
+            mockExeca
+                .mockResolvedValueOnce({
+                stdout: 'NAME: ark-api\nSTATUS: pending-install\n',
+            })
+                .mockResolvedValueOnce({})
+                .mockResolvedValueOnce({});
+            const command = createInstallCommand(mockConfig);
+            await command.parseAsync(['node', 'test', 'ark-api']);
+            expect(mockExeca).toHaveBeenCalledWith('helm', ['status', 'ark-api', '--namespace', 'ark-system'], {});
+            expect(mockExeca).toHaveBeenCalledWith('helm', ['uninstall', 'ark-api', '--namespace', 'ark-system'], { stdio: 'inherit' });
+            expect(mockExeca).toHaveBeenCalledWith('helm', [
+                'upgrade',
+                '--install',
+                'ark-api',
+                './charts/ark-api',
+                '--namespace',
+                'ark-system',
+            ], { stdio: 'inherit' });
+        });
+        it('uninstalls release in failed state', async () => {
+            const mockService = {
+                name: 'ark-api',
+                helmReleaseName: 'ark-api',
+                chartPath: './charts/ark-api',
+                namespace: 'ark-system',
+            };
+            mockGetInstallableServices.mockReturnValue({
+                'ark-api': mockService,
+            });
+            mockExeca
+                .mockResolvedValueOnce({
+                stdout: 'NAME: ark-api\nSTATUS: failed\n',
+            })
+                .mockResolvedValueOnce({})
+                .mockResolvedValueOnce({});
+            const command = createInstallCommand(mockConfig);
+            await command.parseAsync(['node', 'test', 'ark-api']);
+            expect(mockExeca).toHaveBeenCalledWith('helm', ['uninstall', 'ark-api', '--namespace', 'ark-system'], { stdio: 'inherit' });
+        });
+        it('uninstalls release in uninstalling state', async () => {
+            const mockService = {
+                name: 'ark-dashboard',
+                helmReleaseName: 'ark-dashboard',
+                chartPath: './charts/ark-dashboard',
+                namespace: 'default',
+            };
+            mockGetInstallableServices.mockReturnValue({
+                'ark-dashboard': mockService,
+            });
+            mockExeca
+                .mockResolvedValueOnce({
+                stdout: 'NAME: ark-dashboard\nSTATUS: uninstalling\nREVISION: 2\n',
+            })
+                .mockResolvedValueOnce({})
+                .mockResolvedValueOnce({});
+            const command = createInstallCommand(mockConfig);
+            await command.parseAsync(['node', 'test', 'ark-dashboard']);
+            expect(mockExeca).toHaveBeenCalledWith('helm', ['uninstall', 'ark-dashboard', '--namespace', 'default'], { stdio: 'inherit' });
+        });
+        it('does not uninstall release in deployed state', async () => {
+            const mockService = {
+                name: 'ark-api',
+                helmReleaseName: 'ark-api',
+                chartPath: './charts/ark-api',
+                namespace: 'ark-system',
+            };
+            mockGetInstallableServices.mockReturnValue({
+                'ark-api': mockService,
+            });
+            mockExeca
+                .mockResolvedValueOnce({
+                stdout: 'NAME: ark-api\nSTATUS: deployed\n',
+            })
+                .mockResolvedValueOnce({});
+            const command = createInstallCommand(mockConfig);
+            await command.parseAsync(['node', 'test', 'ark-api']);
+            const uninstallCalls = mockExeca.mock.calls.filter((call) => call[0] === 'helm' && call[1][0] === 'uninstall');
+            expect(uninstallCalls).toHaveLength(0);
+            expect(mockExeca).toHaveBeenCalledWith('helm', [
+                'upgrade',
+                '--install',
+                'ark-api',
+                './charts/ark-api',
+                '--namespace',
+                'ark-system',
+            ], { stdio: 'inherit' });
+        });
+        it('handles helm status errors gracefully', async () => {
+            const mockService = {
+                name: 'ark-api',
+                helmReleaseName: 'ark-api',
+                chartPath: './charts/ark-api',
+                namespace: 'ark-system',
+            };
+            mockGetInstallableServices.mockReturnValue({
+                'ark-api': mockService,
+            });
+            mockExeca
+                .mockRejectedValueOnce(new Error('release not found'))
+                .mockResolvedValueOnce({});
+            const command = createInstallCommand(mockConfig);
+            await command.parseAsync(['node', 'test', 'ark-api']);
+            expect(mockExeca).toHaveBeenCalledWith('helm', [
+                'upgrade',
+                '--install',
+                'ark-api',
+                './charts/ark-api',
+                '--namespace',
+                'ark-system',
+            ], { stdio: 'inherit' });
+        });
+        it('handles service without namespace', async () => {
+            const mockService = {
+                name: 'ark-dashboard',
+                helmReleaseName: 'ark-dashboard',
+                chartPath: './charts/ark-dashboard',
+            };
+            mockGetInstallableServices.mockReturnValue({
+                'ark-dashboard': mockService,
+            });
+            mockExeca
+                .mockResolvedValueOnce({
+                stdout: 'NAME: ark-dashboard\nSTATUS: failed\n',
+            })
+                .mockResolvedValueOnce({})
+                .mockResolvedValueOnce({});
+            const command = createInstallCommand(mockConfig);
+            await command.parseAsync(['node', 'test', 'ark-dashboard']);
+            expect(mockExeca).toHaveBeenCalledWith('helm', ['status', 'ark-dashboard'], {});
+            expect(mockExeca).toHaveBeenCalledWith('helm', ['uninstall', 'ark-dashboard'], { stdio: 'inherit' });
+        });
+    });
 });

package/dist/commands/models/create.spec.js

@@ -134,15 +134,34 @@ describe('createModel', () => {
         expect(mockOutput.info).toHaveBeenCalledWith('model creation cancelled');
     });
     it('handles secret creation failure', async () => {
-        mockExeca.mockRejectedValueOnce(new Error('not found')); // model doesn't exist
+        mockExeca
+            .mockRejectedValueOnce(new Error('not found')); // model doesn't exist
         mockInquirer.prompt
             .mockResolvedValueOnce({ modelType: 'openai' })
             .mockResolvedValueOnce({ model: 'gpt-4' })
             .mockResolvedValueOnce({ baseUrl: 'https://api.openai.com' })
             .mockResolvedValueOnce({ apiKey: 'secret' });
+        mockExeca
+            .mockRejectedValueOnce(new Error('not found')); // secret doesn't exist check
         mockExeca.mockRejectedValueOnce(new Error('secret creation failed')); // create secret fails
         const result = await createModel('test-model');
         expect(result).toBe(false);
         expect(mockOutput.error).toHaveBeenCalledWith('failed to create secret');
     });
+    it('updates existing secret when secret already exists', async () => {
+        mockExeca.mockRejectedValueOnce(new Error('not found')); // model doesn't exist
+        mockInquirer.prompt
+            .mockResolvedValueOnce({ modelType: 'openai' })
+            .mockResolvedValueOnce({ model: 'gpt-4' })
+            .mockResolvedValueOnce({ baseUrl: 'https://api.openai.com' })
+            .mockResolvedValueOnce({ apiKey: 'new-secret-key' });
+        mockExeca.mockResolvedValueOnce({}); // secret exists check
+        mockExeca.mockResolvedValueOnce({ stdout: 'secret yaml' }); // dry-run output
+        mockExeca.mockResolvedValueOnce({}); // kubectl apply
+        mockExeca.mockResolvedValueOnce({}); // apply model
+        const result = await createModel('test-model');
+        expect(result).toBe(true);
+        expect(mockOutput.success).toHaveBeenCalledWith('updated secret test-model-model-secret');
+        expect(mockOutput.success).toHaveBeenCalledWith('model test-model created');
+    });
 });

package/dist/commands/models/kubernetes/manifest-builder.js

@@ -11,7 +11,7 @@ export class KubernetesModelManifestBuilder {
                 name: this.modelName,
             },
             spec: {
-                type: config.type,
+                provider: config.type, // Use provider field (required as of v0.50.0)
                 model: {
                     value: config.modelValue,
                 },

package/dist/commands/models/kubernetes/secret-manager.d.ts

@@ -4,4 +4,7 @@ export interface SecretManager {
 }
 export declare class KubernetesSecretManager implements SecretManager {
     createSecret(config: ProviderConfig): Promise<void>;
+    private secretExists;
+    private createNewSecret;
+    private updateSecret;
 }

package/dist/commands/models/kubernetes/secret-manager.js

@@ -3,6 +3,24 @@ import output from '../../../lib/output.js';
 // Kubernetes secret manager implementation
 export class KubernetesSecretManager {
     async createSecret(config) {
+        const secretExists = await this.secretExists(config.secretName);
+        if (secretExists) {
+            await this.updateSecret(config);
+        }
+        else {
+            await this.createNewSecret(config);
+        }
+    }
+    async secretExists(secretName) {
+        try {
+            await execa('kubectl', ['get', 'secret', secretName], { stdio: 'pipe' });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async createNewSecret(config) {
         const secretArgs = ['create', 'secret', 'generic', config.secretName];
         if (config.type === 'bedrock') {
             secretArgs.push(`--from-literal=access-key-id=${config.accessKeyId}`);
@@ -13,8 +31,30 @@ export class KubernetesSecretManager {
         }
         else {
             secretArgs.push(`--from-literal=api-key=${config.apiKey}`);
+            secretArgs.push(`--from-literal=token=${config.apiKey}`);
         }
         await execa('kubectl', secretArgs, { stdio: 'pipe' });
         output.success(`created secret ${config.secretName}`);
     }
+    async updateSecret(config) {
+        const secretArgs = ['create', 'secret', 'generic', config.secretName];
+        if (config.type === 'bedrock') {
+            secretArgs.push(`--from-literal=access-key-id=${config.accessKeyId}`);
+            secretArgs.push(`--from-literal=secret-access-key=${config.secretAccessKey}`);
+            if (config.sessionToken) {
+                secretArgs.push(`--from-literal=session-token=${config.sessionToken}`);
+            }
+        }
+        else {
+            secretArgs.push(`--from-literal=api-key=${config.apiKey}`);
+            secretArgs.push(`--from-literal=token=${config.apiKey}`);
+        }
+        secretArgs.push('--dry-run=client', '-o', 'yaml');
+        const { stdout } = await execa('kubectl', secretArgs, { stdio: 'pipe' });
+        await execa('kubectl', ['apply', '-f', '-'], {
+            input: stdout,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        output.success(`updated secret ${config.secretName}`);
+    }
 }

package/dist/commands/queries/index.js

@@ -26,8 +26,8 @@ async function getQuery(name, options) {
     try {
         const query = await getResource('queries', name);
         if (options.response) {
-            if (query.status?.responses && query.status.responses.length > 0) {
-                const response = query.status.responses[0];
+            if (query.status?.response) {
+                const response = query.status.response;
                 if (options.output === 'markdown') {
                     console.log(renderMarkdown(response.content || ''));
                 }
@@ -40,8 +40,8 @@ async function getQuery(name, options) {
             }
         }
         else if (options.output === 'markdown') {
-            if (query.status?.responses && query.status.responses.length > 0) {
-                console.log(renderMarkdown(query.status.responses[0].content || ''));
+            if (query.status?.response) {
+                console.log(renderMarkdown(query.status.response.content || ''));
             }
             else {
                 output.warning('No response available');

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

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

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

@@ -0,0 +1,167 @@
+import { jest } from '@jest/globals';
+import output from '../../lib/output.js';
+const mockExeca = jest.fn();
+jest.unstable_mockModule('execa', () => ({
+    execa: mockExeca,
+}));
+const { createQueriesCommand } = await import('./index.js');
+describe('queries get command', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        console.log = jest.fn();
+        jest.spyOn(output, 'warning').mockImplementation(() => { });
+        jest.spyOn(output, 'error').mockImplementation(() => { });
+        jest.spyOn(process, 'exit').mockImplementation(() => undefined);
+    });
+    it('should get query with response in JSON format', async () => {
+        const mockQuery = {
+            metadata: {
+                name: 'test-query',
+            },
+            spec: {
+                input: 'test input',
+                target: { type: 'agent', name: 'test-agent' },
+            },
+            status: {
+                phase: 'done',
+                response: {
+                    content: 'This is the response',
+                },
+            },
+        };
+        mockExeca.mockResolvedValue({
+            stdout: JSON.stringify(mockQuery),
+        });
+        const command = createQueriesCommand({});
+        await command.parseAsync(['node', 'test', 'get', 'test-query']);
+        expect(console.log).toHaveBeenCalledWith(JSON.stringify(mockQuery, null, 2));
+        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'queries', 'test-query', '-o', 'json'], { stdio: 'pipe' });
+    });
+    it('should get query with response flag in JSON format', async () => {
+        const mockQuery = {
+            metadata: {
+                name: 'test-query',
+            },
+            spec: {
+                input: 'test input',
+                target: { type: 'agent', name: 'test-agent' },
+            },
+            status: {
+                phase: 'done',
+                response: {
+                    content: 'This is the response content',
+                },
+            },
+        };
+        mockExeca.mockResolvedValue({
+            stdout: JSON.stringify(mockQuery),
+        });
+        const command = createQueriesCommand({});
+        await command.parseAsync([
+            'node',
+            'test',
+            'get',
+            'test-query',
+            '--response',
+        ]);
+        expect(console.log).toHaveBeenCalledWith(JSON.stringify(mockQuery.status.response, null, 2));
+        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'queries', 'test-query', '-o', 'json'], { stdio: 'pipe' });
+    });
+    it('should get query with response flag in markdown format', async () => {
+        const mockQuery = {
+            metadata: {
+                name: 'test-query',
+            },
+            spec: {
+                input: 'test input',
+                target: { type: 'agent', name: 'test-agent' },
+            },
+            status: {
+                phase: 'done',
+                response: {
+                    content: '# Heading\n\nThis is markdown content',
+                },
+            },
+        };
+        mockExeca.mockResolvedValue({
+            stdout: JSON.stringify(mockQuery),
+        });
+        const command = createQueriesCommand({});
+        await command.parseAsync([
+            'node',
+            'test',
+            'get',
+            'test-query',
+            '--response',
+            '--output',
+            'markdown',
+        ]);
+        expect(console.log).toHaveBeenCalled();
+        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'queries', 'test-query', '-o', 'json'], { stdio: 'pipe' });
+    });
+    it('should get query in markdown format without response flag', async () => {
+        const mockQuery = {
+            metadata: {
+                name: 'test-query',
+            },
+            spec: {
+                input: 'test input',
+                target: { type: 'agent', name: 'test-agent' },
+            },
+            status: {
+                phase: 'done',
+                response: {
+                    content: '# Response\n\nMarkdown response',
+                },
+            },
+        };
+        mockExeca.mockResolvedValue({
+            stdout: JSON.stringify(mockQuery),
+        });
+        const command = createQueriesCommand({});
+        await command.parseAsync([
+            'node',
+            'test',
+            'get',
+            'test-query',
+            '--output',
+            'markdown',
+        ]);
+        expect(console.log).toHaveBeenCalled();
+        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'queries', 'test-query', '-o', 'json'], { stdio: 'pipe' });
+    });
+    it('should warn when query has no response with response flag', async () => {
+        const mockQuery = {
+            metadata: {
+                name: 'test-query',
+            },
+            spec: {
+                input: 'test input',
+                target: { type: 'agent', name: 'test-agent' },
+            },
+            status: {
+                phase: 'running',
+            },
+        };
+        mockExeca.mockResolvedValue({
+            stdout: JSON.stringify(mockQuery),
+        });
+        const command = createQueriesCommand({});
+        await command.parseAsync([
+            'node',
+            'test',
+            'get',
+            'test-query',
+            '--response',
+        ]);
+        expect(output.warning).toHaveBeenCalledWith('No response available');
+        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'queries', 'test-query', '-o', 'json'], { stdio: 'pipe' });
+    });
+    it('should handle errors when getting query', async () => {
+        mockExeca.mockRejectedValue(new Error('Query not found'));
+        const command = createQueriesCommand({});
+        await command.parseAsync(['node', 'test', 'get', 'nonexistent-query']);
+        expect(output.error).toHaveBeenCalledWith('fetching query:', 'Query not found');
+        expect(process.exit).toHaveBeenCalled();
+    });
+});

package/dist/components/ChatUI.js

@@ -467,11 +467,11 @@ const ChatUI = ({ initialTargetId, arkApiClient, arkApiProxy, config, }) => {
             }
             // Send message and get response with abort signal
             const fullResponse = await chatClientRef.current.sendMessage(target.id, apiMessages, { ...chatConfig, a2aContextId: a2aContextIdRef.current }, (chunk, toolCalls, arkMetadata) => {
-                // Extract A2A context ID from first response
-                // Chat TUI always queries a single target, so contextId is in responses[0]
-                if (arkMetadata?.completedQuery?.status?.responses?.[0]?.a2a?.contextId) {
+                // Extract A2A context ID from response
+                // Chat TUI always queries a single target, so contextId is in response
+                if (arkMetadata?.completedQuery?.status?.response?.a2a?.contextId) {
                     a2aContextIdRef.current =
-                        arkMetadata.completedQuery.status.responses[0].a2a.contextId;
+                        arkMetadata.completedQuery.status.response.a2a.contextId;
                 }
                 // Update message progressively as chunks arrive
                 setMessages((prev) => {

package/dist/lib/executeQuery.js

@@ -116,12 +116,10 @@ async function executeQueryWithFormat(options) {
             ...((options.conversationId || process.env.ARK_CONVERSATION_ID) && {
                 conversationId: options.conversationId || process.env.ARK_CONVERSATION_ID,
             }),
-            targets: [
-                {
-                    type: options.targetType,
-                    name: options.targetName,
-                },
-            ],
+            target: {
+                type: options.targetType,
+                name: options.targetName,
+            },
         },
     };
     try {

package/dist/lib/types.d.ts

@@ -101,7 +101,7 @@ export interface QueryResponse {
 export interface QueryStatus {
     phase?: 'initializing' | 'running' | 'done' | 'error' | 'canceled';
     conditions?: K8sCondition[];
-    responses?: QueryResponse[];
+    response?: QueryResponse;
     message?: string;
     error?: string;
     tokenUsage?: {
@@ -120,7 +120,7 @@ export interface Query {
     metadata: K8sMetadata;
     spec?: {
         input: string;
-        targets: QueryTarget[];
+        target: QueryTarget;
         sessionId?: string;
         conversationId?: string;
         timeout?: string;

package/dist/types/arkService.d.ts

@@ -1,3 +1,7 @@
+export interface PrerequisiteUninstall {
+    releaseName: string;
+    namespace?: string;
+}
 export interface ArkService {
     name: string;
     helmReleaseName: string;
@@ -7,6 +11,7 @@ export interface ArkService {
     namespace?: string;
     chartPath?: string;
     installArgs?: string[];
+    prerequisiteUninstalls?: PrerequisiteUninstall[];
     k8sServiceName?: string;
     k8sServicePort?: number;
     k8sPortForwardLocalPort?: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agents-at-scale/ark",
-  "version": "0.1.49",
+  "version": "0.1.51",
   "description": "Ark CLI - Interactive terminal interface for ARK agents",
   "main": "dist/index.js",
   "type": "module",
@@ -60,7 +60,7 @@
     "open": "^10.2.0",
     "openai": "^5.19.1",
     "ora": "^8.2.0",
-    "react": "^19.1.0",
+    "react": "^19.1.5",
     "yaml": "^2.6.1"
   },
   "devDependencies": {

package/templates/mcp-server/Dockerfile

@@ -1,5 +1,5 @@
 {{- if eq .Values.technology "node" }}
-FROM node:22
+FROM node:22.22.0-alpine
 
 # Install the MCP server package
 {{- if .Values.packageSource }}
@@ -78,7 +78,7 @@ WORKDIR /app
 RUN go build -o {{ .Values.mcpServerName }} .
 {{- end }}
 
-FROM node:22
+FROM node:22.22.0-alpine
 {{- if eq .Values.packageSource "go-install" }}
 COPY --from=go-builder /go/bin/{{ .Values.packageName }} /usr/local/bin/
 {{- else }}

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

@@ -27,7 +27,7 @@ securityContext:
     - ALL
   readOnlyRootFilesystem: true
   runAsNonRoot: true
-  runAsUser: 1000
+  runAsUser: 1001
 
 service:
   type: ClusterIP

package/templates/project/values.yaml

@@ -49,7 +49,7 @@ security:
   # Pod security context
   podSecurityContext:
     runAsNonRoot: true
-    runAsUser: 1000
+    runAsUser: 1001
     fsGroup: 2000
 
   # Container security context
@@ -57,7 +57,7 @@ security:
     allowPrivilegeEscalation: false
     readOnlyRootFilesystem: true
     runAsNonRoot: true
-    runAsUser: 1000
+    runAsUser: 1001
     capabilities:
       drop:
         - ALL