@askexenow/exe-os 0.9.271 → 0.9.273

package/dist/chunk-7ET5CYTD.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-7IWLKR6N.js

@@ -0,0 +1,76 @@
+import {
+  fastDbInit
+} from "./chunk-SBLHQMMZ.js";
+import {
+  sessionScopeFilter
+} from "./chunk-57UAFTO2.js";
+import {
+  formatStatusAll,
+  formatStatusDeep,
+  getEmployeeStatuses,
+  inTmux
+} from "./chunk-CX6GL3ZJ.js";
+import {
+  getClient,
+  isCoordinatorRole,
+  loadEmployees
+} from "./chunk-UNCGZXPU.js";
+import {
+  isMainModule
+} from "./chunk-6Y4B3QF6.js";
+
+// src/bin/exe-status.ts
+async function status(targetEmployee) {
+  if (!inTmux()) {
+    return "Not in a tmux session. Start tmux first: tmux new-session -s work";
+  }
+  const employees = await loadEmployees();
+  const names = employees.filter((e) => !isCoordinatorRole(e.role)).map((e) => e.name);
+  const roles = new Map(employees.map((e) => [e.name, e.role ?? ""]));
+  await fastDbInit();
+  const client = getClient();
+  const taskMap = /* @__PURE__ */ new Map();
+  try {
+    const esScope = sessionScopeFilter();
+    const result = await client.execute({
+      sql: `SELECT assigned_to, title, priority FROM tasks
+            WHERE status = 'in_progress'${esScope.sql}
+            ORDER BY priority ASC, created_at ASC`,
+      args: [...esScope.args]
+    });
+    for (const row of result.rows) {
+      const assignee = String(row.assigned_to);
+      if (!taskMap.has(assignee)) {
+        taskMap.set(assignee, {
+          title: String(row.title),
+          priority: String(row.priority)
+        });
+      }
+    }
+  } catch {
+  }
+  if (targetEmployee) {
+    if (!names.includes(targetEmployee)) {
+      return `Employee "${targetEmployee}" not found. Available: ${names.join(", ")}`;
+    }
+    const statuses2 = getEmployeeStatuses([targetEmployee]);
+    const s = statuses2[0];
+    return formatStatusDeep(s, taskMap.get(targetEmployee), roles.get(targetEmployee) ?? "");
+  }
+  const statuses = getEmployeeStatuses(names);
+  return formatStatusAll(statuses, taskMap, roles);
+}
+if (isMainModule(import.meta.url)) {
+  const target = process.argv[2];
+  status(target).then((output) => {
+    process.stdout.write(output + "\n");
+  }).catch((err) => {
+    process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+    process.exit(1);
+  });
+}
+
+export {
+  status
+};