@delt/claude-alarm 0.8.0 → 0.8.1

package/dist/hub/server.js

@@ -2,7 +2,7 @@
 
 // src/hub/server.ts
 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";
@@ -653,6 +653,54 @@ function saveConfig(config) {
   fs2.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), { encoding: "utf-8", mode: 384 });
 }
 
+// src/shared/crash-guard.ts
+import fs3 from "fs";
+var BURST_WINDOW_MS = 6e4;
+var BURST_LIMIT = 10;
+function appendToLog(text) {
+  try {
+    fs3.mkdirSync(CONFIG_DIR, { recursive: true });
+    fs3.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})
+`);
+}
+
 // src/hub/server.ts
 var __dirname = path4.dirname(fileURLToPath(import.meta.url));
 var HubServer = class {
@@ -696,9 +744,12 @@ var HubServer = class {
     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)) {
@@ -725,8 +776,11 @@ var HubServer = class {
     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();
@@ -847,8 +901,8 @@ var HubServer = class {
     ];
     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;
@@ -895,6 +949,10 @@ var HubServer = class {
   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 [sessionId, sock] of this.channelSockets) {
         if (sock === ws) {
@@ -1004,6 +1062,10 @@ var HubServer = class {
   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()
@@ -1060,11 +1122,11 @@ var HubServer = class {
       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,
@@ -1077,7 +1139,7 @@ var HubServer = class {
     logger.info(`Image saved and forwarded: ${filename} (${buffer.length} bytes)`);
     setTimeout(() => {
       try {
-        fs3.unlinkSync(filePath);
+        fs4.unlinkSync(filePath);
       } catch {
       }
     }, 5 * 60 * 1e3);
@@ -1247,11 +1309,11 @@ var HubServer = class {
   }
   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 {
         }
       }
@@ -1295,6 +1357,8 @@ var HubServer = class {
   }
 };
 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 config = loadConfig();
   const hub = new HubServer(config);
   hub.start().catch((err) => {