kibi-runtime 2.13.3 → 2.14.0

package/dist/engine-daemon.js

@@ -102,7 +102,7 @@ function manifestVersion(manifestPath, expectedName) {
 }
 function cliVersion() {
   if (true)
-    return "2.18.0";
+    return "2.19.0";
   return manifestVersion(path.join(moduleDirectory, "..", "package.json"), "kibi-cli") ?? "unknown";
 }
 function coreVersion() {
@@ -1798,6 +1798,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,6 +1845,32 @@ function recordStoreLockTakeover(storePath, brokenPid, reason, at = new Date) {
 `, { mode: 384 });
   } catch {}
 }
+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);
+  if (decision.action !== "break")
+    return () => {
+      return;
+    };
+  const brokenPid = owner?.pid ?? null;
+  return () => recordStoreLockTakeover(kbPath, brokenPid, decision.reason);
+}
 function decideStoreLockTakeover(owner) {
   const state = classifyStoreLockHolder(owner);
   switch (state) {
@@ -2302,26 +2355,13 @@ function recoverStaleJournalLock(branchPath) {
   const lockPath = path8.join(branchPath, "rdf", "lock");
   if (!existsSync6(lockPath))
     return;
-  let contents = "";
-  try {
-    contents = readFileSync5(lockPath, "utf8");
-  } catch {
-    return;
-  }
-  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)
+  const pid = readRdfLockPid(lockPath);
+  if (pid === null || pid === process.pid || isProcessAlive(pid))
     return;
+  recordStoreLockTakeover(branchPath, pid, decideStoreLockTakeover({ 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 +2581,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");