Agent skill

Add Tauri Command

A skill your agent uses when the user wants to expose a Rust feature to the Vue frontend, add a Tauri IPC command, invoke something from a Vue component, or wire up any backend/frontend…

MITAuto-check passedDevelopment

Install Add Tauri Command

skills CLI

$ npx skills add devlint/GitWand --skill add-tauri-command -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI

$ gh skill install devlint/GitWand add-tauri-command --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy

$ git clone --depth 1 https://github.com/devlint/GitWand.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.claude/skills/add-tauri-command .claude/skills/add-tauri-command && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Paste into Claude Code

Install the "add-tauri-command" agent skill from https://github.com/devlint/GitWand/tree/main/.claude/skills/add-tauri-command into .claude/skills/add-tauri-command/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "add-tauri-command", then confirm the skill loads.

Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

$skill-installer

$skill-installer install https://github.com/devlint/GitWand/tree/main/.claude/skills/add-tauri-command

Type this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.

skills CLI

$ npx skills add devlint/GitWand --skill add-tauri-command -a codex

Project install goes to .agents/skills/; add -g for ~/.codex/skills/.

GitHub CLI

$ gh skill install devlint/GitWand add-tauri-command --agent codex

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/devlint/GitWand.git skills-src && mkdir -p .agents/skills && cp -r skills-src/.claude/skills/add-tauri-command .agents/skills/add-tauri-command && rm -rf skills-src

Use ~/.agents/skills/ instead of .agents/skills for a personal install.

Codex skills documentation · loads skills from .agents/skills/

Paste into Codex

Install the "add-tauri-command" agent skill from https://github.com/devlint/GitWand/tree/main/.claude/skills/add-tauri-command into .agents/skills/add-tauri-command/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "add-tauri-command", then confirm the skill loads.

Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

skills CLI

$ npx skills add devlint/GitWand --skill add-tauri-command -a cursor

Project install goes to .agents/skills/; add -g for ~/.cursor/skills/.

GitHub CLI

$ gh skill install devlint/GitWand add-tauri-command --agent cursor

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/devlint/GitWand.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/.claude/skills/add-tauri-command .cursor/skills/add-tauri-command && rm -rf skills-src

Use ~/.cursor/skills/ instead of .cursor/skills for a personal install.

Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/

Paste into Cursor

Install the "add-tauri-command" agent skill from https://github.com/devlint/GitWand/tree/main/.claude/skills/add-tauri-command into .cursor/skills/add-tauri-command/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "add-tauri-command", then confirm the skill loads.

Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

gemini skills install

$ gemini skills install https://github.com/devlint/GitWand.git --path .claude/skills/add-tauri-command

--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.

skills CLI

$ npx skills add devlint/GitWand --skill add-tauri-command -a gemini-cli

Project install goes to .agents/skills/; add -g for ~/.gemini/skills/.

GitHub CLI

$ gh skill install devlint/GitWand add-tauri-command --agent gemini-cli

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/devlint/GitWand.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/.claude/skills/add-tauri-command .gemini/skills/add-tauri-command && rm -rf skills-src

Use ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.

Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/

Paste into Gemini CLI

Install the "add-tauri-command" agent skill from https://github.com/devlint/GitWand/tree/main/.claude/skills/add-tauri-command into .gemini/skills/add-tauri-command/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "add-tauri-command", then confirm the skill loads.

Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

GitHub CLI

$ gh skill install devlint/GitWand add-tauri-command

Installs for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).

skills CLI

$ npx skills add devlint/GitWand --skill add-tauri-command -a github-copilot

Project install goes to .agents/skills/; add -g for ~/.copilot/skills/.

Manual copy

$ git clone --depth 1 https://github.com/devlint/GitWand.git skills-src && mkdir -p .github/skills && cp -r skills-src/.claude/skills/add-tauri-command .github/skills/add-tauri-command && rm -rf skills-src

Use ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.

GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/

Paste into GitHub Copilot

Install the "add-tauri-command" agent skill from https://github.com/devlint/GitWand/tree/main/.claude/skills/add-tauri-command into .github/skills/add-tauri-command/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "add-tauri-command", then confirm the skill loads.

GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

skills CLI

$ npx skills add devlint/GitWand --skill add-tauri-command -a opencode

OpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.

GitHub CLI

$ gh skill install devlint/GitWand add-tauri-command --agent opencode

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/devlint/GitWand.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/.claude/skills/add-tauri-command .opencode/skills/add-tauri-command && rm -rf skills-src

Use ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.

OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/

Paste into OpenCode

Install the "add-tauri-command" agent skill from https://github.com/devlint/GitWand/tree/main/.claude/skills/add-tauri-command into .opencode/skills/add-tauri-command/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "add-tauri-command", then confirm the skill loads.

OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

Facts

Skill name: add-tauri-command
GitHub stars: 180
Token cost: ~1.5k tokens
SKILL.md length: 396 words
Files: 1
Skills in repo: 5
Repo updated: Oct 7, 2026
First seen: Oct 7, 2026
Licence: MIT

At a glance

A skill your agent uses when the user wants to expose a Rust feature to the Vue frontend, add a Tauri IPC command, invoke something from a Vue component, or wire up any backend/frontend…

Works in 2 steps: Ouvrir… → Ajouter la permission minimale…
The user wants to expose a Rust feature to the Vue frontend
SKILL.md covers Étape 1 — Spécifier la commande, Étape 2 — Implémenter en Rust…, Étape 3 — Enregistrer dans… and Étape 4 — Ajouter le wrapper…, plus 3 more sections
Calls pnpm and cargo

What it does

Add Tauri Command is an agent skill from devlint/GitWand. Use this skill when the user wants to expose a Rust feature to the Vue frontend, add a Tauri IPC command, invoke something from a Vue component, or wire up any backend/frontend communication via Tauri's invoke bridge.

Its SKILL.md is about 1.5k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Development, covering Git workflow. It works with Tauri, Rust, Vue.js and Git. The repository describes itself as: The Git client that actually resolves conflicts: 8 deterministic patterns auto-resolve the ones that were never decisions, full trace on the rest. Native (Tauri 2 + Rust), free… The licence is MIT.

When your agent uses it

The user wants to expose a Rust feature to the Vue frontend
Add a Tauri IPC command
Invoke something from a Vue component
Wire up any backend/frontend communication via Tauris invoke bridge

Example prompts

“/add-tauri-command”

Workflow steps

2 steps, taken from the first numbered list in SKILL.md.

Ouvrir apps/desktop/src-tauri/capabilities/default.json
Ajouter la permission minimale nécessaire — exemple pour un process externe

What it can do on your machine

Read from SKILL.md and the folder at commit 20114ac. It shows what the files ask for, not the result of running them.

Tool permissions
Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.
From allowed-tools in the SKILL.md frontmatter.
Runs code
Shell commands in SKILL.md call:
- pnpm
- cargo
From the folder's file list and the shell code blocks in SKILL.md.
Network
No URLs in SKILL.md. Its commands use pnpm, which can reach the network depending on how they are called.
From URLs in SKILL.md, links to its own repository left out.
Credentials
Names no API keys, tokens, secrets or passwords.
From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Add Tauri Command loads about 1.5k tokens when it runs. Until then it costs about 59 tokens; SKILL.md has 396 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it: ~59
When it runs · the whole SKILL.md, loaded when a task matches: ~1.5k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from devlint/GitWand at commit 20114ac, republished under its MIT licence (© devlint). 396 words, ~1,492 tokens.

Download SKILL.mdSave it as .claude/skills/add-tauri-command/SKILL.md (or your agent's skills folder).

name: add-tauri-command
description: Use this skill when the user wants to expose a Rust feature to the Vue frontend, add a Tauri IPC command, invoke something from a Vue component, or wire up any backend/frontend communication via Tauri's invoke bridge.

Skill : add-tauri-command

Ajouter une commande Tauri de bout en bout — Rust + TypeScript dans le même commit, sans trou de sécurité.

Les deux fichiers cibles sont toujours :

apps/desktop/src-tauri/src/lib.rs — implémentation Rust
apps/desktop/src/utils/backend.ts — wrapper TypeScript

Les composants et composables Vue ne doivent jamais appeler invoke() directement. Tout passe par backend.ts.

Étape 1 — Spécifier la commande

Avant d'écrire une ligne de code, répondre à ces questions :

Question	Impact
Nom de la commande ?	snake_case en Rust, camelCase en TS
Paramètres et leurs types ?	Identifier ceux qui sont des chemins → `safe_repo_path` obligatoire
Type de retour ?	Définir / réutiliser une interface TS dans `types.ts`
Spawne-t-elle un process externe ?	Vérifier les capabilities Tauri
Exécute-t-elle `git` ?	Règle `.arg()` obligatoire, jamais `format!()`

Étape 2 — Implémenter en Rust dans lib.rs

Appliquer les règles dans cet ordre exact :

2a. Tout paramètre chemin passe par `safe_repo_path()`

rust

/// Retourne le contenu du fichier de config d'un repo.
#[tauri::command]
fn read_config_file(cwd: String, path: String) -> Result<String, String> {
    // ✅ TOUJOURS : valider le chemin avant tout usage
    let safe = safe_repo_path(&cwd, &path)
        .map_err(|e| e.to_string())?;
    let content = std::fs::read_to_string(&safe)
        .map_err(|e| e.to_string())?;
    Ok(content)
}

rust

// ❌ JAMAIS : path traversal possible
fn read_config_file(cwd: String, path: String) -> Result<String, String> {
    let full = std::path::PathBuf::from(&cwd).join(&path); // "../../../etc/passwd" passe !
    Ok(std::fs::read_to_string(full).map_err(|e| e.to_string())?)
}

2b. Les commandes git utilisent `.arg()` séparé — jamais `format!()`

rust

// ✅ Chaque argument est isolé : pas d'injection possible
let output = Command::new(git_binary())
    .arg("log")
    .arg("--oneline")
    .arg("-n").arg(&limit.to_string())
    .arg("--").arg(&safe_path)
    .current_dir(&cwd)
    .output()
    .map_err(|e| e.to_string())?;

rust

// ❌ JAMAIS : une valeur contrôlée par le frontend dans une chaîne shell
Command::new("sh").arg("-c")
    .arg(format!("git log -- {}", user_path)) // injection garantie

2c. Typer les erreurs et documenter

rust

/// Retourne les N derniers commits du fichier `path` dans le repo `cwd`.
/// Erreur si le chemin sort du repo ou si git échoue.
#[tauri::command]
fn file_log(cwd: String, path: String, limit: u32) -> Result<Vec<String>, String> {
    let safe = safe_repo_path(&cwd, &path).map_err(|e| e.to_string())?;
    // ...
    Ok(lines)
}

Étape 3 — Enregistrer dans generate_handler!

Dans run(), ajouter le nom de la fonction (snake_case) dans .invoke_handler(...) :

rust

.invoke_handler(tauri::generate_handler![
    // commandes existantes…
    get_conflicted_files,
    read_file,
    write_file,
    // ✅ nouvelle commande
    file_log,
])

Oublier cette étape → Tauri retourne command not found à l'exécution, sans erreur de compilation.

Étape 4 — Ajouter le wrapper TypeScript dans backend.ts

Respecter le pattern existant : async function typée, tauriInvoke() en mode Tauri, fallback dev-server en mode browser.

typescript

/**
 * Retourne les N derniers commits du fichier `path` dans le repo `cwd`.
 */
export async function fileLog(
  cwd: string,
  path: string,
  limit: number = 50,
): Promise<string[]> {
  if (isTauri()) {
    return tauriInvoke<string[]>('file_log', { cwd, path, limit })
  }
  const res = await fetch(`${DEV_SERVER}/api/file-log`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ cwd, path, limit }),
  })
  if (!res.ok) throw new Error(`Dev server error: ${res.status}`)
  return res.json()
}

Points de contrôle :

Nom Rust file_log → nom TS fileLog (snake_case ↔ camelCase)
Le nom passé à tauriInvoke() doit être exactement le nom Rust
Si le type de retour est un objet structuré, créer l'interface dans src/types.ts et l'importer ici

Show full SKILL.md (157 more words)Show less

Étape 5 — Vérifier les capabilities

Les commandes git standard n'ont pas besoin de nouvelles capabilities.

Si la commande spawne un process externe (autre que git) ou accède à des fichiers hors du repo :

Ouvrir apps/desktop/src-tauri/capabilities/default.json
Ajouter la permission minimale nécessaire — exemple pour un process externe :

json

{
  "permissions": [
    "shell:allow-execute",
    { "identifier": "shell:allow-spawn", "allow": [{ "name": "gh" }] }
  ]
}

Ne jamais utiliser shell:allow-execute de façon globale (autoriserait n'importe quel binaire). Toujours restreindre au nom exact de l'exécutable.

Étape 6 — Valider

bash

# Compile le frontend et vérifie les types TypeScript
cd apps/desktop && pnpm dev:web

# Vérifie la compilation Rust sans lancer l'app
cd apps/desktop/src-tauri && cargo check

Les deux doivent passer sans erreur avant de commiter. Rust + TypeScript partent dans le même commit — un wrapper TS pointant vers une commande Rust non enregistrée est une bombe à retardement.

Checklist finale

safe_repo_path() appelé pour chaque paramètre chemin
Commande git construite avec .arg() séparé, sans format!() ni shell
Fonction enregistrée dans generate_handler!
Wrapper TS dans backend.ts avec le bon nom snake_case
Interface TS créée dans types.ts si le type de retour est nouveau
Capabilities vérifiées (et mises à jour si process externe)
pnpm dev:web et cargo check passent

Files

Just SKILL.md in .claude/skills/add-tauri-command of devlint/GitWand.

Open the folder on GitHubat commit 20114ac

Compare with similar skills

Add Tauri Command next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Add Tauri Command compared with similar skills
Skill	Stars	Used in	Tokens	Auto-check	Licence	Repo updated
Add Tauri Command this skilldevlint/GitWand	180	—	~1.5k	Automated safety check: Pass	MIT	yesterday
Guarded Git Commit and Pushjerrywu001/cc-sessions-viewer	394	—	~603	Automated safety check: Notes	MIT	yesterday
Markbind Typescript MigrationMarkBind/markbind	158	—	~2k	Automated safety check: Pass	MIT	1 mo ago
Worklog Designregisx001/Worklog	258	—	~3.3k	Automated safety check: Pass	MIT	1 mo ago
Sveltekit Svelte5regisx001/Worklog	258	—	~2.3k	Automated safety check: Pass	MIT	1 mo ago
Git Workflowbkywksj/knowledge-base	330	—	~1.1k	Automated safety check: Pass	Custom licence	5 days ago

Similar skills

Guarded Git Commit and Push
jerrywu001/cc-sessions-viewer
Commits and pushes only on an explicit request, pulling first, running the project's CI checks locally, and stopping cold on any conflict or failure.
394 GitHub stars~603 tokensUpdated yesterday
DevelopmentAuto-check: notes
Markbind Typescript Migration
MarkBind/markbind
Complete guide for migrating JavaScript files to TypeScript in the MarkBind project, including the two-commit strategy, import/export syntax conversion, and best practices.
158 GitHub stars~2k tokensUpdated 1 mo ago
DevelopmentAuto-check passed
Worklog Design
regisx001/Worklog
Design and UI skill for the Worklog desktop project manager.
258 GitHub stars~3.3k tokensUpdated 1 mo ago
Frontend & DesignAuto-check passed
Sveltekit Svelte5
regisx001/Worklog
Build, refactor, and debug features in SvelteKit + Svelte 5 runes.
258 GitHub stars~2.3k tokensUpdated 1 mo ago
DevelopmentAuto-check passed
Git Workflow
bkywksj/knowledge-base
Git 工作流与版本管理技能，规范分支策略、提交信息和发布流程. An agent skill from bkywksj/knowledge-base.
330 GitHub stars~1.1k tokensUpdated 5 days ago
DevelopmentAuto-check passed
Project Init
athola/claude-night-market
Scaffolds new projects with git, CI/CD workflows, pre-commit hooks, and build config.
342 GitHub stars~1.2k tokensUpdated yesterday
DevelopmentAuto-check passed

Questions about Add Tauri Command

What does Add Tauri Command do?

A skill your agent uses when the user wants to expose a Rust feature to the Vue frontend, add a Tauri IPC command, invoke something from a Vue component, or wire up any backend/frontend…. Add Tauri Command is an agent skill from devlint/GitWand. Use this skill when the user wants to expose a Rust feature to the Vue frontend, add a Tauri IPC command, invoke something from a Vue component, or wire up any backend/frontend communication via Tauri's invoke bridge.

When should I use Add Tauri Command?

Add Tauri Command fits situations like: the user wants to expose a Rust feature to the Vue frontend; add a Tauri IPC command; invoke something from a Vue component; wire up any backend/frontend communication via Tauris invoke bridge.

How do I install Add Tauri Command in Claude Code?

Run `npx skills add devlint/GitWand --skill add-tauri-command -a claude-code`. Or copy the skill folder (.claude/skills/add-tauri-command in devlint/GitWand) into .claude/skills/add-tauri-command in your project. Claude Code loads it when a task matches its description.

How do I install Add Tauri Command in Codex?

Run `npx skills add devlint/GitWand --skill add-tauri-command -a codex`. Or copy the skill folder (.claude/skills/add-tauri-command in devlint/GitWand) into .agents/skills/add-tauri-command in your project. Codex loads it when a task matches its description.

Can I use Add Tauri Command in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add devlint/GitWand --skill add-tauri-command -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/add-tauri-command, .gemini/skills/add-tauri-command, .github/skills/add-tauri-command and .opencode/skills/add-tauri-command in your project.

What does Add Tauri Command need to run?

Going by SKILL.md and its folder, Add Tauri Command needs the command-line tools its instructions call (pnpm and cargo).

Does Add Tauri Command access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Add Tauri Command safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Add Tauri Command use?

Add Tauri Command is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Add Tauri Command use?

About 1.5k tokens (SKILL.md is roughly 6k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Add Tauri Command?

Skills that share tags, products or a category with Add Tauri Command: Guarded Git Commit and Push (jerrywu001/cc-sessions-viewer, 394 stars), Markbind Typescript Migration (MarkBind/markbind, 158 stars), Worklog Design (regisx001/Worklog, 258 stars) and Sveltekit Svelte5 (regisx001/Worklog, 258 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Add Tauri Command?

devlint (a GitHub user) maintains it in devlint/GitWand, which has 180 GitHub stars. The repository holds 5 skills in this directory. The repository was last updated on October 7, 2026.

Source: devlint/GitWand on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.

Install Add Tauri Command

Facts

At a glance

What it does

When your agent uses it

Example prompts

Workflow steps

What it can do on your machine

Tool permissions

Runs code

Network

Credentials

Context cost

Safety

SKILL.md

Skill : add-tauri-command

Étape 1 — Spécifier la commande

Étape 2 — Implémenter en Rust dans lib.rs

2a. Tout paramètre chemin passe par safe_repo_path()

2b. Les commandes git utilisent .arg() séparé — jamais format!()

2c. Typer les erreurs et documenter

Étape 3 — Enregistrer dans generate_handler!

Étape 4 — Ajouter le wrapper TypeScript dans backend.ts

Étape 5 — Vérifier les capabilities

Étape 6 — Valider

Checklist finale

Files

Compare with similar skills

Similar skills

More from devlint/GitWand

Related

Questions about Add Tauri Command

2a. Tout paramètre chemin passe par `safe_repo_path()`

2b. Les commandes git utilisent `.arg()` séparé — jamais `format!()`