@askexenow/exe-os 0.9.287 → 0.9.289

package/dist/chunk-EVM22AGQ.js

@@ -0,0 +1,382 @@
+// src/automation/trigger-engine.ts
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { randomUUID } from "crypto";
+import path from "path";
+import os from "os";
+var TRIGGERS_PATH = path.join(os.homedir(), ".exe-os", "triggers.json");
+var GRAPH_API_VERSION = "v21.0";
+var MAX_PARAM_LENGTH = 2e3;
+var MAX_TRIGGER_DEPTH = 3;
+var _currentTriggerDepth = 0;
+var OUTBOUND_RATE_LIMIT_PER_HOUR = 100;
+var _outboundWindows = /* @__PURE__ */ new Map();
+function checkOutboundRateLimit(channel) {
+  const now = Date.now();
+  const cutoff = now - 36e5;
+  if (!_outboundWindows.has(channel)) _outboundWindows.set(channel, []);
+  const window = _outboundWindows.get(channel);
+  while (window.length > 0 && window[0] < cutoff) window.shift();
+  if (window.length >= OUTBOUND_RATE_LIMIT_PER_HOUR) return false;
+  window.push(now);
+  return true;
+}
+function sanitizeParam(value, maxLen = MAX_PARAM_LENGTH) {
+  const cleaned = value.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, "");
+  return cleaned.length > maxLen ? cleaned.slice(0, maxLen) : cleaned;
+}
+function sanitizeExternalPayload(text) {
+  let sanitized = text;
+  sanitized = sanitized.replace(/^(system|SYSTEM|System)\s*:/gm, "[filtered]:");
+  sanitized = sanitized.replace(/<\/?system[^>]*>/gi, "[filtered]");
+  sanitized = sanitized.replace(/ignore\s+(all\s+)?previous\s+(instructions|prompts|rules)/gi, "[filtered]");
+  sanitized = sanitized.replace(/you\s+are\s+now\s+/gi, "[filtered] ");
+  return sanitized;
+}
+function substituteTemplate(template, record, sanitizeExternal = false) {
+  return template.replace(
+    /\{\{(\w+(?:\.\w+)*)\}\}/g,
+    (_match, dotPath) => {
+      const segments = dotPath.split(".");
+      if (segments[0] === "record") segments.shift();
+      let current = record;
+      for (const seg of segments) {
+        if (current == null || typeof current !== "object") return "";
+        current = current[seg];
+      }
+      if (current == null) return "";
+      const value = String(current);
+      return sanitizeExternal ? sanitizeExternalPayload(value) : value;
+    }
+  );
+}
+function resolveFieldValue(record, field) {
+  let current = record;
+  for (const segment of field.split(".")) {
+    if (current == null || typeof current !== "object") return void 0;
+    current = current[segment];
+  }
+  return current;
+}
+function evaluateCondition(condition, record) {
+  const fieldValue = resolveFieldValue(record, condition.field);
+  const target = condition.value;
+  switch (condition.op) {
+    case "eq":
+      return String(fieldValue) === String(target);
+    case "neq":
+      return String(fieldValue) !== String(target);
+    case "gt":
+      return Number(fieldValue) > Number(target);
+    case "lt":
+      return Number(fieldValue) < Number(target);
+    case "gte":
+      return Number(fieldValue) >= Number(target);
+    case "lte":
+      return Number(fieldValue) <= Number(target);
+    case "contains":
+      return String(fieldValue).toLowerCase().includes(String(target).toLowerCase());
+    case "not_contains":
+      return !String(fieldValue).toLowerCase().includes(String(target).toLowerCase());
+    default:
+      return false;
+  }
+}
+function evaluateConditions(conditions, record) {
+  if (conditions.length === 0) return true;
+  return conditions.every((c) => evaluateCondition(c, record));
+}
+function loadTriggers(project) {
+  if (!existsSync(TRIGGERS_PATH)) return [];
+  try {
+    const raw = readFileSync(TRIGGERS_PATH, "utf-8");
+    const all = JSON.parse(raw);
+    if (!Array.isArray(all)) return [];
+    if (project) {
+      return all.filter((t) => !t.project || t.project === project);
+    }
+    return all;
+  } catch {
+    return [];
+  }
+}
+function saveTriggers(triggers) {
+  const dir = path.dirname(TRIGGERS_PATH);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(TRIGGERS_PATH, JSON.stringify(triggers, null, 2), "utf-8");
+}
+function createNewTrigger(input) {
+  const triggers = loadTriggers();
+  const trigger = {
+    id: randomUUID().slice(0, 8),
+    ...input
+  };
+  triggers.push(trigger);
+  saveTriggers(triggers);
+  return trigger;
+}
+async function executeSendWhatsapp(params) {
+  if (!checkOutboundRateLimit("whatsapp")) {
+    throw new Error(`Outbound rate limit exceeded for WhatsApp (max ${OUTBOUND_RATE_LIMIT_PER_HOUR}/hour)`);
+  }
+  const { getAccountByName, getDefaultAccount } = await import("./whatsapp-accounts-BWRZUY23.js");
+  const account = params.account ? getAccountByName(params.account) : getDefaultAccount();
+  if (!account) {
+    throw new Error(
+      `No WhatsApp account found${params.account ? ` (${params.account})` : ""}`
+    );
+  }
+  const to = params.to ?? params.recipient;
+  const message = params.message ?? params.text;
+  if (!to || !message)
+    throw new Error("send_whatsapp requires 'to' and 'message' params");
+  const url = `https://graph.facebook.com/${GRAPH_API_VERSION}/${account.phoneNumberId}/messages`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${account.accessToken}`
+    },
+    body: JSON.stringify({
+      messaging_product: "whatsapp",
+      to,
+      type: "text",
+      text: { body: message }
+    }),
+    signal: AbortSignal.timeout(3e4)
+  });
+  if (!res.ok) {
+    const errBody = await res.text();
+    throw new Error(`WhatsApp send failed (${res.status}): ${errBody}`);
+  }
+}
+async function executeSendMessage(params) {
+  const { sendMessage } = await import("./lib/messaging.js");
+  const { getCoordinatorName } = await import("./lib/employees.js");
+  const rawTo = params.to ?? params.recipient;
+  const to = rawTo === "coordinator" ? getCoordinatorName() : rawTo;
+  const content = params.message ?? params.content ?? params.text;
+  if (!to || !content)
+    throw new Error("send_message requires 'to' and 'message' params");
+  await sendMessage({
+    fromAgent: params.from ?? "trigger-engine",
+    targetAgent: to,
+    content,
+    priority: params.priority ?? "normal"
+  });
+}
+async function executeCreateTask(params) {
+  const { createTask } = await import("./lib/tasks.js");
+  const { getCoordinatorName } = await import("./lib/employees.js");
+  const rawAssignedTo = params.assigned_to;
+  await createTask({
+    title: params.title ?? "Triggered task",
+    assignedTo: !rawAssignedTo || rawAssignedTo === "coordinator" ? getCoordinatorName() : rawAssignedTo,
+    assignedBy: "trigger-engine",
+    projectName: params.project ?? "exe-os",
+    priority: params.priority ?? "p1",
+    context: params.context ?? params.description ?? "",
+    baseDir: process.cwd()
+  });
+}
+async function executeUpdateWiki(params) {
+  const apiUrl = process.env.EXE_WIKI_API_URL;
+  const apiKey = process.env.EXE_WIKI_API_KEY;
+  if (!apiUrl || !apiKey) {
+    throw new Error("Wiki not configured: EXE_WIKI_API_URL / EXE_WIKI_API_KEY not set");
+  }
+  const workspace = params.workspace;
+  const content = params.content ?? params.text;
+  const mode = params.mode ?? "append";
+  const section = params.section;
+  if (!workspace || !content) {
+    throw new Error("update_wiki requires 'workspace' and 'content' params");
+  }
+  const documentId = params.document_id;
+  if (documentId && mode === "append") {
+    const readRes = await fetch(`${apiUrl}/v1/document/${documentId}`, {
+      headers: { Authorization: `Bearer ${apiKey}` },
+      signal: AbortSignal.timeout(15e3)
+    });
+    if (!readRes.ok) {
+      throw new Error(`Wiki read failed (${readRes.status})`);
+    }
+    const doc = await readRes.json();
+    const existingContent = String(doc.content ?? "");
+    const title = String(doc.title ?? "Untitled");
+    await fetch(`${apiUrl}/v1/document/${documentId}`, {
+      method: "DELETE",
+      headers: { Authorization: `Bearer ${apiKey}` },
+      signal: AbortSignal.timeout(15e3)
+    }).catch((err) => {
+      process.stderr.write(`[trigger-engine] wiki purge failed: ${err instanceof Error ? err.message : String(err)}
+`);
+    });
+    const uploadRes = await fetch(`${apiUrl}/v1/document/raw-text`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        textContent: section ? existingContent + `
+
+## ${section}
+${content}` : existingContent + "\n\n" + content,
+        metadata: { title },
+        workspaceSlugs: [workspace]
+      }),
+      signal: AbortSignal.timeout(15e3)
+    });
+    if (!uploadRes.ok) throw new Error(`Wiki upload failed (${uploadRes.status})`);
+  } else {
+    const title = params.title ?? "Auto-generated";
+    const res = await fetch(`${apiUrl}/v1/document/raw-text`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        textContent: content,
+        metadata: { title },
+        workspaceSlugs: [workspace]
+      }),
+      signal: AbortSignal.timeout(15e3)
+    });
+    if (!res.ok) throw new Error(`Wiki create failed (${res.status})`);
+  }
+}
+async function routeToApproval(action, resolvedParams, triggerName) {
+  const { createTask } = await import("./lib/tasks.js");
+  const { getCoordinatorName } = await import("./lib/employees.js");
+  const actionSummary = action.type === "send_whatsapp" ? `Send WhatsApp to ${resolvedParams.to ?? resolvedParams.recipient ?? "unknown"}: "${(resolvedParams.message ?? resolvedParams.text ?? "").slice(0, 100)}"` : `${action.type}: ${JSON.stringify(resolvedParams).slice(0, 200)}`;
+  await createTask({
+    title: `[Approval Required] ${triggerName}: ${action.type}`,
+    assignedTo: getCoordinatorName(),
+    assignedBy: "trigger-engine",
+    projectName: resolvedParams.project ?? "exe-os",
+    priority: "p1",
+    context: `Trigger "${triggerName}" wants to execute this action but requires approval.
+
+**Action:** ${action.type}
+**Summary:** ${actionSummary}
+**Full params:** ${JSON.stringify(resolvedParams, null, 2)}
+
+To approve, manually run the action via MCP tools.`,
+    baseDir: process.cwd()
+  });
+}
+async function executeAction(action, record, executor, triggerName) {
+  if (executor) {
+    return executor(action, record);
+  }
+  const resolvedParams = {};
+  for (const [key, val] of Object.entries(action.params)) {
+    resolvedParams[key] = sanitizeParam(substituteTemplate(val, record));
+  }
+  if (action.requires_approval) {
+    try {
+      await routeToApproval(action, resolvedParams, triggerName ?? "Unknown trigger");
+      return { success: true };
+    } catch (err) {
+      return {
+        success: false,
+        error: `Approval routing failed: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+  }
+  try {
+    switch (action.type) {
+      case "send_whatsapp":
+        await executeSendWhatsapp(resolvedParams);
+        break;
+      case "send_message":
+        await executeSendMessage(resolvedParams);
+        break;
+      case "create_task":
+        await executeCreateTask(resolvedParams);
+        break;
+      case "update_wiki":
+        await executeUpdateWiki(resolvedParams);
+        break;
+      case "asana": {
+        const { loadAsanaConfig, executeAsanaOperation } = await import("./asana-MRQ2OQMJ.js");
+        const asanaConfig = loadAsanaConfig();
+        if (!asanaConfig) throw new Error("Asana not configured: set ASANA_API_TOKEN env var");
+        const operation = resolvedParams.operation ?? resolvedParams._operation;
+        if (!operation) throw new Error("asana action requires 'operation' param");
+        await executeAsanaOperation(asanaConfig, operation, resolvedParams);
+        break;
+      }
+      case "mcp_tool":
+        console.log(
+          `[trigger-engine] mcp_tool action: ${JSON.stringify(resolvedParams)}`
+        );
+        break;
+    }
+    return { success: true };
+  } catch (err) {
+    return {
+      success: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+async function processCRMEvent(event, executor, triggersOverride) {
+  if (_currentTriggerDepth >= MAX_TRIGGER_DEPTH) {
+    console.error(
+      `[trigger-engine] Recursion limit (${MAX_TRIGGER_DEPTH}) reached \u2014 skipping event ${event.objectType}.${event.eventType}`
+    );
+    return [];
+  }
+  _currentTriggerDepth++;
+  try {
+    return await _processCRMEventInner(event, executor, triggersOverride);
+  } finally {
+    _currentTriggerDepth--;
+  }
+}
+async function _processCRMEventInner(event, executor, triggersOverride) {
+  const eventString = `${event.objectType}.${event.eventType}`;
+  const triggers = triggersOverride ?? loadTriggers();
+  const logs = [];
+  for (const trigger of triggers) {
+    if (!trigger.enabled) continue;
+    if (trigger.event !== eventString && trigger.event !== "*") continue;
+    if (!evaluateConditions(trigger.conditions, event.record)) continue;
+    const actionResults = [];
+    for (const action of trigger.actions) {
+      const result = await executeAction(action, event.record, executor, trigger.name);
+      actionResults.push({
+        type: action.type,
+        success: result.success,
+        error: result.error
+      });
+    }
+    const log = {
+      triggerId: trigger.id,
+      triggerName: trigger.name,
+      event: eventString,
+      firedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      actionsExecuted: actionResults
+    };
+    logs.push(log);
+    console.log(
+      `[trigger-engine] Fired "${trigger.name}" on ${eventString}: ${actionResults.filter((a) => a.success).length}/${actionResults.length} actions succeeded`
+    );
+  }
+  return logs;
+}
+function isScheduledTrigger(trigger) {
+  return "schedule" in trigger && "query" in trigger;
+}
+
+export {
+  sanitizeParam,
+  substituteTemplate,
+  loadTriggers,
+  createNewTrigger,
+  executeAction,
+  processCRMEvent,
+  isScheduledTrigger
+};

package/dist/chunk-EY7TBDZ5.js

@@ -0,0 +1,38 @@
+import {
+  listReminders
+} from "./chunk-IBLEQQDQ.js";
+
+// src/mcp/tools/list-reminders.ts
+import { z } from "zod";
+function registerListReminders(server) {
+  server.registerTool(
+    "list_reminders",
+    {
+      title: "List Reminders",
+      description: "List active reminders. Pass include_completed=true to see all.",
+      inputSchema: {
+        include_completed: z.boolean().optional().default(false).describe("Include completed reminders")
+      }
+    },
+    async ({ include_completed }) => {
+      const reminders = await listReminders(include_completed);
+      if (reminders.length === 0) {
+        return {
+          content: [{ type: "text", text: "No active reminders." }]
+        };
+      }
+      const lines = reminders.map((r) => {
+        const due = r.dueDate ? ` (due: ${r.dueDate})` : "";
+        const done = r.completedAt ? " [DONE]" : "";
+        return `\u2022 ${r.text}${due}${done}  [id: ${r.id.slice(0, 8)}]`;
+      });
+      return {
+        content: [{ type: "text", text: lines.join("\n") }]
+      };
+    }
+  );
+}
+
+export {
+  registerListReminders
+};

package/dist/chunk-EYLU6MJT.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-QF3KCGVZ.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
+};