@c4t4/heyamigo 0.9.7 → 0.9.9

package/dist/cli/setup.js

@@ -463,7 +463,10 @@ export async function runSetup() {
         }
     }
     // ── Storage ──────────────────────────────────────────────────
-    run('mkdir -p storage/auth storage/messages storage/queue storage/prompts storage/media storage/outbox');
+    // storage/queue (the old fastq persistence dir) removed in Phase 4
+    // — inbound queue lives in SQLite now. storage/backups holds
+    // pre-migration snapshots; created on demand by the migration runner.
+    run('mkdir -p storage/auth storage/messages storage/prompts storage/media storage/outbox');
     run('mkdir -p storage/memory/buckets storage/memory/persons storage/memory/chats');
     p.log.success('Storage directories ready');
     // ── Import existing knowledge ────────────────────────────────

package/dist/gateway/commands.js

@@ -59,5 +59,11 @@ export async function tryCommand(ctx) {
         }).catch(() => undefined);
         return true;
     }
+    if (cmd === 'queues') {
+        const { takeQueuesSnapshot, formatQueuesSnapshot } = await import('../queue/observability.js');
+        const snap = takeQueuesSnapshot();
+        await sendText(ctx.sock, ctx.jid, formatQueuesSnapshot(snap), ctx.quoted);
+        return true;
+    }
     return false;
 }

package/dist/queue/observability.js

@@ -0,0 +1,185 @@
+// Read-only queries that summarize queue + worker state. Used by the
+// /queues chat command and any future HTTP dashboard.
+//
+// All queries are explicit raw SQL via the singleton DB handle so the
+// resulting text matches what an operator would see if they opened
+// the DB with sqlite3 manually.
+import { getRawDb } from '../db/index.js';
+const QUEUE_TABLES = ['inbound', 'outbound'];
+const STUCK_TTL_BY_QUEUE = {
+    inbound: 360,
+    outbound: 60,
+};
+export function takeQueuesSnapshot() {
+    const db = getRawDb();
+    const now = Math.floor(Date.now() / 1000);
+    // Depths
+    const depths = [];
+    for (const q of QUEUE_TABLES) {
+        const rows = db
+            .prepare(`SELECT status, count(*) AS n FROM ${q} GROUP BY status`)
+            .all();
+        const counts = {
+            pending: 0, claimed: 0, failed: 0, dlq: 0,
+        };
+        for (const r of rows)
+            counts[r.status] = r.n;
+        depths.push({
+            queue: q,
+            pending: counts.pending ?? 0,
+            claimed: counts.claimed ?? 0,
+            failed: counts.failed ?? 0,
+            dlq: counts.dlq ?? 0,
+        });
+    }
+    // Stuck claims. Outbound transitions through status='sending' (the
+    // adapter call is in flight); inbound uses 'claimed'. Match either
+    // so we catch stuck rows in any queue.
+    const stuckClaims = [];
+    for (const q of QUEUE_TABLES) {
+        const ttl = STUCK_TTL_BY_QUEUE[q] ?? 60;
+        const rows = db
+            .prepare(`SELECT id, claimed_by, claimed_at
+         FROM ${q}
+         WHERE status IN ('claimed','sending') AND claimed_at < ?`)
+            .all(now - ttl);
+        for (const r of rows) {
+            stuckClaims.push({
+                queue: q,
+                id: r.id,
+                claimedBy: r.claimed_by,
+                claimedFor: now - r.claimed_at,
+            });
+        }
+    }
+    // Workers
+    const wrows = db
+        .prepare(`SELECT id, kind, status, current_job, last_seen
+       FROM workers ORDER BY kind, id`)
+        .all();
+    const workers = wrows.map((r) => ({
+        id: r.id,
+        kind: r.kind,
+        status: r.status,
+        currentJob: r.current_job,
+        ageSeconds: now - r.last_seen,
+    }));
+    // Recent failures (top 5 per queue by updated_at desc)
+    const recentFailures = [];
+    for (const q of QUEUE_TABLES) {
+        const rows = db
+            .prepare(`SELECT id, attempts, last_error, updated_at
+         FROM ${q}
+         WHERE attempts > 0 AND (status='pending' OR status='failed' OR status='dlq')
+         ORDER BY updated_at DESC LIMIT 5`)
+            .all();
+        for (const r of rows) {
+            recentFailures.push({
+                queue: q,
+                id: r.id,
+                attempts: r.attempts,
+                lastError: r.last_error,
+                ageSeconds: now - r.updated_at,
+            });
+        }
+    }
+    // Upcoming crons (next 5 due)
+    const cronRows = db
+        .prepare(`SELECT name, enqueue_into, next_run_at
+       FROM crons WHERE enabled = 1
+       ORDER BY next_run_at LIMIT 5`)
+        .all();
+    const upcomingCrons = cronRows.map((r) => ({
+        name: r.name,
+        enqueueInto: r.enqueue_into,
+        nextRunIn: r.next_run_at - now,
+    }));
+    return {
+        takenAt: now,
+        depths,
+        stuckClaims,
+        workers,
+        recentFailures,
+        upcomingCrons,
+    };
+}
+// Format a snapshot as a single chat-friendly text block. Compact —
+// fits comfortably in a WhatsApp message.
+export function formatQueuesSnapshot(snap) {
+    const lines = [];
+    lines.push('*queues*');
+    // Depths
+    for (const d of snap.depths) {
+        const parts = [d.queue];
+        parts.push(`${d.pending} pending`);
+        if (d.claimed > 0)
+            parts.push(`${d.claimed} in-flight`);
+        if (d.failed > 0)
+            parts.push(`⚠ ${d.failed} failed`);
+        if (d.dlq > 0)
+            parts.push(`⚠ ${d.dlq} dlq`);
+        lines.push('  ' + parts.join(' · '));
+    }
+    // Workers
+    lines.push('*workers*');
+    const byKind = {};
+    for (const w of snap.workers) {
+        if (!byKind[w.kind])
+            byKind[w.kind] = [];
+        byKind[w.kind].push(w);
+    }
+    for (const kind of Object.keys(byKind).sort()) {
+        const ws = byKind[kind];
+        const busy = ws.filter((w) => w.status === 'busy').length;
+        const idle = ws.filter((w) => w.status === 'idle').length;
+        const draining = ws.filter((w) => w.status === 'draining').length;
+        const dead = ws.filter((w) => w.status === 'dead').length;
+        const stale = ws.filter((w) => w.ageSeconds > 30 && w.status !== 'dead').length;
+        const summary = [];
+        if (busy)
+            summary.push(`${busy} busy`);
+        if (idle)
+            summary.push(`${idle} idle`);
+        if (draining)
+            summary.push(`${draining} draining`);
+        if (dead)
+            summary.push(`⚠ ${dead} dead`);
+        if (stale)
+            summary.push(`⚠ ${stale} stale`);
+        lines.push(`  ${kind}: ${summary.length ? summary.join(' · ') : 'none'}`);
+    }
+    // Stuck claims
+    if (snap.stuckClaims.length > 0) {
+        lines.push('*stuck*');
+        for (const s of snap.stuckClaims) {
+            lines.push(`  ${s.queue}:${s.id} by ${s.claimedBy} for ${humanDur(s.claimedFor)}`);
+        }
+    }
+    // Recent failures
+    if (snap.recentFailures.length > 0) {
+        lines.push('*failures*');
+        for (const f of snap.recentFailures) {
+            const err = (f.lastError ?? '').slice(0, 60);
+            lines.push(`  ${f.queue}:${f.id} ×${f.attempts} (${humanDur(f.ageSeconds)} ago): ${err}`);
+        }
+    }
+    // Upcoming crons
+    if (snap.upcomingCrons.length > 0) {
+        lines.push('*crons*');
+        for (const c of snap.upcomingCrons) {
+            const when = c.nextRunIn <= 0 ? 'due now' : `in ${humanDur(c.nextRunIn)}`;
+            lines.push(`  ${c.name} → ${c.enqueueInto} (${when})`);
+        }
+    }
+    return lines.join('\n');
+}
+function humanDur(seconds) {
+    const s = Math.abs(seconds);
+    if (s < 60)
+        return `${s}s`;
+    if (s < 3600)
+        return `${Math.round(s / 60)}m`;
+    if (s < 86400)
+        return `${Math.round(s / 3600)}h`;
+    return `${Math.round(s / 86400)}d`;
+}

package/package.json

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

package/dist/queue/persistence.js

@@ -1,68 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync, } from 'fs';
-import { resolve } from 'path';
-import { logger } from '../logger.js';
-const QUEUE_DIR = resolve(process.cwd(), 'storage/queue');
-const PENDING_FILE = resolve(QUEUE_DIR, 'pending.jsonl');
-function ensureDir() {
-    mkdirSync(QUEUE_DIR, { recursive: true });
-}
-export function persistJob(job) {
-    ensureDir();
-    const line = JSON.stringify({ ...job, enqueuedAt: Date.now() }) + '\n';
-    writeFileSync(PENDING_FILE, line, { flag: 'a', encoding: 'utf-8' });
-}
-export function removeJob(job) {
-    if (!existsSync(PENDING_FILE))
-        return;
-    try {
-        const lines = readFileSync(PENDING_FILE, 'utf-8')
-            .split('\n')
-            .filter(Boolean);
-        const remaining = lines.filter((line) => {
-            try {
-                const parsed = JSON.parse(line);
-                return !(parsed.jid === job.jid && parsed.text === job.text);
-            }
-            catch {
-                return false;
-            }
-        });
-        if (remaining.length === 0) {
-            unlinkSync(PENDING_FILE);
-        }
-        else {
-            writeFileSync(PENDING_FILE, remaining.join('\n') + '\n', 'utf-8');
-        }
-    }
-    catch {
-        // best-effort cleanup
-    }
-}
-export function loadPendingJobs() {
-    if (!existsSync(PENDING_FILE))
-        return [];
-    try {
-        const lines = readFileSync(PENDING_FILE, 'utf-8')
-            .split('\n')
-            .filter(Boolean);
-        const jobs = [];
-        for (const line of lines) {
-            try {
-                const parsed = JSON.parse(line);
-                jobs.push(parsed);
-            }
-            catch {
-                logger.warn({ line: line.slice(0, 100) }, 'skipping malformed pending job');
-            }
-        }
-        logger.info({ count: jobs.length }, 'loaded pending jobs from disk');
-        return jobs;
-    }
-    catch {
-        return [];
-    }
-}
-export function clearPending() {
-    if (existsSync(PENDING_FILE))
-        unlinkSync(PENDING_FILE);
-}

package/dist/queue/queue.js

@@ -1,49 +0,0 @@
-import fastq from 'fastq';
-import { logger } from '../logger.js';
-import { loadPendingJobs, persistJob, removeJob } from './persistence.js';
-import { processJob } from './worker.js';
-const queues = new Map();
-function getQueue(jid) {
-    let q = queues.get(jid);
-    if (!q) {
-        q = fastq.promise(async (job) => {
-            try {
-                const result = await processJob(job);
-                removeJob(job);
-                return result;
-            }
-            catch (err) {
-                removeJob(job);
-                throw err;
-            }
-        }, 1);
-        queues.set(jid, q);
-    }
-    return q;
-}
-export async function enqueue(job) {
-    persistJob(job);
-    return getQueue(job.jid).push(job);
-}
-/**
- * On boot, replay any jobs that were persisted but never completed
- * (process crashed mid-queue). Returns a promise that resolves when
- * all replayed jobs finish or fail. Caller provides a handler for
- * results since the original WAMessage context is gone.
- */
-export async function replayPending(onResult) {
-    const pending = loadPendingJobs();
-    if (!pending.length)
-        return;
-    logger.info({ count: pending.length }, 'replaying pending jobs from last session');
-    const promises = pending.map(async (job) => {
-        try {
-            const result = await getQueue(job.jid).push(job);
-            await onResult(job, result);
-        }
-        catch (err) {
-            logger.error({ err, jid: job.jid }, 'replayed job failed');
-        }
-    });
-    await Promise.allSettled(promises);
-}