@agent-canvas/cli 0.8.0 → 0.9.0

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

@@ -0,0 +1,26 @@
+export interface AddImageOptions {
+    file: string;
+    x: number;
+    y: number;
+    width?: number;
+    height?: number;
+    note?: string;
+}
+export interface ImageClient {
+    send: <T>(request: {
+        type: string;
+        id: string;
+        params?: unknown;
+    }) => Promise<T>;
+    close: () => void;
+}
+export interface AddImageDeps {
+    readFile: (path: string) => Buffer;
+    connectToCanvas: () => Promise<ImageClient>;
+    generateId: () => string;
+    log: (msg: string) => void;
+    error: (msg: string) => void;
+    exit: (code: number) => never | void;
+}
+export declare const defaultDeps: AddImageDeps;
+export declare function addImage(options: AddImageOptions, deps?: AddImageDeps): Promise<void>;

package/dist/commands/add-image.js

@@ -0,0 +1,66 @@
+import { readFileSync } from 'node:fs';
+import { connectToCanvas, generateId } from '../lib/ws-client.js';
+import { getMimeType, generateFileId, MAX_IMAGE_SIZE } from '../lib/image-utils.js';
+export const defaultDeps = {
+    readFile: readFileSync,
+    connectToCanvas,
+    generateId,
+    log: console.log,
+    error: console.error,
+    exit: process.exit,
+};
+export async function addImage(options, deps = defaultDeps) {
+    // 1. Validate file extension
+    const mimeType = getMimeType(options.file);
+    if (!mimeType) {
+        deps.error('Unsupported image format. Supported: PNG, JPEG, GIF, SVG, WebP');
+        deps.exit(1);
+        return;
+    }
+    // 2. Read file
+    let buffer;
+    try {
+        buffer = deps.readFile(options.file);
+    }
+    catch {
+        deps.error(`Failed to read file: ${options.file}`);
+        deps.exit(1);
+        return;
+    }
+    // 3. Check file size
+    if (buffer.length > MAX_IMAGE_SIZE) {
+        const sizeMB = (buffer.length / 1024 / 1024).toFixed(2);
+        deps.error(`Image too large: ${sizeMB}MB (max: 2MB)`);
+        deps.exit(1);
+        return;
+    }
+    // 4. Convert to base64 and generate fileId
+    const base64 = buffer.toString('base64');
+    const dataUrl = `data:${mimeType};base64,${base64}`;
+    const fileId = generateFileId(buffer);
+    // 5. Send WebSocket message
+    const client = await deps.connectToCanvas();
+    const result = await client.send({
+        type: 'addImage',
+        id: deps.generateId(),
+        params: {
+            x: options.x,
+            y: options.y,
+            width: options.width,
+            height: options.height,
+            dataUrl,
+            mimeType,
+            fileId,
+            customData: options.note ? { note: options.note } : undefined,
+        },
+    });
+    // 6. Handle response
+    if (result.success) {
+        deps.log(`Image added (id: ${result.elementId}, fileId: ${result.fileId} x=${result.x} y=${result.y} w=${result.width} h=${result.height})`);
+    }
+    else {
+        deps.error(`Failed: ${result.error}`);
+        deps.exit(1);
+    }
+    client.close();
+}

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

@@ -0,0 +1,27 @@
+export interface AddLineOptions {
+    x: number;
+    y: number;
+    endX: number;
+    endY: number;
+    strokeColor?: string;
+    strokeWidth?: number;
+    strokeStyle?: 'solid' | 'dashed' | 'dotted';
+    note?: string;
+}
+export interface LineClient {
+    send: <T>(request: {
+        type: string;
+        id: string;
+        params?: unknown;
+    }) => Promise<T>;
+    close: () => void;
+}
+export interface AddLineDeps {
+    connectToCanvas: () => Promise<LineClient>;
+    generateId: () => string;
+    log: (msg: string) => void;
+    error: (msg: string) => void;
+    exit: (code: number) => never | void;
+}
+export declare const defaultDeps: AddLineDeps;
+export declare function addLine(options: AddLineOptions, deps?: AddLineDeps): Promise<void>;

package/dist/commands/add-line.js

@@ -0,0 +1,35 @@
+import { connectToCanvas, generateId } from '../lib/ws-client.js';
+export const defaultDeps = {
+    connectToCanvas,
+    generateId,
+    log: console.log,
+    error: console.error,
+    exit: process.exit,
+};
+export async function addLine(options, deps = defaultDeps) {
+    const client = await deps.connectToCanvas();
+    // Build params
+    const params = {
+        x: options.x,
+        y: options.y,
+        endX: options.endX,
+        endY: options.endY,
+        strokeColor: options.strokeColor,
+        strokeWidth: options.strokeWidth,
+        strokeStyle: options.strokeStyle,
+        customData: options.note ? { note: options.note } : undefined,
+    };
+    const result = await client.send({
+        type: 'addLine',
+        id: deps.generateId(),
+        params,
+    });
+    if (result.success) {
+        deps.log(`Line created (id: ${result.elementId})`);
+    }
+    else {
+        deps.error(`Failed: ${result.error}`);
+        deps.exit(1);
+    }
+    client.close();
+}

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

@@ -0,0 +1,26 @@
+export interface AddPolygonOptions {
+    points: string;
+    strokeColor?: string;
+    backgroundColor?: string;
+    strokeWidth?: number;
+    strokeStyle?: 'solid' | 'dashed' | 'dotted';
+    fillStyle?: 'hachure' | 'cross-hatch' | 'solid' | 'zigzag';
+    note?: string;
+}
+export interface PolygonClient {
+    send: <T>(request: {
+        type: string;
+        id: string;
+        params?: unknown;
+    }) => Promise<T>;
+    close: () => void;
+}
+export interface AddPolygonDeps {
+    connectToCanvas: () => Promise<PolygonClient>;
+    generateId: () => string;
+    log: (msg: string) => void;
+    error: (msg: string) => void;
+    exit: (code: number) => never | void;
+}
+export declare const defaultDeps: AddPolygonDeps;
+export declare function addPolygon(options: AddPolygonOptions, deps?: AddPolygonDeps): Promise<void>;

package/dist/commands/add-polygon.js

@@ -0,0 +1,44 @@
+import { connectToCanvas, generateId } from '../lib/ws-client.js';
+export const defaultDeps = {
+    connectToCanvas,
+    generateId,
+    log: console.log,
+    error: console.error,
+    exit: process.exit,
+};
+export async function addPolygon(options, deps = defaultDeps) {
+    // Parse and validate points JSON
+    let points;
+    try {
+        points = JSON.parse(options.points);
+    }
+    catch {
+        deps.error('Invalid points JSON');
+        deps.exit(1);
+        return;
+    }
+    const client = await deps.connectToCanvas();
+    // Build params
+    const params = {
+        points,
+        strokeColor: options.strokeColor,
+        backgroundColor: options.backgroundColor,
+        strokeWidth: options.strokeWidth,
+        strokeStyle: options.strokeStyle,
+        fillStyle: options.fillStyle,
+        customData: options.note ? { note: options.note } : undefined,
+    };
+    const result = await client.send({
+        type: 'addPolygon',
+        id: deps.generateId(),
+        params,
+    });
+    if (result.success) {
+        deps.log(`Polygon created (id: ${result.elementId})`);
+    }
+    else {
+        deps.error(`Failed: ${result.error}`);
+        deps.exit(1);
+    }
+    client.close();
+}

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

@@ -0,0 +1,32 @@
+export interface AddShapeOptions {
+    type: 'rectangle' | 'ellipse' | 'diamond';
+    x: number;
+    y: number;
+    width?: number;
+    height?: number;
+    strokeColor?: string;
+    backgroundColor?: string;
+    strokeWidth?: number;
+    strokeStyle?: 'solid' | 'dashed' | 'dotted';
+    fillStyle?: 'hachure' | 'cross-hatch' | 'solid' | 'zigzag';
+    label?: string;
+    labelFontSize?: number;
+    note?: string;
+}
+export interface ShapeClient {
+    send: <T>(request: {
+        type: string;
+        id: string;
+        params?: unknown;
+    }) => Promise<T>;
+    close: () => void;
+}
+export interface AddShapeDeps {
+    connectToCanvas: () => Promise<ShapeClient>;
+    generateId: () => string;
+    log: (msg: string) => void;
+    error: (msg: string) => void;
+    exit: (code: number) => never | void;
+}
+export declare const defaultDeps: AddShapeDeps;
+export declare function addShape(options: AddShapeOptions, deps?: AddShapeDeps): Promise<void>;

package/dist/commands/add-shape.js

@@ -0,0 +1,41 @@
+import { connectToCanvas, generateId } from '../lib/ws-client.js';
+export const defaultDeps = {
+    connectToCanvas,
+    generateId,
+    log: console.log,
+    error: console.error,
+    exit: process.exit,
+};
+export async function addShape(options, deps = defaultDeps) {
+    const client = await deps.connectToCanvas();
+    // Build params
+    const params = {
+        type: options.type,
+        x: options.x,
+        y: options.y,
+        width: options.width,
+        height: options.height,
+        strokeColor: options.strokeColor,
+        backgroundColor: options.backgroundColor,
+        strokeWidth: options.strokeWidth,
+        strokeStyle: options.strokeStyle,
+        fillStyle: options.fillStyle,
+        customData: options.note ? { note: options.note } : undefined,
+    };
+    if (options.label) {
+        params.label = { text: options.label, fontSize: options.labelFontSize };
+    }
+    const result = await client.send({
+        type: 'addShape',
+        id: deps.generateId(),
+        params,
+    });
+    if (result.success) {
+        deps.log(`Shape created (id: ${result.elementId} x=${result.x} y=${result.y} w=${result.width} h=${result.height})`);
+    }
+    else {
+        deps.error(`Failed: ${result.error}`);
+        deps.exit(1);
+    }
+    client.close();
+}

package/dist/commands/add-text.d.ts

@@ -0,0 +1,28 @@
+import type { TextAnchor } from '../lib/protocol.js';
+export interface AddTextOptions {
+    text: string;
+    x: number;
+    y: number;
+    fontSize?: number;
+    textAlign?: 'left' | 'center' | 'right';
+    anchor?: TextAnchor;
+    strokeColor?: string;
+    note?: string;
+}
+export interface TextClient {
+    send: <T>(request: {
+        type: string;
+        id: string;
+        params?: unknown;
+    }) => Promise<T>;
+    close: () => void;
+}
+export interface AddTextDeps {
+    connectToCanvas: () => Promise<TextClient>;
+    generateId: () => string;
+    log: (msg: string) => void;
+    error: (msg: string) => void;
+    exit: (code: number) => never | void;
+}
+export declare const defaultDeps: AddTextDeps;
+export declare function addText(options: AddTextOptions, deps?: AddTextDeps): Promise<void>;

package/dist/commands/add-text.js

@@ -0,0 +1,35 @@
+import { connectToCanvas, generateId } from '../lib/ws-client.js';
+export const defaultDeps = {
+    connectToCanvas,
+    generateId,
+    log: console.log,
+    error: console.error,
+    exit: process.exit,
+};
+export async function addText(options, deps = defaultDeps) {
+    const client = await deps.connectToCanvas();
+    // Build params
+    const params = {
+        text: options.text,
+        x: options.x,
+        y: options.y,
+        fontSize: options.fontSize,
+        textAlign: options.textAlign,
+        anchor: options.anchor,
+        strokeColor: options.strokeColor,
+        customData: options.note ? { note: options.note } : undefined,
+    };
+    const result = await client.send({
+        type: 'addText',
+        id: deps.generateId(),
+        params,
+    });
+    if (result.success) {
+        deps.log(`Text created (id: ${result.elementId}, x: ${result.x}, y: ${result.y}, ${result.width}x${result.height})`);
+    }
+    else {
+        deps.error(`Failed: ${result.error}`);
+        deps.exit(1);
+    }
+    client.close();
+}

package/dist/commands/clear.d.ts

@@ -0,0 +1,17 @@
+export interface ClearClient {
+    send: <T>(request: {
+        type: string;
+        id: string;
+        params?: unknown;
+    }) => Promise<T>;
+    close: () => void;
+}
+export interface ClearDeps {
+    connectToCanvas: () => Promise<ClearClient>;
+    generateId: () => string;
+    log: (msg: string) => void;
+    error: (msg: string) => void;
+    exit: (code: number) => never | void;
+}
+export declare const defaultDeps: ClearDeps;
+export declare function clear(deps?: ClearDeps): Promise<void>;

package/dist/commands/clear.js

@@ -0,0 +1,23 @@
+import { connectToCanvas, generateId } from '../lib/ws-client.js';
+export const defaultDeps = {
+    connectToCanvas,
+    generateId,
+    log: console.log,
+    error: console.error,
+    exit: process.exit,
+};
+export async function clear(deps = defaultDeps) {
+    const client = await deps.connectToCanvas();
+    const result = await client.send({
+        type: 'clearCanvas',
+        id: deps.generateId(),
+    });
+    if (result.success) {
+        deps.log('Canvas cleared');
+    }
+    else {
+        deps.error(`Failed: ${result.error}`);
+        deps.exit(1);
+    }
+    client.close();
+}

package/dist/commands/delete-elements.d.ts

@@ -0,0 +1,20 @@
+export interface DeleteElementsOptions {
+    elementIds: string;
+}
+export interface DeleteElementsClient {
+    send: <T>(request: {
+        type: string;
+        id: string;
+        params?: unknown;
+    }) => Promise<T>;
+    close: () => void;
+}
+export interface DeleteElementsDeps {
+    connectToCanvas: () => Promise<DeleteElementsClient>;
+    generateId: () => string;
+    log: (msg: string) => void;
+    error: (msg: string) => void;
+    exit: (code: number) => never | void;
+}
+export declare const defaultDeps: DeleteElementsDeps;
+export declare function deleteElements(options: DeleteElementsOptions, deps?: DeleteElementsDeps): Promise<void>;

package/dist/commands/delete-elements.js

@@ -0,0 +1,26 @@
+import { connectToCanvas, generateId } from '../lib/ws-client.js';
+export const defaultDeps = {
+    connectToCanvas,
+    generateId,
+    log: console.log,
+    error: console.error,
+    exit: process.exit,
+};
+export async function deleteElements(options, deps = defaultDeps) {
+    const client = await deps.connectToCanvas();
+    // Parse comma-separated element IDs
+    const elementIds = options.elementIds.split(',').map((s) => s.trim());
+    const result = await client.send({
+        type: 'deleteElements',
+        id: deps.generateId(),
+        params: { elementIds },
+    });
+    if (result.success) {
+        deps.log(`Deleted ${result.deletedCount} element(s)`);
+    }
+    else {
+        deps.error(`Failed: ${result.error}`);
+        deps.exit(1);
+    }
+    client.close();
+}

package/dist/commands/export.d.ts

@@ -0,0 +1,26 @@
+export interface ExportOptions {
+    output?: string;
+    background?: boolean;
+    dark?: boolean;
+    embedScene?: boolean;
+    scale?: number;
+}
+export interface ExportClient {
+    send: <T>(request: {
+        type: string;
+        id: string;
+        params?: unknown;
+    }) => Promise<T>;
+    close: () => void;
+}
+export interface ExportDeps {
+    connectToCanvas: () => Promise<ExportClient>;
+    generateId: () => string;
+    writeFile: (path: string, data: Buffer) => void;
+    now: () => number;
+    log: (msg: string) => void;
+    error: (msg: string) => void;
+    exit: (code: number) => never | void;
+}
+export declare const defaultDeps: ExportDeps;
+export declare function exportImage(options: ExportOptions, deps?: ExportDeps): Promise<void>;

package/dist/commands/export.js

@@ -0,0 +1,45 @@
+import { connectToCanvas, generateId } from '../lib/ws-client.js';
+import { writeFileSync } from 'node:fs';
+export const defaultDeps = {
+    connectToCanvas,
+    generateId,
+    writeFile: writeFileSync,
+    now: Date.now,
+    log: console.log,
+    error: console.error,
+    exit: process.exit,
+};
+export async function exportImage(options, deps = defaultDeps) {
+    // Validate scale
+    const scale = options.scale ?? 1;
+    if (![1, 2, 3].includes(scale)) {
+        deps.error('Scale must be 1, 2, or 3');
+        deps.exit(1);
+        return;
+    }
+    const client = await deps.connectToCanvas();
+    const result = await client.send({
+        type: 'exportImage',
+        id: deps.generateId(),
+        params: {
+            background: options.background ?? true,
+            dark: options.dark ?? false,
+            embedScene: options.embedScene ?? false,
+            scale: scale,
+        },
+    });
+    if (result.success && result.dataUrl) {
+        // Extract base64 data from data URL
+        const base64Data = result.dataUrl.replace(/^data:image\/png;base64,/, '');
+        const buffer = Buffer.from(base64Data, 'base64');
+        // Generate output path if not specified
+        const outputPath = options.output ?? `canvas-${deps.now()}.png`;
+        deps.writeFile(outputPath, buffer);
+        deps.log(`Exported to ${outputPath}`);
+    }
+    else {
+        deps.error(`Failed: ${result.error}`);
+        deps.exit(1);
+    }
+    client.close();
+}

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

@@ -0,0 +1,20 @@
+export interface GroupElementsOptions {
+    elementIds: string[];
+}
+export interface GroupClient {
+    send: <T>(request: {
+        type: string;
+        id: string;
+        params?: unknown;
+    }) => Promise<T>;
+    close: () => void;
+}
+export interface GroupElementsDeps {
+    connectToCanvas: () => Promise<GroupClient>;
+    generateId: () => string;
+    log: (msg: string) => void;
+    error: (msg: string) => void;
+    exit: (code: number) => never | void;
+}
+export declare const defaultDeps: GroupElementsDeps;
+export declare function groupElements(options: GroupElementsOptions, deps?: GroupElementsDeps): Promise<void>;

package/dist/commands/group-elements.js

@@ -0,0 +1,28 @@
+import { connectToCanvas, generateId } from '../lib/ws-client.js';
+export const defaultDeps = {
+    connectToCanvas,
+    generateId,
+    log: console.log,
+    error: console.error,
+    exit: process.exit,
+};
+export async function groupElements(options, deps = defaultDeps) {
+    const client = await deps.connectToCanvas();
+    // Build params
+    const params = {
+        elementIds: options.elementIds,
+    };
+    const result = await client.send({
+        type: 'groupElements',
+        id: deps.generateId(),
+        params,
+    });
+    if (result.success) {
+        deps.log(`Group created (id: ${result.groupId})`);
+    }
+    else {
+        deps.error(`Failed: ${result.error}`);
+        deps.exit(1);
+    }
+    client.close();
+}

package/dist/commands/list.d.ts

@@ -0,0 +1,23 @@
+import type { CanvasMetadata } from '../lib/protocol.js';
+export interface ListClient {
+    send: <T>(request: {
+        type: string;
+        id: string;
+    }) => Promise<T>;
+    close: () => void;
+}
+export interface ListDeps {
+    connectToCanvas: () => Promise<ListClient>;
+    generateId: () => string;
+    log: (msg: string) => void;
+    error: (msg: string) => void;
+    exit: (code: number) => never | void;
+}
+export declare const defaultDeps: ListDeps;
+export interface ListResult {
+    activeCanvasId?: string;
+    agentActiveCanvasId?: string;
+    canvases: CanvasMetadata[];
+}
+export declare function formatCanvasList(result: ListResult): string[];
+export declare function list(deps?: ListDeps): Promise<void>;

package/dist/commands/list.js

@@ -0,0 +1,50 @@
+import { connectToCanvas, generateId } from '../lib/ws-client.js';
+export const defaultDeps = {
+    connectToCanvas,
+    generateId,
+    log: console.log,
+    error: console.error,
+    exit: process.exit,
+};
+export function formatCanvasList(result) {
+    const lines = ['Canvases: ([U]=User [A]=Agent)'];
+    for (const canvas of result.canvases) {
+        const isUser = canvas.id === result.activeCanvasId;
+        const isAgent = canvas.id === result.agentActiveCanvasId;
+        let marker = '    ';
+        if (isUser && isAgent) {
+            marker = '[UA]';
+        }
+        else if (isUser) {
+            marker = '[U] ';
+        }
+        else if (isAgent) {
+            marker = '[A] ';
+        }
+        const date = new Date(canvas.updatedAt).toLocaleString();
+        lines.push(`${marker} ${canvas.name} (updated: ${date})`);
+    }
+    return lines;
+}
+export async function list(deps = defaultDeps) {
+    const client = await deps.connectToCanvas();
+    const result = await client.send({
+        type: 'listCanvases',
+        id: deps.generateId(),
+    });
+    if (result.success && result.canvases) {
+        const lines = formatCanvasList({
+            activeCanvasId: result.activeCanvasId,
+            agentActiveCanvasId: result.agentActiveCanvasId,
+            canvases: result.canvases,
+        });
+        for (const line of lines) {
+            deps.log(line);
+        }
+    }
+    else {
+        deps.error(`Failed: ${result.error}`);
+        deps.exit(1);
+    }
+    client.close();
+}

package/dist/commands/load.d.ts

@@ -0,0 +1,20 @@
+export interface LoadClient {
+    send: <T>(request: {
+        type: string;
+        id: string;
+        params?: unknown;
+    }) => Promise<T>;
+    close: () => void;
+}
+export interface LoadDeps {
+    connectToCanvas: () => Promise<LoadClient>;
+    generateId: () => string;
+    readFile: (path: string, encoding: 'utf-8') => string;
+    existsSync: (path: string) => boolean;
+    resolvePath: (path: string) => string;
+    log: (msg: string) => void;
+    error: (msg: string) => void;
+    exit: (code: number) => never | void;
+}
+export declare const defaultDeps: LoadDeps;
+export declare function load(filepath: string | undefined, deps?: LoadDeps): Promise<void>;