# Add macOS Code Signing and Notarization to a Tauri Release Workflow

Yes. An agent wires Apple signing and notarization secrets into the Tauri release workflow and bundle config, guards unsigned tags, and opens a PR.

[Run this on Rush](https://cloud.getrush.ai/run/add-macos-code-signing/tauri/). Opens the console with this prompt ready to send, in a Project that has your repository.

## What the agent does

The agent reads the release pipeline as it stands, because signing is a change to a workflow that already works for three platforms. In a project like Uninen/tauri-vue-template, `.github/workflows/release.yml` runs on tags matching `v*.*.*` and on `workflow_dispatch`, with a matrix of `macos-latest` building `--target aarch64-apple-darwin`, `ubuntu-24.04` and `windows-latest`; the Intel macOS entry is commented out. Each job installs pnpm 10 and Node 24, stable Rust with the two Apple targets on macOS, the webkit2gtk dependencies on Ubuntu, and runs `tauri-apps/tauri-action@action-v0.5.20` with `tagName: v__VERSION__`, `releaseDraft: true` and a `releaseBody` that tells users macOS builds are not signed and to run `xattr -c` on the app. `src-tauri/tauri.conf.json` names the product `tauri-app`, the identifier `com.tauri-app.my`, `bundle.targets: "all"` and the icon set, and has no `bundle.macOS` block. The app version is `2.10.3` in `package.json` and `tauri.conf.json` but `2.10.0` in `src-tauri/Cargo.toml`, because `bump-version.cjs` replaces the old version read from `package.json` and the crate had drifted. The `README.md` release steps are: tag `vX.Y.Z`, push, publish the draft.

It adds the signing inputs where `tauri-action` reads them: an `env` block on the macOS matrix entry with `APPLE_CERTIFICATE`, `APPLE_CERTIFICATE_PASSWORD` and `APPLE_SIGNING_IDENTITY` for signing, and `APPLE_ID`, `APPLE_PASSWORD` and `APPLE_TEAM_ID` for notarization, each from a repository secret of the same name. The agent documents the alternative App Store Connect API key variables in a comment rather than adding a second path. In `tauri.conf.json` it adds a `bundle.macOS` block with `minimumSystemVersion` and an explicit `entitlements` path, and writes `src-tauri/Entitlements.plist` containing only what a WebView app under the hardened runtime needs, which for this template is nothing beyond the defaults, so the file is small and the pull request says why. The `releaseBody` loses the `xattr` sentence.

Two safeguards make the change honest. A step before `tauri-action` on macOS checks that the certificate secret is present and fails the job with a clear message when it is not, so a tag pushed before the secrets are configured produces no unsigned draft that looks like a release. And the version drift gets fixed: `Cargo.toml` goes to `2.10.3`, and `bump-version.cjs` is extended to read each file's own current version instead of `package.json`'s, so the three files cannot drift again. The agent also uncomments the Intel matrix entry only if asked; the prompt says to leave the platform list alone.

The sandbox is Linux, so it cannot sign or notarize, and the agent does not pretend to. It verifies what it can: `pnpm check` runs `cargo check` on the crate with the edited config, `pnpm build` runs `vue-tsc` and the Vite build, `pnpm test` runs the Vitest suite, `tauri.conf.json` is validated against the `$schema` URL it already declares with a JSON Schema validator, and the workflow is checked with `actionlint`. The pull request says exactly which of signing, notarization and stapling remain to be seen on the first tagged build on a macOS runner.

## Start it with one API call

`POST https://api.phoenix.so/o/{org}/sessions`

```json
{
  "agent": "claude",
  "input": "Add macOS code signing and notarization to this Tauri 2 app's release workflow. Read .github/workflows/release.yml and the other workflows, src-tauri/tauri.conf.json, src-tauri/Cargo.toml, package.json, bump-version.cjs and the README first, and note any version mismatch between the three version files. On the macOS matrix entry, pass the Apple certificate, certificate password, signing identity, Apple ID, app-specific password and team ID to tauri-action from repository secrets of the same names, and add a step before it that fails clearly when the certificate secret is missing. Add a bundle.macOS block to tauri.conf.json with a minimum system version and an entitlements file, and write that file with only what this app needs. Remove the unsigned-build note from the release body. Fix the version drift and make the bump script read each file's own version. Do not change the platform matrix. Run cargo check through the pnpm script, the build, and the tests, validate tauri.conf.json against its declared schema and the workflow with actionlint, and open a pull request that lists the secrets to create and says plainly that signing itself can only be verified on the first macOS build.",
  "resources": [
    {
      "url": "https://github.com/your-org/your-app"
    }
  ]
}
```

1. **Get an API key.** In the console, open Settings, then API keys, and create a key for your org. Send it in the Authorization header as a Bearer token.
2. **Send the request.** POST the body in request.json to https://api.phoenix.so/o/{org}/sessions, with your repository as the resources URL. The run starts in its own cloud sandbox.
3. **Read what came back.** Follow the run on its live stream or wait for the run.completed webhook, then read the result and its trajectory.

## What comes back

What comes back is a pull request that edits `.github/workflows/release.yml`, `src-tauri/tauri.conf.json`, `src-tauri/Cargo.toml` and `bump-version.cjs`, and adds `src-tauri/Entitlements.plist`. The description has a table of the six secrets with where each comes from (the exported `.p12` as base64, the identity string from the certificate, the app-specific password from the Apple ID page, the team ID from the developer account), and a one-line explanation of why the entitlements file is nearly empty.

The run's record keeps `cargo check`, the `vue-tsc` and Vite output, the Vitest result, the schema validation of the config and the `actionlint` run, so a reviewer knows the edited config still parses and the workflow is well formed before any tag is pushed.

Before merging, a reviewer creates the six secrets in the repository settings, merges, and pushes a tag. The macOS job's log shows `tauri-action` signing the bundle, submitting it for notarization and stapling the ticket, and a downloaded `.dmg` opens without the Gatekeeper warning. That first tagged build is the real test, and the pull request says so.

## Run it on every Linear issue labelled release

A team that plans release work in Linear adds an automation with a `linear` trigger on `linear.issue.labeled` for the label `release`, the Project that has this repository, and this prompt. Labelling the issue that asks for signed macOS builds starts one run with the issue's text added after the prompt, and the pull request links back to the issue.

The trigger fills in no placeholder, so the same automation serves the next release issue, such as Windows signing with a certificate from a hardware token or the Intel macOS target, as long as the issue says what should change.

## Why run it on Rush?

Signing is the part of a release pipeline nobody wants to debug on a Friday: six secrets with exact names, a config block the schema must accept, and a workflow that has to fail loudly rather than quietly ship an unsigned build. The agent reads the real workflow and config in its own sandbox, makes the edits together, and runs every check that does not need a Mac, with the output kept.

The pull request draws the line between what was verified and what the first macOS build will show, which is the honest shape for a change whose last step runs only on Apple hardware with Apple credentials.

## Frequently asked questions

### Which secrets do I need to create?

`APPLE_CERTIFICATE` (the Developer ID Application certificate exported as a `.p12` and base64-encoded), `APPLE_CERTIFICATE_PASSWORD`, `APPLE_SIGNING_IDENTITY`, `APPLE_ID`, `APPLE_PASSWORD` (an app-specific password) and `APPLE_TEAM_ID`. The pull request's table says where each one comes from.

### What happens if I push a tag before adding the secrets?

The macOS job fails at the guard step with a message naming the missing secret, and no draft release is created from that job. Linux and Windows builds still run. Add the secrets and re-run the workflow by hand or push the tag again.

### Why is the entitlements file almost empty?

The template uses a WebView, a shell plugin and nothing that needs camera, microphone, JIT or network client entitlements beyond what the hardened runtime allows by default. The file exists so the next entitlement has a place to go, and the pull request says which keys to add for common plugins.

### Does the agent verify the signature?

No. The sandbox runs Linux and has no certificate. It verifies that the crate compiles, the frontend builds and tests pass, the config validates against Tauri's schema and the workflow lints. The first tagged build on a macOS runner shows signing, notarization and stapling in its log.

### Why fix the Cargo.toml version in this pull request?

The release tag is built from the app version, and a crate that says 2.10.0 while the config says 2.10.3 ships a bundle whose Info.plist and binary disagree. The bump script now reads each file's own version, so the three stay together from here on.

## More Tauri jobs

- [Add a Native Menu to a Tauri App](https://getrush.ai/run/add-native-menu/tauri/)
- [Add Native Notifications to a Tauri App](https://getrush.ai/run/add-notifications/tauri/)
- [Persist User Settings in a Tauri App](https://getrush.ai/run/add-persistent-settings/tauri/)

## More jobs like this: Turn a Linear label into a PR

- [Add a Man Page to a Go CLI](https://getrush.ai/run/add-man-page/go-cli/)
- [Add a Message Shortcut to a Slack Bolt App](https://getrush.ai/run/add-message-shortcuts/slack-bolt/)
- [Add Lock Timeouts to Alembic Migrations on PostgreSQL](https://getrush.ai/run/add-migration-lock-timeouts/alembic/)

## Keep reading

- [How a Rush run works on your repository, from request to pull request](https://getrush.ai/cloud/)
- [Compare cloud agents, agent sandboxes and AI code review](https://getrush.ai/compare/)
- [Rush pricing: Free, Pro and Max](https://getrush.ai/pricing/)
