@recallai/desktop-sdk 2.0.7 → 2.0.9

package/CHANGELOG.md

@@ -1,4 +1,40 @@
-### 2.0.7 [patch] (MacOS+Windows) - 2026-02-11
+### 2.0.9 [patch] (MacOS+Windows) - 2026-03-27
+- Forward invalid command errors back to user on Windows.
+- Restart video capture on windows as necessary.
+- Improvements to audio device tracking algorithms on Windows.
+- Teams audio capture fixes on Windows.
+- Teams delayed detection fixes on Windows.
+- Fixed issue where Chromium browsers would occasionally experience slow detection speed when joining the meeting with the microphone muted on MacOS
+- Reduced initial startup burden associated with mic logs on MacOS
+- Zoom screenshare detection works with annotations disabled
+- Fixed issues with speaker labels being misattributed in > 2 participant meetings on MacOS
+- Fixed issue with Teams not firing meeting-closed when closed from PIP view with main window minimized on MacOS
+- Fixed issues with Arc / Brave sometimes failing to detect after-call screen on MacOS
+- Fixed issues with chromium browsers prematurely ending meeting when switching tabs without PIP enabled on MacOS
+- Fixed issue where transcript events would stop firing after recovering from network outage on MacOS
+- Fixed issue where having video frame capture enabled would occasionally cause crashes on MacOS
+- Fixed issue where Brave meetings would sometimes not be detected after leaving and rejoining meeting quickly on MacOS
+- Fixed issue where audio would sometimes die mid-stream causing transcription and audio loss
+- Fixed issue where audio streams would die and never recover
+- Add additional telemetry to audio stream lifecycle
+- Add additional telemetry and fix to commands not properly responding on macOS
+
+### 2.0.8 [patch] (MacOS+Windows) - 2026-03-13
+- Reduced blips/audio-glitches in the audio mixing process
+- Fixed Windows audio latency during capture
+- Added Windows network-status event and automatic recording stopping.
+- More robust device switching and restarting on windows.
+- Prevent google meet updated events after recording stopped on macOS.
+- Fixed Brave detection on macOS
+- Fixed Chrome fullscreen detection on macOS
+- Fixed issue for Google Meet where compliance message would send to wrong input when different window is focused on macOS
+- Fixed issue for Zoom where host would incorrectly get recognized as a separate participant on macOS
+- Fixed issue for screenshare capturing where screen sharing indicator would sometimes persist after recording ended on macOS
+- Added ZoomAudioDevice to mic capture blacklist on macOS
+- Fixed Chrome title detection on macOS
+- Supported title on MS Teams on macOS
+
+### 2.0.7 [patch] (MacOS+Windows) - 2026-02-26
 - Fixed issues capturing audio when devices change on windows.
 - Added a network shutdown event on macOS.
 - Set recording id on SDK events on macOS and windows.
@@ -7,8 +43,7 @@
 ### 2.0.6 [patch] (MacOS+Windows) - 2026-02-11
 - Fix case where recording-ended would not trigger on Windows
 
-### 2.0.5 [patch] (MacOS+Windows) - 2026-02-11
-
+### 2.0.5 [patch] (MacOS+Windows) - 2026-02-11 (deprecated)
 - Support for Google Chrome 145.0.7632.46+
 - Improvements for Brave
 - Automatically detect which microphone is being used by the meeting platform

package/index.d.ts

@@ -33,6 +33,10 @@ export interface RecallAiSdkConfig {
     acquirePermissionsOnStartup?: Permission[];
     restartOnError?: boolean;
     dev?: boolean;
+    testMode?: boolean;
+    testSpeedModifier?: string;
+    testTargetBundleId?: string;
+    testTargetBundleIdRemapped?: string;
 }
 export interface StartRecordingConfig {
     windowId: string;
@@ -48,7 +52,7 @@ export interface ResumeRecordingConfig {
     windowId: string;
 }
 /**
- * @deprecated Recordings are uploaded based on the upload token config.
+ * @deprecated Recordings are automatically uploaded based on your rentention configuration. This is now a no-op.
  */
 export interface UploadRecordingConfig {
     windowId: string;
@@ -130,13 +134,15 @@ export declare function stopRecording({ windowId }: StopRecordingConfig): Promis
 export declare function pauseRecording({ windowId }: PauseRecordingConfig): Promise<null>;
 export declare function resumeRecording({ windowId }: ResumeRecordingConfig): Promise<null>;
 /**
- * @deprecated Recordings are uploaded based on the upload token config.
+ * @deprecated Recordings are automatically uploaded based on your rentention configuration. This is now a no-op.
  */
 export declare function uploadRecording({ windowId }: UploadRecordingConfig): Promise<null>;
 export declare function prepareDesktopAudioRecording(): Promise<string>;
 export declare function requestPermission(permission: Permission): Promise<null>;
 export declare function testUnexpectedShutdown(): Promise<null>;
 export declare function addEventListener<T extends keyof EventTypeToPayloadMap>(type: T, callback: (event: EventTypeToPayloadMap[T]) => void): void;
+export declare function removeEventListener<T extends keyof EventTypeToPayloadMap>(type: T, callback: (event: EventTypeToPayloadMap[T]) => void): void;
+export declare function removeAllEventListeners(): void;
 declare const RecallAiSdk: {
     init: typeof init;
     shutdown: typeof shutdown;
@@ -148,6 +154,8 @@ declare const RecallAiSdk: {
     prepareDesktopAudioRecording: typeof prepareDesktopAudioRecording;
     requestPermission: typeof requestPermission;
     addEventListener: typeof addEventListener;
+    removeEventListener: typeof removeEventListener;
+    removeAllEventListeners: typeof removeAllEventListeners;
     testUnexpectedShutdown: typeof testUnexpectedShutdown;
 };
 export default RecallAiSdk;

package/index.js

@@ -46,6 +46,8 @@ exports.prepareDesktopAudioRecording = prepareDesktopAudioRecording;
 exports.requestPermission = requestPermission;
 exports.testUnexpectedShutdown = testUnexpectedShutdown;
 exports.addEventListener = addEventListener;
+exports.removeEventListener = removeEventListener;
+exports.removeAllEventListeners = removeAllEventListeners;
 const path = __importStar(require("path"));
 const child_process_1 = require("child_process");
 const readline = __importStar(require("node:readline"));
@@ -76,6 +78,14 @@ let lastOptions;
 let remainingAutomaticRestarts = 10;
 let unexpectedShutdown = false;
 let exiting = false;
+let pendingStdinWrites = [];
+let flushingPendingStdinWrites = false;
+let waitingForStdinDrain = false;
+let stdinWriteSession = 0;
+let nextWriteSequence = 1;
+let activeDrainStartMs = null;
+let activeDrainStartIso = null;
+let activeDrainWriteSequence = null;
 let logBuffer = [];
 let logIndex = 0;
 let packageVersion;
@@ -185,6 +195,9 @@ async function doLog(level, log, echo = true) {
         }
     }
     catch (e) {
+        if (proc?.exitCode === 0 || exiting) {
+            return;
+        }
         console.error("Failed to send log to Desktop SDK", e.stack, e.message);
     }
 }
@@ -213,6 +226,157 @@ function flushPendingCommands(err) {
         delete pendingCommands[commandId];
     });
 }
+function resolvePendingCommand(commandId, result) {
+    const pendingCommand = pendingCommands[commandId];
+    if (!pendingCommand) {
+        return;
+    }
+    pendingCommand.resolve(result);
+    delete pendingCommands[commandId];
+}
+function rejectPendingCommand(commandId, err) {
+    const pendingCommand = pendingCommands[commandId];
+    if (!pendingCommand) {
+        return;
+    }
+    pendingCommand.reject(err);
+    delete pendingCommands[commandId];
+}
+function resetPendingStdinWrites() {
+    pendingStdinWrites = [];
+    flushingPendingStdinWrites = false;
+    waitingForStdinDrain = false;
+    stdinWriteSession++;
+    activeDrainStartMs = null;
+    activeDrainStartIso = null;
+    activeDrainWriteSequence = null;
+}
+// Serialize writes into the child stdin and stop when the stream applies backpressure.
+function flushPendingStdinWrites() {
+    if (flushingPendingStdinWrites || waitingForStdinDrain) {
+        return;
+    }
+    const currentProc = proc;
+    const stdin = currentProc?.stdin;
+    if (!currentProc || !stdin || currentProc.exitCode !== null) {
+        return;
+    }
+    flushingPendingStdinWrites = true;
+    const session = stdinWriteSession;
+    try {
+        while (pendingStdinWrites.length > 0) {
+            if (proc !== currentProc || currentProc.stdin !== stdin || currentProc.exitCode !== null) {
+                return;
+            }
+            const nextWrite = pendingStdinWrites.shift();
+            if (!nextWrite) {
+                break;
+            }
+            const canContinue = stdin.write(nextWrite.data, (err) => {
+                if (!err) {
+                    return;
+                }
+                if (session !== stdinWriteSession) {
+                    return;
+                }
+                rejectPendingCommand(nextWrite.commandId, new Error(`Failed writing ${nextWrite.command} command [${nextWrite.writeSequence}] (${nextWrite.commandId}) to Desktop SDK stdin: ${err.message}`));
+                if (currentProc.exitCode === null && !currentProc.killed) {
+                    currentProc.kill();
+                }
+            });
+            if (!canContinue) {
+                activeDrainStartMs = Date.now();
+                activeDrainStartIso = new Date(activeDrainStartMs).toISOString();
+                activeDrainWriteSequence = nextWrite.writeSequence;
+                waitingForStdinDrain = true;
+                stdin.once('drain', () => {
+                    if (session !== stdinWriteSession) {
+                        return;
+                    }
+                    if (proc !== currentProc || currentProc.stdin !== stdin || currentProc.exitCode !== null) {
+                        return;
+                    }
+                    const drainStopMs = Date.now();
+                    const drainStartMs = activeDrainStartMs;
+                    const drainStartIso = activeDrainStartIso;
+                    const drainWriteSequence = activeDrainWriteSequence;
+                    activeDrainStartMs = null;
+                    activeDrainStartIso = null;
+                    activeDrainWriteSequence = null;
+                    waitingForStdinDrain = false;
+                    flushingPendingStdinWrites = false;
+                    if (drainStartMs !== null && drainStartIso) {
+                        const drainStopIso = new Date(drainStopMs).toISOString();
+                        const durationMs = drainStopMs - drainStartMs;
+                        void enqueueCommand("log", {
+                            log: `stdin drain completed | start=${drainStartIso} | stop=${drainStopIso} | durationMs=${durationMs} | blockedWriteSequence=${drainWriteSequence ?? "unknown"}`,
+                            level: "info",
+                            echo: false
+                        }, { front: true, suppressSendLog: true }).catch((error) => {
+                            if (proc?.exitCode === 0 || exiting) {
+                                return;
+                            }
+                            console.error("Failed to enqueue stdin drain log", error.stack, error.message);
+                        });
+                        return;
+                    }
+                    flushPendingStdinWrites();
+                });
+                return;
+            }
+        }
+    }
+    catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        resetPendingStdinWrites();
+        flushPendingCommands(error);
+        return;
+    }
+    finally {
+        if (!waitingForStdinDrain) {
+            flushingPendingStdinWrites = false;
+        }
+    }
+}
+function enqueueStdinWrite(write, front = false) {
+    if (front) {
+        pendingStdinWrites.unshift(write);
+    }
+    else {
+        pendingStdinWrites.push(write);
+    }
+    flushPendingStdinWrites();
+}
+function enqueueCommand(command, params = {}, options = {}) {
+    return new Promise((resolve, reject) => {
+        const currentProc = proc;
+        const stdin = currentProc?.stdin;
+        if (!currentProc ||
+            currentProc.exitCode !== null ||
+            currentProc.killed ||
+            !stdin ||
+            stdin.destroyed ||
+            stdin.writableEnded ||
+            !stdin.writable) {
+            reject(new Error("The Desktop SDK is not started or is no longer accepting commands; call `shutdown` and `init` to start it again."));
+            return;
+        }
+        const commandId = (0, uuid_1.v4)();
+        const writeSequence = nextWriteSequence++;
+        pendingCommands[commandId] = { resolve, reject, command, writeSequence };
+        const payload = {
+            command,
+            commandId,
+            writeSequence,
+            params
+        };
+        const payloadStr = JSON.stringify(payload);
+        enqueueStdinWrite({ command, commandId, data: payloadStr + "\n", writeSequence }, options.front ?? false);
+        if (!options.suppressSendLog && command !== "log") {
+            doLog("info", [`Sending command [${writeSequence}]: ` + payloadStr], false);
+        }
+    });
+}
 function startProcess() {
     if (proc && proc.exitCode === null) {
         logError("Desktop SDK: Trying to start process while it is already started");
@@ -227,6 +391,12 @@ function startProcess() {
         return;
     }
     let envExtra = {};
+    // forward all env starting with RECALL_
+    Object.keys(process.env).forEach(key => {
+        if (key.startsWith("RECALL_")) {
+            envExtra[key] = process.env[key];
+        }
+    });
     if (process.platform === "win32" && process.env.GLOBAL_GST_RECALL !== "1") {
         envExtra["GST_PLUGIN_PATH"] = path.join(path.dirname(exe_path), "gstreamer-1.0");
     }
@@ -244,6 +414,18 @@ function startProcess() {
     if (sdk_version) {
         envExtra["SDK_VERSION"] = sdk_version;
     }
+    if (lastOptions?.testMode) {
+        envExtra["TEST_MODE"] = "1";
+    }
+    if (lastOptions?.testTargetBundleId) {
+        envExtra["TEST_TARGET_BUNDLE_ID"] = lastOptions.testTargetBundleId;
+    }
+    if (lastOptions?.testTargetBundleIdRemapped) {
+        envExtra["TEST_TARGET_BUNDLE_ID_REMAP"] = lastOptions.testTargetBundleIdRemapped;
+    }
+    if (lastOptions?.testSpeedModifier) {
+        envExtra["TEST_SPEED_MODIFIER"] = String(lastOptions.testSpeedModifier);
+    }
     const gst_dump_dir = process.env.RECALLAI_DESKTOP_SDK_DEV ? path.join(os.tmpdir(), "gst.nocommit") : os.tmpdir();
     if (!fs.existsSync(gst_dump_dir)) {
         try {
@@ -257,7 +439,7 @@ function startProcess() {
         stdio: (process.platform === "darwin" ? ["pipe", "pipe", "pipe", "pipe"] : "pipe"),
         env: {
             GST_RECALL_DEBUG: "2,transcriber:4,rtewebsocketsink:4,rtewebhooksink:4,audiomixer:4,galleryview:4,dsdks3sink:5",
-            GST_DEBUG: "3,GST_CAPS:5,GST_SCHEDULING:5,GST_PADS:5,video-scaler:1,transcriber:4,filebuffereds3sink:4,seekables3sink:4,rtpsession:1,videodecoder:2,basesink:2,webrtcbin:2,websocketsink:4,audiomixer:4,galleryview:4,removeonsinkeosbin:4,fallbackswitch:6,sendmessageonsinkeosbin:4,dsdks3sink:5",
+            GST_DEBUG: "3,GST_CAPS:5,GST_SCHEDULING:5,GST_PADS:5,video-scaler:1,transcriber:4,filebuffereds3sink:4,seekables3sink:4,rtpsession:1,audioresample:1,videodecoder:2,basesink:2,webrtcbin:2,websocketsink:4,audiomixer:4,galleryview:4,removeonsinkeosbin:4,fallbackswitch:6,sendmessageonsinkeosbin:4,dsdks3sink:5",
             GST_DEBUG_DUMP_DOT_DIR: gst_dump_dir,
             RUST_BACKTRACE: "1",
             // "DYLD_INSERT_LIBRARIES":"/opt/homebrew/lib/libjemalloc.dylib",
@@ -268,6 +450,10 @@ function startProcess() {
             ...envExtra,
         }
     });
+    const currentProc = proc;
+    stdinWriteSession++;
+    flushingPendingStdinWrites = false;
+    waitingForStdinDrain = false;
     if (process.platform === "darwin") {
         const fd3 = proc.stdio[3];
         if (fd3 && fd3 instanceof node_stream_1.Readable) {
@@ -288,15 +474,13 @@ function startProcess() {
                         }
                         break;
                     case "response":
-                        const pendingCommand = pendingCommands[data.commandId];
-                        if (pendingCommand) {
+                        if (pendingCommands[data.commandId]) {
                             if (data.status === "success") {
-                                pendingCommand.resolve(data.result);
+                                resolvePendingCommand(data.commandId, data.result);
                             }
                             else {
-                                pendingCommand.reject(new Error(data.result));
+                                rejectPendingCommand(data.commandId, new Error(data.result));
                             }
-                            delete pendingCommands[data.commandId];
                         }
                         break;
                 }
@@ -320,7 +504,18 @@ function startProcess() {
         }
     });
     proc.on('error', (error) => {
+        if (proc !== currentProc) {
+            return;
+        }
+        proc = null;
+        resetPendingStdinWrites();
         flushPendingCommands(new Error(`Process error: ${error.message}`));
+        rlData?.close();
+        rlStdout?.close();
+        rlStderr?.close();
+        rlData = null;
+        rlStdout = null;
+        rlStderr = null;
         emitEvent('error', {
             type: 'process',
             message: `The Desktop SDK server process has failed to start or exited improperly.`
@@ -328,10 +523,17 @@ function startProcess() {
         logError(`Desktop SDK: Process error: ${error.message}`);
     });
     proc.on('close', async (code, signal) => {
+        if (proc !== currentProc) {
+            return;
+        }
+        proc = null;
+        resetPendingStdinWrites();
         flushPendingCommands(new Error(`Process exited with code ${code}, signal ${signal}.`));
         emitEvent('shutdown', { code: code ?? 0, signal: signal ?? '' });
+        rlData?.close();
         rlStdout?.close();
         rlStderr?.close();
+        rlData = null;
         rlStdout = null;
         rlStderr = null;
         if (code === 0 || signal === 'SIGINT' || exiting) {
@@ -342,7 +544,6 @@ function startProcess() {
             type: 'process',
             message: "The Desktop SDK server process exited unexpectedly."
         });
-        proc = null;
         unexpectedShutdown = true;
         if (lastOptions.restartOnError && remainingAutomaticRestarts > 0) {
             remainingAutomaticRestarts--;
@@ -354,24 +555,7 @@ function startProcess() {
     });
 }
 function sendCommand(command, params = {}) {
-    return new Promise((resolve, reject) => {
-        if (!proc || !proc.stdin) {
-            reject(new Error("The Desktop SDK is not started; call `init` to start it."));
-            return;
-        }
-        const commandId = (0, uuid_1.v4)();
-        pendingCommands[commandId] = { resolve, reject };
-        const payload = {
-            command,
-            commandId,
-            params
-        };
-        const payloadStr = JSON.stringify(payload);
-        proc.stdin.write(payloadStr + "\n");
-        if (command !== "log") {
-            doLog("info", ["Sending command: " + payloadStr], false);
-        }
-    });
+    return enqueueCommand(command, params);
 }
 async function doInit(options) {
     startProcess();
@@ -404,11 +588,19 @@ async function shutdown() {
     const result = await sendCommand("shutdown");
     if (proc) {
         const currentProc = proc;
-        setTimeout(() => {
-            if (!currentProc.killed) {
-                currentProc.kill();
+        await new Promise((resolve) => {
+            if (currentProc.exitCode !== null) {
+                resolve();
+                return;
             }
-        }, 5000);
+            currentProc.once("close", () => resolve());
+            setTimeout(() => {
+                if (!currentProc.killed) {
+                    currentProc.kill();
+                }
+                resolve();
+            }, 5000);
+        });
     }
     return result;
 }
@@ -431,7 +623,7 @@ function resumeRecording({ windowId }) {
     return sendCommand("resumeRecording", { windowId });
 }
 /**
- * @deprecated Recordings are uploaded based on the upload token config.
+ * @deprecated Recordings are automatically uploaded based on your rentention configuration. This is now a no-op.
  */
 function uploadRecording({ windowId }) {
     return sendCommand("uploadRecording", { windowId });
@@ -448,6 +640,15 @@ function testUnexpectedShutdown() {
 function addEventListener(type, callback) {
     listeners.push({ type, callback });
 }
+function removeEventListener(type, callback) {
+    const index = listeners.findIndex(l => l.type === type && l.callback === callback);
+    if (index !== -1) {
+        listeners.splice(index, 1);
+    }
+}
+function removeAllEventListeners() {
+    listeners.length = 0;
+}
 const RecallAiSdk = {
     init,
     shutdown,
@@ -459,6 +660,8 @@ const RecallAiSdk = {
     prepareDesktopAudioRecording,
     requestPermission,
     addEventListener,
+    removeEventListener,
+    removeAllEventListeners,
     testUnexpectedShutdown
 };
 exports.default = RecallAiSdk;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@recallai/desktop-sdk",
-  "version": "2.0.7",
+  "version": "2.0.9",
   "description": "Recall Desktop SDK",
   "main": "./index.js",
   "types": "./index.d.ts",
@@ -20,5 +20,5 @@
     "@types/node": "^24.2.0",
     "typescript": "^5.3.3"
   },
-  "commit_sha": "541a0e106905afe34c005d84802157d1251cc35a"
+  "commit_sha": "2bc571dbad7ed8b15a925c9a4cdd0e7fab3c6955"
 }