@c4t4/heyamigo 0.9.0 → 0.9.2

package/dist/gateway/outgoing.js

@@ -1,10 +1,11 @@
-import { existsSync, unlinkSync } from 'fs';
+import { existsSync, statSync } from 'fs';
+import { extname } from 'path';
 import { isJidGroup } from 'baileys';
 import { config } from '../config.js';
+import { formatAddress, jidToAddress } from '../db/address.js';
 import { logger } from '../logger.js';
-import { append } from '../store/messages.js';
-import { detectMediaType, sendFile, sendText } from '../wa/sender.js';
-import { getSocket } from '../wa/socket.js';
+import { enqueueOutbound } from '../queue/outbound.js';
+import { detectMediaType } from '../wa/sender.js';
 // Matches [FILE: path], [IMAGE: path], [VIDEO: path], [AUDIO: path], [DOCUMENT: path]
 const FILE_TAG_RE = /\[(?:FILE|IMAGE|VIDEO|AUDIO|DOCUMENT):\s*([^\]]+)\]/gi;
 function extractFiles(reply) {
@@ -21,104 +22,140 @@ function extractFiles(reply) {
     }).trim();
     return { text, files };
 }
-export async function handleReply(job, result, originalMsg) {
-    const sock = getSocket();
-    if (!sock) {
-        logger.warn({ jid: job.jid }, 'no socket available to send reply');
-        return;
+function kindForFile(filePath) {
+    return detectMediaType(filePath);
+}
+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',
+};
+function mimeFor(filePath) {
+    return MIME_MAP[extname(filePath).toLowerCase()] ?? 'application/octet-stream';
+}
+function fileSize(filePath) {
+    try {
+        return statSync(filePath).size;
+    }
+    catch {
+        return undefined;
     }
+}
+// `originalMsg` is currently ignored when routing through the outbound
+// queue — Baileys quoting needs the full WAMessage embedded in
+// contextInfo, which we'd have to serialize through the DB row and
+// reconstruct. Known regression for Phase 1; see refactor-scrap.md.
+// Kept in the signature so existing callers don't change.
+export async function handleReply(job, result, _originalMsg) {
     const raw = result.reply?.replaceAll('—', ', ').replaceAll('–', '-');
     if (!raw)
         return;
     const { text, files } = extractFiles(raw);
     const isGroup = isJidGroup(job.jid) === true;
-    const quoted = isGroup && config.reply.quoteInGroups ? originalMsg : undefined;
+    void isGroup; // quoting deferred; see comment above
+    const address = formatAddress(jidToAddress(job.jid));
     const footer = result.stats && config.reply.showStats
         ? formatStatsFooter(result.stats)
         : '';
-    try {
-        // Send files first (images, videos, PDFs, audio, etc.)
-        for (const filePath of files) {
-            const isFirst = filePath === files[0];
-            const mediaType = detectMediaType(filePath);
-            // First file gets caption if text is short + single file + supports captions
-            const supportsCaption = mediaType !== 'audio';
-            const caption = isFirst && text && text.length <= 1000 && files.length === 1 && supportsCaption
-                ? text
-                : undefined;
-            // Append footer to caption at send time only (not to storage). Only
-            // when this media file is the final user-facing payload (no text
-            // coming after, single file with caption case).
-            const willHaveTextAfter = !!text &&
-                !(files.length === 1 && text.length <= 1000 && supportsCaption);
-            const captionForSend = caption && footer && !willHaveTextAfter
-                ? `${caption}\n\n${footer}`
-                : caption;
-            await sendFile(sock, job.jid, filePath, captionForSend, isFirst ? quoted : undefined);
-            await append({
-                id: `reply-file-${Date.now()}`,
-                jid: job.jid,
-                direction: 'out',
-                fromMe: true,
-                sender: sock.user?.id ?? '',
-                senderNumber: config.owner.number,
-                timestamp: Math.floor(Date.now() / 1000),
-                text: caption || `[${mediaType}: ${filePath}]`,
-                messageType: `${mediaType}Message`,
-                mediaPath: filePath,
-                mediaType,
-            });
-            logger.info({ jid: job.jid, path: filePath, mediaType }, 'file sent');
-            // Clean up temp file after sending
-            try {
-                unlinkSync(filePath);
-            }
-            catch { }
-            if (files.length > 1)
-                await sleep(config.reply.chunkDelayMs);
-        }
-        // Send text (skip if already used as caption on single file)
-        const textAlreadySent = files.length === 1 && text && text.length <= 1000 && detectMediaType(files[0]) !== 'audio';
-        if (text && !textAlreadySent) {
-            const chunks = chunkText(text, config.reply.chunkChars);
-            for (let i = 0; i < chunks.length; i++) {
-                const chunk = chunks[i];
-                const q = i === 0 && files.length === 0 ? quoted : undefined;
-                const isLast = i === chunks.length - 1;
-                const chunkForSend = isLast && footer ? `${chunk}\n\n${footer}` : chunk;
-                await sendText(sock, job.jid, chunkForSend, q);
-                await append({
-                    id: `reply-${Date.now()}-${i}`,
-                    jid: job.jid,
-                    direction: 'out',
-                    fromMe: true,
-                    sender: sock.user?.id ?? '',
-                    senderNumber: config.owner.number,
-                    timestamp: Math.floor(Date.now() / 1000),
-                    text: chunk,
-                    messageType: 'conversation',
-                });
-                if (i < chunks.length - 1)
-                    await sleep(config.reply.chunkDelayMs);
-            }
-        }
-        if (config.reply.typingIndicator) {
-            await sock
-                .sendPresenceUpdate('paused', job.jid)
-                .catch(() => undefined);
-        }
-        logger.info({
-            jid: job.jid,
-            files: files.length,
-            chars: text.length,
-        }, 'reply sent');
+    let pieceIdx = 0;
+    const baseKey = `reply-${job.jid}-${Date.now()}`;
+    const enqueuePiece = (input) => {
+        enqueueOutbound({ ...input, idempotencyKey: `${baseKey}-${pieceIdx++}` });
+    };
+    // Files first. Caption goes on the single-file-with-short-text case,
+    // matching pre-refactor behavior.
+    for (let i = 0; i < files.length; i++) {
+        const filePath = files[i];
+        const isFirst = i === 0;
+        const kind = kindForFile(filePath);
+        const supportsCaption = kind !== 'audio';
+        const caption = isFirst && text && text.length <= 1000 && files.length === 1 && supportsCaption
+            ? text
+            : undefined;
+        const willHaveTextAfter = !!text && !(files.length === 1 && text.length <= 1000 && supportsCaption);
+        const captionForSend = caption && footer && !willHaveTextAfter
+            ? `${caption}\n\n${footer}`
+            : caption;
+        enqueuePiece({
+            address,
+            kind,
+            text: captionForSend,
+            mediaPath: filePath,
+            mediaMime: mimeFor(filePath),
+            mediaBytes: fileSize(filePath),
+        });
     }
-    catch (err) {
-        logger.error({ err, jid: job.jid }, 'failed to send reply');
+    // Text — skip if already used as a caption on a single file.
+    const textAlreadySent = files.length === 1 &&
+        text &&
+        text.length <= 1000 &&
+        kindForFile(files[0]) !== 'audio';
+    if (text && !textAlreadySent) {
+        const chunks = chunkText(text, config.reply.chunkChars);
+        for (let i = 0; i < chunks.length; i++) {
+            const chunk = chunks[i];
+            const isLast = i === chunks.length - 1;
+            const chunkForSend = isLast && footer ? `${chunk}\n\n${footer}` : chunk;
+            enqueuePiece({ address, kind: 'text', text: chunkForSend });
+        }
     }
+    logger.info({ jid: job.jid, files: files.length, chars: text.length, pieces: pieceIdx }, 'reply enqueued for outbound');
 }
-function sleep(ms) {
-    return new Promise((r) => setTimeout(r, ms));
+// Proactive outbound: send a message to a chat without an incoming
+// trigger. Same parsing as handleReply; enqueues outbound rows.
+// `text` may contain [FILE:...] tags; they're extracted and enqueued
+// as media. Returns true if anything was enqueued.
+export async function initiate(params) {
+    const raw = params.text.replaceAll('—', ', ').replaceAll('–', '-');
+    if (!raw.trim())
+        return false;
+    const { text, files } = extractFiles(raw);
+    if (!text && files.length === 0)
+        return false;
+    const address = formatAddress(jidToAddress(params.jid));
+    let pieceIdx = 0;
+    const baseKey = `initiate-${params.jid}-${Date.now()}`;
+    const enqueuePiece = (input) => {
+        enqueueOutbound({ ...input, idempotencyKey: `${baseKey}-${pieceIdx++}` });
+    };
+    for (let i = 0; i < files.length; i++) {
+        const filePath = files[i];
+        const isFirst = i === 0;
+        const kind = kindForFile(filePath);
+        const supportsCaption = kind !== 'audio';
+        const caption = isFirst && text && text.length <= 1000 && files.length === 1 && supportsCaption
+            ? text
+            : undefined;
+        enqueuePiece({
+            address,
+            kind,
+            text: caption,
+            mediaPath: filePath,
+            mediaMime: mimeFor(filePath),
+            mediaBytes: fileSize(filePath),
+        });
+    }
+    const textAlreadySent = files.length === 1 &&
+        text &&
+        text.length <= 1000 &&
+        kindForFile(files[0]) !== 'audio';
+    if (text && !textAlreadySent) {
+        const chunks = chunkText(text, config.reply.chunkChars);
+        for (const chunk of chunks) {
+            enqueuePiece({ address, kind: 'text', text: chunk });
+        }
+    }
+    logger.info({ jid: params.jid, files: files.length, chars: text.length, pieces: pieceIdx }, 'proactive message enqueued for outbound');
+    return pieceIdx > 0;
 }
 // Append-only-at-send footer. Never stored, never in Claude's recent-context
 // feedback loop. Adaptive: shows only what's interesting for this reply.
@@ -142,16 +179,12 @@ export function formatStatsFooter(stats) {
         else if (pct >= 70)
             parts.push(`${pct}% ctx`);
     }
-    // Fresh session — resume is default, says nothing
     if (stats.fresh)
         parts.push('fresh');
-    // Journal flagged — show each slug (usually 0 or 1)
     for (const slug of stats.journalSlugs)
         parts.push(`+journal:${slug}`);
-    // Digest fired
     if (stats.hasDigest)
         parts.push('+digest');
-    // Async spawned
     if (stats.asyncCount > 0) {
         parts.push(stats.asyncCount === 1 ? '+async' : `+${stats.asyncCount} async`);
     }
@@ -164,89 +197,6 @@ function compactTokens(n) {
         return `${(n / 1000).toFixed(1)}k`;
     return `${Math.round(n / 1000)}k`;
 }
-// Proactive outbound: send a message to a chat without an incoming trigger.
-// Extracts [FILE:]/[IMAGE:]/etc tags the same way handleReply does — files
-// get sent as WhatsApp media, remaining text sent normally. Chunks, persists
-// to the message log, never throws. Callers are responsible for the
-// canSendProactive() gate — this function does not re-check it.
-export async function initiate(params) {
-    const sock = getSocket();
-    if (!sock) {
-        logger.warn({ jid: params.jid }, 'initiate: no socket available');
-        return false;
-    }
-    const raw = params.text.replaceAll('—', ', ').replaceAll('–', '-');
-    if (!raw.trim())
-        return false;
-    const { text, files } = extractFiles(raw);
-    try {
-        // Send any files first — images, video, PDFs, audio, etc.
-        for (const filePath of files) {
-            const isFirst = filePath === files[0];
-            const mediaType = detectMediaType(filePath);
-            const supportsCaption = mediaType !== 'audio';
-            const caption = isFirst &&
-                text &&
-                text.length <= 1000 &&
-                files.length === 1 &&
-                supportsCaption
-                ? text
-                : undefined;
-            await sendFile(sock, params.jid, filePath, caption);
-            await append({
-                id: `initiate-file-${Date.now()}`,
-                jid: params.jid,
-                direction: 'out',
-                fromMe: true,
-                sender: sock.user?.id ?? '',
-                senderNumber: config.owner.number,
-                timestamp: Math.floor(Date.now() / 1000),
-                text: caption || `[${mediaType}: ${filePath}]`,
-                messageType: `${mediaType}Message`,
-                mediaPath: filePath,
-                mediaType,
-            });
-            logger.info({ jid: params.jid, path: filePath, mediaType }, 'proactive file sent');
-            try {
-                unlinkSync(filePath);
-            }
-            catch { }
-            if (files.length > 1)
-                await sleep(config.reply.chunkDelayMs);
-        }
-        // Send text — skip only when it was used as the caption on a single file
-        const textAlreadySent = files.length === 1 &&
-            text &&
-            text.length <= 1000 &&
-            detectMediaType(files[0]) !== 'audio';
-        if (text && !textAlreadySent) {
-            const chunks = chunkText(text, config.reply.chunkChars);
-            for (let i = 0; i < chunks.length; i++) {
-                const chunk = chunks[i];
-                await sendText(sock, params.jid, chunk);
-                await append({
-                    id: `initiate-${Date.now()}-${i}`,
-                    jid: params.jid,
-                    direction: 'out',
-                    fromMe: true,
-                    sender: sock.user?.id ?? '',
-                    senderNumber: config.owner.number,
-                    timestamp: Math.floor(Date.now() / 1000),
-                    text: chunk,
-                    messageType: 'conversation',
-                });
-                if (i < chunks.length - 1)
-                    await sleep(config.reply.chunkDelayMs);
-            }
-        }
-        logger.info({ jid: params.jid, files: files.length, chars: text.length }, 'proactive message sent');
-        return true;
-    }
-    catch (err) {
-        logger.error({ err, jid: params.jid }, 'initiate failed');
-        return false;
-    }
-}
 export function chunkText(text, maxChars) {
     if (text.length <= maxChars)
         return [text];

package/dist/index.js

@@ -1,19 +1,28 @@
+import { setBaileysSocket } from './channels/index.js';
 import { closeDb, initDb } from './db/index.js';
+import { syncIdentitiesFromAccess } from './db/identity-sync.js';
 import { attachIncoming } from './gateway/incoming.js';
 import { handleReply } from './gateway/outgoing.js';
 import { logger } from './logger.js';
 import { startScheduler } from './memory/scheduler.js';
 import { replayPending } from './queue/queue.js';
+import { startSenderWorker, stopSenderWorker } from './queue/sender-worker.js';
 import { startSocket } from './wa/socket.js';
 async function main() {
     logger.info('heyamigo starting');
     // Migrations + drift check first; refuses to start on schema mismatch.
-    // Additive — flat-file storage (sessions.json, memory files,
-    // access.json) still authoritative until later phases swap them.
     initDb();
+    // Derived view: populate persons + identities from access.json.
+    syncIdentitiesFromAccess();
+    // Sender worker drains outbound queue → channel adapters. Started
+    // before the socket so it's ready when handleReply enqueues rows.
+    startSenderWorker();
     startScheduler();
     await startSocket((sock) => {
         attachIncoming(sock);
+        // Point the Baileys adapter at the live socket. Called on each
+        // reconnect with a fresh sock; the adapter just keeps the latest.
+        setBaileysSocket(sock);
     });
     // Replay any jobs left from a previous crash (no original WAMessage
     // available, so replies are sent as plain messages, not quoted).
@@ -23,11 +32,13 @@ async function main() {
 }
 process.on('SIGINT', () => {
     logger.info('SIGINT received, shutting down');
+    stopSenderWorker();
     closeDb();
     process.exit(0);
 });
 process.on('SIGTERM', () => {
     logger.info('SIGTERM received, shutting down');
+    stopSenderWorker();
     closeDb();
     process.exit(0);
 });

package/dist/memory/digest-flag.js

@@ -14,6 +14,7 @@ const KINDS = [
     'JOURNAL-NEW',
     'ASYNC',
     'ASYNC-BROWSER',
+    'SEND-TEXT',
 ];
 // Walk backwards from the end of the string, tracking bracket depth, to find
 // the `[` that matches the final `]`. Returns the tag kind, its payload, and
@@ -74,6 +75,7 @@ export function extractFlags(reply) {
     const journalCreates = [];
     const asyncTasks = [];
     const asyncBrowserTasks = [];
+    const sendTexts = [];
     while (true) {
         const peeled = peelTrailingTag(current);
         if (!peeled)
@@ -105,6 +107,11 @@ export function extractFlags(reply) {
                 asyncBrowserTasks.unshift({ description: payload });
             }
         }
+        else if (kind === 'SEND-TEXT') {
+            const parsed = parseSendTextPayload(payload);
+            if (parsed)
+                sendTexts.unshift(parsed);
+        }
     }
     return {
         clean: current,
@@ -113,6 +120,7 @@ export function extractFlags(reply) {
         journalCreates,
         asyncTasks,
         asyncBrowserTasks,
+        sendTexts,
     };
 }
 // Legacy helper kept so existing callers still compile.
@@ -121,6 +129,26 @@ export function extractDigestFlag(reply) {
     return { clean: r.clean, flag: r.digest };
 }
 const JOURNAL_SEP_RE = /\s*(?:[—\-–]|:)\s*/;
+// Parse `address=<addr> body="..."` style key=value payload.
+// Body is delimited by double quotes; everything else by whitespace.
+// Returns null if address or body is missing.
+function parseSendTextPayload(payload) {
+    // Grab body="..." first (longest match so quoted body can contain spaces)
+    const bodyMatch = payload.match(/\bbody\s*=\s*"((?:[^"\\]|\\.)*)"/);
+    if (!bodyMatch)
+        return null;
+    const body = bodyMatch[1]
+        .replace(/\\"/g, '"')
+        .replace(/\\\\/g, '\\');
+    if (!body.trim())
+        return null;
+    // Strip the body=... portion so address parsing doesn't trip on it
+    const withoutBody = payload.replace(bodyMatch[0], '').trim();
+    const addrMatch = withoutBody.match(/\baddress\s*=\s*([^\s]+)/);
+    if (!addrMatch)
+        return null;
+    return { address: addrMatch[1], body };
+}
 function parseJournalPayload(payload) {
     // Split on first em-dash, en-dash, hyphen, or colon between slug and note.
     const match = payload.match(/^([a-zA-Z0-9][a-zA-Z0-9-]*)(.*)$/);

package/dist/queue/async-tasks.js

@@ -124,7 +124,20 @@ async function executeAsyncTask(task) {
     // as markers; clean pre-marker text is only sent to chat when short (a
     // failure explanation or tight ack) or when no markers fired at all.
     const { extractFlags } = await import('../memory/digest-flag.js');
-    const { clean, digest, journals, journalCreates } = extractFlags(output);
+    const { clean, digest, journals, journalCreates, sendTexts } = extractFlags(output);
+    // SEND-TEXT: async task wants to text a different chat too.
+    if (sendTexts.length > 0) {
+        const { enqueueOutbound } = await import('./outbound.js');
+        for (let i = 0; i < sendTexts.length; i++) {
+            const t = sendTexts[i];
+            enqueueOutbound({
+                address: t.address,
+                kind: 'text',
+                text: t.body,
+                idempotencyKey: `async-sendtext-${task.id}-${i}`,
+            });
+        }
+    }
     // Journal creates run first so an entry flagged in the same output against
     // a new slug lands correctly.
     const { appendEntry, createJournal, getJournal, isValidSlug } = await import('../memory/journals.js');
@@ -402,7 +415,19 @@ async function runBrowserTask(task) {
     }
     // Route markers the same way the general async lane does.
     const { extractFlags } = await import('../memory/digest-flag.js');
-    const { clean, digest, journals, journalCreates } = extractFlags(reply);
+    const { clean, digest, journals, journalCreates, sendTexts } = extractFlags(reply);
+    if (sendTexts.length > 0) {
+        const { enqueueOutbound } = await import('./outbound.js');
+        for (let i = 0; i < sendTexts.length; i++) {
+            const t = sendTexts[i];
+            enqueueOutbound({
+                address: t.address,
+                kind: 'text',
+                text: t.body,
+                idempotencyKey: `browser-sendtext-${task.id}-${i}`,
+            });
+        }
+    }
     const { appendEntry, createJournal, getJournal, isValidSlug } = await import('../memory/journals.js');
     for (const op of journalCreates) {
         if (!isValidSlug(op.slug))

package/dist/queue/outbound-postsend.js

@@ -0,0 +1,77 @@
+// Post-send bookkeeping run by the sender worker after a successful
+// channel send. Kept separate from the worker loop so it's easy to
+// extend (e.g. emit metrics, fire webhooks) without bloating the loop.
+//
+// Today's job:
+//  - Append a row to the message log so Claude sees what the bot
+//    said in future bootstrap context.
+//  - Delete the local file if the outbound row pointed at one and the
+//    path looks like ephemeral outbox content. We trust producers to
+//    only point at files they want unlinked after send.
+import { existsSync, unlinkSync } from 'fs';
+import { isAbsolute, resolve } from 'path';
+import { config } from '../config.js';
+import { addressToExternalId, parseAddress } from '../db/address.js';
+import { logger } from '../logger.js';
+import { append } from '../store/messages.js';
+export async function afterSend(row, sentMsgId) {
+    await persistToMessageLog(row, sentMsgId);
+    maybeUnlinkMedia(row);
+}
+async function persistToMessageLog(row, msgId) {
+    let address;
+    try {
+        address = parseAddress(row.address);
+    }
+    catch {
+        return;
+    }
+    // Message log is currently WA-specific (keyed by JID). Only persist
+    // WA-bound replies for now; multi-channel log unification comes in a
+    // later phase.
+    if (address.channel !== 'wa')
+        return;
+    const jid = addressToExternalId(address);
+    const messageType = row.kind === 'text' ? 'conversation' : `${row.kind}Message`;
+    try {
+        await append({
+            id: `outbound-${row.id}-${msgId}`,
+            jid,
+            direction: 'out',
+            fromMe: true,
+            sender: '',
+            senderNumber: config.owner.number,
+            timestamp: Math.floor(Date.now() / 1000),
+            text: row.text ?? (row.mediaPath ? `[${row.kind}: ${row.mediaPath}]` : ''),
+            messageType,
+            mediaPath: row.mediaPath ?? undefined,
+            mediaType: row.kind === 'text' ? undefined : row.kind,
+        });
+    }
+    catch (err) {
+        logger.warn({ err, outboundId: row.id }, 'failed to append to message log (send already succeeded)');
+    }
+}
+function maybeUnlinkMedia(row) {
+    if (!row.mediaPath)
+        return;
+    // Resolve relative paths the same way the sender worker did when
+    // calling the adapter, so we delete the actual file.
+    const path = isAbsolute(row.mediaPath)
+        ? row.mediaPath
+        : resolve(process.cwd(), row.mediaPath);
+    // Only auto-delete files inside known-ephemeral directories. Inbound
+    // media in storage/media/ has its own retention cron and should not
+    // be touched here. config.storage.mediaDir = inbound media.
+    const inboundMediaDir = resolve(process.cwd(), config.storage.mediaDir);
+    if (path.startsWith(inboundMediaDir)) {
+        return;
+    }
+    try {
+        if (existsSync(path))
+            unlinkSync(path);
+    }
+    catch (err) {
+        logger.warn({ err, path }, 'failed to unlink outbound media file');
+    }
+}