alvin-bot 4.5.1 → 4.7.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}`);