@xid-kit/tauri

Tauri-v2-Desktop-SDK mit PKCE-S256-Flow, Deeplink-Callback-Handler,OS-Keychain-Adapter und Rust-Plugin-Vorlage.

Zustand

Paketstatus: Aktuelles Paket. JS-Bridge, PKCE-S256-Flow,Deeplink-Callback-Handler, OS-Keychain-Adapter und Rust-Plugin-Vorlagesind implementiert. Ein echter IdP-Round-Trip auf Produktionsinfrastruktursteht noch manuell aus.

Tauri-Konfiguration

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

Rust-Plugin

Kopieren Sie templates/xid-keychain-plugin.rs nach src-tauri/src/xid_keychain.rs und registrieren Sie es gemäß templates/tauri-app-setup.rs. Fügen Sie keyring = "2", tauri-plugin-deep-link = "2" und tauri-plugin-shell = "2" zu src-tauri/Cargo.toml hinzu.

JS-Integration

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 })

Token-Abruf und Abmeldung

// 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())

Entwicklung/Test ohne Tauri-Runtime

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

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

createXidTauriClient-Optionen

Option	Typ	Beschreibung
`issuer`	string	XID-Issuer-URL
`clientId`	string	OAuth-2.0-client_id
`redirectUri`	string	Callback für benutzerdefiniertes URI-Schema
`scopes`	readonly string[]	Standard: openid, profile, email
`keychain`	XidKeychainAdapter	Token-Speicher-Adapter; Standard ist MemoryKeychainAdapter (in ProduktionTauri-Adapter verwenden)

XidTauriClient-Methoden

Methode	Beschreibung
`signIn(options?)`	PKCE-Autorisierungs-URL erstellen; über openUrl-Callback öffnen
`handleRedirect(url)`	Deeplink parsen, State validieren, Code gegen Tokens eintauschen
`getSession()`	TauriSession oder null; erneuert Token, wenn Ablauf bevorsteht
`getAccessToken(options?)`	Access-Token-String oder null; wird erneuert, wenn Ablauf bevorsteht
`signOut()`	Server-Sitzung widerrufen und Keychain leeren
`buildSignOutUrl(options?)`	OIDC-end_session-URL für den RP-initiierten Logout erstellen
`setTokenStorage(adapter)`	Keychain-Adapter zur Laufzeit tauschen

PKCE und Token-Speicherung

PKCE S256 wird immer verwendet. Plain Challenge wird nie generiert.
Verifier-Entropie beträgt 64 Bytes; Challenge wird über Web Cryptocrypto.subtle.digest('SHA-256', ...) abgeleitet.
Alle Schlüssel sind unter xid.* eingeordnet:xid.access_token, xid.refresh_token, xid.session,xid.pkce_verifier, xid.oauth_state.