kibi-runtime 2.13.3 → 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.18.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)
@@ -1798,6 +1804,33 @@ function classifyStoreLockHolder(owner) {
   }
   return "alive";
 }
+function readStoreLockOwner(storePath) {
+  const candidates = [
+    join(storePath, ".kibi-lock-owner.json"),
+    join(storePath, "rdf", ".kibi-lock-owner.json")
+  ];
+  for (const journalPath of candidates) {
+    if (!existsSync4(journalPath))
+      continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(readFileSync3(journalPath, "utf8"));
+    } catch {
+      continue;
+    }
+    if (parsed === null || typeof parsed !== "object")
+      continue;
+    const record = parsed;
+    const owner = {
+      ...typeof record.pid === "number" ? { pid: record.pid } : {},
+      ...typeof record.workspaceRoot === "string" ? { workspaceRoot: record.workspaceRoot } : {},
+      ...typeof record.bootId === "string" ? { bootId: record.bootId } : {},
+      ...typeof record.startedAt === "string" ? { startedAt: record.startedAt } : {}
+    };
+    return { owner, journalPath };
+  }
+  return null;
+}
 function breakStoreLock(rdfDirectory) {
   const candidates = [
     join(rdfDirectory, "lock"),
@@ -1818,14 +1851,97 @@ function recordStoreLockTakeover(storePath, brokenPid, reason, at = new Date) {
 `, { mode: 384 });
   } catch {}
 }
-function decideStoreLockTakeover(owner) {
+function readRdfLockPid(lockPath) {
+  try {
+    const match = /pid\((\d+)\)/.exec(readFileSync3(lockPath, "utf8"));
+    const pid = Number.parseInt(match?.[1] ?? "", 10);
+    return Number.isInteger(pid) && pid > 0 ? pid : null;
+  } catch {
+    return null;
+  }
+}
+function noteDeadHolderBeforeAttach(kbPath) {
+  const lockPath = join(kbPath, "rdf", "lock");
+  if (!existsSync4(lockPath))
+    return () => {
+      return;
+    };
+  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, { storePath: kbPath });
+  if (decision.action !== "break")
+    return () => {
+      return;
+    };
+  const brokenPid = owner?.pid ?? null;
+  return () => recordStoreLockTakeover(kbPath, brokenPid, decision.reason);
+}
+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",
@@ -1844,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 {
@@ -1877,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";
@@ -1989,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;
@@ -2054,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,
@@ -2302,26 +2420,27 @@ function recoverStaleJournalLock(branchPath) {
   const lockPath = path8.join(branchPath, "rdf", "lock");
   if (!existsSync6(lockPath))
     return;
-  let contents = "";
-  try {
-    contents = readFileSync5(lockPath, "utf8");
-  } catch {
+  const pid = readRdfLockPid(lockPath);
+  if (pid === null || pid === process.pid)
     return;
+  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;
   }
-  const match = /pid\((\d+)\)/.exec(contents);
-  if (!match)
-    return;
-  const pid = Number.parseInt(match[1] ?? "", 10);
-  if (!Number.isFinite(pid) || pid <= 0 || pid === process.pid)
-    return;
+  recordStoreLockTakeover(branchPath, pid, reason);
   try {
-    process.kill(pid, 0);
-    return;
-  } catch {
-    try {
-      rmSync2(lockPath, { force: true });
-    } catch {}
-  }
+    rmSync2(lockPath, { force: true });
+  } catch {}
 }
 function connectSocket(socketPath, timeoutMs) {
   return new Promise((resolve, reject) => {
@@ -2541,8 +2660,11 @@ class EngineSession {
   }
   async boot() {
     await this.prolog.start();
+    const recordTakeover = noteDeadHolderBeforeAttach(this.branchPath);
     const attached = await this.prolog.query(`kb_attach('${quoteProlog(this.branchPath)}')`);
-    if (!attached.success) {
+    if (attached.success)
+      recordTakeover();
+    else {
       const recovered = await retryAttachAfterBreakingStaleLock(this.prolog, this.branchPath, attached);
       if (!recovered.success)
         throw new Error(recovered.error ?? "Failed to attach branch KB");