@delt/claude-alarm 0.8.0 → 0.8.1

package/dist/cli.js

@@ -134,6 +134,62 @@ var init_logger = __esm({
   }
 });
 
+// src/shared/crash-guard.ts
+import fs2 from "fs";
+function appendToLog(text) {
+  try {
+    fs2.mkdirSync(CONFIG_DIR, { recursive: true });
+    fs2.appendFileSync(LOG_FILE, text, "utf-8");
+  } catch {
+  }
+}
+function describe(err) {
+  if (err instanceof Error) return err.stack ?? `${err.name}: ${err.message}`;
+  try {
+    return JSON.stringify(err);
+  } catch {
+    return String(err);
+  }
+}
+function installCrashGuard(context) {
+  let recent = [];
+  const handle = (kind, err) => {
+    const stack = describe(err);
+    appendToLog(`
+[${(/* @__PURE__ */ new Date()).toISOString()}] ${kind} (${context})
+${stack}
+`);
+    logger.error(`${kind} caught by crash guard: ${stack}`);
+    const now = Date.now();
+    recent = recent.filter((t) => now - t < BURST_WINDOW_MS);
+    recent.push(now);
+    if (recent.length > BURST_LIMIT) {
+      const msg = `${recent.length} unhandled errors within ${BURST_WINDOW_MS / 1e3}s \u2014 exiting`;
+      appendToLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] ${msg}
+`);
+      logger.error(msg);
+      process.exit(1);
+    }
+  };
+  process.on("uncaughtException", (err) => handle("uncaughtException", err));
+  process.on("unhandledRejection", (reason) => handle("unhandledRejection", reason));
+}
+function logStartup(context) {
+  appendToLog(`
+[${(/* @__PURE__ */ new Date()).toISOString()}] ${context} started (pid ${process.pid})
+`);
+}
+var BURST_WINDOW_MS, BURST_LIMIT;
+var init_crash_guard = __esm({
+  "src/shared/crash-guard.ts"() {
+    "use strict";
+    init_constants();
+    init_logger();
+    BURST_WINDOW_MS = 6e4;
+    BURST_LIMIT = 10;
+  }
+});
+
 // src/hub/session-manager.ts
 var SessionManager;
 var init_session_manager = __esm({
@@ -312,7 +368,7 @@ var init_notifier = __esm({
 });
 
 // src/hub/telegram.ts
-import fs2 from "fs";
+import fs3 from "fs";
 import path3 from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 var TELEGRAM_API, TelegramBot;
@@ -531,17 +587,17 @@ ${this.mdToHtml(message)}`;
           const buffer = Buffer.from(await imgRes.arrayBuffer());
           const ext = fileData.result.file_path.split(".").pop() || "jpg";
           const mimeType = ext === "png" ? "image/png" : ext === "gif" ? "image/gif" : ext === "webp" ? "image/webp" : "image/jpeg";
-          fs2.mkdirSync(UPLOADS_DIR, { recursive: true });
+          fs3.mkdirSync(UPLOADS_DIR, { recursive: true });
           const filename = `${randomUUID2()}.${ext}`;
           const filePath = path3.join(UPLOADS_DIR, filename);
-          fs2.writeFileSync(filePath, buffer);
+          fs3.writeFileSync(filePath, buffer);
           logger.info(`Telegram photo saved: ${filename} (${buffer.length} bytes)`);
           if (this.onImageToSession) {
             this.onImageToSession(sessionId2, filePath, mimeType, caption);
           }
           setTimeout(() => {
             try {
-              fs2.unlinkSync(filePath);
+              fs3.unlinkSync(filePath);
             } catch {
             }
           }, 5 * 60 * 1e3);
@@ -728,7 +784,7 @@ __export(server_exports, {
   HubServer: () => HubServer
 });
 import http from "http";
-import fs3 from "fs";
+import fs4 from "fs";
 import path4 from "path";
 import { fileURLToPath } from "url";
 import { WebSocketServer, WebSocket } from "ws";
@@ -743,6 +799,7 @@ var init_server = __esm({
     init_notifier();
     init_telegram();
     init_config();
+    init_crash_guard();
     __dirname = path4.dirname(fileURLToPath(import.meta.url));
     HubServer = class {
       httpServer;
@@ -785,9 +842,12 @@ var init_server = __esm({
         this.httpServer = http.createServer((req, res) => this.handleHttp(req, res));
         this.wssChannel = new WebSocketServer({ noServer: true });
         this.wssChannel.on("connection", (ws, req) => this.handleChannelConnection(ws, req));
+        this.wssChannel.on("error", (err) => logger.warn(`Channel WebSocket server error: ${err.message}`));
         this.wssDashboard = new WebSocketServer({ noServer: true });
         this.wssDashboard.on("connection", (ws) => this.handleDashboardConnection(ws));
+        this.wssDashboard.on("error", (err) => logger.warn(`Dashboard WebSocket server error: ${err.message}`));
         this.httpServer.on("upgrade", (req, socket, head) => {
+          socket.on("error", (err) => logger.debug(`Upgrade socket error: ${err.message}`));
           const url = new URL(req.url, `http://${req.headers.host}`);
           const pathname = url.pathname;
           if (this.token && !this.isLocalRequest(req)) {
@@ -814,8 +874,11 @@ var init_server = __esm({
         this.cleanupUploads();
         this.startHeartbeat();
         return new Promise((resolve, reject) => {
-          this.httpServer.on("error", reject);
+          const onStartupError = (err) => reject(err);
+          this.httpServer.once("error", onStartupError);
           this.httpServer.listen(this.port, this.host, () => {
+            this.httpServer.removeListener("error", onStartupError);
+            this.httpServer.on("error", (err) => logger.error(`HTTP server error: ${err.message}`));
             const displayHost = this.host === "0.0.0.0" ? "127.0.0.1" : this.host;
             logger.info(`Hub server listening on http://${displayHost}:${this.port}`);
             resolve();
@@ -936,8 +999,8 @@ var init_server = __esm({
         ];
         logger.debug(`Dashboard candidates: ${JSON.stringify(candidates)}`);
         for (const candidate of candidates) {
-          if (fs3.existsSync(candidate)) {
-            const html = fs3.readFileSync(candidate, "utf-8");
+          if (fs4.existsSync(candidate)) {
+            const html = fs4.readFileSync(candidate, "utf-8");
             res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
             res.end(html);
             return;
@@ -984,6 +1047,10 @@ var init_server = __esm({
       handleChannelConnection(ws, req) {
         const isLocal = this.isLocalRequest(req);
         logger.info(`Channel server connected (local: ${isLocal})`);
+        ws.on("error", (err) => {
+          logger.warn(`Channel WebSocket error: ${err.message}`);
+          ws.terminate();
+        });
         ws.on("pong", () => {
           for (const [sessionId2, sock] of this.channelSockets) {
             if (sock === ws) {
@@ -1093,6 +1160,10 @@ var init_server = __esm({
       handleDashboardConnection(ws) {
         this.dashboardSockets.add(ws);
         logger.info(`Dashboard connected (total: ${this.dashboardSockets.size})`);
+        ws.on("error", (err) => {
+          logger.warn(`Dashboard WebSocket error: ${err.message}`);
+          ws.terminate();
+        });
         const sessionsMsg = {
           type: "sessions_list",
           sessions: this.sessions.getAll()
@@ -1149,11 +1220,11 @@ var init_server = __esm({
           logger.warn("Image upload rejected: exceeds 10MB");
           return;
         }
-        fs3.mkdirSync(UPLOADS_DIR, { recursive: true });
+        fs4.mkdirSync(UPLOADS_DIR, { recursive: true });
         const ext = mimeType.split("/")[1] === "jpeg" ? "jpg" : mimeType.split("/")[1];
         const filename = `${randomUUID3()}.${ext}`;
         const filePath = path4.join(UPLOADS_DIR, filename);
-        fs3.writeFileSync(filePath, buffer);
+        fs4.writeFileSync(filePath, buffer);
         const forwardMsg = {
           type: "image_to_session",
           sessionId: sessionId2,
@@ -1166,7 +1237,7 @@ var init_server = __esm({
         logger.info(`Image saved and forwarded: ${filename} (${buffer.length} bytes)`);
         setTimeout(() => {
           try {
-            fs3.unlinkSync(filePath);
+            fs4.unlinkSync(filePath);
           } catch {
           }
         }, 5 * 60 * 1e3);
@@ -1336,11 +1407,11 @@ var init_server = __esm({
       }
       cleanupUploads() {
         try {
-          if (!fs3.existsSync(UPLOADS_DIR)) return;
-          const files = fs3.readdirSync(UPLOADS_DIR);
+          if (!fs4.existsSync(UPLOADS_DIR)) return;
+          const files = fs4.readdirSync(UPLOADS_DIR);
           for (const file of files) {
             try {
-              fs3.unlinkSync(path4.join(UPLOADS_DIR, file));
+              fs4.unlinkSync(path4.join(UPLOADS_DIR, file));
             } catch {
             }
           }
@@ -1384,6 +1455,8 @@ var init_server = __esm({
       }
     };
     if (process.argv[1] && (process.argv[1].endsWith("hub/server.js") || process.argv[1].endsWith("hub/server.ts"))) {
+      installCrashGuard("hub daemon");
+      logStartup("Hub daemon");
       const config2 = loadConfig();
       const hub = new HubServer(config2);
       hub.start().catch((err) => {
@@ -1749,8 +1822,9 @@ NOTIFICATIONS:
 init_config();
 init_constants();
 init_logger();
+init_crash_guard();
 import { spawn } from "child_process";
-import fs4 from "fs";
+import fs5 from "fs";
 import path6 from "path";
 import readline from "readline";
 import { fileURLToPath as fileURLToPath2 } from "url";
@@ -1776,7 +1850,7 @@ Quick start:
 async function checkForUpdates() {
   try {
     const pkgPath = path6.join(__dirname2, "..", "package.json");
-    const pkg = JSON.parse(fs4.readFileSync(pkgPath, "utf-8"));
+    const pkg = JSON.parse(fs5.readFileSync(pkgPath, "utf-8"));
     const currentVersion = pkg.version;
     const res = await fetch("https://registry.npmjs.org/@delt/claude-alarm/latest", {
       signal: AbortSignal.timeout(3e3)
@@ -1799,17 +1873,17 @@ async function hubStart(daemon) {
   const port = config2.hub.port ?? DEFAULT_HUB_PORT;
   const displayHost = host === "0.0.0.0" ? "127.0.0.1" : host;
   checkForUpdates();
-  if (fs4.existsSync(PID_FILE)) {
-    const pid = parseInt(fs4.readFileSync(PID_FILE, "utf-8").trim(), 10);
+  if (fs5.existsSync(PID_FILE)) {
+    const pid = parseInt(fs5.readFileSync(PID_FILE, "utf-8").trim(), 10);
     if (isProcessRunning(pid)) {
       console.log(`Hub is already running (PID: ${pid}) on http://${displayHost}:${port}`);
       return;
     }
-    fs4.unlinkSync(PID_FILE);
+    fs5.unlinkSync(PID_FILE);
   }
   if (daemon) {
     ensureConfigDir();
-    const logFd = fs4.openSync(LOG_FILE, "a");
+    const logFd = fs5.openSync(LOG_FILE, "a");
     const hubScript = path6.join(__dirname2, "hub", "server.js");
     const child = spawn(process.execPath, [hubScript], {
       detached: true,
@@ -1817,7 +1891,7 @@ async function hubStart(daemon) {
       env: { ...process.env }
     });
     if (child.pid) {
-      fs4.writeFileSync(PID_FILE, String(child.pid), "utf-8");
+      fs5.writeFileSync(PID_FILE, String(child.pid), "utf-8");
       child.unref();
       console.log(`Hub started as daemon (PID: ${child.pid})`);
       console.log(`Dashboard: http://${displayHost}:${port}`);
@@ -1830,15 +1904,18 @@ async function hubStart(daemon) {
   } else {
     console.log(`Starting hub on http://${displayHost}:${port} (press Ctrl+C to stop)`);
     console.log(`Token: ${config2.hub.token}`);
+    console.log(`Logs: ${LOG_FILE}`);
+    installCrashGuard("hub foreground");
+    logStartup("Hub foreground");
     const { HubServer: HubServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
     const hub = new HubServer2(config2);
     await hub.start();
     ensureConfigDir();
-    fs4.writeFileSync(PID_FILE, String(process.pid), "utf-8");
+    fs5.writeFileSync(PID_FILE, String(process.pid), "utf-8");
     const shutdown = async () => {
       console.log("\nShutting down...");
       await hub.stop();
-      if (fs4.existsSync(PID_FILE)) fs4.unlinkSync(PID_FILE);
+      if (fs5.existsSync(PID_FILE)) fs5.unlinkSync(PID_FILE);
       process.exit(0);
     };
     process.on("SIGINT", shutdown);
@@ -1846,18 +1923,18 @@ async function hubStart(daemon) {
   }
 }
 function hubStop() {
-  if (!fs4.existsSync(PID_FILE)) {
+  if (!fs5.existsSync(PID_FILE)) {
     console.log("Hub is not running (no PID file found)");
     return;
   }
-  const pid = parseInt(fs4.readFileSync(PID_FILE, "utf-8").trim(), 10);
+  const pid = parseInt(fs5.readFileSync(PID_FILE, "utf-8").trim(), 10);
   try {
     process.kill(pid, "SIGTERM");
     console.log(`Hub stopped (PID: ${pid})`);
   } catch {
     console.log("Hub process not found (may have already stopped)");
   }
-  fs4.unlinkSync(PID_FILE);
+  fs5.unlinkSync(PID_FILE);
 }
 async function hubStatus() {
   const config2 = loadConfig();
@@ -1865,8 +1942,8 @@ async function hubStatus() {
   const port = config2.hub.port ?? DEFAULT_HUB_PORT;
   const displayHost = host === "0.0.0.0" ? "127.0.0.1" : host;
   let pidInfo = "not running";
-  if (fs4.existsSync(PID_FILE)) {
-    const pid = parseInt(fs4.readFileSync(PID_FILE, "utf-8").trim(), 10);
+  if (fs5.existsSync(PID_FILE)) {
+    const pid = parseInt(fs5.readFileSync(PID_FILE, "utf-8").trim(), 10);
     if (isProcessRunning(pid)) {
       pidInfo = `running (PID: ${pid})`;
     } else {
@@ -1960,9 +2037,9 @@ claude-alarm init for "${projectName}"
   }
   const mcpPath = path6.join(dir, ".mcp.json");
   let mcpConfig = {};
-  if (fs4.existsSync(mcpPath)) {
+  if (fs5.existsSync(mcpPath)) {
     try {
-      mcpConfig = JSON.parse(fs4.readFileSync(mcpPath, "utf-8"));
+      mcpConfig = JSON.parse(fs5.readFileSync(mcpPath, "utf-8"));
     } catch {
       mcpConfig = {};
     }
@@ -1973,7 +2050,7 @@ claude-alarm init for "${projectName}"
     args: ["-y", "@delt/claude-alarm", "serve"],
     env
   };
-  fs4.writeFileSync(mcpPath, JSON.stringify(mcpConfig, null, 2), "utf-8");
+  fs5.writeFileSync(mcpPath, JSON.stringify(mcpConfig, null, 2), "utf-8");
   console.log(`
 \u2713 Created ${mcpPath}`);
   if (remote.toLowerCase() !== "y") {