@askexenow/exe-os 0.9.276 → 0.9.277

package/dist/chunk-N7BYUAHY.js

@@ -0,0 +1,244 @@
+import {
+  employeeSessionName,
+  ensureEmployee,
+  markAsReadByTaskFile,
+  notifyParentExe,
+  resolveExeSession,
+  sendIntercom
+} from "./chunk-PR4XTDPM.js";
+import {
+  getTransport
+} from "./chunk-MVW62NIZ.js";
+import {
+  recordOrchestrationEventBestEffort
+} from "./chunk-3IR6XFGW.js";
+import {
+  getAgentRuntime
+} from "./chunk-H3YWMLS4.js";
+import {
+  getSessionKey
+} from "./chunk-CVYC6DUW.js";
+import {
+  isCoordinatorName,
+  isMultiInstance,
+  shouldAutoInstance
+} from "./chunk-IATEXT4R.js";
+
+// src/lib/tasks-notify.ts
+var VERIFY_DELAY_MS = 1e4;
+var ACK_PATTERNS = [
+  /New task assigned/,
+  /START WORKING NOW/,
+  /marked in_progress/,
+  /Reading.*\.md/
+];
+function resolveDispatchRuntime(agentId, override) {
+  if (override) return override;
+  try {
+    return getAgentRuntime(agentId).runtime ?? null;
+  } catch {
+    return null;
+  }
+}
+async function verifyDispatch(sessionName, delayMs = VERIFY_DELAY_MS) {
+  const transport = getTransport();
+  await new Promise((r) => setTimeout(r, delayMs));
+  if (!transport.isAlive(sessionName)) {
+    return "session_dead";
+  }
+  try {
+    const output = transport.capturePane(sessionName, 20);
+    const acked = ACK_PATTERNS.some((p) => p.test(output));
+    return acked ? "verified" : "sent_unverified";
+  } catch {
+    return "sent_unverified";
+  }
+}
+async function dispatchTaskToEmployee(input) {
+  if (isCoordinatorName(input.assignedTo)) return { dispatched: "skipped" };
+  const dispatchRuntime = resolveDispatchRuntime(input.assignedTo, input.spawnRuntime);
+  recordOrchestrationEventBestEffort({
+    eventType: "dispatch.attempted",
+    source: "tasks-notify.dispatchTaskToEmployee",
+    taskId: input.taskId ?? null,
+    agentId: input.assignedTo,
+    runtime: dispatchRuntime,
+    payload: { priority: input.priority, projectName: input.projectName }
+  });
+  let crossProject = false;
+  if (input.projectName) {
+    try {
+      const { assertSessionScope } = await import("./session-scope-L7PN4EUN.js");
+      const check = assertSessionScope("dispatch_task", input.projectName);
+      if (check.reason === "cross_session_denied") {
+        crossProject = true;
+        recordOrchestrationEventBestEffort({
+          eventType: "dispatch.failed",
+          source: "tasks-notify.dispatchTaskToEmployee",
+          taskId: input.taskId ?? null,
+          agentId: input.assignedTo,
+          runtime: dispatchRuntime,
+          errorCode: "cross_session_denied",
+          payload: { projectName: input.projectName }
+        });
+        return { dispatched: "skipped", crossProject: true };
+      }
+    } catch {
+    }
+  }
+  try {
+    const transport = getTransport();
+    const exeSession = resolveExeSession();
+    if (!exeSession) {
+      recordOrchestrationEventBestEffort({
+        eventType: "dispatch.failed",
+        source: "tasks-notify.dispatchTaskToEmployee",
+        taskId: input.taskId ?? null,
+        agentId: input.assignedTo,
+        runtime: dispatchRuntime,
+        errorCode: "no_exe_session"
+      });
+      return { dispatched: "session_missing" };
+    }
+    const multiInstance = isMultiInstance(input.assignedTo);
+    if (multiInstance) {
+      const projectDir = input.projectDir ?? process.cwd();
+      const autoOpts = shouldAutoInstance(input.assignedTo);
+      const result = ensureEmployee(input.assignedTo, exeSession, projectDir, {
+        ...autoOpts,
+        runtimeOverride: input.spawnRuntime,
+        modelOverride: input.spawnModel
+      });
+      if (result.status === "failed") {
+        process.stderr.write(
+          `[dispatch-audit] SPAWN FAILED \u2192 ${input.assignedTo} | task="${input.title}" [${input.priority}] | error=${result.error}
+`
+        );
+        recordOrchestrationEventBestEffort({
+          eventType: "dispatch.failed",
+          source: "tasks-notify.dispatchTaskToEmployee",
+          taskId: input.taskId ?? null,
+          agentId: input.assignedTo,
+          sessionScope: exeSession,
+          runtime: dispatchRuntime,
+          errorCode: "spawn_failed",
+          payload: { path: "multi_instance", error: result.error }
+        });
+        return { dispatched: "session_missing" };
+      }
+      const dispatched = result.status === "intercom_sent" || result.status === "intercom_unprocessed" ? "sent_unverified" : "spawned";
+      process.stderr.write(
+        `[dispatch-audit] ${dispatched === "spawned" ? "SPAWNED" : "INTERCOM"} \u2192 ${result.sessionName} | task="${input.title}" [${input.priority}]
+`
+      );
+      recordOrchestrationEventBestEffort({
+        eventType: "dispatch.completed",
+        source: "tasks-notify.dispatchTaskToEmployee",
+        taskId: input.taskId ?? null,
+        agentId: input.assignedTo,
+        sessionScope: exeSession,
+        tmuxSession: result.sessionName,
+        runtime: dispatchRuntime,
+        result: dispatched,
+        payload: { path: "multi_instance", priority: input.priority }
+      });
+      return { dispatched, session: result.sessionName, crossProject };
+    }
+    const sessionName = employeeSessionName(input.assignedTo, exeSession);
+    if (transport.isAlive(sessionName)) {
+      const result = sendIntercom(sessionName, { force: true });
+      const dispatched = result === "acknowledged" || result === "debounced" || result === "queued" ? "verified" : result === "delivered" ? "sent_unverified" : "session_dead";
+      process.stderr.write(
+        `[dispatch-audit] intercom \u2192 ${sessionName} | task="${input.title}" [${input.priority}] | result=${dispatched} (sendIntercom=${result})
+`
+      );
+      recordOrchestrationEventBestEffort({
+        eventType: "dispatch.completed",
+        source: "tasks-notify.dispatchTaskToEmployee",
+        taskId: input.taskId ?? null,
+        agentId: input.assignedTo,
+        sessionScope: exeSession,
+        tmuxSession: sessionName,
+        runtime: dispatchRuntime,
+        result: dispatched,
+        payload: { path: "single_instance_intercom", priority: input.priority }
+      });
+      return { dispatched, session: sessionName, crossProject };
+    } else {
+      const projectDir = input.projectDir ?? process.cwd();
+      const result = ensureEmployee(input.assignedTo, exeSession, projectDir, {
+        runtimeOverride: input.spawnRuntime,
+        modelOverride: input.spawnModel
+      });
+      if (result.status === "failed") {
+        process.stderr.write(
+          `[dispatch-audit] SPAWN FAILED \u2192 ${input.assignedTo} | task="${input.title}" [${input.priority}] | error=${result.error}
+`
+        );
+        recordOrchestrationEventBestEffort({
+          eventType: "dispatch.failed",
+          source: "tasks-notify.dispatchTaskToEmployee",
+          taskId: input.taskId ?? null,
+          agentId: input.assignedTo,
+          sessionScope: exeSession,
+          runtime: dispatchRuntime,
+          errorCode: "spawn_failed",
+          payload: { path: "single_instance_spawn", error: result.error }
+        });
+        return { dispatched: "session_missing" };
+      }
+      process.stderr.write(
+        `[dispatch-audit] SPAWNED \u2192 ${result.sessionName} | task="${input.title}" [${input.priority}]
+`
+      );
+      recordOrchestrationEventBestEffort({
+        eventType: "dispatch.completed",
+        source: "tasks-notify.dispatchTaskToEmployee",
+        taskId: input.taskId ?? null,
+        agentId: input.assignedTo,
+        sessionScope: exeSession,
+        tmuxSession: result.sessionName,
+        runtime: dispatchRuntime,
+        result: "spawned",
+        payload: { path: "single_instance_spawn", priority: input.priority }
+      });
+      return { dispatched: "spawned", session: result.sessionName, crossProject };
+    }
+  } catch {
+    recordOrchestrationEventBestEffort({
+      eventType: "dispatch.failed",
+      source: "tasks-notify.dispatchTaskToEmployee",
+      taskId: input.taskId ?? null,
+      agentId: input.assignedTo,
+      runtime: dispatchRuntime,
+      errorCode: "exception"
+    });
+    return { dispatched: "session_missing" };
+  }
+}
+function notifyTaskDone() {
+  try {
+    const key = getSessionKey();
+    if (key && !process.env.VITEST) {
+      notifyParentExe(key);
+      process.stderr.write(
+        `[dispatch-audit] notifyTaskDone \u2192 parent coordinator (session=${key})
+`
+      );
+    }
+  } catch {
+  }
+}
+async function markTaskNotificationsRead(taskFile) {
+  try {
+    await markAsReadByTaskFile(taskFile);
+  } catch {
+  }
+}
+
+export {
+  verifyDispatch,
+  dispatchTaskToEmployee,
+  notifyTaskDone,
+  markTaskNotificationsRead
+};

package/dist/chunk-NBGJVFQQ.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-FZLU4U2I.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-NDUKYBVA.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
+};