alvin-bot 4.8.1 → 4.8.3

package/CHANGELOG.md

@@ -2,6 +2,90 @@
 
 All notable changes to Alvin Bot are documented here.
 
+## [4.8.3] — 2026-04-11
+
+### 🐛 Critical: Claude SDK heartbeat false-positive "unavailable"
+
+Caught in production on the Mac mini: the heartbeat monitor was marking `claude-sdk` as unhealthy every 5 minutes, triggering failover to Ollama, even though `claude -p "ping"` from the same user's terminal worked perfectly. After 9 consecutive heartbeat failures, the main Telegram bot was stuck serving responses via Gemma 4 instead of Claude Max.
+
+**Root cause**: `isAvailable()` in the Claude SDK provider used `claude -p "ping" --output-format text` as an auth probe. That command spawns a full SDK query, takes **6-10 seconds warm** (longer on cold starts), and my timeout was only **10 seconds**. Under load or on cold starts it crossed the timeout threshold, was killed by Node, and execFileAsync rejected → caught by the outer try/catch → cached as "unavailable" for 60 seconds → next heartbeat re-probed and failed the same way.
+
+**Fix**: Replaced the `-p "ping"` probe with `claude auth status`. This is a purpose-built Claude CLI command that:
+
+- Completes in ~150 ms (vs 6-10 s)
+- Returns structured JSON with an explicit `loggedIn` boolean
+- Consumes zero tokens
+- Doesn't touch the SDK or model init path
+
+The new code parses the JSON and returns `true` only when `loggedIn === true`. A fallback path keeps the old `-p "ping"` sniff for older Claude CLI versions that don't support `auth status` as JSON.
+
+Before/after the fix:
+
+```
+Before: 6800ms warm probe, 10s timeout, consumed tokens,
+        failed under load → 9 consecutive false-positive "unavailable"
+After:  150ms probe, 5s timeout, no tokens, structured JSON check
+```
+
+### ✨ New CLI command: `alvin-bot status`
+
+Offline-friendly status command — no running bot required. Prints:
+
+- **Version**: `Alvin Bot vX.Y.Z` + Node version + platform/arch
+- **Data dir**: path + whether `.env` exists + configured `PRIMARY_PROVIDER`
+- **Runtime state**:
+  - On macOS: LaunchAgent plist installed? PID from `launchctl list`?
+  - On Linux/Windows: `pm2 jlist` check for the `alvin-bot` process
+- **Live info** (when the bot is running with the web UI on :3100): Uptime, active model
+
+Answers Ali's request: *"alvin-bot status im Terminal soll auch die Version anzeigen"*. The command prominently features the version at the top so it's the first thing you see.
+
+Example:
+
+```
+🤖 Alvin Bot v4.8.3
+   Node v25.9.0 · darwin/arm64
+
+📁 Data dir:  /Users/alvin_de/.alvin-bot
+   .env:      ✅ present
+   Provider:  claude-sdk
+
+🚀 LaunchAgent: installed
+   Running:    ✅ yes (PID 43589)
+   Uptime:     0h 55m
+   Model:      Gemma 4 E4B (Ollama)
+```
+
+### Tests
+
+2 new test cases in `test/claude-sdk-provider.test.ts` cover the new flow:
+
+- `claude auth status` returning `{loggedIn: true}` → `isAvailable()` returns `true`
+- `claude auth status` returning `{loggedIn: false}` → `isAvailable()` returns `false`
+- Older CLI where `auth status` throws → fall back to `-p "ping"` path (preserves old behavior)
+
+87 tests passing (up from 85).
+
+## [4.8.2] — 2026-04-11
+
+### 🐛 Offline setup: wait long enough for Ollama's first-run init
+
+Second follow-up to 4.8.0's offline-gemma4 wizard. The 4.8.1 brew path successfully installs Ollama, but the subsequent `ensureOllamaServe()` was reporting "Could not start Ollama daemon" because it only waited **2 seconds** after spawning the server.
+
+What actually happens on first run:
+
+1. `nohup ollama serve &` spawns the server process
+2. Server generates a fresh SSH keypair at `~/.ollama/id_ed25519` (~1 s)
+3. Server discovers GPUs — on Apple Silicon this initializes Metal (~5 s)
+4. Server starts the runner subprocess (~1 s)
+5. Server begins listening on `127.0.0.1:11434`
+
+Total cold-start time: **5–15 seconds**. The old 2-second wait was racing ahead of GPU discovery and failing the next `ollama list` call.
+
+Fix: `ensureOllamaServe()` now polls `ollama list` every second for up to **30 seconds**. On success it reports which attempt worked (for visibility). On failure it dumps the last 15 lines of `/tmp/ollama-setup.log` so users can see what Ollama itself said.
+
+Caught during the second run of the setup wizard on the fresh test MacBook — brew install succeeded, daemon was actually running (PID confirmed via pgrep), but the wizard bailed out anyway because it gave up too soon.
+
 ## [4.8.1] — 2026-04-11
 
 ### 🐛 Offline setup: Homebrew preferred on macOS

package/bin/cli.js

@@ -219,28 +219,53 @@ function installOllama() {
 }
 
 /**
- * Ensure the Ollama daemon is running. Spawns it in the background if not.
+ * Ensure the Ollama daemon is running. Spawns it in the background if not,
+ * then polls for readiness — first-run initialization can take 5-15 seconds
+ * on macOS (SSH key generation + GPU discovery + runner startup).
  */
 function ensureOllamaServe() {
+  // Fast path: already running
   try {
-    // 'ollama list' needs the daemon running
     execSync("ollama list", { stdio: "pipe", timeout: 5000 });
     return true;
-  } catch {
-    // Daemon not running — spawn it
+  } catch { /* not running — try to start */ }
+
+  // Spawn in background (detached via `&` inside a shell)
+  try {
+    execSync("nohup ollama serve > /tmp/ollama-setup.log 2>&1 &", {
+      stdio: "pipe",
+      shell: "/bin/sh",
+    });
+  } catch (err) {
+    console.log(`\n  ⚠️  Could not spawn 'ollama serve': ${err.message || err}`);
+    return false;
+  }
+
+  // Poll for readiness — up to 30 seconds total. First-run init is slow
+  // because ollama generates an SSH key pair, discovers GPUs, and starts
+  // the runner subprocess.
+  const deadlineMs = Date.now() + 30_000;
+  let lastError = "";
+  let attempt = 0;
+  while (Date.now() < deadlineMs) {
+    attempt++;
     try {
-      execSync("nohup ollama serve > /tmp/ollama-setup.log 2>&1 &", {
-        stdio: "pipe",
-        shell: "/bin/sh",
-      });
-      // Give it a moment
-      execSync("sleep 2", { stdio: "pipe" });
       execSync("ollama list", { stdio: "pipe", timeout: 5000 });
+      if (attempt > 1) console.log(`  ✅ Ollama daemon ready after ${attempt} attempts`);
       return true;
-    } catch {
-      return false;
+    } catch (err) {
+      lastError = err instanceof Error ? err.message : String(err);
     }
+    // Sleep 1 second between polls via execSync (cross-platform, no promise in sync ctx)
+    try { execSync("sleep 1", { stdio: "pipe" }); } catch { /* shouldn't fail */ }
   }
+  console.log(`  ⚠️  Daemon did not become ready within 30s. Last error: ${lastError}`);
+  console.log(`     Tail of /tmp/ollama-setup.log:`);
+  try {
+    const tail = execSync("tail -15 /tmp/ollama-setup.log", { encoding: "utf-8" });
+    tail.split("\n").forEach((line) => console.log(`       ${line}`));
+  } catch { /* log missing */ }
+  return false;
 }
 
 /**
@@ -1822,6 +1847,86 @@ switch (cmd) {
   case "-v":
     version();
     break;
+  case "status": {
+    // CLI `alvin-bot status` — quick, offline-friendly status without
+    // requiring a running bot. Prints version, node info, data dir,
+    // configured provider, and — on macOS — LaunchAgent state.
+    try {
+      const pkg = JSON.parse(
+        readFileSync(resolve(import.meta.dirname || ".", "../package.json"), "utf-8"),
+      );
+      console.log(`\n🤖 Alvin Bot v${pkg.version}`);
+    } catch {
+      console.log("\n🤖 Alvin Bot (version unknown)");
+    }
+    console.log(`   Node ${process.version} · ${process.platform}/${process.arch}`);
+    console.log("");
+
+    // Data dir + .env
+    const envPath = join(DATA_DIR, ".env");
+    console.log(`📁 Data dir:  ${DATA_DIR}`);
+    console.log(`   .env:      ${existsSync(envPath) ? "✅ present" : "❌ missing"}`);
+
+    // Primary provider from .env
+    if (existsSync(envPath)) {
+      try {
+        const env = readFileSync(envPath, "utf-8");
+        const match = env.match(/^PRIMARY_PROVIDER=(.+)$/m);
+        if (match) console.log(`   Provider:  ${match[1].trim()}`);
+      } catch { /* ignore */ }
+    }
+    console.log("");
+
+    // Runtime state: LaunchAgent (macOS) or pm2 (Linux/Windows)
+    if (process.platform === "darwin") {
+      const { plistPath, label } = launchdPaths();
+      const plistExists = existsSync(plistPath);
+      console.log(`🚀 LaunchAgent: ${plistExists ? "installed" : "not installed"}`);
+      if (plistExists) {
+        try {
+          const out = execSync(`launchctl list | grep ${label} || true`, { encoding: "utf-8" });
+          if (out.trim()) {
+            const parts = out.trim().split(/\s+/);
+            const pid = parts[0];
+            const isRunning = pid !== "-" && pid !== "0";
+            console.log(`   Running:    ${isRunning ? `✅ yes (PID ${pid})` : "❌ no"}`);
+          } else {
+            console.log(`   Running:    ❌ not loaded`);
+          }
+        } catch {
+          console.log(`   Running:    ❌ unknown`);
+        }
+      }
+    } else {
+      // Linux/Windows: check pm2
+      try {
+        const out = execSync("pm2 jlist 2>/dev/null || echo '[]'", { encoding: "utf-8" });
+        const procs = JSON.parse(out);
+        const alvin = procs.find?.((p) => p && p.name === "alvin-bot");
+        if (alvin) {
+          console.log(`🚀 pm2:         ${alvin.pm2_env?.status || "unknown"} (PID ${alvin.pid || "?"})`);
+        } else {
+          console.log(`🚀 pm2:         alvin-bot not managed`);
+        }
+      } catch {
+        console.log(`🚀 pm2:         not installed`);
+      }
+    }
+
+    // Try to reach the running web API for live info
+    try {
+      const apiRes = execSync("curl -fsS -m 2 http://localhost:3100/api/status 2>/dev/null", { encoding: "utf-8" });
+      const parsed = JSON.parse(apiRes);
+      const uptimeSec = Math.floor(parsed.bot?.uptime || 0);
+      const h = Math.floor(uptimeSec / 3600);
+      const m = Math.floor((uptimeSec % 3600) / 60);
+      console.log(`   Uptime:     ${h}h ${m}m`);
+      if (parsed.model?.name) console.log(`   Model:      ${parsed.model.name}`);
+    } catch { /* bot not running or web ui off — skip */ }
+
+    console.log("");
+    process.exit(0);
+  }
   default:
     console.log(`
 ${t("cli.title")}
@@ -1837,6 +1942,7 @@ ${t("cli.commands")}
   start     ${t("cli.startDesc")} (background via PM2)
   start -f  Start in foreground (for debugging)
   stop      Stop the bot
+  status    Show bot version + LaunchAgent/pm2 state (offline)
   launchd   macOS only: install/uninstall/status as launchd user agent
   version   ${t("cli.versionDesc")}
 

package/dist/providers/claude-sdk-provider.js

@@ -237,19 +237,42 @@ export class ClaudeSDKProvider {
             if (!claudePath)
                 return cache(false);
             // Step 1: binary exists?
-            // Async execFile doesn't block the event loop. 5s timeout kills
-            // runaway probes without hanging the bot.
             await execFileAsync(claudePath, ["--version"], { timeout: 5000 });
-            // Step 2: actually authenticated? The Claude Agent SDK shares the
-            // same OAuth token as the CLI — if `claude -p` says "Not logged in",
-            // the SDK will fail too. Probe with a trivial -p call and surface
-            // the failure before the registry hands a request to a broken
-            // provider.
-            const { stdout } = await execFileAsync(claudePath, ["-p", "ping", "--output-format", "text"], { timeout: 10000 });
-            if (isAuthErrorOutput(stdout)) {
+            // Step 2: actually authenticated?
+            //
+            // We used to use `claude -p "ping" --output-format text` and sniff
+            // the stdout for "Not logged in". That spawned a full SDK query,
+            // consumed tokens, and took 5-10 seconds warm — occasionally
+            // crossing our timeout on cold starts or under load, leading to
+            // false-positive "unavailable" reports that cascaded into heartbeat
+            // failures and unnecessary fallback to Ollama.
+            //
+            // `claude auth status` is the purpose-built command: fast (~150ms),
+            // no token cost, no SDK init, returns structured JSON with an
+            // explicit `loggedIn` boolean. Much cleaner.
+            try {
+                const { stdout } = await execFileAsync(claudePath, ["auth", "status"], { timeout: 5000 });
+                const parsed = JSON.parse(stdout);
+                if (parsed.loggedIn === true) {
+                    return cache(true);
+                }
+                // loggedIn === false (or missing) — not authenticated
                 return cache(false);
             }
-            return cache(true);
+            catch (authErr) {
+                // Older claude CLI versions may not expose `auth status` as JSON,
+                // or may exit non-zero when not logged in. Fall back to the
+                // sniff-stdout approach for backward compat.
+                try {
+                    const { stdout: probeOut } = await execFileAsync(claudePath, ["-p", "ping", "--output-format", "text"], { timeout: 15000 });
+                    return cache(!isAuthErrorOutput(probeOut));
+                }
+                catch {
+                    // Both checks failed — treat as unavailable
+                    void authErr;
+                    return cache(false);
+                }
+            }
         }
         catch {
             return cache(false);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alvin-bot",
-  "version": "4.8.1",
+  "version": "4.8.3",
   "description": "Alvin Bot — Your personal AI agent on Telegram, WhatsApp, Discord, Signal, and Web.",
   "type": "module",
   "main": "dist/index.js",

package/test/claude-sdk-provider.test.ts

@@ -25,15 +25,39 @@ describe("ClaudeSDKProvider.isAvailable", () => {
     vi.resetModules();
   });
 
-  it("returns false when `claude -p` returns 'Not logged in'", async () => {
-    // First call: --version succeeds
-    // Second call: -p 'ping' returns "Not logged in · Please run /login"
+  it("returns true when `claude auth status` reports loggedIn: true", async () => {
+    // Sequence: --version then auth status (JSON)
     execFileMock
       .mockImplementationOnce((_p, _a, _o, cb) =>
         cb(null, { stdout: "1.0.0\n", stderr: "" }),
       )
       .mockImplementationOnce((_p, _a, _o, cb) =>
-        cb(null, { stdout: "Not logged in · Please run /login", stderr: "" }),
+        cb(null, {
+          stdout: JSON.stringify({
+            loggedIn: true,
+            authMethod: "claude.ai",
+            subscriptionType: "max",
+          }),
+          stderr: "",
+        }),
+      );
+
+    const { ClaudeSDKProvider } = await import("../src/providers/claude-sdk-provider.js");
+    const p = new ClaudeSDKProvider();
+    const result = await p.isAvailable();
+    expect(result).toBe(true);
+  });
+
+  it("returns false when `claude auth status` reports loggedIn: false", async () => {
+    execFileMock
+      .mockImplementationOnce((_p, _a, _o, cb) =>
+        cb(null, { stdout: "1.0.0\n", stderr: "" }),
+      )
+      .mockImplementationOnce((_p, _a, _o, cb) =>
+        cb(null, {
+          stdout: JSON.stringify({ loggedIn: false }),
+          stderr: "",
+        }),
       );
 
     const { ClaudeSDKProvider } = await import("../src/providers/claude-sdk-provider.js");
@@ -42,11 +66,15 @@ describe("ClaudeSDKProvider.isAvailable", () => {
     expect(result).toBe(false);
   });
 
-  it("returns true when `claude -p` returns a normal response", async () => {
+  it("falls back to `claude -p` probe when `auth status` fails (older CLI)", async () => {
+    // Sequence: --version → auth status rejects → -p ping succeeds
     execFileMock
       .mockImplementationOnce((_p, _a, _o, cb) =>
         cb(null, { stdout: "1.0.0\n", stderr: "" }),
       )
+      .mockImplementationOnce((_p, _a, _o, cb) =>
+        cb(new Error("unknown command: auth status"), { stdout: "", stderr: "" }),
+      )
       .mockImplementationOnce((_p, _a, _o, cb) =>
         cb(null, { stdout: "pong", stderr: "" }),
       );
@@ -56,6 +84,24 @@ describe("ClaudeSDKProvider.isAvailable", () => {
     const result = await p.isAvailable();
     expect(result).toBe(true);
   });
+
+  it("falls back to `claude -p` probe and detects 'Not logged in' text", async () => {
+    execFileMock
+      .mockImplementationOnce((_p, _a, _o, cb) =>
+        cb(null, { stdout: "1.0.0\n", stderr: "" }),
+      )
+      .mockImplementationOnce((_p, _a, _o, cb) =>
+        cb(new Error("auth status not supported"), { stdout: "", stderr: "" }),
+      )
+      .mockImplementationOnce((_p, _a, _o, cb) =>
+        cb(null, { stdout: "Not logged in · Please run /login", stderr: "" }),
+      );
+
+    const { ClaudeSDKProvider } = await import("../src/providers/claude-sdk-provider.js");
+    const p = new ClaudeSDKProvider();
+    const result = await p.isAvailable();
+    expect(result).toBe(false);
+  });
 });
 
 describe("ClaudeSDKProvider — isAuthErrorOutput helper", () => {