vg-x07df 0.1.0

package/packages/sdk/src/core/socketio/handlers/call-join-info.handler.ts

@@ -0,0 +1,181 @@
+import {
+  pushLiveKitConnectError,
+  pushStaleEventError,
+} from "../../../state/errors";
+import { rtcStore } from "../../../state/store";
+import { SdkEventType, eventBus } from "../../events";
+import { BaseSocketHandler } from "./base.handler";
+import { callJoinInfoSchema } from "./schema";
+import type { CallJoinInfoEvent } from "./schema";
+
+export class CallJoinInfoHandler extends BaseSocketHandler<CallJoinInfoEvent> {
+  protected readonly eventName = "call.join-info";
+  protected readonly schema = callJoinInfoSchema;
+
+  protected async handle(data: CallJoinInfoEvent): Promise<void> {
+    const currentState = rtcStore.getState();
+    // Get current user ID from auth instead of localParticipantId
+    const currentUserId = this.authManager?.getCurrentUserId();
+    
+    const currentSessionId = this.getSessionId();
+
+    if (currentSessionId !== data.callId) {
+      this.logger.error("CallId mismatch in join-info event", {
+        eventCallId: data.callId,
+        sessionCallId: currentSessionId,
+        currentUserId,
+      });
+      pushStaleEventError("call.join-info", "callId mismatch", {
+        eventCallId: data.callId,
+        sessionCallId: currentSessionId,
+      });
+      return;
+    }
+
+    if (this.livekit?.room.state === "connected") {
+      this.logger.warn("Already connected to LiveKit, ignoring join-info", {
+        callId: data.callId,
+        currentUserId,
+        currentRoomState: this.livekit.room.state,
+      });
+      return;
+    }
+
+    // Store join info and set ready to join
+    this.updateStore((state) => {
+      state.session.livekitInfo = {
+        token: data.token,
+        roomName: data.roomName,
+        callId: data.callId,
+        url: data.url,
+      };
+
+      // Always set READY_TO_JOIN when receiving join-info
+      // Backend controls when to send join-info, so we trust it
+      state.session.status = "READY_TO_JOIN";
+    });
+
+    // Simplified auto-join logic: auto-join if enabled and user exists
+    const shouldAutoJoin = this.autoJoinConfig?.enabled && currentUserId;
+
+    if (shouldAutoJoin && this.livekit && data.url) {
+      try {
+        this.logger.info("Auto-joining LiveKit room after receiving join-info", {
+          callId: data.callId,
+          currentUserId,
+        });
+
+        // Update state to connecting before joining
+        this.updateStore((state) => {
+          state.session.status = "CONNECTING";
+        });
+
+        const joinSuccess = this.autoJoinConfig?.retryOnFailure
+          ? await this.retryAutoJoin(data.callId, data.token, data.url)
+          : await this.livekit.joinRoom(data.token, data.url).then(() => true).catch(() => false);
+
+        if (joinSuccess) {
+          // Update state after successful join
+          this.updateStore((state) => {
+            state.session.status = "ACTIVE";
+            if (currentUserId) {
+              // Defensive check: create participant if it doesn't exist
+              if (!state.room.participants[currentUserId]) {
+                this.logger.warn("Creating missing participant during auto-join", {
+                  currentUserId,
+                  callId: data.callId,
+                });
+                
+                state.room.participants[currentUserId] = {
+                  id: currentUserId,
+                  role: state.session.myRole || "MEMBER",
+                  callState: "INVITED",
+                  invitedAt: Date.now(),
+                  audioEnabled: true,
+                  videoEnabled: true,
+                  isSpeaking: false,
+                };
+              }
+              
+              state.room.participants[currentUserId].callState = "JOINED";
+              state.room.participants[currentUserId].joinedAt = Date.now();
+              
+              this.logger.debug("Participant joined during auto-join", {
+                participantId: currentUserId,
+                callState: "JOINED",
+                callId: data.callId,
+              });
+            }
+          });
+
+          // Emit participant joined event
+          eventBus.emit(
+            SdkEventType.PARTICIPANT_JOINED,
+            {
+              callId: data.callId,
+              participant: {
+                id: currentUserId,
+                role: currentState.session.myRole || "MEMBER",
+              },
+              timestamp: Date.now(),
+            },
+            "socket"
+          );
+
+          this.logger.info("Successfully auto-joined LiveKit room", {
+            callId: data.callId,
+            currentUserId,
+            retriesUsed: this.autoJoinConfig?.retryOnFailure,
+          });
+        } else {
+          throw new Error("Auto-join failed after retries");
+        }
+
+      } catch (error) {
+        this.logger.error("Failed to auto-join to LiveKit room", {
+          callId: data.callId,
+          error,
+        });
+
+        // Reset state on failure
+        this.updateStore((state) => {
+          state.session.status = "READY_TO_JOIN"; // Ready for manual join
+          if (currentUserId) {
+            // Defensive check: only update if participant exists
+            if (state.room.participants[currentUserId]) {
+              state.room.participants[currentUserId].callState = "LEFT";
+            }
+          }
+        });
+
+        pushLiveKitConnectError(
+          error instanceof Error ? error.message : "Unknown error",
+          error
+        );
+
+        // Don't throw error - allow manual join as fallback
+        this.logger.warn("Auto-join failed, user can manually join", {
+          callId: data.callId,
+        });
+      }
+    }
+
+    // Emit join info received event
+    eventBus.emit(
+      SdkEventType.JOIN_INFO_RECEIVED,
+      {
+        callId: data.callId,
+        participantId: currentUserId || "unknown",
+        timestamp: Date.now(),
+        hasUrl: !!data.url,
+        hasToken: !!data.token,
+        autoJoined: shouldAutoJoin,
+      },
+      "socket"
+    );
+  }
+
+  private getSessionId(): string {
+    return rtcStore.getState().session.id || "";
+  }
+}

package/packages/sdk/src/core/socketio/handlers/call-participant-joined.handler.ts

@@ -0,0 +1,42 @@
+import { BaseSocketHandler } from "./base.handler";
+import { callParticipantJoinedSchema } from "./schema";
+import type { CallParticipantJoinedEvent } from "./schema";
+
+export class CallParticipantJoinedHandler extends BaseSocketHandler<CallParticipantJoinedEvent> {
+  protected readonly eventName = "call.participant-joined";
+  protected readonly schema = callParticipantJoinedSchema;
+
+  protected handle(data: CallParticipantJoinedEvent): void {
+    this.updateStore((state) => {
+      const participant = state.room.participants[data.participant.id];
+      if (participant) {
+        participant.callState = "JOINED";
+        participant.joinedAt = data.timestamp || Date.now();
+        
+        // Update profile data from socket event
+        if (data.participant.firstName) {
+          participant.firstName = data.participant.firstName;
+        }
+        if (data.participant.lastName) {
+          participant.lastName = data.participant.lastName;
+        }
+        if (data.participant.profilePhoto) {
+          participant.avatarUrl = data.participant.profilePhoto;
+        }
+        
+        this.logger.debug("Participant state updated via socket event", {
+          participantId: data.participant.id,
+          callState: "JOINED",
+          callId: data.callId,
+          source: "call.participant-joined",
+        });
+      } else {
+        this.logger.warn("Participant not found for join event", {
+          participantId: data.participant.id,
+          callId: data.callId,
+          availableParticipants: Object.keys(state.room.participants),
+        });
+      }
+    });
+  }
+}

package/packages/sdk/src/core/socketio/handlers/call-participant-joining.handler.ts

@@ -0,0 +1,42 @@
+import { BaseSocketHandler } from "./base.handler";
+import { callParticipantJoiningSchema } from "./schema";
+import type { CallParticipantJoiningEvent } from "./schema";
+
+export class CallParticipantJoiningHandler extends BaseSocketHandler<CallParticipantJoiningEvent> {
+  protected readonly eventName = "call.participant-joining";
+  protected readonly schema = callParticipantJoiningSchema;
+
+  protected handle(data: CallParticipantJoiningEvent): void {
+    this.updateStore((state) => {
+      const participant = state.room.participants[data.participant.id];
+      if (participant) {
+        participant.callState = "RINGING"; // Participant is getting ready to join
+        participant.joinedAt = data.timestamp || Date.now();
+        
+        // Update profile data from socket event
+        if (data.participant.firstName) {
+          participant.firstName = data.participant.firstName;
+        }
+        if (data.participant.lastName) {
+          participant.lastName = data.participant.lastName;
+        }
+        if (data.participant.profilePhoto) {
+          participant.avatarUrl = data.participant.profilePhoto;
+        }
+        
+        this.logger.debug("Participant state updated via socket event", {
+          participantId: data.participant.id,
+          callState: "RINGING",
+          callId: data.callId,
+          source: "call.participant-joining",
+        });
+      } else {
+        this.logger.warn("Participant not found for joining event", {
+          participantId: data.participant.id,
+          callId: data.callId,
+          availableParticipants: Object.keys(state.room.participants),
+        });
+      }
+    });
+  }
+}

package/packages/sdk/src/core/socketio/handlers/call-timeout.handler.ts

@@ -0,0 +1,31 @@
+import type { Participant } from "../../../state/types";
+import { BaseSocketHandler } from "./base.handler";
+import { callTimeoutSchema } from "./schema";
+import type { CallTimeoutEvent } from "./schema";
+
+export class CallTimeoutHandler extends BaseSocketHandler<CallTimeoutEvent> {
+  protected readonly eventName = "call.timeout";
+  protected readonly schema = callTimeoutSchema;
+
+  protected handle(data: CallTimeoutEvent): void {
+    const reason = data.reason || "timeout";
+    this.logger.info(`Call timeout: ${reason}`, { callId: data.callId });
+
+    this.updateStore((state) => {
+      if (state.session.id === data.callId) {
+        state.session.status = "ENDED";
+        state.incomingCall = undefined;
+
+        // Mark all participants as left
+        for (const participant of Object.values(
+          state.room.participants
+        ) as Participant[]) {
+          participant.callState = "LEFT";
+          if (!participant.leftAt) {
+            participant.leftAt = data.timestamp || Date.now();
+          }
+        }
+      }
+    });
+  }
+}

package/packages/sdk/src/core/socketio/handlers/handler.registry.ts

@@ -0,0 +1,62 @@
+import type { Socket } from "socket.io-client";
+import { createLogger } from "../../../utils/logger";
+import type { SocketHandlerOptions } from "./base.handler";
+import { CallParticipantAcceptedHandler } from "./call-accepted.handler";
+import { CallCanceledHandler } from "./call-canceled.handler";
+import { CallParticipantDeclinedHandler } from "./call-declined.handler";
+import { CallEndedHandler } from "./call-ended.handler";
+import { CallIncomingHandler } from "./call-incoming.handler";
+import { CallJoinInfoHandler } from "./call-join-info.handler";
+import { CallParticipantJoinedHandler } from "./call-participant-joined.handler";
+import { CallParticipantJoiningHandler } from "./call-participant-joining.handler";
+import { CallTimeoutHandler } from "./call-timeout.handler";
+import { ParticipantLeftHandler } from "./participant-left.handler";
+
+const logger = createLogger("socketio:registry");
+
+export class SocketHandlerRegistry {
+  private handlers = new Map<string, any>();
+
+  constructor(private options: SocketHandlerOptions = {}) {
+    this.initializeHandlers();
+  }
+
+  private initializeHandlers(): void {
+    const handlers = [
+      new CallIncomingHandler(this.options),
+      new CallParticipantAcceptedHandler(this.options),
+      new CallParticipantDeclinedHandler(this.options),
+      new CallEndedHandler(this.options),
+      new CallJoinInfoHandler(this.options),
+      new ParticipantLeftHandler(this.options),
+      new CallParticipantJoiningHandler(this.options),
+      new CallParticipantJoinedHandler(this.options),
+      new CallTimeoutHandler(this.options),
+      new CallCanceledHandler(this.options),
+    ];
+
+    for (const handler of handlers) {
+      this.handlers.set((handler as any).eventName, handler);
+    }
+  }
+
+  registerEventListeners(socket: Socket): void {
+    for (const [eventName, handler] of this.handlers) {
+      socket.on(eventName, (rawData: any) => {
+        handler.handleRaw(rawData).catch((error: Error) => {
+          logger.error(`Handler error for ${eventName}:`, error);
+        });
+      });
+    }
+  }
+
+  removeEventListeners(socket: Socket): void {
+    for (const eventName of this.handlers.keys()) {
+      socket.off(eventName);
+    }
+  }
+
+  destroy(): void {
+    this.handlers.clear();
+  }
+}

package/packages/sdk/src/core/socketio/handlers/index.ts

@@ -0,0 +1,21 @@
+export { BaseSocketHandler } from "./base.handler";
+export { CallIncomingHandler } from "./call-incoming.handler";
+export { CallParticipantAcceptedHandler } from "./call-accepted.handler";
+export { CallParticipantDeclinedHandler } from "./call-declined.handler";
+export { CallEndedHandler } from "./call-ended.handler";
+export { CallJoinInfoHandler } from "./call-join-info.handler";
+export { ParticipantLeftHandler } from "./participant-left.handler";
+export { CallParticipantJoiningHandler } from "./call-participant-joining.handler";
+export { CallParticipantJoinedHandler } from "./call-participant-joined.handler";
+export { CallTimeoutHandler } from "./call-timeout.handler";
+export { CallCanceledHandler } from "./call-canceled.handler";
+export { SocketHandlerRegistry } from "./handler.registry";
+
+// Re-export schema types for convenience
+export type {
+  CallIncomingEvent,
+  CallAcceptedEvent,
+  CallEndedEvent,
+  CallJoinInfoEvent,
+  ParticipantLeftEvent,
+} from "./schema";

package/packages/sdk/src/core/socketio/handlers/participant-left.handler.ts

@@ -0,0 +1,37 @@
+import { pushStaleEventError } from "../../../state/errors";
+import { BaseSocketHandler } from "./base.handler";
+import { participantLeftSchema } from "./schema";
+import type { ParticipantLeftEvent } from "./schema";
+
+export class ParticipantLeftHandler extends BaseSocketHandler<ParticipantLeftEvent> {
+  protected readonly eventName = "call.participant-left";
+  protected readonly schema = participantLeftSchema;
+
+  protected handle(data: ParticipantLeftEvent): void {
+    this.updateStore((state) => {
+      if (state.session.id !== data.callId) {
+        pushStaleEventError("call.participant-left", "callId mismatch", {
+          eventCallId: data.callId,
+          sessionCallId: state.session.id,
+        });
+        return;
+      }
+
+      const participant = state.room.participants[data.participant.id];
+      if (participant) {
+        participant.callState = "LEFT";
+        participant.leftAt = data.timestamp || Date.now();
+      }
+    });
+
+    const isLocalParticipant =
+      this.livekit?.room.localParticipant?.identity === data.participant.id;
+    if (isLocalParticipant && this.livekit) {
+      this.livekit.disconnect().catch((error: any) => {
+        this.logger.error("Error disconnecting from LiveKit after self-leave", {
+          error,
+        });
+      });
+    }
+  }
+}

package/packages/sdk/src/core/socketio/handlers/schema.ts

@@ -0,0 +1,130 @@
+import { z } from "zod";
+
+// Participant with a role for socket events
+export const socketParticipantSchema = z.object({
+  id: z.string(),
+  firstName: z.string().nullable(),
+  lastName: z.string().nullable(),
+  username: z.string().nullable(),
+  profilePhoto: z.string().nullable(),
+  role: z.enum(["CALLER", "CALLEE", "HOST", "MEMBER"]).optional(),
+});
+
+// call.incoming event schema
+export const callIncomingSchema = z.object({
+  callId: z.string(),
+  type: z.enum(["AUDIO", "VIDEO"]),
+  participants: z.array(socketParticipantSchema).min(1), // Required, at least 1 participant
+  timestamp: z.number(),
+});
+
+// call.accepted event schema (legacy)
+export const callAcceptedSchema = z.object({
+  callId: z.string(),
+  by: z.object({
+    id: z.string(),
+    acceptedAt: z.number().optional(),
+  }),
+});
+
+// call.participant-accepted event schema
+export const callParticipantAcceptedSchema = z.object({
+  callId: z.string(),
+  participantId: z.string(),
+  participant: socketParticipantSchema,
+  acceptedAt: z.string().optional(),
+});
+
+// call.join-info event schema
+export const callJoinInfoSchema = z.object({
+  callId: z.string(),
+  token: z.string(),
+  url: z.string().optional(),
+  roomName: z.string(),
+  expiresAt: z.number().optional(),
+});
+
+// call.ended event schema
+export const callEndedSchema = z.object({
+  callId: z.string(),
+  reason: z.string().optional(),
+  endedAt: z.string().optional(),
+}).passthrough(); // Allow additional fields to pass through
+
+
+// call.participant-left event schema
+export const participantLeftSchema = z.object({
+  callId: z.string(),
+  participant: z.object({
+    id: z.string(),
+    name: z.string().optional(),
+  }),
+  timestamp: z.number().optional(),
+});
+
+// call.participant-joining event schema
+export const callParticipantJoiningSchema = z.object({
+  callId: z.string(),
+  participantId: z.string(),
+  participant: socketParticipantSchema,
+  timestamp: z.number().optional(),
+});
+
+// call.participant-joined event schema
+export const callParticipantJoinedSchema = z.object({
+  callId: z.string(),
+  participantId: z.string(),
+  participant: socketParticipantSchema,
+  timestamp: z.number().optional(),
+});
+
+// call.timeout event schema
+export const callTimeoutSchema = z.object({
+  callId: z.string(),
+  reason: z.string().optional(),
+  timestamp: z.number().optional(),
+});
+
+// call.participant-declined event schema
+export const callParticipantDeclinedSchema = z.object({
+  callId: z.string(),
+  participantId: z.string(),
+  participant: socketParticipantSchema,
+  declinedAt: z.string().optional(),
+});
+
+// call.canceled event schema
+export const callCanceledSchema = z.object({
+  callId: z.string(),
+  reason: z.string().optional(),
+  timestamp: z.number().optional(),
+  by: socketParticipantSchema.optional(),
+});
+
+// Optional participant.joined event schema (for future use)
+export const participantJoinedSchema = z.object({
+  callId: z.string(),
+  participant: z.object({
+    id: z.string(),
+    name: z.string().optional(),
+  }),
+  timestamp: z.number().optional(),
+});
+
+// Inferred types for use in handlers
+export type CallIncomingEvent = z.infer<typeof callIncomingSchema>;
+export type CallAcceptedEvent = z.infer<typeof callAcceptedSchema>;
+export type CallParticipantAcceptedEvent = z.infer<typeof callParticipantAcceptedSchema>;
+export type CallJoinInfoEvent = z.infer<typeof callJoinInfoSchema>;
+export type CallEndedEvent = z.infer<typeof callEndedSchema>;
+export type ParticipantLeftEvent = z.infer<typeof participantLeftSchema>;
+export type ParticipantJoinedEvent = z.infer<typeof participantJoinedSchema>;
+export type CallParticipantJoiningEvent = z.infer<
+  typeof callParticipantJoiningSchema
+>;
+export type CallParticipantJoinedEvent = z.infer<
+  typeof callParticipantJoinedSchema
+>;
+export type CallTimeoutEvent = z.infer<typeof callTimeoutSchema>;
+export type CallParticipantDeclinedEvent = z.infer<typeof callParticipantDeclinedSchema>;
+export type CallCanceledEvent = z.infer<typeof callCanceledSchema>;

package/packages/sdk/src/core/socketio/index.ts

@@ -0,0 +1,5 @@
+export { SocketManager } from "./socket.manager";
+export type {
+  ConnectionConfig,
+  ConnectionState,
+} from "./types";