@elixpo/lixsketch 5.6.2 → 5.6.3

package/dist/mcp/stdio.js

@@ -187,12 +187,23 @@ function applyScenePatch(sceneInput, operations, { expectedRevision, dryRun = fa
       scene.name = String(operation.name || "").trim().slice(0, 72) || scene.name;
     } else throw new Error(`Unsupported operation "${operation.op}"`);
   }
+  reconcileFrameContainment(scene);
   scene.mcpRevision = revision + 1;
   scene.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
   const result = validateScene(scene);
   if (!result.valid) throw new Error(`Patch produced an invalid scene: ${result.errors.join("; ")}`);
   return { scene, revision: scene.mcpRevision, dryRun: Boolean(dryRun), changedShapeIDs: [...changedIds] };
 }
+function reconcileFrameContainment(scene) {
+  const frames = new Map(scene.shapes.filter((shape) => shape.type === "frame").map((shape) => [shape.shapeID, shape]));
+  for (const frame of frames.values()) frame.containedShapeIDs = [];
+  for (const shape of scene.shapes) {
+    if (!shape.parentFrame) continue;
+    const frame = frames.get(shape.parentFrame);
+    if (!frame) throw new Error(`Shape "${shape.shapeID}" references missing frame "${shape.parentFrame}"`);
+    frame.containedShapeIDs.push(shape.shapeID);
+  }
+}
 function applyShapeChanges(shape, changes) {
   if (!changes || typeof changes !== "object" || Array.isArray(changes)) throw new Error("Shape changes must be an object");
   const allowed = {
@@ -263,9 +274,9 @@ function mergeTemplateScene(sceneInput, templateInput, { x, y } = {}) {
   const validation = validateScene(template);
   if (!validation.valid) throw new Error(`Template scene is invalid: ${validation.errors.join("; ")}`);
   if (scene.shapes.length + template.shapes.length > MAX_SHAPES) throw new Error(`Imported template would exceed ${MAX_SHAPES} shapes`);
-  const bounds = getSceneBounds(template) || { x: 0, y: 0 };
+  const bounds2 = getSceneBounds(template) || { x: 0, y: 0 };
   const targetX = finite(x, scene.viewport?.x || 0), targetY = finite(y, scene.viewport?.y || 0);
-  const dx = targetX - bounds.x, dy = targetY - bounds.y;
+  const dx = targetX - bounds2.x, dy = targetY - bounds2.y;
   const idMap = new Map(template.shapes.map((shape) => [shape.shapeID, `${shape.type}-${crypto.randomUUID()}`]));
   const imported = template.shapes.map((shape) => {
     const moved = translateShape(shape, dx, dy);
@@ -357,9 +368,9 @@ function renderShape(shape) {
   return "";
 }
 function renderSceneSvg(scene, { background = "#15111f", padding = 40 } = {}) {
-  const bounds = getSceneBounds(scene) || { x: 0, y: 0, width: 1280, height: 720 };
+  const bounds2 = getSceneBounds(scene) || { x: 0, y: 0, width: 1280, height: 720 };
   const pad = Math.max(0, Math.min(200, Number(padding) || 0));
-  const viewBox = { x: bounds.x - pad, y: bounds.y - pad, width: Math.max(1, bounds.width + pad * 2), height: Math.max(1, bounds.height + pad * 2) };
+  const viewBox = { x: bounds2.x - pad, y: bounds2.y - pad, width: Math.max(1, bounds2.width + pad * 2), height: Math.max(1, bounds2.height + pad * 2) };
   const svg = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="${viewBox.x} ${viewBox.y} ${viewBox.width} ${viewBox.height}" width="${Math.ceil(viewBox.width)}" height="${Math.ceil(viewBox.height)}"><defs><marker id="arrowhead" markerWidth="10" markerHeight="7" refX="9" refY="3.5" orient="auto"><polygon points="0 0,10 3.5,0 7" fill="#8b76d6"/></marker></defs><rect x="${viewBox.x}" y="${viewBox.y}" width="${viewBox.width}" height="${viewBox.height}" fill="${color(background, "#15111f")}"/>${(scene.shapes || []).map(renderShape).join("")}</svg>`;
   if (new TextEncoder().encode(svg).byteLength > MAX_PREVIEW_BYTES) {
     throw new Error("Canvas preview exceeds the 5 MB output limit");
@@ -367,9 +378,349 @@ function renderSceneSvg(scene, { background = "#15111f", padding = 40 } = {}) {
   return svg;
 }
 
+// src/core/LixScriptParser.js
+function tokenize(source) {
+  const tokens = [];
+  const lines = source.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i];
+    const lineNum = i + 1;
+    const commentIdx = raw.indexOf("//");
+    const line = commentIdx !== -1 ? raw.slice(0, commentIdx) : raw;
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    tokens.push({ type: "LINE", value: trimmed, line: lineNum });
+  }
+  return tokens;
+}
+function parseLixScript(source) {
+  const tokens = tokenize(source);
+  const variables = {};
+  const shapes = [];
+  const errors = [];
+  let i = 0;
+  while (i < tokens.length) {
+    const token = tokens[i];
+    const line = token.value;
+    const lineNum = token.line;
+    try {
+      if (line.startsWith("$")) {
+        const match = line.match(/^\$(\w+)\s*=\s*(.+)$/);
+        if (match) {
+          variables[match[1]] = match[2].trim();
+        } else {
+          errors.push({ line: lineNum, message: `Invalid variable syntax: ${line}` });
+        }
+        i++;
+        continue;
+      }
+      const shapeMatch = line.match(/^(rect|circle|ellipse|arrow|line|text|frame|freehand|image|icon)\s+(\w+)\s+(.+)$/);
+      if (shapeMatch) {
+        const [, type, id, rest] = shapeMatch;
+        const shape = parseShapeDeclaration(type, id, rest, lineNum, errors, variables);
+        if (rest.includes("{") && !rest.includes("}")) {
+          i++;
+          const props = [];
+          while (i < tokens.length && !tokens[i].value.startsWith("}")) {
+            props.push(tokens[i].value);
+            i++;
+          }
+          if (i < tokens.length) i++;
+          parseProperties(shape, props, variables, errors);
+        } else if (rest.includes("{") && rest.includes("}")) {
+          const blockMatch = rest.match(/\{([^}]*)\}/);
+          if (blockMatch) {
+            const props = blockMatch[1].split(/[,;]/).map((s) => s.trim()).filter(Boolean);
+            parseProperties(shape, props, variables, errors);
+          }
+          i++;
+        } else {
+          i++;
+        }
+        shapes.push(shape);
+        continue;
+      }
+      errors.push({ line: lineNum, message: `Unrecognized syntax: ${line}` });
+      i++;
+    } catch (err) {
+      errors.push({ line: lineNum, message: err.message });
+      i++;
+    }
+  }
+  return { variables, shapes, errors };
+}
+function parseShapeDeclaration(type, id, rest, lineNum, errors, variables) {
+  const shape = { type, id, line: lineNum, props: {} };
+  if (type === "arrow" || type === "line") {
+    const connMatch = rest.match(/from\s+(.+?)\s+to\s+(.+?)(?:\s*\{|$)/);
+    if (connMatch) {
+      shape.from = parsePointOrRef(connMatch[1].trim(), variables);
+      shape.to = parsePointOrRef(connMatch[2].trim(), variables);
+    } else {
+      errors.push({ line: lineNum, message: `${type} requires 'from ... to ...' syntax` });
+    }
+  } else {
+    const atMatch = rest.match(/at\s+([\w$.+\-*\s]+?),\s*([\w$.+\-*\s]+?)(?:\s+size|\s*\{|$)/);
+    if (atMatch) {
+      shape.x = parseExpr(atMatch[1].trim(), variables);
+      shape.y = parseExpr(atMatch[2].trim(), variables);
+    } else if (type !== "frame") {
+      errors.push({ line: lineNum, message: `${type} requires 'at X, Y' syntax` });
+    }
+    const sizeMatch = rest.match(/size\s+([\w$.+\-*]+)\s*x\s*([\w$.+\-*]+)/);
+    if (sizeMatch) {
+      shape.width = parseExpr(sizeMatch[1].trim(), variables);
+      shape.height = parseExpr(sizeMatch[2].trim(), variables);
+    }
+  }
+  return shape;
+}
+function parsePointOrRef(str, variables) {
+  const refMatch = str.match(/^(\w+)\.(\w+)(?:\s*([+-])\s*([\d.]+))?$/);
+  if (refMatch) {
+    return {
+      ref: refMatch[1],
+      side: refMatch[2],
+      offset: refMatch[3] ? parseFloat((refMatch[3] === "-" ? "-" : "") + refMatch[4]) : 0
+    };
+  }
+  const coordMatch = str.match(/^([\d.]+)\s*,?\s*([\d.]+)$/);
+  if (coordMatch) {
+    return { x: parseFloat(coordMatch[1]), y: parseFloat(coordMatch[2]) };
+  }
+  if (/^\w+$/.test(str)) {
+    return { ref: str, side: "center", offset: 0 };
+  }
+  return { x: 0, y: 0 };
+}
+function parseExpr(str, variables) {
+  let resolved = str.replace(/\$(\w+)/g, (_, name) => {
+    return variables[name] !== void 0 ? variables[name] : "0";
+  });
+  const num = parseFloat(resolved);
+  if (!isNaN(num) && String(num) === resolved.trim()) {
+    return num;
+  }
+  if (/\w+\.\w+/.test(resolved)) {
+    return { expr: resolved };
+  }
+  const arithMatch = resolved.match(/^([\d.]+)\s*([+-])\s*([\d.]+)$/);
+  if (arithMatch) {
+    const a = parseFloat(arithMatch[1]);
+    const b = parseFloat(arithMatch[3]);
+    return arithMatch[2] === "+" ? a + b : a - b;
+  }
+  return isNaN(num) ? 0 : num;
+}
+function parseProperties(shape, lines, variables, errors) {
+  for (const line of lines) {
+    const propMatch = line.match(/^(\w+)\s*:\s*(.+)$/);
+    if (!propMatch) continue;
+    let [, key, value] = propMatch;
+    value = value.trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    value = value.replace(/\$(\w+)/g, (_, name) => {
+      return variables[name] !== void 0 ? variables[name] : value;
+    });
+    const num = parseFloat(value);
+    if (!isNaN(num) && String(num) === value) {
+      shape.props[key] = num;
+    } else if (value === "true") {
+      shape.props[key] = true;
+    } else if (value === "false") {
+      shape.props[key] = false;
+    } else {
+      shape.props[key] = value;
+    }
+  }
+}
+function resolveShapeRefs(shapes) {
+  const shapeMap = /* @__PURE__ */ new Map();
+  const MAX_PASSES = 10;
+  for (let pass = 0; pass < MAX_PASSES; pass++) {
+    let progress = false;
+    for (const s of shapes) {
+      if (typeof s.x === "number" && typeof s.y === "number" && !shapeMap.has(s.id)) {
+        shapeMap.set(s.id, s);
+        progress = true;
+      }
+    }
+    let anyUnresolved = false;
+    for (const s of shapes) {
+      if (s.x && typeof s.x === "object" && s.x.expr) {
+        const resolved = resolveExpr(s.x.expr, shapeMap);
+        if (typeof resolved === "number" && !isNaN(resolved)) {
+          s.x = resolved;
+          progress = true;
+        } else {
+          anyUnresolved = true;
+        }
+      }
+      if (s.y && typeof s.y === "object" && s.y.expr) {
+        const resolved = resolveExpr(s.y.expr, shapeMap);
+        if (typeof resolved === "number" && !isNaN(resolved)) {
+          s.y = resolved;
+          progress = true;
+        } else {
+          anyUnresolved = true;
+        }
+      }
+    }
+    if (!anyUnresolved || !progress) break;
+  }
+  for (const s of shapes) {
+    if (s.x && typeof s.x === "object" && s.x.expr) s.x = 0;
+    if (s.y && typeof s.y === "object" && s.y.expr) s.y = 0;
+  }
+}
+function resolveExpr(expr, shapeMap) {
+  const m = expr.match(/^(\w+)\.(\w+)(?:\s*([+-])\s*([\d.]+))?$/);
+  if (!m) return NaN;
+  const [, ref, prop, op, offsetStr] = m;
+  const shape = shapeMap.get(ref);
+  if (!shape) return NaN;
+  let val = 0;
+  switch (prop) {
+    case "x":
+      val = shape.x || 0;
+      break;
+    case "y":
+      val = shape.y || 0;
+      break;
+    case "right":
+      val = (shape.x || 0) + (shape.width || 0);
+      break;
+    case "left":
+      val = shape.x || 0;
+      break;
+    case "top":
+      val = shape.y || 0;
+      break;
+    case "bottom":
+      val = (shape.y || 0) + (shape.height || 0);
+      break;
+    case "centerX":
+      val = (shape.x || 0) + (shape.width || 0) / 2;
+      break;
+    case "centerY":
+      val = (shape.y || 0) + (shape.height || 0) / 2;
+      break;
+    case "width":
+      val = shape.width || 0;
+      break;
+    case "height":
+      val = shape.height || 0;
+      break;
+    default:
+      val = 0;
+  }
+  const offset = offsetStr ? parseFloat(offsetStr) : 0;
+  return op === "-" ? val - offset : val + offset;
+}
+
+// src/mcp/lixscript.js
+var MAX_SOURCE_LENGTH = 1e5;
+function options2(def) {
+  return {
+    stroke: def.props.stroke || def.props.color || "#8b76d6",
+    strokeWidth: Number(def.props.strokeWidth) || 2,
+    fill: def.props.fill || "transparent",
+    fillStyle: def.props.fillStyle || "solid",
+    roughness: def.props.roughness === void 0 ? 1.2 : Number(def.props.roughness),
+    opacity: def.props.opacity === void 0 ? 1 : Number(def.props.opacity)
+  };
+}
+function bounds(def) {
+  const width = Number(def.width) || (def.type === "frame" ? 600 : def.type === "rect" ? 160 : 80);
+  const height = Number(def.height) || (def.type === "frame" ? 400 : def.type === "rect" ? 60 : 80);
+  return { x: Number(def.x) || 0, y: Number(def.y) || 0, width, height };
+}
+function endpoint(point2, definitions) {
+  if (Number.isFinite(point2?.x) && Number.isFinite(point2?.y)) return { x: point2.x, y: point2.y };
+  const target = definitions.get(point2?.ref);
+  if (!target) throw new Error(`Cannot resolve LixScript connection target "${point2?.ref || ""}"`);
+  const box = bounds(target);
+  const offset = Number(point2.offset) || 0;
+  const side = point2.side || "center";
+  if (side === "top") return { x: box.x + box.width / 2 + offset, y: box.y };
+  if (side === "bottom") return { x: box.x + box.width / 2 + offset, y: box.y + box.height };
+  if (side === "left") return { x: box.x, y: box.y + box.height / 2 + offset };
+  if (side === "right") return { x: box.x + box.width, y: box.y + box.height / 2 + offset };
+  return { x: box.x + box.width / 2 + offset, y: box.y + box.height / 2 };
+}
+function labelShape(def, shapeID, parentFrame) {
+  if (!def.props.label) return null;
+  const box = bounds(def);
+  return {
+    type: "text",
+    shapeID: `${shapeID}-label`,
+    x: box.x + box.width / 2,
+    y: box.y + box.height / 2,
+    text: String(def.props.label),
+    fontSize: Number(def.props.labelFontSize) || 14,
+    color: def.props.labelColor || "#e8e3f3",
+    parentFrame
+  };
+}
+function compileLixScript(source, { x = 0, y = 0 } = {}) {
+  const input = String(source || "");
+  if (!input.trim()) throw new Error("LixScript source is required");
+  if (input.length > MAX_SOURCE_LENGTH) throw new Error("LixScript source exceeds 100 KB");
+  const parsed = parseLixScript(input);
+  if (parsed.errors.length) throw new Error(`LixScript parse failed: ${parsed.errors.map((entry) => `line ${entry.line}: ${entry.message}`).join("; ")}`);
+  resolveShapeRefs(parsed.shapes);
+  const prefix = `lix-${crypto.randomUUID().slice(0, 8)}`;
+  const shapeId = (id) => `${prefix}-${id}`;
+  const definitions = new Map(parsed.shapes.map((shape) => [shape.id, shape]));
+  const frame = parsed.shapes.find((shape) => shape.type === "frame");
+  const frameId = frame ? shapeId(frame.id) : `${prefix}-frame`;
+  const frameMembers = frame?.props.contains ? new Set(String(frame.props.contains).split(",").map((value) => value.trim()).filter(Boolean)) : null;
+  const shapes = [];
+  for (const def of parsed.shapes) {
+    const box = bounds(def);
+    const parentFrame = def === frame || frameMembers && !frameMembers.has(def.id) ? null : frameId;
+    let shape;
+    const id = shapeId(def.id);
+    if (def.type === "rect") shape = { type: "rectangle", shapeID: id, x: box.x + x, y: box.y + y, width: box.width, height: box.height, rotation: Number(def.props.rotation) || 0, options: options2(def), parentFrame };
+    else if (def.type === "circle" || def.type === "ellipse") shape = { type: "circle", shapeID: id, x: box.x + box.width / 2 + x, y: box.y + box.height / 2 + y, rx: box.width / 2, ry: box.height / 2, rotation: Number(def.props.rotation) || 0, options: options2(def), parentFrame };
+    else if (def.type === "text") shape = { type: "text", shapeID: id, x: box.x + x, y: box.y + y, text: String(def.props.content || def.props.text || "Text"), fontSize: Number(def.props.fontSize) || 16, color: def.props.color || def.props.fill || "#e8e3f3", fontFamily: def.props.fontFamily || "lixFont", parentFrame };
+    else if (def.type === "frame") shape = { type: "frame", shapeID: id, x: box.x + x, y: box.y + y, width: box.width, height: box.height, frameName: String(def.props.frameName || def.props.name || def.id), fillStyle: def.props.fillStyle || "transparent", fillColor: def.props.fillColor || def.props.fill || "#1e1e28", options: options2(def) };
+    else if (def.type === "freehand") {
+      const points = String(def.props.points || "").split(";").map((value) => value.split(",").map(Number)).filter((point2) => point2.length >= 2 && point2.every(Number.isFinite)).map(([px, py, pressure = 0.5]) => [px + x, py + y, pressure]);
+      shape = { type: "freehandStroke", shapeID: id, points, options: options2(def), parentFrame };
+    } else if (def.type === "line" || def.type === "arrow") {
+      const startPoint = endpoint(def.from, definitions), endPoint = endpoint(def.to, definitions);
+      startPoint.x += x;
+      startPoint.y += y;
+      endPoint.x += x;
+      endPoint.y += y;
+      shape = def.type === "line" ? { type: "line", shapeID: id, startPoint, endPoint, isCurved: def.props.curve === true || def.props.curve === "true", options: options2(def), parentFrame } : { type: "arrow", shapeID: id, startPoint, endPoint, arrowHeadStyle: def.props.head || "triangle", arrowOutlineStyle: def.props.style || "solid", arrowCurved: def.props.curve && def.props.curve !== "straight", arrowCurveAmount: Number(def.props.curveAmount) || 0.2, options: options2(def), parentFrame };
+    } else throw new Error(`LixScript ${def.type} is not writable through MCP`);
+    shapes.push(shape);
+    const label = labelShape(def, id, parentFrame);
+    if (label) {
+      label.x += x;
+      label.y += y;
+      shapes.push(label);
+    }
+  }
+  if (!frame && shapes.length) {
+    const boxes = parsed.shapes.filter((def) => !["arrow", "line"].includes(def.type)).map(bounds);
+    const pointShapes = shapes.filter((shape) => shape.startPoint && shape.endPoint);
+    const minX = boxes.length ? Math.min(...boxes.map((box) => box.x)) + x : Math.min(...pointShapes.flatMap((shape) => [shape.startPoint.x, shape.endPoint.x]));
+    const minY = boxes.length ? Math.min(...boxes.map((box) => box.y)) + y : Math.min(...pointShapes.flatMap((shape) => [shape.startPoint.y, shape.endPoint.y]));
+    const maxX = boxes.length ? Math.max(...boxes.map((box) => box.x + box.width)) + x : Math.max(...pointShapes.flatMap((shape) => [shape.startPoint.x, shape.endPoint.x]));
+    const maxY = boxes.length ? Math.max(...boxes.map((box) => box.y + box.height)) + y : Math.max(...pointShapes.flatMap((shape) => [shape.startPoint.y, shape.endPoint.y]));
+    shapes.unshift({ type: "frame", shapeID: frameId, x: minX - 40, y: minY - 40, width: Math.max(80, maxX - minX + 80), height: Math.max(80, maxY - minY + 80), frameName: "LixScript", fillStyle: "transparent", fillColor: "#1e1e28" });
+  }
+  return { shapes, operations: shapes.map((shape) => ({ op: "add", shape })), sourceShapeCount: parsed.shapes.length };
+}
+
 // src/mcp/server.js
 var SERVER_NAME = "lixsketch";
-var SERVER_VERSION = "1.0.0";
+var SERVER_VERSION = "1.1.0";
 var PROTOCOL_VERSION = "2025-11-25";
 var SUPPORTED_PROTOCOL_VERSIONS = /* @__PURE__ */ new Set([PROTOCOL_VERSION, "2025-06-18", "2024-11-05"]);
 var PATCH_OPERATION_SCHEMA = {
@@ -417,6 +768,13 @@ var LIXSKETCH_MCP_TOOLS = Object.freeze([
     inputSchema: { type: "object", required: ["confirm"], properties: { name: { type: "string", maxLength: 72 }, confirm: { const: true } }, additionalProperties: false },
     annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false }
   },
+  {
+    name: "lixscript_apply",
+    title: "Apply LixScript diagram",
+    description: "Compile LixScript into the same validated atomic scene patch used by structured canvas edits. Supports revisions and dry runs.",
+    inputSchema: { type: "object", required: ["source"], properties: { source: { type: "string", maxLength: 1e5 }, x: { type: "number" }, y: { type: "number" }, expectedRevision: { type: "integer", minimum: 0 }, dryRun: { type: "boolean", default: false } }, additionalProperties: false },
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
+  },
   {
     name: "templates_search",
     title: "Search LixSketch templates",
@@ -489,10 +847,20 @@ var LixSketchMcpServer = class {
         case "canvas_new":
           if (args.confirm !== true) throw new Error("canvas_new requires confirm=true");
           return await this.enqueueMutation(async () => {
+            const current = await this.store.read();
             const scene = createEmptyScene(args.name);
+            scene.mcpRevision = Number(current.mcpRevision || 0) + 1;
             await this.store.write(scene);
             return toolResult({ summary: getSceneSummary(scene) }, "Blank canvas created.");
           });
+        case "lixscript_apply":
+          return await this.enqueueMutation(async () => {
+            const scene = await this.store.read();
+            const compiled = compileLixScript(args.source, args);
+            const result = applyScenePatch(scene, compiled.operations, args);
+            if (!args.dryRun) await this.store.write(result.scene);
+            return toolResult({ revision: result.revision, dryRun: result.dryRun, sourceShapeCount: compiled.sourceShapeCount, createdShapeIDs: result.changedShapeIDs, summary: getSceneSummary(result.scene) }, args.dryRun ? "LixScript is valid. No changes were saved." : `LixScript added ${result.changedShapeIDs.length} canvas elements.`);
+          });
         case "template_insert":
           return await this.enqueueMutation(async () => {
             const scene = await this.store.read();
@@ -544,8 +912,8 @@ function encodeBase64(value) {
   if (typeof btoa === "function") return btoa(unescape(encodeURIComponent(value)));
   return Buffer.from(value, "utf8").toString("base64");
 }
-function createLixSketchMcpServer(options2) {
-  return new LixSketchMcpServer(options2);
+function createLixSketchMcpServer(options3) {
+  return new LixSketchMcpServer(options3);
 }
 
 // src/mcp/fileStore.js
@@ -668,50 +1036,149 @@ function serveLixSketchStdio(server, { input = process.stdin, output = process.s
   };
 }
 
+// src/mcp/remoteStore.js
+function decodeBase64Url2(value) {
+  const base64 = String(value).replaceAll("-", "+").replaceAll("_", "/");
+  const padded = base64 + "=".repeat((4 - base64.length % 4) % 4);
+  const binary = atob(padded);
+  return Uint8Array.from(binary, (character) => character.charCodeAt(0));
+}
+function encodeBase64Url(bytes) {
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
+}
+async function importWorkspaceKey(keyValue, usages) {
+  const bytes = decodeBase64Url2(keyValue);
+  if (bytes.byteLength !== 32) throw new Error("The workspace encryption key is not AES-256");
+  return crypto.subtle.importKey("raw", bytes, { name: "AES-GCM", length: 256 }, false, usages);
+}
+async function decryptRemoteScene(ciphertext, keyValue) {
+  const combined = decodeBase64Url2(ciphertext);
+  if (combined.byteLength < 28) throw new Error("The encrypted workspace payload is invalid");
+  const key = await importWorkspaceKey(keyValue, ["decrypt"]);
+  const plaintext = await crypto.subtle.decrypt({ name: "AES-GCM", iv: combined.slice(0, 12) }, key, combined.slice(12));
+  return JSON.parse(new TextDecoder().decode(plaintext));
+}
+async function encryptRemoteScene(scene, keyValue) {
+  const key = await importWorkspaceKey(keyValue, ["encrypt"]);
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+  const plaintext = new TextEncoder().encode(JSON.stringify(scene));
+  const ciphertext = new Uint8Array(await crypto.subtle.encrypt({ name: "AES-GCM", iv }, key, plaintext));
+  const combined = new Uint8Array(iv.byteLength + ciphertext.byteLength);
+  combined.set(iv);
+  combined.set(ciphertext, iv.byteLength);
+  return encodeBase64Url(combined);
+}
+var RemoteSceneStore = class {
+  constructor({ baseUrl = "https://sketch.elixpo.com", workspaceId, token, encryptionKey, fetchImpl = globalThis.fetch } = {}) {
+    if (!workspaceId) throw new Error("RemoteSceneStore requires workspaceId");
+    if (!token) throw new Error("RemoteSceneStore requires an agent grant token");
+    if (!encryptionKey) throw new Error("RemoteSceneStore requires the workspace encryption key");
+    if (typeof fetchImpl !== "function") throw new Error("RemoteSceneStore requires fetch");
+    this.url = new URL(`/api/mcp/workspaces/${encodeURIComponent(workspaceId)}`, String(baseUrl).replace(/\/$/, ""));
+    this.workspaceId = workspaceId;
+    this.token = token;
+    this.encryptionKey = encryptionKey;
+    this.fetch = fetchImpl;
+    this.remoteRevision = null;
+  }
+  async read() {
+    const response = await this.fetch(this.url, { headers: this.headers(), cache: "no-store" });
+    const body = await readJson(response);
+    if (!response.ok) throw remoteError(response, body);
+    const scene = await decryptRemoteScene(body.encryptedData, this.encryptionKey);
+    const validation = validateScene(scene);
+    if (!validation.valid) throw new Error(`Remote workspace is invalid: ${validation.errors.join("; ")}`);
+    this.remoteRevision = Number(body.revision || 0);
+    scene.mcpRevision = this.remoteRevision;
+    return scene;
+  }
+  async write(scene) {
+    const validation = validateScene(scene);
+    if (!validation.valid) throw new Error(`Refusing to store invalid remote scene: ${validation.errors.join("; ")}`);
+    if (!Number.isInteger(this.remoteRevision)) throw new Error("Read the remote workspace before writing it");
+    const encryptedData = await encryptRemoteScene(scene, this.encryptionKey);
+    const response = await this.fetch(this.url, {
+      method: "PUT",
+      headers: { ...this.headers(), "Content-Type": "application/json" },
+      body: JSON.stringify({ encryptedData, expectedRevision: this.remoteRevision, workspaceName: scene.name })
+    });
+    const body = await readJson(response);
+    if (!response.ok) throw remoteError(response, body);
+    this.remoteRevision = Number(body.revision);
+    return structuredClone({ ...scene, mcpRevision: this.remoteRevision });
+  }
+  headers() {
+    return { Accept: "application/json", Authorization: `Bearer ${this.token}` };
+  }
+};
+async function readJson(response) {
+  return response.json().catch(() => ({}));
+}
+function remoteError(response, body) {
+  const error = new Error(body.error === "REVISION_CONFLICT" ? `Revision conflict: expected ${body.expectedRevision}, current ${body.currentRevision}` : body.error || `Remote workspace request failed (${response.status})`);
+  error.status = response.status;
+  error.details = body;
+  return error;
+}
+
 // src/mcp/stdio.js
 function parseArguments(argv) {
-  const options2 = { scene: process.env.LIXSKETCH_SCENE_FILE || "./lixsketch-mcp.lixjson", marketplaceUrl: process.env.LIXSKETCH_MARKETPLACE_URL || "https://sketch.elixpo.com" };
+  const options3 = { scene: process.env.LIXSKETCH_SCENE_FILE || "./lixsketch-mcp.lixjson", remote: process.env.LIXSKETCH_REMOTE_URL || "", workspace: process.env.LIXSKETCH_WORKSPACE_ID || "", marketplaceUrl: process.env.LIXSKETCH_MARKETPLACE_URL || "https://sketch.elixpo.com" };
   for (let index = 0; index < argv.length; index += 1) {
     const argument = argv[index];
-    if (argument === "--scene") options2.scene = argv[++index];
-    else if (argument === "--marketplace-url") options2.marketplaceUrl = argv[++index];
-    else if (argument === "--help" || argument === "-h") options2.help = true;
+    if (argument === "--scene") options3.scene = argv[++index];
+    else if (argument === "--remote") options3.remote = argv[++index];
+    else if (argument === "--workspace") options3.workspace = argv[++index];
+    else if (argument === "--marketplace-url") options3.marketplaceUrl = argv[++index];
+    else if (argument === "--help" || argument === "-h") options3.help = true;
     else throw new Error(`Unknown argument: ${argument}`);
   }
-  if (!options2.scene) throw new Error("--scene requires a file path");
-  return options2;
+  if (!options3.scene) throw new Error("--scene requires a file path");
+  if (options3.remote && !options3.workspace) throw new Error("--remote requires --workspace or LIXSKETCH_WORKSPACE_ID");
+  return options3;
 }
 function printHelp() {
   process.stderr.write(`LixSketch MCP server
 
 Usage:
   lixsketch-mcp --scene ./diagram.lixjson
+  lixsketch-mcp --remote https://sketch.elixpo.com --workspace lx-...
 
 Options:
-  --scene <path>             Atomic .lixjson scene file (default: ./lixsketch-mcp.lixjson)
+  --scene <path>             Atomic local .lixjson scene file
+  --remote <origin>          Remote LixSketch deployment origin
+  --workspace <id>           Remote workspace session ID
   --marketplace-url <url>    Template marketplace origin
   -h, --help                 Show this help
 
-Environment:
+Remote environment (never pass secrets as arguments):
+  LIXSKETCH_AGENT_TOKEN
+  LIXSKETCH_ENCRYPTION_KEY
+
+Other environment:
   LIXSKETCH_SCENE_FILE
+  LIXSKETCH_REMOTE_URL
+  LIXSKETCH_WORKSPACE_ID
   LIXSKETCH_MARKETPLACE_URL
 `);
 }
 async function main() {
-  const options2 = parseArguments(process.argv.slice(2));
-  if (options2.help) {
+  const options3 = parseArguments(process.argv.slice(2));
+  if (options3.help) {
     printHelp();
     return;
   }
-  const store = new FileSceneStore(options2.scene);
-  const server = createLixSketchMcpServer({ store, templateProvider: new MarketplaceTemplateProvider({ baseUrl: options2.marketplaceUrl }) });
+  const store = options3.remote ? new RemoteSceneStore({ baseUrl: options3.remote, workspaceId: options3.workspace, token: process.env.LIXSKETCH_AGENT_TOKEN, encryptionKey: process.env.LIXSKETCH_ENCRYPTION_KEY }) : new FileSceneStore(options3.scene);
+  const server = createLixSketchMcpServer({ store, templateProvider: new MarketplaceTemplateProvider({ baseUrl: options3.marketplaceUrl }) });
   const transport = serveLixSketchStdio(server);
   const close = () => {
     void transport.close().finally(() => process.exit(0));
   };
   process.once("SIGINT", close);
   process.once("SIGTERM", close);
-  process.stderr.write(`LixSketch MCP ready: ${store.filePath}
+  process.stderr.write(`LixSketch MCP ready: ${store.filePath || `${options3.remote}/c/${options3.workspace}`}
 `);
   await transport.closed;
 }