@stage-labs/metro 0.1.0-beta.262 → 0.1.0-beta.264

package/runtime/node_modules/@metro-labs/whatsapp/src/history.ts

@@ -0,0 +1,195 @@
+import { errMsg, log } from '@metro-labs/core/log';
+import { TrainError } from '@metro-labs/core/train-error';
+import type { proto, WAMessage, WAMessageUpdate } from 'baileys';
+import { HistoryEvents } from './history-events.js';
+import { HistoryState } from './history-state.js';
+import {
+  HISTORY_LIMITS, HISTORY_SAVE_MS, HISTORY_SWEEP_MS, newestFirst,
+  type History, type HistoryDelete, type HistoryOptions, type HistoryPage, type HistoryRow, type StoredRow,
+} from './history-types.js';
+
+export { historyFiles } from './history-state.js';
+export type { History, HistoryOptions, HistoryPage, HistoryRow } from './history-types.js';
+
+function shown(row: StoredRow): HistoryRow {
+  return {
+    key: { ...row.key }, messageId: row.key.id ?? '', chatJid: row.key.remoteJid ?? '',
+    fromMe: row.key.fromMe === true, timestamp: new Date(row.at).toISOString(), text: row.text,
+    ...(row.senderJid ? { senderJid: row.senderJid } : {}),
+    ...(row.truncated ? { truncated: true } : {}),
+    ...(row.attachments ? { attachments: row.attachments.map((a) => ({ ...a })) } : {}),
+  };
+}
+
+function readBounds(options: HistoryOptions): { limit: number; since: number } {
+  const limit = options.limit ?? 50;
+  const since = options.since === undefined ? 0 : Date.parse(options.since);
+  if (!Number.isInteger(limit) || limit < 1 || !Number.isFinite(since))
+    throw new TrainError('bad_request', 'WhatsApp history needs a positive integer limit and a valid since timestamp');
+  return { limit: Math.min(limit, HISTORY_LIMITS.pageSize), since };
+}
+
+const rowTime = (row: StoredRow | undefined): string | null => row === undefined ? null : new Date(row.at).toISOString();
+
+function boundedPage(result: HistoryPage, rows: StoredRow[], limit: number): HistoryPage {
+  let bytes = Buffer.byteLength(JSON.stringify(result));
+  for (const row of rows.slice(0, limit)) {
+    const message = shown(row);
+    const added = Buffer.byteLength(JSON.stringify(message)) + 1;
+    const cursor = Buffer.byteLength(JSON.stringify({ count: result.messages.length + 1, hasMore: true, nextBefore: message.messageId }));
+    if (bytes + added + cursor > HISTORY_LIMITS.pageBytes - 128 * 1024) break;
+    result.messages.push(message);
+    bytes += added;
+  }
+  result.count = result.messages.length;
+  result.hasMore = rows.length > result.count;
+  if (result.hasMore) result.nextBefore = result.messages.at(-1)?.messageId;
+  return result;
+}
+
+function page(state: HistoryState, jid: string, options: HistoryOptions): HistoryPage {
+  const { limit, since } = readBounds(options);
+  const rows = [...state.rows.values()].filter((row) => state.same(row.key.remoteJid ?? '', jid)).sort(newestFirst);
+  const before = options.before === undefined ? -1 : rows.findIndex((row) => row.key.id === options.before);
+  if (options.before !== undefined && before < 0)
+    throw new TrainError('whatsapp_history_cursor', 'The before message is not retained in this chat. Read without before to restart local pagination.');
+  const matching = rows.slice(before + 1).filter((row) => row.at >= since);
+  return boundedPage({
+    messages: [], count: 0, hasMore: false,
+    coverage: {
+      partial: true, source: 'local',
+      description: 'Only locally observed or synced messages and successful sends with known expiry state. Own sends with unknown expiry are omitted until observed or synced. Gaps remain; no older backfill or media downloads. View-once and unknown-expiry content is omitted. before is exclusive; since is inclusive. Pages reserve output-formatting overhead within the serialized-byte limit. hasMore describes retained local matches only.',
+      oldest: rowTime(rows.at(-1)), newest: rowTime(rows[0]),
+      retained: rows.length, retainedAfter: new Date(state.after(jid)).toISOString(), limits: HISTORY_LIMITS,
+    },
+  }, matching, limit);
+}
+
+class LocalHistory implements History {
+  private readonly state: HistoryState;
+  private readonly events: HistoryEvents;
+  private readonly sweep: ReturnType<typeof setInterval>;
+  private timer?: ReturnType<typeof setTimeout>;
+  private closed = false;
+
+  constructor(private readonly accountId: string) {
+    this.state = new HistoryState(accountId);
+    this.events = new HistoryEvents(this.state);
+    this.state.prune(Date.now());
+    this.sweep = setInterval(() => { this.saveSafely(); }, HISTORY_SWEEP_MS);
+    this.sweep.unref();
+    this.schedule();
+  }
+
+  private assertOpen(): void {
+    if (this.closed) throw new TrainError('whatsapp_history_closed', 'WhatsApp local history is closed');
+  }
+
+  private saveSafely(): void {
+    try {
+      this.flush();
+    } catch (err) {
+      log.error({ accountId: this.accountId, err: errMsg(err) }, 'whatsapp: could not save local history');
+    }
+  }
+
+  private schedule(): void {
+    if (this.timer) return;
+    this.timer = setTimeout(() => { this.saveSafely(); }, HISTORY_SAVE_MS);
+    this.timer.unref();
+  }
+
+  private changed(now: number): void {
+    this.state.prune(now);
+    this.schedule();
+  }
+
+  read(jid: string, options: HistoryOptions = {}): HistoryPage {
+    this.assertOpen();
+    this.changed(Date.now());
+    this.state.assertReadable(jid);
+    return page(this.state, jid, options);
+  }
+
+  ingest(messages: readonly WAMessage[], selfJid?: string): void {
+    this.ingestAll(messages, selfJid);
+  }
+
+  ingestSent(messages: readonly WAMessage[], selfJid?: string, ephemeralExpiration?: number): void {
+    this.ingestAll(messages, selfJid, { expiration: ephemeralExpiration });
+  }
+
+  private ingestAll(messages: readonly WAMessage[], selfJid?: string, sent?: { expiration?: number }): void {
+    this.assertOpen();
+    const now = Date.now();
+    for (const [index, message] of messages.entries()) {
+      this.events.ingest(message, now, selfJid, sent);
+      if (index % 128 === 127) this.state.prune(now);
+    }
+    this.changed(now);
+  }
+
+  alias(pn: string, lid: string): void {
+    this.assertOpen();
+    const now = Date.now();
+    this.state.alias(pn, lid, now);
+    this.changed(now);
+  }
+
+  clearRange(jid: string, range?: proto.SyncActionValue.ISyncActionMessageRange | null): void {
+    this.assertOpen();
+    const now = Date.now();
+    this.state.clearRange(jid, range ?? {}, now);
+    this.changed(now);
+  }
+
+  invalidate(): void {
+    this.assertOpen();
+    this.state.invalidate(Date.now());
+  }
+
+  update(updates: readonly WAMessageUpdate[], selfJid?: string): void {
+    this.assertOpen();
+    const now = Date.now();
+    for (const [index, update] of updates.entries()) {
+      this.events.update(update, now, selfJid);
+      if (index % 128 === 127) this.state.prune(now);
+    }
+    this.changed(now);
+  }
+
+  deleteMessages(event: HistoryDelete): void {
+    this.assertOpen();
+    const now = Date.now();
+    if ('keys' in event) {
+      for (const [index, key] of event.keys.entries()) {
+        this.state.remove(key, now);
+        if (index % 128 === 127) this.state.prune(now);
+      }
+    } else this.state.clear(event.jid, now);
+    this.changed(now);
+  }
+
+  edit(jid: string, messageId: string, text: string): void {
+    this.assertOpen();
+    const now = Date.now();
+    this.state.prune(now);
+    this.events.edit(jid, messageId, text, now);
+    this.changed(now);
+  }
+
+  flush(): void {
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = undefined;
+    this.state.flush();
+  }
+
+  close(): void {
+    if (this.closed) return;
+    clearInterval(this.sweep);
+    this.closed = true;
+    this.flush();
+  }
+}
+
+export const createHistory = (accountId: string): History => new LocalHistory(accountId);

package/runtime/node_modules/@metro-labs/whatsapp/src/index.ts

@@ -4,4 +4,4 @@ import { createClient } from './client.js';
 import { startInbound } from './inbound.js';
 import { makeHandleCall } from './actions.js';
 
-runClientTrain({ station: 'whatsapp', accounts, loadAccounts, createClient, startInbound, makeHandleCall });
+runClientTrain({ station: 'whatsapp', accounts, loadAccounts, createClient, startInbound, makeHandleCall, disconnectClient: (client) => client.disconnect() });

package/runtime/node_modules/@metro-labs/whatsapp/src/members.ts

@@ -0,0 +1,94 @@
+import { getBinaryNodeChild, type BinaryNode, type GroupParticipant } from 'baileys';
+import { extractGroupMetadata } from 'baileys/lib/Socket/groups.js';
+import { TrainError } from '@metro-labs/core/train-error';
+import { isRecord } from '@metro-labs/core/is-record';
+import type { MemberCapability, MemberList, MetroMember } from '@metro-labs/core/stations/types';
+import { isGroupJid } from './parse.js';
+import { phoneOf, type NameBook } from './names.js';
+
+interface WhatsAppMember extends MetroMember {
+  lid?: string;
+  phoneNumber?: string;
+}
+
+function memberName(p: GroupParticipant, names: NameBook): string | undefined {
+  return names.get(p.id) ?? p.name ?? p.notify
+    ?? (p.lid ? names.get(p.lid) : undefined)
+    ?? (p.phoneNumber ? names.get(p.phoneNumber) : undefined);
+}
+
+function memberRole(p: GroupParticipant): string | undefined {
+  return p.admin ?? (p.isSuperAdmin ? 'superadmin' : p.isAdmin ? 'admin' : undefined);
+}
+
+function memberOf(p: GroupParticipant, names: NameBook): WhatsAppMember {
+  const lid = p.id.endsWith('@lid') ? p.id : p.lid;
+  const phoneNumber = p.id.endsWith('@s.whatsapp.net') ? p.id : p.phoneNumber;
+  const displayName = memberName(p, names);
+  const address = phoneOf(phoneNumber);
+  const role = memberRole(p);
+  return {
+    id: p.id,
+    ...(displayName ? { display_name: displayName } : {}),
+    ...(lid ? { lid } : {}),
+    ...(phoneNumber ? { phoneNumber } : {}),
+    ...(address ? { address } : {}),
+    roles: role ? [role] : [],
+    is_admin: role === 'admin' || role === 'superadmin',
+  };
+}
+
+function memberLimit(limit: number | undefined): number {
+  if (limit === undefined) return 200;
+  if (!Number.isFinite(limit) || limit < 1 || !Number.isInteger(limit))
+    throw new TrainError('bad_request', 'limit must be a positive integer');
+  return Math.min(limit, 1000);
+}
+
+function binaryNode(value: unknown): value is BinaryNode {
+  if (!isRecord(value) || typeof value.tag !== 'string' || !isRecord(value.attrs)) return false;
+  if (!Object.values(value.attrs).every((attr) => typeof attr === 'string')) return false;
+  const content = value.content;
+  return content === undefined || typeof content === 'string' || content instanceof Uint8Array
+    || (Array.isArray(content) && content.every(binaryNode));
+}
+
+function memberTotal(response: BinaryNode): number | undefined {
+  const value = getBinaryNodeChild(response, 'group')?.attrs.size;
+  if (!value || !/^\d+$/.test(value)) return undefined;
+  const size = Number(value);
+  return Number.isSafeInteger(size) ? size : undefined;
+}
+
+function capability(total: number | undefined, fetched: number, returned: number): MemberCapability {
+  const complete = total !== undefined && total === fetched && returned === total;
+  const reason = returned < fetched ? 'Member list was limited; increase limit up to 1000'
+    : total === undefined ? 'WhatsApp did not report a total member count'
+      : total !== fetched ? 'WhatsApp returned a partial member list' : undefined;
+  return { supported: true, complete, ...(total === undefined ? {} : { total }), ...(reason ? { reason } : {}) };
+}
+
+export async function listMembers(
+  jid: string,
+  query: (node: BinaryNode) => Promise<unknown>,
+  names: NameBook,
+  limit?: number,
+): Promise<MemberList> {
+  const cap = memberLimit(limit);
+  if (!isGroupJid(jid)) return {
+    members: [],
+    capability: { supported: false, complete: false, reason: 'WhatsApp member lookup requires a group line (@g.us)' },
+  };
+  const response = await query({
+    tag: 'iq', attrs: { type: 'get', xmlns: 'w:g2', to: jid },
+    content: [{ tag: 'query', attrs: { request: 'interactive' } }],
+  });
+  if (!binaryNode(response)) throw new TrainError('whatsapp_call', 'WhatsApp returned invalid group metadata');
+  const group = extractGroupMetadata(response);
+  const participants = [...new Map(group.participants.map((p) => [p.id, p])).values()];
+  const members = participants.slice(0, cap).map((p) => memberOf(p, names));
+  return {
+    members,
+    capability: capability(memberTotal(response), participants.length, members.length),
+  };
+}

package/runtime/node_modules/@metro-labs/whatsapp/src/messages.ts

@@ -0,0 +1,70 @@
+import { jidNormalizedUser, type Contact, type WASocket } from 'baileys';
+import { bindAppState, noteHistoryContact } from './app-state.js';
+import type { InboundHandlers } from './client-types.js';
+import type { History } from './history.js';
+import type { KeyCache } from './keys.js';
+import { noteContact, type NameBook } from './names.js';
+import { toInbound, toReaction, type SelfRef } from './parse.js';
+
+interface MessageHooks {
+  accountId: string;
+  keys: KeyCache;
+  names: NameBook;
+  history: History;
+  current(): boolean;
+  handlers(): InboundHandlers | undefined;
+  self(): SelfRef;
+}
+
+export function bindMessages(sock: Pick<WASocket, 'ev' | 'user'>, hooks: MessageHooks): void {
+  const selfJid = (): string | undefined => sock.user?.id ? jidNormalizedUser(sock.user.id) : undefined;
+  const noteContacts = (contacts: Partial<Contact>[]): void => {
+    if (!hooks.current()) return;
+    for (const contact of contacts) {
+      noteContact(hooks.names, contact);
+      noteHistoryContact(hooks.history, contact);
+    }
+  };
+  bindAppState(sock.ev, hooks);
+  sock.ev.on('messages.upsert', ({ messages, type }) => {
+    if (!hooks.current()) return;
+    for (const m of messages) hooks.keys.remember(m.key);
+    hooks.history.ingest(messages, selfJid());
+    const handlers = hooks.handlers();
+    if (type !== 'notify' || !handlers) return;
+    for (const m of messages) {
+      if (m.key.fromMe) continue;
+      const inbound = toInbound(hooks.accountId, m, hooks.self());
+      if (!inbound) continue;
+      hooks.names.note(inbound.senderJid, inbound.pushName);
+      handlers.onMessage(inbound, m);
+    }
+  });
+  sock.ev.on('contacts.upsert', noteContacts);
+  sock.ev.on('contacts.update', noteContacts);
+  sock.ev.on('messaging-history.set', ({ contacts, messages, lidPnMappings }) => {
+    if (!hooks.current()) return;
+    noteContacts(contacts);
+    for (const { pn, lid } of lidPnMappings ?? []) hooks.history.alias(pn, lid);
+    for (const m of messages) {
+      hooks.keys.remember(m.key);
+      if (m.key.fromMe !== true) hooks.names.note(m.key.participant ?? m.key.remoteJid, m.pushName);
+    }
+    hooks.history.ingest(messages, selfJid());
+  });
+  sock.ev.on('messages.update', (updates) => {
+    if (hooks.current()) hooks.history.update(updates, selfJid());
+  });
+  sock.ev.on('messages.delete', (event) => {
+    if (hooks.current()) hooks.history.deleteMessages(event);
+  });
+  sock.ev.on('messages.reaction', (events) => {
+    if (!hooks.current()) return;
+    const handlers = hooks.handlers();
+    if (!handlers) return;
+    for (const event of events) {
+      const reaction = toReaction(hooks.accountId, event);
+      if (reaction) handlers.onReaction(reaction);
+    }
+  });
+}

package/runtime/node_modules/@metro-labs/whatsapp/src/send-expiry.ts

@@ -0,0 +1,65 @@
+import type { ChatUpdate, WASocket } from 'baileys';
+import { errMsg, log } from '@metro-labs/core/log';
+import { isGroupJid, isPrivateJid } from './parse.js';
+
+const MAX_CHATS = 2000;
+type Content = Parameters<WASocket['sendMessage']>[1];
+interface Setting { duration: number; at: number }
+
+function duration(value: number | undefined): number | undefined {
+  return value !== undefined && Number.isSafeInteger(value) && value >= 0 ? value : undefined;
+}
+
+function setting(chat: ChatUpdate): Setting | undefined {
+  if (!Object.hasOwn(chat, 'ephemeralExpiration')) return undefined;
+  const seconds = duration(chat.ephemeralExpiration === null ? 0 : chat.ephemeralExpiration);
+  const timestamp = chat.ephemeralSettingTimestamp;
+  const at = typeof timestamp === 'number' ? timestamp : timestamp?.toNumber();
+  if (seconds === undefined || at === undefined || !Number.isSafeInteger(at) || at <= 0) return undefined;
+  return { duration: seconds, at };
+}
+
+export class SendExpiry {
+  private readonly chats = new Map<string, Setting>();
+
+  constructor(private readonly accountId: string) {}
+
+  private note(chat: ChatUpdate): void {
+    if (!chat.id || !isPrivateJid(chat.id)) return;
+    const next = setting(chat);
+    if (!next) return;
+    const known = this.chats.get(chat.id);
+    if (known && known.at > next.at) return;
+    this.chats.delete(chat.id);
+    this.chats.set(chat.id, next);
+    if (this.chats.size > MAX_CHATS) {
+      const oldest = this.chats.keys().next().value;
+      if (oldest !== undefined) this.chats.delete(oldest);
+    }
+  }
+
+  bind(sock: WASocket, current: () => boolean): void {
+    this.chats.clear();
+    const note = (chats: readonly ChatUpdate[]): void => {
+      if (current()) for (const chat of chats) this.note(chat);
+    };
+    sock.ev.on('chats.upsert', note);
+    sock.ev.on('chats.update', note);
+    sock.ev.on('messaging-history.set', ({ chats }) => { note(chats); });
+    sock.ev.on('chats.delete', (jids) => {
+      if (current()) for (const jid of jids) this.chats.delete(jid);
+    });
+  }
+
+  async forSend(sock: WASocket, jid: string, content: Content): Promise<number | undefined> {
+    if ('edit' in content || 'delete' in content || 'react' in content) return undefined;
+    if (!isGroupJid(jid)) return this.chats.get(jid)?.duration;
+    try {
+      const group = await sock.groupMetadata(jid);
+      return duration(group.ephemeralDuration ?? 0);
+    } catch (err) {
+      log.warn({ accountId: this.accountId, err: errMsg(err) }, 'whatsapp: send expiry unknown; local history may omit the message');
+      return undefined;
+    }
+  }
+}

package/runtime/node_modules/@metro-labs/whatsapp/src/station.ts

@@ -2,12 +2,14 @@ import type { Station, Verb } from '@metro-labs/core/stations/types';
 import { PROFILE_FIELDS, type ProfileField } from '@metro-labs/core/stations/profile';
 import { tokenFiles } from './token-store.js';
 import { nameFiles } from './names.js';
+import { historyFiles } from './history-state.js';
 
 export const whatsappStation: Station = {
   name: 'whatsapp',
   hasAccounts: true,
   hasTrain: true,
   messageVerbs: new Set<Verb>([
+    'read',
     'send',
     'reply',
     'react',
@@ -23,10 +25,12 @@ export const whatsappStation: Station = {
   forget: (accountId) => {
     tokenFiles.forget(accountId);
     nameFiles.forget(accountId);
+    historyFiles.forget(accountId);
   },
   forgetExcept: (kept) => {
     tokenFiles.forgetExcept(kept);
     nameFiles.forgetExcept(kept);
+    historyFiles.forgetExcept(kept);
   },
   tools: [],
 };

package/runtime/patches/5bca2c07d5852d3f58453cff0448dd85da13d3665b61e3d758905b298d432d7c.patch

@@ -0,0 +1,31 @@
+diff --git a/lib/Types/Events.d.ts b/lib/Types/Events.d.ts
+index f55c4c325b08b8c25dc9d17032514ce5c80ad3fd..930cb143e813b9a656533ae765f9db70f6eb7ccd 100644
+--- a/lib/Types/Events.d.ts
++++ b/lib/Types/Events.d.ts
+@@ -46,6 +46,10 @@ export type BaileysEventMap = {
+     'lid-mapping.update': LIDMapping;
+     /** delete chats with given ID */
+     'chats.delete': string[];
++    'chats.clear': {
++        id: string;
++        messageRange?: proto.SyncActionValue.ISyncActionMessageRange | null;
++    };
+     /** presence of contact in a chat updated */
+     'presence.update': {
+         id: string;
+diff --git a/lib/Utils/chat-utils.js b/lib/Utils/chat-utils.js
+index c30265d36671bacd25a8c456cafedcd9fc2fdd9a..2be37df069eda49c546eac1eb3485e649432dbeb 100644
+--- a/lib/Utils/chat-utils.js
++++ b/lib/Utils/chat-utils.js
+@@ -763,7 +763,11 @@ export const processSyncAction = (syncAction, ev, me, initialSyncOpts, logger) =
+             }
+         ]);
+     }
++    else if (action?.clearChatAction || type === 'clearChat') {
++        ev.emit('chats.clear', { id, messageRange: action?.clearChatAction?.messageRange });
++    }
+     else if (action?.deleteChatAction || type === 'deleteChat') {
++        ev.emit('chats.clear', { id, messageRange: action?.deleteChatAction?.messageRange });
+         if (!isInitialSync) {
+             ev.emit('chats.delete', [id]);
+         }

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.262"
+  "version": "0.1.0-beta.264"
 }

package/runtime/sdk-runner/node_modules/@metro-labs/core/src/events.ts

@@ -85,7 +85,51 @@ export interface BufferedEvent {
   event: MetroEvent;
 }
 
-const BUS_BUFFER_MAX = 500;
+export const BUS_BUFFER_MAX = 500;
+
+export interface RunEventMetadata {
+  isPrivate?: boolean;
+  senderVerified?: boolean;
+  mentionsSelf?: boolean;
+  replyToSelf?: boolean;
+  emoji?: string;
+  removed?: boolean;
+  targetId?: string;
+  attachmentCount?: number;
+  attachmentTypes?: ('image' | 'video' | 'audio' | 'file')[];
+  attachmentStatus?: 'saved' | 'failed';
+  attachmentFor?: string;
+}
+
+export interface RunEvent {
+  id: string;
+  seq: number;
+  ts: string;
+  kind: StructuredEvent['type'];
+  direction: 'inbound' | 'outbound' | 'system';
+  agentId: string;
+  station: string;
+  accountId: string | null;
+  line: string;
+  lineName?: string;
+  from?: string;
+  fromName?: string;
+  fromDisplayName?: string;
+  to?: string;
+  text?: string;
+  truncated: boolean;
+  messageId?: string;
+  replyTo?: string;
+  metadata: RunEventMetadata;
+}
+
+export interface RunEventsPage {
+  events: RunEvent[];
+  cursor: string;
+  hasMore: boolean;
+  reset: boolean;
+  retention: { capacity: number; oldestAt: string | null; oldestSeq: number | null };
+}
 
 const listeners = new Set<BusListener>();
 const buffer: BufferedEvent[] = [];

package/runtime/sdk-runner/node_modules/@metro-labs/core/src/stations/train-boot.ts

@@ -1,4 +1,4 @@
-import { errMsg } from '../log.js';
+import { errMsg, logFatalSync } from '../log.js';
 import { readCalls } from '../protocol.js';
 import { TrainError } from '../train-error.js';
 import type { CallMsg } from './station-runtime.js';
@@ -18,12 +18,33 @@ export interface ClientTrain<A extends { id: string }, C> {
   loadAccounts: () => A[];
   createClient: (account: A) => C;
   startInbound: (client: C) => Promise<void>;
+  disconnectClient?: (client: C) => Promise<void>;
   makeHandleCall: (clientFor: (accountId: string) => C) => (msg: CallMsg) => Promise<void>;
 }
 
 export function runClientTrain<A extends { id: string }, C>(train: ClientTrain<A, C>): void {
   const clients = new Map<string, C>();
+  let stopping = false;
+  if (train.disconnectClient) {
+    const disconnect = train.disconnectClient;
+    const shutdown = (): void => {
+      if (stopping) return;
+      stopping = true;
+      process.stdin.pause();
+      Promise.allSettled([...clients.values()].map(async (client) => { await disconnect(client); })).then((results) => {
+        const errors = results.flatMap((result) => result.status === 'rejected' ? [errMsg(result.reason)] : []);
+        if (errors.length) logFatalSync({ station: train.station, errors }, 'train: shutdown failed');
+        process.exit(errors.length ? 1 : 0);
+      }).catch((err: unknown) => {
+        logFatalSync({ station: train.station, err: errMsg(err) }, 'train: shutdown failed');
+        process.exit(1);
+      });
+    };
+    process.on('SIGTERM', shutdown);
+    process.on('SIGINT', shutdown);
+  }
   const clientFor = (accountId: string): C => {
+    if (stopping) throw new TrainError('train_stopping', `${train.station} is shutting down`);
     const known = clients.get(accountId);
     if (known !== undefined) return known;
     const account = train.accounts.get(accountId);

package/runtime/sdk-runner/runner.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.1.0-beta.262",
+  "version": "0.1.0-beta.264",
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "0.3.287",
     "@modelcontextprotocol/sdk": "^1.29.0",

package/runtime/stations.json

@@ -36,5 +36,8 @@
     "outlook": {},
     "gmail": {},
     "webhook": {}
+  },
+  "patchedDependencies": {
+    "baileys@7.0.0-rc14": "patches/5bca2c07d5852d3f58453cff0448dd85da13d3665b61e3d758905b298d432d7c.patch"
   }
 }