coderail-watch 0.1.2 → 0.1.4

package/README.md

@@ -8,6 +8,12 @@ Usage:
 npx coderail-watch --session-id <session_id> --project-key <project_public_id> --base-url http://localhost:8000
 ```
 
+Watch a log file instead of stdin:
+
+```bash
+npx coderail-watch --session-id <session_id> --project-key <project_public_id> --base-url http://localhost:8000 --log-path /path/to/logfile
+```
+
 Publish (npm):
 
 ```bash

package/bin/coderail-watch.js

@@ -1,11 +1,15 @@
 #!/usr/bin/env node
 "use strict";
 
+const fs = require("fs");
 const readline = require("readline");
-const WebSocket = require("ws");
 
 const DEFAULT_BASE_URL = "http://localhost:8000";
 const DEFAULT_RETRY_WAIT_MS = 2000;
+const ALERT_PREFIX = "[[CODERAIL_ERROR]] ";
+const ERROR_PATTERN = /(^|[\s:])(?:error|exception|traceback|panic|fatal)(?=[\s:])/i;
+
+const isErrorLine = (line) => ERROR_PATTERN.test(line);
 
 const parseArgs = (argv) => {
   const args = {};
@@ -28,6 +32,19 @@ const log = (message) => {
   process.stderr.write(`[coderail-watch] ${message}\n`);
 };
 
+let WebSocketImpl = globalThis.WebSocket;
+if (!WebSocketImpl) {
+  try {
+    WebSocketImpl = require("ws");
+  } catch (error) {
+    log(
+      "Missing dependency 'ws'. Run `cd tools/coderail-watch && npm install` or use the published package via `npx coderail-watch@latest ...`.",
+    );
+    process.exit(1);
+  }
+}
+const WebSocket = WebSocketImpl;
+
 const buildWsUrl = (baseUrl, sessionId, projectKey, token) => {
   let normalized = baseUrl.trim();
   if (!normalized.startsWith("http://") && !normalized.startsWith("https://")) {
@@ -52,6 +69,7 @@ const projectKey = args["project-key"];
 const baseUrl = args["base-url"] || DEFAULT_BASE_URL;
 const token = args["token"];
 const retryWaitMs = Number(args["retry-wait"] || DEFAULT_RETRY_WAIT_MS);
+const logPath = args["log-path"];
 
 if (!sessionId || !projectKey) {
   log("Missing required args: --session-id and --project-key");
@@ -62,27 +80,84 @@ const wsUrl = buildWsUrl(baseUrl, sessionId, projectKey, token);
 let socket = null;
 let isOpen = false;
 const queue = [];
+let retryCount = 0;
+let lastErrorMessage = "";
+
+const attachHandler = (target, event, handler) => {
+  if (typeof target.on === "function") {
+    target.on(event, handler);
+    return;
+  }
+  if (typeof target.addEventListener === "function") {
+    target.addEventListener(event, handler);
+  }
+};
+
+const isSocketOpen = () => {
+  if (!socket) return false;
+  if (typeof WebSocket.OPEN === "number") {
+    return socket.readyState === WebSocket.OPEN;
+  }
+  return isOpen;
+};
 
 const connect = () => {
-  socket = new WebSocket(wsUrl);
+  retryCount += 1;
+  log(`connecting (#${retryCount})...`);
+  try {
+    socket = new WebSocket(wsUrl);
+  } catch (error) {
+    lastErrorMessage = String(error);
+    log(`connect failed: ${lastErrorMessage}`);
+    setTimeout(connect, retryWaitMs);
+    return;
+  }
 
-  socket.on("open", () => {
+  attachHandler(socket, "open", () => {
     isOpen = true;
+    retryCount = 0;
     log(`connected: ${wsUrl}`);
     while (queue.length) {
       const payload = queue.shift();
-      socket.send(payload);
+      if (!isSocketOpen()) {
+        queue.unshift(payload);
+        break;
+      }
+      try {
+        socket.send(payload);
+      } catch (error) {
+        queue.unshift(payload);
+        break;
+      }
     }
   });
 
-  socket.on("close", () => {
+  attachHandler(socket, "close", (event) => {
     isOpen = false;
-    log("disconnected; retrying...");
+    const code =
+      event && typeof event === "object" && "code" in event ? event.code : null;
+    const reason =
+      event && typeof event === "object" && "reason" in event
+        ? event.reason
+        : "";
+    const detail = [code ? `code=${code}` : null, reason || null]
+      .filter(Boolean)
+      .join(" ");
+    log(
+      `disconnected; retrying in ${retryWaitMs}ms${
+        detail ? ` (${detail})` : ""
+      }`,
+    );
     setTimeout(connect, retryWaitMs);
   });
 
-  socket.on("error", (error) => {
-    log(`error: ${error.message}`);
+  attachHandler(socket, "error", (error) => {
+    const message =
+      error && typeof error === "object" && "message" in error
+        ? error.message
+        : String(error);
+    lastErrorMessage = message;
+    log(`error: ${message}`);
   });
 };
 
@@ -93,21 +168,133 @@ const rl = readline.createInterface({
   crlfDelay: Infinity,
 });
 
-rl.on("line", (line) => {
+const enqueueOrSend = (payload) => {
+  if (isSocketOpen()) {
+    try {
+      socket.send(payload);
+      return;
+    } catch (error) {
+      queue.push(payload);
+      return;
+    }
+  }
+  queue.push(payload);
+};
+
+const handleLine = (line) => {
   const payload = JSON.stringify({
     type: "log",
     content: line,
     timestamp: new Date().toISOString(),
   });
-  if (isOpen && socket) {
-    socket.send(payload);
-  } else {
-    queue.push(payload);
+  enqueueOrSend(payload);
+  if (isErrorLine(line)) {
+    const alertPayload = JSON.stringify({
+      type: "alert",
+      content: `${ALERT_PREFIX}${line}`,
+      timestamp: new Date().toISOString(),
+    });
+    enqueueOrSend(alertPayload);
   }
-});
+};
+
+const startFileTailer = (targetPath) => {
+  let fileOffset = 0;
+  let remainder = "";
+
+  const initializeOffset = () => {
+    try {
+      const stats = fs.statSync(targetPath);
+      fileOffset = stats.size;
+      return true;
+    } catch (error) {
+      log(`log-path not found: ${targetPath} (retrying...)`);
+      return false;
+    }
+  };
+
+  const flushChunk = (chunk) => {
+    const text = `${remainder}${chunk}`;
+    const lines = text.split(/\r?\n/);
+    remainder = lines.pop() ?? "";
+    lines.forEach((line) => {
+      if (line.length > 0) {
+        handleLine(line);
+      }
+    });
+  };
 
-rl.on("close", () => {
-  if (socket) {
-    socket.close();
+  const readNewData = () => {
+    fs.stat(targetPath, (error, stats) => {
+      if (error) {
+        log(`log-path read error: ${error.message || String(error)}`);
+        return;
+      }
+      if (stats.size < fileOffset) {
+        fileOffset = 0;
+      }
+      if (stats.size === fileOffset) {
+        return;
+      }
+      const stream = fs.createReadStream(targetPath, {
+        start: fileOffset,
+        end: stats.size - 1,
+        encoding: "utf8",
+      });
+      stream.on("data", flushChunk);
+      stream.on("end", () => {
+        fileOffset = stats.size;
+      });
+      stream.on("error", (streamError) => {
+        log(
+          `log-path stream error: ${
+            streamError.message || String(streamError)
+          }`,
+        );
+      });
+    });
+  };
+
+  const startWatcher = () => {
+    try {
+      fs.watch(targetPath, { persistent: true }, (eventType) => {
+        if (eventType === "change") {
+          readNewData();
+        }
+      });
+    } catch (error) {
+      log(`log-path watch error: ${error.message || String(error)}`);
+    }
+  };
+
+  if (!initializeOffset()) {
+    const retryTimer = setInterval(() => {
+      if (initializeOffset()) {
+        clearInterval(retryTimer);
+        startWatcher();
+      }
+    }, retryWaitMs);
+    return;
   }
-});
+
+  startWatcher();
+};
+
+if (logPath) {
+  startFileTailer(logPath);
+} else {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    crlfDelay: Infinity,
+  });
+
+  rl.on("line", (line) => {
+    handleLine(line);
+  });
+
+  rl.on("close", () => {
+    if (socket) {
+      socket.close();
+    }
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coderail-watch",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Stream terminal output to CodeRail backend over WebSocket.",
   "bin": {
     "coderail-watch": "bin/coderail-watch.js"