agentic-canvas 0.0.0-stage → 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-UKST5A57.js

@@ -0,0 +1,228 @@
+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";
+import { assertCollection, assertId, createMemoryStore, parseRegion, StoreConflictError } from "agentic-identity";
+var MAX_TRANSACTION_RUNS = 50;
+var clone = (value) => JSON.parse(JSON.stringify(value));
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var codeOf = (error) => error?.code;
+function processIsAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return codeOf(error) === "EPERM";
+  }
+}
+function lockIsStale(text, staleAfterMs) {
+  let held;
+  try {
+    held = JSON.parse(text);
+  } catch {
+    return false;
+  }
+  if (typeof held !== "object" || held === null) return false;
+  const { pid, at } = held;
+  if (typeof pid !== "number" || !Number.isInteger(pid) || pid < 1 || typeof at !== "number" || !Number.isFinite(at)) return false;
+  return !processIsAlive(pid) || Date.now() - at > staleAfterMs;
+}
+function createFileStore(path, options = {}) {
+  const region = parseRegion(options.region ?? "unknown");
+  const lockPath = `${path}.lock`;
+  const timeoutMs = options.lockTimeoutMs ?? 1e4;
+  const staleAfterMs = options.staleAfterMs ?? 3e4;
+  for (const ms of [timeoutMs, staleAfterMs]) if (typeof ms !== "number" || !Number.isFinite(ms) || ms < 0) throw new TypeError("lockTimeoutMs and staleAfterMs must be finite numbers of 0 or more");
+  let queue = Promise.resolve();
+  async function load() {
+    let text;
+    try {
+      text = await readFile(path, "utf8");
+    } catch (error) {
+      if (codeOf(error) === "ENOENT") return /* @__PURE__ */ new Map();
+      throw error;
+    }
+    try {
+      const data = JSON.parse(text);
+      if (typeof data !== "object" || data === null || Array.isArray(data)) throw new Error();
+      return new Map(
+        Object.entries(data).map(([name, docs]) => {
+          if (typeof docs !== "object" || docs === null || Array.isArray(docs)) throw new Error();
+          for (const doc of Object.values(docs)) if (typeof doc !== "object" || doc === null || Array.isArray(doc)) throw new Error();
+          return [name, new Map(Object.entries(docs))];
+        })
+      );
+    } catch {
+      throw new FileStoreError("DAMAGED", `the database file is not valid JSON. Repair or remove it`);
+    }
+  }
+  async function save(snapshot) {
+    const text = JSON.stringify(Object.fromEntries([...snapshot].map(([name, docs]) => [name, Object.fromEntries(docs)])));
+    const temp = `${path}.${process.pid}.${randomUUID()}.tmp`;
+    try {
+      const handle = await open(temp, "w");
+      try {
+        await handle.writeFile(text);
+        await handle.sync();
+      } finally {
+        await handle.close();
+      }
+      await rename(temp, path);
+    } catch (error) {
+      await unlink(temp).catch(() => void 0);
+      throw error;
+    }
+  }
+  async function takeOverIfStale() {
+    let seen;
+    try {
+      seen = await readFile(lockPath, "utf8");
+    } catch {
+      return;
+    }
+    if (!lockIsStale(seen, staleAfterMs)) return;
+    const aside = `${lockPath}.stale.${randomUUID()}`;
+    try {
+      await rename(lockPath, aside);
+    } catch {
+      return;
+    }
+    if (await readFile(aside, "utf8").catch(() => "") !== seen) await link(aside, lockPath).catch(() => void 0);
+    await unlink(aside).catch(() => void 0);
+  }
+  async function acquire() {
+    const token = randomUUID();
+    const deadline = Date.now() + timeoutMs;
+    for (; ; ) {
+      try {
+        const handle = await open(lockPath, "wx");
+        try {
+          await handle.writeFile(JSON.stringify({ pid: process.pid, at: Date.now(), token }));
+        } finally {
+          await handle.close();
+        }
+        return token;
+      } catch (error) {
+        if (codeOf(error) !== "EEXIST") throw error;
+      }
+      await takeOverIfStale();
+      if (Date.now() > deadline) throw new FileStoreError("LOCKED", `the database file is locked. If no agentic-canvas process runs, remove the .lock file next to it`);
+      await sleep(5 + Math.random() * 15);
+    }
+  }
+  async function release(token) {
+    const text = await readFile(lockPath, "utf8").catch(() => "");
+    if (text.includes(`"token":"${token}"`)) await unlink(lockPath).catch(() => void 0);
+  }
+  async function memoryOf(snapshot, only) {
+    const memory = createMemoryStore({ region });
+    for (const [name, docs] of snapshot) if (only === void 0 || only === name) for (const [id, doc] of docs) await memory.put(name, id, doc);
+    return memory;
+  }
+  const recording = (inner, log) => ({
+    get: (collection, id) => inner.get(collection, id),
+    query: (collection, query) => inner.query(collection, query),
+    put: async (collection, id, doc) => {
+      await inner.put(collection, id, doc);
+      log.push([collection, id, clone(doc)]);
+    },
+    delete: async (collection, id) => {
+      await inner.delete(collection, id);
+      log.push([collection, id, null]);
+    }
+  });
+  const locked = (body) => {
+    const run = queue.then(async () => {
+      const token = await acquire();
+      try {
+        return await body();
+      } finally {
+        await release(token);
+      }
+    });
+    queue = run.catch(() => void 0);
+    return run;
+  };
+  async function commit(snapshot, log) {
+    for (const [name, id, doc] of log) {
+      if (doc === null) snapshot.get(name)?.delete(id);
+      else snapshot.set(name, (snapshot.get(name) ?? /* @__PURE__ */ new Map()).set(id, doc));
+    }
+    if (log.length > 0) await save(snapshot);
+  }
+  const writeOne = (write) => locked(async () => {
+    const log = [];
+    await write(recording(createMemoryStore({ region }), log));
+    await commit(await load(), log);
+  });
+  const watching = (inner, seen) => ({
+    ...inner,
+    async get(collection, id) {
+      const doc = await inner.get(collection, id);
+      if (!seen.has(`${collection}/${id}`)) seen.set(`${collection}/${id}`, JSON.stringify(doc));
+      return doc;
+    },
+    async query(collection, query) {
+      const page = await inner.query(collection, query);
+      for (const item of page.items) if (!seen.has(`${collection}/${item.id}`)) seen.set(`${collection}/${item.id}`, JSON.stringify(item.data));
+      return page;
+    }
+  });
+  const unchanged = (snapshot, seen) => [...seen].every(([key, text]) => {
+    const slash = key.indexOf("/");
+    return JSON.stringify(snapshot.get(key.slice(0, slash))?.get(key.slice(slash + 1)) ?? null) === text;
+  });
+  return {
+    region,
+    async get(collection, id) {
+      assertCollection(collection);
+      assertId(id);
+      const doc = (await load()).get(collection)?.get(id);
+      return doc ? clone(doc) : null;
+    },
+    async query(collection, query) {
+      assertCollection(collection);
+      return (await memoryOf(await load(), collection)).query(collection, query);
+    },
+    put: (collection, id, doc) => writeOne((ops) => ops.put(collection, id, doc)),
+    delete: (collection, id) => writeOne((ops) => ops.delete(collection, id)),
+    // Optimistic, as the port requires: run on a copy of the file with no lock, then take the lock and commit
+    // only if every doc the run read is unchanged. Else run again. The memory adapter keeps the rule that
+    // every read comes before the first write.
+    async transaction(fn) {
+      for (let run = 0; run < MAX_TRANSACTION_RUNS; run++) {
+        const log = [];
+        const seen = /* @__PURE__ */ new Map();
+        const result = await (await memoryOf(await load())).transaction(async (tx) => {
+          log.length = 0;
+          seen.clear();
+          return fn(watching(recording(tx, log), seen));
+        });
+        const done = log.length === 0 ? unchanged(await load(), seen) : await locked(async () => {
+          const current = await load();
+          if (!unchanged(current, seen)) return false;
+          await commit(current, log);
+          return true;
+        });
+        if (done) return result;
+      }
+      throw new StoreConflictError();
+    }
+  };
+}
+function openLocalStore(dir) {
+  mkdirSync(dir, { recursive: true });
+  return createFileStore(join(dir, STORE_FILE));
+}
+var STORE_FILE = "canvas.json";
+
+export {
+  createFileStore,
+  openLocalStore,
+  STORE_FILE
+};