@stage-labs/metro 0.1.0-beta.32 → 0.1.0-beta.321

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

@@ -3,8 +3,8 @@ import {
   assertAttachmentSize,
   saveStreamToCache,
   type SavedAttachment,
-} from '@metro-labs/mcp/stations/attachments';
-import { TrainError } from '@metro-labs/mcp/train-error';
+} from '@metro-labs/core/stations/attachments';
+import { TrainError } from '@metro-labs/core/train-error';
 import { baileysLogger } from './logger.js';
 import type { WAMediaRef } from './media.js';
 

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

@@ -8,7 +8,7 @@ import {
   type SignalDataTypeMap,
   type SignalKeyStore,
 } from 'baileys';
-import { TrainError } from '@metro-labs/mcp/train-error';
+import { TrainError } from '@metro-labs/core/train-error';
 import {
   isPersistedKeyType,
   tokenStoreFor,

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

@@ -0,0 +1,137 @@
+import { readFileSync, statSync } from 'node:fs';
+import { isRecord } from '@metro-labs/core/is-record';
+import { errMsg, log } from '@metro-labs/core/log';
+import { writeSecure } from '@metro-labs/core/secure-fs';
+import { accountFiles } from '@metro-labs/core/stations/account-files';
+import { DIRECTORY_LIMIT, type ChannelEntry } from '@metro-labs/core/stations/channel-directory';
+import { lineOf } from './accounts.js';
+
+export const channelFiles = accountFiles('WHATSAPP_TOKEN_DIR', 'whatsapp-channels-');
+const FILE_BYTES = 16 * 1024 * 1024;
+const NAME_LIMIT = 256;
+
+interface ChatMetadata {
+  id?: string | null;
+  name?: string | null;
+  conversationTimestamp?: number | { toNumber(): number } | null;
+}
+
+interface StoredChat {
+  id: string;
+  name?: string;
+  deleted?: true;
+  deletedAt?: number;
+}
+
+function directId(value: unknown): string | undefined {
+  if (typeof value !== 'string' || value.length > 128 || !/^\d+(?::\d+)?@(s\.whatsapp\.net|lid)$/.test(value)) return undefined;
+  return value.replace(/:\d+@/, '@');
+}
+
+export function channelName(value: unknown): string | undefined {
+  return typeof value === 'string' ? value.trim().slice(0, NAME_LIMIT) || undefined : undefined;
+}
+
+function deletionTime(value: unknown): number {
+  return typeof value === 'number' && Number.isSafeInteger(value) && value > 0 ? value : Date.now();
+}
+
+function newerActivity(chat: ChatMetadata, deletedAt: number): boolean {
+  const value = chat.conversationTimestamp;
+  const seconds = typeof value === 'number' ? value : value?.toNumber();
+  if (seconds === undefined || !Number.isSafeInteger(seconds)) return false;
+  const at = seconds * 1000;
+  return at > deletedAt && at <= Date.now();
+}
+
+function blocked(chat: ChatMetadata, prior: StoredChat | undefined, fresh: boolean): boolean {
+  return prior?.deleted === true && (!fresh || !newerActivity(chat, deletionTime(prior.deletedAt)));
+}
+
+function storedChat(row: unknown): StoredChat | undefined {
+  if (!isRecord(row)) return undefined;
+  const id = directId(row.id);
+  if (!id) return undefined;
+  return row.deleted === true
+    ? { id, deleted: true, deletedAt: deletionTime(row.deletedAt) }
+    : { id, name: channelName(row.name) };
+}
+
+export class KnownChats {
+  private readonly chats = new Map<string, StoredChat>();
+  private readonly file: string;
+
+  constructor(private readonly accountId: string) {
+    this.file = channelFiles.path(accountId);
+    this.load();
+  }
+
+  private load(): void {
+    try {
+      if (statSync(this.file).size > FILE_BYTES) throw new Error('channel metadata file is too large');
+      const raw: unknown = JSON.parse(readFileSync(this.file, 'utf8'));
+      if (!Array.isArray(raw)) throw new Error('invalid channel metadata');
+      for (const row of raw.slice(-DIRECTORY_LIMIT)) {
+        const chat = storedChat(row);
+        if (chat) this.put(chat);
+      }
+    } catch (err) {
+      if (isRecord(err) && err.code === 'ENOENT') return;
+      log.warn({ accountId: this.accountId, err: errMsg(err) }, 'whatsapp: could not load channel metadata');
+    }
+  }
+
+  private put(row: StoredChat): void {
+    this.chats.delete(row.id);
+    this.chats.set(row.id, row);
+    if (this.chats.size > DIRECTORY_LIMIT) {
+      const oldest = this.chats.keys().next().value;
+      if (oldest !== undefined) this.chats.delete(oldest);
+    }
+  }
+
+  private save(): void {
+    try {
+      writeSecure(this.file, JSON.stringify([...this.chats.values()]));
+    } catch (err) {
+      log.warn({ accountId: this.accountId, err: errMsg(err) }, 'whatsapp: could not save channel metadata');
+    }
+  }
+
+  private noteChat(chat: ChatMetadata, fresh: boolean): boolean {
+    const id = directId(chat.id);
+    if (!id) return false;
+    const prior = this.chats.get(id);
+    if (blocked(chat, prior, fresh)) return false;
+    const name = channelName(chat.name) ?? prior?.name;
+    if (prior && !prior.deleted && prior.name === name) return false;
+    this.put({ id, name });
+    return true;
+  }
+
+  note(chats: readonly ChatMetadata[], fresh = false): void {
+    let changed = false;
+    for (const chat of chats) {
+      if (this.noteChat(chat, fresh)) changed = true;
+    }
+    if (changed) this.save();
+  }
+
+  remove(ids: readonly string[]): void {
+    let changed = false;
+    for (const value of ids) {
+      const id = directId(value);
+      if (!id) continue;
+      const deletedAt = Math.max(Date.now(), this.chats.get(id)?.deletedAt ?? 0);
+      this.put({ id, deleted: true, deletedAt });
+      changed = true;
+    }
+    if (changed) this.save();
+  }
+
+  list(): ChannelEntry[] {
+    return [...this.chats.values()].filter((chat) => !chat.deleted).map(({ id, name }) => ({
+      id, line: lineOf(this.accountId, id), kind: 'direct', ...(name ? { name } : {}),
+    }));
+  }
+}

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

@@ -0,0 +1,48 @@
+import type { WASocket } from 'baileys';
+import { ChannelDirectory, DIRECTORY_LIMIT, type ChannelEntry, type ChannelList } from '@metro-labs/core/stations/channel-directory';
+import { lineOf } from './accounts.js';
+import { KnownChats, channelName } from './channel-chats.js';
+
+const REASON = `Participating groups come from WhatsApp. Direct chats are limited to at most ${DIRECTORY_LIMIT} chat metadata records observed or synced to this installation; WhatsApp has no all-direct-chats directory. Cleared chats are omitted, and WhatsApp channels are not enumerated.`;
+
+export class WhatsAppChannels {
+  private readonly chats: KnownChats;
+  private readonly directory = new ChannelDirectory();
+
+  constructor(private readonly accountId: string) {
+    this.chats = new KnownChats(accountId);
+  }
+
+  bind(sock: Pick<WASocket, 'ev'>, current: () => boolean): void {
+    sock.ev.on('chats.upsert', (chats) => {
+      if (current()) this.chats.note(chats, true);
+    });
+    sock.ev.on('chats.update', (chats) => {
+      if (current()) this.chats.note(chats, true);
+    });
+    sock.ev.on('messaging-history.set', ({ chats }) => {
+      if (current()) this.chats.note(chats);
+    });
+    sock.ev.on('chats.delete', (ids) => {
+      if (current()) this.chats.remove(ids);
+    });
+    sock.ev.on('chats.clear', ({ id }) => {
+      if (current()) this.chats.remove([id]);
+    });
+  }
+
+  list(ready: () => Promise<Pick<WASocket, 'groupFetchAllParticipating'>>, args: Record<string, unknown>): Promise<ChannelList> {
+    return this.directory.list(this.accountId, args, async () => {
+      const groups = await (await ready()).groupFetchAllParticipating();
+      const channels: ChannelEntry[] = [];
+      for (const group of Object.values(groups)) {
+        if (!/^\d+(?:-\d+)?@g\.us$/.test(group.id) || group.id.length > 128) continue;
+        const name = channelName(group.subject);
+        channels.push({ id: group.id, line: lineOf(this.accountId, group.id), kind: 'group', ...(name ? { name } : {}) });
+        if (channels.length > DIRECTORY_LIMIT) break;
+      }
+      channels.push(...this.chats.list());
+      return { channels, capability: { supported: true, complete: false, source: 'mixed', reason: REASON } };
+    });
+  }
+}

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

@@ -0,0 +1,31 @@
+import { log } from '@metro-labs/core/log';
+import { TrainError } from '@metro-labs/core/train-error';
+import { supportsHistoryDeletion } from './app-state.js';
+import { createHistory, type History } from './history.js';
+
+const UNAVAILABLE = 'WhatsApp local history is unavailable because this runtime lacks the deletion patch. Ask the owner to update and restart Metro to load the patched runtime. Prior history was invalidated to avoid stale deleted messages.';
+const ignore = (): void => undefined;
+
+export function createClientHistory(accountId: string, supported = supportsHistoryDeletion()): History {
+  const history = createHistory(accountId);
+  if (supported) return history;
+  try {
+    history.invalidate();
+  } finally {
+    history.close();
+  }
+  log.warn({ accountId }, UNAVAILABLE);
+  return {
+    read() { throw new TrainError('whatsapp_history_unavailable', UNAVAILABLE); },
+    ingest: ignore,
+    ingestSent: ignore,
+    alias: ignore,
+    clearRange: ignore,
+    invalidate: ignore,
+    update: ignore,
+    deleteMessages: ignore,
+    edit: ignore,
+    flush: ignore,
+    close: ignore,
+  };
+}

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

@@ -0,0 +1,50 @@
+import type makeWASocket from 'baileys';
+import type { fetchLatestWaWebVersion, WAMessage } from 'baileys';
+import type { MemberList } from '@metro-labs/core/stations/types';
+import type { ChannelList } from '@metro-labs/core/stations/channel-directory';
+import type { ProfileChange } from '@metro-labs/core/stations/profile';
+import type { SenderProfile } from '@metro-labs/core/stations/sender-profile';
+import type { AccountStatus } from '@metro-labs/core/stations/account-status';
+import type { WhatsAppAccount } from './types.js';
+import type { InboundMessage, ReactionInput } from './format.js';
+import type { SenderFound } from './resolve.js';
+import type { HistoryOptions, HistoryPage } from './history.js';
+
+export interface InboundHandlers {
+  onMessage(m: InboundMessage, raw: WAMessage): void;
+  onReaction(r: ReactionInput): void;
+}
+
+export interface WAMedia {
+  kind: string;
+  path: string;
+  mime: string;
+  name: string;
+  caption?: string;
+}
+
+export interface WAClient {
+  account: WhatsAppAccount;
+  self(): string | null;
+  status(): AccountStatus;
+  start(handlers: InboundHandlers): Promise<void>;
+  read(jid: string, options?: HistoryOptions): Promise<HistoryPage>;
+  listMembers(jid: string, limit?: number): Promise<MemberList>;
+  listChannels(args: Record<string, unknown>): Promise<ChannelList>;
+  sendText(jid: string, text: string, quotedId?: string): Promise<string>;
+  sendMedia(jid: string, media: WAMedia, quotedId?: string): Promise<string>;
+  sendReaction(jid: string, messageId: string, emoji: string): Promise<void>;
+  showTyping(jid: string): Promise<void>;
+  editMessage(jid: string, messageId: string, text: string): Promise<void>;
+  deleteMessage(jid: string, messageId: string): Promise<void>;
+  reuploadMedia(m: WAMessage): Promise<WAMessage>;
+  lookupSender(number: string): Promise<SenderFound>;
+  setProfile(change: ProfileChange): Promise<void>;
+  senderProfile(jid: string): Promise<SenderProfile | null>;
+  disconnect(): Promise<void>;
+}
+
+export interface ClientRuntime {
+  makeSocket: typeof makeWASocket;
+  fetchVersion: typeof fetchLatestWaWebVersion;
+}