@pingagent/sdk 0.1.0

package/src/ws-subscription.ts

@@ -0,0 +1,198 @@
+/**
+ * WebSocket subscription for real-time inbox messages.
+ * Connects to Gateway /v1/ws per conversation and receives ws_message pushes.
+ */
+
+import WebSocket from 'ws';
+import type { ConversationEntry } from './client.js';
+
+export interface WsControlPayload {
+  action: string;
+  target?: string;
+}
+
+export interface WsSubscriptionOptions {
+  serverUrl: string;
+  getAccessToken: () => string | Promise<string>;
+  myDid: string;
+  listConversations: () => Promise<ConversationEntry[]>;
+  onMessage: (envelope: any, conversationId: string) => void;
+  onControl?: (control: WsControlPayload, conversationId: string) => void;
+  onError?: (err: Error) => void;
+}
+
+const RECONNECT_BASE_MS = 1000;
+const RECONNECT_MAX_MS = 30_000;
+const RECONNECT_JITTER = 0.2;
+const LIST_CONVERSATIONS_INTERVAL_MS = 60_000;
+
+export class WsSubscription {
+  private opts: WsSubscriptionOptions;
+  private connections = new Map<string, WebSocket>();
+  private reconnectTimers = new Map<string, ReturnType<typeof setTimeout>>();
+  private reconnectAttempts = new Map<string, number>();
+  private listInterval: ReturnType<typeof setInterval> | null = null;
+  private stopped = false;
+  /** Conversation IDs that were explicitly stopped (e.g. revoke); do not reconnect. */
+  private stoppedConversations = new Set<string>();
+
+  constructor(opts: WsSubscriptionOptions) {
+    this.opts = opts;
+  }
+
+  start(): void {
+    this.stopped = false;
+    this.connectAll();
+    this.listInterval = setInterval(() => this.syncConnections(), LIST_CONVERSATIONS_INTERVAL_MS);
+  }
+
+  stop(): void {
+    this.stopped = true;
+    if (this.listInterval) {
+      clearInterval(this.listInterval);
+      this.listInterval = null;
+    }
+    for (const timer of this.reconnectTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.reconnectTimers.clear();
+    for (const [convId, ws] of this.connections) {
+      ws.removeAllListeners();
+      if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) {
+        ws.close();
+      }
+      this.connections.delete(convId);
+    }
+    this.reconnectAttempts.clear();
+    this.stoppedConversations.clear();
+  }
+
+  /**
+   * Stop a single conversation's WebSocket and do not reconnect.
+   * Used when the conversation is revoked or the client no longer wants to subscribe.
+   */
+  stopConversation(conversationId: string): void {
+    this.stoppedConversations.add(conversationId);
+    const timer = this.reconnectTimers.get(conversationId);
+    if (timer) {
+      clearTimeout(timer);
+      this.reconnectTimers.delete(conversationId);
+    }
+    const ws = this.connections.get(conversationId);
+    if (ws) {
+      ws.removeAllListeners();
+      if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) {
+        ws.close();
+      }
+      this.connections.delete(conversationId);
+    }
+  }
+
+  private wsUrl(conversationId: string): string {
+    const base = this.opts.serverUrl.replace(/^http/, 'ws').replace(/\/$/, '');
+    return `${base}/v1/ws?conversation_id=${encodeURIComponent(conversationId)}`;
+  }
+
+  private async connectAsync(conversationId: string): Promise<void> {
+    if (this.stopped || this.stoppedConversations.has(conversationId) || this.connections.has(conversationId)) return;
+
+    const token = await Promise.resolve(this.opts.getAccessToken());
+    const url = this.wsUrl(conversationId);
+    const ws = new WebSocket(url, {
+      headers: { Authorization: `Bearer ${token}` },
+    });
+
+    this.connections.set(conversationId, ws);
+
+    ws.on('open', () => {
+      this.reconnectAttempts.set(conversationId, 0);
+      // ws_connected will arrive as first message
+    });
+
+    ws.on('message', (data: Buffer | string) => {
+      try {
+        const msg = JSON.parse(data.toString());
+        if (msg.type === 'ws_message' && msg.envelope) {
+          const env = msg.envelope;
+          if (env.sender_did !== this.opts.myDid) {
+            this.opts.onMessage(env, conversationId);
+          }
+        } else if (msg.type === 'ws_control' && msg.control) {
+          this.opts.onControl?.(msg.control, conversationId);
+        }
+      } catch {
+        // ignore parse errors
+      }
+    });
+
+    ws.on('close', () => {
+      this.connections.delete(conversationId);
+      if (!this.stopped && !this.stoppedConversations.has(conversationId)) {
+        this.scheduleReconnect(conversationId);
+      }
+    });
+
+    ws.on('error', (err) => {
+      this.opts.onError?.(err);
+    });
+  }
+
+  private scheduleReconnect(conversationId: string): void {
+    if (this.reconnectTimers.has(conversationId)) return;
+
+    const attempt = this.reconnectAttempts.get(conversationId) ?? 0;
+    this.reconnectAttempts.set(conversationId, attempt + 1);
+
+    const tryConnect = () => {
+      this.reconnectTimers.delete(conversationId);
+      if (this.stopped) return;
+      void this.connectAsync(conversationId);
+    };
+
+    const delay = Math.min(
+      RECONNECT_BASE_MS * Math.pow(2, attempt) + (Math.random() - 0.5) * RECONNECT_JITTER * RECONNECT_BASE_MS,
+      RECONNECT_MAX_MS,
+    );
+    const timer = setTimeout(tryConnect, delay);
+    this.reconnectTimers.set(conversationId, timer);
+  }
+
+  private async connectAll(): Promise<void> {
+    try {
+      const convos = await this.opts.listConversations();
+      const subscribable = convos.filter((c) => c.type === 'dm' || c.type === 'channel');
+      for (const c of subscribable) {
+        void this.connectAsync(c.conversation_id);
+      }
+    } catch (err) {
+      this.opts.onError?.(err instanceof Error ? err : new Error(String(err)));
+    }
+  }
+
+  private async syncConnections(): Promise<void> {
+    if (this.stopped) return;
+    try {
+      const convos = await this.opts.listConversations();
+      const subscribableIds = new Set(
+        convos.filter((c) => c.type === 'dm' || c.type === 'channel').map((c) => c.conversation_id),
+      );
+      for (const convId of subscribableIds) {
+        if (!this.stoppedConversations.has(convId) && !this.connections.has(convId)) {
+          void this.connectAsync(convId);
+        }
+      }
+      for (const convId of this.connections.keys()) {
+        if (!subscribableIds.has(convId) || this.stoppedConversations.has(convId)) {
+          const ws = this.connections.get(convId);
+          if (ws) {
+            ws.removeAllListeners();
+            ws.close();
+            this.connections.delete(convId);
+          }
+        }
+      }
+    } catch {
+      // ignore
+    }
+  }
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src"]
+}