@dmytro-prototypes/cadbridge-mcp 0.1.14 → 0.1.15

package/bin/plugin.js

@@ -18,16 +18,25 @@ import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync,
 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.
+// Autodesk's per-user auto-load location — and it is not the same mechanism on
+// the two platforms.
+//
+// Windows reads ApplicationPlugins: a container folder holding
+// PackageContents.xml plus the modules it names. That is the AutoLoader, and
+// the folder is trusted, so SECURELOAD does not prompt.
+//
+// macOS does not consume PackageContents.xml at all. Observed on AutoCAD 2026
+// for Mac: a container in ApplicationPlugins never loads — not ours, and not
+// Autodesk's own sample plug-in — while a plain .bundle placed directly in
+// ApplicationAddins loads at startup with no prompt. So macOS gets
+// ApplicationAddins, and installPlugin puts the modules there unwrapped.
 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")
+  if (platform === "darwin") return join(home, "Library", "Application Support", "Autodesk", "ApplicationAddins")
   return null
 }
 
@@ -110,9 +119,9 @@ export function coveredReleases(manifest) {
 // seal that Gatekeeper and AutoCAD both check.
 const STAMP = ".cadbridge-npm-install"
 
-function installed(destination) {
+function installedStamp(stamp) {
   try {
-    return JSON.parse(readFileSync(join(destination, STAMP), "utf8"))
+    return JSON.parse(readFileSync(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.
@@ -120,6 +129,39 @@ function installed(destination) {
   }
 }
 
+// The modules to place, and under what names.
+//
+// Windows installs the container itself: AutoCAD reads PackageContents.xml and
+// picks the Components block matching its release.
+//
+// macOS has no manifest to pick with, so the selection has to be made here —
+// and it is made per ObjectARX SERIES, not per release. 2025 and 2026 both link
+// acdb25, so both binaries load into either one: installing them side by side
+// gives AutoCAD two live CADBridge instances that fight over the same command
+// names. One binary per series is what the old single Components block
+// (R25.0-R25.99) always asserted; this makes it true on disk.
+export function pluginModules(source, { platform = process.platform } = {}) {
+  if (platform !== "darwin") return [{ name: "CADBridge.bundle", from: source }]
+
+  const osx = join(source, "Contents", "Resources", "osx")
+  const bySeries = new Map()
+  for (const entry of readdirSync(osx, { withFileTypes: true })) {
+    // CADBridge-R25.1.bundle -> series R25, minor 1.
+    const match = /^CADBridge-R(\d+)\.(\d+)\.bundle$/.exec(entry.name)
+    if (!entry.isDirectory() || !match) continue
+    const [, series, minor] = match
+    const previous = bySeries.get(series)
+    // Highest minor wins: it is built against the newest SDK of the series and
+    // serves every release in it.
+    if (!previous || Number(minor) > previous.minor) {
+      bySeries.set(series, { minor: Number(minor), from: join(osx, entry.name) })
+    }
+  }
+  return [...bySeries]
+    .sort(([a], [b]) => (a < b ? -1 : 1))
+    .map(([series, { from }]) => ({ name: `CADBridge-R${series}.bundle`, from }))
+}
+
 // 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 —
@@ -142,8 +184,9 @@ export function installPlugin(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.
+    // PackageContents.xml is the file AutoCAD itself reads on Windows, and on
+    // both platforms it is what states the version and the releases served, so
+    // its absence means there is no loadable bundle here whatever else shipped.
     manifest = readFileSync(join(source, "PackageContents.xml"), "utf8")
     version = /AppVersion="([^"]*)"/.exec(manifest)?.[1] ?? "unknown"
   } catch {
@@ -152,57 +195,74 @@ export function installPlugin(binary, {
     return { status: "absent" }
   }
 
-  const destination = join(root, "CADBridge.bundle")
+  let modules
+  try {
+    modules = pluginModules(source, { platform })
+  } catch {
+    return { status: "absent" }
+  }
+  if (!modules.length) return { status: "absent" }
+
+  const destination = platform === "darwin" ? root : join(root, "CADBridge.bundle")
+  // Windows keeps its stamp inside the container, beside PackageContents.xml.
+  // macOS cannot: there is no container, and a file added inside a module would
+  // invalidate the signature Gatekeeper and AutoCAD both check — so the stamp
+  // sits beside the modules, where AutoCAD ignores it for not being a .bundle.
+  const stamp = platform === "darwin" ? join(root, STAMP) : join(destination, STAMP)
   const digest = hashTree(source)
   const covers = { manifest, installedAutoCAD: autocad ?? installedAutoCAD({ platform }) }
-  if (installed(destination)?.sha256 === digest) return { status: "current", version, destination, ...covers }
+  if (installedStamp(stamp)?.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.
+  // One temp directory holds both the new trees being assembled and the old
+  // ones 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
+  // Set only when a 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`)
+    for (const [index, module] of modules.entries()) {
+      const staged = join(staging, module.name)
+      const displaced = join(staging, `displaced-${index}`)
+      const target = join(root, module.name)
+      cpSync(module.from, staged, { recursive: true })
 
-    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
+      let moved = false
+      try {
+        renameSync(target, displaced)
+        moved = true
+      } catch (error) {
+        if (error.code !== "ENOENT") throw error
+      }
+      try {
+        renameSync(staged, target)
+      } catch (error) {
+        // Leave the working plugin in place rather than a half-installed one.
+        if (moved) {
+          try {
+            renameSync(displaced, target)
+          } 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
       }
-      throw error
     }
+    // Written last: a stamp is a claim that every module above is in place.
+    writeFileSync(stamp, `${JSON.stringify({ sha256: digest, version }, null, 2)}\n`)
     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.
+    // AutoCAD maps the plugin for the whole session, 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 {

package/package.json

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