cli-whatsapp 0.1.1 → 0.1.2

package/src/utils/format.ts

@@ -1,102 +0,0 @@
-import type { ChatRow, MessageRow } from '../db/sqlite.ts';
-
-// Minimal ANSI styling — no dependency, respects NO_COLOR.
-const useColor = !process.env.NO_COLOR && process.stdout.isTTY;
-const wrap = (code: string) => (s: string | number) =>
-  useColor ? `\x1b[${code}m${s}\x1b[0m` : String(s);
-// 24-bit truecolor for brand colors (modern terminals). Falls back to plain
-// text under NO_COLOR / non-TTY.
-const rgb = (r: number, g: number, b: number) => (s: string | number) =>
-  useColor ? `\x1b[38;2;${r};${g};${b}m${s}\x1b[0m` : String(s);
-
-// WhatsApp brand palette.
-export const BRAND = {
-  green: [37, 211, 102] as const, // #25D366 signature green
-  teal: [18, 140, 126] as const, // #128C7E
-  darkTeal: [7, 94, 84] as const, // #075E54
-};
-
-export const c = {
-  bold: wrap('1'),
-  dim: wrap('2'),
-  green: rgb(...BRAND.green), // WhatsApp green (used for "me", ✓, accents)
-  teal: rgb(...BRAND.teal),
-  darkTeal: rgb(...BRAND.darkTeal),
-  cyan: wrap('36'),
-  yellow: wrap('33'),
-  magenta: wrap('35'),
-  red: wrap('31'),
-  gray: wrap('90'),
-};
-
-/** Human-friendly timestamp. Absolute time for today, date otherwise. */
-export function formatTime(ms: number, time24h = true): string {
-  if (!ms) return '';
-  const d = new Date(ms);
-  const now = new Date();
-  const sameDay =
-    d.getFullYear() === now.getFullYear() &&
-    d.getMonth() === now.getMonth() &&
-    d.getDate() === now.getDate();
-  const time = d.toLocaleTimeString(undefined, {
-    hour: '2-digit',
-    minute: '2-digit',
-    hour12: !time24h,
-  });
-  if (sameDay) return time;
-  const date = d.toLocaleDateString(undefined, {
-    month: 'short',
-    day: 'numeric',
-  });
-  return `${date} ${time}`;
-}
-
-export function displayName(chat: ChatRow): string {
-  if (chat.name) return chat.name;
-  // Fall back to the phone number portion of a direct jid.
-  const num = chat.jid.split('@')[0];
-  return chat.isGroup ? `Group ${num}` : `+${num}`;
-}
-
-/** Render the numbered chat list shown by `wa chats`. */
-export function renderChatList(chats: ChatRow[], time24h = true): string {
-  if (chats.length === 0) {
-    return c.dim('No chats yet. Run `wa sync` after logging in.');
-  }
-  const width = String(chats.length).length;
-  return chats
-    .map((chat, i) => {
-      const idx = c.dim(String(i + 1).padStart(width) + '.');
-      const name = c.bold(displayName(chat));
-      const pin = chat.pinned ? c.yellow(' 📌') : '';
-      const unread =
-        chat.unreadCount > 0 ? c.green(` (${chat.unreadCount})`) : '';
-      const time = c.gray(formatTime(chat.lastTimestamp, time24h));
-      const preview = c.dim(truncate(chat.lastMessage ?? '', 48));
-      return `${idx} ${name}${pin}${unread}  ${time}\n     ${preview}`;
-    })
-    .join('\n');
-}
-
-/** Render a conversation transcript for `wa open` / `wa history`. */
-export function renderMessages(
-  messages: MessageRow[],
-  time24h = true,
-): string {
-  if (messages.length === 0) return c.dim('No messages.');
-  return messages
-    .map((m) => {
-      const time = c.gray(formatTime(m.timestamp, time24h));
-      const who = m.fromMe ? c.green('me') : c.cyan(m.sender ?? 'unknown');
-      const body =
-        m.text ?? (m.type ? c.dim(`[${m.type}]`) : c.dim('[no text]'));
-      const id = c.dim(`#${m.id}`);
-      return `${time} ${who}: ${body} ${id}`;
-    })
-    .join('\n');
-}
-
-export function truncate(s: string, n: number): string {
-  const oneLine = s.replace(/\s+/g, ' ').trim();
-  return oneLine.length > n ? oneLine.slice(0, n - 1) + '…' : oneLine;
-}

package/src/utils/jid.ts

@@ -1,51 +0,0 @@
-import { findChat, findContact, type ChatRow } from '../db/sqlite.ts';
-
-/** A raw phone number like +1 (415) 555-0000 → 14155550000@s.whatsapp.net */
-export function phoneToJid(input: string): string | null {
-  const digits = input.replace(/[^\d]/g, '');
-  if (digits.length < 7) return null;
-  return `${digits}@s.whatsapp.net`;
-}
-
-export interface ResolvedTarget {
-  jid: string;
-  name: string;
-  /** true when we matched a known chat, false when built from a raw number. */
-  known: boolean;
-}
-
-/**
- * Resolve a user-supplied chat target to a jid.
- * Order: exact jid → known chat (name/fuzzy) → raw phone number.
- * Returns null when nothing plausible matches.
- */
-export function resolveTarget(query: string): ResolvedTarget | null {
-  const q = query.trim();
-  if (!q) return null;
-
-  // Already a full jid (ends with a WhatsApp domain, no spaces). Note: a
-  // contact name can contain "@" (e.g. "Vishwas @Mobius"), so we must match the
-  // domain suffix, not merely the presence of "@".
-  if (/^\S+@(s\.whatsapp\.net|g\.us|lid|c\.us|broadcast)$/.test(q)) {
-    return { jid: q, name: q, known: false };
-  }
-
-  const chat: ChatRow | null = findChat(q);
-  if (chat) {
-    return { jid: chat.jid, name: chat.name ?? chat.jid, known: true };
-  }
-
-  // Known contact with no existing chat yet (e.g. first message to someone).
-  const contact = findContact(q);
-  if (contact) {
-    return { jid: contact.jid, name: contact.name ?? contact.jid, known: true };
-  }
-
-  // Looks like a phone number.
-  if (/^[+\d][\d\s()\-]{5,}$/.test(q)) {
-    const jid = phoneToJid(q);
-    if (jid) return { jid, name: q, known: false };
-  }
-
-  return null;
-}

package/src/utils/notify.ts

@@ -1,29 +0,0 @@
-import { execFile } from 'node:child_process';
-import { platform } from 'node:os';
-
-/**
- * Fire a native desktop notification. Best-effort and non-blocking: shells out
- * to the platform notifier (macOS `osascript`, Linux `notify-send`). Any
- * failure (tool missing, no display) is silently ignored — notifications must
- * never break the CLI.
- */
-export function notify(title: string, body: string): void {
-  try {
-    const p = platform();
-    if (p === 'darwin') {
-      const esc = (s: string) => s.replace(/[\\"]/g, '\\$&');
-      const script = `display notification "${esc(clip(body))}" with title "${esc(clip(title))}"`;
-      execFile('osascript', ['-e', script], () => {});
-    } else if (p === 'linux') {
-      execFile('notify-send', ['-a', 'WhatsApp CLI', clip(title), clip(body)], () => {});
-    }
-    // Windows: no reliable dependency-free path; skipped intentionally.
-  } catch {
-    /* notifications are best-effort */
-  }
-}
-
-function clip(s: string): string {
-  const oneLine = s.replace(/\s+/g, ' ').trim();
-  return oneLine.length > 120 ? oneLine.slice(0, 119) + '…' : oneLine;
-}

package/src/utils/ui.ts

@@ -1,35 +0,0 @@
-import { c } from './format.ts';
-
-export function ok(msg: string): void {
-  process.stdout.write(`${c.green('✓')} ${msg}\n`);
-}
-
-export function info(msg: string): void {
-  process.stdout.write(`${c.cyan('›')} ${msg}\n`);
-}
-
-export function warn(msg: string): void {
-  process.stderr.write(`${c.yellow('!')} ${msg}\n`);
-}
-
-/** A user-facing, expected error (bad input, no session, etc.). */
-export class AppError extends Error {}
-
-/**
- * Abort the current command with a user-facing message. Throws an AppError so
- * callers decide how to handle it: the CLI prints it and exits non-zero; the
- * interactive shell prints it and keeps the session alive.
- */
-export function fail(msg: string): never {
-  throw new AppError(msg);
-}
-
-/** Render an error the way the CLI/shell should display it. */
-export function printError(err: unknown): void {
-  const msg = err instanceof Error ? err.message : String(err);
-  process.stderr.write(`${c.red('✗')} ${msg}\n`);
-}
-
-export function print(msg = ''): void {
-  process.stdout.write(msg + '\n');
-}

package/src/whatsapp/client.ts

@@ -1,207 +0,0 @@
-import makeWASocket, {
-  useMultiFileAuthState,
-  fetchLatestBaileysVersion,
-  makeCacheableSignalKeyStore,
-  Browsers,
-  DisconnectReason,
-} from '@whiskeysockets/baileys';
-import type { WASocket } from '@whiskeysockets/baileys';
-import { existsSync, readFileSync, rmSync, mkdirSync } from 'node:fs';
-import { join } from 'node:path';
-import { PATHS, ensureDirs } from '../config/index.ts';
-import { logger } from './logger.ts';
-
-export type Socket = WASocket;
-
-export interface ConnectOptions {
-  /** Called with each QR string so the caller can render it (login only). */
-  onQR?: (qr: string) => void;
-  /** Pull full message history on connect (used by `sync`). */
-  syncFullHistory?: boolean;
-  /** Reject instead of showing a QR when no valid session exists. */
-  requireSession?: boolean;
-  /**
-   * Log in with a short pairing code instead of a QR. Provide the phone number
-   * in international format (digits only). The code is delivered via onPairingCode.
-   */
-  pairingPhone?: string;
-  onPairingCode?: (code: string) => void;
-}
-
-export interface Connection {
-  sock: Socket;
-  /** Persist updated credentials to disk. */
-  saveCreds: () => Promise<void>;
-  /** Resolves when the socket reaches the "open" state. */
-  ready: Promise<void>;
-  /** Cleanly end the socket. */
-  close: () => void;
-}
-
-/** Extract the numeric status code from a Baileys disconnect error. */
-function statusCode(err: unknown): number | undefined {
-  return (err as { output?: { statusCode?: number } })?.output?.statusCode;
-}
-
-/**
- * Serialized chain of pending credential writes. WhatsApp streams `creds.update`
- * events whose `saveCreds()` writes to disk asynchronously; exiting the process
- * mid-write corrupts the session. Callers must `await whenWritesSettled()`
- * before `process.exit()`.
- */
-let pendingWrites: Promise<void> = Promise.resolve();
-
-export function whenWritesSettled(): Promise<void> {
-  return pendingWrites;
-}
-
-/**
- * A session counts as linked when creds.json exists, parses, and carries the
- * account identity (`me.id`) — that's set only after a device is fully linked
- * and it persists. (The `registered` flag is unreliable: it can remain false
- * after a successful QR link due to write ordering across the 515 reconnect.)
- * A missing, corrupt, or half-written creds file has no `me.id` → "not linked".
- */
-export function hasSession(): boolean {
-  const p = join(PATHS.sessions, 'creds.json');
-  if (!existsSync(p)) return false;
-  try {
-    const creds = JSON.parse(readFileSync(p, 'utf8'));
-    return !!creds?.me?.id || creds?.registered === true;
-  } catch {
-    return false;
-  }
-}
-
-/** Delete the local session (used when it's dead / logged out server-side). */
-export function clearSession(): void {
-  rmSync(PATHS.sessions, { recursive: true, force: true });
-  mkdirSync(PATHS.sessions, { recursive: true });
-}
-
-/**
- * Establish a connection with a single QR/open lifecycle. Reconnection on
- * transient drops is handled by callers via {@link runWithConnection}, which
- * recreates the connection when appropriate.
- */
-export async function connect(opts: ConnectOptions = {}): Promise<Connection> {
-  ensureDirs();
-
-  if (opts.requireSession && !hasSession()) {
-    throw new Error('Not logged in. Run `wa login` first.');
-  }
-
-  const { state, saveCreds } = await useMultiFileAuthState(PATHS.sessions);
-  const { version } = await fetchLatestBaileysVersion();
-
-  const sock = makeWASocket({
-    version,
-    logger: logger as never,
-    printQRInTerminal: false,
-    auth: {
-      creds: state.creds,
-      keys: makeCacheableSignalKeyStore(state.keys, logger as never),
-    },
-    browser: Browsers.macOS('WhatsApp CLI'),
-    syncFullHistory: opts.syncFullHistory ?? false,
-    markOnlineOnConnect: false,
-    generateHighQualityLinkPreview: false,
-  });
-
-  // Serialize creds writes and track them so the process never exits mid-write.
-  sock.ev.on('creds.update', () => {
-    pendingWrites = pendingWrites.then(() => saveCreds()).catch(() => {});
-  });
-
-  let resolveReady!: () => void;
-  let rejectReady!: (err: Error) => void;
-  const ready = new Promise<void>((res, rej) => {
-    resolveReady = res;
-    rejectReady = rej;
-  });
-
-  let pairingRequested = false;
-  sock.ev.on('connection.update', (update) => {
-    const { connection, lastDisconnect, qr } = update;
-    if (qr) {
-      if (opts.pairingPhone) {
-        // Pairing-code mode: request the code once on the first `qr` (which
-        // signals the socket is ready to pair). Ignore all later qr refreshes —
-        // never render a QR, and never re-request (that would change the code).
-        if (!pairingRequested) {
-          pairingRequested = true;
-          void sock
-            .requestPairingCode(opts.pairingPhone)
-            .then((code) => opts.onPairingCode?.(code))
-            .catch((e) =>
-              rejectReady(new Error(`PAIRING_FAILED:${(e as Error).message}`)),
-            );
-        }
-      } else if (opts.onQR) {
-        opts.onQR(qr);
-      }
-    }
-    if (connection === 'open') {
-      resolveReady();
-    } else if (connection === 'close') {
-      const code = statusCode(lastDisconnect?.error);
-      const loggedOut = code === DisconnectReason.loggedOut;
-      const err = new Error(
-        loggedOut
-          ? 'LOGGED_OUT'
-          : `CONNECTION_CLOSED:${code ?? 'unknown'}`,
-      );
-      rejectReady(err);
-    }
-  });
-
-  return {
-    sock,
-    saveCreds,
-    ready,
-    close: () => {
-      try {
-        sock.end(undefined);
-      } catch {
-        /* already closed */
-      }
-    },
-  };
-}
-
-/**
- * Run a task with an open connection, auto-reconnecting on transient drops.
- * Rejects on logout or after exhausting retries. Always closes the socket.
- */
-export async function runWithConnection<T>(
-  task: (conn: Connection) => Promise<T>,
-  opts: ConnectOptions & { maxRetries?: number } = {},
-): Promise<T> {
-  const maxRetries = opts.maxRetries ?? 3;
-  let attempt = 0;
-  // eslint-disable-next-line no-constant-condition
-  while (true) {
-    const conn = await connect(opts);
-    try {
-      await conn.ready;
-      const result = await task(conn);
-      return result;
-    } catch (err) {
-      const msg = (err as Error).message ?? '';
-      if (msg === 'LOGGED_OUT') {
-        conn.close();
-        throw new Error(
-          'Session logged out. Run `wa logout` then `wa login` again.',
-        );
-      }
-      if (attempt++ >= maxRetries) {
-        conn.close();
-        throw err;
-      }
-      // brief backoff before reconnecting
-      await new Promise((r) => setTimeout(r, 1000 * attempt));
-    } finally {
-      conn.close();
-    }
-  }
-}

package/src/whatsapp/events.ts

@@ -1,166 +0,0 @@
-import { proto } from '@whiskeysockets/baileys';
-import type { WAMessage } from '@whiskeysockets/baileys';
-import type { Socket } from './client.ts';
-import { insertMessage, upsertChat, upsertContact } from '../db/sqlite.ts';
-
-/** A value that is either a plain number or a protobuf Long (has toNumber). */
-type NumberLike = number | { toNumber: () => number } | null | undefined;
-
-/** Baileys timestamps are seconds (sometimes Long); normalize to ms. */
-export function toMs(ts: NumberLike): number {
-  if (ts == null) return 0;
-  const n = typeof ts === 'number' ? ts : ts.toNumber();
-  if (!Number.isFinite(n) || n <= 0) return 0;
-  return n < 1e12 ? n * 1000 : n; // treat >=1e12 as already-ms
-}
-
-export function isGroupJid(jid: string | null | undefined): boolean {
-  return !!jid && jid.endsWith('@g.us');
-}
-
-/** Best-effort plain-text extraction from any WhatsApp message content. */
-export function extractText(message: proto.IMessage | null | undefined): string {
-  if (!message) return '';
-  return (
-    message.conversation ||
-    message.extendedTextMessage?.text ||
-    message.imageMessage?.caption ||
-    message.videoMessage?.caption ||
-    message.documentMessage?.caption ||
-    message.documentWithCaptionMessage?.message?.documentMessage?.caption ||
-    message.buttonsResponseMessage?.selectedDisplayText ||
-    message.listResponseMessage?.title ||
-    message.templateButtonReplyMessage?.selectedDisplayText ||
-    (message.reactionMessage?.text
-      ? `reacted ${message.reactionMessage.text}`
-      : '') ||
-    ''
-  );
-}
-
-/** Classify a message by its dominant content type (for filtering/media). */
-export function messageType(message: proto.IMessage | null | undefined): string {
-  if (!message) return 'unknown';
-  if (message.conversation || message.extendedTextMessage) return 'text';
-  if (message.imageMessage) return 'image';
-  if (message.videoMessage) return 'video';
-  if (message.audioMessage) return 'audio';
-  if (message.documentMessage || message.documentWithCaptionMessage)
-    return 'document';
-  if (message.stickerMessage) return 'sticker';
-  if (message.locationMessage) return 'location';
-  if (message.contactMessage) return 'contact';
-  if (message.reactionMessage) return 'reaction';
-  return 'other';
-}
-
-/** Persist a single Baileys message into the local cache. */
-export function persistMessage(msg: WAMessage): void {
-  const jid = msg.key.remoteJid;
-  if (!jid || jid === 'status@broadcast') return;
-
-  const text = extractText(msg.message);
-  const type = messageType(msg.message);
-  const ts = toMs(msg.messageTimestamp as number);
-  const fromMe = !!msg.key.fromMe;
-  const sender = fromMe ? 'me' : msg.pushName || msg.key.participant || jid;
-
-  // For media, keep the raw content so `wa download` can decrypt it later.
-  const isMedia = ['image', 'video', 'audio', 'document', 'sticker'].includes(type);
-  let raw: string | null = null;
-  if (isMedia && msg.message) {
-    try {
-      // Protobuf-encode so binary fields (mediaKey, etc.) survive round-trips.
-      raw = Buffer.from(proto.Message.encode(msg.message).finish()).toString('base64');
-    } catch {
-      raw = null;
-    }
-  }
-
-  insertMessage({
-    chatJid: jid,
-    messageId: msg.key.id ?? `${ts}`,
-    sender,
-    text: text || null,
-    timestamp: ts,
-    status: undefined,
-    type,
-    fromMe,
-    raw,
-  });
-
-  // Keep the chat row's "last message" preview fresh.
-  upsertChat({
-    jid,
-    name: isGroupJid(jid) ? undefined : !fromMe ? msg.pushName || undefined : undefined,
-    lastMessage: text || `[${type}]`,
-    lastTimestamp: ts,
-    isGroup: isGroupJid(jid) ? 1 : 0,
-  });
-
-  // Record the direct contact's push name when we learn it.
-  if (!isGroupJid(jid) && !fromMe && msg.pushName) {
-    upsertContact({ jid, name: msg.pushName });
-  }
-}
-
-/**
- * Register all persistence handlers on a live socket. Used by `sync` (batch
- * history) and `watch` (live stream). Returns nothing; handlers persist to DB.
- */
-export function registerPersistence(
-  sock: Socket,
-  hooks: { onMessage?: (msg: WAMessage) => void } = {},
-): void {
-  // Live + recent messages.
-  sock.ev.on('messages.upsert', ({ messages }) => {
-    for (const msg of messages) {
-      persistMessage(msg);
-      hooks.onMessage?.(msg);
-    }
-  });
-
-  // Bulk history sync delivered after login / on demand.
-  sock.ev.on('messaging-history.set', ({ chats, contacts, messages }) => {
-    for (const c of chats) {
-      if (!c.id) continue;
-      upsertChat({
-        jid: c.id,
-        name: c.name ?? undefined,
-        unreadCount: c.unreadCount ?? 0,
-        archived: c.archived ? 1 : 0,
-        pinned: c.pinned ? 1 : 0,
-        lastTimestamp: toMs(c.conversationTimestamp as number),
-        isGroup: isGroupJid(c.id) ? 1 : 0,
-      });
-    }
-    for (const ct of contacts) {
-      if (ct.id) upsertContact({ jid: ct.id, name: ct.name ?? ct.notify ?? undefined });
-    }
-    for (const msg of messages) persistMessage(msg);
-  });
-
-  // Chat metadata updates.
-  sock.ev.on('chats.upsert', (chats) => {
-    for (const c of chats) {
-      if (!c.id) continue;
-      upsertChat({
-        jid: c.id,
-        name: c.name ?? undefined,
-        unreadCount: c.unreadCount ?? 0,
-        archived: c.archived ? 1 : 0,
-        pinned: c.pinned ? 1 : 0,
-        isGroup: isGroupJid(c.id) ? 1 : 0,
-      });
-    }
-  });
-
-  // Contact names.
-  const onContacts = (contacts: { id: string; name?: string | null; notify?: string | null }[]) => {
-    for (const ct of contacts) {
-      if (ct.id) upsertContact({ jid: ct.id, name: ct.name ?? ct.notify ?? undefined });
-    }
-  };
-  sock.ev.on('contacts.upsert', onContacts);
-  sock.ev.on('contacts.update', onContacts as never);
-}

package/src/whatsapp/logger.ts

@@ -1,71 +0,0 @@
-/**
- * Baileys expects a pino-compatible logger. We keep the terminal clean by
- * default and only surface logs when WA_DEBUG is set. This avoids pulling in
- * pino itself, keeping dependencies minimal.
- */
-export interface BaileysLogger {
-  level: string;
-  trace: (...a: unknown[]) => void;
-  debug: (...a: unknown[]) => void;
-  info: (...a: unknown[]) => void;
-  warn: (...a: unknown[]) => void;
-  error: (...a: unknown[]) => void;
-  fatal: (...a: unknown[]) => void;
-  child: () => BaileysLogger;
-}
-
-const DEBUG = !!process.env.WA_DEBUG;
-
-function make(level: string): BaileysLogger {
-  const emit =
-    (tag: string) =>
-    (...args: unknown[]) => {
-      if (!DEBUG) return;
-      // Baileys calls logger.error(obj, msg); print compactly.
-      process.stderr.write(`[wa:${tag}] ${args.map(fmt).join(' ')}\n`);
-    };
-  return {
-    level,
-    trace: emit('trace'),
-    debug: emit('debug'),
-    info: emit('info'),
-    warn: emit('warn'),
-    error: emit('error'),
-    fatal: emit('fatal'),
-    child: () => make(level),
-  };
-}
-
-function fmt(v: unknown): string {
-  if (typeof v === 'string') return v;
-  try {
-    return JSON.stringify(v);
-  } catch {
-    return String(v);
-  }
-}
-
-export const logger: BaileysLogger = make(DEBUG ? 'debug' : 'silent');
-
-/**
- * Baileys' vendored libsignal logs session churn via `console.log`/`console.error`
- * directly, bypassing the logger above and cluttering the terminal (e.g.
- * "Closing session: SessionEntry { … }"). Filter those specific lines out
- * unless debugging. Call once at startup.
- */
-// libsignal (node_modules/libsignal/src/session_record.js) logs session churn
-// directly via console.info/warn/error, bypassing the logger above.
-const NOISE =
-  /^(Closing (open |stale )?session|Opening session|Session already (closed|open)|Migrating session|Removing old closed session|V1 session storage migration|Session error|Bad MAC|SessionEntry)/;
-
-export function installConsoleFilter(): void {
-  if (DEBUG) return;
-  for (const method of ['log', 'info', 'error', 'warn'] as const) {
-    const original = console[method].bind(console);
-    console[method] = (...args: unknown[]) => {
-      const first = args[0];
-      if (typeof first === 'string' && NOISE.test(first)) return;
-      original(...args);
-    };
-  }
-}