kratos-memory 1.9.0 → 1.9.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kratos-memory",
-  "version": "1.9.0",
+  "version": "1.9.2",
   "description": "Persistent memory for AI coding agents — CLI-first, local, zero network calls",
   "main": "dist/cli/index.js",
   "type": "module",
@@ -35,7 +35,7 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
-    "better-sqlite3": "^12.8.0",
+    "better-sqlite3": "12.9.0",
     "chalk": "^5.3.0",
     "commander": "^12.1.0",
     "fs-extra": "^11.2.0"

package/scripts/ensure-better-sqlite3.mjs

@@ -1,5 +1,5 @@
 import { spawnSync } from 'node:child_process';
-import { existsSync, rmSync } from 'node:fs';
+import { existsSync, mkdirSync, rmSync, statSync } from 'node:fs';
 import path from 'node:path';
 import { createRequire } from 'node:module';
 import { fileURLToPath } from 'node:url';
@@ -9,6 +9,9 @@ const __dirname = path.dirname(__filename);
 const packageRoot = path.resolve(__dirname, '..');
 const requireFromPackage = createRequire(path.join(packageRoot, 'package.json'));
 
+const LOCK_WAIT_MS = 180_000;   // how long a process waits for another's rebuild
+const LOCK_STALE_MS = 600_000;  // locks older than this are abandoned crashes
+
 function resolveBetterSqlite3Dir() {
   const pkgPath = requireFromPackage.resolve('better-sqlite3/package.json');
   return path.dirname(pkgPath);
@@ -70,6 +73,66 @@ function formatOutput(result) {
   return chunks.join('\n');
 }
 
+function sleepSync(ms) {
+  spawnSync(process.execPath, ['-e', `setTimeout(() => process.exit(0), ${ms})`]);
+}
+
+/**
+ * Cross-process lock via atomic mkdir. Concurrent kratos invocations on a
+ * fresh install must not rebuild the native module simultaneously — the
+ * second process waits for the first, then re-checks instead of rebuilding.
+ */
+function acquireLock(lockDir) {
+  const start = Date.now();
+  for (;;) {
+    try {
+      mkdirSync(lockDir);
+      return true;
+    } catch {
+      try {
+        const stat = statSync(lockDir);
+        if (Date.now() - stat.mtimeMs > LOCK_STALE_MS) {
+          rmSync(lockDir, { recursive: true, force: true });
+          continue;
+        }
+      } catch {
+        continue; // lock vanished between attempts — retry immediately
+      }
+      if (Date.now() - start > LOCK_WAIT_MS) {
+        return false;
+      }
+      sleepSync(500);
+    }
+  }
+}
+
+function releaseLock(lockDir) {
+  rmSync(lockDir, { recursive: true, force: true });
+}
+
+/**
+ * Fast path: download the official prebuilt binary (seconds, no compiler).
+ * This is what better-sqlite3's own install script does — it gets skipped
+ * when users install with --ignore-scripts.
+ */
+function tryPrebuildInstall(moduleDir) {
+  let prebuildBin;
+  try {
+    const requireFromModule = createRequire(path.join(moduleDir, 'package.json'));
+    const prebuildPkg = requireFromModule.resolve('prebuild-install/package.json');
+    const prebuildDir = path.dirname(prebuildPkg);
+    const binRel = JSON.parse(
+      spawnSync(process.execPath, ['-e', `console.log(JSON.stringify(require(${JSON.stringify(prebuildPkg)}).bin))`], { encoding: 'utf8' }).stdout.trim()
+    );
+    prebuildBin = path.join(prebuildDir, typeof binRel === 'string' ? binRel : Object.values(binRel)[0]);
+  } catch {
+    return false; // prebuild-install not resolvable — fall through to source build
+  }
+
+  const result = runCommand(process.execPath, [prebuildBin], moduleDir);
+  return result.status === 0;
+}
+
 export function ensureBetterSqlite3() {
   let moduleDir;
 
@@ -84,30 +147,49 @@ export function ensureBetterSqlite3() {
     return;
   }
 
-  const binaryPath = getBinaryPath(moduleDir);
-  console.warn(`[kratos-memory] better-sqlite3 binary missing or unloadable at ${binaryPath}`);
-  console.warn('[kratos-memory] rebuilding better-sqlite3 from source...');
-
-  rmSync(path.join(moduleDir, 'build'), { recursive: true, force: true });
-
-  const npm = findNpmCommand();
-  const rebuild = runCommand(
-    npm.command,
-    [...npm.argsPrefix, 'run', 'build-release', '--foreground-scripts'],
-    moduleDir
-  );
-
-  if (canLoadBetterSqlite3(moduleDir)) {
-    console.warn('[kratos-memory] better-sqlite3 rebuild succeeded.');
-    return;
+  const lockDir = path.join(moduleDir, '.kratos-setup-lock');
+  if (!acquireLock(lockDir)) {
+    // Another process held the lock the whole time — check its result
+    if (canLoadBetterSqlite3(moduleDir)) return;
+    throw new Error('Timed out waiting for another kratos process to finish native setup.');
   }
 
-  const detail = formatOutput(rebuild);
-  throw new Error(
-    detail
-      ? `Failed to build better-sqlite3.\n${detail}`
-      : 'Failed to build better-sqlite3.'
-  );
+  try {
+    // Another process may have completed setup while we waited for the lock
+    if (canLoadBetterSqlite3(moduleDir)) {
+      return;
+    }
+
+    rmSync(path.join(moduleDir, 'build'), { recursive: true, force: true });
+
+    console.warn('[kratos-memory] one-time native setup: fetching prebuilt SQLite binary...');
+    if (tryPrebuildInstall(moduleDir) && canLoadBetterSqlite3(moduleDir)) {
+      console.warn('[kratos-memory] prebuilt binary installed.');
+      return;
+    }
+
+    console.warn('[kratos-memory] no prebuilt binary available — compiling from source (one time, may take a minute)...');
+    const npm = findNpmCommand();
+    const rebuild = runCommand(
+      npm.command,
+      [...npm.argsPrefix, 'run', 'build-release', '--foreground-scripts'],
+      moduleDir
+    );
+
+    if (canLoadBetterSqlite3(moduleDir)) {
+      console.warn('[kratos-memory] better-sqlite3 rebuild succeeded.');
+      return;
+    }
+
+    const detail = formatOutput(rebuild);
+    throw new Error(
+      detail
+        ? `Failed to build better-sqlite3.\n${detail}`
+        : 'Failed to build better-sqlite3.'
+    );
+  } finally {
+    releaseLock(lockDir);
+  }
 }
 
 if (process.argv[1] === __filename) {