@c4t4/heyamigo 0.9.15 → 0.9.17

package/dist/queue/browser-worker.js

@@ -0,0 +1,170 @@
+// Browser worker pool. N workers (config.browser.maxWorkers, default
+// 3) drain the browser_tasks SQLite table. Each task runs as a fresh
+// agent with its own tab on the shared Chrome — same model as before
+// the durability change, just claimable from the DB now.
+//
+// Differences vs in-memory fastq:
+// - Tasks survive process crashes (durable rows).
+// - Orchestrator reclaims stuck claims via reclaimStuckBrowserTasks.
+// - Retry / DLQ semantics live in the queue helpers.
+import { hostname } from 'os';
+import { eq } from 'drizzle-orm';
+import { config } from '../config.js';
+import { getDb } from '../db/index.js';
+import { parseAddress } from '../db/address.js';
+import { workers } from '../db/schema.js';
+import { logger } from '../logger.js';
+import { claimNextBrowserTask, markBrowserTaskDone, markBrowserTaskRetryOrDlq, } from './browser-queue.js';
+import { initiate } from '../gateway/outgoing.js';
+import { runBrowserTask } from './async-tasks.js';
+const HEARTBEAT_INTERVAL_MS = 5_000;
+const IDLE_POLL_INTERVAL_MS = 500;
+const BUSY_POLL_INTERVAL_MS = 0;
+const activeWorkers = [];
+let stopping = false;
+let heartbeatTimer = null;
+function newWorkerId(slot) {
+    return `${hostname()}-${process.pid}-browser-${slot}`;
+}
+function registerWorker(id) {
+    const db = getDb();
+    const now = Math.floor(Date.now() / 1000);
+    db.insert(workers)
+        .values({
+        id,
+        kind: 'browser',
+        status: 'idle',
+        currentJob: null,
+        lastSeen: now,
+        startedAt: now,
+    })
+        .onConflictDoUpdate({
+        target: workers.id,
+        set: { status: 'idle', currentJob: null, lastSeen: now, startedAt: now },
+    })
+        .run();
+}
+function setWorkerStatus(id, status, currentJob = null) {
+    const db = getDb();
+    db.update(workers)
+        .set({
+        status,
+        currentJob,
+        lastSeen: Math.floor(Date.now() / 1000),
+    })
+        .where(eq(workers.id, id))
+        .run();
+}
+function heartbeatAll() {
+    if (activeWorkers.length === 0)
+        return;
+    const db = getDb();
+    const now = Math.floor(Date.now() / 1000);
+    for (const id of activeWorkers) {
+        db.update(workers)
+            .set({ lastSeen: now })
+            .where(eq(workers.id, id))
+            .run();
+    }
+}
+// Convert a row into the AsyncTask shape that runBrowserTask expects.
+// The id field is a synthetic string for log lines; the real row id
+// is used for queue bookkeeping.
+function rowToAsyncTask(row) {
+    let allowedTools = 'all';
+    if (row.allowedTools) {
+        try {
+            allowedTools = JSON.parse(row.allowedTools);
+        }
+        catch {
+            // bad JSON → fall back to 'all'
+        }
+    }
+    return {
+        id: `browser-${row.id}`,
+        jid: parseAddress(row.address).externalId,
+        senderNumber: row.senderNumber,
+        senderName: row.senderName ?? undefined,
+        description: row.description,
+        originatingMessage: row.originatingMessage,
+        allowedTools,
+        startedAt: row.claimedAt ?? row.createdAt,
+    };
+}
+async function processOne(workerId, row) {
+    setWorkerStatus(workerId, 'busy', `browser_tasks:${row.id}`);
+    const task = rowToAsyncTask(row);
+    try {
+        await runBrowserTask(task);
+        const ok = markBrowserTaskDone(row.id, workerId);
+        if (!ok) {
+            logger.warn({ id: row.id, workerId }, 'browser task markDone failed (claim lost?). work already done.');
+        }
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        const result = markBrowserTaskRetryOrDlq(row.id, workerId, msg);
+        if (result.deadLettered) {
+            logger.error({ err, id: row.id, address: row.address }, 'browser task dead-lettered after max attempts');
+            // User-facing failure ack so the chat isn't left hanging.
+            try {
+                await initiate({
+                    jid: parseAddress(row.address).externalId,
+                    text: `Heads up: the browser task "${row.description.slice(0, 80)}" failed. Ask me again and I'll retry.`,
+                });
+            }
+            catch (e) {
+                logger.error({ err: e, id: row.id }, 'failed to send DLQ-ack reply');
+            }
+        }
+        else if (result.retried) {
+            logger.warn({ err, id: row.id, address: row.address }, 'browser task transient fail, will retry');
+        }
+    }
+    finally {
+        setWorkerStatus(workerId, 'idle');
+    }
+}
+async function loop(workerId) {
+    while (!stopping) {
+        let processed = false;
+        try {
+            const row = claimNextBrowserTask(workerId);
+            if (row) {
+                await processOne(workerId, row);
+                processed = true;
+            }
+        }
+        catch (err) {
+            logger.error({ err, workerId }, 'browser worker loop error');
+        }
+        const delay = processed ? BUSY_POLL_INTERVAL_MS : IDLE_POLL_INTERVAL_MS;
+        if (delay > 0) {
+            await new Promise((res) => setTimeout(res, delay));
+        }
+        else {
+            await new Promise((res) => setImmediate(res));
+        }
+    }
+    setWorkerStatus(workerId, 'dead');
+}
+export function startBrowserWorkers() {
+    if (activeWorkers.length > 0) {
+        logger.warn('browser workers already started; ignoring');
+        return;
+    }
+    const pool = Math.max(1, config.browser?.maxWorkers ?? 3);
+    for (let i = 0; i < pool; i++) {
+        const id = newWorkerId(i);
+        activeWorkers.push(id);
+        registerWorker(id);
+        void loop(id).catch((err) => logger.fatal({ err, workerId: id }, 'browser worker loop crashed'));
+    }
+    heartbeatTimer = setInterval(heartbeatAll, HEARTBEAT_INTERVAL_MS);
+    logger.info({ pool }, 'browser worker pool started');
+}
+export function stopBrowserWorkers() {
+    stopping = true;
+    if (heartbeatTimer)
+        clearInterval(heartbeatTimer);
+}

package/dist/queue/inbound.js

@@ -37,6 +37,7 @@ export function enqueueInbound(input) {
         mediaBytes: input.mediaBytes ?? null,
         pushName: input.pushName ?? null,
         triggerReason: input.triggerReason ?? null,
+        kind: input.kind ?? null,
         payload: input.payload === undefined ? null : JSON.stringify(input.payload),
         status: 'pending',
         attempts: 0,

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 { reclaimStuckBrowserTasks } from './browser-queue.js';
 import { reclaimStuckInbound } from './inbound.js';
 import { reclaimStuckMemoryWrites } from './memory-writes.js';
 import { reclaimStuckOutbound } from './outbound.js';
@@ -112,6 +113,10 @@ async function tick(id) {
         if (reclaimedMemWr > 0) {
             logger.info({ reclaimed: reclaimedMemWr }, 'reclaimed stuck memory_writes rows');
         }
+        const reclaimedBrowser = reclaimStuckBrowserTasks();
+        if (reclaimedBrowser > 0) {
+            logger.info({ reclaimed: reclaimedBrowser }, 'reclaimed stuck browser_tasks rows');
+        }
         // Fire any due crons. Order: dispatch each in turn; if dispatch
         // throws (it shouldn't — dispatch swallows), the cron is NOT
         // marked fired and we'll retry on the next tick.

package/migrations/0006_phase4_browser_tasks.sql

@@ -0,0 +1,20 @@
+CREATE TABLE `browser_tasks` (
+	`id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	`address` text NOT NULL,
+	`actor_person_id` text,
+	`description` text NOT NULL,
+	`originating_message` text NOT NULL,
+	`sender_number` text NOT NULL,
+	`sender_name` text,
+	`allowed_tools` text,
+	`status` text NOT NULL,
+	`attempts` integer DEFAULT 0 NOT NULL,
+	`next_attempt_at` integer,
+	`last_error` text,
+	`claimed_by` text,
+	`claimed_at` integer,
+	`created_at` integer NOT NULL,
+	`updated_at` integer NOT NULL
+);
+--> statement-breakpoint
+CREATE INDEX `btasks_by_status_next` ON `browser_tasks` (`status`,`next_attempt_at`);

package/migrations/0007_estimates_kind.sql

@@ -0,0 +1,2 @@
+ALTER TABLE `inbound` ADD `kind` text;--> statement-breakpoint
+CREATE INDEX `inbound_by_kind_done` ON `inbound` (`kind`,`status`);