dsh-dbhub-live 5.2.0-dev.3 → 6.0.0-rc.1

package/lib/capability.mjs

@@ -12,12 +12,43 @@
 // Detection is deliberately file-based (no extra process spawn): the executable
 // we resolved lives inside a package directory (`…/node_modules/.bin/dbhub.cmd`
 // next to `…/node_modules/@bytebase/dbhub/package.json`) or under mise's
-// `npm-bytebase-dbhub/<version>/` layout, and both carry the version.
+// `npm-bytebase-dbhub/<version>/` layout, or it is the classic global layout
+// (`<prefix>/bin/dbhub` + `<prefix>/lib/node_modules/@bytebase/dbhub`), and all
+// of them carry the version. An UNKNOWN version still allows both features
+// (R62); the point of covering the standard layouts is that "unknown" stays the
+// exception instead of being the default answer.
 // Pure module: `node:fs` + `node:path` only, no Cordis service.
 
-import { existsSync, readFileSync, statSync } from 'node:fs'
+import { existsSync, readFileSync, statSync, realpathSync } from 'node:fs'
 import { dirname, join, resolve } from 'node:path'
 
+// Process-wide detection cache, keyed by `<absolute exe path>\0<mtimeMs>`. The
+// answer for one executable is immutable for the life of the process, while a
+// TOML call used to re-walk up to 18 candidate manifests with readFileSync on
+// EVERY tool call (the guard runs before each read-only / tunnelled spawn). The
+// mtime keeps an in-place upgrade (`npm install` over the old prefix) from
+// serving a stale version, and one statSync is microseconds next to that walk.
+const DETECTION_CACHE = new Map()
+
+// Production reads the real fs; tests swap single primitives to COUNT the probes
+// (the same seam config.mjs uses for its storage writers). Nothing here reads a
+// hook unless a test installed one. `realpathSync` resolves a shim that is a
+// SYMLINK (nvm / volta / pnpm, and npm -g's `bin/dbhub` link) to the package
+// directory it really lives in.
+const NODE_FS = { existsSync, readFileSync, statSync, realpathSync }
+let fsHooks = NODE_FS
+
+/**
+ * Replace a subset of the file primitives used by the version probe.
+ * @param hooks - `{ existsSync?, readFileSync?, statSync?, realpathSync? }`, or
+ *   `null` to restore node:fs. Unlisted primitives keep the real implementation.
+ *   The detection cache is dropped so a swapped fs can never be served a hit.
+ */
+export function setFsHooks(hooks) {
+  fsHooks = hooks ? { ...NODE_FS, ...hooks } : NODE_FS
+  DETECTION_CACHE.clear()
+}
+
 /** Minimum dbhub version whose TOML dialect this plugin generates. */
 export const DBHUB_MIN_VERSION = '1.4.0'
 /** Versions below this predate the TOML tool model entirely. */
@@ -62,11 +93,27 @@ export function versionFromMisePath(exe) {
   return parseVersion(m[1]) ? m[1] : ''
 }
 
+/**
+ * The real path of an executable, or the given path when it cannot be resolved.
+ *
+ * A dbhub reached through a link must be walked UP from its TARGET: npm -g puts
+ * `bin/dbhub` as a symlink into `lib/node_modules`, and nvm / volta / pnpm shim
+ * the same way, so the link's own directory contains no manifest at all.
+ */
+function realExe(raw) {
+  try {
+    return fsHooks.realpathSync(raw)
+  } catch (e) {
+    return raw
+  }
+}
+
 /**
  * Walk up from the executable (bounded) looking for the owning package.json and
  * read its version. Works for the auto-managed install
- * (`<RUNTIME_DIR>/node_modules/@bytebase/dbhub/package.json`) and for any npm /
- * pnpm / mise layout that keeps the manifest above the shim.
+ * (`<RUNTIME_DIR>/node_modules/@bytebase/dbhub/package.json`), for any npm /
+ * pnpm / mise layout that keeps the manifest above the shim, and for the
+ * classic global layout (`<prefix>/bin/dbhub` + `<prefix>/lib/node_modules/…`).
  * @returns a version string, or `''`.
  */
 export function versionFromPackageJson(exe) {
@@ -74,25 +121,36 @@ export function versionFromPackageJson(exe) {
   if (!raw) return ''
   let dir
   try {
-    dir = dirname(resolve(raw))
+    dir = dirname(realExe(resolve(raw)))
   } catch (e) {
     return ''
   }
   for (let i = 0; i < 6 && dir; i++) {
-    // Three layouts matter, and all of them must be probed at EVERY level:
+    // Every layout matters, and all of them must be probed at EVERY level:
     //   · `<pkg>/package.json` — the mise shim package that pins dbhub;
-    //   · `<dir>/node_modules/@bytebase/dbhub/package.json` — what
+    //   · `<dir>/node_modules/{@bytebase/dbhub,dbhub}/package.json` — what
     //     `npm install @bytebase/dbhub --prefix <dir>` produces, i.e. the
-    //     DEFAULT auto-managed install (and `npm -g` too);
-    //   · `<dir>/node_modules/dbhub/package.json` — an unscoped install.
+    //     DEFAULT auto-managed install;
+    //   · `<dir>/lib/node_modules/…` — the npm GLOBAL / nvm / volta prefix
+    //     (`<prefix>/bin/dbhub` next to `<prefix>/lib/node_modules/…`). This
+    //     candidate is what keeps a default `npm i -g` install from resolving
+    //     to '' : an unknown version is ALLOWED by design (R62), so the
+    //     `< 1.0.0` refusal was unreachable and a `[[tools]] readonly` TOML was
+    //     handed to a dbhub that ignores it — looking read-only while every
+    //     write still went through;
+    //   · `<dir>/../../lib/node_modules/…` — the same prefix seen from a shim
+    //     that sits one directory deeper (`<prefix>/bin/<sub>/dbhub`).
     for (const candidate of [
       join(dir, 'package.json'),
       join(dir, 'node_modules', '@bytebase', 'dbhub', 'package.json'),
       join(dir, 'node_modules', 'dbhub', 'package.json'),
+      join(dir, 'lib', 'node_modules', '@bytebase', 'dbhub', 'package.json'),
+      join(dir, 'lib', 'node_modules', 'dbhub', 'package.json'),
+      join(dir, '..', '..', 'lib', 'node_modules', '@bytebase', 'dbhub', 'package.json'),
     ]) {
       try {
-        if (!existsSync(candidate) || !statSync(candidate).isFile()) continue
-        const doc = JSON.parse(readFileSync(candidate, 'utf8'))
+        if (!fsHooks.existsSync(candidate) || !fsHooks.statSync(candidate).isFile()) continue
+        const doc = JSON.parse(fsHooks.readFileSync(candidate, 'utf8'))
         const version = parseVersion(doc && doc.version) ? String(doc.version) : ''
         if (!version) continue
         // Only trust a manifest that IS dbhub: an unrelated package.json above
@@ -139,19 +197,45 @@ export function capabilitiesOf(rawVersion) {
   return { version, readonlyTools: true, ssh: true, warning: '' }
 }
 
+/**
+ * Detection cache key: the path plus the executable's mtime (0 when it cannot be
+ * stat'ed, which keeps the key stable for a layout whose shim does not exist).
+ */
+function cacheKeyOf(raw) {
+  let stamp = 0
+  if (raw) {
+    try {
+      stamp = Number(fsHooks.statSync(raw).mtimeMs) || 0
+    } catch (e) {
+      stamp = 0
+    }
+  }
+  return raw + '\u0000' + String(stamp)
+}
+
 /**
  * Detect the capabilities of one resolved dbhub executable.
  * Never throws and never blocks: an unresolvable version is reported as
  * `unknown` and the features stay enabled (the caller only *uses* this on
  * read-only / SSH environments, and an genuine incompatibility surfaces as a
  * clear dbhub error).
+ *
+ * Cached per executable (see DETECTION_CACHE); a copy is returned so a caller can
+ * never poison the cache.
  * @param exe - resolved dbhub executable path (may be undefined at boot).
  * @returns `{ version, readonlyTools, ssh, warning }`.
  */
 export function detectDbhubCapabilities(exe) {
+  const raw = String(exe === undefined || exe === null ? '' : exe).trim()
+  const key = cacheKeyOf(raw)
+  const hit = DETECTION_CACHE.get(key)
+  if (hit) return { ...hit }
+  let value
   try {
-    return capabilitiesOf(detectVersion(exe))
+    value = capabilitiesOf(detectVersion(raw))
   } catch (e) {
-    return { version: '', readonlyTools: true, ssh: true, warning: 'unknown' }
+    value = { version: '', readonlyTools: true, ssh: true, warning: 'unknown' }
   }
+  DETECTION_CACHE.set(key, value)
+  return { ...value }
 }