@agent-canvas/cli 0.8.0 → 0.9.0

package/dist/commands/load.js

@@ -0,0 +1,67 @@
+import { resolve } from 'node:path';
+import { readFileSync, existsSync } from 'node:fs';
+import { connectToCanvas, generateId } from '../lib/ws-client.js';
+export const defaultDeps = {
+    connectToCanvas,
+    generateId,
+    readFile: readFileSync,
+    existsSync,
+    resolvePath: resolve,
+    log: console.log,
+    error: console.error,
+    exit: process.exit,
+};
+export async function load(filepath, deps = defaultDeps) {
+    // Validate filepath is provided
+    if (!filepath) {
+        deps.error('Usage: agent-canvas load <filepath>');
+        deps.exit(1);
+        return;
+    }
+    // Resolve to absolute path
+    const absolutePath = deps.resolvePath(filepath);
+    // Check file exists
+    if (!deps.existsSync(absolutePath)) {
+        deps.error(`File not found: ${absolutePath}`);
+        deps.exit(1);
+        return;
+    }
+    // Read and parse file
+    let content;
+    let data;
+    try {
+        content = deps.readFile(absolutePath, 'utf-8');
+    }
+    catch (err) {
+        deps.error(`Failed to read file: ${err instanceof Error ? err.message : err}`);
+        deps.exit(1);
+        return;
+    }
+    try {
+        data = JSON.parse(content);
+    }
+    catch (err) {
+        deps.error(`Failed to parse file: ${err instanceof Error ? err.message : err}`);
+        deps.exit(1);
+        return;
+    }
+    // Connect and send loadScene message
+    const client = await deps.connectToCanvas();
+    const result = await client.send({
+        type: 'loadScene',
+        id: deps.generateId(),
+        params: {
+            elements: data.elements || [],
+            appState: data.appState,
+            files: data.files,
+        },
+    });
+    if (result.success) {
+        deps.log(`Loaded ${result.elementCount} elements from ${filepath}`);
+    }
+    else {
+        deps.error(`Failed to load file: ${result.error}`);
+        deps.exit(1);
+    }
+    client.close();
+}

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

@@ -0,0 +1,22 @@
+export interface MoveElementsOptions {
+    elementIds: string;
+    deltaX: number;
+    deltaY: number;
+}
+export interface MoveElementsClient {
+    send: <T>(request: {
+        type: string;
+        id: string;
+        params?: unknown;
+    }) => Promise<T>;
+    close: () => void;
+}
+export interface MoveElementsDeps {
+    connectToCanvas: () => Promise<MoveElementsClient>;
+    generateId: () => string;
+    log: (msg: string) => void;
+    error: (msg: string) => void;
+    exit: (code: number) => never | void;
+}
+export declare const defaultDeps: MoveElementsDeps;
+export declare function moveElements(options: MoveElementsOptions, deps?: MoveElementsDeps): Promise<void>;

package/dist/commands/move-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 moveElements(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: 'moveElements',
+        id: deps.generateId(),
+        params: { elementIds, deltaX: options.deltaX, deltaY: options.deltaY },
+    });
+    if (result.success) {
+        deps.log(`Moved ${result.movedCount} element(s)`);
+    }
+    else {
+        deps.error(`Failed: ${result.error}`);
+        deps.exit(1);
+    }
+    client.close();
+}

package/dist/commands/new-canvas.d.ts

@@ -0,0 +1,21 @@
+export interface NewCanvasOptions {
+    name: string;
+    use?: boolean;
+}
+export interface NewCanvasClient {
+    send: <T>(request: {
+        type: string;
+        id: string;
+        params?: unknown;
+    }) => Promise<T>;
+    close: () => void;
+}
+export interface NewCanvasDeps {
+    connectToCanvas: () => Promise<NewCanvasClient>;
+    generateId: () => string;
+    log: (msg: string) => void;
+    error: (msg: string) => void;
+    exit: (code: number) => never | void;
+}
+export declare const defaultDeps: NewCanvasDeps;
+export declare function newCanvas(options: NewCanvasOptions, deps?: NewCanvasDeps): Promise<void>;

package/dist/commands/new-canvas.js

@@ -0,0 +1,29 @@
+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 newCanvas(options, deps = defaultDeps) {
+    const client = await deps.connectToCanvas();
+    const params = {
+        name: options.name,
+        switchTo: options.use ?? false,
+    };
+    const result = await client.send({
+        type: 'createCanvas',
+        id: deps.generateId(),
+        params,
+    });
+    if (result.success && result.canvas) {
+        const switched = options.use ? ' and switched to it' : '';
+        deps.log(`Canvas "${result.canvas.name}" created${switched}`);
+    }
+    else {
+        deps.error(`Failed: ${result.error}`);
+        deps.exit(1);
+    }
+    client.close();
+}

package/dist/commands/read.d.ts

@@ -0,0 +1,23 @@
+import { encode as toToon } from '@toon-format/toon';
+export interface ReadClient {
+    send: <T>(request: {
+        type: string;
+        id: string;
+        params?: unknown;
+    }) => Promise<T>;
+    close: () => void;
+}
+export interface ReadDeps {
+    connectToCanvas: () => Promise<ReadClient>;
+    generateId: () => string;
+    toToon: typeof toToon;
+    log: (msg: string) => void;
+    error: (msg: string) => void;
+    exit: (code: number) => never | void;
+}
+export declare const defaultDeps: ReadDeps;
+export interface ReadOptions {
+    json?: boolean;
+    withStyle?: boolean;
+}
+export declare function read(options: ReadOptions, deps?: ReadDeps): Promise<void>;

package/dist/commands/read.js

@@ -0,0 +1,49 @@
+import { encode as toToon } from '@toon-format/toon';
+import { connectToCanvas, generateId } from '../lib/ws-client.js';
+import { convertElementsToToon } from '../lib/toon-converter.js';
+export const defaultDeps = {
+    connectToCanvas,
+    generateId,
+    toToon,
+    log: console.log,
+    error: console.error,
+    exit: process.exit,
+};
+export async function read(options, deps = defaultDeps) {
+    const client = await deps.connectToCanvas();
+    if (options.json) {
+        // Return raw Excalidraw scene data
+        const result = await client.send({
+            type: 'saveScene',
+            id: deps.generateId(),
+        });
+        if (result.success && result.data) {
+            deps.log(JSON.stringify(result.data, null, 2));
+        }
+        else {
+            deps.error(`Failed: ${result.error}`);
+            deps.exit(1);
+        }
+        client.close();
+        return;
+    }
+    // Default: TOON format
+    const result = await client.send({
+        type: 'readScene',
+        id: deps.generateId(),
+    });
+    if (result.success && result.elements) {
+        const toonData = convertElementsToToon(result.elements, options.withStyle ?? false);
+        deps.log(deps.toToon(toonData));
+        // Output selected elements
+        const selectedIds = result.selectedElementIds ?? [];
+        if (selectedIds.length > 0) {
+            deps.log(`\nSelected: ${selectedIds.join(', ')}`);
+        }
+    }
+    else {
+        deps.error(`Failed: ${result.error}`);
+        deps.exit(1);
+    }
+    client.close();
+}

package/dist/commands/rename-canvas.d.ts

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

package/dist/commands/rename-canvas.js

@@ -0,0 +1,27 @@
+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 renameCanvas(options, deps = defaultDeps) {
+    const client = await deps.connectToCanvas();
+    const params = {
+        newName: options.newName,
+    };
+    const result = await client.send({
+        type: 'renameCanvas',
+        id: deps.generateId(),
+        params,
+    });
+    if (result.success && result.canvas) {
+        deps.log(`Canvas renamed to "${result.canvas.name}"`);
+    }
+    else {
+        deps.error(`Failed: ${result.error}`);
+        deps.exit(1);
+    }
+    client.close();
+}

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

@@ -0,0 +1,24 @@
+export interface ResizeElementsOptions {
+    elementIds: string[];
+    top?: number;
+    bottom?: number;
+    left?: number;
+    right?: number;
+}
+export interface ResizeClient {
+    send: <T>(request: {
+        type: string;
+        id: string;
+        params?: unknown;
+    }) => Promise<T>;
+    close: () => void;
+}
+export interface ResizeElementsDeps {
+    connectToCanvas: () => Promise<ResizeClient>;
+    generateId: () => string;
+    log: (msg: string) => void;
+    error: (msg: string) => void;
+    exit: (code: number) => never | void;
+}
+export declare const defaultDeps: ResizeElementsDeps;
+export declare function resizeElements(options: ResizeElementsOptions, deps?: ResizeElementsDeps): Promise<void>;

package/dist/commands/resize-elements.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 resizeElements(options, deps = defaultDeps) {
+    const top = options.top ?? 0;
+    const bottom = options.bottom ?? 0;
+    const left = options.left ?? 0;
+    const right = options.right ?? 0;
+    if (top === 0 && bottom === 0 && left === 0 && right === 0) {
+        deps.error('At least one of --top, --bottom, --left, --right must be specified');
+        deps.exit(1);
+        return;
+    }
+    const client = await deps.connectToCanvas();
+    // Build params
+    const params = {
+        elementIds: options.elementIds,
+        top,
+        bottom,
+        left,
+        right,
+    };
+    const result = await client.send({
+        type: 'resizeElements',
+        id: deps.generateId(),
+        params,
+    });
+    if (result.success) {
+        deps.log(`Resized ${result.resizedCount} element(s)`);
+    }
+    else {
+        deps.error(`Failed: ${result.error}`);
+        deps.exit(1);
+    }
+    client.close();
+}

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

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

package/dist/commands/rotate-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 rotateElements(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: 'rotateElements',
+        id: deps.generateId(),
+        params: { elementIds, angle: options.angle },
+    });
+    if (result.success) {
+        deps.log(`Rotated ${result.rotatedCount} element(s)`);
+    }
+    else {
+        deps.error(`Failed: ${result.error}`);
+        deps.exit(1);
+    }
+    client.close();
+}

package/dist/commands/save.d.ts

@@ -0,0 +1,18 @@
+export interface SaveClient {
+    send: <T>(request: {
+        type: string;
+        id: string;
+        params?: unknown;
+    }) => Promise<T>;
+    close: () => void;
+}
+export interface SaveDeps {
+    connectToCanvas: () => Promise<SaveClient>;
+    generateId: () => string;
+    writeFile: (path: string, data: string) => void;
+    log: (msg: string) => void;
+    error: (msg: string) => void;
+    exit: (code: number) => never | void;
+}
+export declare const defaultDeps: SaveDeps;
+export declare function save(filepath: string, deps?: SaveDeps): Promise<void>;

package/dist/commands/save.js

@@ -0,0 +1,27 @@
+import { connectToCanvas, generateId } from '../lib/ws-client.js';
+import { writeFileSync } from 'node:fs';
+export const defaultDeps = {
+    connectToCanvas,
+    generateId,
+    writeFile: writeFileSync,
+    log: console.log,
+    error: console.error,
+    exit: process.exit,
+};
+export async function save(filepath, deps = defaultDeps) {
+    const client = await deps.connectToCanvas();
+    const result = await client.send({
+        type: 'saveScene',
+        id: deps.generateId(),
+    });
+    if (result.success && result.data) {
+        const outputPath = filepath.endsWith('.excalidraw') ? filepath : `${filepath}.excalidraw`;
+        deps.writeFile(outputPath, JSON.stringify(result.data, null, 2));
+        deps.log(`Saved to ${outputPath}`);
+    }
+    else {
+        deps.error(`Failed: ${result.error}`);
+        deps.exit(1);
+    }
+    client.close();
+}

package/dist/commands/start.d.ts

@@ -1,2 +1 @@
-export declare function loadFile(filePath?: string): Promise<void>;
 export declare function start(): Promise<void>;

package/dist/commands/start.js

@@ -1,8 +1,5 @@
 import { exec } from 'child_process';
-import { resolve } from 'path';
-import { readFileSync, existsSync } from 'fs';
 import { promisify } from 'util';
-import { connectToCanvas, generateId } from '../lib/ws-client.js';
 import { startServer, isBrowserServerRunning, isBrowserConnected } from '../server/index.js';
 const execAsync = promisify(exec);
 async function openBrowser(url) {
@@ -22,44 +19,6 @@ async function openBrowser(url) {
         console.log(`Please open ${url} in your browser`);
     }
 }
-export async function loadFile(filePath) {
-    if (!filePath) {
-        console.error('Usage: agent-canvas load <filepath>');
-        process.exit(1);
-    }
-    const absolutePath = resolve(filePath);
-    if (!existsSync(absolutePath)) {
-        console.error(`File not found: ${absolutePath}`);
-        process.exit(1);
-    }
-    console.log(`Loading file: ${absolutePath}`);
-    try {
-        const content = readFileSync(absolutePath, 'utf-8');
-        const data = JSON.parse(content);
-        const client = await connectToCanvas();
-        const result = await client.send({
-            type: 'loadScene',
-            id: generateId(),
-            params: {
-                elements: data.elements || [],
-                appState: data.appState,
-                files: data.files,
-            },
-        });
-        if (result.success) {
-            console.log(`Loaded ${result.elementCount} elements from ${filePath}`);
-        }
-        else {
-            console.error(`Failed to load file: ${result.error}`);
-            process.exit(1);
-        }
-        client.close();
-    }
-    catch (err) {
-        console.error(`Failed to parse file: ${err instanceof Error ? err.message : err}`);
-        process.exit(1);
-    }
-}
 export async function start() {
     const running = await isBrowserServerRunning();
     if (!running) {

package/dist/commands/ungroup-element.d.ts

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

package/dist/commands/ungroup-element.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 ungroupElement(options, deps = defaultDeps) {
+    const client = await deps.connectToCanvas();
+    // Build params
+    const params = {
+        elementId: options.elementId,
+    };
+    const result = await client.send({
+        type: 'ungroupElement',
+        id: deps.generateId(),
+        params,
+    });
+    if (result.success) {
+        deps.log('Element ungrouped');
+    }
+    else {
+        deps.error(`Failed: ${result.error}`);
+        deps.exit(1);
+    }
+    client.close();
+}

package/dist/commands/use-canvas.d.ts

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

package/dist/commands/use-canvas.js

@@ -0,0 +1,27 @@
+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 useCanvas(options, deps = defaultDeps) {
+    const client = await deps.connectToCanvas();
+    const params = {
+        name: options.name,
+    };
+    const result = await client.send({
+        type: 'switchCanvas',
+        id: deps.generateId(),
+        params,
+    });
+    if (result.success && result.canvas) {
+        deps.log(`Switched to canvas "${result.canvas.name}"`);
+    }
+    else {
+        deps.error(`Failed: ${result.error}`);
+        deps.exit(1);
+    }
+    client.close();
+}