mediasfu-shared 1.0.5 → 1.1.0

package/src/methods/utils/headless/moderation.ts

@@ -0,0 +1,455 @@
+import { Participant } from '../../../types/types';
+import { removeParticipants } from '../../participants/removeParticipants';
+import { respondToWaiting } from '../../waiting/respondToWaiting';
+import { respondToRequests } from '../../requests/respondToRequests';
+import { modifyCoHostSettings } from '../../coHostMethods/modifyCoHostSettings';
+import { HeadlessOptions, HeadlessParameters } from './headlessTypes';
+import { getCurrentParams } from './getCurrentParams';
+import { HeadlessActionResult } from './roomActions';
+
+/** The co-host responsibility keys MediaSFU recognises. */
+export type ModerationArea = 'media' | 'participants' | 'chat' | 'waiting';
+
+export interface ModerationPermissions {
+  /** True when the local user is the host (islevel '2'). */
+  isHost: boolean;
+  /** True when the local user is the room's co-host. */
+  isCoHost: boolean;
+  /** Turn other participants' camera/mic/screen off. */
+  canControlMedia: boolean;
+  /** Remove or ban participants. */
+  canManageParticipants: boolean;
+  /** Moderate chat. */
+  canManageChat: boolean;
+  /** Admit or deny people in the waiting room. */
+  canManageWaitingRoom: boolean;
+}
+
+export type GetModerationPermissionsType = (
+  options: HeadlessOptions
+) => ModerationPermissions;
+
+function hasResponsibility(
+  parameters: HeadlessParameters,
+  area: ModerationArea
+): boolean {
+  const list = Array.isArray(parameters?.coHostResponsibility)
+    ? parameters.coHostResponsibility
+    : [];
+  return list.find((item: any) => item?.name === area)?.value === true;
+}
+
+/**
+ * What the local user is allowed to moderate.
+ *
+ * MediaSFU's rule is `islevel === '2' || (coHost === member && <area>.value)`,
+ * and it is enforced *inside* each action — an unauthorised call is swallowed
+ * with an alert rather than returning an error. That makes it very easy to ship
+ * a moderation button that silently does nothing for co-hosts. Gate your UI on
+ * this instead.
+ *
+ * @example
+ * ```ts
+ * import { getModerationPermissions } from 'mediasfu-shared';
+ *
+ * const perms = getModerationPermissions({ parameters });
+ * <button disabled={!perms.canControlMedia}>Mute everyone</button>
+ * ```
+ */
+export function getModerationPermissions({
+  parameters,
+}: HeadlessOptions): ModerationPermissions {
+  const source = parameters || {};
+  const isHost = String(source.islevel) === '2';
+  const isCoHost = Boolean(source.coHost && source.coHost === source.member);
+  const allow = (area: ModerationArea) =>
+    isHost || (isCoHost && hasResponsibility(source, area));
+  return {
+    isHost,
+    isCoHost,
+    canControlMedia: allow('media'),
+    canManageParticipants: allow('participants'),
+    canManageChat: allow('chat'),
+    canManageWaitingRoom: allow('waiting'),
+  };
+}
+
+function participantList(parameters: HeadlessParameters): Participant[] {
+  const source = parameters || {};
+  const primary = Array.isArray(source.participants) ? source.participants : [];
+  if (primary.length > 0) return primary;
+  return Array.isArray(source.participantsAll) ? source.participantsAll : [];
+}
+
+function findParticipant(
+  parameters: HeadlessParameters,
+  { id, name }: { id?: string; name?: string }
+): Participant | null {
+  const participants = participantList(parameters);
+  return (
+    (id ? participants.find((part) => part.id === id) : undefined) ||
+    (name ? participants.find((part) => part.name === name) : undefined) ||
+    null
+  );
+}
+
+export interface SetParticipantMediaOptions extends HeadlessOptions {
+  /** Participant display name. */
+  name?: string;
+  /** Participant id. Takes precedence over `name`. */
+  id?: string;
+  /** Which media to switch off. */
+  kind: 'audio' | 'video' | 'screenshare' | 'all';
+}
+
+export type SetParticipantMediaType = (
+  options: SetParticipantMediaOptions
+) => Promise<HeadlessActionResult>;
+
+/**
+ * Turn a participant's media off as host or authorised co-host.
+ *
+ * This is one-directional by design: MediaSFU lets a moderator *stop* someone's
+ * camera, microphone or screen share, but cannot start it on their behalf — the
+ * participant must re-enable it themselves.
+ *
+ * The SDK's own `controlMedia` consumer only emits for `type: 'audio'` and
+ * `type: 'video'`; `'all'` and `'screenshare'` fall through its guard and do
+ * nothing. This helper emits the `controlMedia` event directly with the same
+ * permission and self-protection checks applied uniformly, so every kind works.
+ * Hosts (`islevel === '2'`) cannot be muted by anyone, including other hosts.
+ *
+ * @example
+ * ```ts
+ * import { setParticipantMedia } from 'mediasfu-shared';
+ *
+ * await setParticipantMedia({ parameters, name: 'Paul', kind: 'video' });
+ * await setParticipantMedia({ parameters, name: 'Paul', kind: 'all' });
+ * ```
+ */
+export async function setParticipantMedia({
+  parameters,
+  name = '',
+  id = '',
+  kind,
+}: SetParticipantMediaOptions): Promise<HeadlessActionResult> {
+  try {
+    const live = getCurrentParams({ parameters });
+    const permissions = getModerationPermissions({ parameters: live });
+    if (!permissions.canControlMedia) {
+      return {
+        ok: false,
+        error: 'You are not allowed to control media for other participants.',
+      };
+    }
+    const socket = live?.socket;
+    if (!socket || typeof socket.emit !== 'function' || !live?.roomName) {
+      return { ok: false, error: 'The room connection is not ready.' };
+    }
+    const participant = findParticipant(live, { id, name });
+    if (!participant) return { ok: false, error: 'That participant is not in the room.' };
+    if (String(participant.islevel) === '2') {
+      return { ok: false, error: 'A host’s media cannot be turned off.' };
+    }
+
+    socket.emit('controlMedia', {
+      participantId: participant.id,
+      participantName: participant.name,
+      type: kind,
+      roomName: live.roomName,
+    });
+    return { ok: true, error: '' };
+  } catch (error: any) {
+    return { ok: false, error: error?.message || 'The media control failed.' };
+  }
+}
+
+export interface ModerateParticipantOptions extends HeadlessOptions {
+  name?: string;
+  id?: string;
+}
+
+/** Mute a participant's microphone. See {@link setParticipantMedia}. */
+export function muteParticipant(
+  options: ModerateParticipantOptions
+): Promise<HeadlessActionResult> {
+  return setParticipantMedia({ ...options, kind: 'audio' });
+}
+
+/** Turn a participant's camera off. See {@link setParticipantMedia}. */
+export function disableParticipantVideo(
+  options: ModerateParticipantOptions
+): Promise<HeadlessActionResult> {
+  return setParticipantMedia({ ...options, kind: 'video' });
+}
+
+/** Stop a participant's screen share. See {@link setParticipantMedia}. */
+export function stopParticipantScreenShare(
+  options: ModerateParticipantOptions
+): Promise<HeadlessActionResult> {
+  return setParticipantMedia({ ...options, kind: 'screenshare' });
+}
+
+export interface MuteEveryoneOptions extends HeadlessOptions {
+  /** Which media to switch off for everyone. Defaults to `audio`. */
+  kind?: 'audio' | 'video' | 'screenshare' | 'all';
+}
+
+export type MuteEveryoneType = (
+  options: MuteEveryoneOptions
+) => Promise<HeadlessActionResult>;
+
+/**
+ * Turn media off for every non-host participant.
+ *
+ * MediaSFU has no bulk primitive, so this fans out per participant. Hosts and
+ * the local user are skipped. Succeeds if at least one participant was
+ * actioned; reports the failure otherwise.
+ */
+export async function muteEveryone({
+  parameters,
+  kind = 'audio',
+}: MuteEveryoneOptions): Promise<HeadlessActionResult> {
+  const live = getCurrentParams({ parameters });
+  const permissions = getModerationPermissions({ parameters: live });
+  if (!permissions.canControlMedia) {
+    return {
+      ok: false,
+      error: 'You are not allowed to control media for other participants.',
+    };
+  }
+  const targets = participantList(live).filter(
+    (part) => String(part.islevel) !== '2' && part.name !== live.member
+  );
+  if (targets.length === 0) return { ok: false, error: 'There is nobody else to mute.' };
+
+  const results = await Promise.all(
+    targets.map((part) =>
+      setParticipantMedia({ parameters: live, id: part.id, name: part.name, kind })
+    )
+  );
+  const failed = results.filter((result) => !result.ok);
+  if (failed.length === results.length) {
+    return { ok: false, error: failed[0]?.error || 'No participant could be muted.' };
+  }
+  return { ok: true, error: '' };
+}
+
+export type RemoveParticipantType = (
+  options: ModerateParticipantOptions
+) => Promise<HeadlessActionResult>;
+
+/**
+ * Remove a participant from the room.
+ *
+ * @example
+ * ```ts
+ * await removeParticipant({ parameters, name: 'Paul' });
+ * ```
+ */
+export async function removeParticipant({
+  parameters,
+  name = '',
+  id = '',
+}: ModerateParticipantOptions): Promise<HeadlessActionResult> {
+  try {
+    const live = getCurrentParams({ parameters });
+    const permissions = getModerationPermissions({ parameters: live });
+    if (!permissions.canManageParticipants) {
+      return { ok: false, error: 'You are not allowed to remove participants.' };
+    }
+    const participant = findParticipant(live, { id, name });
+    if (!participant) return { ok: false, error: 'That participant is not in the room.' };
+    if (String(participant.islevel) === '2') {
+      return { ok: false, error: 'A host cannot be removed.' };
+    }
+    await removeParticipants({
+      coHostResponsibility: live.coHostResponsibility || [],
+      participant,
+      member: live.member || '',
+      islevel: live.islevel || '1',
+      showAlert: live.showAlert,
+      coHost: live.coHost || '',
+      participants: participantList(live),
+      socket: live.socket,
+      roomName: live.roomName || '',
+      updateParticipants: live.updateParticipants,
+    });
+    return { ok: true, error: '' };
+  } catch (error: any) {
+    return { ok: false, error: error?.message || 'The participant could not be removed.' };
+  }
+}
+
+export interface RespondToWaitingParticipantOptions extends HeadlessOptions {
+  name?: string;
+  id?: string;
+  /** True to admit, false to deny. */
+  admit: boolean;
+}
+
+export type RespondToWaitingParticipantType = (
+  options: RespondToWaitingParticipantOptions
+) => Promise<HeadlessActionResult>;
+
+/**
+ * Admit or deny somebody waiting to join.
+ *
+ * Reads `waitingRoomList` off the bag, so you only supply the person's name or
+ * id and whether to let them in.
+ *
+ * @example
+ * ```ts
+ * for (const person of parameters.waitingRoomList ?? []) {
+ *   await respondToWaitingParticipant({ parameters, id: person.id, admit: true });
+ * }
+ * ```
+ */
+export async function respondToWaitingParticipant({
+  parameters,
+  name = '',
+  id = '',
+  admit,
+}: RespondToWaitingParticipantOptions): Promise<HeadlessActionResult> {
+  try {
+    const live = getCurrentParams({ parameters });
+    const permissions = getModerationPermissions({ parameters: live });
+    if (!permissions.canManageWaitingRoom) {
+      return { ok: false, error: 'You are not allowed to manage the waiting room.' };
+    }
+    const waitingList = Array.isArray(live.waitingRoomList) ? live.waitingRoomList : [];
+    const entry =
+      (id ? waitingList.find((person: any) => person?.id === id) : undefined) ||
+      (name ? waitingList.find((person: any) => person?.name === name) : undefined);
+    if (!entry) return { ok: false, error: 'That person is no longer waiting to join.' };
+
+    await respondToWaiting({
+      participantId: entry.id,
+      participantName: entry.name,
+      updateWaitingList: live.updateWaitingRoomList,
+      waitingList,
+      type: admit,
+      roomName: live.roomName || '',
+      socket: live.socket,
+    });
+    return { ok: true, error: '' };
+  } catch (error: any) {
+    return {
+      ok: false,
+      error: error?.message || 'The waiting-room response failed.',
+    };
+  }
+}
+
+export interface RespondToParticipantRequestOptions extends HeadlessOptions {
+  /** The request id from `parameters.requestList`. */
+  requestId?: string;
+  /** Or match by requester name. */
+  name?: string;
+  /** True to approve, false to reject. */
+  approve: boolean;
+}
+
+export type RespondToParticipantRequestType = (
+  options: RespondToParticipantRequestOptions
+) => Promise<HeadlessActionResult>;
+
+/**
+ * Approve or reject a participant request (raise hand, ask to share, ask to
+ * speak). Requests live on `parameters.requestList`; each carries an `icon`
+ * naming the capability being asked for.
+ */
+export async function respondToParticipantRequest({
+  parameters,
+  requestId = '',
+  name = '',
+  approve,
+}: RespondToParticipantRequestOptions): Promise<HeadlessActionResult> {
+  try {
+    const live = getCurrentParams({ parameters });
+    const permissions = getModerationPermissions({ parameters: live });
+    if (!permissions.canManageParticipants) {
+      return { ok: false, error: 'You are not allowed to respond to requests.' };
+    }
+    const requestList = Array.isArray(live.requestList) ? live.requestList : [];
+    const request =
+      (requestId
+        ? requestList.find((item: any) => item?.id === requestId)
+        : undefined) ||
+      (name
+        ? requestList.find(
+            (item: any) => item?.name === name || item?.username === name
+          )
+        : undefined);
+    if (!request) return { ok: false, error: 'That request is no longer pending.' };
+
+    await respondToRequests({
+      socket: live.socket,
+      request,
+      updateRequestList: live.updateRequestList,
+      requestList,
+      action: approve ? 'accepted' : 'rejected',
+      roomName: live.roomName || '',
+    });
+    return { ok: true, error: '' };
+  } catch (error: any) {
+    return { ok: false, error: error?.message || 'The request response failed.' };
+  }
+}
+
+export interface SetCoHostOptions extends HeadlessOptions {
+  /** Participant to promote. Pass '' to clear the current co-host. */
+  name: string;
+  /** Areas the co-host may moderate. Defaults to media + participants. */
+  areas?: ModerationArea[];
+}
+
+export type SetCoHostType = (
+  options: SetCoHostOptions
+) => Promise<HeadlessActionResult>;
+
+/**
+ * Promote a participant to co-host and choose what they may moderate.
+ *
+ * Only the host may do this. Areas not listed are explicitly disabled, so this
+ * sets the complete responsibility set rather than merging with the previous one.
+ *
+ * @example
+ * ```ts
+ * await setCoHost({ parameters, name: 'Paul', areas: ['media', 'waiting'] });
+ * ```
+ */
+export async function setCoHost({
+  parameters,
+  name,
+  areas = ['media', 'participants'],
+}: SetCoHostOptions): Promise<HeadlessActionResult> {
+  try {
+    const live = getCurrentParams({ parameters });
+    if (String(live.islevel) !== '2') {
+      return { ok: false, error: 'Only the host can assign a co-host.' };
+    }
+    const all: ModerationArea[] = ['media', 'participants', 'chat', 'waiting'];
+    const responsibilities = all.map((area) => ({
+      name: area,
+      value: areas.includes(area),
+      dedicated: false,
+    }));
+
+    await modifyCoHostSettings({
+      roomName: live.roomName || '',
+      showAlert: live.showAlert,
+      selectedParticipant: name,
+      coHost: live.coHost || '',
+      coHostResponsibility: responsibilities,
+      updateIsCoHostModalVisible:
+        live.updateIsCoHostModalVisible || (() => undefined),
+      updateCoHostResponsibility: live.updateCoHostResponsibility,
+      updateCoHost: live.updateCoHost,
+      socket: live.socket,
+    });
+    return { ok: true, error: '' };
+  } catch (error: any) {
+    return { ok: false, error: error?.message || 'The co-host update failed.' };
+  }
+}

package/src/methods/utils/headless/participantState.ts

@@ -0,0 +1,254 @@
+import { Participant } from '../../../types/types';
+import { HeadlessOptions, HeadlessParameters } from './headlessTypes';
+
+/** MediaSFU writes 'none' rather than an empty string when a producer is absent. */
+function hasProducer(value: unknown): boolean {
+  return (
+    typeof value === 'string' &&
+    value.length > 3 &&
+    value.toLowerCase() !== 'none'
+  );
+}
+
+function participantList(parameters: HeadlessParameters): Participant[] {
+  const source = parameters || {};
+  const primary = Array.isArray(source.participants) ? source.participants : [];
+  if (primary.length > 0) return primary;
+  return Array.isArray(source.participantsAll) ? source.participantsAll : [];
+}
+
+export interface ParticipantMediaState {
+  participant: Participant | null;
+  /** The participant's own display name, or '' when unresolved. */
+  name: string;
+  /** True when this row is the local user. */
+  isSelf: boolean;
+  /** True when the participant is a host (islevel '2'). */
+  isHost: boolean;
+  /** True when the participant is publishing a camera. */
+  hasVideo: boolean;
+  /** True when the participant is publishing a microphone. */
+  hasAudio: boolean;
+  /** True when the participant's microphone is muted. */
+  muted: boolean;
+  /** The camera producer id, or '' when not publishing. */
+  videoProducerId: string;
+  /** The microphone producer id, or '' when not publishing. */
+  audioProducerId: string;
+}
+
+export interface GetParticipantMediaStateOptions extends HeadlessOptions {
+  /** Match by display name. */
+  name?: string;
+  /** Match by participant id. Takes precedence over `name`. */
+  id?: string;
+}
+
+export type GetParticipantMediaStateType = (
+  options: GetParticipantMediaStateOptions
+) => ParticipantMediaState;
+
+/**
+ * Whether a participant is publishing, and what to label them.
+ *
+ * "Is this person on camera?" is not `participant.muted` and not the presence of
+ * a stream in your grid — it is whether `videoID` holds a real producer
+ * reference. MediaSFU writes the string `'none'` rather than an empty value when
+ * there is no producer, which is why a naive truthiness check reports everyone
+ * as publishing.
+ *
+ * @example
+ * ```ts
+ * import { getParticipantMediaState } from 'mediasfu-shared';
+ *
+ * const paul = getParticipantMediaState({ parameters, name: 'Paul' });
+ * if (paul.hasVideo) renderCamera(paul.videoProducerId);
+ * ```
+ */
+export function getParticipantMediaState({
+  parameters,
+  name = '',
+  id = '',
+}: GetParticipantMediaStateOptions): ParticipantMediaState {
+  const source = parameters || {};
+  const participants = participantList(source);
+  const participant =
+    (id ? participants.find((part) => part.id === id) : undefined) ||
+    (name ? participants.find((part) => part.name === name) : undefined) ||
+    null;
+
+  const videoProducerId = hasProducer(participant?.videoID)
+    ? (participant!.videoID as string)
+    : '';
+  const audioProducerId = hasProducer(participant?.audioID)
+    ? (participant!.audioID as string)
+    : '';
+
+  return {
+    participant,
+    name: participant?.name || '',
+    isSelf: Boolean(participant?.name && participant.name === source.member),
+    isHost: String(participant?.islevel) === '2',
+    hasVideo: Boolean(videoProducerId),
+    hasAudio: Boolean(audioProducerId),
+    muted: participant?.muted === true,
+    videoProducerId,
+    audioProducerId,
+  };
+}
+
+export type ListParticipantMediaStatesType = (
+  options: HeadlessOptions
+) => ParticipantMediaState[];
+
+/** {@link getParticipantMediaState} for everyone currently in the room. */
+export function listParticipantMediaStates({
+  parameters,
+}: HeadlessOptions): ParticipantMediaState[] {
+  const source = parameters || {};
+  return participantList(source).map((participant) =>
+    getParticipantMediaState({
+      parameters: source,
+      id: participant.id,
+      name: participant.name,
+    })
+  );
+}
+
+export interface ActiveSpeaker {
+  /** Loudest participant's display name, or '' when the room is quiet. */
+  name: string;
+  /** That participant's average loudness. */
+  level: number;
+  participant: Participant | null;
+}
+
+export type GetActiveSpeakerType = (options: HeadlessOptions) => ActiveSpeaker;
+
+/**
+ * The loudest participant right now.
+ *
+ * Reads `audioDecibels`, which the SDK maintains per participant. MediaSFU's own
+ * grids treat roughly 127.5 as the noise floor, so quieter rooms report no
+ * active speaker rather than flickering between people.
+ *
+ * @example
+ * ```ts
+ * const speaker = getActiveSpeaker({ parameters });
+ * if (speaker.name) highlight(speaker.name);
+ * ```
+ */
+export function getActiveSpeaker({ parameters }: HeadlessOptions): ActiveSpeaker {
+  const source = parameters || {};
+  const decibels = Array.isArray(source.audioDecibels) ? source.audioDecibels : [];
+  const participants = participantList(source);
+
+  let best: { name: string; averageLoudness: number } | null = null;
+  for (const entry of decibels) {
+    if (!entry?.name || typeof entry.averageLoudness !== 'number') continue;
+    if (entry.averageLoudness <= 127.5) continue;
+    if (!best || entry.averageLoudness > best.averageLoudness) best = entry;
+  }
+  if (!best) return { name: '', level: 0, participant: null };
+
+  return {
+    name: best.name,
+    level: best.averageLoudness,
+    participant: participants.find((part) => part.name === best!.name) || null,
+  };
+}
+
+export interface MediaDeviceList {
+  cameras: MediaDeviceInfo[];
+  microphones: MediaDeviceInfo[];
+}
+
+export type ListMediaDevicesType = (
+  options: HeadlessOptions
+) => Promise<MediaDeviceList>;
+
+/**
+ * Cameras and microphones available for a device picker.
+ *
+ * Uses the SDK's own `getMediaDevicesList` when the bag exposes it, so the
+ * result reflects the same `mediaDevices` instance the SDK captures with;
+ * otherwise falls back to `navigator.mediaDevices.enumerateDevices()`.
+ *
+ * Labels are blank until the user has granted permission once — call this after
+ * the first successful capture if you need readable device names.
+ *
+ * @example
+ * ```ts
+ * const { cameras } = await listMediaDevices({ parameters });
+ * await runMediaControl({
+ *   parameters,
+ *   control: 'switchVideo',
+ *   extra: { videoPreference: cameras[1].deviceId },
+ * });
+ * ```
+ */
+export async function listMediaDevices({
+  parameters,
+}: HeadlessOptions): Promise<MediaDeviceList> {
+  const source = parameters || {};
+  try {
+    if (typeof source.getMediaDevicesList === 'function') {
+      const [cameras, microphones] = await Promise.all([
+        source.getMediaDevicesList('videoinput'),
+        source.getMediaDevicesList('audioinput'),
+      ]);
+      return {
+        cameras: Array.isArray(cameras) ? cameras : [],
+        microphones: Array.isArray(microphones) ? microphones : [],
+      };
+    }
+    const devices = await navigator.mediaDevices.enumerateDevices();
+    return {
+      cameras: devices.filter((device) => device.kind === 'videoinput'),
+      microphones: devices.filter((device) => device.kind === 'audioinput'),
+    };
+  } catch {
+    return { cameras: [], microphones: [] };
+  }
+}
+
+export interface SelectedDevices {
+  /** Device id of the camera currently in use, or '' when none is selected. */
+  cameraId: string;
+  /** Device id of the microphone currently in use, or '' when none is selected. */
+  microphoneId: string;
+  /** Cameras the SDK has enumerated for this room. */
+  cameras: MediaDeviceInfo[];
+  /** Microphones the SDK has enumerated for this room. */
+  microphones: MediaDeviceInfo[];
+}
+
+export type GetSelectedDevicesType = (options: HeadlessOptions) => SelectedDevices;
+
+/**
+ * Which camera and microphone the SDK is actually using, plus the device lists
+ * it has already enumerated.
+ *
+ * Unlike {@link listMediaDevices} this is synchronous and needs no permission
+ * prompt: it reads `userDefaultVideoInputDevice` / `userDefaultAudioInputDevice`
+ * and the `videoInputs` / `audioInputs` the SDK populated during setup. Use it
+ * to mark the current entry in a device picker; use `listMediaDevices` when you
+ * need a freshly enumerated list.
+ *
+ * @example
+ * ```tsx
+ * const { cameras, cameraId } = getSelectedDevices({ parameters });
+ * <select value={cameraId} onChange={(e) => room.controls.selectCamera(e.target.value)}>
+ *   {cameras.map((d) => <option key={d.deviceId} value={d.deviceId}>{d.label}</option>)}
+ * </select>
+ * ```
+ */
+export function getSelectedDevices({ parameters }: HeadlessOptions): SelectedDevices {
+  const source = parameters || {};
+  return {
+    cameraId: source.userDefaultVideoInputDevice || '',
+    microphoneId: source.userDefaultAudioInputDevice || '',
+    cameras: Array.isArray(source.videoInputs) ? source.videoInputs : [],
+    microphones: Array.isArray(source.audioInputs) ? source.audioInputs : [],
+  };
+}