remove logger

Author: isaiahb

package.json

@@ -4,16 +4,17 @@
   "type": "module",
   "module": "src/index.ts",
   "scripts": {
-    "dev": "doppler run -- bun --watch src/index.ts",
-    "dev:local": "bun --watch src/index.ts",
+    "dev": "bun run kill-ports && doppler run -- bun --watch src/index.ts",
+    "dev:local": "bun run kill-ports && bun --watch src/index.ts",
+    "kill-ports": "lsof -ti:8069,8070 | xargs kill -9 2>/dev/null || true",
     "build:webview": "bun run build.ts",
     "start": "doppler run -- bun run build:webview && doppler run -- bun src/index.ts",
     "start:local": "bun run build:webview && bun src/index.ts",
     "ngrok": "ngrok http --url=isaiah-tpa.ngrok.app 8069",
     "doppler:setup": "doppler setup"
   },
   "dependencies": {
-    "@mentra/sdk": "^2.1.29-beta.2",
+    "@mentra/sdk": "^2.1.31-beta.4",
     "@mentra/react": "^0.2.0",
     "@aws-sdk/client-s3": "^3.812.0",
     "@radix-ui/react-dialog": "^1.1.6",

src/services/recordings.service.ts

@@ -438,22 +438,16 @@ class RecordingsService {
     // Register this as an active session
     registerActiveSession(userId);
 
-    // Set up handlers for audio chunks
-    // IMPORTANT: This handler is intentionally synchronous for the critical path
-    // to ensure chunks are queued in arrival order
-    session.events.onAudioChunk((chunk: AudioChunk) => {
-      // Fast, synchronous cache lookup
-      const cached = this.getCachedActiveRecording(userId);
-
-      if (cached) {
-        // Fast, synchronous queue push
-        this.enqueueChunk(cached.recordingId, chunk.arrayBuffer as ArrayBuffer);
-      }
-    });
-
-    // Set up handlers for transcription
+    // IMPORTANT: Set up transcription handler FIRST, then audio handler.
+    // This fixes a race condition in the SDK where subscription updates are sent
+    // as each handler is added. By setting up transcription first, we ensure
+    // the final subscription state includes both audio_chunk AND transcription.
+    // If audio is set up first, there's a timing issue where a subsequent
+    // subscription update can accidentally drop the transcription subscription.
+
+    // Set up handlers for transcription (MUST be before audio handler)
     try {
-      session.onTranscriptionForLanguage(
+      session.events.onTranscriptionForLanguage(
         "en-US",
         async (transcription: TranscriptionData) => {
           console.log(
@@ -627,6 +621,22 @@ class RecordingsService {
     } catch (error) {
       console.error("Error setting up transcription handler:", error);
     }
+
+    // Set up handlers for audio chunks (AFTER transcription handler)
+    // IMPORTANT: This handler is intentionally synchronous for the critical path
+    // to ensure chunks are queued in arrival order
+    session.events.onAudioChunk((chunk: AudioChunk) => {
+      // Fast, synchronous cache lookup
+      const cached = this.getCachedActiveRecording(userId);
+
+      if (cached) {
+        // Fast, synchronous queue push
+        this.enqueueChunk(cached.recordingId, chunk.arrayBuffer as ArrayBuffer);
+      }
+    });
+    console.log(
+      `[TPA SESSION] ✅ Handlers registered for user ${userId} (transcription + audio)`,
+    );
   }
 
   /**

src/webview/Api.ts

@@ -4,7 +4,6 @@
 
 import axios from "axios";
 import { RecordingI } from "./types";
-import logger from "./utils/remoteLogger";
 
 /**
  * Check if we're in development mode
@@ -56,17 +55,17 @@ const axiosInstance = axios.create({
 // Add response interceptor for debugging
 axiosInstance.interceptors.response.use(
   (response) => {
-    logger.debug(
+    console.debug(
       `[API] Response ${response.config.method?.toUpperCase()} ${response.config.url} - Status: ${response.status}`,
     );
     return response;
   },
   (error) => {
     if (axios.isAxiosError(error)) {
-      logger.error(
+      console.error(
         `[API] Error ${error.config?.method?.toUpperCase()} ${error.config?.url} - Status: ${error.response?.status}`,
       );
-      logger.error("[API] Error response:", error.response?.data);
+      console.error("[API] Error response:", error.response?.data);
     }
     return Promise.reject(error);
   },
@@ -120,8 +119,8 @@ const api = {
     },
 
     startRecording: async (sessionId: string): Promise<string> => {
-      logger.log(`[API] Starting recording with sessionId: ${sessionId}`);
-      logger.log("[API] Auth headers:", JSON.stringify(getAuthHeader()));
+      console.log(`[API] Starting recording with sessionId: ${sessionId}`);
+      console.log("[API] Auth headers:", JSON.stringify(getAuthHeader()));
 
       try {
         const response = await axiosInstance.post(
@@ -132,16 +131,16 @@ const api = {
           },
         );
 
-        logger.log(`[API] Start recording response status: ${response.status}`);
-        logger.log(`[API] Start recording response data:`, response.data);
+        console.log(`[API] Start recording response status: ${response.status}`);
+        console.log(`[API] Start recording response data:`, response.data);
 
         return response.data.id;
       } catch (error) {
-        logger.error("[API] Start recording request failed:", error);
+        console.error("[API] Start recording request failed:", error);
         if (axios.isAxiosError(error)) {
-          logger.error("[API] Response status:", error.response?.status);
-          logger.error("[API] Response data:", error.response?.data);
-          logger.error("[API] Response headers:", error.response?.headers);
+          console.error("[API] Response status:", error.response?.status);
+          console.error("[API] Response data:", error.response?.data);
+          console.error("[API] Response headers:", error.response?.headers);
         }
         throw error;
       }

src/webview/App.tsx

@@ -6,7 +6,6 @@ import PlaybackImproved from "./screens/PlaybackImproved/PlaybackImproved";
 import { useRecordings } from "./hooks/useRecordings";
 import { RecordingI } from "./types/recording";
 import api, { setFrontendToken, getBackendUrl } from "./Api";
-import logger from "./utils/remoteLogger";
 
 /**
  * Check if we're in development mode
@@ -184,14 +183,14 @@ const App: React.FC = () => {
 
   const handleStartRecording = async () => {
     try {
-      logger.log("[APP] handleStartRecording called from App.tsx");
+      console.log("[APP] handleStartRecording called from App.tsx");
       const recordingId = await startRecording();
-      logger.log("[APP] Recording started successfully with ID:", recordingId);
+      console.log("[APP] Recording started successfully with ID:", recordingId);
       return recordingId;
     } catch (error) {
-      logger.error("[APP] Failed to start recording:", error);
-      logger.error("[APP] Error type:", typeof error);
-      logger.error(
+      console.error("[APP] Failed to start recording:", error);
+      console.error("[APP] Error type:", typeof error);
+      console.error(
         "[APP] Error message:",
         error instanceof Error ? error.message : String(error),
       );

src/webview/hooks/useRecordings.ts

@@ -6,7 +6,6 @@ import { useState, useEffect, useCallback, useRef } from "react";
 import api from "../Api";
 import { RecordingI, RecordingStatusE } from "../types/recording";
 import { useRealTimeEvents } from "./useRealTimeEvents";
-import logger from "../utils/remoteLogger";
 
 export interface UseRecordingsOptions {
   autoRefresh?: boolean;
@@ -130,41 +129,41 @@ export function useRecordings(options: UseRecordingsOptions = {}) {
   const startRecording = useCallback(async (): Promise<string> => {
     // Prevent multiple simultaneous start attempts
     if (startingRecording.current) {
-      logger.warn(
+      console.warn(
         "[useRecordings] Already starting a recording, skipping duplicate attempt",
       );
       throw new Error("Already starting a recording");
     }
 
-    logger.log("[useRecordings] Setting startingRecording flag to true");
+    console.log("[useRecordings] Setting startingRecording flag to true");
     startingRecording.current = true;
 
     try {
       // Check session status first
-      logger.log(
+      console.log(
         "[useRecordings] Checking session status before starting recording",
       );
       const isConnected = await checkSessionStatus();
       if (!isConnected) {
-        logger.error("[useRecordings] No active session, throwing error");
+        console.error("[useRecordings] No active session, throwing error");
         throw new Error(
           "No active AugmentOS SDK session. Please ensure your glasses are connected.",
         );
       }
 
       const sessionId = `session_${Date.now()}`;
-      logger.log(
+      console.log(
         `[useRecordings] Making API call to start recording with sessionId: ${sessionId}`,
       );
       const recordingId = await api.recordings.startRecording(sessionId);
-      logger.log(
+      console.log(
         `[useRecordings] Recording started successfully with ID: ${recordingId}`,
       );
       return recordingId;
     } catch (err) {
-      logger.error("[useRecordings] Error starting recording:", err);
-      logger.error("[useRecordings] Error type:", typeof err);
-      logger.error(
+      console.error("[useRecordings] Error starting recording:", err);
+      console.error("[useRecordings] Error type:", typeof err);
+      console.error(
         "[useRecordings] Error message:",
         err instanceof Error ? err.message : String(err),
       );
@@ -182,7 +181,7 @@ export function useRecordings(options: UseRecordingsOptions = {}) {
         err instanceof Error &&
         err.message.includes("already has an active recording")
       ) {
-        logger.warn(
+        console.warn(
           "[useRecordings] User already has an active recording, not setting general error state",
         );
         throw err; // Still throw so caller can handle it
@@ -193,7 +192,7 @@ export function useRecordings(options: UseRecordingsOptions = {}) {
       );
       throw err;
     } finally {
-      logger.log("[useRecordings] Setting startingRecording flag to false");
+      console.log("[useRecordings] Setting startingRecording flag to false");
       startingRecording.current = false;
     }
   }, [checkSessionStatus]);