@lsdsoftware/janus-client-node 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 LSD Software
+
+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,2 @@
+# janus-client-node
+Janus WebSocket client for Node, built on RxJS observables

package/dist/client.js

@@ -0,0 +1,60 @@
+import { connect } from "@service-broker/websocket";
+import assert from "assert";
+import * as rxjs from "rxjs";
+import { JanusError } from "./types.js";
+export function createClient(websocketUrl, websocketOpts) {
+    return connect(websocketUrl, websocketOpts, 'janus-protocol').pipe(rxjs.map(conn => {
+        const requestSubject = new rxjs.Subject();
+        const pendingRequests = new Map();
+        return {
+            requestSubject,
+            send$: requestSubject.pipe(rxjs.concatMap(request => {
+                const txId = String(Math.random());
+                request.message.transaction = txId;
+                return new rxjs.Observable(subscriber => conn.send(JSON.stringify(request.message), err => {
+                    if (err) {
+                        subscriber.next(new Error('JanusClient sendMessage fail', { cause: err }));
+                        subscriber.complete();
+                    }
+                    else {
+                        subscriber.complete();
+                        pendingRequests.set(txId, request);
+                    }
+                }));
+            }), rxjs.share()),
+            receive$: conn.message$.pipe(rxjs.concatMap(event => {
+                try {
+                    assert(typeof event.data == 'string');
+                    const message = JSON.parse(event.data);
+                    if (message.janus == 'event' && typeof message.transaction == 'undefined') {
+                        return rxjs.of(message);
+                    }
+                    else {
+                        const request = pendingRequests.get(message.transaction);
+                        if (request) {
+                            pendingRequests.delete(message.transaction);
+                            if (message.janus == 'error') {
+                                const { code, reason } = message.error;
+                                request.reject(new JanusError(code, reason));
+                            }
+                            else {
+                                request.fulfill(message);
+                            }
+                            return rxjs.EMPTY;
+                        }
+                        else {
+                            throw new Error('Stray');
+                        }
+                    }
+                }
+                catch (err) {
+                    if (err instanceof Error)
+                        err.cause = event.data;
+                    return rxjs.of(new Error('JanusClient processMessage fail', { cause: err }));
+                }
+            }), rxjs.share()),
+            close$: conn.close$,
+            close: conn.close.bind(conn)
+        };
+    }));
+}

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from "./types.js";
+export * from "./client.js";
+export * from "./session.js";
+export * from "./plugin-handle.js";
+export * from "./util.js";

package/dist/index.test.js

@@ -0,0 +1,39 @@
+import { afterEverything, describe, expect, Expectation } from "@service-broker/test-utils";
+import assert from "assert";
+import * as rxjs from "rxjs";
+import { createClient, createPluginHandle, createSession, JanusError, request } from "./index.js";
+const requestSubject = new rxjs.ReplaySubject();
+const shutdownSubject = new rxjs.Subject();
+assert(process.env.JANUS_URL, 'Missing env JANUS_URL');
+createClient(process.env.JANUS_URL).pipe(rxjs.tap(() => console.info('JanusClient connected')), 
+//rxjs.retry({ delay: 15_000 }),
+//rxjs.repeat({ delay: 1_000 }),
+rxjs.exhaustMap(client => rxjs.merge(client.send$, client.receive$, createSession(client).pipe(rxjs.tap(() => console.info('JanusSession created')), rxjs.exhaustMap(session => rxjs.merge(session.send$, session.keepAlive$, createPluginHandle(session, 'janus.plugin.videoroom').pipe(rxjs.tap(() => console.info('JanusPluginHandle attached')), rxjs.exhaustMap(handle => rxjs.merge(handle.send$, requestSubject.pipe(rxjs.concatMap(request => {
+    handle.requestSubject.next(request);
+    return rxjs.EMPTY;
+}))).pipe(rxjs.finalize(() => handle.detach()))))).pipe(rxjs.finalize(() => session.destroy()))))).pipe(rxjs.takeUntil(client.close$), rxjs.finalize(() => client.close()))), rxjs.takeUntil(shutdownSubject)).subscribe({
+    next(event) {
+        if (event instanceof Error)
+            console.error(event);
+        else if (event instanceof JanusError)
+            console.error('JanusError', event);
+        else
+            console.info('Unhandled', event);
+    },
+    error(err) {
+        console.error('FATAL', err);
+    }
+});
+afterEverything(() => shutdownSubject.next());
+function req(message) {
+    return rxjs.firstValueFrom(request(requestSubject, message));
+}
+describe('main', ({ test }) => {
+    test('first', async () => {
+        const result = await req({ request: 'list' });
+        expect(result, {
+            videoroom: 'success',
+            list: new Expectation('is', 'array', actual => assert(Array.isArray(actual)))
+        });
+    });
+});

package/dist/plugin-handle.js

@@ -0,0 +1,41 @@
+import * as rxjs from "rxjs";
+import { JanusError } from "./types.js";
+import { request } from "./util.js";
+export function createPluginHandle(session, plugin) {
+    return request(session.requestSubject, { janus: "attach", plugin }).pipe(rxjs.map(({ data: { id: handleId } }) => {
+        const requestSubject = new rxjs.Subject();
+        return {
+            requestSubject,
+            send$: requestSubject.pipe(rxjs.concatMap(request => {
+                session.requestSubject.next({
+                    message: {
+                        janus: "message",
+                        handle_id: handleId,
+                        body: request.message
+                    },
+                    fulfill(response) {
+                        const { data } = response.plugindata;
+                        if (data.error) {
+                            const { error, error_code } = data;
+                            request.reject(new JanusError(error_code, error));
+                        }
+                        else {
+                            request.fulfill(data);
+                        }
+                    },
+                    reject(err) {
+                        request.reject(err);
+                    }
+                });
+                return rxjs.EMPTY;
+            })),
+            detach() {
+                session.requestSubject.next({
+                    message: { janus: "detach" },
+                    fulfill: rxjs.noop,
+                    reject: err => console.error('JanusPluginHandle detach fail', handleId, err)
+                });
+            }
+        };
+    }));
+}

package/dist/session.js

@@ -0,0 +1,32 @@
+import * as rxjs from "rxjs";
+import { request } from "./util.js";
+export function createSession(client, { keepAliveInterval = 45_000 } = {}) {
+    return request(client.requestSubject, { janus: 'create' }).pipe(rxjs.map(({ data: { id: sessionId } }) => {
+        const requestSubject = new rxjs.Subject();
+        return {
+            requestSubject,
+            send$: requestSubject.pipe(rxjs.concatMap(request => {
+                request.message.session_id = sessionId;
+                client.requestSubject.next(request);
+                return rxjs.EMPTY;
+            })),
+            keepAlive$: requestSubject.pipe(rxjs.switchMap(() => rxjs.interval(keepAliveInterval).pipe(rxjs.switchMap(() => new rxjs.Observable(subscriber => client.requestSubject.next({
+                message: { janus: "keepalive", session_id: sessionId },
+                fulfill() {
+                    subscriber.complete();
+                },
+                reject(err) {
+                    subscriber.next(err);
+                    subscriber.complete();
+                }
+            })))))),
+            destroy() {
+                client.requestSubject.next({
+                    message: { janus: 'destroy' },
+                    fulfill: rxjs.noop,
+                    reject: err => console.error('JanusSession destroy fail', sessionId, err)
+                });
+            }
+        };
+    }));
+}

package/dist/types.js

@@ -0,0 +1,8 @@
+export class JanusError {
+    code;
+    reason;
+    constructor(code, reason) {
+        this.code = code;
+        this.reason = reason;
+    }
+}

package/dist/util.js

@@ -0,0 +1,13 @@
+import * as rxjs from "rxjs";
+export function request(requestSubject, message) {
+    return new rxjs.Observable(subscriber => requestSubject.next({
+        message,
+        fulfill(response) {
+            subscriber.next(response);
+            subscriber.complete();
+        },
+        reject(err) {
+            subscriber.error(err);
+        }
+    }));
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@lsdsoftware/janus-client-node",
+  "version": "1.0.0",
+  "description": "Janus WebSocket client for Node, built on RxJS observables",
+  "keywords": [
+    "janus",
+    "janus-client",
+    "janus-gateway",
+    "websocket",
+    "rxjs"
+  ],
+  "homepage": "https://github.com/lsdsoftware/janus-client-node#readme",
+  "bugs": {
+    "url": "https://github.com/lsdsoftware/janus-client-node/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lsdsoftware/janus-client-node.git"
+  },
+  "license": "MIT",
+  "author": "Hai Phan <hai.phan@gmail.com>",
+  "type": "module",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "test": "node dist/index.test.js"
+  },
+  "dependencies": {
+    "@service-broker/websocket": "^1.1.0"
+  },
+  "devDependencies": {
+    "@service-broker/test-utils": "^1.1.2",
+    "typescript": "^5.9.3"
+  }
+}

package/src/client.ts

@@ -0,0 +1,67 @@
+import { connect } from "@service-broker/websocket"
+import assert from "assert"
+import { ClientRequestArgs } from "http"
+import * as rxjs from "rxjs"
+import { ClientOptions } from "ws"
+import { JanusError, JanusMessage, JanusRequest } from "./types.js"
+
+export function createClient(websocketUrl: string, websocketOpts?: ClientOptions | ClientRequestArgs) {
+  return connect(websocketUrl, websocketOpts, 'janus-protocol').pipe(
+    rxjs.map(conn => {
+      const requestSubject = new rxjs.Subject<JanusRequest>()
+      const pendingRequests = new Map<unknown, JanusRequest>()
+      return {
+        requestSubject,
+        send$: requestSubject.pipe(
+          rxjs.concatMap(request => {
+            const txId = String(Math.random())
+            request.message.transaction = txId
+            return new rxjs.Observable<Error>(subscriber =>
+              conn.send(JSON.stringify(request.message), err => {
+                if (err) {
+                  subscriber.next(new Error('JanusClient sendMessage fail', { cause: err }))
+                  subscriber.complete()
+                } else {
+                  subscriber.complete()
+                  pendingRequests.set(txId, request)
+                }
+              })
+            )
+          }),
+          rxjs.share()
+        ),
+        receive$: conn.message$.pipe(
+          rxjs.concatMap(event => {
+            try {
+              assert(typeof event.data == 'string')
+              const message = JSON.parse(event.data) as JanusMessage
+              if (message.janus == 'event' && typeof message.transaction == 'undefined') {
+                return rxjs.of(message)
+              } else {
+                const request = pendingRequests.get(message.transaction)
+                if (request) {
+                  pendingRequests.delete(message.transaction)
+                  if (message.janus == 'error') {
+                    const { code, reason } = message.error as { code: number, reason: string }
+                    request.reject(new JanusError(code, reason))
+                  } else {
+                    request.fulfill(message)
+                  }
+                  return rxjs.EMPTY
+                } else {
+                  throw new Error('Stray')
+                }
+              }
+            } catch (err) {
+              if (err instanceof Error) err.cause = event.data
+              return rxjs.of(new Error('JanusClient processMessage fail', { cause: err }))
+            }
+          }),
+          rxjs.share()
+        ),
+        close$: conn.close$,
+        close: conn.close.bind(conn)
+      }
+    })
+  )
+}

package/src/index.test.ts

@@ -0,0 +1,80 @@
+import { afterEverything, describe, expect, Expectation } from "@service-broker/test-utils"
+import assert from "assert"
+import * as rxjs from "rxjs"
+import { createClient, createPluginHandle, createSession, JanusError, JanusRequest, request } from "./index.js"
+
+const requestSubject = new rxjs.ReplaySubject<JanusRequest>()
+const shutdownSubject = new rxjs.Subject<void>()
+
+assert(process.env.JANUS_URL, 'Missing env JANUS_URL')
+
+createClient(process.env.JANUS_URL).pipe(
+  rxjs.tap(() => console.info('JanusClient connected')),
+  //rxjs.retry({ delay: 15_000 }),
+  //rxjs.repeat({ delay: 1_000 }),
+  rxjs.exhaustMap(client =>
+    rxjs.merge(
+      client.send$,
+      client.receive$,
+      createSession(client).pipe(
+        rxjs.tap(() => console.info('JanusSession created')),
+        rxjs.exhaustMap(session =>
+          rxjs.merge(
+            session.send$,
+            session.keepAlive$,
+            createPluginHandle(session, 'janus.plugin.videoroom').pipe(
+              rxjs.tap(() => console.info('JanusPluginHandle attached')),
+              rxjs.exhaustMap(handle =>
+                rxjs.merge(
+                  handle.send$,
+                  requestSubject.pipe(
+                    rxjs.concatMap(request => {
+                      handle.requestSubject.next(request)
+                      return rxjs.EMPTY
+                    })
+                  )
+                ).pipe(
+                  rxjs.finalize(() => handle.detach())
+                )
+              )
+            )
+          ).pipe(
+            rxjs.finalize(() => session.destroy())
+          )
+        )
+      ),
+    ).pipe(
+      rxjs.takeUntil(client.close$),
+      rxjs.finalize(() => client.close())
+    )
+  ),
+  rxjs.takeUntil(shutdownSubject)
+).subscribe({
+  next(event) {
+    if (event instanceof Error) console.error(event)
+    else if (event instanceof JanusError) console.error('JanusError', event)
+    else console.info('Unhandled', event)
+  },
+  error(err) {
+    console.error('FATAL', err)
+  }
+})
+
+afterEverything(() => shutdownSubject.next())
+
+function req(message: Record<string, unknown>) {
+  return rxjs.firstValueFrom(
+    request(requestSubject, message)
+  )
+}
+
+
+describe('main', ({ test }) => {
+  test('first', async () => {
+    const result = await req({ request: 'list' })
+    expect(result, {
+      videoroom: 'success',
+      list: new Expectation('is', 'array', actual => assert(Array.isArray(actual)))
+    })
+  })
+})

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from "./types.js"
+export * from "./client.js"
+export * from "./session.js"
+export * from "./plugin-handle.js"
+export * from "./util.js"

package/src/plugin-handle.ts

@@ -0,0 +1,45 @@
+import * as rxjs from "rxjs"
+import { JanusError, JanusRequest } from "./types.js"
+import { request } from "./util.js"
+
+export function createPluginHandle(session: { requestSubject: rxjs.Subject<JanusRequest> }, plugin: string) {
+  return request<{ data: { id: number } }>(session.requestSubject, { janus: "attach", plugin }).pipe(
+    rxjs.map(({ data: { id: handleId }}) => {
+      const requestSubject = new rxjs.Subject<JanusRequest>()
+      return {
+        requestSubject,
+        send$: requestSubject.pipe(
+          rxjs.concatMap(request => {
+            session.requestSubject.next({
+              message: {
+                janus: "message",
+                handle_id: handleId,
+                body: request.message
+              },
+              fulfill(response) {
+                const { data } = response.plugindata as { data: Record<string, unknown> }
+                if (data.error) {
+                  const { error, error_code } = data as { error: string, error_code: number }
+                  request.reject(new JanusError(error_code, error))
+                } else {
+                  request.fulfill(data)
+                }
+              },
+              reject(err) {
+                request.reject(err)
+              }
+            })
+            return rxjs.EMPTY
+          })
+        ),
+        detach() {
+          session.requestSubject.next({
+            message: { janus: "detach" },
+            fulfill: rxjs.noop,
+            reject: err => console.error('JanusPluginHandle detach fail', handleId, err)
+          })
+        }
+      }
+    })
+  )
+}

package/src/session.ts

@@ -0,0 +1,50 @@
+import * as rxjs from "rxjs"
+import { JanusError, JanusRequest } from "./types.js"
+import { request } from "./util.js"
+
+export function createSession(client: { requestSubject: rxjs.Subject<JanusRequest> }, { keepAliveInterval = 45_000 }: {
+  keepAliveInterval?: number
+} = {}) {
+  return request<{ data: { id: number } }>(client.requestSubject, { janus: 'create' }).pipe(
+    rxjs.map(({ data: { id: sessionId } }) => {
+      const requestSubject = new rxjs.Subject<JanusRequest>()
+      return {
+        requestSubject,
+        send$: requestSubject.pipe(
+          rxjs.concatMap(request => {
+            request.message.session_id = sessionId
+            client.requestSubject.next(request)
+            return rxjs.EMPTY
+          })
+        ),
+        keepAlive$: requestSubject.pipe(
+          rxjs.switchMap(() =>
+            rxjs.interval(keepAliveInterval).pipe(
+              rxjs.switchMap(() =>
+                new rxjs.Observable<JanusError>(subscriber =>
+                  client.requestSubject.next({
+                    message: { janus: "keepalive", session_id: sessionId },
+                    fulfill() {
+                      subscriber.complete()
+                    },
+                    reject(err) {
+                      subscriber.next(err)
+                      subscriber.complete()
+                    }
+                  })
+                )
+              )
+            )
+          )
+        ),
+        destroy() {
+          client.requestSubject.next({
+            message: { janus: 'destroy' },
+            fulfill: rxjs.noop,
+            reject: err => console.error('JanusSession destroy fail', sessionId, err)
+          })
+        }
+      }
+    })
+  )
+}

package/src/types.ts

@@ -0,0 +1,12 @@
+
+export type JanusMessage = Record<string, unknown>
+
+export class JanusError {
+  constructor(readonly code: number, readonly reason: string) {}
+}
+
+export interface JanusRequest {
+  readonly message: JanusMessage
+  fulfill(response: JanusMessage): void
+  reject(err: JanusError): void
+}

package/src/util.ts

@@ -0,0 +1,20 @@
+import * as rxjs from "rxjs"
+import { JanusMessage, JanusRequest } from "./types.js"
+
+export function request<T extends JanusMessage>(
+  requestSubject: rxjs.Subject<JanusRequest>,
+  message: JanusMessage
+) {
+  return new rxjs.Observable<T>(subscriber =>
+    requestSubject.next({
+      message,
+      fulfill(response) {
+        subscriber.next(response as T)
+        subscriber.complete()
+      },
+      reject(err) {
+        subscriber.error(err)
+      }
+    })
+  )
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "module": "nodenext",
+    "target": "es2022",
+    "moduleResolution": "nodenext",
+    "strict": true,
+    "newLine": "lf",
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": [
+    "src/**/*"
+  ]
+}