@agentdance/node-webrtc 1.0.0

package/src/peer-connection.ts

@@ -0,0 +1,253 @@
+import { EventEmitter } from 'events';
+import type {
+  RTCConfiguration,
+  RTCSessionDescriptionInit,
+  RTCSessionDescription,
+  RTCIceCandidateInit,
+  RTCOfferOptions,
+  RTCAnswerOptions,
+  RTCSignalingState,
+  RTCPeerConnectionState,
+  RTCIceConnectionState,
+  RTCIceGatheringState,
+  RTCDataChannelInit,
+  RTCRtpTransceiverDirection,
+} from './types.js';
+import { RTCDataChannel as _RTCDataChannel } from './data-channel.js';
+import { RTCRtpTransceiver as _RTCRtpTransceiver } from './rtp-transceiver.js';
+
+export { RTCSessionDescription } from './session-description.js';
+export { RTCIceCandidate } from './ice-candidate.js';
+export { RTCDataChannel } from './data-channel.js';
+export { RTCRtpSender } from './rtp-sender.js';
+export { RTCRtpReceiver } from './rtp-receiver.js';
+export { RTCRtpTransceiver } from './rtp-transceiver.js';
+
+export * from './types.js';
+
+export declare interface RTCPeerConnection {
+  on(event: 'icecandidate', listener: (init: RTCIceCandidateInit | null) => void): this;
+  on(event: 'icecandidateerror', listener: (ev: { errorCode: number; errorText: string }) => void): this;
+  on(event: 'iceconnectionstatechange', listener: () => void): this;
+  on(event: 'icegatheringstatechange', listener: () => void): this;
+  on(event: 'connectionstatechange', listener: () => void): this;
+  on(event: 'signalingstatechange', listener: () => void): this;
+  on(event: 'negotiationneeded', listener: () => void): this;
+  on(event: 'datachannel', listener: (channel: import('./data-channel.js').RTCDataChannel) => void): this;
+  on(event: 'track', listener: (ev: RTCTrackEvent) => void): this;
+}
+
+export interface RTCTrackEvent {
+  receiver: import('./rtp-receiver.js').RTCRtpReceiver;
+  track: { kind: string };
+}
+
+export class RTCPeerConnection extends EventEmitter {
+  readonly localDescription: RTCSessionDescription | null = null;
+  readonly remoteDescription: RTCSessionDescription | null = null;
+  readonly currentLocalDescription: RTCSessionDescription | null = null;
+  readonly currentRemoteDescription: RTCSessionDescription | null = null;
+  readonly pendingLocalDescription: RTCSessionDescription | null = null;
+  readonly pendingRemoteDescription: RTCSessionDescription | null = null;
+
+  signalingState: RTCSignalingState = 'stable';
+  connectionState: RTCPeerConnectionState = 'new';
+  iceConnectionState: RTCIceConnectionState = 'new';
+  iceGatheringState: RTCIceGatheringState = 'new';
+
+  private _config: Required<RTCConfiguration>;
+  private _isClosed = false;
+  private _transceivers: _RTCRtpTransceiver[] = [];
+  private _dataChannels: Map<string, _RTCDataChannel> = new Map();
+  private _pendingChannels: _RTCDataChannel[] = [];
+
+  // Protocol stack (initialized lazily)
+  private _internals: import('./internal/peer-internals.js').PeerInternals | undefined;
+
+  constructor(config: RTCConfiguration = {}) {
+    super();
+    this._config = {
+      iceServers: config.iceServers ?? [{ urls: 'stun:stun.l.google.com:19302' }],
+      iceTransportPolicy: config.iceTransportPolicy ?? 'all',
+      bundlePolicy: config.bundlePolicy ?? 'max-bundle',
+      rtcpMuxPolicy: config.rtcpMuxPolicy ?? 'require',
+      iceCandidatePoolSize: config.iceCandidatePoolSize ?? 0,
+      certificates: config.certificates ?? [],
+    };
+  }
+
+  async createOffer(options?: RTCOfferOptions): Promise<RTCSessionDescriptionInit> {
+    this._assertNotClosed();
+    const internals = await this._getOrCreateInternals();
+    return internals.createOffer(options ?? {});
+  }
+
+  async createAnswer(options?: RTCAnswerOptions): Promise<RTCSessionDescriptionInit> {
+    this._assertNotClosed();
+    const internals = await this._getOrCreateInternals();
+    return internals.createAnswer(options ?? {});
+  }
+
+  async setLocalDescription(description: RTCSessionDescriptionInit): Promise<void> {
+    this._assertNotClosed();
+    const internals = await this._getOrCreateInternals();
+    await internals.setLocalDescription(description);
+    (this as { localDescription: RTCSessionDescription | null }).localDescription = {
+      type: description.type,
+      sdp: description.sdp,
+    };
+    this._updateSignalingState(description.type, 'local');
+  }
+
+  async setRemoteDescription(description: RTCSessionDescriptionInit): Promise<void> {
+    this._assertNotClosed();
+    const internals = await this._getOrCreateInternals();
+    await internals.setRemoteDescription(description);
+    (this as { remoteDescription: RTCSessionDescription | null }).remoteDescription = {
+      type: description.type,
+      sdp: description.sdp,
+    };
+    this._updateSignalingState(description.type, 'remote');
+  }
+
+  async addIceCandidate(candidate: RTCIceCandidateInit | null): Promise<void> {
+    const internals = this._internals;
+    if (!internals) return;
+    // null or empty candidate string = end-of-candidates signal (RFC 8840 §4.4)
+    if (!candidate || !candidate.candidate) {
+      internals.iceAgent?.remoteGatheringComplete();
+      return;
+    }
+    await internals.addIceCandidate(candidate);
+  }
+
+  createDataChannel(label: string, init?: RTCDataChannelInit): _RTCDataChannel {
+    this._assertNotClosed();
+    const channel = new _RTCDataChannel(label, init ?? {}, null);
+    // Use a unique key: label + id (if specified) + random suffix to avoid collisions
+    const key = label + ':' + (init?.id ?? '') + ':' + Math.random().toString(36).slice(2);
+    this._dataChannels.set(key, channel);
+
+    if (this._internals?.sctpAssociation?.state === 'connected') {
+      // SCTP is ready now — open immediately
+      this._internals.openDataChannel(channel);
+    } else if (this._internals) {
+      // Internals exist but SCTP not ready — hand off to internals pending queue
+      this._internals.openDataChannel(channel);
+    } else {
+      // Internals not yet created — store locally until SCTP is ready
+      this._pendingChannels.push(channel);
+    }
+
+    // Clean up the map when the channel closes
+    channel.on('close', () => {
+      this._dataChannels.delete(key);
+    });
+
+    return channel;
+  }
+
+  addTransceiver(
+    kind: 'audio' | 'video',
+    init?: { direction?: RTCRtpTransceiverDirection },
+  ): _RTCRtpTransceiver {
+    this._assertNotClosed();
+    const transceiver = new _RTCRtpTransceiver(kind, init?.direction ?? 'sendrecv');
+    this._transceivers.push(transceiver);
+    this.emit('negotiationneeded');
+    return transceiver;
+  }
+
+  getTransceivers(): _RTCRtpTransceiver[] {
+    return [...this._transceivers];
+  }
+
+  getSenders(): import('./rtp-sender.js').RTCRtpSender[] {
+    return this._transceivers
+      .map((t) => t.sender)
+      .filter(Boolean) as import('./rtp-sender.js').RTCRtpSender[];
+  }
+
+  getReceivers(): import('./rtp-receiver.js').RTCRtpReceiver[] {
+    return this._transceivers
+      .map((t) => t.receiver)
+      .filter(Boolean) as import('./rtp-receiver.js').RTCRtpReceiver[];
+  }
+
+  async getStats(): Promise<import('./stats.js').RTCStatsReport> {
+    const { RTCStatsReportImpl } = await import('./stats.js');
+    const internals = this._internals;
+    if (!internals) return new RTCStatsReportImpl(new Map());
+    return internals.getStats();
+  }
+
+  close(): void {
+    if (this._isClosed) return;
+    this._isClosed = true;
+    this._internals?.close();
+    this._updateConnectionState('closed');
+    this.signalingState = 'closed';
+  }
+
+  restartIce(): void {
+    this._internals?.restartIce();
+  }
+
+  private async _getOrCreateInternals(): Promise<import('./internal/peer-internals.js').PeerInternals> {
+    if (!this._internals) {
+      const { PeerInternals } = await import('./internal/peer-internals.js');
+      this._internals = new PeerInternals(this._config, this);
+      // Transfer any channels created before internals existed
+      for (const channel of this._pendingChannels) {
+        this._internals.openDataChannel(channel);
+      }
+      this._pendingChannels = [];
+    }
+    return this._internals;
+  }
+
+  private _assertNotClosed(): void {
+    if (this._isClosed) throw new Error('RTCPeerConnection is closed');
+  }
+
+  private _updateSignalingState(type: string, side: 'local' | 'remote'): void {
+    const prev = this.signalingState;
+    let next: RTCSignalingState = prev;
+
+    if (type === 'rollback') {
+      next = 'stable';
+    } else if (type === 'offer') {
+      next = side === 'local' ? 'have-local-offer' : 'have-remote-offer';
+    } else if (type === 'answer') {
+      next = 'stable';
+    } else if (type === 'pranswer') {
+      next = side === 'local' ? 'have-local-pranswer' : 'have-remote-pranswer';
+    }
+
+    if (next !== prev) {
+      this.signalingState = next;
+      this.emit('signalingstatechange');
+    }
+  }
+
+  _updateConnectionState(state: RTCPeerConnectionState): void {
+    if (this.connectionState !== state) {
+      this.connectionState = state;
+      this.emit('connectionstatechange');
+    }
+  }
+
+  _updateIceConnectionState(state: RTCIceConnectionState): void {
+    if (this.iceConnectionState !== state) {
+      this.iceConnectionState = state;
+      this.emit('iceconnectionstatechange');
+    }
+  }
+
+  _updateIceGatheringState(state: RTCIceGatheringState): void {
+    if (this.iceGatheringState !== state) {
+      this.iceGatheringState = state;
+      this.emit('icegatheringstatechange');
+    }
+  }
+}

package/src/rtp-receiver.ts

@@ -0,0 +1,51 @@
+import { EventEmitter } from 'events';
+import type { RTCRtpReceiveParameters } from './types.js';
+import type { MediaStreamTrack } from './rtp-sender.js';
+
+export class RTCRtpReceiver extends EventEmitter {
+  readonly track: MediaStreamTrack | null = null;
+  readonly transport: RTCDtlsTransport | null = null;
+
+  getParameters(): RTCRtpReceiveParameters {
+    return { codecs: [], headerExtensions: [] };
+  }
+
+  async getStats(): Promise<RTCStatsReport> {
+    return new Map() as unknown as RTCStatsReport;
+  }
+
+  getContributingSources(): RTCRtpContributingSource[] {
+    return [];
+  }
+
+  getSynchronizationSources(): RTCRtpSynchronizationSource[] {
+    return [];
+  }
+
+  static getCapabilities(kind: string): { codecs: unknown[]; headerExtensions: unknown[] } | null {
+    if (kind === 'audio') {
+      return {
+        codecs: [
+          { mimeType: 'audio/opus', clockRate: 48000, channels: 2 },
+          { mimeType: 'audio/PCMU', clockRate: 8000 },
+        ],
+        headerExtensions: [],
+      };
+    } else if (kind === 'video') {
+      return {
+        codecs: [
+          { mimeType: 'video/VP8', clockRate: 90000 },
+          { mimeType: 'video/VP9', clockRate: 90000 },
+        ],
+        headerExtensions: [],
+      };
+    }
+    return null;
+  }
+}
+
+// Stub types
+interface RTCDtlsTransport {}
+interface RTCStatsReport {}
+interface RTCRtpContributingSource { source: number; timestamp: number; audioLevel?: number; }
+interface RTCRtpSynchronizationSource extends RTCRtpContributingSource {}

package/src/rtp-sender.ts

@@ -0,0 +1,77 @@
+import { EventEmitter } from 'events';
+import type { RTCRtpSendParameters, RTCRtpEncodingParameters } from './types.js';
+
+// Minimal track interface for Node.js (browser MediaStreamTrack not available)
+export interface MediaStreamTrack {
+  kind: string;
+  id: string;
+  enabled: boolean;
+  muted: boolean;
+  readyState: 'live' | 'ended';
+}
+
+export class RTCRtpSender extends EventEmitter {
+  readonly track: MediaStreamTrack | null;
+  readonly transport: RTCDtlsTransport | null = null;
+  private _parameters: RTCRtpSendParameters;
+
+  constructor(track: MediaStreamTrack | null) {
+    super();
+    this.track = track;
+    this._parameters = {
+      codecs: [],
+      headerExtensions: [],
+      encodings: [],
+      transactionId: '',
+    };
+  }
+
+  async getStats(): Promise<RTCStatsReport> {
+    return new Map() as unknown as RTCStatsReport;
+  }
+
+  getParameters(): RTCRtpSendParameters {
+    return { ...this._parameters };
+  }
+
+  async setParameters(params: RTCRtpSendParameters): Promise<void> {
+    this._parameters = params;
+  }
+
+  replaceTrack(withTrack: MediaStreamTrack | null): Promise<void> {
+    (this as unknown as { track: MediaStreamTrack | null }).track = withTrack;
+    return Promise.resolve();
+  }
+
+  static getCapabilities(kind: string): { codecs: unknown[]; headerExtensions: unknown[] } | null {
+    // Return default codec capabilities
+    if (kind === 'audio') {
+      return {
+        codecs: [
+          { mimeType: 'audio/opus', clockRate: 48000, channels: 2 },
+          { mimeType: 'audio/PCMU', clockRate: 8000 },
+          { mimeType: 'audio/PCMA', clockRate: 8000 },
+        ],
+        headerExtensions: [
+          { uri: 'urn:ietf:params:rtp-hdrext:ssrc-audio-level', id: 1 },
+        ],
+      };
+    } else if (kind === 'video') {
+      return {
+        codecs: [
+          { mimeType: 'video/VP8', clockRate: 90000 },
+          { mimeType: 'video/VP9', clockRate: 90000 },
+          { mimeType: 'video/H264', clockRate: 90000 },
+        ],
+        headerExtensions: [
+          { uri: 'http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time', id: 2 },
+        ],
+      };
+    }
+    return null;
+  }
+}
+
+// Stub types for compatibility
+interface RTCDtlsTransport {}
+interface RTCStatsReport {}

package/src/rtp-transceiver.ts

@@ -0,0 +1,40 @@
+import { EventEmitter } from 'events';
+import type { RTCRtpTransceiverDirection } from './types.js';
+import { RTCRtpSender } from './rtp-sender.js';
+import { RTCRtpReceiver } from './rtp-receiver.js';
+
+export class RTCRtpTransceiver extends EventEmitter {
+  readonly kind: 'audio' | 'video';
+  readonly sender: RTCRtpSender;
+  readonly receiver: RTCRtpReceiver;
+  readonly mid: string | null = null;
+  direction: RTCRtpTransceiverDirection;
+  currentDirection: RTCRtpTransceiverDirection | null = null;
+  stopped = false;
+
+  constructor(kind: 'audio' | 'video', direction: RTCRtpTransceiverDirection) {
+    super();
+    this.kind = kind;
+    this.sender = new RTCRtpSender(null);
+    this.receiver = new RTCRtpReceiver();
+    this.direction = direction;
+  }
+
+  stop(): void {
+    this.stopped = true;
+    this.direction = 'stopped';
+    this.currentDirection = 'stopped';
+  }
+
+  setCodecPreferences(codecs: RTCRtpCodecParameters[]): void {
+    // Store codec preferences for SDP generation
+  }
+}
+
+interface RTCRtpCodecParameters {
+  mimeType: string;
+  clockRate: number;
+  channels?: number;
+  sdpFmtpLine?: string;
+  payloadType: number;
+}

package/src/session-description.ts

@@ -0,0 +1,15 @@
+import type { RTCSessionDescriptionInit, RTCSdpType } from './types.js';
+
+export class RTCSessionDescription implements RTCSessionDescriptionInit {
+  readonly type: RTCSdpType;
+  readonly sdp: string;
+
+  constructor(init: RTCSessionDescriptionInit) {
+    this.type = init.type;
+    this.sdp = init.sdp;
+  }
+
+  toJSON(): RTCSessionDescriptionInit {
+    return { type: this.type, sdp: this.sdp };
+  }
+}

package/src/stats.ts

@@ -0,0 +1,35 @@
+export interface RTCStats {
+  id: string;
+  type: string;
+  timestamp: number;
+}
+
+export type RTCStatsReport = RTCStatsReportImpl;
+
+export class RTCStatsReportImpl {
+  private readonly _map: Map<string, RTCStats>;
+
+  constructor(map: Map<string, RTCStats>) {
+    this._map = map;
+  }
+
+  entries(): IterableIterator<[string, RTCStats]> {
+    return this._map.entries();
+  }
+
+  get(id: string): RTCStats | undefined {
+    return this._map.get(id);
+  }
+
+  has(id: string): boolean {
+    return this._map.has(id);
+  }
+
+  forEach(callbackfn: (value: RTCStats, key: string) => void): void {
+    this._map.forEach(callbackfn);
+  }
+
+  [Symbol.iterator](): IterableIterator<[string, RTCStats]> {
+    return this._map.entries();
+  }
+}

package/src/types.ts

@@ -0,0 +1,156 @@
+export type RTCSignalingState =
+  | 'stable'
+  | 'have-local-offer'
+  | 'have-remote-offer'
+  | 'have-local-pranswer'
+  | 'have-remote-pranswer'
+  | 'closed';
+
+export type RTCPeerConnectionState =
+  | 'new'
+  | 'connecting'
+  | 'connected'
+  | 'disconnected'
+  | 'failed'
+  | 'closed';
+
+export type RTCIceConnectionState =
+  | 'new'
+  | 'checking'
+  | 'connected'
+  | 'completed'
+  | 'failed'
+  | 'disconnected'
+  | 'closed';
+
+export type RTCIceGatheringState = 'new' | 'gathering' | 'complete';
+
+export type RTCSdpType = 'offer' | 'pranswer' | 'answer' | 'rollback';
+
+export interface RTCSessionDescriptionInit {
+  type: RTCSdpType;
+  sdp: string;
+}
+
+export interface RTCSessionDescription {
+  type: RTCSdpType;
+  sdp: string;
+}
+
+export interface RTCIceCandidateInit {
+  candidate: string;
+  sdpMid?: string;
+  sdpMLineIndex?: number;
+  usernameFragment?: string;
+}
+
+export interface RTCIceServer {
+  urls: string | string[];
+  username?: string;
+  credential?: string;
+}
+
+export interface RTCConfiguration {
+  iceServers?: RTCIceServer[];
+  iceTransportPolicy?: 'all' | 'relay';
+  bundlePolicy?: 'balanced' | 'max-bundle' | 'max-compat';
+  rtcpMuxPolicy?: 'require';
+  iceCandidatePoolSize?: number;
+  certificates?: RTCDtlsTransportCertificate[];
+}
+
+export interface RTCDtlsTransportCertificate {
+  fingerprint: { algorithm: string; value: string };
+}
+
+export interface RTCOfferOptions {
+  iceRestart?: boolean;
+  offerToReceiveAudio?: boolean;
+  offerToReceiveVideo?: boolean;
+}
+
+export interface RTCAnswerOptions {}
+
+export type RTCRtpTransceiverDirection =
+  | 'sendrecv'
+  | 'sendonly'
+  | 'recvonly'
+  | 'inactive'
+  | 'stopped';
+
+export interface RTCRtpCodecParameters {
+  mimeType: string;
+  clockRate: number;
+  channels?: number;
+  sdpFmtpLine?: string;
+  payloadType: number;
+}
+
+export interface RTCRtpHeaderExtensionParameters {
+  uri: string;
+  id: number;
+  encrypted?: boolean;
+}
+
+export interface RTCRtpParameters {
+  codecs: RTCRtpCodecParameters[];
+  headerExtensions: RTCRtpHeaderExtensionParameters[];
+}
+
+export interface RTCRtpSendParameters extends RTCRtpParameters {
+  encodings: RTCRtpEncodingParameters[];
+  transactionId: string;
+}
+
+export interface RTCRtpReceiveParameters extends RTCRtpParameters {}
+
+export interface RTCRtpEncodingParameters {
+  rid?: string;
+  active?: boolean;
+  maxBitrate?: number;
+  scaleResolutionDownBy?: number;
+  ssrc?: number;
+}
+
+export interface RTCSctpTransportInit {
+  maxMessageSize: number;
+  maxChannels: number;
+  state: 'new' | 'connecting' | 'connected' | 'closed';
+}
+
+export type RTCDataChannelState = 'connecting' | 'open' | 'closing' | 'closed';
+
+export interface RTCDataChannelInit {
+  ordered?: boolean;
+  maxPacketLifeTime?: number;
+  maxRetransmits?: number;
+  protocol?: string;
+  negotiated?: boolean;
+  id?: number;
+  priority?: 'very-low' | 'low' | 'medium' | 'high';
+}
+
+export interface RTCStats {
+  id: string;
+  type: string;
+  timestamp: number;
+}
+
+export interface RTCIceCandidatePairStats extends RTCStats {
+  type: 'candidate-pair';
+  localCandidateId: string;
+  remoteCandidateId: string;
+  state: string;
+  nominated: boolean;
+  bytesSent: number;
+  bytesReceived: number;
+  totalRoundTripTime: number;
+  currentRoundTripTime?: number;
+}
+
+export interface RTCStatsReport {
+  entries(): IterableIterator<[string, RTCStats]>;
+  get(id: string): RTCStats | undefined;
+  has(id: string): boolean;
+  forEach(callbackfn: (value: RTCStats, key: string) => void): void;
+}