@delt/claude-alarm 0.8.0 → 0.8.2

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;
@@ -322,7 +378,7 @@ var init_telegram = __esm({
     init_logger();
     init_constants();
     TELEGRAM_API = "https://api.telegram.org/bot";
-    TelegramBot = class {
+    TelegramBot = class _TelegramBot {
       config;
       offset = 0;
       polling = false;
@@ -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);
@@ -554,33 +610,45 @@ ${this.mdToHtml(message)}`;
       }
       /** Send a permission request with inline buttons */
       async sendPermissionRequest(sessionId2, sessionLabel, requestId, toolName, description, inputPreview) {
+        const isNotify = toolName.endsWith("__notify") || toolName === "notify";
         let preview = inputPreview;
+        let kind = "code";
+        let lang = "";
         let truncated = false;
         try {
           const p = JSON.parse(inputPreview);
-          if (p.command) preview = `$ ${p.command}`;
-          else if (p.title && p.message) preview = p.message;
-          else if (p.file_path) {
+          if (p.command) {
+            preview = `$ ${p.command}`;
+            lang = "bash";
+          } else if (p.title && p.message) {
+            preview = p.message;
+            kind = "prose";
+          } else if (p.file_path) {
             preview = p.file_path;
+            lang = this.langOf(p.file_path);
             if (p.content) {
               preview += "\n" + p.content.slice(0, 3e3);
               if (p.content.length > 500) truncated = true;
             }
           } else if (p.content && typeof p.content === "string") {
             preview = p.content.slice(0, 3e3);
+            if (isNotify) kind = "prose";
             if (p.content.length > 500) truncated = true;
           }
         } catch {
           truncated = true;
           const cmdMatch = inputPreview.match(/"command"\s*:\s*"((?:[^"\\]|\\.)*)"/);
           const contentMatch = inputPreview.match(/"content"\s*:\s*"((?:[^"\\]|\\.)*)"/);
-          if (cmdMatch) preview = `$ ${cmdMatch[1]}`;
-          else if (contentMatch) preview = contentMatch[1].slice(0, 3e3);
+          if (cmdMatch) {
+            preview = `$ ${cmdMatch[1]}`;
+            lang = "bash";
+          } else if (contentMatch) preview = contentMatch[1].slice(0, 3e3);
         }
         const truncNote = truncated ? "\n\n<i>...truncated</i>" : "";
         const previewSlice = preview.slice(0, 3e3);
         const isShort = !previewSlice.includes("\n") && previewSlice.length < 100;
-        const previewHtml = isShort ? `<code>${this.escHtml(previewSlice)}</code>` : this.escHtml(previewSlice);
+        const langAttr = lang ? ` class="language-${lang}"` : "";
+        const previewHtml = kind === "prose" ? this.mdToHtml(previewSlice) : isShort ? `<code>${this.escHtml(previewSlice)}</code>` : `<pre><code${langAttr}>${this.escHtml(previewSlice)}</code></pre>`;
         let displayTool = toolName;
         if ((toolName.endsWith("__notify") || toolName === "notify") && inputPreview) {
           try {
@@ -680,6 +748,40 @@ ${label}`);
       escHtml(s) {
         return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
       }
+      static LANG_BY_EXT = {
+        js: "javascript",
+        mjs: "javascript",
+        cjs: "javascript",
+        jsx: "javascript",
+        ts: "typescript",
+        tsx: "typescript",
+        py: "python",
+        rb: "ruby",
+        go: "go",
+        java: "java",
+        kt: "kotlin",
+        rs: "rust",
+        php: "php",
+        cs: "csharp",
+        sh: "bash",
+        bash: "bash",
+        zsh: "bash",
+        ps1: "powershell",
+        json: "json",
+        yml: "yaml",
+        yaml: "yaml",
+        xml: "xml",
+        sql: "sql",
+        md: "markdown",
+        html: "html",
+        vue: "html",
+        css: "css",
+        scss: "scss"
+      };
+      langOf(path7) {
+        const m = /\.([a-z0-9]+)$/i.exec(path7 || "");
+        return m ? _TelegramBot.LANG_BY_EXT[m[1].toLowerCase()] ?? "" : "";
+      }
       /** Convert markdown to Telegram HTML (escape first, then apply formatting) */
       mdToHtml(s) {
         let text = s.replace(
@@ -728,7 +830,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 +845,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 +888,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 +920,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 +1045,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 +1093,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 +1206,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 +1266,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 +1283,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 +1453,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 +1501,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 +1868,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 +1896,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 +1919,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 +1937,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 +1950,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 +1969,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 +1988,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 +2083,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 +2096,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") {