coderail-watch 0.1.7 → 0.1.8

package/README.md

@@ -36,6 +36,23 @@ npm version patch
 npm run publish:public
 ```
 
+If publish fails with "Access token expired or revoked":
+
+```bash
+cd tools/coderail-watch
+npm logout
+npm login
+npm run publish:public
+```
+
+If you use an npm access token (CI or 2FA), set it explicitly:
+
+```bash
+cd tools/coderail-watch
+npm config set //registry.npmjs.org/:_authToken <YOUR_NPM_TOKEN>
+npm run publish:public
+```
+
 2FA note:
 
 - npm no longer allows adding new TOTP 2FA from the CLI. Enable 2FA with a security key at https://npmjs.com/settings/<your-username>/tfa before publishing.

package/bin/coderail-watch.js

@@ -2,17 +2,39 @@
 "use strict";
 
 const fs = require("fs");
+const path = require("path");
 const readline = require("readline");
 
-const DEFAULT_BASE_URL = "http://localhost:8000";
+const DEFAULT_BASE_URL = "https://api.dev-coderail.local";
 const ENV_BASE_URLS = {
-  local: "http://localhost:8000",
+  local: "https://api.dev-coderail.local",
   staging: "https://ai-tutor-backend-stg-673992211852.asia-northeast1.run.app",
   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;
+const DEFAULT_PROJECT_TREE_MAX_FILES = 1000;
+const DEFAULT_PROJECT_TREE_MAX_BYTES = 4096;
+const PROJECT_TREE_EXTENSIONS = new Set([".py", ".js"]);
+const OPENAI_CHAT_API_URL = "https://api.openai.com/v1/chat/completions";
+const DEFAULT_OPENAI_MODEL = "gpt-4o-mini";
+const DEFAULT_SNAPSHOT_EXCLUDES = new Set([
+  ".git",
+  "node_modules",
+  ".venv",
+  "venv",
+  ".next",
+  "dist",
+  "build",
+  "tests",
+]);
+const DEFAULT_SNAPSHOT_EXCLUDE_PREFIXES = new Set([
+  "frontend/.next",
+  "backend/.venv",
+  "backend/.pytest_cache",
+]);
+const SNAPSHOT_EXCLUDE_PREFIXES = Array.from(DEFAULT_SNAPSHOT_EXCLUDE_PREFIXES);
 
 const isErrorLine = (line) => ERROR_PATTERN.test(line);
 
@@ -50,12 +72,21 @@ if (!WebSocketImpl) {
 }
 const WebSocket = WebSocketImpl;
 
-const buildWsUrl = (baseUrl, sessionId, projectKey, token) => {
+const normalizeHttpBaseUrl = (baseUrl) => {
   let normalized = baseUrl.trim();
   if (!normalized.startsWith("http://") && !normalized.startsWith("https://")) {
     normalized = `http://${normalized}`;
   }
-  const url = new URL(normalized);
+  return normalized;
+};
+
+const normalizeBaseHttpUrl = (baseUrl) => {
+  const normalized = normalizeHttpBaseUrl(baseUrl);
+  return normalized.replace(/\/$/, "");
+};
+
+const buildWsUrl = (baseUrl, sessionId, projectKey, token) => {
+  const url = new URL(normalizeHttpBaseUrl(baseUrl));
   const wsProtocol = url.protocol === "https:" ? "wss:" : "ws:";
   url.protocol = wsProtocol;
   url.pathname = `${url.pathname.replace(/\/$/, "")}/api/v1/terminal_watch/ws`;
@@ -68,35 +99,242 @@ const buildWsUrl = (baseUrl, sessionId, projectKey, token) => {
   return url.toString();
 };
 
+const normalizeBoolArg = (value, defaultValue) => {
+  if (value === undefined) return defaultValue;
+  return value !== "false";
+};
+
+const normalizeTrueArg = (value) => value === "true";
+
+const normalizeIntArg = (value, fallback, minValue) => {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed < minValue) return fallback;
+  return Math.floor(parsed);
+};
+
+const resolveBaseUrl = (args) => {
+  const env = args["env"];
+  if (env && !ENV_BASE_URLS[env]) {
+    throw new Error(
+      `Unknown env '${env}'. Use one of: ${Object.keys(ENV_BASE_URLS).join(", ")}`,
+    );
+  }
+  return (
+    args["base-url"] ||
+    (env ? ENV_BASE_URLS[env] : null) ||
+    DEFAULT_BASE_URL
+  );
+  return normalizeHttpBaseUrl(rawBaseUrl);
+};
+
+const isExcludedPath = (relPath, entryName, excludes) => {
+  if (!relPath) return true;
+  if (excludes.has(entryName)) return true;
+  if (entryName.startsWith(".")) return true;
+  if (DEFAULT_SNAPSHOT_EXCLUDE_PREFIXES.has(relPath)) return true;
+  if (SNAPSHOT_EXCLUDE_PREFIXES.some((prefix) => relPath.startsWith(`${prefix}/`))) {
+    return true;
+  }
+  return false;
+};
+
+const collectSnapshotPaths = (rootDir, excludes) => {
+  const results = [];
+  const queue = [rootDir];
+  while (queue.length) {
+    const current = queue.pop();
+    if (!current) continue;
+    let entries = [];
+    try {
+      entries = fs.readdirSync(current, { withFileTypes: true });
+    } catch (error) {
+      log(`snapshot read failed: ${current} (${error})`);
+      continue;
+    }
+    for (const entry of entries) {
+      const fullPath = path.join(current, entry.name);
+      const relPath = path.relative(rootDir, fullPath).replace(/\\/g, "/");
+      if (isExcludedPath(relPath, entry.name, excludes)) continue;
+      if (entry.isSymbolicLink && entry.isSymbolicLink()) continue;
+      if (entry.isDirectory()) {
+        queue.push(fullPath);
+        continue;
+      }
+      if (entry.isFile()) {
+        const ext = path.extname(entry.name).toLowerCase();
+        if (PROJECT_TREE_EXTENSIONS.has(ext)) {
+          results.push(relPath);
+        }
+      }
+    }
+  }
+  return results.sort();
+};
+
+const extractApiEndpointItems = (jsonText) => {
+  if (!jsonText) return [];
+  let parsed = null;
+  try {
+    parsed = JSON.parse(jsonText);
+  } catch (error) {
+    return [];
+  }
+  const raw = Array.isArray(parsed) ? parsed : parsed?.endpoints;
+  if (!Array.isArray(raw)) return [];
+  const endpoints = [];
+  for (const item of raw) {
+    if (typeof item === "string") {
+      const trimmed = item.trim();
+      if (trimmed) endpoints.push(trimmed);
+      continue;
+    }
+    if (!item || typeof item !== "object") continue;
+    const method = String(item.method || "").trim().toUpperCase();
+    const pathValue = String(item.path || "").trim();
+    if (!pathValue) continue;
+    endpoints.push(method ? `${method} ${pathValue}` : pathValue);
+  }
+  return endpoints;
+};
+
+const isBinaryBuffer = (buffer) => buffer.includes(0);
+
+const buildProjectTreeLines = (
+  rootDir,
+  excludes,
+  maxFiles,
+  includeContents,
+  maxBytes,
+) => {
+  const paths = collectSnapshotPaths(rootDir, excludes);
+  const limited = paths.slice(0, maxFiles);
+  const lines = [
+    "[project-tree] listing files",
+    `[project-tree] root=${rootDir}`,
+    `[project-tree] total=${paths.length} shown=${limited.length}`,
+  ];
+  for (const relPath of limited) {
+    lines.push(`- ${relPath}`);
+    if (!includeContents) {
+      continue;
+    }
+    const fullPath = path.join(rootDir, relPath);
+    let content = "";
+    try {
+      const buffer = fs.readFileSync(fullPath);
+      if (isBinaryBuffer(buffer)) {
+        lines.push(`(binary skipped) ${relPath}`);
+        continue;
+      }
+      content = buffer.toString("utf8");
+    } catch (error) {
+      lines.push(`(read failed) ${relPath}: ${error}`);
+      continue;
+    }
+    if (!content) {
+      lines.push(`(empty) ${relPath}`);
+      continue;
+    }
+    const slice = content.slice(0, maxBytes);
+    lines.push(`----- ${relPath} (first ${slice.length} chars) -----`);
+    lines.push(slice);
+    if (content.length > maxBytes) {
+      lines.push(`----- ${relPath} (truncated) -----`);
+    }
+  }
+  if (paths.length > limited.length) {
+    lines.push(`[project-tree] truncated: ${paths.length - limited.length} more`);
+  }
+  return lines;
+};
+
 const args = parseArgs(process.argv.slice(2));
 const sessionId = args["session-id"];
 const projectKey = args["project-key"];
-const env = args["env"];
-const baseUrl =
-  args["base-url"] ||
-  (env && ENV_BASE_URLS[env] ? ENV_BASE_URLS[env] : DEFAULT_BASE_URL);
+let baseUrl = "";
+try {
+  baseUrl = resolveBaseUrl(args);
+} catch (error) {
+  log(error.message || String(error));
+  process.exit(1);
+}
 const token = args["token"];
-const retryWaitMs = Number(args["retry-wait"] || DEFAULT_RETRY_WAIT_MS);
+const retryWaitMs = normalizeIntArg(
+  args["retry-wait"],
+  DEFAULT_RETRY_WAIT_MS,
+  0,
+);
 const logPath = args["log-path"];
+const projectRoot = path.resolve(args["project-root"] || process.cwd());
+const sendProjectTree = normalizeBoolArg(args["project-tree"], true);
+const includeProjectTreeContents = normalizeTrueArg(
+  args["project-tree-contents"],
+);
+const projectTreeMaxFiles = normalizeIntArg(
+  args["project-tree-max-files"],
+  DEFAULT_PROJECT_TREE_MAX_FILES,
+  1,
+);
+const projectTreeMaxBytes = normalizeIntArg(
+  args["project-tree-max-bytes"],
+  DEFAULT_PROJECT_TREE_MAX_BYTES,
+  1,
+);
+const enableApiCheck = normalizeBoolArg(args["api-llm-check"], true);
+const enableScreenCheck = normalizeBoolArg(args["screen-check"], true);
+const dotenvPath = args["env-file"] || path.join(projectRoot, ".env");
+const loadEnvFile = (filePath) => {
+  try {
+    const raw = fs.readFileSync(filePath, "utf8");
+    const entries = {};
+    raw.split(/\r?\n/).forEach((line) => {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) return;
+      const idx = trimmed.indexOf("=");
+      if (idx <= 0) return;
+      const key = trimmed.slice(0, idx).trim();
+      let value = trimmed.slice(idx + 1).trim();
+      if (
+        (value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))
+      ) {
+        value = value.slice(1, -1);
+      }
+      entries[key] = value;
+    });
+    return entries;
+  } catch (error) {
+    return {};
+  }
+};
+const envFromFile = loadEnvFile(dotenvPath);
+const openaiApiKey =
+  args["openai-api-key"] ||
+  process.env.OPENAI_API_KEY ||
+  envFromFile.OPENAI_API_KEY ||
+  "";
+const openaiModel =
+  args["openai-model"] ||
+  process.env.OPENAI_MODEL ||
+  envFromFile.OPENAI_MODEL ||
+  DEFAULT_OPENAI_MODEL;
+const apiEndpointUrl = `${baseUrl.replace(/\/$/, "")}/api/v1/projects/${encodeURIComponent(
+  projectKey,
+)}/api_endpoint_list`;
+let apiEndpointCandidatesCached = [];
 
 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;
 const queue = [];
 let retryCount = 0;
 let lastErrorMessage = "";
+let apiCheckInFlight = false;
 
 const attachHandler = (target, event, handler) => {
   if (typeof target.on === "function") {
@@ -132,6 +370,20 @@ const connect = () => {
     isOpen = true;
     retryCount = 0;
     log(`connected: ${wsUrl}`);
+    if (sendProjectTree) {
+      emitProjectTree();
+    }
+    if (enableApiCheck) {
+      void (async () => {
+        if (!apiEndpointCandidatesCached.length) {
+          await fetchApiEndpointList();
+        }
+        logApiCheckStatus();
+        if (apiEndpointCandidatesCached.length) {
+          await runApiCheck();
+        }
+      })();
+    }
     while (queue.length) {
       const payload = queue.shift();
       if (!isSocketOpen()) {
@@ -147,6 +399,38 @@ const connect = () => {
     }
   });
 
+  attachHandler(socket, "message", (event) => {
+    const raw =
+      event && typeof event === "object" && "data" in event ? event.data : event;
+    if (!raw) return;
+    const text =
+      typeof raw === "string"
+        ? raw
+        : typeof raw.toString === "function"
+          ? raw.toString()
+          : "";
+    if (!text || !text.trim().startsWith("{")) return;
+    let payload = null;
+    try {
+      payload = JSON.parse(text);
+    } catch (error) {
+      return;
+    }
+    if (!payload || typeof payload !== "object") return;
+    if (payload.type !== "control") return;
+    if (payload.action === "api_check") {
+      void triggerApiCheck("control");
+      return;
+    }
+    if (payload.action === "screen_check") {
+      if (enableScreenCheck) {
+        void triggerScreenCheck("control");
+      } else {
+        sendScreenCheckLine("screen check disabled; skipping.");
+      }
+    }
+  });
+
   attachHandler(socket, "close", (event) => {
     isOpen = false;
     const code =
@@ -196,6 +480,38 @@ const enqueueOrSend = (payload) => {
   queue.push(payload);
 };
 
+const sendLogLine = (line) => {
+  const payload = JSON.stringify({
+    type: "log",
+    content: line,
+    timestamp: new Date().toISOString(),
+  });
+  enqueueOrSend(payload);
+};
+
+const sendApiCheckLine = (line) => {
+  const tagged = `[api-check] ${line}`;
+  log(tagged);
+  sendLogLine(tagged);
+};
+
+const sendScreenCheckLine = (line) => {
+  const tagged = `[screen-check] ${line}`;
+  log(tagged);
+  sendLogLine(tagged);
+};
+
+const logApiCheckStatus = () => {
+  const maskedKey = openaiApiKey ? `${openaiApiKey.slice(0, 6)}...` : "";
+  sendApiCheckLine(
+    `必須チェック: api_endpoint_list=${
+      apiEndpointCandidatesCached.length ? "OK" : "NG"
+    } openai_api_key=${openaiApiKey ? "OK" : "NG"} ${
+      maskedKey ? `(${maskedKey})` : ""
+    } openai_model=${openaiModel ? "OK" : "NG"}`,
+  );
+};
+
 const handleLine = (line) => {
   const payload = JSON.stringify({
     type: "log",
@@ -213,6 +529,269 @@ const handleLine = (line) => {
   }
 };
 
+const emitProjectTree = () => {
+  const lines = buildProjectTreeLines(
+    projectRoot,
+    DEFAULT_SNAPSHOT_EXCLUDES,
+    projectTreeMaxFiles,
+    includeProjectTreeContents,
+    projectTreeMaxBytes,
+  );
+  lines.forEach((line) => {
+    log(line);
+    sendLogLine(line);
+  });
+};
+
+const buildApiCheckPrompt = (endpoints, treeLines) => {
+  return [
+    "You are a senior backend engineer. Determine which API endpoints are NOT implemented in the codebase.",
+    "Use the file tree (and optional file excerpts) to infer whether each endpoint is implemented.",
+    "If unsure, mark as 'unknown'.",
+    "Return JSON only: {\"missing\": [{\"endpoint\": \"METHOD /path\", \"reason\": \"...\", \"confidence\": 0-1}], \"unknown\": [\"METHOD /path\"], \"implemented\": [\"METHOD /path\"]}",
+    "",
+    "API endpoints:",
+    ...endpoints.map((item) => `- ${item}`),
+    "",
+    "Project files:",
+    ...treeLines,
+  ].join("\n");
+};
+
+const collectTreeForApiCheck = () => {
+  return buildProjectTreeLines(
+    projectRoot,
+    DEFAULT_SNAPSHOT_EXCLUDES,
+    projectTreeMaxFiles,
+    includeProjectTreeContents,
+    projectTreeMaxBytes,
+  );
+};
+
+const runApiCheck = async () => {
+  if (!enableApiCheck) return;
+  if (!apiEndpointCandidatesCached.length) return;
+  if (!openaiApiKey) {
+    sendApiCheckLine("OPENAI_API_KEY is not set; skipping API check.");
+    return;
+  }
+  if (!openaiModel) {
+    sendApiCheckLine("OPENAI_MODEL is not set; skipping API check.");
+    return;
+  }
+  if (typeof fetch !== "function") {
+    sendApiCheckLine("fetch is not available in this runtime; skipping API check.");
+    return;
+  }
+  const treeLines = collectTreeForApiCheck();
+  const prompt = buildApiCheckPrompt(apiEndpointCandidatesCached, treeLines);
+  const payload = {
+    model: openaiModel,
+    messages: [
+      {
+        role: "system",
+        content:
+          "You return strictly valid JSON. Do not wrap in markdown or add commentary.",
+      },
+      { role: "user", content: prompt },
+    ],
+    temperature: 0.2,
+  };
+  let response = null;
+  try {
+    response = await fetch(OPENAI_CHAT_API_URL, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${openaiApiKey}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(payload),
+    });
+  } catch (error) {
+    sendApiCheckLine(`OpenAI request failed: ${error}`);
+    return;
+  }
+  if (!response.ok) {
+    const text = await response.text();
+    sendApiCheckLine(
+      `OpenAI request failed: ${response.status} ${response.statusText}`,
+    );
+    sendApiCheckLine(text.slice(0, 1000));
+    return;
+  }
+  let data = null;
+  try {
+    data = await response.json();
+  } catch (error) {
+    sendApiCheckLine(`OpenAI response parse failed: ${error}`);
+    return;
+  }
+  const content = data?.choices?.[0]?.message?.content?.trim();
+  if (!content) {
+    sendApiCheckLine("OpenAI response was empty.");
+    return;
+  }
+  try {
+    const parsed = JSON.parse(content);
+    const missing = Array.isArray(parsed?.missing) ? parsed.missing : [];
+    const unknown = Array.isArray(parsed?.unknown) ? parsed.unknown : [];
+    const implemented = Array.isArray(parsed?.implemented)
+      ? parsed.implemented
+      : [];
+    sendApiCheckLine(
+      `missing=${missing.length} unknown=${unknown.length} implemented=${implemented.length}`,
+    );
+    missing.forEach((item) => {
+      if (item && typeof item === "object") {
+        sendApiCheckLine(
+          `missing: ${item.endpoint || ""} (${item.reason || "no reason"})`,
+        );
+      } else {
+        sendApiCheckLine(`missing: ${String(item)}`);
+      }
+    });
+    unknown.forEach((item) => sendApiCheckLine(`unknown: ${String(item)}`));
+    implemented.forEach((item) =>
+      sendApiCheckLine(`implemented: ${String(item)}`),
+    );
+  } catch (error) {
+    sendApiCheckLine("OpenAI output was not valid JSON. Raw output:");
+    sendApiCheckLine(content.slice(0, 2000));
+  }
+};
+
+const screenCheckUrl = `${normalizeBaseHttpUrl(baseUrl)}/api/v1/project_snapshot/check`;
+
+const runScreenCheck = async () => {
+  if (!projectKey) {
+    sendScreenCheckLine("project_key is missing; skipping screen check.");
+    return;
+  }
+  if (typeof fetch !== "function") {
+    sendScreenCheckLine("fetch is not available in this runtime; skipping screen check.");
+    return;
+  }
+  const paths = collectSnapshotPaths(projectRoot, DEFAULT_SNAPSHOT_EXCLUDES);
+  const limitedPaths = paths.slice(0, projectTreeMaxFiles);
+  const payload = {
+    projectPublicId: projectKey,
+    paths: limitedPaths,
+  };
+  let response = null;
+  try {
+    response = await fetch(screenCheckUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload),
+    });
+  } catch (error) {
+    sendScreenCheckLine(`screen check request failed: ${error}`);
+    return;
+  }
+  if (!response.ok) {
+    const text = await response.text();
+    sendScreenCheckLine(
+      `screen check failed: ${response.status} ${response.statusText}`,
+    );
+    sendScreenCheckLine(text.slice(0, 1000));
+    return;
+  }
+  let data = null;
+  try {
+    data = await response.json();
+  } catch (error) {
+    sendScreenCheckLine(`screen check response parse failed: ${error}`);
+    return;
+  }
+  const expected = Array.isArray(data?.expectedScreens) ? data.expectedScreens : [];
+  const missing = Array.isArray(data?.check?.missingScreens)
+    ? data.check.missingScreens
+    : [];
+  const implemented = expected.filter((item) => !missing.includes(item));
+  sendScreenCheckLine(
+    `missing_screens=${missing.length} expected=${expected.length} implemented=${implemented.length}`,
+  );
+  missing.forEach((item) => sendScreenCheckLine(`missing: ${String(item)}`));
+  implemented.forEach((item) =>
+    sendScreenCheckLine(`implemented: ${String(item)}`),
+  );
+  if (data?.check?.notes) {
+    sendScreenCheckLine(`note: ${String(data.check.notes)}`);
+  }
+};
+
+const triggerApiCheck = async (reason) => {
+  if (apiCheckInFlight) return;
+  apiCheckInFlight = true;
+  try {
+    sendApiCheckLine(`api-check start (${reason})`);
+    if (!apiEndpointCandidatesCached.length) {
+      await fetchApiEndpointList();
+    }
+    logApiCheckStatus();
+    if (!apiEndpointCandidatesCached.length) {
+      sendApiCheckLine("api_endpoint_list is empty; skipping api-check.");
+      return;
+    }
+    await runApiCheck();
+  } finally {
+    apiCheckInFlight = false;
+  }
+};
+
+const triggerScreenCheck = async (reason) => {
+  try {
+    sendScreenCheckLine(`screen-check start (${reason})`);
+    await runScreenCheck();
+  } catch (error) {
+    sendScreenCheckLine(`screen-check failed: ${error}`);
+  }
+};
+
+const fetchApiEndpointList = async () => {
+  if (!apiEndpointUrl) return [];
+  if (typeof fetch !== "function") {
+    sendApiCheckLine("fetch is not available in this runtime; skipping fetch.");
+    return [];
+  }
+  try {
+    const response = await fetch(apiEndpointUrl, {
+      method: "GET",
+      headers: { "Content-Type": "application/json" },
+    });
+    if (!response.ok) {
+      let detail = "";
+      try {
+        detail = await response.text();
+      } catch (error) {
+        detail = "";
+      }
+      const detailSnippet = detail ? ` detail=${detail.slice(0, 200)}` : "";
+      sendApiCheckLine(
+        `api_endpoint_list取得失敗: ${response.status} ${response.statusText} (${apiEndpointUrl})${detailSnippet}`,
+      );
+      return [];
+    }
+    const data = await response.json();
+    if (data?.api_endpoint_list) {
+      apiEndpointCandidatesCached = extractApiEndpointItems(
+        data.api_endpoint_list,
+      );
+      return apiEndpointCandidatesCached;
+    }
+    if (Array.isArray(data?.endpoints)) {
+      apiEndpointCandidatesCached = extractApiEndpointItems(
+        JSON.stringify({ endpoints: data.endpoints }),
+      );
+      return apiEndpointCandidatesCached;
+    }
+    return [];
+  } catch (error) {
+    sendApiCheckLine(`api_endpoint_list fetch error: ${error}`);
+    return [];
+  }
+};
+
 const startFileTailer = (targetPath) => {
   let fileOffset = 0;
   let remainder = "";

package/package.json

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