kirby-ocpp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,129 @@
+# kirby-ocpp
+
+Terminal OCPP 1.6J charge point emulator for local and staging CSMS testing.
+
+It runs as an interactive TUI, speaks OCPP 1.6 JSON over WebSocket, validates payloads against bundled OCPP 1.6J JSON schemas, and can persist station state per charge point id.
+
+## Install
+
+Run without installing:
+
+```bash
+npx kirby-ocpp --url ws://localhost:9000/ocpp --id CP-001
+```
+
+Or install globally:
+
+```bash
+npm install -g kirby-ocpp
+kirby-ocpp --url ws://localhost:9000/ocpp --id CP-001
+```
+
+## Usage
+
+```bash
+kirby-ocpp --url ws://localhost:9000/ocpp --id CP-001
+```
+
+Common options:
+
+```bash
+kirby-ocpp \
+  --url ws://localhost:9000/ocpp \
+  --id CP-001 \
+  --vendor Kirby \
+  --model TUI-16 \
+  --connector 1 \
+  --connectors 2 \
+  --heartbeat 30
+```
+
+WSS/TLS options:
+
+```bash
+kirby-ocpp \
+  --url wss://csms.example.com/ocpp \
+  --id CP-001 \
+  --tls-ca ./ca.pem \
+  --tls-cert ./client-cert.pem \
+  --tls-key ./client-key.pem
+```
+
+Useful runtime flags:
+
+- `--no-persist`: run an ephemeral station.
+- `--state-dir <path>`: choose where station state is stored.
+- `--ws-subprotocol <protocol>`: defaults to `ocpp1.6`.
+- `--ws-ping <seconds>`: WebSocket ping interval, `0` disables pings.
+- `--no-reconnect`: disable automatic reconnect.
+- `--reconnect-initial-ms <ms>`, `--reconnect-max-ms <ms>`, `--reconnect-max-attempts <count>`: reconnect backoff.
+- `--call-timeout-ms <ms>`: OCPP CALL response timeout.
+- `--tls-server-name <name>` and `--tls-skip-verify`: local/self-signed WSS testing.
+
+Environment variables mirror the main flags: `OCPP_URL`, `OCPP_CHARGE_POINT_ID`, `OCPP_VENDOR`, `OCPP_MODEL`, `OCPP_WS_SUBPROTOCOL`, `OCPP_WS_PING_INTERVAL`, `OCPP_RECONNECT`, `OCPP_RECONNECT_INITIAL_MS`, `OCPP_RECONNECT_MAX_MS`, `OCPP_RECONNECT_MAX_ATTEMPTS`, `OCPP_CALL_TIMEOUT_MS`, `OCPP_TLS_CA_FILE`, `OCPP_TLS_CERT_FILE`, `OCPP_TLS_KEY_FILE`, `OCPP_TLS_SERVER_NAME`, and `OCPP_TLS_SKIP_VERIFY`.
+
+## TUI
+
+The interface is organized into tabs. Use `1`-`7` or `Tab` / `Shift+Tab` to switch tabs, `Up` / `Down` to select an action, and `Enter` to run it.
+
+- `1` Station
+- `2` Connector
+- `3` Transaction
+- `4` Maintenance
+- `5` Data
+- `6` Logs
+- `7` Scenarios
+
+Global shortcuts:
+
+- `/`: command palette.
+- `[` / `]`: previous/next connector.
+- `+`: add connector.
+- `j` / `k`: scroll logs.
+- `G`: jump logs to bottom.
+- `F`: cycle log filter.
+- `l`: full-screen plain log view.
+- `y`: copy current log buffer.
+- `?`: help.
+- `q`: quit.
+
+Forms prompt for values such as `idTag`, connector id, measurands, and `DataTransfer` payloads. There is no built-in default RFID/idTag.
+
+## Persistence
+
+State is persisted by default per `chargePointId`. This includes mutable configuration, local auth lists/cache, charging profiles, connector meter values, reservations, and pending offline transactions.
+
+```bash
+kirby-ocpp --url ws://localhost:9000/ocpp --id CP-001 --no-persist
+kirby-ocpp --url ws://localhost:9000/ocpp --id CP-001 --state-dir ./station-state
+```
+
+## Scope
+
+kirby-ocpp targets OCPP 1.6J. It supports common Charge Point calls and Central System commands for booting, authorization, transactions, metering, local auth lists, reservations, availability, reset, diagnostics, firmware, smart charging, trigger messages, and data transfer.
+
+Detailed coverage is tracked in [docs/OCPP_1.6J_CONFORMANCE.md](docs/OCPP_1.6J_CONFORMANCE.md).
+
+## Development
+
+```bash
+npm install
+npm run dev -- --url ws://localhost:9000/ocpp --id CP-001
+```
+
+Before publishing:
+
+```bash
+npm run typecheck
+npm test
+npm run smoke
+npm run pack:check
+```
+
+`npm run pack:check` builds the package, installs the generated tarball into a temporary directory, and verifies the installed CLI and bundled schemas.
+
+## Third-Party Materials
+
+This project is MIT licensed. Bundled OCPP 1.6J JSON schemas are sourced from the official Open Charge Alliance OCPP 1.6 download package and are included for validation/conformance. They are not owned by this project and are not covered by this project's MIT license.
+
+See [THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md).

package/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,15 @@
+# Third-Party Notices
+
+## OCPP 1.6J JSON schemas
+
+This package bundles the OCPP 1.6J JSON schemas under `dist/ocpp/schemas/json` for local protocol validation.
+
+The schemas are sourced from the official Open Charge Alliance OCPP 1.6 download package:
+
+- https://openchargealliance.org/my-oca/ocpp/
+
+The OCPP 1.6J specification package references Creative Commons Attribution-NoDerivatives 4.0 International:
+
+- https://creativecommons.org/licenses/by-nd/4.0/legalcode
+
+The bundled schemas are included for compatibility/conformance validation and are not owned by this project. The project license in `LICENSE` applies to this project's own source code, not to Open Charge Alliance materials. Open Charge Alliance does not sponsor or endorse this package.

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { createRequire } from "node:module";
+import { ZodError } from "zod";
+import { parseConfig } from "./config.js";
+import { Station } from "./station.js";
+import { Tui } from "./tui.js";
+const program = new Command();
+const require = createRequire(import.meta.url);
+const packageJson = require("../package.json");
+program
+    .name("kirby-ocpp")
+    .description("Terminal OCPP charge point emulator")
+    .version(packageJson.version ?? "0.1.0")
+    .option("-u, --url <url>", "Central System WebSocket URL, e.g. ws://localhost:9000/ocpp")
+    .option("-i, --id <id>", "charge point id", process.env.OCPP_CHARGE_POINT_ID ?? "CP-001")
+    .option("--vendor <vendor>", "charge point vendor", process.env.OCPP_VENDOR ?? "archhaze24")
+    .option("--model <model>", "charge point model", process.env.OCPP_MODEL ?? "KIRBY")
+    .option("-c, --connector <id>", "initial connector id", "1")
+    .option("--connectors <count>", "number of station connectors", "1")
+    .option("--heartbeat <seconds>", "fallback heartbeat interval in seconds", "30")
+    .option("--no-persist", "do not save station state such as local auth list and charging profiles")
+    .option("--state-dir <path>", "directory for persisted station state")
+    .option("--ws-subprotocol <protocol>", "WebSocket subprotocol to request", "ocpp1.6")
+    .option("--ws-ping <seconds>", "WebSocket ping interval in seconds, 0 disables pings", "30")
+    .option("--no-reconnect", "do not automatically reconnect after an unexpected WebSocket disconnect")
+    .option("--reconnect-initial-ms <milliseconds>", "initial automatic reconnect delay in milliseconds", "1000")
+    .option("--reconnect-max-ms <milliseconds>", "maximum automatic reconnect delay in milliseconds", "30000")
+    .option("--reconnect-max-attempts <attempts>", "maximum automatic reconnect attempts, 0 means unlimited", "0")
+    .option("--call-timeout-ms <milliseconds>", "OCPP CALL response timeout in milliseconds", "30000")
+    .option("--tls-ca <path>", "CA certificate bundle for wss:// connections")
+    .option("--tls-cert <path>", "client certificate for wss:// mutual TLS")
+    .option("--tls-key <path>", "client private key for wss:// mutual TLS")
+    .option("--tls-server-name <name>", "TLS server name override for wss:// connections")
+    .option("--tls-skip-verify", "disable TLS certificate verification for local/self-signed wss:// testing")
+    .parse();
+const options = program.opts();
+try {
+    const config = parseConfig({
+        centralSystemUrl: options.url,
+        chargePointId: options.id,
+        vendor: options.vendor,
+        model: options.model,
+        connectorId: options.connector,
+        connectorCount: Math.max(Number.parseInt(options.connectors, 10), Number.parseInt(options.connector, 10)),
+        heartbeatIntervalSeconds: options.heartbeat,
+        persistState: options.persist,
+        stateDirectory: options.stateDir,
+        webSocketSubprotocol: options.wsSubprotocol,
+        webSocketPingIntervalSeconds: options.wsPing,
+        webSocketReconnectEnabled: options.reconnect,
+        webSocketReconnectInitialDelayMs: options.reconnectInitialMs,
+        webSocketReconnectMaxDelayMs: options.reconnectMaxMs,
+        webSocketReconnectMaxAttempts: options.reconnectMaxAttempts,
+        callTimeoutMs: options.callTimeoutMs,
+        tlsRejectUnauthorized: !options.tlsSkipVerify,
+        tlsCaFile: options.tlsCa,
+        tlsCertFile: options.tlsCert,
+        tlsKeyFile: options.tlsKey,
+        tlsServerName: options.tlsServerName
+    });
+    const station = new Station(config);
+    const tui = new Tui(station);
+    tui.start();
+}
+catch (error) {
+    if (error instanceof ZodError) {
+        console.error(error.errors.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("\n"));
+        process.exit(1);
+    }
+    throw error;
+}

package/dist/config.d.ts

@@ -0,0 +1,2 @@
+import type { StationConfig } from "./ocpp/types.js";
+export declare function parseConfig(input: Partial<Record<keyof StationConfig, unknown>>): StationConfig;

package/dist/config.js

@@ -0,0 +1,53 @@
+import { z } from "zod";
+const configSchema = z.object({
+    centralSystemUrl: z
+        .string({
+        required_error: "Use --url or OCPP_URL to set the Central System WebSocket URL"
+    })
+        .url(),
+    chargePointId: z.string().min(1),
+    vendor: z.string().min(1),
+    model: z.string().min(1),
+    connectorId: z.coerce.number().int().positive(),
+    connectorCount: z.coerce.number().int().positive(),
+    heartbeatIntervalSeconds: z.coerce.number().int().positive(),
+    persistState: z.coerce.boolean(),
+    stateDirectory: z.string().min(1).optional(),
+    webSocketSubprotocol: z.string().min(1),
+    webSocketPingIntervalSeconds: z.coerce.number().int().nonnegative(),
+    webSocketReconnectEnabled: z.coerce.boolean(),
+    webSocketReconnectInitialDelayMs: z.coerce.number().int().nonnegative(),
+    webSocketReconnectMaxDelayMs: z.coerce.number().int().nonnegative(),
+    webSocketReconnectMaxAttempts: z.coerce.number().int().nonnegative(),
+    callTimeoutMs: z.coerce.number().int().positive(),
+    tlsRejectUnauthorized: z.coerce.boolean(),
+    tlsCaFile: z.string().min(1).optional(),
+    tlsCertFile: z.string().min(1).optional(),
+    tlsKeyFile: z.string().min(1).optional(),
+    tlsServerName: z.string().min(1).optional()
+});
+export function parseConfig(input) {
+    return configSchema.parse({
+        centralSystemUrl: input.centralSystemUrl ?? process.env.OCPP_URL,
+        chargePointId: input.chargePointId ?? process.env.OCPP_CHARGE_POINT_ID ?? "CP-001",
+        vendor: input.vendor ?? process.env.OCPP_VENDOR ?? "archhaze24",
+        model: input.model ?? process.env.OCPP_MODEL ?? "KIRBY",
+        connectorId: input.connectorId ?? 1,
+        connectorCount: input.connectorCount ?? input.connectorId ?? 1,
+        heartbeatIntervalSeconds: input.heartbeatIntervalSeconds ?? 30,
+        persistState: input.persistState ?? process.env.KIRBY_OCPP_NO_PERSIST !== "1",
+        stateDirectory: input.stateDirectory ?? process.env.KIRBY_OCPP_STATE_DIR,
+        webSocketSubprotocol: input.webSocketSubprotocol ?? process.env.OCPP_WS_SUBPROTOCOL ?? "ocpp1.6",
+        webSocketPingIntervalSeconds: input.webSocketPingIntervalSeconds ?? process.env.OCPP_WS_PING_INTERVAL ?? 30,
+        webSocketReconnectEnabled: input.webSocketReconnectEnabled ?? process.env.OCPP_RECONNECT !== "0",
+        webSocketReconnectInitialDelayMs: input.webSocketReconnectInitialDelayMs ?? process.env.OCPP_RECONNECT_INITIAL_MS ?? 1_000,
+        webSocketReconnectMaxDelayMs: input.webSocketReconnectMaxDelayMs ?? process.env.OCPP_RECONNECT_MAX_MS ?? 30_000,
+        webSocketReconnectMaxAttempts: input.webSocketReconnectMaxAttempts ?? process.env.OCPP_RECONNECT_MAX_ATTEMPTS ?? 0,
+        callTimeoutMs: input.callTimeoutMs ?? process.env.OCPP_CALL_TIMEOUT_MS ?? 30_000,
+        tlsRejectUnauthorized: input.tlsRejectUnauthorized ?? process.env.OCPP_TLS_SKIP_VERIFY !== "1",
+        tlsCaFile: input.tlsCaFile ?? process.env.OCPP_TLS_CA_FILE,
+        tlsCertFile: input.tlsCertFile ?? process.env.OCPP_TLS_CERT_FILE,
+        tlsKeyFile: input.tlsKeyFile ?? process.env.OCPP_TLS_KEY_FILE,
+        tlsServerName: input.tlsServerName ?? process.env.OCPP_TLS_SERVER_NAME
+    });
+}

package/dist/ocpp/client.d.ts

@@ -0,0 +1,59 @@
+import EventEmitter from "node:events";
+import type { CallResponse, OcppMessage } from "./types.js";
+interface OcppClientEvents {
+    connected: [];
+    disconnected: [code?: number, reason?: string];
+    error: [error: Error];
+    log: [direction: "in" | "out", message: OcppMessage];
+    call: [messageId: string, action: string, payload: Record<string, unknown>];
+}
+export interface OcppClientOptions {
+    subprotocol?: string;
+    pingIntervalSeconds?: number;
+    tlsRejectUnauthorized?: boolean;
+    tlsCaFile?: string;
+    tlsCertFile?: string;
+    tlsKeyFile?: string;
+    tlsServerName?: string;
+}
+export declare interface OcppClient {
+    on<K extends keyof OcppClientEvents>(event: K, listener: (...args: OcppClientEvents[K]) => void): this;
+    emit<K extends keyof OcppClientEvents>(event: K, ...args: OcppClientEvents[K]): boolean;
+}
+export declare class OcppClient extends EventEmitter {
+    private readonly centralSystemUrl;
+    private readonly chargePointId;
+    private readonly options;
+    private socket?;
+    private pingTimer?;
+    private awaitingPong;
+    private readonly pending;
+    private readonly incomingCalls;
+    private readonly schemaValidator;
+    constructor(centralSystemUrl: string, chargePointId: string, options?: OcppClientOptions);
+    get isConnected(): boolean;
+    connect(): void;
+    close(): void;
+    call(action: string, payload: Record<string, unknown>, timeoutMs?: number): Promise<CallResponse>;
+    reply(messageId: string, payload: Record<string, unknown>): void;
+    replyError(messageId: string, code: string, description: string, details?: Record<string, unknown>): void;
+    private send;
+    private handleMessage;
+    private resolveCall;
+    private rejectCall;
+    private rejectPending;
+    private toError;
+    private assertValidRequest;
+    private assertValidResponse;
+    private validationErrorCode;
+    private isValidCall;
+    private isValidCallResult;
+    private isValidCallError;
+    private isObjectPayload;
+    private readMessageId;
+    private startPingTimer;
+    private stopPingTimer;
+    private buildChargePointUrl;
+    private buildWebSocketOptions;
+}
+export {};

package/dist/ocpp/client.js

@@ -0,0 +1,294 @@
+import EventEmitter from "node:events";
+import { readFileSync } from "node:fs";
+import { nanoid } from "nanoid";
+import WebSocket from "ws";
+import { OcppSchemaValidator } from "./schema-validator.js";
+export class OcppClient extends EventEmitter {
+    centralSystemUrl;
+    chargePointId;
+    options;
+    socket;
+    pingTimer;
+    awaitingPong = false;
+    pending = new Map();
+    incomingCalls = new Map();
+    schemaValidator = new OcppSchemaValidator();
+    constructor(centralSystemUrl, chargePointId, options = {}) {
+        super();
+        this.centralSystemUrl = centralSystemUrl;
+        this.chargePointId = chargePointId;
+        this.options = options;
+    }
+    get isConnected() {
+        return this.socket?.readyState === WebSocket.OPEN;
+    }
+    connect() {
+        this.close();
+        const url = this.buildChargePointUrl();
+        const subprotocol = this.options.subprotocol ?? "ocpp1.6";
+        this.socket = new WebSocket(url, [subprotocol], this.buildWebSocketOptions());
+        this.socket.on("open", () => {
+            if (this.socket?.protocol !== subprotocol) {
+                const error = new Error(`Central System did not negotiate required WebSocket subprotocol ${subprotocol}`);
+                this.emit("error", error);
+                this.socket?.close(1002, "OCPP subprotocol required");
+                return;
+            }
+            this.startPingTimer();
+            this.emit("connected");
+        });
+        this.socket.on("message", (data) => this.handleMessage(data.toString()));
+        this.socket.on("pong", () => {
+            this.awaitingPong = false;
+        });
+        this.socket.on("close", (code, reason) => {
+            this.stopPingTimer();
+            this.rejectPending(new Error(`Connection closed (${code})`));
+            this.emit("disconnected", code, reason.toString());
+        });
+        this.socket.on("error", (error) => this.emit("error", error));
+    }
+    close() {
+        if (!this.socket) {
+            return;
+        }
+        this.rejectPending(new Error("Connection closed"));
+        this.stopPingTimer();
+        this.socket.removeAllListeners();
+        if (this.socket.readyState === WebSocket.OPEN || this.socket.readyState === WebSocket.CONNECTING) {
+            this.socket.close();
+        }
+        this.socket = undefined;
+    }
+    async call(action, payload, timeoutMs = 30_000) {
+        if (!this.isConnected || !this.socket) {
+            throw new Error("Not connected to Central System");
+        }
+        this.assertValidRequest(action, payload);
+        const messageId = nanoid(12);
+        const message = [2, messageId, action, payload];
+        const response = new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.pending.delete(messageId);
+                reject(new Error(`${action} timed out after ${timeoutMs}ms`));
+            }, timeoutMs);
+            this.pending.set(messageId, { action, resolve, reject, timeout });
+        });
+        this.send(message);
+        return response;
+    }
+    reply(messageId, payload) {
+        const action = this.incomingCalls.get(messageId);
+        if (!action) {
+            throw new Error(`Cannot reply to unknown CALL ${messageId}`);
+        }
+        this.assertValidResponse(action, payload);
+        this.incomingCalls.delete(messageId);
+        this.send([3, messageId, payload]);
+    }
+    replyError(messageId, code, description, details = {}) {
+        this.incomingCalls.delete(messageId);
+        this.send([4, messageId, code, description, details]);
+    }
+    send(message) {
+        if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
+            throw new Error("WebSocket is not open");
+        }
+        this.socket.send(JSON.stringify(message));
+        this.emit("log", "out", message);
+    }
+    handleMessage(raw) {
+        let message;
+        try {
+            message = JSON.parse(raw);
+        }
+        catch (error) {
+            this.emit("error", error instanceof Error ? error : new Error(String(error)));
+            return;
+        }
+        this.emit("log", "in", message);
+        if (!Array.isArray(message)) {
+            this.emit("error", new Error("Invalid OCPP message: expected array"));
+            return;
+        }
+        if (message[0] === 2) {
+            if (!this.isValidCall(message)) {
+                const messageId = this.readMessageId(message);
+                if (messageId) {
+                    this.replyError(messageId, "FormationViolation", "Invalid CALL frame");
+                }
+                this.emit("error", new Error("Invalid CALL frame"));
+                return;
+            }
+            const call = message;
+            if (!this.schemaValidator.hasRequestSchema(call[2])) {
+                this.replyError(call[1], "NotImplemented", `${call[2]} is not an OCPP 1.6J action`);
+                return;
+            }
+            const validation = this.schemaValidator.validateRequest(call[2], call[3]);
+            if (!validation.valid) {
+                this.replyError(call[1], this.validationErrorCode(validation.errorNames), validation.errors.join("; "));
+                return;
+            }
+            this.incomingCalls.set(call[1], call[2]);
+            this.emit("call", call[1], call[2], call[3] ?? {});
+            return;
+        }
+        if (message[0] === 3) {
+            if (!this.isValidCallResult(message)) {
+                this.emit("error", new Error("Invalid CALLRESULT frame"));
+                return;
+            }
+            this.resolveCall(message);
+            return;
+        }
+        if (message[0] === 4) {
+            if (!this.isValidCallError(message)) {
+                this.emit("error", new Error("Invalid CALLERROR frame"));
+                return;
+            }
+            this.rejectCall(message);
+            return;
+        }
+        this.emit("error", new Error(`Unsupported OCPP message type: ${message[0]}`));
+    }
+    resolveCall(message) {
+        const [, messageId, payload] = message;
+        const pending = this.pending.get(messageId);
+        if (!pending) {
+            return;
+        }
+        clearTimeout(pending.timeout);
+        this.pending.delete(messageId);
+        const validation = this.schemaValidator.validateResponse(pending.action, payload);
+        if (!validation.valid) {
+            pending.reject(new Error(`${pending.action} response violates OCPP 1.6J schema (${this.validationErrorCode(validation.errorNames)}): ${validation.errors.join("; ")}`));
+            return;
+        }
+        pending.resolve({ messageId, payload });
+    }
+    rejectCall(message) {
+        const error = this.toError(message);
+        const pending = this.pending.get(error.messageId);
+        if (!pending) {
+            this.emit("error", new Error(error.description || error.code));
+            return;
+        }
+        clearTimeout(pending.timeout);
+        this.pending.delete(error.messageId);
+        pending.reject(new Error(`${pending.action} failed: ${error.code} ${error.description}`.trim()));
+    }
+    rejectPending(error) {
+        for (const [messageId, pending] of this.pending) {
+            clearTimeout(pending.timeout);
+            pending.reject(error);
+            this.pending.delete(messageId);
+        }
+    }
+    toError(message) {
+        const [, messageId, code, description, details] = message;
+        return { messageId, code, description, details };
+    }
+    assertValidRequest(action, payload) {
+        const validation = this.schemaValidator.validateRequest(action, payload);
+        if (!validation.valid) {
+            throw new Error(`${action} request violates OCPP 1.6J schema (${this.validationErrorCode(validation.errorNames)}): ${validation.errors.join("; ")}`);
+        }
+    }
+    assertValidResponse(action, payload) {
+        const validation = this.schemaValidator.validateResponse(action, payload);
+        if (!validation.valid) {
+            throw new Error(`${action} response violates OCPP 1.6J schema (${this.validationErrorCode(validation.errorNames)}): ${validation.errors.join("; ")}`);
+        }
+    }
+    validationErrorCode(errorNames) {
+        if (errorNames.includes("required")) {
+            return "OccurenceConstraintViolation";
+        }
+        if (errorNames.includes("type")) {
+            return "TypeConstraintViolation";
+        }
+        if (errorNames.some((name) => ["additionalProperties", "enum", "maxLength", "minLength", "minimum", "maximum", "multipleOf", "format"].includes(name))) {
+            return "PropertyConstraintViolation";
+        }
+        return "FormationViolation";
+    }
+    isValidCall(message) {
+        return (message.length === 4 &&
+            message[0] === 2 &&
+            typeof message[1] === "string" &&
+            typeof message[2] === "string" &&
+            this.isObjectPayload(message[3]));
+    }
+    isValidCallResult(message) {
+        return message.length === 3 && message[0] === 3 && typeof message[1] === "string" && this.isObjectPayload(message[2]);
+    }
+    isValidCallError(message) {
+        return (message.length === 5 &&
+            message[0] === 4 &&
+            typeof message[1] === "string" &&
+            typeof message[2] === "string" &&
+            typeof message[3] === "string" &&
+            this.isObjectPayload(message[4]));
+    }
+    isObjectPayload(value) {
+        return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+    }
+    readMessageId(message) {
+        return typeof message[1] === "string" ? message[1] : undefined;
+    }
+    startPingTimer() {
+        this.stopPingTimer();
+        const intervalSeconds = this.options.pingIntervalSeconds ?? 30;
+        if (intervalSeconds <= 0) {
+            return;
+        }
+        this.awaitingPong = false;
+        this.pingTimer = setInterval(() => {
+            if (this.socket?.readyState === WebSocket.OPEN) {
+                if (this.awaitingPong) {
+                    this.emit("error", new Error("WebSocket pong timed out"));
+                    this.socket.terminate();
+                    return;
+                }
+                this.awaitingPong = true;
+                this.socket.ping();
+            }
+        }, intervalSeconds * 1000);
+        this.pingTimer.unref();
+    }
+    stopPingTimer() {
+        if (!this.pingTimer) {
+            return;
+        }
+        clearInterval(this.pingTimer);
+        this.pingTimer = undefined;
+        this.awaitingPong = false;
+    }
+    buildChargePointUrl() {
+        const base = this.centralSystemUrl.replace(/\/+$/, "");
+        const id = encodeURIComponent(this.chargePointId);
+        if (base.endsWith(`/${id}`)) {
+            return base;
+        }
+        return `${base}/${id}`;
+    }
+    buildWebSocketOptions() {
+        const options = {
+            rejectUnauthorized: this.options.tlsRejectUnauthorized ?? true
+        };
+        if (this.options.tlsCaFile) {
+            options.ca = readFileSync(this.options.tlsCaFile);
+        }
+        if (this.options.tlsCertFile) {
+            options.cert = readFileSync(this.options.tlsCertFile);
+        }
+        if (this.options.tlsKeyFile) {
+            options.key = readFileSync(this.options.tlsKeyFile);
+        }
+        if (this.options.tlsServerName) {
+            options.servername = this.options.tlsServerName;
+        }
+        return options;
+    }
+}

package/dist/ocpp/schema-validator.d.ts

@@ -0,0 +1,15 @@
+export interface OcppSchemaValidationResult {
+    valid: boolean;
+    errors: string[];
+    errorNames: string[];
+}
+export declare class OcppSchemaValidator {
+    private readonly validator;
+    private readonly schemas;
+    constructor(schemaDirectory?: string);
+    hasRequestSchema(action: string): boolean;
+    hasResponseSchema(action: string): boolean;
+    validateRequest(action: string, payload: unknown): OcppSchemaValidationResult;
+    validateResponse(action: string, payload: unknown): OcppSchemaValidationResult;
+    private validate;
+}