agentic-canvas 0.8.0 → 0.10.0

package/README.md

@@ -7,7 +7,7 @@
 
 A shared whiteboard for diagrams, drawn by people and agents.
 
-> Status: 0.8.0. The board model, the agent operations, the exports, the CLI, the
+> Status: 0.10.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`, `delete` (a whole board). Run `npx agentic-canvas --help`.
+Other commands: `list`, `add`, `connect`, `update`, `move`, `rm`, `delete` (a whole board), and `access`, `grant`, `revoke`, `invite` (sharing, server only). 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,8 +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`,
-`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
+`delete_board`, `list_boards`, `read_board`, `add_shape`, `connect`, `update_element`, `move`, `remove`, `draw_flow`, `export_svg`, `export_png`, and the sharing tools `list_access`, `grant_access`, `revoke_access`, and `create_invite`. `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.
 
@@ -184,6 +183,33 @@ HTTP routes, under `/api/v1/canvas`. Each needs a bearer token, except the link
 | `DELETE /boards/:id/links/:link` | Owner. Revoke a link of this board. |
 | `GET /shared/:id` and `GET /shared/:id/svg` | No bearer token needed. Send the link token in `x-link-token`. Read only. |
 
+### Share from the client, the CLI, and MCP
+
+Sharing lives on the server, so these need a Worker and a token with `canvas:admin` that owns the board.
+A local store has no owners: the CLI commands exit 2 there, and the MCP tools fail with `UNAVAILABLE`.
+
+```ts
+const canvas = createClient({ baseUrl, token });
+await canvas.grant("demo", { subjectKind: "agent", subjectId: "helper", role: "editor" });
+await canvas.invite("demo", { role: "viewer", email: "ada@example.com", expiresInMs: 86_400_000 });
+const { grants, invites } = await canvas.access("demo"); // an invite shows no email
+await canvas.revoke("demo", { subjectKind: "agent", subjectId: "helper" });
+```
+
+```sh
+export CANVAS_SERVER=https://canvas.example.com CANVAS_TOKEN=...
+npx agentic-canvas access demo
+npx agentic-canvas grant demo agent:helper --role editor
+npx agentic-canvas invite demo --role viewer --handle helper --expires-in-ms 86400000
+npx agentic-canvas revoke demo agent:helper
+```
+
+With `CANVAS_SERVER` set, `npx agentic-canvas mcp` serves `list_access`, `grant_access`, `revoke_access`, and `create_invite` as well.
+Each prints or returns the server's JSON. A refusal has the server's code, such as `NOT_FOUND`, `FORBIDDEN`, or `INVALID`.
+Share links and invite acceptance stay on the HTTP API.
+
+A live MCP server with an admin token can share boards: an agent that holds it can grant `owner` and revoke grants. Give an agent a token with `canvas:write` only, unless it must share.
+
 The static dev fallback holds no board roles. Its tokens reach every board and cannot share.
 
 ## UI
@@ -337,7 +363,7 @@ Every name that each entry point exports is listed here. A name marked (type) ex
 | `PRINCIPAL_KINDS`, `PrincipalKind` (type), `Principal` (type), `principalSchema`, `isMachineMade` | The principal kinds, the schema of a principal, and the rule that marks machine-made kinds. `principalSchema` uses the identity rule below. |
 | `operatorActor(env?)`, `ActorConfigError` | Read the actor from `CANVAS_ACTOR` as `<kind>:<id>`. It throws `ActorConfigError` when the value is missing or bad. |
 | `CanvasService` | The board operations that the CLI, the MCP server and the Worker share. It takes a `Store`. |
-| `createMcpServer(service, actor)`, `runMcp(service, actor)` | Make the MCP server, or run it on stdio. |
+| `createMcpServer(service, actor, sharing?)`, `runMcp(service, actor, sharing?)` | Make the MCP server, or run it on stdio. `sharing` is a client from `agentic-canvas/client`: it turns on the sharing tools. |
 | `createFileStore`, `openLocalStore`, `FileStoreOptions` (type) | Stores on one local file. See `agentic-canvas/file-store`. |
 
 ### Actor ids
@@ -353,6 +379,8 @@ old author stays on its elements. Only new writes follow the strict rule.
 | Name | What it is |
 |---|---|
 | `createClient(options)`, `CanvasApiError` | The remote client. See Remote client above. |
+| `parseSubject(text)` | Reads `human:<id>` or `agent:<id>` as `{ subjectKind, subjectId }`. It throws a `TypeError` for any other text. |
+| `BoardSharing` (type), `BoardRole` (type), `SubjectKind` (type), `Subject` (type), `BoardGrant` (type), `BoardInvite` (type), `InviteInput` (type) | Types for sharing. |
 | `ClientOptions` (type), `CallOptions` (type), `CanvasClient` (type), `ShapeInput` (type), `ConnectorInput` (type), `ShapePatch` (type), `ConnectorPatch` (type), `ImageInfo` (type), `ApiErrorCode` (type) | Types for the client. `ApiErrorCode` adds the client's own codes, such as `NETWORK`, to `ErrorCode`. |
 
 ### `agentic-canvas/file-store`
@@ -391,9 +419,10 @@ The stylesheet is a separate export, `agentic-canvas/ui.css`. Load `agentic-desi
 | `createApp(options?)` | Make the Hono app for the Worker. Pass `live` to turn on the live-room socket. |
 | `default` | The Worker, without live rooms. |
 | `authenticate(request, env)` | Read a bearer token from the `Authorization` header, or from a WebSocket sub-protocol. Return a promise of the actor and the role, or `null`. |
+| `identify(request, env, store?)` | Like `authenticate`, with the whole caller: its actor, role, principal context, and whether the dev fallback signed it in. Return a promise of the caller, or `null`. |
 | `sniffImage(bytes)` | Find the image type from the first bytes, or return `null`. The client's claim of a type is not trusted. |
 | `WS_PROTOCOL` | The sub-protocol name for a WebSocket: `agentic-canvas`. The token travels in the entry `agentic-canvas.bearer.<token in base64url>`. |
-| `WorkerEnv` (type), `AppOptions` (type), `Role` (type) | Types for the Worker bindings, the app options and the role, `editor` or `viewer`. |
+| `WorkerEnv` (type), `AppOptions` (type), `Role` (type), `Caller` (type) | Types for the Worker bindings, the app options, the role, `editor` or `viewer`, and the caller that `identify` returns. |
 
 ### `agentic-canvas/live-worker`
 
@@ -405,7 +434,7 @@ 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.6.
+- Canvas takes principal kinds, regions, and the Store and Blobs ports from `agentic-identity` 0.7.
 - A board made before sharing has no owner. Identity credentials get 404 on it. Only the dev fallback reaches it. Make it again, or add its
   `canvas` resource and an owner grant with `agentic-identity`.
 - An image is stored under the hash of its bytes, not under a board. Any credential with `canvas:read` can fetch an image if it knows the hash.

package/dist/{chunk-7IOW6LML.js → chunk-NLTN7J22.js}

@@ -8,7 +8,7 @@ import {
 
 // src/version.ts
 import { createRequire } from "module";
-var VERSION = true ? "0.8.0" : readPackageVersion();
+var VERSION = true ? "0.10.0" : readPackageVersion();
 
 // src/brand.ts
 var BRAND = {
@@ -70,9 +70,11 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
 var json = (value) => ({ content: [{ type: "text", text: JSON.stringify(value) }] });
+var isApiError = (error) => error instanceof Error && error.name === "CanvasApiError" && typeof error.code === "string";
 function failure(error) {
-  if (!(error instanceof CanvasError)) console.error(error instanceof Error ? error.message : String(error));
-  const body = error instanceof CanvasError ? { code: error.code, message: error.message } : { code: "INTERNAL", message: "the board operation failed" };
+  const safe = error instanceof CanvasError || isApiError(error);
+  if (!safe) console.error(error instanceof Error ? error.message : String(error));
+  const body = safe ? { code: error.code, message: error.message } : { code: "INTERNAL", message: "the board operation failed" };
   return { isError: true, content: [{ type: "text", text: JSON.stringify(body) }] };
 }
 function tool(run) {
@@ -86,7 +88,7 @@ function tool(run) {
 }
 var board = z.string().describe("Board id.");
 var num = z.number();
-function createMcpServer(service, actor) {
+function createMcpServer(service, actor, sharing) {
   const server = new McpServer({ name: BRAND.command, version: BRAND.version });
   const read = { readOnlyHint: true };
   server.registerTool(
@@ -170,10 +172,38 @@ function createMcpServer(service, actor) {
     { description: "Export the board as a PNG image. Needs the optional playwright-core and a Chromium.", inputSchema: { board }, annotations: read },
     tool(async (a) => ({ content: [{ type: "image", data: Buffer.from(await svgToPng(await service.exportSvg(a.board))).toString("base64"), mimeType: "image/png" }] }))
   );
+  const shared = () => {
+    if (!sharing) throw new CanvasError("UNAVAILABLE", "sharing needs a server: set CANVAS_SERVER and CANVAS_TOKEN");
+    return sharing;
+  };
+  const kind = z.enum(["human", "agent"]).describe("human or agent. A person and an agent can share one id, and hold separate roles.");
+  server.registerTool(
+    "list_access",
+    { description: "List the grants and the open invites of a board. Needs the owner role.", inputSchema: { board }, annotations: read },
+    tool(async (a) => json(await shared().access(a.board)))
+  );
+  server.registerTool(
+    "grant_access",
+    { description: "Give a person or an agent a role on a board. A lower role replaces a higher one. Needs the owner role.", inputSchema: { board, subjectKind: kind, subjectId: z.string(), role: z.enum(["viewer", "commenter", "editor", "owner"]) }, annotations: { destructiveHint: true } },
+    tool(async ({ board: b, ...input }) => json(await shared().grant(b, input)))
+  );
+  server.registerTool(
+    "revoke_access",
+    { description: "Take a role back from a person or an agent. The last owner cannot be removed. Needs the owner role.", inputSchema: { board, subjectKind: kind, subjectId: z.string() }, annotations: { destructiveHint: true } },
+    tool(async ({ board: b, ...input }) => json(await shared().revoke(b, input)))
+  );
+  server.registerTool(
+    "create_invite",
+    {
+      description: "Invite a person by email or an agent by handle to a board. Give email or handle, not both. The role is not owner. Needs the owner role.",
+      inputSchema: { board, role: z.enum(["viewer", "commenter", "editor"]), email: z.string().optional(), handle: z.string().optional(), expiresInMs: z.number().optional() }
+    },
+    tool(async ({ board: b, ...input }) => json(await shared().invite(b, input)))
+  );
   return server;
 }
-async function runMcp(service, actor) {
-  await createMcpServer(service, actor).connect(new StdioServerTransport());
+async function runMcp(service, actor, sharing) {
+  await createMcpServer(service, actor, sharing).connect(new StdioServerTransport());
 }
 
 export {

package/dist/cli.js

@@ -5,7 +5,7 @@ import {
   operatorActor,
   runMcp,
   svgToPng
-} from "./chunk-7IOW6LML.js";
+} from "./chunk-NLTN7J22.js";
 import {
   openLocalStore
 } from "./chunk-NRLF6MGR.js";
@@ -21,6 +21,96 @@ import "./chunk-JOBTIAFJ.js";
 // src/cli.ts
 import { readFileSync, writeFileSync } from "fs";
 import { parseArgs } from "util";
+
+// src/client.ts
+var CanvasApiError = class extends Error {
+  constructor(code, message, status) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.name = "CanvasApiError";
+  }
+  code;
+  status;
+};
+function parseSubject(text) {
+  const at = text.indexOf(":");
+  const kind = text.slice(0, at);
+  if (at < 1 || kind !== "human" && kind !== "agent" || at === text.length - 1) throw new TypeError(`"${text}" is not human:<id> or agent:<id>`);
+  return { subjectKind: kind, subjectId: text.slice(at + 1) };
+}
+function createClient(options) {
+  const { token } = options;
+  const base = options.baseUrl.replace(/\/+$/, "");
+  if (!token) throw new TypeError("token is required");
+  const doFetch = options.fetch ?? ((input, init) => globalThis.fetch(input, init));
+  const seg = encodeURIComponent;
+  async function send(method, path, init, call) {
+    const headers = { authorization: `Bearer ${token}` };
+    if (init.json !== void 0) headers["content-type"] = "application/json";
+    if (init.contentType) headers["content-type"] = init.contentType;
+    let response;
+    try {
+      response = await doFetch(`${base}${path}`, {
+        method,
+        headers,
+        body: init.json === void 0 ? init.body : JSON.stringify(init.json),
+        signal: call?.signal
+      });
+    } catch (error) {
+      if (call?.signal?.aborted) throw error;
+      throw new CanvasApiError("NETWORK", error instanceof Error ? error.message : "the request failed", 0);
+    }
+    if (response.ok) return response;
+    let code = "HTTP_ERROR";
+    let message = `the server answered ${response.status}`;
+    try {
+      const { error } = await response.json();
+      if (typeof error?.code === "string") code = error.code;
+      if (typeof error?.message === "string") message = error.message;
+    } catch {
+      if (call?.signal?.aborted) throw call.signal.reason;
+    }
+    throw new CanvasApiError(code, message, response.status);
+  }
+  const parse = async (response, call) => {
+    try {
+      return await response.json();
+    } catch (error) {
+      if (call?.signal?.aborted) throw error;
+      throw new CanvasApiError("HTTP_ERROR", "the server did not answer with JSON", response.status);
+    }
+  };
+  const json = async (method, path, body, call) => parse(await send(method, path, { json: body }, call), call);
+  const bytes = async (response) => new Uint8Array(await response.arrayBuffer());
+  return {
+    me: (o) => json("GET", "/me", void 0, o),
+    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),
+    drawFlow: (id, text, o) => json("POST", `/boards/${seg(id)}/flow`, { text }, o),
+    update: (id, element, patch, o) => json("PATCH", `/boards/${seg(id)}/elements/${seg(element)}`, patch, o),
+    move: (id, element, dx, dy, o) => json("POST", `/boards/${seg(id)}/move`, { element, dx, dy }, o),
+    remove: (id, element, o) => json("DELETE", `/boards/${seg(id)}/elements/${seg(element)}`, void 0, o),
+    access: (id, o) => json("GET", `/boards/${seg(id)}/access`, void 0, o),
+    grant: (id, input, o) => json("POST", `/boards/${seg(id)}/grants`, input, o),
+    revoke: (id, { subjectKind, subjectId }, o) => json("DELETE", `/boards/${seg(id)}/grants?subjectKind=${seg(subjectKind)}&subjectId=${seg(subjectId)}`, void 0, o),
+    invite: (id, input, o) => json("POST", `/boards/${seg(id)}/invites`, input, o),
+    uploadImage: async (data, o) => parse(await send("POST", "/images", { body: data, contentType: "application/octet-stream" }, o), o),
+    getImage: async (id, o) => {
+      const response = await send("GET", `/images/${seg(id)}`, {}, o);
+      return { bytes: await bytes(response), type: response.headers.get("content-type") ?? "application/octet-stream" };
+    },
+    state: async (id, o) => bytes(await send("GET", `/boards/${seg(id)}/state`, {}, o)),
+    checkpoint: async (id, update, o) => parse(await send("POST", `/boards/${seg(id)}/checkpoint`, { body: update, contentType: "application/octet-stream" }, o), o)
+  };
+}
+
+// src/cli.ts
 var UsageError = class extends Error {
 };
 var HELP = `${BRAND.command} ${BRAND.version}
@@ -41,11 +131,16 @@ Commands:
   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.
   repair <board> [--drop <element>]...     Owner only: fix a broken or over-cap board. Needs CANVAS_ACTOR=human:<id>.
+  access <board>                           Server only. List the grants and open invites. Owner.
+  grant <board> <human|agent>:<id> --role <viewer|commenter|editor|owner>  Server only. Give a role. Owner.
+  revoke <board> <human|agent>:<id>        Server only. Take a role back. Owner.
+  invite <board> --role <viewer|commenter|editor> --email <e> | --handle <h> [--expires-in-ms <n>]  Server only. Owner.
   mcp                                      Serve these as MCP tools on stdio. Needs CANVAS_ACTOR.
 
 Live mode: set CANVAS_SERVER=<worker url> and CANVAS_TOKEN=<bearer token>. Every command then runs in the live room of
 the board on that server, so a person and an agent can edit one board at once. The token sets the actor, the kind,
 and the role, so CANVAS_ACTOR is not needed. If it is set, it must match the token. --dir, CANVAS_DIR, and repair are local only.
+The sharing commands need CANVAS_SERVER: a local store has no owners.
 
 Write commands need an actor in CANVAS_ACTOR as <kind>:<id>, such as "agent:helper".
 The operator sets it. A caller cannot pick its own kind: there is no --actor flag.
@@ -69,6 +164,10 @@ var flags = {
   file: { type: "string" },
   prefix: { type: "string" },
   format: { type: "string" },
+  role: { type: "string" },
+  email: { type: "string" },
+  handle: { type: "string" },
+  "expires-in-ms": { type: "string" },
   out: { type: "string" },
   drop: { type: "string", multiple: true },
   help: { type: "boolean" },
@@ -117,6 +216,17 @@ async function run(argv) {
       throw error;
     }
   };
+  const sharing = () => {
+    if (!server) throw new UsageError(`"${command}" needs a server: set CANVAS_SERVER and CANVAS_TOKEN`);
+    return createClient({ baseUrl: `${server.replace(/\/$/, "")}/api/v1/canvas`, token: process.env.CANVAS_TOKEN });
+  };
+  const subject = (text) => {
+    try {
+      return parseSubject(text ?? "");
+    } catch (error) {
+      throw new UsageError(error.message);
+    }
+  };
   const print = (value) => console.log(JSON.stringify(value));
   switch (command) {
     case "new":
@@ -169,9 +279,23 @@ async function run(argv) {
     case "repair":
       need(1, "<board> [--drop <element>]...");
       return print(await service.repair(board, actor(), v.drop ?? []));
+    case "access":
+      need(1, "<board>");
+      return print(await sharing().access(board));
+    case "grant":
+      need(2, "<board> <human|agent>:<id> --role <role>");
+      return print(await sharing().grant(board, { ...subject(rest[0]), role: v.role }));
+    case "revoke":
+      need(2, "<board> <human|agent>:<id>");
+      return print(await sharing().revoke(board, subject(rest[0])));
+    case "invite": {
+      need(1, "<board> --role <role> --email <e> | --handle <h> [--expires-in-ms <n>]");
+      const expiresInMs = num(v["expires-in-ms"]);
+      return print(await sharing().invite(board, { role: v.role, email: v.email, handle: v.handle, ...expiresInMs === void 0 ? {} : { expiresInMs } }));
+    }
     case "mcp":
       need(0, "");
-      return runMcp(service, actor());
+      return runMcp(service, actor(), server ? sharing() : void 0);
     default:
       throw new UsageError(`unknown command "${command}"`);
   }
@@ -182,7 +306,7 @@ run(process.argv.slice(2)).catch((error) => {
     console.error(`${error.message}
 Run "${BRAND.command} --help" for usage.`);
     process.exitCode = 2;
-  } else if (error instanceof CanvasError) {
+  } else if (error instanceof CanvasError || error instanceof CanvasApiError) {
     console.error(`${error.code}: ${error.message}`);
     process.exitCode = 1;
   } else {

package/dist/client-Dyd30StF.d.ts

@@ -0,0 +1,153 @@
+import { a as BoardData, c as ShapeType, S as Shape, E as Endpoint, C as Connector } from './read-UIJlrkwx.js';
+import { PrincipalKind } from 'agentic-identity';
+
+/** Options for every call. */
+interface CallOptions {
+    signal?: AbortSignal;
+}
+interface ShapeInput {
+    id?: string;
+    type: ShapeType;
+    x: number;
+    y: number;
+    w?: number;
+    h?: number;
+    text?: string;
+    fill?: string;
+    stroke?: string;
+    /** A `data:` URL or a `blob:` ref, for an image. */
+    src?: string;
+}
+interface ConnectorInput {
+    id?: string;
+    from: Endpoint;
+    to: Endpoint;
+    text?: string;
+    startArrow?: boolean;
+    endArrow?: boolean;
+    stroke?: string;
+}
+type ShapePatch = Partial<Pick<ShapeInput, "x" | "y" | "w" | "h" | "text" | "fill" | "stroke" | "src">>;
+type ConnectorPatch = Partial<Pick<ConnectorInput, "from" | "to" | "text" | "startArrow" | "endArrow" | "stroke">>;
+/** A role on a board, from least to most. */
+type BoardRole = "viewer" | "commenter" | "editor" | "owner";
+/** Who holds a grant. A person and an agent may share one id and hold separate roles. */
+type SubjectKind = "human" | "agent";
+interface Subject {
+    subjectKind: SubjectKind;
+    subjectId: string;
+}
+interface BoardGrant {
+    subjectKind: SubjectKind;
+    subjectId: string;
+    role: BoardRole;
+    [field: string]: unknown;
+}
+/** An open invite. It never shows the email. */
+interface BoardInvite {
+    id: string;
+    role: BoardRole;
+    [field: string]: unknown;
+}
+interface InviteInput {
+    /** Not `owner`: only a grant makes an owner. */
+    role: Exclude<BoardRole, "owner">;
+    /** The person to invite. Give this or `handle`. */
+    email?: string;
+    /** The agent to invite. Give this or `email`. */
+    handle?: string;
+    /** How long the invite lives, in milliseconds. */
+    expiresInMs?: number;
+}
+interface ImageInfo {
+    id: string;
+    ref: string;
+    type: string;
+    size: number;
+    /** False when the same bytes were stored before. */
+    created: boolean;
+}
+interface CanvasClient {
+    /** Who the token stands for. */
+    me(options?: CallOptions): Promise<{
+        actor: string;
+        kind: PrincipalKind;
+        role: "editor" | "viewer";
+    }>;
+    /** The first 100 boards, with titles. */
+    listBoards(options?: CallOptions): Promise<{
+        boards: {
+            id: string;
+            title: string;
+        }[];
+    }>;
+    createBoard(input?: {
+        id?: string;
+        title?: string;
+    }, options?: CallOptions): Promise<{
+        id: string;
+        title: string;
+    }>;
+    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>;
+    addConnector(id: string, connector: ConnectorInput, options?: CallOptions): Promise<Connector>;
+    /** Draw a flowchart from text such as `A -> B: label`. Returns the new ids. */
+    drawFlow(id: string, text: string, options?: CallOptions): Promise<{
+        nodes: string[];
+        edges: string[];
+    }>;
+    /** Change fields of one shape or connector, such as its size or text. The patch holds at least one field. */
+    update(id: string, element: string, patch: ShapePatch | ConnectorPatch, options?: CallOptions): Promise<Shape | Connector>;
+    /** Move an element. Returns the ids that moved: a shape takes its connectors with it. */
+    move(id: string, element: string, dx: number, dy: number, options?: CallOptions): Promise<{
+        moved: string[];
+    }>;
+    /** Remove an element. Returns the ids removed. */
+    remove(id: string, element: string, options?: CallOptions): Promise<{
+        removed: string[];
+    }>;
+    /** The grants and the open invites of a board. Needs the owner role. */
+    access(id: string, options?: CallOptions): Promise<{
+        grants: BoardGrant[];
+        invites: BoardInvite[];
+    }>;
+    /** Give a person or an agent a role on a board. Needs the owner role. */
+    grant(id: string, input: Subject & {
+        role: BoardRole;
+    }, options?: CallOptions): Promise<{
+        ok: true;
+    }>;
+    /** Take a role back. The last owner cannot be removed. Needs the owner role. */
+    revoke(id: string, input: Subject, options?: CallOptions): Promise<{
+        ok: true;
+    }>;
+    /** Invite a person by email or an agent by handle. Returns the invite id. Needs the owner role. */
+    invite(id: string, input: InviteInput, options?: CallOptions): Promise<{
+        id: string;
+    }>;
+    uploadImage(bytes: Uint8Array | ArrayBuffer | Blob, options?: CallOptions): Promise<ImageInfo>;
+    /** The bytes of a stored image, and its content type. */
+    getImage(id: string, options?: CallOptions): Promise<{
+        bytes: Uint8Array;
+        type: string;
+    }>;
+    /** The stored board as a Yjs update. Only a server with live rooms serves it. */
+    state(id: string, options?: CallOptions): Promise<Uint8Array>;
+    /** Merge a live room's Yjs update into the stored board. Only a server with live rooms serves it. */
+    checkpoint(id: string, update: Uint8Array, options?: CallOptions): Promise<{
+        elements: number;
+        fixed: string[];
+    }>;
+}
+/** What the CLI and the MCP server need to share a board. Sharing lives on the server, so it needs a client. */
+type BoardSharing = Pick<CanvasClient, "access" | "grant" | "revoke" | "invite">;
+
+export type { BoardSharing as B, CanvasClient as C };

package/dist/client.d.ts

@@ -1,7 +1,68 @@
-import { E as ErrorCode, a as BoardData, c as ShapeType, S as Shape, d as Endpoint, C as Connector } from './read--Jd3kE13.js';
 import { PrincipalKind } from 'agentic-identity';
-import 'yjs';
-import 'zod';
+
+type Principal = {
+    kind: PrincipalKind;
+    id: string;
+};
+
+type ErrorCode = "INVALID" | "DUPLICATE_ID" | "NOT_FOUND" | "BAD_REFERENCE" | "LIMIT" | "UNAVAILABLE" | "FORBIDDEN";
+declare const SHAPE_TYPES: readonly ["rect", "ellipse", "diamond", "text", "sticky", "frame", "image"];
+type ShapeType = (typeof SHAPE_TYPES)[number];
+type Endpoint = {
+    id: string;
+} | {
+    x: number;
+    y: number;
+};
+interface Stamp {
+    id: string;
+    z: number;
+    groupId?: string;
+    /** Who made the element. Never changes. */
+    author: Principal;
+    /** Who made the last edit. */
+    editedBy: Principal;
+}
+interface Shape extends Stamp {
+    type: ShapeType;
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    text: string;
+    fill?: string;
+    stroke?: string;
+    src?: string;
+}
+interface Connector extends Stamp {
+    type: "connector";
+    from: Endpoint;
+    to: Endpoint;
+    text: string;
+    startArrow: boolean;
+    endArrow: boolean;
+    stroke?: string;
+}
+
+interface Labels {
+    /** The author is an agent or acts for one. */
+    machineMade: boolean;
+    /** The last edit came from an agent or one acting for one. */
+    lastEditMachineMade: boolean;
+}
+type NodeData = Shape & Labels;
+type EdgeData = Connector & Labels;
+interface BoardData {
+    title: string;
+    nodes: NodeData[];
+    edges: EdgeData[];
+    groups: {
+        id: string;
+        members: string[];
+    }[];
+    /** Every non-empty text, back to front. */
+    texts: string[];
+}
 
 interface ClientOptions {
     /** The API root, for example `https://canvas.example.com/api/v1/canvas`. */
@@ -39,6 +100,36 @@ interface ConnectorInput {
 }
 type ShapePatch = Partial<Pick<ShapeInput, "x" | "y" | "w" | "h" | "text" | "fill" | "stroke" | "src">>;
 type ConnectorPatch = Partial<Pick<ConnectorInput, "from" | "to" | "text" | "startArrow" | "endArrow" | "stroke">>;
+/** A role on a board, from least to most. */
+type BoardRole = "viewer" | "commenter" | "editor" | "owner";
+/** Who holds a grant. A person and an agent may share one id and hold separate roles. */
+type SubjectKind = "human" | "agent";
+interface Subject {
+    subjectKind: SubjectKind;
+    subjectId: string;
+}
+interface BoardGrant {
+    subjectKind: SubjectKind;
+    subjectId: string;
+    role: BoardRole;
+    [field: string]: unknown;
+}
+/** An open invite. It never shows the email. */
+interface BoardInvite {
+    id: string;
+    role: BoardRole;
+    [field: string]: unknown;
+}
+interface InviteInput {
+    /** Not `owner`: only a grant makes an owner. */
+    role: Exclude<BoardRole, "owner">;
+    /** The person to invite. Give this or `handle`. */
+    email?: string;
+    /** The agent to invite. Give this or `email`. */
+    handle?: string;
+    /** How long the invite lives, in milliseconds. */
+    expiresInMs?: number;
+}
 interface ImageInfo {
     id: string;
     ref: string;
@@ -104,6 +195,25 @@ interface CanvasClient {
     remove(id: string, element: string, options?: CallOptions): Promise<{
         removed: string[];
     }>;
+    /** The grants and the open invites of a board. Needs the owner role. */
+    access(id: string, options?: CallOptions): Promise<{
+        grants: BoardGrant[];
+        invites: BoardInvite[];
+    }>;
+    /** Give a person or an agent a role on a board. Needs the owner role. */
+    grant(id: string, input: Subject & {
+        role: BoardRole;
+    }, options?: CallOptions): Promise<{
+        ok: true;
+    }>;
+    /** Take a role back. The last owner cannot be removed. Needs the owner role. */
+    revoke(id: string, input: Subject, options?: CallOptions): Promise<{
+        ok: true;
+    }>;
+    /** Invite a person by email or an agent by handle. Returns the invite id. Needs the owner role. */
+    invite(id: string, input: InviteInput, options?: CallOptions): Promise<{
+        id: string;
+    }>;
     uploadImage(bytes: Uint8Array | ArrayBuffer | Blob, options?: CallOptions): Promise<ImageInfo>;
     /** The bytes of a stored image, and its content type. */
     getImage(id: string, options?: CallOptions): Promise<{
@@ -118,6 +228,10 @@ interface CanvasClient {
         fixed: string[];
     }>;
 }
+/** What the CLI and the MCP server need to share a board. Sharing lives on the server, so it needs a client. */
+type BoardSharing = Pick<CanvasClient, "access" | "grant" | "revoke" | "invite">;
+/** `kind:id` of a person or an agent, as the CLI and the tools write it. */
+declare function parseSubject(text: string): Subject;
 declare function createClient(options: ClientOptions): CanvasClient;
 
-export { type ApiErrorCode, type CallOptions, CanvasApiError, type CanvasClient, type ClientOptions, type ConnectorInput, type ConnectorPatch, type ImageInfo, type ShapeInput, type ShapePatch, createClient };
+export { type ApiErrorCode, type BoardGrant, type BoardInvite, type BoardRole, type BoardSharing, type CallOptions, CanvasApiError, type CanvasClient, type ClientOptions, type ConnectorInput, type ConnectorPatch, type ImageInfo, type InviteInput, type ShapeInput, type ShapePatch, type Subject, type SubjectKind, createClient, parseSubject };

package/dist/client.js

@@ -9,6 +9,12 @@ var CanvasApiError = class extends Error {
   code;
   status;
 };
+function parseSubject(text) {
+  const at = text.indexOf(":");
+  const kind = text.slice(0, at);
+  if (at < 1 || kind !== "human" && kind !== "agent" || at === text.length - 1) throw new TypeError(`"${text}" is not human:<id> or agent:<id>`);
+  return { subjectKind: kind, subjectId: text.slice(at + 1) };
+}
 function createClient(options) {
   const { token } = options;
   const base = options.baseUrl.replace(/\/+$/, "");
@@ -66,6 +72,10 @@ function createClient(options) {
     update: (id, element, patch, o) => json("PATCH", `/boards/${seg(id)}/elements/${seg(element)}`, patch, o),
     move: (id, element, dx, dy, o) => json("POST", `/boards/${seg(id)}/move`, { element, dx, dy }, o),
     remove: (id, element, o) => json("DELETE", `/boards/${seg(id)}/elements/${seg(element)}`, void 0, o),
+    access: (id, o) => json("GET", `/boards/${seg(id)}/access`, void 0, o),
+    grant: (id, input, o) => json("POST", `/boards/${seg(id)}/grants`, input, o),
+    revoke: (id, { subjectKind, subjectId }, o) => json("DELETE", `/boards/${seg(id)}/grants?subjectKind=${seg(subjectKind)}&subjectId=${seg(subjectId)}`, void 0, o),
+    invite: (id, input, o) => json("POST", `/boards/${seg(id)}/invites`, input, o),
     uploadImage: async (data, o) => parse(await send("POST", "/images", { body: data, contentType: "application/octet-stream" }, o), o),
     getImage: async (id, o) => {
       const response = await send("GET", `/images/${seg(id)}`, {}, o);
@@ -77,5 +87,6 @@ function createClient(options) {
 }
 export {
   CanvasApiError,
-  createClient
+  createClient,
+  parseSubject
 };

package/dist/embed.d.ts

@@ -1,7 +1,7 @@
 import * as react from 'react';
-import { CanvasClient } from './client.js';
+import { C as CanvasClient } from './client-Dyd30StF.js';
 import { PrincipalKind } from 'agentic-identity';
-import './read--Jd3kE13.js';
+import './read-UIJlrkwx.js';
 import 'yjs';
 import 'zod';
 

package/dist/index.d.ts

@@ -1,8 +1,9 @@
-import { B as Board, P as Principal } from './read--Jd3kE13.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--Jd3kE13.js';
-import { B as BoardAccess } from './service-OiTtNadu.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-OiTtNadu.js';
+import { B as Board, P as Principal } from './read-UIJlrkwx.js';
+export { a as BoardData, b as CanvasElement, d as CanvasError, C as Connector, e as EdgeData, E as Endpoint, f 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-UIJlrkwx.js';
+import { B as BoardAccess } from './service-ojpxVNVl.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-ojpxVNVl.js';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { B as BoardSharing } from './client-Dyd30StF.js';
 export { FileStoreOptions, createFileStore, openLocalStore } from './store-file.js';
 export { PRINCIPAL_KINDS, PrincipalKind, isMachineMade } from 'agentic-identity';
 import 'yjs';
@@ -39,10 +40,11 @@ declare function operatorActor(env?: Record<string, string | undefined>): Princi
 
 /**
  * The tools mirror the CLI. The actor is fixed here by the operator. No tool takes an actor,
- * author, or kind, so a caller cannot choose who it writes as.
+ * author, or kind, so a caller cannot choose who it writes as. The sharing tools run on a server, as the owner of its token:
+ * with no `sharing` client they fail with UNAVAILABLE.
  */
-declare function createMcpServer(service: BoardAccess, actor: Principal): McpServer;
+declare function createMcpServer(service: BoardAccess, actor: Principal, sharing?: BoardSharing): McpServer;
 /** Serve the tools on stdin and stdout. Stdout carries protocol frames only. */
-declare function runMcp(service: BoardAccess, actor: Principal): Promise<void>;
+declare function runMcp(service: BoardAccess, actor: Principal, sharing?: BoardSharing): Promise<void>;
 
 export { ActorConfigError, BRAND, Board, Principal, VERSION, createMcpServer, operatorActor, runMcp, svgToPng, toSvg };

package/dist/index.js

@@ -6,7 +6,7 @@ import {
   operatorActor,
   runMcp,
   svgToPng
-} from "./chunk-7IOW6LML.js";
+} from "./chunk-NLTN7J22.js";
 import {
   createFileStore,
   openLocalStore

package/dist/live-worker.d.ts

@@ -5,10 +5,10 @@ import 'agentic-identity';
 import 'agentic-realtime';
 import 'agentic-identity/cloudflare';
 import 'hono';
-import './read--Jd3kE13.js';
+import './read-UIJlrkwx.js';
 import 'yjs';
 import 'zod';
-import './service-OiTtNadu.js';
+import './service-ojpxVNVl.js';
 
 type Namespace = Parameters<typeof createDurableObjectRealtime>[0];
 interface LiveEnv extends WorkerEnv {

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--Jd3kE13.js';
+import { B as Board, P as Principal, a as BoardData, S as Shape, C as Connector, b as CanvasElement } from './read-UIJlrkwx.js';
 import { Peer } from 'agentic-realtime/client';
-import { B as BoardAccess, D as DrawOptions } from './service-OiTtNadu.js';
+import { B as BoardAccess, D as DrawOptions } from './service-ojpxVNVl.js';
 import 'yjs';
 import 'agentic-identity';
 import 'zod';

package/dist/{read--Jd3kE13.d.ts → read-UIJlrkwx.d.ts}

@@ -181,4 +181,4 @@ interface BoardData {
 /** The board as plain data for an agent. Reads only. Embedded image bytes are left out. */
 declare function readBoard(board: Board): BoardData;
 
-export { Board as B, type Connector as C, type ErrorCode as E, type Group as G, MAX_ELEMENTS as M, type NodeData as N, type Principal as P, type Shape as S, type BoardData as a, type CanvasElement as b, type ShapeType as c, type Endpoint as d, CanvasError as e, type EdgeData as f, MAX_TEXT as g, SHAPE_TYPES as h, principalSchema as p, readBoard as r };
+export { Board as B, type Connector as C, type Endpoint as E, type Group as G, MAX_ELEMENTS as M, type NodeData as N, type Principal as P, type Shape as S, type BoardData as a, type CanvasElement as b, type ShapeType as c, CanvasError as d, type EdgeData as e, type ErrorCode as f, MAX_TEXT as g, SHAPE_TYPES as h, principalSchema as p, readBoard as r };

package/dist/{service-OiTtNadu.d.ts → service-ojpxVNVl.d.ts}

@@ -1,4 +1,4 @@
-import { c as ShapeType, B as Board, P as Principal, a as BoardData, S as Shape, C as Connector, b as CanvasElement } from './read--Jd3kE13.js';
+import { c as ShapeType, B as Board, P as Principal, a as BoardData, S as Shape, C as Connector, b as CanvasElement } from './read-UIJlrkwx.js';
 import { Store } from 'agentic-identity';
 
 declare const MAX_FLOW_NODES = 500;

package/dist/ui.css

@@ -1,38 +1,38 @@
 /* Every rule is nested under .cv-root, so the styles do not reach the host page. */
 .cv-root {
-  .row { display: flex; align-items: center; justify-content: space-between; gap: var(--ad-space-4); flex-wrap: wrap; }
-  .failure { border: 1px solid var(--ad-color-danger); border-radius: var(--ad-radius-md); padding: var(--ad-space-4); color: var(--ad-color-danger-text); background: var(--ad-color-danger-subtle); display: grid; gap: var(--ad-space-3); justify-items: start; }
-  .note { color: var(--ad-color-text-muted); }
+  .row { display: flex; align-items: center; justify-content: space-between; gap: var(--agd-space-4); flex-wrap: wrap; }
+  .failure { border: 1px solid var(--agd-color-danger); border-radius: var(--agd-radius-md); padding: var(--agd-space-4); color: var(--agd-color-danger-text); background: var(--agd-color-danger-subtle); display: grid; gap: var(--agd-space-3); justify-items: start; }
+  .note { color: var(--agd-color-text-muted); }
   .sr-only { position: absolute; width: 1px; height: 1px; overflow: hidden; clip: rect(0 0 0 0); white-space: nowrap; }
 
-  .board { display: grid; gap: var(--ad-space-3); }
-  .stage { position: relative; display: grid; grid-template-columns: minmax(0, 1fr) 16rem; gap: var(--ad-space-3); height: 65vh; min-height: 22rem; }
+  .board { display: grid; gap: var(--agd-space-3); }
+  .stage { position: relative; display: grid; grid-template-columns: minmax(0, 1fr) 16rem; gap: var(--agd-space-3); height: 65vh; min-height: 22rem; }
   @media (max-width: 48rem) { .stage { grid-template-columns: 1fr; height: auto; } .canvas { height: 55vh; } }
-  .canvas { background: var(--ad-color-surface-sunken); border: 1px solid var(--ad-color-border); border-radius: var(--ad-radius-md); overflow: hidden; touch-action: none; min-height: 18rem; }
-  .canvas:focus-visible { outline: 3px solid var(--ad-color-focus); outline-offset: 2px; }
-  .canvas svg { display: block; cursor: grab; font-family: var(--ad-font-family-sans); font-size: 14px; }
+  .canvas { background: var(--agd-color-surface-sunken); border: 1px solid var(--agd-color-border); border-radius: var(--agd-radius-md); overflow: hidden; touch-action: none; min-height: 18rem; }
+  .canvas:focus-visible { outline: 3px solid var(--agd-color-focus); outline-offset: 2px; }
+  .canvas svg { display: block; cursor: grab; font-family: var(--agd-font-family-sans); font-size: 14px; }
   .item { outline: none; cursor: pointer; }
-  .shape { fill: var(--ad-color-surface-raised); stroke: var(--ad-color-border-strong); stroke-width: 1.5; }
+  .shape { fill: var(--agd-color-surface-raised); stroke: var(--agd-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: var(--ad-color-warning-subtle); stroke: var(--ad-color-warning); }
-  .label { fill: var(--ad-color-text); pointer-events: none; }
-  .sticky-label { fill: var(--ad-color-warning-text); }
-  .edge { stroke: var(--ad-color-text-muted); stroke-width: 2; fill: none; pointer-events: none; }
+  .shape.sticky { fill: var(--agd-color-warning-subtle); stroke: var(--agd-color-warning); }
+  .label { fill: var(--agd-color-text); pointer-events: none; }
+  .sticky-label { fill: var(--agd-color-warning-text); }
+  .edge { stroke: var(--agd-color-text-muted); stroke-width: 2; fill: none; pointer-events: none; }
   .hit { stroke: transparent; stroke-width: 14; }
-  .arrowhead { fill: var(--ad-color-text-muted); }
-  .edge-text { fill: var(--ad-color-text); paint-order: stroke; stroke: var(--ad-color-surface-sunken); stroke-width: 4px; pointer-events: none; }
+  .arrowhead { fill: var(--agd-color-text-muted); }
+  .edge-text { fill: var(--agd-color-text); paint-order: stroke; stroke: var(--agd-color-surface-sunken); stroke-width: 4px; pointer-events: none; }
   .ring, .ring-line { fill: none; stroke: none; stroke-width: 3; pointer-events: none; }
-  .item.selected .ring, .item.selected .ring-line, .item:focus-visible .ring, .item:focus-visible .ring-line { stroke: var(--ad-color-focus); }
+  .item.selected .ring, .item.selected .ring-line, .item:focus-visible .ring, .item:focus-visible .ring-line { stroke: var(--agd-color-focus); }
   .item:focus-visible .ring, .item:focus-visible .ring-line { stroke-width: 4; }
-  .handle { fill: var(--ad-color-focus); stroke: var(--ad-color-bg); stroke-width: 2; cursor: nwse-resize; }
-  .agent-badge rect { fill: var(--ad-color-agent-subtle); stroke: var(--ad-color-agent); }
-  .agent-badge text { fill: var(--ad-color-agent-text); font-size: 11px; font-weight: 600; pointer-events: none; }
+  .handle { fill: var(--agd-color-focus); stroke: var(--agd-color-bg); stroke-width: 2; cursor: nwse-resize; }
+  .agent-badge rect { fill: var(--agd-color-agent-subtle); stroke: var(--agd-color-agent); }
+  .agent-badge text { fill: var(--agd-color-agent-text); font-size: 11px; font-weight: 600; pointer-events: none; }
   .empty-overlay { position: absolute; inset: 0 16rem 0 0; display: grid; place-items: center; pointer-events: none; }
   @media (max-width: 48rem) { .empty-overlay { inset: 0; bottom: auto; height: 55vh; } }
-  .inspector { border: 1px solid var(--ad-color-border); border-radius: var(--ad-radius-md); padding: var(--ad-space-3); background: var(--ad-color-surface); display: grid; gap: var(--ad-space-3); align-content: start; overflow: auto; }
-  .inspector h2 { margin: 0; font-size: var(--ad-font-size-lg); }
-  .inspector form { display: grid; gap: var(--ad-space-3); }
-  .inspector .by { margin: 0; color: var(--ad-color-text-muted); font-size: var(--ad-font-size-sm); }
-  .sizes { display: grid; grid-template-columns: 1fr 1fr; gap: var(--ad-space-2); }
+  .inspector { border: 1px solid var(--agd-color-border); border-radius: var(--agd-radius-md); padding: var(--agd-space-3); background: var(--agd-color-surface); display: grid; gap: var(--agd-space-3); align-content: start; overflow: auto; }
+  .inspector h2 { margin: 0; font-size: var(--agd-font-size-lg); }
+  .inspector form { display: grid; gap: var(--agd-space-3); }
+  .inspector .by { margin: 0; color: var(--agd-color-text-muted); font-size: var(--agd-font-size-sm); }
+  .sizes { display: grid; grid-template-columns: 1fr 1fr; gap: var(--agd-space-2); }
 }

package/dist/worker.d.ts

@@ -2,8 +2,8 @@ import { Store, PrincipalContext, Action, Grant, InviteSummary, Blobs } from 'ag
 import { Realtime } from 'agentic-realtime';
 import { D1Like, R2Like } from 'agentic-identity/cloudflare';
 import { Hono } from 'hono';
-import { P as Principal } from './read--Jd3kE13.js';
-import { C as CanvasService } from './service-OiTtNadu.js';
+import { P as Principal } from './read-UIJlrkwx.js';
+import { C as CanvasService } from './service-ojpxVNVl.js';
 import 'yjs';
 import 'zod';
 

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|delete|flow|export.
+- CLI: agentic-canvas new|list|read|add|connect|update|move|rm|delete|flow|export, and with CANVAS_SERVER: access|grant|revoke|invite. MCP tools for sharing: list_access, grant_access, revoke_access, create_invite.
 - 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, deleteBoard, 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, access, grant, revoke, invite, 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.8.0",
+  "version": "0.10.0",
   "description": "A shared whiteboard for diagrams, drawn by people and agents.",
   "keywords": [
     "whiteboard",
@@ -70,7 +70,7 @@
     "agentic-canvas": "./dist/cli.js"
   },
   "scripts": {
-    "build": "tsup && vite build && node ui/build-css.mjs",
+    "build": "rm -rf dist && tsup && vite build && node ui/build-css.mjs",
     "typecheck": "tsc --noEmit && tsc --noEmit -p ui",
     "test": "vitest run",
     "clean": "rm -rf dist",
@@ -81,8 +81,8 @@
   "dependencies": {
     "@dagrejs/dagre": "^3.1.3",
     "@modelcontextprotocol/sdk": "^1.12.0",
-    "agentic-design": "^0.3.2",
-    "agentic-identity": "^0.7.0",
+    "agentic-design": "^0.4.0",
+    "agentic-identity": "^0.8.0",
     "agentic-realtime": "^0.4.2",
     "yjs": "^13.6.0",
     "zod": "^4.6.7"