@c4t4/heyamigo 0.1.0

package/dist/queue/persistence.js

@@ -0,0 +1,68 @@
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync, } from 'fs';
+import { resolve } from 'path';
+import { logger } from '../logger.js';
+const QUEUE_DIR = resolve(process.cwd(), 'storage/queue');
+const PENDING_FILE = resolve(QUEUE_DIR, 'pending.jsonl');
+function ensureDir() {
+    mkdirSync(QUEUE_DIR, { recursive: true });
+}
+export function persistJob(job) {
+    ensureDir();
+    const line = JSON.stringify({ ...job, enqueuedAt: Date.now() }) + '\n';
+    writeFileSync(PENDING_FILE, line, { flag: 'a', encoding: 'utf-8' });
+}
+export function removeJob(job) {
+    if (!existsSync(PENDING_FILE))
+        return;
+    try {
+        const lines = readFileSync(PENDING_FILE, 'utf-8')
+            .split('\n')
+            .filter(Boolean);
+        const remaining = lines.filter((line) => {
+            try {
+                const parsed = JSON.parse(line);
+                return !(parsed.jid === job.jid && parsed.text === job.text);
+            }
+            catch {
+                return false;
+            }
+        });
+        if (remaining.length === 0) {
+            unlinkSync(PENDING_FILE);
+        }
+        else {
+            writeFileSync(PENDING_FILE, remaining.join('\n') + '\n', 'utf-8');
+        }
+    }
+    catch {
+        // best-effort cleanup
+    }
+}
+export function loadPendingJobs() {
+    if (!existsSync(PENDING_FILE))
+        return [];
+    try {
+        const lines = readFileSync(PENDING_FILE, 'utf-8')
+            .split('\n')
+            .filter(Boolean);
+        const jobs = [];
+        for (const line of lines) {
+            try {
+                const parsed = JSON.parse(line);
+                jobs.push(parsed);
+            }
+            catch {
+                logger.warn({ line: line.slice(0, 100) }, 'skipping malformed pending job');
+            }
+        }
+        logger.info({ count: jobs.length }, 'loaded pending jobs from disk');
+        return jobs;
+    }
+    catch {
+        return [];
+    }
+}
+export function clearPending() {
+    if (existsSync(PENDING_FILE))
+        unlinkSync(PENDING_FILE);
+}

package/dist/queue/queue.js

@@ -0,0 +1,49 @@
+import fastq from 'fastq';
+import { logger } from '../logger.js';
+import { loadPendingJobs, persistJob, removeJob } from './persistence.js';
+import { processJob } from './worker.js';
+const queues = new Map();
+function getQueue(jid) {
+    let q = queues.get(jid);
+    if (!q) {
+        q = fastq.promise(async (job) => {
+            try {
+                const result = await processJob(job);
+                removeJob(job);
+                return result;
+            }
+            catch (err) {
+                removeJob(job);
+                throw err;
+            }
+        }, 1);
+        queues.set(jid, q);
+    }
+    return q;
+}
+export async function enqueue(job) {
+    persistJob(job);
+    return getQueue(job.jid).push(job);
+}
+/**
+ * On boot, replay any jobs that were persisted but never completed
+ * (process crashed mid-queue). Returns a promise that resolves when
+ * all replayed jobs finish or fail. Caller provides a handler for
+ * results since the original WAMessage context is gone.
+ */
+export async function replayPending(onResult) {
+    const pending = loadPendingJobs();
+    if (!pending.length)
+        return;
+    logger.info({ count: pending.length }, 'replaying pending jobs from last session');
+    const promises = pending.map(async (job) => {
+        try {
+            const result = await getQueue(job.jid).push(job);
+            await onResult(job, result);
+        }
+        catch (err) {
+            logger.error({ err, jid: job.jid }, 'replayed job failed');
+        }
+    });
+    await Promise.allSettled(promises);
+}

package/dist/queue/types.js

@@ -0,0 +1 @@
+export {};

package/dist/queue/worker.js

@@ -0,0 +1,51 @@
+import { askClaude } from '../ai/claude.js';
+import { clearSession, setSession, setUsage } from '../ai/sessions.js';
+import { logger } from '../logger.js';
+import { extractDigestFlag } from '../memory/digest-flag.js';
+import { scheduleDigest } from '../memory/scheduler.js';
+function isStaleSessionError(err) {
+    return (err instanceof Error &&
+        err.message.includes('No conversation found'));
+}
+async function callClaude(job) {
+    const { reply, sessionId, usage } = await askClaude({
+        input: job.input,
+        sessionId: job.sessionId,
+        allowedTools: job.allowedTools,
+    });
+    if (!job.sessionId) {
+        setSession(job.jid, sessionId);
+    }
+    const totalContextTokens = usage.inputTokens +
+        usage.cacheReadTokens +
+        usage.cacheCreationTokens +
+        usage.outputTokens;
+    setUsage(job.jid, {
+        ...usage,
+        totalContextTokens,
+        updatedAt: Math.floor(Date.now() / 1000),
+    });
+    const { clean, flag } = extractDigestFlag(reply);
+    if (flag) {
+        logger.info({ jid: job.jid, number: job.senderNumber, reason: flag }, 'DIGEST flag raised, scheduling');
+        scheduleDigest({
+            jid: job.jid,
+            number: job.senderNumber,
+            reason: flag,
+        });
+    }
+    return { reply: clean };
+}
+export async function processJob(job) {
+    try {
+        return await callClaude(job);
+    }
+    catch (err) {
+        if (job.sessionId && isStaleSessionError(err)) {
+            logger.warn({ jid: job.jid, staleId: job.sessionId }, 'stale session detected, clearing and retrying with fresh bootstrap');
+            clearSession(job.jid);
+            return callClaude({ ...job, sessionId: undefined, allowedTools: job.allowedTools });
+        }
+        throw err;
+    }
+}

package/dist/store/media.js

@@ -0,0 +1,108 @@
+import { mkdir, readdir, stat, unlink } from 'fs/promises';
+import { writeFileSync } from 'fs';
+import { resolve } from 'path';
+import { downloadMediaMessage, extensionForMediaMessage, getContentType, } from 'baileys';
+import { config } from '../config.js';
+import { logger } from '../logger.js';
+const MEDIA_TYPES = {
+    imageMessage: 'image',
+    videoMessage: 'video',
+    audioMessage: 'audio',
+    documentMessage: 'document',
+    documentWithCaptionMessage: 'document',
+    stickerMessage: 'sticker',
+};
+function mediaDir(jid) {
+    return resolve(process.cwd(), config.storage.mediaDir, jid);
+}
+export function detectMediaType(msg) {
+    const content = msg.message;
+    if (!content)
+        return null;
+    const type = getContentType(content);
+    if (!type)
+        return null;
+    return MEDIA_TYPES[type] ?? null;
+}
+export async function downloadAndSave(msg, jid) {
+    const mediaType = detectMediaType(msg);
+    if (!mediaType)
+        return null;
+    try {
+        const buffer = await downloadMediaMessage(msg, 'buffer', {});
+        const ext = extensionForMediaMessage(msg.message) || 'bin';
+        const id = msg.key.id || `${Date.now()}`;
+        const dir = mediaDir(jid);
+        await mkdir(dir, { recursive: true });
+        const filename = `${id}.${ext}`;
+        const filePath = resolve(dir, filename);
+        writeFileSync(filePath, buffer);
+        const content = msg.message;
+        const messageType = getContentType(content);
+        const mediaMsg = content[messageType];
+        const mimetype = mediaMsg?.mimetype ?? `application/octet-stream`;
+        logger.debug({ jid, mediaType, filename, bytes: buffer.length }, 'media saved');
+        return {
+            mediaType,
+            mediaPath: filePath,
+            mediaMime: mimetype,
+        };
+    }
+    catch (err) {
+        logger.error({ err, jid, msgId: msg.key.id }, 'media download failed');
+        return null;
+    }
+}
+export function mediaPromptTag(info, caption) {
+    const label = info.mediaType === 'image'
+        ? 'an image'
+        : info.mediaType === 'video'
+            ? 'a video'
+            : info.mediaType === 'audio'
+                ? 'a voice message'
+                : info.mediaType === 'document'
+                    ? 'a document'
+                    : 'a sticker';
+    const lines = [
+        `[User sent ${label}: ${info.mediaPath}]`,
+        `Read this file to see what the user sent.`,
+    ];
+    if (caption)
+        lines.push(`Caption: "${caption}"`);
+    return lines.join('\n');
+}
+/**
+ * Delete media files older than retention period.
+ */
+export async function pruneMedia() {
+    const days = config.storage.mediaRetentionDays;
+    if (days <= 0)
+        return;
+    const cutoffMs = Date.now() - days * 24 * 60 * 60 * 1000;
+    const baseDir = resolve(process.cwd(), config.storage.mediaDir);
+    try {
+        const jids = await readdir(baseDir, { withFileTypes: true });
+        for (const jidEntry of jids) {
+            if (!jidEntry.isDirectory())
+                continue;
+            const jidDir = resolve(baseDir, jidEntry.name);
+            const files = await readdir(jidDir);
+            for (const file of files) {
+                const fp = resolve(jidDir, file);
+                try {
+                    const s = await stat(fp);
+                    if (s.mtimeMs < cutoffMs) {
+                        await unlink(fp);
+                    }
+                }
+                catch { }
+            }
+            // remove empty jid dirs
+            const remaining = await readdir(jidDir);
+            if (remaining.length === 0) {
+                await readdir(jidDir).then(() => import('fs/promises').then((fs) => fs.rmdir(jidDir)));
+            }
+        }
+    }
+    catch { }
+}

package/dist/store/messages.js

@@ -0,0 +1,33 @@
+import { appendFile, mkdir, readFile } from 'fs/promises';
+import { resolve } from 'path';
+import { config } from '../config.js';
+let dirReady = false;
+async function ensureDir() {
+    if (dirReady)
+        return;
+    await mkdir(resolve(process.cwd(), config.storage.messagesDir), {
+        recursive: true,
+    });
+    dirReady = true;
+}
+function fileFor(jid) {
+    return resolve(process.cwd(), config.storage.messagesDir, `${jid}.jsonl`);
+}
+export async function append(msg) {
+    await ensureDir();
+    const line = JSON.stringify(msg) + '\n';
+    await appendFile(fileFor(msg.jid), line, 'utf-8');
+}
+export async function readLast(jid, n) {
+    try {
+        const content = await readFile(fileFor(jid), 'utf-8');
+        const lines = content.trimEnd().split('\n').filter(Boolean);
+        const tail = lines.slice(-n);
+        return tail.map((l) => JSON.parse(l));
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return [];
+        throw err;
+    }
+}

package/dist/wa/auth.js

@@ -0,0 +1,9 @@
+import { mkdirSync } from 'fs';
+import { resolve } from 'path';
+import { useMultiFileAuthState } from 'baileys';
+import { config } from '../config.js';
+export async function initAuth() {
+    const authDir = resolve(process.cwd(), config.whatsapp.authDir);
+    mkdirSync(authDir, { recursive: true });
+    return useMultiFileAuthState(authDir);
+}

package/dist/wa/sender.js

@@ -0,0 +1,79 @@
+import { readFileSync } from 'fs';
+import { basename, extname } from 'path';
+export async function sendText(sock, jid, text, quoted) {
+    return sock.sendMessage(jid, { text }, quoted ? { quoted } : undefined);
+}
+const EXT_MAP = {
+    '.png': 'image',
+    '.jpg': 'image',
+    '.jpeg': 'image',
+    '.gif': 'image',
+    '.webp': 'image',
+    '.mp4': 'video',
+    '.avi': 'video',
+    '.mov': 'video',
+    '.mkv': 'video',
+    '.mp3': 'audio',
+    '.ogg': 'audio',
+    '.opus': 'audio',
+    '.m4a': 'audio',
+    '.wav': 'audio',
+    '.pdf': 'document',
+    '.doc': 'document',
+    '.docx': 'document',
+    '.xls': 'document',
+    '.xlsx': 'document',
+    '.csv': 'document',
+    '.txt': 'document',
+    '.zip': 'document',
+};
+const MIME_MAP = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.mp4': 'video/mp4',
+    '.avi': 'video/avi',
+    '.mov': 'video/quicktime',
+    '.mkv': 'video/x-matroska',
+    '.mp3': 'audio/mpeg',
+    '.ogg': 'audio/ogg',
+    '.opus': 'audio/opus',
+    '.m4a': 'audio/mp4',
+    '.wav': 'audio/wav',
+    '.pdf': 'application/pdf',
+    '.doc': 'application/msword',
+    '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    '.xls': 'application/vnd.ms-excel',
+    '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    '.csv': 'text/csv',
+    '.txt': 'text/plain',
+    '.zip': 'application/zip',
+};
+export function detectMediaType(filePath) {
+    const ext = extname(filePath).toLowerCase();
+    return EXT_MAP[ext] ?? 'document';
+}
+export async function sendFile(sock, jid, filePath, caption, quoted) {
+    const buffer = readFileSync(filePath);
+    const ext = extname(filePath).toLowerCase();
+    const mime = MIME_MAP[ext] ?? 'application/octet-stream';
+    const type = detectMediaType(filePath);
+    const opts = quoted ? { quoted } : undefined;
+    switch (type) {
+        case 'image':
+            return sock.sendMessage(jid, { image: buffer, caption: caption || undefined }, opts);
+        case 'video':
+            return sock.sendMessage(jid, { video: buffer, caption: caption || undefined, mimetype: mime }, opts);
+        case 'audio':
+            return sock.sendMessage(jid, { audio: buffer, mimetype: mime }, opts);
+        case 'document':
+            return sock.sendMessage(jid, {
+                document: buffer,
+                mimetype: mime,
+                fileName: basename(filePath),
+                caption: caption || undefined,
+            }, opts);
+    }
+}

package/dist/wa/socket.js

@@ -0,0 +1,84 @@
+import makeWASocket, { Browsers, DisconnectReason, fetchLatestWaWebVersion, } from 'baileys';
+import QRCode from 'qrcode';
+import { config } from '../config.js';
+import { logger } from '../logger.js';
+import { initAuth } from './auth.js';
+let currentSocket = null;
+let currentQr = null;
+let pairingCodeShown = false;
+let reconnectAttempts = 0;
+const MAX_RECONNECT_ATTEMPTS = 10;
+let onNewSocket = null;
+export function getSocket() {
+    return currentSocket;
+}
+export function getCurrentQr() {
+    return currentQr;
+}
+export async function startSocket(listener) {
+    if (listener)
+        onNewSocket = listener;
+    const { state, saveCreds } = await initAuth();
+    const { version, isLatest } = await fetchLatestWaWebVersion({});
+    logger.info({ version, isLatest }, 'using WA Web version');
+    const sock = makeWASocket({
+        auth: state,
+        version,
+        browser: Browsers.macOS(config.whatsapp.browserName),
+        logger: logger.child({ module: 'baileys' }),
+        // Don't emit events for messages we send ourselves — eliminates echo
+        // loops and avoids double-storing outbound messages (outgoing.ts
+        // persists them explicitly).
+        emitOwnEvents: false,
+    });
+    currentSocket = sock;
+    onNewSocket?.(sock);
+    sock.ev.on('creds.update', saveCreds);
+    sock.ev.on('connection.update', async (update) => {
+        const { connection, lastDisconnect, qr } = update;
+        if (qr) {
+            currentQr = qr;
+            const ascii = await QRCode.toString(qr, { type: 'utf8', margin: 2 });
+            process.stdout.write('\nScan this QR in WhatsApp → Settings → Linked Devices → Link a device\n');
+            process.stdout.write(ascii + '\n');
+            // Also show pairing code (works on any terminal, even broken QR rendering)
+            if (!pairingCodeShown && config.owner.number) {
+                pairingCodeShown = true;
+                sock
+                    .requestPairingCode(config.owner.number)
+                    .then((code) => {
+                    process.stdout.write(`\nOr enter pairing code: ${code}\n` +
+                        `WhatsApp → Linked Devices → Link with phone number\n\n`);
+                })
+                    .catch(() => undefined);
+            }
+        }
+        if (connection === 'open') {
+            logger.info({ user: sock.user }, 'connection open');
+            reconnectAttempts = 0;
+            currentQr = null;
+            pairingCodeShown = false;
+        }
+        if (connection === 'close') {
+            const statusCode = lastDisconnect?.error?.output?.statusCode;
+            const loggedOut = statusCode === DisconnectReason.loggedOut;
+            logger.warn({ statusCode, loggedOut }, 'connection closed');
+            currentSocket = null;
+            if (loggedOut) {
+                logger.error('logged out — delete storage/auth and restart to re-pair');
+                return;
+            }
+            reconnectAttempts += 1;
+            if (reconnectAttempts > MAX_RECONNECT_ATTEMPTS) {
+                logger.fatal({ attempts: reconnectAttempts }, 'max reconnect attempts reached, giving up');
+                process.exit(1);
+            }
+            const delayMs = Math.min(2000 * reconnectAttempts, 30000);
+            logger.info({ attempt: reconnectAttempts, delayMs }, 'reconnecting');
+            setTimeout(() => {
+                void startSocket().catch((err) => logger.error({ err }, 'reconnect failed'));
+            }, delayMs);
+        }
+    });
+    return sock;
+}