skimpyclaw 0.3.14 → 0.4.0

package/dist/__tests__/orchestrator.test.js

@@ -1,425 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { existsSync, appendFileSync, readFileSync } from 'fs';
-import { initOrchestrationSystem, getActiveOrchestrations, getOrchestration, listRecentOrchestrations, setCurrentPlanningSession, getCurrentPlanningSession, executeOrchestratorTool, loadSession, resetForTesting, } from '../orchestrator.js';
-// Mock runAgentTurn
-vi.mock('../agent.js', () => ({
-    runAgentTurn: vi.fn().mockResolvedValue('mock agent response'),
-    buildSystemPrompt: vi.fn().mockReturnValue('mock system prompt'),
-    chatWithTools: vi.fn().mockResolvedValue({ response: 'mock response', toolCalls: [] }),
-    resolveModel: vi.fn((model) => model),
-    buildSystemParam: vi.fn((content) => content),
-}));
-// Mock getCurrentModel
-vi.mock('../gateway.js', () => ({
-    getCurrentModel: vi.fn().mockReturnValue('anthropic/claude-sonnet-4-5'),
-}));
-// Mock subagent
-vi.mock('../subagent.js', () => ({
-    ensureAgentSetup: vi.fn(),
-}));
-// Mock tools
-vi.mock('../tools.js', () => ({
-    getToolDefinitions: vi.fn().mockResolvedValue([]),
-    executeTool: vi.fn().mockResolvedValue('mock tool result'),
-}));
-// Mock fs operations
-vi.mock('fs', async () => {
-    const actual = await vi.importActual('fs');
-    return {
-        ...actual,
-        existsSync: vi.fn().mockReturnValue(true),
-        mkdirSync: vi.fn(),
-        writeFileSync: vi.fn(),
-        appendFileSync: vi.fn(),
-        readFileSync: vi.fn().mockReturnValue(''),
-    };
-});
-function createMockConfig() {
-    return {
-        gateway: { port: 18790, mode: 'local' },
-        agents: {
-            default: 'main',
-            list: {
-                main: {
-                    identity: { name: 'Test', emoji: '🦞' },
-                    model: 'anthropic/claude-sonnet-4-5',
-                },
-                general: {
-                    identity: { name: 'General Agent', emoji: '🦞' },
-                    model: 'anthropic/claude-sonnet-4-5',
-                },
-            },
-        },
-        models: {
-            providers: {
-                anthropic: { apiKey: 'test-key' },
-            },
-            aliases: {},
-        },
-        channels: {
-            telegram: {
-                enabled: false,
-                token: '',
-                allowFrom: [],
-            },
-        },
-        cron: { jobs: [] },
-        heartbeat: {
-            intervalMs: 300000,
-            prompt: 'test',
-        },
-    };
-}
-function createMockSession(overrides) {
-    return {
-        id: 'orch_test_123',
-        prompt: 'Test prompt',
-        status: 'planning',
-        model: 'anthropic/claude-sonnet-4-5',
-        chatId: 456,
-        tasks: [],
-        workers: [],
-        messages: [],
-        createdAt: new Date().toISOString(),
-        ...overrides,
-    };
-}
-describe('orchestrator', () => {
-    let deliveredMessages;
-    beforeEach(() => {
-        resetForTesting();
-        deliveredMessages = [];
-        initOrchestrationSystem(async (chatId, message) => {
-            deliveredMessages.push({ chatId, message });
-        });
-        vi.mocked(existsSync).mockReturnValue(true);
-        vi.mocked(appendFileSync).mockReset();
-        vi.mocked(readFileSync).mockReturnValue('');
-    });
-    describe('initOrchestrationSystem', () => {
-        it('initializes without error', () => {
-            expect(() => initOrchestrationSystem(async () => { })).not.toThrow();
-        });
-    });
-    describe('executeOrchestratorTool', () => {
-        it('CreateTask creates a task on the planning session', () => {
-            const session = createMockSession();
-            setCurrentPlanningSession(session);
-            const result = executeOrchestratorTool('CreateTask', {
-                title: 'Write tests',
-                description: 'Write unit tests for the orchestrator',
-                agentType: 'coding',
-            });
-            expect(result).toContain('ot1');
-            expect(result).toContain('Write tests');
-            expect(session.tasks).toHaveLength(1);
-            expect(session.tasks[0].id).toBe('ot1');
-            expect(session.tasks[0].title).toBe('Write tests');
-            expect(session.tasks[0].description).toBe('Write unit tests for the orchestrator');
-            expect(session.tasks[0].status).toBe('pending');
-            expect(session.tasks[0].dependsOn).toEqual([]);
-            setCurrentPlanningSession(null);
-        });
-        it('CreateTask with dependencies', () => {
-            const session = createMockSession();
-            setCurrentPlanningSession(session);
-            executeOrchestratorTool('CreateTask', {
-                title: 'Task 1',
-                description: 'First task',
-                agentType: 'research',
-            });
-            const result = executeOrchestratorTool('CreateTask', {
-                title: 'Task 2',
-                description: 'Depends on task 1',
-                agentType: 'coding',
-                dependsOn: ['ot1'],
-            });
-            expect(result).toContain('ot2');
-            expect(session.tasks).toHaveLength(2);
-            expect(session.tasks[1].dependsOn).toEqual(['ot1']);
-            setCurrentPlanningSession(null);
-        });
-        it('CreateTask increments IDs', () => {
-            const session = createMockSession();
-            setCurrentPlanningSession(session);
-            executeOrchestratorTool('CreateTask', {
-                title: 'A', description: 'a', agentType: 'general',
-            });
-            executeOrchestratorTool('CreateTask', {
-                title: 'B', description: 'b', agentType: 'general',
-            });
-            executeOrchestratorTool('CreateTask', {
-                title: 'C', description: 'c', agentType: 'general',
-            });
-            expect(session.tasks.map(t => t.id)).toEqual(['ot1', 'ot2', 'ot3']);
-            setCurrentPlanningSession(null);
-        });
-        it('CreateTask rejects invalid agentType', () => {
-            const session = createMockSession();
-            setCurrentPlanningSession(session);
-            const result = executeOrchestratorTool('CreateTask', {
-                title: 'Bad', description: 'bad', agentType: 'invalid',
-            });
-            expect(result).toContain('Error');
-            expect(result).toContain('Invalid agentType');
-            expect(session.tasks).toHaveLength(0);
-            setCurrentPlanningSession(null);
-        });
-        it('CreateTask rejects missing fields', () => {
-            const session = createMockSession();
-            setCurrentPlanningSession(session);
-            const result = executeOrchestratorTool('CreateTask', {
-                title: 'No desc',
-                agentType: 'general',
-            });
-            expect(result).toContain('Error');
-            expect(session.tasks).toHaveLength(0);
-            setCurrentPlanningSession(null);
-        });
-        it('CreateTask errors without planning session', () => {
-            const result = executeOrchestratorTool('CreateTask', {
-                title: 'Test', description: 'test', agentType: 'general',
-            });
-            expect(result).toContain('Error');
-            expect(result).toContain('No active planning session');
-        });
-        it('FinishPlanning returns success', () => {
-            const session = createMockSession();
-            session.tasks.push({
-                id: 'ot1', sessionId: session.id, title: 'T',
-                description: 'd', status: 'pending', dependsOn: [],
-                createdAt: new Date().toISOString(),
-            });
-            setCurrentPlanningSession(session);
-            const result = executeOrchestratorTool('FinishPlanning', {});
-            expect(result).toContain('Planning complete');
-            expect(result).toContain('1 task(s)');
-            setCurrentPlanningSession(null);
-        });
-        it('FinishPlanning errors without planning session', () => {
-            const result = executeOrchestratorTool('FinishPlanning', {});
-            expect(result).toContain('Error');
-        });
-        it('GetTaskStatus returns summary', () => {
-            const session = createMockSession();
-            session.tasks.push({
-                id: 'ot1', sessionId: session.id, title: 'Research APIs',
-                description: 'd', status: 'completed', dependsOn: [],
-                createdAt: new Date().toISOString(),
-            }, {
-                id: 'ot2', sessionId: session.id, title: 'Write code',
-                description: 'd', status: 'pending', dependsOn: ['ot1'],
-                createdAt: new Date().toISOString(),
-            });
-            setCurrentPlanningSession(session);
-            const result = executeOrchestratorTool('GetTaskStatus', {});
-            expect(result).toContain('ot1');
-            expect(result).toContain('completed');
-            expect(result).toContain('Research APIs');
-            expect(result).toContain('ot2');
-            expect(result).toContain('pending');
-            expect(result).toContain('depends on: ot1');
-            setCurrentPlanningSession(null);
-        });
-        it('GetTaskStatus with no tasks', () => {
-            const session = createMockSession();
-            setCurrentPlanningSession(session);
-            const result = executeOrchestratorTool('GetTaskStatus', {});
-            expect(result).toBe('No tasks created yet.');
-            setCurrentPlanningSession(null);
-        });
-        it('unknown tool returns error', () => {
-            const result = executeOrchestratorTool('DoSomething', {});
-            expect(result).toContain('Error');
-            expect(result).toContain('Unknown orchestrator tool');
-        });
-    });
-    describe('session management', () => {
-        it('setCurrentPlanningSession and getCurrentPlanningSession', () => {
-            expect(getCurrentPlanningSession()).toBeNull();
-            const session = createMockSession();
-            setCurrentPlanningSession(session);
-            expect(getCurrentPlanningSession()).toBe(session);
-            setCurrentPlanningSession(null);
-            expect(getCurrentPlanningSession()).toBeNull();
-        });
-        it('getActiveOrchestrations returns empty initially', () => {
-            expect(getActiveOrchestrations()).toHaveLength(0);
-        });
-        it('listRecentOrchestrations returns empty initially', () => {
-            expect(listRecentOrchestrations()).toHaveLength(0);
-        });
-        it('getOrchestration returns null for unknown id', () => {
-            expect(getOrchestration('orch_nonexistent')).toBeNull();
-        });
-    });
-    describe('JSONL event storage', () => {
-        it('loadSession returns null for missing file', () => {
-            vi.mocked(existsSync).mockReturnValue(false);
-            expect(loadSession('orch_missing')).toBeNull();
-        });
-        it('loadSession reconstructs from session_created event', () => {
-            const session = createMockSession({ id: 'orch_load_test' });
-            const eventLine = JSON.stringify({
-                type: 'session_created',
-                timestamp: new Date().toISOString(),
-                sessionId: 'orch_load_test',
-                data: { session },
-            });
-            vi.mocked(existsSync).mockReturnValue(true);
-            vi.mocked(readFileSync).mockReturnValue(eventLine);
-            const loaded = loadSession('orch_load_test');
-            expect(loaded).not.toBeNull();
-            expect(loaded.id).toBe('orch_load_test');
-            expect(loaded.prompt).toBe('Test prompt');
-            expect(loaded.status).toBe('planning');
-        });
-        it('loadSession applies task_created events', () => {
-            const session = createMockSession({ id: 'orch_task_test' });
-            const task = {
-                id: 'ot1',
-                sessionId: 'orch_task_test',
-                title: 'Test Task',
-                description: 'A test',
-                status: 'pending',
-                dependsOn: [],
-                createdAt: new Date().toISOString(),
-            };
-            const lines = [
-                JSON.stringify({
-                    type: 'session_created',
-                    timestamp: new Date().toISOString(),
-                    sessionId: 'orch_task_test',
-                    data: { session },
-                }),
-                JSON.stringify({
-                    type: 'task_created',
-                    timestamp: new Date().toISOString(),
-                    sessionId: 'orch_task_test',
-                    data: { task },
-                }),
-            ].join('\n');
-            vi.mocked(existsSync).mockReturnValue(true);
-            vi.mocked(readFileSync).mockReturnValue(lines);
-            const loaded = loadSession('orch_task_test');
-            expect(loaded.tasks).toHaveLength(1);
-            expect(loaded.tasks[0].id).toBe('ot1');
-            expect(loaded.tasks[0].title).toBe('Test Task');
-        });
-        it('loadSession applies task status transitions', () => {
-            const session = createMockSession({ id: 'orch_status_test' });
-            const task = {
-                id: 'ot1', sessionId: 'orch_status_test', title: 'T',
-                description: 'd', status: 'pending', dependsOn: [],
-                createdAt: new Date().toISOString(),
-            };
-            const lines = [
-                JSON.stringify({ type: 'session_created', timestamp: new Date().toISOString(), sessionId: 'orch_status_test', data: { session } }),
-                JSON.stringify({ type: 'task_created', timestamp: new Date().toISOString(), sessionId: 'orch_status_test', data: { task } }),
-                JSON.stringify({ type: 'task_started', timestamp: new Date().toISOString(), sessionId: 'orch_status_test', data: { taskId: 'ot1', workerId: 'w1' } }),
-                JSON.stringify({ type: 'task_completed', timestamp: new Date().toISOString(), sessionId: 'orch_status_test', data: { taskId: 'ot1', result: 'done' } }),
-            ].join('\n');
-            vi.mocked(existsSync).mockReturnValue(true);
-            vi.mocked(readFileSync).mockReturnValue(lines);
-            const loaded = loadSession('orch_status_test');
-            expect(loaded.tasks[0].status).toBe('completed');
-            expect(loaded.tasks[0].result).toBe('done');
-            expect(loaded.tasks[0].workerId).toBe('w1');
-        });
-        it('loadSession applies session_completed', () => {
-            const session = createMockSession({ id: 'orch_complete_test' });
-            const lines = [
-                JSON.stringify({ type: 'session_created', timestamp: new Date().toISOString(), sessionId: 'orch_complete_test', data: { session } }),
-                JSON.stringify({ type: 'session_completed', timestamp: new Date().toISOString(), sessionId: 'orch_complete_test', data: { finalResult: 'All done' } }),
-            ].join('\n');
-            vi.mocked(existsSync).mockReturnValue(true);
-            vi.mocked(readFileSync).mockReturnValue(lines);
-            const loaded = loadSession('orch_complete_test');
-            expect(loaded.status).toBe('completed');
-            expect(loaded.finalResult).toBe('All done');
-        });
-        it('loadSession applies session_failed', () => {
-            const session = createMockSession({ id: 'orch_fail_test' });
-            const lines = [
-                JSON.stringify({ type: 'session_created', timestamp: new Date().toISOString(), sessionId: 'orch_fail_test', data: { session } }),
-                JSON.stringify({ type: 'session_failed', timestamp: new Date().toISOString(), sessionId: 'orch_fail_test', data: { error: 'boom' } }),
-            ].join('\n');
-            vi.mocked(existsSync).mockReturnValue(true);
-            vi.mocked(readFileSync).mockReturnValue(lines);
-            const loaded = loadSession('orch_fail_test');
-            expect(loaded.status).toBe('failed');
-            expect(loaded.error).toBe('boom');
-        });
-        it('loadSession applies phase_changed', () => {
-            const session = createMockSession({ id: 'orch_phase_test' });
-            const lines = [
-                JSON.stringify({ type: 'session_created', timestamp: new Date().toISOString(), sessionId: 'orch_phase_test', data: { session } }),
-                JSON.stringify({ type: 'phase_changed', timestamp: new Date().toISOString(), sessionId: 'orch_phase_test', data: { phase: 'executing' } }),
-            ].join('\n');
-            vi.mocked(existsSync).mockReturnValue(true);
-            vi.mocked(readFileSync).mockReturnValue(lines);
-            const loaded = loadSession('orch_phase_test');
-            expect(loaded.status).toBe('executing');
-        });
-        it('loadSession applies task_failed', () => {
-            const session = createMockSession({ id: 'orch_taskfail_test' });
-            const task = {
-                id: 'ot1', sessionId: 'orch_taskfail_test', title: 'T',
-                description: 'd', status: 'pending', dependsOn: [],
-                createdAt: new Date().toISOString(),
-            };
-            const lines = [
-                JSON.stringify({ type: 'session_created', timestamp: new Date().toISOString(), sessionId: 'orch_taskfail_test', data: { session } }),
-                JSON.stringify({ type: 'task_created', timestamp: new Date().toISOString(), sessionId: 'orch_taskfail_test', data: { task } }),
-                JSON.stringify({ type: 'task_failed', timestamp: new Date().toISOString(), sessionId: 'orch_taskfail_test', data: { taskId: 'ot1', error: 'timeout' } }),
-            ].join('\n');
-            vi.mocked(existsSync).mockReturnValue(true);
-            vi.mocked(readFileSync).mockReturnValue(lines);
-            const loaded = loadSession('orch_taskfail_test');
-            expect(loaded.tasks[0].status).toBe('failed');
-            expect(loaded.tasks[0].error).toBe('timeout');
-        });
-        it('loadSession applies message_sent', () => {
-            const session = createMockSession({ id: 'orch_msg_test' });
-            const message = { id: 'm1', from: 'w1', to: 'coordinator', content: 'done', timestamp: new Date().toISOString() };
-            const lines = [
-                JSON.stringify({ type: 'session_created', timestamp: new Date().toISOString(), sessionId: 'orch_msg_test', data: { session } }),
-                JSON.stringify({ type: 'message_sent', timestamp: new Date().toISOString(), sessionId: 'orch_msg_test', data: { message } }),
-            ].join('\n');
-            vi.mocked(existsSync).mockReturnValue(true);
-            vi.mocked(readFileSync).mockReturnValue(lines);
-            const loaded = loadSession('orch_msg_test');
-            expect(loaded.messages).toHaveLength(1);
-            expect(loaded.messages[0].content).toBe('done');
-        });
-    });
-    describe('resetForTesting', () => {
-        it('clears all state', () => {
-            const session = createMockSession();
-            setCurrentPlanningSession(session);
-            resetForTesting();
-            expect(getCurrentPlanningSession()).toBeNull();
-            expect(getActiveOrchestrations()).toHaveLength(0);
-            expect(listRecentOrchestrations()).toHaveLength(0);
-        });
-    });
-    describe('CreateTask persists events', () => {
-        it('appends task_created event to JSONL', () => {
-            const session = createMockSession({ id: 'orch_persist_test' });
-            setCurrentPlanningSession(session);
-            executeOrchestratorTool('CreateTask', {
-                title: 'Persist me',
-                description: 'Test persistence',
-                agentType: 'coding',
-            });
-            expect(appendFileSync).toHaveBeenCalled();
-            const calls = vi.mocked(appendFileSync).mock.calls;
-            const lastCall = calls[calls.length - 1];
-            const eventStr = lastCall[1];
-            const event = JSON.parse(eventStr.trim());
-            expect(event.type).toBe('task_created');
-            expect(event.data.task.title).toBe('Persist me');
-            setCurrentPlanningSession(null);
-        });
-    });
-});

package/dist/__tests__/sandbox-bridge.test.js

@@ -1,116 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-const { mockExecInContainer } = vi.hoisted(() => ({
-    mockExecInContainer: vi.fn(),
-}));
-vi.mock('../sandbox/runtime.js', () => ({
-    execInContainer: mockExecInContainer,
-}));
-import { sandboxBash, sandboxReadFile, sandboxWriteFile, sandboxListDir, sandboxGlob, } from '../sandbox/bridge.js';
-describe('sandbox/bridge', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    describe('sandboxBash', () => {
-        it('passes command through', async () => {
-            mockExecInContainer.mockResolvedValue({ stdout: 'ok', stderr: '', exitCode: 0 });
-            const result = await sandboxBash('ctr', 'echo hi');
-            expect(result).toBe('ok');
-            expect(mockExecInContainer).toHaveBeenCalledWith('ctr', ['echo hi'], expect.any(Object));
-        });
-        it('handles cwd', async () => {
-            mockExecInContainer.mockResolvedValue({ stdout: '', stderr: '', exitCode: 0 });
-            await sandboxBash('ctr', 'ls', '/workspace');
-            const args = mockExecInContainer.mock.calls[0][1][0];
-            expect(args).toContain('cd');
-            expect(args).toContain('/workspace');
-        });
-        it('handles timeout', async () => {
-            mockExecInContainer.mockResolvedValue({ stdout: '', stderr: '', exitCode: 0 });
-            await sandboxBash('ctr', 'sleep 1', undefined, 5000);
-            const opts = mockExecInContainer.mock.calls[0][2];
-            expect(opts.timeout).toBe(5000);
-        });
-        it('truncates long output', async () => {
-            const longOutput = 'x'.repeat(60 * 1024);
-            mockExecInContainer.mockResolvedValue({ stdout: longOutput, stderr: '', exitCode: 0 });
-            const result = await sandboxBash('ctr', 'cmd');
-            expect(result.length).toBeLessThan(longOutput.length);
-            expect(result).toContain('truncated');
-        });
-        it('includes exit code on failure', async () => {
-            mockExecInContainer.mockResolvedValue({ stdout: 'out', stderr: 'err', exitCode: 42 });
-            const result = await sandboxBash('ctr', 'bad');
-            expect(result).toContain('[exit code: 42]');
-        });
-        it('returns (no output) when empty', async () => {
-            mockExecInContainer.mockResolvedValue({ stdout: '', stderr: '', exitCode: 0 });
-            const result = await sandboxBash('ctr', 'true');
-            expect(result).toBe('(no output)');
-        });
-    });
-    describe('sandboxReadFile', () => {
-        it('calls cat with path', async () => {
-            mockExecInContainer.mockResolvedValue({ stdout: 'content', stderr: '', exitCode: 0 });
-            const result = await sandboxReadFile('ctr', '/workspace/file.txt');
-            expect(result).toBe('content');
-            expect(mockExecInContainer.mock.calls[0][1][0]).toContain('cat');
-        });
-        it('truncates large files', async () => {
-            const big = 'y'.repeat(120 * 1024);
-            mockExecInContainer.mockResolvedValue({ stdout: big, stderr: '', exitCode: 0 });
-            const result = await sandboxReadFile('ctr', '/f');
-            expect(result.length).toBeLessThan(big.length);
-            expect(result).toContain('truncated');
-        });
-        it('throws on failure', async () => {
-            mockExecInContainer.mockResolvedValue({ stdout: '', stderr: 'not found', exitCode: 1 });
-            await expect(sandboxReadFile('ctr', '/missing')).rejects.toThrow('Failed to read');
-        });
-    });
-    describe('sandboxWriteFile', () => {
-        it('sends content via stdin', async () => {
-            mockExecInContainer.mockResolvedValue({ stdout: '', stderr: '', exitCode: 0 });
-            const result = await sandboxWriteFile('ctr', '/workspace/f.txt', 'hello');
-            expect(result).toContain('Written');
-            expect(result).toContain('5 bytes');
-            const opts = mockExecInContainer.mock.calls[0][2];
-            expect(opts.stdin).toBe('hello');
-        });
-        it('creates parent dirs', async () => {
-            mockExecInContainer.mockResolvedValue({ stdout: '', stderr: '', exitCode: 0 });
-            await sandboxWriteFile('ctr', '/workspace/a/b/c.txt', 'data');
-            expect(mockExecInContainer.mock.calls[0][1][0]).toContain('mkdir -p');
-        });
-        it('throws on failure', async () => {
-            mockExecInContainer.mockResolvedValue({ stdout: '', stderr: 'perm denied', exitCode: 1 });
-            await expect(sandboxWriteFile('ctr', '/f', 'x')).rejects.toThrow('Failed to write');
-        });
-    });
-    describe('sandboxListDir', () => {
-        it('calls ls -la', async () => {
-            mockExecInContainer.mockResolvedValue({ stdout: 'drwxr-xr-x ...', stderr: '', exitCode: 0 });
-            const result = await sandboxListDir('ctr', '/workspace');
-            expect(result).toBe('drwxr-xr-x ...');
-            expect(mockExecInContainer.mock.calls[0][1][0]).toContain('ls -la');
-        });
-        it('throws on failure', async () => {
-            mockExecInContainer.mockResolvedValue({ stdout: '', stderr: 'no such dir', exitCode: 1 });
-            await expect(sandboxListDir('ctr', '/bad')).rejects.toThrow('Failed to list');
-        });
-    });
-    describe('sandboxGlob', () => {
-        it('calls find with correct args', async () => {
-            mockExecInContainer.mockResolvedValue({ stdout: '/workspace/a.ts\n', stderr: '', exitCode: 0 });
-            const result = await sandboxGlob('ctr', '/workspace', '*.ts');
-            expect(result).toContain('/workspace/a.ts');
-            const cmd = mockExecInContainer.mock.calls[0][1][0];
-            expect(cmd).toContain('find');
-            expect(cmd).toContain('-name');
-            expect(cmd).toContain('-maxdepth');
-        });
-        it('throws on failure', async () => {
-            mockExecInContainer.mockResolvedValue({ stdout: '', stderr: 'err', exitCode: 1 });
-            await expect(sandboxGlob('ctr', '/x', '*.js')).rejects.toThrow('Failed to glob');
-        });
-    });
-});