@c4t4/heyamigo 0.9.5 → 0.9.7

package/dist/queue/inbound.js

@@ -0,0 +1,191 @@
+// Inbound queue helpers. Gateway (gateway/incoming.ts) calls
+// enqueueInbound; chat workers (queue/chat-worker.ts) drain via
+// claimNextInbound. Per-address serialization preserves reply order
+// within a chat while different chats run in parallel.
+//
+// Same primitives as outbound (claim/done/retry/dlq) with the added
+// `address NOT IN (claimed)` filter in the claim query.
+import { and, asc, eq, isNull, lte, notInArray, or, sql } from 'drizzle-orm';
+import { getDb } from '../db/index.js';
+import { inbound } from '../db/schema.js';
+// Idempotent on external_msg_id when set. Same channel message
+// arriving twice (Baileys replay, network retransmit) returns the
+// existing row instead of duplicating.
+export function enqueueInbound(input) {
+    const db = getDb();
+    const now = Math.floor(Date.now() / 1000);
+    if (input.externalMsgId) {
+        const found = db
+            .select()
+            .from(inbound)
+            .where(eq(inbound.externalMsgId, input.externalMsgId))
+            .get();
+        if (found)
+            return { inserted: false, row: found };
+    }
+    const row = db
+        .insert(inbound)
+        .values({
+        address: input.address,
+        actorAddress: input.actorAddress ?? null,
+        personId: input.personId ?? null,
+        actorPersonId: input.actorPersonId ?? null,
+        externalMsgId: input.externalMsgId ?? null,
+        text: input.text,
+        mediaPath: input.mediaPath ?? null,
+        mediaMime: input.mediaMime ?? null,
+        mediaBytes: input.mediaBytes ?? null,
+        pushName: input.pushName ?? null,
+        triggerReason: input.triggerReason ?? null,
+        payload: input.payload === undefined ? null : JSON.stringify(input.payload),
+        status: 'pending',
+        attempts: 0,
+        nextAttemptAt: null,
+        lastError: null,
+        claimedBy: null,
+        claimedAt: null,
+        receivedAt: input.receivedAt ?? now,
+        createdAt: now,
+        updatedAt: now,
+    })
+        .returning()
+        .get();
+    return { inserted: true, row };
+}
+// Atomic claim with per-address serialization. Skips any pending row
+// whose address already has another row in `claimed` state →
+// preserves reply order per chat while letting different chats run
+// in parallel.
+export function claimNextInbound(workerId) {
+    const db = getDb();
+    const now = Math.floor(Date.now() / 1000);
+    return db.transaction((tx) => {
+        // Subquery: addresses currently claimed (= one in-flight per chat).
+        const busyAddrs = tx
+            .select({ address: inbound.address })
+            .from(inbound)
+            .where(eq(inbound.status, 'claimed'))
+            .all()
+            .map((r) => r.address);
+        const conds = [
+            eq(inbound.status, 'pending'),
+            or(isNull(inbound.nextAttemptAt), lte(inbound.nextAttemptAt, now)),
+        ];
+        if (busyAddrs.length > 0) {
+            conds.push(notInArray(inbound.address, busyAddrs));
+        }
+        const target = tx
+            .select({ id: inbound.id })
+            .from(inbound)
+            .where(and(...conds))
+            .orderBy(asc(inbound.id))
+            .limit(1)
+            .get();
+        if (!target)
+            return null;
+        const claimed = tx
+            .update(inbound)
+            .set({
+            status: 'claimed',
+            claimedBy: workerId,
+            claimedAt: now,
+            updatedAt: now,
+        })
+            .where(and(eq(inbound.id, target.id), eq(inbound.status, 'pending')))
+            .returning()
+            .get();
+        return claimed ?? null;
+    });
+}
+export function markInboundDone(id, workerId) {
+    const db = getDb();
+    const now = Math.floor(Date.now() / 1000);
+    const result = db
+        .update(inbound)
+        .set({ status: 'done', updatedAt: now })
+        .where(and(eq(inbound.id, id), eq(inbound.status, 'claimed'), eq(inbound.claimedBy, workerId)))
+        .returning({ id: inbound.id })
+        .all();
+    return result.length > 0;
+}
+// Backoff: 5s, 30s, 2min, 5min, give up. Bigger gaps than outbound
+// because chat replies are expensive (AI call); a faster retry loop
+// would just burn tokens on transient errors.
+const BACKOFF_SECONDS = [5, 30, 120, 300];
+const MAX_ATTEMPTS = BACKOFF_SECONDS.length;
+export function markInboundRetryOrDlq(id, workerId, errorMessage) {
+    const db = getDb();
+    return db.transaction((tx) => {
+        const row = tx.select().from(inbound).where(eq(inbound.id, id)).get();
+        if (!row || row.status !== 'claimed' || row.claimedBy !== workerId) {
+            return { retried: false, deadLettered: false };
+        }
+        const now = Math.floor(Date.now() / 1000);
+        const nextAttempts = row.attempts + 1;
+        if (nextAttempts > MAX_ATTEMPTS) {
+            tx.update(inbound)
+                .set({
+                status: 'dlq',
+                attempts: nextAttempts,
+                lastError: errorMessage,
+                claimedBy: null,
+                claimedAt: null,
+                updatedAt: now,
+            })
+                .where(eq(inbound.id, id))
+                .run();
+            return { retried: false, deadLettered: true };
+        }
+        const backoff = BACKOFF_SECONDS[Math.min(row.attempts, BACKOFF_SECONDS.length - 1)];
+        tx.update(inbound)
+            .set({
+            status: 'pending',
+            attempts: nextAttempts,
+            nextAttemptAt: now + backoff,
+            lastError: errorMessage,
+            claimedBy: null,
+            claimedAt: null,
+            updatedAt: now,
+        })
+            .where(eq(inbound.id, id))
+            .run();
+        return { retried: true, deadLettered: false };
+    });
+}
+export function markInboundFailed(id, workerId, errorMessage) {
+    const db = getDb();
+    const now = Math.floor(Date.now() / 1000);
+    const result = db
+        .update(inbound)
+        .set({
+        status: 'failed',
+        lastError: errorMessage,
+        claimedBy: null,
+        claimedAt: null,
+        updatedAt: now,
+    })
+        .where(and(eq(inbound.id, id), eq(inbound.status, 'claimed'), eq(inbound.claimedBy, workerId)))
+        .returning({ id: inbound.id })
+        .all();
+    return result.length > 0;
+}
+// Orchestrator helper. Chat workers run longer than sender workers
+// (AI calls + memory writes), so the TTL is more generous. 300s
+// matches the typical chat-track timeout (5min).
+const CLAIM_TTL_SECONDS = 360;
+export function reclaimStuckInbound() {
+    const db = getDb();
+    const cutoff = Math.floor(Date.now() / 1000) - CLAIM_TTL_SECONDS;
+    const result = db
+        .update(inbound)
+        .set({
+        status: 'pending',
+        claimedBy: null,
+        claimedAt: null,
+        updatedAt: sql `${inbound.updatedAt}`,
+    })
+        .where(and(eq(inbound.status, 'claimed'), lte(inbound.claimedAt, cutoff)))
+        .returning({ id: inbound.id })
+        .all();
+    return result.length;
+}

package/dist/queue/orchestrator.js

@@ -16,6 +16,7 @@ import { and, eq, lt, ne } from 'drizzle-orm';
 import { getDb } from '../db/index.js';
 import { workers } from '../db/schema.js';
 import { logger } from '../logger.js';
+import { reclaimStuckInbound } from './inbound.js';
 import { reclaimStuckOutbound } from './outbound.js';
 import { clearControl, readControl, requestControl } from './control.js';
 import { listDueCrons, markCronFired } from './crons.js';
@@ -98,9 +99,13 @@ async function tick(id) {
                 .run();
         }
         // Cross-queue housekeeping. More queues land in later phases.
-        const reclaimed = reclaimStuckOutbound();
-        if (reclaimed > 0) {
-            logger.info({ reclaimed }, 'reclaimed stuck outbound rows');
+        const reclaimedOutbound = reclaimStuckOutbound();
+        if (reclaimedOutbound > 0) {
+            logger.info({ reclaimed: reclaimedOutbound }, 'reclaimed stuck outbound rows');
+        }
+        const reclaimedInbound = reclaimStuckInbound();
+        if (reclaimedInbound > 0) {
+            logger.info({ reclaimed: reclaimedInbound }, 'reclaimed stuck inbound rows');
         }
         // Fire any due crons. Order: dispatch each in turn; if dispatch
         // throws (it shouldn't — dispatch swallows), the cron is NOT

package/migrations/0003_phase4_inbound.sql

@@ -0,0 +1,28 @@
+CREATE TABLE `inbound` (
+	`id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	`address` text NOT NULL,
+	`actor_address` text,
+	`person_id` text,
+	`actor_person_id` text,
+	`external_msg_id` text,
+	`text` text NOT NULL,
+	`media_path` text,
+	`media_mime` text,
+	`media_bytes` integer,
+	`push_name` text,
+	`trigger_reason` text,
+	`status` text NOT NULL,
+	`attempts` integer DEFAULT 0 NOT NULL,
+	`next_attempt_at` integer,
+	`last_error` text,
+	`claimed_by` text,
+	`claimed_at` integer,
+	`received_at` integer NOT NULL,
+	`created_at` integer NOT NULL,
+	`updated_at` integer NOT NULL
+);
+--> statement-breakpoint
+CREATE INDEX `inbound_by_status_next` ON `inbound` (`status`,`next_attempt_at`);--> statement-breakpoint
+CREATE INDEX `inbound_by_address` ON `inbound` (`address`);--> statement-breakpoint
+CREATE INDEX `inbound_by_person` ON `inbound` (`person_id`,`received_at`);--> statement-breakpoint
+CREATE UNIQUE INDEX `inbound_external_msg_id_uq` ON `inbound` (`external_msg_id`) WHERE "inbound"."external_msg_id" IS NOT NULL;

package/migrations/0004_phase4_inbound_payload.sql

@@ -0,0 +1 @@
+ALTER TABLE `inbound` ADD `payload` text;