feat: Add Docker healthcheck (#70)

* feat: add healthcheck

* Move healthcheck to typescript and add tests

Author: popstas

Dockerfile

@@ -25,5 +25,9 @@ WORKDIR /app
 COPY --from=builder /build/node_modules ./node_modules
 COPY . .
 
+# healthcheck script
+HEALTHCHECK --interval=30s --timeout=10s --start-period=30s --retries=3 \
+  CMD npm -s run healthcheck
+
 # default command
 CMD ["npm", "run", "start"]

package.json

@@ -14,7 +14,8 @@
     "lint": "eslint",
     "format": "prettier -l --write \"src/**/*.{ts,js,json,md}\" \"tests/**/*.{ts,js,json,md}\"",
     "format:check": "prettier --check \"src/**/*.{ts,js,json,md}\" \"tests/**/*.{ts,js,json,md}\"",
-    "agent": "tsx src/cli-agent.ts"
+    "agent": "tsx src/cli-agent.ts",
+    "healthcheck": "tsx src/healthcheck.ts"
   },
   "author": "",
   "license": "ISC",

src/bot.ts

@@ -12,3 +12,7 @@ export function useBot(bot_token?: string) {
   }
   return bots[bot_token];
 }
+
+export function getBots() {
+  return bots;
+}

src/healthcheck.ts

@@ -0,0 +1,65 @@
+import http from "http";
+import { fileURLToPath } from "url";
+import { resolve } from "path";
+
+type HealthResponse = {
+  botsRunning: boolean;
+  mqttConnected: boolean;
+};
+
+export async function request(path: string): Promise<{
+  statusCode: number;
+  data: string;
+}> {
+  return new Promise((resolve) => {
+    const req = http.get(
+      { host: "localhost", port: process.env.PORT || 7586, path },
+      (res) => {
+        let data = "";
+        res.on("data", (c) => (data += c));
+        res.on("end", () => resolve({ statusCode: res.statusCode || 0, data }));
+      },
+    );
+    req.on("error", () => resolve({ statusCode: 0, data: "" }));
+  });
+}
+
+export const runHealthcheck = async () => {
+  const ping = await request("/ping");
+  if (ping.statusCode !== 200) {
+    console.error("Ping failed");
+    return false;
+  }
+  const health = await request("/health");
+  if (health.statusCode !== 200) {
+    console.error("Health endpoint unavailable");
+    return false;
+  }
+  try {
+    const { botsRunning, mqttConnected } = JSON.parse(
+      health.data,
+    ) as HealthResponse;
+    if (!botsRunning || !mqttConnected) {
+      console.error("Bots or MQTT unhealthy");
+      return false;
+    }
+  } catch {
+    console.error("Invalid health response");
+    return false;
+  }
+  return true;
+};
+
+(async () => {
+  const isMain = (() => {
+    const currentFilePath = fileURLToPath(import.meta.url);
+    const scriptPath = process.argv[1]
+      ? resolve(process.cwd(), process.argv[1])
+      : "";
+    return scriptPath === currentFilePath;
+  })();
+  if (isMain) {
+    const ok = await runHealthcheck();
+    process.exit(ok ? 0 : 1);
+  }
+})();

src/index.ts

@@ -11,7 +11,7 @@ import {
 import { initCommands } from "./commands.ts";
 import { log } from "./helpers.ts";
 import express from "express";
-import { useBot } from "./bot";
+import { useBot, getBots } from "./bot";
 import onTextMessage from "./handlers/onTextMessage.ts";
 import onPhoto from "./handlers/onPhoto.ts";
 import onAudio from "./handlers/onAudio.ts";
@@ -22,7 +22,7 @@ import {
   agentPostHandler,
   toolPostHandler,
 } from "./httpHandlers.ts";
-import { useMqtt } from "./mqtt.ts";
+import { useMqtt, isMqttConnected } from "./mqtt.ts";
 
 process.on("uncaughtException", (error, source) => {
   console.log("Uncaught Exception:", error);
@@ -160,6 +160,19 @@ function initHttp() {
     res.send("pong");
   });
 
+  app.get("/health", (_req, res) => {
+    const bots = getBots();
+    const botsRunning = Object.values(bots).every((bot) => {
+      const polling = (
+        bot as unknown as {
+          polling?: { abortController: { signal: AbortSignal } };
+        }
+      ).polling;
+      return polling && !polling.abortController.signal.aborted;
+    });
+    res.json({ botsRunning, mqttConnected: isMqttConnected() });
+  });
+
   // Add route handler to create a virtual message and call onMessage
   // @ts-expect-error express types need proper request/response typing
   app.post("/telegram/:chatId", telegramPostHandler);

src/mqtt.ts

@@ -5,6 +5,7 @@ import { log } from "./helpers.ts";
 
 const MQTT_LOG_PATH = "data/mqtt.log";
 let client: mqtt.MqttClient | undefined;
+let connected = false;
 
 export function useMqtt() {
   if (client) return client;
@@ -18,10 +19,12 @@ export function useMqtt() {
   });
   client.on("connect", () => {
     log({ msg: "mqtt connected", logPath: MQTT_LOG_PATH });
+    connected = true;
     client?.subscribe(`${cfg.base}/+`);
   });
   client.on("offline", () => {
     log({ msg: "mqtt offline", logPath: MQTT_LOG_PATH });
+    connected = false;
   });
   client.on("message", async (topic, message) => {
     if (!client) return;
@@ -51,3 +54,7 @@ export function publishMqttProgress(msg: string, agent?: string) {
   if (!agent) return;
   client?.publish(`${cfg.base}/${agent}/progress`, msg);
 }
+
+export function isMqttConnected() {
+  return connected;
+}

tests/healthcheck.test.ts

@@ -0,0 +1,59 @@
+import { jest, describe, it, expect, beforeEach } from "@jest/globals";
+import { EventEmitter } from "events";
+
+const mockGet = jest.fn();
+
+jest.unstable_mockModule("http", () => ({
+  __esModule: true,
+  default: { get: (...args: unknown[]) => mockGet(...args) },
+  get: (...args: unknown[]) => mockGet(...args),
+}));
+
+let runHealthcheck: typeof import("../src/healthcheck").runHealthcheck;
+
+beforeEach(async () => {
+  jest.resetModules();
+  mockGet.mockReset();
+  ({ runHealthcheck } = await import("../src/healthcheck"));
+});
+
+function mockResponse(path: string, status: number, data: string) {
+  mockGet.mockImplementationOnce(
+    (
+      _opts: unknown,
+      cb: (res: EventEmitter & { statusCode?: number }) => void,
+    ) => {
+      const res = new EventEmitter() as EventEmitter & { statusCode?: number };
+      res.statusCode = status;
+      cb(res);
+      process.nextTick(() => {
+        if (data) res.emit("data", data);
+        res.emit("end");
+      });
+      return { on: jest.fn() } as unknown as EventEmitter;
+    },
+  );
+}
+
+describe("runHealthcheck", () => {
+  it("returns true on healthy response", async () => {
+    mockResponse("/ping", 200, "pong");
+    mockResponse(
+      "/health",
+      200,
+      JSON.stringify({ botsRunning: true, mqttConnected: true }),
+    );
+    await expect(runHealthcheck()).resolves.toBe(true);
+  });
+
+  it("returns false on ping failure", async () => {
+    mockResponse("/ping", 500, "");
+    await expect(runHealthcheck()).resolves.toBe(false);
+  });
+
+  it("returns false on invalid health", async () => {
+    mockResponse("/ping", 200, "pong");
+    mockResponse("/health", 200, "oops");
+    await expect(runHealthcheck()).resolves.toBe(false);
+  });
+});