@gtchakama/wa-tui 1.0.0

package/src/ui/state.js

@@ -0,0 +1,30 @@
+const state = {
+  screen: 'loading', // 'loading', 'qr', 'chats', 'chatDetail'
+  qr: null,
+  chats: [],
+  currentChatId: null,
+  currentChatName: null,
+  currentRawChat: null,
+  currentMessages: [],
+  /** Saved input per chat id when leaving the thread */
+  chatDrafts: {},
+  /** absolute paths from Ctrl+D download, keyed by message id */
+  mediaPaths: {},
+  /** Reply quote target for next send */
+  replyTo: null,
+  /** Index into currentMessages for quote selection */
+  replyPickIndex: null,
+  filter: 'all', // 'all', 'direct', 'groups'
+  /** 'recent' | 'unread' | 'alpha' */
+  chatSort: 'recent',
+  unreadOnly: false,
+  page: 1,
+  pageSize: 10,
+  loading: true,
+  error: null,
+  unreadCount: 0,
+  /** When opening Settings (F2), where to return: chats | chatDetail */
+  settingsReturnScreen: null
+};
+
+module.exports = state;

package/src/utils/format.js

@@ -0,0 +1,54 @@
+function formatTimestamp(timestamp) {
+  const date = new Date(timestamp * 1000);
+  const now = new Date();
+  
+  if (date.toDateString() === now.toDateString()) {
+    return date.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+  }
+  return date.toLocaleDateString([], { month: 'short', day: 'numeric' });
+}
+
+function truncate(str, len = 40) {
+  if (!str) return '';
+  if (str.length <= len) return str;
+  return str.substring(0, len) + '...';
+}
+
+/** Compare chat JIDs when WA uses @c.us vs @s.whatsapp.net (or casing differs). */
+function canonicalChatIdForCompare(id) {
+  if (!id || typeof id !== 'string') return '';
+  const lower = id.toLowerCase();
+  const at = lower.lastIndexOf('@');
+  if (at === -1) return lower;
+  const user = lower.slice(0, at);
+  const host = lower.slice(at + 1);
+  if (host === 'g.us') return `${user}@g.us`;
+  if (host === 'c.us' || host === 's.whatsapp.net') return `${user}@c.us`;
+  return lower;
+}
+
+function chatIdsMatch(a, b) {
+  if (!a || !b) return false;
+  if (a === b) return true;
+  return canonicalChatIdForCompare(a) === canonicalChatIdForCompare(b);
+}
+
+/** Readable fallback when pushname is missing (e.g. +263… instead of raw JID). */
+function formatPeerLabel(jidOrName) {
+  if (jidOrName == null || jidOrName === '') return '';
+  const s = String(jidOrName);
+  if (!s.includes('@')) return s;
+  const at = s.lastIndexOf('@');
+  const user = s.slice(0, at);
+  const host = s.slice(at + 1).toLowerCase();
+  if (host === 'g.us') return s;
+  if (/^\d+$/.test(user)) return `+${user}`;
+  return user;
+}
+
+module.exports = {
+  formatTimestamp,
+  truncate,
+  chatIdsMatch,
+  formatPeerLabel
+};

package/src/utils/messageFormat.js

@@ -0,0 +1,53 @@
+const { MessageTypes } = require('whatsapp-web.js');
+const { truncate } = require('./format');
+
+function mediaBracketLabel(type, hasMedia) {
+  if (!hasMedia) return null;
+  switch (type) {
+    case MessageTypes.IMAGE:
+    case MessageTypes.ALBUM:
+      return 'image';
+    case MessageTypes.VIDEO:
+      return 'video';
+    case MessageTypes.VOICE:
+      return 'voice';
+    case MessageTypes.AUDIO:
+      return 'audio';
+    case MessageTypes.DOCUMENT:
+      return 'doc';
+    case MessageTypes.STICKER:
+      return 'sticker';
+    case MessageTypes.LOCATION:
+      return 'location';
+    default:
+      return 'media';
+  }
+}
+
+/** Primary line body: caption/text or [kind] for media-only. */
+function displayBodyForParts(type, hasMedia, body) {
+  const text = body != null ? String(body).trim() : '';
+  if (text) return text;
+  const kind = mediaBracketLabel(type, hasMedia);
+  return kind ? `[${kind}]` : '';
+}
+
+/** Plain text augmentation (renderer applies colors). */
+function augmentDisplayPlain(row) {
+  const base =
+    displayBodyForParts(row.type, row.hasMedia, row.body) || '—';
+  let out = base;
+  if (row.hasQuotedMsg && row.quotedSnippet) {
+    out += ` (re: ${row.quotedSnippet})`;
+  }
+  if (row.localPath) {
+    out += ` @ ${truncate(row.localPath, 56)}`;
+  }
+  return out;
+}
+
+module.exports = {
+  mediaBracketLabel,
+  displayBodyForParts,
+  augmentDisplayPlain
+};

package/src/utils/notifySound.js

@@ -0,0 +1,72 @@
+const { spawn } = require('child_process');
+const fs = require('fs');
+
+function trySpawn(cmd, args, extra = {}) {
+  try {
+    const child = spawn(cmd, args, {
+      stdio: 'ignore',
+      detached: true,
+      ...extra
+    });
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Short notification when an incoming message arrives elsewhere in the UI.
+ * Set WA_TUI_NO_SOUND=1 to disable.
+ */
+function playIncomingMessageSound() {
+  if (process.env.WA_TUI_NO_SOUND === '1') return;
+
+  const platform = process.platform;
+
+  if (platform === 'darwin') {
+    const custom = process.env.WA_TUI_SOUND && String(process.env.WA_TUI_SOUND).trim();
+    if (custom && fs.existsSync(custom) && trySpawn('afplay', [custom])) return;
+    const ping = '/System/Library/Sounds/Ping.aiff';
+    if (fs.existsSync(ping) && trySpawn('afplay', [ping])) return;
+  }
+
+  if (platform === 'win32') {
+    if (
+      trySpawn(
+        'powershell.exe',
+        [
+          '-NoProfile',
+          '-NonInteractive',
+          '-Command',
+          '[console]::Beep(1050, 45); [console]::Beep(1400, 65)'
+        ],
+        { windowsHide: true }
+      )
+    ) {
+      return;
+    }
+  }
+
+  if (platform === 'linux') {
+    const custom = process.env.WA_TUI_SOUND && String(process.env.WA_TUI_SOUND).trim();
+    if (custom && fs.existsSync(custom)) {
+      if (trySpawn('paplay', [custom])) return;
+      if (trySpawn('aplay', ['-q', custom])) return;
+    }
+    const complete = '/usr/share/sounds/freedesktop/stereo/complete.oga';
+    if (fs.existsSync(complete) && trySpawn('paplay', [complete])) return;
+    const oga = '/usr/share/sounds/freedesktop/stereo/message.oga';
+    if (fs.existsSync(oga) && trySpawn('paplay', [oga])) return;
+    const wav = '/usr/share/sounds/sound-icons/echocancel.wav';
+    if (fs.existsSync(wav) && trySpawn('aplay', ['-q', wav])) return;
+  }
+
+  try {
+    process.stdout.write('\x07');
+  } catch {
+    // ignore
+  }
+}
+
+module.exports = { playIncomingMessageSound };

package/src/utils/pager.js

@@ -0,0 +1,19 @@
+function paginate(items, page = 1, pageSize = 10) {
+    const totalItems = items.length;
+    const totalPages = Math.max(1, Math.ceil(totalItems / pageSize));
+    const safePage = Math.min(Math.max(page, 1), totalPages);
+    const start = (safePage - 1) * pageSize;
+    const paginatedItems = items.slice(start, start + pageSize);
+
+    return {
+        items: paginatedItems,
+        page: safePage,
+        totalPages,
+        totalItems,
+        pageSize
+    };
+}
+
+module.exports = {
+    paginate
+};

package/src/whatsapp/service.js

@@ -0,0 +1,264 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const {
+  Client,
+  LocalAuth,
+  MessageTypes
+} = require('whatsapp-web.js');
+const EventEmitter = require('events');
+const { formatPeerLabel, truncate } = require('../utils/format');
+const { displayBodyForParts } = require('../utils/messageFormat');
+
+async function resolveIncomingAuthor(msg, chat) {
+  const isGroup = Boolean(chat && chat.isGroup);
+  const peerTitle = (chat && (chat.name || chat.formattedTitle || '').trim()) || '';
+  if (!isGroup) {
+    if (peerTitle) return peerTitle;
+    return formatPeerLabel(msg.author || msg.from);
+  }
+  try {
+    const c = await msg.getContact();
+    const n = (c.pushname || c.name || c.shortName || '').trim();
+    if (n) return n;
+  } catch (_) {}
+  return formatPeerLabel(msg.author || msg.from);
+}
+
+const SUPPRESSED_MESSAGE_TYPES = new Set([
+  MessageTypes.E2E_NOTIFICATION,
+  MessageTypes.PROTOCOL,
+  MessageTypes.GP2,
+  MessageTypes.CIPHERTEXT,
+  MessageTypes.REACTION,
+  MessageTypes.DEBUG,
+  MessageTypes.BROADCAST_NOTIFICATION,
+  MessageTypes.REVOKED
+]);
+
+function shouldEmitUserMessage(msg) {
+  if (!msg || msg.isStatus || !msg.id?._serialized) return false;
+  if (msg.broadcast) return false;
+  if (SUPPRESSED_MESSAGE_TYPES.has(msg.type)) return false;
+  const body = msg.body != null ? String(msg.body).trim() : '';
+  if (!body && !msg.hasMedia) return false;
+  return true;
+}
+
+async function quotedSnippetFrom(msg) {
+  if (!msg.hasQuotedMsg) return '';
+  try {
+    const q = await msg.getQuotedMessage();
+    if (!q) return '';
+    const qb =
+      q.body != null && String(q.body).trim()
+        ? String(q.body).trim()
+        : displayBodyForParts(q.type, Boolean(q.hasMedia), q.body);
+    return truncate(qb, 40);
+  } catch (_) {
+    return '';
+  }
+}
+
+async function rowFromClientMessage(msg, chat) {
+  const author = msg.fromMe ? 'You' : await resolveIncomingAuthor(msg, chat);
+  const quotedSnippet = await quotedSnippetFrom(msg);
+  return {
+    id: msg.id._serialized,
+    body: msg.body,
+    displayBody: displayBodyForParts(msg.type, msg.hasMedia, msg.body),
+    fromMe: msg.fromMe,
+    author,
+    timestamp: msg.timestamp,
+    type: msg.type,
+    hasMedia: Boolean(msg.hasMedia),
+    hasQuotedMsg: Boolean(msg.hasQuotedMsg),
+    quotedSnippet
+  };
+}
+
+class WhatsAppService extends EventEmitter {
+  constructor() {
+    super();
+    this.client = new Client({
+      authStrategy: new LocalAuth(),
+      puppeteer: {
+        headless: true,
+        args: ['--no-sandbox', '--disable-setuid-sandbox']
+      }
+    });
+    this.ready = false;
+  }
+
+  initialize(onQr, onReady, onAuth) {
+    this.client.on('qr', (qr) => {
+      onQr(qr);
+    });
+
+    this.client.on('ready', () => {
+      this.ready = true;
+      onReady();
+    });
+
+    this.client.on('authenticated', () => {
+      if (onAuth) onAuth();
+    });
+
+    this.client.on('message_create', (msg) => {
+      void (async () => {
+        if (!shouldEmitUserMessage(msg)) return;
+
+        const remote =
+          msg.id &&
+          msg.id.remote &&
+          msg.id.remote !== 'status@broadcast'
+            ? String(msg.id.remote)
+            : '';
+        const chatId = remote || (msg.fromMe ? msg.to : msg.from);
+
+        let author = 'You';
+        if (!msg.fromMe) {
+          try {
+            const chat = await msg.getChat();
+            author = await resolveIncomingAuthor(msg, chat);
+          } catch (_) {
+            author = formatPeerLabel(msg.author || msg.from);
+          }
+        }
+
+        const quotedSnippet = await quotedSnippetFrom(msg);
+
+        this.emit('message', {
+          id: msg.id._serialized,
+          chatId,
+          body: msg.body,
+          displayBody: displayBodyForParts(msg.type, msg.hasMedia, msg.body),
+          timestamp: msg.timestamp,
+          author,
+          fromMe: msg.fromMe,
+          type: msg.type,
+          hasMedia: Boolean(msg.hasMedia),
+          hasQuotedMsg: Boolean(msg.hasQuotedMsg),
+          quotedSnippet
+        });
+      })();
+    });
+
+    this.client.on('auth_failure', (msg) => {
+      console.error('Authentication failure:', msg);
+    });
+
+    return this.client.initialize();
+  }
+
+  async getChats() {
+    const chats = await this.client.getChats();
+    const sorted = chats.sort((a, b) => b.timestamp - a.timestamp);
+
+    return sorted.map((chat) => {
+      const title =
+        chat.name || chat.formattedTitle || (chat.id && chat.id.user) || 'Unknown';
+
+      return {
+        id: chat.id._serialized,
+        name: title,
+        isGroup: chat.isGroup,
+        unreadCount: chat.unreadCount || 0,
+        timestamp: chat.timestamp || 0,
+        lastMessage: chat.lastMessage ? chat.lastMessage.body : '',
+        raw: chat
+      };
+    });
+  }
+
+  async getMessages(chatId, limit = 40, rawChat = null) {
+    try {
+      let chat = rawChat;
+
+      if (!chat) {
+        const chats = await this.getChats();
+        const found = chats.find((c) => c.id === chatId);
+        if (found) chat = found.raw;
+      }
+
+      if (!chat) {
+        chat = await this.client.getChatById(chatId).catch(() => null);
+      }
+
+      if (!chat || !chat.fetchMessages) return [];
+
+      const messages = await chat.fetchMessages({ limit });
+      const filtered = messages.filter((msg) => shouldEmitUserMessage(msg));
+      return Promise.all(filtered.map((msg) => rowFromClientMessage(msg, chat)));
+    } catch (err) {
+      console.error('Error in getMessages:', err);
+      return [];
+    }
+  }
+
+  async sendMessage(chatId, text, rawChat = null, sendOptions = {}) {
+    try {
+      const hasQuote = Boolean(sendOptions && sendOptions.quotedMessageId);
+      if (hasQuote) {
+        return this.client.sendMessage(chatId, text, sendOptions);
+      }
+      if (rawChat && rawChat.sendMessage) {
+        return rawChat.sendMessage(text);
+      }
+      if (chatId == null || chatId === '') {
+        throw new Error('No chat selected');
+      }
+      return this.client.sendMessage(chatId, text);
+    } catch (err) {
+      console.error('Error in sendMessage:', err);
+      throw err;
+    }
+  }
+
+  /** Saves media to ~/Downloads/wa-tui/, returns absolute file path. */
+  async downloadMessageMedia(messageId, chatId, rawChat = null) {
+    let chat = rawChat;
+    if (!chat) {
+      const chats = await this.getChats();
+      const found = chats.find((c) => c.id === chatId);
+      if (found) chat = found.raw;
+    }
+    if (!chat) {
+      chat = await this.client.getChatById(chatId).catch(() => null);
+    }
+    if (!chat || !chat.fetchMessages) {
+      throw new Error('Chat not available');
+    }
+    const messages = await chat.fetchMessages({ limit: 80 });
+    const msg = messages.find((m) => m.id._serialized === messageId);
+    if (!msg) throw new Error('Message not found');
+    if (!msg.hasMedia) throw new Error('This message has no media to download');
+    const media = await msg.downloadMedia();
+    if (!media || !media.data) throw new Error('Download failed');
+
+    const dir = path.join(os.homedir(), 'Downloads', 'wa-tui');
+    fs.mkdirSync(dir, { recursive: true });
+    const ext =
+      (media.mimetype && media.mimetype.split('/')[1] && media.mimetype.split('/')[1].split(';')[0]) ||
+      'bin';
+    const safe = String(messageId).replace(/[^a-z0-9]+/gi, '_').slice(-24);
+    const fname = `${Date.now()}_${safe}.${ext}`;
+    const fpath = path.join(dir, fname);
+    fs.writeFileSync(fpath, media.data, 'base64');
+    return fpath;
+  }
+
+  async logoutSession() {
+    this.ready = false;
+    try {
+      await this.client.logout();
+    } catch (err) {
+      console.error('Logout:', err.message || err);
+      try {
+        await this.client.destroy();
+      } catch (_) {}
+    }
+  }
+}
+
+module.exports = new WhatsAppService();