Session Service

async createSession(ws: WebSocket, userId: string): Promise<{ 
  userSession: UserSession, 
  reconnection: boolean 
}> {
  // Check for existing session
  const existingSession = UserSession.getById(userId);
  
  if (existingSession) {
    // Reconnection scenario
    existingSession.updateWebSocket(ws);
    existingSession.disconnectedAt = null;
    
    // Clear cleanup timer
    if (existingSession.cleanupTimerId) {
      clearTimeout(existingSession.cleanupTimerId);
      existingSession.cleanupTimerId = undefined;
    }
    
    return { userSession: existingSession, reconnection: true };
  }
  
  // Create new session
  const userSession = new UserSession(userId, ws);
  
  // Fetch and populate installed apps
  const installedApps = await appService.getAllApps(userId);
  for (const app of installedApps) {
    userSession.installedApps.set(app.packageName, app);
  }
  
  return { userSession: userSession, reconnection: false };
}

// By session ID
getSession(sessionId: string): UserSession | null

// By user ID (email)
getSessionByUserId(userId: string): UserSession | null

// All active sessions
getAllSessions(): UserSession[]

async transformUserSessionForClient(userSession: UserSession): Promise<any> {
  // Collect app subscriptions
  const appSubscriptions: Record<string, string[]> = {};
  for (const packageName of userSession.runningApps) {
    appSubscriptions[packageName] = subscriptionService.getAppSubscriptions(
      userId, 
      packageName
    );
  }
  
  // Calculate stream requirements
  const hasPCMTranscriptionSubscriptions = 
    subscriptionService.hasPCMTranscriptionSubscriptions(userId);
  const requiresAudio = hasPCMTranscriptionSubscriptions.hasMedia;
  
  // Update microphone state based on requirements
  const requiredData = userSession.microphoneManager.calculateRequiredData(
    hasPCMTranscriptionSubscriptions.hasPCM, 
    hasPCMTranscriptionSubscriptions.hasTranscription
  );
  userSession.microphoneManager.updateState(requiresAudio, requiredData);
  
  return {
    userId,
    startTime: userSession.startTime,
    activeAppSessions: Array.from(userSession.runningApps),
    loadingApps: Array.from(userSession.loadingApps),
    appSubscriptions,
    requiresAudio,
    minimumTranscriptionLanguages,
    isTranscribing: userSession.isTranscribing || false
  };
}

relayMessageToApps(userSession: UserSession, data: GlassesToCloudMessage): void {
  // Get subscribed apps
  const subscribedPackageNames = subscriptionService.getSubscribedApps(
    userSession, 
    data.type
  );
  
  // Send to each subscriber
  for (const packageName of subscribedPackageNames) {
    const connection = userSession.appWebsockets.get(packageName);
    
    if (connection && connection.readyState === WebSocket.OPEN) {
      const dataStream: DataStream = {
        type: CloudToAppMessageType.DATA_STREAM,
        sessionId: `${userSession.sessionId}-${packageName}`,
        streamType: data.type as StreamType,
        data,
        timestamp: new Date()
      };
      
      connection.send(JSON.stringify(dataStream));
    }
  }
}

relayAudioToApps(userSession: UserSession, audioData: ArrayBuffer): void {
  userSession.audioManager.processAudioData(audioData, false);
}

relayAudioPlayResponseToApp(userSession: UserSession, audioResponse: any): void {
  const requestId = audioResponse.requestId;
  
  // Find which app made the request
  const packageName = userSession.audioPlayRequestMapping.get(requestId);
  
  if (packageName) {
    const connection = userSession.appWebsockets.get(packageName);
    // Send response to app...
  }
}

async getUserSettings(userId: string): Promise<Record<string, any>> {
  const user = await User.findOne({ email: userId });
  
  if (!user) {
    return DEFAULT_AUGMENTOS_SETTINGS;
  }
  
  // Get system settings
  const augmentosSettings = user.getAugmentosSettings();
  
  // Add app settings
  const allSettings = {
    ...augmentosSettings,
    appSettings: Object.fromEntries(user.appSettings || new Map())
  };
  
  return allSettings;
}

async getAppSettings(userId: string, packageName: string): Promise<Record<string, any>> {
  const allSettings = await this.getUserSettings(userId);
  return allSettings.appSettings?.[packageName] || {};
}

const DEFAULT_AUGMENTOS_SETTINGS = {
  useOnboardMic: false,
  contextualDashboard: true,
  headUpAngle: 20,
  brightness: 50,
  autoBrightness: false,
  sensingEnabled: true,
  alwaysOnStatusBar: false,
  bypassVad: false,
  bypassAudioEncoding: false,
  metricSystemEnabled: false
};