@askexenow/exe-os 0.9.279 → 0.9.281

package/dist/chunk-MJ44I6HG.js

@@ -0,0 +1,244 @@
+import {
+  employeeSessionName,
+  ensureEmployee,
+  markAsReadByTaskFile,
+  notifyParentExe,
+  resolveExeSession,
+  sendIntercom
+} from "./chunk-UKVPGFD4.js";
+import {
+  getTransport
+} from "./chunk-MVW62NIZ.js";
+import {
+  recordOrchestrationEventBestEffort
+} from "./chunk-X46O77S4.js";
+import {
+  getAgentRuntime
+} from "./chunk-PMVOUPTY.js";
+import {
+  getSessionKey
+} from "./chunk-CVYC6DUW.js";
+import {
+  isCoordinatorName,
+  isMultiInstance,
+  shouldAutoInstance
+} from "./chunk-ZJP3ZONM.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-FZ7CJ2PU.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-MJ7X5IBW.js

@@ -0,0 +1,227 @@
+import {
+  getClient
+} from "./chunk-52UDAVZE.js";
+
+// src/lib/token-spend.ts
+import { readdir, stat } from "fs/promises";
+import { createReadStream } from "fs";
+import { createInterface } from "readline";
+import path from "path";
+import os from "os";
+var MODEL_PRICING = {
+  // Opus 4.5+ ($5/$25 — Anthropic price drop from original Opus 4)
+  "claude-opus-4-7": { input: 5 / 1e6, output: 25 / 1e6, cacheRead: 0.5 / 1e6, cacheWrite: 6.25 / 1e6 },
+  "claude-opus-4-6": { input: 5 / 1e6, output: 25 / 1e6, cacheRead: 0.5 / 1e6, cacheWrite: 6.25 / 1e6 },
+  "claude-opus-4-5": { input: 5 / 1e6, output: 25 / 1e6, cacheRead: 0.5 / 1e6, cacheWrite: 6.25 / 1e6 },
+  // Opus 4.0/4.1 (legacy $15/$75)
+  "claude-opus-4-1": { input: 15 / 1e6, output: 75 / 1e6, cacheRead: 1.5 / 1e6, cacheWrite: 18.75 / 1e6 },
+  "claude-opus-4": { input: 15 / 1e6, output: 75 / 1e6, cacheRead: 1.5 / 1e6, cacheWrite: 18.75 / 1e6 },
+  // Sonnet 4.x
+  "claude-sonnet-4": { input: 3 / 1e6, output: 15 / 1e6, cacheRead: 0.3 / 1e6, cacheWrite: 3.75 / 1e6 },
+  // Sonnet 3.7/3.5
+  "claude-3-7-sonnet": { input: 3 / 1e6, output: 15 / 1e6, cacheRead: 0.3 / 1e6, cacheWrite: 3.75 / 1e6 },
+  "claude-3-5-sonnet": { input: 3 / 1e6, output: 15 / 1e6, cacheRead: 0.3 / 1e6, cacheWrite: 3.75 / 1e6 },
+  // Haiku 4.5
+  "claude-haiku-4-5": { input: 1 / 1e6, output: 5 / 1e6, cacheRead: 0.1 / 1e6, cacheWrite: 1.25 / 1e6 },
+  // Haiku 3.5
+  "claude-3-5-haiku": { input: 0.8 / 1e6, output: 4 / 1e6, cacheRead: 0.08 / 1e6, cacheWrite: 1 / 1e6 },
+  // Opus 3
+  "claude-3-opus": { input: 15 / 1e6, output: 75 / 1e6, cacheRead: 1.5 / 1e6, cacheWrite: 18.75 / 1e6 },
+  // Sonnet 3
+  "claude-3-sonnet": { input: 3 / 1e6, output: 15 / 1e6, cacheRead: 0.3 / 1e6, cacheWrite: 3.75 / 1e6 },
+  // Haiku 3
+  "claude-3-haiku": { input: 0.25 / 1e6, output: 1.25 / 1e6, cacheRead: 0.03 / 1e6, cacheWrite: 0.3 / 1e6 }
+};
+var DEFAULT_PRICING = MODEL_PRICING["claude-sonnet-4"];
+var CACHE_TTL_MS = 5 * 60 * 1e3;
+var JSONL_INDEX_TTL_MS = 5 * 60 * 1e3;
+var USAGE_CACHE_MAX_ENTRIES = 1e4;
+var _spendCache = /* @__PURE__ */ new Map();
+var _spendInFlight = /* @__PURE__ */ new Map();
+var _usageCache = /* @__PURE__ */ new Map();
+var _usageInFlight = /* @__PURE__ */ new Map();
+var _jsonlPathIndex = null;
+function yieldToEventLoop() {
+  return new Promise((resolve) => setImmediate(resolve));
+}
+function getPricing(model) {
+  if (MODEL_PRICING[model]) return MODEL_PRICING[model];
+  const stripped = model.replace(/-\d{8}$/, "");
+  if (MODEL_PRICING[stripped]) return MODEL_PRICING[stripped];
+  const sortedKeys = Object.keys(MODEL_PRICING).sort((a, b) => b.length - a.length);
+  for (const key of sortedKeys) {
+    if (model.includes(key)) return MODEL_PRICING[key];
+  }
+  return DEFAULT_PRICING;
+}
+async function getAgentSpend(period = "7d") {
+  const cached = _spendCache.get(period);
+  if (cached && Date.now() < cached.expires) {
+    return cached.result;
+  }
+  const inFlight = _spendInFlight.get(period);
+  if (inFlight) return inFlight;
+  const promise = computeAgentSpend(period).finally(() => _spendInFlight.delete(period));
+  _spendInFlight.set(period, promise);
+  return promise;
+}
+async function computeAgentSpend(period) {
+  const cutoff = periodToCutoff(period);
+  const client = getClient();
+  const dbResult = await client.execute({
+    sql: `SELECT session_uuid, agent_id FROM session_agent_map WHERE started_at >= ?`,
+    args: [cutoff]
+  });
+  if (dbResult.rows.length === 0) return [];
+  const sessionAgent = /* @__PURE__ */ new Map();
+  for (const row of dbResult.rows) {
+    sessionAgent.set(row.session_uuid, row.agent_id);
+  }
+  const jsonlPaths = await getClaudeSessionJsonlIndex();
+  if (jsonlPaths.size === 0) return [];
+  const agentTotals = /* @__PURE__ */ new Map();
+  let processed = 0;
+  for (const [sessionUuid, agentId] of sessionAgent) {
+    const jsonlPath = jsonlPaths.get(sessionUuid);
+    if (!jsonlPath) continue;
+    try {
+      const usage = await extractSessionUsageCached(jsonlPath);
+      if (usage.input === 0 && usage.output === 0) continue;
+      const totals = agentTotals.get(agentId) ?? {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheCreate: 0,
+        costUSD: 0,
+        sessions: /* @__PURE__ */ new Set()
+      };
+      totals.input += usage.input;
+      totals.output += usage.output;
+      totals.cacheRead += usage.cacheRead;
+      totals.cacheCreate += usage.cacheCreate;
+      totals.costUSD += usage.costUSD;
+      totals.sessions.add(sessionUuid);
+      agentTotals.set(agentId, totals);
+    } catch {
+    }
+    processed++;
+    if (processed % 25 === 0) await yieldToEventLoop();
+  }
+  const result = Array.from(agentTotals.entries()).map(([agentId, t]) => ({
+    agentId,
+    inputTokens: t.input,
+    outputTokens: t.output,
+    cacheReadTokens: t.cacheRead,
+    cacheCreationTokens: t.cacheCreate,
+    costUSD: t.costUSD,
+    sessions: t.sessions.size,
+    period
+  })).sort((a, b) => b.costUSD - a.costUSD);
+  _spendCache.set(period, { result, expires: Date.now() + CACHE_TTL_MS });
+  return result;
+}
+async function getClaudeSessionJsonlIndex() {
+  if (_jsonlPathIndex && Date.now() < _jsonlPathIndex.expires) {
+    return _jsonlPathIndex.paths;
+  }
+  const claudeDir = path.join(os.homedir(), ".claude", "projects");
+  const paths = /* @__PURE__ */ new Map();
+  let projectDirs = [];
+  try {
+    const entries = await readdir(claudeDir, { withFileTypes: true });
+    projectDirs = entries.filter((entry) => entry.isDirectory()).map((entry) => path.join(claudeDir, entry.name));
+  } catch {
+    _jsonlPathIndex = { expires: Date.now() + JSONL_INDEX_TTL_MS, paths };
+    return paths;
+  }
+  let scanned = 0;
+  for (const dir of projectDirs) {
+    try {
+      const files = await readdir(dir);
+      for (const file of files) {
+        if (!file.endsWith(".jsonl")) continue;
+        paths.set(file.slice(0, -".jsonl".length), path.join(dir, file));
+      }
+    } catch {
+    }
+    scanned++;
+    if (scanned % 25 === 0) await yieldToEventLoop();
+  }
+  _jsonlPathIndex = { expires: Date.now() + JSONL_INDEX_TTL_MS, paths };
+  return paths;
+}
+async function extractSessionUsageCached(jsonlPath) {
+  const st = await stat(jsonlPath);
+  const cached = _usageCache.get(jsonlPath);
+  if (cached && cached.mtimeMs === st.mtimeMs && cached.size === st.size) {
+    return cached.usage;
+  }
+  const existing = _usageInFlight.get(jsonlPath);
+  if (existing) return existing;
+  const promise = extractSessionUsage(jsonlPath).then((usage) => {
+    _usageCache.set(jsonlPath, { mtimeMs: st.mtimeMs, size: st.size, usage });
+    pruneUsageCache();
+    return usage;
+  }).finally(() => _usageInFlight.delete(jsonlPath));
+  _usageInFlight.set(jsonlPath, promise);
+  return promise;
+}
+function pruneUsageCache() {
+  if (_usageCache.size <= USAGE_CACHE_MAX_ENTRIES) return;
+  const overflow = _usageCache.size - USAGE_CACHE_MAX_ENTRIES;
+  let removed = 0;
+  for (const key of _usageCache.keys()) {
+    _usageCache.delete(key);
+    removed++;
+    if (removed >= overflow) break;
+  }
+}
+async function extractSessionUsage(jsonlPath) {
+  let input = 0;
+  let output = 0;
+  let cacheRead = 0;
+  let cacheCreate = 0;
+  let costUSD = 0;
+  const seenMessageIds = /* @__PURE__ */ new Set();
+  const rl = createInterface({
+    input: createReadStream(jsonlPath, { encoding: "utf8" }),
+    crlfDelay: Infinity
+  });
+  for await (const line of rl) {
+    if (!line.includes('"type":"assistant"')) continue;
+    try {
+      const record = JSON.parse(line);
+      if (record.type !== "assistant") continue;
+      const messageId = record.message?.id;
+      if (messageId) {
+        if (seenMessageIds.has(messageId)) continue;
+        seenMessageIds.add(messageId);
+      }
+      const usage = record.message?.usage;
+      if (!usage) continue;
+      const model = record.message?.model ?? "";
+      const pricing = getPricing(model);
+      const inp = usage.input_tokens ?? 0;
+      const out = usage.output_tokens ?? 0;
+      const cr = usage.cache_read_input_tokens ?? 0;
+      const cc = usage.cache_creation_input_tokens ?? 0;
+      input += inp;
+      output += out;
+      cacheRead += cr;
+      cacheCreate += cc;
+      if (pricing) {
+        costUSD += inp * pricing.input + out * pricing.output + cr * pricing.cacheRead + cc * pricing.cacheWrite;
+      }
+    } catch {
+    }
+  }
+  return { input, output, cacheRead, cacheCreate, costUSD };
+}
+function periodToCutoff(period) {
+  const ms = { "24h": 864e5, "7d": 6048e5, "30d": 2592e6 }[period];
+  return new Date(Date.now() - ms).toISOString();
+}
+
+export {
+  getAgentSpend
+};

package/dist/chunk-MLGRWCY4.js

@@ -0,0 +1,54 @@
+import {
+  processCRMEvent
+} from "./chunk-X4VOU6BQ.js";
+
+// src/gateway/adapters/crm-webhook.ts
+function parseTwentyWebhook(payload) {
+  if (!payload || typeof payload !== "object") return null;
+  const p = payload;
+  const eventName = p.eventName;
+  if (!eventName || typeof eventName !== "string") return null;
+  const dotIndex = eventName.indexOf(".");
+  if (dotIndex === -1) return null;
+  const objectType = eventName.slice(0, dotIndex);
+  const eventType = eventName.slice(dotIndex + 1);
+  if (!objectType || !eventType) return null;
+  const normalizedObjectType = objectType.charAt(0).toUpperCase() + objectType.slice(1);
+  const record = p.record ?? {};
+  if (typeof record !== "object") return null;
+  return {
+    eventType,
+    objectType: normalizedObjectType,
+    record
+  };
+}
+function createCRMWebhookHandler(options) {
+  return async (body) => {
+    const event = parseTwentyWebhook(body);
+    if (!event) {
+      console.warn(
+        "[crm-webhook] Malformed CRM webhook payload \u2014 skipping"
+      );
+      return;
+    }
+    console.log(
+      `[crm-webhook] ${event.objectType}.${event.eventType} received`
+    );
+    try {
+      const logs = await processCRMEvent(event, options?.executor, options?.triggers);
+      if (logs.length > 0 && options?.onFired) {
+        options.onFired(logs);
+      }
+    } catch (err) {
+      console.error(
+        "[crm-webhook] Error processing CRM event:",
+        err instanceof Error ? err.message : err
+      );
+    }
+  };
+}
+
+export {
+  parseTwentyWebhook,
+  createCRMWebhookHandler
+};