erlc-v2 1.0.0 → 1.1.0

package/src/api/LocalApiServer.js

@@ -0,0 +1,538 @@
+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;

package/src/events/Poller.js

@@ -58,6 +58,7 @@ class Poller {
       joins: new SeenSignatures(),
       commands: new SeenSignatures(),
       modCalls: new SeenSignatures(),
+      emergencyCalls: new SeenSignatures(),
     };
   }
 
@@ -98,6 +99,8 @@ class Poller {
       this.seen.commands.seed(buildLogSignature("commands", item));
     for (const item of snapshot.modCalls)
       this.seen.modCalls.seed(buildLogSignature("modCalls", item));
+    for (const item of snapshot.emergencyCalls)
+      this.seen.emergencyCalls.seed(buildLogSignature("emergencyCalls", item));
   }
 
   _emitServerUpdate(current) {
@@ -241,6 +244,16 @@ class Poller {
         });
       }
     }
+
+    for (const emergencyCall of current.emergencyCalls) {
+      const signature = buildLogSignature("emergencyCalls", emergencyCall);
+      if (!this.seen.emergencyCalls.checkAndAdd(signature)) continue;
+      this.client.emit("emergencyCall", {
+        emergencyCall,
+        signature,
+        snapshot: current,
+      });
+    }
   }
 
   _handleSnapshot(current) {
@@ -280,6 +293,7 @@ class Poller {
           killLogs: true,
           commandLogs: true,
           modCalls: true,
+          emergencyCalls: true,
           vehicles: true,
         },
         {

package/src/events/diff.js

@@ -10,10 +10,11 @@ function getVehicleKey(vehicle) {
   if (!vehicle) return "";
   const name = vehicle.Name ?? "";
   const owner = vehicle.Owner ?? "";
+  const plate = vehicle.Plate ?? "";
   const texture = vehicle.Texture ?? "";
   const colorHex = vehicle.ColorHex ?? "";
   const colorName = vehicle.ColorName ?? "";
-  return `${name}|${owner}|${texture}|${colorHex}|${colorName}`;
+  return `${name}|${owner}|${plate}|${texture}|${colorHex}|${colorName}`;
 }
 
 function diffByKey(previous, current, keyFn) {
@@ -74,6 +75,14 @@ function buildLogSignature(type, item) {
         caller: item?.Caller ?? "",
         moderator: item?.Moderator ?? "",
       });
+    case "emergencyCalls":
+      return stableStringify({
+        startedAt: item?.StartedAt ?? null,
+        callNumber: item?.CallNumber ?? null,
+        team: item?.Team ?? "",
+        caller: item?.Caller ?? "",
+        description: item?.Description ?? "",
+      });
     default:
       return stableStringify(item);
   }

package/src/util/constants.js

@@ -21,6 +21,7 @@ const QUERY_FLAG_MAP = {
   killLogs: "KillLogs",
   commandLogs: "CommandLogs",
   modCalls: "ModCalls",
+  emergencyCalls: "EmergencyCalls",
   vehicles: "Vehicles",
 };
 
@@ -43,6 +44,16 @@ const DEFAULT_OPTIONS = {
     intervalMs: 2500,
     bypassCache: true,
   },
+  api: {
+    enabled: false,
+    host: "127.0.0.1",
+    port: null,
+    path: "/erlc",
+    webhookPath: null,
+    publicUrl: "",
+    token: "",
+    logRequests: true,
+  },
 };
 
 module.exports = {

package/src/util/errors.js

@@ -65,7 +65,7 @@ function createApiError({
     return new ERLCAPIError(message, common);
   }
 
-  return new ERLCHttpError(`HTTP ${status}`, {
+  return new ERLCHttpError(message === API_ERROR_MESSAGES[0] ? `HTTP ${status}` : message, {
     status,
     endpoint,
     bucket,

package/src/util/normalize.js

@@ -15,6 +15,7 @@ function normalizeServerResponse(raw = {}) {
     killLogs: Array.isArray(raw.KillLogs) ? raw.KillLogs : [],
     commandLogs: Array.isArray(raw.CommandLogs) ? raw.CommandLogs : [],
     modCalls: Array.isArray(raw.ModCalls) ? raw.ModCalls : [],
+    emergencyCalls: Array.isArray(raw.EmergencyCalls) ? raw.EmergencyCalls : [],
     vehicles: Array.isArray(raw.Vehicles) ? raw.Vehicles : [],
     raw,
   };