@atlisp/mcp 1.3.0 → 1.3.1

package/dist/cad-worker.js

@@ -0,0 +1,221 @@
+#!/usr/bin/env node
+
+// src/cad-worker.js
+import edge from "edge-js";
+import process from "process";
+import fs from "fs";
+import path from "path";
+var BUSY_RETRIES = parseInt(process.env.BUSY_RETRIES || "10", 10);
+var BUSY_DELAY = parseInt(process.env.BUSY_DELAY || "500", 10);
+var DEBUG_FILE = process.env.DEBUG_FILE || path.join(process.env.TEMP || "/tmp", "cad-worker-debug.log");
+function log(msg) {
+  const entry = `${(/* @__PURE__ */ new Date()).toISOString()} ${msg}
+`;
+  if (process.env.DEBUG) {
+    fs.appendFile(DEBUG_FILE, entry, () => {
+    });
+  }
+}
+var cadConnect = edge.func(function() {
+});
+var cadLaunch = edge.func(function() {
+});
+var cadSend = edge.func(function() {
+});
+var cadSendWithResult = edge.func(function() {
+});
+process.stdin.setEncoding("utf8");
+var stdinBuffer = "";
+process.stdin.on("data", (data) => {
+  stdinBuffer += data;
+  const lines = stdinBuffer.split("\n");
+  stdinBuffer = lines.pop() || "";
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    try {
+      const msg = JSON.parse(line);
+      const requestId = msg.requestId;
+      handleMessage(msg).then((result) => {
+        process.stdout.write(JSON.stringify({ ...result, requestId }) + "\n");
+      }).catch((err) => {
+        process.stdout.write(JSON.stringify({ error: err.message, requestId }) + "\n");
+      });
+    } catch (e) {
+      process.stdout.write(JSON.stringify({ error: "invalid message" }) + "\n");
+    }
+  }
+});
+var cadIsBusy = edge.func(function() {
+});
+var cadHasDoc = edge.func(function() {
+});
+var cadNewDoc = edge.func(function() {
+});
+var cadBringToFront = edge.func(function() {
+});
+async function waitForIdle(platform) {
+  let retries = BUSY_RETRIES;
+  while (retries > 0) {
+    const checkResult = await new Promise((resolve, reject) => {
+      cadIsBusy(platform || "AutoCAD", (e, r) => {
+        if (e) reject(e);
+        else resolve(r);
+      });
+    });
+    if (!checkResult.isBusy) return true;
+    retries--;
+    if (retries > 0) await new Promise((resolve) => setTimeout(resolve, BUSY_DELAY));
+  }
+  return false;
+}
+function checkParens(code) {
+  let depth = 0;
+  let inString = false;
+  for (let i = 0; i < code.length; i++) {
+    const ch = code[i];
+    if (inString) {
+      if (ch === "\\" && i + 1 < code.length) {
+        i++;
+        continue;
+      }
+      if (ch === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      continue;
+    }
+    if (ch === ";") {
+      while (i < code.length && code[i] !== "\n") i++;
+      continue;
+    }
+    if (ch === "(") depth++;
+    if (ch === ")") depth--;
+    if (depth < 0) return { valid: false, error: "\u591A\u4F59\u53F3\u62EC\u53F7 )", pos: i };
+  }
+  if (depth > 0) return { valid: false, error: `\u7F3A\u5C11 ${depth} \u4E2A\u53F3\u62EC\u53F7 )`, pos: code.length - 1 };
+  if (depth < 0) return { valid: false, error: `\u591A\u4F59 ${-depth} \u4E2A\u5DE6\u62EC\u53F7 (` };
+  return { valid: true };
+}
+async function handleMessage(msg) {
+  if (msg.type === "ping") {
+    return { pong: true };
+  }
+  if (msg.type === "connect") {
+    try {
+      const result = await new Promise((resolve, reject) => {
+        cadConnect({}, (e, r) => {
+          if (e) reject(e);
+          else resolve(r);
+        });
+      });
+      if (result && result.success) return result;
+    } catch (e) {
+      log("cadConnect failed: " + e.message);
+    }
+    return new Promise((resolve, reject) => {
+      cadLaunch({}, (e, r) => {
+        if (e) reject(e);
+        else resolve(r);
+      });
+    });
+  }
+  if (msg.type === "hasdoc") {
+    return new Promise((resolve, reject) => {
+      cadHasDoc(msg.platform || "AutoCAD", (e, r) => {
+        if (e) reject(e);
+        else resolve(r);
+      });
+    });
+  }
+  if (msg.type === "newdoc") {
+    return new Promise((resolve, reject) => {
+      cadNewDoc(msg.platform || "AutoCAD", (e, r) => {
+        if (e) reject(e);
+        else resolve(r);
+      });
+    });
+  }
+  if (msg.type === "bringToFront") {
+    return new Promise((resolve, reject) => {
+      cadBringToFront(msg.platform || "AutoCAD", (e, r) => {
+        if (e) reject(e);
+        else resolve(r);
+      });
+    });
+  }
+  if (msg.type === "send") {
+    const docCheck = await new Promise((resolve, reject) => {
+      cadHasDoc(msg.platform || "AutoCAD", (e, r) => {
+        if (e) reject(e);
+        else resolve(r);
+      });
+    });
+    if (!docCheck.hasDoc) {
+      return { success: false, error: "No open document" };
+    }
+    const parenCheck = checkParens(msg.code);
+    if (!parenCheck.valid) {
+      return { success: false, error: `\u62EC\u53F7\u9519\u8BEF: ${parenCheck.error} (\u4F4D\u7F6E ${parenCheck.pos})` };
+    }
+    if (!await waitForIdle(msg.platform || "AutoCAD")) {
+      return { success: false, error: "CAD is busy, timeout" };
+    }
+    log(`send: ${msg.code}`);
+    return new Promise((resolve, reject) => {
+      cadSend({ code: msg.code, platform: msg.platform }, (e, r) => {
+        if (e) {
+          log(`send error: ${e.message}`);
+          reject(e);
+        } else {
+          log(`send result: ${JSON.stringify(r)}`);
+          resolve(r);
+        }
+      });
+    });
+  }
+  if (msg.type === "sendResult") {
+    const docCheck = await new Promise((resolve, reject) => {
+      cadHasDoc(msg.platform || "AutoCAD", (e, r) => {
+        if (e) reject(e);
+        else resolve(r);
+      });
+    });
+    if (!docCheck.hasDoc) {
+      return { success: false, error: "No open document" };
+    }
+    const parenCheck = checkParens(msg.code);
+    if (!parenCheck.valid) {
+      return { success: false, error: `\u62EC\u53F7\u9519\u8BEF: ${parenCheck.error} (\u4F4D\u7F6E ${parenCheck.pos})` };
+    }
+    if (!await waitForIdle(msg.platform)) {
+      return { success: false, error: "CAD is busy, timeout" };
+    }
+    log(`sendResult: ${msg.code}`);
+    return new Promise((resolve, reject) => {
+      cadSendWithResult({ code: msg.code, platform: msg.platform, encoding: msg.encoding || "" }, (e, r) => {
+        if (e) {
+          log(`sendResult error: ${e.message}`);
+          reject(e);
+        } else {
+          log(`sendResult result: ${JSON.stringify(r)}`);
+          resolve(r);
+        }
+      });
+    });
+  }
+  if (msg.type === "isBusy") {
+    return new Promise((resolve, reject) => {
+      cadIsBusy(msg.platform || "AutoCAD", (e, r) => {
+        if (e) reject(e);
+        else resolve(r);
+      });
+    });
+  }
+  return { error: "unknown message type" };
+}
+export {
+  checkParens
+};

package/package.json

@@ -1,21 +1,25 @@
 {
     "name": "@atlisp/mcp",
-    "version": "1.3.0",
+    "version": "1.3.1",
     "description": "MCP Server for @lisp on CAD",
     "type": "module",
     "bin": {
-        "atlisp-mcp": "./src/atlisp-mcp.js"
+        "atlisp-mcp": "./dist/atlisp-mcp.js"
     },
-    "main": "src/atlisp-mcp.js",
+    "main": "dist/atlisp-mcp.js",
     "exports": {
-        ".": "./src/atlisp-mcp.js",
-        "./cad": "./src/cad.js"
+        ".": "./dist/atlisp-mcp.js",
+        "./cad": "./dist/atlisp-mcp.js"
     },
     "files": [
-        "src"
+        "dist"
     ],
     "scripts": {
         "start": "node src/atlisp-mcp.js",
+        "build": "npm run build:main && npm run build:worker",
+        "build:main": "esbuild src/atlisp-mcp.js --bundle --platform=node --target=node18 --format=esm --outdir=dist --external:edge-js --packages=external --banner:js=\"#!/usr/bin/env node\"",
+        "build:worker": "esbuild src/cad-worker.js --bundle --platform=node --target=node18 --format=esm --outdir=dist --external:edge-js --packages=external",
+        "prepublishOnly": "npm run build",
         "test": "vitest run",
         "test:watch": "vitest"
     },
@@ -48,6 +52,7 @@
         "node": ">=18.0.0"
     },
     "devDependencies": {
+        "esbuild": "^0.28.0",
         "vitest": "^4.1.5"
     }
 }