@xid-kit/tauri

SDK bureau Tauri v2 avec flux PKCE S256, gestionnaire de callbackdeeplink, adaptateur de trousseau OS et modèle de plugin Rust.

Statut

Le statut du package est Package actuel. Le pont JS, le flux PKCES256, le gestionnaire de callback deeplink, l’adaptateur de trousseau OSet le modèle de plugin Rust sont implémentés. Un aller-retour réel avec unIdP sur une infrastructure de production est en attente de vérificationmanuelle.

Configuration Tauri

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

Plugin Rust

Copiez templates/xid-keychain-plugin.rs dans src-tauri/src/xid_keychain.rs et enregistrez-le en suivant templates/tauri-app-setup.rs. Ajoutez keyring = "2", tauri-plugin-deep-link = "2" et tauri-plugin-shell = "2" dans src-tauri/Cargo.toml.

Intégration JS

import { createXidTauriClient, createTauriKeychainAdapter } from '@xid-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 = createXidTauriClient({
  issuer: 'https://xid.dev',
  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 })

Récupération du jeton et déconnexion

// Get current access token (refreshes transparently if near expiry)
const token = await client.getAccessToken()

// Get full session (userId, organizationId, expiresAt)
const session = await client.getSession()

// Revoke server session and clear all keychain entries
await client.signOut()

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

Développement/test sans runtime Tauri

import { createXidTauriClient, createMemoryKeychainAdapter } from '@xid-kit/tauri'

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

Options de createXidTauriClient

Option	Type	Description
`issuer`	chaîne	URL d’émetteur XID
`clientId`	chaîne	client_id OAuth 2.0
`redirectUri`	chaîne	Callback de schéma URI personnalisé
`scopes`	readonly string[]	Par défaut : openid, profile, email
`keychain`	XidKeychainAdapter	Adaptateur de stockage des jetons ; par défaut MemoryKeychainAdapter(utiliser l’adaptateur Tauri en production)

Méthodes XidTauriClient

Méthode	Description
`signIn(options?)`	Construire l’URL d’autorisation PKCE ; ouvrir via le callback openUrl
`handleRedirect(url)`	Analyser le deeplink, valider l’état, échanger le code contre des jetons
`getSession()`	TauriSession ou null ; rafraîchit le jeton si proche de l’expiration
`getAccessToken(options?)`	Chaîne de jeton d’accès ou null ; se rafraîchit si proche de l’expiration
`signOut()`	Révoquer la session serveur et vider le trousseau
`buildSignOutUrl(options?)`	Construire l’URL end_session OIDC pour la déconnexion initiée par le RP
`setTokenStorage(adapter)`	Remplacer l’adaptateur de trousseau à l’exécution

PKCE et stockage des jetons

PKCE S256 est toujours utilisé. Le challenge plain n’est jamais généré.
L’entropie du vérificateur est de 64 octets ; le challenge est dérivé viaWeb Crypto crypto.subtle.digest('SHA-256', ...).
Toutes les clés sont sous l’espace de nommage xid.* :xid.access_token, xid.refresh_token, xid.session,xid.pkce_verifier, xid.oauth_state.