agentic-canvas 0.6.1 → 0.7.0

package/README.md

@@ -7,7 +7,7 @@
 
 A shared whiteboard for diagrams, drawn by people and agents.
 
-> Status: 0.6.0. The board model, the agent operations, the exports, the CLI, the
+> Status: 0.7.0. The board model, the agent operations, the exports, the CLI, the
 > MCP server, a small Worker API, and live co-editing work. The CLI, the MCP server,
 > and the SDK can join a live room. A remote client calls the Worker API. A small web UI, served by the Worker, is new in 0.4.0.
 > The package exports `agentic-canvas/ui`, a board view you can mount in your own app, new in 0.5.0.
@@ -38,7 +38,7 @@ npx agentic-canvas export demo --out demo.svg
 npx agentic-canvas export demo --format png --out demo.png
 ```
 
-Other commands: `list`, `add`, `connect`, `update`, `move`, `rm`. Run `npx agentic-canvas --help`.
+Other commands: `list`, `add`, `connect`, `update`, `move`, `rm`, `delete` (a whole board). Run `npx agentic-canvas --help`.
 `repair` is for the owner only. It needs `CANVAS_ACTOR=human:<id>`.
 Boards live in `./.agentic-canvas` (or `--dir`, or `CANVAS_DIR`). Every write
 needs an actor in `CANVAS_ACTOR`, as `<kind>:<id>`. The operator sets it. A write
@@ -52,7 +52,7 @@ CANVAS_ACTOR=agent:helper npx agentic-canvas --dir ./boards mcp
 ```
 
 The server speaks MCP on stdio. It has one tool for each CLI command: `create_board`,
-`list_boards`, `read_board`, `add_shape`, `connect`, `update_element`, `move`, `remove`, `draw_flow`, `export_svg`, and
+`delete_board`, `list_boards`, `read_board`, `add_shape`, `connect`, `update_element`, `move`, `remove`, `draw_flow`, `export_svg`, and
 `export_png`. `repair` is not a tool. Only a human operator runs it, from the CLI. The server will not start unless `CANVAS_ACTOR` is set to a valid
 `<kind>:<id>`. That actor stamps every write. No tool takes an actor, author, or kind, so a
 caller cannot choose who it writes as. An error comes back as a tool error with a code.
@@ -105,7 +105,7 @@ try {
 }
 ```
 
-There is one method per route: `me`, `listBoards`, `createBoard`, `readBoard`, `exportSvg`, `addShape`, `addConnector`,
+There is one method per route: `me`, `listBoards`, `createBoard`, `readBoard`, `deleteBoard`, `exportSvg`, `addShape`, `addConnector`,
 `drawFlow`, `update`, `move`, `remove`, `uploadImage`, `getImage`, `state`, and `checkpoint`. Each takes
 `{ signal }` last, so an `AbortSignal` can stop a call. The token sets the actor. A failed call throws
 `CanvasApiError` with the API `code` and the HTTP `status`. A call that gets no reply has code `NETWORK`
@@ -125,12 +125,37 @@ no CI secret is used:
 ```sh
 npm ci && npm run build
 WRANGLER_SEND_METRICS=false CLOUDFLARE_API_TOKEN=... npx wrangler deploy -c wrangler.demo.jsonc
-npx wrangler secret put CANVAS_API_TOKENS -c wrangler.demo.jsonc   # only to set or rotate tokens
+npx wrangler secret put CANVAS_API_TOKENS -c wrangler.demo.jsonc   # only to set or rotate the demo tokens
 ```
 
-`wrangler.demo.jsonc` holds the config. The tokens are a Worker secret and are not in the repo. To run your
+`wrangler.demo.jsonc` holds the config. The demo is a throwaway: it turns on the dev fallback (see "Auth") and
+signs in with a static token list. The tokens are a Worker secret and are not in the repo. To run your
 own copy, create a D1 database and an R2 bucket (both in the EU), put their names and id in a copy of that
-file, and deploy it the same way.
+file, and deploy it the same way. Remove `CANVAS_UNSAFE_STATIC_TOKENS` from your copy unless it is a throwaway.
+
+## Auth
+
+The Worker signs requests in with `agentic-identity` (`agentic-identity/http`). A bearer key (an `api_key` or
+`pat` credential) is a credential in the same Store as the boards (D1). A `session` credential works as a
+bearer key too, and as the `session` cookie for reads. A write or a socket that rides on the cookie gets 401,
+because the Worker lists no allowed origins. A credential names a principal, and the principal's scopes set the role:
+
+- Any scope that covers `canvas:write`, such as `canvas:write`, `canvas:admin`, `*:write`, or `*:admin`, is an editor.
+- Any scope that covers `canvas:read`, such as `canvas:read` or `*:read`, is a viewer. A viewer reads and cannot change a board, over HTTP or in a live room.
+- A principal with neither scope, an unknown, expired, or revoked credential, or a revoked parent in the
+  delegation chain, gets 401.
+
+Make principals and credentials in the database of this Worker with `agentic-identity` (its Worker, or
+`issueCredential` from its SDK). The two must share one D1 database and its schema (`D1_SCHEMA`). A credential
+that lives in another database gets 401 here. The author kind of every write is the kind of the principal.
+A browser sends its credential as the WebSocket sub-protocol `agentic-canvas.bearer.<token in base64url>`.
+
+**Dev fallback.** `CANVAS_API_TOKENS` is a static list of tokens, as JSON: `{ "<token>": { "actor": "ada", "kind": "human", "role": "viewer" } }`.
+It is read only when `CANVAS_UNSAFE_STATIC_TOKENS=1` is set too. Then it adds to the identity credentials: a
+token that is not a credential is looked up in the list. A static token reaches every board and cannot be
+revoked without a new deploy. It ignores revocation in the Store: a static grant named `ada` still writes as
+`ada` after the identity credential of `ada` is revoked. Use it for local work and throwaway demos only. If `CANVAS_API_TOKENS` is set
+and the switch is not, every API request gets 503 `NOT_CONFIGURED`, so a deploy never trusts the list by accident.
 
 ## UI
 
@@ -146,12 +171,13 @@ npm ci
 npm run build                      # writes the UI to ui-dist/
 cat > .dev.vars <<'EOF2'
 CANVAS_REGION=unknown
+CANVAS_UNSAFE_STATIC_TOKENS=1
 CANVAS_API_TOKENS={"ada-token-0123456789-0123456789-0123456789":{"actor":"ada","kind":"human"}}
 EOF2
 WRANGLER_SEND_METRICS=false npx wrangler dev
 ```
 
-Open the address that wrangler prints and paste the token. A token has 32 characters or more. Its
+`CANVAS_UNSAFE_STATIC_TOKENS=1` turns on the dev fallback: see "Auth". Open the address that wrangler prints and paste the token. A static token has 32 characters or more. Its
 grant sets the name, the kind (a person or an agent), and the role. A `viewer` token reads and
 cannot change a board. The token stays in the tab's session storage.
 
@@ -239,11 +265,11 @@ at the same time keep the last write. The board list shows the first 100 boards.
 - A CLI over a local file store. Several processes can write at once.
 - An MCP server (stdio) over the same service as the CLI.
 - A Worker (`agentic-canvas/worker`) under `/api/v1/canvas`. Boards live in D1 and images in R2
-  (EU jurisdiction), through the shared `Store` and `Blobs` ports. Set `CANVAS_API_TOKENS`
-  (a JSON map of token to `{ actor, kind }`, tokens of 32 characters or more) and `CANVAS_REGION`.
-  Routes: `POST /boards`, `GET /boards/:id`, `GET /boards/:id/svg`, `POST /boards/:id/shapes`,
+  (EU jurisdiction), through the shared `Store` and `Blobs` ports. Set `CANVAS_REGION`. Callers sign in with
+  `agentic-identity` credentials (see "Auth" below). `CANVAS_API_TOKENS` is a dev fallback only.
+  Routes: `POST /boards`, `GET /boards/:id`, `DELETE /boards/:id`, `GET /boards/:id/svg`, `POST /boards/:id/shapes`,
   `/connectors`, `/flow`, `/move`, `GET /boards`, `PATCH /boards/:id/elements/:element`, `DELETE /boards/:id/elements/:element`, `POST /images`,
-  `GET /images/:id`. An image is stored under the SHA-256 of its bytes, and the reply gives
+  `GET /images/:id`. An editor may delete a board. The Worker also erases its live room. An image is stored under the SHA-256 of its bytes, and the reply gives
   the `blob:` ref for a shape. A busy database or bucket answers 503: try again.
 - Live rooms (`agentic-canvas/live-worker`, on `agentic-realtime`). One Durable Object holds one
   board. A token may carry `"role": "viewer"`: a viewer reads and cannot write. `GET /boards/:id/ws`
@@ -350,9 +376,8 @@ The stylesheet is a separate export, `agentic-canvas/ui.css`. Load `agentic-desi
 
 ## Limits
 
-- Canvas takes principal kinds, regions, and the Store and Blobs ports from `agentic-identity` 0.5.
-  It does not use the sharing API yet. Its editor and viewer tokens are a separate table in
-  `CANVAS_API_TOKENS`. It has no board delete or erase. When it adopts sharing, grants are keyed
+- Canvas takes principal kinds, regions, and the Store and Blobs ports from `agentic-identity` 0.6.
+  It does not use the sharing API yet: every principal with `canvas:write` reaches every board. When it adopts sharing, grants are keyed
   on kind and id, and a delete calls `deleteResource`.
 - A board holds at most 10,000 elements. A flow holds at most 500 nodes and 2,000
   edges.

package/dist/{chunk-VFJJGXTK.js → chunk-3QW4UF2R.js}

@@ -8,7 +8,7 @@ import {
 
 // src/version.ts
 import { createRequire } from "module";
-var VERSION = true ? "0.6.1" : readPackageVersion();
+var VERSION = true ? "0.7.0" : readPackageVersion();
 
 // src/brand.ts
 var BRAND = {
@@ -104,6 +104,11 @@ function createMcpServer(service, actor) {
     { description: "Read a board as data: nodes, edges, groups, text, and who made what.", inputSchema: { board }, annotations: read },
     tool(async (a) => json(await service.read(a.board)))
   );
+  server.registerTool(
+    "delete_board",
+    { description: "Delete a whole board for good. It cannot be undone.", inputSchema: { board }, annotations: { destructiveHint: true } },
+    tool(async (a) => json(await service.delete(a.board)))
+  );
   server.registerTool(
     "add_shape",
     {

package/dist/{chunk-PH67TSYW.js → chunk-EH7WCMK6.js}

@@ -1,13 +1,13 @@
 import {
   CanvasService,
   MAX_LIVE_BYTES
-} from "./chunk-66FFQMHI.js";
+} from "./chunk-GPSOLW2Y.js";
 import {
   CanvasError
 } from "./chunk-ZSPZMGHG.js";
 
 // src/worker.ts
-import { hasScope, parsePrincipal, parseRegion } from "agentic-identity";
+import { createStoreAuth, hasScope, parsePrincipal, parseRegion } from "agentic-identity";
 import { createD1Store, createR2Blobs, D1_SCHEMA } from "agentic-identity/cloudflare";
 import { acceptWebSocketProtocol, principalFromWebSocketRequest } from "agentic-identity/http";
 
@@ -1902,6 +1902,9 @@ function remember(id, mark) {
   if (saved.size > 500) saved.clear();
   saved.set(id, mark);
 }
+function forget(id) {
+  saved.delete(id);
+}
 async function pull(live, service, id, force = false) {
   const { updates, compactions } = await live.meta(id);
   const mark = `${updates}:${compactions}`;
@@ -1979,8 +1982,41 @@ function tokenAuth(env) {
     }
   };
 }
-async function authenticate(request, env) {
-  const found = await principalFromWebSocketRequest(request, tokenAuth(env), { protocol: WS_PROTOCOL });
+var staticTokensOn = (env) => env.CANVAS_UNSAFE_STATIC_TOKENS === "1";
+function workerAuth(env, store) {
+  const auths = [];
+  if (store) auths.push(createStoreAuth(store));
+  if (staticTokensOn(env)) auths.push(tokenAuth(env));
+  let failure;
+  const auth = {
+    async authenticate(request) {
+      for (const auth2 of auths) {
+        let found;
+        try {
+          found = await auth2.authenticate(request);
+        } catch (error) {
+          failure = error;
+          return null;
+        }
+        if (!found) continue;
+        let step;
+        try {
+          step = parsePrincipal({ kind: found.kind, id: found.principalId });
+        } catch {
+          return null;
+        }
+        if (step.kind === SEEDER.kind && step.id === SEEDER.id) return null;
+        return found;
+      }
+      return null;
+    }
+  };
+  return { auth, failure: () => failure };
+}
+async function authenticate(request, env, store) {
+  const { auth, failure } = workerAuth(env, store);
+  const found = await principalFromWebSocketRequest(request, auth, { protocol: WS_PROTOCOL, scope: "canvas:read" });
+  if (failure() !== void 0) throw failure();
   if (found instanceof Response) return null;
   return { actor: { kind: found.kind, id: found.principalId }, role: hasScope(found.scopes, "canvas:write") ? "editor" : "viewer" };
 }
@@ -2061,13 +2097,15 @@ function createApp(options = {}) {
       return fail("NOT_CONFIGURED", 'set CANVAS_REGION to "eu", "us", or "unknown"', 503);
     }
     if (!c.env.DB || !c.env.IMAGES) return fail("NOT_CONFIGURED", "bind DB (D1) and IMAGES (R2)", 503);
-    const who = await authenticate(c.req.raw, c.env);
+    if (c.env.CANVAS_API_TOKENS && !staticTokensOn(c.env)) return fail("NOT_CONFIGURED", "CANVAS_API_TOKENS is a dev fallback. Set CANVAS_UNSAFE_STATIC_TOKENS=1 to use it, or remove it and issue agentic-identity credentials", 503);
+    await ready(c.env.DB);
+    const store = createD1Store(c.env.DB, { region });
+    const who = await authenticate(c.req.raw, c.env, store);
     if (!who) return fail("UNAUTHORIZED", "send a valid bearer token", 401);
     if (who.role === "viewer" && c.req.method !== "GET") return fail("FORBIDDEN", "this token is a viewer; it cannot change a board", 403);
     c.set("actor", who.actor);
     c.set("role", who.role);
-    await ready(c.env.DB);
-    c.set("service", new CanvasService(createD1Store(c.env.DB, { region })));
+    c.set("service", new CanvasService(store));
     c.set("blobs", createR2Blobs(c.env.IMAGES, { region, urlBase: new URL(c.req.url).origin, urlSecret: `${crypto.randomUUID()}${crypto.randomUUID()}` }));
     await next();
   });
@@ -2116,6 +2154,19 @@ function createApp(options = {}) {
     return c.json(await c.var.service.create(c.var.actor, { id, title }), 201);
   });
   api.get("/boards/:id", async (c) => c.json(await c.var.service.read(c.req.param("id"))));
+  api.delete("/boards/:id", async (c) => {
+    const id = c.req.param("id");
+    await c.var.service.assertExists(id);
+    const live = options.live?.(c.env);
+    if (live) await live.erase(id);
+    const deleted = await c.var.service.delete(id);
+    if (live) {
+      await live.erase(id);
+      forget(id);
+    }
+    console.log(JSON.stringify({ level: "info", op: "delete-board", actorKind: c.var.actor.kind }));
+    return c.json(deleted);
+  });
   api.get("/boards/:id/svg", async (c) => new Response(await c.var.service.exportSvg(c.req.param("id")), { headers: { "content-type": "image/svg+xml", "x-content-type-options": "nosniff", "content-security-policy": "default-src 'none'; style-src 'unsafe-inline'; img-src data:" } }));
   api.post("/boards/:id/shapes", async (c) => c.json(await c.var.service.add(c.req.param("id"), await jsonBody(c), c.var.actor), 201));
   api.post("/boards/:id/connectors", async (c) => c.json(await c.var.service.connect(c.req.param("id"), await jsonBody(c), c.var.actor), 201));

package/dist/{chunk-66FFQMHI.js → chunk-GPSOLW2Y.js}

@@ -65,6 +65,15 @@ var CanvasService = class {
       }
     });
   }
+  /** Delete a board and everything on it. Throws NOT_FOUND unless the board exists. The Worker erases the live room too. */
+  async delete(id) {
+    boardKey(id);
+    return this.store.transaction(async (tx) => {
+      if (!await tx.get(COLLECTION, id)) throw new CanvasError("NOT_FOUND", `no board "${id}"`);
+      await tx.delete(COLLECTION, id);
+      return { deleted: id };
+    });
+  }
   /** Throws NOT_FOUND unless the board exists. A live room opens only for a board that exists. */
   async assertExists(id) {
     boardKey(id);

package/dist/cli.js

@@ -5,13 +5,13 @@ import {
   operatorActor,
   runMcp,
   svgToPng
-} from "./chunk-VFJJGXTK.js";
+} from "./chunk-3QW4UF2R.js";
 import {
   openLocalStore
 } from "./chunk-UKST5A57.js";
 import {
   CanvasService
-} from "./chunk-66FFQMHI.js";
+} from "./chunk-GPSOLW2Y.js";
 import "./chunk-NWQED42L.js";
 import {
   CanvasError
@@ -36,6 +36,7 @@ Commands:
   connect <board> <from> <to> [--text <t>] Join two shapes with an arrow.
   update <board> <element> [--x --y --w --h --text --fill --stroke]  Change fields of an element. Resize with --w and --h.
   move <board> <element> --dx <n> --dy <n> Move an element or a group.
+  delete <board>                           Delete a whole board for good.
   rm <board> <element>                     Delete an element.
   flow <board> --text <t> | --file <p>     Draw a flowchart from text ("A -> B: label"). Use --file - for stdin.
   export <board> [--format svg|png] [--out <path>]  Print SVG, or write PNG to --out.
@@ -141,6 +142,10 @@ async function run(argv) {
     case "move":
       need(2, "<board> <element> --dx <n> --dy <n>");
       return print(await service.move(board, rest[0], num(v.dx) ?? Number.NaN, num(v.dy) ?? Number.NaN, actor()));
+    case "delete":
+      need(1, "<board>");
+      actor();
+      return print(await service.delete(board));
     case "rm":
       need(2, "<board> <element>");
       return print(await service.remove(board, rest[0]));

package/dist/client.d.ts

@@ -81,6 +81,10 @@ interface CanvasClient {
     readBoard(id: string, options?: CallOptions): Promise<BoardData & {
         id: string;
     }>;
+    /** Delete a board for good, with its live room. Returns the id. */
+    deleteBoard(id: string, options?: CallOptions): Promise<{
+        deleted: string;
+    }>;
     /** The board as an SVG document. */
     exportSvg(id: string, options?: CallOptions): Promise<string>;
     addShape(id: string, shape: ShapeInput, options?: CallOptions): Promise<Shape>;

package/dist/client.js

@@ -58,6 +58,7 @@ function createClient(options) {
     listBoards: (o) => json("GET", "/boards", void 0, o),
     createBoard: (input = {}, o) => json("POST", "/boards", input, o),
     readBoard: (id, o) => json("GET", `/boards/${seg(id)}`, void 0, o),
+    deleteBoard: (id, o) => json("DELETE", `/boards/${seg(id)}`, void 0, o),
     exportSvg: async (id, o) => (await send("GET", `/boards/${seg(id)}/svg`, {}, o)).text(),
     addShape: (id, shape, o) => json("POST", `/boards/${seg(id)}/shapes`, shape, o),
     addConnector: (id, connector, o) => json("POST", `/boards/${seg(id)}/connectors`, connector, o),

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { B as Board, P as Principal } from './read-CeWoSAAy.js';
 export { a as BoardData, b as CanvasElement, e as CanvasError, C as Connector, f as EdgeData, d as Endpoint, E as ErrorCode, G as Group, M as MAX_ELEMENTS, g as MAX_TEXT, N as NodeData, h as SHAPE_TYPES, S as Shape, c as ShapeType, p as principalSchema, r as readBoard } from './read-CeWoSAAy.js';
-import { B as BoardAccess } from './service-Ckz-3qhK.js';
-export { C as CanvasService, D as DrawOptions, F as FlowEdge, a as FlowGraph, b as FlowNode, M as MAX_FLOW_EDGES, c as MAX_FLOW_NODES, P as Placement, d as drawFlow, l as layoutFlow, p as parseFlow } from './service-Ckz-3qhK.js';
+import { B as BoardAccess } from './service-D9WzMLH1.js';
+export { C as CanvasService, D as DrawOptions, F as FlowEdge, a as FlowGraph, b as FlowNode, M as MAX_FLOW_EDGES, c as MAX_FLOW_NODES, P as Placement, d as drawFlow, l as layoutFlow, p as parseFlow } from './service-D9WzMLH1.js';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 export { FileStoreOptions, createFileStore, openLocalStore } from './store-file.js';
 export { PRINCIPAL_KINDS, PrincipalKind, isMachineMade } from 'agentic-identity';

package/dist/index.js

@@ -6,14 +6,14 @@ import {
   operatorActor,
   runMcp,
   svgToPng
-} from "./chunk-VFJJGXTK.js";
+} from "./chunk-3QW4UF2R.js";
 import {
   createFileStore,
   openLocalStore
 } from "./chunk-UKST5A57.js";
 import {
   CanvasService
-} from "./chunk-66FFQMHI.js";
+} from "./chunk-GPSOLW2Y.js";
 import "./chunk-NWQED42L.js";
 import {
   Board,

package/dist/live-worker.d.ts

@@ -8,7 +8,7 @@ import 'hono';
 import './read-CeWoSAAy.js';
 import 'yjs';
 import 'zod';
-import './service-Ckz-3qhK.js';
+import './service-D9WzMLH1.js';
 
 type Namespace = Parameters<typeof createDurableObjectRealtime>[0];
 interface LiveEnv extends WorkerEnv {

package/dist/live-worker.js

@@ -1,7 +1,7 @@
 import {
   createApp
-} from "./chunk-PH67TSYW.js";
-import "./chunk-66FFQMHI.js";
+} from "./chunk-EH7WCMK6.js";
+import "./chunk-GPSOLW2Y.js";
 import "./chunk-NWQED42L.js";
 import {
   CanvasError

package/dist/live.d.ts

@@ -1,6 +1,6 @@
 import { B as Board, P as Principal, a as BoardData, S as Shape, C as Connector, b as CanvasElement } from './read-CeWoSAAy.js';
 import { Peer } from 'agentic-realtime/client';
-import { B as BoardAccess, D as DrawOptions } from './service-Ckz-3qhK.js';
+import { B as BoardAccess, D as DrawOptions } from './service-D9WzMLH1.js';
 import 'yjs';
 import 'agentic-identity';
 import 'zod';
@@ -83,6 +83,9 @@ declare class LiveService implements BoardAccess {
         id: string;
         title: string;
     }[]>;
+    delete(id: string): Promise<{
+        deleted: string;
+    }>;
     read(id: string): Promise<BoardData & {
         id: string;
     }>;

package/dist/live.js

@@ -145,6 +145,13 @@ var LiveService = class {
     if (!Array.isArray(boards) || !boards.every((b) => typeof b?.id === "string" && typeof b?.title === "string")) throw new CanvasError("INVALID", "the server sent a board list this client does not know");
     return boards;
   }
+  async delete(id) {
+    const response = await call(this.options.server, this.options.token, `/boards/${encodeURIComponent(id)}`, { method: "DELETE" });
+    if (!response.ok) throw await refusal(response, "the server refused the request");
+    const { deleted } = await json(response);
+    if (deleted !== id) throw new CanvasError("INVALID", "the server sent a result this client does not know");
+    return { deleted };
+  }
   async read(id) {
     return this.use(id, async (live) => ({ id, ...readBoard(live.board) }));
   }

package/dist/{service-Ckz-3qhK.d.ts → service-D9WzMLH1.d.ts}

@@ -68,6 +68,10 @@ declare class CanvasService {
         id: string;
         title: string;
     }[]>;
+    /** Delete a board and everything on it. Throws NOT_FOUND unless the board exists. The Worker erases the live room too. */
+    delete(id: string): Promise<{
+        deleted: 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 & {
@@ -123,6 +127,6 @@ declare class CanvasService {
     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">;
+type BoardAccess = Pick<CanvasService, "create" | "list" | "read" | "delete" | "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/ui.css

@@ -15,9 +15,9 @@
   .shape { fill: var(--ad-color-surface-raised); stroke: var(--ad-color-border-strong); stroke-width: 1.5; }
   .shape.text { fill: transparent; stroke: none; }
   .shape.frame, .shape.image { fill: none; stroke-dasharray: 6 4; pointer-events: visiblePainted; }
-  .shape.sticky { fill: #ffe08a; stroke: #7a5b00; }
+  .shape.sticky { fill: var(--ad-color-warning-subtle); stroke: var(--ad-color-warning); }
   .label { fill: var(--ad-color-text); pointer-events: none; }
-  .sticky-label { fill: #1b1b1b; }
+  .sticky-label { fill: var(--ad-color-warning-text); }
   .edge { stroke: var(--ad-color-text-muted); stroke-width: 2; fill: none; pointer-events: none; }
   .hit { stroke: transparent; stroke-width: 14; }
   .arrowhead { fill: var(--ad-color-text-muted); }

package/dist/worker.d.ts

@@ -1,9 +1,9 @@
-import { Blobs } from 'agentic-identity';
+import { Store, Blobs } from 'agentic-identity';
 import { Realtime } from 'agentic-realtime';
 import { D1Like, R2Like } from 'agentic-identity/cloudflare';
 import { Hono } from 'hono';
 import { P as Principal } from './read-CeWoSAAy.js';
-import { C as CanvasService } from './service-Ckz-3qhK.js';
+import { C as CanvasService } from './service-D9WzMLH1.js';
 import 'yjs';
 import 'zod';
 
@@ -11,10 +11,16 @@ interface WorkerEnv {
     DB: D1Like;
     IMAGES: R2Like;
     /**
+     * Dev fallback. Set it to "1" to let `CANVAS_API_TOKENS` sign requests in. Without it, `CANVAS_API_TOKENS` is not read,
+     * and a request that sets it gets 503, so a deploy never trusts a static list by accident. Never set it in production.
+     */
+    CANVAS_UNSAFE_STATIC_TOKENS?: string;
+    /**
+     * Dev fallback, read only when `CANVAS_UNSAFE_STATIC_TOKENS` is "1". It is tried after the identity credentials.
      * JSON: `{ "<token>": { "actor": "ada", "kind": "human", "role": "viewer" } }`. A token has 32 characters or more.
      * A grant needs an actor id and a kind. A token with a missing or bad part gets 401.
      * The role is "editor" (the default) or "viewer". A viewer reads and cannot write, over HTTP or in a live room.
-     * Without this setting, every request gets 401. Every token reaches every board.
+     * Every token reaches every board, and a token cannot be revoked without a new deploy.
      */
     CANVAS_API_TOKENS?: string;
     /**
@@ -42,8 +48,13 @@ interface AppOptions {
 }
 /** A browser cannot set a header on a WebSocket. It offers the sub-protocols `agentic-canvas` and `agentic-canvas.bearer.<token in base64url>`. */
 declare const WS_PROTOCOL = "agentic-canvas";
-/** 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): Promise<{
+/**
+ * The principal and role for a request, or null. A credential issued by agentic-identity (a bearer key or an access token in the
+ * store) signs in. Its scopes set the role: `canvas:write` is an editor, `canvas:read` a viewer, and none is denied.
+ * The static list signs in only with `CANVAS_UNSAFE_STATIC_TOKENS=1`. The kind is never defaulted: a principal without a valid kind gets null.
+ * Without `store` only the static list is read.
+ */
+declare function authenticate(request: Request, env: WorkerEnv, store?: Store): Promise<{
     actor: Principal;
     role: Role;
 } | null>;

package/dist/worker.js

@@ -4,8 +4,8 @@ import {
   createApp,
   sniffImage,
   worker_default
-} from "./chunk-PH67TSYW.js";
-import "./chunk-66FFQMHI.js";
+} from "./chunk-EH7WCMK6.js";
+import "./chunk-GPSOLW2Y.js";
 import "./chunk-NWQED42L.js";
 import "./chunk-ZSPZMGHG.js";
 import "./chunk-JOBTIAFJ.js";

package/llms.txt

@@ -6,11 +6,11 @@ Keywords: whiteboard,canvas,diagrams,drawing,collaboration,agents,mcp,cli.
 
 - SDK: import { Board, drawFlow, readBoard, toSvg } from "agentic-canvas".
 - Exports: the README "Exports" section lists every name of each entry point: agentic-canvas, /client, /file-store, /live, /worker and /live-worker.
-- 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.
+- CLI: agentic-canvas new|list|read|add|connect|update|move|rm|delete|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: an agentic-identity credential (scope canvas:write or canvas:read). A static CANVAS_API_TOKENS list works only with CANVAS_UNSAFE_STATIC_TOKENS=1 (dev).
 - 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.
+- SDK: import { createClient, CanvasApiError } from "agentic-canvas/client". It calls the Worker API with fetch. Methods: me, listBoards, createBoard, readBoard, deleteBoard, exportSvg, addShape, addConnector, drawFlow, update, move, remove, uploadImage, getImage, state, checkpoint. A failure throws CanvasApiError with `code` and `status`. No retries.
 - UI: import { mount } from "agentic-canvas/ui"; import "agentic-canvas/ui.css" (with agentic-design/styles.css). mount(element, { boardId, client, principal: { kind, name, role }, readOnly?, room?: { baseUrl, token } }) renders the board and returns { update(options), unmount() }. BoardEditor is the same as a React component. React 19 is a peer dependency.
 
 ## Docs

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-canvas",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "description": "A shared whiteboard for diagrams, drawn by people and agents.",
   "keywords": [
     "whiteboard",
@@ -82,7 +82,7 @@
     "@modelcontextprotocol/sdk": "^1.12.0",
     "agentic-design": "^0.2.0",
     "agentic-identity": "^0.6.0",
-    "agentic-realtime": "^0.3.0",
+    "agentic-realtime": "^0.4.2",
     "yjs": "^13.6.0",
     "zod": "^3.25.0"
   },