agentic-canvas 0.2.0 → 0.4.0

package/dist/service-Cim7TWnJ.d.ts

@@ -0,0 +1,128 @@
+import { S as ShapeType, c as Board, P as Principal, B as BoardData, a as Shape, C as Connector, d as CanvasElement } from './read-Bdg1uiFC.js';
+import { Store } from 'agentic-identity';
+
+declare const MAX_FLOW_NODES = 500;
+declare const MAX_FLOW_EDGES = 2000;
+interface FlowNode {
+    id: string;
+    text: string;
+    shape: Extract<ShapeType, "rect" | "ellipse" | "diamond">;
+}
+interface FlowEdge {
+    from: string;
+    to: string;
+    text: string;
+}
+interface FlowGraph {
+    direction: "TB" | "LR";
+    nodes: FlowNode[];
+    edges: FlowEdge[];
+}
+declare function parseFlow(source: string): FlowGraph;
+interface Placement {
+    id: string;
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+/** Layered layout. The top-left of the result is (0, 0). The layout breaks cycles and handles self-loops. */
+declare function layoutFlow(graph: FlowGraph): Placement[];
+interface DrawOptions {
+    /**
+     * Put in front of every id. Default: a new random prefix for each call, so two agents that draw at
+     * the same time never write the same id. A prefix you pass is used as given, and it makes ids
+     * repeatable. Up to 16 of A-Z, a-z, 0-9, _ and -.
+     */
+    idPrefix?: string;
+    /** Top-left of the drawing. Default: below the shapes already on the board. */
+    origin?: {
+        x: number;
+        y: number;
+    };
+}
+/** Draw a flow on the board. All or nothing: on any error the board stays as it was. */
+declare function drawFlow(board: Board, source: string, actor: Principal, options?: DrawOptions): {
+    nodes: string[];
+    edges: string[];
+};
+
+/** Who sent the Yjs item with this id, if the room knows. */
+type Writer = (item: {
+    client: number;
+    clock: number;
+}) => Principal | undefined;
+/** One place for every board operation. The CLI, the MCP server, and the Worker call it. */
+declare class CanvasService {
+    private readonly store;
+    constructor(store: Store);
+    create(actor: Principal, options?: {
+        id?: string;
+        title?: string;
+    }): Promise<{
+        id: string;
+        title: string;
+    }>;
+    /** The first 100 boards (the store sorts by id), with titles. A board whose stored bytes are damaged shows an empty title: it stays in the list so a person can find and repair it. */
+    list(): Promise<{
+        id: string;
+        title: string;
+    }[]>;
+    /** Throws NOT_FOUND unless the board exists. A live room opens only for a board that exists. */
+    assertExists(id: string): Promise<void>;
+    read(id: string): Promise<BoardData & {
+        id: string;
+    }>;
+    /** Run `change` on the board and save it, all inside one transaction. */
+    change<R>(id: string, change: (board: Board) => R): Promise<R>;
+    add(id: string, shape: unknown, actor: Principal): Promise<Shape>;
+    connect(id: string, connector: unknown, actor: Principal): Promise<Connector>;
+    /** Change fields of one shape or connector: position, size, text, colors. */
+    update(id: string, elementId: string, patch: unknown, actor: Principal): Promise<CanvasElement>;
+    move(id: string, elementId: string, dx: number, dy: number, actor: Principal): Promise<{
+        moved: string[];
+    }>;
+    remove(id: string, elementId: string): Promise<{
+        removed: string[];
+    }>;
+    flow(id: string, text: string, actor: Principal, options?: DrawOptions): Promise<{
+        nodes: string[];
+        edges: string[];
+    }>;
+    exportSvg(id: string): Promise<string>;
+    /** The stored board as a Yjs update. A client applies it to a room to seed it: the room does not read it. */
+    state(id: string): Promise<Uint8Array>;
+    /** What the stored board has that a room with state `room` lacks, as a Yjs update, or null when the room has all of it. */
+    missingFrom(id: string, room?: Uint8Array): Promise<Uint8Array | null>;
+    /**
+     * `writer` names who sent each Yjs item, from the room's log. It sets the stamps where it knows (see `Board.restamp`).
+     * Merge a live room's state into the stored board. `authors` are the principals the room saw send updates. A null
+     * `actor` trusts only them: the Worker saves a room that way, with nobody present to vouch.
+     * An element stamped by anyone else is deleted, and a changed author is put back (see `Board.restamp`),
+     * so a client that writes raw Yjs cannot put another author on its work. Broken entries are repaired and
+     * a board past the element cap is refused. Returns the ids the checks fixed.
+     *
+     * Limits: the save corrects the stored board only. The room keeps what its clients wrote, so a client that sees
+     * a non-empty `fixed` must join again, or its later edits are lost at the next save. The room remembers its
+     * authors for good, so an OLD item that the log does not name (a seeded one, or a range the log dropped) keeps the older rule: its
+     * stamp may name anyone who once sent an update in that room. A NEW item with no writer is deleted or undone.
+     * The log records who adds an item, not who deletes a key: a deleted optional key is credited to the writer of the editor
+     * stamp written in the same save, or undone if there is none.
+     * A client that adds a root type of its own makes every later save of that room fail, because the room keeps it.
+     */
+    checkpoint(id: string, update: Uint8Array, actor: Principal | null, authors?: Principal[], writer?: Writer): Promise<{
+        elements: number;
+        fixed: string[];
+    }>;
+    /** Owner only. Repair a board and delete the named elements. Only a human actor may call it. */
+    repair(id: string, actor: Principal, drop?: string[]): Promise<{
+        id: string;
+        fixed: string[];
+        elements: number;
+    }>;
+    private load;
+}
+/** What the CLI and the MCP server need. `CanvasService` runs it on a store, and `LiveService` runs it in a live room. */
+type BoardAccess = Pick<CanvasService, "create" | "list" | "read" | "update" | "add" | "connect" | "move" | "remove" | "flow" | "exportSvg">;
+
+export { type BoardAccess as B, CanvasService as C, type DrawOptions as D, type FlowEdge as F, MAX_FLOW_EDGES as M, type Placement as P, type FlowGraph as a, type FlowNode as b, MAX_FLOW_NODES as c, drawFlow as d, layoutFlow as l, parseFlow as p };

package/dist/worker.d.ts

@@ -2,7 +2,8 @@ import { Blobs } from 'agentic-identity';
 import { Realtime } from 'agentic-realtime';
 import { D1Like, R2Like } from 'agentic-identity/cloudflare';
 import { Hono } from 'hono';
-import { P as Principal, c as CanvasService } from './service-CJTe-uBI.js';
+import { P as Principal } from './read-Bdg1uiFC.js';
+import { C as CanvasService } from './service-Cim7TWnJ.js';
 import 'yjs';
 import 'zod';
 
@@ -39,6 +40,8 @@ interface AppOptions {
     /** Makes the live-room server from the Worker bindings. Without it, the ws route answers 404. */
     live?: (env: WorkerEnv) => Realtime;
 }
+/** A browser cannot set a header on a WebSocket. It offers the token as the sub-protocols `agentic-canvas.bearer` and the token in base64url. */
+declare const WS_PROTOCOL = "agentic-canvas.bearer";
 /** The principal and role for a bearer token, or null. The kind is never defaulted: a grant without a valid kind gets null. */
 declare function authenticate(request: Request, env: WorkerEnv): {
     actor: Principal;
@@ -51,4 +54,4 @@ declare const _default: {
     fetch: (request: Request, env: WorkerEnv, ctx: unknown) => Response | Promise<Response>;
 };
 
-export { type AppOptions, type Role, type WorkerEnv, authenticate, createApp, _default as default, sniffImage };
+export { type AppOptions, type Role, WS_PROTOCOL, type WorkerEnv, authenticate, createApp, _default as default, sniffImage };

package/dist/worker.js

@@ -1,13 +1,15 @@
 import {
+  WS_PROTOCOL,
   authenticate,
   createApp,
   sniffImage,
   worker_default
-} from "./chunk-V477KSZQ.js";
-import "./chunk-W7NRP3EX.js";
-import "./chunk-GGQPE65T.js";
+} from "./chunk-HPUYT5TC.js";
+import "./chunk-J52RPFRP.js";
+import "./chunk-JZA525X5.js";
 import "./chunk-NWQED42L.js";
 export {
+  WS_PROTOCOL,
   authenticate,
   createApp,
   worker_default as default,

package/llms.txt

@@ -5,9 +5,11 @@ A shared whiteboard for diagrams, drawn by people and agents.
 Keywords: whiteboard,canvas,diagrams,drawing,collaboration,agents,mcp,cli.
 
 - SDK: import { Board, drawFlow, readBoard, toSvg } from "agentic-canvas".
-- CLI: agentic-canvas new|read|add|connect|move|rm|flow|export.
+- CLI: agentic-canvas new|list|read|add|connect|update|move|rm|flow|export.
+- UI: the Worker serves a web UI at its root (run `npm run build`, then `wrangler dev`). A person signs in with a bearer token.
 - Live: set CANVAS_SERVER and CANVAS_TOKEN, and the CLI and `agentic-canvas mcp` edit the board in its live room.
 - SDK: import { LiveBoard, LiveService } from "agentic-canvas/live".
+- SDK: import { createClient, CanvasApiError } from "agentic-canvas/client". It calls the Worker API with fetch. Methods: me, listBoards, createBoard, readBoard, exportSvg, addShape, addConnector, drawFlow, update, move, remove, uploadImage, getImage, state, checkpoint. A failure throws CanvasApiError with `code` and `status`. No retries.
 
 ## Docs
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-canvas",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "A shared whiteboard for diagrams, drawn by people and agents.",
   "keywords": [
     "whiteboard",
@@ -51,6 +51,10 @@
       "types": "./dist/live-worker.d.ts",
       "import": "./dist/live-worker.js"
     },
+    "./client": {
+      "types": "./dist/client.d.ts",
+      "import": "./dist/client.js"
+    },
     "./file-store": {
       "types": "./dist/store-file.d.ts",
       "import": "./dist/store-file.js"
@@ -60,17 +64,19 @@
     "agentic-canvas": "./dist/cli.js"
   },
   "scripts": {
-    "build": "tsup",
-    "typecheck": "tsc --noEmit",
+    "build": "tsup && vite build",
+    "typecheck": "tsc --noEmit && tsc --noEmit -p ui",
     "test": "vitest run",
     "clean": "rm -rf dist",
-    "ci:local": "npm run build && npm run typecheck && npm test"
+    "ci:local": "npm run build && npm run typecheck && npm test && npm run test:e2e",
+    "deploy:demo": "wrangler deploy -c wrangler.demo.jsonc",
+    "test:e2e": "playwright test -c e2e/playwright.config.ts"
   },
   "dependencies": {
     "@dagrejs/dagre": "^3.1.3",
     "@modelcontextprotocol/sdk": "^1.12.0",
-    "agentic-identity": "^0.4.0",
-    "agentic-realtime": "^0.1.0",
+    "agentic-identity": "^0.5.0",
+    "agentic-realtime": "^0.3.0",
     "yjs": "^13.6.0",
     "zod": "^3.25.0"
   },
@@ -83,12 +89,21 @@
     }
   },
   "devDependencies": {
+    "@axe-core/playwright": "^4.14.0",
+    "@playwright/test": "^1.64.1",
     "@types/node": "^22.0.0",
+    "@types/react": "^19.3.0",
+    "@types/react-dom": "^19.3.0",
+    "@vitejs/plugin-react": "^5.2.0",
+    "agentic-design": "^0.2.0",
     "hono": "^4.13.14",
     "miniflare": "^4.20260730.0",
     "playwright-core": "^1.64.1",
+    "react": "^19.3.1",
+    "react-dom": "^19.3.1",
     "tsup": "^8.0.0",
     "typescript": "^5.6.0",
+    "vite": "^7.3.7",
     "vitest": "^3.0.0",
     "wrangler": "^4.155.0"
   }