kibi-runtime 2.13.2 → 2.14.0

package/dist/engine-daemon.js

@@ -3,7 +3,7 @@ import { createRequire } from "node:module";
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // ../cli/src/engine-daemon.ts
-import { writeFileSync as writeFileSync3 } from "node:fs";
+import { writeFileSync as writeFileSync4 } from "node:fs";
 import path9 from "node:path";
 import { pathToFileURL } from "node:url";
 
@@ -24,7 +24,7 @@ import {
   rmSync as rmSync2,
   statSync as statSync4,
   unlinkSync,
-  writeFileSync as writeFileSync2
+  writeFileSync as writeFileSync3
 } from "node:fs";
 import * as net from "node:net";
 import * as os from "node:os";
@@ -102,7 +102,7 @@ function manifestVersion(manifestPath, expectedName) {
 }
 function cliVersion() {
   if (true)
-    return "2.17.0";
+    return "2.19.0";
   return manifestVersion(path.join(moduleDirectory, "..", "package.json"), "kibi-cli") ?? "unknown";
 }
 function coreVersion() {
@@ -1576,7 +1576,7 @@ writeln('${INTERACTIVE_QUERY_FRAME_END}').
       child.kill(signal);
     } catch {}
   }
-  async terminateProcessTree(child) {
+  async terminateProcessTree(child, graceMs = 0) {
     let closed = false;
     const exited = new Promise((resolve) => {
       const markExited = () => {
@@ -1586,6 +1586,19 @@ writeln('${INTERACTIVE_QUERY_FRAME_END}').
       child.once("close", markExited);
       child.once("error", markExited);
     });
+    if (graceMs > 0 && child.exitCode === null && child.signalCode === null) {
+      let graceTimer;
+      await Promise.race([
+        exited,
+        new Promise((resolve) => {
+          graceTimer = setTimeout(resolve, graceMs);
+        })
+      ]);
+      if (graceTimer)
+        clearTimeout(graceTimer);
+      if (closed)
+        return;
+    }
     if (child.exitCode === null)
       this.signalProcessTree(child, "SIGTERM");
     await Promise.race([
@@ -1707,7 +1720,7 @@ writeln('${INTERACTIVE_QUERY_FRAME_END}').
     }
     return new PrologProcessTerminatedError(this.terminationReason ?? "process exited");
   }
-  async terminate() {
+  async terminate(options = {}) {
     if (this.interactiveStarted) {
       this.terminationReason ??= "terminated";
     }
@@ -1727,7 +1740,7 @@ writeln('${INTERACTIVE_QUERY_FRAME_END}').
       this.terminationPromise = (async () => {
         if (current) {
           current.stdin?.end();
-          await this.terminateProcessTree(current);
+          await this.terminateProcessTree(current, options.graceMs ?? 0);
         }
         await Promise.all(oneShots.map((child) => this.terminateProcessTree(child)));
       })();
@@ -1741,7 +1754,7 @@ writeln('${INTERACTIVE_QUERY_FRAME_END}').
 }
 
 // ../cli/src/prolog/store-lock.ts
-import { existsSync as existsSync4, rmSync } from "node:fs";
+import { existsSync as existsSync4, rmSync, writeFileSync } from "node:fs";
 import { readFileSync as readFileSync3 } from "node:fs";
 import { dirname, join } from "node:path";
 var cachedBootId;
@@ -1785,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"),
@@ -1797,6 +1837,40 @@ function breakStoreLock(rdfDirectory) {
     }
   }
 }
+var STORE_LOCK_TAKEOVER_FILE = ".kibi-lock-takeover.json";
+var STORE_LOCK_TAKEOVER_VISIBLE_MS = 24 * 60 * 60 * 1000;
+function recordStoreLockTakeover(storePath, brokenPid, reason, at = new Date) {
+  try {
+    writeFileSync(join(storePath, STORE_LOCK_TAKEOVER_FILE), `${JSON.stringify({ brokenPid, reason, at: at.toISOString() })}
+`, { 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) {
@@ -1833,6 +1907,7 @@ Store lock holder: ${holderSummary}. Close that session, or run 'kibi engine sto
     };
   }
   const lockDirectory = storeLocked.lockDirectory !== "" ? storeLocked.lockDirectory : join(kbPath, "rdf");
+  recordStoreLockTakeover(kbPath, storeLocked.owner?.pid ?? null, decision.reason);
   breakStoreLock(lockDirectory);
   const retried = await prolog.query(`kb_attach('${escapeAtom(kbPath)}')`);
   if (retried.success) {
@@ -1856,7 +1931,7 @@ import {
   readFileSync as readFileSync4,
   readdirSync,
   statSync as statSync3,
-  writeFileSync
+  writeFileSync as writeFileSync2
 } from "node:fs";
 import path5 from "node:path";
 var BRANCH_STORE_MANIFEST_VERSION = 1;
@@ -1918,7 +1993,7 @@ function ensureBranchStoreManifest(workspaceRoot, branch) {
     if (entries.length > 0) {
       throw new Error(`Branch store at ${storePath} has compiled data but no valid identity manifest; refusing to adopt it.`);
     }
-    writeFileSync(manifestPath, `${JSON.stringify(expectedBranchStoreManifest(branch), null, 2)}
+    writeFileSync2(manifestPath, `${JSON.stringify(expectedBranchStoreManifest(branch), null, 2)}
 `, { mode: 384 });
   }
   return storePath;
@@ -2005,6 +2080,8 @@ var READ_LIMITED_METHODS = new Set([
 ]);
 var ENGINE_PROTOCOL_VERSION = 1;
 var ENGINE_IDLE_TIMEOUT_MS = 10 * 60 * 1000;
+var ENGINE_IDLE_CHECK_INTERVAL_MS = 30 * 1000;
+var ENGINE_PROLOG_EXIT_GRACE_MS = 1000;
 function enginePackageVersions() {
   return kibiPackageVersions();
 }
@@ -2174,7 +2251,7 @@ function runtimeDirectory() {
       try {
         mkdirSync2(candidate, { recursive: true, mode: 448 });
         const probe = path8.join(candidate, `.kibi-write-${process.pid}`);
-        writeFileSync2(probe, "", { mode: 384 });
+        writeFileSync3(probe, "", { mode: 384 });
         unlinkSync(probe);
         return candidate;
       } catch {}
@@ -2214,7 +2291,7 @@ function runtimeDirectory() {
       if (Buffer.byteLength(path8.join(canonical, socketName), "utf8") > maximumBytes)
         continue;
       const probe = path8.join(canonical, `.kibi-write-${randomUUID()}`);
-      writeFileSync2(probe, "", { mode: 384, flag: "wx" });
+      writeFileSync3(probe, "", { mode: 384, flag: "wx" });
       unlinkSync(probe);
       return canonical;
     } catch {}
@@ -2278,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) => {
@@ -2340,7 +2404,7 @@ async function ensureJournaledBranchStoreAsync(branchPath) {
         recoverStaleJournalLock(branchPath);
         archiveLegacyFiles(branchPath);
         if (!existsSync6(sentinelPath)) {
-          writeFileSync2(sentinelPath, `KIBI_STORAGE_FORMAT=kibi.rdf-journal.v1
+          writeFileSync3(sentinelPath, `KIBI_STORAGE_FORMAT=kibi.rdf-journal.v1
 `, { mode: 384 });
         }
         return;
@@ -2359,7 +2423,7 @@ async function ensureJournaledBranchStoreAsync(branchPath) {
       recoverStaleJournalLock(branchPath);
       archiveLegacyFiles(branchPath);
       if (!existsSync6(sentinelPath)) {
-        writeFileSync2(sentinelPath, `KIBI_STORAGE_FORMAT=kibi.rdf-journal.v1
+        writeFileSync3(sentinelPath, `KIBI_STORAGE_FORMAT=kibi.rdf-journal.v1
 `, { mode: 384 });
       }
       return;
@@ -2369,13 +2433,13 @@ async function ensureJournaledBranchStoreAsync(branchPath) {
   const legacyAudit = path8.join(branchPath, "audit.log");
   if (!existsSync6(legacyRdf) && !existsSync6(legacyAudit)) {
     mkdirSync2(path8.join(branchPath, "rdf"), { recursive: true });
-    writeFileSync2(markerPath, `{"format":"kibi.rdf-journal.v1","schemaVersion":1}
+    writeFileSync3(markerPath, `{"format":"kibi.rdf-journal.v1","schemaVersion":1}
 `, { mode: 384 });
-    writeFileSync2(path8.join(branchPath, "CURRENT"), `generation-1:0
+    writeFileSync3(path8.join(branchPath, "CURRENT"), `generation-1:0
 `, {
       mode: 384
     });
-    writeFileSync2(path8.join(branchPath, "kb.rdf"), `KIBI_STORAGE_FORMAT=kibi.rdf-journal.v1
+    writeFileSync3(path8.join(branchPath, "kb.rdf"), `KIBI_STORAGE_FORMAT=kibi.rdf-journal.v1
 `, { mode: 384 });
     return;
   }
@@ -2424,7 +2488,7 @@ async function ensureJournaledBranchStoreAsync(branchPath) {
     renameSync(source, target);
   }
   archiveLegacyFiles(branchPath);
-  writeFileSync2(path8.join(branchPath, "kb.rdf"), `KIBI_STORAGE_FORMAT=kibi.rdf-journal.v1
+  writeFileSync3(path8.join(branchPath, "kb.rdf"), `KIBI_STORAGE_FORMAT=kibi.rdf-journal.v1
 `, { mode: 384 });
   fsyncJournaledBranchStore(branchPath);
   rmSync2(staging, { recursive: true, force: true });
@@ -2517,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");
@@ -2617,11 +2684,12 @@ async function runEngineDaemon(requestedOptions) {
       rmSync2(options.socketPath, { force: true });
     } catch {}
   }
-  writeFileSync2(enginePidPath(options.workspaceRoot, options.branch), `${process.pid}
+  writeFileSync3(enginePidPath(options.workspaceRoot, options.branch), `${process.pid}
 `, { mode: 384 });
   const server = net.createServer();
   let activeClients = 0;
-  let idleTimer = null;
+  let lastActivityAt = Date.now();
+  let idleWatch = null;
   let queue = Promise.resolve();
   let idleCompactionQueued = false;
   const queryCache = new Map;
@@ -2698,12 +2766,15 @@ async function runEngineDaemon(requestedOptions) {
         idleCompactionQueued = false;
       });
     }
-    if (idleTimer)
-      clearTimeout(idleTimer);
-    idleTimer = setTimeout(() => {
-      if (activeClients === 0)
+    lastActivityAt = Date.now();
+    if (idleWatch)
+      return;
+    const idleMs = engineIdleTimeoutMs();
+    idleWatch = setInterval(() => {
+      if (!shuttingDown && activeClients === 0 && Date.now() - lastActivityAt >= idleMs)
         shutdown();
-    }, engineIdleTimeoutMs());
+    }, Math.min(idleMs, ENGINE_IDLE_CHECK_INTERVAL_MS));
+    idleWatch.unref();
   };
   const handle = async (request, cancelledRequests) => {
     if (request.protocolVersion !== ENGINE_PROTOCOL_VERSION) {
@@ -2958,20 +3029,22 @@ async function runEngineDaemon(requestedOptions) {
     shuttingDown = true;
     process.off("SIGTERM", requestSignalShutdown);
     process.off("SIGINT", requestSignalShutdown);
-    if (idleTimer)
-      clearTimeout(idleTimer);
+    if (idleWatch)
+      clearInterval(idleWatch);
     clearInterval(workspaceWatchdog);
     server.close();
     await queue.catch(() => {
       return;
     });
     const saved = session.needsRecycle() ? null : await prolog.query("kb_save").catch(() => null);
+    let detached = false;
     if (saved?.success) {
       try {
         fsyncJournaledBranchStore(branchPath);
       } catch {}
+      detached = await prolog.query("kb_detach").then((result) => result.success).catch(() => false);
     }
-    await prolog.terminate().catch(() => {
+    await prolog.terminate({ graceMs: detached ? 0 : ENGINE_PROLOG_EXIT_GRACE_MS }).catch(() => {
       return;
     });
     for (const client of clients)
@@ -3008,6 +3081,7 @@ async function runEngineDaemon(requestedOptions) {
         const bytes = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
         buffer = parseFrames(Buffer.concat([buffer, bytes]), (value) => {
           const request = value;
+          lastActivityAt = Date.now();
           if (shuttingDown) {
             writeSocketFrame(socket, {
               id: request.id,
@@ -3114,7 +3188,7 @@ async function runEngineDaemonCli(args = process.argv.slice(2)) {
     const socketPath = socketIndex >= 0 ? args[socketIndex + 1] : undefined;
     if (socketPath) {
       try {
-        writeFileSync3(`${socketPath}.error`, `${message}
+        writeFileSync4(`${socketPath}.error`, `${message}
 `, { mode: 384 });
       } catch {}
     }