@askexenow/exe-os 0.9.299 → 0.9.300

package/dist/chunk-F5OWHPRG.js

@@ -0,0 +1,236 @@
+import {
+  deserializeResultSet,
+  serializeValue
+} from "./chunk-QGGH7LOU.js";
+import {
+  connectEmbedDaemon,
+  isClientConnected,
+  sendDaemonRequest
+} from "./chunk-NTWF4DAF.js";
+
+// src/lib/db-daemon-client.ts
+function normalizeStatement(stmt) {
+  if (typeof stmt === "string") {
+    return { sql: stmt, args: [] };
+  }
+  const sql = stmt.sql;
+  let args = [];
+  if (Array.isArray(stmt.args)) {
+    args = stmt.args.map((v) => serializeValue(v));
+  } else if (stmt.args && typeof stmt.args === "object") {
+    const named = {};
+    for (const [key, val] of Object.entries(stmt.args)) {
+      named[key] = serializeValue(val);
+    }
+    return { sql, args: named };
+  }
+  return { sql, args };
+}
+function isReadOnlySql(sql) {
+  const normalized = sql.replace(/^\s*--.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "").trim().toLowerCase();
+  return /^(select|pragma\s+(?!wal_checkpoint|journal_mode|synchronous|user_version)|with\b.*\bselect\b)/s.test(normalized);
+}
+var TRANSIENT_TRANSPORT_ERRORS = [
+  "Not connected",
+  "Connection closed",
+  "Request timeout",
+  "DB not initialized",
+  "Server shutting down",
+  "Daemon transport error"
+];
+function isTransientDaemonTransportError(err) {
+  const msg = err instanceof Error ? err.message : String(err);
+  return TRANSIENT_TRANSPORT_ERRORS.some((s) => msg.includes(s));
+}
+async function retryOnDaemonTransportError(fn, opts = {}) {
+  const attempts = Math.max(1, opts.attempts ?? 4);
+  const baseDelayMs = opts.baseDelayMs ?? 150;
+  let lastErr;
+  for (let i = 0; i < attempts; i++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastErr = err;
+      if (i === attempts - 1 || !isTransientDaemonTransportError(err)) throw err;
+      await connectEmbedDaemon().catch(() => false);
+      await new Promise((r) => setTimeout(r, baseDelayMs * (i + 1)));
+    }
+  }
+  throw lastErr;
+}
+function createDaemonDbClient(fallbackClient) {
+  let _useDaemon = false;
+  const isMcpProcess = () => process.env.EXE_MCP_MODE === "1";
+  const isTransportError = (errMsg) => errMsg === "Not connected" || errMsg === "Request timeout" || errMsg === "Write failed" || errMsg === "DB not initialized" || errMsg === "Connection closed" || errMsg === "Server shutting down";
+  async function ensureDaemonRoute() {
+    if (_useDaemon && isClientConnected()) return true;
+    const connected = await connectEmbedDaemon().catch(() => false);
+    if (connected) {
+      _useDaemon = true;
+      return true;
+    }
+    return false;
+  }
+  function unavailableForMcp(errMsg) {
+    const suffix = errMsg ? ` Last transport error: ${errMsg}.` : "";
+    return new Error(
+      "Daemon unavailable for MCP DB operation. Refusing direct SQLite fallback from MCP process to preserve the single-writer gate and prevent FTS5 corruption." + suffix
+    );
+  }
+  const client = {
+    // Daemon-routed clients cannot span a transaction across requests —
+    // BEGIN/COMMIT via execute() is rejected by the daemon SQL guard.
+    // Callers that need atomic multi-statement writes must use batch()
+    // (executed atomically daemon-side). See store.ts flushBatch.
+    // @ts-expect-error -- capability marker consumed by flushBatch
+    interactiveTransactions: false,
+    async execute(stmt) {
+      const daemonReady = await ensureDaemonRoute();
+      if (!daemonReady) {
+        if (isMcpProcess()) throw unavailableForMcp();
+        return fallbackClient.execute(stmt);
+      }
+      const { sql, args } = normalizeStatement(stmt);
+      let response = await sendDaemonRequest({
+        type: "db-execute",
+        sql,
+        args
+      });
+      if (response.error) {
+        const errMsg = String(response.error);
+        if (isTransportError(errMsg) && isReadOnlySql(sql)) {
+          _useDaemon = false;
+          if (await ensureDaemonRoute()) {
+            response = await sendDaemonRequest({ type: "db-execute", sql, args });
+            if (!response.error && response.db) {
+              return deserializeResultSet(response.db);
+            }
+          }
+          if (isMcpProcess()) throw unavailableForMcp(errMsg);
+          process.stderr.write(`[db-daemon] Transport error (${errMsg}), falling back to direct
+`);
+          return fallbackClient.execute(stmt);
+        }
+        if (isTransportError(errMsg)) {
+          _useDaemon = false;
+          throw new Error(`Daemon transport error after write request; refusing unsafe retry: ${errMsg}`);
+        }
+        throw new Error(errMsg);
+      }
+      if (response.db) {
+        return deserializeResultSet(response.db);
+      }
+      if (isMcpProcess()) throw unavailableForMcp("Unexpected daemon response shape");
+      if (!isReadOnlySql(sql)) {
+        throw new Error("Unexpected daemon response after write request; refusing unsafe direct fallback");
+      }
+      process.stderr.write("[db-daemon] Unexpected response shape, falling back to direct\n");
+      return fallbackClient.execute(stmt);
+    },
+    async batch(stmts, mode) {
+      const daemonReady = await ensureDaemonRoute();
+      if (!daemonReady) {
+        if (isMcpProcess()) throw unavailableForMcp();
+        return fallbackClient.batch(stmts, mode);
+      }
+      const statements = stmts.map(normalizeStatement);
+      let response = await sendDaemonRequest({
+        type: "db-batch",
+        statements,
+        mode: mode ?? "deferred"
+      });
+      if (response.error) {
+        const errMsg = String(response.error);
+        const readOnlyBatch = statements.every((s) => isReadOnlySql(s.sql));
+        if (isTransportError(errMsg) && readOnlyBatch) {
+          _useDaemon = false;
+          if (await ensureDaemonRoute()) {
+            response = await sendDaemonRequest({
+              type: "db-batch",
+              statements,
+              mode: mode ?? "deferred"
+            });
+            const retriedResults = response["db-batch"];
+            if (!response.error && retriedResults) {
+              return retriedResults.map(deserializeResultSet);
+            }
+          }
+          if (isMcpProcess()) throw unavailableForMcp(errMsg);
+          process.stderr.write(`[db-daemon] Batch transport error (${errMsg}), falling back to direct
+`);
+          return fallbackClient.batch(stmts, mode);
+        }
+        if (isTransportError(errMsg)) {
+          _useDaemon = false;
+          throw new Error(`Daemon transport error after write batch; refusing unsafe retry: ${errMsg}`);
+        }
+        throw new Error(errMsg);
+      }
+      const batchResults = response["db-batch"];
+      if (batchResults) {
+        return batchResults.map(deserializeResultSet);
+      }
+      if (isMcpProcess()) throw unavailableForMcp("Unexpected daemon batch response shape");
+      if (!statements.every((s) => isReadOnlySql(s.sql))) {
+        throw new Error("Unexpected daemon response after write batch; refusing unsafe direct fallback");
+      }
+      process.stderr.write("[db-daemon] Unexpected batch response shape, falling back to direct\n");
+      return fallbackClient.batch(stmts, mode);
+    },
+    // Transaction support — delegate to fallback (transactions need direct connection)
+    async transaction(mode) {
+      return fallbackClient.transaction(mode);
+    },
+    // executeMultiple — delegate to fallback (used only for schema migrations)
+    async executeMultiple(sql) {
+      return fallbackClient.executeMultiple(sql);
+    },
+    // migrate — delegate to fallback
+    async migrate(stmts) {
+      return fallbackClient.migrate(stmts);
+    },
+    // Sync mode — delegate to fallback
+    sync() {
+      return fallbackClient.sync();
+    },
+    close() {
+      _useDaemon = false;
+    },
+    get closed() {
+      return fallbackClient.closed;
+    },
+    get protocol() {
+      return fallbackClient.protocol;
+    }
+  };
+  return {
+    ...client,
+    /** Enable daemon routing (call after confirming daemon is connected) */
+    _enableDaemon() {
+      _useDaemon = true;
+    },
+    /** Check if daemon routing is active */
+    _isDaemonActive() {
+      return _useDaemon && isClientConnected();
+    }
+  };
+}
+async function initDaemonDbClient(fallbackClient) {
+  if (process.env.EXE_IS_DAEMON === "1") return null;
+  const connected = await connectEmbedDaemon();
+  const client = createDaemonDbClient(fallbackClient);
+  if (connected) {
+    client._enableDaemon();
+    process.stderr.write("[db-daemon] DB routing through daemon (single-writer)\n");
+  } else {
+    process.stderr.write("[db-daemon] Daemon unavailable at init \u2014 will retry lazily\n");
+  }
+  return client;
+}
+
+export {
+  isTransientDaemonTransportError,
+  retryOnDaemonTransportError,
+  createDaemonDbClient,
+  initDaemonDbClient
+};

package/dist/chunk-F7MZA3QP.js

@@ -0,0 +1,199 @@
+import {
+  resolveAnthropicAuth
+} from "./chunk-EJIF4FNT.js";
+
+// 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 worker = health.embedWorker;
+          const embeddingField = health.embedding;
+          if (worker?.disabledByDesign || embeddingField === "disabled") {
+            embedDaemon = "disabled";
+          } else if (worker) {
+            embedDaemon = worker.forked && worker.ready && worker.pid != null ? "running" : "stopped";
+          } else if (embeddingField === "ok") {
+            embedDaemon = "running";
+          } 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 = resolveAnthropicAuth() ? "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-AP5R6ZHO.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-GNZS42YO.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: "info",
+      message: "Self-query-router using rule-based fallback (LLM routing is an optional enrichment; keyword + graph retrieval unaffected)",
+      remediation: "To enable LLM-based query routing, provide an Anthropic credential: set ANTHROPIC_API_KEY, or ANTHROPIC_AUTH_TOKEN if you use Claude Code / OpenCode / a subscription-OAuth host."
+    });
+  }
+  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
+};

package/dist/chunk-FRNXQSB4.js

@@ -0,0 +1,134 @@
+// src/lib/cc-binary-detect.ts
+import { execSync } from "child_process";
+import { existsSync, readFileSync, readdirSync } from "fs";
+import path from "path";
+var CC_NATIVE_ONLY_CUTOFF = "2.1.119";
+var CC_SAFE_PINNED_VERSION = "2.1.98";
+function detectAutoupdaterVar(varName, homeDir = process.env.HOME ?? process.env.USERPROFILE ?? "", env = process.env) {
+  if (env[varName] === "1") {
+    return { source: "env" };
+  }
+  if (homeDir.length === 0) return null;
+  const profiles = [
+    ".zshrc",
+    ".zprofile",
+    ".bashrc",
+    ".bash_profile",
+    ".profile"
+  ];
+  const pattern = new RegExp(
+    `^\\s*(?:export\\s+)?${varName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}=["']?1["']?\\s*$`,
+    "m"
+  );
+  for (const name of profiles) {
+    const file = path.join(homeDir, name);
+    if (!existsSync(file)) continue;
+    try {
+      const content = readFileSync(file, "utf8");
+      const uncommented = content.split("\n").filter((line) => !/^\s*#/.test(line)).join("\n");
+      if (pattern.test(uncommented)) {
+        return { source: "profile", profile: name };
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function isAutoupdaterDisabled(env = process.env, homeDir = env.HOME ?? env.USERPROFILE ?? "") {
+  return detectAutoupdaterVar("DISABLE_AUTOUPDATER", homeDir, env) !== null || detectAutoupdaterVar("CLAUDE_CODE_AUTOUPDATER_DISABLED", homeDir, env) !== null;
+}
+function compareSemver(a, b) {
+  const pa = a.split(".").map((n) => Number.parseInt(n, 10));
+  const pb = b.split(".").map((n) => Number.parseInt(n, 10));
+  const len = Math.max(pa.length, pb.length);
+  for (let i = 0; i < len; i++) {
+    const x = Number.isFinite(pa[i]) ? pa[i] : 0;
+    const y = Number.isFinite(pb[i]) ? pb[i] : 0;
+    if (x !== y) return x - y;
+  }
+  return 0;
+}
+function looksNative(p) {
+  return p.includes("bin/claude.exe") || p.includes("bin/claude-native") || p.includes("claude.exe") || p.includes("claude-native") || p.includes("claude/versions/");
+}
+function detectCcNativeBinary(env = process.env) {
+  const reasons = [];
+  let resolvedPath;
+  let version;
+  const execPath = (env.CLAUDE_CODE_EXECPATH ?? "").trim();
+  if (execPath.length > 0 && looksNative(execPath)) {
+    reasons.push(`CLAUDE_CODE_EXECPATH points to native binary: ${execPath}`);
+  }
+  try {
+    const claudePath = execSync("which claude 2>/dev/null || true", {
+      encoding: "utf8",
+      timeout: 5e3
+    }).trim();
+    if (claudePath) {
+      let resolved = claudePath;
+      try {
+        resolved = execSync(
+          `readlink -f "${claudePath}" 2>/dev/null || readlink "${claudePath}" 2>/dev/null || echo "${claudePath}"`,
+          { encoding: "utf8", timeout: 5e3 }
+        ).trim();
+      } catch {
+      }
+      resolvedPath = resolved;
+      if (looksNative(resolved)) {
+        reasons.push(`claude resolves to native binary: ${resolved}`);
+      }
+    }
+  } catch {
+  }
+  try {
+    const versionsDir = path.join(
+      env.HOME ?? env.USERPROFILE ?? "",
+      ".local",
+      "share",
+      "claude",
+      "versions"
+    );
+    if (versionsDir && existsSync(versionsDir)) {
+      const entries = readdirSync(versionsDir);
+      if (entries.length > 0) {
+        reasons.push(
+          `${entries.length} cached native CC version(s) in ${versionsDir}`
+        );
+      }
+    }
+  } catch {
+  }
+  try {
+    const out = execSync("claude --version 2>/dev/null || echo unknown", {
+      encoding: "utf8",
+      timeout: 5e3
+    }).trim();
+    const m = out.match(/(\d+\.\d+\.\d+)/);
+    if (m) {
+      version = m[1];
+      if (compareSemver(version, CC_NATIVE_ONLY_CUTOFF) >= 0) {
+        reasons.push(
+          `CC version ${version} is \u2265${CC_NATIVE_ONLY_CUTOFF} (native-binary build)`
+        );
+      }
+    }
+  } catch {
+  }
+  return { detected: reasons.length > 0, reasons, resolvedPath, version };
+}
+function ccNativeBinaryWarningLine(status = detectCcNativeBinary(), env = process.env) {
+  if (!status.detected) return null;
+  if (isAutoupdaterDisabled(env)) return null;
+  const ver = status.version ? ` (v${status.version})` : "";
+  return `\u{1F534} Claude Code native binary detected${ver} \u2014 phantom-billing risk. exe-os is tested against cli.js. Mitigate: disable the auto-updater (export DISABLE_AUTOUPDATER=1 and CLAUDE_CODE_AUTOUPDATER_DISABLED=1 in your shell profile) (run \`exe-os healthcheck\` for details). Advisory only.`;
+}
+
+export {
+  CC_NATIVE_ONLY_CUTOFF,
+  CC_SAFE_PINNED_VERSION,
+  detectAutoupdaterVar,
+  isAutoupdaterDisabled,
+  compareSemver,
+  detectCcNativeBinary,
+  ccNativeBinaryWarningLine
+};