@c4t4/heyamigo 0.9.0 → 0.9.1

package/dist/channels/adapter.js

@@ -0,0 +1,24 @@
+// Channel adapter interface. The sender worker drains the outbound
+// queue, parses each row's address (wa:dm:..., tg:dm:..., etc.), and
+// dispatches to the adapter for the matching channel. Adapters are
+// the *only* place that talks to a channel SDK (Baileys, Telegram bot,
+// whatever). Workers stay channel-agnostic.
+// Distinguishes between "the channel said no, try again later" and
+// "the message itself is broken." Sender worker uses this to decide
+// retry vs DLQ.
+export class TransientChannelError extends Error {
+    cause;
+    constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+        this.name = 'TransientChannelError';
+    }
+}
+export class PermanentChannelError extends Error {
+    cause;
+    constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+        this.name = 'PermanentChannelError';
+    }
+}

package/dist/channels/baileys.js

@@ -0,0 +1,158 @@
+// Baileys (WhatsApp) channel adapter. Wraps the existing wa/sender.ts
+// behind the ChannelAdapter interface so the sender worker stays
+// channel-agnostic.
+//
+// The WASocket is created in src/wa/socket.ts and replaced on each
+// reconnect. Boot path (or the connection callback) calls
+// setBaileysSocket(sock) so the adapter always points at the live one.
+import { readFileSync, statSync } from 'fs';
+import { basename, extname } from 'path';
+import { PermanentChannelError, TransientChannelError, } from './adapter.js';
+let activeSocket = null;
+export function setBaileysSocket(sock) {
+    activeSocket = sock;
+}
+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, fallback) {
+    if (fallback)
+        return fallback;
+    const ext = extname(filePath).toLowerCase();
+    return MIME_MAP[ext] ?? 'application/octet-stream';
+}
+function requireSocket() {
+    if (!activeSocket) {
+        // Socket isn't ready — sender worker should not have tried. This
+        // becomes "retry later" so the message stays in queue until WA
+        // reconnects.
+        throw new TransientChannelError('baileys socket not connected');
+    }
+    return activeSocket;
+}
+function requireFile(path) {
+    try {
+        const stat = statSync(path);
+        const buf = readFileSync(path);
+        return { buf, bytes: stat.size };
+    }
+    catch (err) {
+        throw new PermanentChannelError(`media file unreadable: ${path} (${err.message})`, err);
+    }
+}
+// Map a Baileys send error onto our transient/permanent classification.
+// Network/connection issues → transient. Anything else (invalid jid,
+// payload, etc.) → permanent.
+function classifyBaileysError(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    // Heuristic: Baileys throws "connection closed" / "timed out" /
+    // "socket" for transient stuff; everything else assume permanent.
+    const transientHints = [
+        'connection closed',
+        'connection lost',
+        'timed out',
+        'timeout',
+        'socket',
+        'lost connection',
+        'no connection',
+    ];
+    const lower = message.toLowerCase();
+    if (transientHints.some((h) => lower.includes(h))) {
+        return new TransientChannelError(message, err);
+    }
+    return new PermanentChannelError(message, err);
+}
+async function sendOne(sock, jid, msg) {
+    const quoteOpts = msg.quoteMsgId
+        ? // Baileys quoting actually needs the full WAMessage to embed in
+            // contextInfo; we only have the id. For now we send without
+            // quoting in that case (future: cache recent WAMessages keyed
+            // by id so we can rehydrate the quote target).
+            undefined
+        : undefined;
+    switch (msg.kind) {
+        case 'text':
+            if (!msg.text) {
+                throw new PermanentChannelError('text outbound has no body');
+            }
+            return sock.sendMessage(jid, { text: msg.text }, quoteOpts);
+        case 'image': {
+            if (!msg.mediaPath) {
+                throw new PermanentChannelError('image outbound missing mediaPath');
+            }
+            const { buf } = requireFile(msg.mediaPath);
+            return sock.sendMessage(jid, { image: buf, caption: msg.text ?? undefined }, quoteOpts);
+        }
+        case 'video': {
+            if (!msg.mediaPath) {
+                throw new PermanentChannelError('video outbound missing mediaPath');
+            }
+            const { buf } = requireFile(msg.mediaPath);
+            return sock.sendMessage(jid, {
+                video: buf,
+                caption: msg.text ?? undefined,
+                mimetype: mimeFor(msg.mediaPath, msg.mediaMime),
+            }, quoteOpts);
+        }
+        case 'audio': {
+            if (!msg.mediaPath) {
+                throw new PermanentChannelError('audio outbound missing mediaPath');
+            }
+            const { buf } = requireFile(msg.mediaPath);
+            return sock.sendMessage(jid, { audio: buf, mimetype: mimeFor(msg.mediaPath, msg.mediaMime) }, quoteOpts);
+        }
+        case 'document': {
+            if (!msg.mediaPath) {
+                throw new PermanentChannelError('document outbound missing mediaPath');
+            }
+            const { buf } = requireFile(msg.mediaPath);
+            return sock.sendMessage(jid, {
+                document: buf,
+                mimetype: mimeFor(msg.mediaPath, msg.mediaMime),
+                fileName: basename(msg.mediaPath),
+                caption: msg.text ?? undefined,
+            }, quoteOpts);
+        }
+    }
+}
+export const baileysAdapter = {
+    channel: 'wa',
+    async send(externalId, msg) {
+        const sock = requireSocket();
+        let sent;
+        try {
+            sent = await sendOne(sock, externalId, msg);
+        }
+        catch (err) {
+            throw classifyBaileysError(err);
+        }
+        const msgId = sent?.key?.id;
+        if (!msgId) {
+            // Baileys returned without an id; treat as transient so we retry
+            // (rather than silently losing track of whether the send happened).
+            throw new TransientChannelError('baileys send returned no message id');
+        }
+        return { msgId };
+    },
+};

package/dist/channels/index.js

@@ -0,0 +1,16 @@
+// Channel adapter registry. Sender worker calls getChannelAdapter(name)
+// keyed off the parsed address.channel.
+import { baileysAdapter } from './baileys.js';
+const REGISTRY = {
+    wa: baileysAdapter,
+    // tg: telegramAdapter, // Phase 8
+};
+export function getChannelAdapter(channel) {
+    const adapter = REGISTRY[channel];
+    if (!adapter) {
+        throw new Error(`no channel adapter registered for channel="${channel}"`);
+    }
+    return adapter;
+}
+export { setBaileysSocket } from './baileys.js';
+export { PermanentChannelError, TransientChannelError, } from './adapter.js';

package/dist/config.js

@@ -70,6 +70,10 @@ const ConfigSchema = z.object({
         errorMessage: z.string(),
         maxMessageAgeMs: z.number(),
         showStats: z.boolean().default(true),
+        // Hard cap on outbound media size enforced by the sender worker.
+        // Default 25MB matches WhatsApp's published per-message media limit
+        // for most kinds. Set to null to disable the check.
+        maxOutboundMediaBytes: z.number().int().positive().nullable().default(25 * 1024 * 1024),
     }),
     storage: z.object({
         messagesDir: z.string(),

package/dist/db/identity-sync.js

@@ -0,0 +1,147 @@
+// Derive persons + identities from existing config/access.json. Runs
+// at boot, idempotently. The file stays authoritative; the DB rows
+// are a *derived view* so future queue rows can reference person_id
+// without joining against the file every time.
+//
+// No schema change to access.json. Phase 0 doesn't touch the file.
+// Person mapping:
+//   - config.owner.number             → person-owner
+//   - each entry in access.users      → person-<sanitized-number>
+//   - each entry in access.dms.allowed → ensure a person exists
+//   - groups are addresses, not persons — skipped
+//
+// Re-running the sync on every boot:
+//   - upserts display_name (in case access.json was edited)
+//   - adds new identities (in case the owner added a number)
+//   - never deletes (avoid surprise data loss; explicit cleanup
+//     command can come later)
+import { eq } from 'drizzle-orm';
+import { config } from '../config.js';
+import { logger } from '../logger.js';
+import { jidToAddress, formatAddress } from './address.js';
+import { getDb } from './index.js';
+import { identities, persons } from './schema.js';
+import { getAccess } from '../wa/whitelist.js';
+const OWNER_PERSON_ID = 'person-owner';
+function personIdForNumber(number) {
+    // Strip non-digits, prefix with 'person-'. Stable + deterministic.
+    const sanitized = number.replace(/\D/g, '');
+    return `person-${sanitized}`;
+}
+function dmAddressFor(number) {
+    const sanitized = number.replace(/\D/g, '');
+    return formatAddress(jidToAddress(`${sanitized}@s.whatsapp.net`));
+}
+function collectSeeds() {
+    const access = getAccess();
+    const now = Math.floor(Date.now() / 1000);
+    void now;
+    const out = new Map();
+    // Owner
+    if (config.owner.number) {
+        out.set(OWNER_PERSON_ID, {
+            id: OWNER_PERSON_ID,
+            displayName: 'Owner',
+            addresses: [dmAddressFor(config.owner.number)],
+        });
+    }
+    // Users
+    for (const [number, entry] of Object.entries(access.users ?? {})) {
+        const id = number === config.owner.number ? OWNER_PERSON_ID : personIdForNumber(number);
+        const existing = out.get(id);
+        const addr = dmAddressFor(number);
+        if (existing) {
+            if (entry.name)
+                existing.displayName = entry.name;
+            if (!existing.addresses.includes(addr))
+                existing.addresses.push(addr);
+        }
+        else {
+            out.set(id, {
+                id,
+                displayName: entry.name ?? null,
+                addresses: [addr],
+            });
+        }
+    }
+    // DM allowed — ensure persons exist, even without a name
+    for (const dm of access.dms?.allowed ?? []) {
+        const id = dm.number === config.owner.number ? OWNER_PERSON_ID : personIdForNumber(dm.number);
+        const addr = dmAddressFor(dm.number);
+        const existing = out.get(id);
+        if (existing) {
+            if (!existing.addresses.includes(addr))
+                existing.addresses.push(addr);
+        }
+        else {
+            out.set(id, { id, displayName: null, addresses: [addr] });
+        }
+    }
+    return [...out.values()];
+}
+// Idempotent upsert. Inserts new rows; updates display_name on existing
+// person rows (in case it was filled in later); never deletes.
+export function syncIdentitiesFromAccess() {
+    const db = getDb();
+    const seeds = collectSeeds();
+    const now = Math.floor(Date.now() / 1000);
+    let personsUpserted = 0;
+    let identitiesUpserted = 0;
+    db.transaction((tx) => {
+        for (const seed of seeds) {
+            const existing = tx
+                .select()
+                .from(persons)
+                .where(eq(persons.id, seed.id))
+                .all();
+            if (existing.length === 0) {
+                tx.insert(persons)
+                    .values({
+                    id: seed.id,
+                    displayName: seed.displayName,
+                    timezone: config.owner.timezone,
+                    createdAt: now,
+                })
+                    .run();
+                personsUpserted++;
+            }
+            else if (seed.displayName &&
+                existing[0].displayName !== seed.displayName) {
+                tx.update(persons)
+                    .set({ displayName: seed.displayName })
+                    .where(eq(persons.id, seed.id))
+                    .run();
+                personsUpserted++;
+            }
+            for (const addr of seed.addresses) {
+                const have = tx
+                    .select()
+                    .from(identities)
+                    .where(eq(identities.address, addr))
+                    .all();
+                if (have.length === 0) {
+                    tx.insert(identities)
+                        .values({ personId: seed.id, address: addr, addedAt: now })
+                        .run();
+                    identitiesUpserted++;
+                }
+                // If have.length > 0 but personId differs, leave it — manual
+                // merge required. Don't reassign silently.
+            }
+        }
+    });
+    logger.info({ personsUpserted, identitiesUpserted, seeded: seeds.length }, 'identity sync from access.json complete');
+    return { personsUpserted, identitiesUpserted };
+}
+// Lookup helper used by the inbound resolution step (in later phases).
+// Returns null if the address has no matching person — caller decides
+// whether to auto-create or treat as stranger.
+export function personIdForAddress(address) {
+    const db = getDb();
+    const row = db
+        .select({ personId: identities.personId })
+        .from(identities)
+        .where(eq(identities.address, address))
+        .get();
+    return row?.personId ?? null;
+}

package/dist/db/schema.js

@@ -2,7 +2,8 @@
 // `npx drizzle-kit generate` produces a SQL migration in migrations/.
 // Direct ALTER/CREATE/DROP outside this flow is forbidden — see the
 // "Cardinal rule" section in refactor.md.
-import { sqliteTable, text, integer, primaryKey, index } from 'drizzle-orm/sqlite-core';
+import { sql } from 'drizzle-orm';
+import { sqliteTable, text, integer, primaryKey, index, uniqueIndex } from 'drizzle-orm/sqlite-core';
 // ──────────────────────────────────────────────────────────────────
 // Identity
 // ──────────────────────────────────────────────────────────────────
@@ -51,3 +52,46 @@ export const control = sqliteTable('control', {
     requestedBy: text('requested_by'),
     requestedAt: integer('requested_at').notNull(),
 });
+// ──────────────────────────────────────────────────────────────────
+// Outbound queue (Phase 1)
+// ──────────────────────────────────────────────────────────────────
+// Replies waiting to be sent on any channel. Workers (chat / async /
+// browser) insert rows here; the sender worker drains by channel
+// adapter. AI code never touches the WA socket directly.
+//
+// Status lifecycle:
+//   pending → sending → done   (happy path)
+//   sending → pending          (transient fail, attempts++, backoff)
+//   sending → failed           (permanent fail, kept for inspection)
+//   sending → dlq              (attempts > N; dead-letter)
+//
+// idempotency_key prevents double-sends when a worker is reclaimed
+// after TTL and its delayed insert collides with the replacement
+// worker's insert. Format suggested: `from-inbound-<id>` or
+// `from-async-<task-id>`.
+export const outbound = sqliteTable('outbound', {
+    id: integer('id').primaryKey({ autoIncrement: true }),
+    address: text('address').notNull(), // 'wa:dm:...' | 'wa:group:...' | etc.
+    kind: text('kind').notNull(), // 'text'|'image'|'video'|'audio'|'document'
+    text: text('text'), // body or caption
+    mediaPath: text('media_path'), // relative to storage/ when set
+    mediaMime: text('media_mime'),
+    mediaBytes: integer('media_bytes'), // enforced cap
+    quoteMsgId: text('quote_msg_id'),
+    idempotencyKey: text('idempotency_key'),
+    status: text('status').notNull(), // 'pending'|'sending'|'done'|'failed'|'dlq'
+    attempts: integer('attempts').notNull().default(0),
+    nextAttemptAt: integer('next_attempt_at'), // unix seconds; null = ready immediately
+    lastError: text('last_error'),
+    claimedBy: text('claimed_by'),
+    claimedAt: integer('claimed_at'),
+    createdAt: integer('created_at').notNull(),
+    updatedAt: integer('updated_at').notNull(),
+}, t => ({
+    byStatusNext: index('outbound_by_status_next').on(t.status, t.nextAttemptAt),
+    byAddress: index('outbound_by_address').on(t.address),
+    // Sparse unique: enforced only when idempotencyKey is non-null.
+    uniqIdemp: uniqueIndex('outbound_idempotency_key_uq')
+        .on(t.idempotencyKey)
+        .where(sql `${t.idempotencyKey} IS NOT NULL`),
+}));