homeio

1import "server-only";
2
3import { request } from "node:http";
4import type { IncomingMessage } from "node:http";
5import { serverEnv } from "@/lib/server/env";
6
7export type DockerLogLine = {
8  timestamp: string;
9  stream: "stdout" | "stderr";
10  message: string;
11};
12
13/**
14 * Opens a streaming HTTP connection to the Docker socket for container logs.
15 * Returns the raw IncomingMessage — caller is responsible for destroying it.
16 *
17 * The response body uses Docker's multiplexed stream format:
18 *   byte 0:   stream type (1 = stdout, 2 = stderr)
19 *   bytes 1-3: reserved zeros
20 *   bytes 4-7: big-endian uint32 payload size
21 *   then:     payload bytes
22 */
23export function streamDockerContainerLogs(
24  containerName: string,
25  tail = 200,
26): Promise<IncomingMessage> {
27  const path = `/containers/${encodeURIComponent(containerName)}/logs?follow=1&stdout=1&stderr=1&timestamps=1&tail=${tail}`;
28
29  return new Promise((resolve, reject) => {
30    const req = request(
31      {
32        socketPath: serverEnv.DOCKER_SOCKET_PATH,
33        path,
34        method: "GET",
35        headers: { Host: "docker" },
36      },
37      (res) => {
38        if (res.statusCode && res.statusCode >= 400) {
39          let body = "";
40          res.setEncoding("utf8");
41          res.on("data", (chunk: string) => {
42            body += chunk;
43          });
44          res.on("end", () => {
45            reject(
46              new Error(
47                `Docker API error (${res.statusCode}): ${body}`,
48              ),
49            );
50          });
51          return;
52        }
53        resolve(res);
54      },
55    );
56
57    req.on("error", reject);
58    req.end();
59  });
60}
61
62/**
63 * Containers that colour their output — most Node images do, Uptime Kuma
64 * among them — emit SGR escape sequences the viewer has no way to render, so
65 * they showed up as literal `[36m` and `[38;5;119m` noise wrapped around every
66 * field. Worse, the codes glue onto the words: `\x1b[33mWARN:` has no word
67 * boundary before WARN, so level detection missed it entirely and the line
68 * fell through to the stderr badge, marking warnings as errors.
69 *
70 * Covers the CSI sequences containers actually produce (colour, cursor) and
71 * the two-character escapes; anything else is left alone rather than guessed at.
72 */
73 
74const ANSI_ESCAPE_PATTERN = /\u001B(?:\[[0-?]*[ -\/]*[@-~]|[@-Z\\-_])/g;
75
76export function stripAnsi(value: string) {
77  return value.replace(ANSI_ESCAPE_PATTERN, "");
78}
79
80/**
81 * Parses a single raw log line produced by Docker's multiplexed stream.
82 * Docker prepends RFC3339Nano timestamps when `timestamps=1` is set:
83 *   "2024-01-01T00:00:00.000000000Z actual log message here"
84 */
85export function parseDockerLogLine(
86  raw: string,
87  stream: "stdout" | "stderr",
88): DockerLogLine {
89  // Timestamp is the first space-delimited token when timestamps=1
90  const spaceIdx = raw.indexOf(" ");
91  if (spaceIdx > 0) {
92    const ts = raw.slice(0, spaceIdx);
93    const msg = raw.slice(spaceIdx + 1);
94    // Validate it looks like an ISO timestamp
95    if (ts.includes("T") && ts.includes("Z")) {
96      return { timestamp: ts, stream, message: stripAnsi(msg) };
97    }
98  }
99  return { timestamp: new Date().toISOString(), stream, message: stripAnsi(raw) };
100}
101
102/**
103 * Detects a log level from a log message string.
104 */
105export function detectLogLevel(
106  message: string,
107): "ERROR" | "WARN" | "INFO" | "DEBUG" | null {
108  const upper = stripAnsi(message).toUpperCase();
109  if (/\bERROR\b|\bERR\b|\bFATAL\b|\bCRIT\b/.test(upper)) return "ERROR";
110  if (/\bWARN\b|\bWARNING\b/.test(upper)) return "WARN";
111  if (/\bINFO\b/.test(upper)) return "INFO";
112  if (/\bDEBUG\b|\bTRACE\b/.test(upper)) return "DEBUG";
113  return null;
114}
115
116/**
117 * Reads Docker's multiplexed binary frame header and emits complete log lines.
118 * Calls `onLine` for each decoded line.
119 */
120export function createDockerLogParser(
121  onLine: (line: DockerLogLine) => void,
122): (chunk: Buffer) => void {
123  let buf = Buffer.alloc(0);
124
125  return function processChunk(chunk: Buffer) {
126    buf = Buffer.concat([buf, chunk]);
127
128    while (buf.length >= 8) {
129      const streamType = buf[0];
130      const frameSize = buf.readUInt32BE(4);
131
132      if (buf.length < 8 + frameSize) break;
133
134      const payload = buf.slice(8, 8 + frameSize).toString("utf8");
135      buf = buf.slice(8 + frameSize);
136
137      const stream: "stdout" | "stderr" =
138        streamType === 2 ? "stderr" : "stdout";
139
140      // A single frame may contain multiple newline-delimited lines
141      const lines = payload.split("\n");
142      for (const line of lines) {
143        const trimmed = line.trimEnd();
144        if (trimmed.length === 0) continue;
145        onLine(parseDockerLogLine(trimmed, stream));
146      }
147    }
148  };
149}
150