@askexenow/exe-os 0.9.238 → 0.9.243

package/dist/chunk-5DMAMQNU.js

@@ -0,0 +1,168 @@
+// src/bin/vps-backup.ts
+import { spawnSync } from "child_process";
+import { existsSync, mkdirSync, readdirSync, statSync, unlinkSync } from "fs";
+import path from "path";
+var BACKUP_DIR = "/opt/exe-stack/backups";
+var DEFAULT_DATABASE_URL = "postgres://exe@localhost:5432/exedb";
+var MAX_SNAPSHOTS = 28;
+var KEEP_DAYS = 7;
+function runPgBackup(tag) {
+  mkdirSync(BACKUP_DIR, { recursive: true });
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const filename = tag ? `pg-${tag}-${timestamp}.dump` : `pg-${timestamp}.dump`;
+  const filepath = path.join(BACKUP_DIR, filename);
+  const databaseUrl = process.env.DATABASE_URL || DEFAULT_DATABASE_URL;
+  const result = spawnSync("pg_dump", ["-Fc", "-d", databaseUrl, "-f", filepath], {
+    stdio: ["pipe", "pipe", "pipe"],
+    timeout: 3e5,
+    // 5 minutes max
+    env: { ...process.env }
+  });
+  if (result.status !== 0) {
+    const stderr = result.stderr?.toString() || "";
+    throw new Error(`pg_dump failed (exit ${result.status}): ${stderr}`);
+  }
+  const size = existsSync(filepath) ? statSync(filepath).size : 0;
+  console.log(`[vps-backup] \u2713 Backup created: ${filepath} (${formatBytes(size)})`);
+  return filepath;
+}
+function cleanOldBackups(keepDays = KEEP_DAYS) {
+  if (!existsSync(BACKUP_DIR)) return 0;
+  const files = readdirSync(BACKUP_DIR).filter((f) => f.startsWith("pg-") && f.endsWith(".dump")).map((f) => ({
+    name: f,
+    path: path.join(BACKUP_DIR, f),
+    mtime: statSync(path.join(BACKUP_DIR, f)).mtimeMs
+  })).sort((a, b) => b.mtime - a.mtime);
+  const cutoff = Date.now() - keepDays * 24 * 60 * 60 * 1e3;
+  let removed = 0;
+  for (let i = 0; i < files.length; i++) {
+    const file = files[i];
+    if (file.mtime >= cutoff && i < MAX_SNAPSHOTS) continue;
+    if (file.name.includes("pre-deploy-") && file.mtime >= cutoff) continue;
+    try {
+      unlinkSync(file.path);
+      removed++;
+      console.log(`[vps-backup] Removed old backup: ${file.name}`);
+    } catch (err) {
+      console.warn(`[vps-backup] Failed to remove ${file.name}: ${err instanceof Error ? err.message : err}`);
+    }
+  }
+  if (removed > 0) {
+    console.log(`[vps-backup] \u2713 Cleaned ${removed} old backup(s)`);
+  } else {
+    console.log("[vps-backup] \u2713 No old backups to clean");
+  }
+  return removed;
+}
+function preDeployBackup(version) {
+  const sanitized = version.replace(/[^a-zA-Z0-9._-]/g, "_");
+  console.log(`[vps-backup] Creating pre-deploy backup for version ${version}...`);
+  return runPgBackup(`pre-deploy-${sanitized}`);
+}
+function setupCron() {
+  const which = spawnSync("which", ["exe-os"], { encoding: "utf8", timeout: 5e3 });
+  const exeOsBin = which.stdout?.trim() || "/usr/local/bin/exe-os";
+  const cronLine = `0 */6 * * * ${exeOsBin} vps-backup --clean 2>&1 | tail -5 >> /var/log/exe-backup.log`;
+  const cronComment = "# exe-os automated postgres backup (every 6 hours)";
+  const current = spawnSync("crontab", ["-l"], {
+    encoding: "utf8",
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  const existingCron = current.status === 0 ? current.stdout : "";
+  if (existingCron.includes("exe-os vps-backup") || existingCron.includes("exe-os vps-backup")) {
+    console.log("[vps-backup] \u2713 Cron job already installed");
+    return;
+  }
+  const newCron = existingCron.trimEnd() + "\n\n" + cronComment + "\n" + cronLine + "\n";
+  const install = spawnSync("crontab", ["-"], {
+    input: newCron,
+    encoding: "utf8",
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  if (install.status !== 0) {
+    throw new Error(`Failed to install cron: ${install.stderr}`);
+  }
+  console.log("[vps-backup] \u2713 Cron job installed (every 6 hours)");
+  console.log(`[vps-backup]   ${cronLine}`);
+}
+function listBackups() {
+  if (!existsSync(BACKUP_DIR)) {
+    console.log("[vps-backup] No backups directory found");
+    return;
+  }
+  const files = readdirSync(BACKUP_DIR).filter((f) => f.startsWith("pg-") && f.endsWith(".dump")).map((f) => {
+    const stat = statSync(path.join(BACKUP_DIR, f));
+    return { name: f, size: stat.size, mtime: stat.mtimeMs };
+  }).sort((a, b) => b.mtime - a.mtime);
+  if (files.length === 0) {
+    console.log("[vps-backup] No backups found");
+    return;
+  }
+  console.log(`
+  Backups in ${BACKUP_DIR} (${files.length} total):
+`);
+  for (const f of files) {
+    const age = formatAge(Date.now() - f.mtime);
+    console.log(`  ${f.name}  ${formatBytes(f.size).padStart(10)}  ${age} ago`);
+  }
+  console.log("");
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+}
+function formatAge(ms) {
+  const hours = Math.floor(ms / (1e3 * 60 * 60));
+  if (hours < 1) return `${Math.floor(ms / (1e3 * 60))}m`;
+  if (hours < 48) return `${hours}h`;
+  return `${Math.floor(hours / 24)}d`;
+}
+async function main(args) {
+  if (args.includes("--help") || args.includes("-h")) {
+    console.log(`
+  exe-os vps-backup \u2014 Postgres backup manager
+
+  Usage:
+    exe-os vps-backup              Run backup now
+    exe-os vps-backup --setup      Install cron job (every 6 hours)
+    exe-os vps-backup --clean      Run backup + clean old backups
+    exe-os vps-backup --list       List current backups
+    exe-os vps-backup --pre-deploy <version>  Pre-deploy snapshot
+`);
+    return;
+  }
+  if (args.includes("--setup")) {
+    setupCron();
+    return;
+  }
+  if (args.includes("--list")) {
+    listBackups();
+    return;
+  }
+  const preDeployIdx = args.indexOf("--pre-deploy");
+  if (preDeployIdx !== -1) {
+    const version = args[preDeployIdx + 1];
+    if (!version) {
+      console.error("[vps-backup] --pre-deploy requires a version argument");
+      process.exitCode = 1;
+      return;
+    }
+    preDeployBackup(version);
+    return;
+  }
+  runPgBackup();
+  if (args.includes("--clean")) {
+    cleanOldBackups();
+  }
+}
+
+export {
+  runPgBackup,
+  cleanOldBackups,
+  preDeployBackup,
+  setupCron,
+  listBackups,
+  main
+};

package/dist/{chunk-MPG2FFQS.js → chunk-5JIG2FP2.js}

@@ -1,6 +1,6 @@
 import {
   isCoordinatorRole
-} from "./chunk-2LYJTK47.js";
+} from "./chunk-CEJO7244.js";
 
 // src/lib/task-router.ts
 import { randomUUID } from "crypto";

package/dist/{chunk-UWQ3XCDG.js → chunk-5WK7X5CF.js}

@@ -1,10 +1,10 @@
 import {
   readMcpHttpEvents,
   summarizeMcpTransport
-} from "./chunk-UODVZGBQ.js";
+} from "./chunk-KN7LPTIB.js";
 import {
   EXE_AI_DIR
-} from "./chunk-TRZ5KA2R.js";
+} from "./chunk-VXIMSRTO.js";
 import {
   isMainModule
 } from "./chunk-6Y4B3QF6.js";

package/dist/{chunk-NS7FW3NG.js → chunk-6JAGJN77.js}

@@ -1,9 +1,9 @@
 import {
   sendMessage
-} from "./chunk-T3ASODFG.js";
+} from "./chunk-DGBGIXCC.js";
 import {
   getActiveAgent
-} from "./chunk-IQNT6KAE.js";
+} from "./chunk-MCESA5UW.js";
 
 // src/mcp/tools/send-message.ts
 import { z } from "zod";

package/dist/{chunk-NCJNGQUZ.js → chunk-73UE2PHT.js}

@@ -1,6 +1,6 @@
 import {
   getClient
-} from "./chunk-2LYJTK47.js";
+} from "./chunk-CEJO7244.js";
 
 // src/lib/token-spend.ts
 import { readdir, stat } from "fs/promises";

package/dist/{chunk-JL3K5OTS.js → chunk-7IZWLMTP.js}

@@ -1,6 +1,6 @@
 import {
   EXE_AI_DIR
-} from "./chunk-TRZ5KA2R.js";
+} from "./chunk-VXIMSRTO.js";
 import {
   enforcePrivateFileSync,
   ensurePrivateDirSync

package/dist/{chunk-FQJWTRCB.js → chunk-A4K2ZT6N.js}

@@ -1,6 +1,6 @@
 import {
   getClient
-} from "./chunk-2LYJTK47.js";
+} from "./chunk-CEJO7244.js";
 
 // src/lib/pipeline-router.ts
 import crypto from "crypto";
@@ -116,12 +116,12 @@ async function sinkCRM(msg, agentResponse, agentName) {
 }
 async function sinkWiki(msg, agentResponse) {
   try {
-    const { createWikiClient } = await import("./wiki-client-MAFYBXCQ.js");
+    const { createWikiClient } = await import("./wiki-client-GBPR45BQ.js");
     const client = await createWikiClient();
     if (!client) return false;
     const content = msg.text ?? "";
     if (content.length < 50) return false;
-    const { chatInWorkspace } = await import("./wiki-client-MAFYBXCQ.js");
+    const { chatInWorkspace } = await import("./wiki-client-GBPR45BQ.js");
     const ingestText = [
       `[${msg.platform}] Message from ${msg.senderName ?? msg.senderId} (${msg.timestamp}):`,
       content,
@@ -149,7 +149,7 @@ async function sinkEntityExtraction(msg, agentResponse, agentName) {
     const client = getClient();
     const memoryId = `conv:${msg.messageId}`;
     await storeExtraction(client, extraction, memoryId, msg.timestamp);
-    import("./conversation-wiki-populator-YU35LNRK.js").then(
+    import("./conversation-wiki-populator-L7O6F3BB.js").then(
       ({ populateWikiFromExtraction }) => populateWikiFromExtraction(extraction, msg, agentResponse, agentName)
     ).catch((err) => {
       process.stderr.write(

package/dist/{chunk-EAIZLNLP.js → chunk-AHXEU5XB.js}

@@ -1,6 +1,6 @@
 import {
   MODELS_DIR
-} from "./chunk-TRZ5KA2R.js";
+} from "./chunk-VXIMSRTO.js";
 
 // src/lib/reranker.ts
 import path from "path";

package/dist/{chunk-NNEYTOUS.js → chunk-AWRL5FGM.js}

@@ -1,11 +1,10 @@
 import {
   EXE_AI_DIR
-} from "./chunk-TRZ5KA2R.js";
+} from "./chunk-VXIMSRTO.js";
 
 // src/lib/db-backup.ts
-import { copyFileSync, existsSync, mkdirSync, readdirSync, unlinkSync, statSync } from "fs";
+import { existsSync, readdirSync, unlinkSync, statSync } from "fs";
 import { copyFile, mkdir, unlink } from "fs/promises";
-import { execFileSync } from "child_process";
 import path from "path";
 var BACKUP_DIR = path.join(EXE_AI_DIR, "backups");
 var DEFAULT_KEEP_DAYS = 3;
@@ -17,60 +16,8 @@ function findActiveDb() {
   }
   return null;
 }
-function createBackup(reason = "manual") {
-  const dbPath = findActiveDb();
-  if (!dbPath) return null;
-  mkdirSync(BACKUP_DIR, { recursive: true });
-  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);
-  try {
-    execFileSync("sqlite3", [dbPath, "PRAGMA wal_checkpoint(TRUNCATE);"], {
-      timeout: 3e4,
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-  } catch {
-    process.stderr.write(`[db-backup] WAL checkpoint skipped (sqlite3 CLI unavailable or encrypted DB)
-`);
-  }
-  copyFileSync(dbPath, backupPath);
-  try {
-    const result = execFileSync("sqlite3", [backupPath, "PRAGMA quick_check;"], {
-      encoding: "utf8",
-      timeout: 1e4,
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    if (result !== "ok") {
-      process.stderr.write(`[db-backup] WARNING: backup failed quick_check (${reason}): ${result}
-`);
-      try {
-        unlinkSync(backupPath);
-      } catch {
-      }
-      return null;
-    }
-  } catch (err) {
-    process.stderr.write(
-      `[db-backup] Backup validation skipped: ${err instanceof Error ? err.message : String(err)}
-`
-    );
-  }
-  const walPath = dbPath + "-wal";
-  if (existsSync(walPath)) {
-    try {
-      copyFileSync(walPath, backupPath + "-wal");
-    } catch {
-    }
-  }
-  const shmPath = dbPath + "-shm";
-  if (existsSync(shmPath)) {
-    try {
-      copyFileSync(shmPath, backupPath + "-shm");
-    } catch {
-    }
-  }
-  return backupPath;
+async function createBackup(reason = "manual") {
+  return createBackupAsync(reason);
 }
 async function createBackupAsync(reason = "manual") {
   const dbPath = findActiveDb();
@@ -97,16 +44,12 @@ async function createBackupAsync(reason = "manual") {
   }
   await copyFile(dbPath, backupPath);
   try {
-    const { execFile } = await import("child_process");
-    const { promisify } = await import("util");
-    const execFileAsync = promisify(execFile);
-    const { stdout } = await execFileAsync("sqlite3", [backupPath, "PRAGMA quick_check;"], {
-      encoding: "utf8",
-      timeout: 1e4
-    });
-    const result = String(stdout ?? "").trim();
-    if (result !== "ok") {
-      process.stderr.write(`[db-backup] WARNING: backup failed quick_check (${reason}): ${result}
+    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);
@@ -114,11 +57,9 @@ async function createBackupAsync(reason = "manual") {
       }
       return null;
     }
-  } catch (err) {
-    process.stderr.write(
-      `[db-backup] Backup validation skipped: ${err instanceof Error ? err.message : String(err)}
-`
-    );
+  } 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)) {
@@ -180,25 +121,25 @@ function getLatestBackup() {
   const backups = listBackups();
   return backups.length > 0 ? backups[0].path : null;
 }
-function restoreBackup(backupPath) {
+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;
-    copyFileSync(source2, target);
+    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;
-  const preRestoreBackup = createBackup("pre-restore");
-  copyFileSync(source, dbPath);
+  const preRestoreBackup = await createBackup("pre-restore");
+  await copyFile(source, dbPath);
   const walPath = source + "-wal";
   const shmPath = source + "-shm";
   if (existsSync(walPath)) {
     try {
-      copyFileSync(walPath, dbPath + "-wal");
+      await copyFile(walPath, dbPath + "-wal");
     } catch {
     }
   } else {
@@ -209,7 +150,7 @@ function restoreBackup(backupPath) {
   }
   if (existsSync(shmPath)) {
     try {
-      copyFileSync(shmPath, dbPath + "-shm");
+      await copyFile(shmPath, dbPath + "-shm");
     } catch {
     }
   } else {

package/dist/{chunk-JBMZS5WO.js → chunk-BSPOEYAO.js}

@@ -1,6 +1,6 @@
 import {
   completeReminder
-} from "./chunk-YENDNLAD.js";
+} from "./chunk-YMZHTTOQ.js";
 
 // src/mcp/tools/complete-reminder.ts
 import { z } from "zod";

package/dist/{chunk-M5TK7JET.js → chunk-CBDPEJOR.js}

@@ -1,13 +1,13 @@
 import {
   getMasterKey,
   setMasterKey
-} from "./chunk-KDJRFJDL.js";
+} from "./chunk-K333WOW4.js";
 import {
   LEGACY_LANCE_PATH,
   MODELS_DIR,
   loadConfig,
   saveConfig
-} from "./chunk-TRZ5KA2R.js";
+} from "./chunk-VXIMSRTO.js";
 import {
   atomicWriteJsonSync,
   atomicWriteSync
@@ -380,7 +380,7 @@ async function runSetupWizard(opts = {}) {
             "Setup cancelled: recovery phrase was not confirmed. Save the 24-word phrase before continuing \u2014 it is required to recover encrypted memories."
           );
         }
-        const { markKeyBackupConfirmed } = await import("./key-backup-status-OZ2CXUDW.js");
+        const { markKeyBackupConfirmed } = await import("./key-backup-status-4YKCV4ZV.js");
         markKeyBackupConfirmed("setup-wizard");
       }
       state.completedSteps.push(1);
@@ -534,7 +534,7 @@ async function runSetupWizard(opts = {}) {
       if (cloudConfig) {
         config.cloud = cloudConfig;
       }
-      const { applyDefaultOrchestrationPhase } = await import("./orchestration-phase-SGA7PJ5G.js");
+      const { applyDefaultOrchestrationPhase } = await import("./orchestration-phase-C26XVKLZ.js");
       applyDefaultOrchestrationPhase(config);
       await saveConfig(config);
       log("");
@@ -863,7 +863,7 @@ async function runSetupWizard(opts = {}) {
       log("  Phase 3: Parallel org \u2014 specialists execute in parallel with reviews");
       log("");
       const unlockExecutives = (await askOrEnv("Unlock Phase 2 executives now? (y/N): ", void 0, "n")).toLowerCase() === "y";
-      const { setOrchestrationPhase } = await import("./orchestration-phase-SGA7PJ5G.js");
+      const { setOrchestrationPhase } = await import("./orchestration-phase-C26XVKLZ.js");
       if (!unlockExecutives) {
         await setOrchestrationPhase("phase_1_coo", "setup-wizard");
         log("");

package/dist/{chunk-2LYJTK47.js → chunk-CEJO7244.js}

@@ -1,13 +1,13 @@
 import {
   listBackups
-} from "./chunk-NNEYTOUS.js";
+} from "./chunk-AWRL5FGM.js";
 import {
   EMBEDDING_DIM
 } from "./chunk-FXU7JOXK.js";
 import {
   EXE_AI_DIR,
   loadConfigSync
-} from "./chunk-TRZ5KA2R.js";
+} from "./chunk-VXIMSRTO.js";
 import {
   atomicWriteJson
 } from "./chunk-LYH5HE24.js";

package/dist/{chunk-JLHSEBNQ.js → chunk-CPXGLSIL.js}

@@ -1,6 +1,6 @@
 import {
   routeTask
-} from "./chunk-MPG2FFQS.js";
+} from "./chunk-5JIG2FP2.js";
 import {
   createTaskCore,
   employeeSessionName,
@@ -9,11 +9,11 @@ import {
   isEmployeeAlive,
   sessionScopeFilter,
   updateTaskStatus
-} from "./chunk-ENWFSMOS.js";
+} from "./chunk-F7JLZXHC.js";
 import {
   DEFAULT_COORDINATOR_TEMPLATE_NAME,
   getCoordinatorName
-} from "./chunk-2LYJTK47.js";
+} from "./chunk-CEJO7244.js";
 
 // src/runtime/orchestrator.ts
 var STALE_THRESHOLD_MS = 2 * 60 * 60 * 1e3;

package/dist/{chunk-WQXJIMBO.js → chunk-CWITU7DW.js}

@@ -1,13 +1,13 @@
 import {
   vectorToBlob
-} from "./chunk-NQU2RTCP.js";
+} from "./chunk-222SI7QC.js";
 import {
   extractKeywords,
   keywordsToString
 } from "./chunk-CHCA3ZM2.js";
 import {
   isCoordinatorName
-} from "./chunk-2LYJTK47.js";
+} from "./chunk-CEJO7244.js";
 
 // src/lib/consolidation.ts
 import { randomUUID } from "crypto";

package/dist/{chunk-T3ASODFG.js → chunk-DGBGIXCC.js}

@@ -4,17 +4,17 @@ import {
   resolveExeSession,
   sendIntercom,
   strictSessionScopeFilter
-} from "./chunk-ENWFSMOS.js";
+} from "./chunk-F7JLZXHC.js";
 import {
   parseMessage,
   serializeMessage
 } from "./chunk-4JERP7NT.js";
 import {
   recordOrchestrationEventBestEffort
-} from "./chunk-2O5GJFYQ.js";
+} from "./chunk-HCBMPZDT.js";
 import {
   getClient
-} from "./chunk-2LYJTK47.js";
+} from "./chunk-CEJO7244.js";
 
 // src/lib/messaging.ts
 import crypto from "crypto";
@@ -153,7 +153,7 @@ async function deliverLocalMessage(messageId) {
     if (!isCOO && !isEmployeeAlive(sessionName)) {
       throw new Error("Session not running \u2014 message stays queued");
     }
-    const intercomResult = sendIntercom(sessionName, { force: true });
+    const intercomResult = sendIntercom(sessionName, { force: true, reason: "message" });
     process.stderr.write(`[messaging] intercom result for ${sessionName}: ${intercomResult}
 `);
     await client.execute({