# Add an Auto-Updater to a Tauri App

Yes. An agent adds the Tauri updater plugin, a signing key workflow, an update check on launch and updater artifacts to your release, then opens a PR.

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

## What the agent does

The agent clones the app into its own cloud sandbox and reads the Tauri side before the Vue side. In an app like Uninen/tauri-vue-template, `src-tauri/tauri.conf.json` names the product `tauri-app` at version `2.10.3` with identifier `com.tauri-app.my`, one `800` by `600` window, a content security policy that limits `connect-src` to `ipc:` and `http://ipc.localhost`, and a `bundle` block with `active: true` and `targets: "all"`. `src-tauri/Cargo.toml` depends on `tauri` 2, `tauri-plugin-shell` 2 and `tauri-plugin-prevent-default` 5.0, with a release profile that sets `opt-level = "s"`, `lto`, `strip` and `panic = "abort"`. `src-tauri/src/lib.rs` registers the shell and prevent-default plugins, opens devtools in debug builds and exposes one `greet` command. There is no `src-tauri/capabilities/` directory, no updater plugin and no update endpoint anywhere.

It then reads how releases are made. `package.json` runs on pnpm 10 with `@tauri-apps/api` and `@tauri-apps/cli` at `^2.10.1`, a `build` script of `vue-tsc --noEmit && vite build`, `test` on vitest and a `bump` script, `bump-version.cjs`, that rewrites the version in `package.json`, `tauri.conf.json` and `Cargo.toml` together. `.github/workflows/release.yml` runs on `v*.*.*` tags across `macos-latest` for `aarch64-apple-darwin`, `ubuntu-24.04` and `windows-latest`, and calls `tauri-apps/tauri-action@action-v0.5.20` with `releaseDraft: true` and a release body that warns macOS builds are unsigned and need `xattr -c` to open. `test-build.yml` builds on Ubuntu after installing `libwebkit2gtk-4.1-dev`, `libappindicator3-dev`, `librsvg2-dev` and `patchelf`; `.github/renovate.json` automerges Cargo, npm and action updates on a schedule.

The change touches four places. In `Cargo.toml` and `package.json` it adds `tauri-plugin-updater` and `tauri-plugin-process` with their JavaScript packages; in `lib.rs` it registers both plugins; in `tauri.conf.json` it adds a `plugins.updater` block with the public key and one endpoint, the `latest.json` asset of the repository's latest GitHub release, and sets `bundle.createUpdaterArtifacts` to `true` so `tauri build` emits a signature beside each installer. It creates `src-tauri/capabilities/default.json` granting `core:default`, `updater:default` and `process:default` to the main window, since the template has no capability file and the webview cannot call the plugin without one. On the Vue side it adds an `updates.ts` module called from `store.ts` during `initApp` that runs `check()`, and when an update exists, `downloadAndInstall()` followed by `relaunch()`, with a confirmation step before the download rather than a silent restart.

The signing key is the part a template cannot ship. The agent runs `pnpm tauri signer generate` in the sandbox with a throwaway password, puts the public key in `tauri.conf.json`, and documents in the pull request that the private key and password belong in the `TAURI_SIGNING_PRIVATE_KEY` and `TAURI_SIGNING_PRIVATE_KEY_PASSWORD` repository secrets, which `release.yml` now passes to `tauri-action` along with `includeUpdaterJson: true` so the action writes `latest.json` into the release. Because `releaseDraft` is `true`, the endpoint only answers once a maintainer publishes the draft, which the pull request states as the release step. To prove the build, the agent installs the four Ubuntu packages the workflow lists, runs `pnpm install`, `pnpm check` for `cargo check`, `pnpm build` for `vue-tsc` and `pnpm test`, then `pnpm tauri build` with the throwaway key in the environment and shows the `.sig` files appearing next to the Linux bundles.

## Start it with one API call

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

```json
{
  "agent": "claude",
  "input": "Add an auto-updater to this Tauri 2 app. Read src-tauri/tauri.conf.json, src-tauri/Cargo.toml, src-tauri/src/lib.rs, package.json, src/store.ts and every workflow under .github/workflows first. Add tauri-plugin-updater and tauri-plugin-process on the Rust and JavaScript sides and register them in lib.rs. Add a plugins.updater block with a public key and a single endpoint pointing at the latest.json asset of the repository's latest GitHub release, and set bundle.createUpdaterArtifacts to true. Add a capabilities file for the main window that grants the core, updater and process defaults. On launch, check for an update, ask the user before downloading, then install and relaunch. Generate a throwaway signing key in the sandbox for the build only; put the public key in the config and document the private key and password secrets the release workflow needs, and pass them and includeUpdaterJson to tauri-action. Install the Linux build dependencies the workflow lists, run the type check, unit tests, cargo check and a tauri build, and open a pull request that shows the signature files beside the bundles.",
  "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 `Cargo.toml`, `Cargo.lock`, `package.json`, `pnpm-lock.yaml`, `tauri.conf.json`, `lib.rs`, `store.ts` and `release.yml`, and adds `src-tauri/capabilities/default.json` and `src/updates.ts`. The description names the two secrets the workflow needs, the endpoint the app will poll, and the fact that the draft release must be published before the endpoint answers.

The run's record keeps the key generation, the dependency install, `cargo check`, `vue-tsc`, the vitest run and the `tauri build` output listing the `.sig` files, so a reviewer can see the plugin compiles against the pinned Tauri version and the updater artifacts are produced without trusting a sentence that says so. The throwaway private key is never committed and is not the key releases will use.

Before merging, a reviewer generates the real key pair on a machine they control, stores the private key and password as repository secrets, replaces the public key in `tauri.conf.json`, and decides whether macOS builds should be signed and notarised first, since the release body already warns they are not.

## Run it on every Linear issue labelled release

Desktop apps accumulate release chores: an updater, code signing, a changelog, a bump script. An automation with a `linear` trigger on `linear.issue.labeled` and the label `release` starts one run per labelled issue, with the issue after the prompt, so the issue that says to add the updater and the later one that says to notarise macOS builds each get a run in the same repository with its own pull request linking back.

A run whose `cargo check` or `tauri build` fails ends `needs_review` with the compiler output in its trajectory instead of opening a pull request that cannot build, and the next comment on the issue is the fix, not a request to reproduce it.

## Why run it on Rush?

An updater is a cross-cutting change: a Rust dependency, a JavaScript dependency, a capability, a config block, a UI prompt, a signing key and a workflow input, and a mistake in any one of them shows up only when a real release tries to update a real install. The agent makes all seven in one pass in its own sandbox, with the Linux build dependencies installed and a throwaway key in the environment, and proves the pieces fit with a build whose artifact list is in the record.

An organisation that maintains several Tauri apps sends the same request to each and gets one pull request per app, each wired to that app's own identifier, workflow and release settings, with the same two secrets to add. The apps that already have a capability file get a smaller diff; the ones built from a template that has none get it created.

## Frequently asked questions

### Does the agent create my signing key?

It generates a throwaway pair in the sandbox so the build can produce signature files, and that private key is never committed or reused. The pull request tells you to generate the real pair yourself, store the private key and its password as the two repository secrets it names, and replace the public key in `tauri.conf.json` before the first signed release.

### Why does the app need a capabilities file?

In Tauri 2 the webview can only call plugin commands a capability grants it. This template has no `src-tauri/capabilities/` directory, so the agent adds one that grants the core, updater and process defaults to the main window; without it the update check fails at runtime with a permission error.

### Will updates work while releases are drafts?

No. `release.yml` sets `releaseDraft: true`, so `latest.json` is attached to a draft that the public endpoint does not serve until a maintainer publishes it. The agent keeps that setting and states the publish step in the pull request rather than changing your release policy.

### Does it restart the app without asking?

No. The launch check calls `check()`, and only after the user confirms does it call `downloadAndInstall()` and then `relaunch()`. A silent restart would discard unsaved work, so the confirmation is in the diff and easy to replace with your own dialog.

### Can the agent test the update itself?

Not end to end: that needs two published releases and an installed copy of the older one. The agent proves the plugin compiles, the capability is valid, the frontend type-checks and `tauri build` writes a signature next to each Linux bundle, and leaves the first real update to the reviewer's test release.

## More Tauri jobs

- [Add Launch at Login to a Tauri App](https://getrush.ai/run/add-autostart/tauri/)
- [Add Crash Reporting to a Tauri App](https://getrush.ai/run/add-crash-reporting/tauri/)
- [Add Dark Mode to a Tauri App](https://getrush.ai/run/add-dark-mode/tauri/)

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

- [Add Automatic Tax to a Stripe Checkout Subscription](https://getrush.ai/run/add-automatic-tax/stripe/)
- [Add AutoThrottle to a Scrapy Project](https://getrush.ai/run/add-autothrottle/scrapy/)
- [Add Background Jobs to a Litestar App](https://getrush.ai/run/add-background-jobs/litestar/)

## 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/)
