@trops/dash-core 0.1.627 → 0.1.629

package/dist/electron/index.js

@@ -73814,11 +73814,25 @@ function validateBotDefinition$1(def) {
   if (!WHILE_PAUSED.has(def.whilePaused)) {
     errors.push(`whilePaused must be one of ${[...WHILE_PAUSED].join(", ")}`);
   }
-  for (const field of ["mcpServers", "allowedTools", "schedules"]) {
-    if (!Array.isArray(def[field])) {
+  for (const field of [
+    "mcpServers",
+    "allowedTools",
+    "schedules",
+    "subscriptions",
+  ]) {
+    if (def[field] !== undefined && !Array.isArray(def[field])) {
       errors.push(`${field} must be an array`);
     }
   }
+  // Each subscription must name an eventType (PRD FR-009).
+  if (Array.isArray(def.subscriptions)) {
+    for (const sub of def.subscriptions) {
+      if (!sub || typeof sub.eventType !== "string" || !sub.eventType.trim()) {
+        errors.push("each subscription must have a non-empty eventType");
+        break;
+      }
+    }
+  }
   return { valid: errors.length === 0, errors };
 }
 
@@ -75740,6 +75754,92 @@ function handleMemoryTool$1(memory, ctx, toolName, args = {}) {
 
 var memoryTools = { MEMORY_SERVER: MEMORY_SERVER$1, MEMORY_TOOLS: MEMORY_TOOLS$1, handleMemoryTool: handleMemoryTool$1 };
 
+/**
+ * eventMatcher.js
+ *
+ * Given a fired event and the set of bots, returns the bots that subscribe to
+ * it (PRD FR-009 / US-010). A bot subscribes via `subscriptions: [{ eventType }]`.
+ *
+ * Workspace scoping is designed in but not yet exercised: when an event carries
+ * a `workspaceId`, a bot only matches if it's unscoped (`workspaceId` falsy) or
+ * its `workspaceId` equals the event's. Events aren't stamped with a workspace
+ * yet (a follow-up slice), so today every subscribed bot matches — but the
+ * scoping "just works" once stamping lands, with no matcher change.
+ *
+ * Pure (NFR-006): no Electron, no I/O.
+ */
+
+/**
+ * @param {Array<object>} bots  bot definitions (each may have `subscriptions`)
+ * @param {{ eventType: string, workspaceId?: string }} event
+ * @param {{ excludeBotId?: string }} [opts]  loop guard — never match this bot
+ * @returns {Array<object>} the subscribing bots
+ */
+function matchSubscribedBots$1(bots, event, opts = {}) {
+  if (!Array.isArray(bots) || !event || !event.eventType) return [];
+  const excludeBotId = opts.excludeBotId || null;
+  const eventWorkspace = event.workspaceId || null;
+
+  return bots.filter((bot) => {
+    if (!bot || bot.id === excludeBotId) return false;
+    const subs = Array.isArray(bot.subscriptions) ? bot.subscriptions : [];
+    const subscribed = subs.some((s) => s && s.eventType === event.eventType);
+    if (!subscribed) return false;
+
+    // Workspace scoping (forward-compatible): only enforced once events carry a
+    // workspaceId. An unscoped bot (no workspaceId) listens everywhere.
+    if (eventWorkspace && bot.workspaceId) {
+      return bot.workspaceId === eventWorkspace;
+    }
+    return true;
+  });
+}
+
+var eventMatcher = { matchSubscribedBots: matchSubscribedBots$1 };
+
+/**
+ * EventDispatcher.js
+ *
+ * Rate guard for event-triggered bot runs (PRD FR-009): a chatty event must not
+ * spawn a flood of runs. Enforces a per-bot cooldown — a given bot won't be
+ * event-triggered more often than once per `cooldownMs`. The dispatch decision
+ * (pause, already-running) lives in botController; this owns only the timing.
+ *
+ * Pure (NFR-006): the clock is injected, so it's deterministic under test and
+ * Electron-free.
+ */
+
+const DEFAULT_COOLDOWN_MS = 10_000;
+
+let EventDispatcher$1 = class EventDispatcher {
+  /**
+   * @param {{ cooldownMs?: number, clock?: { nowMs: () => number } }} [opts]
+   */
+  constructor(opts = {}) {
+    this._cooldownMs =
+      typeof opts.cooldownMs === "number"
+        ? opts.cooldownMs
+        : DEFAULT_COOLDOWN_MS;
+    this._nowMs = (opts.clock && opts.clock.nowMs) || (() => Date.now());
+    /** @type {Map<string, number>} botId → last dispatch time (ms) */
+    this._last = new Map();
+  }
+
+  /** @returns {boolean} true if the bot is allowed to run for an event now. */
+  shouldDispatch(botId) {
+    const last = this._last.get(botId);
+    if (last === undefined) return true;
+    return this._nowMs() - last >= this._cooldownMs;
+  }
+
+  /** Record that the bot was just event-dispatched (starts its cooldown). */
+  note(botId) {
+    this._last.set(botId, this._nowMs());
+  }
+};
+
+var EventDispatcher_1 = { EventDispatcher: EventDispatcher$1, DEFAULT_COOLDOWN_MS };
+
 /**
  * mcpResult.js
  *
@@ -75812,6 +75912,8 @@ const {
   MEMORY_TOOLS,
   handleMemoryTool,
 } = memoryTools;
+const { matchSubscribedBots } = eventMatcher;
+const { EventDispatcher } = EventDispatcher_1;
 const { normalizeMcpResult } = mcpResult;
 const {
   getProvider: getProvider$1,
@@ -75833,6 +75935,25 @@ function pricingFor(providerId, model) {
   return (m && m.pricing) || null;
 }
 
+/** Build the run prompt for an event-triggered bot (P1: FR-009). */
+function composeEventPrompt(event) {
+  let payload;
+  try {
+    payload =
+      event.content === undefined
+        ? "(no payload)"
+        : JSON.stringify(event.content);
+  } catch (_e) {
+    payload = "(unserializable payload)";
+  }
+  return (
+    `An event you subscribe to just fired.\n\n` +
+    `Event: ${event.eventType}\n` +
+    `Payload: ${payload}\n\n` +
+    `Follow your instructions to handle it.`
+  );
+}
+
 const botController$1 = {
   _ready: false,
 
@@ -75892,6 +76013,10 @@ const botController$1 = {
     // tools that every bot can use without a consent prompt.
     this._memory = new BotMemory({ persistence: host.memoryPersistence });
 
+    // Event-bus bridge (P1: FR-009): per-bot cooldown so a chatty event can't
+    // flood the runner with event-triggered runs.
+    this._dispatcher = new EventDispatcher();
+
     this._runner = new BotRunner({
       engines,
       store: this._store,
@@ -75947,6 +76072,30 @@ const botController$1 = {
     }
   },
 
+  /**
+   * Dispatch a fired event to every subscribed bot (P1: FR-009 / US-010).
+   * Called by dash-electron's widget-event relay tap. Guards: never re-trigger
+   * the origin bot (loop safety), skip paused bots and bots in cooldown; a bot
+   * already running is skipped by the runner itself.
+   * @param {{ eventType: string, content?: any, workspaceId?: string,
+   *           originBotId?: string }} event
+   */
+  handleEvent(event) {
+    if (!this._ready || !event || !event.eventType) return;
+    const bots = matchSubscribedBots(this._store.list(), event, {
+      excludeBotId: event.originBotId,
+    });
+    for (const bot of bots) {
+      if (this._pause.isPaused(bot.id)) continue;
+      if (!this._dispatcher.shouldDispatch(bot.id)) continue;
+      this._dispatcher.note(bot.id);
+      this._run(bot.id, {
+        prompt: composeEventPrompt(event),
+        trigger: "event",
+      });
+    }
+  },
+
   // ---- IPC-facing operations ---------------------------------------------
 
   list() {