alvin-bot 4.12.4 → 4.13.1

package/dist/services/process-manager.js

@@ -0,0 +1,291 @@
+/**
+ * v4.13.1 — Process manager abstraction for the Maintenance Web UI.
+ *
+ * History: the bot was originally PM2-managed. Since v4.8 the macOS
+ * install uses launchd (`com.alvinbot.app.plist`). The WebUI
+ * Maintenance section kept calling `pm2 jlist`/`pm2 restart`/...
+ * which returned "PM2 not available" for launchd users — all status,
+ * stop, start, and logs buttons were broken.
+ *
+ * This module auto-detects the active manager per request and
+ * routes commands accordingly:
+ *
+ *   - launchd (macOS) — via `launchctl print` / `bootout` / `bootstrap`
+ *   - pm2 (VPS / Linux) — via `pm2 jlist` / `pm2 stop` / `pm2 start`
+ *   - standalone — no supervisor; only `scheduleGracefulRestart` works
+ *
+ * Restart is NOT on this interface — it always uses
+ * `scheduleGracefulRestart` (Grammy-safe) and relies on whichever
+ * supervisor is present to bring the process back. For "standalone",
+ * a restart effectively kills the process and the user has to run it
+ * again manually (we warn in the UI).
+ */
+import { execSync } from "node:child_process";
+import os from "node:os";
+import { resolve } from "node:path";
+const LAUNCHD_LABEL = "com.alvinbot.app";
+const LAUNCHD_PLIST = resolve(os.homedir(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
+const PM2_NAME = "alvin-bot";
+// ── Detection ───────────────────────────────────────────────────
+export function detectProcessManager(opts = {}) {
+    const platform = opts.platform ?? process.platform;
+    const uid = opts.uid ?? (typeof process.getuid === "function" ? process.getuid() : 0);
+    // Only try launchd on macOS
+    if (platform === "darwin") {
+        try {
+            const out = execSync(`launchctl print gui/${uid}/${LAUNCHD_LABEL}`, { encoding: "utf-8", timeout: 3000, stdio: "pipe" });
+            if (out && out.length > 0) {
+                return createLaunchdManager(uid);
+            }
+        }
+        catch {
+            // Not loaded in launchd — fall through
+        }
+    }
+    // PM2 fallback (Linux VPS, or Mac installs that stayed on PM2)
+    try {
+        const out = execSync("pm2 jlist", {
+            encoding: "utf-8",
+            timeout: 3000,
+            stdio: "pipe",
+        });
+        const parsed = JSON.parse(out);
+        if (Array.isArray(parsed) &&
+            parsed.some((p) => p?.name === PM2_NAME)) {
+            return createPm2Manager();
+        }
+    }
+    catch {
+        // pm2 not installed or didn't report our process
+    }
+    return createStandaloneManager();
+}
+function parseLaunchdPrint(text) {
+    const out = {};
+    // state = running
+    const stateMatch = text.match(/\bstate\s*=\s*(\S+)/);
+    if (stateMatch)
+        out.state = stateMatch[1];
+    // pid = 12345
+    const pidMatch = text.match(/\bpid\s*=\s*(\d+)/);
+    if (pidMatch)
+        out.pid = Number(pidMatch[1]);
+    // program = /path/to/node
+    const programMatch = text.match(/\bprogram\s*=\s*(\S+)/);
+    if (programMatch)
+        out.program = programMatch[1];
+    // working directory = /path
+    const cwdMatch = text.match(/\bworking directory\s*=\s*(\S+)/);
+    if (cwdMatch)
+        out.cwd = cwdMatch[1];
+    return out;
+}
+export function createLaunchdManager(uid) {
+    const service = `gui/${uid}/${LAUNCHD_LABEL}`;
+    return {
+        kind: "launchd",
+        async getStatus() {
+            try {
+                const out = execSync(`launchctl print ${service}`, {
+                    encoding: "utf-8",
+                    timeout: 3000,
+                    stdio: "pipe",
+                });
+                const parsed = parseLaunchdPrint(out);
+                const pid = parsed.pid;
+                // Enrich with ps info if we have a PID
+                let memory;
+                let cpu;
+                let uptime;
+                if (pid) {
+                    try {
+                        // ps output: %cpu %mem rss etime
+                        const psOut = execSync(`ps -p ${pid} -o %cpu=,%mem=,rss=,etime=`, { encoding: "utf-8", timeout: 2000, stdio: "pipe" }).trim();
+                        const [cpuStr, , rssStr, etime] = psOut.split(/\s+/);
+                        cpu = parseFloat(cpuStr) || 0;
+                        memory = (parseInt(rssStr, 10) || 0) * 1024; // rss is kB
+                        uptime = parseEtimeToMs(etime);
+                    }
+                    catch {
+                        /* ps may fail if pid vanished — ignore */
+                    }
+                }
+                return {
+                    kind: "launchd",
+                    status: parsed.state === "running" ? "running" : parsed.state || "unknown",
+                    pid,
+                    uptime,
+                    memory,
+                    cpu,
+                    execPath: parsed.program,
+                    cwd: parsed.cwd,
+                    nodeVersion: process.version,
+                };
+            }
+            catch {
+                return { kind: "launchd", status: "not-loaded" };
+            }
+        },
+        async stop() {
+            // bootout removes the service from the domain, which stops it
+            // and disables KeepAlive until bootstrap is run again.
+            execSync(`launchctl bootout ${service}`, {
+                encoding: "utf-8",
+                timeout: 5000,
+                stdio: "pipe",
+            });
+        },
+        async start() {
+            // bootstrap re-registers the plist with the domain.
+            execSync(`launchctl bootstrap gui/${uid} ${JSON.stringify(LAUNCHD_PLIST).slice(1, -1)}`, { encoding: "utf-8", timeout: 5000, stdio: "pipe" });
+        },
+        async getLogs(lines = 30) {
+            // launchd redirects stdout/stderr to files — just tail them.
+            const logDir = resolve(process.env.ALVIN_DATA_DIR || resolve(os.homedir(), ".alvin-bot"), "logs");
+            const outLog = resolve(logDir, "alvin-bot.out.log");
+            const errLog = resolve(logDir, "alvin-bot.err.log");
+            try {
+                return execSync(`tail -n ${lines} ${outLog} ${errLog} 2>/dev/null`, {
+                    encoding: "utf-8",
+                    timeout: 3000,
+                    stdio: "pipe",
+                });
+            }
+            catch {
+                return "No logs available.";
+            }
+        },
+    };
+}
+function parseEtimeToMs(etime) {
+    // ps etime format: "MM:SS", "HH:MM:SS", "D-HH:MM:SS"
+    if (!etime)
+        return undefined;
+    const parts = etime.split("-");
+    let days = 0;
+    let hms;
+    if (parts.length === 2) {
+        days = parseInt(parts[0], 10) || 0;
+        hms = parts[1];
+    }
+    else {
+        hms = parts[0];
+    }
+    const bits = hms.split(":").map((x) => parseInt(x, 10) || 0);
+    let h = 0, m = 0, s = 0;
+    if (bits.length === 3)
+        [h, m, s] = bits;
+    else if (bits.length === 2)
+        [m, s] = bits;
+    else
+        return undefined;
+    return (((days * 24 + h) * 60 + m) * 60 + s) * 1000;
+}
+export function createPm2Manager() {
+    return {
+        kind: "pm2",
+        async getStatus() {
+            try {
+                const out = execSync("pm2 jlist", {
+                    encoding: "utf-8",
+                    timeout: 3000,
+                    stdio: "pipe",
+                });
+                const procs = JSON.parse(out);
+                const me = procs.find((p) => p.name === PM2_NAME);
+                if (!me) {
+                    return { kind: "pm2", status: "unknown" };
+                }
+                const env = me.pm2_env ?? {};
+                return {
+                    kind: "pm2",
+                    status: env.status || "unknown",
+                    pid: me.pid,
+                    uptime: env.pm_uptime ? Date.now() - env.pm_uptime : undefined,
+                    memory: me.monit?.memory,
+                    cpu: me.monit?.cpu,
+                    restarts: env.restart_time ?? 0,
+                    version: env.version,
+                    nodeVersion: env.node_version || process.version,
+                    execPath: env.pm_exec_path,
+                    cwd: env.pm_cwd,
+                };
+            }
+            catch {
+                return { kind: "pm2", status: "unknown" };
+            }
+        },
+        async stop() {
+            execSync(`pm2 stop ${PM2_NAME}`, {
+                encoding: "utf-8",
+                timeout: 10_000,
+                stdio: "pipe",
+            });
+        },
+        async start() {
+            execSync(`pm2 start ${PM2_NAME}`, {
+                encoding: "utf-8",
+                timeout: 10_000,
+                stdio: "pipe",
+            });
+        },
+        async getLogs(lines = 30) {
+            try {
+                const raw = execSync(`pm2 logs ${PM2_NAME} --nostream --lines ${lines} 2>&1`, {
+                    encoding: "utf-8",
+                    timeout: 5000,
+                    stdio: "pipe",
+                    env: { ...process.env, FORCE_COLOR: "0", NO_COLOR: "1" },
+                });
+                // eslint-disable-next-line no-control-regex
+                return raw.replace(/\x1b\[[0-9;]*m/g, "");
+            }
+            catch {
+                return "No logs available.";
+            }
+        },
+    };
+}
+// ── standalone ──────────────────────────────────────────────────
+export function createStandaloneManager() {
+    return {
+        kind: "standalone",
+        async getStatus() {
+            return {
+                kind: "standalone",
+                status: "running",
+                pid: process.pid,
+                uptime: process.uptime() * 1000,
+                memory: process.memoryUsage().rss,
+                nodeVersion: process.version,
+                execPath: process.execPath,
+                cwd: process.cwd(),
+            };
+        },
+        async stop() {
+            // No supervisor — just exit. User must restart manually.
+            setTimeout(() => process.exit(0), 300);
+        },
+        async start() {
+            // Cannot start ourselves if we're already running (nonsensical).
+            // Callers should not hit this path when status is "running".
+            throw new Error("standalone: cannot 'start' — no supervisor. Run the bot manually.");
+        },
+        async getLogs(lines = 30) {
+            // Standalone mode may or may not redirect stdout. Try the
+            // default ~/.alvin-bot/logs path first.
+            const logDir = resolve(process.env.ALVIN_DATA_DIR || resolve(os.homedir(), ".alvin-bot"), "logs");
+            const outLog = resolve(logDir, "alvin-bot.out.log");
+            try {
+                return execSync(`tail -n ${lines} ${outLog} 2>/dev/null`, {
+                    encoding: "utf-8",
+                    timeout: 3000,
+                    stdio: "pipe",
+                });
+            }
+            catch {
+                return "No logs available (standalone mode — stdout not captured).";
+            }
+        },
+    };
+}

package/dist/web/doctor-api.js

@@ -491,42 +491,42 @@ export async function handleDoctorAPI(req, res, urlPath, body) {
         scheduleGracefulRestart(500);
         return true;
     }
-    // ── PM2 Process Control ────────────────────────────────
-    // GET /api/pm2/status — Get PM2 process info
+    // ── Process Control (v4.13.1: launchd/pm2/standalone auto-detect) ──
+    //
+    // Routes kept under `/api/pm2/*` for UI compat — the UI still calls
+    // those paths. Under the hood we now use the process-manager
+    // abstraction which auto-detects launchd (macOS native installs)
+    // or pm2 (VPS / legacy Mac installs) or standalone (neither).
+    // GET /api/pm2/status — Get process info via detected manager
     if (urlPath === "/api/pm2/status") {
         try {
-            const output = execSync("pm2 jlist", { encoding: "utf-8", timeout: 5000, stdio: "pipe" });
-            const processes = JSON.parse(output);
-            // Find our process (by name or script)
-            const botProcess = processes.find((p) => p.name === "alvin-bot" ||
-                p.pm2_env?.pm_exec_path?.includes("alvin-bot")) || processes[0]; // fallback to first process
-            if (!botProcess) {
-                res.end(JSON.stringify({ error: "No PM2 process found" }));
-                return true;
-            }
-            const env = botProcess.pm2_env || {};
+            const { detectProcessManager } = await import("../services/process-manager.js");
+            const pm = detectProcessManager();
+            const status = await pm.getStatus();
             res.end(JSON.stringify({
                 process: {
-                    name: botProcess.name,
-                    pid: botProcess.pid,
-                    status: env.status || "unknown",
-                    uptime: env.pm_uptime ? Date.now() - env.pm_uptime : 0,
-                    memory: botProcess.monit?.memory || 0,
-                    cpu: botProcess.monit?.cpu || 0,
-                    restarts: env.restart_time || 0,
-                    version: env.version || "?",
-                    nodeVersion: env.node_version || process.version,
-                    execPath: env.pm_exec_path || "?",
-                    cwd: env.pm_cwd || "?",
+                    name: "alvin-bot",
+                    kind: status.kind,
+                    pid: status.pid ?? 0,
+                    status: status.status,
+                    uptime: status.uptime ?? 0,
+                    memory: status.memory ?? 0,
+                    cpu: status.cpu ?? 0,
+                    restarts: status.restarts ?? 0,
+                    version: status.version || "?",
+                    nodeVersion: status.nodeVersion || process.version,
+                    execPath: status.execPath || "?",
+                    cwd: status.cwd || "?",
                 },
             }));
         }
         catch (err) {
-            res.end(JSON.stringify({ error: "PM2 not available" }));
+            const msg = err instanceof Error ? err.message : String(err);
+            res.end(JSON.stringify({ error: `Process manager detection failed: ${msg}` }));
         }
         return true;
     }
-    // POST /api/pm2/action — Execute PM2 action (restart, stop, start, reload, flush)
+    // POST /api/pm2/action — Execute action via detected manager
     if (urlPath === "/api/pm2/action" && req.method === "POST") {
         try {
             const { action } = JSON.parse(body);
@@ -536,41 +536,44 @@ export async function handleDoctorAPI(req, res, urlPath, body) {
                 res.end(JSON.stringify({ ok: false, error: `Invalid action: ${action}` }));
                 return true;
             }
-            // Find our process name
-            let processName = "alvin-bot";
-            try {
-                const jlist = execSync("pm2 jlist", { encoding: "utf-8", timeout: 5000, stdio: "pipe" });
-                const procs = JSON.parse(jlist);
-                const found = procs.find((p) => p.name === "alvin-bot" || p.name === "alvin-bot");
-                if (found)
-                    processName = found.name;
-            }
-            catch { /* use default */ }
+            const { detectProcessManager } = await import("../services/process-manager.js");
+            const pm = detectProcessManager();
             if (action === "flush") {
-                execSync(`pm2 flush ${processName}`, { encoding: "utf-8", timeout: 10000, stdio: "pipe" });
+                // Truncate our own log files directly — works on both launchd
+                // and standalone. PM2's flush is also just truncation.
+                const logDir = resolve(DATA_DIR, "logs");
+                for (const f of ["alvin-bot.out.log", "alvin-bot.err.log"]) {
+                    try {
+                        fs.truncateSync(resolve(logDir, f), 0);
+                    }
+                    catch {
+                        /* file may not exist — ignore */
+                    }
+                }
                 res.end(JSON.stringify({ ok: true, message: "Logs flushed" }));
                 return true;
             }
             if (action === "stop") {
-                // Stop is special — we can't respond after stopping ourselves
-                res.end(JSON.stringify({ ok: true, message: "Bot is stopping..." }));
+                // Stop is special — can't respond after we've killed ourselves.
+                res.end(JSON.stringify({ ok: true, message: `Bot is stopping (${pm.kind})...` }));
                 setTimeout(() => {
-                    try {
-                        execSync(`pm2 stop ${processName}`, { timeout: 10000, stdio: "pipe" });
-                    }
-                    catch { /* process might already be dead */ }
+                    pm.stop().catch(() => {
+                        /* process might already be dead */
+                    });
                 }, 300);
                 return true;
             }
             if (action === "start") {
-                // Start the process if stopped
-                execSync(`pm2 start ${processName}`, { encoding: "utf-8", timeout: 10000, stdio: "pipe" });
-                res.end(JSON.stringify({ ok: true, message: "Bot started" }));
+                await pm.start();
+                res.end(JSON.stringify({ ok: true, message: `Bot started via ${pm.kind}` }));
                 return true;
             }
             if (action === "restart" || action === "reload") {
                 const { scheduleGracefulRestart } = await import("../services/restart.js");
-                res.end(JSON.stringify({ ok: true, message: `Bot is ${action === "restart" ? "restarting" : "reloading"}...` }));
+                res.end(JSON.stringify({
+                    ok: true,
+                    message: `Bot is ${action === "restart" ? "restarting" : "reloading"} (${pm.kind})...`,
+                }));
                 scheduleGracefulRestart(500);
                 return true;
             }
@@ -580,31 +583,20 @@ export async function handleDoctorAPI(req, res, urlPath, body) {
         }
         return true;
     }
-    // GET /api/pm2/logs — Get recent PM2 logs
+    // GET /api/pm2/logs — Get recent logs via detected manager
     if (urlPath === "/api/pm2/logs") {
         try {
-            // Find process name
-            let processName = "alvin-bot";
-            try {
-                const jlist = execSync("pm2 jlist", { encoding: "utf-8", timeout: 5000, stdio: "pipe" });
-                const procs = JSON.parse(jlist);
-                const found = procs.find((p) => p.name === "alvin-bot" || p.name === "alvin-bot");
-                if (found)
-                    processName = found.name;
-            }
-            catch { /* use default */ }
-            let logs = execSync(`pm2 logs ${processName} --nostream --lines 30 2>&1`, {
-                encoding: "utf-8",
-                timeout: 5000,
-                stdio: "pipe",
-                env: { ...process.env, FORCE_COLOR: "0", NO_COLOR: "1" },
-            });
-            // Strip ANSI escape codes
-            logs = logs.replace(/\x1b\[[0-9;]*m/g, "");
-            res.end(JSON.stringify({ logs }));
+            const { detectProcessManager } = await import("../services/process-manager.js");
+            const pm = detectProcessManager();
+            const logs = await pm.getLogs(30);
+            res.end(JSON.stringify({ logs, kind: pm.kind }));
         }
         catch (err) {
-            res.end(JSON.stringify({ error: "Logs not available", logs: "" }));
+            res.end(JSON.stringify({
+                error: "Logs not available",
+                logs: "",
+                detail: err instanceof Error ? err.message : String(err),
+            }));
         }
         return true;
     }

package/dist/web/setup-api.js

@@ -874,6 +874,58 @@ export async function handleSetupAPI(req, res, urlPath, body) {
                 }
                 return true;
             }
+            if (platformId === "slack") {
+                // v4.13.1 — Validate Slack config via auth.test (Bot Token) +
+                // format check on App Token (xapp-). We can't actually "ping"
+                // Socket Mode without opening a WebSocket, so we rely on the
+                // App Token prefix as the cheapest sanity check.
+                const botToken = process.env.SLACK_BOT_TOKEN;
+                const appToken = process.env.SLACK_APP_TOKEN;
+                if (!botToken) {
+                    res.end(JSON.stringify({ ok: false, error: "SLACK_BOT_TOKEN not set" }));
+                    return true;
+                }
+                try {
+                    const apiRes = await fetch("https://slack.com/api/auth.test", {
+                        method: "POST",
+                        headers: {
+                            "Authorization": `Bearer ${botToken}`,
+                            "Content-Type": "application/x-www-form-urlencoded",
+                        },
+                    });
+                    const data = await apiRes.json();
+                    if (!data.ok) {
+                        res.end(JSON.stringify({
+                            ok: false,
+                            error: `Slack rejected Bot Token: ${data.error || "unknown error"}`,
+                        }));
+                        return true;
+                    }
+                    // Bot Token valid. Now check App Token format — Socket Mode
+                    // requires it and the xapp- prefix is the quickest sanity check.
+                    let warning = "";
+                    if (!appToken) {
+                        warning = " ⚠️ SLACK_APP_TOKEN not set — Socket Mode will fail.";
+                    }
+                    else if (!appToken.startsWith("xapp-")) {
+                        warning =
+                            " ⚠️ SLACK_APP_TOKEN has wrong prefix (expected xapp-) — Socket Mode will fail.";
+                    }
+                    res.end(JSON.stringify({
+                        ok: true,
+                        info: `@${data.user} on ${data.team} (team_id: ${data.team_id}, bot_id: ${data.bot_id})` +
+                            warning,
+                    }));
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    res.end(JSON.stringify({
+                        ok: false,
+                        error: `Failed to reach slack.com/api/auth.test: ${msg}`,
+                    }));
+                }
+                return true;
+            }
             res.end(JSON.stringify({ ok: false, error: "Unknown platform" }));
         }
         catch (err) {

package/package.json

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