cli-whatsapp 0.1.1 → 0.1.3

package/src/cli/commands/shell.ts

@@ -1,596 +0,0 @@
-import readline, { createInterface, type Interface } from 'node:readline';
-import { readdirSync, statSync, existsSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import { chats, contacts, search, history } from './read.ts';
-import { reply, buildMediaContent, sendContent } from './send.ts';
-import { media } from './media.ts';
-import { pickFile, pickFromList, type ListItem } from './filepicker.ts';
-import { recent, pin, unpin, archive, unarchive } from './manage.ts';
-import { status } from './auth.ts';
-import { connect, hasSession, type Connection } from '../../whatsapp/client.ts';
-import { registerPersistence, extractText, isGroupJid } from '../../whatsapp/events.ts';
-import {
-  listChats,
-  findChat,
-  getMessages,
-  countMessages,
-  type ChatRow,
-} from '../../db/sqlite.ts';
-import { resolveTarget } from '../../utils/jid.ts';
-import { loadConfig, saveConfig } from '../../config/index.ts';
-import { c, displayName, formatTime, truncate, renderMessages } from '../../utils/format.ts';
-import { print, warn, printError } from '../../utils/ui.ts';
-import { notify } from '../../utils/notify.ts';
-
-type Status = 'offline' | 'connecting' | 'live';
-
-interface State {
-  active: ChatRow | null;
-  conn: Connection | null;
-  status: Status;
-  rl: Interface;
-  quitting: boolean;
-  /** Set when the user closes the connection on purpose (/disconnect, /quit),
-   *  so the connection-drop listener doesn't also print a message. */
-  manualClose: boolean;
-}
-
-// ---- tab completion --------------------------------------------------------
-
-const SLASH_ITEMS: ListItem[] = [
-  { value: '/open', desc: 'open a chat — then just type to send', args: true },
-  { value: '/close', desc: 'leave the current chat' },
-  { value: '/chats', desc: 'list conversations' },
-  { value: '/recent', desc: 'recently active chats' },
-  { value: '/contacts', desc: 'list contacts' },
-  { value: '/history', desc: 'extended message history', args: true },
-  { value: '/search', desc: 'search messages', args: true },
-  { value: '/send', desc: 'send a message to a chat', args: true },
-  { value: '/sendfile', desc: 'send a file (media)', args: true },
-  { value: '/reply', desc: 'reply to a message by #id', args: true },
-  { value: '/media', desc: 'list cached media' },
-  { value: '/pin', desc: 'pin a chat to the top', args: true },
-  { value: '/unpin', desc: 'unpin a chat', args: true },
-  { value: '/archive', desc: 'archive (hide) a chat', args: true },
-  { value: '/unarchive', desc: 'unarchive a chat', args: true },
-  { value: '/connect', desc: 'go live — receive messages' },
-  { value: '/disconnect', desc: 'drop the live connection' },
-  { value: '/status', desc: 'session & cache status' },
-  { value: '/settings', desc: 'view settings' },
-  { value: '/set', desc: 'change a setting', args: true },
-  { value: '/clear', desc: 'clear the screen' },
-  { value: '/help', desc: 'list commands' },
-  { value: '/quit', desc: 'exit' },
-];
-const SLASH = SLASH_ITEMS.map((it) => it.value);
-const CHAT_CMDS = new Set([
-  '/open', '/send', '/sendfile', '/pin', '/unpin', '/archive', '/unarchive', '/history',
-]);
-
-let nameCache: string[] = [];
-function refreshNames(): void {
-  nameCache = listChats(1000, true).map(displayName);
-}
-
-function completer(line: string): [string[], string] {
-  // `@…` anywhere in the line → complete a filesystem path to attach.
-  const lastTok = line.slice(line.lastIndexOf(' ') + 1);
-  if (lastTok.startsWith('@')) return completeAtPath(lastTok);
-
-  const parts = line.split(/\s+/);
-  if (parts.length <= 1) {
-    if (!line.startsWith('/')) return [[], line];
-    const hits = SLASH.filter((cmd) => cmd.startsWith(line));
-    return [hits.length ? hits : SLASH, line];
-  }
-  if (CHAT_CMDS.has(parts[0])) {
-    const partial = parts[parts.length - 1].toLowerCase();
-    const hits = nameCache.filter((n) => n.toLowerCase().startsWith(partial)).slice(0, 25);
-    return [hits, parts[parts.length - 1]];
-  }
-  return [[], line];
-}
-
-/** Expand a leading ~ to the home directory. */
-function expandHome(p: string): string {
-  return p.replace(/^~(?=\/|$)/, homedir());
-}
-
-/**
- * Tab-completion for an `@<path>` token: lists matching files/dirs so you can
- * browse the filesystem to attach a file (directories get a trailing /).
- */
-function completeAtPath(token: string): [string[], string] {
-  const raw = token.slice(1); // drop the leading '@'
-  const slash = raw.lastIndexOf('/');
-  const dirPart = slash >= 0 ? raw.slice(0, slash + 1) : ''; // keeps trailing /
-  const basePart = slash >= 0 ? raw.slice(slash + 1) : raw;
-  const fsDir = expandHome(dirPart || '.');
-  let entries: string[];
-  try {
-    entries = readdirSync(fsDir);
-  } catch {
-    return [[token], token];
-  }
-  const showHidden = basePart.startsWith('.');
-  const hits = entries
-    .filter((e) => e.startsWith(basePart) && (showHidden || !e.startsWith('.')))
-    .sort()
-    .slice(0, 100)
-    .map((e) => {
-      let suffix = '';
-      try {
-        if (statSync(join(fsDir, e)).isDirectory()) suffix = '/';
-      } catch {
-        /* ignore unstatable entries */
-      }
-      return '@' + dirPart + e + suffix;
-    });
-  return [hits.length ? hits : [token], token];
-}
-
-/**
- * Find an `@<path>` attachment in a composed message, if the file exists.
- * Supports `@"quoted paths with spaces"` as well as bare `@path` tokens.
- */
-function extractAttachment(
-  line: string,
-): { file: string; caption: string } | null {
-  const m = line.match(/(?:^|\s)@(?:"([^"]+)"|(\S+))/);
-  if (!m || m.index === undefined) return null;
-  const file = expandHome(m[1] ?? m[2]);
-  if (!existsSync(file) || !statSync(file).isFile()) return null;
-  const caption = (line.slice(0, m.index) + line.slice(m.index + m[0].length)).trim();
-  return { file, caption };
-}
-
-// ---- rendering -------------------------------------------------------------
-
-function banner(): void {
-  const linked = hasSession();
-  const dot = linked ? c.green('●') : c.red('○');
-  const state = linked ? c.green('linked') : c.red('not linked');
-  const stats = c.dim(`${listChats(5000).length} chats · ${countMessages()} messages`);
-  const lines = [
-    `${c.green('✆')} ${c.bold(c.green('WhatsApp'))} ${c.bold('CLI')}  ${c.dim('interactive')}`,
-    `${dot} ${state}   ${stats}`,
-    linked
-      ? c.dim('Type /open <chat> then just type to chat. /help for commands.')
-      : c.dim('Run /connect after `wa login` to link this device.'),
-  ];
-  const width = Math.min(
-    64,
-    Math.max(...lines.map((l) => stripAnsi(l).length)) + 2,
-  );
-  const bar = (l: string, r: string) => c.teal(l + '─'.repeat(width) + r);
-  print(bar('╭', '╮'));
-  for (const l of lines) {
-    const pad = ' '.repeat(Math.max(0, width - 1 - stripAnsi(l).length));
-    print(c.teal('│') + ' ' + l + pad + c.teal('│'));
-  }
-  print(bar('╰', '╯'));
-}
-
-function stripAnsi(s: string): string {
-  // eslint-disable-next-line no-control-regex
-  return s.replace(/\x1b\[[0-9;]*m/g, '');
-}
-
-function statusDot(s: Status): string {
-  return s === 'live' ? c.green('●') : s === 'connecting' ? c.yellow('◐') : c.dim('○');
-}
-
-function setPrompt(state: State): void {
-  const where = state.active ? c.bold(displayName(state.active)) : c.dim('wa');
-  state.rl.setPrompt(`${statusDot(state.status)} ${where} ${c.dim('›')} `);
-}
-
-/** Print a line above the input prompt without disturbing what's being typed. */
-function printAbove(state: State, text: string): void {
-  readline.cursorTo(process.stdout, 0);
-  readline.clearLine(process.stdout, 0);
-  process.stdout.write(text + '\n');
-  state.rl.prompt(true);
-}
-
-function bubble(who: string, text: string, incoming: boolean): string {
-  const time = c.gray(formatTime(Date.now(), loadConfig().preferences.time24h));
-  const name = incoming ? c.cyan(who) : c.green('me');
-  return `${time} ${name}: ${text}`;
-}
-
-// ---- connection ------------------------------------------------------------
-
-function onIncoming(state: State, msg: import('@whiskeysockets/baileys').WAMessage): void {
-  if (msg.key.fromMe) return;
-  const jid = msg.key.remoteJid;
-  if (!jid || jid === 'status@broadcast') return;
-  const text = extractText(msg.message) || c.dim('[media]');
-  const chat = findChat(jid);
-  const who =
-    isGroupJid(jid) && msg.pushName
-      ? `${chat ? displayName(chat) : jid.split('@')[0]}/${msg.pushName}`
-      : chat
-        ? displayName(chat)
-        : msg.pushName ?? jid.split('@')[0];
-  if (state.active && jid === state.active.jid) {
-    printAbove(state, bubble(who, text, true));
-  } else {
-    printAbove(state, c.dim(`🔔 ${who}: ${truncate(stripAnsi(text), 60)}`));
-  }
-  if (loadConfig().preferences.notifications) {
-    notify(who, extractText(msg.message) || 'sent media');
-  }
-}
-
-async function ensureConnected(state: State): Promise<Connection | null> {
-  if (state.conn && state.status === 'live') return state.conn;
-  if (!hasSession()) {
-    warn('Not linked. Run `wa login` in another terminal first.');
-    return null;
-  }
-  state.status = 'connecting';
-  setPrompt(state);
-  printAbove(state, c.dim('connecting…'));
-  try {
-    const conn = await connect({ requireSession: true });
-    registerPersistence(conn.sock, { onMessage: (m) => onIncoming(state, m) });
-    conn.sock.ev.on('connection.update', (u) => {
-      if (u.connection !== 'close' || state.quitting) return;
-      if (state.manualClose) {
-        // User-initiated (/disconnect) — that handler already reported it.
-        state.manualClose = false;
-        return;
-      }
-      state.status = 'offline';
-      state.conn = null;
-      setPrompt(state);
-      printAbove(state, c.dim('disconnected. Type /connect to reconnect.'));
-    });
-    await conn.ready;
-    state.conn = conn;
-    state.status = 'live';
-    setPrompt(state);
-    printAbove(state, c.green('● live — receiving messages'));
-    return conn;
-  } catch (err) {
-    state.status = 'offline';
-    state.conn = null;
-    setPrompt(state);
-    warn(`Could not connect: ${(err as Error).message}`);
-    return null;
-  }
-}
-
-// ---- sending ---------------------------------------------------------------
-
-async function sendTo(
-  state: State,
-  jid: string,
-  name: string,
-  content: import('@whiskeysockets/baileys').AnyMessageContent,
-  meta: { previewText: string; type: string; mediaPath?: string },
-): Promise<void> {
-  const conn = await ensureConnected(state);
-  if (!conn) return;
-  try {
-    await sendContent(conn.sock, jid, content, meta);
-    const echo = meta.type === 'text' ? meta.previewText : `[${meta.type}] ${meta.previewText}`;
-    printAbove(state, bubble(name, echo, false));
-    refreshNames();
-  } catch (err) {
-    warn(`Send failed: ${(err as Error).message}`);
-  }
-}
-
-// ---- chat context ----------------------------------------------------------
-
-function openChat(state: State, target: string): void {
-  const chat = findChat(target);
-  if (!chat) {
-    warn(`No chat matching "${target}". Try /chats or /search.`);
-    return;
-  }
-  state.active = chat;
-  setPrompt(state);
-  print(c.dim('─'.repeat(40)));
-  print(c.bold(displayName(chat)) + c.dim(`  ${chat.jid}`));
-  print(renderMessages(getMessages(chat.jid, 15), loadConfig().preferences.time24h));
-  print(c.dim(`─── in this chat: type to send · @ opens a file picker to attach · /close ───`));
-}
-
-// ---- settings --------------------------------------------------------------
-
-function showSettings(): void {
-  const cfg = loadConfig();
-  print(c.bold('Settings'));
-  print(`  openLimit       ${c.cyan(String(cfg.preferences.openLimit))}   ${c.dim('messages shown by /open')}`);
-  print(`  time24h         ${c.cyan(String(cfg.preferences.time24h))}   ${c.dim('24-hour clock')}`);
-  print(`  notifications   ${c.cyan(String(cfg.preferences.notifications))}   ${c.dim('desktop alerts on new messages')}`);
-  print(`  autoConnect     ${c.cyan(String(cfg.preferences.autoConnect))}   ${c.dim('go live automatically on start')}`);
-  print(`  ai.enabled      ${c.cyan(String(cfg.ai.enabled))}   ${c.dim('(AI plugin)')}`);
-  print(c.dim('  Change with: /set <key> <value>   e.g. /set autoConnect false'));
-}
-
-function setSetting(key: string, value: string): void {
-  const cfg = loadConfig();
-  switch (key) {
-    case 'openLimit':
-      cfg.preferences.openLimit = Math.max(1, parseInt(value, 10) || cfg.preferences.openLimit);
-      break;
-    case 'time24h':
-      cfg.preferences.time24h = value === 'true' || value === '1';
-      break;
-    case 'notifications':
-      cfg.preferences.notifications = value === 'true' || value === '1';
-      break;
-    case 'autoConnect':
-      cfg.preferences.autoConnect = value === 'true' || value === '1';
-      break;
-    case 'ai.enabled':
-      cfg.ai.enabled = value === 'true' || value === '1';
-      break;
-    default:
-      warn(`Unknown key "${key}". Editable: openLimit, time24h, notifications, autoConnect, ai.enabled`);
-      return;
-  }
-  saveConfig(cfg);
-  print(`${c.green('✓')} set ${key} = ${value}`);
-}
-
-// ---- help ------------------------------------------------------------------
-
-const HELP = `${c.bold('Commands')} ${c.dim('(slash optional for the first word)')}
-  ${c.cyan('/open')} <chat>          open a chat — then just type to send
-  ${c.green('@')}                       open a file picker to attach (↑↓ to choose, ⏎ to pick)
-  ${c.cyan('/close')}                 leave the current chat
-  ${c.cyan('/chats')} · ${c.cyan('/recent')} · ${c.cyan('/contacts')}   list chats / recent / contacts
-  ${c.cyan('/history')} [n] · ${c.cyan('/search')} <text>       more history / search
-  ${c.cyan('/send')} <chat> <msg>    send without opening
-  ${c.cyan('/sendfile')} <chat> <path> [caption]   send media
-  ${c.cyan('/reply')} <id> <msg>     reply to a message by #id
-  ${c.cyan('/media')} [type]         list media
-  ${c.cyan('/pin')} · ${c.cyan('/unpin')} · ${c.cyan('/archive')} · ${c.cyan('/unarchive')} <chat>
-  ${c.cyan('/connect')} · ${c.cyan('/disconnect')}     go live (receive) / drop connection
-  ${c.cyan('/status')} · ${c.cyan('/settings')} · ${c.cyan('/set')} <k> <v>   status / settings
-  ${c.cyan('/clear')} · ${c.cyan('/help')} · ${c.cyan('/quit')}`;
-
-// ---- command dispatch ------------------------------------------------------
-
-function tokenize(line: string): string[] {
-  const out: string[] = [];
-  const re = /"([^"]*)"|'([^']*)'|(\S+)/g;
-  let m: RegExpExecArray | null;
-  while ((m = re.exec(line))) out.push(m[1] ?? m[2] ?? m[3]);
-  return out;
-}
-
-async function handle(state: State, raw: string): Promise<void> {
-  const line = raw.trim();
-  if (!line) return;
-
-  // Message composed with a chat open (no leading slash).
-  if (!line.startsWith('/') && state.active) {
-    const jid = state.active.jid;
-    const name = displayName(state.active);
-    // `@<path>` attaches a file (rest of the line becomes the caption).
-    const at = extractAttachment(line);
-    if (at) {
-      try {
-        const built = buildMediaContent(at.file, at.caption || undefined);
-        await sendTo(state, jid, name, built.content, {
-          previewText: at.caption || `[${built.kind}]`,
-          type: built.kind,
-          mediaPath: built.path,
-        });
-      } catch (err) {
-        printError(err);
-      }
-      return;
-    }
-    // Otherwise plain text.
-    await sendTo(state, jid, name, { text: line }, { previewText: line, type: 'text' });
-    return;
-  }
-
-  const [cmdRaw, ...args] = tokenize(line);
-  const cmd = cmdRaw.replace(/^\//, '').toLowerCase();
-  const need = (v: string | undefined, n: string): boolean => {
-    if (!v) {
-      warn(`Missing <${n}>.`);
-      return false;
-    }
-    return true;
-  };
-
-  switch (cmd) {
-    case 'quit': case 'exit': case 'q':
-      state.quitting = true;
-      state.rl.close();
-      return;
-    case 'help': case 'h': case '?':
-      print(HELP); return;
-    case 'clear':
-      process.stdout.write('\x1b[2J\x1b[3J\x1b[H'); banner(); return;
-    case 'open':
-      if (need(args[0], 'chat')) openChat(state, args.join(' ')); return;
-    case 'close': case 'back':
-      state.active = null; setPrompt(state); print(c.dim('left chat.')); return;
-    case 'chats': chats({ limit: args[0] }); refreshNames(); return;
-    case 'recent': recent({ limit: args[0] }); return;
-    case 'contacts': contacts({ limit: args[0] }); return;
-    case 'history':
-      if (state.active && (!args[0] || /^\d+$/.test(args[0])))
-        history(state.active.jid, { limit: args[0] });
-      else if (need(args[0], 'chat')) history(args[0], { limit: args[1] });
-      return;
-    case 'search':
-      if (need(args[0], 'text')) search(args.join(' '), {}); return;
-    case 'media': media(args[0], {}); return;
-    case 'status': status(); return;
-    case 'settings': case 'config': showSettings(); return;
-    case 'set':
-      if (need(args[0], 'key') && need(args[1], 'value')) setSetting(args[0], args[1]); return;
-    case 'pin': if (need(args[0], 'chat')) { pin(args.join(' ')); refreshNames(); } return;
-    case 'unpin': if (need(args[0], 'chat')) unpin(args.join(' ')); return;
-    case 'archive': if (need(args[0], 'chat')) archive(args.join(' ')); return;
-    case 'unarchive': if (need(args[0], 'chat')) unarchive(args.join(' ')); return;
-    case 'connect': case 'watch': case 'live':
-      await ensureConnected(state); return;
-    case 'disconnect':
-      if (state.conn) {
-        state.manualClose = true; // suppress the drop-listener's message
-        state.conn.close();
-        state.conn = null;
-        state.status = 'offline';
-        setPrompt(state);
-        print(c.dim('disconnected.'));
-      } else print(c.dim('not connected.'));
-      return;
-    case 'send': {
-      if (!need(args[0], 'chat') || !need(args[1], 'message')) return;
-      const t = resolveTarget(args[0]);
-      if (!t) { warn(`Could not resolve "${args[0]}".`); return; }
-      const text = args.slice(1).join(' ');
-      await sendTo(state, t.jid, t.name, { text }, { previewText: text, type: 'text' });
-      return;
-    }
-    case 'sendfile': {
-      if (!need(args[0], 'chat') || !need(args[1], 'path')) return;
-      const t = resolveTarget(args[0]);
-      if (!t) { warn(`Could not resolve "${args[0]}".`); return; }
-      try {
-        const caption = args.slice(2).join(' ') || undefined;
-        const built = buildMediaContent(args[1], caption);
-        await sendTo(state, t.jid, t.name, built.content, {
-          previewText: caption || `[${built.kind}]`,
-          type: built.kind,
-          mediaPath: built.path,
-        });
-      } catch (err) {
-        printError(err);
-      }
-      return;
-    }
-    case 'reply':
-      if (need(args[0], 'id') && need(args[1], 'message')) await reply(args[0], args.slice(1).join(' '));
-      return;
-    default:
-      warn(`Unknown command "${cmd}". Type /help.`);
-  }
-}
-
-// ---- entry -----------------------------------------------------------------
-
-/** wa shell — the interactive client. Also runs when `wa` is given no command. */
-export async function shell(): Promise<void> {
-  banner();
-  refreshNames();
-  const rl = createInterface({
-    input: process.stdin,
-    output: process.stdout,
-    completer,
-    historySize: 200,
-  });
-  const state: State = { active: null, conn: null, status: 'offline', rl, quitting: false, manualClose: false };
-  setPrompt(state);
-  rl.prompt();
-
-  // Go live automatically on start (unless disabled or not linked). Fire-and-
-  // forget so browsing stays instant while the socket connects in the background.
-  if (process.stdin.isTTY && hasSession() && loadConfig().preferences.autoConnect) {
-    void ensureConnected(state);
-  }
-
-  let busy = false;
-  const queue: string[] = [];
-  const pump = async () => {
-    if (busy) return;
-    busy = true;
-    while (queue.length) {
-      const line = queue.shift()!;
-      try {
-        await handle(state, line);
-      } catch (err) {
-        printError(err);
-      }
-    }
-    busy = false;
-    if (!state.quitting) rl.prompt();
-  };
-
-  rl.on('line', (line) => {
-    queue.push(line);
-    void pump();
-  });
-
-  // Overlays open synchronously on the trigger key so they reliably capture the
-  // keys you type next (no race with the line being submitted). `/` at the start
-  // of the line opens the slash-command menu; `@` (with a chat open, at a token
-  // boundary) opens the file picker. readline processes the keypress before our
-  // listener, so rl.line already includes the just-typed character.
-  readline.emitKeypressEvents(process.stdin);
-  let pickerOpen = false;
-  process.stdin.on('keypress', (str: string, _key: unknown) => {
-    void _key;
-    if (!process.stdin.isTTY || pickerOpen || busy) return;
-
-    // `/` menu — only when it's the first character on the line.
-    if (str === '/' && rl.line === '/') {
-      pickerOpen = true;
-      pickFromList('Slash Commands', SLASH_ITEMS, '')
-        .then((picked) => {
-          rl.write(null as never, { ctrl: true, name: 'u' }); // clear the '/'
-          if (!picked) return; // cancelled (esc / backspace) — leave the line empty
-          const item = SLASH_ITEMS.find((i) => i.value === picked);
-          if (item && !item.args) {
-            // No arguments needed → run it right away (no second Enter).
-            queue.push(picked);
-            void pump();
-          } else {
-            rl.write(picked + ' '); // needs args → wait for input
-          }
-        })
-        .finally(() => {
-          pickerOpen = false;
-        });
-      return;
-    }
-
-    // `@` file picker — only with a chat open and at a fresh token boundary.
-    if (str === '@' && state.active) {
-      const before = rl.line.slice(0, Math.max(0, rl.cursor - 1)).replace(/@$/, '');
-      if (before !== '' && !before.endsWith(' ')) return;
-      pickerOpen = true;
-      pickFile(process.cwd())
-        .then((picked) => {
-          // Quote paths with spaces so the whole path is treated as one token.
-          if (picked) rl.write(picked.includes(' ') ? `"${picked}"` : picked);
-          else rl.prompt(true);
-        })
-        .finally(() => {
-          pickerOpen = false;
-        });
-    }
-  });
-
-  rl.on('SIGINT', () => {
-    if (rl.line) {
-      // Clear the current input on first Ctrl+C.
-      rl.write(null as never, { ctrl: true, name: 'u' });
-    } else {
-      state.quitting = true;
-      rl.close();
-    }
-  });
-
-  await new Promise<void>((resolve) => {
-    rl.on('close', () => {
-      state.quitting = true;
-      state.conn?.close();
-      print('\n' + c.dim('Bye.'));
-      resolve();
-    });
-  });
-}

package/src/cli/commands/sync.ts

@@ -1,80 +0,0 @@
-import { connect, runWithConnection } from '../../whatsapp/client.ts';
-import { registerPersistence, extractText, isGroupJid } from '../../whatsapp/events.ts';
-import { countMessages, listChats, findChat } from '../../db/sqlite.ts';
-import { loadConfig, saveConfig } from '../../config/index.ts';
-import { ok, info, print } from '../../utils/ui.ts';
-import { c, formatTime, displayName } from '../../utils/format.ts';
-import { notify } from '../../utils/notify.ts';
-
-/** wa sync [--seconds N] — pull recent chats/messages into the local cache. */
-export async function sync(opts: { seconds?: string }): Promise<void> {
-  const seconds = Math.min(Math.max(parseInt(opts.seconds ?? '12', 10) || 12, 3), 120);
-  const before = { chats: listChats(5000).length, msgs: countMessages() };
-  info(`Syncing for ~${seconds}s… (WhatsApp streams history in the background)`);
-
-  await runWithConnection(
-    async (conn) => {
-      registerPersistence(conn.sock);
-      // Periodic progress so long syncs don't look frozen.
-      const started = Date.now();
-      const timer = setInterval(() => {
-        const elapsed = Math.round((Date.now() - started) / 1000);
-        process.stdout.write(
-          `\r${c.dim(`  ${elapsed}s — ${countMessages()} messages cached`)}   `,
-        );
-      }, 1000);
-      await new Promise((r) => setTimeout(r, seconds * 1000));
-      clearInterval(timer);
-      process.stdout.write('\r' + ' '.repeat(50) + '\r');
-    },
-    { requireSession: true, syncFullHistory: true },
-  );
-
-  const after = { chats: listChats(5000).length, msgs: countMessages() };
-  const cfg = loadConfig();
-  cfg.session.lastSyncAt = Date.now();
-  saveConfig(cfg);
-
-  ok(
-    `Sync complete. +${after.chats - before.chats} chats, +${after.msgs - before.msgs} messages ` +
-      `(${after.chats} chats, ${after.msgs} messages total).`,
-  );
-}
-
-/** wa watch — stream incoming messages live until interrupted. */
-export async function watch(): Promise<void> {
-  const cfg = loadConfig();
-  info('Watching for incoming messages. Press Ctrl+C to stop.');
-  print(c.dim('─'.repeat(40)));
-
-  const conn = await connect({ requireSession: true });
-  registerPersistence(conn.sock, {
-    onMessage: (msg) => {
-      if (msg.key.fromMe) return;
-      const jid = msg.key.remoteJid;
-      if (!jid || jid === 'status@broadcast') return;
-      const text = extractText(msg.message) || c.dim('[media]');
-      const chat = findChat(jid);
-      const name = chat ? displayName(chat) : (msg.pushName ?? jid.split('@')[0]);
-      const sender =
-        isGroupJid(jid) && msg.pushName ? `${name}/${msg.pushName}` : name;
-      const time = c.gray(formatTime(Date.now(), cfg.preferences.time24h));
-      print(`${time} ${c.cyan(sender)}: ${text}`);
-      if (cfg.preferences.notifications) notify(sender, extractText(msg.message) || 'sent media');
-    },
-  });
-
-  await conn.ready;
-  ok('Connected. Live.');
-
-  // Keep the process alive until the user interrupts.
-  await new Promise<void>((resolve) => {
-    const stop = () => {
-      conn.close();
-      print('\n' + c.dim('Stopped watching.'));
-      resolve();
-    };
-    process.on('SIGINT', stop);
-    process.on('SIGTERM', stop);
-  });
-}