@agenticmail/claudecode 0.1.6 → 0.1.7

package/dist/{chunk-5M43V6CB.js → chunk-3ZBSRXAK.js}

@@ -59,7 +59,7 @@ function rememberBounded(set, item) {
   }
 }
 var DEFAULT_MAX_CONCURRENT = 10;
-var DEFAULT_SYNC_INTERVAL_MS = 5e3;
+var DEFAULT_SYNC_INTERVAL_MS = 3e4;
 var DEFAULT_RECONNECT_BASE_MS = 2e3;
 var DEFAULT_RECONNECT_MAX_MS = 6e4;
 var TASK_MAIL_SUPPRESS_WINDOW_MS = 3e4;
@@ -229,6 +229,7 @@ var Dispatcher = class {
   channels = /* @__PURE__ */ new Map();
   // keyed by account.id
   accountSyncTimer = null;
+  systemChannelController = null;
   running = 0;
   waiters = [];
   stopped = false;
@@ -251,11 +252,19 @@ var Dispatcher = class {
     this.accountSyncTimer = setInterval(() => {
       this.syncAccounts().catch((err) => this.log("warn", `[dispatcher] account sync failed: ${err}`));
     }, this.syncIntervalMs);
+    void this.runSystemChannel();
   }
   async stop() {
     this.stopped = true;
     if (this.accountSyncTimer) clearInterval(this.accountSyncTimer);
     this.accountSyncTimer = null;
+    if (this.systemChannelController) {
+      try {
+        this.systemChannelController.abort();
+      } catch {
+      }
+      this.systemChannelController = null;
+    }
     for (const ch of this.channels.values()) {
       ch.stopping = true;
       ch.controller?.abort();
@@ -352,6 +361,118 @@ var Dispatcher = class {
       void this.runChannel(ch);
     }
   }
+  /**
+   * Subscribe to the API's master-scoped system events SSE.
+   *
+   * Pushes from /system/events arrive as JSON-per-frame just like the
+   * per-account stream:
+   *   { type: "connected" }
+   *   { type: "account_created", account: { id, name, email, apiKey, ... } }
+   *   { type: "account_deleted", accountId, name }
+   *
+   * On `account_created` we eagerly open a per-account SSE channel using
+   * the apiKey carried in the event payload — no extra round trip, the
+   * channel is live within milliseconds of the POST /accounts response.
+   *
+   * Reconnect with the same exponential backoff scheme as per-account
+   * channels. If the API is older and doesn't expose /system/events
+   * (404), we log once and stop trying — polling-only fallback still
+   * works.
+   */
+  async runSystemChannel() {
+    let backoff = this.reconnectBaseMs;
+    let giveUp = false;
+    while (!this.stopped && !giveUp) {
+      this.systemChannelController = new AbortController();
+      try {
+        const url = `${this.cfg.apiUrl.replace(/\/$/, "")}/api/agenticmail/system/events`;
+        const res = await this.fetchImpl(url, {
+          headers: {
+            "Authorization": `Bearer ${this.cfg.masterKey}`,
+            "Accept": "text/event-stream"
+          },
+          signal: this.systemChannelController.signal
+        });
+        if (res.status === 404) {
+          this.log("warn", "[dispatcher] /system/events not available on this API \u2014 falling back to polling-only account discovery (please upgrade @agenticmail/api to >=0.7.3)");
+          giveUp = true;
+          break;
+        }
+        if (!res.ok || !res.body) {
+          throw new Error(`system/events HTTP ${res.status}`);
+        }
+        backoff = this.reconnectBaseMs;
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        while (!this.stopped) {
+          const { value, done } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          let boundary;
+          while ((boundary = buffer.indexOf("\n\n")) !== -1) {
+            const frame = buffer.slice(0, boundary);
+            buffer = buffer.slice(boundary + 2);
+            for (const line of frame.split("\n")) {
+              if (!line.startsWith("data: ")) continue;
+              try {
+                const event = JSON.parse(line.slice(6));
+                this.handleSystemEvent(event);
+              } catch {
+              }
+            }
+          }
+        }
+      } catch (err) {
+        if (this.stopped) break;
+        this.log("warn", `[dispatcher] system-events stream error: ${err.message}; reconnecting in ${backoff}ms`);
+      }
+      if (this.stopped || giveUp) break;
+      await sleep(backoff);
+      backoff = Math.min(backoff * 2, this.reconnectMaxMs);
+    }
+  }
+  /** Apply an account-lifecycle event from /system/events. */
+  handleSystemEvent(event) {
+    const type = typeof event.type === "string" ? event.type : "";
+    if (type === "account_created" && event.account && typeof event.account === "object") {
+      const account = event.account;
+      if (!account.id || !account.name || !account.apiKey) {
+        this.log("warn", "[dispatcher] account_created event missing required fields; ignoring");
+        return;
+      }
+      if (!this.shouldWatch(account)) {
+        this.log("info", `[dispatcher] account_created "${account.name}" \u2014 skipping (bridge/role excluded)`);
+        return;
+      }
+      if (this.channels.has(account.id)) return;
+      const ch = {
+        account,
+        controller: null,
+        stopping: false,
+        backoffMs: this.reconnectBaseMs,
+        seenUids: /* @__PURE__ */ new Set(),
+        seenTaskIds: /* @__PURE__ */ new Set(),
+        suppressTaskMailUntilMs: 0
+      };
+      this.channels.set(account.id, ch);
+      this.log("info", `[dispatcher] account_created "${account.name}" (${account.email}) \u2014 opening SSE channel immediately`);
+      void this.runChannel(ch);
+      return;
+    }
+    if (type === "account_deleted" && typeof event.accountId === "string") {
+      const ch = this.channels.get(event.accountId);
+      if (!ch) return;
+      ch.stopping = true;
+      try {
+        ch.controller?.abort();
+      } catch {
+      }
+      this.channels.delete(event.accountId);
+      this.log("info", `[dispatcher] account_deleted "${ch.account.name}" \u2014 closed SSE channel`);
+      return;
+    }
+  }
   /** Watch one account's SSE stream forever; reconnect with backoff on drop. */
   async runChannel(ch) {
     while (!ch.stopping && !this.stopped) {

package/dist/dispatcher-bin.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   Dispatcher
-} from "./chunk-5M43V6CB.js";
+} from "./chunk-3ZBSRXAK.js";
 import "./chunk-YWSO3QOQ.js";
 
 // src/dispatcher-bin.ts

package/dist/dispatcher.d.ts

@@ -103,6 +103,7 @@ declare class Dispatcher {
     private log;
     private channels;
     private accountSyncTimer;
+    private systemChannelController;
     private running;
     private waiters;
     private stopped;
@@ -131,6 +132,27 @@ declare class Dispatcher {
     private shouldWatch;
     /** Re-fetch /accounts; open SSE for new ones, close for vanished ones. */
     private syncAccounts;
+    /**
+     * Subscribe to the API's master-scoped system events SSE.
+     *
+     * Pushes from /system/events arrive as JSON-per-frame just like the
+     * per-account stream:
+     *   { type: "connected" }
+     *   { type: "account_created", account: { id, name, email, apiKey, ... } }
+     *   { type: "account_deleted", accountId, name }
+     *
+     * On `account_created` we eagerly open a per-account SSE channel using
+     * the apiKey carried in the event payload — no extra round trip, the
+     * channel is live within milliseconds of the POST /accounts response.
+     *
+     * Reconnect with the same exponential backoff scheme as per-account
+     * channels. If the API is older and doesn't expose /system/events
+     * (404), we log once and stop trying — polling-only fallback still
+     * works.
+     */
+    private runSystemChannel;
+    /** Apply an account-lifecycle event from /system/events. */
+    private handleSystemEvent;
     /** Watch one account's SSE stream forever; reconnect with backoff on drop. */
     private runChannel;
     /** Single SSE attach. Returns when the stream closes for any reason. */

package/dist/dispatcher.js

@@ -1,6 +1,6 @@
 import {
   Dispatcher
-} from "./chunk-5M43V6CB.js";
+} from "./chunk-3ZBSRXAK.js";
 import "./chunk-YWSO3QOQ.js";
 export {
   Dispatcher

package/dist/index.js

@@ -1,7 +1,7 @@
 import {
   Dispatcher,
   loadPersonaForAgent
-} from "./chunk-5M43V6CB.js";
+} from "./chunk-3ZBSRXAK.js";
 import {
   createIntegrationRoutes
 } from "./chunk-N43A7EQB.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agenticmail/claudecode",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "Claude Code integration for AgenticMail — surfaces every AgenticMail agent as a native Claude Code subagent so any Claude Code session can delegate to them with the Agent tool",
   "type": "module",
   "main": "dist/index.js",