All jobs

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 RushOpens 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 with this body:

{
  "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.

The use case this job follows, with its automation and trigger: Turn a Linear label into a PR.

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

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

Keep reading