POC: nodejs control plane (Feedback wanted)

node/.gitignore

@@ -0,0 +1,8 @@
+node_modules
+*.lock
+/log/
+/media/
+/template/
+/data/
+/casparcg.config
+/_media/

node/package.json

@@ -0,0 +1,32 @@
+{
+    "name": "casparcg-server-node",
+    "version": "1.0.0",
+    "type": "module",
+    "main": "main.js",
+    "license": "MIT",
+    "dependencies": {
+        "cmake-js": "^7.2.1",
+        "date-fns": "^3.6.0",
+        "fast-xml-parser": "^4.3.3",
+        "node-addon-api": "^7.0.0",
+        "object-path": "^0.11.8",
+        "osc": "^2.4.4",
+        "type-fest": "^4.10.0"
+    },
+    "scripts": {
+        "start": "yarn ts-node-esm src/main.ts",
+        "build": "cmake-js -d ../src build --prefer-clang=false"
+    },
+    "binary": {
+        "napi_versions": [
+            7
+        ]
+    },
+    "devDependencies": {
+        "@sofie-automation/code-standard-preset": "^2.5.2",
+        "@types/node": "^20.11.0",
+        "@types/object-path": "^0.11.4",
+        "ts-node": "^10.9.2",
+        "typescript": "^5.3.3"
+    }
+}

node/src/@types/osc.d.ts

@@ -0,0 +1,141 @@
+// Copied from https://github.com/colinbdclark/osc.js/pull/105
+
+declare module "osc" {
+    export class EventEmitter<T> {
+        addListener<E extends keyof T>(event: E, listener: T[E]): this;
+
+        on<E extends keyof T>(event: E, listener: T[E]): this;
+
+        once<E extends keyof T>(event: E, listener: T[E]): this;
+
+        removeListener<E extends keyof T>(event: E, listener: T[E]): this;
+
+        removeAllListeners(event?: keyof T): this;
+
+        setMaxListeners(n: number): this;
+
+        getMaxListeners(): number;
+
+        listeners<E extends keyof T>(event: E): T[E][];
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        emit(event: string | symbol, ...args: any[]): boolean;
+        listenerCount(type: keyof T): number;
+
+        // Added in Node 6...
+        prependListener<E extends keyof T>(event: E, listener: T[E]): this;
+
+        prependOnceListener<E extends keyof T>(event: E, listener: T[E]): this;
+
+        eventNames(): Array<keyof T>;
+    }
+
+    export const defaults: {
+        metadata: boolean;
+        unpackSingleArgs: boolean;
+    };
+    export type Argument = number | string | Uint8Array;
+    export type MetaArgument =
+        | { type: "i" | "f"; value: number }
+        | { type: "s"; value: string }
+        | { type: "b"; value: Uint8Array };
+
+    export abstract class SLIPPort {}
+
+    export interface OscMessage {
+        address: string;
+        args: Argument | Array<Argument> | MetaArgument | Array<MetaArgument>;
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-empty-interface
+    export interface OscBundle {}
+
+    export interface SenderInfo {
+        address: string;
+        port: number;
+        size: number;
+        family: "IPv4" | "IPv6";
+    }
+
+    export interface PortEvents {
+        ready: () => void;
+        message: (
+            message: OscMessage,
+            timeTag: number | undefined,
+            info: SenderInfo
+        ) => void;
+        bundle: (bundle: OscBundle, timeTag: number, info: SenderInfo) => void;
+        osc: (packet: OscBundle | OscMessage, info: SenderInfo) => void;
+        raw: (data: Uint8Array, info: SenderInfo) => void;
+        error: (err: Error) => void;
+    }
+
+    export interface UdpOptions {
+        /**
+         * The port to listen on
+         */
+        localPort?: number; // 57121
+        /**
+         * The local address to bind to
+         */
+        localAddress?: string; // '127.0.0.1'
+        /**
+         * The remote port to send messages to
+         */
+        remotePort?: number;
+        /**
+         * The remote address to send messages to
+         */
+        remoteAddress?: string;
+        broadcast?: boolean; // false
+        /**
+         * The time to live (number of hops) for a multicast connection
+         */
+        multicastTTL?: number;
+        /**
+         * An array of multicast addresses to join when listening for multicast messages
+         */
+        multicastMembership?: string[];
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        socket?: any;
+
+        /**
+         * should message arguments be wrapped with type?
+         */
+        metadata?: boolean;
+        unpackSingleArgs?: boolean;
+    }
+
+    export interface OscSender {
+        send(msg: OscMessage, address?: string, port?: number): void;
+    }
+
+    export abstract class Port
+        extends EventEmitter<PortEvents>
+        implements OscSender
+    {
+        send(msg: OscMessage, address?: string, port?: number): void;
+    }
+
+    export class SerialPort extends SLIPPort {
+        open(): void;
+
+        close(): void;
+
+        listen(): void;
+    }
+
+    export class UDPPort extends Port {
+        static setupMulticast(that: UDPPort): void;
+
+        options: UdpOptions;
+
+        constructor(options: UdpOptions);
+
+        open(): void;
+
+        close(): void;
+
+        listen(): void;
+    }
+}

node/src/amcp/channel_locks.ts

@@ -0,0 +1,76 @@
+import type { Client } from "./client.js";
+
+interface ChannelLock {
+    clientIds: Set<string>;
+    lockPhrase: string;
+}
+
+export class ChannelLocks {
+    readonly #locked = new Map<number, ChannelLock>();
+    readonly #overridePhrase: string;
+
+    constructor(overridePhrase: string) {
+        this.#overridePhrase = overridePhrase;
+    }
+
+    public forgetClient(client: Client): void {
+        for (const key of this.#locked.keys()) {
+            this.releaseLock(client, key);
+        }
+    }
+
+    public isChannelLocked(client: Client, channelIndex: number): boolean {
+        if (channelIndex < 0) return false;
+
+        const lock = this.#locked.get(channelIndex);
+        if (!lock) return false;
+        return !lock.clientIds.has(client.id);
+    }
+
+    public releaseLock(client: Client, channelIndex: number): void {
+        const lock = this.#locked.get(channelIndex);
+        if (!lock) return;
+
+        if (lock.clientIds.delete(client.id)) {
+            console.info(`Channel ${channelIndex} released`);
+
+            if (lock.clientIds.size === 0) {
+                this.#locked.delete(channelIndex);
+            }
+        }
+    }
+
+    public tryLock(
+        client: Client,
+        channelIndex: number,
+        lockPhrase: string
+    ): boolean {
+        const lock = this.#locked.get(channelIndex) ?? {
+            clientIds: new Set(),
+            lockPhrase: "",
+        };
+        this.#locked.set(channelIndex, lock);
+
+        if (lock.lockPhrase && lock.lockPhrase !== lockPhrase) {
+            return false;
+        }
+
+        lock.lockPhrase = lockPhrase;
+        lock.clientIds.add(client.id);
+
+        console.info(`Channel ${channelIndex} acquired`);
+
+        return true;
+    }
+
+    public clearLocks(overridePhrase: string | undefined): boolean {
+        if (this.#overridePhrase && this.#overridePhrase !== overridePhrase) {
+            return false;
+        }
+
+        this.#locked.clear();
+
+        console.info("Channel locks cleared");
+        return true;
+    }
+}

node/src/amcp/client.ts

@@ -0,0 +1,8 @@
+import type { AMCPClientBatchInfo } from "./protocol.js";
+
+export interface Client {
+    readonly id: string;
+    readonly address: string;
+
+    readonly batch: AMCPClientBatchInfo;
+}