kibi-runtime 2.14.0 → 2.14.1

package/dist/engine-daemon.js

@@ -19,10 +19,10 @@ import {
   openSync as openSync2,
   readFileSync as readFileSync5,
   readdirSync as readdirSync2,
-  realpathSync as realpathSync3,
+  realpathSync as realpathSync4,
   renameSync,
   rmSync as rmSync2,
-  statSync as statSync4,
+  statSync as statSync5,
   unlinkSync,
   writeFileSync as writeFileSync3
 } from "node:fs";
@@ -102,7 +102,7 @@ function manifestVersion(manifestPath, expectedName) {
 }
 function cliVersion() {
   if (true)
-    return "2.19.0";
+    return "2.20.0";
   return manifestVersion(path.join(moduleDirectory, "..", "package.json"), "kibi-cli") ?? "unknown";
 }
 function coreVersion() {
@@ -1754,9 +1754,15 @@ writeln('${INTERACTIVE_QUERY_FRAME_END}').
 }
 
 // ../cli/src/prolog/store-lock.ts
-import { existsSync as existsSync4, rmSync, writeFileSync } from "node:fs";
+import {
+  existsSync as existsSync4,
+  realpathSync as realpathSync2,
+  rmSync,
+  statSync as statSync3,
+  writeFileSync
+} from "node:fs";
 import { readFileSync as readFileSync3 } from "node:fs";
-import { dirname, join } from "node:path";
+import { basename, dirname, join } from "node:path";
 var cachedBootId;
 function currentBootId() {
   if (cachedBootId !== undefined)
@@ -1863,7 +1869,7 @@ function noteDeadHolderBeforeAttach(kbPath) {
   const lockPid = readRdfLockPid(lockPath);
   const journal = readStoreLockOwner(kbPath)?.owner ?? null;
   const owner = journal !== null && (lockPid === null || journal.pid === lockPid) ? journal : lockPid !== null ? { pid: lockPid } : null;
-  const decision = decideStoreLockTakeover(owner);
+  const decision = decideStoreLockTakeover(owner, { storePath: kbPath });
   if (decision.action !== "break")
     return () => {
       return;
@@ -1871,14 +1877,71 @@ function noteDeadHolderBeforeAttach(kbPath) {
   const brokenPid = owner?.pid ?? null;
   return () => recordStoreLockTakeover(kbPath, brokenPid, decision.reason);
 }
-function decideStoreLockTakeover(owner) {
+var FOREIGN_STORE_LOCK_REASON_PREFIX = "journal belongs to another workspace";
+function existingRealPath(pathname) {
+  try {
+    return realpathSync2(pathname);
+  } catch {
+    return null;
+  }
+}
+function sameDirectory(left, right) {
+  try {
+    const a = statSync3(left);
+    const b = statSync3(right);
+    return a.dev === b.dev && a.ino === b.ino;
+  } catch {
+    return false;
+  }
+}
+function owningWorkspaceRoot(storePath) {
+  let current = storePath;
+  for (;; ) {
+    const parent = dirname(current);
+    if (parent === current)
+      return null;
+    if (basename(parent) === "branches" && basename(dirname(parent)) === ".kb")
+      return dirname(dirname(parent));
+    current = parent;
+  }
+}
+function foreignStoreLockJournalRoot(owner, storePath) {
+  const recorded = owner?.workspaceRoot;
+  if (recorded === undefined || recorded === "")
+    return null;
+  const store = existingRealPath(storePath);
+  if (store === null)
+    return null;
+  const ownWorkspace = owningWorkspaceRoot(store);
+  if (ownWorkspace === null)
+    return null;
+  const lockPid = readRdfLockPid(join(storePath, "rdf", "lock"));
+  if (lockPid !== null && lockPid !== owner?.pid)
+    return null;
+  const recordedPath = existingRealPath(recorded);
+  if (recordedPath === null || recordedPath === store)
+    return null;
+  if (sameDirectory(recordedPath, store))
+    return null;
+  const recordedWorkspace = owningWorkspaceRoot(recordedPath) ?? recordedPath;
+  return recordedWorkspace === ownWorkspace ? null : recorded;
+}
+function decideStoreLockTakeover(owner, options = {}) {
   const state = classifyStoreLockHolder(owner);
+  if (state === "dead") {
+    return {
+      action: "break",
+      reason: `recorded holder pid ${owner?.pid ?? "?"} is no longer running`
+    };
+  }
+  const foreignRoot = options.storePath === undefined ? null : foreignStoreLockJournalRoot(owner, options.storePath);
+  if (foreignRoot !== null) {
+    return {
+      action: "break",
+      reason: `${FOREIGN_STORE_LOCK_REASON_PREFIX} ${foreignRoot}`
+    };
+  }
   switch (state) {
-    case "dead":
-      return {
-        action: "break",
-        reason: `recorded holder pid ${owner?.pid ?? "?"} is no longer running`
-      };
     case "unknown":
       return {
         action: "surface",
@@ -1897,7 +1960,9 @@ async function retryAttachAfterBreakingStaleLock(prolog, kbPath, failed) {
   const storeLocked = record?.storeLocked;
   if (storeLocked === undefined)
     return failed;
-  const decision = decideStoreLockTakeover(storeLocked.owner);
+  const decision = decideStoreLockTakeover(storeLocked.owner, {
+    storePath: kbPath
+  });
   if (decision.action !== "break") {
     const holderSummary = storeLocked.owner === null ? decision.reason : `pid ${storeLocked.owner.pid ?? "?"} (${decision.reason})`;
     return {
@@ -1930,7 +1995,7 @@ import {
   mkdirSync,
   readFileSync as readFileSync4,
   readdirSync,
-  statSync as statSync3,
+  statSync as statSync4,
   writeFileSync as writeFileSync2
 } from "node:fs";
 import path5 from "node:path";
@@ -2042,14 +2107,14 @@ function isValidBranchName(name) {
 }
 
 // ../cli/src/utils/canonical-path.ts
-import { lstatSync as lstatSync2, realpathSync as realpathSync2 } from "node:fs";
+import { lstatSync as lstatSync2, realpathSync as realpathSync3 } from "node:fs";
 import path7 from "node:path";
 function canonicalFilesystemPath(candidate) {
   let existing = path7.resolve(candidate);
   const missing = [];
   for (;; ) {
     try {
-      return path7.resolve(realpathSync2.native(existing), ...missing);
+      return path7.resolve(realpathSync3.native(existing), ...missing);
     } catch (error) {
       if (error.code !== "ENOENT")
         throw error;
@@ -2107,10 +2172,10 @@ function readJournalGeneration(branchPath) {
 function readEngineAttachmentIdentity(branchPath) {
   if (!existsSync6(branchPath))
     return null;
-  const stats = statSync4(branchPath);
+  const stats = statSync5(branchPath);
   let resolved = path8.resolve(branchPath);
   try {
-    resolved = realpathSync3(branchPath);
+    resolved = realpathSync4(branchPath);
   } catch {}
   return {
     path: resolved,
@@ -2356,9 +2421,23 @@ function recoverStaleJournalLock(branchPath) {
   if (!existsSync6(lockPath))
     return;
   const pid = readRdfLockPid(lockPath);
-  if (pid === null || pid === process.pid || isProcessAlive(pid))
+  if (pid === null || pid === process.pid)
     return;
-  recordStoreLockTakeover(branchPath, pid, decideStoreLockTakeover({ pid }).reason);
+  let reason;
+  if (!isProcessAlive(pid)) {
+    reason = decideStoreLockTakeover({ pid }).reason;
+  } else {
+    const journal = readStoreLockOwner(branchPath)?.owner ?? null;
+    if (journal === null || journal.pid !== pid)
+      return;
+    const decision = decideStoreLockTakeover(journal, {
+      storePath: branchPath
+    });
+    if (decision.action !== "break")
+      return;
+    reason = decision.reason;
+  }
+  recordStoreLockTakeover(branchPath, pid, reason);
   try {
     rmSync2(lockPath, { force: true });
   } catch {}