kalshi-trading-bot-cli 2.1.0

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

@@ -0,0 +1,40 @@
+import type { GatewayConfig } from '../../config.js';
+
+export type ReconnectPolicy = {
+  initialMs: number;
+  maxMs: number;
+  factor: number;
+  jitter: number;
+  maxAttempts: number;
+};
+
+export const DEFAULT_RECONNECT_POLICY: ReconnectPolicy = {
+  initialMs: 2_000,
+  maxMs: 30_000,
+  factor: 1.8,
+  jitter: 0.25,
+  maxAttempts: 12,
+};
+
+function clamp(value: number, min: number, max: number): number {
+  return Math.min(max, Math.max(min, value));
+}
+
+export function computeBackoff(policy: ReconnectPolicy, attempt: number): number {
+  const base = policy.initialMs * policy.factor ** Math.max(attempt - 1, 0);
+  const jitter = base * policy.jitter * Math.random();
+  return Math.min(policy.maxMs, Math.round(base + jitter));
+}
+
+export function resolveReconnectPolicy(cfg: GatewayConfig): ReconnectPolicy {
+  const merged: ReconnectPolicy = {
+    ...DEFAULT_RECONNECT_POLICY,
+    ...(cfg.gateway.reconnect ?? {}),
+  };
+  merged.initialMs = Math.max(250, merged.initialMs);
+  merged.maxMs = Math.max(merged.initialMs, merged.maxMs);
+  merged.factor = clamp(merged.factor, 1.1, 10);
+  merged.jitter = clamp(merged.jitter, 0, 1);
+  merged.maxAttempts = Math.max(0, Math.floor(merged.maxAttempts));
+  return merged;
+}

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

@@ -0,0 +1,122 @@
+import { monitorWebInbox } from './inbound.js';
+import { setActiveWebListener } from './outbound.js';
+import { logout } from './auth-store.js';
+import type { WhatsAppInboundMessage } from './types.js';
+import type { ReconnectPolicy } from './reconnect.js';
+import { computeBackoff, DEFAULT_RECONNECT_POLICY } from './reconnect.js';
+
+export async function monitorWhatsAppChannel(params: {
+  accountId: string;
+  authDir: string;
+  verbose: boolean;
+  allowFrom: string[];
+  dmPolicy: 'pairing' | 'allowlist' | 'open' | 'disabled';
+  groupPolicy: 'open' | 'allowlist' | 'disabled';
+  groupAllowFrom: string[];
+  sendReadReceipts?: boolean;
+  heartbeatSeconds?: number;
+  reconnect?: ReconnectPolicy;
+  abortSignal: AbortSignal;
+  onMessage: (msg: WhatsAppInboundMessage) => Promise<void>;
+  onStatus?: (status: { connected: boolean; lastError?: string | null }) => void;
+}): Promise<void> {
+  const MESSAGE_TIMEOUT_MS = 30 * 60 * 1000;
+  const WATCHDOG_CHECK_MS = 60 * 1000;
+  const heartbeatSeconds =
+    typeof params.heartbeatSeconds === 'number' && params.heartbeatSeconds > 0
+      ? params.heartbeatSeconds
+      : 60;
+  const reconnectPolicy = params.reconnect ?? DEFAULT_RECONNECT_POLICY;
+  let reconnectAttempts = 0;
+  while (!params.abortSignal.aborted) {
+    const startedAt = Date.now();
+    let handledMessages = 0;
+    let lastMessageAt: number | null = null;
+    let heartbeat: NodeJS.Timeout | null = null;
+    let watchdog: NodeJS.Timeout | null = null;
+    try {
+      const listener = await monitorWebInbox({
+        accountId: params.accountId,
+        authDir: params.authDir,
+        verbose: params.verbose,
+        allowFrom: params.allowFrom,
+        dmPolicy: params.dmPolicy,
+        groupPolicy: params.groupPolicy,
+        groupAllowFrom: params.groupAllowFrom,
+        sendReadReceipts: params.sendReadReceipts,
+        onMessage: async (msg) => {
+          handledMessages += 1;
+          lastMessageAt = Date.now();
+          await params.onMessage(msg);
+        },
+      });
+      setActiveWebListener(params.accountId, listener.sock);
+      params.onStatus?.({ connected: true, lastError: null });
+      heartbeat = setInterval(() => {
+        const uptimeMs = Date.now() - startedAt;
+        if (params.verbose) {
+          console.log(
+            `[whatsapp heartbeat] account=${params.accountId} messages=${handledMessages} uptimeMs=${uptimeMs}`,
+          );
+        }
+      }, heartbeatSeconds * 1000);
+      watchdog = setInterval(() => {
+        if (!lastMessageAt) {
+          return;
+        }
+        if (Date.now() - lastMessageAt <= MESSAGE_TIMEOUT_MS) {
+          return;
+        }
+        void listener.close();
+      }, WATCHDOG_CHECK_MS);
+      const closeReason = await listener.onClose;
+      await listener.close();
+      setActiveWebListener(params.accountId, null);
+      if (heartbeat) {
+        clearInterval(heartbeat);
+      }
+      if (watchdog) {
+        clearInterval(watchdog);
+      }
+
+      if (closeReason.isLoggedOut) {
+        // Clear stale credentials when WhatsApp reports logged out (401)
+        await logout(params.authDir);
+        params.onStatus?.({ connected: false, lastError: 'logged out - please re-run gateway:login' });
+        break;
+      }
+
+      const uptimeMs = Date.now() - startedAt;
+      if (uptimeMs > heartbeatSeconds * 1000) {
+        reconnectAttempts = 0;
+      }
+      reconnectAttempts += 1;
+      const delayMs = computeBackoff(reconnectPolicy, reconnectAttempts);
+      params.onStatus?.({
+        connected: false,
+        lastError: `disconnected (attempt ${reconnectAttempts})`,
+      });
+      if (reconnectPolicy.maxAttempts > 0 && reconnectAttempts >= reconnectPolicy.maxAttempts) {
+        break;
+      }
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    } catch (error) {
+      if (heartbeat) {
+        clearInterval(heartbeat);
+      }
+      if (watchdog) {
+        clearInterval(watchdog);
+      }
+      reconnectAttempts += 1;
+      const message = error instanceof Error ? error.message : String(error);
+      params.onStatus?.({ connected: false, lastError: message });
+      const delayMs = computeBackoff(reconnectPolicy, reconnectAttempts);
+      if (reconnectPolicy.maxAttempts > 0 && reconnectAttempts >= reconnectPolicy.maxAttempts) {
+        break;
+      }
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+  }
+  setActiveWebListener(params.accountId, null);
+}
+

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

@@ -0,0 +1,89 @@
+import {
+  DisconnectReason,
+  fetchLatestBaileysVersion,
+  makeCacheableSignalKeyStore,
+  makeWASocket,
+  useMultiFileAuthState,
+  type ConnectionState,
+} from '@whiskeysockets/baileys';
+import { mkdirSync } from 'node:fs';
+import { createSilentLogger } from './logger.js';
+import { maybeRestoreCredsFromBackup, backupCredsBeforeSave } from './auth-store.js';
+
+export type WaSocket = ReturnType<typeof makeWASocket>;
+
+export async function createWaSocket(params: {
+  authDir: string;
+  printQr: boolean;
+  onQr?: (qr: string) => void;
+  verbose?: boolean;
+}): Promise<WaSocket> {
+  mkdirSync(params.authDir, { recursive: true });
+
+  // Restore credentials from backup if main creds.json is corrupted
+  maybeRestoreCredsFromBackup(params.authDir);
+
+  const { state, saveCreds } = await useMultiFileAuthState(params.authDir);
+  const { version } = await fetchLatestBaileysVersion();
+  const logger = createSilentLogger();
+  const sock = makeWASocket({
+    auth: {
+      creds: state.creds,
+      keys: makeCacheableSignalKeyStore(state.keys, logger),
+    },
+    version,
+    logger,
+    printQRInTerminal: params.printQr,
+    browser: ['octagon', 'cli', '1.0.0'],
+    markOnlineOnConnect: false,
+    syncFullHistory: false,
+  });
+
+  // Backup credentials before each save
+  sock.ev.on('creds.update', () => {
+    backupCredsBeforeSave(params.authDir);
+    saveCreds();
+  });
+  sock.ev.on('connection.update', (update: Partial<ConnectionState>) => {
+    if (update.qr) {
+      params.onQr?.(update.qr);
+    }
+  });
+
+  // Handle WebSocket-level errors to prevent unhandled exceptions
+  if (sock.ws && typeof (sock.ws as unknown as { on?: unknown }).on === 'function') {
+    sock.ws.on('error', () => {
+      // Silently handle WebSocket errors - reconnection logic handles recovery
+    });
+  }
+
+  return sock;
+}
+
+export async function waitForWaConnection(sock: WaSocket): Promise<void> {
+  return await new Promise<void>((resolve, reject) => {
+    const onUpdate = (update: Partial<ConnectionState>) => {
+      if (update.connection === 'open') {
+        sock.ev.off('connection.update', onUpdate);
+        resolve();
+      }
+      if (update.connection === 'close') {
+        sock.ev.off('connection.update', onUpdate);
+        reject(update.lastDisconnect?.error ?? new Error('Connection closed'));
+      }
+    };
+    sock.ev.on('connection.update', onUpdate);
+  });
+}
+
+export function getStatusCode(error: unknown): number | undefined {
+  return (
+    (error as { output?: { statusCode?: number } })?.output?.statusCode ??
+    (error as { status?: number })?.status
+  );
+}
+
+export function isLoggedOutReason(error: unknown): boolean {
+  return getStatusCode(error) === DisconnectReason.loggedOut;
+}
+

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

@@ -0,0 +1,32 @@
+import type { AnyMessageContent } from '@whiskeysockets/baileys';
+
+export type WhatsAppInboundMessage = {
+  id?: string;
+  accountId: string;
+  chatId: string;
+  /** The JID to use when replying (resolved from LID to phone JID if applicable) */
+  replyToJid: string;
+  chatType: 'direct' | 'group';
+  from: string;
+  senderId: string;
+  senderName?: string;
+  isFromMe?: boolean;
+  selfE164?: string | null;
+  groupSubject?: string;
+  groupParticipants?: string[];
+  mentionedJids?: string[];
+  selfJid?: string | null;
+  selfLid?: string | null;
+  body: string;
+  timestamp?: number;
+  sendComposing: () => Promise<void>;
+  reply: (text: string) => Promise<void>;
+  sendMedia: (payload: AnyMessageContent) => Promise<void>;
+};
+
+export type WhatsAppCloseReason = {
+  status?: number;
+  isLoggedOut: boolean;
+  error?: unknown;
+};
+

package/src/gateway/commands/handler.ts

@@ -0,0 +1,64 @@
+import type { CommandIntent } from './parser.js';
+import type { AlertRouter } from '../alerts/router.js';
+import type { ParsedArgs } from '../../commands/parse-args.js';
+import { handleScan } from '../../commands/scan.js';
+import { handleEdge } from '../../commands/edge.js';
+import { handlePortfolio } from '../../commands/portfolio.js';
+import {
+  formatScanForWhatsApp,
+  formatEdgeForWhatsApp,
+  formatPortfolioForWhatsApp,
+} from './wa-formatters.js';
+
+function makeArgs(overrides: Partial<ParsedArgs>): ParsedArgs {
+  return {
+    subcommand: 'chat',
+    positionalArgs: [],
+    json: false,
+    live: false,
+    refresh: false,
+    report: false,
+    dryRun: false,
+    verbose: false,
+    performance: false,
+    resolved: false,
+    unresolved: false,
+
+
+    parseErrors: [],
+    ...overrides,
+  };
+}
+
+export async function handleCommand(
+  intent: CommandIntent,
+  alertRouter: AlertRouter,
+  sessionKey: string,
+): Promise<string | null> {
+  switch (intent.type) {
+    case 'none':
+      return null;
+
+    case 'scan': {
+      const args = makeArgs({ theme: intent.theme });
+      const result = await handleScan(args);
+      if (!result.ok) return `Scan failed: ${result.error?.message ?? 'unknown error'}`;
+      return formatScanForWhatsApp(result.data);
+    }
+
+    case 'edge': {
+      const args = makeArgs({ subcommand: 'edge', ticker: intent.ticker });
+      const result = await handleEdge(args);
+      if (!result.ok) return `Edge failed: ${result.error?.message ?? 'unknown error'}`;
+      return formatEdgeForWhatsApp(result.data);
+    }
+
+    case 'portfolio': {
+      const args = makeArgs({ subcommand: 'portfolio' });
+      const result = await handlePortfolio(args);
+      if (!result.ok) return `Portfolio failed: ${result.error?.message ?? 'unknown error'}`;
+      return formatPortfolioForWhatsApp(result.data);
+    }
+
+  }
+}

package/src/gateway/commands/index.ts

@@ -0,0 +1,7 @@
+export { parseCommand, type CommandIntent } from './parser.js';
+export { handleCommand } from './handler.js';
+export {
+  formatScanForWhatsApp,
+  formatEdgeForWhatsApp,
+  formatPortfolioForWhatsApp,
+} from './wa-formatters.js';

package/src/gateway/commands/parser.ts

@@ -0,0 +1,29 @@
+export type CommandIntent =
+  | { type: 'scan'; theme?: string }
+  | { type: 'edge'; ticker?: string }
+  | { type: 'portfolio' }
+  | { type: 'none' };
+
+export function parseCommand(body: string): CommandIntent {
+  const trimmed = body.trim();
+  const lower = trimmed.toLowerCase();
+
+  // Portfolio / positions
+  if (lower === 'portfolio' || lower === 'positions') {
+    return { type: 'portfolio' };
+  }
+
+  // Scan [theme]
+  if (lower === 'scan' || lower.startsWith('scan ')) {
+    const rest = trimmed.slice(4).trim();
+    return { type: 'scan', theme: rest || undefined };
+  }
+
+  // Edge [ticker]
+  if (lower === 'edge' || lower.startsWith('edge ')) {
+    const rest = trimmed.slice(4).trim();
+    return { type: 'edge', ticker: rest || undefined };
+  }
+
+  return { type: 'none' };
+}

package/src/gateway/commands/wa-formatters.ts

@@ -0,0 +1,92 @@
+import type { ScanResult } from '../../scan/loop.js';
+import type { PortfolioData } from '../../commands/portfolio.js';
+import type { EdgeRow } from '../../db/edge.js';
+
+const MAX_ITEMS = 8;
+
+export function formatScanForWhatsApp(result: ScanResult): string {
+  const lines: string[] = [];
+  lines.push(`*SCAN COMPLETE*`);
+  lines.push(`Events: ${result.eventsScanned} | Edges: ${result.edgeSnapshots.length} | Alerts: ${result.alerts.length}`);
+  lines.push('');
+
+  const actionable = result.edgeSnapshots
+    .filter((s) => s.confidence === 'high' || s.confidence === 'very_high')
+    .sort((a, b) => Math.abs(b.edge) - Math.abs(a.edge))
+    .slice(0, MAX_ITEMS);
+
+  if (actionable.length === 0) {
+    lines.push('No actionable edges found.');
+  } else {
+    lines.push('*Top Edges:*');
+    for (const snap of actionable) {
+      const sign = snap.edge >= 0 ? '+' : '';
+      const edgePct = `${sign}${(snap.edge * 100).toFixed(1)}%`;
+      const conf = snap.confidence === 'very_high' ? 'V.HIGH' : snap.confidence.toUpperCase();
+      lines.push(`• *${snap.ticker}* ${edgePct} (${conf})`);
+      if (snap.drivers[0]) {
+        lines.push(`  _${snap.drivers[0].claim}_`);
+      }
+    }
+  }
+
+  lines.push('');
+  lines.push(`Duration: ${(result.duration / 1000).toFixed(1)}s | Credits: ${result.octagonCreditsUsed}`);
+  return lines.join('\n');
+}
+
+export function formatEdgeForWhatsApp(rows: EdgeRow[]): string {
+  const lines: string[] = [];
+  lines.push(`*EDGE SNAPSHOT*`);
+  lines.push('');
+
+  const sorted = [...rows]
+    .sort((a, b) => Math.abs(b.edge) - Math.abs(a.edge))
+    .slice(0, MAX_ITEMS);
+
+  if (sorted.length === 0) {
+    lines.push('No edges found.');
+  } else {
+    for (const row of sorted) {
+      const sign = row.edge >= 0 ? '+' : '';
+      const edgePct = `${sign}${(row.edge * 100).toFixed(1)}%`;
+      const conf = row.confidence === 'very_high' ? 'V.HIGH' : (row.confidence ?? 'N/A').toUpperCase();
+      lines.push(`• *${row.ticker}* ${edgePct} (${conf})`);
+    }
+  }
+
+  return lines.join('\n');
+}
+
+export function formatPortfolioForWhatsApp(data: PortfolioData): string {
+  const lines: string[] = [];
+  lines.push(`*PORTFOLIO*`);
+  lines.push('');
+
+  const acct = data.accountSummary;
+  if (acct) {
+    lines.push(`Cash: $${(acct.cashBalance / 100).toFixed(2)}`);
+    lines.push(`Portfolio: $${(acct.portfolioValue / 100).toFixed(2)}`);
+    lines.push(`Exposure: $${(acct.openExposure / 100).toFixed(2)}`);
+    lines.push(`Available: $${(acct.available / 100).toFixed(2)}`);
+  } else {
+    lines.push(`Account data unavailable`);
+  }
+  lines.push('');
+
+  if (data.positions.length === 0) {
+    lines.push('No open positions.');
+  } else {
+    lines.push(`*Positions (${data.positions.length}):*`);
+    for (const p of data.positions.slice(0, MAX_ITEMS)) {
+      const edgeTxt = p.currentEdge !== null ? `${(p.currentEdge * 100).toFixed(1)}%` : '-';
+      const pnlTxt = p.unrealizedPnl !== null ? `$${(p.unrealizedPnl / 100).toFixed(2)}` : '-';
+      lines.push(`• *${p.ticker}* ${p.direction.toUpperCase()} x${p.size} | Edge: ${edgeTxt} | P&L: ${pnlTxt}`);
+    }
+    if (data.positions.length > MAX_ITEMS) {
+      lines.push(`  _...and ${data.positions.length - MAX_ITEMS} more_`);
+    }
+  }
+
+  return lines.join('\n');
+}