@recallai/desktop-sdk 2025.3.20-daa9afad0e8b396cbde4cc76835f277cf9f86955 → 2025.3.24-281fab31aa87043b2fbe0ed81ae984c326e4d33e

package/index.d.ts

@@ -1,6 +1,4 @@
 declare module '@recallai/desktop-sdk' {
-    export function init(config: RecallAiSdkConfig): void;
-
     export type RecallAiSdkEvent =
         | RecordingStartEvent
         | RecordingStopEvent
@@ -11,7 +9,9 @@ declare module '@recallai/desktop-sdk' {
         | SdkStateChangeEvent
         | ErrorEvent
         | MediaCaptureStatusEvent
-        | PermissionsGrantedEvent;
+        | PermissionsGrantedEvent
+        | RealtimeEvent
+        | ShutdownEvent;
 
     export type EventTypeToPayloadMap = {
         'recording-started': RecordingStartEvent;
@@ -24,59 +24,93 @@ declare module '@recallai/desktop-sdk' {
         'error': ErrorEvent;
         'media-capture-status': MediaCaptureStatusEvent;
         'permissions-granted': PermissionsGrantedEvent;
+        'permission-status': PermissionStatusEvent;
         'realtime-event': RealtimeEvent;
+        'shutdown': ShutdownEvent;
     };
 
+    export type Permission =
+        | 'accessibility'
+        | 'screen-capture'
+        | 'microphone';
+
     export function addEventListener<T extends keyof EventTypeToPayloadMap>(
         type: T,
         listener: (event: EventTypeToPayloadMap[T]) => void
     ): void;
 
-    export function startRecording(config: StartRecordingConfig): void;
-    export function stopRecording(config: StopRecordingConfig): void;
-    export function uploadRecording(config: UploadRecordingConfig): void;
+    export function init(config: RecallAiSdkConfig): Promise<null>;
+    export function startRecording(config: StartRecordingConfig): Promise<null>;
+    export function pauseRecording(config: PauseRecordingConfig): Promise<null>;
+    export function resumeRecording(config: ResumeRecordingConfig): Promise<null>;
+    export function stopRecording(config: StopRecordingConfig): Promise<null>;
+    export function uploadRecording(config: UploadRecordingConfig): Promise<null>;
     export function prepareDesktopAudioRecording(): Promise<string>;
+    export function requestPermission(permission: Permission): Promise<null>;
+    export function shutdown(): Promise<null>;
+
+    ///
 
     export interface RecallAiSdkWindow {
         id: string;
-        title: string | undefined;
-        url: string | undefined;
+        title?: string;
+        url?: string;
         platform: string;
     }
 
     export interface RecallAiSdkConfig {
         api_url: string;
+        acquirePermissionsOnStartup?: Permission[]
     }
+
     export interface StartRecordingConfig {
         windowId: string;
         uploadToken: string;
     }
+
     export interface StopRecordingConfig {
         windowId: string;
     }
+
+    export interface PauseRecordingConfig {
+        windowId: string;
+    }
+
+    export interface ResumeRecordingConfig {
+        windowId: string;
+    }
+
     export interface UploadRecordingConfig {
         windowId: string;
     }
 
+    ///
+
     export interface RecordingStartEvent {
         window: RecallAiSdkWindow;
     }
+
     export interface RecordingStopEvent {
         window: RecallAiSdkWindow;
     }
+
     export interface UploadProgressEvent {
         window: { id: string };
         progress: number;
     }
+
     export interface MeetingDetectedEvent {
         window: RecallAiSdkWindow;
     }
+
     export interface MeetingUpdatedEvent {
         window: RecallAiSdkWindow;
     }
+
     export interface MeetingClosedEvent {
         window: RecallAiSdkWindow;
     }
+
     export interface SdkStateChangeEvent {
         sdk: {
             state: {
@@ -84,22 +118,34 @@ declare module '@recallai/desktop-sdk' {
             };
         };
     }
+
     export interface MediaCaptureStatusEvent {
         window: RecallAiSdkWindow;
         type: 'video' | 'audio';
         capturing: boolean;
     }
-    export interface PermissionsGrantedEvent {
+
+    export interface PermissionsGrantedEvent {}
+
+    export interface PermissionStatusEvent {
+        permission: Permission;
+        granted: bool;
     }
+
     export interface ErrorEvent {
-        error: {
-            type: string;
-            message: string;
-        };
+        window?: RecallAiSdkWindow;
+        type: string;
+        message: string;
     }
+
     export interface RealtimeEvent {
         window: RecallAiSdkWindow;
         event: string;
         data: any;
     }
+
+    export interface ShutdownEvent {
+        code: number;
+        signal: string;
+    }
 }

package/index.js

@@ -45,7 +45,23 @@ let proc;
 const listeners = [];
 const pendingCommands = {};
 
+function emitEvent(type, payload) {
+  for (const listener of listeners) {
+    if (listener.type === type)
+      listener.callback(payload);
+  }
+}
+
+function flushPendingCommands(err) {
+  Object.keys(pendingCommands).forEach(commandId => {
+    pendingCommands[commandId].reject(err);
+    delete pendingCommands[commandId];
+  });
+}
+
 function startProcess() {
+  if (proc && proc.exitCode === null) return;
+
   const exe_path = exe_paths.find(fs.existsSync);
 
   if (!exe_path) {
@@ -68,11 +84,13 @@ function startProcess() {
   const rlStderr = readline.createInterface({ input: proc.stderr, crlfDelay: Infinity });
 
   rlStdout.on('line', (data) => {
-    if (process.env.RECALLAI_DESKTOP_SDK_DEV) console.log(data);
+    if (process.env.RECALLAI_DESKTOP_SDK_DEV)
+      console.log(data);
   });
 
   rlStderr.on('line', (data) => {
-    if (process.env.RECALLAI_DESKTOP_SDK_DEV) console.error(data);
+    if (process.env.RECALLAI_DESKTOP_SDK_DEV)
+      console.error(data);
   });
 
   rl.on('line', (line) => {
@@ -82,27 +100,21 @@ function startProcess() {
       switch (data.type) {
         case "event":
           const event = JSON.parse(data.event);
-          for (const { type, callback } of listeners) {
-            if (type === event.type) callback(event.payload);
-          }
+          emitEvent(event.type, event.payload);
           break;
 
         case "response":
           const pendingCommand = pendingCommands[data.commandId];
           if (pendingCommand) {
-            pendingCommand.resolve(data.result);
+            if (data.status === "success") {
+              pendingCommand.resolve(data.result);
+            }
+            else {
+              pendingCommand.reject(new Error(data.result));
+            }
             delete pendingCommands[data.commandId];
           }
           break;
-        case "status":
-          const status = data.status;
-
-          if (status == "success")
-            break;
-          else if (status == "error")
-            console.error(`Desktop SDK: Error response from command. ${data.command} - ${data.status}`);
-
-          break;
       }
     } catch (err) {
       console.error("Desktop SDK: Failed to parse incoming data:", err);
@@ -110,27 +122,48 @@ function startProcess() {
   });
 
   proc.on('error', (error) => {
+    flushPendingCommands(new Error(`Process error: ${error.message}`));
+    emitEvent('error', {
+      type: 'process',
+      message: `The Desktop SDK server process has failed to start or exited improperly.`
+    });
     console.error(`Desktop SDK: Process error: ${error.message}`);
   });
 
-  proc.on('close', (code) => {
-    console.error(`Desktop SDK: Process exited with code ${code}. Restarting...`);
-    startProcess();
+  proc.on('close', (code, signal) => {
+    flushPendingCommands(new Error(`Process exited with code ${code}, signal ${signal}.`));
+    emitEvent('shutdown', { code, signal });
 
-    for (const { type, callback } of listeners) {
-      if (type === 'error')
-        callback({
-          type: "crash",
-          message: "The Desktop SDK server process crashed and has restarted."
-        });
-    }
+    if (code === 0 || signal == 'SIGINT')
+      return;
+
+    console.error(`Desktop SDK: Process exited with code ${code}, signal ${signal}`);
+
+    emitEvent('error', {
+      type: 'process',
+      message: "The Desktop SDK server process exited unexpectedly."
+    });
   });
 }
 
-function sendJSON(obj) {
-  if (proc && proc.stdin) {
-    proc.stdin.write(JSON.stringify(obj) + "\n");
-  }
+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 = uuidv4();
+    pendingCommands[commandId] = { resolve, reject };
+
+    const payload = {
+      command,
+      commandId,
+      params
+    };
+
+    proc.stdin.write(JSON.stringify(payload) + "\n");
+  });
 }
 
 function init(options) {
@@ -138,53 +171,67 @@ function init(options) {
   if (!dev && (!api_url || !api_url.startsWith("https"))) {
     throw new Error(`api_url must be an https url, got: ${api_url}`);
   }
-  sendJSON({
-    command: "init",
-    config: JSON.stringify(options)
-  });
+
+  startProcess();
+  return sendCommand("init", { config: JSON.stringify(options) });
+}
+
+async function shutdown() {
+  const result = await sendCommand("shutdown");
+
+  if (proc) {
+    const currentProc = proc;
+    setTimeout(() => {
+      if (!currentProc.killed) {
+        currentProc.kill();
+      }
+    }, 5000);
+  }
+
+  return result;
 }
 
 function startRecording(config) {
-  sendJSON({ command: "startRecording", config: JSON.stringify(config) });
+  return sendCommand("startRecording", { config: JSON.stringify(config) });
 }
 
 function stopRecording({ windowId }) {
-  sendJSON({
-    command: "stopRecording",
-    windowId
-  });
+  return sendCommand("stopRecording", { windowId });
+}
+
+function pauseRecording({ windowId }) {
+  return sendCommand("pauseRecording", { windowId });
+}
+
+function resumeRecording({ windowId }) {
+  return sendCommand("resumeRecording", { windowId });
 }
 
 function uploadRecording({ windowId }) {
-  sendJSON({
-    command: "uploadRecording",
-    windowId
-  });
+  return sendCommand("uploadRecording", { windowId });
 }
 
 function prepareDesktopAudioRecording() {
-  return new Promise((resolve, reject) => {
-    let commandId = uuidv4();
-    pendingCommands[commandId] = { resolve, reject };
-    sendJSON({
-      command: "prepareDesktopAudioRecording",
-      commandId
-    });
-  });
+  return sendCommand("prepareDesktopAudioRecording");
+}
+
+function requestPermission(permission) {
+  return sendCommand("requestPermission", { permission });
 }
 
 function addEventListener(type, callback) {
   listeners.push({ type, callback });
 }
 
-// Start the process initially
-startProcess();
-
 module.exports = {
   init,
+  shutdown,
   addEventListener,
   startRecording,
+  pauseRecording,
+  resumeRecording,
   stopRecording,
   uploadRecording,
   prepareDesktopAudioRecording,
+  requestPermission
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@recallai/desktop-sdk",
-  "version": "2025.03.20-daa9afad0e8b396cbde4cc76835f277cf9f86955",
+  "version": "2025.03.24-281fab31aa87043b2fbe0ed81ae984c326e4d33e",
   "description": "Recall Desktop SDK (Alpha)",
   "main": "./index.js",
   "types": "./index.d.ts",