@askexenow/exe-os 0.9.414 → 0.9.415

package/dist/lib/db-read-worker-client.js

@@ -11,12 +11,46 @@ import "../chunk-MLKGABMK.js";
 import { fork } from "child_process";
 import { existsSync } from "fs";
 import path from "path";
+import { fileURLToPath } from "url";
 import { randomUUID } from "crypto";
 var _worker = null;
 var _workerReady = false;
 var _spawnAttempts = 0;
 var MAX_SPAWN_ATTEMPTS = 5;
-var QUERY_TIMEOUT_MS = 12e4;
+function queryTimeoutMs() {
+  return Number(process.env.EXE_DB_READ_WORKER_TIMEOUT_MS) || 12e4;
+}
+var _restarting = false;
+var _lastSpawnArgs = null;
+var _readyDeadline = null;
+var _retryAfterExit = false;
+function respawnReadyTimeoutMs() {
+  return Number(process.env.EXE_DB_READ_WORKER_READY_TIMEOUT_MS) || 3e4;
+}
+function clearReadyDeadline() {
+  if (_readyDeadline) clearTimeout(_readyDeadline);
+  _readyDeadline = null;
+}
+function armReadyDeadline(child) {
+  clearReadyDeadline();
+  const ms = respawnReadyTimeoutMs();
+  _readyDeadline = setTimeout(() => {
+    _readyDeadline = null;
+    if (_worker !== child || _workerReady) return;
+    process.stderr.write(
+      `[exed] DB read worker respawn (pid=${child.pid}) not ready after ${ms}ms \u2014 marking it unavailable (reads use the direct path) and retrying the spawn.
+`
+    );
+    _restarting = false;
+    rejectAllPending(`db read worker not available (respawn not ready after ${ms}ms)`);
+    _retryAfterExit = true;
+    try {
+      child.kill("SIGKILL");
+    } catch {
+    }
+  }, ms);
+  _readyDeadline.unref?.();
+}
 var _pending = /* @__PURE__ */ new Map();
 function buildDbReadWorkerEnv(dbPath, encryptionKey, source = process.env) {
   const env = {
@@ -29,18 +63,43 @@ function buildDbReadWorkerEnv(dbPath, encryptionKey, source = process.env) {
   if (encryptionKey) env.EXE_DB_READ_WORKER_KEY = encryptionKey;
   return env;
 }
-function rejectAllPending(reason) {
+var DbReadWorkerTimeoutError = class extends Error {
+  constructor(timeoutMs) {
+    super(`db read worker query timed out after ${timeoutMs}ms (not re-run on the daemon event loop)`);
+    this.name = "DbReadWorkerTimeoutError";
+  }
+};
+var DbReadWorkerRestartedError = class extends Error {
+  retryable = true;
+  constructor(detail) {
+    super(`db read worker restarted (${detail}); retry the read`);
+    this.name = "DbReadWorkerRestartedError";
+  }
+};
+function isDbReadWorkerTimeout(err) {
+  return err instanceof DbReadWorkerTimeoutError || err instanceof DbReadWorkerRestartedError;
+}
+function rejectAll(make, which = () => true) {
   for (const [id, cb] of _pending) {
+    if (!which(cb)) continue;
     clearTimeout(cb.timer);
-    cb.reject(new Error(reason));
+    cb.reject(make());
     _pending.delete(id);
   }
 }
+function rejectAllPending(reason) {
+  rejectAll(() => new Error(reason));
+}
+function resolveReadWorkerPath() {
+  if (process.env.EXE_DB_READ_WORKER_BIN) return process.env.EXE_DB_READ_WORKER_BIN;
+  return path.join(path.dirname(fileURLToPath(import.meta.url)), "db-read-worker.js");
+}
 function spawnDbReadWorker(dbPath, encryptionKey) {
   if (_worker) return;
+  _lastSpawnArgs = { dbPath, encryptionKey };
   if (_spawnAttempts >= MAX_SPAWN_ATTEMPTS) return;
   _spawnAttempts++;
-  const workerPath = path.join(path.dirname(new URL(import.meta.url).pathname), "db-read-worker.js");
+  const workerPath = resolveReadWorkerPath();
   if (!existsSync(workerPath)) {
     process.stderr.write(`[db-read-worker-client] worker not found at ${workerPath} \u2014 heavy reads will run on the event loop.
 `);
@@ -52,20 +111,31 @@ function spawnDbReadWorker(dbPath, encryptionKey) {
     _spawnAttempts = Math.max(0, _spawnAttempts - 1);
     return;
   }
+  let child;
   try {
-    _worker = fork(workerPath, [], { stdio: ["ignore", "ignore", "inherit", "ipc"], env });
+    child = fork(workerPath, [], { stdio: ["ignore", "ignore", "inherit", "ipc"], env });
   } catch (err) {
     process.stderr.write(`[db-read-worker-client] fork failed: ${err instanceof Error ? err.message : String(err)}
 `);
     _worker = null;
     return;
   }
-  _worker.on("message", (msg) => {
+  _worker = child;
+  if (_restarting || _retryAfterExit) armReadyDeadline(child);
+  _retryAfterExit = false;
+  child.on("message", (msg) => {
     if (msg.type === "ready") {
+      if (_worker !== child) return;
+      clearReadyDeadline();
       _workerReady = !msg.error;
       _spawnAttempts = 0;
-      process.stderr.write(`[exed] DB read worker ${msg.error ? `failed: ${msg.error}` : `ready (pid=${_worker?.pid})`}
+      process.stderr.write(`[exed] DB read worker ${msg.error ? `failed: ${msg.error}` : `ready (pid=${child.pid})`}
 `);
+      if (_restarting) {
+        _restarting = false;
+        if (_workerReady) flushQueued();
+        else rejectAll(() => new Error("db read worker not available (restart failed)"));
+      }
       return;
     }
     if (!msg.id) return;
@@ -77,22 +147,41 @@ function spawnDbReadWorker(dbPath, encryptionKey) {
     else if (msg.db) cb.resolve(msg.db);
     else cb.reject(new Error("invalid read-worker response"));
   });
-  _worker.on("error", (err) => {
+  child.on("error", (err) => {
     process.stderr.write(`[exed] DB read worker error: ${err.message}
 `);
     _workerReady = false;
-    rejectAllPending("read worker crashed");
+    if (!_restarting) rejectAllPending("read worker crashed");
   });
-  _worker.on("exit", (code, signal) => {
+  child.on("exit", (code, signal) => {
     process.stderr.write(`[exed] DB read worker exited (code=${code}, signal=${signal ?? "none"}).
 `);
-    _workerReady = false;
+    if (_worker !== child) return;
+    clearReadyDeadline();
     _worker = null;
-    rejectAllPending("read worker exited");
+    _workerReady = false;
+    if (_retryAfterExit) {
+      if (_lastSpawnArgs) spawnDbReadWorker(_lastSpawnArgs.dbPath, _lastSpawnArgs.encryptionKey);
+      _retryAfterExit = false;
+      return;
+    }
+    if (!_restarting) {
+      rejectAllPending("read worker exited");
+      return;
+    }
+    rejectAll(
+      () => new DbReadWorkerRestartedError("killed after a query exceeded its timeout"),
+      (p) => p.sent
+    );
+    if (_lastSpawnArgs) spawnDbReadWorker(_lastSpawnArgs.dbPath, _lastSpawnArgs.encryptionKey);
+    if (!_worker) {
+      _restarting = false;
+      rejectAllPending("db read worker not available (respawn failed)");
+    }
   });
 }
 function isDbReadWorkerReady() {
-  return _worker !== null && _workerReady;
+  return _worker !== null && (_workerReady || _restarting);
 }
 async function runReadQueryInWorker(sql, args = []) {
   return deserializeResultSet(
@@ -100,26 +189,62 @@ async function runReadQueryInWorker(sql, args = []) {
   );
 }
 function runReadQueryInWorkerSerialized(sql, args = []) {
-  if (!_worker || !_workerReady) {
+  if (!_worker || !_workerReady && !_restarting) {
     return Promise.reject(new Error("db read worker not available"));
   }
   const id = randomUUID();
+  const timeoutMs = queryTimeoutMs();
   return new Promise((resolve, reject) => {
-    const timer = setTimeout(() => {
-      _pending.delete(id);
-      reject(new Error("db read worker query timed out"));
-    }, QUERY_TIMEOUT_MS);
-    _pending.set(id, { resolve, reject, timer });
-    try {
-      _worker.send({ id, type: "query", sql, args });
-    } catch (err) {
-      _pending.delete(id);
-      clearTimeout(timer);
-      reject(err instanceof Error ? err : new Error(String(err)));
-    }
+    const timer = setTimeout(() => onQueryTimeout(id, timeoutMs), timeoutMs);
+    const entry = { resolve, reject, timer, message: { id, type: "query", sql, args }, sent: false };
+    _pending.set(id, entry);
+    if (!_restarting) sendPending(id, entry);
   });
 }
+function sendPending(id, entry) {
+  try {
+    _worker.send(entry.message);
+    entry.sent = true;
+  } catch (err) {
+    _pending.delete(id);
+    clearTimeout(entry.timer);
+    entry.reject(err instanceof Error ? err : new Error(String(err)));
+  }
+}
+function flushQueued() {
+  for (const [id, entry] of _pending) {
+    if (!entry.sent) sendPending(id, entry);
+  }
+}
+function onQueryTimeout(id, timeoutMs) {
+  const entry = _pending.get(id);
+  if (!entry) return;
+  _pending.delete(id);
+  if (!entry.sent) {
+    entry.reject(new DbReadWorkerRestartedError(`still restarting after ${timeoutMs}ms`));
+    return;
+  }
+  entry.reject(new DbReadWorkerTimeoutError(timeoutMs));
+  const worker = _worker;
+  if (!worker || _restarting) return;
+  process.stderr.write(
+    `[exed] DB read worker query ${id.slice(0, 8)} exceeded ${timeoutMs}ms \u2014 killing the read worker and respawning it.
+`
+  );
+  _restarting = true;
+  _workerReady = false;
+  try {
+    worker.kill("SIGKILL");
+  } catch {
+  }
+}
+function _getDbReadWorkerForTests() {
+  return _worker;
+}
 function disposeDbReadWorker() {
+  _restarting = false;
+  _retryAfterExit = false;
+  clearReadyDeadline();
   rejectAllPending("read worker disposed");
   if (_worker) {
     try {
@@ -131,9 +256,13 @@ function disposeDbReadWorker() {
   _workerReady = false;
 }
 export {
+  DbReadWorkerRestartedError,
+  DbReadWorkerTimeoutError,
+  _getDbReadWorkerForTests,
   buildDbReadWorkerEnv,
   disposeDbReadWorker,
   isDbReadWorkerReady,
+  isDbReadWorkerTimeout,
   runReadQueryInWorker,
   runReadQueryInWorkerSerialized,
   spawnDbReadWorker

package/dist/lib/db-write-worker-client.js

@@ -4,12 +4,14 @@ import {
   disposeDbWriteWorker,
   isDbWriteWorkerReady,
   isWriteWorkerEnabled,
+  memoryWriteBehindSweepBoundMs,
   requestMaintenanceWrite,
+  resolveDbWriteWorkerPath,
   spawnDbWriteWorker,
   sweepConversationsRetentionInWorker,
   sweepSessionEventsRetentionInWorker,
   writeMemoryInWorker
-} from "../chunk-PEYQ6MWO.js";
+} from "../chunk-R3ZU4F7M.js";
 import "../chunk-YYB5PMTK.js";
 import "../chunk-MLKGABMK.js";
 export {
@@ -18,7 +20,9 @@ export {
   disposeDbWriteWorker,
   isDbWriteWorkerReady,
   isWriteWorkerEnabled,
+  memoryWriteBehindSweepBoundMs,
   requestMaintenanceWrite,
+  resolveDbWriteWorkerPath,
   spawnDbWriteWorker,
   sweepConversationsRetentionInWorker,
   sweepSessionEventsRetentionInWorker,

package/dist/lib/db-write-worker.js

@@ -1,9 +1,9 @@
 import {
   insertOntologyForMemory
-} from "../chunk-YVWXI2HM.js";
+} from "../chunk-H6HWBMJ3.js";
 import {
   persistMemoryBatch
-} from "../chunk-6777GNWI.js";
+} from "../chunk-YBVSVB6C.js";
 import "../chunk-7FE43JRU.js";
 import {
   isPostgresBackendEnabled
@@ -180,9 +180,9 @@ async function handleSessionEventsRetention(msg) {
     return;
   }
   try {
-    const { sweepExpiredSessionEvents } = await import("../session-events-7IJGTBVH.js");
-    const deleted = await sweepExpiredSessionEvents(_client, msg.retentionDays);
-    send({ id: msg.id, deleted });
+    const { sweepExpiredSessionEventsBatches } = await import("../session-events-OOYSDWTW.js");
+    const { deleted, drained } = await sweepExpiredSessionEventsBatches(_client, msg.retentionDays, msg.maxBatches);
+    send({ id: msg.id, deleted, drained });
   } catch (err) {
     send({ id: msg.id, error: err instanceof Error ? err.message : String(err) });
   }
@@ -194,13 +194,14 @@ async function handleConversationsRetention(msg) {
     return;
   }
   try {
-    const { sweepExpiredConversations, parseConversationsRetentionMode } = await import("../conversations-retention-XTBFJBUM.js");
+    const { sweepExpiredConversations, parseConversationsRetentionMode } = await import("../conversations-retention-HFM2K6ND.js");
     const res = await sweepExpiredConversations(
       _client,
       msg.retentionDays,
-      parseConversationsRetentionMode(msg.retentionMode)
+      parseConversationsRetentionMode(msg.retentionMode),
+      { maxBatches: msg.maxBatches }
     );
-    send({ id: msg.id, deleted: res.removed, archived: res.archived, purged: res.purged, mode: res.mode });
+    send({ id: msg.id, deleted: res.removed, archived: res.archived, purged: res.purged, mode: res.mode, drained: res.drained });
   } catch (err) {
     send({ id: msg.id, error: err instanceof Error ? err.message : String(err) });
   }

package/dist/lib/db.js

@@ -44,13 +44,14 @@ import {
   sweepExpiredSoftDeletedMemories,
   tryGetRawClient,
   verifyAndCleanStaleDbLock
-} from "../chunk-L5JFVK5T.js";
+} from "../chunk-GDZJL5GQ.js";
 import "../chunk-BBMTVAE3.js";
 import "../chunk-TKDITWDN.js";
-import "../chunk-SINIRUYZ.js";
-import "../chunk-6777GNWI.js";
-import "../chunk-7FE43JRU.js";
 import "../chunk-5YEUPUV4.js";
+import "../chunk-I4N7F54M.js";
+import "../chunk-CCFWKW2D.js";
+import "../chunk-YBVSVB6C.js";
+import "../chunk-7FE43JRU.js";
 import "../chunk-YYB5PMTK.js";
 import "../chunk-WAAGVFFN.js";
 import "../chunk-QH5ZQ5SJ.js";

package/dist/lib/device-registry.js

@@ -3,7 +3,7 @@ import {
   getDeviceInfo,
   resolveTargetDevice,
   setFriendlyName
-} from "../chunk-6D2O5SAH.js";
+} from "../chunk-GTGXFYYI.js";
 import "../chunk-MMS2HBRT.js";
 import "../chunk-RH4AH3YB.js";
 import "../chunk-HSGBZSCA.js";

package/dist/lib/employee-templates.js

@@ -11,17 +11,18 @@ import {
   getTemplateByRole,
   personalizePrompt,
   renderClientCOOTemplate
-} from "../chunk-TS4LSNRI.js";
-import "../chunk-HDQAVAV6.js";
+} from "../chunk-745M4HPM.js";
+import "../chunk-D6ORFO5E.js";
 import "../chunk-4CN3EE6U.js";
-import "../chunk-N45FAI6D.js";
-import "../chunk-L5JFVK5T.js";
+import "../chunk-EORDC4BQ.js";
+import "../chunk-GDZJL5GQ.js";
 import "../chunk-BBMTVAE3.js";
 import "../chunk-TKDITWDN.js";
-import "../chunk-SINIRUYZ.js";
-import "../chunk-6777GNWI.js";
-import "../chunk-7FE43JRU.js";
 import "../chunk-5YEUPUV4.js";
+import "../chunk-I4N7F54M.js";
+import "../chunk-CCFWKW2D.js";
+import "../chunk-YBVSVB6C.js";
+import "../chunk-7FE43JRU.js";
 import "../chunk-YYB5PMTK.js";
 import "../chunk-WAAGVFFN.js";
 import "../chunk-QH5ZQ5SJ.js";

package/dist/lib/employees.js

@@ -31,13 +31,14 @@ import {
   saveEmployees,
   shouldAutoInstance,
   validateEmployeeName
-} from "../chunk-L5JFVK5T.js";
+} from "../chunk-GDZJL5GQ.js";
 import "../chunk-BBMTVAE3.js";
 import "../chunk-TKDITWDN.js";
-import "../chunk-SINIRUYZ.js";
-import "../chunk-6777GNWI.js";
-import "../chunk-7FE43JRU.js";
 import "../chunk-5YEUPUV4.js";
+import "../chunk-I4N7F54M.js";
+import "../chunk-CCFWKW2D.js";
+import "../chunk-YBVSVB6C.js";
+import "../chunk-7FE43JRU.js";
 import "../chunk-YYB5PMTK.js";
 import "../chunk-WAAGVFFN.js";
 import "../chunk-QH5ZQ5SJ.js";