---
title: "@vonvon-kit/tauri"
description: "SDK desktop Tauri v2 com fluxo PKCE S256, manipulador de callback dedeeplink, adaptador de keychain do SO e template de plugin Rust."
locale: "pt-BR"
---

> Documentation Index
> Fetch the relevant documentation index at: https://vonvon.id/pt-br/sdks/llms.txt
> Use this file to discover all available pages before exploring further.

# @vonvon-kit/tauri

## Estado

Status do registry: UNPUBLISHED. Instale este SDK somente a partir do checkout do código-fonte do repositório; não use um registry de pacotes externo.

O status do pacote é **Pacote atual**. Bridge JS, fluxo PKCE S256,manipulador de callback de deeplink, adaptador de keychain do SO etemplate de plugin Rust estão implementados. Uma ida e volta real como IdP em infraestrutura de produção ainda está pendente deverificação manual.

## Configuração do Tauri

```json
// tauri.conf.json
{
  "bundle": { "identifier": "com.example.myapp" },
  "plugins": {
"deep-link": { "desktop": { "schemes": ["myapp"] } }
  }
}
```

## Plugin Rust

Copie `templates/vonvon-keychain-plugin.rs` para`src-tauri/src/vonvon_keychain.rs` e registre-o seguindo`templates/tauri-app-setup.rs`. Adicione `keyring =\\\"2\\\"`, `tauri-plugin-deep-link = \\\"2\\\"` e`tauri-plugin-shell = \\\"2\\\"` ao `src-tauri/Cargo.toml`.

## Integração JS

```ts
import { createVonvonTauriClient, createTauriKeychainAdapter } from '@vonvon-kit/tauri'
import { invoke } from '@tauri-apps/api/core'
import { open } from '@tauri-apps/plugin-shell'
import { onOpenUrl } from '@tauri-apps/plugin-deep-link'

const client = createVonvonTauriClient({
  issuer: 'https://vonvon.id',
  clientId: 'YOUR_CLIENT_ID',
  redirectUri: 'myapp://auth/callback',
  keychain: createTauriKeychainAdapter({ invoke }),
})

// Register deeplink handler (e.g. on App component mount)
await onOpenUrl(async (urls) => {
  for (const url of urls) await client.handleRedirect(url)
})

// Trigger sign-in: opens system browser
await client.signIn({ openUrl: open })
```

## Obtenção de token e logout

```ts
// Get the current unexpired access token. Expiry requires a new sign-in.
const token = await client.getAccessToken()

// Get the current unexpired session (userId, organizationId, expiresAt).
const session = await client.getSession()

// Clear local keychain state. No refresh or revoke request is sent.
await client.signOut()

// To request full IdP sign-out, open an explicit OIDC RP-initiated logout URL.
const logoutUrl = client.buildSignOutUrl({ postLogoutRedirectUri: 'myapp://logout' })
await open(logoutUrl.toString())
```

## Desenvolvimento/teste sem o runtime do Tauri

```ts
import { createVonvonTauriClient, createMemoryKeychainAdapter } from '@vonvon-kit/tauri'

const client = createVonvonTauriClient({
  issuer: 'http://localhost:8788',
  clientId: 'test-client',
  redirectUri: 'http://localhost:1420/callback',
  keychain: createMemoryKeychainAdapter(),
})
```

## Opções de createVonvonTauriClient

| Opcao | Tipo | Descrição |
| --- | --- | --- |
| `issuer` | string | URL do emissor Vonvon |
| `clientId` | string | client\_id OAuth 2.0 |
| `redirectUri` | string | Callback de esquema de URI personalizado |
| `scopes` | readonly string\[\] | Padrão: openid, profile, email |
| `keychain` | VonvonKeychainAdapter | Adaptador de armazenamento de tokens; padrão é MemoryKeychainAdapter(use o adaptador Tauri em produção) |

## Métodos do VonvonTauriClient

| Método | Descrição |
| --- | --- |
| `signIn(options?)` | Constrói a URL de autorização PKCE; abre via callback openUrl |
| `handleRedirect(url)` | Processa o deeplink, valida o state, troca o código por tokens |
| `getSession()` | TauriSession ou null para uma sessão local atual não expirada; o estado expirado é limpo |
| `getAccessToken(options?)` | String do token de acesso atual não expirado ou null; nenhuma solicitação de renovação é realizada. O SDK rejeita offline\_access até que DPoP seja implementado. |
| `signOut()` | Limpar o estado local do Keychain sem uma solicitação de revogação |
| `buildSignOutUrl(options?)` | Constrói a URL end\_session OIDC para logout iniciado pelo RP |
| `setTokenStorage(adapter)` | Substitui o adaptador de keychain em tempo de execução |

## PKCE e armazenamento de tokens

- PKCE S256 é sempre usado. O desafio plain nunca é gerado.
- A entropia do verificador é 64 bytes; o desafio é derivado via WebCrypto `crypto.subtle.digest('SHA-256', ...)`.
- Todas as chaves usam o namespace `vonvon.*`. `vonvon.access_token` é a atual. `vonvon.refresh_token` é removida apenas para limpar dados legados. `vonvon.session`, `vonvon.pkce_verifier` e `vonvon.oauth_state` contêm o estado atual da sessão e da autorização; nenhuma credencial de renovação é lida ou gravada.

Source: https://vonvon.id/pt-br/sdks/tauri/index.mdx