More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Tauri 2 Release Readiness: Audit, Sign, Update, Ship

    1

    Pre-release audit and guided release for Tauri 2 desktop apps.

    $9

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Tauri 2 Release Readiness: Audit, Sign, Update, Ship

    Tauri 2 Release Readiness: Audit, Sign, Update, Ship

    Example session with this skill installed

    I want to release notepile to the public on Windows and macOS, with automatic updates. Get it ready to ship.

    • Read your context and instructions
    • Compiled the tauri 2 release
    • Generated the app files

    (Run on a small sample Tauri 2 note app. Excerpt - the full report had 17 findings.)

    Release profile: Public release on Windows and macOS with signed automatic updates - Windows code signing, Apple Developer ID plus notarization (both paid, yearly), installers built in CI per OS.

    BLOCKERS - fix before any release

    1. Two commands read and write any path they are given - src-tauri/src/lib.rs:4-5 and :9-10
      read_note and save_note pass the path from the frontend straight to fs::read_to_string / fs::write. The path is free text typed into an input (src/App.tsx:20).
      Why it matters: your own commands are not limited by the fs scope in the capabilities file, so the webview can read or overwrite any file your user account can touch.
      Fix: keep notes in one folder, reject paths outside it, and return Result<_, String> instead of unwrap().

    2. The summary API key is built into the app - src/config.ts:3 (used at src/App.tsx:13)
      Why it matters: anything in the installer can be extracted by any user. A public release means a public key and a bill you do not control.
      Fix: your choice - (a) a small server of yours holds the key, or (b) each user enters their own key.

    3. Three different version numbers - package.json:4 (0.3.0), src-tauri/tauri.conf.json:4 (0.2.1), src-tauri/Cargo.toml:4 (0.1.0)
      Why it matters: the installer and the updater use the tauri.conf.json value. A wrong version means an update that is never offered, or offered forever.

    4. The identifier ends in ".app" and nothing records it as final - src-tauri/tauri.conf.json:5 ("com.notepile.app")
      Why it matters: ".app" collides with the macOS bundle extension. After the first public release the identifier cannot change without moving the app data folder and breaking updates for installed copies.
      Fix: needs your explicit yes. If no copy has gone to anyone yet, change it now. If copies are already out, keep it and I record the reason. Which is it?

    SHOULD FIX

    1. Permissions wider than the features - src-tauri/capabilities/default.json:9-29

      Permission (line)Code that uses it
      core:default (9)invoke() - src/App.tsx:8-9
      fs:default (10)-
      fs:allow-read-text-file, $HOME/** (12-17)-
      fs:allow-write-text-file, $HOME/** (20-25)-
      shell:allow-execute (27)-
      shell:allow-open (28)-
      notification:default (29)- (plugin not installed)

      Six grants with no feature behind them, including the whole home folder for read and write.
      Fix: remove lines 10-29 and both plugins.

    2. Developer tools enabled in release builds - src-tauri/Cargo.toml:14 (features = ["devtools"])

    NOT CHECKED

    • git history search for secrets and key files: the folder is not a git repository.
    • Whether notepile has already been released to anyone: only you know; it decides finding 6.
    • Clean-machine install, update and uninstall: on your machines.

    Nothing has been changed. Next I would fix in groups, waiting for your yes on each: identity and version, permissions and security, bundle, then signing and updater.

    App.tsx

    ZIP · project files

    Generated

    Example file from a real run - the skill writes it into your workspace.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    What it does

    Your Tauri 2 app runs in development. This skill gets it out the door without the mistakes that cannot be undone later.

    It reads your project, reports what would hurt you after release - with file and line - fixes what you approve, and then walks you through signing, updater setup, the build and a clean-machine install test.

    What makes it different

    • It audits your project, it does not explain Tauri. Most Tauri skills teach the framework or write architecture documents. This one opens your tauri.conf.json, capabilities and Rust commands and reports what is wrong, with file and line.
    • Irreversible mistakes first. An identifier changed after release cuts users off from their data and updates. A lost updater key ends updates for every installed copy. These are checked before anything else and never changed without a separate yes.
    • Permissions matched to code. You get a table: each capability on the left, the code that needs it on the right. An empty right-hand cell is a permission to remove.
    • Sized to your audience. A tool for yourself, an app for a few friends and a public release need different things. Three questions set the profile, so you are not pushed into paid signing you do not need.
    • Your keys stay yours. It never creates, reads or prints signing keys or passwords. You run those commands; it checks the result.
    • Ends with a real install test. Install, first run, update and uninstall on a clean machine, including the detail most people miss: download the installer through a browser, because a copied file skips the OS checks your users will hit.

    Use it when

    • You are about to release a Tauri 2 app for the first time
    • You want auto-update and do not want to lose the signing key
    • You are not sure whether you need code signing, or what users see without it
    • Your capabilities file grew during development and nobody has reviewed it
    • You want an install, update and uninstall test you can actually follow

    What it checks

    • Identity and version - identifier still a placeholder, identifier that will break macOS bundles, version declared differently in three files
    • Permissions and security - every capability matched to the code that uses it, unscoped file access, shell access, commands that read or write any path, missing CSP, API keys inside the app
    • Bundle - targets, WebView2 install mode, install scope, metadata, resources that exist in dev and vanish in the installer
    • Data - where it is written, numbered migrations, what happens on uninstall
    • Signing - Windows certificate or cloud signing, timestamp server, macOS Developer ID and notarization, no key files in the repository
    • Updater - plugin wiring, updater artifacts, public key, HTTPS endpoints, permissions, update experience, key backup
    • Repository and CI - secret-shaped strings, ignore rules, per-OS builds

    How it works

    1. Confirms the project is Tauri 2.
    2. Asks three questions: who uses the app, which OS, how updates arrive. The answers set a release profile - only me, a few people, or the public - so a personal tool is not pushed through a public-release process.
    3. Audits and reports: blockers, should-fix, OK, not checked.
    4. Fixes one group at a time, each after your approval.
    5. Guides signing and updater setup with the commands in order.
    6. Builds and lists the produced files.
    7. Gives you a clean-machine test checklist and records the result.
    8. Writes a release record into your project.

    What you get

    • An audit report where every finding names a file and line
    • Approved fixes applied to your config and code
    • Step-by-step signing and updater commands with placeholders for secrets
    • A clean-machine checklist for install, first run, update and uninstall
    • docs/release.md with the identifier, signing and updater setup, and per-version test results

    Where it stops

    • You create keys, buy certificates, run signing and publish. The skill never creates, reads or prints signing keys or passwords.
    • It does not commit, tag, push or publish unless you ask.
    • Tauri 2 desktop only - no Tauri 1, no mobile, no Microsoft Store or Mac App Store submission.
    • It does not write your app. It reviews and releases one that already runs.

    What is in the package

    Instructions only. No scripts, no network calls, no environment variables read.

    • SKILL.md - the eight-step flow
    • references/audit-checklist.md - about fifty checks with where to look and what counts as a problem
    • references/signing.md - Windows and macOS signing, notarization, what unsigned users see
    • references/updater.md - keys, config, update manifest, release order
    • references/clean-install-test.md - the install, first run, update and uninstall test
    • templates/release-record.md - the release record

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Frontend & Web Apps.

    • Tauri 2 desktop apps only. No Tauri 1, no mobile targets, no Microsoft Store or Mac App Store submission.
    • Reviews and releases an app that already runs. It does not build features.
    • Cannot buy certificates, hold keys, or test on machines it has no access to. You run signing, notarization, publishing and the clean-machine test.
    • A correctly signed new Windows app can still show a SmartScreen reputation notice for a while. The skill says so instead of promising it away.
    • Tauri option names change between minor versions. The skill checks findings against your installed version and the official docs, but confirm before a release that matters.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before buying a skill.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 4 days ago

    Software
    Tauri 2 projectNode.js with the Tauri CLIRust toolchain
    Optional
    git (history checks)GitHub Actions (per-OS release builds)Apple Developer account (macOS signing and notarization)
    Windows code signing certificate
    orcloud signing service

    Windows installers are built on Windows and macOS bundles on macOS. You run key generation, signing, notarization and publishing yourself; the skill gives the commands and checks the result.

    Permissions

    Terminal / Shell
    Read Files
    Write Files

    File Scopes

    src-tauri/**
    src/**
    package.json
    .gitignore
    .github/workflows/**
    docs/release.md

    Reads the Tauri project to audit it. Writes only fixes you approve, plus docs/release.md. Runs the project's own check and build commands. No network calls of its own, and it never reads signing keys, certificates or environment variables.

    Listed4 days ago

    What's inside

    Frequently Asked Questions

    Only after you approve. Findings come first as a report. Fixes are proposed in groups, and changing the identifier, product name or updater public key always needs a separate yes.

    No. It gives you the commands with placeholders and you run them in your own terminal. Afterwards it checks that the public key is in the config and that no key file is in the repository.

    The first question is who uses the app. For "only me" it skips signing and updates and checks what still matters: identifier, permissions and data location.

    It tells you what the CI must do (build each OS on that OS, secrets from the secret store) and reviews an existing workflow. It can write a GitHub Actions workflow with tauri-action if you ask.

    Any agent connected to Agensi that can read files and run commands in your project, such as Claude Code, Cursor or Codex CLI.

    New in Frontend & Web Apps