Agent SDK Prototype - React layer

agent-sdk/agent-session/ConnectionCredentialsProvider.ts

@@ -0,0 +1,118 @@
+import { decodeJwt } from 'jose';
+
+import { ConnectionDetails } from "@/app/api/connection-details/route";
+
+const ONE_MINUTE_IN_MILLISECONDS = 60 * 1000;
+
+/**
+  * ConnectionDetails handles getting credentials for connecting to a new Room, caching
+  * the last result and using it until it expires. */
+export abstract class ConnectionCredentials {
+  private cachedConnectionDetails: ConnectionDetails | null = null;
+
+  protected isCachedConnectionDetailsExpired() {
+    const token = this.cachedConnectionDetails?.participantToken;
+    if (!token) {
+      return true;
+    }
+
+    const jwtPayload = decodeJwt(token);
+    if (!jwtPayload.exp) {
+      return true;
+    }
+    const expiresAt = new Date(jwtPayload.exp - ONE_MINUTE_IN_MILLISECONDS);
+
+    const now = new Date();
+    return expiresAt >= now;
+  }
+
+  async generate() {
+    if (this.isCachedConnectionDetailsExpired()) {
+      await this.refresh();
+    }
+
+    return this.cachedConnectionDetails!;
+  }
+
+  async refresh() {
+    this.cachedConnectionDetails = await this.fetch();
+  }
+
+  protected abstract fetch(): Promise<ConnectionDetails>;
+};
+
+export class ManualConnectionCredentials extends ConnectionCredentials {
+  protected fetch: () => Promise<ConnectionDetails>;
+
+  constructor(handler: () => Promise<ConnectionDetails>) {
+    super();
+    this.fetch = handler;
+  }
+}
+
+export class LiteralConnectionCredentials extends ConnectionCredentials {
+  payload: ConnectionDetails;
+
+  constructor(payload: ConnectionDetails) {
+    super();
+    this.payload = payload;
+  }
+
+  async fetch() {
+    if (this.isCachedConnectionDetailsExpired()) {
+      // FIXME: figure out a better logging solution?
+      console.warn('WARNING: The credentials within LiteralConnectionCredentials have expired, so any upcoming room connections will fail.');
+    }
+    return this.payload;
+  }
+
+  async refresh() { /* cannot refresh a literal set of credentials! */ }
+}
+
+
+type SandboxConnectionCredentialsOptions = {
+  sandboxId: string;
+  baseUrl?: string;
+
+  /** The name of the room to join. If omitted, a random new room name will be generated instead. */
+  roomName?: string;
+
+  /** The identity of the participant the token should connect as connect as. If omitted, a random
+    * identity will be used instead. */
+  participantName?: string;
+};
+
+export class SandboxConnectionCredentials extends ConnectionCredentials {
+  protected options: SandboxConnectionCredentialsOptions;
+
+  constructor(options: SandboxConnectionCredentialsOptions) {
+    super();
+    this.options = options;
+
+    if (process.env.NODE_ENV === 'production') {
+      // FIXME: figure out a better logging solution?
+      console.warn('WARNING: SandboxConnectionCredentials is meant for development, and is not security hardened. In production, implement your own token generation solution.');
+    }
+  }
+
+  async fetch() {
+    const baseUrl = this.options.baseUrl ?? "https://cloud-api.livekit.io";
+    const response = await fetch(`${baseUrl}/api/sandbox/connection-details`, {
+      method: "POST",
+      headers: {
+        "X-Sandbox-ID": this.options.sandboxId,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        roomName: this.options.roomName,
+        participantName: this.options.participantName,
+      }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Error generting token from sandbox token server: ${response.status} ${await response.text()}`);
+    }
+
+    return response.json();
+  }
+}

agent-sdk/agent-session/Local.ts

@@ -0,0 +1,134 @@
+import { ParticipantEvent, Room, RoomEvent } from 'livekit-client';
+import type TypedEventEmitter from 'typed-emitter';
+import { EventEmitter } from "events";
+import { LocalParticipant, Track } from 'livekit-client';
+import { createLocalTrack, LocalTrackInstance } from './LocalTrack';
+import { ParticipantPermission } from 'livekit-server-sdk';
+import { trackSourceToProtocol } from '../external-deps/components-js';
+import { createScopedGetSet } from '../lib/scoped-get-set';
+
+export enum LocalEvent {
+  PermissionsChanged = 'permissionsChanged',
+};
+
+export type LocalCallbacks = {
+  [LocalEvent.PermissionsChanged]: (permissions: ParticipantPermission | null) => void;
+};
+
+export type LocalInstance = {
+  [Symbol.toStringTag]: "LocalInstance";
+
+  permissions: ParticipantPermission | null;
+  publishPermissions: {
+    camera: boolean | null;
+    microphone: boolean | null;
+    screenShare: boolean | null;
+    data: boolean;
+  };
+
+  camera: LocalTrackInstance<Track.Source.Camera>;
+  microphone: LocalTrackInstance<Track.Source.Microphone>;
+  screenShare: LocalTrackInstance<Track.Source.ScreenShare>;
+
+  subtle: {
+    emitter: TypedEventEmitter<LocalCallbacks>;
+    initialize: () => void;
+    teardown: () => void;
+
+    localParticipant: LocalParticipant;
+  };
+};
+
+export function createLocal(
+  room: Room,
+  get: () => LocalInstance,
+  set: (fn: (old: LocalInstance) => LocalInstance) => void,
+): LocalInstance {
+  const emitter = new EventEmitter() as TypedEventEmitter<LocalCallbacks>;
+
+  const handleParticipantPermissionsChanged = () => {
+    const permissions = room.localParticipant.permissions ?? null;
+
+    const canPublishSource = (source: Track.Source) => {
+      return (
+        permissions?.canPublish &&
+        (permissions.canPublishSources.length === 0 ||
+          permissions.canPublishSources.includes(trackSourceToProtocol(source)))
+      );
+    };
+
+    set((old) => ({
+      ...old,
+      permissions,
+      publishPermissions: { // FIXME: figure out a better place to put this? Maybe in with tracks?
+        camera: canPublishSource(Track.Source.Camera) ?? null,
+        microphone: canPublishSource(Track.Source.Microphone) ?? null,
+        screenShare: canPublishSource(Track.Source.ScreenShare) ?? null,
+        data: permissions?.canPublishData ?? false,
+      },
+    }));
+
+    emitter.emit(LocalEvent.PermissionsChanged, permissions);
+  };
+
+  const initialize = () => {
+    get().camera.subtle.initialize();
+    get().microphone.subtle.initialize();
+    get().screenShare.subtle.initialize();
+
+    room.on(RoomEvent.ParticipantPermissionsChanged, handleParticipantPermissionsChanged);
+  };
+
+  const teardown = () => {
+    room.localParticipant.off(ParticipantEvent.ParticipantPermissionsChanged, handleParticipantPermissionsChanged);
+
+    get().camera.subtle.teardown();
+    get().microphone.subtle.teardown();
+    get().screenShare.subtle.teardown();
+  };
+
+  const { get: trackGet, set: trackSet } = createScopedGetSet(get, set, 'camera', 'LocalTrack');
+  const camera = createLocalTrack({
+    room,
+    trackSource: Track.Source.Camera,
+    preventUserChoicesSave: false,
+  }, trackGet, trackSet);
+
+  const { get: microphoneTrackGet, set: microphoneTrackSet } = createScopedGetSet(get, set, 'microphone', 'LocalTrack');
+  const microphone = createLocalTrack({
+    room,
+    trackSource: Track.Source.Microphone,
+    preventUserChoicesSave: false,
+  }, microphoneTrackGet, microphoneTrackSet);
+
+  const { get: screenShareTrackGet, set: screenShareTrackSet } = createScopedGetSet(get, set, 'screenShare', 'LocalTrack');
+  const screenShare = createLocalTrack({
+    room,
+    trackSource: Track.Source.ScreenShare,
+    preventUserChoicesSave: false,
+  }, screenShareTrackGet, screenShareTrackSet);
+
+  return {
+    [Symbol.toStringTag]: "LocalInstance",
+
+    permissions: room.localParticipant.permissions ?? null,
+    publishPermissions: {
+      camera: null,
+      microphone: null,
+      screenShare: null,
+      data: false,
+    },
+
+    camera,
+    microphone,
+    screenShare,
+
+    subtle: {
+      emitter,
+      initialize,
+      teardown,
+
+      localParticipant: room.localParticipant,
+    },
+  };
+}