@agents-at-scale/ark 0.1.35 → 0.1.36-rc1

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.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Check if a command is available in the system
+ */
+export declare function isCommandAvailable(command: string): Promise<boolean>;

package/dist/lib/commandUtils.js

@@ -0,0 +1,18 @@
+import { execa } from 'execa';
+/**
+ * Check if a command is available in the system
+ */
+export async function isCommandAvailable(command) {
+    try {
+        if (process.platform === 'win32') {
+            await execa('where', [command]);
+        }
+        else {
+            await execa('sh', ['-c', `command -v ${command}`]);
+        }
+        return true;
+    }
+    catch (_error) {
+        return false;
+    }
+}

package/dist/lib/commandUtils.test.d.ts

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

package/dist/lib/commandUtils.test.js

@@ -0,0 +1,44 @@
+import { exec } from 'child_process';
+import { isCommandAvailable } from './commandUtils';
+jest.mock('child_process');
+describe('commandUtils', () => {
+    describe('isCommandAvailable', () => {
+        const mockedExec = exec;
+        beforeEach(() => {
+            jest.clearAllMocks();
+        });
+        it('should return true when command exists on unix', async () => {
+            const originalPlatform = Object.getOwnPropertyDescriptor(process, 'platform');
+            Object.defineProperty(process, 'platform', { value: 'darwin' });
+            mockedExec.mockImplementation((cmd, callback) => {
+                callback(null, '/usr/local/bin/helm', '');
+            });
+            const result = await isCommandAvailable('helm');
+            expect(result).toBe(true);
+            expect(mockedExec).toHaveBeenCalledWith('command -v helm', expect.any(Function));
+            if (originalPlatform) {
+                Object.defineProperty(process, 'platform', originalPlatform);
+            }
+        });
+        it('should return true when command exists on windows', async () => {
+            const originalPlatform = Object.getOwnPropertyDescriptor(process, 'platform');
+            Object.defineProperty(process, 'platform', { value: 'win32' });
+            mockedExec.mockImplementation((cmd, callback) => {
+                callback(null, 'C:\\Program Files\\helm\\helm.exe', '');
+            });
+            const result = await isCommandAvailable('helm');
+            expect(result).toBe(true);
+            expect(mockedExec).toHaveBeenCalledWith('where helm', expect.any(Function));
+            if (originalPlatform) {
+                Object.defineProperty(process, 'platform', originalPlatform);
+            }
+        });
+        it('should return false when command does not exist', async () => {
+            mockedExec.mockImplementation((cmd, callback) => {
+                callback(new Error('command not found'), null, 'command not found');
+            });
+            const result = await isCommandAvailable('nonexistent');
+            expect(result).toBe(false);
+        });
+    });
+});

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 {};

package/dist/lib/commands.spec.js

@@ -0,0 +1,146 @@
+import { describe, it, expect, jest, beforeEach } from '@jest/globals';
+// Mock chalk to avoid ANSI codes in tests
+jest.unstable_mockModule('chalk', () => ({
+    default: {
+        gray: (str) => str,
+    },
+}));
+// Mock execa using unstable_mockModule
+jest.unstable_mockModule('execa', () => ({
+    execa: jest.fn(),
+}));
+// Dynamic imports after mock
+const { execa } = await import('execa');
+const { checkCommandExists, execute } = await import('./commands.js');
+// Type the mock properly
+const mockExeca = execa;
+describe('commands', () => {
+    describe('checkCommandExists', () => {
+        beforeEach(() => {
+            jest.clearAllMocks();
+        });
+        it('returns true when command executes successfully', async () => {
+            mockExeca.mockResolvedValue({
+                stdout: 'v1.0.0',
+                stderr: '',
+                exitCode: 0,
+            });
+            const result = await checkCommandExists('helm', ['version']);
+            expect(result).toBe(true);
+            expect(mockExeca).toHaveBeenCalledWith('helm', ['version']);
+        });
+        it('returns false when command fails', async () => {
+            mockExeca.mockRejectedValue(new Error('Command not found'));
+            const result = await checkCommandExists('nonexistent', ['--version']);
+            expect(result).toBe(false);
+            expect(mockExeca).toHaveBeenCalledWith('nonexistent', ['--version']);
+        });
+        it('uses default --version arg when no args provided', async () => {
+            mockExeca.mockResolvedValue({
+                stdout: '1.0.0',
+                stderr: '',
+                exitCode: 0,
+            });
+            const result = await checkCommandExists('node');
+            expect(result).toBe(true);
+            expect(mockExeca).toHaveBeenCalledWith('node', ['--version']);
+        });
+        it('uses custom args when provided', async () => {
+            mockExeca.mockResolvedValue({
+                stdout: 'Client Version: v1.28.0',
+                stderr: '',
+                exitCode: 0,
+            });
+            const result = await checkCommandExists('kubectl', [
+                'version',
+                '--client',
+            ]);
+            expect(result).toBe(true);
+            expect(mockExeca).toHaveBeenCalledWith('kubectl', [
+                'version',
+                '--client',
+            ]);
+        });
+        it('handles empty args array', async () => {
+            mockExeca.mockResolvedValue({
+                stdout: '',
+                stderr: '',
+                exitCode: 0,
+            });
+            const result = await checkCommandExists('echo', []);
+            expect(result).toBe(true);
+            expect(mockExeca).toHaveBeenCalledWith('echo', []);
+        });
+    });
+    describe('execute', () => {
+        let mockConsoleLog;
+        beforeEach(() => {
+            jest.clearAllMocks();
+            mockConsoleLog = jest.spyOn(console, 'log').mockImplementation(() => { });
+        });
+        afterEach(() => {
+            mockConsoleLog.mockRestore();
+        });
+        it('executes command without verbose output by default', async () => {
+            mockExeca.mockResolvedValue({
+                stdout: 'success',
+                stderr: '',
+                exitCode: 0,
+            });
+            await execute('helm', ['install', 'test'], { stdio: 'inherit' });
+            expect(mockConsoleLog).not.toHaveBeenCalled();
+            expect(mockExeca).toHaveBeenCalledWith('helm', ['install', 'test'], {
+                stdio: 'inherit',
+            });
+        });
+        it('prints command when verbose is true', async () => {
+            mockExeca.mockResolvedValue({
+                stdout: 'success',
+                stderr: '',
+                exitCode: 0,
+            });
+            await execute('helm', ['install', 'test'], { stdio: 'inherit' }, { verbose: true });
+            expect(mockConsoleLog).toHaveBeenCalledWith('$ helm install test');
+            expect(mockExeca).toHaveBeenCalledWith('helm', ['install', 'test'], {
+                stdio: 'inherit',
+            });
+        });
+        it('works with empty args array', async () => {
+            mockExeca.mockResolvedValue({
+                stdout: '',
+                stderr: '',
+                exitCode: 0,
+            });
+            await execute('ls', [], {}, { verbose: true });
+            expect(mockConsoleLog).toHaveBeenCalledWith('$ ls ');
+            expect(mockExeca).toHaveBeenCalledWith('ls', [], {});
+        });
+        it('passes through execa options correctly', async () => {
+            mockExeca.mockResolvedValue({
+                stdout: '',
+                stderr: '',
+                exitCode: 0,
+            });
+            const execaOpts = { stdio: 'pipe', timeout: 5000, cwd: '/tmp' };
+            await execute('kubectl', ['get', 'pods'], execaOpts);
+            expect(mockConsoleLog).not.toHaveBeenCalled();
+            expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'pods'], execaOpts);
+        });
+        it('handles command failure', async () => {
+            const error = new Error('Command failed');
+            mockExeca.mockRejectedValue(error);
+            await expect(execute('fail', ['now'])).rejects.toThrow('Command failed');
+            expect(mockExeca).toHaveBeenCalledWith('fail', ['now'], {});
+        });
+        it('defaults to no verbose when additionalOptions not provided', async () => {
+            mockExeca.mockResolvedValue({
+                stdout: 'ok',
+                stderr: '',
+                exitCode: 0,
+            });
+            await execute('echo', ['test']);
+            expect(mockConsoleLog).not.toHaveBeenCalled();
+            expect(mockExeca).toHaveBeenCalledWith('echo', ['test'], {});
+        });
+    });
+});