@agents-at-scale/ark 0.1.53 → 0.1.55

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

@@ -1,154 +0,0 @@
-import { jest } from '@jest/globals';
-import { Command } from 'commander';
-// Mock execa to avoid real kubectl calls
-jest.unstable_mockModule('execa', () => ({
-    execa: jest.fn(),
-}));
-const mockOutput = {
-    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 mockConsoleLog = jest.spyOn(console, 'log').mockImplementation(() => { });
-const { execa } = await import('execa');
-const mockExeca = execa;
-const { createTargetsCommand } = await import('./index.js');
-describe('targets command', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    it('creates command with correct structure', () => {
-        const command = createTargetsCommand({});
-        expect(command).toBeInstanceOf(Command);
-        expect(command.name()).toBe('targets');
-    });
-    it('lists targets in text format', async () => {
-        // Mock kubectl responses for each resource type (order: model, agent, team, tool)
-        mockExeca
-            .mockResolvedValueOnce({
-            stdout: JSON.stringify({
-                items: [{ metadata: { name: 'gpt-4' }, status: { available: true } }],
-            }),
-        })
-            .mockResolvedValueOnce({
-            stdout: JSON.stringify({
-                items: [
-                    { metadata: { name: 'gpt-assistant' }, status: { phase: 'ready' } },
-                ],
-            }),
-        })
-            .mockResolvedValueOnce({ stdout: JSON.stringify({ items: [] }) })
-            .mockResolvedValueOnce({ stdout: JSON.stringify({ items: [] }) });
-        const command = createTargetsCommand({});
-        await command.parseAsync(['node', 'test']);
-        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'models', '-o', 'json'], {
-            stdio: 'pipe',
-        });
-        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'agents', '-o', 'json'], {
-            stdio: 'pipe',
-        });
-        expect(mockConsoleLog).toHaveBeenCalledWith('agent/gpt-assistant');
-        expect(mockConsoleLog).toHaveBeenCalledWith('model/gpt-4');
-    });
-    it('lists targets in json format', async () => {
-        // Order: model, agent, team, tool
-        mockExeca
-            .mockResolvedValueOnce({ stdout: JSON.stringify({ items: [] }) })
-            .mockResolvedValueOnce({
-            stdout: JSON.stringify({
-                items: [{ metadata: { name: 'gpt' }, status: { phase: 'ready' } }],
-            }),
-        })
-            .mockResolvedValueOnce({ stdout: JSON.stringify({ items: [] }) })
-            .mockResolvedValueOnce({ stdout: JSON.stringify({ items: [] }) });
-        const command = createTargetsCommand({});
-        await command.parseAsync(['node', 'test', '-o', 'json']);
-        const expectedTargets = [
-            { type: 'agent', name: 'gpt', id: 'agent/gpt', available: true },
-        ];
-        expect(mockConsoleLog).toHaveBeenCalledWith(JSON.stringify(expectedTargets, null, 2));
-    });
-    it('filters targets by type', async () => {
-        mockExeca.mockResolvedValueOnce({
-            stdout: JSON.stringify({
-                items: [
-                    { metadata: { name: 'gpt' }, status: { phase: 'ready' } },
-                    { metadata: { name: 'helper' }, status: { phase: 'ready' } },
-                ],
-            }),
-        });
-        const command = createTargetsCommand({});
-        await command.parseAsync(['node', 'test', '-t', 'agent']);
-        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'agents', '-o', 'json'], {
-            stdio: 'pipe',
-        });
-        expect(mockExeca).toHaveBeenCalledTimes(1); // Only agents, not other types
-        expect(mockConsoleLog).toHaveBeenCalledWith('agent/gpt');
-        expect(mockConsoleLog).toHaveBeenCalledWith('agent/helper');
-    });
-    it('sorts targets by type then name', async () => {
-        // Order: model, agent, team, tool
-        mockExeca
-            .mockResolvedValueOnce({
-            stdout: JSON.stringify({
-                items: [
-                    { metadata: { name: 'b' }, status: { available: true } },
-                    { metadata: { name: 'a' }, status: { available: true } },
-                ],
-            }),
-        })
-            .mockResolvedValueOnce({
-            stdout: JSON.stringify({
-                items: [
-                    { metadata: { name: 'z' }, status: { phase: 'ready' } },
-                    { metadata: { name: 'a' }, status: { phase: 'ready' } },
-                ],
-            }),
-        })
-            .mockResolvedValueOnce({ stdout: JSON.stringify({ items: [] }) })
-            .mockResolvedValueOnce({ stdout: JSON.stringify({ items: [] }) });
-        const command = createTargetsCommand({});
-        await command.parseAsync(['node', 'test']);
-        // Check order of calls - sorted by type then name
-        const calls = mockConsoleLog.mock.calls
-            .filter((call) => call[0] && call[0].includes('/'))
-            .map((call) => call[0]);
-        expect(calls).toEqual(['agent/a', 'agent/z', 'model/a', 'model/b']);
-    });
-    it('shows warning when no targets', async () => {
-        // All resource types return empty (order: model, agent, team, tool)
-        mockExeca
-            .mockResolvedValueOnce({ stdout: JSON.stringify({ items: [] }) })
-            .mockResolvedValueOnce({ stdout: JSON.stringify({ items: [] }) })
-            .mockResolvedValueOnce({ stdout: JSON.stringify({ items: [] }) })
-            .mockResolvedValueOnce({ stdout: JSON.stringify({ items: [] }) });
-        const command = createTargetsCommand({});
-        await command.parseAsync(['node', 'test']);
-        expect(mockOutput.warning).toHaveBeenCalledWith('no targets available');
-    });
-    it('handles errors', async () => {
-        mockExeca.mockRejectedValue(new Error('kubectl not found'));
-        const command = createTargetsCommand({});
-        await expect(command.parseAsync(['node', 'test'])).rejects.toThrow('process.exit called');
-        expect(mockOutput.error).toHaveBeenCalledWith('fetching targets:', 'kubectl not found');
-        expect(mockExit).toHaveBeenCalledWith(1);
-    });
-    it('list subcommand works', async () => {
-        // Order: model, agent, team, tool
-        mockExeca
-            .mockResolvedValueOnce({ stdout: JSON.stringify({ items: [] }) })
-            .mockResolvedValueOnce({ stdout: JSON.stringify({ items: [] }) })
-            .mockResolvedValueOnce({ stdout: JSON.stringify({ items: [] }) })
-            .mockResolvedValueOnce({ stdout: JSON.stringify({ items: [] }) });
-        const command = createTargetsCommand({});
-        await command.parseAsync(['node', 'test', 'list']);
-        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'models', '-o', 'json'], {
-            stdio: 'pipe',
-        });
-    });
-});

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

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

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

@@ -1,70 +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(),
-    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 mockConsoleLog = jest.spyOn(console, 'log').mockImplementation(() => { });
-const { createTeamsCommand } = await import('./index.js');
-describe('teams command', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    it('creates command with correct structure', () => {
-        const command = createTeamsCommand({});
-        expect(command).toBeInstanceOf(Command);
-        expect(command.name()).toBe('teams');
-    });
-    it('lists teams in text format', async () => {
-        const mockTeams = {
-            items: [
-                { metadata: { name: 'engineering' } },
-                { metadata: { name: 'data-science' } },
-            ],
-        };
-        mockExeca.mockResolvedValue({ stdout: JSON.stringify(mockTeams) });
-        const command = createTeamsCommand({});
-        await command.parseAsync(['node', 'test']);
-        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'teams', '-o', 'json'], { stdio: 'pipe' });
-        expect(mockConsoleLog).toHaveBeenCalledWith('engineering');
-        expect(mockConsoleLog).toHaveBeenCalledWith('data-science');
-    });
-    it('lists teams in json format', async () => {
-        const mockTeams = {
-            items: [{ metadata: { name: 'engineering' } }],
-        };
-        mockExeca.mockResolvedValue({ stdout: JSON.stringify(mockTeams) });
-        const command = createTeamsCommand({});
-        await command.parseAsync(['node', 'test', '-o', 'json']);
-        expect(mockConsoleLog).toHaveBeenCalledWith(JSON.stringify(mockTeams.items, null, 2));
-    });
-    it('shows info when no teams', async () => {
-        mockExeca.mockResolvedValue({ stdout: JSON.stringify({ items: [] }) });
-        const command = createTeamsCommand({});
-        await command.parseAsync(['node', 'test']);
-        expect(mockOutput.info).toHaveBeenCalledWith('No teams found');
-    });
-    it('handles errors', async () => {
-        mockExeca.mockRejectedValue(new Error('kubectl failed'));
-        const command = createTeamsCommand({});
-        await expect(command.parseAsync(['node', 'test'])).rejects.toThrow('process.exit called');
-        expect(mockOutput.error).toHaveBeenCalledWith('fetching teams:', 'kubectl failed');
-        expect(mockExit).toHaveBeenCalledWith(1);
-    });
-    it('list subcommand works', async () => {
-        mockExeca.mockResolvedValue({ stdout: JSON.stringify({ items: [] }) });
-        const command = createTeamsCommand({});
-        await command.parseAsync(['node', 'test', 'list']);
-        expect(mockExeca).toHaveBeenCalled();
-    });
-});

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

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

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

@@ -1,70 +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(),
-    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 mockConsoleLog = jest.spyOn(console, 'log').mockImplementation(() => { });
-const { createToolsCommand } = await import('./index.js');
-describe('tools command', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    it('creates command with correct structure', () => {
-        const command = createToolsCommand({});
-        expect(command).toBeInstanceOf(Command);
-        expect(command.name()).toBe('tools');
-    });
-    it('lists tools in text format', async () => {
-        const mockTools = {
-            items: [
-                { metadata: { name: 'github-mcp' } },
-                { metadata: { name: 'slack-mcp' } },
-            ],
-        };
-        mockExeca.mockResolvedValue({ stdout: JSON.stringify(mockTools) });
-        const command = createToolsCommand({});
-        await command.parseAsync(['node', 'test']);
-        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'mcpservers', '-o', 'json'], { stdio: 'pipe' });
-        expect(mockConsoleLog).toHaveBeenCalledWith('github-mcp');
-        expect(mockConsoleLog).toHaveBeenCalledWith('slack-mcp');
-    });
-    it('lists tools in json format', async () => {
-        const mockTools = {
-            items: [{ metadata: { name: 'github-mcp' } }],
-        };
-        mockExeca.mockResolvedValue({ stdout: JSON.stringify(mockTools) });
-        const command = createToolsCommand({});
-        await command.parseAsync(['node', 'test', '-o', 'json']);
-        expect(mockConsoleLog).toHaveBeenCalledWith(JSON.stringify(mockTools.items, null, 2));
-    });
-    it('shows info when no tools', async () => {
-        mockExeca.mockResolvedValue({ stdout: JSON.stringify({ items: [] }) });
-        const command = createToolsCommand({});
-        await command.parseAsync(['node', 'test']);
-        expect(mockOutput.info).toHaveBeenCalledWith('No tools found');
-    });
-    it('handles errors', async () => {
-        mockExeca.mockRejectedValue(new Error('kubectl failed'));
-        const command = createToolsCommand({});
-        await expect(command.parseAsync(['node', 'test'])).rejects.toThrow('process.exit called');
-        expect(mockOutput.error).toHaveBeenCalledWith('fetching tools:', 'kubectl failed');
-        expect(mockExit).toHaveBeenCalledWith(1);
-    });
-    it('list subcommand works', async () => {
-        mockExeca.mockResolvedValue({ stdout: JSON.stringify({ items: [] }) });
-        const command = createToolsCommand({});
-        await command.parseAsync(['node', 'test', 'list']);
-        expect(mockExeca).toHaveBeenCalled();
-    });
-});

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

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

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

@@ -1,125 +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 = {};
-jest.unstable_mockModule('../../arkServices.js', () => ({
-    getInstallableServices: mockGetInstallableServices,
-    arkServices: mockArkServices,
-}));
-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 { createUninstallCommand } = await import('./index.js');
-describe('uninstall 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 = createUninstallCommand(mockConfig);
-        expect(command).toBeInstanceOf(Command);
-        expect(command.name()).toBe('uninstall');
-    });
-    it('uninstalls single service with correct helm parameters', async () => {
-        const mockService = {
-            name: 'ark-api',
-            helmReleaseName: 'ark-api',
-            namespace: 'ark-system',
-        };
-        mockGetInstallableServices.mockReturnValue({
-            'ark-api': mockService,
-        });
-        const command = createUninstallCommand(mockConfig);
-        await command.parseAsync(['node', 'test', 'ark-api']);
-        expect(mockExeca).toHaveBeenCalledWith('helm', [
-            'uninstall',
-            'ark-api',
-            '--ignore-not-found',
-            '--namespace',
-            'ark-system',
-        ], {
-            stdio: 'inherit',
-        });
-        expect(mockOutput.success).toHaveBeenCalledWith('ark-api uninstalled successfully');
-    });
-    it('shows error when service not found', async () => {
-        mockGetInstallableServices.mockReturnValue({
-            'ark-api': { name: 'ark-api' },
-            'ark-controller': { name: 'ark-controller' },
-        });
-        const command = createUninstallCommand(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',
-            // namespace is undefined - should use current context
-        };
-        mockGetInstallableServices.mockReturnValue({
-            'ark-dashboard': mockService,
-        });
-        const command = createUninstallCommand(mockConfig);
-        await command.parseAsync(['node', 'test', 'ark-dashboard']);
-        // Should NOT include --namespace flag
-        expect(mockExeca).toHaveBeenCalledWith('helm', ['uninstall', 'ark-dashboard', '--ignore-not-found'], {
-            stdio: 'inherit',
-        });
-    });
-    it('handles helm uninstall error gracefully', async () => {
-        const mockService = {
-            name: 'ark-api',
-            helmReleaseName: 'ark-api',
-            namespace: 'ark-system',
-        };
-        mockGetInstallableServices.mockReturnValue({
-            'ark-api': mockService,
-        });
-        mockExeca.mockRejectedValue(new Error('helm failed'));
-        const command = createUninstallCommand(mockConfig);
-        await expect(command.parseAsync(['node', 'test', 'ark-api'])).rejects.toThrow('process.exit called');
-        expect(mockOutput.error).toHaveBeenCalledWith('failed to uninstall ark-api');
-        expect(mockExit).toHaveBeenCalledWith(1);
-    });
-    it('exits when cluster not connected', async () => {
-        mockGetClusterInfo.mockResolvedValue({ error: true });
-        const command = createUninstallCommand({});
-        await expect(command.parseAsync(['node', 'test', 'ark-api'])).rejects.toThrow('process.exit called');
-        expect(mockExit).toHaveBeenCalledWith(1);
-    });
-});

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

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

package/dist/lib/arkServiceProxy.spec.js

@@ -1,100 +0,0 @@
-import { jest } from '@jest/globals';
-import { Buffer } from 'buffer';
-const mockFind = jest.fn();
-jest.unstable_mockModule('find-process', () => ({
-    default: mockFind,
-}));
-const mockSpawn = jest.fn();
-const mockChildProcess = {
-    spawn: mockSpawn,
-};
-jest.unstable_mockModule('child_process', () => ({
-    ...mockChildProcess,
-    spawn: mockSpawn,
-}));
-const { ArkServiceProxy } = await import('./arkServiceProxy.js');
-describe('ArkServiceProxy', () => {
-    const mockService = {
-        name: 'test-service',
-        helmReleaseName: 'test-service',
-        description: 'Test service',
-        k8sServiceName: 'test-service-k8s',
-        k8sServicePort: 8080,
-        namespace: 'default',
-        enabled: true,
-        category: 'test',
-    };
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    describe('port-forward reuse', () => {
-        it('creates new port-forward when reuse is disabled', async () => {
-            const proxy = new ArkServiceProxy(mockService, 3000, false);
-            const mockProcess = {
-                stdout: { on: jest.fn() },
-                stderr: { on: jest.fn() },
-                on: jest.fn(),
-                kill: jest.fn(),
-            };
-            mockSpawn.mockReturnValue(mockProcess);
-            setTimeout(() => {
-                const stdoutCallback = mockProcess.stdout.on.mock.calls.find((call) => call[0] === 'data')?.[1];
-                if (stdoutCallback) {
-                    stdoutCallback(Buffer.from('Forwarding from 127.0.0.1:3000'));
-                }
-            }, 10);
-            const url = await proxy.start();
-            expect(url).toBe('http://localhost:3000');
-            expect(mockFind).not.toHaveBeenCalled();
-            expect(mockSpawn).toHaveBeenCalledWith('kubectl', ['port-forward', 'service/test-service-k8s', '3000:8080', '--namespace', 'default'], expect.any(Object));
-        });
-        it('reuses existing kubectl port-forward when reuse is enabled', async () => {
-            mockFind.mockResolvedValue([
-                {
-                    pid: 12345,
-                    name: 'kubectl',
-                    cmd: 'kubectl port-forward service/test-service-k8s 3000:8080',
-                },
-            ]);
-            const proxy = new ArkServiceProxy(mockService, 3000, true);
-            const url = await proxy.start();
-            expect(url).toBe('http://localhost:3000');
-            expect(mockFind).toHaveBeenCalledWith('port', 3000);
-            expect(mockSpawn).not.toHaveBeenCalled();
-        });
-        it('creates new port-forward when port is not in use', async () => {
-            mockFind.mockResolvedValue([]);
-            const proxy = new ArkServiceProxy(mockService, 3000, true);
-            const mockProcess = {
-                stdout: { on: jest.fn() },
-                stderr: { on: jest.fn() },
-                on: jest.fn(),
-                kill: jest.fn(),
-            };
-            mockSpawn.mockReturnValue(mockProcess);
-            setTimeout(() => {
-                const stdoutCallback = mockProcess.stdout.on.mock.calls.find((call) => call[0] === 'data')?.[1];
-                if (stdoutCallback) {
-                    stdoutCallback(Buffer.from('Forwarding from 127.0.0.1:3000'));
-                }
-            }, 10);
-            const url = await proxy.start();
-            expect(url).toBe('http://localhost:3000');
-            expect(mockFind).toHaveBeenCalledWith('port', 3000);
-            expect(mockSpawn).toHaveBeenCalled();
-        });
-        it('throws error when port is in use by non-kubectl process', async () => {
-            mockFind.mockResolvedValue([
-                {
-                    pid: 54321,
-                    name: 'node',
-                    cmd: 'node server.js',
-                },
-            ]);
-            const proxy = new ArkServiceProxy(mockService, 3000, true);
-            await expect(proxy.start()).rejects.toThrow('test-service port forward failed: port 3000 is already in use by node (PID: 54321)');
-            expect(mockFind).toHaveBeenCalledWith('port', 3000);
-            expect(mockSpawn).not.toHaveBeenCalled();
-        });
-    });
-});

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

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

package/dist/lib/arkStatus.spec.js

@@ -1,49 +0,0 @@
-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.spec.d.ts

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