@elixpo/lixsketch 5.6.1 → 5.6.3

package/src/mcp/stdio.js

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+
+import { createLixSketchMcpServer } from './server.js';
+import { FileSceneStore } from './fileStore.js';
+import { MarketplaceTemplateProvider } from './templates.js';
+import { serveLixSketchStdio } from './stdioTransport.js';
+import { RemoteSceneStore } from './remoteStore.js';
+
+function parseArguments(argv) {
+  const options = { 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') options.scene = argv[++index];
+    else if (argument === '--remote') options.remote = argv[++index];
+    else if (argument === '--workspace') options.workspace = argv[++index];
+    else if (argument === '--marketplace-url') options.marketplaceUrl = argv[++index];
+    else if (argument === '--help' || argument === '-h') options.help = true;
+    else throw new Error(`Unknown argument: ${argument}`);
+  }
+  if (!options.scene) throw new Error('--scene requires a file path');
+  if (options.remote && !options.workspace) throw new Error('--remote requires --workspace or LIXSKETCH_WORKSPACE_ID');
+  return options;
+}
+
+function printHelp() {
+  process.stderr.write(`LixSketch MCP server\n\nUsage:\n  lixsketch-mcp --scene ./diagram.lixjson\n  lixsketch-mcp --remote https://sketch.elixpo.com --workspace lx-...\n\nOptions:\n  --scene <path>             Atomic local .lixjson scene file\n  --remote <origin>          Remote LixSketch deployment origin\n  --workspace <id>           Remote workspace session ID\n  --marketplace-url <url>    Template marketplace origin\n  -h, --help                 Show this help\n\nRemote environment (never pass secrets as arguments):\n  LIXSKETCH_AGENT_TOKEN\n  LIXSKETCH_ENCRYPTION_KEY\n\nOther environment:\n  LIXSKETCH_SCENE_FILE\n  LIXSKETCH_REMOTE_URL\n  LIXSKETCH_WORKSPACE_ID\n  LIXSKETCH_MARKETPLACE_URL\n`);
+}
+
+async function main() {
+  const options = parseArguments(process.argv.slice(2));
+  if (options.help) { printHelp(); return; }
+  const store = options.remote
+    ? new RemoteSceneStore({ baseUrl: options.remote, workspaceId: options.workspace, token: process.env.LIXSKETCH_AGENT_TOKEN, encryptionKey: process.env.LIXSKETCH_ENCRYPTION_KEY })
+    : new FileSceneStore(options.scene);
+  const server = createLixSketchMcpServer({ store, templateProvider: new MarketplaceTemplateProvider({ baseUrl: options.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 || `${options.remote}/c/${options.workspace}`}\n`);
+  await transport.closed;
+}
+
+main().catch((error) => {
+  process.stderr.write(`LixSketch MCP failed: ${error?.message || error}\n`);
+  process.exitCode = 1;
+});

package/src/mcp/stdioTransport.js

@@ -0,0 +1,46 @@
+import { createInterface } from 'node:readline';
+
+const MAX_MESSAGE_BYTES = 10 * 1024 * 1024;
+
+export function serveLixSketchStdio(server, { input = process.stdin, output = process.stdout } = {}) {
+  if (!server?.handleRequest) throw new Error('A LixSketch MCP server is required');
+  const lines = createInterface({ input, crlfDelay: Infinity, terminal: false });
+  let processing = Promise.resolve();
+  let resolveClosed;
+  const closed = new Promise((resolve) => { resolveClosed = resolve; });
+  const send = (message) => output.write(`${JSON.stringify(message)}\n`);
+
+  lines.on('line', (line) => {
+    processing = processing.then(async () => {
+      if (!line.trim()) return;
+      if (Buffer.byteLength(line, 'utf8') > MAX_MESSAGE_BYTES) {
+        send({ jsonrpc: '2.0', id: null, error: { code: -32600, message: 'MCP request exceeds the 10 MB limit' } });
+        return;
+      }
+      let request;
+      try { request = JSON.parse(line); }
+      catch { send({ jsonrpc: '2.0', id: null, error: { code: -32700, message: 'Parse error' } }); return; }
+      if (request.jsonrpc !== '2.0' || typeof request.method !== 'string') {
+        if (request.id !== undefined) send({ jsonrpc: '2.0', id: request.id ?? null, error: { code: -32600, message: 'Invalid Request' } });
+        return;
+      }
+      try {
+        const result = await server.handleRequest(request);
+        if (request.id !== undefined && result !== undefined) send({ jsonrpc: '2.0', id: request.id, result });
+      } catch (error) {
+        if (request.id !== undefined) send({ jsonrpc: '2.0', id: request.id, error: { code: Number(error?.code) || -32603, message: error?.message || 'Internal error' } });
+      }
+    }).catch((error) => {
+      process.stderr.write(`LixSketch MCP transport error: ${error?.message || error}\n`);
+    });
+  });
+  lines.once('close', () => processing.finally(resolveClosed));
+
+  return {
+    closed,
+    close: async () => {
+      lines.close();
+      await processing;
+    },
+  };
+}

package/src/mcp/store.js

@@ -0,0 +1,23 @@
+import { createEmptyScene, validateScene } from './scene.js';
+
+export class MemorySceneStore {
+  #scene;
+
+  constructor(scene = createEmptyScene()) {
+    const validation = validateScene(scene);
+    if (!validation.valid) throw new Error(`Invalid initial scene: ${validation.errors.join('; ')}`);
+    this.#scene = structuredClone(scene);
+  }
+
+  async read() {
+    return structuredClone(this.#scene);
+  }
+
+  async write(scene) {
+    const validation = validateScene(scene);
+    if (!validation.valid) throw new Error(`Refusing to store invalid scene: ${validation.errors.join('; ')}`);
+    this.#scene = structuredClone(scene);
+    return this.read();
+  }
+}
+

package/src/mcp/templates.js

@@ -0,0 +1,51 @@
+const DEFAULT_MARKETPLACE_URL = 'https://sketch.elixpo.com';
+
+function decodeBase64Url(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));
+}
+
+export async function decryptPublicTemplate(ciphertext, keyValue) {
+  const keyBytes = decodeBase64Url(keyValue);
+  if (keyBytes.byteLength !== 32) throw new Error('Template key is not AES-256');
+  const combined = decodeBase64Url(ciphertext);
+  if (combined.byteLength < 28) throw new Error('Template ciphertext is invalid');
+  const key = await crypto.subtle.importKey('raw', keyBytes, { name: 'AES-GCM', length: 256 }, false, ['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));
+}
+
+export class MarketplaceTemplateProvider {
+  constructor({ baseUrl = DEFAULT_MARKETPLACE_URL, fetchImpl = globalThis.fetch } = {}) {
+    if (typeof fetchImpl !== 'function') throw new Error('MarketplaceTemplateProvider requires fetch');
+    this.baseUrl = String(baseUrl).replace(/\/$/, '');
+    this.fetch = fetchImpl;
+  }
+
+  async search({ query = '', tag = '', limit = 12 } = {}) {
+    const url = new URL('/api/templates', this.baseUrl);
+    if (query) url.searchParams.set('q', String(query).slice(0, 80));
+    if (tag) url.searchParams.set('tag', String(tag).slice(0, 24));
+    url.searchParams.set('limit', String(Math.min(24, Math.max(1, Number(limit) || 12))));
+    const response = await this.fetch(url, { headers: { accept: 'application/json' } });
+    const body = await response.json();
+    if (!response.ok) throw new Error(body.error || `Marketplace request failed (${response.status})`);
+    return body.templates || [];
+  }
+
+  async load(slug) {
+    const safeSlug = String(slug || '').trim();
+    if (!/^[a-z0-9-]{1,80}$/.test(safeSlug)) throw new Error('Template slug is invalid');
+    const url = new URL(`/api/templates/${encodeURIComponent(safeSlug)}`, this.baseUrl);
+    url.searchParams.set('snapshot', '1');
+    const response = await this.fetch(url, { headers: { accept: 'application/json' } });
+    const body = await response.json();
+    if (!response.ok) throw new Error(body.error || `Template request failed (${response.status})`);
+    const template = body.template;
+    if (!template?.encryptedData || !template?.publicKey) throw new Error('Template snapshot is unavailable');
+    return { metadata: { ...template, encryptedData: undefined, publicKey: undefined, encryptedDocData: undefined }, scene: await decryptPublicTemplate(template.encryptedData, template.publicKey) };
+  }
+}
+