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

package/dist/lib/arkServiceProxy.js

@@ -18,9 +18,11 @@ export class ArkServiceProxy {
                 'port-forward',
                 `service/${this.service.k8sServiceName}`,
                 `${this.localPort}:${this.service.k8sServicePort}`,
-                '--namespace',
-                this.service.namespace,
             ];
+            // Add namespace flag only if namespace is defined
+            if (this.service.namespace) {
+                args.push('--namespace', this.service.namespace);
+            }
             this.kubectlProcess = spawn('kubectl', args, {
                 stdio: ['ignore', 'pipe', 'pipe'],
             });

package/dist/lib/arkStatus.d.ts

@@ -1,3 +1,8 @@
+/**
+ * Get current installed ARK version
+ * @returns version string if found, undefined otherwise
+ */
+export declare function getArkVersion(): Promise<string | undefined>;
 /**
  * Check if ARK is ready by verifying the ark-controller is running
  * @returns true if ark-controller deployment exists and has ready replicas

package/dist/lib/arkStatus.js

@@ -1,4 +1,21 @@
 import { execa } from 'execa';
+import { arkServices } from '../arkServices.js';
+/**
+ * Get current installed ARK version
+ * @returns version string if found, undefined otherwise
+ */
+export async function getArkVersion() {
+    try {
+        const controller = arkServices['ark-controller'];
+        const { stdout } = await execa('helm', ['list', '-n', controller.namespace, '-o', 'json'], { stdio: 'pipe' });
+        const releases = JSON.parse(stdout);
+        const arkController = releases.find((r) => r.name === controller.helmReleaseName);
+        return arkController?.app_version;
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
  * Check if ARK is ready by verifying the ark-controller is running
  * @returns true if ark-controller deployment exists and has ready replicas
@@ -10,11 +27,53 @@ export async function isArkReady() {
         const deployment = JSON.parse(result.stdout);
         const readyReplicas = deployment.status?.readyReplicas || 0;
         const replicas = deployment.spec?.replicas || 0;
+        // If main deployment has 0 replicas, check devspace deployment
+        if (replicas === 0) {
+            try {
+                const devResult = await execa('kubectl', [
+                    'get',
+                    'deployment',
+                    'ark-controller-devspace',
+                    '-n',
+                    'ark-system',
+                    '-o',
+                    'json',
+                ], { stdio: 'pipe' });
+                const devDeployment = JSON.parse(devResult.stdout);
+                const devReadyReplicas = devDeployment.status?.readyReplicas || 0;
+                const devReplicas = devDeployment.spec?.replicas || 0;
+                // ARK is ready if devspace deployment has ready replicas
+                return devReadyReplicas > 0 && devReadyReplicas === devReplicas;
+            }
+            catch {
+                // Devspace deployment doesn't exist
+                return false;
+            }
+        }
         // ARK is ready if deployment exists and has at least one ready replica
         return readyReplicas > 0 && readyReplicas === replicas;
     }
     catch {
-        // Deployment doesn't exist or kubectl failed
-        return false;
+        // Main deployment doesn't exist, try devspace deployment
+        try {
+            const devResult = await execa('kubectl', [
+                'get',
+                'deployment',
+                'ark-controller-devspace',
+                '-n',
+                'ark-system',
+                '-o',
+                'json',
+            ], { stdio: 'pipe' });
+            const devDeployment = JSON.parse(devResult.stdout);
+            const devReadyReplicas = devDeployment.status?.readyReplicas || 0;
+            const devReplicas = devDeployment.spec?.replicas || 0;
+            // ARK is ready if devspace deployment has ready replicas
+            return devReadyReplicas > 0 && devReadyReplicas === devReplicas;
+        }
+        catch {
+            // Neither deployment exists or kubectl failed
+            return false;
+        }
     }
 }

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

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

package/dist/lib/arkStatus.spec.js

@@ -0,0 +1,49 @@
+import { describe, it, expect, jest, beforeEach } from '@jest/globals';
+// Mock execa using unstable_mockModule
+jest.unstable_mockModule('execa', () => ({
+    execa: jest.fn(),
+}));
+// Dynamic imports after mock
+const { execa } = await import('execa');
+const { isArkReady } = await import('./arkStatus.js');
+describe('arkStatus with __mocks__', () => {
+    describe('isArkReady', () => {
+        beforeEach(() => {
+            jest.clearAllMocks();
+        });
+        it('should return true when ark-controller is deployed and ready', async () => {
+            // Mock successful kubectl response with ready deployment
+            const mockDeployment = {
+                metadata: { name: 'ark-controller' },
+                spec: { replicas: 3 },
+                status: {
+                    readyReplicas: 3,
+                    availableReplicas: 3,
+                },
+            };
+            execa.mockResolvedValue({
+                stdout: JSON.stringify(mockDeployment),
+                stderr: '',
+                exitCode: 0,
+                failed: false,
+            });
+            const result = await isArkReady();
+            expect(result).toBe(true);
+            expect(execa).toHaveBeenCalledWith('kubectl', [
+                'get',
+                'deployment',
+                'ark-controller',
+                '-n',
+                'ark-system',
+                '-o',
+                'json',
+            ], { stdio: 'pipe' });
+        });
+        it('should return false when kubectl fails', async () => {
+            // Mock kubectl failure
+            execa.mockRejectedValue(new Error('kubectl not found'));
+            const result = await isArkReady();
+            expect(result).toBe(false);
+        });
+    });
+});

package/dist/lib/chatClient.js

@@ -1,4 +1,3 @@
-import output from './output.js';
 export class ChatClient {
     constructor(arkApiClient) {
         this.arkApiClient = arkApiClient;
@@ -93,8 +92,7 @@ export class ChatClient {
             }
         }
         catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            output.error('failed to call openai api:', errorMessage);
+            // Don't log here - error will be displayed in the message thread
             throw error;
         }
     }

package/dist/lib/cluster.js

@@ -1,10 +1,7 @@
-import { executeCommand } from './exec.js';
+import { execa } from 'execa';
 export async function detectClusterType() {
     try {
-        const { stdout } = await executeCommand('kubectl', [
-            'config',
-            'current-context',
-        ]);
+        const { stdout } = await execa('kubectl', ['config', 'current-context']);
         const context = stdout.trim();
         if (context.includes('minikube')) {
             return { type: 'minikube', context };
@@ -39,7 +36,7 @@ export async function getClusterInfo(context) {
         // If context is provided, use it
         const contextArgs = context ? ['--context', context] : [];
         // Get all config info in one command
-        const { stdout: configJson } = await executeCommand('kubectl', [
+        const { stdout: configJson } = await execa('kubectl', [
             'config',
             'view',
             '--minify',
@@ -62,12 +59,12 @@ export async function getClusterInfo(context) {
         switch (clusterInfo.type) {
             case 'minikube':
                 try {
-                    const { stdout } = await executeCommand('minikube', ['ip']);
+                    const { stdout } = await execa('minikube', ['ip']);
                     ip = stdout.trim();
                 }
                 catch {
                     // Fallback to kubectl if minikube command fails
-                    const { stdout } = await executeCommand('kubectl', [
+                    const { stdout } = await execa('kubectl', [
                         'get',
                         'nodes',
                         '-o',
@@ -77,7 +74,7 @@ export async function getClusterInfo(context) {
                 }
                 break;
             case 'kind': {
-                const { stdout: kindOutput } = await executeCommand('kubectl', [
+                const { stdout: kindOutput } = await execa('kubectl', [
                     'get',
                     'nodes',
                     '-o',
@@ -90,7 +87,7 @@ export async function getClusterInfo(context) {
                 ip = 'localhost';
                 break;
             case 'k3s': {
-                const { stdout: k3sOutput } = await executeCommand('kubectl', [
+                const { stdout: k3sOutput } = await execa('kubectl', [
                     'get',
                     'nodes',
                     '-o',
@@ -102,7 +99,7 @@ export async function getClusterInfo(context) {
             case 'cloud':
                 // For cloud clusters, try to get the external IP or load balancer IP
                 try {
-                    const { stdout: lbOutput } = await executeCommand('kubectl', [
+                    const { stdout: lbOutput } = await execa('kubectl', [
                         'get',
                         'svc',
                         '-n',
@@ -113,7 +110,7 @@ export async function getClusterInfo(context) {
                     ]);
                     ip = lbOutput.trim();
                     if (!ip) {
-                        const { stdout: hostnameOutput } = await executeCommand('kubectl', [
+                        const { stdout: hostnameOutput } = await execa('kubectl', [
                             'get',
                             'svc',
                             '-n',
@@ -127,7 +124,7 @@ export async function getClusterInfo(context) {
                 }
                 catch {
                     // Fallback to node IP
-                    const { stdout: nodeOutput } = await executeCommand('kubectl', [
+                    const { stdout: nodeOutput } = await execa('kubectl', [
                         'get',
                         'nodes',
                         '-o',
@@ -137,7 +134,7 @@ export async function getClusterInfo(context) {
                 }
                 break;
             default: {
-                const { stdout: defaultOutput } = await executeCommand('kubectl', [
+                const { stdout: defaultOutput } = await execa('kubectl', [
                     'get',
                     'nodes',
                     '-o',

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

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

package/dist/lib/cluster.spec.js

@@ -0,0 +1,338 @@
+import { jest } from '@jest/globals';
+const mockExeca = jest.fn();
+jest.unstable_mockModule('execa', () => ({
+    execa: mockExeca,
+}));
+const { getClusterInfo, detectClusterType } = await import('./cluster.js');
+describe('cluster', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('detectClusterType', () => {
+        it('detects minikube cluster', async () => {
+            mockExeca.mockResolvedValue({ stdout: 'minikube' });
+            const result = await detectClusterType();
+            expect(result).toEqual({ type: 'minikube', context: 'minikube' });
+            expect(mockExeca).toHaveBeenCalledWith('kubectl', [
+                'config',
+                'current-context',
+            ]);
+        });
+        it('detects kind cluster', async () => {
+            mockExeca.mockResolvedValue({ stdout: 'kind-kind' });
+            const result = await detectClusterType();
+            expect(result).toEqual({ type: 'kind', context: 'kind-kind' });
+        });
+        it('detects k3s cluster', async () => {
+            mockExeca.mockResolvedValue({ stdout: 'k3s-default' });
+            const result = await detectClusterType();
+            expect(result).toEqual({ type: 'k3s', context: 'k3s-default' });
+        });
+        it('detects docker-desktop cluster', async () => {
+            mockExeca.mockResolvedValue({ stdout: 'docker-desktop' });
+            const result = await detectClusterType();
+            expect(result).toEqual({
+                type: 'docker-desktop',
+                context: 'docker-desktop',
+            });
+        });
+        it('detects gke cloud cluster', async () => {
+            mockExeca.mockResolvedValue({ stdout: 'gke_project_zone_cluster' });
+            const result = await detectClusterType();
+            expect(result).toEqual({
+                type: 'cloud',
+                context: 'gke_project_zone_cluster',
+            });
+        });
+        it('detects eks cloud cluster', async () => {
+            mockExeca.mockResolvedValue({
+                stdout: 'arn:aws:eks:region:account:cluster/name',
+            });
+            const result = await detectClusterType();
+            expect(result).toEqual({
+                type: 'cloud',
+                context: 'arn:aws:eks:region:account:cluster/name',
+            });
+        });
+        it('detects aks cloud cluster', async () => {
+            mockExeca.mockResolvedValue({ stdout: 'aks-cluster-name' });
+            const result = await detectClusterType();
+            expect(result).toEqual({ type: 'cloud', context: 'aks-cluster-name' });
+        });
+        it('returns unknown for unrecognized cluster', async () => {
+            mockExeca.mockResolvedValue({ stdout: 'some-other-cluster' });
+            const result = await detectClusterType();
+            expect(result).toEqual({ type: 'unknown', context: 'some-other-cluster' });
+        });
+        it('handles kubectl error', async () => {
+            mockExeca.mockRejectedValue(new Error('kubectl not found'));
+            const result = await detectClusterType();
+            expect(result).toEqual({ type: 'unknown', error: 'kubectl not found' });
+        });
+    });
+    describe('getClusterInfo', () => {
+        const mockConfig = {
+            'current-context': 'minikube',
+            contexts: [
+                {
+                    name: 'minikube',
+                    context: {
+                        namespace: 'default',
+                    },
+                },
+            ],
+        };
+        it('gets minikube cluster info with IP', async () => {
+            mockExeca
+                .mockResolvedValueOnce({ stdout: JSON.stringify(mockConfig) })
+                .mockResolvedValueOnce({ stdout: 'minikube' })
+                .mockResolvedValueOnce({ stdout: '192.168.49.2' });
+            const result = await getClusterInfo();
+            expect(result).toEqual({
+                type: 'minikube',
+                context: 'minikube',
+                namespace: 'default',
+                ip: '192.168.49.2',
+            });
+            expect(mockExeca).toHaveBeenCalledWith('kubectl', [
+                'config',
+                'view',
+                '--minify',
+                '-o',
+                'json',
+            ]);
+            expect(mockExeca).toHaveBeenCalledWith('kubectl', [
+                'config',
+                'current-context',
+            ]);
+            expect(mockExeca).toHaveBeenCalledWith('minikube', ['ip']);
+        });
+        it('falls back to kubectl for minikube IP if minikube command fails', async () => {
+            mockExeca
+                .mockResolvedValueOnce({ stdout: JSON.stringify(mockConfig) })
+                .mockResolvedValueOnce({ stdout: 'minikube' })
+                .mockRejectedValueOnce(new Error('minikube not found'))
+                .mockResolvedValueOnce({ stdout: '192.168.49.2' });
+            const result = await getClusterInfo();
+            expect(result.ip).toBe('192.168.49.2');
+            expect(mockExeca).toHaveBeenCalledWith('kubectl', [
+                'get',
+                'nodes',
+                '-o',
+                'jsonpath={.items[0].status.addresses[?(@.type=="InternalIP")].address}',
+            ]);
+        });
+        it('gets kind cluster info with IP', async () => {
+            const kindConfig = {
+                'current-context': 'kind-kind',
+                contexts: [
+                    {
+                        name: 'kind-kind',
+                        context: {
+                            namespace: 'kube-system',
+                        },
+                    },
+                ],
+            };
+            mockExeca
+                .mockResolvedValueOnce({ stdout: JSON.stringify(kindConfig) })
+                .mockResolvedValueOnce({ stdout: 'kind-kind' })
+                .mockResolvedValueOnce({ stdout: '172.18.0.2' });
+            const result = await getClusterInfo();
+            expect(result).toEqual({
+                type: 'kind',
+                context: 'kind-kind',
+                namespace: 'kube-system',
+                ip: '172.18.0.2',
+            });
+        });
+        it('gets docker-desktop cluster info', async () => {
+            const dockerConfig = {
+                'current-context': 'docker-desktop',
+                contexts: [
+                    {
+                        name: 'docker-desktop',
+                        context: {},
+                    },
+                ],
+            };
+            mockExeca
+                .mockResolvedValueOnce({ stdout: JSON.stringify(dockerConfig) })
+                .mockResolvedValueOnce({ stdout: 'docker-desktop' });
+            const result = await getClusterInfo();
+            expect(result).toEqual({
+                type: 'docker-desktop',
+                context: 'docker-desktop',
+                namespace: 'default',
+                ip: 'localhost',
+            });
+        });
+        it('gets cloud cluster info with load balancer IP', async () => {
+            const cloudConfig = {
+                'current-context': 'gke_project_zone_cluster',
+                contexts: [
+                    {
+                        name: 'gke_project_zone_cluster',
+                        context: {
+                            namespace: 'production',
+                        },
+                    },
+                ],
+            };
+            mockExeca
+                .mockResolvedValueOnce({ stdout: JSON.stringify(cloudConfig) })
+                .mockResolvedValueOnce({ stdout: 'gke_project_zone_cluster' })
+                .mockResolvedValueOnce({ stdout: '35.201.125.17' });
+            const result = await getClusterInfo();
+            expect(result).toEqual({
+                type: 'cloud',
+                context: 'gke_project_zone_cluster',
+                namespace: 'production',
+                ip: '35.201.125.17',
+            });
+            expect(mockExeca).toHaveBeenCalledWith('kubectl', [
+                'get',
+                'svc',
+                '-n',
+                'istio-system',
+                'istio-ingressgateway',
+                '-o',
+                'jsonpath={.status.loadBalancer.ingress[0].ip}',
+            ]);
+        });
+        it('falls back to hostname for cloud cluster if no IP', async () => {
+            const cloudConfig = {
+                'current-context': 'eks-cluster',
+                contexts: [
+                    {
+                        name: 'eks-cluster',
+                        context: {},
+                    },
+                ],
+            };
+            mockExeca
+                .mockResolvedValueOnce({ stdout: JSON.stringify(cloudConfig) })
+                .mockResolvedValueOnce({ stdout: 'eks-cluster' })
+                .mockResolvedValueOnce({ stdout: '' })
+                .mockResolvedValueOnce({ stdout: 'a1234.elb.amazonaws.com' });
+            const result = await getClusterInfo();
+            expect(result.ip).toBe('a1234.elb.amazonaws.com');
+        });
+        it('falls back to external node IP for cloud cluster', async () => {
+            const cloudConfig = {
+                'current-context': 'gke-cluster',
+                contexts: [
+                    {
+                        name: 'gke-cluster',
+                        context: {},
+                    },
+                ],
+            };
+            mockExeca
+                .mockResolvedValueOnce({ stdout: JSON.stringify(cloudConfig) })
+                .mockResolvedValueOnce({ stdout: 'gke-cluster' })
+                .mockRejectedValueOnce(new Error('service not found'))
+                .mockResolvedValueOnce({ stdout: '35.201.125.18' });
+            const result = await getClusterInfo();
+            expect(result.ip).toBe('35.201.125.18');
+            expect(mockExeca).toHaveBeenCalledWith('kubectl', [
+                'get',
+                'nodes',
+                '-o',
+                'jsonpath={.items[0].status.addresses[?(@.type=="ExternalIP")].address}',
+            ]);
+        });
+        it('gets k3s cluster info', async () => {
+            const k3sConfig = {
+                'current-context': 'k3s-default',
+                contexts: [
+                    {
+                        name: 'k3s-default',
+                        context: {},
+                    },
+                ],
+            };
+            mockExeca
+                .mockResolvedValueOnce({ stdout: JSON.stringify(k3sConfig) })
+                .mockResolvedValueOnce({ stdout: 'k3s-default' })
+                .mockResolvedValueOnce({ stdout: '10.0.0.5' });
+            const result = await getClusterInfo();
+            expect(result).toEqual({
+                type: 'k3s',
+                context: 'k3s-default',
+                namespace: 'default',
+                ip: '10.0.0.5',
+            });
+        });
+        it('uses provided context parameter', async () => {
+            const multiConfig = {
+                'current-context': 'kind-staging',
+                contexts: [
+                    {
+                        name: 'kind-staging',
+                        context: {
+                            namespace: 'staging-ns',
+                        },
+                    },
+                ],
+            };
+            mockExeca
+                .mockResolvedValueOnce({ stdout: JSON.stringify(multiConfig) })
+                .mockResolvedValueOnce({ stdout: 'kind-staging' })
+                .mockResolvedValueOnce({ stdout: '172.18.0.3' });
+            const result = await getClusterInfo('kind-staging');
+            expect(result.context).toBe('kind-staging');
+            expect(mockExeca).toHaveBeenCalledWith('kubectl', [
+                'config',
+                'view',
+                '--minify',
+                '-o',
+                'json',
+                '--context',
+                'kind-staging',
+            ]);
+        });
+        it('handles unknown cluster type', async () => {
+            const unknownConfig = {
+                'current-context': 'custom-cluster',
+                contexts: [
+                    {
+                        name: 'custom-cluster',
+                        context: {},
+                    },
+                ],
+            };
+            mockExeca
+                .mockResolvedValueOnce({ stdout: JSON.stringify(unknownConfig) })
+                .mockResolvedValueOnce({ stdout: 'custom-cluster' })
+                .mockResolvedValueOnce({ stdout: '10.0.0.1' });
+            const result = await getClusterInfo();
+            expect(result).toEqual({
+                type: 'unknown',
+                context: 'custom-cluster',
+                namespace: 'default',
+                ip: '10.0.0.1',
+            });
+        });
+        it('handles kubectl config error', async () => {
+            mockExeca.mockRejectedValue(new Error('kubectl not configured'));
+            const result = await getClusterInfo();
+            expect(result).toEqual({
+                type: 'unknown',
+                error: 'kubectl not configured',
+            });
+        });
+        it('handles missing context in config', async () => {
+            const emptyConfig = {
+                contexts: [],
+            };
+            mockExeca
+                .mockResolvedValueOnce({ stdout: JSON.stringify(emptyConfig) })
+                .mockResolvedValueOnce({ stdout: '' })
+                .mockResolvedValueOnce({ stdout: '10.0.0.1' });
+            const result = await getClusterInfo();
+            expect(result.context).toBe('');
+            expect(result.namespace).toBe('default');
+        });
+    });
+});

package/dist/lib/commandUtils.js

@@ -1,15 +1,15 @@
-import { exec } from 'child_process';
-import { promisify } from 'util';
-const execAsync = promisify(exec);
+import { execa } from 'execa';
 /**
  * Check if a command is available in the system
  */
 export async function isCommandAvailable(command) {
     try {
-        const checkCommand = process.platform === 'win32'
-            ? `where ${command}`
-            : `command -v ${command}`;
-        await execAsync(checkCommand);
+        if (process.platform === 'win32') {
+            await execa('where', [command]);
+        }
+        else {
+            await execa('sh', ['-c', `command -v ${command}`]);
+        }
         return true;
     }
     catch (_error) {

package/dist/lib/commands.d.ts

@@ -0,0 +1,16 @@
+import { type Options } from 'execa';
+/**
+ * Check if a command exists and is executable by running it with specified args
+ */
+export declare function checkCommandExists(command: string, args?: string[]): Promise<boolean>;
+export { checkCommandExists as isCommandAvailable };
+/**
+ * Execute a command with optional verbose output
+ * @param command The command to execute
+ * @param args Array of arguments
+ * @param execaOptions Standard execa options
+ * @param additionalOptions Additional options for execute (e.g., verbose)
+ */
+export declare function execute(command: string, args?: string[], execaOptions?: Options, additionalOptions?: {
+    verbose?: boolean;
+}): Promise<import("execa").Result<Options>>;

package/dist/lib/commands.js

@@ -0,0 +1,29 @@
+import { execa } from 'execa';
+import chalk from 'chalk';
+/**
+ * Check if a command exists and is executable by running it with specified args
+ */
+export async function checkCommandExists(command, args = ['--version']) {
+    try {
+        await execa(command, args);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export { checkCommandExists as isCommandAvailable };
+/**
+ * Execute a command with optional verbose output
+ * @param command The command to execute
+ * @param args Array of arguments
+ * @param execaOptions Standard execa options
+ * @param additionalOptions Additional options for execute (e.g., verbose)
+ */
+export async function execute(command, args = [], execaOptions = {}, additionalOptions = {}) {
+    const { verbose = false } = additionalOptions;
+    if (verbose) {
+        console.log(chalk.gray(`$ ${command} ${args.join(' ')}`));
+    }
+    return await execa(command, args, execaOptions);
+}

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

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