alvin-bot 4.5.0 → 4.6.0

package/dist/services/updater.js

@@ -0,0 +1,158 @@
+/**
+ * Updater Service — git-based self-update for alvin-bot.
+ *
+ * Provides:
+ *   - runUpdate(): manual update (git pull + install + build)
+ *   - getAutoUpdate() / setAutoUpdate(): persistent on/off toggle
+ *   - startAutoUpdateLoop(): periodic check every 6h if enabled
+ *
+ * After a successful update that produces new artifacts, the bot calls
+ * process.exit(0) and PM2 auto-restarts it with fresh code. This is the
+ * only safe self-restart path — we never re-exec the Node process directly.
+ *
+ * The auto-update flag is persisted to ~/.alvin-bot/auto-update.flag
+ * (a plain text file containing "on" or "off"), so it survives restarts.
+ */
+import { exec } from "child_process";
+import { promisify } from "util";
+import { resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+import fs from "fs";
+import os from "os";
+const execAsync = promisify(exec);
+const PROJECT_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "../..");
+const DATA_DIR = process.env.ALVIN_DATA_DIR || resolve(os.homedir(), ".alvin-bot");
+const FLAG_FILE = resolve(DATA_DIR, "auto-update.flag");
+const AUTO_CHECK_INTERVAL_MS = 6 * 60 * 60 * 1000; // 6 hours
+let autoTimer = null;
+async function isGitRepo() {
+    try {
+        const { stdout } = await execAsync("git rev-parse --is-inside-work-tree", {
+            cwd: PROJECT_ROOT,
+            timeout: 5_000,
+        });
+        return stdout.trim() === "true";
+    }
+    catch {
+        return false;
+    }
+}
+/** Pull latest changes, install deps, rebuild. Returns a structured result
+ * instead of throwing so the /update command can report cleanly to Telegram. */
+export async function runUpdate() {
+    try {
+        const isRepo = await isGitRepo();
+        if (!isRepo) {
+            return {
+                ok: false,
+                message: "Not in a git repo — update only supported for source installs.",
+                requiresRestart: false,
+            };
+        }
+        // Fetch latest without merging
+        await execAsync("git fetch --quiet", {
+            cwd: PROJECT_ROOT,
+            timeout: 30_000,
+        });
+        // Count commits we're behind the upstream
+        let behindCount = 0;
+        try {
+            const { stdout } = await execAsync("git rev-list --count HEAD..@{upstream}", {
+                cwd: PROJECT_ROOT,
+                timeout: 10_000,
+            });
+            behindCount = parseInt(stdout.trim() || "0", 10);
+        }
+        catch {
+            // No upstream configured — treat as up-to-date
+            behindCount = 0;
+        }
+        if (behindCount === 0) {
+            return {
+                ok: true,
+                message: "Already up to date — no new commits.",
+                requiresRestart: false,
+            };
+        }
+        // Fast-forward pull (refuses to merge if history diverged)
+        await execAsync("git pull --ff-only", {
+            cwd: PROJECT_ROOT,
+            timeout: 60_000,
+        });
+        // Install (frozen lockfile to match upstream exactly)
+        await execAsync("pnpm install --frozen-lockfile", {
+            cwd: PROJECT_ROOT,
+            timeout: 180_000,
+        });
+        // Build
+        await execAsync("pnpm run build", {
+            cwd: PROJECT_ROOT,
+            timeout: 180_000,
+        });
+        return {
+            ok: true,
+            message: `Installed ${behindCount} commit(s), build successful.`,
+            requiresRestart: true,
+        };
+    }
+    catch (err) {
+        const raw = err instanceof Error ? err.message : String(err);
+        // Keep error messages short — Telegram has a 4096 char limit and the
+        // user doesn't need a 50-line stack trace.
+        const message = raw.length > 300 ? raw.slice(0, 300) + "…" : raw;
+        return { ok: false, message, requiresRestart: false };
+    }
+}
+export function getAutoUpdate() {
+    try {
+        if (!fs.existsSync(FLAG_FILE))
+            return false;
+        return fs.readFileSync(FLAG_FILE, "utf-8").trim() === "on";
+    }
+    catch {
+        return false;
+    }
+}
+export function setAutoUpdate(enabled) {
+    try {
+        fs.mkdirSync(dirname(FLAG_FILE), { recursive: true });
+        fs.writeFileSync(FLAG_FILE, enabled ? "on" : "off", "utf-8");
+        if (enabled) {
+            startAutoUpdateLoop();
+        }
+        else {
+            stopAutoUpdateLoop();
+        }
+    }
+    catch (err) {
+        console.error("[auto-update] setAutoUpdate failed:", err);
+    }
+}
+export function startAutoUpdateLoop() {
+    if (autoTimer)
+        return;
+    if (!getAutoUpdate())
+        return;
+    autoTimer = setInterval(async () => {
+        const result = await runUpdate();
+        if (result.ok && result.requiresRestart) {
+            console.log(`[auto-update] ${result.message} — exiting for PM2 restart`);
+            // Small delay so any in-flight log write completes
+            setTimeout(() => process.exit(0), 1_000);
+        }
+        else if (result.ok) {
+            // up-to-date, no-op
+        }
+        else {
+            console.log(`[auto-update] check failed: ${result.message}`);
+        }
+    }, AUTO_CHECK_INTERVAL_MS);
+    console.log(`[auto-update] loop started (interval: 6h)`);
+}
+export function stopAutoUpdateLoop() {
+    if (autoTimer) {
+        clearInterval(autoTimer);
+        autoTimer = null;
+        console.log(`[auto-update] loop stopped`);
+    }
+}

package/dist/services/usage-tracker.js

@@ -92,14 +92,21 @@ export function getUsageSummary() {
         }
     }
     const totalDays = Object.keys(data.daily).length;
-    const allTokens = Object.values(data.daily).reduce((s, d) => s + d.inputTokens + d.outputTokens, 0);
-    const allCost = Object.values(data.daily).reduce((s, d) => s + d.costUsd, 0);
+    // Average is computed over the same 7-day window as `week` so it
+    // stays internally consistent: a user reading "Week: 250M" directly
+    // above "Avg: 50M/day" would otherwise rightly assume 50×7=350 and
+    // conclude the bot was lying. Previously the avg was total-ever/days-ever
+    // which diverged from week/7 as soon as usage was uneven or the bot
+    // was only a few days old.
+    const weekTokens = weekStats.inputTokens + weekStats.outputTokens;
+    const avgTokensPerDay = Math.round(weekTokens / 7);
+    const avgCostPerDay = weekStats.costUsd / 7;
     return {
         today: todayStats,
         week: weekStats,
         daysTracked: totalDays,
-        avgDailyTokens: totalDays > 0 ? Math.round(allTokens / totalDays) : 0,
-        avgDailyCost: totalDays > 0 ? allCost / totalDays : 0,
+        avgDailyTokens: avgTokensPerDay,
+        avgDailyCost: avgCostPerDay,
     };
 }
 /** Store rate limit info from provider response headers. */

package/dist/services/users.js

@@ -12,6 +12,7 @@
 import fs from "fs";
 import { resolve } from "path";
 import { config } from "../config.js";
+import { LOCALE_NAMES } from "../i18n.js";
 import { killSession } from "./session.js";
 import { USERS_DIR, MEMORY_DIR } from "../paths.js";
 // Ensure users dir exists
@@ -190,7 +191,7 @@ export function buildUserContext(userId) {
         return "";
     const parts = [];
     parts.push(`User: ${profile.name}${profile.username ? ` (@${profile.username})` : ""}`);
-    parts.push(`Language: ${profile.language === "de" ? "Deutsch" : "English"}`);
+    parts.push(`Language: ${LOCALE_NAMES[profile.language] || profile.language}`);
     parts.push(`Messages: ${profile.totalMessages}`);
     if (profile.notes) {
         parts.push(`\nNotes about this user:\n${profile.notes}`);

package/dist/tui/index.js

@@ -105,27 +105,25 @@ function drawHeader() {
     console.log(`${C.gray}${"─".repeat(w)}${C.reset}`);
 }
 /**
- * Redraw the header in place. Only safe to call when NOT streaming —
- * the previous implementation used aggressive cursor save/restore escape
- * sequences that collided with readline's internal cursor state and
- * produced garbled output. Now this is a no-op during streaming and
- * a clean redraw otherwise.
+ * Redraw the header. The old "in-place" implementation used cursor save/
+ * restore escape sequences and jumped to \x1b[H — but once the terminal
+ * has scrolled past the original header, \x1b[H resolves to the current
+ * viewport top (not the document top), which means the header gets
+ * re-rendered inline in the middle of the content. That's what produced
+ * the "header appears in the middle of the bot response" bug in 4.5.0.
+ *
+ * The only safe way to redraw the header in a scrolling terminal is to
+ * clear the whole screen and redraw from scratch. Do that only in
+ * explicit reset contexts (/clear, SIGWINCH resize, initial connect).
+ * For mid-session cost/status updates, use inline info messages instead.
  */
-function redrawHeader() {
+function redrawHeader(opts = {}) {
     if (isStreaming)
-        return; // Don't touch the cursor mid-stream
-    clearCurrentLine();
-    process.stdout.write("\x1b[s"); // Save cursor
-    process.stdout.write("\x1b[H"); // Move to top-left
-    for (let i = 0; i < HEADER_LINES; i++) {
-        cursorTo(process.stdout, 0);
-        rlClearLine(process.stdout, 0);
-        if (i < HEADER_LINES - 1)
-            process.stdout.write("\x1b[1B");
+        return;
+    if (opts.clearScreen) {
+        console.clear();
     }
-    process.stdout.write("\x1b[H");
     drawHeader();
-    process.stdout.write("\x1b[u"); // Restore cursor
     if (rl && !isStreaming)
         rl.prompt(true);
 }
@@ -222,7 +220,8 @@ function connectWebSocket() {
     ws = new WebSocket(wsUrl);
     ws.on("open", () => {
         connected = true;
-        redrawHeader();
+        // No header redraw here — the header was already drawn at startTUI().
+        // Calling redrawHeader() in a scrolled terminal re-renders it inline.
         printInfo(t("tui.connectedTo"));
         showPrompt();
     });
@@ -236,7 +235,7 @@ function connectWebSocket() {
     ws.on("close", () => {
         connected = false;
         isStreaming = false;
-        redrawHeader();
+        // No header redraw — it would appear inline mid-chat.
         printError(t("tui.connectionLost"));
         setTimeout(connectWebSocket, 3000);
     });
@@ -279,7 +278,10 @@ function handleMessage(msg) {
             isStreaming = false;
             currentResponse = "";
             currentToolName = "";
-            redrawHeader(); // Update cost in header (only if not streaming — see redrawHeader)
+            // NOTE: do NOT call redrawHeader() here. On a scrolled terminal it
+            // renders the header inline at the viewport top, which looks like
+            // the header appeared in the middle of the conversation. The total
+            // cost is already shown inline at the end of each response.
             showPrompt();
             break;
         case "error":
@@ -395,7 +397,8 @@ async function handleCommand(cmd) {
                     if (res.ok) {
                         currentModel = res.active || parts[1];
                         printSuccess(`${t("tui.switchedTo")}: ${currentModel}`);
-                        redrawHeader();
+                        // Header stays as-is (would appear inline otherwise) —
+                        // next /clear redraws it with the new model.
                     }
                     else {
                         printError(res.error || t("tui.switchError"));
@@ -508,10 +511,15 @@ async function handleCommand(cmd) {
         }
         case "clear":
         case "c":
-            console.clear();
-            drawHeader();
+            // /clear is the ONLY command that safely redraws the header, because
+            // it wipes the entire screen first.
+            redrawHeader({ clearScreen: true });
             if (ws?.readyState === WebSocket.OPEN) {
-                ws.send(JSON.stringify({ type: "reset" }));
+                ws.send(JSON.stringify({
+                    type: "reset",
+                    target: activeTarget,
+                    sessionKey: activeTarget === "tui" ? tuiSessionKey : undefined,
+                }));
             }
             break;
         case "target":
@@ -520,12 +528,10 @@ async function handleCommand(cmd) {
             if (val === "tui") {
                 activeTarget = "tui";
                 printSuccess("Target: TUI (your own isolated session)");
-                redrawHeader();
             }
             else if (val === "telegram" || val === "tel") {
                 activeTarget = "telegram";
                 printSuccess("Target: Telegram (your messages now go into the Telegram session — the bot replies in Telegram AND here)");
-                redrawHeader();
             }
             else {
                 printInfo(`Current target: ${activeTarget}. Use /target tui or /target telegram.`);
@@ -639,12 +645,12 @@ export async function startTUI() {
     // mode on top of that causes every keystroke to be echoed TWICE (once by
     // the terminal, once by readline's line editor) — producing the classic
     // "hheelllloo" double-echo bug. Let readline manage the tty mode itself.
-    // Handle terminal resize — redraw header to fit the new width.
+    // Handle terminal resize — we can't safely redraw the header in place
+    // on a scrolled buffer. Just re-render the prompt so readline picks up
+    // the new width for its line editor.
     process.stdout.on("resize", () => {
-        if (!isStreaming) {
-            redrawHeader();
+        if (!isStreaming)
             showPrompt();
-        }
     });
     await fetchInitialModel();
     connectWebSocket();