@askexenow/exe-os 0.9.286 → 0.9.288

package/dist/chunk-ONTUBOYP.js

@@ -0,0 +1,230 @@
+// 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-CZ2QHS6T.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,
+  checkPostgres,
+  checkRawEvents,
+  checkGoTrue,
+  runHealthGate,
+  logResult,
+  main
+};

package/dist/chunk-OQB7TERT.js

@@ -0,0 +1,54 @@
+import {
+  processCRMEvent
+} from "./chunk-EVM22AGQ.js";
+
+// src/gateway/adapters/crm-webhook.ts
+function parseTwentyWebhook(payload) {
+  if (!payload || typeof payload !== "object") return null;
+  const p = payload;
+  const eventName = p.eventName;
+  if (!eventName || typeof eventName !== "string") return null;
+  const dotIndex = eventName.indexOf(".");
+  if (dotIndex === -1) return null;
+  const objectType = eventName.slice(0, dotIndex);
+  const eventType = eventName.slice(dotIndex + 1);
+  if (!objectType || !eventType) return null;
+  const normalizedObjectType = objectType.charAt(0).toUpperCase() + objectType.slice(1);
+  const record = p.record ?? {};
+  if (typeof record !== "object") return null;
+  return {
+    eventType,
+    objectType: normalizedObjectType,
+    record
+  };
+}
+function createCRMWebhookHandler(options) {
+  return async (body) => {
+    const event = parseTwentyWebhook(body);
+    if (!event) {
+      console.warn(
+        "[crm-webhook] Malformed CRM webhook payload \u2014 skipping"
+      );
+      return;
+    }
+    console.log(
+      `[crm-webhook] ${event.objectType}.${event.eventType} received`
+    );
+    try {
+      const logs = await processCRMEvent(event, options?.executor, options?.triggers);
+      if (logs.length > 0 && options?.onFired) {
+        options.onFired(logs);
+      }
+    } catch (err) {
+      console.error(
+        "[crm-webhook] Error processing CRM event:",
+        err instanceof Error ? err.message : err
+      );
+    }
+  };
+}
+
+export {
+  parseTwentyWebhook,
+  createCRMWebhookHandler
+};

package/dist/chunk-P362EYLO.js

@@ -0,0 +1,106 @@
+import {
+  loadConfig,
+  saveConfig
+} from "./chunk-CEKZ77KA.js";
+
+// src/lib/orchestration-phase.ts
+var ORCHESTRATION_PHASES = [
+  "phase_1_coo",
+  "phase_2_executives",
+  "phase_3_parallel_org"
+];
+var PHASE_INFO = {
+  phase_1_coo: {
+    phase: "phase_1_coo",
+    shortLabel: "Phase 1 \u2014 Coordinator mode",
+    label: "Phase 1 \u2014 Coordinator / Chief of Staff mode",
+    focus: "building company context before delegation",
+    nextSuggestion: "Unlock executives when technical, marketing, ops, legal, or finance work repeats."
+  },
+  phase_2_executives: {
+    phase: "phase_2_executives",
+    shortLabel: "Phase 2 \u2014 Executive bench",
+    label: "Phase 2 \u2014 Executive bench",
+    focus: "Coordinator works with domain executives like CTO/CMO before specialist fan-out",
+    nextSuggestion: "Unlock parallel execution when review gates, permissions, and workflows are ready."
+  },
+  phase_3_parallel_org: {
+    phase: "phase_3_parallel_org",
+    shortLabel: "Phase 3 \u2014 Parallel org",
+    label: "Phase 3 \u2014 Parallel execution org",
+    focus: "executives can delegate to specialists in parallel with review gates",
+    nextSuggestion: "Keep review/CI/permission gates healthy; downgrade anytime if you want simpler coordinator-only mode."
+  }
+};
+function normalizeOrchestrationPhase(input) {
+  if (typeof input !== "string") return "phase_1_coo";
+  const normalized = input.trim().toLowerCase().replace(/\s+/g, "_");
+  if (["1", "phase1", "phase_1", "coo", "coo_mode", "chief_of_staff", "phase_1_coo"].includes(normalized)) {
+    return "phase_1_coo";
+  }
+  if (["2", "phase2", "phase_2", "executives", "executive", "executive_bench", "phase_2_executives"].includes(normalized)) {
+    return "phase_2_executives";
+  }
+  if (["3", "phase3", "phase_3", "parallel", "parallel_org", "parallel_execution", "phase_3_parallel_org"].includes(normalized)) {
+    return "phase_3_parallel_org";
+  }
+  if (ORCHESTRATION_PHASES.includes(normalized)) return normalized;
+  return "phase_1_coo";
+}
+function getOrchestrationPhaseInfo(phase) {
+  return PHASE_INFO[normalizeOrchestrationPhase(phase)];
+}
+function getConfigOrchestrationPhase(config) {
+  const orchestration = config.orchestration;
+  return normalizeOrchestrationPhase(orchestration?.phase);
+}
+function applyDefaultOrchestrationPhase(config) {
+  if (!config.orchestration) {
+    config.orchestration = {
+      phase: "phase_1_coo",
+      phaseSetAt: (/* @__PURE__ */ new Date()).toISOString(),
+      phaseSetBy: "setup-default"
+    };
+    return config;
+  }
+  if (!config.orchestration.phase) {
+    config.orchestration = {
+      ...config.orchestration,
+      phase: "phase_1_coo",
+      phaseSetAt: config.orchestration.phaseSetAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+      phaseSetBy: config.orchestration.phaseSetBy ?? "setup-default"
+    };
+  }
+  return config;
+}
+async function loadOrchestrationPhase() {
+  const config = await loadConfig();
+  return getOrchestrationPhaseInfo(config.orchestration?.phase);
+}
+async function setOrchestrationPhase(phaseInput, setBy = "user") {
+  const config = await loadConfig();
+  const phase = normalizeOrchestrationPhase(phaseInput);
+  config.orchestration = {
+    ...config.orchestration ?? {},
+    phase,
+    phaseSetAt: (/* @__PURE__ */ new Date()).toISOString(),
+    phaseSetBy: setBy
+  };
+  await saveConfig(config);
+  return getOrchestrationPhaseInfo(phase);
+}
+function phaseReminderLine(phase) {
+  const info = getOrchestrationPhaseInfo(phase);
+  return `${info.shortLabel}: ${info.focus}. ${info.nextSuggestion}`;
+}
+
+export {
+  ORCHESTRATION_PHASES,
+  normalizeOrchestrationPhase,
+  getOrchestrationPhaseInfo,
+  getConfigOrchestrationPhase,
+  applyDefaultOrchestrationPhase,
+  loadOrchestrationPhase,
+  setOrchestrationPhase,
+  phaseReminderLine
+};

package/dist/chunk-P4T4JOCE.js

@@ -0,0 +1,192 @@
+// src/lib/retrieval-health.ts
+async function getRetrievalHealth() {
+  let embedDaemon = "unavailable";
+  try {
+    const { isDaemonAlive } = await import("./mcp-health-WDOB6XUB.js");
+    const { alive } = isDaemonAlive();
+    if (alive) {
+      try {
+        const { pingDaemon } = await import("./lib/exe-daemon-client.js");
+        const health = await pingDaemon();
+        if (health) {
+          const embeddingField = health.embedding;
+          if (embeddingField === "ok") {
+            embedDaemon = "running";
+          } else if (embeddingField === "disabled") {
+            embedDaemon = "disabled";
+          } else {
+            embedDaemon = "stopped";
+          }
+        } else {
+          embedDaemon = "stopped";
+        }
+      } catch {
+        embedDaemon = "stopped";
+      }
+    } else {
+      embedDaemon = "unavailable";
+    }
+  } catch {
+    embedDaemon = "unavailable";
+  }
+  let configuredSearchMode = "hybrid";
+  let selfQueryRouterEnabled = true;
+  try {
+    const { loadConfigSync } = await import("./lib/config.js");
+    const cfg = loadConfigSync();
+    configuredSearchMode = cfg.searchMode ?? "hybrid";
+    selfQueryRouterEnabled = cfg.selfQueryRouter ?? true;
+  } catch {
+  }
+  let actualSearchMode;
+  if (configuredSearchMode === "fts") {
+    actualSearchMode = "fts+graph";
+  } else if (embedDaemon === "running") {
+    actualSearchMode = "hybrid (vector+fts+graph)";
+  } else {
+    actualSearchMode = "fts+graph (degraded from hybrid)";
+  }
+  let queryRouter;
+  if (!selfQueryRouterEnabled) {
+    queryRouter = "disabled";
+  } else if (embedDaemon === "running" || embedDaemon === "disabled") {
+    queryRouter = process.env.ANTHROPIC_API_KEY ? "active" : "fallback";
+  } else {
+    queryRouter = "fallback";
+  }
+  let totalMemories = 0;
+  let memoriesWithVectors = 0;
+  let entities = 0;
+  let relationships = 0;
+  try {
+    const { getClient } = await import("./lib/database.js");
+    const client = getClient();
+    const [totalRes, vectorRes] = await Promise.all([
+      client.execute("SELECT COUNT(*) as cnt FROM memories WHERE status IS NULL OR status != 'deleted'"),
+      client.execute("SELECT COUNT(*) as cnt FROM memories WHERE vector IS NOT NULL AND (status IS NULL OR status != 'deleted')")
+    ]);
+    totalMemories = Number(totalRes.rows[0]?.cnt ?? 0);
+    memoriesWithVectors = Number(vectorRes.rows[0]?.cnt ?? 0);
+    try {
+      const { getGraphStats } = await import("./graph-query-XEDHA2PQ.js");
+      const stats = await getGraphStats(client);
+      entities = stats.entities;
+      relationships = stats.relationships;
+    } catch {
+    }
+  } catch {
+  }
+  const staleCount = totalMemories - memoriesWithVectors;
+  const coveragePct = totalMemories > 0 ? Math.round(memoriesWithVectors / totalMemories * 100) : null;
+  let dbRestore = { hasEvents: false, count: 0, last: null, quarantineFiles: 0 };
+  try {
+    const { getDbRestoreHealth } = await import("./db-restore-events-AIL6GSEK.js");
+    dbRestore = getDbRestoreHealth();
+  } catch {
+  }
+  const summary = {
+    embedDaemon,
+    searchMode: {
+      configured: configuredSearchMode,
+      actual: actualSearchMode
+    },
+    queryRouter,
+    vectorBackfill: {
+      totalMemories,
+      memoriesWithVectors,
+      staleCount,
+      coveragePct
+    },
+    graph: {
+      entities,
+      relationships
+    },
+    dbRestore
+  };
+  return {
+    ...summary,
+    degradations: computeDegradations(summary)
+  };
+}
+function computeDegradations(h) {
+  const out = [];
+  const isRuntimeDowngrade = h.searchMode.actual.includes("degraded");
+  if (isRuntimeDowngrade) {
+    out.push({
+      code: "retrieval_downgraded",
+      severity: "warn",
+      message: `Retrieval running as "${h.searchMode.actual}" (configured: "${h.searchMode.configured}")`,
+      remediation: h.embedDaemon === "disabled" ? "Embeddings are disabled. Enable them in settings if you want vector retrieval." : "Embed daemon is not running. Start the daemon / embed worker to restore hybrid retrieval."
+    });
+  } else if (h.searchMode.configured === "fts") {
+    out.push({
+      code: "embeddings_off",
+      severity: "info",
+      message: "Search mode is FTS-only by configuration (keyword + graph; no vector retrieval)",
+      remediation: 'Switch searchMode to "hybrid" in settings to enable vector retrieval.'
+    });
+  }
+  if (h.queryRouter === "fallback") {
+    out.push({
+      code: "query_router_fallback",
+      severity: "warn",
+      message: "Self-query-router using rule-based fallback (no LLM routing)",
+      remediation: "Set ANTHROPIC_API_KEY (and ensure the embed daemon is reachable) to enable LLM-based query routing."
+    });
+  }
+  if (h.dbRestore.hasEvents) {
+    const last = h.dbRestore.last;
+    if (last && (last.kind === "restore-failed" || last.kind === "zeroed-no-wal")) {
+      out.push({
+        code: "db_corruption_unrecovered",
+        severity: "critical",
+        message: `DB corruption could not be auto-recovered: ${last.detail ?? last.kind} (${last.at})`,
+        remediation: "Restore from a known-good backup (`exe-os cloud reupload` or restore a backup); preserved corrupt DB is in ~/.exe-os/."
+      });
+    } else if (last && (last.kind === "auto-restore" || last.kind === "wal-recovery")) {
+      out.push({
+        code: "db_auto_restored",
+        severity: "warn",
+        message: last.kind === "auto-restore" ? `DB was auto-restored from backup${last.restoredFrom ? ` (${last.restoredFrom})` : ""}${typeof last.hoursLost === "number" ? `, ~${last.hoursLost}h data-loss window` : ""} at ${last.at}` : `DB was reconstructed from WAL after a 0-byte corruption at ${last.at}`,
+        remediation: "Recent memories may be missing. Run a cloud sync to reconcile and verify recent data."
+      });
+    } else if (h.dbRestore.quarantineFiles > 0) {
+      out.push({
+        code: "db_corruption_quarantine",
+        severity: "warn",
+        message: `${h.dbRestore.quarantineFiles} quarantined corrupt DB file(s) present in ~/.exe-os/ (prior corruption event)`,
+        remediation: "Verify data integrity; remove quarantined .corrupt-*/.zeroed-* files once you've confirmed no data is needed."
+      });
+    }
+  }
+  return out;
+}
+var SEVERITY_ICON = {
+  info: "\u2139\uFE0F",
+  // ℹ️
+  warn: "\u{1F7E0}",
+  // 🟠
+  critical: "\u{1F534}"
+  // 🔴
+};
+function formatDegradations(degradations, heading = "Degradations") {
+  const lines = [];
+  lines.push(`### ${heading}`);
+  if (degradations.length === 0) {
+    lines.push("\u{1F7E2} None \u2014 all retrieval and storage subsystems nominal.");
+    return lines.join("\n");
+  }
+  const order = { critical: 0, warn: 1, info: 2 };
+  const sorted = [...degradations].sort((a, b) => order[a.severity] - order[b.severity]);
+  for (const d of sorted) {
+    lines.push(`${SEVERITY_ICON[d.severity]} ${d.message}`);
+    if (d.remediation) lines.push(`   \u2192 ${d.remediation}`);
+  }
+  return lines.join("\n");
+}
+
+export {
+  getRetrievalHealth,
+  computeDegradations,
+  formatDegradations
+};