@askexenow/exe-os 0.9.280 → 0.9.281

package/dist/chunk-4WWECNAY.js

@@ -0,0 +1,50 @@
+import {
+  sendMessage
+} from "./chunk-SY2B74KL.js";
+import {
+  getActiveAgent
+} from "./chunk-MYA2X5OY.js";
+
+// src/mcp/tools/send-message.ts
+import { z } from "zod";
+function registerSendMessage(server) {
+  server.registerTool(
+    "send_message",
+    {
+      title: "Send Message",
+      description: "Send a structured message to another agent. Messages are queued and delivered via intercom. NOTE: messages are fire-and-forget \u2014 do NOT use for actionable work dispatch. Use create_task instead to assign work to employees.",
+      inputSchema: {
+        target_agent: z.string().describe("Recipient agent name"),
+        content: z.string().describe("Message content"),
+        target_project: z.string().optional().describe("Project context (optional)"),
+        priority: z.enum(["normal", "urgent"]).default("normal").describe("Message priority (default: normal)"),
+        target_device: z.string().optional().describe("Target device ID for cross-machine delivery (default: local)")
+      }
+    },
+    async ({ target_agent, content, target_project, priority, target_device }) => {
+      const { agentId } = getActiveAgent();
+      const msg = await sendMessage({
+        fromAgent: agentId,
+        targetAgent: target_agent,
+        targetProject: target_project,
+        targetDevice: target_device,
+        content,
+        priority
+      });
+      const statusText = msg.status === "delivered" ? "delivered" : msg.status === "failed" ? `failed: ${msg.failureReason}` : "queued (pending delivery)";
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Message sent to ${target_agent}: ${statusText}
+ID: ${msg.id}`
+          }
+        ]
+      };
+    }
+  );
+}
+
+export {
+  registerSendMessage
+};

package/dist/chunk-4ZJDDR6L.js

@@ -0,0 +1,171 @@
+import {
+  writeMemoryViaDaemon
+} from "./chunk-U76CXW3D.js";
+
+// src/lib/auto-checkpoint.ts
+var FILE_RE = /(?:^|\s)([\w./-]+\.(?:ts|tsx|js|jsx|json|md|yml|yaml|sql|go|py|css|scss|html|sh))(?:\b|$)/g;
+var DECISION_RE = /\b(decision:|decided:|we decided|founder directive|captured in .*architecture|source of truth)\b/i;
+function asString(value, fallback = "") {
+  if (value == null) return fallback;
+  return String(value);
+}
+function compactLine(text, max = 220) {
+  return text.replace(/\s+/g, " ").trim().slice(0, max);
+}
+function topEntries(counts, limit) {
+  return [...counts.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, limit).map(([name, count]) => `${name}(${count})`);
+}
+function buildAutoCheckpoint(input) {
+  const maxSamples = input.maxSamples ?? 8;
+  const projectCounts = /* @__PURE__ */ new Map();
+  const toolCounts = /* @__PURE__ */ new Map();
+  const files = /* @__PURE__ */ new Set();
+  const errors = [];
+  const samples = [];
+  const decisionTexts = [];
+  for (const row of input.memories) {
+    const tool = asString(row.tool_name, "unknown");
+    const project = asString(row.project_name, input.projectName || "unknown");
+    const raw = asString(row.raw_text);
+    const hasError = row.has_error === 1 || row.has_error === true;
+    toolCounts.set(tool, (toolCounts.get(tool) ?? 0) + 1);
+    projectCounts.set(project, (projectCounts.get(project) ?? 0) + 1);
+    if (hasError && errors.length < 5) errors.push(compactLine(raw, 180));
+    if (samples.length < maxSamples && raw.length > 30) {
+      samples.push(`[${tool}] ${compactLine(raw)}`);
+    }
+    if (DECISION_RE.test(raw) && decisionTexts.length < 5) {
+      decisionTexts.push(`AUTO DECISION CANDIDATE [${input.agentId}]: ${compactLine(raw, 500)}`);
+    }
+    for (const match of raw.matchAll(FILE_RE)) {
+      if (match[1]) files.add(match[1]);
+      if (files.size >= 20) break;
+    }
+  }
+  const taskLines = (input.tasks ?? []).slice(0, 10).map((task) => {
+    const status = asString(task.status, "unknown");
+    const priority = asString(task.priority, "?").toUpperCase();
+    const title = asString(task.title, "untitled");
+    const taskFile = asString(task.task_file);
+    return `- [${status}/${priority}] ${title}${taskFile ? ` (${taskFile})` : ""}`;
+  });
+  const parts = [
+    `CONTEXT CHECKPOINT [auto:${input.reason}]`,
+    `Agent: ${input.agentId} (${input.agentRole})`,
+    `Session: ${input.sessionId}`,
+    `Project: ${input.projectName}`,
+    `Time: ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    "",
+    "## Recent Activity",
+    `- Memories scanned: ${input.memories.length}`,
+    `- Projects: ${topEntries(projectCounts, 5).join(", ") || input.projectName}`,
+    `- Tools: ${topEntries(toolCounts, 8).join(", ") || "none"}`
+  ];
+  if (taskLines.length > 0) {
+    parts.push("", "## Open / Active Tasks", ...taskLines);
+  }
+  if (files.size > 0) {
+    parts.push("", "## Files Mentioned", ...[...files].slice(0, 20).map((f) => `- ${f}`));
+  }
+  if (samples.length > 0) {
+    parts.push("", "## Important Recent Traces", ...samples.map((s) => `- ${s}`));
+  }
+  if (errors.length > 0) {
+    parts.push("", "## Errors / Risks", ...errors.map((e) => `- ${e}`));
+  }
+  if (decisionTexts.length > 0) {
+    parts.push("", "## Decision Candidates", ...decisionTexts.map((d) => `- ${d.replace(/^AUTO DECISION CANDIDATE \\[[^\\]]+\\]: /, "")}`));
+  }
+  return {
+    checkpointText: parts.join("\n"),
+    decisionTexts
+  };
+}
+
+// src/lib/checkpoint-orchestrator.ts
+function toolNameForReason(reason) {
+  switch (reason) {
+    case "periodic":
+      return "auto-summary";
+    case "session-end":
+      return "SessionEnd";
+    case "pre-compact":
+      return "pre-compact-hook";
+    case "capacity-signal":
+      return "auto-checkpoint";
+  }
+}
+function importanceForReason(reason, override) {
+  if (override !== void 0) return override;
+  switch (reason) {
+    case "periodic":
+      return 7;
+    case "session-end":
+    case "pre-compact":
+    case "capacity-signal":
+      return 8;
+  }
+}
+function buildContinuityCheckpoint(input) {
+  const { checkpointText, decisionTexts } = buildAutoCheckpoint({
+    agentId: input.agentId,
+    agentRole: input.agentRole,
+    sessionId: input.sessionId,
+    projectName: input.projectName,
+    reason: input.reason,
+    memories: input.memories ?? [],
+    tasks: input.tasks ?? [],
+    maxSamples: input.maxSamples
+  });
+  const extra = input.extraSections?.filter((section) => section.trim().length > 0) ?? [];
+  return {
+    checkpointText: extra.length > 0 ? `${checkpointText}
+
+${extra.join("\n\n")}` : checkpointText,
+    decisionTexts
+  };
+}
+async function writeContinuityCheckpoint(input) {
+  const result = buildContinuityCheckpoint(input);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  await writeMemoryViaDaemon({
+    raw_text: result.checkpointText,
+    agent_id: input.agentId,
+    agent_role: input.agentRole,
+    session_id: input.sessionId,
+    tool_name: toolNameForReason(input.reason),
+    project_name: input.projectName,
+    timestamp: now,
+    importance: importanceForReason(input.reason, input.importance),
+    task_id: input.taskId,
+    memory_type: "checkpoint"
+  });
+  const decisionLimit = input.reason === "periodic" ? 3 : 5;
+  for (const decisionText of result.decisionTexts.slice(0, decisionLimit)) {
+    await writeMemoryViaDaemon({
+      raw_text: decisionText,
+      agent_id: input.agentId,
+      agent_role: input.agentRole,
+      session_id: input.sessionId,
+      tool_name: "auto-decision",
+      project_name: input.projectName,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      importance: 8,
+      memory_type: "decision"
+    });
+  }
+  return result;
+}
+async function checkpointActiveTask(input) {
+  const { writeCheckpoint } = await import("./lib/tasks.js");
+  await writeCheckpoint({
+    taskId: input.taskId,
+    step: input.step ?? "pre-compaction-checkpoint",
+    contextSummary: `Auto-checkpoint before context compaction. Task: ${input.taskTitle}. Session: ${input.sessionId}. Project: ${input.projectName}.`
+  });
+}
+
+export {
+  writeContinuityCheckpoint,
+  checkpointActiveTask
+};

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