@c4t4/heyamigo 0.9.12 → 0.9.14

package/dist/channels/baileys.js

@@ -138,6 +138,17 @@ async function sendOne(sock, jid, msg) {
 }
 export const baileysAdapter = {
     channel: 'wa',
+    async sendTyping(externalId, state) {
+        const sock = activeSocket;
+        if (!sock)
+            return; // silently no-op if disconnected
+        try {
+            await sock.sendPresenceUpdate(state, externalId);
+        }
+        catch {
+            // typing is a UX hint; swallow errors
+        }
+    },
     async send(externalId, msg) {
         const sock = requireSocket();
         let sent;

package/dist/config.js

@@ -90,6 +90,12 @@ const ConfigSchema = z.object({
         // 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),
+        // Send a quick acknowledgement when an incoming message has media.
+        // Bridge for the typing-indicator regression in Phase 4 — without
+        // this, users wait silently while the chat worker processes the
+        // image. Set false to disable.
+        ackOnMedia: z.boolean().default(true),
+        mediaAckText: z.string().default('looking…'),
     }),
     storage: z.object({
         messagesDir: z.string(),

package/dist/gateway/incoming.js

@@ -8,6 +8,7 @@ import { config } from '../config.js';
 import { logger } from '../logger.js';
 import { buildMemoryPreamble } from '../memory/preamble.js';
 import { enqueueInbound } from '../queue/inbound.js';
+import { enqueueOutbound } from '../queue/outbound.js';
 import { detectMediaType, downloadAndSave, getMediaSize, mediaPromptTag, } from '../store/media.js';
 import { append } from '../store/messages.js';
 import { getDailyTokens } from '../store/usage.js';
@@ -215,6 +216,19 @@ async function processMessages(messages, sock, ownerJid, isHistorySync = false)
             const actorPersonId = senderAddress
                 ? personIdForAddress(senderAddress)
                 : null;
+            // For media-bearing messages, send an immediate "looking…" ack
+            // via outbound so the user isn't left wondering whether the bot
+            // saw the image (typing indicator was dropped in Phase 4 —
+            // followup commit will reinstate via ChannelAdapter.sendTyping).
+            // The chat worker still processes the actual reply normally.
+            if (media && config.reply.ackOnMedia !== false) {
+                enqueueOutbound({
+                    address: chatAddress,
+                    kind: 'text',
+                    text: config.reply.mediaAckText,
+                    idempotencyKey: `media-ack-${msg.key.id}`,
+                });
+            }
             enqueueInbound({
                 address: chatAddress,
                 actorAddress: senderAddress,

package/dist/memory/scheduler.js

@@ -75,11 +75,12 @@ async function sweep() {
         logger.error({ err }, 'journal observer sweep failed');
     }
 }
-let sweepTimer = null;
 const NUDGE_TICK_MS = 5 * 60 * 1000; // 5 minutes
+let started = false;
 export function startScheduler() {
-    if (sweepTimer)
+    if (started)
         return;
+    started = true;
     ensureScaffold();
     void prunePrompts(); // run once on boot
     // Rebuild the compressed memory view on boot so every session starts with
@@ -93,9 +94,23 @@ export function startScheduler() {
             logger.error({ err }, 'compressed: boot rebuild failed');
         }
     })();
-    sweepTimer = setInterval(() => {
-        void sweep().catch((err) => logger.error({ err }, 'sweep failed'));
-    }, config.memory.sweepIntervalMs);
+    // Memory sweep: migrated from setInterval to a cron entry. Same
+    // cadence (config.memory.sweepIntervalMs); body runs as an internal
+    // cron handler so the orchestrator drives the schedule.
+    registerInternalCronHandler('memory-sweep', async () => {
+        try {
+            await sweep();
+        }
+        catch (err) {
+            logger.error({ err }, 'sweep failed');
+        }
+    });
+    enqueueCron({
+        name: 'memory-sweep',
+        enqueueInto: 'internal',
+        payload: { handler: 'memory-sweep' },
+        recurrence: `@every ${Math.floor(config.memory.sweepIntervalMs / 1000)}s`,
+    });
     // Proactive journal nudges (check-ins, silent-nudges). Migrated from
     // setInterval to a cron row → orchestrator. Same cadence, same body;
     // benefits are: survives restarts, visible in `crons` table, can be
@@ -122,17 +137,13 @@ async function runNudgeTickSafe() {
     }
 }
 export function stopScheduler() {
-    if (sweepTimer) {
-        clearInterval(sweepTimer);
-        sweepTimer = null;
-    }
-    // Nudge cron is owned by the crons table; orchestrator stops on its
-    // own. Deleting the cron row here would re-arm itself on next boot,
-    // so leave it alone — disabling via the `enabled` column is the
-    // user-facing knob.
+    // All recurring work is now in the crons table; orchestrator handles
+    // its own shutdown. Just clear the in-process debounce timers (for
+    // scheduleDigest's per-jid coalescing).
     for (const t of pendingTimers.values())
         clearTimeout(t);
     pendingTimers.clear();
+    started = false;
 }
 // Exported for callers (CLI, /nudge command) that want to surgically
 // disable nudges without editing config. Use `setCronEnabled` from

package/dist/queue/chat-worker.js

@@ -15,8 +15,10 @@
 // nothing breaks.
 import { hostname } from 'os';
 import { eq } from 'drizzle-orm';
+import { getChannelAdapter } from '../channels/index.js';
 import { config } from '../config.js';
 import { getDb } from '../db/index.js';
+import { parseAddress } from '../db/address.js';
 import { workers } from '../db/schema.js';
 import { handleReply } from '../gateway/outgoing.js';
 import { logger } from '../logger.js';
@@ -87,11 +89,46 @@ function jobFromRow(row) {
         return null;
     }
 }
+// Typing indicator. Fire-and-forget; UX nicety, never block real
+// work. WA's presence-update expires ~15s, so we refresh every 10s
+// for the duration of the job.
+function startTyping(address) {
+    let parsed;
+    try {
+        parsed = parseAddress(address);
+    }
+    catch {
+        return () => undefined;
+    }
+    if (parsed.channel === 'system')
+        return () => undefined;
+    let adapter;
+    try {
+        adapter = getChannelAdapter(parsed.channel);
+    }
+    catch {
+        return () => undefined;
+    }
+    if (!adapter.sendTyping)
+        return () => undefined;
+    const externalId = parsed.externalId;
+    const fire = () => {
+        void adapter.sendTyping?.(externalId, 'composing').catch(() => undefined);
+    };
+    fire();
+    const interval = setInterval(fire, 10_000);
+    return () => {
+        clearInterval(interval);
+        void adapter.sendTyping?.(externalId, 'paused').catch(() => undefined);
+    };
+}
 async function processOne(workerId, row) {
     setWorkerStatus(workerId, 'busy', `inbound:${row.id}`);
+    const stopTyping = startTyping(row.address);
     const job = jobFromRow(row);
     if (!job) {
         markInboundFailed(row.id, workerId, 'invalid payload');
+        stopTyping();
         setWorkerStatus(workerId, 'idle');
         return;
     }
@@ -134,6 +171,7 @@ async function processOne(workerId, row) {
         }
     }
     finally {
+        stopTyping();
         setWorkerStatus(workerId, 'idle');
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@c4t4/heyamigo",
-  "version": "0.9.12",
+  "version": "0.9.14",
   "description": "WhatsApp AI bot powered by Claude with long-term memory, browser control, and role-based access",
   "type": "module",
   "main": "dist/index.js",