Publishing Your App

Packaging requirements

ASAR packaging

When packaging Electron apps, it’s common to bundle the app into an app.asar archive. The Recall Desktop SDK includes helper executables that must be accessible as real files on disk at runtime. If these files are packaged inside app.asar, the SDK may fail to initialize with errors like spawn ENOTDIR. We highly recommend using the forge.config.js file for our sample DSDK project, since it's configured to handle issues like this automatically.

MacOS

⚠️

Applications using the Desktop Recording SDK cannot be published on the MacOS App Store

The Desktop Recording SDK is not compatible with the sandboxing requirements of the MacOS app store. Key features of the DSDK are unavailable in this environment, so publishing with the app store is currently not supported.

Distributing an Electron application on MacOS requires two critical security steps: code signing and notarization. Both are requirements from Apple to ensure users can safely download and run your application without security warnings. For both of these steps, we recommend using Electron Forge.

Code signing

📘

For a bundled app to properly handle permissions, it must be code signed and notarized. A bundled app that is not code signed and notarized will fail to be granted any permissions, even if they are shown to be granted in MacOS system settings.

Code signing is the process of digitally signing your application with a certificate from Apple. This signature proves your application comes from a verified developer, and allows MacOS to trust your application and run it without blocking. Without code signing, MacOS Gatekeeper will prevent users from running your app, showing warnings like "This app is from an unidentified developer."

Requirements:

• An Apple Developer account ($99/year)
• A valid Developer ID Application certificate
• Access to your signing credentials (certificate and private key)

To get started with code signing, we recommend following the code signing guide from Electron Forge.

DSDK-Specific Configuration

Electron Forge's standard osx-sign tool has issues with the Desktop Recording SDK's structure, which can cause it to take a long time to sign applications using the Desktop Recording SDK. To resolve this, Recall provides a modified version of the osx-sign package to properly sign all bundled components. Use Recall's fork of osx-sign by adding the following to your package.json:

  "overrides": {
    "@electron/packager": {
      "@electron/osx-sign": "github:recallai/osx-sign"
    }
  },

If you don't want to worry about configuring this, you can also try our sample project which already has it configured!

Notarization

📘

Notarize your app early!

You should not wait until your app is ready to ship to perform the notarization process, you should get approved earlier! The initial process can be very time-consuming, but subsequent attempts will be much faster.

Notarization is Apple's automated security scan of your already-signed application. When you submit your app to Apple for notarization, Apple scans it for malicious content and code-signing issues. If approved, Apple adds a notarization ticket to your app.

Without notarization, MacOS (Catalina and later) will show security warnings even if your app is code-signed. Users will see "Apple cannot check it for malicious software" warnings.

❗️

Notarization can take multiple hours

Notarization is typically a fast process, but it can take multiple hours to notarize your application when running it for the first time. After the initial notarization, subsequent attempts should be much faster.

Setting up notarization

Unlike with code-signing, there are no specific changes you'll need to make for applications running the Desktop Recording SDK. We recommend the comprehensive notarization guide from Electron Forge, which shows the the different methods you can use to notarize your application.

Complete Build Process

Once you've configured code signing and notarization as explained above, you're almost ready to distribute your app. The next step is to run electron-forge make. When you run electron-forge make, Electron Forge will automatically:

1. Package your application
2. Code sign all components using the Recall.ai fork of osx-sign
3. Submit to Apple for notarization
4. Wait for Apple's approval (usually 2-10 minutes, can be multiple hours on the first try)
5. Staple the notarization ticket to your app

The final .dmg or .zip file will be fully signed and notarized, ready for distribution.

Windows

Windows applications also require code signing, but do not require the notarization process that Apple mandates. You’ll need a code-signing certificate, which you can purchase from various certificate providers. See Electron’s Windows code-signing guide for provider options and instructions for signing your application.

Sign your application and all bundled Desktop Recording SDK executables (.exe) and libraries (.dll) with your code-signing certificate. When signing, only include .exe and .dll files.

Best Practices

When deploying to corporate-managed devices, work with the customer’s IT administrator to facilitate installation and allowlist your application for execution.

Some customers may have a corporate firewalls or VPNs that blocks endpoints required by the Desktop Recording SDK. At a minimum, ask their IT administrator to allow access to the .recall.ai endpoints for your Recall region. If you use real-time transcription, they must also allow access to your transcription provider’s endpoints.

For Recall to receive diagnostic information, customers with more restrictive security policies must also allow access (allowlist) to the following hosts:

browser-intake-datadoghq.com
*.datadoghq.com
sentry.io
*.sentry.io

This allows the Recall team to receive the diagnostic information needed to investigate issues these customers may encounter.