alvin-bot 4.6.0 → 4.8.0

package/dist/handlers/commands.js

@@ -18,6 +18,7 @@ import { screenshotUrl, extractText, generatePdf, hasPlaywright } from "../servi
 import { listJobs, createJob, deleteJob, toggleJob, runJobNow, formatNextRun, humanReadableSchedule } from "../services/cron.js";
 import { storePassword, revokePassword, getSudoStatus, verifyPassword } from "../services/sudo.js";
 import { config } from "../config.js";
+import { BOT_VERSION } from "../version.js";
 import { getWebPort } from "../web/server.js";
 import { getUsageSummary, getAllRateLimits, formatTokens } from "../services/usage-tracker.js";
 import { runUpdate, getAutoUpdate, setAutoUpdate, startAutoUpdateLoop } from "../services/updater.js";
@@ -141,6 +142,7 @@ export function registerCommands(bot) {
         { command: "effort", description: "Set reasoning depth" },
         { command: "voice", description: "Voice replies on/off" },
         { command: "status", description: "Current status" },
+        { command: "version", description: "Show Alvin Bot version" },
         { command: "new", description: "Start new session" },
         { command: "dir", description: "Change working directory" },
         { command: "web", description: "Quick web search" },
@@ -219,6 +221,10 @@ export function registerCommands(bot) {
             await ctx.reply(`Directory not found: ${resolved}`);
         }
     });
+    bot.command("version", async (ctx) => {
+        await ctx.reply(`🤖 *Alvin Bot* \`v${BOT_VERSION}\`\n` +
+            `Node ${process.version} · ${process.platform}/${process.arch}`, { parse_mode: "Markdown" });
+    });
     bot.command("status", async (ctx) => {
         const userId = ctx.from.id;
         const session = getSession(userId);
@@ -371,7 +377,7 @@ export function registerCommands(bot) {
             const failoverBadge = failedOver ? ` ${t("bot.status.failedOver", lang)}` : "";
             healthLines = `\n${t("bot.status.providerHealth", lang)}${failoverBadge}\n${rows.join("\n")}\n`;
         }
-        await ctx.reply(`🤖 *Alvin Bot Status*\n\n` +
+        await ctx.reply(`🤖 *Alvin Bot* \`v${BOT_VERSION}\`\n\n` +
             `*Model:* ${info.name} ${providerTag}\n` +
             `*Effort:* ${EFFORT_LABELS[session.effort]}\n` +
             `*Voice:* ${session.voiceReply ? "on" : "off"}\n` +
@@ -1728,7 +1734,7 @@ export function registerCommands(bot) {
     // type both "/sub-agents" and "/subagents" — Telegram routes both to this.
     bot.command(["sub_agents", "subagents"], async (ctx) => {
         const lang = getSession(ctx.from.id).language;
-        const { listSubAgents, cancelSubAgent, getSubAgentResult, getMaxParallelAgents, getConfiguredMaxParallel, setMaxParallelAgents, findSubAgentByName, getVisibility, setVisibility, } = await import("../services/subagents.js");
+        const { listSubAgents, cancelSubAgent, getSubAgentResult, getMaxParallelAgents, getConfiguredMaxParallel, setMaxParallelAgents, findSubAgentByName, getVisibility, setVisibility, getQueueCap, setQueueCap, } = await import("../services/subagents.js");
         const arg = (ctx.match || "").trim();
         const tokens = arg.split(/\s+/).filter(Boolean);
         const sub = tokens[0]?.toLowerCase() || "";
@@ -1741,7 +1747,8 @@ export function registerCommands(bot) {
             const ageLabel = ageSec < 60 ? `${ageSec}s` : ageSec < 3600 ? `${Math.floor(ageSec / 60)}m` : `${Math.floor(ageSec / 3600)}h`;
             const sourceBadge = a.source === "cron" ? "⏰" : a.source === "implicit" ? "🔗" : "👤";
             const depthTag = a.depth > 0 ? ` d${a.depth}` : "";
-            return `${indent}${sourceBadge} \`${shortId(a.id)}\` ${a.name} (${a.status}, ${ageLabel}${depthTag})`;
+            const queueTag = a.status === "queued" && a.queuePosition ? ` #${a.queuePosition}` : "";
+            return `${indent}${sourceBadge} \`${shortId(a.id)}\` ${a.name} (${a.status}${queueTag}, ${ageLabel}${depthTag})`;
         };
         // /sub-agents max <n>
         if (sub === "max") {
@@ -1754,7 +1761,50 @@ export function registerCommands(bot) {
             await ctx.reply(t("bot.subagents.maxSet", lang, { n, eff: effective }), { parse_mode: "Markdown" });
             return;
         }
-        // /sub-agents visibility <auto|banner|silent>
+        // /subagents stats — show rolling 24h run stats (H3)
+        if (sub === "stats") {
+            const { getSubAgentStats } = await import("../services/subagent-stats.js");
+            const s = getSubAgentStats();
+            const formatTok = (n) => (n < 1000 ? `${n}` : `${(n / 1000).toFixed(1)}k`);
+            const formatDur = (ms) => {
+                const sec = Math.floor(ms / 1000);
+                if (sec < 60)
+                    return `${sec}s`;
+                const m = Math.floor(sec / 60);
+                return `${m}m`;
+            };
+            const lines = [
+                `📊 *Sub-Agent Stats* — last ${s.windowHours}h`,
+                ``,
+                `*Total:* ${s.total.runs} runs · ${formatTok(s.total.inputTokens)} in / ${formatTok(s.total.outputTokens)} out · ${formatDur(s.total.totalDurationMs)}`,
+                ``,
+                `*By source:*`,
+                `  👤 user:     ${s.bySource.user.runs} runs · ${formatTok(s.bySource.user.inputTokens)} in / ${formatTok(s.bySource.user.outputTokens)} out`,
+                `  ⏰ cron:     ${s.bySource.cron.runs} runs · ${formatTok(s.bySource.cron.inputTokens)} in / ${formatTok(s.bySource.cron.outputTokens)} out`,
+                `  🔗 implicit: ${s.bySource.implicit.runs} runs · ${formatTok(s.bySource.implicit.inputTokens)} in / ${formatTok(s.bySource.implicit.outputTokens)} out`,
+                ``,
+                `*By status:*`,
+                `  ✅ completed: ${s.byStatus.completed}`,
+                `  ⚠️ cancelled: ${s.byStatus.cancelled}`,
+                `  ⏱️ timeout:   ${s.byStatus.timeout}`,
+                `  ❌ error:     ${s.byStatus.error}`,
+            ];
+            await ctx.reply(lines.join("\n"), { parse_mode: "Markdown" });
+            return;
+        }
+        // /subagents queue <n> — set bounded-queue cap (0 disables queue)
+        if (sub === "queue") {
+            const n = parseInt(tokens[1] || "", 10);
+            if (isNaN(n)) {
+                const current = getQueueCap();
+                await ctx.reply(`Queue cap: *${current}* (${current === 0 ? "disabled" : "bounded"})\nUsage: \`/subagents queue <n>\` (0 disables the queue, max 200)`, { parse_mode: "Markdown" });
+                return;
+            }
+            const effective = setQueueCap(n);
+            await ctx.reply(`✅ Queue cap set to *${effective}* ${effective === 0 ? "(queue disabled — full pool rejects immediately)" : ""}`, { parse_mode: "Markdown" });
+            return;
+        }
+        // /sub-agents visibility <auto|banner|silent|live>
         if (sub === "visibility") {
             const mode = tokens[1];
             if (!mode) {

package/dist/i18n.js

@@ -519,10 +519,10 @@ const strings = {
         fr: "Durée : {sec}s · Tokens : {in}/{out}",
     },
     "bot.subagents.usage": {
-        en: "Commands:\n/subagents — show status\n/subagents max <n> — set parallel limit (0=auto)\n/subagents visibility <auto|banner|silent> — delivery mode\n/subagents list — list all\n/subagents cancel <name|id> — cancel one\n/subagents result <name|id> — show result",
-        de: "Befehle:\n/subagents — Status anzeigen\n/subagents max <n> — Parallel-Limit setzen (0=auto)\n/subagents visibility <auto|banner|silent> — Delivery-Modus\n/subagents list — alle anzeigen\n/subagents cancel <name|id> — abbrechen\n/subagents result <name|id> — Ergebnis anzeigen",
-        es: "Comandos:\n/subagents — ver estado\n/subagents max <n> — establecer límite (0=auto)\n/subagents visibility <auto|banner|silent> — modo de entrega\n/subagents list — listar todos\n/subagents cancel <nombre|id> — cancelar uno\n/subagents result <nombre|id> — ver resultado",
-        fr: "Commandes :\n/subagents — état\n/subagents max <n> — limite parallèle (0=auto)\n/subagents visibility <auto|banner|silent> — mode de livraison\n/subagents list — lister tous\n/subagents cancel <nom|id> — annuler un\n/subagents result <nom|id> — voir résultat",
+        en: "Commands:\n/subagents — show status\n/subagents max <n> — set parallel limit (0=auto)\n/subagents visibility <auto|banner|silent|live> — delivery mode\n/subagents queue <n> — bounded-queue cap (0 = disabled)\n/subagents stats — last 24h run stats\n/subagents list — list all\n/subagents cancel <name|id> — cancel one\n/subagents result <name|id> — show result",
+        de: "Befehle:\n/subagents — Status anzeigen\n/subagents max <n> — Parallel-Limit setzen (0=auto)\n/subagents visibility <auto|banner|silent|live> — Delivery-Modus\n/subagents list — alle anzeigen\n/subagents cancel <name|id> — abbrechen\n/subagents result <name|id> — Ergebnis anzeigen",
+        es: "Comandos:\n/subagents — ver estado\n/subagents max <n> — establecer límite (0=auto)\n/subagents visibility <auto|banner|silent|live> — modo de entrega\n/subagents list — listar todos\n/subagents cancel <nombre|id> — cancelar uno\n/subagents result <nombre|id> — ver resultado",
+        fr: "Commandes :\n/subagents — état\n/subagents max <n> — limite parallèle (0=auto)\n/subagents visibility <auto|banner|silent|live> — mode de livraison\n/subagents list — lister tous\n/subagents cancel <nom|id> — annuler un\n/subagents result <nom|id> — voir résultat",
     },
     "bot.subagents.visibilityLabel": {
         en: "Visibility:",
@@ -537,10 +537,10 @@ const strings = {
         fr: "✅ Visibilité réglée sur *{mode}*",
     },
     "bot.subagents.visibilityInvalid": {
-        en: "❌ Invalid mode _{mode}_. Use: auto | banner | silent",
-        de: "❌ Ungültiger Modus _{mode}_. Nutze: auto | banner | silent",
-        es: "❌ Modo inválido _{mode}_. Usa: auto | banner | silent",
-        fr: "❌ Mode invalide _{mode}_. Utilise : auto | banner | silent",
+        en: "❌ Invalid mode _{mode}_. Use: auto | banner | silent | live",
+        de: "❌ Ungültiger Modus _{mode}_. Nutze: auto | banner | silent | live",
+        es: "❌ Modo inválido _{mode}_. Usa: auto | banner | silent | live",
+        fr: "❌ Mode invalide _{mode}_. Utilise : auto | banner | silent | live",
     },
     // Relative time formatting (formatRelativeTime helper)
     "bot.time.justNow": {

package/dist/index.js

@@ -134,6 +134,7 @@ if (hasTelegram) {
     attachBotApi({
         sendMessage: (chatId, text, opts) => botRef.api.sendMessage(chatId, text, opts),
         sendDocument: (chatId, doc, opts) => botRef.api.sendDocument(chatId, doc, opts),
+        editMessageText: (chatId, messageId, text, opts) => botRef.api.editMessageText(chatId, messageId, text, opts),
     });
     // Auth middleware — alle Messages durchlaufen das
     bot.use(authMiddleware);

package/dist/services/subagent-delivery.js

@@ -53,6 +53,157 @@ function buildBanner(info, result) {
     const to = formatTokens(result.tokensUsed.output);
     return `${icon} *${info.name}* ${result.status} · ${dur} · ${ti} in / ${to} out`;
 }
+// ── A4 Live-Stream ──────────────────────────────────────────
+/**
+ * Per-spawn live-stream state. Edits a single Telegram message as the
+ * sub-agent produces text, throttled to ~800ms between edits. Posts a
+ * separate banner message at finalize so the user gets a completion
+ * notification (edits don't trigger Telegram notifications).
+ *
+ * The live message uses plain text (no parse_mode) so half-formed
+ * markdown during streaming can never crash the edit. The final banner
+ * does use markdown.
+ */
+const LIVE_EDIT_THROTTLE_MS = 800;
+const LIVE_INITIAL_TEXT = (name) => `⏳ ${name} thinking…`;
+export class LiveStream {
+    api;
+    chatId;
+    agentName;
+    messageId = null;
+    lastEditAt = 0;
+    pendingText = null;
+    pendingTimer = null;
+    started = false;
+    failed = false;
+    constructor(api, chatId, agentName) {
+        this.api = api;
+        this.chatId = chatId;
+        this.agentName = agentName;
+    }
+    /** Post the initial placeholder message. Called before the first chunk. */
+    async start() {
+        if (!this.api.editMessageText) {
+            this.failed = true;
+            console.warn(`[subagent-live] bot api has no editMessageText — falling back`);
+            return;
+        }
+        try {
+            const initial = LIVE_INITIAL_TEXT(this.agentName);
+            const msg = await this.api.sendMessage(this.chatId, initial);
+            const msgId = msg.message_id;
+            if (typeof msgId === "number") {
+                this.messageId = msgId;
+                this.lastEditAt = Date.now();
+                this.started = true;
+            }
+            else {
+                console.warn(`[subagent-live] sendMessage returned no message_id`);
+                this.failed = true;
+            }
+        }
+        catch (err) {
+            console.error(`[subagent-live] start failed:`, err);
+            this.failed = true;
+        }
+    }
+    /**
+     * Record a new accumulated text state. Will schedule a throttled edit
+     * ~800ms after the previous edit. Later updates that arrive before
+     * the throttled flush coalesce — only the latest text is used.
+     */
+    update(text) {
+        if (!this.started || this.failed || this.messageId === null)
+            return;
+        this.pendingText = text;
+        if (this.pendingTimer)
+            return;
+        const elapsed = Date.now() - this.lastEditAt;
+        const delay = Math.max(0, LIVE_EDIT_THROTTLE_MS - elapsed);
+        this.pendingTimer = setTimeout(() => {
+            this.flush().catch((err) => {
+                console.warn(`[subagent-live] scheduled flush failed:`, err);
+            });
+        }, delay);
+    }
+    async flush() {
+        this.pendingTimer = null;
+        if (!this.pendingText || this.messageId === null || this.failed)
+            return;
+        if (!this.api.editMessageText) {
+            this.failed = true;
+            return;
+        }
+        // Cap edit length — Telegram rejects >4096 chars
+        const body = this.pendingText.slice(0, MAX_TG_CHUNK);
+        const display = `⏳ ${this.agentName}\n\n${body}`;
+        try {
+            await this.api.editMessageText(this.chatId, this.messageId, display);
+            this.lastEditAt = Date.now();
+        }
+        catch (err) {
+            // "message is not modified" is harmless (same content as before)
+            const msg = err instanceof Error ? err.message : String(err);
+            if (!/not modified/i.test(msg)) {
+                console.warn(`[subagent-live] edit failed:`, msg);
+            }
+        }
+        this.pendingText = null;
+    }
+    /**
+     * Flush any pending edit, then post the final banner as a new message
+     * so the user gets a notification. The live-stream message stays in
+     * place as the body; the banner is a separate message above/below it.
+     */
+    async finalize(info, result) {
+        if (this.pendingTimer) {
+            clearTimeout(this.pendingTimer);
+            this.pendingTimer = null;
+        }
+        if (this.pendingText) {
+            await this.flush();
+        }
+        this.started = false;
+        if (this.failed)
+            return;
+        // One last edit to remove the "thinking…" header (replace with final text)
+        if (this.messageId !== null && this.api.editMessageText) {
+            const finalBody = (result.output?.trim() || "(empty output)").slice(0, MAX_TG_CHUNK);
+            const finalDisplay = `${info.name}\n\n${finalBody}`;
+            try {
+                await this.api.editMessageText(this.chatId, this.messageId, finalDisplay);
+            }
+            catch {
+                // If the final edit fails, the "thinking…" header stays —
+                // the banner below will still communicate completion.
+            }
+        }
+        // Post the banner as a new message (notification-triggering)
+        const banner = buildBanner(info, result);
+        try {
+            await this.api.sendMessage(this.chatId, banner, { parse_mode: "Markdown" });
+        }
+        catch (err) {
+            console.error(`[subagent-live] finalize banner failed:`, err);
+            this.failed = true;
+            throw err;
+        }
+    }
+}
+/**
+ * Factory for LiveStream — returns null if the bot api isn't attached
+ * yet, or if the api doesn't support editMessageText. Callers check
+ * the return value and fall back to normal delivery if null.
+ */
+export function createLiveStream(chatId, agentName) {
+    const api = getBotApi();
+    if (!api || !api.editMessageText) {
+        console.warn(`[subagent-live] no compatible bot api — live mode unavailable`);
+        return null;
+    }
+    return new LiveStream(api, chatId, agentName);
+}
+// ── Main delivery entry point ───────────────────────────────
 /**
  * Main delivery entry point. Resolves the effective visibility (override →
  * config default), then dispatches to the source-specific renderer.
@@ -68,6 +219,10 @@ export async function deliverSubAgentResult(info, result, opts = {}) {
     const effective = opts.visibility ?? getVisibility();
     if (effective === "silent")
         return;
+    // "live" mode is handled inline by runSubAgent via LiveStream. If we
+    // get here with "live" visibility it means the live-stream path wasn't
+    // applicable (wrong source, missing editMessageText, etc.) — fall
+    // through to the normal banner+final behavior below.
     const api = getBotApi();
     if (!api) {
         console.warn(`[subagent-delivery] no bot api available for ${info.name}`);

package/dist/services/subagent-stats.js

@@ -0,0 +1,123 @@
+/**
+ * Sub-Agent Stats (H3) — rolling 24h aggregation of per-agent run data.
+ *
+ * Append-only JSON ring buffer persisted to ~/.alvin-bot/subagent-stats.json.
+ * On load, entries older than 24h are pruned. On each append, entries older
+ * than 24h are pruned.
+ *
+ * Used by /subagents stats to show run totals per source (user, cron, implicit)
+ * over the last 24 hours. No SQLite dependency — when a real SQLite migration
+ * lands we can swap the backend without touching the consumer API.
+ */
+import os from "os";
+import fs from "fs";
+import { resolve, dirname } from "path";
+const DATA_DIR = process.env.ALVIN_DATA_DIR || resolve(os.homedir(), ".alvin-bot");
+const STATS_FILE = resolve(DATA_DIR, "subagent-stats.json");
+const WINDOW_MS = 24 * 60 * 60 * 1000; // 24 hours
+const MAX_ENTRIES = 5000; // hard cap to prevent unbounded growth on high-frequency bots
+let cache = null;
+function load() {
+    if (cache)
+        return cache;
+    try {
+        const raw = fs.readFileSync(STATS_FILE, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed)) {
+            cache = [];
+            return cache;
+        }
+        // Prune stale entries (> 24h old) on load
+        const cutoff = Date.now() - WINDOW_MS;
+        cache = parsed.filter((e) => typeof e === "object" &&
+            e !== null &&
+            typeof e.completedAt === "number" &&
+            e.completedAt >= cutoff);
+        return cache;
+    }
+    catch {
+        cache = [];
+        return cache;
+    }
+}
+function save(entries) {
+    try {
+        fs.mkdirSync(dirname(STATS_FILE), { recursive: true });
+        fs.writeFileSync(STATS_FILE, JSON.stringify(entries, null, 0), "utf-8");
+    }
+    catch (err) {
+        console.error("[subagent-stats] failed to write:", err);
+    }
+}
+/**
+ * Record a completed sub-agent run. Called from runSubAgent.finally() via
+ * a side-effect hook. Automatically prunes entries older than 24h and
+ * keeps the file bounded at MAX_ENTRIES.
+ */
+export function recordSubAgentRun(info, result) {
+    const entries = load();
+    const cutoff = Date.now() - WINDOW_MS;
+    // Prune in-place
+    const pruned = entries.filter((e) => e.completedAt >= cutoff);
+    const newEntry = {
+        completedAt: Date.now(),
+        name: info.name,
+        source: (info.source ?? "implicit"),
+        status: result.status,
+        durationMs: result.duration,
+        inputTokens: result.tokensUsed.input,
+        outputTokens: result.tokensUsed.output,
+    };
+    pruned.push(newEntry);
+    // Enforce hard cap — oldest entries drop first
+    const final = pruned.length > MAX_ENTRIES ? pruned.slice(-MAX_ENTRIES) : pruned;
+    cache = final;
+    save(final);
+}
+/**
+ * Compute a summary of the last 24h of sub-agent runs. Safe to call
+ * concurrently with recordSubAgentRun — both read from the same cache.
+ */
+export function getSubAgentStats() {
+    const entries = load();
+    const cutoff = Date.now() - WINDOW_MS;
+    const recent = entries.filter((e) => e.completedAt >= cutoff);
+    const empty = () => ({
+        runs: 0,
+        inputTokens: 0,
+        outputTokens: 0,
+        totalDurationMs: 0,
+    });
+    const bySource = {
+        user: empty(),
+        cron: empty(),
+        implicit: empty(),
+    };
+    const byStatus = {
+        completed: 0,
+        timeout: 0,
+        error: 0,
+        cancelled: 0,
+    };
+    const total = empty();
+    for (const e of recent) {
+        const bucket = bySource[e.source] ?? bySource.implicit;
+        bucket.runs += 1;
+        bucket.inputTokens += e.inputTokens;
+        bucket.outputTokens += e.outputTokens;
+        bucket.totalDurationMs += e.durationMs;
+        total.runs += 1;
+        total.inputTokens += e.inputTokens;
+        total.outputTokens += e.outputTokens;
+        total.totalDurationMs += e.durationMs;
+        byStatus[e.status] = (byStatus[e.status] ?? 0) + 1;
+    }
+    return { windowHours: 24, total, bySource, byStatus };
+}
+/**
+ * Reset the in-memory cache — for test isolation. Does NOT delete the
+ * file; use ALVIN_DATA_DIR in tests to point at a fresh temp dir.
+ */
+export function __resetStatsCacheForTest() {
+    cache = null;
+}