kalshi-trading-bot-cli 2.1.0

package/src/gateway/channels/whatsapp/inbound.ts

@@ -0,0 +1,326 @@
+import {
+  isJidGroup,
+  normalizeMessageContent,
+  extractMessageContent,
+  type ConnectionState,
+  type WAMessage,
+  type proto,
+} from '@whiskeysockets/baileys';
+import { createWaSocket, getStatusCode, isLoggedOutReason, waitForWaConnection } from './session.js';
+import type { WhatsAppCloseReason, WhatsAppInboundMessage } from './types.js';
+import { setActiveWebListener } from './outbound.js';
+import { isRecentInboundMessage } from './dedupe.js';
+import { readSelfId } from './auth-store.js';
+import { checkInboundAccessControl } from '../../access-control.js';
+import { resolveJidToPhoneJid, type LidLookup } from './lid.js';
+import { appendFileSync } from 'node:fs';
+import { appPath } from '../../../utils/paths.js';
+
+const LOG_PATH = appPath('gateway-debug.log');
+function debugLog(msg: string) {
+  appendFileSync(LOG_PATH, `${new Date().toISOString()} ${msg}\n`);
+}
+
+function extractMentionedJids(message: WAMessage): string[] {
+  const rawMsg = message.message;
+  if (!rawMsg) return [];
+
+  const normalized = normalizeMessageContent(rawMsg);
+  if (!normalized) return [];
+
+  // Check contextInfo.mentionedJid across message types that support mentions
+  const contextInfo =
+    normalized.extendedTextMessage?.contextInfo ??
+    normalized.imageMessage?.contextInfo ??
+    normalized.videoMessage?.contextInfo ??
+    normalized.documentMessage?.contextInfo;
+
+  const jids = contextInfo?.mentionedJid;
+  return Array.isArray(jids) ? jids.filter((j): j is string => typeof j === 'string') : [];
+}
+
+function extractText(message: WAMessage): string {
+  const rawMsg = message.message;
+  if (!rawMsg) {
+    debugLog(`[extractText] no message content`);
+    return '';
+  }
+  
+  // Use Baileys' normalizeMessageContent to unwrap viewOnce, ephemeral, etc.
+  const normalized = normalizeMessageContent(rawMsg);
+  if (!normalized) {
+    debugLog(`[extractText] normalizeMessageContent returned null`);
+    return '';
+  }
+  
+  // Log available message keys for debugging
+  const keys = Object.keys(normalized);
+  debugLog(`[extractText] message keys: ${keys.join(', ')}`);
+  
+  // Try extractMessageContent for deeper extraction
+  const extracted = extractMessageContent(normalized);
+  const candidates = [normalized, extracted && extracted !== normalized ? extracted : undefined];
+  
+  for (const candidate of candidates) {
+    if (!candidate) continue;
+    
+    // Check conversation (simple text)
+    if (typeof candidate.conversation === 'string' && candidate.conversation.trim()) {
+      return candidate.conversation.trim();
+    }
+    
+    // Check extended text message
+    const extended = candidate.extendedTextMessage?.text;
+    if (extended?.trim()) {
+      return extended.trim();
+    }
+    
+    // Check media captions
+    const caption =
+      candidate.imageMessage?.caption ??
+      candidate.videoMessage?.caption ??
+      candidate.documentMessage?.caption;
+    if (caption?.trim()) {
+      return caption.trim();
+    }
+  }
+  
+  return '';
+}
+
+function toPhoneFromJid(jid: string): string {
+  const base = jid.split('@')[0] ?? '';
+  const match = base.match(/^(\d+)(?::\d+)?$/);
+  const digits = match?.[1] ?? base.replace(/\D/g, '');
+  return digits ? `+${digits}` : '';
+}
+
+function jidToE164(jid?: string | null): string | null {
+  if (!jid) {
+    return null;
+  }
+  const phone = toPhoneFromJid(jid);
+  return phone || null;
+}
+
+export async function monitorWebInbox(params: {
+  accountId: string;
+  authDir: string;
+  verbose: boolean;
+  allowFrom: string[];
+  dmPolicy: 'pairing' | 'allowlist' | 'open' | 'disabled';
+  groupPolicy: 'open' | 'allowlist' | 'disabled';
+  groupAllowFrom: string[];
+  sendReadReceipts?: boolean;
+  onMessage: (msg: WhatsAppInboundMessage) => Promise<void>;
+}): Promise<{
+  sock: Awaited<ReturnType<typeof createWaSocket>>;
+  onClose: Promise<WhatsAppCloseReason>;
+  close: () => Promise<void>;
+}> {
+  const sock = await createWaSocket({
+    authDir: params.authDir,
+    printQr: false,
+    verbose: params.verbose,
+  });
+  await waitForWaConnection(sock);
+  console.log('[whatsapp] Connected');
+  const connectedAtMs = Date.now();
+  const selfJid = sock.user?.id;
+  const selfLid = (sock.user as unknown as Record<string, unknown>)?.lid as string | undefined ?? null;
+  const selfFromSock = jidToE164(selfJid);
+  const selfFromCreds = readSelfId(params.authDir).e164;
+  const selfE164 = selfFromSock ?? selfFromCreds;
+  debugLog(`[inbound] selfJid=${selfJid} selfLid=${selfLid} selfE164=${selfE164}`);
+
+  // Get LID lookup for resolving LID JIDs to phone JIDs
+  // Baileys 7.x provides signalRepository.lidMapping for LID resolution
+  const lidMapping = sock.signalRepository?.lidMapping;
+  const lidLookup: LidLookup | undefined = lidMapping ? {
+    getPNForLID: lidMapping.getPNForLID?.bind(lidMapping),
+  } : undefined;
+  debugLog(`[inbound] lidLookup available: ${!!lidLookup}, getPNForLID: ${typeof lidLookup?.getPNForLID}`);
+
+  let onCloseResolve: ((reason: WhatsAppCloseReason) => void) | null = null;
+  const onClose = new Promise<WhatsAppCloseReason>((resolve) => {
+    onCloseResolve = resolve;
+  });
+  const resolveClose = (reason: WhatsAppCloseReason) => {
+    if (!onCloseResolve) {
+      return;
+    }
+    const resolve = onCloseResolve;
+    onCloseResolve = null;
+    resolve(reason);
+  };
+
+  const onMessagesUpsert = async (upsert: { type?: string; messages?: WAMessage[] }) => {
+    debugLog(`[inbound] upsert type=${upsert.type} count=${upsert.messages?.length ?? 0}`);
+    if (upsert.type !== 'notify' && upsert.type !== 'append') {
+      return;
+    }
+    for (const message of upsert.messages ?? []) {
+      const remoteJid = message.key?.remoteJid;
+      debugLog(`[inbound] message remoteJid=${remoteJid} fromMe=${message.key?.fromMe}`);
+      if (!remoteJid) {
+        continue;
+      }
+
+      // Skip duplicate messages
+      const messageId = message.key?.id;
+      const dedupeKey = messageId ? `${params.accountId}:${remoteJid}:${messageId}` : undefined;
+      if (dedupeKey && isRecentInboundMessage(dedupeKey)) {
+        debugLog(`[inbound] skipping duplicate ${dedupeKey}`);
+        continue;
+      }
+
+      const isGroup = isJidGroup(remoteJid) === true;
+      const senderJid = message.key?.participant ?? remoteJid;
+      
+      // For direct chats, resolve LID JID to phone JID for reliable replies
+      let replyToJid = remoteJid;
+      if (!isGroup) {
+        debugLog(`[inbound] attempting LID resolution for ${remoteJid}, lidLookup available: ${!!lidLookup}, getPNForLID available: ${!!lidLookup?.getPNForLID}`);
+        const resolvedJid = await resolveJidToPhoneJid(remoteJid, lidLookup, debugLog);
+        debugLog(`[inbound] resolveJidToPhoneJid result: ${resolvedJid}`);
+        if (resolvedJid) {
+          replyToJid = resolvedJid;
+          debugLog(`[inbound] using resolved JID ${resolvedJid} for replies`);
+        } else {
+          debugLog(`[inbound] LID resolution failed, using original ${remoteJid} for replies`);
+        }
+      }
+      
+      const from = toPhoneFromJid(isGroup ? senderJid : replyToJid);
+      const messageTimestampMs = message.messageTimestamp
+        ? Number(message.messageTimestamp) * 1000
+        : undefined;
+      debugLog(`[inbound] from=${from} selfE164=${selfE164} isGroup=${isGroup} isFromMe=${message.key?.fromMe} allowFrom=${JSON.stringify(params.allowFrom)} dmPolicy=${params.dmPolicy} groupPolicy=${params.groupPolicy}`);
+      const access = await checkInboundAccessControl({
+        accountId: params.accountId,
+        from,
+        selfE164,
+        senderE164: isGroup ? toPhoneFromJid(senderJid) || null : from || null,
+        group: isGroup,
+        isFromMe: Boolean(message.key?.fromMe),
+        dmPolicy: params.dmPolicy,
+        groupPolicy: params.groupPolicy,
+        allowFrom: params.allowFrom,
+        groupAllowFrom: params.groupAllowFrom,
+        messageTimestampMs,
+        connectedAtMs,
+        reply: async (text: string) => {
+          await sock.sendMessage(remoteJid, { text });
+        },
+      });
+      debugLog(
+        `[inbound] access allowed=${access.allowed} denyReason=${access.denyReason ?? 'none'} isSelfChat=${access.isSelfChat} shouldMarkRead=${access.shouldMarkRead}`,
+      );
+      if (!access.allowed) {
+        continue;
+      }
+
+      let groupSubject: string | undefined;
+      let groupParticipants: string[] | undefined;
+      if (isGroup) {
+        try {
+          const meta = await sock.groupMetadata(remoteJid);
+          groupSubject = meta.subject;
+          groupParticipants = meta.participants?.map((participant: { id: string }) => toPhoneFromJid(participant.id));
+        } catch {
+          // ignore metadata fetch failures
+        }
+      }
+
+      const body = extractText(message);
+      debugLog(`[inbound] body="${body.slice(0, 50)}..."`);
+      if (!body.trim()) {
+        debugLog(`[inbound] skipping empty body`);
+        continue;
+      }
+      const mentionedJids = extractMentionedJids(message);
+      const inbound: WhatsAppInboundMessage = {
+        id: message.key?.id ?? undefined,
+        accountId: access.resolvedAccountId,
+        chatId: remoteJid,
+        replyToJid,
+        chatType: isGroup ? 'group' : 'direct',
+        from,
+        senderId: from,
+        senderName: message.pushName ? String(message.pushName) : undefined,
+        isFromMe: Boolean(message.key?.fromMe),
+        selfE164,
+        mentionedJids,
+        selfJid: selfJid ?? null,
+        selfLid,
+        groupSubject,
+        groupParticipants,
+        body,
+        timestamp: messageTimestampMs,
+        sendComposing: async () => {
+          await sock.sendPresenceUpdate('composing', replyToJid);
+        },
+        reply: async (text: string) => {
+          await sock.sendMessage(replyToJid, { text });
+        },
+        sendMedia: async (payload) => {
+          await sock.sendMessage(replyToJid, payload);
+        },
+      };
+      if (
+        params.sendReadReceipts !== false &&
+        message.key?.id &&
+        access.shouldMarkRead &&
+        !access.isSelfChat
+      ) {
+        await sock.readMessages([
+          {
+            remoteJid,
+            id: message.key.id,
+            participant: message.key.participant,
+            fromMe: false,
+          },
+        ]);
+      }
+      // History/offline catch-up: mark read above but skip auto-reply.
+      if (upsert.type === 'append') {
+        debugLog(`[inbound] skipping append message (read-only, no reply)`);
+        continue;
+      }
+      debugLog(`[inbound] calling onMessage for ${from}: "${body.slice(0, 30)}..."`);
+      await params.onMessage(inbound);
+    }
+  };
+
+  const onConnectionUpdate = (update: Partial<ConnectionState>) => {
+    if (update.connection === 'close') {
+      const status = getStatusCode(update.lastDisconnect?.error);
+      const isLoggedOut = isLoggedOutReason(update.lastDisconnect?.error);
+      console.log(`[whatsapp] Disconnected (status=${status}, loggedOut=${isLoggedOut})`);
+      resolveClose({
+        status,
+        isLoggedOut,
+        error: update.lastDisconnect?.error,
+      });
+    }
+  };
+
+  sock.ev.on('messages.upsert', onMessagesUpsert);
+  sock.ev.on('connection.update', onConnectionUpdate);
+
+  return {
+    sock,
+    onClose,
+    close: async () => {
+      resolveClose({
+        status: 499,
+        isLoggedOut: false,
+      });
+      sock.ev.off('messages.upsert', onMessagesUpsert);
+      sock.ev.off('connection.update', onConnectionUpdate);
+      setActiveWebListener(params.accountId, null);
+      sock.ws.close();
+    },
+  };
+}
+

package/src/gateway/channels/whatsapp/index.ts

@@ -0,0 +1,5 @@
+export { loginWhatsApp } from './login.js';
+export { monitorWhatsAppChannel } from './runtime.js';
+export { assertOutboundAllowed, sendComposing, sendMessageWhatsApp } from './outbound.js';
+export type { WhatsAppInboundMessage } from './types.js';
+

package/src/gateway/channels/whatsapp/lid.ts

@@ -0,0 +1,56 @@
+/**
+ * LID (Linked ID) resolution utilities for WhatsApp.
+ * 
+ * WhatsApp uses LID JIDs for self-chat which don't have Signal sessions.
+ * We need to resolve LID JIDs to phone number JIDs (@s.whatsapp.net) for replies.
+ */
+
+export type LidLookup = {
+  getPNForLID?: (lid: string) => Promise<string | null>;
+};
+
+/**
+ * Resolve a JID to a phone number JID suitable for sending messages.
+ * 
+ * - If already @s.whatsapp.net or @g.us, returns as-is
+ * - If @lid, attempts resolution via lidLookup.getPNForLID()
+ * - Returns null if resolution fails or jid is null/undefined
+ */
+export async function resolveJidToPhoneJid(
+  jid: string | null | undefined,
+  lidLookup?: LidLookup,
+  debugLog?: (msg: string) => void,
+): Promise<string | null> {
+  const log = debugLog ?? (() => {});
+  
+  if (!jid) {
+    log(`[lid] jid is null/undefined`);
+    return null;
+  }
+
+  // If already a phone JID or group JID, return as-is
+  if (jid.endsWith('@s.whatsapp.net') || jid.endsWith('@g.us')) {
+    log(`[lid] ${jid} is already a phone/group JID`);
+    return jid;
+  }
+
+  // Try LID resolution
+  if (jid.endsWith('@lid')) {
+    log(`[lid] ${jid} is an LID JID, attempting resolution`);
+    if (lidLookup?.getPNForLID) {
+      try {
+        const pnJid = await lidLookup.getPNForLID(jid);
+        log(`[lid] getPNForLID returned: ${pnJid}`);
+        if (pnJid) return pnJid;
+      } catch (err) {
+        log(`[lid] getPNForLID error: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    } else {
+      log(`[lid] getPNForLID not available`);
+    }
+  } else {
+    log(`[lid] ${jid} is not an LID JID (doesn't end with @lid)`);
+  }
+
+  return null;
+}

package/src/gateway/channels/whatsapp/logger.ts

@@ -0,0 +1,25 @@
+export type PinoLikeLogger = {
+  level: string;
+  child: (bindings?: Record<string, unknown>) => PinoLikeLogger;
+  trace: (...args: unknown[]) => void;
+  debug: (...args: unknown[]) => void;
+  info: (...args: unknown[]) => void;
+  warn: (...args: unknown[]) => void;
+  error: (...args: unknown[]) => void;
+  fatal: (...args: unknown[]) => void;
+};
+
+export function createSilentLogger(): PinoLikeLogger {
+  const noop = () => {};
+  const logger: PinoLikeLogger = {
+    level: 'silent',
+    child: () => logger,
+    trace: noop,
+    debug: noop,
+    info: noop,
+    warn: noop,
+    error: noop,
+    fatal: noop,
+  };
+  return logger;
+}

package/src/gateway/channels/whatsapp/login.ts

@@ -0,0 +1,94 @@
+import qrcode from 'qrcode-terminal';
+import { createWaSocket, getStatusCode, waitForWaConnection } from './session.js';
+import { formatError } from './error.js';
+
+export type LoginResult = {
+  phone: string | null;
+};
+
+function extractPhoneFromJid(jid: string | undefined): string | null {
+  if (!jid) {
+    return null;
+  }
+  // Format: "1234567890:123@s.whatsapp.net" -> "+1234567890"
+  const match = jid.match(/^(\d+):/);
+  return match ? `+${match[1]}` : null;
+}
+
+function getErrorStatusCode(err: unknown): number | undefined {
+  return (
+    (err as { error?: { output?: { statusCode?: number } } })?.error?.output?.statusCode ??
+    getStatusCode(err)
+  );
+}
+
+export async function loginWhatsApp(params: { authDir: string }): Promise<LoginResult> {
+  let resolved = false;
+  const sock = await createWaSocket({
+    authDir: params.authDir,
+    printQr: false,
+    onQr: (qr) => {
+      if (resolved) {
+        return;
+      }
+      console.log('Scan this QR in WhatsApp -> Linked Devices:');
+      qrcode.generate(qr, { small: true });
+    },
+  });
+
+  try {
+    await waitForWaConnection(sock);
+    resolved = true;
+    const phone = extractPhoneFromJid(sock.user?.id);
+    console.log('WhatsApp linked successfully.');
+    return { phone };
+  } catch (err) {
+    const code = getErrorStatusCode(err);
+
+    // Handle 515 "restart required" - WhatsApp asks for reconnection after pairing
+    if (code === 515) {
+      console.log('WhatsApp asked for restart (code 515); credentials saved. Retrying connection...');
+      try {
+        sock.ws.close();
+      } catch {
+        // ignore
+      }
+
+      // Retry without QR - credentials are already saved from the first connection
+      const retry = await createWaSocket({
+        authDir: params.authDir,
+        printQr: false,
+      });
+
+      try {
+        await waitForWaConnection(retry);
+        resolved = true;
+        const phone = extractPhoneFromJid(retry.user?.id);
+        console.log('WhatsApp linked successfully after restart.');
+        return { phone };
+      } finally {
+        setTimeout(() => {
+          try {
+            retry.ws.close();
+          } catch {
+            // ignore
+          }
+        }, 500);
+      }
+    }
+
+    // Other errors
+    const formatted = formatError(err);
+    console.error(`WhatsApp connection failed: ${formatted}`);
+    throw new Error(formatted, { cause: err });
+  } finally {
+    setTimeout(() => {
+      try {
+        sock.ws.close();
+      } catch {
+        // ignore
+      }
+    }, 500);
+  }
+}
+

package/src/gateway/channels/whatsapp/outbound.ts

@@ -0,0 +1,119 @@
+import type { AnyMessageContent } from '@whiskeysockets/baileys';
+import fs from 'node:fs';
+import type { WaSocket } from './session.js';
+import { loadGatewayConfig, resolveWhatsAppAccount } from '../../config.js';
+import { normalizeE164, toWhatsappJid } from '../../utils.js';
+import { appPath } from '../../../utils/paths.js';
+
+function debugLog(msg: string) {
+  try {
+    const logDir = appPath('debug', 'logs');
+    const logPath = appPath('debug', 'logs', 'gateway-outbound.log');
+    fs.mkdirSync(logDir, { recursive: true });
+    fs.appendFileSync(logPath, `${new Date().toISOString()} ${msg}\n`);
+  } catch {
+    // Avoid breaking outbound sends if log dir is unwritable
+  }
+}
+
+type ActiveListener = {
+  accountId: string;
+  sock: WaSocket;
+};
+
+const listeners = new Map<string, ActiveListener>();
+
+export function setActiveWebListener(accountId: string, sock: WaSocket | null): void {
+  if (!sock) {
+    listeners.delete(accountId);
+    return;
+  }
+  listeners.set(accountId, { accountId, sock });
+}
+
+function getActive(accountId?: string): ActiveListener {
+  if (accountId) {
+    const found = listeners.get(accountId);
+    if (found) {
+      return found;
+    }
+  }
+  const first = listeners.values().next().value as ActiveListener | undefined;
+  if (!first) {
+    throw new Error('No active WhatsApp listener. Run the gateway.');
+  }
+  return first;
+}
+
+function extractE164FromJid(jid: string): string | null {
+  const localPart = jid.split('@')[0] ?? '';
+  const rawPhone = localPart.includes(':') ? localPart.split(':')[0] : localPart;
+  if (!/^\d+$/.test(rawPhone)) {
+    return null;
+  }
+  return normalizeE164(rawPhone);
+}
+
+export function assertOutboundAllowed(params: {
+  to: string;
+  accountId?: string;
+}): { toJid: string; recipientE164: string } {
+  const cfg = loadGatewayConfig();
+  const accountId = params.accountId ?? cfg.gateway.accountId;
+  const account = resolveWhatsAppAccount(cfg, accountId);
+  const toJid = toWhatsappJid(params.to);
+
+  if (toJid.endsWith('@g.us')) {
+    if (account.groupPolicy === 'disabled') {
+      throw new Error('Outbound blocked: group destinations are disabled in strict self-chat mode.');
+    }
+    // Group JIDs don't have E.164 recipients — skip individual recipient validation
+    return { toJid, recipientE164: '' };
+  }
+
+  const recipientE164 = extractE164FromJid(toJid);
+  if (!recipientE164) {
+    throw new Error(`Outbound blocked: invalid recipient JID ${toJid}`);
+  }
+
+  // Strict mode: require explicit recipient allowlist entries and ignore wildcard.
+  const explicitAllowedRecipients = account.allowFrom
+    .filter((entry) => entry !== '*')
+    .map(normalizeE164);
+  if (explicitAllowedRecipients.length === 0) {
+    throw new Error('Outbound blocked: no explicit allowFrom recipient configured.');
+  }
+  if (!explicitAllowedRecipients.includes(recipientE164)) {
+    throw new Error(`Outbound blocked: ${recipientE164} is not in allowFrom.`);
+  }
+
+  return { toJid, recipientE164 };
+}
+
+export async function sendMessageWhatsApp(params: {
+  to: string;
+  body: string;
+  accountId?: string;
+  media?: AnyMessageContent;
+}): Promise<{ messageId: string; toJid: string }> {
+  const active = getActive(params.accountId);
+  debugLog(`[outbound] input to=${params.to}`);
+  const { toJid: to } = assertOutboundAllowed({ to: params.to, accountId: params.accountId });
+  debugLog(`[outbound] normalized to=${to}`);
+  const payload = params.media ?? { text: params.body };
+  debugLog(`[outbound] sending message...`);
+  const startedAt = Date.now();
+  const result = await active.sock.sendMessage(to, payload);
+  const durationMs = Date.now() - startedAt;
+  const messageId = result?.key?.id ?? 'unknown';
+  console.log(`Sent message ${messageId} -> ${to} (${durationMs}ms)`);
+  debugLog(`[outbound] sendMessage result id=${messageId}`);
+  return { messageId, toJid: to };
+}
+
+export async function sendComposing(params: { to: string; accountId?: string }): Promise<void> {
+  const active = getActive(params.accountId);
+  const { toJid: to } = assertOutboundAllowed({ to: params.to, accountId: params.accountId });
+  await active.sock.sendPresenceUpdate('composing', to);
+}
+

package/src/gateway/channels/whatsapp/plugin.ts

@@ -0,0 +1,54 @@
+import type { GatewayConfig, WhatsAppAccountConfig } from '../../config.js';
+import { listWhatsAppAccountIds, resolveWhatsAppAccount } from '../../config.js';
+import type { ChannelPlugin } from '../types.js';
+import { monitorWhatsAppChannel, type WhatsAppInboundMessage } from './index.js';
+import { resolveReconnectPolicy } from './reconnect.js';
+
+export function createWhatsAppPlugin(params: {
+  loadConfig: () => GatewayConfig;
+  onMessage: (msg: WhatsAppInboundMessage) => Promise<void>;
+}): ChannelPlugin<GatewayConfig, WhatsAppAccountConfig> {
+  return {
+    id: 'whatsapp',
+    config: {
+      listAccountIds: (cfg) => listWhatsAppAccountIds(cfg),
+      resolveAccount: (cfg, accountId) => resolveWhatsAppAccount(cfg, accountId),
+      isEnabled: (account, cfg) => account.enabled && cfg.channels.whatsapp.enabled !== false,
+      isConfigured: async (account) => Boolean(account.authDir),
+    },
+    gateway: {
+      startAccount: async (ctx) => {
+        const cfg = params.loadConfig();
+        await monitorWhatsAppChannel({
+          accountId: ctx.accountId,
+          authDir: ctx.account.authDir,
+          verbose: true,
+          allowFrom: ctx.account.allowFrom,
+          dmPolicy: ctx.account.dmPolicy,
+          groupPolicy: ctx.account.groupPolicy,
+          groupAllowFrom: ctx.account.groupAllowFrom,
+          sendReadReceipts: ctx.account.sendReadReceipts,
+          heartbeatSeconds: cfg.gateway.heartbeatSeconds,
+          reconnect: resolveReconnectPolicy(cfg),
+          abortSignal: ctx.abortSignal,
+          onMessage: params.onMessage,
+          onStatus: (status) => {
+            ctx.setStatus({
+              connected: status.connected,
+              lastError: status.lastError ?? null,
+            });
+          },
+        });
+      },
+    },
+    status: {
+      defaultRuntime: {
+        accountId: 'default',
+        running: false,
+        connected: false,
+        lastError: null,
+      },
+    },
+  };
+}
+