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 with this body:
{
"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"
}
]
}- 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.
- 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.
- 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.
The use case this job follows, with its automation and trigger: Turn a Linear label into a PR.
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.