@c4t4/heyamigo 0.9.15 → 0.9.17

package/dist/boot.js

@@ -8,6 +8,7 @@ import { syncIdentitiesFromAccess } from './db/identity-sync.js';
 import { attachIncoming } from './gateway/incoming.js';
 import { logger } from './logger.js';
 import { startScheduler } from './memory/scheduler.js';
+import { startBrowserWorkers, stopBrowserWorkers } from './queue/browser-worker.js';
 import { startChatWorkers, stopChatWorkers } from './queue/chat-worker.js';
 import { startMemoryWorker, stopMemoryWorker, } from './queue/memory-worker.js';
 import { requestShutdown, startOrchestrator, stopOrchestrator, } from './queue/orchestrator.js';
@@ -31,6 +32,7 @@ export async function bootBot() {
     startOrchestrator({
         onShutdownDrained: () => {
             stopChatWorkers();
+            stopBrowserWorkers();
             stopSenderWorker();
             stopMemoryWorker();
             stopOrchestrator();
@@ -42,6 +44,7 @@ export async function bootBot() {
     // No separate replay step needed.
     startSenderWorker();
     startMemoryWorker();
+    startBrowserWorkers();
     startChatWorkers();
     startScheduler();
     await startSocket((sock) => {

package/dist/db/schema.js

@@ -159,6 +159,12 @@ export const inbound = sqliteTable('inbound', {
     mediaBytes: integer('media_bytes'),
     pushName: text('push_name'), // sender's display name at send time
     triggerReason: text('trigger_reason'), // 'alias'|'mention'|'reply'|'owner'|...
+    // Job-kind tag for duration estimation (see src/estimates/). Set
+    // at ingest time when a registered estimator matches the message
+    // (e.g. 'image-gen', 'browser:ig'). Null otherwise. Queried by
+    // the estimator on subsequent invocations to compute past-sample
+    // averages.
+    kind: text('kind'),
     // Producer-built worker payload (JSON). Chat worker deserializes
     // at claim time to reconstruct the Job. Keeps the rebuild logic
     // out of the worker for Phase 4; later phases may move portions
@@ -179,6 +185,8 @@ export const inbound = sqliteTable('inbound', {
     byStatusNext: index('inbound_by_status_next').on(t.status, t.nextAttemptAt),
     byAddress: index('inbound_by_address').on(t.address),
     byPerson: index('inbound_by_person').on(t.personId, t.receivedAt),
+    // Used by the duration estimator: "last N done rows of this kind".
+    byKindDone: index('inbound_by_kind_done').on(t.kind, t.status),
     // Sparse unique on external_msg_id: enforced only when set. Same
     // pattern as outbound's idempotency_key.
     uniqExtId: uniqueIndex('inbound_external_msg_id_uq')
@@ -216,3 +224,33 @@ export const memoryWrites = sqliteTable('memory_writes', {
         .on(t.idempotencyKey)
         .where(sql `${t.idempotencyKey} IS NOT NULL`),
 }));
+// ──────────────────────────────────────────────────────────────────
+// Browser tasks (Phase 4, durable)
+// ──────────────────────────────────────────────────────────────────
+// Browser-driven background tasks ([ASYNC-BROWSER:] markers). Replaces
+// the in-memory fastq queue with SQLite-backed durable storage: tasks
+// survive process crashes and reclaim via TTL.
+//
+// Browser worker pool (config.browser.maxWorkers) drains; each task
+// runs as a fresh agent (no persistent session — Phase 4) and opens
+// its own tab on the shared Chrome.
+export const browserTasks = sqliteTable('browser_tasks', {
+    id: integer('id').primaryKey({ autoIncrement: true }),
+    address: text('address').notNull(),
+    actorPersonId: text('actor_person_id'),
+    description: text('description').notNull(),
+    originatingMessage: text('originating_message').notNull(),
+    senderNumber: text('sender_number').notNull(),
+    senderName: text('sender_name'),
+    allowedTools: text('allowed_tools'), // JSON: 'all' | string[]
+    status: text('status').notNull(),
+    attempts: integer('attempts').notNull().default(0),
+    nextAttemptAt: integer('next_attempt_at'),
+    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('btasks_by_status_next').on(t.status, t.nextAttemptAt),
+}));

package/dist/estimates/image-gen.js

@@ -0,0 +1,36 @@
+// Image-generation estimator. Matches when the user message looks
+// like a request to produce an image. Tracks duration of the chat-
+// track turn that handles it (claimedAt → updatedAt on the inbound
+// row).
+import { aggregateMean, registerEstimator } from './registry.js';
+// Conservative regex. Requires a generation verb AND an image-class
+// noun within 80 chars. Prefers false-negative to false-positive —
+// a single mistagged sample drags the average for everyone.
+const IMAGE_GEN_RE = /\b(generate|create|make|draw|render|design|sketch|paint|illustrate)\b[^.?!\n]{0,80}\b(image|picture|drawing|art|artwork|photo|portrait|illustration|sketch|render|painting|wallpaper|logo|icon|graphic)\b/i;
+class ImageGenEstimator {
+    kind = 'image-gen';
+    // 30s starting point — reasonable ballpark for current
+    // image-generation APIs (DALL-E 3, Imagen, Flux, etc.). The very
+    // first request shows this; from sample 1 onward it averages real
+    // observations.
+    defaultMs = 30_000;
+    matches(ctx) {
+        return IMAGE_GEN_RE.test(ctx.description);
+    }
+    estimate(samples) {
+        return aggregateMean(samples, this.defaultMs);
+    }
+    format(estimate) {
+        if (estimate.rangeMs) {
+            return `generating image, anywhere from ~${secs(estimate.rangeMs.lowMs)} to ~${secs(estimate.rangeMs.highMs)}`;
+        }
+        return `generating image, ~${secs(estimate.pointMs)}`;
+    }
+}
+function secs(ms) {
+    const s = Math.max(1, Math.round(ms / 1000));
+    if (s < 60)
+        return `${s}s`;
+    return `${Math.round(s / 60)}min`;
+}
+registerEstimator(new ImageGenEstimator());

package/dist/estimates/index.js

@@ -0,0 +1,12 @@
+// Estimates module entry point. Importing this side-effect-loads
+// every built-in plugin (each plugin file calls registerEstimator()
+// at module load). Outside callers only need:
+//
+//   import { classify, estimate } from './estimates/index.js'
+//
+// Adding a new kind = drop a file alongside image-gen.ts and import
+// it below. No other code in the codebase needs to change.
+import './image-gen.js';
+// future: import './browser-ig.js'
+// future: import './voice-gen.js'
+export { classify, estimate, formatEstimateDefault, humanDur, listEstimators, querySamplesForKind, registerEstimator, } from './registry.js';

package/dist/estimates/registry.js

@@ -0,0 +1,113 @@
+// Estimator registry + the single entry points the rest of the bot
+// uses: classify() and estimate(). Plugins self-register by importing
+// this module and calling registerEstimator().
+import { and, desc, eq, isNotNull } from 'drizzle-orm';
+import { getDb } from '../db/index.js';
+import { inbound } from '../db/schema.js';
+const REGISTRY = [];
+export function registerEstimator(e) {
+    // Idempotent on kind so hot-reload during dev doesn't duplicate.
+    const i = REGISTRY.findIndex((x) => x.kind === e.kind);
+    if (i >= 0)
+        REGISTRY[i] = e;
+    else
+        REGISTRY.push(e);
+}
+export function listEstimators() {
+    return REGISTRY;
+}
+// Find the first estimator whose matches() returns true. First-match
+// wins — order matters when registering. More-specific kinds should
+// register before broad fallbacks.
+export function classify(ctx) {
+    for (const e of REGISTRY) {
+        if (e.matches(ctx))
+            return e;
+    }
+    return null;
+}
+// Pull the last N completed inbound rows for this kind. Returns
+// newest-first; estimators that care about recency can use that
+// order directly, the mean-based aggregator below doesn't.
+//
+// Limited to N=20 by default. The mean is fast and stable past 5-10
+// samples; older data isn't helpful and risks staleness.
+const SAMPLE_LIMIT = 20;
+export function querySamplesForKind(kind, limit = SAMPLE_LIMIT) {
+    const db = getDb();
+    const rows = db
+        .select({
+        claimedAt: inbound.claimedAt,
+        updatedAt: inbound.updatedAt,
+    })
+        .from(inbound)
+        .where(and(eq(inbound.kind, kind), eq(inbound.status, 'done'), isNotNull(inbound.claimedAt)))
+        .orderBy(desc(inbound.id))
+        .limit(limit)
+        .all();
+    return rows
+        .filter((r) => r.claimedAt !== null)
+        .map((r) => ({
+        durationMs: (r.updatedAt - r.claimedAt) * 1000,
+        finishedAt: r.updatedAt,
+    }))
+        .filter((s) => s.durationMs > 0);
+}
+// Public entry point. Returns the kind + formatted text, or null
+// when no estimator matched (i.e. this isn't a job-kind we estimate).
+// If an estimator matches, the result is ALWAYS non-null — the
+// estimator falls back to its defaultMs when no samples exist.
+export function estimate(ctx) {
+    const e = classify(ctx);
+    if (!e)
+        return null;
+    const samples = querySamplesForKind(e.kind);
+    const result = e.estimate(samples);
+    const text = (e.format ?? formatEstimateDefault)(result);
+    return { kind: e.kind, result, text };
+}
+// Default UX-friendly rendering. Each estimator can override.
+export function formatEstimateDefault(r) {
+    if (r.rangeMs) {
+        return `anywhere from ~${humanDur(r.rangeMs.lowMs)} to ~${humanDur(r.rangeMs.highMs)}`;
+    }
+    return `~${humanDur(r.pointMs)}`;
+}
+export function humanDur(ms) {
+    const s = Math.max(1, Math.round(ms / 1000));
+    if (s < 60)
+        return `${s}s`;
+    const m = Math.round(s / 60);
+    if (m < 60)
+        return `${m}min`;
+    return `${Math.round(m / 60)}h`;
+}
+// Shared aggregator used by built-in estimators. Each estimator may
+// implement its own estimate() but most just call this.
+export function aggregateMean(samples, defaultMs) {
+    if (samples.length === 0) {
+        return { pointMs: defaultMs, sampleSize: 0, confidence: 'low' };
+    }
+    const ds = samples.map((s) => s.durationMs);
+    const mean = ds.reduce((a, b) => a + b, 0) / ds.length;
+    if (samples.length === 1) {
+        return { pointMs: mean, sampleSize: 1, confidence: 'low' };
+    }
+    const variance = ds.reduce((acc, x) => acc + (x - mean) ** 2, 0) / ds.length;
+    const std = Math.sqrt(variance);
+    const confidence = samples.length >= 10 ? 'high' : samples.length >= 5 ? 'medium' : 'low';
+    // Disclose range when stddev is a large fraction of the mean.
+    // Threshold chosen at 50% — beyond that, a single point estimate
+    // hides too much.
+    return std / mean > 0.5
+        ? {
+            pointMs: mean,
+            sampleSize: samples.length,
+            confidence,
+            rangeMs: {
+                lowMs: Math.max(0, mean - std),
+                highMs: mean + std,
+            },
+        }
+        : { pointMs: mean, sampleSize: samples.length, confidence };
+}

package/dist/estimates/types.js

@@ -0,0 +1,6 @@
+// Job duration estimation interface. The system stays "blackbox" by
+// design — outside callers only touch the registry's classify() /
+// estimate() functions. Each kind plugs in via a self-contained file
+// in src/estimates/<kind>.ts that calls registerEstimator() at module
+// load.
+export {};

package/dist/gateway/incoming.js

@@ -5,6 +5,7 @@ import { getSession } from '../ai/sessions.js';
 import { formatAddress, jidToAddress } from '../db/address.js';
 import { personIdForAddress } from '../db/identity-sync.js';
 import { config } from '../config.js';
+import { estimate as estimateJob } from '../estimates/index.js';
 import { logger } from '../logger.js';
 import { buildMemoryPreamble } from '../memory/preamble.js';
 import { enqueueInbound } from '../queue/inbound.js';
@@ -216,12 +217,30 @@ 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) {
+            // Estimator: classify this message and, when a kind matches,
+            // (a) tag the inbound row so future estimates of the same kind
+            // get a fresh sample, and (b) send the estimate text as an
+            // immediate ack so the user sees a timeline before the agent
+            // even starts.
+            const est = estimateJob({
+                description: stored.text,
+                attachments: media ? [{ kind: media.mediaType }] : undefined,
+                senderPersonId: actorPersonId ?? undefined,
+            });
+            const jobKind = est?.kind ?? null;
+            if (est) {
+                enqueueOutbound({
+                    address: chatAddress,
+                    kind: 'text',
+                    text: est.text,
+                    idempotencyKey: `estimate-${msg.key.id}`,
+                });
+            }
+            else if (media && config.reply.ackOnMedia !== false) {
+                // Fallback media-ack when no estimator matched — keeps the
+                // pre-estimator behavior so image messages still get the
+                // "looking…" hint. A future MediaIncomingEstimator can replace
+                // this with a real average.
                 enqueueOutbound({
                     address: chatAddress,
                     kind: 'text',
@@ -238,6 +257,7 @@ async function processMessages(messages, sock, ownerJid, isHistorySync = false)
                 text: stored.text,
                 pushName: stored.pushName ?? null,
                 triggerReason,
+                kind: jobKind,
                 receivedAt: stored.timestamp,
                 payload: job,
             });

package/dist/queue/async-tasks.js

@@ -1,8 +1,10 @@
 import { getProvider } from '../ai/providers.js';
+import { formatAddress, jidToAddress } from '../db/address.js';
 import { config } from '../config.js';
 import fastq from 'fastq';
 import { initiate } from '../gateway/outgoing.js';
 import { logger } from '../logger.js';
+import { enqueueBrowserJob } from './browser-queue.js';
 // Concurrency: how many async workers can run simultaneously.
 // Start conservative — each process is expensive (Playwright, multi-minute runs).
 // Tune via config.asyncTasks.concurrency once we have real usage data.
@@ -241,36 +243,32 @@ function truncate(s, n) {
 //   (the chat-track agent writes self-contained task descriptions).
 //   Per-task tab isolation is enforced by the prompt instructions
 //   below.
-// Browser pool: multiple agents share one Chrome (the logged-in
-// profile), each task opens its own tab. Persistent agent session is
-// dropped — every task is fresh, with self-contained instructions
-// from the chat-track agent. The trade-off: no cross-task agent
-// memory; the win: real parallelism.
-const BROWSER_CONCURRENCY = Math.max(1, config.browser?.maxWorkers ?? 3);
-const browserQueue = fastq.promise(async (task) => {
-    inProgress.set(task.id, task);
-    try {
-        await runBrowserTask(task);
-    }
-    catch (err) {
-        logger.error({ err, id: task.id, jid: task.jid }, 'browser task failed unexpectedly');
-    }
-    finally {
-        inProgress.delete(task.id);
-    }
-}, BROWSER_CONCURRENCY);
+// Browser tasks now go into the durable browser_tasks SQLite table.
+// The browser worker pool (src/queue/browser-worker.ts) drains it.
+// In-flight tasks survive process crashes; the orchestrator reclaims
+// stuck claims via the TTL on the table.
 export function enqueueBrowserTask(input) {
+    // Keep AsyncTask shape exported so existing callers (worker.ts)
+    // don't change. The returned id is informational only — the real
+    // row id is the DB auto-increment.
     const task = {
         ...input,
         id: `browser-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
         startedAt: Math.floor(Date.now() / 1000),
     };
+    enqueueBrowserJob({
+        address: formatAddress(jidToAddress(task.jid)),
+        description: task.description,
+        originatingMessage: task.originatingMessage,
+        senderNumber: task.senderNumber,
+        senderName: task.senderName ?? null,
+        allowedTools: task.allowedTools,
+    });
     logger.info({
         id: task.id,
         jid: task.jid,
         description: task.description.slice(0, 200),
     }, 'browser task enqueued');
-    browserQueue.push(task).catch((err) => logger.error({ err, id: task.id }, 'browser queue push failed'));
     return task;
 }
 function buildBrowserPrompt(task) {
@@ -324,7 +322,10 @@ function browserAddDirs() {
         config.storage.mediaDir,
     ];
 }
-async function runBrowserTask(task) {
+// Exported so the browser worker (src/queue/browser-worker.ts) can
+// invoke it for each claimed row. Body unchanged from the pre-queue
+// version — just rehomed for direct invocation by the pool.
+export async function runBrowserTask(task) {
     const provider = getProvider();
     // Each task is fresh (Phase 4 browser parallelism). No persistent
     // session — would force serialization on concurrent tasks.

package/dist/queue/browser-queue.js

@@ -0,0 +1,141 @@
+// Browser tasks queue helpers. Producers call enqueueBrowserJob;
+// the browser worker pool drains via claimNextBrowserTask. Same
+// primitives as inbound/outbound — claim is atomic, retry uses
+// per-task backoff, claimed_by safety check on completion.
+//
+// No per-address serialization: multiple browser tasks for the same
+// originating chat CAN run concurrently (each opens its own tab on
+// the shared Chrome). Reply order isn't a concern because each browser
+// task ends with an outbound row, and the sender worker serializes
+// per-address there.
+import { and, asc, eq, isNull, lte, or, sql } from 'drizzle-orm';
+import { getDb } from '../db/index.js';
+import { browserTasks } from '../db/schema.js';
+export function enqueueBrowserJob(input) {
+    const db = getDb();
+    const now = Math.floor(Date.now() / 1000);
+    return db
+        .insert(browserTasks)
+        .values({
+        address: input.address,
+        actorPersonId: input.actorPersonId ?? null,
+        description: input.description,
+        originatingMessage: input.originatingMessage,
+        senderNumber: input.senderNumber,
+        senderName: input.senderName ?? null,
+        allowedTools: input.allowedTools
+            ? JSON.stringify(input.allowedTools)
+            : null,
+        status: 'pending',
+        attempts: 0,
+        nextAttemptAt: null,
+        lastError: null,
+        claimedBy: null,
+        claimedAt: null,
+        createdAt: now,
+        updatedAt: now,
+    })
+        .returning()
+        .get();
+}
+export function claimNextBrowserTask(workerId) {
+    const db = getDb();
+    const now = Math.floor(Date.now() / 1000);
+    return db.transaction((tx) => {
+        const target = tx
+            .select({ id: browserTasks.id })
+            .from(browserTasks)
+            .where(and(eq(browserTasks.status, 'pending'), or(isNull(browserTasks.nextAttemptAt), lte(browserTasks.nextAttemptAt, now))))
+            .orderBy(asc(browserTasks.id))
+            .limit(1)
+            .get();
+        if (!target)
+            return null;
+        const claimed = tx
+            .update(browserTasks)
+            .set({
+            status: 'claimed',
+            claimedBy: workerId,
+            claimedAt: now,
+            updatedAt: now,
+        })
+            .where(and(eq(browserTasks.id, target.id), eq(browserTasks.status, 'pending')))
+            .returning()
+            .get();
+        return claimed ?? null;
+    });
+}
+export function markBrowserTaskDone(id, workerId) {
+    const db = getDb();
+    const now = Math.floor(Date.now() / 1000);
+    const result = db
+        .update(browserTasks)
+        .set({ status: 'done', updatedAt: now })
+        .where(and(eq(browserTasks.id, id), eq(browserTasks.status, 'claimed'), eq(browserTasks.claimedBy, workerId)))
+        .returning({ id: browserTasks.id })
+        .all();
+    return result.length > 0;
+}
+// Browser tasks are expensive (multi-minute Playwright sessions) so
+// retries are sparse: 30s, 5min, give up (DLQ after 2 attempts past
+// the first). Most browser failures are deterministic (login wall,
+// bot detection) and won't benefit from rapid retries.
+const BACKOFF_SECONDS = [30, 300];
+const MAX_ATTEMPTS = BACKOFF_SECONDS.length;
+export function markBrowserTaskRetryOrDlq(id, workerId, errorMessage) {
+    const db = getDb();
+    return db.transaction((tx) => {
+        const row = tx.select().from(browserTasks).where(eq(browserTasks.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(browserTasks)
+                .set({
+                status: 'dlq',
+                attempts: nextAttempts,
+                lastError: errorMessage,
+                claimedBy: null,
+                claimedAt: null,
+                updatedAt: now,
+            })
+                .where(eq(browserTasks.id, id))
+                .run();
+            return { retried: false, deadLettered: true };
+        }
+        const backoff = BACKOFF_SECONDS[Math.min(row.attempts, BACKOFF_SECONDS.length - 1)];
+        tx.update(browserTasks)
+            .set({
+            status: 'pending',
+            attempts: nextAttempts,
+            nextAttemptAt: now + backoff,
+            lastError: errorMessage,
+            claimedBy: null,
+            claimedAt: null,
+            updatedAt: now,
+        })
+            .where(eq(browserTasks.id, id))
+            .run();
+        return { retried: true, deadLettered: false };
+    });
+}
+// Browser tasks take 1-15 min routinely. Generous reclaim TTL.
+const CLAIM_TTL_SECONDS = 20 * 60;
+export function reclaimStuckBrowserTasks() {
+    const db = getDb();
+    const cutoff = Math.floor(Date.now() / 1000) - CLAIM_TTL_SECONDS;
+    const result = db
+        .update(browserTasks)
+        .set({
+        status: 'pending',
+        claimedBy: null,
+        claimedAt: null,
+        updatedAt: sql `${browserTasks.updatedAt}`,
+    })
+        .where(and(eq(browserTasks.status, 'claimed'), lte(browserTasks.claimedAt, cutoff)))
+        .returning({ id: browserTasks.id })
+        .all();
+    return result.length;
+}