@agent-canvas/cli 0.8.1 → 0.9.1

package/dist/commands/__tests__/add-arrow.test.d.ts

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

package/dist/commands/__tests__/add-arrow.test.js

@@ -0,0 +1,186 @@
+import { describe, it, expect, vi } from 'vitest';
+import { addArrow, parseViaPoints } from '../add-arrow';
+function createMockClient(sendFn) {
+    return {
+        send: sendFn ?? vi.fn(() => Promise.resolve({ success: true, elementId: 'el-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,
+    };
+}
+// ==================== parseViaPoints Pure Function Tests ====================
+describe('parseViaPoints', () => {
+    it('should parse single point', () => {
+        const result = parseViaPoints('100,200');
+        expect(result).toEqual([{ x: 100, y: 200 }]);
+    });
+    it('should parse multiple points', () => {
+        const result = parseViaPoints('100,200;300,400');
+        expect(result).toEqual([{ x: 100, y: 200 }, { x: 300, y: 400 }]);
+    });
+    it('should parse three points', () => {
+        const result = parseViaPoints('10,20;30,40;50,60');
+        expect(result).toEqual([{ x: 10, y: 20 }, { x: 30, y: 40 }, { x: 50, y: 60 }]);
+    });
+});
+describe('addArrow', () => {
+    // ==================== Parameter Assembly Tests ====================
+    describe('parameter assembly', () => {
+        it('should send correct params with required options only', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, elementId: 'el-1' }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await addArrow({ x: 100, y: 200, endX: 300, endY: 400 }, deps);
+            expect(mockSend).toHaveBeenCalledWith(expect.objectContaining({
+                type: 'addArrow',
+                id: 'test-id',
+                params: expect.objectContaining({
+                    x: 100,
+                    y: 200,
+                    endX: 300,
+                    endY: 400,
+                }),
+            }));
+            // customData and midpoints should be undefined when not provided
+            const callParams = mockSend.mock.calls[0][0].params;
+            expect(callParams.customData).toBeUndefined();
+            expect(callParams.midpoints).toBeUndefined();
+        });
+        it('should send correct optional style params', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, elementId: 'el-1' }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await addArrow({
+                x: 0,
+                y: 0,
+                endX: 100,
+                endY: 100,
+                strokeColor: '#ff0000',
+                strokeWidth: 2,
+                strokeStyle: 'dashed',
+                startArrowhead: 'none',
+                endArrowhead: 'triangle',
+                arrowType: 'round',
+            }, deps);
+            const callParams = mockSend.mock.calls[0][0].params;
+            expect(callParams.strokeColor).toBe('#ff0000');
+            expect(callParams.strokeWidth).toBe(2);
+            expect(callParams.strokeStyle).toBe('dashed');
+            expect(callParams.startArrowhead).toBe('none');
+            expect(callParams.endArrowhead).toBe('triangle');
+            expect(callParams.arrowType).toBe('round');
+        });
+        it('should parse via into midpoints when provided', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, elementId: 'el-1' }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await addArrow({
+                x: 0,
+                y: 0,
+                endX: 200,
+                endY: 200,
+                via: '100,50;150,150',
+            }, deps);
+            const callParams = mockSend.mock.calls[0][0].params;
+            expect(callParams.midpoints).toEqual([{ x: 100, y: 50 }, { x: 150, y: 150 }]);
+        });
+        it('should have undefined midpoints when via is not provided', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, elementId: 'el-1' }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await addArrow({ x: 0, y: 0, endX: 100, endY: 100 }, deps);
+            const callParams = mockSend.mock.calls[0][0].params;
+            expect(callParams.midpoints).toBeUndefined();
+        });
+        it('should set customData with note when note is provided', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, elementId: 'el-1' }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await addArrow({
+                x: 0,
+                y: 0,
+                endX: 100,
+                endY: 100,
+                note: 'my arrow note',
+            }, deps);
+            const callParams = mockSend.mock.calls[0][0].params;
+            expect(callParams.customData).toEqual({ note: 'my arrow note' });
+        });
+        it('should not include customData when note is not provided', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, elementId: 'el-1' }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await addArrow({ x: 0, y: 0, endX: 100, endY: 100 }, deps);
+            const callParams = mockSend.mock.calls[0][0].params;
+            expect(callParams.customData).toBeUndefined();
+        });
+    });
+    // ==================== Response Handling Tests ====================
+    describe('response handling', () => {
+        it('should log success message with element id', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({
+                success: true,
+                elementId: 'el-123',
+            }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await addArrow({ x: 0, y: 0, endX: 100, endY: 100 }, deps);
+            expect(deps.log).toHaveBeenCalledWith('Arrow created (id: el-123)');
+        });
+        it('should error and exit on failure response', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({
+                success: false,
+                error: 'Something went wrong',
+            }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await addArrow({ x: 0, y: 0, endX: 100, endY: 100 }, deps);
+            expect(deps.error).toHaveBeenCalledWith('Failed: Something went wrong');
+            expect(deps.exit).toHaveBeenCalledWith(1);
+        });
+        it('should close client after success', async () => {
+            const mockClose = vi.fn();
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, elementId: 'el-1' }));
+            const mockClient = { send: mockSend, close: mockClose };
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await addArrow({ x: 0, y: 0, endX: 100, endY: 100 }, 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 addArrow({ x: 0, y: 0, endX: 100, endY: 100 }, deps);
+            expect(mockClose).toHaveBeenCalled();
+        });
+    });
+});

package/dist/commands/__tests__/add-image.test.d.ts

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

package/dist/commands/__tests__/add-image.test.js

@@ -0,0 +1,170 @@
+import { describe, it, expect, vi } from 'vitest';
+import { addImage } from '../add-image';
+function createMockClient(sendFn) {
+    return {
+        send: sendFn ?? vi.fn(() => Promise.resolve({ success: true, elementId: 'el-1', fileId: 'file-1' })),
+        close: vi.fn(),
+    };
+}
+function createMockDeps(overrides) {
+    return {
+        readFile: vi.fn(() => Buffer.from('fake-image-data')),
+        connectToCanvas: vi.fn(() => Promise.resolve(createMockClient())),
+        generateId: vi.fn(() => 'test-id'),
+        log: vi.fn(),
+        error: vi.fn(),
+        exit: vi.fn(),
+        ...overrides,
+    };
+}
+describe('addImage', () => {
+    // ==================== Input Validation Tests ====================
+    describe('input validation', () => {
+        it('should error on unsupported image format', async () => {
+            const deps = createMockDeps();
+            await addImage({ file: 'test.txt', x: 0, y: 0 }, deps);
+            expect(deps.error).toHaveBeenCalledWith('Unsupported image format. Supported: PNG, JPEG, GIF, SVG, WebP');
+            expect(deps.exit).toHaveBeenCalledWith(1);
+            expect(deps.connectToCanvas).not.toHaveBeenCalled();
+        });
+        it('should error when file does not exist', async () => {
+            const deps = createMockDeps({
+                readFile: vi.fn(() => { throw new Error('ENOENT'); }),
+            });
+            await addImage({ file: 'missing.png', x: 0, y: 0 }, deps);
+            expect(deps.error).toHaveBeenCalledWith('Failed to read file: missing.png');
+            expect(deps.exit).toHaveBeenCalledWith(1);
+        });
+        it('should error when file is too large', async () => {
+            const largeBuffer = Buffer.alloc(3 * 1024 * 1024); // 3MB
+            const deps = createMockDeps({
+                readFile: vi.fn(() => largeBuffer),
+            });
+            await addImage({ file: 'large.png', x: 0, y: 0 }, deps);
+            expect(deps.error).toHaveBeenCalledWith('Image too large: 3.00MB (max: 2MB)');
+            expect(deps.exit).toHaveBeenCalledWith(1);
+        });
+    });
+    // ==================== Parameter Assembly Tests ====================
+    describe('parameter assembly', () => {
+        it('should send correct params with required options only', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, elementId: 'el-1', fileId: 'file-1' }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await addImage({ file: 'test.png', x: 100, y: 200 }, deps);
+            expect(mockSend).toHaveBeenCalledWith(expect.objectContaining({
+                type: 'addImage',
+                params: expect.objectContaining({
+                    x: 100,
+                    y: 200,
+                    mimeType: 'image/png',
+                }),
+            }));
+            // customData should be undefined when no note
+            const callParams = mockSend.mock.calls[0][0].params;
+            expect(callParams.customData).toBeUndefined();
+        });
+        it('should send correct params with all options', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, elementId: 'el-1', fileId: 'file-1' }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await addImage({
+                file: 'test.jpg',
+                x: 100,
+                y: 200,
+                width: 300,
+                height: 400,
+                note: 'test note',
+            }, deps);
+            const callParams = mockSend.mock.calls[0][0].params;
+            expect(callParams.x).toBe(100);
+            expect(callParams.y).toBe(200);
+            expect(callParams.width).toBe(300);
+            expect(callParams.height).toBe(400);
+            expect(callParams.mimeType).toBe('image/jpeg');
+            expect(callParams.customData).toEqual({ note: 'test note' });
+        });
+        it('should generate correct dataUrl format', async () => {
+            const testData = Buffer.from('test-image-content');
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, elementId: 'el-1', fileId: 'file-1' }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                readFile: vi.fn(() => testData),
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await addImage({ file: 'test.png', x: 0, y: 0 }, deps);
+            const callParams = mockSend.mock.calls[0][0].params;
+            expect(callParams.dataUrl).toBe(`data:image/png;base64,${testData.toString('base64')}`);
+        });
+        it('should generate fileId from buffer content', async () => {
+            const testData = Buffer.from('unique-content');
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, elementId: 'el-1', fileId: 'file-1' }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                readFile: vi.fn(() => testData),
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await addImage({ file: 'test.png', x: 0, y: 0 }, deps);
+            const callParams = mockSend.mock.calls[0][0].params;
+            // fileId should be 40 char SHA-1 hash
+            expect(callParams.fileId).toMatch(/^[0-9a-f]{40}$/);
+        });
+    });
+    // ==================== Response Handling Tests ====================
+    describe('response handling', () => {
+        it('should log success message with dimensions when provided', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({
+                success: true,
+                elementId: 'el-123',
+                fileId: 'file-456',
+                x: 100,
+                y: 200,
+                width: 300,
+                height: 400,
+            }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await addImage({ file: 'test.png', x: 100, y: 200 }, deps);
+            expect(deps.log).toHaveBeenCalledWith('Image added (id: el-123, fileId: file-456 x=100 y=200 w=300 h=400)');
+        });
+        it('should error and exit on failure response', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({
+                success: false,
+                error: 'Something went wrong',
+            }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await addImage({ file: 'test.png', x: 0, y: 0 }, deps);
+            expect(deps.error).toHaveBeenCalledWith('Failed: Something went wrong');
+            expect(deps.exit).toHaveBeenCalledWith(1);
+        });
+        it('should close client after success', async () => {
+            const mockClose = vi.fn();
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, elementId: 'el-1', fileId: 'file-1' }));
+            const mockClient = { send: mockSend, close: mockClose };
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await addImage({ file: 'test.png', x: 0, y: 0 }, 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 addImage({ file: 'test.png', x: 0, y: 0 }, deps);
+            expect(mockClose).toHaveBeenCalled();
+        });
+    });
+});

package/dist/commands/__tests__/add-line.test.d.ts

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

package/dist/commands/__tests__/add-line.test.js

@@ -0,0 +1,138 @@
+import { describe, it, expect, vi } from 'vitest';
+import { addLine } from '../add-line';
+function createMockClient(sendFn) {
+    return {
+        send: sendFn ?? vi.fn(() => Promise.resolve({ success: true, elementId: 'el-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('addLine', () => {
+    // ==================== Parameter Assembly Tests ====================
+    describe('parameter assembly', () => {
+        it('should send correct params with required options only', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, elementId: 'el-1' }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await addLine({ x: 100, y: 200, endX: 300, endY: 400 }, deps);
+            expect(mockSend).toHaveBeenCalledWith(expect.objectContaining({
+                type: 'addLine',
+                id: 'test-id',
+                params: expect.objectContaining({
+                    x: 100,
+                    y: 200,
+                    endX: 300,
+                    endY: 400,
+                }),
+            }));
+            // customData should be undefined when no note
+            const callParams = mockSend.mock.calls[0][0].params;
+            expect(callParams.customData).toBeUndefined();
+        });
+        it('should send correct optional style params', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, elementId: 'el-1' }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await addLine({
+                x: 0,
+                y: 0,
+                endX: 100,
+                endY: 100,
+                strokeColor: '#ff0000',
+                strokeWidth: 2,
+                strokeStyle: 'dashed',
+            }, deps);
+            const callParams = mockSend.mock.calls[0][0].params;
+            expect(callParams.strokeColor).toBe('#ff0000');
+            expect(callParams.strokeWidth).toBe(2);
+            expect(callParams.strokeStyle).toBe('dashed');
+        });
+        it('should set customData with note when note is provided', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, elementId: 'el-1' }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await addLine({
+                x: 0,
+                y: 0,
+                endX: 100,
+                endY: 100,
+                note: 'my line note',
+            }, deps);
+            const callParams = mockSend.mock.calls[0][0].params;
+            expect(callParams.customData).toEqual({ note: 'my line note' });
+        });
+        it('should not include customData when note is not provided', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, elementId: 'el-1' }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await addLine({ x: 0, y: 0, endX: 100, endY: 100 }, deps);
+            const callParams = mockSend.mock.calls[0][0].params;
+            expect(callParams.customData).toBeUndefined();
+        });
+    });
+    // ==================== Response Handling Tests ====================
+    describe('response handling', () => {
+        it('should log success message with element id', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({
+                success: true,
+                elementId: 'el-123',
+            }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await addLine({ x: 0, y: 0, endX: 100, endY: 100 }, deps);
+            expect(deps.log).toHaveBeenCalledWith('Line created (id: el-123)');
+        });
+        it('should error and exit on failure response', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({
+                success: false,
+                error: 'Something went wrong',
+            }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await addLine({ x: 0, y: 0, endX: 100, endY: 100 }, deps);
+            expect(deps.error).toHaveBeenCalledWith('Failed: Something went wrong');
+            expect(deps.exit).toHaveBeenCalledWith(1);
+        });
+        it('should close client after success', async () => {
+            const mockClose = vi.fn();
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, elementId: 'el-1' }));
+            const mockClient = { send: mockSend, close: mockClose };
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await addLine({ x: 0, y: 0, endX: 100, endY: 100 }, 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 addLine({ x: 0, y: 0, endX: 100, endY: 100 }, deps);
+            expect(mockClose).toHaveBeenCalled();
+        });
+    });
+});

package/dist/commands/__tests__/add-polygon.test.d.ts

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

package/dist/commands/__tests__/add-polygon.test.js

@@ -0,0 +1,147 @@
+import { describe, it, expect, vi } from 'vitest';
+import { addPolygon } from '../add-polygon';
+function createMockClient(sendFn) {
+    return {
+        send: sendFn ?? vi.fn(() => Promise.resolve({ success: true, elementId: 'el-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('addPolygon', () => {
+    // ==================== Input Validation Tests ====================
+    describe('input validation', () => {
+        it('should error and exit when points JSON is invalid', async () => {
+            const deps = createMockDeps();
+            await addPolygon({ points: 'not-valid-json' }, deps);
+            expect(deps.error).toHaveBeenCalledWith('Invalid points JSON');
+            expect(deps.exit).toHaveBeenCalledWith(1);
+            // WebSocket should not be called
+            expect(deps.connectToCanvas).not.toHaveBeenCalled();
+        });
+        it('should not connect to WebSocket when JSON parsing fails', async () => {
+            const deps = createMockDeps();
+            await addPolygon({ points: '{invalid' }, deps);
+            expect(deps.connectToCanvas).not.toHaveBeenCalled();
+        });
+    });
+    // ==================== Parameter Assembly Tests ====================
+    describe('parameter assembly', () => {
+        it('should parse and send points correctly', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, elementId: 'el-1' }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            const pointsJson = '[{"x":0,"y":0},{"x":100,"y":0},{"x":50,"y":100}]';
+            await addPolygon({ points: pointsJson }, deps);
+            expect(mockSend).toHaveBeenCalledWith(expect.objectContaining({
+                type: 'addPolygon',
+                id: 'test-id',
+                params: expect.objectContaining({
+                    points: [{ x: 0, y: 0 }, { x: 100, y: 0 }, { x: 50, y: 100 }],
+                }),
+            }));
+        });
+        it('should send correct style params', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, elementId: 'el-1' }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await addPolygon({
+                points: '[{"x":0,"y":0},{"x":100,"y":0}]',
+                strokeColor: '#ff0000',
+                backgroundColor: '#00ff00',
+                strokeWidth: 2,
+                strokeStyle: 'dashed',
+                fillStyle: 'solid',
+            }, deps);
+            const callParams = mockSend.mock.calls[0][0].params;
+            expect(callParams.strokeColor).toBe('#ff0000');
+            expect(callParams.backgroundColor).toBe('#00ff00');
+            expect(callParams.strokeWidth).toBe(2);
+            expect(callParams.strokeStyle).toBe('dashed');
+            expect(callParams.fillStyle).toBe('solid');
+        });
+        it('should set customData with note when note is provided', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, elementId: 'el-1' }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await addPolygon({
+                points: '[{"x":0,"y":0},{"x":100,"y":0}]',
+                note: 'my note',
+            }, deps);
+            const callParams = mockSend.mock.calls[0][0].params;
+            expect(callParams.customData).toEqual({ note: 'my note' });
+        });
+        it('should not include customData when note is not provided', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, elementId: 'el-1' }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await addPolygon({ points: '[{"x":0,"y":0}]' }, deps);
+            const callParams = mockSend.mock.calls[0][0].params;
+            expect(callParams.customData).toBeUndefined();
+        });
+    });
+    // ==================== Response Handling Tests ====================
+    describe('response handling', () => {
+        it('should log success message with element id', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({
+                success: true,
+                elementId: 'el-123',
+            }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await addPolygon({ points: '[{"x":0,"y":0}]' }, deps);
+            expect(deps.log).toHaveBeenCalledWith('Polygon created (id: el-123)');
+        });
+        it('should error and exit on failure response', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({
+                success: false,
+                error: 'Something went wrong',
+            }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await addPolygon({ points: '[{"x":0,"y":0}]' }, deps);
+            expect(deps.error).toHaveBeenCalledWith('Failed: Something went wrong');
+            expect(deps.exit).toHaveBeenCalledWith(1);
+        });
+        it('should close client after success', async () => {
+            const mockClose = vi.fn();
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, elementId: 'el-1' }));
+            const mockClient = { send: mockSend, close: mockClose };
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await addPolygon({ points: '[{"x":0,"y":0}]' }, 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 addPolygon({ points: '[{"x":0,"y":0}]' }, deps);
+            expect(mockClose).toHaveBeenCalled();
+        });
+    });
+});

package/dist/commands/__tests__/add-shape.test.d.ts

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