@dmytro-prototypes/cadbridge-mcp 0.1.11 → 0.1.13

package/bin/cli.js

@@ -16,6 +16,7 @@ import { createRequire } from "node:module"
 import { homedir } from "node:os"
 import { join } from "node:path"
 import { fileURLToPath } from "node:url"
+import { installPlugin, reportPluginInstall } from "./plugin.js"
 
 const require = createRequire(import.meta.url)
 
@@ -107,7 +108,22 @@ export function installBinary(source, {
 }
 
 export function run(argv = process.argv.slice(2)) {
-  const binary = installBinary(resolveBinary())
+  // The package path and the installed path are different directories, and the
+  // two callers below need different ones: the plugin bundle is a sibling of
+  // bin/ inside the npm package, while the executable is run from the stable
+  // per-user location. Passing the installed path to installPlugin looks for a
+  // bundle in a directory that never holds one.
+  const packaged = resolveBinary()
+  const binary = installBinary(packaged)
+
+  // Best effort, and deliberately never fatal: the plugin half only matters
+  // once AutoCAD restarts, so a locked or unwritable ApplicationPlugins
+  // directory must not stop the server half from starting now.
+  try {
+    reportPluginInstall(installPlugin(packaged))
+  } catch (error) {
+    process.stderr.write(`CADBridge: skipped the AutoCAD plugin install: ${error.message}\n`)
+  }
   // stdio: "inherit" — this process is a stdio MCP server; the client's pipes
   // must reach the real binary untouched. Nothing here may write to stdout.
   const child = spawn(binary, argv, { stdio: "inherit" })

package/bin/plugin.js

@@ -0,0 +1,254 @@
+// Installs the AutoCAD plugin bundle that ships alongside the server binary.
+//
+// The server and the plugin are two halves of one product: the Rust binary
+// speaks MCP to the client and ZeroMQ to CADBridge.arx, and a mismatched pair
+// fails in ways that look like AutoCAD bugs. Shipping the bundle inside the
+// same platform package and installing it on launch is what keeps the two
+// halves the same age — before this, `npx` updated the server and left
+// whatever plugin the user installed by hand months earlier.
+//
+// The bundle is copied, never built, and it arrives pre-signed: on macOS the
+// inner .bundle is Developer ID signed, notarized and stapled, and the ticket
+// is a plain file inside it, so an npm tarball round-trip preserves the whole
+// assessment. npm also fetches over an HTTP client that sets neither
+// com.apple.quarantine nor Mark-of-the-Web, so nothing here is ever gated by
+// Gatekeeper or SmartScreen.
+import { createHash } from "node:crypto"
+import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs"
+import { homedir } from "node:os"
+import { dirname, join, sep } from "node:path"
+
+// Autodesk's per-user auto-load location. Anything under it with a
+// PackageContents.xml is loaded at AutoCAD startup, no admin rights and no
+// registry entry — and it is a trusted path, so SECURELOAD does not prompt.
+export function pluginRoot({
+  platform = process.platform,
+  home = homedir(),
+  appData = process.env.APPDATA || join(home, "AppData", "Roaming"),
+} = {}) {
+  if (platform === "win32") return join(appData, "Autodesk", "ApplicationPlugins")
+  if (platform === "darwin") return join(home, "Library", "Application Support", "Autodesk", "ApplicationPlugins")
+  return null
+}
+
+// The bundle sits next to bin/ in the platform package, so the binary this
+// launcher already resolved locates it without a second require.resolve —
+// which matters because the two must come from the same package version.
+export function pluginSource(binary) {
+  return join(dirname(dirname(binary)), "plugin", "CADBridge.bundle")
+}
+
+function walk(root, prefix = "") {
+  const entries = []
+  // Sorted, so the digest depends on the tree's content and not on the order
+  // the filesystem happens to hand back.
+  for (const entry of readdirSync(join(root, prefix), { withFileTypes: true }).sort((a, b) => (a.name < b.name ? -1 : 1))) {
+    const relative = prefix ? join(prefix, entry.name) : entry.name
+    if (entry.isDirectory()) entries.push(...walk(root, relative))
+    else entries.push(relative)
+  }
+  return entries
+}
+
+// Content plus the executable bit: a bundle whose Mach-O lost +x on the way
+// through a CI artifact is a different bundle, and AutoCAD's failure to load
+// it says nothing about why.
+export function hashTree(root) {
+  const digest = createHash("sha256")
+  for (const relative of walk(root)) {
+    // POSIX separators regardless of host, so a tree packed on Windows and the
+    // same tree on macOS agree.
+    digest.update(relative.split(sep).join("/"))
+    digest.update(statSync(join(root, relative)).mode & 0o111 ? "x" : "-")
+    digest.update(readFileSync(join(root, relative)))
+  }
+  return digest.digest("hex")
+}
+
+// AutoCAD releases installed on this machine, newest first. LT is excluded
+// deliberately: it shares the naming but cannot load ObjectARX modules at all,
+// so counting it would report coverage that can never happen.
+//
+// Detection only ever adds information. The bundle is installed either way —
+// it is inert without AutoCAD, and a false negative here (an install in a
+// non-standard location) must not be able to withhold the plugin from someone
+// who does have AutoCAD.
+export function installedAutoCAD({ platform = process.platform, roots } = {}) {
+  const search = roots ?? (platform === "win32"
+    ? [process.env["ProgramFiles"] || "C:\\Program Files", process.env["ProgramW6432"]].filter(Boolean).map(p => join(p, "Autodesk"))
+    : ["/Applications/Autodesk"])
+
+  const found = new Set()
+  for (const root of search) {
+    let entries
+    try {
+      entries = readdirSync(root, { withFileTypes: true })
+    } catch {
+      continue
+    }
+    for (const entry of entries) {
+      // "AutoCAD 2026" yes, "AutoCAD LT 2026" no.
+      const match = /^AutoCAD (\d{4})$/.exec(entry.name)
+      if (match) found.add(match[1])
+    }
+  }
+  return [...found].sort().reverse()
+}
+
+// Which AutoCAD releases the bundle about to be installed actually serves.
+// Read out of the manifest itself rather than from plugin/series.json, which
+// is a build-time file and is not shipped: the manifest is both what AutoCAD
+// obeys and the only copy that reaches a user's machine. Its per-release
+// Components blocks are generated by scripts/package-contents.mjs, which names
+// the release in each Description.
+export function coveredReleases(manifest) {
+  return [...manifest.matchAll(/<Components Description="CADBridge for AutoCAD (\d{4})"/g)].map(([, release]) => release)
+}
+
+// Beside PackageContents.xml rather than inside Contents/: the signed bundle
+// is nested one level down, and adding a file inside it would invalidate the
+// seal that Gatekeeper and AutoCAD both check.
+const STAMP = ".cadbridge-npm-install"
+
+function installed(destination) {
+  try {
+    return JSON.parse(readFileSync(join(destination, STAMP), "utf8"))
+  } catch {
+    // Missing, unreadable or hand-edited all mean the same thing: this is not
+    // a copy we can prove we put there, so replace it.
+    return null
+  }
+}
+
+// A directory cannot be swapped the way installBinary swaps a file: rename
+// onto a non-empty directory fails on both platforms. So stage a complete
+// copy, move the old tree aside, move the new one in, and only then delete —
+// and put the old tree back if the second move is the one that fails.
+export function installPlugin(binary, {
+  platform = process.platform,
+  home = homedir(),
+  appData = process.env.APPDATA || join(home, "AppData", "Roaming"),
+  env = process.env,
+  // Injectable so a test does not depend on what AutoCAD happens to be
+  // installed on the machine running it.
+  autocad,
+} = {}) {
+  if (env.CADBRIDGE_SKIP_PLUGIN_INSTALL) return { status: "skipped" }
+
+  const root = pluginRoot({ platform, home, appData })
+  if (!root) return { status: "unsupported" }
+
+  const source = pluginSource(binary)
+  let version
+  let manifest
+  try {
+    // PackageContents.xml is the file AutoCAD itself reads, so its absence
+    // means there is no loadable bundle here whatever else was shipped.
+    manifest = readFileSync(join(source, "PackageContents.xml"), "utf8")
+    version = /AppVersion="([^"]*)"/.exec(manifest)?.[1] ?? "unknown"
+  } catch {
+    // Older platform packages shipped the server alone. Nothing to install,
+    // and nothing worth saying about it.
+    return { status: "absent" }
+  }
+
+  const destination = join(root, "CADBridge.bundle")
+  const digest = hashTree(source)
+  const covers = { manifest, installedAutoCAD: autocad ?? installedAutoCAD({ platform }) }
+  if (installed(destination)?.sha256 === digest) return { status: "current", version, destination, ...covers }
+
+  mkdirSync(root, { recursive: true })
+  // One temp directory holds both the new tree being assembled and the old one
+  // moved out of the way, so a single cleanup covers both and no name has to be
+  // derived from the pid — a pid-derived name collides with the leftovers of a
+  // run that was killed mid-swap, and a rename onto that stale directory fails
+  // with exactly the codes that mean "AutoCAD has it open", wedging every later
+  // launch behind advice that cannot help.
+  const staging = mkdtempSync(join(root, ".cadbridge-staging-"))
+  const displaced = join(staging, "displaced")
+  // Set only when the previous bundle could NOT be put back, in which case this
+  // directory holds the user's sole copy and must survive the cleanup below.
+  let stranded = null
+  try {
+    const staged = join(staging, "CADBridge.bundle")
+    cpSync(source, staged, { recursive: true })
+    writeFileSync(join(staged, STAMP), `${JSON.stringify({ sha256: digest, version }, null, 2)}\n`)
+
+    let moved = false
+    try {
+      renameSync(destination, displaced)
+      moved = true
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error
+    }
+    try {
+      renameSync(staged, destination)
+    } catch (error) {
+      // Leave the working plugin in place rather than a half-installed one.
+      if (moved) {
+        try {
+          renameSync(displaced, destination)
+        } catch {
+          // Both moves failed, so the old bundle is still in the temp
+          // directory and is now the only copy there is. Keep it and say
+          // where, rather than deleting the user's working plugin.
+          stranded = displaced
+        }
+      }
+      throw error
+    }
+    return { status: "installed", version, destination, ...covers }
+  } catch (error) {
+    // AutoCAD maps CADBridge.arx for the whole session (PackageContents.xml
+    // sets LoadOnAutoCADStartup), and Windows will not let a mapped module be
+    // renamed or deleted. That is the ordinary case of "the user started
+    // AutoCAD first", not a failure worth refusing to start the server over.
+    const status = !stranded && ["EBUSY", "EPERM", "EACCES", "ENOTEMPTY"].includes(error.code) ? "locked" : "failed"
+    return { status, version, destination, stranded, error, ...covers }
+  } finally {
+    if (!stranded) rmSync(staging, { recursive: true, force: true })
+  }
+}
+
+// stdout belongs to the MCP protocol; every byte here goes to stderr, which
+// clients surface in their server logs.
+export function reportPluginInstall(result, write = message => process.stderr.write(`${message}\n`)) {
+  // An AutoCAD that is installed but that the bundle does not serve is the one
+  // thing the user cannot discover for themselves: AutoCAD ignores a
+  // non-matching Components block in silence, so CADBridge would simply never
+  // appear there with no clue why. Reported on any status, because the bundle
+  // being already current does not make the gap go away.
+  if (result.manifest && result.installedAutoCAD?.length) {
+    const covered = coveredReleases(result.manifest)
+    const missing = result.installedAutoCAD.filter(release => !covered.includes(release))
+    if (missing.length) {
+      write(
+        `CADBridge: no plugin build for AutoCAD ${missing.join(", ")} — ` +
+          `this bundle serves ${covered.join(", ") || "no installed release"}. ` +
+          `CADBridge will not load there.`,
+      )
+    }
+  }
+  if (result.status === "installed") {
+    // The plugin's own version, which is not the server's and not this npm
+    // package's — the three are released independently and only
+    // `protocolVersion` has to agree. Naming it explicitly stops a bug report
+    // from guessing.
+    write(`CADBridge: installed AutoCAD plugin ${result.version} to ${result.destination}`)
+    write("CADBridge: restart AutoCAD to load it.")
+  } else if (result.status === "locked") {
+    write(
+      `CADBridge: could not update the AutoCAD plugin to ${result.version} — ` +
+        `${result.destination} is in use. Close AutoCAD and start this server again to finish the update.`,
+    )
+  } else if (result.status === "failed") {
+    write(`CADBridge: could not install the AutoCAD plugin to ${result.destination}: ${result.error.message}`)
+    if (result.stranded) {
+      // The one case where the user has to act: their previous bundle could
+      // not be put back, so name its location instead of leaving them with an
+      // empty ApplicationPlugins directory and no idea why.
+      write(`CADBridge: the previous plugin is still at ${result.stranded} — move it back to ${result.destination}.`)
+    }
+  }
+  return result
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dmytro-prototypes/cadbridge-mcp",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "mcpName": "net.dmytro-prototypes/cadbridge-mcp-autocad",
   "description": "Drive a live AutoCAD session from an AI client through MCP",
   "type": "module",
@@ -30,10 +30,14 @@
     "LICENSE.txt"
   ],
   "optionalDependencies": {
-    "@dmytro-prototypes/cadbridge-mcp-darwin-arm64": "0.1.11",
-    "@dmytro-prototypes/cadbridge-mcp-win32-x64": "0.1.11"
+    "@dmytro-prototypes/cadbridge-mcp-darwin-arm64": "0.1.13",
+    "@dmytro-prototypes/cadbridge-mcp-win32-x64": "0.1.13"
   },
   "publishConfig": {
     "access": "public"
+  },
+  "cadbridge": {
+    "server": "0.1.11",
+    "plugin": "0.1.12"
   }
 }