@recallai/desktop-sdk 2.0.8 → 2.0.9

package/CHANGELOG.md

@@ -1,3 +1,24 @@
+### 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

package/index.d.ts

@@ -52,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;
@@ -134,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;
@@ -152,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;
@@ -216,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");
@@ -289,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) {
@@ -309,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;
                 }
@@ -341,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.`
@@ -349,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) {
@@ -363,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--;
@@ -375,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();
@@ -460,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 });
@@ -477,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,
@@ -488,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.8",
+  "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": "b7a1c938d0de3e558014e49d4e79299e71d84f17"
+  "commit_sha": "2bc571dbad7ed8b15a925c9a4cdd0e7fab3c6955"
 }