coderail-watch 0.1.3 → 0.1.5

package/README.md

@@ -8,6 +8,18 @@ Usage:
 npx coderail-watch --session-id <session_id> --project-key <project_public_id> --base-url http://localhost:8000
 ```
 
+Switch base URL by env:
+
+```bash
+npx coderail-watch --session-id <session_id> --project-key <project_public_id> --env staging
+```
+
+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,9 +1,15 @@
 #!/usr/bin/env node
 "use strict";
 
+const fs = require("fs");
 const readline = require("readline");
 
 const DEFAULT_BASE_URL = "http://localhost:8000";
+const ENV_BASE_URLS = {
+  local: "http://localhost:8000",
+  staging: "https://api.dev-coderail.local",
+  production: "https://api.coderail.local",
+};
 const DEFAULT_RETRY_WAIT_MS = 2000;
 const ALERT_PREFIX = "[[CODERAIL_ERROR]] ";
 const ERROR_PATTERN = /(^|[\s:])(?:error|exception|traceback|panic|fatal)(?=[\s:])/i;
@@ -65,15 +71,26 @@ const buildWsUrl = (baseUrl, sessionId, projectKey, token) => {
 const args = parseArgs(process.argv.slice(2));
 const sessionId = args["session-id"];
 const projectKey = args["project-key"];
-const baseUrl = args["base-url"] || DEFAULT_BASE_URL;
+const env = args["env"];
+const baseUrl =
+  args["base-url"] ||
+  (env && ENV_BASE_URLS[env] ? ENV_BASE_URLS[env] : 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");
   process.exit(1);
 }
 
+if (env && !ENV_BASE_URLS[env]) {
+  log(
+    `Unknown env '${env}'. Use one of: ${Object.keys(ENV_BASE_URLS).join(", ")}`,
+  );
+  process.exit(1);
+}
+
 const wsUrl = buildWsUrl(baseUrl, sessionId, projectKey, token);
 let socket = null;
 let isOpen = false;
@@ -179,7 +196,7 @@ const enqueueOrSend = (payload) => {
   queue.push(payload);
 };
 
-rl.on("line", (line) => {
+const handleLine = (line) => {
   const payload = JSON.stringify({
     type: "log",
     content: line,
@@ -194,10 +211,105 @@ rl.on("line", (line) => {
     });
     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);
+      }
+    });
+  };
+
+  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)}`);
+    }
+  };
 
-rl.on("close", () => {
-  if (socket) {
-    socket.close();
+  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.3",
+  "version": "0.1.5",
   "description": "Stream terminal output to CodeRail backend over WebSocket.",
   "bin": {
     "coderail-watch": "bin/coderail-watch.js"