@askexenow/exe-os 0.9.166 → 0.9.167

package/dist/bin/vps-backup.js

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+import "../chunk-MLKGABMK.js";
+
+// 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 {
+  cleanOldBackups,
+  listBackups,
+  main,
+  preDeployBackup,
+  runPgBackup,
+  setupCron
+};

package/dist/bin/vps-health-gate.js

@@ -0,0 +1,232 @@
+#!/usr/bin/env node
+import "../chunk-MLKGABMK.js";
+
+// src/bin/vps-health-gate.ts
+import { spawnSync } from "child_process";
+import { appendFileSync, existsSync, mkdirSync, readdirSync } from "fs";
+import http from "http";
+import path from "path";
+var DEPLOY_LOG = "/opt/exe-stack/deploy-log.jsonl";
+var BACKUP_DIR = "/opt/exe-stack/backups";
+async function checkCRM() {
+  const start = Date.now();
+  try {
+    const status = await httpGet("http://localhost:3000/api");
+    return {
+      check: "crm",
+      status: status >= 200 && status < 400 ? "pass" : "fail",
+      message: status >= 200 && status < 400 ? `CRM healthy (HTTP ${status})` : `CRM unhealthy (HTTP ${status})`,
+      durationMs: Date.now() - start
+    };
+  } catch (err) {
+    return {
+      check: "crm",
+      status: "fail",
+      message: `CRM unreachable: ${err instanceof Error ? err.message : err}`,
+      durationMs: Date.now() - start
+    };
+  }
+}
+async function checkGateway() {
+  const start = Date.now();
+  try {
+    const status = await httpGet("http://localhost:3100/health");
+    return {
+      check: "gateway",
+      status: status >= 200 && status < 300 ? "pass" : "fail",
+      message: status >= 200 && status < 300 ? `Gateway healthy (HTTP ${status})` : `Gateway unhealthy (HTTP ${status})`,
+      durationMs: Date.now() - start
+    };
+  } catch (err) {
+    return {
+      check: "gateway",
+      status: "fail",
+      message: `Gateway unreachable: ${err instanceof Error ? err.message : err}`,
+      durationMs: Date.now() - start
+    };
+  }
+}
+function checkPostgres() {
+  const start = Date.now();
+  const databaseUrl = process.env.DATABASE_URL || "postgres://exe@localhost:5432/exedb";
+  const result = spawnSync("psql", [databaseUrl, "-c", "SELECT 1"], {
+    encoding: "utf8",
+    stdio: ["pipe", "pipe", "pipe"],
+    timeout: 1e4
+  });
+  return {
+    check: "postgres",
+    status: result.status === 0 ? "pass" : "fail",
+    message: result.status === 0 ? "Postgres responding" : `Postgres failed: ${result.stderr?.trim() || `exit ${result.status}`}`,
+    durationMs: Date.now() - start
+  };
+}
+function checkRawEvents() {
+  const start = Date.now();
+  const databaseUrl = process.env.DATABASE_URL || "postgres://exe@localhost:5432/exedb";
+  const result = spawnSync(
+    "psql",
+    [databaseUrl, "-t", "-c", "SELECT count(*) FROM raw.raw_events"],
+    {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 1e4
+    }
+  );
+  if (result.status !== 0) {
+    return {
+      check: "raw_events",
+      status: "fail",
+      message: `raw.raw_events query failed: ${result.stderr?.trim() || `exit ${result.status}`}`,
+      durationMs: Date.now() - start
+    };
+  }
+  const count = parseInt(result.stdout?.trim() || "0", 10);
+  return {
+    check: "raw_events",
+    status: count > 0 ? "pass" : "fail",
+    message: count > 0 ? `raw.raw_events has ${count} rows` : "raw.raw_events is empty",
+    durationMs: Date.now() - start
+  };
+}
+async function checkGoTrue() {
+  const start = Date.now();
+  try {
+    const status = await httpGet("http://localhost:9999/health");
+    return {
+      check: "gotrue",
+      status: status >= 200 && status < 300 ? "pass" : "fail",
+      message: status >= 200 && status < 300 ? `GoTrue healthy (HTTP ${status})` : `GoTrue unhealthy (HTTP ${status})`,
+      durationMs: Date.now() - start
+    };
+  } catch (err) {
+    return {
+      check: "gotrue",
+      status: "fail",
+      message: `GoTrue unreachable: ${err instanceof Error ? err.message : err}`,
+      durationMs: Date.now() - start
+    };
+  }
+}
+async function runHealthGate() {
+  console.log("[health-gate] Running post-deploy health checks...\n");
+  const results = [];
+  results.push(checkPostgres());
+  results.push(checkRawEvents());
+  results.push(await checkCRM());
+  results.push(await checkGateway());
+  results.push(await checkGoTrue());
+  const passed = results.every((r) => r.status === "pass");
+  for (const r of results) {
+    const icon = r.status === "pass" ? "\u2713" : "\u2717";
+    const color = r.status === "pass" ? "\x1B[32m" : "\x1B[31m";
+    console.log(`  ${color}${icon}\x1B[0m ${r.check.padEnd(12)} ${r.message} (${r.durationMs}ms)`);
+  }
+  console.log("");
+  const result = {
+    passed,
+    results,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  return result;
+}
+function logResult(result) {
+  mkdirSync(path.dirname(DEPLOY_LOG), { recursive: true });
+  const line = JSON.stringify({
+    ...result,
+    type: "health_gate"
+  }) + "\n";
+  try {
+    appendFileSync(DEPLOY_LOG, line);
+    console.log(`[health-gate] Result logged to ${DEPLOY_LOG}`);
+  } catch (err) {
+    console.warn(`[health-gate] Failed to write deploy log: ${err instanceof Error ? err.message : err}`);
+  }
+}
+function restorePreDeployBackup() {
+  if (!existsSync(BACKUP_DIR)) return false;
+  const backups = readdirSync(BACKUP_DIR).filter((f) => f.startsWith("pg-pre-deploy-") && f.endsWith(".dump")).sort().reverse();
+  if (backups.length === 0) {
+    console.warn("[health-gate] No pre-deploy backup found to restore");
+    return false;
+  }
+  const latest = backups[0];
+  const filepath = path.join(BACKUP_DIR, latest);
+  const databaseUrl = process.env.DATABASE_URL || "postgres://exe@localhost:5432/exedb";
+  console.log(`[health-gate] Restoring pre-deploy backup: ${latest}`);
+  const result = spawnSync("pg_restore", ["-d", databaseUrl, "--clean", "--if-exists", filepath], {
+    encoding: "utf8",
+    stdio: ["pipe", "pipe", "pipe"],
+    timeout: 3e5
+  });
+  if (result.status !== 0) {
+    console.error(`[health-gate] pg_restore failed: ${result.stderr?.trim() || `exit ${result.status}`}`);
+    return false;
+  }
+  console.log("[health-gate] \u2713 Pre-deploy backup restored");
+  return true;
+}
+function httpGet(url) {
+  return new Promise((resolve, reject) => {
+    const req = http.request(url, { method: "GET", timeout: 1e4 }, (res) => {
+      res.resume();
+      resolve(res.statusCode ?? 0);
+    });
+    req.on("timeout", () => req.destroy(new Error("timeout")));
+    req.on("error", reject);
+    req.end();
+  });
+}
+async function main(args) {
+  if (args.includes("--help") || args.includes("-h")) {
+    console.log(`
+  exe-os vps-health-gate \u2014 Post-deploy health checks
+
+  Runs 5 checks: Postgres, raw_events, CRM, Gateway, GoTrue.
+  If any check fails, triggers rollback and exits with code 1.
+
+  Usage:
+    exe-os vps-health-gate              Run health gate
+    exe-os vps-health-gate --check-only Run checks without rollback on failure
+`);
+    return;
+  }
+  const checkOnly = args.includes("--check-only");
+  const result = await runHealthGate();
+  logResult(result);
+  if (result.passed) {
+    console.log("[health-gate] \u2713 All checks passed \u2014 deploy is healthy");
+    return;
+  }
+  const failed = result.results.filter((r) => r.status === "fail");
+  console.error(`[health-gate] \u2717 ${failed.length} check(s) failed`);
+  if (checkOnly) {
+    process.exitCode = 1;
+    return;
+  }
+  console.log("[health-gate] Starting rollback...");
+  restorePreDeployBackup();
+  try {
+    const { rollbackStackUpdate, defaultStackPaths } = await import("../stack-update-2B2UXREV.js");
+    const paths = defaultStackPaths();
+    await rollbackStackUpdate({
+      manifestRef: paths.manifestRef,
+      composeFile: paths.composeFile,
+      envFile: paths.envFile
+    });
+    console.log("[health-gate] \u2713 Stack rolled back to previous version");
+  } catch (err) {
+    console.error(`[health-gate] Stack rollback failed: ${err instanceof Error ? err.message : err}`);
+  }
+  process.exitCode = 1;
+}
+export {
+  checkCRM,
+  checkGateway,
+  checkGoTrue,
+  checkPostgres,
+  checkRawEvents,
+  logResult,
+  main,
+  runHealthGate
+};

package/dist/{capacity-monitor-ZEAE4WP2.js → capacity-monitor-JBZB2S4P.js}

@@ -8,26 +8,26 @@ import {
   isAtCapacity,
   isWithinRelaunchCooldown,
   pollCapacityDead
-} from "./chunk-MKZBHM6A.js";
-import "./chunk-T5YULDDO.js";
-import "./chunk-W7SDGBEC.js";
+} from "./chunk-XLWF3C4R.js";
+import "./chunk-FVI4UBKO.js";
+import "./chunk-MFI5OXYW.js";
 import "./chunk-LOQCOHEW.js";
-import "./chunk-TXSJ2L5O.js";
+import "./chunk-QI4IXJN7.js";
 import "./chunk-64WZEXXA.js";
-import "./chunk-A7KEWR6S.js";
-import "./chunk-X347L57O.js";
 import "./chunk-GZIAQYGI.js";
+import "./chunk-TXWQPL2U.js";
+import "./chunk-CSTJQDOE.js";
 import "./chunk-ZQX6UOP6.js";
 import "./chunk-H2CFBUGF.js";
 import "./chunk-NGP6LSV2.js";
-import "./chunk-HLVQ5Y7B.js";
-import "./chunk-OPU3NYOO.js";
+import "./chunk-RE4VLK45.js";
 import "./chunk-CVYC6DUW.js";
+import "./chunk-OPU3NYOO.js";
 import "./chunk-GJV3WDWM.js";
 import "./chunk-MP2AFCGL.js";
-import "./chunk-YS63NS6M.js";
+import "./chunk-IHSM5GR4.js";
 import "./chunk-HYZV25LY.js";
-import "./chunk-5RSYY7BE.js";
+import "./chunk-SJYOPYXH.js";
 import "./chunk-RVSGXGWG.js";
 import "./chunk-FXU7JOXK.js";
 import "./chunk-MVMMULOJ.js";

package/dist/{catchup-brief-OGWCHENC.js → catchup-brief-HE2EMZS5.js}

@@ -1,31 +1,32 @@
 import {
   lightweightSearch
-} from "./chunk-23PTS2ZD.js";
-import "./chunk-6BURHBE6.js";
-import "./chunk-S2FX5KJ4.js";
+} from "./chunk-IP7KJAUW.js";
+import "./chunk-ZXB44R3E.js";
+import "./chunk-CHCA3ZM2.js";
+import "./chunk-WBLILGAP.js";
 import {
   sessionScopeFilter,
   strictSessionScopeFilter
-} from "./chunk-W7SDGBEC.js";
+} from "./chunk-MFI5OXYW.js";
 import "./chunk-LOQCOHEW.js";
-import "./chunk-TXSJ2L5O.js";
+import "./chunk-QI4IXJN7.js";
 import "./chunk-64WZEXXA.js";
-import "./chunk-A7KEWR6S.js";
-import "./chunk-X347L57O.js";
 import "./chunk-GZIAQYGI.js";
+import "./chunk-TXWQPL2U.js";
+import "./chunk-CSTJQDOE.js";
 import "./chunk-ZQX6UOP6.js";
 import "./chunk-H2CFBUGF.js";
 import "./chunk-NGP6LSV2.js";
-import "./chunk-HLVQ5Y7B.js";
-import "./chunk-OPU3NYOO.js";
+import "./chunk-RE4VLK45.js";
 import "./chunk-CVYC6DUW.js";
+import "./chunk-OPU3NYOO.js";
 import "./chunk-GJV3WDWM.js";
 import "./chunk-MP2AFCGL.js";
-import "./chunk-YS63NS6M.js";
+import "./chunk-IHSM5GR4.js";
 import "./chunk-HYZV25LY.js";
 import {
   getClient
-} from "./chunk-5RSYY7BE.js";
+} from "./chunk-SJYOPYXH.js";
 import "./chunk-RVSGXGWG.js";
 import "./chunk-FXU7JOXK.js";
 import "./chunk-6D23UNXU.js";

package/dist/{chunk-DJJNB47C.js → chunk-27DO3EZO.js}

@@ -1,7 +1,7 @@
 import {
   clean,
   stableId
-} from "./chunk-2BGGDNRD.js";
+} from "./chunk-IPPJEM26.js";
 
 // src/lib/reflection-checkpoints.ts
 function parsePayload(payload) {

package/dist/{chunk-45FYZIHI.js → chunk-32YUET3Y.js}

@@ -1,6 +1,6 @@
 import {
   buildClaudeHttpMcpEntry
-} from "./chunk-L7ROZR2H.js";
+} from "./chunk-KXAUMIOX.js";
 import {
   loadPreferences
 } from "./chunk-GNHN5HRQ.js";
@@ -11,7 +11,7 @@ import {
 } from "./chunk-L3TB7CC3.js";
 import {
   ensureAllAgentSymlinks
-} from "./chunk-YS63NS6M.js";
+} from "./chunk-IHSM5GR4.js";
 import {
   MCP_LEGACY_KEY,
   MCP_PRIMARY_KEY

package/dist/{chunk-Y75ECPO5.js → chunk-3FW5LUGI.js}

@@ -1,6 +1,6 @@
 import {
   sessionScopeFilter
-} from "./chunk-W7SDGBEC.js";
+} from "./chunk-MFI5OXYW.js";
 
 // src/lib/git-task-sweep.ts
 import { execSync } from "child_process";
@@ -178,7 +178,7 @@ async function sweepTasks(projectName, options = {}) {
     }
     if (!dryRun) {
       try {
-        const { updateTaskStatus } = await import("./tasks-crud-ADLCGHGH.js");
+        const { updateTaskStatus } = await import("./tasks-crud-HPJKI3QQ.js");
         await updateTaskStatus({
           taskId: task.id,
           status: "needs_review",