@agent-canvas/cli 0.8.0 → 0.9.0

package/dist/commands/__tests__/export.test.js

@@ -0,0 +1,187 @@
+import { describe, it, expect, vi } from 'vitest';
+import { exportImage } from '../export';
+const SAMPLE_DATA_URL = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==';
+function createMockClient(sendFn) {
+    return {
+        send: sendFn ?? vi.fn(() => Promise.resolve({ success: true, dataUrl: SAMPLE_DATA_URL })),
+        close: vi.fn(),
+    };
+}
+function createMockDeps(overrides) {
+    return {
+        connectToCanvas: vi.fn(() => Promise.resolve(createMockClient())),
+        generateId: vi.fn(() => 'test-id'),
+        writeFile: vi.fn(),
+        now: vi.fn(() => 1234567890),
+        log: vi.fn(),
+        error: vi.fn(),
+        exit: vi.fn(),
+        ...overrides,
+    };
+}
+describe('exportImage', () => {
+    // ==================== Input Validation Tests ====================
+    describe('input validation', () => {
+        it('should error and exit when scale is not 1, 2, or 3', async () => {
+            const deps = createMockDeps();
+            await exportImage({ scale: 4 }, deps);
+            expect(deps.error).toHaveBeenCalledWith('Scale must be 1, 2, or 3');
+            expect(deps.exit).toHaveBeenCalledWith(1);
+            expect(deps.connectToCanvas).not.toHaveBeenCalled();
+        });
+        it('should accept scale 1', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, dataUrl: SAMPLE_DATA_URL }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await exportImage({ scale: 1 }, deps);
+            expect(deps.error).not.toHaveBeenCalled();
+            expect(mockSend).toHaveBeenCalled();
+        });
+        it('should accept scale 2', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, dataUrl: SAMPLE_DATA_URL }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await exportImage({ scale: 2 }, deps);
+            expect(deps.error).not.toHaveBeenCalled();
+            expect(mockSend).toHaveBeenCalled();
+        });
+        it('should accept scale 3', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, dataUrl: SAMPLE_DATA_URL }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await exportImage({ scale: 3 }, deps);
+            expect(deps.error).not.toHaveBeenCalled();
+            expect(mockSend).toHaveBeenCalled();
+        });
+    });
+    // ==================== Parameter/Logic Tests ====================
+    describe('parameter handling', () => {
+        it('should send correct params with defaults', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, dataUrl: SAMPLE_DATA_URL }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await exportImage({}, deps);
+            expect(mockSend).toHaveBeenCalledWith(expect.objectContaining({
+                type: 'exportImage',
+                id: 'test-id',
+                params: {
+                    background: true,
+                    dark: false,
+                    embedScene: false,
+                    scale: 1,
+                },
+            }));
+        });
+        it('should send correct params with all options', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, dataUrl: SAMPLE_DATA_URL }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await exportImage({
+                background: false,
+                dark: true,
+                embedScene: true,
+                scale: 2,
+            }, deps);
+            expect(mockSend).toHaveBeenCalledWith(expect.objectContaining({
+                params: {
+                    background: false,
+                    dark: true,
+                    embedScene: true,
+                    scale: 2,
+                },
+            }));
+        });
+        it('should correctly parse dataUrl to buffer', async () => {
+            const mockWriteFile = vi.fn();
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, dataUrl: SAMPLE_DATA_URL }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+                writeFile: mockWriteFile,
+            });
+            await exportImage({ output: 'test.png' }, deps);
+            const expectedBuffer = Buffer.from('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==', 'base64');
+            expect(mockWriteFile).toHaveBeenCalledWith('test.png', expectedBuffer);
+        });
+        it('should generate default filename when output not specified', async () => {
+            const mockWriteFile = vi.fn();
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, dataUrl: SAMPLE_DATA_URL }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+                writeFile: mockWriteFile,
+                now: vi.fn(() => 1234567890),
+            });
+            await exportImage({}, deps);
+            expect(mockWriteFile).toHaveBeenCalledWith('canvas-1234567890.png', expect.any(Buffer));
+            expect(deps.log).toHaveBeenCalledWith('Exported to canvas-1234567890.png');
+        });
+        it('should use provided output path', async () => {
+            const mockWriteFile = vi.fn();
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, dataUrl: SAMPLE_DATA_URL }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+                writeFile: mockWriteFile,
+            });
+            await exportImage({ output: 'my-diagram.png' }, deps);
+            expect(mockWriteFile).toHaveBeenCalledWith('my-diagram.png', expect.any(Buffer));
+            expect(deps.log).toHaveBeenCalledWith('Exported to my-diagram.png');
+        });
+    });
+    // ==================== Response Handling Tests ====================
+    describe('response handling', () => {
+        it('should log success message on success', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, dataUrl: SAMPLE_DATA_URL }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await exportImage({ output: 'output.png' }, deps);
+            expect(deps.log).toHaveBeenCalledWith('Exported to output.png');
+        });
+        it('should error and exit on failure response', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({
+                success: false,
+                error: 'Export failed',
+            }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await exportImage({}, deps);
+            expect(deps.error).toHaveBeenCalledWith('Failed: Export failed');
+            expect(deps.exit).toHaveBeenCalledWith(1);
+        });
+        it('should close client after success', async () => {
+            const mockClose = vi.fn();
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, dataUrl: SAMPLE_DATA_URL }));
+            const mockClient = { send: mockSend, close: mockClose };
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await exportImage({}, deps);
+            expect(mockClose).toHaveBeenCalled();
+        });
+        it('should close client after failure', async () => {
+            const mockClose = vi.fn();
+            const mockSend = vi.fn(() => Promise.resolve({ success: false, error: 'error' }));
+            const mockClient = { send: mockSend, close: mockClose };
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await exportImage({}, deps);
+            expect(mockClose).toHaveBeenCalled();
+        });
+    });
+});

package/dist/commands/__tests__/group-elements.test.d.ts

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

package/dist/commands/__tests__/group-elements.test.js

@@ -0,0 +1,93 @@
+import { describe, it, expect, vi } from 'vitest';
+import { groupElements } from '../group-elements';
+function createMockClient(sendFn) {
+    return {
+        send: sendFn ?? vi.fn(() => Promise.resolve({ success: true, groupId: 'group-1' })),
+        close: vi.fn(),
+    };
+}
+function createMockDeps(overrides) {
+    return {
+        connectToCanvas: vi.fn(() => Promise.resolve(createMockClient())),
+        generateId: vi.fn(() => 'test-id'),
+        log: vi.fn(),
+        error: vi.fn(),
+        exit: vi.fn(),
+        ...overrides,
+    };
+}
+describe('groupElements', () => {
+    // ==================== Parameter Assembly Tests ====================
+    describe('parameter assembly', () => {
+        it('should send correct params with elementIds', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, groupId: 'group-1' }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await groupElements({ elementIds: ['el-1', 'el-2', 'el-3'] }, deps);
+            expect(mockSend).toHaveBeenCalledWith(expect.objectContaining({
+                type: 'groupElements',
+                id: 'test-id',
+                params: {
+                    elementIds: ['el-1', 'el-2', 'el-3'],
+                },
+            }));
+        });
+        it('should handle single element', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, groupId: 'group-2' }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await groupElements({ elementIds: ['el-single'] }, deps);
+            const callParams = mockSend.mock.calls[0][0].params;
+            expect(callParams.elementIds).toEqual(['el-single']);
+        });
+    });
+    // ==================== Response Handling Tests ====================
+    describe('response handling', () => {
+        it('should log success message with group ID', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, groupId: 'grp-abc123' }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await groupElements({ elementIds: ['el-1', 'el-2'] }, deps);
+            expect(deps.log).toHaveBeenCalledWith('Group created (id: grp-abc123)');
+        });
+        it('should error and exit on failure response', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({
+                success: false,
+                error: 'Cannot group less than 2 elements',
+            }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await groupElements({ elementIds: ['el-1'] }, deps);
+            expect(deps.error).toHaveBeenCalledWith('Failed: Cannot group less than 2 elements');
+            expect(deps.exit).toHaveBeenCalledWith(1);
+        });
+        it('should close client after success', async () => {
+            const mockClose = vi.fn();
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, groupId: 'group-1' }));
+            const mockClient = { send: mockSend, close: mockClose };
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await groupElements({ elementIds: ['el-1', 'el-2'] }, deps);
+            expect(mockClose).toHaveBeenCalled();
+        });
+        it('should close client after failure', async () => {
+            const mockClose = vi.fn();
+            const mockSend = vi.fn(() => Promise.resolve({ success: false, error: 'error' }));
+            const mockClient = { send: mockSend, close: mockClose };
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await groupElements({ elementIds: ['el-1', 'el-2'] }, deps);
+            expect(mockClose).toHaveBeenCalled();
+        });
+    });
+});

package/dist/commands/__tests__/list.test.d.ts

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

package/dist/commands/__tests__/list.test.js

@@ -0,0 +1,134 @@
+import { describe, it, expect, vi } from 'vitest';
+import { list, formatCanvasList } from '../list';
+function createMockClient(sendFn) {
+    return {
+        send: sendFn ?? vi.fn(() => Promise.resolve({ success: true, canvases: [] })),
+        close: vi.fn(),
+    };
+}
+function createMockDeps(overrides) {
+    return {
+        connectToCanvas: vi.fn(() => Promise.resolve(createMockClient())),
+        generateId: vi.fn(() => 'test-id'),
+        log: vi.fn(),
+        error: vi.fn(),
+        exit: vi.fn(),
+        ...overrides,
+    };
+}
+describe('list', () => {
+    // ==================== Format Function Tests ====================
+    describe('formatCanvasList', () => {
+        it('should output header', () => {
+            const lines = formatCanvasList({ canvases: [] });
+            expect(lines[0]).toBe('Canvases: ([U]=User [A]=Agent)');
+        });
+        it('should mark canvas with [U] for user active', () => {
+            const lines = formatCanvasList({
+                activeCanvasId: 'canvas-1',
+                canvases: [
+                    { id: 'canvas-1', name: 'Test Canvas', createdAt: 1000, updatedAt: 2000 },
+                ],
+            });
+            expect(lines[1]).toContain('[U] ');
+            expect(lines[1]).toContain('Test Canvas');
+        });
+        it('should mark canvas with [A] for agent active', () => {
+            const lines = formatCanvasList({
+                agentActiveCanvasId: 'canvas-1',
+                canvases: [
+                    { id: 'canvas-1', name: 'Test Canvas', createdAt: 1000, updatedAt: 2000 },
+                ],
+            });
+            expect(lines[1]).toContain('[A] ');
+            expect(lines[1]).toContain('Test Canvas');
+        });
+        it('should mark canvas with [UA] for both user and agent active', () => {
+            const lines = formatCanvasList({
+                activeCanvasId: 'canvas-1',
+                agentActiveCanvasId: 'canvas-1',
+                canvases: [
+                    { id: 'canvas-1', name: 'Test Canvas', createdAt: 1000, updatedAt: 2000 },
+                ],
+            });
+            expect(lines[1]).toContain('[UA]');
+            expect(lines[1]).toContain('Test Canvas');
+        });
+        it('should not mark canvas when not active', () => {
+            const lines = formatCanvasList({
+                activeCanvasId: 'other-id',
+                agentActiveCanvasId: 'another-id',
+                canvases: [
+                    { id: 'canvas-1', name: 'Test Canvas', createdAt: 1000, updatedAt: 2000 },
+                ],
+            });
+            expect(lines[1]).toMatch(/^    /);
+            expect(lines[1]).toContain('Test Canvas');
+        });
+        it('should include canvas name and formatted date', () => {
+            const timestamp = new Date('2024-01-15T10:30:00Z').getTime();
+            const lines = formatCanvasList({
+                canvases: [
+                    { id: 'canvas-1', name: 'My Canvas', createdAt: 1000, updatedAt: timestamp },
+                ],
+            });
+            expect(lines[1]).toContain('My Canvas');
+            expect(lines[1]).toContain('(updated:');
+        });
+    });
+    // ==================== Response Handling Tests ====================
+    describe('response handling', () => {
+        it('should log each formatted line on success', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({
+                success: true,
+                activeCanvasId: 'canvas-1',
+                canvases: [
+                    { id: 'canvas-1', name: 'Canvas 1', createdAt: 1000, updatedAt: 2000 },
+                    { id: 'canvas-2', name: 'Canvas 2', createdAt: 1000, updatedAt: 3000 },
+                ],
+            }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await list(deps);
+            // First call is header
+            expect(deps.log).toHaveBeenCalledWith('Canvases: ([U]=User [A]=Agent)');
+            // Should have called log 3 times (header + 2 canvases)
+            expect(deps.log).toHaveBeenCalledTimes(3);
+        });
+        it('should error and exit on failure response', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({
+                success: false,
+                error: 'Connection failed',
+            }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await list(deps);
+            expect(deps.error).toHaveBeenCalledWith('Failed: Connection failed');
+            expect(deps.exit).toHaveBeenCalledWith(1);
+        });
+        it('should close client after success', async () => {
+            const mockClose = vi.fn();
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, canvases: [] }));
+            const mockClient = { send: mockSend, close: mockClose };
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await list(deps);
+            expect(mockClose).toHaveBeenCalled();
+        });
+        it('should close client after failure', async () => {
+            const mockClose = vi.fn();
+            const mockSend = vi.fn(() => Promise.resolve({ success: false, error: 'error' }));
+            const mockClient = { send: mockSend, close: mockClose };
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await list(deps);
+            expect(mockClose).toHaveBeenCalled();
+        });
+    });
+});

package/dist/commands/__tests__/load.test.d.ts

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

package/dist/commands/__tests__/load.test.js

@@ -0,0 +1,158 @@
+import { describe, it, expect, vi } from 'vitest';
+import { load } from '../load';
+function createMockClient(sendFn) {
+    return {
+        send: sendFn ?? vi.fn(() => Promise.resolve({ success: true, elementCount: 5 })),
+        close: vi.fn(),
+    };
+}
+function createMockDeps(overrides) {
+    return {
+        connectToCanvas: vi.fn(() => Promise.resolve(createMockClient())),
+        generateId: vi.fn(() => 'test-id'),
+        readFile: vi.fn(() => JSON.stringify({ elements: [{ id: 'el-1' }] })),
+        existsSync: vi.fn(() => true),
+        resolvePath: vi.fn((p) => `/absolute/path/${p}`),
+        log: vi.fn(),
+        error: vi.fn(),
+        exit: vi.fn(),
+        ...overrides,
+    };
+}
+describe('load', () => {
+    // ==================== Input Validation Tests ====================
+    describe('input validation', () => {
+        it('should error and exit when filepath is not provided', async () => {
+            const deps = createMockDeps();
+            await load(undefined, deps);
+            expect(deps.error).toHaveBeenCalledWith('Usage: agent-canvas load <filepath>');
+            expect(deps.exit).toHaveBeenCalledWith(1);
+            expect(deps.connectToCanvas).not.toHaveBeenCalled();
+        });
+        it('should error and exit when file does not exist', async () => {
+            const deps = createMockDeps({
+                existsSync: vi.fn(() => false),
+                resolvePath: vi.fn(() => '/path/to/missing.excalidraw'),
+            });
+            await load('missing.excalidraw', deps);
+            expect(deps.error).toHaveBeenCalledWith('File not found: /path/to/missing.excalidraw');
+            expect(deps.exit).toHaveBeenCalledWith(1);
+            expect(deps.connectToCanvas).not.toHaveBeenCalled();
+        });
+        it('should error and exit when file cannot be read', async () => {
+            const deps = createMockDeps({
+                readFile: vi.fn(() => { throw new Error('Permission denied'); }),
+            });
+            await load('test.excalidraw', deps);
+            expect(deps.error).toHaveBeenCalledWith('Failed to read file: Permission denied');
+            expect(deps.exit).toHaveBeenCalledWith(1);
+            expect(deps.connectToCanvas).not.toHaveBeenCalled();
+        });
+        it('should error and exit when file contains invalid JSON', async () => {
+            const deps = createMockDeps({
+                readFile: vi.fn(() => '{ invalid json }'),
+            });
+            await load('test.excalidraw', deps);
+            expect(deps.error).toHaveBeenCalledWith(expect.stringMatching(/^Failed to parse file:/));
+            expect(deps.exit).toHaveBeenCalledWith(1);
+            expect(deps.connectToCanvas).not.toHaveBeenCalled();
+        });
+    });
+    // ==================== Parameter Assembly Tests ====================
+    describe('parameter assembly', () => {
+        it('should resolve filepath to absolute path', async () => {
+            const mockResolvePath = vi.fn(() => '/absolute/path/test.excalidraw');
+            const deps = createMockDeps({ resolvePath: mockResolvePath });
+            await load('test.excalidraw', deps);
+            expect(mockResolvePath).toHaveBeenCalledWith('test.excalidraw');
+            expect(deps.existsSync).toHaveBeenCalledWith('/absolute/path/test.excalidraw');
+            expect(deps.readFile).toHaveBeenCalledWith('/absolute/path/test.excalidraw', 'utf-8');
+        });
+        it('should send loadScene message with parsed elements', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, elementCount: 2 }));
+            const mockClient = createMockClient(mockSend);
+            const sceneData = {
+                elements: [{ id: 'el-1' }, { id: 'el-2' }],
+                appState: { viewBackgroundColor: '#ffffff' },
+                files: { 'file-1': { mimeType: 'image/png' } },
+            };
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+                readFile: vi.fn(() => JSON.stringify(sceneData)),
+            });
+            await load('scene.excalidraw', deps);
+            expect(mockSend).toHaveBeenCalledWith({
+                type: 'loadScene',
+                id: 'test-id',
+                params: {
+                    elements: sceneData.elements,
+                    appState: sceneData.appState,
+                    files: sceneData.files,
+                },
+            });
+        });
+        it('should default to empty array when elements is missing', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, elementCount: 0 }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+                readFile: vi.fn(() => JSON.stringify({ appState: {} })),
+            });
+            await load('empty.excalidraw', deps);
+            expect(mockSend).toHaveBeenCalledWith({
+                type: 'loadScene',
+                id: 'test-id',
+                params: {
+                    elements: [],
+                    appState: {},
+                    files: undefined,
+                },
+            });
+        });
+    });
+    // ==================== Response Handling Tests ====================
+    describe('response handling', () => {
+        it('should log success message with element count', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, elementCount: 10 }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await load('scene.excalidraw', deps);
+            expect(deps.log).toHaveBeenCalledWith('Loaded 10 elements from scene.excalidraw');
+        });
+        it('should error and exit on failure response', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({
+                success: false,
+                error: 'Invalid scene format',
+            }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await load('bad.excalidraw', deps);
+            expect(deps.error).toHaveBeenCalledWith('Failed to load file: Invalid scene format');
+            expect(deps.exit).toHaveBeenCalledWith(1);
+        });
+        it('should close client after success', async () => {
+            const mockClose = vi.fn();
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, elementCount: 5 }));
+            const mockClient = { send: mockSend, close: mockClose };
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await load('scene.excalidraw', deps);
+            expect(mockClose).toHaveBeenCalled();
+        });
+        it('should close client after failure', async () => {
+            const mockClose = vi.fn();
+            const mockSend = vi.fn(() => Promise.resolve({ success: false, error: 'error' }));
+            const mockClient = { send: mockSend, close: mockClose };
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await load('scene.excalidraw', deps);
+            expect(mockClose).toHaveBeenCalled();
+        });
+    });
+});

package/dist/commands/__tests__/move-elements.test.d.ts

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