@ar-ai/brink-cli 0.0.0-stage → 1.0.4

package/support/monitor.js

@@ -0,0 +1,443 @@
+"use strict";
+
+const LOG_LIMIT = 400;
+const HISTORY_LIMIT = 100;
+const MODEL_LIMIT = 64;
+const { stripVTControlCharacters } = require("node:util");
+
+function safeText(value, limit = 400) {
+  return stripVTControlCharacters(String(value ?? ""))
+    .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "")
+    .replace(/\bBearer\s+\S+/gi, "Bearer [redacted]")
+    .replace(/\bsk-[A-Za-z0-9_-]+/g, "[redacted]")
+    .replace(
+      /((?:api[_-]?key|token|authorization|secret)\s*[=:]\s*)[^\s,;]+/gi,
+      "$1[redacted]",
+    )
+    .replace(/https?:\/\/[^\s]+/g, (url) => {
+      try {
+        const parsed = new URL(url);
+        return parsed.origin + parsed.pathname;
+      } catch {
+        return "[url]";
+      }
+    })
+    .replace(/[\x00-\x1f\x7f-\x9f\u202a-\u202e\u2066-\u2069]/g, " ")
+    .slice(0, limit);
+}
+
+function createMonitor({ port }) {
+  const startedAt = Date.now();
+  const active = new Map();
+  const recent = [];
+  const models = new Map();
+  const logs = [];
+  const progress = new Map();
+  const listeners = new Set();
+  const totals = {
+    requests: 0,
+    completed: 0,
+    failed: 0,
+    cancelled: 0,
+    bytes: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    cachedTokens: 0,
+    reasoningTokens: 0,
+    usageRequests: 0,
+  };
+  let nextRequest = 0;
+  let nextLog = 0;
+  let timer = null;
+  let closed = false;
+
+  function modelStats(model) {
+    if (models.has(model)) return models.get(model);
+    if (models.size >= MODEL_LIMIT) {
+      const idle = [...models.values()]
+        .filter((entry) => entry.active === 0)
+        .sort((a, b) => a.lastSeen - b.lastSeen)[0];
+      if (idle) models.delete(idle.model);
+      else return null;
+    }
+    const entry = {
+      model,
+      requests: 0,
+      completed: 0,
+      failed: 0,
+      cancelled: 0,
+      bytes: 0,
+      inputTokens: 0,
+      outputTokens: 0,
+      cachedTokens: 0,
+      reasoningTokens: 0,
+      usageRequests: 0,
+      active: 0,
+      lastSeen: Date.now(),
+    };
+    models.set(model, entry);
+    return entry;
+  }
+
+  function snapshot() {
+    const now = Date.now();
+    const running = [...active.values()].map((item) => ({
+      ...item,
+      activity: {
+        ...item.activity,
+        tools: item.activity.tools.map((tool) => ({ ...tool })),
+      },
+      durationMs: now - item.startedAt,
+    }));
+    const insights = [];
+    for (const item of running) {
+      if (item.firstByteMs === null && now - item.startedAt > 30000) {
+        insights.push({
+          level: "warn",
+          message: `${item.model}: waiting ${Math.floor((now - item.startedAt) / 1000)}s for output; long reasoning can be silent. No duplicate request sent.`,
+        });
+      }
+    }
+    const failure = recent.find(
+      (item) => item.state === "failed" && now - item.endedAt < 120000,
+    );
+    if (failure) {
+      const advice =
+        failure.status === 429
+          ? "Rate limited upstream. Wait before sending another request."
+          : [401, 403].includes(failure.status)
+            ? "Check the provider key and model access permissions."
+            : failure.status >= 500
+              ? "Upstream/channel error. No model substitution was made."
+              : "Request failed; inspect the correlated log entry.";
+      insights.push({ level: "warn", message: `${failure.model}: ${advice}` });
+    }
+    if (running.length > 1)
+      insights.push({
+        level: "info",
+        message: `${running.length} concurrent requests; each retains its selected model and route.`,
+      });
+    return {
+      startedAt,
+      now,
+      port,
+      totals: { ...totals },
+      active: running,
+      recent: recent.map((item) => ({
+        ...item,
+        activity: {
+          ...item.activity,
+          tools: item.activity.tools.map((tool) => ({ ...tool })),
+        },
+      })),
+      models: [...models.values()]
+        .map((item) => ({ ...item }))
+        .sort((a, b) => b.lastSeen - a.lastSeen),
+      logs: [...logs],
+      insights: insights.slice(0, 6),
+    };
+  }
+
+  function publish() {
+    timer = null;
+    if (!listeners.size || closed) return;
+    const state = snapshot();
+    for (const listener of listeners) listener(state);
+  }
+  function schedule() {
+    if (closed || timer || !listeners.size) return;
+    timer = setTimeout(publish, 250);
+    timer.unref();
+  }
+  // Only active requests need periodic elapsed/waiting-state updates.
+  const tick = setInterval(() => {
+    const now = Date.now();
+    for (const item of active.values()) {
+      const previous = progress.get(item.id);
+      if (!previous || now - previous.time < 10000) continue;
+      const received = item.bytes - previous.bytes;
+      const status = item.completionObserved
+        ? "response completed; waiting for connection close"
+        : item.firstByteMs === null
+          ? "waiting for first response byte"
+          : received > 0
+            ? "streaming"
+            : "stream open; no new bytes in this interval";
+      log(
+        "info",
+        `${status} · ${Math.floor((now - item.startedAt) / 1000)}s elapsed · +${received} bytes · ${item.inputTokens ?? "?"} in / ${item.outputTokens ?? "?"} out tokens`,
+        item,
+      );
+      previous.time = now;
+      previous.bytes = item.bytes;
+    }
+    if (active.size) schedule();
+  }, 1000);
+  tick.unref();
+
+  function log(level, message, request) {
+    const entry = {
+      id: ++nextLog,
+      time: Date.now(),
+      level: ["info", "warn", "error"].includes(level) ? level : "info",
+      message: safeText(message),
+    };
+    if (request) {
+      entry.requestId = request.id;
+      entry.model = request.model;
+    }
+    logs.push(entry);
+    if (logs.length > LOG_LIMIT) logs.shift();
+    // A terminal subscriber owns stdout while the alternate screen is active.
+    if (!listeners.size) {
+      const method =
+        entry.level === "error"
+          ? "error"
+          : entry.level === "warn"
+            ? "warn"
+            : "log";
+      console[method](
+        `${new Date(entry.time).toLocaleTimeString()} ${entry.level.toUpperCase()}${request ? ` [${request.id}] ${request.model}` : ""} ${entry.message}`,
+      );
+    }
+    schedule();
+  }
+
+  function begin(req, res, { model, route, path: requestPath }) {
+    const now = Date.now();
+    const routePath = String(requestPath || "").split("?")[0];
+    const displayPath = [
+      "/v1/responses",
+      "/v1/chat/completions",
+      "/v1/messages",
+      "/v1/messages/count_tokens",
+      "/responses",
+      "/messages",
+    ].includes(routePath)
+      ? routePath
+      : "other";
+    const item = {
+      id: `r${++nextRequest}`,
+      model: safeText(model || "unknown", 128),
+      route: ["claude-bridge", "messages-bridge", "native-messages"].includes(route) ? route : "native",
+      path: displayPath,
+      startedAt: now,
+      endedAt: null,
+      state: "waiting",
+      status: null,
+      bytes: 0,
+      firstByteMs: null,
+      durationMs: 0,
+      error: null,
+      inputTokens: null,
+      outputTokens: null,
+      cachedTokens: null,
+      reasoningTokens: null,
+      completionObserved: false,
+      clientDisconnected: false,
+      activity: {
+        phase: "waiting",
+        assistant: "",
+        summary: "",
+        tools: [],
+        updatedAt: now,
+      },
+    };
+    const stats = modelStats(item.model);
+    active.set(item.id, item);
+    progress.set(item.id, { time: now, bytes: 0 });
+    totals.requests++;
+    if (stats) {
+      stats.requests++;
+      stats.active++;
+      stats.lastSeen = now;
+    }
+    let settled = false;
+    let failed = false;
+    const originalWrite = res.write;
+    const originalEnd = res.end;
+    const previewBuffers = { assistant: "", summary: "" };
+    const previewIds = { assistant: null, summary: null };
+    function activity(update) {
+      if (settled || !update || typeof update !== "object") return;
+      const preview = item.activity;
+      if (update.kind === "assistant" || update.kind === "summary") {
+        if (typeof update.text !== "string") return;
+        const kind = update.kind;
+        const limit = kind === "assistant" ? 1600 : 800;
+        const id = safeText(update.id, 160);
+        if (previewIds[kind] !== id || update.replace)
+          previewBuffers[kind] = "";
+        previewIds[kind] = id;
+        // Redact after joining deltas so split credential/escape sequences
+        // are not retained in the final visible preview. No preview enters logs.
+        previewBuffers[kind] = (previewBuffers[kind] + update.text).slice(
+          -(limit + 512),
+        );
+        preview[kind] = safeText(previewBuffers[kind], limit + 512).slice(
+          -limit,
+        );
+        preview.phase = kind === "assistant" ? "speaking" : "summary";
+      } else if (update.kind === "tool") {
+        const id = safeText(update.id, 160);
+        let entry = preview.tools.find((tool) => tool.id === id);
+        if (!entry) {
+          entry = { id, name: "tool", status: "preparing" };
+          preview.tools.push(entry);
+          if (preview.tools.length > 8) preview.tools.shift();
+        }
+        entry.name = safeText(update.name || "tool", 120);
+        entry.status =
+          update.status === "requested" ? "requested" : "preparing";
+        preview.phase = "tool";
+      } else if (update.kind === "reasoning") {
+        preview.phase = "reasoning";
+      } else return;
+      preview.updatedAt = Date.now();
+      schedule();
+    }
+    function count(chunk, encoding) {
+      if (chunk == null || typeof chunk === "function") return;
+      const bytes =
+        typeof chunk === "string"
+          ? Buffer.byteLength(
+              chunk,
+              typeof encoding === "string" ? encoding : "utf8",
+            )
+          : chunk.byteLength || 0;
+      if (!bytes) return;
+      item.bytes += bytes;
+      totals.bytes += bytes;
+      if (stats) stats.bytes += bytes;
+      if (item.firstByteMs === null) {
+        item.firstByteMs = Date.now() - item.startedAt;
+        if (!failed) item.state = "streaming";
+      }
+      schedule();
+    }
+    res.write = function (chunk, encoding, callback) {
+      count(chunk, encoding);
+      return originalWrite.call(this, chunk, encoding, callback);
+    };
+    res.end = function (chunk, encoding, callback) {
+      count(chunk, encoding);
+      return originalEnd.call(this, chunk, encoding, callback);
+    };
+    function usage(report) {
+      if (settled || !report || typeof report !== "object") return;
+      const values = {
+        inputTokens: report.prompt_tokens ?? report.input_tokens,
+        outputTokens: report.completion_tokens ?? report.output_tokens,
+        cachedTokens:
+          report.prompt_tokens_details?.cached_tokens ??
+          report.input_tokens_details?.cached_tokens ??
+          report.cache_read_input_tokens,
+        reasoningTokens:
+          report.completion_tokens_details?.reasoning_tokens ??
+          report.output_tokens_details?.reasoning_tokens,
+      };
+      const first = item.inputTokens === null && item.outputTokens === null;
+      for (const [field, value] of Object.entries(values)) {
+        if (!Number.isSafeInteger(value) || value < 0) continue;
+        // Providers report cumulative request usage, not additive deltas.
+        const delta = value - (item[field] ?? 0);
+        item[field] = value;
+        totals[field] += delta;
+        if (stats) stats[field] += delta;
+      }
+      if (first && (item.inputTokens !== null || item.outputTokens !== null)) {
+        totals.usageRequests++;
+        if (stats) stats.usageRequests++;
+      }
+      schedule();
+    }
+    function fail(message) {
+      if (settled || failed) return;
+      failed = true;
+      item.error = safeText(message);
+      item.state = "failed";
+      log("error", item.error, item);
+    }
+    function finish(cancelled) {
+      if (settled) return;
+      settled = true;
+      res.write = originalWrite;
+      res.end = originalEnd;
+      item.endedAt = Date.now();
+      item.durationMs = item.endedAt - item.startedAt;
+      item.status = res.headersSent ? res.statusCode : item.status;
+      item.clientDisconnected = cancelled;
+      item.state =
+        failed || item.status >= 400
+          ? "failed"
+          : cancelled && !item.completionObserved
+            ? "cancelled"
+            : "completed";
+      totals[item.state]++;
+      if (stats) {
+        stats[item.state]++;
+        stats.active--;
+        stats.lastSeen = item.endedAt;
+      }
+      active.delete(item.id);
+      progress.delete(item.id);
+      recent.unshift(item);
+      if (recent.length > HISTORY_LIMIT) recent.pop();
+      const closure = cancelled
+        ? item.completionObserved
+          ? " · client disconnected after response completion; delivery not confirmed"
+          : " · client disconnected before response completion; reason unknown"
+        : "";
+      log(
+        item.state === "failed"
+          ? "error"
+          : item.state === "cancelled"
+            ? "warn"
+            : "info",
+        `${item.state}${item.status ? ` · HTTP ${item.status}` : ""} · ${item.durationMs}ms · ${item.inputTokens ?? "?"} in / ${item.outputTokens ?? "?"} out tokens · ${item.bytes} bytes${closure}`,
+        item,
+      );
+    }
+    res.once("finish", () => finish(false));
+    res.once("close", () => finish(!res.writableFinished));
+    res.once("error", () => fail("Client response stream failed"));
+    log(
+      "info",
+      `Request started · ${item.route === "claude-bridge" ? "Responses -> Chat bridge" : item.route === "messages-bridge" ? "Messages -> Responses bridge" : item.route === "native-messages" ? "native Messages" : "native Responses"}`,
+      item,
+    );
+    return {
+      activity,
+      usage,
+      complete() {
+        if (settled || failed) return;
+        item.completionObserved = true;
+        schedule();
+      },
+      upstream(status) {
+        if (settled) return;
+        item.status = status;
+        log(status >= 400 ? "warn" : "info", `Upstream HTTP ${status}`, item);
+      },
+      fail,
+      note(level, message) {
+        if (!settled) log(level, message, item);
+      },
+    };
+  }
+
+  function subscribe(listener) {
+    listeners.add(listener);
+    listener(snapshot());
+    return () => listeners.delete(listener);
+  }
+  function close() {
+    closed = true;
+    clearInterval(tick);
+    clearTimeout(timer);
+    listeners.clear();
+  }
+  return { snapshot, subscribe, begin, log, close };
+}
+
+module.exports = { createMonitor };