@tspappsen/elamax 1.2.3

package/dist/copilot/watchdog-tools.js

@@ -0,0 +1,312 @@
+import { z } from "zod";
+import { defineTool } from "@github/copilot-sdk";
+import { config } from "../config.js";
+import { MAIN_MAX_HOME, MAX_PROFILE } from "../paths.js";
+import { execSync } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { hostname, uptime, totalmem, freemem, platform, loadavg } from "os";
+import http from "http";
+/** All known pm2 names for the watchdog's own process.
+ * Includes the derived name (max-<profile>) AND the pm2-injected process name. */
+function getOwnPm2Names() {
+    const names = new Set();
+    if (MAX_PROFILE)
+        names.add(`max-${MAX_PROFILE}`);
+    // pm2 sets process.env.name for managed processes
+    if (process.env.name)
+        names.add(process.env.name);
+    return Array.from(names);
+}
+function execCommand(cmd, timeoutMs = 30_000) {
+    try {
+        const stdout = execSync(cmd, {
+            timeout: timeoutMs,
+            stdio: ["ignore", "pipe", "pipe"],
+            encoding: "utf-8",
+            maxBuffer: 1024 * 1024,
+        });
+        return { stdout: stdout.slice(0, 4096), stderr: "", exitCode: 0 };
+    }
+    catch (err) {
+        return {
+            stdout: String(err.stdout || "").slice(0, 4096),
+            stderr: String(err.stderr || err.message || "").slice(0, 4096),
+            exitCode: err.status ?? null,
+        };
+    }
+}
+function formatDuration(ms) {
+    if (!ms || ms <= 0)
+        return "unknown";
+    const totalSeconds = Math.floor(ms / 1000);
+    const days = Math.floor(totalSeconds / 86_400);
+    const hours = Math.floor((totalSeconds % 86_400) / 3_600);
+    const minutes = Math.floor((totalSeconds % 3_600) / 60);
+    const seconds = totalSeconds % 60;
+    const parts = [
+        days ? `${days}d` : "",
+        hours ? `${hours}h` : "",
+        minutes ? `${minutes}m` : "",
+        !days && !hours ? `${seconds}s` : "",
+    ].filter(Boolean);
+    return parts.join(" ") || "0s";
+}
+function formatBytes(bytes) {
+    if (bytes === undefined || Number.isNaN(bytes))
+        return "unknown";
+    const units = ["B", "KB", "MB", "GB", "TB"];
+    let value = bytes;
+    let unitIndex = 0;
+    while (value >= 1024 && unitIndex < units.length - 1) {
+        value /= 1024;
+        unitIndex += 1;
+    }
+    return `${value.toFixed(value >= 10 || unitIndex === 0 ? 0 : 1)} ${units[unitIndex]}`;
+}
+function summarizePm2Process(proc) {
+    if (!proc) {
+        return {
+            found: false,
+            name: config.mainMaxPm2Name,
+            status: "not found",
+            uptime: "unknown",
+            restarts: 0,
+            pid: null,
+            memory: "unknown",
+        };
+    }
+    return {
+        found: true,
+        name: proc.pm2_env?.name || config.mainMaxPm2Name,
+        status: proc.pm2_env?.status || "unknown",
+        uptime: formatDuration(proc.pm2_env?.pm_uptime ? Date.now() - proc.pm2_env.pm_uptime : undefined),
+        restarts: proc.pm2_env?.restart_time ?? 0,
+        pid: proc.pid ?? null,
+        memory: formatBytes(proc.monit?.memory),
+    };
+}
+function parsePm2Status() {
+    const result = execCommand("pm2 jlist");
+    const combinedOutput = `${result.stdout}\n${result.stderr}`.trim();
+    if (result.exitCode !== 0) {
+        if (/not recognized|not found|enoent/i.test(combinedOutput)) {
+            return { ok: false, message: "pm2 is not installed. Try: ps aux | grep max", details: result };
+        }
+        return {
+            ok: false,
+            message: combinedOutput || "Failed to query pm2.",
+            details: result,
+        };
+    }
+    try {
+        const parsed = JSON.parse(result.stdout);
+        const proc = parsed.find((entry) => entry.pm2_env?.name === config.mainMaxPm2Name);
+        return { ok: true, process: summarizePm2Process(proc), rawCount: parsed.length };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            message: `pm2 returned invalid JSON: ${err instanceof Error ? err.message : String(err)}`,
+            details: result,
+        };
+    }
+}
+function pingMainMax() {
+    const mainApiPort = Number.parseInt(process.env.MAIN_MAX_API_PORT || "7777", 10) || 7777;
+    return new Promise((resolve) => {
+        const req = http.get({
+            host: "127.0.0.1",
+            port: mainApiPort,
+            path: "/",
+            timeout: 3_000,
+        }, (res) => {
+            res.resume();
+            resolve({
+                reachable: true,
+                detail: `reachable on http://127.0.0.1:${mainApiPort}/ (HTTP ${res.statusCode ?? "unknown"})`,
+            });
+        });
+        req.on("timeout", () => {
+            req.destroy(new Error("timeout"));
+        });
+        req.on("error", (err) => {
+            resolve({
+                reachable: false,
+                detail: `unreachable on http://127.0.0.1:${mainApiPort}/ (${err.message})`,
+            });
+        });
+    });
+}
+function isSelfTargetedPm2Command(command) {
+    for (const name of getOwnPm2Names()) {
+        const escapedName = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        if (new RegExp(`\\bpm2\\b[^\\n\\r;|&]*\\b(stop|restart|delete|kill)\\b[^\\n\\r;|&]*\\b${escapedName}\\b`, "i").test(command)) {
+            return true;
+        }
+    }
+    return false;
+}
+function buildMainStatus(status, httpStatus) {
+    return {
+        pm2Name: status.name,
+        status: status.status,
+        uptime: status.uptime,
+        restarts: status.restarts,
+        pid: status.pid,
+        memory: status.memory,
+        http: httpStatus.detail,
+    };
+}
+export function createWatchdogTools() {
+    return [
+        defineTool("check_main_max", {
+            description: "Check whether the main Max process is healthy via pm2 status and an HTTP ping.",
+            parameters: z.object({}),
+            handler: async () => {
+                const pm2Status = parsePm2Status();
+                const httpStatus = await pingMainMax();
+                if (!pm2Status.ok) {
+                    return {
+                        ok: false,
+                        pm2: pm2Status.message,
+                        http: httpStatus.detail,
+                    };
+                }
+                return {
+                    ok: true,
+                    mainMax: buildMainStatus(pm2Status.process, httpStatus),
+                };
+            },
+        }),
+        defineTool("restart_main_max", {
+            description: "Restart the main Max pm2 process, then report its fresh status.",
+            parameters: z.object({
+                reason: z.string().optional().describe("Optional reason for the restart"),
+            }),
+            handler: async (args) => {
+                const ownNames = getOwnPm2Names();
+                if (ownNames.includes(config.mainMaxPm2Name)) {
+                    return `Refusing restart: target pm2 process '${config.mainMaxPm2Name}' matches the watchdog's own process name.`;
+                }
+                console.log(`[watchdog] restart_main_max target=${config.mainMaxPm2Name} reason=${args.reason || "unspecified"}`);
+                const result = execCommand(`pm2 restart ${JSON.stringify(config.mainMaxPm2Name)}`);
+                const httpStatus = await pingMainMax();
+                const pm2Status = parsePm2Status();
+                if (!pm2Status.ok) {
+                    return {
+                        ok: result.exitCode === 0,
+                        restart: result,
+                        pm2: pm2Status.message,
+                        http: httpStatus.detail,
+                    };
+                }
+                return {
+                    ok: result.exitCode === 0,
+                    restart: result,
+                    mainMax: buildMainStatus(pm2Status.process, httpStatus),
+                };
+            },
+        }),
+        defineTool("read_main_logs", {
+            description: "Read the tail of the main Max daemon log.",
+            parameters: z.object({
+                lines: z.number().int().min(1).max(500).default(100).describe("How many lines to return (default 100, max 500)"),
+            }),
+            handler: async (args) => {
+                const logPath = join(MAIN_MAX_HOME, "daemon.log");
+                const oldLogPath = join(MAIN_MAX_HOME, "daemon.log.old");
+                const lineCount = args.lines ?? 100;
+                try {
+                    const content = readFileSync(logPath, "utf-8");
+                    const tail = content.split(/\r?\n/).slice(-lineCount).join("\n");
+                    return {
+                        path: logPath,
+                        lines: lineCount,
+                        content: tail,
+                        oldLogAvailable: existsSync(oldLogPath) ? oldLogPath : undefined,
+                    };
+                }
+                catch (err) {
+                    const enoent = typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
+                    if (enoent) {
+                        const fallback = existsSync(oldLogPath)
+                            ? ` Fallback log exists at ${oldLogPath}.`
+                            : "";
+                        return `Main Max log file not found at ${logPath}. Main Max may not have started yet.${fallback}`;
+                    }
+                    return `Failed to read main Max log: ${err instanceof Error ? err.message : String(err)}`;
+                }
+            },
+        }),
+        defineTool("server_health", {
+            description: "Report basic host health for the watchdog server.",
+            parameters: z.object({}),
+            handler: async () => {
+                const total = totalmem();
+                const free = freemem();
+                const disk = platform() === "win32"
+                    ? "Disk check skipped on Windows."
+                    : (() => {
+                        const result = execCommand("df -h /");
+                        return result.exitCode === 0 ? result.stdout.trim() : (result.stderr || result.stdout || "Disk check failed.").trim();
+                    })();
+                return {
+                    hostname: hostname(),
+                    platform: platform(),
+                    uptime: formatDuration(uptime() * 1000),
+                    memory: {
+                        total: formatBytes(total),
+                        free: formatBytes(free),
+                        used: formatBytes(total - free),
+                    },
+                    loadAverage: loadavg().map((value) => value.toFixed(2)).join(", "),
+                    disk,
+                };
+            },
+        }),
+        defineTool("run_shell", {
+            description: "Run a shell command on the server with a short timeout and capped output.",
+            parameters: z.object({
+                command: z.string().min(1).describe("Shell command to execute"),
+            }),
+            handler: async (args) => {
+                if (isSelfTargetedPm2Command(args.command)) {
+                    return `Refusing command: it appears to target the watchdog's own pm2 process (${getOwnPm2Names().join(', ')}).`;
+                }
+                const result = execCommand(args.command, 30_000);
+                console.log(`[watchdog] run_shell command=${JSON.stringify(args.command)} exitCode=${result.exitCode} stdout=${JSON.stringify(result.stdout)} stderr=${JSON.stringify(result.stderr)}`);
+                return result;
+            },
+        }),
+        defineTool("update_main_max", {
+            description: "Stop the main Max process, update the global package, and start it again.",
+            parameters: z.object({}),
+            handler: async () => {
+                const ownNames = getOwnPm2Names();
+                if (ownNames.includes(config.mainMaxPm2Name)) {
+                    return `Refusing update: target pm2 process '${config.mainMaxPm2Name}' matches the watchdog's own process name.`;
+                }
+                console.log(`[watchdog] update_main_max target=${config.mainMaxPm2Name}`);
+                const command = `pm2 stop ${JSON.stringify(config.mainMaxPm2Name)} && npm update -g elamax && pm2 start ${JSON.stringify(config.mainMaxPm2Name)}`;
+                const result = execCommand(command, 120_000);
+                const httpStatus = await pingMainMax();
+                const pm2Status = parsePm2Status();
+                if (!pm2Status.ok) {
+                    return {
+                        ok: result.exitCode === 0,
+                        update: result,
+                        pm2: pm2Status.message,
+                        http: httpStatus.detail,
+                    };
+                }
+                return {
+                    ok: result.exitCode === 0,
+                    update: result,
+                    mainMax: buildMainStatus(pm2Status.process, httpStatus),
+                };
+            },
+        }),
+    ];
+}
+//# sourceMappingURL=watchdog-tools.js.map

package/dist/copilot/workspace-instructions.js

@@ -0,0 +1,100 @@
+import { readdirSync, readFileSync, copyFileSync, watch, existsSync, mkdirSync } from "fs";
+import { join, basename, dirname } from "path";
+import { fileURLToPath } from "url";
+import { INSTRUCTIONS_DIR } from "../paths.js";
+/** Directory containing bundled template files shipped with Max */
+const TEMPLATES_DIR = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "templates", "instructions");
+/**
+ * Scan ~/.max/instructions/ for .md files and return their concatenated content.
+ * Each file is rendered as a section with its filename as the heading.
+ * Files are sorted alphabetically for deterministic ordering.
+ */
+export function loadWorkspaceInstructions() {
+    if (!existsSync(INSTRUCTIONS_DIR))
+        return "";
+    let entries;
+    try {
+        entries = readdirSync(INSTRUCTIONS_DIR)
+            .filter((f) => f.endsWith(".md"))
+            .sort();
+    }
+    catch {
+        return "";
+    }
+    if (entries.length === 0)
+        return "";
+    const sections = [];
+    for (const entry of entries) {
+        try {
+            const content = readFileSync(join(INSTRUCTIONS_DIR, entry), "utf-8").trim();
+            if (content) {
+                const name = basename(entry, ".md");
+                sections.push(`## ${name}\n${content}`);
+            }
+        }
+        catch {
+            // skip unreadable files
+        }
+    }
+    if (sections.length === 0)
+        return "";
+    return `\n## Workspace Instructions\nThe following instructions were loaded from ${INSTRUCTIONS_DIR}:\n\n${sections.join("\n\n")}\n`;
+}
+/**
+ * Copy bundled template .md files into ~/.max/instructions/ if they don't already exist.
+ * This gives new users starter AGENTS.md and TOOLS.md files to customize.
+ */
+export function seedDefaultInstructions() {
+    if (!existsSync(INSTRUCTIONS_DIR)) {
+        mkdirSync(INSTRUCTIONS_DIR, { recursive: true });
+    }
+    if (!existsSync(TEMPLATES_DIR))
+        return;
+    let templates;
+    try {
+        templates = readdirSync(TEMPLATES_DIR).filter((f) => f.endsWith(".md"));
+    }
+    catch {
+        return;
+    }
+    for (const file of templates) {
+        const dest = join(INSTRUCTIONS_DIR, file);
+        if (!existsSync(dest)) {
+            try {
+                copyFileSync(join(TEMPLATES_DIR, file), dest);
+                console.log(`[max] Seeded default instruction: ${file}`);
+            }
+            catch (err) {
+                console.log(`[max] Could not seed ${file}: ${err instanceof Error ? err.message : err}`);
+            }
+        }
+    }
+}
+/**
+ * Watch ~/.max/instructions/ for changes and invoke `onChange` when any .md file
+ * is added, removed, or modified. Uses a 500ms debounce to coalesce rapid edits.
+ * Returns a cleanup function that stops the watcher.
+ */
+export function watchInstructions(onChange) {
+    if (!existsSync(INSTRUCTIONS_DIR)) {
+        mkdirSync(INSTRUCTIONS_DIR, { recursive: true });
+    }
+    let debounceTimer;
+    const watcher = watch(INSTRUCTIONS_DIR, (_event, filename) => {
+        // Only react to .md files
+        if (filename && !filename.endsWith(".md"))
+            return;
+        if (debounceTimer)
+            clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(() => {
+            console.log(`[max] Instructions changed${filename ? ` (${filename})` : ""} — invalidating session`);
+            onChange();
+        }, 500);
+    });
+    return () => {
+        if (debounceTimer)
+            clearTimeout(debounceTimer);
+        watcher.close();
+    };
+}
+//# sourceMappingURL=workspace-instructions.js.map

package/dist/daemon.js

@@ -0,0 +1,237 @@
+import { getClient, stopClient } from "./copilot/client.js";
+import { initOrchestrator, setMessageLogger, setProactiveNotify, getWorkers } from "./copilot/orchestrator.js";
+import { startApiServer, broadcastToSSE } from "./api/server.js";
+import { createBot, startBot, stopBot, sendProactiveMessage } from "./telegram/bot.js";
+import { createDiscordBot, startDiscordBot, stopDiscordBot, sendDiscordProactiveMessage } from "./discord/bot.js";
+import { getDb, closeDb } from "./store/db.js";
+import { config } from "./config.js";
+import { spawn } from "child_process";
+import { checkForUpdate } from "./update.js";
+import { DAEMON_LOG_PATH, ensureMaxHome, MAX_HOME, MAX_PROFILE } from "./paths.js";
+import { createWriteStream, statSync, renameSync } from "fs";
+// --- Persistent file logging (survives restarts) ---
+const MAX_LOG_SIZE = 5 * 1024 * 1024; // 5 MB
+function rotateLogIfNeeded() {
+    try {
+        const stat = statSync(DAEMON_LOG_PATH);
+        if (stat.size > MAX_LOG_SIZE) {
+            renameSync(DAEMON_LOG_PATH, DAEMON_LOG_PATH + ".old");
+        }
+    }
+    catch {
+        // File doesn't exist yet — nothing to rotate
+    }
+}
+ensureMaxHome();
+rotateLogIfNeeded();
+const logStream = createWriteStream(DAEMON_LOG_PATH, { flags: "a" });
+function writeToLog(level, args) {
+    const ts = new Date().toISOString();
+    const msg = args.map((a) => (a instanceof Error ? a.stack ?? a.message : typeof a === "string" ? a : JSON.stringify(a))).join(" ");
+    logStream.write(`${ts} [${level}] ${msg}\n`);
+}
+const origLog = console.log.bind(console);
+const origError = console.error.bind(console);
+const origWarn = console.warn.bind(console);
+console.log = (...args) => { origLog(...args); writeToLog("INFO", args); };
+console.error = (...args) => { origError(...args); writeToLog("ERROR", args); };
+console.warn = (...args) => { origWarn(...args); writeToLog("WARN", args); };
+function truncate(text, max = 200) {
+    const oneLine = text.replace(/\n/g, " ").trim();
+    return oneLine.length > max ? oneLine.slice(0, max) + "…" : oneLine;
+}
+async function main() {
+    console.log("[max] Starting Max daemon...");
+    console.log(`[max] Profile: ${MAX_PROFILE || "main"}`);
+    console.log(`[max] MAX_HOME: ${MAX_HOME}`);
+    if (config.selfEditEnabled) {
+        console.log("[max] ⚠ Self-edit mode enabled — Max can modify his own source code");
+    }
+    // Set up message logging to daemon console
+    setMessageLogger((direction, source, text) => {
+        const arrow = direction === "in" ? "⟶" : "⟵";
+        const tag = source.padEnd(8);
+        console.log(`[max] ${tag} ${arrow}  ${truncate(text)}`);
+    });
+    // Initialize SQLite
+    getDb();
+    console.log("[max] Database initialized");
+    // Start Copilot SDK client
+    console.log("[max] Starting Copilot SDK client...");
+    const client = await getClient();
+    console.log("[max] Copilot SDK client ready");
+    // Initialize orchestrator session
+    console.log("[max] Creating orchestrator session...");
+    await initOrchestrator(client);
+    console.log("[max] Orchestrator session ready");
+    // Wire up proactive notifications — route to the originating channel
+    setProactiveNotify((text, channel) => {
+        console.log(`[max] bg-notify (${channel ?? "all"}) ⟵  ${truncate(text)}`);
+        if (!channel || channel === "telegram") {
+            if (config.telegramEnabled)
+                sendProactiveMessage(text);
+        }
+        if (!channel || channel === "tui") {
+            broadcastToSSE(text);
+        }
+    });
+    // Start HTTP API for TUI
+    await startApiServer();
+    // Start Telegram bot (if configured)
+    if (config.telegramEnabled) {
+        createBot();
+        await startBot();
+    }
+    else if (!config.telegramBotToken && config.authorizedUserId === undefined) {
+        console.log("[max] Telegram not configured — skipping bot. Run 'max setup' to configure.");
+    }
+    else if (!config.telegramBotToken) {
+        console.log("[max] Telegram bot token missing — skipping bot. Run 'max setup' and enter your bot token.");
+    }
+    else {
+        console.log("[max] Telegram user ID missing — skipping bot. Run 'max setup' and enter your Telegram user ID (get it from @userinfobot).");
+    }
+    // Start Discord bot (if configured)
+    if (config.discordEnabled) {
+        createDiscordBot();
+        await startDiscordBot();
+    }
+    else if (!config.discordBotToken) {
+        console.log("[max] Discord not configured — skipping. Run 'max setup' to configure.");
+    }
+    else {
+        console.log("[max] Discord allowed channels missing — skipping. Run 'max setup' and enter channel IDs.");
+    }
+    console.log("[max] Max is fully operational.");
+    // Non-blocking update check
+    checkForUpdate()
+        .then(({ updateAvailable, current, latest }) => {
+        if (updateAvailable) {
+            console.log(`[max] ⬆ Update available: v${current} → v${latest}  —  run 'max update' to install`);
+        }
+    })
+        .catch(() => { }); // silent — network may be unavailable
+    // Notify user if this is a restart (not a fresh start)
+    if (process.env.MAX_RESTARTED === "1") {
+        if (config.telegramEnabled) {
+            await sendProactiveMessage("I'm back online 🟢").catch(() => { });
+        }
+        if (config.discordEnabled) {
+            for (const channelId of config.discordAllowedChannelIds) {
+                await sendDiscordProactiveMessage("I'm back online 🟢", channelId).catch(() => { });
+            }
+        }
+        delete process.env.MAX_RESTARTED;
+    }
+}
+// Graceful shutdown
+let shutdownState = "idle";
+async function shutdown() {
+    if (shutdownState === "shutting_down") {
+        console.log("\n[max] Forced exit.");
+        process.exit(1);
+    }
+    // Check for active workers before shutting down
+    const workers = getWorkers();
+    const running = Array.from(workers.values()).filter(w => w.status === "running");
+    if (running.length > 0 && shutdownState === "idle") {
+        const names = running.map(w => w.name).join(", ");
+        console.log(`\n[max] ⚠ ${running.length} active worker(s) will be destroyed: ${names}`);
+        console.log("[max] Press Ctrl+C again to shut down, or wait for workers to finish.");
+        shutdownState = "warned";
+        return;
+    }
+    shutdownState = "shutting_down";
+    console.log("\n[max] Shutting down... (Ctrl+C again to force)");
+    // Force exit after 3 seconds no matter what
+    const forceTimer = setTimeout(() => {
+        console.log("[max] Shutdown timed out — forcing exit.");
+        process.exit(1);
+    }, 3000);
+    forceTimer.unref();
+    if (config.telegramEnabled) {
+        try {
+            await stopBot();
+        }
+        catch { /* best effort */ }
+    }
+    if (config.discordEnabled) {
+        try {
+            await stopDiscordBot();
+        }
+        catch { /* best effort */ }
+    }
+    // Destroy all active worker sessions to free memory
+    await Promise.allSettled(Array.from(workers.values()).map((w) => w.session.destroy()));
+    workers.clear();
+    try {
+        await stopClient();
+    }
+    catch { /* best effort */ }
+    closeDb();
+    console.log("[max] Goodbye.");
+    process.exit(0);
+}
+/** Restart the daemon by spawning a new process and exiting. */
+export async function restartDaemon() {
+    console.log("[max] Restarting...");
+    const activeWorkers = getWorkers();
+    const runningCount = Array.from(activeWorkers.values()).filter(w => w.status === "running").length;
+    if (runningCount > 0) {
+        console.log(`[max] ⚠ Destroying ${runningCount} active worker(s) for restart`);
+    }
+    if (config.telegramEnabled) {
+        await sendProactiveMessage("Restarting — back in a sec ⏳").catch(() => { });
+        try {
+            await stopBot();
+        }
+        catch { /* best effort */ }
+    }
+    if (config.discordEnabled) {
+        for (const channelId of config.discordAllowedChannelIds) {
+            await sendDiscordProactiveMessage("Restarting — back in a sec ⏳", channelId).catch(() => { });
+        }
+        try {
+            await stopDiscordBot();
+        }
+        catch { /* best effort */ }
+    }
+    // Destroy all active worker sessions to free memory
+    await Promise.allSettled(Array.from(activeWorkers.values()).map((w) => w.session.destroy()));
+    activeWorkers.clear();
+    try {
+        await stopClient();
+    }
+    catch { /* best effort */ }
+    closeDb();
+    // When pm2 is managing the process, just exit — pm2 will restart automatically.
+    // Spawning here too would result in two running instances.
+    const underPm2 = process.env.PM2_HOME !== undefined || process.env.pm_id !== undefined;
+    if (underPm2) {
+        console.log("[max] Running under pm2 — exiting cleanly so pm2 handles restart.");
+        process.exit(0);
+    }
+    // Spawn a detached replacement process with the same args (include execArgv for tsx/loaders)
+    const child = spawn(process.execPath, [...process.execArgv, ...process.argv.slice(1)], {
+        detached: true,
+        stdio: "inherit",
+        env: { ...process.env, MAX_RESTARTED: "1" },
+    });
+    child.unref();
+    console.log("[max] New process spawned. Exiting old process.");
+    process.exit(0);
+}
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);
+// Prevent unhandled errors from crashing the daemon
+process.on("unhandledRejection", (reason) => {
+    console.error("[max] Unhandled rejection (kept alive):", reason);
+});
+process.on("uncaughtException", (err) => {
+    console.error("[max] Uncaught exception (kept alive):", err);
+});
+main().catch((err) => {
+    console.error("[max] Fatal error:", err);
+    process.exit(1);
+});
+//# sourceMappingURL=daemon.js.map