agentic-canvas 0.1.0 → 0.2.0

package/dist/chunk-KEMOXKBY.js

@@ -0,0 +1,166 @@
+import {
+  CanvasError,
+  PRINCIPAL_KINDS,
+  SHAPE_TYPES,
+  principalSchema
+} from "./chunk-GGQPE65T.js";
+
+// src/version.ts
+import { createRequire } from "module";
+var VERSION = true ? "0.2.0" : readPackageVersion();
+
+// src/brand.ts
+var BRAND = {
+  command: "agentic-canvas",
+  description: "A shared whiteboard for diagrams, drawn by people and agents.",
+  version: VERSION
+};
+
+// src/actor.ts
+var ActorConfigError = class extends Error {
+};
+function operatorActor(env = process.env) {
+  const raw = env.CANVAS_ACTOR;
+  if (!raw) throw new ActorConfigError("the operator must set CANVAS_ACTOR=<kind>:<id>");
+  const at = raw.indexOf(":");
+  const parsed = principalSchema.safeParse({ kind: raw.slice(0, at), id: raw.slice(at + 1) });
+  if (at < 0 || !parsed.success) {
+    throw new ActorConfigError(`bad CANVAS_ACTOR "${raw}": use <kind>:<id>, kind is one of ${PRINCIPAL_KINDS.join(", ")}`);
+  }
+  return parsed.data;
+}
+
+// src/png.ts
+var MAX_SIDE = 16384;
+var MAX_PIXELS = 16e6;
+var TIMEOUT_MS = 2e4;
+async function svgToPng(svg) {
+  const size = /^<svg [^>]*?width="(\d+)" height="(\d+)"/.exec(svg);
+  const width = Number(size?.[1]);
+  const height = Number(size?.[2]);
+  if (!(width > 0 && height > 0) || width > MAX_SIDE || height > MAX_SIDE || width * height > MAX_PIXELS) {
+    throw new CanvasError("LIMIT", `the board is too large for PNG: up to ${MAX_SIDE} px a side and ${MAX_PIXELS / 1e6} million pixels`);
+  }
+  let chromium;
+  try {
+    ({ chromium } = await import("playwright-core"));
+  } catch {
+    throw new CanvasError("UNAVAILABLE", "PNG export needs the playwright-core package. Install it, or export SVG.");
+  }
+  const browser = await chromium.launch().catch(() => {
+    throw new CanvasError("UNAVAILABLE", "PNG export needs Chromium. Run: npx playwright-core install chromium");
+  });
+  try {
+    const context = await browser.newContext({ viewport: { width, height }, javaScriptEnabled: false, serviceWorkers: "block" });
+    context.setDefaultTimeout(TIMEOUT_MS);
+    await context.route("**/*", (route) => route.abort());
+    const page = await context.newPage();
+    await page.setContent(`<!doctype html><body style="margin:0">${svg}</body>`);
+    return await page.screenshot({ clip: { x: 0, y: 0, width, height } });
+  } finally {
+    await browser.close();
+  }
+}
+
+// src/mcp.ts
+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) }] });
+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" };
+  return { isError: true, content: [{ type: "text", text: JSON.stringify(body) }] };
+}
+function tool(run) {
+  return async (args) => {
+    try {
+      return await run(args);
+    } catch (error) {
+      return failure(error);
+    }
+  };
+}
+var board = z.string().describe("Board id.");
+var num = z.number();
+function createMcpServer(service, actor) {
+  const server = new McpServer({ name: BRAND.command, version: BRAND.version });
+  const read = { readOnlyHint: true };
+  server.registerTool(
+    "create_board",
+    { description: "Make a board.", inputSchema: { id: z.string().optional(), title: z.string().optional() } },
+    tool(async (a) => json(await service.create(actor, a)))
+  );
+  server.registerTool(
+    "read_board",
+    { 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(
+    "add_shape",
+    {
+      description: "Add a shape. Image shapes need src.",
+      inputSchema: {
+        board,
+        id: z.string().optional(),
+        type: z.enum(SHAPE_TYPES),
+        x: num,
+        y: num,
+        w: num.optional(),
+        h: num.optional(),
+        text: z.string().optional(),
+        fill: z.string().optional(),
+        stroke: z.string().optional(),
+        src: z.string().optional()
+      }
+    },
+    tool(async ({ board: b, ...shape }) => json(await service.add(b, shape, actor)))
+  );
+  server.registerTool(
+    "connect",
+    { description: "Join two shapes with an arrow.", inputSchema: { board, from: z.string(), to: z.string(), id: z.string().optional(), text: z.string().optional() } },
+    tool(async (a) => json(await service.connect(a.board, { id: a.id, from: { id: a.from }, to: { id: a.to }, text: a.text }, actor)))
+  );
+  server.registerTool(
+    "move",
+    { description: "Move an element, or a whole group.", inputSchema: { board, element: z.string(), dx: num, dy: num } },
+    tool(async (a) => json(await service.move(a.board, a.element, a.dx, a.dy, actor)))
+  );
+  server.registerTool(
+    "remove",
+    { description: "Delete an element. A shape takes its connectors, a group its members.", inputSchema: { board, element: z.string() }, annotations: { destructiveHint: true } },
+    tool(async (a) => json(await service.remove(a.board, a.element)))
+  );
+  server.registerTool(
+    "draw_flow",
+    {
+      description: 'Draw a flowchart from text, one statement per line: "A[Box] -> B{Choice}: label". [] box, () ellipse, {} diamond.',
+      inputSchema: { board, text: z.string(), idPrefix: z.string().optional() }
+    },
+    tool(async (a) => json(await service.flow(a.board, a.text, actor, { idPrefix: a.idPrefix })))
+  );
+  server.registerTool(
+    "export_svg",
+    { description: "Export the board as SVG text.", inputSchema: { board }, annotations: read },
+    tool(async (a) => ({ content: [{ type: "text", text: await service.exportSvg(a.board) }] }))
+  );
+  server.registerTool(
+    "export_png",
+    { 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" }] }))
+  );
+  return server;
+}
+async function runMcp(service, actor) {
+  await createMcpServer(service, actor).connect(new StdioServerTransport());
+}
+
+export {
+  VERSION,
+  BRAND,
+  ActorConfigError,
+  operatorActor,
+  svgToPng,
+  createMcpServer,
+  runMcp
+};

package/dist/chunk-NWQED42L.js

@@ -0,0 +1,13 @@
+// src/store-errors.ts
+var FileStoreError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "FileStoreError";
+  }
+  code;
+};
+
+export {
+  FileStoreError
+};

package/dist/{chunk-I3EJ5JB7.js → chunk-UKST5A57.js}

@@ -1,20 +1,12 @@
+import {
+  FileStoreError
+} from "./chunk-NWQED42L.js";
+
 // src/store-file.ts
 import { randomUUID } from "crypto";
 import { mkdirSync } from "fs";
 import { link, open, readFile, rename, unlink } from "fs/promises";
 import { join } from "path";
-
-// src/store-errors.ts
-var FileStoreError = class extends Error {
-  constructor(code, message) {
-    super(message);
-    this.code = code;
-    this.name = "FileStoreError";
-  }
-  code;
-};
-
-// src/store-file.ts
 import { assertCollection, assertId, createMemoryStore, parseRegion, StoreConflictError } from "agentic-identity";
 var MAX_TRANSACTION_RUNS = 50;
 var clone = (value) => JSON.parse(JSON.stringify(value));
@@ -230,7 +222,6 @@ function openLocalStore(dir) {
 var STORE_FILE = "canvas.json";
 
 export {
-  FileStoreError,
   createFileStore,
   openLocalStore,
   STORE_FILE