@c4t4/heyamigo 0.1.0

package/dist/cli/start.js

@@ -0,0 +1,37 @@
+import { execSync } from 'child_process';
+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 { startSocket } from '../wa/socket.js';
+export async function main() {
+    try {
+        execSync('which claude', { stdio: 'pipe' });
+    }
+    catch {
+        console.error('Claude CLI not found. Install it first:\n\n' +
+            '  npm install -g @anthropic-ai/claude-code\n');
+        process.exit(1);
+    }
+    logger.info('heyamigo starting');
+    startScheduler();
+    await startSocket((sock) => {
+        attachIncoming(sock);
+    });
+    void replayPending(async (job, result) => {
+        await handleReply(job, result, {});
+    }).catch((err) => logger.error({ err }, 'replay failed'));
+}
+process.on('SIGINT', () => {
+    logger.info('SIGINT received, shutting down');
+    process.exit(0);
+});
+process.on('SIGTERM', () => {
+    logger.info('SIGTERM received, shutting down');
+    process.exit(0);
+});
+main().catch((err) => {
+    logger.error({ err }, 'fatal error during boot');
+    process.exit(1);
+});

package/dist/cli/supervisor.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+/**
+ * Supervisor: runs the bot, restarts on crash.
+ * Spawned by `heyamigo start` as a detached process.
+ */
+import { spawn } from 'child_process';
+import { resolve } from 'path';
+const RESTART_DELAY_MS = 5000;
+const cwd = process.cwd();
+let child = null;
+let shuttingDown = false;
+function run() {
+    child = spawn(process.execPath, [
+        '--import',
+        'file://' + resolve(cwd, 'node_modules/tsx/dist/loader.mjs'),
+        resolve(cwd, 'src/cli/start.ts'),
+    ], { stdio: 'inherit', cwd, env: { ...process.env, NODE_ENV: 'production' } });
+    child.on('exit', (code, signal) => {
+        if (shuttingDown) {
+            process.exit(0);
+        }
+        const ts = new Date().toISOString();
+        console.error(`[${ts}] Bot exited (code=${code}, signal=${signal}), restarting in ${RESTART_DELAY_MS / 1000}s...`);
+        setTimeout(run, RESTART_DELAY_MS);
+    });
+}
+process.on('SIGTERM', () => {
+    shuttingDown = true;
+    child?.kill('SIGTERM');
+    setTimeout(() => process.exit(0), 3000);
+});
+process.on('SIGINT', () => {
+    shuttingDown = true;
+    child?.kill('SIGINT');
+    setTimeout(() => process.exit(0), 3000);
+});
+run();

package/dist/config.js

@@ -0,0 +1,104 @@
+import { readFileSync } from 'fs';
+import { resolve } from 'path';
+import { z } from 'zod';
+const TriggerModeSchema = z.enum(['all', 'mention', 'command', 'off']);
+const ConfigSchema = z.object({
+    whatsapp: z.object({
+        authDir: z.string(),
+        browserName: z.string(),
+    }),
+    owner: z.object({
+        number: z.string(),
+        treatAsAllowedEverywhere: z.boolean(),
+    }),
+    triggers: z.object({
+        aliases: z.array(z.string()),
+        groupMode: TriggerModeSchema,
+        dmMode: TriggerModeSchema,
+        replyToBotCounts: z.boolean(),
+    }),
+    commands: z.object({
+        prefix: z.string(),
+        reset: z.array(z.string()),
+        status: z.array(z.string()),
+        reload: z.array(z.string()),
+    }),
+    claude: z.object({
+        model: z.string(),
+        timeoutMs: z.number(),
+        personalityFile: z.string(),
+        addDirs: z.array(z.string()),
+        outputFormat: z.enum(['json', 'text', 'stream-json']),
+        contextWindow: z.number(),
+    }),
+    bootstrap: z.object({
+        historyDepth: z.number(),
+        includeHistory: z.boolean(),
+        includeChatMetadata: z.boolean(),
+    }),
+    reply: z.object({
+        quoteInGroups: z.boolean(),
+        chunkChars: z.number(),
+        chunkDelayMs: z.number(),
+        typingIndicator: z.boolean(),
+        errorMessage: z.string(),
+        maxMessageAgeMs: z.number(),
+    }),
+    storage: z.object({
+        messagesDir: z.string(),
+        sessionsFile: z.string(),
+        mediaDir: z.string(),
+        mediaRetentionDays: z.number(),
+    }),
+    memory: z.object({
+        dir: z.string(),
+        instructionsFile: z.string(),
+        importInstructionsFile: z.string(),
+        importPermissionMode: z.enum(['acceptEdits', 'bypass']),
+        digestDebounceMs: z.number(),
+        sweepIntervalMs: z.number(),
+        sweepMinNewMessages: z.number(),
+        maxHistoryForDigest: z.number(),
+    }),
+    logging: z.object({
+        level: z.enum(['trace', 'debug', 'info', 'warn', 'error', 'fatal']),
+        promptRetentionDays: z.number(),
+    }),
+});
+function loadJsonIfExists(path) {
+    try {
+        return JSON.parse(readFileSync(path, 'utf-8'));
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return undefined;
+        throw err;
+    }
+}
+function deepMerge(base, override) {
+    if (override === null || override === undefined)
+        return base;
+    if (typeof override !== 'object' || Array.isArray(override))
+        return override;
+    if (base === null || base === undefined)
+        return override;
+    if (typeof base !== 'object' || Array.isArray(base))
+        return override;
+    const out = { ...base };
+    for (const [k, v] of Object.entries(override)) {
+        out[k] = deepMerge(base[k], v);
+    }
+    return out;
+}
+function loadConfig() {
+    const cwd = process.cwd();
+    const baseFile = resolve(cwd, 'config/config.json');
+    const localFile = resolve(cwd, 'config/config.local.json');
+    const base = loadJsonIfExists(baseFile);
+    if (base === undefined)
+        throw new Error(`Missing config file: ${baseFile}`);
+    const local = loadJsonIfExists(localFile);
+    const merged = local ? deepMerge(base, local) : base;
+    return ConfigSchema.parse(merged);
+}
+export const config = loadConfig();

package/dist/gateway/bootstrap.js

@@ -0,0 +1,56 @@
+import { isJidGroup } from 'baileys';
+import { config } from '../config.js';
+import { logger } from '../logger.js';
+import { readLast } from '../store/messages.js';
+export async function buildInitPayload(params) {
+    const { jid, sock, userText, userNumber } = params;
+    const isGroup = isJidGroup(jid) === true;
+    const lines = [];
+    if (config.bootstrap.includeChatMetadata) {
+        lines.push('You are the assistant behind a WhatsApp chat.');
+        if (isGroup) {
+            let subject = 'unknown';
+            let participantSummary = '';
+            try {
+                const meta = await sock.groupMetadata(jid);
+                subject = meta.subject || subject;
+                if (meta.participants?.length) {
+                    participantSummary = `${meta.participants.length} participants`;
+                }
+            }
+            catch (err) {
+                logger.warn({ err, jid }, 'group metadata fetch failed in bootstrap');
+            }
+            lines.push(`Chat type: group`);
+            lines.push(`Chat name: "${subject}"`);
+            if (participantSummary)
+                lines.push(`Members: ${participantSummary}`);
+        }
+        else {
+            lines.push(`Chat type: direct message`);
+        }
+        lines.push(`JID: ${jid}`);
+        lines.push('');
+    }
+    if (config.bootstrap.includeHistory) {
+        const history = await readLast(jid, config.bootstrap.historyDepth);
+        const prior = history.slice(0, -1); // exclude current message (appended already)
+        if (prior.length) {
+            lines.push('[Prior conversation history]');
+            for (const m of prior)
+                lines.push(formatLine(m));
+            lines.push('');
+        }
+    }
+    lines.push('[Current message]');
+    lines.push(`${userNumber}: ${userText}`);
+    return lines.join('\n');
+}
+function formatLine(m) {
+    const date = new Date(m.timestamp * 1000)
+        .toISOString()
+        .slice(0, 16)
+        .replace('T', ' ');
+    const who = m.direction === 'out' ? 'assistant' : m.pushName || m.senderNumber || 'user';
+    return `${who} (${date}): ${m.text}`;
+}

package/dist/gateway/commands.js

@@ -0,0 +1,58 @@
+import { clearSession, getSessionInfo } from '../ai/sessions.js';
+import { reloadSystemPrompt } from '../ai/claude.js';
+import { config } from '../config.js';
+import { runDigestNow } from '../memory/scheduler.js';
+import { sendText } from '../wa/sender.js';
+export async function tryCommand(ctx) {
+    const prefix = config.commands.prefix;
+    const trimmed = ctx.text.trim();
+    if (!trimmed.startsWith(prefix))
+        return false;
+    const cmd = trimmed.slice(prefix.length).split(/\s+/)[0]?.toLowerCase() ?? '';
+    if (!cmd)
+        return false;
+    if (config.commands.reset.includes(cmd)) {
+        const existed = clearSession(ctx.jid);
+        const reply = existed
+            ? 'Session reset. Next message will bootstrap a fresh Claude session.'
+            : 'No session to reset.';
+        await sendText(ctx.sock, ctx.jid, reply, ctx.quoted);
+        return true;
+    }
+    if (config.commands.status.includes(cmd)) {
+        const info = getSessionInfo(ctx.jid);
+        if (!info) {
+            await sendText(ctx.sock, ctx.jid, 'No session yet. Next message will bootstrap one.', ctx.quoted);
+            return true;
+        }
+        const lines = [`Session: ${info.sessionId.slice(0, 8)}…`];
+        if (info.usage) {
+            const max = config.claude.contextWindow;
+            const used = info.usage.totalContextTokens;
+            const leftPct = Math.max(0, 100 - (used / max) * 100).toFixed(1);
+            lines.push(`Context: ${used.toLocaleString()} / ${max.toLocaleString()} (${leftPct}% left)`);
+            lines.push(`Turns: ${info.usage.numTurns}`);
+        }
+        await sendText(ctx.sock, ctx.jid, lines.join('\n'), ctx.quoted);
+        return true;
+    }
+    if (config.commands.reload.includes(cmd)) {
+        reloadSystemPrompt();
+        const existed = clearSession(ctx.jid);
+        const reply = existed
+            ? 'Personality reloaded and session reset.'
+            : 'Personality reloaded.';
+        await sendText(ctx.sock, ctx.jid, reply, ctx.quoted);
+        return true;
+    }
+    if (cmd === 'digest') {
+        await sendText(ctx.sock, ctx.jid, 'Digesting memory now, this may take a moment.', ctx.quoted);
+        runDigestNow({
+            jid: ctx.jid,
+            number: ctx.senderNumber || undefined,
+            reason: 'manual /digest',
+        }).catch(() => undefined);
+        return true;
+    }
+    return false;
+}

package/dist/gateway/incoming.js

@@ -0,0 +1,239 @@
+import { getContentType, isJidGroup, jidDecode, jidNormalizedUser, } from 'baileys';
+import { getSession } from '../ai/sessions.js';
+import { config } from '../config.js';
+import { logger } from '../logger.js';
+import { buildMemoryPreamble } from '../memory/preamble.js';
+import { enqueue } from '../queue/queue.js';
+import { downloadAndSave, mediaPromptTag } from '../store/media.js';
+import { append } from '../store/messages.js';
+import { checkAccess, discoverGroupIfNew, getRoleForContext, } from '../wa/whitelist.js';
+import { buildInitPayload } from './bootstrap.js';
+import { tryCommand } from './commands.js';
+import { handleReply } from './outgoing.js';
+import { checkTrigger } from './triggers.js';
+export function attachIncoming(sock) {
+    const ownerJid = sock.user?.id
+        ? jidNormalizedUser(sock.user.id)
+        : '';
+    // History sync: WhatsApp delivers older messages via this event on connect.
+    // Process ones within the age window through the normal pipeline.
+    sock.ev.on('messaging-history.set', ({ messages: historyMsgs }) => {
+        logger.info({ count: historyMsgs.length }, 'history sync received');
+        void processMessages(historyMsgs, sock, ownerJid);
+    });
+    sock.ev.on('messages.upsert', async ({ messages, type }) => {
+        if (type !== 'notify' && type !== 'append')
+            return;
+        void processMessages(messages, sock, ownerJid, type === 'append');
+    });
+}
+async function processMessages(messages, sock, ownerJid, isHistorySync = false) {
+    for (const msg of messages) {
+        try {
+            const stored = await toStored(msg, ownerJid, sock);
+            if (!stored)
+                continue;
+            // Age gate: skip messages older than maxMessageAgeMs
+            const ageMs = Date.now() - stored.timestamp * 1000;
+            if (ageMs > config.reply.maxMessageAgeMs) {
+                if (isHistorySync)
+                    continue; // don't store ancient history
+                await append(stored);
+                logger.debug({ jid: stored.jid, ageMs: Math.floor(ageMs) }, 'message too old, stored silently');
+                continue;
+            }
+            const isGroup = stored.jid.endsWith('@g.us');
+            if (isGroup)
+                await discoverGroupIfNew(sock, stored.jid);
+            const decision = checkAccess({
+                jid: stored.jid,
+                isGroup,
+                senderNumber: stored.senderNumber,
+                fromMe: stored.fromMe,
+            });
+            const logCtx = {
+                jid: stored.jid,
+                from: stored.senderNumber || '(owner)',
+                fromMe: stored.fromMe,
+                type: stored.messageType,
+                text: stored.text.slice(0, 80),
+                decision: decision.reason,
+            };
+            if (!decision.store) {
+                logger.debug(logCtx, 'message dropped');
+                continue;
+            }
+            // Download media if present (image, video, audio, document)
+            const media = await downloadAndSave(msg, stored.jid);
+            if (media) {
+                stored.mediaType = media.mediaType;
+                stored.mediaPath = media.mediaPath;
+                stored.mediaMime = media.mediaMime;
+            }
+            await append(stored);
+            if (!decision.respond) {
+                logger.info(logCtx, 'message captured, silent');
+                continue;
+            }
+            // Need either text or media to respond
+            if (!stored.text.trim() && !media) {
+                logger.debug(logCtx, 'message captured, respond skipped (empty)');
+                continue;
+            }
+            // Commands short-circuit the AI pipeline (always, regardless of trigger mode)
+            const isCommand = await tryCommand({
+                sock,
+                jid: stored.jid,
+                text: stored.text,
+                senderNumber: stored.senderNumber,
+                quoted: isGroup && config.reply.quoteInGroups ? msg : undefined,
+            });
+            if (isCommand) {
+                logger.info(logCtx, 'command handled');
+                continue;
+            }
+            // Trigger gate: alias / @mention / reply-to-bot depending on mode
+            const trigger = checkTrigger({
+                isGroup,
+                text: stored.text,
+                msg,
+                sock,
+            });
+            if (!trigger.triggered) {
+                logger.info({ ...logCtx, trigger: trigger.reason }, 'message captured, no trigger');
+                continue;
+            }
+            const { role } = getRoleForContext(stored.senderNumber, isGroup);
+            const existingSession = getSession(stored.jid);
+            let userContent = stored.text;
+            if (media) {
+                const tag = mediaPromptTag(media, stored.text);
+                userContent = tag;
+            }
+            const recentText = stored.text;
+            const memoryPreamble = buildMemoryPreamble({
+                jid: stored.jid,
+                senderNumber: stored.senderNumber,
+                isGroup,
+                recentText,
+            });
+            const core = existingSession
+                ? userContent
+                : await buildInitPayload({
+                    jid: stored.jid,
+                    sock,
+                    userText: userContent,
+                    userNumber: stored.senderNumber,
+                });
+            const input = `${memoryPreamble}\n\n---\n\n${core}`;
+            logger.info({ ...logCtx, resume: !!existingSession, trigger: trigger.reason }, 'message captured, enqueuing');
+            const job = {
+                jid: stored.jid,
+                text: stored.text,
+                input,
+                sessionId: existingSession,
+                senderNumber: stored.senderNumber,
+                fromMe: stored.fromMe,
+                allowedTools: role.tools,
+            };
+            // Start typing indicator immediately; refresh every 10s (WA expires ~15s)
+            let typingHeartbeat = null;
+            if (config.reply.typingIndicator) {
+                void sock
+                    .sendPresenceUpdate('composing', stored.jid)
+                    .catch(() => undefined);
+                typingHeartbeat = setInterval(() => {
+                    void sock
+                        .sendPresenceUpdate('composing', stored.jid)
+                        .catch(() => undefined);
+                }, 10000);
+            }
+            const stopTyping = () => {
+                if (typingHeartbeat)
+                    clearInterval(typingHeartbeat);
+                typingHeartbeat = null;
+            };
+            enqueue(job)
+                .then((result) => {
+                stopTyping();
+                return handleReply(job, result, msg);
+            })
+                .catch((err) => {
+                stopTyping();
+                logger.error({ err, jid: job.jid }, 'pipeline failed');
+                void handleReply(job, { reply: config.reply.errorMessage }, msg).catch((e) => logger.error({ err: e, jid: job.jid }, 'failed to send error reply'));
+            });
+        }
+        catch (err) {
+            logger.error({ err, msgId: msg.key.id }, 'failed to process incoming message');
+        }
+    }
+}
+async function resolveToPn(sock, jid) {
+    if (!jid || !jid.endsWith('@lid'))
+        return jid;
+    try {
+        const pn = await sock.signalRepository.lidMapping.getPNForLID(jid);
+        return pn ?? jid;
+    }
+    catch {
+        return jid;
+    }
+}
+async function toStored(msg, ownerJid, sock) {
+    const rawJid = msg.key.remoteJid;
+    if (!rawJid)
+        return null;
+    if (!msg.message)
+        return null;
+    if (rawJid === 'status@broadcast')
+        return null;
+    const fromMe = !!msg.key.fromMe;
+    const isGroup = isJidGroup(rawJid) === true;
+    // canonicalize chat jid: groups stay as @g.us, DMs preferred as @s.whatsapp.net,
+    // drop device suffix (e.g. ":19") so chats from different devices merge
+    const jid = isGroup
+        ? jidNormalizedUser(rawJid)
+        : jidNormalizedUser(await resolveToPn(sock, rawJid));
+    let senderRaw;
+    if (fromMe) {
+        senderRaw = ownerJid;
+    }
+    else if (isGroup) {
+        senderRaw = msg.key.participant ?? '';
+    }
+    else {
+        senderRaw = rawJid;
+    }
+    const sender = jidNormalizedUser(await resolveToPn(sock, senderRaw));
+    const senderNumber = jidDecode(sender)?.user ?? '';
+    const messageType = getContentType(msg.message) ?? 'unknown';
+    const text = extractText(msg.message);
+    return {
+        id: msg.key.id ?? '',
+        jid,
+        direction: fromMe ? 'out' : 'in',
+        fromMe,
+        sender,
+        senderNumber,
+        pushName: msg.pushName ?? undefined,
+        timestamp: typeof msg.messageTimestamp === 'number'
+            ? msg.messageTimestamp
+            : Number(msg.messageTimestamp ?? 0),
+        text,
+        messageType,
+    };
+}
+function extractText(message) {
+    if (message.conversation)
+        return message.conversation;
+    if (message.extendedTextMessage?.text)
+        return message.extendedTextMessage.text;
+    if (message.imageMessage?.caption)
+        return message.imageMessage.caption;
+    if (message.videoMessage?.caption)
+        return message.videoMessage.caption;
+    if (message.documentMessage?.caption)
+        return message.documentMessage.caption;
+    return '';
+}