@agents-at-scale/ark 0.1.50 → 0.1.52

package/dist/arkServices.js

@@ -134,17 +134,20 @@ const defaultArkServices = {
         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',
@@ -156,7 +159,7 @@ const defaultArkServices = {
         chartPath: `${REGISTRY_BASE}/localhost-gateway`,
         installArgs: [],
     },
-    'noah': {
+    noah: {
         name: 'noah',
         helmReleaseName: 'noah',
         description: 'Runtime administration agent with cluster privileges',
@@ -176,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

@@ -21,8 +21,30 @@ async function uninstallPrerequisites(service, verbose = false) {
         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/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/package.json

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