@askexenow/exe-os 0.9.295 → 0.9.296

package/dist/chunk-22TVSRQQ.js

@@ -0,0 +1,226 @@
+import {
+  getAgentContext
+} from "./chunk-GJV3WDWM.js";
+
+// src/lib/tmux-transport.ts
+import { execFileSync } from "child_process";
+import { writeFileSync, unlinkSync, mkdirSync } from "fs";
+import { randomBytes } from "crypto";
+import path from "path";
+import os from "os";
+var LONG_MESSAGE_THRESHOLD = 500;
+var TMUX_STATUS_CACHE_TTL_MS = Number(process.env.EXE_TMUX_STATUS_CACHE_TTL_MS || 2e3);
+var CODEX_SUBMIT_DELAY_MS = Number(process.env.EXE_CODEX_SUBMIT_DELAY_MS || 250);
+function sleepSync(ms) {
+  if (ms <= 0) return;
+  try {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+  } catch {
+  }
+}
+var QUIET = {
+  encoding: "utf8",
+  stdio: ["pipe", "pipe", "pipe"],
+  timeout: 3e3
+};
+var TmuxTransport = class {
+  sessionsCache = { ts: 0, sessions: [] };
+  paneStatusCache = { ts: 0, bySession: /* @__PURE__ */ new Map(), byPaneId: /* @__PURE__ */ new Map() };
+  invalidateCaches() {
+    this.sessionsCache = { ts: 0, sessions: [] };
+    this.paneStatusCache = { ts: 0, bySession: /* @__PURE__ */ new Map(), byPaneId: /* @__PURE__ */ new Map() };
+  }
+  listSessionsCached() {
+    const now = Date.now();
+    if (now - this.sessionsCache.ts < TMUX_STATUS_CACHE_TTL_MS) return this.sessionsCache.sessions;
+    try {
+      const sessions = execFileSync("tmux", ["list-sessions", "-F", "#{session_name}"], QUIET).trim().split("\n").filter(Boolean);
+      this.sessionsCache = { ts: now, sessions };
+      return sessions;
+    } catch {
+      this.sessionsCache = { ts: now, sessions: [] };
+      return [];
+    }
+  }
+  listPaneStatusCached() {
+    const now = Date.now();
+    if (now - this.paneStatusCache.ts < TMUX_STATUS_CACHE_TTL_MS) return this.paneStatusCache;
+    const bySession = /* @__PURE__ */ new Map();
+    const byPaneId = /* @__PURE__ */ new Map();
+    try {
+      const out = execFileSync(
+        "tmux",
+        ["list-panes", "-a", "-F", "#{session_name}	#{pane_id}	#{pane_dead}"],
+        QUIET
+      );
+      for (const line of out.trim().split("\n").filter(Boolean)) {
+        const [session, paneId, paneDead] = line.split("	");
+        if (!session) continue;
+        const dead = paneDead === "1" ? "1" : "0";
+        const panes = bySession.get(session) ?? [];
+        panes.push(dead);
+        bySession.set(session, panes);
+        if (paneId) byPaneId.set(paneId, dead);
+      }
+    } catch {
+    }
+    this.paneStatusCache = { ts: now, bySession, byPaneId };
+    return this.paneStatusCache;
+  }
+  getMySession() {
+    try {
+      return execFileSync("tmux", ["display-message", "-p", "#{session_name}"], QUIET).trim() || null;
+    } catch {
+      return null;
+    }
+  }
+  listSessions() {
+    return this.listSessionsCached();
+  }
+  isAlive(target) {
+    try {
+      const paneStatus = this.listPaneStatusCached();
+      if (target.startsWith("%")) {
+        const dead = paneStatus.byPaneId.get(target);
+        return dead !== void 0 && dead !== "1";
+      }
+      const sessions = this.listSessionsCached();
+      if (!sessions.includes(target)) return false;
+      const paneDeaths = paneStatus.bySession.get(target);
+      if (!paneDeaths || paneDeaths.length === 0) return true;
+      return paneDeaths.some((dead) => dead !== "1");
+    } catch {
+      return false;
+    }
+  }
+  sendKeys(target, keys) {
+    execFileSync("tmux", ["send-keys", "-t", target, keys], QUIET);
+    execFileSync("tmux", ["send-keys", "-t", target, "Enter"], QUIET);
+  }
+  /**
+   * Send text as literal characters, then submit with Enter as a separate call.
+   * Fixes Codex intercom bug: long text + Enter in one send-keys blast causes
+   * Codex to drop the Enter. Splitting them ensures the text renders before
+   * the submit keystroke arrives.
+   *
+   * Runtime-aware (bug 21ab6018): for `runtime === "codex"`, the text is
+   * delivered first, then a deliberate `CODEX_SUBMIT_DELAY_MS` pause lets the
+   * Codex TUI commit the pasted input buffer, and only then is the submit Enter
+   * sent as a separate `C-m` keystroke. Without the pause the Enter is coalesced
+   * with the paste and dropped, stalling the review loop. Claude/OpenCode paths
+   * are unchanged (no delay) so they don't regress.
+   */
+  sendKeysLiteral(target, text, runtime) {
+    const isCodex = runtime === "codex";
+    if (text.length >= LONG_MESSAGE_THRESHOLD) {
+      const tmpDir = path.join(os.tmpdir(), "exe-os-intercom");
+      mkdirSync(tmpDir, { recursive: true });
+      const tmpFile = path.join(tmpDir, `msg-${randomBytes(8).toString("hex")}.txt`);
+      try {
+        writeFileSync(tmpFile, text, "utf-8");
+        execFileSync("tmux", ["load-buffer", tmpFile], QUIET);
+        execFileSync("tmux", ["paste-buffer", "-p", "-t", target], QUIET);
+        if (isCodex) sleepSync(CODEX_SUBMIT_DELAY_MS);
+        execFileSync("tmux", ["send-keys", "-t", target, isCodex ? "C-m" : "Enter"], QUIET);
+      } finally {
+        try {
+          unlinkSync(tmpFile);
+        } catch {
+        }
+      }
+    } else {
+      execFileSync("tmux", ["send-keys", "-t", target, "-l", text], QUIET);
+      if (isCodex) sleepSync(CODEX_SUBMIT_DELAY_MS);
+      execFileSync("tmux", ["send-keys", "-t", target, isCodex ? "C-m" : "Enter"], QUIET);
+    }
+  }
+  capturePane(target, lines) {
+    const args = ["capture-pane", "-t", target, "-p"];
+    if (lines) args.push("-S", `-${lines}`);
+    return execFileSync("tmux", args, QUIET);
+  }
+  isPaneInCopyMode(target) {
+    try {
+      const result = execFileSync(
+        "tmux",
+        ["display-message", "-p", "-t", target, "#{pane_in_mode}"],
+        QUIET
+      ).trim();
+      return result === "1";
+    } catch {
+      return false;
+    }
+  }
+  spawn(name, config) {
+    try {
+      const args = ["new-session", "-d", "-s", name, "-x", "200", "-y", "50"];
+      if (config.cwd) args.push("-c", config.cwd);
+      execFileSync("tmux", args);
+      execFileSync("tmux", ["send-keys", "-t", name, config.command, "Enter"]);
+      this.invalidateCaches();
+      return { sessionName: name };
+    } catch (e) {
+      return { sessionName: name, error: `spawn failed: ${e}` };
+    }
+  }
+  kill(target, callerScope) {
+    const resolvedCaller = this.resolveCallerScope(callerScope);
+    if (resolvedCaller && target.includes("-")) {
+      const targetScope = target.slice(target.lastIndexOf("-") + 1);
+      const cScope = resolvedCaller.includes("-") ? resolvedCaller.slice(resolvedCaller.lastIndexOf("-") + 1) : resolvedCaller;
+      if (targetScope !== cScope) {
+        process.stderr.write(
+          `[tmux-transport] BLOCKED kill: caller scope "${resolvedCaller}" tried to kill ${target} (scope ${targetScope} \u2260 ${cScope}). Session isolation enforced.
+`
+        );
+        return;
+      }
+    }
+    try {
+      execFileSync("tmux", ["kill-session", "-t", target], QUIET);
+    } catch {
+    }
+    this.invalidateCaches();
+  }
+  /**
+   * Resolve the caller's coordinator scope for isolation enforcement.
+   * In the shared HTTP daemon, ambient tmux is meaningless — prefer the
+   * explicit/ALS/env scope. Falls back to ambient tmux for direct CLI callers.
+   */
+  resolveCallerScope(explicit) {
+    if (explicit) return explicit;
+    const isDaemon = process.env.EXE_IS_DAEMON === "1";
+    if (isDaemon) {
+      const alsHint = (() => {
+        try {
+          return getAgentContext()?.sessionHint || "";
+        } catch {
+          return "";
+        }
+      })();
+      const envHint = process.env.EXE_SESSION_NAME || process.env.EXE_SESSION || "";
+      const hint = alsHint || envHint;
+      if (hint) return hint;
+      return null;
+    }
+    return this.getMySession();
+  }
+  pipeLog(target, logFile) {
+    try {
+      const resolved = path.resolve(logFile);
+      const logsDir = path.join(os.homedir(), ".exe-os", "session-logs");
+      if (!resolved.startsWith(logsDir)) {
+        process.stderr.write(`[tmux-transport] pipeLog rejected: path escapes session-logs dir: ${logFile}
+`);
+        return;
+      }
+      const safePath = logFile.replace(/'/g, "'\\''");
+      execFileSync("tmux", ["pipe-pane", "-t", target, `cat >> '${safePath}'`], QUIET);
+    } catch {
+    }
+  }
+};
+
+export {
+  TmuxTransport
+};

package/dist/chunk-2E43UXRH.js

@@ -0,0 +1,395 @@
+import {
+  EXE_AI_DIR
+} from "./chunk-R36FAN53.js";
+
+// src/lib/db-backup.ts
+import { existsSync, readdirSync, unlinkSync, statSync, statfsSync } from "fs";
+import { copyFile, mkdir, unlink, rename } from "fs/promises";
+import path from "path";
+var BACKUP_DIR = path.join(EXE_AI_DIR, "backups");
+var DEFAULT_KEEP_DAYS = 3;
+var DB_NAMES = ["memories.db", "exe-mem.db", "exe-os.db", "exe.db"];
+var REASON_COUNT_CAP = {
+  // Bug 727b7b1e: a daemon OOM crash loop made a ~1.5GB pre-restart backup on
+  // EVERY restart. 22 crashes = 11GB of pre-restart snapshots with no rotation.
+  // Keep only the 2 newest — enough to recover, small enough not to fill disk.
+  "pre-restart": 2,
+  "pre-consolidation": 5,
+  "pre-fix": 5,
+  "pre-restore": 5,
+  // 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
+  // count cap is a belt-and-braces safety net on top of day-based rotation.
+  "daily": 3
+};
+var MIN_FREE_BYTES = 5 * 1024 * 1024 * 1024;
+var STALE_TMP_MAX_AGE_MS = 60 * 60 * 1e3;
+function findActiveDb() {
+  for (const name of DB_NAMES) {
+    const p = path.join(EXE_AI_DIR, name);
+    if (existsSync(p)) return p;
+  }
+  return null;
+}
+async function createBackup(reason = "manual") {
+  return createBackupAsync(reason);
+}
+async function createBackupAsync(reason = "manual", opts = {}) {
+  const dbPath = findActiveDb();
+  if (!dbPath) return null;
+  await mkdir(BACKUP_DIR, { recursive: true });
+  try {
+    let dbSize = 0;
+    try {
+      dbSize = statSync(dbPath).size;
+    } catch {
+    }
+    const freeBytes = getFreeBytes(BACKUP_DIR);
+    if (!hasEnoughDiskSpace(freeBytes, dbSize)) {
+      process.stderr.write(
+        `[db-backup] DISK GUARD: skipping "${reason}" backup \u2014 ${Math.round(freeBytes / 1024 / 1024)}MB free, need >${Math.round(Math.max(MIN_FREE_BYTES, dbSize * 2) / 1024 / 1024)}MB. Disk is nearly full; refusing to make it worse.
+`
+      );
+      return null;
+    }
+  } catch {
+  }
+  const dbName = path.basename(dbPath, ".db");
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+  const backupName = `${dbName}-${reason}-${timestamp}.db`;
+  const backupPath = path.join(BACKUP_DIR, backupName);
+  const tmpBackupPath = `${backupPath}.tmp`;
+  const checkpointMode = opts.checkpointMode ?? "TRUNCATE";
+  try {
+    const { getClient } = await import("./lib/database.js");
+    const client = getClient();
+    await client.execute(`PRAGMA wal_checkpoint(${checkpointMode})`);
+  } catch {
+    try {
+      const { execFile: execFileCb } = await import("child_process");
+      const { promisify } = await import("util");
+      const execFileAsync = promisify(execFileCb);
+      await execFileAsync("sqlite3", [dbPath, `PRAGMA wal_checkpoint(${checkpointMode});`], { timeout: 3e4 });
+    } catch {
+      process.stderr.write(`[db-backup] WAL checkpoint skipped \u2014 proceeding with copy (backup may include stale WAL)
+`);
+    }
+  }
+  try {
+    await unlink(tmpBackupPath);
+  } catch {
+  }
+  await copyFile(dbPath, tmpBackupPath);
+  await rename(tmpBackupPath, backupPath);
+  try {
+    const { getClient } = await import("./lib/database.js");
+    const client = getClient();
+    const chk = await client.execute("PRAGMA quick_check;");
+    const result = String(chk.rows[0]?.quick_check ?? chk.rows[0]?.[0] ?? "").trim();
+    if (result && result !== "ok") {
+      process.stderr.write(`[db-backup] WARNING: backup source failed quick_check (${reason}): ${result}
+`);
+      try {
+        await unlink(backupPath);
+      } catch {
+      }
+      return null;
+    }
+  } catch {
+    process.stderr.write(`[db-backup] Backup validation skipped (encrypted DB or CLI context) \u2014 proceeding with checkpoint-consistent copy.
+`);
+  }
+  const walPath = dbPath + "-wal";
+  if (existsSync(walPath)) {
+    try {
+      await copyFile(walPath, backupPath + "-wal.tmp");
+      await rename(backupPath + "-wal.tmp", backupPath + "-wal");
+    } catch {
+    }
+  }
+  const shmPath = dbPath + "-shm";
+  if (existsSync(shmPath)) {
+    try {
+      await copyFile(shmPath, backupPath + "-shm.tmp");
+      await rename(backupPath + "-shm.tmp", backupPath + "-shm");
+    } catch {
+    }
+  }
+  return backupPath;
+}
+function rotateBackups(keepDays = DEFAULT_KEEP_DAYS) {
+  if (!existsSync(BACKUP_DIR)) return 0;
+  const cutoff = Date.now() - keepDays * 24 * 60 * 60 * 1e3;
+  let deleted = 0;
+  try {
+    const files = readdirSync(BACKUP_DIR);
+    for (const file of files) {
+      if (file.endsWith(".tmp")) continue;
+      if (!file.endsWith(".db") && !file.endsWith(".db-wal") && !file.endsWith(".db-shm")) continue;
+      const filePath = path.join(BACKUP_DIR, file);
+      try {
+        const stat = statSync(filePath);
+        if (stat.mtimeMs < cutoff) {
+          unlinkSync(filePath);
+          deleted++;
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return deleted;
+}
+function selectBackupsToDelete(backups, keep) {
+  if (keep < 0) keep = 0;
+  const sorted = [...backups].sort((a, b) => b.mtimeMs - a.mtimeMs);
+  return sorted.slice(keep).map((b) => b.path);
+}
+function selectStaleTmpFiles(tmpFiles, cutoffMs) {
+  return tmpFiles.filter((f) => f.mtimeMs < cutoffMs).map((f) => f.path);
+}
+function cleanupStaleTmp(maxAgeMs = STALE_TMP_MAX_AGE_MS) {
+  if (!existsSync(BACKUP_DIR)) return 0;
+  const cutoffMs = Date.now() - maxAgeMs;
+  let deleted = 0;
+  try {
+    const candidates = [];
+    for (const file of readdirSync(BACKUP_DIR)) {
+      if (!file.endsWith(".tmp")) continue;
+      const filePath = path.join(BACKUP_DIR, file);
+      try {
+        candidates.push({ path: filePath, mtimeMs: statSync(filePath).mtimeMs });
+      } catch {
+      }
+    }
+    for (const target of selectStaleTmpFiles(candidates, cutoffMs)) {
+      try {
+        unlinkSync(target);
+        deleted++;
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return deleted;
+}
+function hasEnoughDiskSpace(freeBytes, backupSizeBytes, minFreeBytes = MIN_FREE_BYTES) {
+  const required = Math.max(minFreeBytes, backupSizeBytes * 2);
+  return freeBytes >= required;
+}
+function getFreeBytes(dir) {
+  try {
+    const s = statfsSync(dir);
+    return s.bavail * s.bsize;
+  } catch {
+    return Number.POSITIVE_INFINITY;
+  }
+}
+async function quickCheckBackupSource(source) {
+  try {
+    const { execFile: execFileCb } = await import("child_process");
+    const { promisify } = await import("util");
+    const execFileAsync = promisify(execFileCb);
+    const { stdout } = await execFileAsync("sqlite3", [source, "PRAGMA quick_check;"], { timeout: 3e4 });
+    const result = String(stdout ?? "").trim();
+    if (result !== "ok") {
+      throw new Error(result || "quick_check returned no result");
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (/file is not a database|not an error/i.test(msg)) {
+      process.stderr.write(`[db-backup] Backup source quick_check unavailable for encrypted backup (${path.basename(source)}); proceeding with atomic restore.
+`);
+      return;
+    }
+    throw new Error(`Backup source failed quick_check: ${msg}`);
+  }
+}
+function rotateBackupsByReason(reason, keep) {
+  if (!existsSync(BACKUP_DIR)) return 0;
+  let deleted = 0;
+  try {
+    const files = readdirSync(BACKUP_DIR);
+    const matches = [];
+    for (const file of files) {
+      if (file.endsWith(".tmp")) continue;
+      if (!file.endsWith(".db")) continue;
+      if (!file.includes(`-${reason}-`)) continue;
+      const filePath = path.join(BACKUP_DIR, file);
+      try {
+        matches.push({ path: filePath, mtimeMs: statSync(filePath).mtimeMs });
+      } catch {
+      }
+    }
+    for (const target of selectBackupsToDelete(matches, keep)) {
+      for (const p of [target, target + "-wal", target + "-shm"]) {
+        try {
+          if (existsSync(p)) {
+            unlinkSync(p);
+            if (p === target) deleted++;
+          }
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  return deleted;
+}
+function enforceRetention(reason, keepDays = DEFAULT_KEEP_DAYS) {
+  let deleted = rotateBackups(keepDays);
+  const cap = REASON_COUNT_CAP[reason];
+  if (typeof cap === "number") {
+    deleted += rotateBackupsByReason(reason, cap);
+  }
+  deleted += cleanupStaleTmp();
+  return deleted;
+}
+var QUARANTINE_KEEP = 2;
+function pruneCorruptQuarantine(keep = QUARANTINE_KEEP) {
+  if (!existsSync(EXE_AI_DIR)) return 0;
+  let deleted = 0;
+  try {
+    const matches = [];
+    for (const file of readdirSync(EXE_AI_DIR)) {
+      if (!/\.corrupt-\d+$/.test(file)) continue;
+      const filePath = path.join(EXE_AI_DIR, file);
+      try {
+        matches.push({ path: filePath, mtimeMs: statSync(filePath).mtimeMs });
+      } catch {
+      }
+    }
+    for (const target of selectBackupsToDelete(matches, keep)) {
+      for (const p of [target, target + "-wal", target + "-shm"]) {
+        try {
+          if (existsSync(p)) {
+            unlinkSync(p);
+            if (p === target) deleted++;
+          }
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  return deleted;
+}
+function cleanupCrashDebris() {
+  let deleted = 0;
+  deleted += rotateBackupsByReason("pre-restart", REASON_COUNT_CAP["pre-restart"] ?? 2);
+  deleted += cleanupStaleTmp();
+  deleted += pruneCorruptQuarantine();
+  return deleted;
+}
+function listBackups() {
+  if (!existsSync(BACKUP_DIR)) return [];
+  try {
+    const files = readdirSync(BACKUP_DIR).filter((f) => f.endsWith(".db") && !f.endsWith(".tmp") && !f.endsWith("-wal") && !f.endsWith("-shm"));
+    return files.map((name) => {
+      const p = path.join(BACKUP_DIR, name);
+      const stat = statSync(p);
+      return { path: p, name, size: stat.size, date: stat.mtime };
+    }).sort((a, b) => b.date.getTime() - a.date.getTime());
+  } catch {
+    return [];
+  }
+}
+function hasBackupToday(reason) {
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const backups = listBackups();
+  return backups.some((b) => b.name.includes(reason) && b.name.includes(today.replace(/-/g, "-")));
+}
+function hasRecentBackup(reason, withinMs) {
+  try {
+    if (!existsSync(BACKUP_DIR)) return false;
+    const now = Date.now();
+    for (const file of readdirSync(BACKUP_DIR)) {
+      if (file.endsWith(".tmp")) continue;
+      if (!file.endsWith(".db")) continue;
+      if (!file.includes(`-${reason}-`)) continue;
+      try {
+        if (now - statSync(path.join(BACKUP_DIR, file)).mtimeMs <= withinMs) return true;
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return false;
+}
+function getLatestBackup() {
+  const backups = listBackups();
+  return backups.length > 0 ? backups[0].path : null;
+}
+async function restoreBackup(backupPath) {
+  const dbPath = findActiveDb();
+  if (!dbPath) {
+    const target = path.join(EXE_AI_DIR, DB_NAMES[0]);
+    const source2 = backupPath ?? getLatestBackup();
+    if (!source2 || !existsSync(source2)) return null;
+    await copyFile(source2, target);
+    return { restored: path.basename(source2), preRestoreBackup: null };
+  }
+  const source = backupPath ?? getLatestBackup();
+  if (!source || !existsSync(source)) return null;
+  if (path.resolve(source) === path.resolve(dbPath)) return null;
+  await quickCheckBackupSource(source);
+  const preRestoreBackup = await createBackup("pre-restore");
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const tmpDb = `${dbPath}.restore-${stamp}.tmp`;
+  const oldDb = `${dbPath}.pre-restore-active-${stamp}`;
+  await copyFile(source, tmpDb);
+  const walPath = source + "-wal";
+  const shmPath = source + "-shm";
+  const tmpWal = `${tmpDb}-wal`;
+  const tmpShm = `${tmpDb}-shm`;
+  if (existsSync(walPath)) {
+    try {
+      await copyFile(walPath, tmpWal);
+    } catch {
+    }
+  }
+  if (existsSync(shmPath)) {
+    try {
+      await copyFile(shmPath, tmpShm);
+    } catch {
+    }
+  }
+  try {
+    unlinkSync(dbPath + "-wal");
+  } catch {
+  }
+  try {
+    unlinkSync(dbPath + "-shm");
+  } catch {
+  }
+  await rename(dbPath, oldDb);
+  await rename(tmpDb, dbPath);
+  if (existsSync(tmpWal)) await rename(tmpWal, dbPath + "-wal");
+  if (existsSync(tmpShm)) await rename(tmpShm, dbPath + "-shm");
+  return { restored: path.basename(source), preRestoreBackup };
+}
+function getBackupDir() {
+  return BACKUP_DIR;
+}
+
+export {
+  findActiveDb,
+  createBackup,
+  createBackupAsync,
+  rotateBackups,
+  selectBackupsToDelete,
+  selectStaleTmpFiles,
+  cleanupStaleTmp,
+  hasEnoughDiskSpace,
+  rotateBackupsByReason,
+  enforceRetention,
+  pruneCorruptQuarantine,
+  cleanupCrashDebris,
+  listBackups,
+  hasBackupToday,
+  hasRecentBackup,
+  getLatestBackup,
+  restoreBackup,
+  getBackupDir
+};