erlc-v2 1.1.0 → 1.1.2

package/src/api/LocalApiServer.js

@@ -1,538 +1,535 @@
-const http = require("http");
-const { QUERY_FLAG_MAP } = require("../util/constants");
-const { searchVehicles } = require("../util/vehicleSearch");
-const {
-  getHeader,
-  verifyWebhookSignature,
-  normalizeWebhookPayload,
-} = require("../util/webhook");
-
-function cleanPath(value, fallback) {
-  const input = String(value || fallback || "/").trim();
-  const withLeadingSlash = input.startsWith("/") ? input : `/${input}`;
-  if (withLeadingSlash.length > 1 && withLeadingSlash.endsWith("/")) {
-    return withLeadingSlash.slice(0, -1);
-  }
-  return withLeadingSlash;
-}
-
-function buildUrl(base, path) {
-  if (!base) return null;
-  return new URL(path, base.endsWith("/") ? base : `${base}/`).toString();
-}
-
-function sendJson(res, status, payload) {
-  const body = Buffer.from(JSON.stringify(payload));
-  res.statusCode = status;
-  res.setHeader("Content-Type", "application/json; charset=utf-8");
-  res.setHeader("Content-Length", body.length);
-  res.end(body);
-}
-
-function sendEmpty(res, status) {
-  res.statusCode = status;
-  res.end();
-}
-
-function readBody(req) {
-  return new Promise((resolve, reject) => {
-    const chunks = [];
-    req.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
-    req.on("end", () => resolve(Buffer.concat(chunks)));
-    req.on("error", reject);
-  });
-}
-
-function parseJson(rawBody) {
-  if (!rawBody || rawBody.length === 0) return {};
-  return JSON.parse(rawBody.toString("utf8"));
-}
-
-function parseBool(value) {
-  if (typeof value !== "string") return false;
-  const text = value.trim().toLowerCase();
-  return text === "true" || text === "1" || text === "yes";
-}
-
-function bodyPreview(body) {
-  if (!body || typeof body !== "object") return body ?? null;
-  try {
-    return JSON.parse(JSON.stringify(body));
-  } catch {
-    return { message: "unserializable body" };
-  }
-}
-
-function getRoutePath(url, basePath) {
-  if (url.pathname === basePath) return "";
-  if (!url.pathname.startsWith(`${basePath}/`)) return null;
-  return url.pathname.slice(basePath.length);
-}
-
-class LocalApiServer {
-  constructor(client, options = {}) {
-    this.client = client;
-    this.options = options || {};
-    this.server = null;
-    this.startPromise = null;
-  }
-
-  info() {
-    const basePath = cleanPath(this.options.path, "/erlc");
-    const webhookPath = cleanPath(
-      this.options.webhookPath || `${basePath}/events`,
-      `${basePath}/events`,
-    );
-    const address = this.server?.address();
-    const host =
-      typeof this.options.host === "string" && this.options.host.trim()
-        ? this.options.host.trim()
-        : "127.0.0.1";
-    const port =
-      address && typeof address === "object" ? address.port : this.options.port;
-    const localHost =
-      host === "0.0.0.0" || host === "::" ? "127.0.0.1" : host;
-    const localUrl =
-      Number.isInteger(port) && port >= 0
-        ? `http://${localHost}:${port}${basePath}`
-        : null;
-
-    return {
-      running: Boolean(this.server?.listening),
-      host,
-      port: Number.isInteger(port) ? port : null,
-      path: basePath,
-      webhookPath,
-      localUrl,
-      webhookUrl: buildUrl(this.options.publicUrl, webhookPath),
-      publicUrl: this.options.publicUrl || null,
-      tokenEnabled: Boolean(this.options.token),
-    };
-  }
-
-  async start() {
-    if (this.server?.listening) {
-      return this.info();
-    }
-    if (this.startPromise) {
-      return this.startPromise;
-    }
-
-    const port = Number(this.options.port);
-    if (!Number.isInteger(port) || port < 0) {
-      throw new Error("Local API requires a valid api.port");
-    }
-
-    const host =
-      typeof this.options.host === "string" && this.options.host.trim()
-        ? this.options.host.trim()
-        : "127.0.0.1";
-
-    this.server = http.createServer((req, res) => {
-      void this._handle(req, res);
-    });
-
-    this.startPromise = new Promise((resolve, reject) => {
-      const onError = (error) => {
-        this.server?.off("listening", onListening);
-        this.startPromise = null;
-        reject(error);
-      };
-      const onListening = () => {
-        this.server?.off("error", onError);
-        this.startPromise = null;
-        this.client.logger.info({
-          msg: "local_api_started",
-          ...this.info(),
-        });
-        resolve(this.info());
-      };
-
-      this.server.once("error", onError);
-      this.server.once("listening", onListening);
-      this.server.listen(port, host);
-    });
-
-    return this.startPromise;
-  }
-
-  stop() {
-    if (!this.server) return;
-    const server = this.server;
-    this.server = null;
-    this.startPromise = null;
-    server.close();
-  }
-
-  async _handle(req, res) {
-    const info = this.info();
-    const url = new URL(req.url || "/", `http://${req.headers.host || "localhost"}`);
-    const startedAt = Date.now();
-
-    try {
-      if (url.pathname === info.webhookPath && req.method === "POST") {
-        await this._handleWebhook(req, res);
-        return;
-      }
-
-      const routePath = getRoutePath(url, info.path);
-      if (routePath === null) {
-        this._recordRequest({
-          req,
-          url,
-          startedAt,
-          kind: "route",
-          status: 404,
-          note: "not_found",
-        });
-        sendJson(res, 404, { message: "Not found" });
-        return;
-      }
-
-      if (!this._isAuthorized(req)) {
-        this._recordRequest({
-          req,
-          url,
-          startedAt,
-          kind: "route",
-          status: 401,
-          note: "unauthorized",
-        });
-        sendJson(res, 401, { message: "Unauthorized" });
-        return;
-      }
-
-      if (req.method === "GET" && routePath === "") {
-        this._recordRequest({
-          req,
-          url,
-          startedAt,
-          kind: "route",
-          status: 200,
-        });
-        sendJson(res, 200, this.info());
-        return;
-      }
-
-      if (req.method === "GET" && routePath === "/health") {
-        this._recordRequest({
-          req,
-          url,
-          startedAt,
-          kind: "route",
-          status: 200,
-        });
-        sendJson(res, 200, {
-          ok: true,
-          polling: this.client.poller?.running === true,
-          disconnected: this.client.state?.disconnected === true,
-        });
-        return;
-      }
-
-      if (req.method === "GET" && routePath === "/server") {
-        const snapshot = await this.client.server.fetch(
-          this._getServerFlags(url.searchParams),
-          {
-            bypassCache: parseBool(url.searchParams.get("bypassCache")),
-          },
-        );
-        this._recordRequest({
-          req,
-          url,
-          startedAt,
-          kind: "route",
-          status: 200,
-          note: "server_snapshot",
-        });
-        sendJson(res, 200, snapshot);
-        return;
-      }
-
-      if (req.method === "GET" && routePath === "/players") {
-        const players = await this.client.players.list({
-          bypassCache: parseBool(url.searchParams.get("bypassCache")),
-        });
-        this._recordRequest({
-          req,
-          url,
-          startedAt,
-          kind: "route",
-          status: 200,
-          note: `players=${players.length}`,
-        });
-        sendJson(res, 200, {
-          count: players.length,
-          players,
-        });
-        return;
-      }
-
-      if (req.method === "GET" && routePath === "/vehicles") {
-        const vehicles = await this.client.vehicles.list({
-          bypassCache: parseBool(url.searchParams.get("bypassCache")),
-        });
-        const filtered = searchVehicles(vehicles, {
-          query: url.searchParams.get("query") || url.searchParams.get("search"),
-          plate: url.searchParams.get("plate"),
-          owner: url.searchParams.get("owner"),
-          name: url.searchParams.get("name"),
-          color: url.searchParams.get("color"),
-          texture: url.searchParams.get("texture"),
-          exact: parseBool(url.searchParams.get("exact")),
-          limit: url.searchParams.get("limit"),
-        });
-        this._recordRequest({
-          req,
-          url,
-          startedAt,
-          kind: "route",
-          status: 200,
-          note: `vehicles=${filtered.length}`,
-        });
-        sendJson(res, 200, {
-          count: filtered.length,
-          vehicles: filtered,
-        });
-        return;
-      }
-
-      if (req.method === "GET" && routePath.startsWith("/vehicles/")) {
-        const plate = decodeURIComponent(routePath.slice("/vehicles/".length));
-        const vehicle = await this.client.vehicles.findByPlate(plate, {
-          bypassCache: parseBool(url.searchParams.get("bypassCache")),
-        });
-        if (!vehicle) {
-          this._recordRequest({
-            req,
-            url,
-            startedAt,
-            kind: "route",
-            status: 404,
-            note: `plate=${plate}`,
-          });
-          sendJson(res, 404, { message: "Vehicle not found" });
-          return;
-        }
-        this._recordRequest({
-          req,
-          url,
-          startedAt,
-          kind: "route",
-          status: 200,
-          note: `plate=${plate}`,
-        });
-        sendJson(res, 200, vehicle);
-        return;
-      }
-
-      if (req.method === "GET" && routePath === "/emergency-calls") {
-        const calls = await this.client.logs.emergencyCalls({
-          bypassCache: parseBool(url.searchParams.get("bypassCache")),
-        });
-        this._recordRequest({
-          req,
-          url,
-          startedAt,
-          kind: "route",
-          status: 200,
-          note: `emergencyCalls=${calls.length}`,
-        });
-        sendJson(res, 200, {
-          count: calls.length,
-          emergencyCalls: calls,
-        });
-        return;
-      }
-
-      if (req.method === "POST" && routePath === "/command") {
-        const rawBody = await readBody(req);
-        const body = parseJson(rawBody);
-        const result = await this.client.commands.execute(body.command);
-        this._recordRequest({
-          req,
-          url,
-          startedAt,
-          kind: "route",
-          status: 200,
-          body,
-          note: "command",
-        });
-        sendJson(res, 200, result);
-        return;
-      }
-
-      this._recordRequest({
-        req,
-        url,
-        startedAt,
-        kind: "route",
-        status: 404,
-        note: "not_found",
-      });
-      sendJson(res, 404, { message: "Not found" });
-    } catch (error) {
-      const status = Number(error?.status) || 500;
-      this._recordRequest({
-        req,
-        url,
-        startedAt,
-        kind: "route",
-        status,
-        note: error?.message || "internal_error",
-      });
-      sendJson(res, status, {
-        message: error?.message || "Internal server error",
-        status,
-        code: error?.errorCode ?? null,
-      });
-    }
-  }
-
-  async _handleWebhook(req, res) {
-    const timestamp = getHeader(req, "x-signature-timestamp");
-    const signature = getHeader(req, "x-signature-ed25519");
-    const rawBody = await readBody(req);
-    const url = new URL(req.url || "/", `http://${req.headers.host || "localhost"}`);
-    const startedAt = Date.now();
-
-    if (!timestamp || !signature) {
-      this._recordRequest({
-        req,
-        url,
-        startedAt,
-        kind: "webhook",
-        status: 400,
-        note: "missing_signature_headers",
-      });
-      sendJson(res, 400, { message: "Missing signature headers" });
-      return;
-    }
-
-    if (!verifyWebhookSignature(timestamp, signature, rawBody)) {
-      this._recordRequest({
-        req,
-        url,
-        startedAt,
-        kind: "webhook",
-        status: 401,
-        note: "invalid_signature",
-      });
-      sendJson(res, 401, { message: "Invalid signature" });
-      return;
-    }
-
-    let body;
-    try {
-      body = parseJson(rawBody);
-    } catch {
-      this._recordRequest({
-        req,
-        url,
-        startedAt,
-        kind: "webhook",
-        status: 400,
-        note: "invalid_json",
-      });
-      sendJson(res, 400, { message: "Invalid JSON body" });
-      return;
-    }
-
-    const payload = normalizeWebhookPayload(body, {
-      timestamp,
-      signature,
-      rawBody,
-      headers: req.headers,
-    });
-
-    this._recordRequest({
-      req,
-      url,
-      startedAt,
-      kind: "webhook",
-      status: 204,
-      type: payload.type,
-      body,
-      note: "signature_valid",
-    });
+const http = require("http");
+const { QUERY_FLAG_MAP } = require("../util/constants");
+const { searchVehicles } = require("../util/vehicleSearch");
+const {
+  getHeader,
+  verifyWebhookSignature,
+  normalizeWebhookPayload,
+} = require("../util/webhook");
+
+function cleanPath(value, fallback) {
+  const input = String(value || fallback || "/").trim();
+  const withLeadingSlash = input.startsWith("/") ? input : `/${input}`;
+  if (withLeadingSlash.length > 1 && withLeadingSlash.endsWith("/")) {
+    return withLeadingSlash.slice(0, -1);
+  }
+  return withLeadingSlash;
+}
+
+function buildUrl(base, path) {
+  if (!base) return null;
+  return new URL(path, base.endsWith("/") ? base : `${base}/`).toString();
+}
+
+function sendJson(res, status, payload) {
+  const body = Buffer.from(JSON.stringify(payload));
+  res.statusCode = status;
+  res.setHeader("Content-Type", "application/json; charset=utf-8");
+  res.setHeader("Content-Length", body.length);
+  res.end(body);
+}
+
+function sendEmpty(res, status) {
+  res.statusCode = status;
+  res.end();
+}
+
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+    req.on("end", () => resolve(Buffer.concat(chunks)));
+    req.on("error", reject);
+  });
+}
+
+function parseJson(rawBody) {
+  if (!rawBody || rawBody.length === 0) return {};
+  return JSON.parse(rawBody.toString("utf8"));
+}
+
+function parseBool(value) {
+  if (typeof value !== "string") return false;
+  const text = value.trim().toLowerCase();
+  return text === "true" || text === "1" || text === "yes";
+}
+
+function bodyPreview(body) {
+  if (!body || typeof body !== "object") return body ?? null;
+  try {
+    return JSON.parse(JSON.stringify(body));
+  } catch {
+    return { message: "unserializable body" };
+  }
+}
+
+function getRoutePath(url, basePath) {
+  if (url.pathname === basePath) return "";
+  if (!url.pathname.startsWith(`${basePath}/`)) return null;
+  return url.pathname.slice(basePath.length);
+}
+
+class LocalApiServer {
+  constructor(client, options = {}) {
+    this.client = client;
+    this.options = options || {};
+    this.server = null;
+    this.startPromise = null;
+  }
+
+  info() {
+    const basePath = cleanPath(this.options.path, "/erlc");
+    const webhookPath = cleanPath(
+      this.options.webhookPath || `${basePath}/events`,
+      `${basePath}/events`,
+    );
+    const address = this.server?.address();
+    const host =
+      typeof this.options.host === "string" && this.options.host.trim()
+        ? this.options.host.trim()
+        : "127.0.0.1";
+    const port =
+      address && typeof address === "object" ? address.port : this.options.port;
+    const localHost =
+      host === "0.0.0.0" || host === "::" ? "127.0.0.1" : host;
+    const localUrl =
+      Number.isInteger(port) && port >= 0
+        ? `http://${localHost}:${port}${basePath}`
+        : null;
+
+    return {
+      running: Boolean(this.server?.listening),
+      host,
+      port: Number.isInteger(port) ? port : null,
+      path: basePath,
+      webhookPath,
+      localUrl,
+      webhookUrl: buildUrl(this.options.publicUrl, webhookPath),
+      publicUrl: this.options.publicUrl || null,
+      tokenEnabled: Boolean(this.options.token),
+    };
+  }
+
+  async start() {
+    if (this.server?.listening) {
+      return this.info();
+    }
+    if (this.startPromise) {
+      return this.startPromise;
+    }
+
+    const port = Number(this.options.port);
+    if (!Number.isInteger(port) || port < 0) {
+      throw new Error("Local API requires a valid api.port");
+    }
+
+    const host =
+      typeof this.options.host === "string" && this.options.host.trim()
+        ? this.options.host.trim()
+        : "127.0.0.1";
+
+    this.server = http.createServer((req, res) => {
+      void this._handle(req, res);
+    });
+
+    this.startPromise = new Promise((resolve, reject) => {
+      const onError = (error) => {
+        this.server?.off("listening", onListening);
+        this.startPromise = null;
+        reject(error);
+      };
+      const onListening = () => {
+        this.server?.off("error", onError);
+        this.startPromise = null;
+        this.client.logger.info({
+          msg: "local_api_started",
+          ...this.info(),
+        });
+        resolve(this.info());
+      };
+
+      this.server.once("error", onError);
+      this.server.once("listening", onListening);
+      this.server.listen(port, host);
+    });
+
+    return this.startPromise;
+  }
+
+  stop() {
+    if (!this.server) return;
+    const server = this.server;
+    this.server = null;
+    this.startPromise = null;
+    server.close();
+  }
+
+  async _handle(req, res) {
+    const info = this.info();
+    const url = new URL(req.url || "/", `http://${req.headers.host || "localhost"}`);
+    const startedAt = Date.now();
+
+    try {
+      if (url.pathname === info.webhookPath && req.method === "POST") {
+        await this._handleWebhook(req, res);
+        return;
+      }
+
+      const routePath = getRoutePath(url, info.path);
+      if (routePath === null) {
+        this._recordRequest({
+          req,
+          url,
+          startedAt,
+          kind: "route",
+          status: 404,
+          note: "not_found",
+        });
+        sendJson(res, 404, { message: "Not found" });
+        return;
+      }
+
+      if (!this._isAuthorized(req)) {
+        this._recordRequest({
+          req,
+          url,
+          startedAt,
+          kind: "route",
+          status: 401,
+          note: "unauthorized",
+        });
+        sendJson(res, 401, { message: "Unauthorized" });
+        return;
+      }
+
+      if (req.method === "GET" && routePath === "") {
+        this._recordRequest({
+          req,
+          url,
+          startedAt,
+          kind: "route",
+          status: 200,
+        });
+        sendJson(res, 200, this.info());
+        return;
+      }
+
+      if (req.method === "GET" && routePath === "/health") {
+        this._recordRequest({
+          req,
+          url,
+          startedAt,
+          kind: "route",
+          status: 200,
+        });
+        sendJson(res, 200, {
+          ok: true,
+          polling: this.client.poller?.running === true,
+          disconnected: this.client.state?.disconnected === true,
+        });
+        return;
+      }
+
+      if (req.method === "GET" && routePath === "/server") {
+        const snapshot = await this.client.server.fetch(
+          this._getServerFlags(url.searchParams),
+          {
+            bypassCache: parseBool(url.searchParams.get("bypassCache")),
+          },
+        );
+        this._recordRequest({
+          req,
+          url,
+          startedAt,
+          kind: "route",
+          status: 200,
+          note: "server_snapshot",
+        });
+        sendJson(res, 200, snapshot);
+        return;
+      }
+
+      if (req.method === "GET" && routePath === "/players") {
+        const players = await this.client.players.list({
+          bypassCache: parseBool(url.searchParams.get("bypassCache")),
+        });
+        this._recordRequest({
+          req,
+          url,
+          startedAt,
+          kind: "route",
+          status: 200,
+          note: `players=${players.length}`,
+        });
+        sendJson(res, 200, {
+          count: players.length,
+          players,
+        });
+        return;
+      }
+
+      if (req.method === "GET" && routePath === "/vehicles") {
+        const vehicles = await this.client.vehicles.list({
+          bypassCache: parseBool(url.searchParams.get("bypassCache")),
+        });
+        const filtered = searchVehicles(vehicles, {
+          query: url.searchParams.get("query") || url.searchParams.get("search"),
+          plate: url.searchParams.get("plate"),
+          owner: url.searchParams.get("owner"),
+          name: url.searchParams.get("name"),
+          color: url.searchParams.get("color"),
+          texture: url.searchParams.get("texture"),
+          exact: parseBool(url.searchParams.get("exact")),
+          limit: url.searchParams.get("limit"),
+        });
+        this._recordRequest({
+          req,
+          url,
+          startedAt,
+          kind: "route",
+          status: 200,
+          note: `vehicles=${filtered.length}`,
+        });
+        sendJson(res, 200, {
+          count: filtered.length,
+          vehicles: filtered,
+        });
+        return;
+      }
+
+      if (req.method === "GET" && routePath.startsWith("/vehicles/")) {
+        const plate = decodeURIComponent(routePath.slice("/vehicles/".length));
+        const vehicle = await this.client.vehicles.findByPlate(plate, {
+          bypassCache: parseBool(url.searchParams.get("bypassCache")),
+        });
+        if (!vehicle) {
+          this._recordRequest({
+            req,
+            url,
+            startedAt,
+            kind: "route",
+            status: 404,
+            note: `plate=${plate}`,
+          });
+          sendJson(res, 404, { message: "Vehicle not found" });
+          return;
+        }
+        this._recordRequest({
+          req,
+          url,
+          startedAt,
+          kind: "route",
+          status: 200,
+          note: `plate=${plate}`,
+        });
+        sendJson(res, 200, vehicle);
+        return;
+      }
+
+      if (req.method === "GET" && routePath === "/emergency-calls") {
+        const calls = await this.client.logs.emergencyCalls({
+          bypassCache: parseBool(url.searchParams.get("bypassCache")),
+        });
+        this._recordRequest({
+          req,
+          url,
+          startedAt,
+          kind: "route",
+          status: 200,
+          note: `emergencyCalls=${calls.length}`,
+        });
+        sendJson(res, 200, {
+          count: calls.length,
+          emergencyCalls: calls,
+        });
+        return;
+      }
+
+      if (req.method === "POST" && routePath === "/command") {
+        const rawBody = await readBody(req);
+        const body = parseJson(rawBody);
+        const result = await this.client.commands.execute(body.command);
+        this._recordRequest({
+          req,
+          url,
+          startedAt,
+          kind: "route",
+          status: 200,
+          body,
+          note: "command",
+        });
+        sendJson(res, 200, result);
+        return;
+      }
+
+      this._recordRequest({
+        req,
+        url,
+        startedAt,
+        kind: "route",
+        status: 404,
+        note: "not_found",
+      });
+      sendJson(res, 404, { message: "Not found" });
+    } catch (error) {
+      const status = Number(error?.status) || 500;
+      this._recordRequest({
+        req,
+        url,
+        startedAt,
+        kind: "route",
+        status,
+        note: error?.message || "internal_error",
+      });
+      sendJson(res, status, {
+        message: error?.message || "Internal server error",
+        status,
+        code: error?.errorCode ?? null,
+      });
+    }
+  }
+
+  async _handleWebhook(req, res) {
+    const timestamp = getHeader(req, "x-signature-timestamp");
+    const signature = getHeader(req, "x-signature-ed25519");
+    const rawBody = await readBody(req);
+    const url = new URL(req.url || "/", `http://${req.headers.host || "localhost"}`);
+    const startedAt = Date.now();
+
+    if (!timestamp || !signature) {
+      this._recordRequest({
+        req,
+        url,
+        startedAt,
+        kind: "webhook",
+        status: 400,
+        note: "missing_signature_headers",
+      });
+      sendJson(res, 400, { message: "Missing signature headers" });
+      return;
+    }
+
+    if (!verifyWebhookSignature(timestamp, signature, rawBody)) {
+      this._recordRequest({
+        req,
+        url,
+        startedAt,
+        kind: "webhook",
+        status: 401,
+        note: "invalid_signature",
+      });
+      sendJson(res, 401, { message: "Invalid signature" });
+      return;
+    }
+
+    let body;
+    try {
+      body = parseJson(rawBody);
+    } catch {
+      this._recordRequest({
+        req,
+        url,
+        startedAt,
+        kind: "webhook",
+        status: 400,
+        note: "invalid_json",
+      });
+      sendJson(res, 400, { message: "Invalid JSON body" });
+      return;
+    }
+
+    const payload = normalizeWebhookPayload(body, {
+      timestamp,
+      signature,
+      rawBody,
+      headers: req.headers,
+    });
+
+    this._recordRequest({
+      req,
+      url,
+      startedAt,
+      kind: "webhook",
+      status: 204,
+      type: payload.type,
+      body,
+      note: "signature_valid",
+    });
 
     this.client.emit("webhook", payload);
-    if (payload.type === "command") {
-      this.client.emit("webhookCommand", payload);
-    }
     if (payload.type === "emergencyCall") {
       this.client.emit("webhookEmergencyCall", payload);
     }
-
-    sendEmpty(res, 204);
-  }
-
-  _recordRequest({
-    req,
-    url,
-    startedAt,
-    kind,
-    status,
-    type = null,
-    body = null,
-    note = "",
-  }) {
-    const payload = {
-      method: req.method || "GET",
-      path: url.pathname,
-      query: Object.fromEntries(url.searchParams.entries()),
-      kind,
-      status,
-      type,
-      body: bodyPreview(body),
-      note,
-      tookMs: Date.now() - startedAt,
-      ip:
-        req.socket?.remoteAddress ||
-        req.headers["x-forwarded-for"] ||
-        null,
-      at: new Date().toISOString(),
-    };
-
-    this.client.emit("apiRequest", payload);
-
-    if (this.options.logRequests === false) return;
-
-    const parts = [
-      `[ERLC API] ${payload.method} ${payload.path}`,
-      `status=${payload.status}`,
-      `kind=${payload.kind}`,
-    ];
-    if (payload.type) parts.push(`type=${payload.type}`);
-    if (payload.note) parts.push(`note=${payload.note}`);
-    parts.push(`took=${payload.tookMs}ms`);
-
-    console.log(parts.join(" | "));
-    if (payload.body) {
-      console.log(JSON.stringify(payload.body, null, 2));
-    }
-  }
-
-  _isAuthorized(req) {
-    const token = String(this.options.token || "").trim();
-    if (!token) return true;
-
-    const auth = getHeader(req, "authorization");
-    if (auth === `Bearer ${token}`) return true;
-
-    const alt = getHeader(req, "x-api-token");
-    return alt === token;
-  }
-
-  _getServerFlags(searchParams) {
-    const flags = {};
-    for (const [key, apiKey] of Object.entries(QUERY_FLAG_MAP)) {
-      if (parseBool(searchParams.get(key)) || parseBool(searchParams.get(apiKey))) {
-        flags[key] = true;
-      }
-    }
-    return flags;
-  }
-}
-
-module.exports = LocalApiServer;
+
+    sendEmpty(res, 204);
+  }
+
+  _recordRequest({
+    req,
+    url,
+    startedAt,
+    kind,
+    status,
+    type = null,
+    body = null,
+    note = "",
+  }) {
+    const payload = {
+      method: req.method || "GET",
+      path: url.pathname,
+      query: Object.fromEntries(url.searchParams.entries()),
+      kind,
+      status,
+      type,
+      body: bodyPreview(body),
+      note,
+      tookMs: Date.now() - startedAt,
+      ip:
+        req.socket?.remoteAddress ||
+        req.headers["x-forwarded-for"] ||
+        null,
+      at: new Date().toISOString(),
+    };
+
+    this.client.emit("apiRequest", payload);
+
+    if (this.options.logRequests === false) return;
+
+    const parts = [
+      `[ERLC API] ${payload.method} ${payload.path}`,
+      `status=${payload.status}`,
+      `kind=${payload.kind}`,
+    ];
+    if (payload.type) parts.push(`type=${payload.type}`);
+    if (payload.note) parts.push(`note=${payload.note}`);
+    parts.push(`took=${payload.tookMs}ms`);
+
+    console.log(parts.join(" | "));
+    if (payload.body) {
+      console.log(JSON.stringify(payload.body, null, 2));
+    }
+  }
+
+  _isAuthorized(req) {
+    const token = String(this.options.token || "").trim();
+    if (!token) return true;
+
+    const auth = getHeader(req, "authorization");
+    if (auth === `Bearer ${token}`) return true;
+
+    const alt = getHeader(req, "x-api-token");
+    return alt === token;
+  }
+
+  _getServerFlags(searchParams) {
+    const flags = {};
+    for (const [key, apiKey] of Object.entries(QUERY_FLAG_MAP)) {
+      if (parseBool(searchParams.get(key)) || parseBool(searchParams.get(apiKey))) {
+        flags[key] = true;
+      }
+    }
+    return flags;
+  }
+}
+
+module.exports = LocalApiServer;