openrtc 0.1.0

package/dist/moq/messages.js

@@ -0,0 +1,367 @@
+import { BufferWriter, StreamBuffer } from './common';
+// MoQ Transport Draft-07 (0xff000007) Constants
+// https://www.ietf.org/archive/id/draft-ietf-moq-transport-07.html
+export var MsgType;
+(function (MsgType) {
+    MsgType[MsgType["SUBSCRIBE"] = 3] = "SUBSCRIBE";
+    MsgType[MsgType["SUBSCRIBE_OK"] = 4] = "SUBSCRIBE_OK";
+    MsgType[MsgType["SUBSCRIBE_ERROR"] = 5] = "SUBSCRIBE_ERROR";
+    MsgType[MsgType["ANNOUNCE"] = 6] = "ANNOUNCE";
+    MsgType[MsgType["ANNOUNCE_OK"] = 7] = "ANNOUNCE_OK";
+    MsgType[MsgType["ANNOUNCE_ERROR"] = 8] = "ANNOUNCE_ERROR";
+    MsgType[MsgType["UNANNOUNCE"] = 9] = "UNANNOUNCE";
+    MsgType[MsgType["UNSUBSCRIBE"] = 10] = "UNSUBSCRIBE";
+    MsgType[MsgType["SUBSCRIBE_DONE"] = 11] = "SUBSCRIBE_DONE";
+    MsgType[MsgType["ANNOUNCE_CANCEL"] = 12] = "ANNOUNCE_CANCEL";
+    MsgType[MsgType["TRACK_STATUS_REQUEST"] = 13] = "TRACK_STATUS_REQUEST";
+    MsgType[MsgType["TRACK_STATUS"] = 14] = "TRACK_STATUS";
+    MsgType[MsgType["GOAWAY"] = 16] = "GOAWAY";
+    MsgType[MsgType["MAX_SUBSCRIBE_ID"] = 21] = "MAX_SUBSCRIBE_ID";
+    MsgType[MsgType["CLIENT_SETUP"] = 64] = "CLIENT_SETUP";
+    MsgType[MsgType["SERVER_SETUP"] = 65] = "SERVER_SETUP";
+})(MsgType || (MsgType = {}));
+export const SETUP_ROLE_PARAMETER_KEY = 0x00;
+export const SETUP_PATH_PARAMETER_KEY = 0x01;
+// Helper: write a Track Namespace tuple (Draft-07 uses tuple encoding)
+// For simplicity, we encode our single namespace string as a 1-element tuple
+function writeNamespaceTuple(w, namespace) {
+    const bytes = new TextEncoder().encode(namespace);
+    w.writeVarInt(1); // Number of elements in tuple
+    w.writeVarInt(bytes.length); // Length of element 1
+    w.writeBytes(bytes); // Element 1 data
+}
+// Helper: read a Track Namespace tuple
+function readNamespaceTuple(sb) {
+    const numElements = Number(sb.readVarInt());
+    const parts = [];
+    for (let i = 0; i < numElements; i++) {
+        const len = Number(sb.readVarInt());
+        const bytes = sb.readBytes(len);
+        parts.push(new TextDecoder().decode(bytes));
+    }
+    return parts.join('/');
+}
+export class MoQSerializer {
+    /**
+     * Serialize a MoQ control message with proper framing:
+     * Type (varint) + Length (varint) + Payload (bytes)
+     * Per Draft-07: https://www.ietf.org/archive/id/draft-ietf-moq-transport-07.html
+     */
+    static serialize(msg) {
+        const payload = new BufferWriter();
+        switch (msg.type) {
+            case MsgType.CLIENT_SETUP: {
+                const m = msg;
+                payload.writeVarInt(m.supportedVersions.length);
+                for (const v of m.supportedVersions)
+                    payload.writeVarInt(v);
+                // Build params
+                const params = new BufferWriter();
+                let paramCount = 0;
+                // Role (required)
+                if (m.role !== undefined) {
+                    paramCount++;
+                    params.writeVarInt(SETUP_ROLE_PARAMETER_KEY);
+                    params.writeVarInt(1); // Length of value
+                    params.writeVarInt(m.role);
+                }
+                // PATH - MUST NOT be used with WebTransport per Draft-07
+                // (We only use WebTransport, so never send PATH)
+                payload.writeVarInt(paramCount);
+                payload.writeBytes(params.toUint8Array());
+                break;
+            }
+            case MsgType.SERVER_SETUP: {
+                const m = msg;
+                payload.writeVarInt(m.selectedVersion);
+                const params = new BufferWriter();
+                let paramCount = 0;
+                if (m.role !== undefined) {
+                    paramCount++;
+                    params.writeVarInt(SETUP_ROLE_PARAMETER_KEY);
+                    params.writeVarInt(1);
+                    params.writeVarInt(m.role);
+                }
+                payload.writeVarInt(paramCount);
+                payload.writeBytes(params.toUint8Array());
+                break;
+            }
+            case MsgType.SUBSCRIBE: {
+                // Draft-07 SUBSCRIBE:
+                // Subscribe ID (i), Track Alias (i),
+                // Track Namespace (tuple), Track Name Length (i), Track Name (..),
+                // Subscriber Priority (8), Group Order (8), Filter Type (i),
+                // [StartGroup, StartObject], [EndGroup, EndObject],
+                // Number of Parameters (i), Params...
+                const m = msg;
+                payload.writeVarInt(m.subscribeId);
+                payload.writeVarInt(m.trackAlias);
+                // Track Namespace as tuple
+                writeNamespaceTuple(payload, m.trackNamespace);
+                // Track Name (length-prefixed bytes)
+                const nameBytes = new TextEncoder().encode(m.trackName);
+                payload.writeVarInt(nameBytes.length);
+                payload.writeBytes(nameBytes);
+                // Subscriber Priority (8-bit raw byte)
+                payload.writeUint8(m.subscriberPriority ?? 128);
+                // Group Order (8-bit raw byte) 0x0=Original
+                payload.writeUint8(m.groupOrder ?? 0x01); // 0x01 = Ascending
+                // Filter Type (Draft-07: 0x1=LatestGroup, 0x2=LatestObject, 0x3=AbsoluteStart, 0x4=AbsoluteRange)
+                if (m.startGroup !== undefined && m.startObject !== undefined &&
+                    m.endGroup !== undefined && m.endObject !== undefined) {
+                    payload.writeVarInt(0x4); // AbsoluteRange
+                    payload.writeVarInt(m.startGroup);
+                    payload.writeVarInt(m.startObject);
+                    payload.writeVarInt(m.endGroup);
+                    payload.writeVarInt(m.endObject);
+                }
+                else if (m.startGroup !== undefined && m.startObject !== undefined) {
+                    payload.writeVarInt(0x3); // AbsoluteStart
+                    payload.writeVarInt(m.startGroup);
+                    payload.writeVarInt(m.startObject);
+                }
+                else {
+                    payload.writeVarInt(0x1); // LatestGroup
+                }
+                // Number of Parameters
+                payload.writeVarInt(0);
+                break;
+            }
+            case MsgType.SUBSCRIBE_OK: {
+                // Draft-07 SUBSCRIBE_OK:
+                // Subscribe ID (i), Expires (i), Group Order (8), ContentExists (8),
+                // [Largest Group ID (i)], [Largest Object ID (i)],
+                // Number of Parameters (i), Params...
+                const m = msg;
+                payload.writeVarInt(m.subscribeId);
+                payload.writeVarInt(m.expires);
+                payload.writeUint8(0x01); // Group Order: Ascending
+                payload.writeUint8(0); // ContentExists: false
+                // (no Largest Group/Object since ContentExists=0)
+                payload.writeVarInt(0); // Params
+                break;
+            }
+            case MsgType.ANNOUNCE: {
+                // Draft-07 ANNOUNCE:
+                // Track Namespace (tuple), Number of Parameters (i), Params...
+                const m = msg;
+                writeNamespaceTuple(payload, m.trackNamespace);
+                payload.writeVarInt(0); // Params
+                break;
+            }
+            case MsgType.ANNOUNCE_OK: {
+                // Draft-07 ANNOUNCE_OK:
+                // Track Namespace (tuple)
+                const m = msg;
+                writeNamespaceTuple(payload, m.trackNamespace);
+                break;
+            }
+        }
+        // Frame it: Type + Length + Payload
+        const payloadBytes = payload.toUint8Array();
+        const frame = new BufferWriter();
+        frame.writeVarInt(msg.type);
+        frame.writeVarInt(payloadBytes.length);
+        frame.writeBytes(payloadBytes);
+        return frame.toUint8Array();
+    }
+    // Returns parsed message or null if incomplete (EOF)
+    static deserialize(sb) {
+        const typeRes = sb.peekVarInt();
+        if (!typeRes)
+            return null;
+        try {
+            sb.checkpoint();
+            const type = Number(sb.readVarInt());
+            // Read message length (required by MoQ framing)
+            const msgLength = Number(sb.readVarInt());
+            console.log(`[MoQ] Deserializing msg type=0x${type.toString(16)}, length=${msgLength}`);
+            // Verify we have enough bytes for the full message payload
+            if (!sb.has(msgLength)) {
+                sb.rewind();
+                return null;
+            }
+            let msg;
+            switch (type) {
+                case MsgType.SERVER_SETUP: {
+                    const selectedVersion = Number(sb.readVarInt());
+                    const paramCount = Number(sb.readVarInt());
+                    let role = 0;
+                    for (let i = 0; i < paramCount; i++) {
+                        const key = Number(sb.readVarInt());
+                        const len = Number(sb.readVarInt());
+                        const valBytes = sb.readBytes(len);
+                        if (key === SETUP_ROLE_PARAMETER_KEY) {
+                            const pr = new StreamBuffer();
+                            pr.append(valBytes);
+                            role = Number(pr.readVarInt());
+                        }
+                    }
+                    msg = { type, selectedVersion, role };
+                    break;
+                }
+                case MsgType.SUBSCRIBE: {
+                    // Draft-07 SUBSCRIBE
+                    const subscribeId = Number(sb.readVarInt());
+                    const trackAlias = Number(sb.readVarInt());
+                    const trackNamespace = readNamespaceTuple(sb);
+                    // Track Name (length-prefixed bytes)
+                    const nameLen = Number(sb.readVarInt());
+                    const nameBytes = sb.readBytes(nameLen);
+                    const trackName = new TextDecoder().decode(nameBytes);
+                    // Subscriber Priority (8-bit)
+                    sb.readUint8();
+                    // Group Order (8-bit)
+                    sb.readUint8();
+                    const filterType = Number(sb.readVarInt());
+                    let startGroup, startObject, endGroup, endObject;
+                    if (filterType === 0x3) { // AbsoluteStart
+                        startGroup = Number(sb.readVarInt());
+                        startObject = Number(sb.readVarInt());
+                    }
+                    else if (filterType === 0x4) { // AbsoluteRange
+                        startGroup = Number(sb.readVarInt());
+                        startObject = Number(sb.readVarInt());
+                        endGroup = Number(sb.readVarInt());
+                        endObject = Number(sb.readVarInt());
+                    }
+                    // Parameters
+                    const paramCount = Number(sb.readVarInt());
+                    for (let i = 0; i < paramCount; i++) {
+                        const k = Number(sb.readVarInt());
+                        const l = Number(sb.readVarInt());
+                        sb.readBytes(l);
+                    }
+                    msg = { type, subscribeId, trackAlias, trackNamespace, trackName, startGroup, startObject };
+                    break;
+                }
+                case MsgType.SUBSCRIBE_OK: {
+                    // Draft-07 SUBSCRIBE_OK:
+                    // Subscribe ID (i), Expires (i), Group Order (8), ContentExists (8),
+                    // [Largest Group ID (i), Largest Object ID (i)],
+                    // Number of Params (i), Params...
+                    const subscribeId = Number(sb.readVarInt());
+                    const expires = Number(sb.readVarInt());
+                    sb.readUint8(); // Group Order (8-bit)
+                    const contentExists = sb.readUint8(); // ContentExists (8-bit)
+                    if (contentExists === 1) {
+                        sb.readVarInt(); // Largest Group ID
+                        sb.readVarInt(); // Largest Object ID
+                    }
+                    // Parameters
+                    const paramCount = Number(sb.readVarInt());
+                    for (let i = 0; i < paramCount; i++) {
+                        const k = Number(sb.readVarInt());
+                        const l = Number(sb.readVarInt());
+                        sb.readBytes(l);
+                    }
+                    msg = { type, subscribeId, expires };
+                    break;
+                }
+                case MsgType.ANNOUNCE_OK: {
+                    // Draft-07: Track Namespace (tuple)
+                    const trackNamespace = readNamespaceTuple(sb);
+                    msg = { type, trackNamespace };
+                    break;
+                }
+                case MsgType.ANNOUNCE_ERROR: {
+                    const trackNamespace = readNamespaceTuple(sb);
+                    const code = Number(sb.readVarInt());
+                    const reasonLen = Number(sb.readVarInt());
+                    const reasonBytes = sb.readBytes(reasonLen);
+                    const reason = new TextDecoder().decode(reasonBytes);
+                    console.warn(`[MoQ] ANNOUNCE_ERROR: ns=${trackNamespace} code=${code} reason=${reason}`);
+                    msg = { type, trackNamespace, code, reason };
+                    break;
+                }
+                case MsgType.MAX_SUBSCRIBE_ID: {
+                    const subscribeId = Number(sb.readVarInt());
+                    console.log(`[MoQ] MAX_SUBSCRIBE_ID: ${subscribeId}`);
+                    msg = { type, subscribeId };
+                    break;
+                }
+                case MsgType.SUBSCRIBE_ERROR: {
+                    const subscribeId = Number(sb.readVarInt());
+                    const code = Number(sb.readVarInt());
+                    const reasonLen = Number(sb.readVarInt());
+                    const reasonBytes = sb.readBytes(reasonLen);
+                    const reason = new TextDecoder().decode(reasonBytes);
+                    const trackAlias = Number(sb.readVarInt()); // Draft-07: Track Alias at end
+                    console.warn(`[MoQ] SUBSCRIBE_ERROR: id=${subscribeId} code=${code} reason=${reason} alias=${trackAlias}`);
+                    msg = { type, subscribeId, code, reason };
+                    break;
+                }
+                case MsgType.GOAWAY: {
+                    // Just read the URI
+                    const uriLen = Number(sb.readVarInt());
+                    sb.readBytes(uriLen);
+                    console.warn(`[MoQ] GOAWAY received`);
+                    msg = { type };
+                    break;
+                }
+                case MsgType.CLIENT_SETUP: {
+                    const verLen = Number(sb.readVarInt());
+                    const supportedVersions = [];
+                    for (let i = 0; i < verLen; i++)
+                        supportedVersions.push(Number(sb.readVarInt()));
+                    const pCount = Number(sb.readVarInt());
+                    let role = 0;
+                    let path;
+                    for (let i = 0; i < pCount; i++) {
+                        const key = Number(sb.readVarInt());
+                        const len = Number(sb.readVarInt());
+                        const valBytes = sb.readBytes(len);
+                        if (key === SETUP_ROLE_PARAMETER_KEY) {
+                            const pr = new StreamBuffer();
+                            pr.append(valBytes);
+                            role = Number(pr.readVarInt());
+                        }
+                        else if (key === SETUP_PATH_PARAMETER_KEY) {
+                            path = new TextDecoder().decode(valBytes);
+                        }
+                    }
+                    msg = { type, supportedVersions, role, path };
+                    break;
+                }
+                case MsgType.UNSUBSCRIBE: {
+                    const subscribeId = Number(sb.readVarInt());
+                    console.log(`[MoQ] UNSUBSCRIBE for id=${subscribeId}`);
+                    msg = { type, subscribeId };
+                    break;
+                }
+                case MsgType.SUBSCRIBE_DONE: {
+                    const subscribeId = Number(sb.readVarInt());
+                    const code = Number(sb.readVarInt());
+                    const reasonLen = Number(sb.readVarInt());
+                    const reasonBytes = sb.readBytes(reasonLen);
+                    const reason = new TextDecoder().decode(reasonBytes);
+                    let finalGroup, finalObject;
+                    const contentExists = sb.readUint8();
+                    if (contentExists === 1) {
+                        finalGroup = Number(sb.readVarInt());
+                        finalObject = Number(sb.readVarInt());
+                    }
+                    console.log(`[MoQ] SUBSCRIBE_DONE for id=${subscribeId} code=${code} reason=${reason}`);
+                    msg = { type, subscribeId, code, reason, finalGroup, finalObject };
+                    break;
+                }
+                default: {
+                    // Unknown type - skip using the length we already read
+                    console.warn(`[MoQ] Unknown MsgType: 0x${type.toString(16)}, skipping ${msgLength} bytes`);
+                    sb.readBytes(msgLength);
+                    msg = { type };
+                    break;
+                }
+            }
+            sb.commit();
+            return msg;
+        }
+        catch (e) {
+            if (e.message === 'EOF') {
+                sb.rewind();
+                return null;
+            }
+            throw e;
+        }
+    }
+}

package/dist/presets/plutoHosted.d.ts

@@ -0,0 +1,13 @@
+import type { ClientOptions } from '../core/types';
+export declare const PLUTO_HOSTED_PROJECT_ID = "pluto-rtc-prod";
+export declare const PLUTO_HOSTED_FIREBASE_CONFIG: {
+    readonly apiKey: "AIzaSyA62Krj-7ZYFT5xjrTUq7mXana41Ahj_mM";
+    readonly authDomain: "api.openrtc.app";
+    readonly projectId: "pluto-rtc-prod";
+    readonly storageBucket: "pluto-rtc-prod.firebasestorage.app";
+    readonly messagingSenderId: "607066575224";
+    readonly appId: "1:607066575224:web:ed3f51825ba228db92b88d";
+};
+export declare function withPlutoHostedDefaults<T extends ClientOptions>(options: T): T & {
+    projectId: string;
+};

package/dist/presets/plutoHosted.js

@@ -0,0 +1,18 @@
+export const PLUTO_HOSTED_PROJECT_ID = 'pluto-rtc-prod';
+export const PLUTO_HOSTED_FIREBASE_CONFIG = {
+    apiKey: 'AIzaSyA62Krj-7ZYFT5xjrTUq7mXana41Ahj_mM',
+    authDomain: 'api.openrtc.app',
+    projectId: PLUTO_HOSTED_PROJECT_ID,
+    storageBucket: 'pluto-rtc-prod.firebasestorage.app',
+    messagingSenderId: '607066575224',
+    appId: '1:607066575224:web:ed3f51825ba228db92b88d',
+};
+export function withPlutoHostedDefaults(options) {
+    const projectId = typeof options.projectId === 'string' && options.projectId.trim()
+        ? options.projectId.trim()
+        : PLUTO_HOSTED_PROJECT_ID;
+    return {
+        ...options,
+        projectId,
+    };
+}

package/dist/runtime/DelegatingRuntimeAdapter.d.ts

@@ -0,0 +1,68 @@
+import type { AuthContext } from '../core/IEngineBridge';
+import type { Device, DeviceEvent, ExplicitFileDataSendParams, ISignalingBackend, LocalDeviceInfo, NativeConnectResult, RuntimeIdentity, SessionEvent, SignalingEnvelope, SignalingSession } from '../core/types';
+export declare abstract class DelegatingRuntimeAdapter implements ISignalingBackend {
+    protected readonly backend: ISignalingBackend;
+    protected constructor(backend: ISignalingBackend);
+    get currentUser(): RuntimeIdentity | null;
+    setAuthContext(context: AuthContext | null): Promise<void> | void;
+    signInAnonymously(): Promise<void>;
+    signInWithPluto(): Promise<void>;
+    signOut(): Promise<void>;
+    stopAuthScopedActivity(): Promise<void>;
+    getTurnCredentials(): Promise<any>;
+    updatePresence(localNodeId: string, ticketStr: string, isOnline: boolean, ttlMs: number, metadata?: string): Promise<void>;
+    setOffline(localNodeId: string): Promise<void>;
+    cleanupStaleDevices(): Promise<void>;
+    searchDevices(excludeNodeId?: string): Promise<Device[]>;
+    listDevicesWithStatus(): Promise<import('../core/types').DeviceStatusSnapshot[]>;
+    getPeerSession(id: string): Promise<import('../core/types').PeerSessionSnapshot | null>;
+    listPeerSessions(): Promise<import('../core/types').PeerSessionSnapshot[]>;
+    waitForSettledPeer(id: string, timeoutMs?: number): Promise<import('../core/types').PeerSessionSnapshot | null>;
+    resolvePeerIdentity(id: string): Promise<import('../core/types').ResolvedPeerIdentity>;
+    resolvePeerConnectionRecords(id: string): Promise<import('../core/types').ManagedConnectionRecord[]>;
+    updateDevice(deviceId: string, updates: {
+        deviceName?: string;
+        capabilities?: Device['capabilities'];
+        metadata?: string;
+    }): Promise<void>;
+    deleteDevice(deviceId: string): Promise<void>;
+    onDevicesChange(callback: (devices: Device[]) => void, excludeNodeId?: string): () => void;
+    onAuthChange(callback: (user: RuntimeIdentity | null) => void): () => void;
+    checkForSSOToken(): Promise<void>;
+    waitForAuth(): Promise<void>;
+    sendMessage(targetId: string, payload: string, state?: string, replyPayload?: string): Promise<string>;
+    pollMessages(targetId: string): Promise<SignalingEnvelope[]>;
+    subscribeDevices(userId: string): Promise<ReadableStream<DeviceEvent[]>>;
+    startAutoConnect(userId: string, localDeviceId: string): void;
+    startPresenceLoop(userId: string, localNodeId: string, deviceName: string, ticket: string, metadata?: string): void;
+    createSession(session: SignalingSession): Promise<void>;
+    updateSession(sessionId: string, updateData: any): Promise<void>;
+    subscribeSessions(localDeviceId: string): Promise<ReadableStream<SessionEvent[]>>;
+    forceReconnectSnapshot(): void;
+    getLocalDeviceId(): Promise<string | null>;
+    getLocalDeviceInfo(): Promise<LocalDeviceInfo | null>;
+    updateLocalDeviceName(deviceName: string): Promise<LocalDeviceInfo | null>;
+    getManagedNodeId(options?: {
+        initializeIfMissing?: boolean;
+    }): Promise<string | null>;
+    getEndpointTicket(): Promise<string>;
+    getEndpointTicketWithToken(scope: string, maxConnections: number): Promise<string | null>;
+    registerSessionToken(token: string, scope: string, maxConnections: number): Promise<void>;
+    revokeSessionTokensByScope(scope: string): Promise<string[]>;
+    openPeerBi(id: string, timeoutMs?: number): Promise<import('../core/types').BackendPeerBiStream>;
+    openPeerUni(id: string, timeoutMs?: number): Promise<import('../core/types').BackendPeerUniStream>;
+    connectToDevice(params: {
+        deviceId?: string | null;
+        endpointTicket: string;
+    }): Promise<NativeConnectResult>;
+    disconnectDevice(deviceId: string): Promise<void>;
+    isConnected(nodeId: string): Promise<boolean>;
+    getConnectionStates(): Promise<import('../core/types').BackendConnectionState[]>;
+    onConnectionStateChange(callback: (state: import('../core/types').BackendConnectionState) => void): Promise<() => void> | (() => void);
+    sendExplicitFilePath(connectionId: string, filePath: string, transferId?: string): Promise<string>;
+    sendExplicitFileData(params: ExplicitFileDataSendParams): Promise<void>;
+    getTransferHistory(limit?: number): Promise<Array<[string, unknown]>>;
+    deleteTransferJob(jobId: string): Promise<void>;
+    onIncomingNativeMessage(callback: (connectionId: string, remoteNodeId: string | null, message: any) => void): Promise<() => void>;
+    unwrap(): ISignalingBackend;
+}