@askexenow/exe-os 0.9.299 → 0.9.301

package/dist/chunk-OO4IFABD.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-OYIP3QVN.js

@@ -0,0 +1,167 @@
+import {
+  EXE_AI_DIR
+} from "./chunk-R36FAN53.js";
+
+// src/lib/worker-gate.ts
+import { readdirSync, writeFileSync, unlinkSync, mkdirSync, existsSync, readFileSync } from "fs";
+import path from "path";
+import { totalmem, cpus } from "os";
+var WORKER_PID_DIR = path.join(EXE_AI_DIR, "worker-pids");
+function computeMaxWorkers() {
+  const totalGB = totalmem() / 1024 ** 3;
+  const coreCount = cpus().length;
+  const byRam = Math.floor(totalGB / 4);
+  const byCpu = Math.floor(coreCount / 2);
+  return Math.max(2, Math.min(8, Math.min(byRam, byCpu)));
+}
+var MAX_CONCURRENT_WORKERS = process.env.EXE_MAX_WORKERS ? Math.max(1, parseInt(process.env.EXE_MAX_WORKERS, 10) || 3) : computeMaxWorkers();
+function tryAcquireWorkerSlot() {
+  try {
+    mkdirSync(WORKER_PID_DIR, { recursive: true });
+    const reservationId = `res-${process.pid}-${Date.now()}`;
+    const reservationPath = path.join(WORKER_PID_DIR, `${reservationId}.pid`);
+    writeFileSync(reservationPath, String(process.pid));
+    const files = readdirSync(WORKER_PID_DIR);
+    let alive = 0;
+    for (const f of files) {
+      if (!f.endsWith(".pid")) continue;
+      if (f.startsWith("res-")) {
+        const resParts = f.replace(".pid", "").split("-");
+        const resPid = parseInt(resParts[1] ?? "", 10);
+        if (!isNaN(resPid) && resPid > 0) {
+          try {
+            process.kill(resPid, 0);
+            alive++;
+          } catch {
+            try {
+              unlinkSync(path.join(WORKER_PID_DIR, f));
+            } catch {
+            }
+          }
+        } else {
+          alive++;
+        }
+        continue;
+      }
+      const dashIdx = f.lastIndexOf("-");
+      const pid = parseInt(f.slice(dashIdx + 1).replace(".pid", ""), 10);
+      if (isNaN(pid)) continue;
+      try {
+        process.kill(pid, 0);
+        alive++;
+      } catch {
+        try {
+          unlinkSync(path.join(WORKER_PID_DIR, f));
+        } catch {
+        }
+      }
+    }
+    if (alive >= MAX_CONCURRENT_WORKERS) {
+      try {
+        unlinkSync(reservationPath);
+      } catch {
+      }
+      return false;
+    }
+    try {
+      unlinkSync(reservationPath);
+    } catch {
+    }
+    return true;
+  } catch {
+    return true;
+  }
+}
+function registerWorkerPid(pid) {
+  try {
+    mkdirSync(WORKER_PID_DIR, { recursive: true });
+    writeFileSync(path.join(WORKER_PID_DIR, `worker-${pid}.pid`), String(pid));
+  } catch {
+  }
+}
+function cleanupWorkerPid() {
+  try {
+    unlinkSync(path.join(WORKER_PID_DIR, `worker-${process.pid}.pid`));
+  } catch {
+  }
+}
+var BACKFILL_LOCK = path.join(WORKER_PID_DIR, "backfill.lock");
+function tryAcquireBackfillLock() {
+  try {
+    mkdirSync(WORKER_PID_DIR, { recursive: true });
+    if (existsSync(BACKFILL_LOCK)) {
+      try {
+        const pid = parseInt(
+          readFileSync(BACKFILL_LOCK, "utf8").trim(),
+          10
+        );
+        if (!isNaN(pid) && pid > 0) {
+          try {
+            process.kill(pid, 0);
+            return false;
+          } catch {
+          }
+        }
+      } catch {
+      }
+    }
+    writeFileSync(BACKFILL_LOCK, String(process.pid));
+    return true;
+  } catch {
+    return true;
+  }
+}
+function releaseBackfillLock() {
+  try {
+    unlinkSync(BACKFILL_LOCK);
+  } catch {
+  }
+}
+async function getTaskAwareCapacity() {
+  const { getClient } = await import("./lib/database.js");
+  const { sessionScopeFilter } = await import("./task-scope-JTTEZKDU.js");
+  const client = getClient();
+  const scope = sessionScopeFilter();
+  const result = await client.execute({
+    sql: `SELECT assigned_to, COUNT(*) as cnt
+          FROM tasks
+          WHERE status IN ('open', 'in_progress')${scope.sql}
+          GROUP BY assigned_to`,
+    args: [...scope.args]
+  });
+  const busyAgents = [];
+  let totalInProgress = 0;
+  for (const row of result.rows) {
+    const agent = String(row.assigned_to ?? "");
+    const count = Number(row.cnt ?? 0);
+    if (agent && count > 0) {
+      busyAgents.push(agent);
+      totalInProgress += count;
+    }
+  }
+  const idleAgents = [];
+  try {
+    const { listTmuxSessions } = await import("./lib/tmux-status.js");
+    const { isExeSession } = await import("./lib/tmux-routing.js");
+    const { baseAgentName } = await import("./lib/employees.js");
+    const liveSessions = listTmuxSessions().filter((s) => !isExeSession(s) && s.includes("-"));
+    const liveAgentNames = new Set(liveSessions.map((s) => baseAgentName(s.split("-")[0] ?? "")));
+    for (const name of liveAgentNames) {
+      if (name && !busyAgents.includes(name)) {
+        idleAgents.push(name);
+      }
+    }
+  } catch {
+  }
+  return { busyAgents, idleAgents, totalInProgress };
+}
+
+export {
+  MAX_CONCURRENT_WORKERS,
+  tryAcquireWorkerSlot,
+  registerWorkerPid,
+  cleanupWorkerPid,
+  tryAcquireBackfillLock,
+  releaseBackfillLock,
+  getTaskAwareCapacity
+};