@adhdev/ghostty-vt-node 1.0.46 → 1.0.78

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/ghostty-vt-node",
-  "version": "1.0.46",
+  "version": "1.0.78",
   "description": "Native Node binding for libghostty-vt",
   "main": "index.js",
   "types": "index.d.ts",

package/scripts/build-or-use-prebuilt.mjs

@@ -27,24 +27,105 @@ function latestSourceMtime() {
   return sourceInputs.reduce((latest, filePath) => Math.max(latest, safeMtime(filePath)), 0);
 }
 
+const PREBUILT_ROOT = path.join(packageDir, 'prebuilt');
+const ADDON_FILE = 'ghostty_vt_node.node';
+// The addon plus its co-located runtime libs (.dylib/.so/.dll) — the addon
+// resolves libghostty-vt next to itself, so it must travel with it.
+const RUNTIME_FILE_PATTERN = /\.(node|dylib|so|so\.\d.*|dll)$/;
+
+// The addon is a pure Node-API binding, so every same `platform-arch`
+// prebuilt is loadable regardless of the `nodeNNN` ABI in its directory name
+// (see index.js, which falls back the same way at runtime). Exact ABI first,
+// then the other same-platform-arch directories, newest ABI first. Accepting
+// only the exact triplet sent e.g. a Node 22 (ABI 127) fresh clone — where
+// only `*-node137` is committed — into a cmake/zig source compile.
+function samePlatformArchTriplets() {
+  const prefix = `${process.platform}-${process.arch}-node`;
+  let names = [];
+  try {
+    names = fs.readdirSync(PREBUILT_ROOT, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory() && entry.name.startsWith(prefix) && entry.name !== triplet)
+      .map((entry) => entry.name);
+  } catch {
+    return [];
+  }
+  const abi = (name) => Number.parseInt(name.slice(prefix.length), 10) || 0;
+  return names.sort((a, b) => abi(b) - abi(a));
+}
+
 function candidatePrebuiltPaths() {
   const candidates = [];
   const explicitDir = process.env.ADHDEV_GHOSTTY_VT_PREBUILT_DIR?.trim();
   if (explicitDir) {
-    candidates.push(path.join(explicitDir, triplet, 'ghostty_vt_node.node'));
-    candidates.push(path.join(explicitDir, 'ghostty_vt_node.node'));
+    candidates.push({ file: path.join(explicitDir, triplet, ADDON_FILE), explicit: true });
+    candidates.push({ file: path.join(explicitDir, ADDON_FILE), explicit: true });
+  }
+  for (const name of [triplet, ...samePlatformArchTriplets()]) {
+    candidates.push({ file: path.join(PREBUILT_ROOT, name, ADDON_FILE), explicit: false });
   }
-  candidates.push(path.join(packageDir, 'prebuilt', triplet, 'ghostty_vt_node.node'));
   return candidates;
 }
 
-function installPrebuiltIfPresent(minMtime = 0) {
+function git(args) {
+  const result = spawnSync('git', ['-C', packageDir, ...args], { encoding: 'utf8', windowsHide: true });
+  if (result.error || result.status === null) return null;
+  return { status: result.status, stdout: result.stdout || '' };
+}
+
+// Staleness of a candidate prebuilt relative to the sources it was built from.
+//
+// The mtime guard only means something for files this machine PRODUCED (a
+// local compile, or a prebuilt emitted from one): their mtimes order
+// genuinely. A git-tracked prebuilt's mtime is just checkout order — in a
+// fresh clone a valid prebuilt often looks "older" than addon.cc and was
+// skipped, and the build then died for lack of cmake. For a tracked prebuilt
+// the question that matters is whether the SOURCES were edited locally since
+// the committed state; only then is the committed binary out of date.
+let sourcesLocallyModifiedMemo;
+function sourcesLocallyModified() {
+  if (sourcesLocallyModifiedMemo !== undefined) return sourcesLocallyModifiedMemo;
+  const rels = sourceInputs.map((filePath) => path.relative(packageDir, filePath));
+  const status = git(['status', '--porcelain', '--', ...rels]);
+  sourcesLocallyModifiedMemo = !!status && status.status === 0 && status.stdout.trim().length > 0;
+  return sourcesLocallyModifiedMemo;
+}
+
+function isGitTracked(filePath) {
+  const result = git(['ls-files', '--error-unmatch', '--', path.relative(packageDir, filePath)]);
+  return !!result && result.status === 0;
+}
+
+function isUsablePrebuilt(candidate, sourceMtime) {
+  // An explicit override dir is the operator's choice — trust it.
+  if (candidate.explicit) return true;
+  if (isGitTracked(candidate.file)) return !sourcesLocallyModified();
+  // Not tracked: either a locally emitted prebuilt (mtime is meaningful) or an
+  // npm-installed package with no git at all, where the shipped sources and
+  // prebuilts are pristine together. Without git metadata there is nothing
+  // local to be stale against, so only a working tree applies the guard.
+  const insideWorkTree = git(['rev-parse', '--is-inside-work-tree']);
+  if (!insideWorkTree || insideWorkTree.status !== 0) return true;
+  return safeMtime(candidate.file) >= sourceMtime;
+}
+
+function installPrebuilt(candidateFile) {
+  fs.mkdirSync(outputDir, { recursive: true });
+  const sourceDir = path.dirname(candidateFile);
+  for (const entry of fs.readdirSync(sourceDir)) {
+    if (RUNTIME_FILE_PATTERN.test(entry)) fs.copyFileSync(path.join(sourceDir, entry), path.join(outputDir, entry));
+  }
+  if (!fs.existsSync(outputFile)) fs.copyFileSync(candidateFile, outputFile);
+}
+
+function installPrebuiltIfPresent(sourceMtime) {
   for (const candidate of candidatePrebuiltPaths()) {
-    if (!fs.existsSync(candidate)) continue;
-    if (safeMtime(candidate) < minMtime) continue;
-    fs.mkdirSync(outputDir, { recursive: true });
-    fs.copyFileSync(candidate, outputFile);
-    console.log(`[ghostty-vt-node] using prebuilt native binding from ${candidate}`);
+    if (!fs.existsSync(candidate.file)) continue;
+    if (!isUsablePrebuilt(candidate, sourceMtime)) {
+      console.log(`[ghostty-vt-node] skipping prebuilt ${candidate.file}: sources were modified locally after it was built`);
+      continue;
+    }
+    installPrebuilt(candidate.file);
+    console.log(`[ghostty-vt-node] using prebuilt native binding from ${candidate.file}`);
     return true;
   }
   return false;
@@ -53,17 +134,19 @@ function installPrebuiltIfPresent(minMtime = 0) {
 const sourceMtime = latestSourceMtime();
 const outputMtime = safeMtime(outputFile);
 
+// A local build output is something this machine compiled, so its mtime
+// against the sources is meaningful: keep it while it is not older.
 if (outputMtime >= sourceMtime && outputMtime > 0) {
   console.log(`[ghostty-vt-node] keeping existing local build at ${outputFile}`);
   process.exit(0);
 }
 
-if (!installPrebuiltIfPresent(sourceMtime) && process.env.ADHDEV_SKIP_GHOSTTY_VT_BUILD === '1') {
-  console.log(`[ghostty-vt-node] skipping native build for ${triplet} (ADHDEV_SKIP_GHOSTTY_VT_BUILD=1)`);
+if (installPrebuiltIfPresent(sourceMtime)) {
   process.exit(0);
 }
 
-if (installPrebuiltIfPresent(sourceMtime)) {
+if (process.env.ADHDEV_SKIP_GHOSTTY_VT_BUILD === '1') {
+  console.log(`[ghostty-vt-node] skipping native build for ${triplet} (ADHDEV_SKIP_GHOSTTY_VT_BUILD=1)`);
   process.exit(0);
 }
 

package/scripts/ensure-prebuilt-sonames.mjs

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+// Make every Linux prebuilt directory carry the SONAME file its addon links
+// against (libghostty-vt.so.0). CI artifacts and npm tarballs drop symlinks, so
+// a directory restored from an artifact has only libghostty-vt.so and
+// libghostty-vt.so.0.1.0 — and the addon then fails to load on every Linux
+// machine (v1.0.77). Copies the versioned file to the SONAME name when missing.
+//
+//   node scripts/ensure-prebuilt-sonames.mjs            # fix in place
+//   node scripts/ensure-prebuilt-sonames.mjs --check    # fail if any is missing
+//   ... --load   also require() the package and fail unless the binding loads
+//                (only meaningful on a platform that has a prebuilt)
+import { copyFileSync, existsSync, readdirSync, statSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const pkgDir = join(dirname(fileURLToPath(import.meta.url)), '..');
+const prebuiltDir = join(pkgDir, 'prebuilt');
+const check = process.argv.includes('--check');
+const load = process.argv.includes('--load');
+const SONAME = 'libghostty-vt.so.0';
+const VERSIONED = /^libghostty-vt\.so\.0\.\d+\.\d+$/;
+
+const problems = [];
+for (const triplet of existsSync(prebuiltDir) ? readdirSync(prebuiltDir) : []) {
+    if (!triplet.startsWith('linux-')) continue;
+    const dir = join(prebuiltDir, triplet);
+    if (!statSync(dir).isDirectory()) continue;
+    if (existsSync(join(dir, SONAME))) continue;
+    const versioned = readdirSync(dir).find((name) => VERSIONED.test(name));
+    if (!versioned) { problems.push(`${triplet}: no ${SONAME} and no versioned library to copy`); continue; }
+    if (check) { problems.push(`${triplet}: missing ${SONAME}`); continue; }
+    copyFileSync(join(dir, versioned), join(dir, SONAME));
+    console.log(`[ghostty-vt] ${triplet}: ${versioned} -> ${SONAME}`);
+}
+
+if (load) {
+    try {
+        const req = createRequire(join(pkgDir, 'index.js'));
+        const mod = req(join(pkgDir, 'index.js'));
+        if (!mod || (typeof mod !== 'object' && typeof mod !== 'function')) throw new Error('binding export is empty');
+        console.log(`[ghostty-vt] binding loads on ${process.platform}-${process.arch} (abi ${process.versions.modules})`);
+    } catch (error) {
+        problems.push(`binding failed to load on ${process.platform}-${process.arch}: ${error?.message || error}`);
+    }
+}
+
+if (problems.length) {
+    for (const p of problems) console.error(`✗ ${p}`);
+    process.exit(1);
+}
+if (check) console.log('[ghostty-vt] prebuilt SONAME check passed');