@askexenow/exe-os 0.9.341 → 0.9.342

package/dist/chunk-O7LWR36Z.js

@@ -0,0 +1,269 @@
+// src/lib/dispatch-ack.ts
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+  unlinkSync,
+  readdirSync,
+  rmSync
+} from "fs";
+import path from "path";
+import os from "os";
+function ackDir() {
+  return process.env.EXE_DISPATCH_ACK_DIR || path.join(os.homedir(), ".exe-os", "dispatch-acks");
+}
+var DISPATCH_DEDUP_WINDOW_MS = 90 * 1e3;
+function ensureAckDir() {
+  const dir = ackDir();
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+}
+function writeDispatchPending(taskId, assignedTo, sessionName) {
+  ensureAckDir();
+  const signal = {
+    taskId,
+    assignedTo,
+    dispatchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    sessionName
+  };
+  writeFileSync(path.join(ackDir(), `${taskId}.pending`), JSON.stringify(signal), "utf-8");
+}
+function spawnLockName(taskId, bucket) {
+  return `${taskId}.spawnlock.b${bucket}`;
+}
+function ownerPidAlive(dir) {
+  try {
+    const owner = JSON.parse(readFileSync(path.join(dir, "owner.json"), "utf-8"));
+    if (typeof owner.pid !== "number") return true;
+    try {
+      process.kill(owner.pid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  } catch {
+    return true;
+  }
+}
+function tryAcquireDispatchClaim(taskId, assignedTo, sessionName, windowMs = DISPATCH_DEDUP_WINDOW_MS) {
+  ensureAckDir();
+  const dir = ackDir();
+  const bucket = Math.floor(Date.now() / windowMs);
+  const curLock = path.join(dir, spawnLockName(taskId, bucket));
+  const prevLock = path.join(dir, spawnLockName(taskId, bucket - 1));
+  try {
+    if (existsSync(prevLock) && ownerPidAlive(prevLock)) return false;
+  } catch {
+  }
+  try {
+    mkdirSync(curLock);
+  } catch (err) {
+    if (err?.code === "EEXIST") return false;
+    return true;
+  }
+  try {
+    writeFileSync(
+      path.join(curLock, "owner.json"),
+      JSON.stringify({ pid: process.pid, assignedTo, sessionName, ts: (/* @__PURE__ */ new Date()).toISOString() }),
+      "utf-8"
+    );
+  } catch {
+  }
+  try {
+    writeDispatchPending(taskId, assignedTo, sessionName);
+  } catch {
+  }
+  return true;
+}
+function removeSpawnLockdirs(taskId) {
+  const dir = ackDir();
+  try {
+    const prefix = `${taskId}.spawnlock.b`;
+    for (const entry of readdirSync(dir)) {
+      if (entry.startsWith(prefix)) {
+        try {
+          rmSync(path.join(dir, entry), { recursive: true, force: true });
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+}
+function releaseDispatchClaim(taskId, assignedTo, reason = "dispatch failed") {
+  ensureAckDir();
+  removeSpawnLockdirs(taskId);
+  try {
+    writeDispatchFailed(taskId, assignedTo, reason);
+  } catch {
+  }
+}
+function writeDispatchAck(taskId, agentId) {
+  ensureAckDir();
+  const pendingPath = path.join(ackDir(), `${taskId}.pending`);
+  const ackPath = path.join(ackDir(), `${taskId}.ack`);
+  let signal;
+  try {
+    signal = JSON.parse(readFileSync(pendingPath, "utf-8"));
+  } catch {
+    signal = { taskId, assignedTo: agentId, dispatchedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  }
+  signal.ackedAt = (/* @__PURE__ */ new Date()).toISOString();
+  writeFileSync(ackPath, JSON.stringify(signal), "utf-8");
+  try {
+    unlinkSync(pendingPath);
+  } catch {
+  }
+  removeSpawnLockdirs(taskId);
+}
+function writeDispatchFailed(taskId, assignedTo, error, sessionName) {
+  ensureAckDir();
+  const pendingPath = path.join(ackDir(), `${taskId}.pending`);
+  let signal;
+  try {
+    signal = JSON.parse(readFileSync(pendingPath, "utf-8"));
+  } catch {
+    signal = { taskId, assignedTo, dispatchedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  }
+  signal.failedAt = (/* @__PURE__ */ new Date()).toISOString();
+  signal.error = error;
+  if (sessionName) signal.sessionName = sessionName;
+  writeFileSync(path.join(ackDir(), `${taskId}.failed`), JSON.stringify(signal), "utf-8");
+  try {
+    unlinkSync(pendingPath);
+  } catch {
+  }
+}
+function checkDispatchStatus(taskId) {
+  ensureAckDir();
+  const ackPath = path.join(ackDir(), `${taskId}.ack`);
+  const failedPath = path.join(ackDir(), `${taskId}.failed`);
+  const pendingPath = path.join(ackDir(), `${taskId}.pending`);
+  if (existsSync(ackPath)) {
+    try {
+      const signal = JSON.parse(readFileSync(ackPath, "utf-8"));
+      return { status: "acked", signal };
+    } catch {
+      return { status: "acked" };
+    }
+  }
+  if (existsSync(failedPath)) {
+    try {
+      const signal = JSON.parse(readFileSync(failedPath, "utf-8"));
+      return { status: "failed", signal };
+    } catch {
+      return { status: "failed" };
+    }
+  }
+  if (existsSync(pendingPath)) {
+    try {
+      const signal = JSON.parse(readFileSync(pendingPath, "utf-8"));
+      return { status: "pending", signal };
+    } catch {
+      return { status: "pending" };
+    }
+  }
+  return { status: "unknown" };
+}
+var TERMINAL_FAILURE_DIR = path.join(os.homedir(), ".exe-os", "session-cache", "terminal-launcher-failure");
+var TERMINAL_FAILURE_DEFAULT_TTL_MS = Number(process.env.EXE_TERMINAL_FAILURE_TTL_MS) || 6 * 60 * 60 * 1e3;
+function terminalFailurePath(agentId, scope, baseDir) {
+  const safe = `${agentId}::${scope}`.replace(/[/\\]/g, "_");
+  return path.join(baseDir, `${safe}.json`);
+}
+function writeTerminalLauncherFailure(rec, baseDir = TERMINAL_FAILURE_DIR) {
+  try {
+    if (!existsSync(baseDir)) mkdirSync(baseDir, { recursive: true });
+    const payload = {
+      reason: rec.reason,
+      ...rec.detail ? { detail: rec.detail } : {},
+      runtime: rec.runtime,
+      ts: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    writeFileSync(terminalFailurePath(rec.agentId, rec.scope, baseDir), JSON.stringify(payload), "utf-8");
+  } catch {
+  }
+}
+function readTerminalLauncherFailure(agentId, scope, opts) {
+  const baseDir = opts?.baseDir ?? TERMINAL_FAILURE_DIR;
+  const ttlMs = opts?.ttlMs ?? TERMINAL_FAILURE_DEFAULT_TTL_MS;
+  const now = opts?.now ?? Date.now();
+  try {
+    const p = terminalFailurePath(agentId, scope, baseDir);
+    if (!existsSync(p)) return null;
+    const rec = JSON.parse(readFileSync(p, "utf-8"));
+    if (!rec || typeof rec.reason !== "string" || rec.reason.trim().length === 0) return null;
+    if (typeof rec.ts !== "string") return null;
+    if (typeof rec.runtime !== "string") return null;
+    const age = now - new Date(rec.ts).getTime();
+    if (!Number.isFinite(age)) return null;
+    if (age < 0 || age > ttlMs) return null;
+    return rec;
+  } catch {
+    return null;
+  }
+}
+function clearTerminalLauncherFailure(agentId, scope, baseDir = TERMINAL_FAILURE_DIR) {
+  try {
+    unlinkSync(terminalFailurePath(agentId, scope, baseDir));
+  } catch {
+  }
+}
+function cleanStaleDispatchAcks(maxAgeMs = 60 * 60 * 1e3) {
+  ensureAckDir();
+  const now = Date.now();
+  let cleaned = 0;
+  try {
+    const dir = ackDir();
+    for (const file of readdirSync(dir)) {
+      const fullPath = path.join(dir, file);
+      if (file.includes(".spawnlock.b")) {
+        try {
+          const owner = JSON.parse(readFileSync(path.join(fullPath, "owner.json"), "utf-8"));
+          const ownerTs = owner.ts ? new Date(owner.ts).getTime() : NaN;
+          if (!Number.isFinite(ownerTs) || now - ownerTs > maxAgeMs) {
+            rmSync(fullPath, { recursive: true, force: true });
+            cleaned++;
+          }
+        } catch {
+          try {
+            rmSync(fullPath, { recursive: true, force: true });
+            cleaned++;
+          } catch {
+          }
+        }
+        continue;
+      }
+      try {
+        const signal = JSON.parse(readFileSync(fullPath, "utf-8"));
+        const ts = signal.ackedAt ?? signal.dispatchedAt;
+        if (now - new Date(ts).getTime() > maxAgeMs) {
+          unlinkSync(fullPath);
+          cleaned++;
+        }
+      } catch {
+        try {
+          unlinkSync(fullPath);
+          cleaned++;
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  return cleaned;
+}
+
+export {
+  DISPATCH_DEDUP_WINDOW_MS,
+  writeDispatchPending,
+  tryAcquireDispatchClaim,
+  releaseDispatchClaim,
+  writeDispatchAck,
+  writeDispatchFailed,
+  checkDispatchStatus,
+  writeTerminalLauncherFailure,
+  readTerminalLauncherFailure,
+  clearTerminalLauncherFailure,
+  cleanStaleDispatchAcks
+};

package/dist/{chunk-BV6GBSRP.js → chunk-OLMQ4UOF.js}

@@ -1,9 +1,9 @@
 import {
   EXE_AI_DIR
-} from "./chunk-7Y5UDEVM.js";
+} from "./chunk-WZHZCDDO.js";
 
 // src/lib/db-backup.ts
-import { existsSync, readdirSync, unlinkSync, statSync, statfsSync } from "fs";
+import { existsSync, readdirSync, unlinkSync, statSync, statfsSync, constants as fsConstants } from "fs";
 import { copyFile, mkdir, unlink, rename } from "fs/promises";
 import path from "path";
 var BACKUP_DIR = path.join(EXE_AI_DIR, "backups");
@@ -18,6 +18,9 @@ var REASON_COUNT_CAP = {
   "pre-consolidation": 5,
   "pre-fix": 5,
   "pre-restore": 5,
+  // Bug 98cf412f: guaranteed sub-daily snapshots bound the restore window.
+  // At the default 6h cadence, keep the last 24h of restore points.
+  "guaranteed": 4,
   // Bug 91b1b167: daily snapshots are full uncompressed SQLCipher copies
   // (~2-3GB apiece on large enterprise DBs). Time-based rotation alone left
   // 19GB accumulating when mtimes drifted / the disk guard tripped. A hard
@@ -102,7 +105,7 @@ async function createBackupAsync(reason = "manual", opts = {}) {
     await unlink(tmpBackupPath);
   } catch {
   }
-  await copyFile(dbPath, tmpBackupPath);
+  await copyFile(dbPath, tmpBackupPath, fsConstants.COPYFILE_FICLONE);
   await rename(tmpBackupPath, backupPath);
   try {
     const { getClient } = await import("./lib/database.js");
@@ -139,7 +142,7 @@ async function createBackupAsync(reason = "manual", opts = {}) {
     }
   }
   try {
-    const { manifestWriteEnabled, writeBackupManifest } = await import("./backup-verify-ZAJLEL4X.js");
+    const { manifestWriteEnabled, writeBackupManifest } = await import("./backup-verify-3Y2FHGZU.js");
     if (manifestWriteEnabled()) {
       await writeBackupManifest(backupPath, dbName);
     }
@@ -218,6 +221,15 @@ function hasEnoughDiskSpace(freeBytes, backupSizeBytes, minFreeBytes = MIN_FREE_
   const required = Math.max(minFreeBytes, backupSizeBytes * 2);
   return freeBytes >= required;
 }
+function backupMinFreeRatio() {
+  const raw = Number(process.env.EXE_BACKUP_MIN_FREE_RATIO);
+  return Number.isFinite(raw) && raw > 0 ? raw : 2;
+}
+function shouldSkipBackupUnderMemoryPressure(freeBytes, dbBytes, ratio = backupMinFreeRatio()) {
+  if (!(dbBytes > 0)) return false;
+  if (!Number.isFinite(freeBytes)) return false;
+  return freeBytes < dbBytes * ratio;
+}
 function getFreeBytes(dir) {
   try {
     const s = statfsSync(dir);
@@ -380,16 +392,28 @@ function hasBackupToday(reason) {
   const backups = listBackups();
   return backups.some((b) => b.name.includes(reason) && b.name.includes(today.replace(/-/g, "-")));
 }
-function hasRecentBackup(reason, withinMs) {
+var DEFAULT_PRE_RESTART_DEDUP_MS = 30 * 60 * 1e3;
+function preRestartDedupWindowMs() {
+  const raw = Number(process.env.EXE_PRE_RESTART_DEDUP_MS);
+  return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : DEFAULT_PRE_RESTART_DEDUP_MS;
+}
+var REAL_RECENT_BACKUP_DEPS = {
+  backupDir: BACKUP_DIR,
+  existsSync,
+  readdirSync,
+  statMtimeMs: (p) => statSync(p).mtimeMs,
+  now: () => Date.now()
+};
+function hasRecentBackup(reason, withinMs, deps = REAL_RECENT_BACKUP_DEPS) {
   try {
-    if (!existsSync(BACKUP_DIR)) return false;
-    const now = Date.now();
-    for (const file of readdirSync(BACKUP_DIR)) {
+    if (!deps.existsSync(deps.backupDir)) return false;
+    const now = deps.now();
+    for (const file of deps.readdirSync(deps.backupDir)) {
       if (file.endsWith(".tmp")) continue;
       if (!file.endsWith(".db")) continue;
-      if (!file.includes(`-${reason}-`)) continue;
+      if (!matchesBackupReason(file, reason)) continue;
       try {
-        if (now - statSync(path.join(BACKUP_DIR, file)).mtimeMs <= withinMs) return true;
+        if (now - deps.statMtimeMs(path.join(deps.backupDir, file)) <= withinMs) return true;
       } catch {
       }
     }
@@ -397,6 +421,9 @@ function hasRecentBackup(reason, withinMs) {
   }
   return false;
 }
+function shouldMakePreRestartBackup(existingBackupMtimesMs, now, windowMs = preRestartDedupWindowMs()) {
+  return !existingBackupMtimesMs.some((mtime) => now - mtime <= windowMs);
+}
 function getLatestBackup() {
   const backups = listBackups();
   return backups.length > 0 ? backups[0].path : null;
@@ -462,6 +489,8 @@ export {
   selectStaleTmpFiles,
   cleanupStaleTmp,
   hasEnoughDiskSpace,
+  backupMinFreeRatio,
+  shouldSkipBackupUnderMemoryPressure,
   rotateBackupsByReason,
   matchesBackupReason,
   reasonFromBackupName,
@@ -471,7 +500,10 @@ export {
   cleanupCrashDebris,
   listBackups,
   hasBackupToday,
+  DEFAULT_PRE_RESTART_DEDUP_MS,
+  preRestartDedupWindowMs,
   hasRecentBackup,
+  shouldMakePreRestartBackup,
   getLatestBackup,
   restoreBackup,
   getBackupDir

package/dist/{chunk-UIU2DGRV.js → chunk-OTF44GXL.js}

@@ -8,11 +8,11 @@ import {
 import {
   loadLicense,
   readCachedLicenseToken
-} from "./chunk-7SEC2AG5.js";
+} from "./chunk-PQIDGXSG.js";
 import {
   EXE_AI_DIR,
   loadConfig
-} from "./chunk-7Y5UDEVM.js";
+} from "./chunk-WZHZCDDO.js";
 
 // src/bin/exe-support.ts
 import { mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
@@ -275,7 +275,7 @@ function nextForPostFailure(status) {
   return "Run `exe-os support health`; if it passes, send this output to AskExe.";
 }
 async function runFlush(json) {
-  const { flushSupportOutbox } = await import("./support-outbox-GB5SQFRJ.js");
+  const { flushSupportOutbox } = await import("./support-outbox-WHGPUYL2.js");
   const result = await flushSupportOutbox({ maxPerFlush: 10 });
   if (json) {
     console.log(JSON.stringify(result, null, 2));
@@ -298,7 +298,7 @@ async function runFlush(json) {
   console.log("");
 }
 async function runStatus(json) {
-  const { getOutboxStatus } = await import("./support-outbox-GB5SQFRJ.js");
+  const { getOutboxStatus } = await import("./support-outbox-WHGPUYL2.js");
   const status = await getOutboxStatus();
   if (json) {
     console.log(JSON.stringify(status, null, 2));