@agents-at-scale/ark 0.1.53 → 0.1.55

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

@@ -1,161 +0,0 @@
-import { jest } from '@jest/globals';
-import { Command } from 'commander';
-const mockExecuteDirectEvaluation = jest.fn();
-const mockExecuteQueryEvaluation = jest.fn();
-jest.unstable_mockModule('../../lib/executeEvaluation.js', () => ({
-    executeDirectEvaluation: mockExecuteDirectEvaluation,
-    executeQueryEvaluation: mockExecuteQueryEvaluation,
-}));
-const { createEvaluationCommand } = await import('./index.js');
-describe('createEvaluationCommand', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    it('should create an evaluation command', () => {
-        const command = createEvaluationCommand({});
-        expect(command).toBeInstanceOf(Command);
-        expect(command.name()).toBe('evaluation');
-        expect(command.description()).toBe('Execute evaluations against evaluators');
-    });
-    describe('direct evaluation', () => {
-        it('should execute direct evaluation with required options', async () => {
-            mockExecuteDirectEvaluation.mockResolvedValue(undefined);
-            const command = createEvaluationCommand({});
-            await command.parseAsync([
-                'node',
-                'test',
-                'my-evaluator',
-                '--input',
-                'test-input',
-                '--output',
-                'test-output',
-            ]);
-            expect(mockExecuteDirectEvaluation).toHaveBeenCalledWith({
-                evaluatorName: 'my-evaluator',
-                input: 'test-input',
-                output: 'test-output',
-                timeout: undefined,
-                watchTimeout: undefined,
-            });
-        });
-        it('should execute direct evaluation with timeout options', async () => {
-            mockExecuteDirectEvaluation.mockResolvedValue(undefined);
-            const command = createEvaluationCommand({});
-            await command.parseAsync([
-                'node',
-                'test',
-                'my-evaluator',
-                '--input',
-                'test-input',
-                '--output',
-                'test-output',
-                '--timeout',
-                '10m',
-                '--watch-timeout',
-                '11m',
-            ]);
-            expect(mockExecuteDirectEvaluation).toHaveBeenCalledWith({
-                evaluatorName: 'my-evaluator',
-                input: 'test-input',
-                output: 'test-output',
-                timeout: '10m',
-                watchTimeout: '11m',
-            });
-        });
-    });
-    describe('query evaluation', () => {
-        it('should execute query evaluation with required arguments', async () => {
-            mockExecuteQueryEvaluation.mockResolvedValue(undefined);
-            const command = createEvaluationCommand({});
-            await command.parseAsync(['node', 'test', 'my-evaluator', 'test-query']);
-            expect(mockExecuteQueryEvaluation).toHaveBeenCalledWith({
-                evaluatorName: 'my-evaluator',
-                queryName: 'test-query',
-                responseTarget: undefined,
-                timeout: undefined,
-                watchTimeout: undefined,
-            });
-        });
-        it('should execute query evaluation from stdin', async () => {
-            mockExecuteQueryEvaluation.mockResolvedValue(undefined);
-            const command = createEvaluationCommand({});
-            const mockStdin = {
-                isTTY: false,
-                setEncoding: jest.fn(),
-                on: jest.fn((event, callback) => {
-                    if (event === 'data') {
-                        callback('piped-query-name');
-                    }
-                    else if (event === 'end') {
-                        callback();
-                    }
-                }),
-            };
-            const originalStdin = process.stdin;
-            Object.defineProperty(process, 'stdin', {
-                value: mockStdin,
-                writable: true,
-                configurable: true,
-            });
-            try {
-                await command.parseAsync(['node', 'test', 'my-evaluator']);
-                expect(mockExecuteQueryEvaluation).toHaveBeenCalledWith({
-                    evaluatorName: 'my-evaluator',
-                    queryName: 'piped-query-name',
-                    responseTarget: undefined,
-                    timeout: undefined,
-                    watchTimeout: undefined,
-                });
-            }
-            finally {
-                Object.defineProperty(process, 'stdin', {
-                    value: originalStdin,
-                    writable: true,
-                    configurable: true,
-                });
-            }
-        });
-        it('should execute query evaluation with response-target option', async () => {
-            mockExecuteQueryEvaluation.mockResolvedValue(undefined);
-            const command = createEvaluationCommand({});
-            await command.parseAsync([
-                'node',
-                'test',
-                'my-evaluator',
-                'test-query',
-                '--response-target',
-                'agent:my-agent',
-            ]);
-            expect(mockExecuteQueryEvaluation).toHaveBeenCalledWith({
-                evaluatorName: 'my-evaluator',
-                queryName: 'test-query',
-                responseTarget: 'agent:my-agent',
-                timeout: undefined,
-                watchTimeout: undefined,
-            });
-        });
-        it('should execute query evaluation with all options', async () => {
-            mockExecuteQueryEvaluation.mockResolvedValue(undefined);
-            const command = createEvaluationCommand({});
-            await command.parseAsync([
-                'node',
-                'test',
-                'my-evaluator',
-                'test-query',
-                '--response-target',
-                'agent:my-agent',
-                '--timeout',
-                '10m',
-                '--watch-timeout',
-                '11m',
-            ]);
-            expect(mockExecuteQueryEvaluation).toHaveBeenCalledWith({
-                evaluatorName: 'my-evaluator',
-                queryName: 'test-query',
-                responseTarget: 'agent:my-agent',
-                timeout: '10m',
-                watchTimeout: '11m',
-            });
-        });
-    });
-});

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

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

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

@@ -1,145 +0,0 @@
-import { jest } from '@jest/globals';
-import { Command } from 'commander';
-const mockExeca = jest.fn();
-jest.unstable_mockModule('execa', () => ({
-    execa: mockExeca,
-}));
-const mockWriteFile = jest.fn();
-jest.unstable_mockModule('fs/promises', () => ({
-    writeFile: mockWriteFile,
-}));
-const mockOutput = {
-    info: jest.fn(),
-    success: jest.fn(),
-    warning: jest.fn(),
-    error: jest.fn(),
-};
-jest.unstable_mockModule('../../lib/output.js', () => ({
-    default: mockOutput,
-}));
-const mockExit = jest.spyOn(process, 'exit').mockImplementation((() => {
-    throw new Error('process.exit called');
-}));
-const mockKubectlGetResponse = {
-    "apiVersion": "v1",
-    "items": [{ "spec": "foo" }],
-    "kind": "List",
-    "metadata": {
-        "resourceVersion": ""
-    }
-};
-const { createExportCommand } = await import('./index.js');
-describe('export command', () => {
-    const mockConfig = {};
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    it('should create export command with correct description', () => {
-        const command = createExportCommand(mockConfig);
-        expect(command).toBeInstanceOf(Command);
-        expect(command.name()).toBe('export');
-        expect(command.description()).toBe('export ARK resources to a file');
-    });
-    it('should export all resource types by default', async () => {
-        mockExeca.mockResolvedValue({
-            stdout: JSON.stringify(mockKubectlGetResponse),
-        });
-        mockWriteFile.mockResolvedValue(undefined);
-        const command = createExportCommand(mockConfig);
-        await command.parseAsync(['node', 'test', '-o', 'test.yaml']);
-        const expectedResourceTypes = [
-            'secrets',
-            'tools',
-            'models',
-            'agents',
-            'teams',
-            'evaluators',
-            'mcpservers',
-            'a2aservers',
-        ];
-        expect(mockExeca).toHaveBeenCalledTimes(expectedResourceTypes.length);
-        for (const resourceType of expectedResourceTypes) {
-            expect(mockExeca).toHaveBeenCalledWith('kubectl', expect.arrayContaining(['get', resourceType, '-o', 'json']), expect.any(Object));
-            expect(mockOutput.success).toHaveBeenCalledWith(`found 1 ${resourceType}`);
-        }
-        expect(mockWriteFile).toHaveBeenCalledTimes(1);
-    });
-    it('should export types specified in config in dependency order', async () => {
-        mockExeca.mockResolvedValue({
-            stdout: JSON.stringify(mockKubectlGetResponse),
-        });
-        mockWriteFile.mockResolvedValue(undefined);
-        const newDefaultTypes = ['teams', 'agents'];
-        const modifiedConfig = { defaultExportTypes: newDefaultTypes };
-        const command = createExportCommand(modifiedConfig);
-        await command.parseAsync(['node', 'test', '-o', 'test.yaml']);
-        expect(mockExeca.mock.calls).toEqual([
-            ['kubectl', expect.arrayContaining(['get', 'agents']), expect.any(Object)],
-            ['kubectl', expect.arrayContaining(['get', 'teams']), expect.any(Object)],
-        ]);
-        expect(mockWriteFile).toHaveBeenCalledTimes(1);
-    });
-    it('should filter by resource types when specified and export in order', async () => {
-        mockExeca.mockResolvedValue({
-            stdout: JSON.stringify(mockKubectlGetResponse),
-        });
-        mockWriteFile.mockResolvedValue(undefined);
-        const command = createExportCommand(mockConfig);
-        await command.parseAsync([
-            'node',
-            'test',
-            '-t',
-            'agents,models',
-            '-o',
-            'test.yaml',
-        ]);
-        expect(mockExeca.mock.calls).toEqual([
-            ['kubectl', expect.arrayContaining(['get', 'models']), expect.any(Object)],
-            ['kubectl', expect.arrayContaining(['get', 'agents']), expect.any(Object)],
-        ]);
-    });
-    it('should use namespace filter when specified', async () => {
-        mockExeca.mockResolvedValue({
-            stdout: JSON.stringify(mockKubectlGetResponse),
-        });
-        mockWriteFile.mockResolvedValue(undefined);
-        const command = createExportCommand(mockConfig);
-        await command.parseAsync([
-            'node',
-            'test',
-            '-n',
-            'custom-namespace',
-            '-t',
-            'agents',
-            '-o',
-            'test.yaml',
-        ]);
-        expect(mockExeca).toHaveBeenCalledWith('kubectl', expect.arrayContaining(['-n', 'custom-namespace']), expect.any(Object));
-        expect(mockWriteFile).toHaveBeenCalledTimes(1);
-    });
-    it('should use label selector when specified', async () => {
-        mockExeca.mockResolvedValue({
-            stdout: JSON.stringify(mockKubectlGetResponse),
-        });
-        mockWriteFile.mockResolvedValue(undefined);
-        const command = createExportCommand(mockConfig);
-        await command.parseAsync([
-            'node',
-            'test',
-            '-l',
-            'app=test',
-            '-t',
-            'agents',
-            '-o',
-            'test.yaml',
-        ]);
-        expect(mockExeca).toHaveBeenCalledWith('kubectl', expect.arrayContaining(['-l', 'app=test']), expect.any(Object));
-        expect(mockWriteFile).toHaveBeenCalledTimes(1);
-    });
-    it('fails if kubectl get fails for a resource type', async () => {
-        mockExeca.mockRejectedValue('Export broke');
-        const command = createExportCommand(mockConfig);
-        await command.parseAsync(['node', 'test']);
-        expect(mockOutput.error).toHaveBeenCalledWith('export failed:', 'Export broke');
-    });
-});

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

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

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

@@ -1,46 +0,0 @@
-import { jest } from '@jest/globals';
-import { Command } from 'commander';
-const mockExeca = jest.fn();
-jest.unstable_mockModule('execa', () => ({
-    execa: mockExeca,
-}));
-const mockOutput = {
-    info: jest.fn(),
-    success: jest.fn(),
-    warning: jest.fn(),
-    error: jest.fn(),
-};
-jest.unstable_mockModule('../../lib/output.js', () => ({
-    default: mockOutput,
-}));
-const mockExit = jest.spyOn(process, 'exit').mockImplementation((() => {
-    throw new Error('process.exit called');
-}));
-const { createImportCommand } = await import('./index.js');
-describe('import command', () => {
-    const mockConfig = {};
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    it('should create import command with correct description', () => {
-        const command = createImportCommand(mockConfig);
-        expect(command).toBeInstanceOf(Command);
-        expect(command.name()).toBe('import');
-        expect(command.description()).toBe('import ARK resources from a file');
-    });
-    it('should use kubectl to import', async () => {
-        mockExeca.mockResolvedValue({
-            stdout: JSON.stringify({ items: [] }),
-        });
-        const command = createImportCommand(mockConfig);
-        await command.parseAsync(['node', 'test', 'test.yaml']);
-        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['create', '-f', 'test.yaml'], expect.any(Object));
-    });
-    it('exits with error when kubectl create has error', async () => {
-        mockExeca.mockRejectedValue('Import broke');
-        const command = createImportCommand(mockConfig);
-        await expect(command.parseAsync(['node', 'test', 'test.yaml'])).rejects.toThrow('process.exit called');
-        expect(mockOutput.error).toHaveBeenCalledWith('import failed:', 'Import broke');
-        expect(mockExit).toHaveBeenCalledWith(1);
-    });
-});

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

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

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

@@ -1,286 +0,0 @@
-import { jest } from '@jest/globals';
-import { Command } from 'commander';
-const mockExeca = jest.fn(() => Promise.resolve());
-jest.unstable_mockModule('execa', () => ({
-    execa: mockExeca,
-}));
-const mockGetClusterInfo = jest.fn();
-jest.unstable_mockModule('../../lib/cluster.js', () => ({
-    getClusterInfo: mockGetClusterInfo,
-}));
-const mockGetInstallableServices = jest.fn();
-const mockArkServices = {};
-const mockArkDependencies = {};
-jest.unstable_mockModule('../../arkServices.js', () => ({
-    getInstallableServices: mockGetInstallableServices,
-    arkServices: mockArkServices,
-    arkDependencies: mockArkDependencies,
-}));
-const mockOutput = {
-    error: jest.fn(),
-    info: jest.fn(),
-    success: jest.fn(),
-    warning: jest.fn(),
-};
-jest.unstable_mockModule('../../lib/output.js', () => ({
-    default: mockOutput,
-}));
-const mockExit = jest.spyOn(process, 'exit').mockImplementation((() => {
-    throw new Error('process.exit called');
-}));
-jest.spyOn(console, 'log').mockImplementation(() => { });
-jest.spyOn(console, 'error').mockImplementation(() => { });
-const { createInstallCommand } = await import('./index.js');
-describe('install command', () => {
-    const mockConfig = {
-        clusterInfo: {
-            context: 'test-cluster',
-            type: 'minikube',
-            namespace: 'default',
-        },
-    };
-    beforeEach(() => {
-        jest.clearAllMocks();
-        mockGetClusterInfo.mockResolvedValue({
-            context: 'test-cluster',
-            type: 'minikube',
-            namespace: 'default',
-        });
-    });
-    it('creates command with correct structure', () => {
-        const command = createInstallCommand(mockConfig);
-        expect(command).toBeInstanceOf(Command);
-        expect(command.name()).toBe('install');
-    });
-    it('installs single service with correct helm parameters', async () => {
-        const mockService = {
-            name: 'ark-api',
-            helmReleaseName: 'ark-api',
-            chartPath: './charts/ark-api',
-            namespace: 'ark-system',
-            installArgs: ['--set', 'image.tag=latest'],
-        };
-        mockGetInstallableServices.mockReturnValue({
-            'ark-api': mockService,
-        });
-        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',
-            '--set',
-            'image.tag=latest',
-        ], { stdio: 'inherit' });
-        expect(mockOutput.success).toHaveBeenCalledWith('ark-api installed successfully');
-    });
-    it('shows error when service not found', async () => {
-        mockGetInstallableServices.mockReturnValue({
-            'ark-api': { name: 'ark-api' },
-            'ark-controller': { name: 'ark-controller' },
-        });
-        const command = createInstallCommand(mockConfig);
-        await expect(command.parseAsync(['node', 'test', 'invalid-service'])).rejects.toThrow('process.exit called');
-        expect(mockOutput.error).toHaveBeenCalledWith("service 'invalid-service' not found");
-        expect(mockOutput.info).toHaveBeenCalledWith('available services:');
-        expect(mockOutput.info).toHaveBeenCalledWith('  ark-api');
-        expect(mockOutput.info).toHaveBeenCalledWith('  ark-controller');
-        expect(mockExit).toHaveBeenCalledWith(1);
-    });
-    it('handles service without namespace (uses current context)', async () => {
-        const mockService = {
-            name: 'ark-dashboard',
-            helmReleaseName: 'ark-dashboard',
-            chartPath: './charts/ark-dashboard',
-            // namespace is undefined - should use current context
-            installArgs: ['--set', 'replicas=2'],
-        };
-        mockGetInstallableServices.mockReturnValue({
-            'ark-dashboard': mockService,
-        });
-        const command = createInstallCommand(mockConfig);
-        await command.parseAsync(['node', 'test', 'ark-dashboard']);
-        // Should NOT include --namespace flag
-        expect(mockExeca).toHaveBeenCalledWith('helm', [
-            'upgrade',
-            '--install',
-            'ark-dashboard',
-            './charts/ark-dashboard',
-            '--set',
-            'replicas=2',
-        ], { stdio: 'inherit' });
-    });
-    it('handles service without installArgs', async () => {
-        const mockService = {
-            name: 'simple-service',
-            helmReleaseName: 'simple-service',
-            chartPath: './charts/simple',
-            namespace: 'default',
-        };
-        mockGetInstallableServices.mockReturnValue({
-            'simple-service': mockService,
-        });
-        const command = createInstallCommand(mockConfig);
-        await command.parseAsync(['node', 'test', 'simple-service']);
-        expect(mockExeca).toHaveBeenCalledWith('helm', [
-            'upgrade',
-            '--install',
-            'simple-service',
-            './charts/simple',
-            '--namespace',
-            'default',
-        ], { stdio: 'inherit' });
-    });
-    it('exits when cluster not connected', async () => {
-        mockGetClusterInfo.mockResolvedValue({ error: true });
-        const command = createInstallCommand({});
-        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/marketplace/index.spec.d.ts

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