From fb18afaf6548ae5e3602817af2796fc6818d97aa Mon Sep 17 00:00:00 2001 From: Matthew Kern Date: Mon, 30 Mar 2026 14:10:02 -0700 Subject: [PATCH 01/25] docs: add design spec for 1Password Rust SDK port Port of the Go SDK (v0.4.1-beta.1) to idiomatic Rust with WASM core and desktop app integration support. --- .../2026-03-30-onepassword-sdk-rust-design.md | 317 ++++++++++++++++++ 1 file changed, 317 insertions(+) create mode 100644 docs/superpowers/specs/2026-03-30-onepassword-sdk-rust-design.md diff --git a/docs/superpowers/specs/2026-03-30-onepassword-sdk-rust-design.md b/docs/superpowers/specs/2026-03-30-onepassword-sdk-rust-design.md new file mode 100644 index 0000000..a6ba98b --- /dev/null +++ b/docs/superpowers/specs/2026-03-30-onepassword-sdk-rust-design.md @@ -0,0 +1,317 @@ +# 1Password Rust SDK — Design Spec + +## Overview + +Port of the [1Password Go SDK](https://github.com/1Password/onepassword-sdk-go/tree/v0.4.1-beta.1) to Rust. The SDK is a typed wrapper around an opaque `core.wasm` binary (and optionally a native shared library) that implements the 1Password protocol and cryptographic engine. The Rust SDK provides the same API surface as the Go SDK with idiomatic Rust patterns. + +**Source of truth:** Go SDK at tag `v0.4.1-beta.1`. + +**Conventions:** Follow patterns from the [cordon](https://github.com/codezero-llc/cordon) project — edition 2024, Rust 1.93.1, `thiserror`, `serde`, `cargo-deny`, inline tests, conventional commits. + +## Architecture + +``` +┌─────────────────────────────────────────────┐ +│ User Code │ +│ client.secrets().resolve("op://...") │ +├─────────────────────────────────────────────┤ +│ Public API Layer │ +│ SecretsApi, ItemsApi, VaultsApi, etc. │ +│ Typed Rust structs/enums ↔ JSON serde │ +├─────────────────────────────────────────────┤ +│ Client │ +│ Builder pattern, invoke() dispatcher │ +├─────────────────────────────────────────────┤ +│ Core Trait │ +│ init_client / invoke / release_client │ +├──────────────────┬──────────────────────────┤ +│ ExtismCore │ SharedLibCore │ +│ (WASM, default) │ (desktop feature, FFI) │ +│ include_bytes! │ libloading + dlopen │ +│ Mutex │ platform-specific │ +└──────────────────┴──────────────────────────┘ +``` + +All API methods serialize parameters to JSON, call `Core::invoke()`, and deserialize the response. This matches the Go SDK's `clientInvoke()` pattern exactly. + +## Crate Structure + +Single crate, not a workspace. Matches the Go SDK's single-package approach. + +``` +onepassword-sdk-rust/ + Cargo.toml + deny.toml + rust-toolchain.toml + .gitignore + .github/ + workflows/ + ci.yml + LICENSE + README.md + CLAUDE.md + src/ + lib.rs # Crate root, public re-exports, #![deny(unsafe_code)] + client.rs # Client struct, ClientBuilder + core.rs # Core trait definition + core_extism.rs # ExtismCore — WASM runtime (default) + core_shared_lib.rs # SharedLibCore — native FFI (desktop feature) + core_shared_lib_unix.rs # dlopen path for macOS/Linux + core_shared_lib_win.rs # LoadLibrary path for Windows + errors.rs # SdkError enum (thiserror) + types.rs # All domain types (serde structs/enums) + secrets.rs # SecretsApi trait + implementation + items.rs # ItemsApi trait + implementation + items_files.rs # ItemsFilesApi trait + implementation + items_shares.rs # ItemsSharesApi trait + implementation + vaults.rs # VaultsApi trait + implementation + groups.rs # GroupsApi trait + implementation + environments.rs # EnvironmentsApi trait + implementation + wasm/ + core.wasm # Embedded WASM binary (~9.1MB) + examples/ + service_account.rs + desktop_app.rs +``` + +## Core Abstraction + +```rust +pub(crate) trait Core: Send + Sync { + fn init_client(&self, config: &[u8]) -> Result, SdkError>; + fn invoke(&self, invoke_config: &[u8]) -> Result, SdkError>; + fn release_client(&self, client_id: &[u8]); +} +``` + +### ExtismCore (default) + +- Embeds `core.wasm` via `include_bytes!("../wasm/core.wasm")` +- Uses `extism` crate (Rust host SDK) to create and manage the plugin +- `Mutex` for thread-safe access (matches Go's `sync.Mutex` pattern) +- Implements host functions: `randomFill`, `getTime`, `getTimezoneOffset` +- 50MB message size limit (matches Go) + +### SharedLibCore (feature: `desktop`) + +- Loads `libop_sdk_ipc_client.{dylib,so,dll}` from the 1Password desktop app installation +- Uses `libloading` crate for cross-platform dynamic library loading +- `#[allow(unsafe_code)]` scoped to the FFI modules only +- Platform-specific discovery of the shared library path +- Separate modules for Unix (`dlopen`) and Windows (`LoadLibrary`) matching Go's `shared_lib_core_unix.go` / `shared_lib_core_windows.go` split + +## Client Builder + +```rust +use onepassword_sdk::{Client, ClientBuilder}; + +// Service account auth (default, WASM core) +let client = Client::builder() + .service_account_token("ops_...") + .integration_info("My App", "v1.0.0") + .build()?; + +// Desktop app auth (requires `desktop` feature) +let client = Client::builder() + .desktop_app_integration("My App") + .integration_info("My App", "v1.0.0") + .build()?; +``` + +Builder validates that exactly one auth method is set (service account XOR desktop app), matching Go's mutual exclusivity check. `integration_info` defaults to `("Unknown", "Unknown")` if not set. + +## Public API Surface + +### SecretsApi + +```rust +pub trait SecretsApi { + fn resolve(&self, secret_reference: &str) -> Result; + fn resolve_all(&self, secret_references: &[String]) -> Result; +} +``` + +Plus standalone functions (no client needed): +- `secrets::validate_secret_reference(reference: &str) -> Result<(), SdkError>` +- `secrets::generate_password(recipe: PasswordRecipe) -> Result` + +### ItemsApi + +```rust +pub trait ItemsApi { + fn create(&self, params: ItemCreateParams) -> Result; + fn create_all(&self, vault_id: &str, params: &[ItemCreateParams]) -> Result; + fn get(&self, vault_id: &str, item_id: &str) -> Result; + fn get_all(&self, vault_id: &str, item_ids: &[String]) -> Result; + fn put(&self, item: Item) -> Result; + fn delete(&self, vault_id: &str, item_id: &str) -> Result<(), SdkError>; + fn delete_all(&self, vault_id: &str, item_ids: &[String]) -> Result; + fn archive(&self, vault_id: &str, item_id: &str) -> Result<(), SdkError>; + fn list(&self, vault_id: &str, filters: &[ItemListFilter]) -> Result, SdkError>; + fn shares(&self) -> &dyn ItemsSharesApi; + fn files(&self) -> &dyn ItemsFilesApi; +} +``` + +### ItemsSharesApi + +```rust +pub trait ItemsSharesApi { + fn get_account_policy(&self, vault_id: &str, item_id: &str) -> Result; + fn validate_recipients(&self, policy: ItemShareAccountPolicy, recipients: &[String]) -> Result, SdkError>; + fn create(&self, item: Item, policy: ItemShareAccountPolicy, params: ItemShareParams) -> Result; +} +``` + +### ItemsFilesApi + +```rust +pub trait ItemsFilesApi { + fn attach(&self, item: Item, file_params: FileCreateParams) -> Result; + fn read(&self, vault_id: &str, item_id: &str, attr: FileAttributes) -> Result, SdkError>; + fn delete(&self, item: Item, section_id: &str, field_id: &str) -> Result; + fn replace_document(&self, item: Item, doc_params: DocumentCreateParams) -> Result; +} +``` + +### VaultsApi + +```rust +pub trait VaultsApi { + fn create(&self, params: VaultCreateParams) -> Result; + fn list(&self, params: Option) -> Result, SdkError>; + fn get_overview(&self, vault_id: &str) -> Result; + fn get(&self, vault_id: &str, params: VaultGetParams) -> Result; + fn update(&self, vault_id: &str, params: VaultUpdateParams) -> Result; + fn delete(&self, vault_id: &str) -> Result<(), SdkError>; + fn grant_group_permissions(&self, vault_id: &str, group_permissions: &[GroupAccess]) -> Result<(), SdkError>; + fn update_group_permissions(&self, group_permissions: &[GroupVaultAccess]) -> Result<(), SdkError>; + fn revoke_group_permissions(&self, vault_id: &str, group_id: &str) -> Result<(), SdkError>; +} +``` + +### GroupsApi + +```rust +pub trait GroupsApi { + fn get(&self, group_id: &str, params: GroupGetParams) -> Result; +} +``` + +### EnvironmentsApi + +```rust +pub trait EnvironmentsApi { + fn get_variables(&self, environment_id: &str) -> Result; +} +``` + +## Domain Types + +All types ported from the Go SDK's `types.go` (which is itself generated from Rust via `typeshare`). Key mapping decisions: + +| Go Pattern | Rust Pattern | +|---|---| +| Struct with exported fields | `pub struct` with `#[derive(Debug, Clone, Serialize, Deserialize)]` | +| Tagged union (`Type` + content field + manual JSON marshal) | `#[serde(tag = "type", content = "content")]` enum — native Rust, no manual impl | +| `[]string` | `Vec` | +| `[]byte` | `Vec` | +| `*string` (optional) | `Option` | +| Go constants (iota) | Rust enum variants | +| Bitmask permission constants | `pub const` values in a `permissions` module, or a bitflags type | + +### Key type categories + +- **Items:** `Item`, `ItemCreateParams`, `ItemOverview`, `ItemField`, `ItemSection`, `ItemCategory` (23 variants), `ItemFieldType` (15 variants), `ItemFieldDetails` (tagged enum: OTP/SSHKey/Address), `ItemState` +- **Files:** `FileAttributes`, `FileCreateParams`, `DocumentCreateParams`, `ItemFile` +- **Secrets:** `ResolveAllResponse`, `ResolvedReference`, `ResolveReferenceError` (17 variants), `PasswordRecipe` (tagged enum: Memorable/Pin/Random), `GeneratePasswordResponse` +- **Vaults:** `Vault`, `VaultOverview`, `VaultCreateParams`, `VaultUpdateParams`, `VaultGetParams`, `VaultListParams`, `VaultType` (5 variants) +- **Groups:** `Group`, `GroupGetParams`, `GroupType` (7 variants), `GroupState`, `GroupAccess`, `GroupVaultAccess`, `VaultAccess` +- **Sharing:** `ItemShareAccountPolicy`, `ItemShareParams`, `ItemShareDuration`, `ValidRecipient` (tagged enum), `AllowedType`, `AllowedRecipientType` +- **Environments:** `GetVariablesResponse`, `EnvironmentVariable` +- **Batch responses:** Generic `BatchResponse` for `ItemsUpdateAllResponse`, `ItemsGetAllResponse`, `ItemsDeleteAllResponse`, `ResolveAllResponse` + +## Error Handling + +```rust +#[derive(Debug, thiserror::Error)] +pub enum SdkError { + #[error("1Password SDK error: {message}")] + Core { name: String, message: String }, + + #[error("serialization error: {0}")] + Serialization(#[from] serde_json::Error), + + #[error("WASM plugin error: {0}")] + Plugin(String), + + #[error("configuration error: {0}")] + Config(String), + + #[error("desktop session expired")] + DesktopSessionExpired, + + #[error("rate limit exceeded")] + RateLimitExceeded, + + #[error("shared library error: {0}")] + SharedLib(String), +} +``` + +Core errors arrive as JSON `{"name": "...", "message": "..."}` and are deserialized. `DesktopSessionExpired` triggers automatic client re-initialization and retry (matching Go behavior). + +Batch operations use per-item error types rather than failing the whole batch, matching Go's `Response[T, E]` pattern. + +## Resource Cleanup + +`Client` implements `Drop` to call `core.release_client()`. This is cleaner than Go's `runtime.SetFinalizer` approach — deterministic cleanup rather than GC-dependent. + +## Host Functions + +The WASM core imports three host functions that we must provide: + +| Function | Purpose | Implementation | +|---|---|---| +| `randomFill(ptr, len)` | Cryptographic random bytes | `getrandom` crate | +| `getTime()` | Current Unix timestamp (ms) | `std::time::SystemTime` | +| `getTimezoneOffset()` | UTC offset in minutes | `chrono::Local` or `time` crate | + +These are registered as Extism host functions when creating the plugin. + +## Feature Flags + +| Feature | Default | Description | +|---|---|---| +| (none/default) | yes | WASM-based core, service account auth | +| `desktop` | no | Desktop app integration via native shared library | + +## Dependencies + +| Crate | Purpose | +|---|---| +| `extism` | WASM plugin host runtime | +| `serde`, `serde_json` | JSON serialization for core RPC | +| `thiserror` | Error derive macros | +| `getrandom` | Cryptographic random for WASM host function | +| `chrono` or `time` | Timezone offset for WASM host function | +| `libloading` | Dynamic library loading (desktop feature only) | + +## Tooling & CI + +From cordon conventions: + +- `rust-toolchain.toml`: channel `1.93.1`, components `rustfmt`, `clippy` +- `deny.toml`: license allowlist, advisory db, ban wildcards, deny unknown sources +- CI workflow: `cargo fmt --check`, `cargo-deny check`, `cargo clippy -- -D warnings`, `cargo nextest run`, `cargo test --doc` +- `#![deny(unsafe_code)]` at crate root (not `forbid`, to allow scoped `#[allow]` on FFI modules) + +## Not At Parity + +These items cannot be achieved with the current approach and are flagged: + +1. **Code generation pipeline** — The Go SDK types are generated by `op-codegen`/`typeshare` from the private Rust core repo. We're hand-porting them. If the core WASM updates, types must be manually reconciled. This is acceptable for an exploratory port. + +2. **Automated core updates** — 1Password's `1PasswordSDKBot` pushes WASM updates to the Go/Python/JS SDKs automatically. Our repo won't receive these. Core updates require manually copying `core.wasm` from a reference SDK. + +3. **Extism host function ABI** — The exact ABI for host functions (memory layout, calling convention) needs to be validated against the actual WASM binary. The Go SDK's implementation is the reference, but Rust's Extism host SDK may have slightly different ergonomics. From 7b9e341bab4e0d1097e823ec8111c574496166d1 Mon Sep 17 00:00:00 2001 From: Matthew Kern Date: Mon, 30 Mar 2026 14:22:34 -0700 Subject: [PATCH 02/25] docs: add implementation plan for 1Password Rust SDK port 13 tasks covering project scaffolding, types, core abstraction, WASM runtime, client builder, all 7 API surfaces, desktop app integration, examples, and CI. --- .../plans/2026-03-30-onepassword-sdk-rust.md | 2688 +++++++++++++++++ 1 file changed, 2688 insertions(+) create mode 100644 docs/superpowers/plans/2026-03-30-onepassword-sdk-rust.md diff --git a/docs/superpowers/plans/2026-03-30-onepassword-sdk-rust.md b/docs/superpowers/plans/2026-03-30-onepassword-sdk-rust.md new file mode 100644 index 0000000..b69f8c7 --- /dev/null +++ b/docs/superpowers/plans/2026-03-30-onepassword-sdk-rust.md @@ -0,0 +1,2688 @@ +# 1Password Rust SDK Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Port the 1Password Go SDK (v0.4.1-beta.1) to idiomatic Rust with full API parity. + +**Architecture:** Typed Rust wrapper around the same `core.wasm` binary used by Go/Python/JS SDKs. JSON-based RPC to the WASM core via Extism host SDK. Desktop app integration via `libloading` behind a `desktop` feature flag. + +**Tech Stack:** Rust 2024 edition, extism, serde/serde_json, thiserror, libloading (desktop feature), getrandom, chrono + +--- + +## File Structure + +| File | Responsibility | +|---|---| +| `Cargo.toml` | Crate manifest with `desktop` feature flag | +| `rust-toolchain.toml` | Pin Rust 1.93.1, rustfmt, clippy | +| `deny.toml` | License/advisory/source auditing | +| `.gitignore` | Ignore target/, IDE files | +| `CLAUDE.md` | Developer conventions | +| `src/lib.rs` | Crate root, `#![deny(unsafe_code)]`, public re-exports | +| `src/errors.rs` | `SdkError` enum via thiserror | +| `src/core.rs` | `Core` trait + `InnerClient` + `InvokeConfig` structs | +| `src/core_extism.rs` | `ExtismCore` — WASM runtime + host functions | +| `src/core_shared_lib.rs` | `SharedLibCore` — native FFI (desktop feature, cfg unix/windows) | +| `src/client.rs` | `Client` struct + `ClientBuilder` | +| `src/types.rs` | All domain types (structs, enums, serde) | +| `src/secrets.rs` | `SecretsApi` trait + `SecretsSource` impl | +| `src/items.rs` | `ItemsApi` trait + `ItemsSource` impl | +| `src/items_files.rs` | `ItemsFilesApi` trait + impl | +| `src/items_shares.rs` | `ItemsSharesApi` trait + impl | +| `src/vaults.rs` | `VaultsApi` trait + `VaultsSource` impl | +| `src/groups.rs` | `GroupsApi` trait + `GroupsSource` impl | +| `src/environments.rs` | `EnvironmentsApi` trait + impl | +| `wasm/core.wasm` | Embedded WASM binary (~9.1MB) | +| `examples/service_account.rs` | Service account usage example | +| `examples/desktop_app.rs` | Desktop app usage example | +| `.github/workflows/ci.yml` | CI: fmt, clippy, deny, test | + +--- + +### Task 1: Project Scaffolding + +**Files:** +- Create: `Cargo.toml` +- Create: `rust-toolchain.toml` +- Create: `deny.toml` +- Create: `.gitignore` +- Create: `CLAUDE.md` +- Create: `src/lib.rs` + +- [ ] **Step 1: Create `Cargo.toml`** + +```toml +[package] +name = "onepassword-sdk" +version = "0.4.1-beta.1" +edition = "2024" +publish = false +license = "MIT" +description = "1Password SDK for Rust" + +[features] +default = [] +desktop = ["dep:libloading"] + +[dependencies] +chrono = { version = "0.4", default-features = false, features = ["clock"] } +extism = "1" +getrandom = "0.2" +libloading = { version = "0.8", optional = true } +serde = { version = "1", features = ["derive"] } +serde_json = "1" +thiserror = "2" + +[dev-dependencies] +``` + +- [ ] **Step 2: Create `rust-toolchain.toml`** + +```toml +[toolchain] +channel = "1.93.1" +components = ["rustfmt", "clippy"] +``` + +- [ ] **Step 3: Create `deny.toml`** + +```toml +[graph] +all-features = true + +[advisories] +unmaintained = "warn" + +[bans] +multiple-versions = "warn" +wildcards = "deny" + +[licenses] +allow = [ + "MIT", + "Apache-2.0", + "BSD-2-Clause", + "BSD-3-Clause", + "ISC", + "Unicode-3.0", + "Unicode-DFS-2016", + "OpenSSL", + "Zlib", +] +confidence-threshold = 0.8 + +[[licenses.exceptions]] +allow = ["MPL-2.0"] +crate = "webpki-roots" + +[sources] +unknown-registry = "deny" +unknown-git = "deny" +``` + +- [ ] **Step 4: Create `.gitignore`** + +``` +/target +.DS_Store +.idea/ +*.swp +``` + +- [ ] **Step 5: Create `CLAUDE.md`** + +```markdown +# 1Password Rust SDK + +## Build Commands + +- `cargo fmt --check` — check formatting +- `cargo clippy -- -D warnings` — lint +- `cargo test` — run tests +- `cargo build` — build (default features) +- `cargo build --features desktop` — build with desktop app integration + +## Conventions + +- Edition 2024, Rust 1.93.1 +- `#![deny(unsafe_code)]` at crate root; `#[allow(unsafe_code)]` only on FFI modules +- `thiserror` for error types +- `serde` for all JSON serialization +- Inline `#[cfg(test)] mod tests` blocks +- Conventional commits: `type(scope): description` +- Run `cargo fmt --check && cargo clippy -- -D warnings && cargo test` before pushing + +## Architecture + +Typed wrapper around an opaque WASM core binary. All API calls serialize params to JSON, +call `Core::invoke()`, and deserialize the response. Two core backends: +- `ExtismCore` (default) — embedded WASM via Extism +- `SharedLibCore` (feature: `desktop`) — native shared library from 1Password desktop app +``` + +- [ ] **Step 6: Create `src/lib.rs`** + +```rust +#![deny(unsafe_code)] + +mod client; +mod core; +mod core_extism; +mod errors; +mod types; + +mod secrets; +mod items; +mod items_files; +mod items_shares; +mod vaults; +mod groups; +mod environments; + +#[cfg(feature = "desktop")] +mod core_shared_lib; + +pub use client::{Client, ClientBuilder}; +pub use errors::SdkError; +pub use types::*; + +pub use secrets::SecretsApi; +pub use items::ItemsApi; +pub use items_files::ItemsFilesApi; +pub use items_shares::ItemsSharesApi; +pub use vaults::VaultsApi; +pub use groups::GroupsApi; +pub use environments::EnvironmentsApi; +``` + +- [ ] **Step 7: Verify it compiles (will fail — stubs needed, but Cargo.toml is valid)** + +Run: `cargo check 2>&1 | head -5` +Expected: Errors about missing modules (this is fine — we'll fill them in) + +- [ ] **Step 8: Commit** + +```bash +git add Cargo.toml rust-toolchain.toml deny.toml .gitignore CLAUDE.md src/lib.rs +git commit -m "feat: scaffold project with Cargo.toml, toolchain, and lib.rs" +``` + +--- + +### Task 2: Error Types + +**Files:** +- Create: `src/errors.rs` + +- [ ] **Step 1: Write test for error deserialization** + +Add to `src/errors.rs`: + +```rust +use serde::Deserialize; +use serde_json; + +#[derive(Debug, thiserror::Error)] +pub enum SdkError { + #[error("1Password SDK error: {message}")] + Core { name: String, message: String }, + + #[error("serialization error: {0}")] + Serialization(#[from] serde_json::Error), + + #[error("WASM plugin error: {0}")] + Plugin(String), + + #[error("configuration error: {0}")] + Config(String), + + #[error("desktop session expired: {0}")] + DesktopSessionExpired(String), + + #[error("rate limit exceeded: {0}")] + RateLimitExceeded(String), + + #[error("shared library error: {0}")] + SharedLib(String), +} + +#[derive(Deserialize)] +struct CoreError { + name: String, + message: String, +} + +/// Deserialize a JSON error string from the WASM core into an SdkError. +/// Matches Go SDK's `unmarshalError` behavior. +pub(crate) fn unmarshal_error(err: &str) -> SdkError { + match serde_json::from_str::(err) { + Ok(core_err) => match core_err.name.as_str() { + "DesktopSessionExpired" => SdkError::DesktopSessionExpired(core_err.message), + "RateLimitExceeded" => SdkError::RateLimitExceeded(core_err.message), + _ => SdkError::Core { + name: core_err.name, + message: core_err.message, + }, + }, + Err(_) => SdkError::Core { + name: "Unknown".to_string(), + message: err.to_string(), + }, + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn unmarshal_core_error() { + let err = unmarshal_error(r#"{"name":"SomeError","message":"something broke"}"#); + match err { + SdkError::Core { name, message } => { + assert_eq!(name, "SomeError"); + assert_eq!(message, "something broke"); + } + _ => panic!("expected Core error"), + } + } + + #[test] + fn unmarshal_session_expired() { + let err = unmarshal_error(r#"{"name":"DesktopSessionExpired","message":"session gone"}"#); + assert!(matches!(err, SdkError::DesktopSessionExpired(_))); + } + + #[test] + fn unmarshal_rate_limit() { + let err = unmarshal_error(r#"{"name":"RateLimitExceeded","message":"slow down"}"#); + assert!(matches!(err, SdkError::RateLimitExceeded(_))); + } + + #[test] + fn unmarshal_invalid_json() { + let err = unmarshal_error("not json at all"); + match err { + SdkError::Core { message, .. } => assert_eq!(message, "not json at all"), + _ => panic!("expected Core error for invalid JSON"), + } + } +} +``` + +- [ ] **Step 2: Verify tests pass** + +Run: `cargo test -p onepassword-sdk errors::tests 2>&1` +Expected: Will fail until other modules exist. We'll verify after Task 3. + +- [ ] **Step 3: Commit** + +```bash +git add src/errors.rs +git commit -m "feat: add SdkError type and unmarshal_error" +``` + +--- + +### Task 3: Core Trait and Internal Types + +**Files:** +- Create: `src/core.rs` + +- [ ] **Step 1: Write the Core trait and supporting types** + +```rust +use std::collections::HashMap; + +use serde::{Deserialize, Serialize}; + +use crate::errors::SdkError; + +pub(crate) const SDK_LANGUAGE: &str = "Rust"; +pub(crate) const DEFAULT_REQUEST_LIBRARY: &str = "reqwest"; +pub(crate) const MESSAGE_LIMIT: usize = 50 * 1024 * 1024; + +pub(crate) trait Core: Send + Sync { + fn init_client(&self, config: &[u8]) -> Result, SdkError>; + fn invoke(&self, invoke_config: &[u8]) -> Result, SdkError>; + fn release_client(&self, client_id: &[u8]); +} + +#[derive(Debug, Serialize)] +pub(crate) struct ClientConfig { + #[serde(rename = "serviceAccountToken")] + pub sa_token: String, + #[serde(rename = "programmingLanguage")] + pub language: String, + #[serde(rename = "sdkVersion")] + pub sdk_version: String, + #[serde(rename = "integrationName")] + pub integration_name: String, + #[serde(rename = "integrationVersion")] + pub integration_version: String, + #[serde(rename = "requestLibraryName")] + pub request_library_name: String, + #[serde(rename = "requestLibraryVersion")] + pub request_library_version: String, + #[serde(rename = "os")] + pub system_os: String, + #[serde(rename = "osVersion")] + pub system_os_version: String, + #[serde(rename = "architecture")] + pub system_arch: String, + #[serde(skip_serializing_if = "Option::is_none")] + pub account_name: Option, +} + +impl ClientConfig { + pub fn new_default() -> Self { + Self { + sa_token: String::new(), + language: SDK_LANGUAGE.to_string(), + sdk_version: env!("CARGO_PKG_VERSION").to_string(), + integration_name: "Unknown".to_string(), + integration_version: "Unknown".to_string(), + request_library_name: DEFAULT_REQUEST_LIBRARY.to_string(), + request_library_version: "0.0.0".to_string(), + system_os: std::env::consts::OS.to_string(), + system_os_version: "0.0.0".to_string(), + system_arch: std::env::consts::ARCH.to_string(), + account_name: None, + } + } +} + +#[derive(Debug, Serialize)] +pub(crate) struct InvokeConfig { + pub invocation: Invocation, +} + +#[derive(Debug, Serialize)] +pub(crate) struct Invocation { + #[serde(rename = "clientId", skip_serializing_if = "Option::is_none")] + pub client_id: Option, + pub parameters: Parameters, +} + +#[derive(Debug, Serialize)] +pub(crate) struct Parameters { + pub name: String, + pub parameters: HashMap, +} + +/// Wraps a Core implementation and handles JSON marshaling/unmarshaling. +pub(crate) struct CoreWrapper { + pub inner: Box, +} + +impl CoreWrapper { + pub fn init_client(&self, config: &ClientConfig) -> Result { + let config_bytes = serde_json::to_vec(config)?; + let res = self.inner.init_client(&config_bytes)?; + let id: u64 = serde_json::from_slice(&res)?; + Ok(id) + } + + pub fn invoke(&self, invoke_config: &InvokeConfig) -> Result { + let input = serde_json::to_vec(invoke_config)?; + if input.len() > MESSAGE_LIMIT { + return Err(SdkError::Config(format!( + "message size exceeds the limit of {} bytes", + MESSAGE_LIMIT + ))); + } + let res = self.inner.invoke(&input)?; + Ok(String::from_utf8_lossy(&res).into_owned()) + } + + pub fn release_client(&self, client_id: u64) { + if let Ok(id_bytes) = serde_json::to_vec(&client_id) { + self.inner.release_client(&id_bytes); + } + } +} + +/// The inner client state shared by all API implementations. +pub(crate) struct InnerClient { + pub id: u64, + pub config: ClientConfig, + pub core: CoreWrapper, +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn default_config_has_correct_language() { + let config = ClientConfig::new_default(); + assert_eq!(config.language, "Rust"); + assert_eq!(config.system_os, std::env::consts::OS); + assert_eq!(config.system_arch, std::env::consts::ARCH); + } + + #[test] + fn invoke_config_serializes_correctly() { + let config = InvokeConfig { + invocation: Invocation { + client_id: Some(42), + parameters: Parameters { + name: "SecretsResolve".to_string(), + parameters: { + let mut m = HashMap::new(); + m.insert( + "secret_reference".to_string(), + serde_json::Value::String("op://vault/item/field".to_string()), + ); + m + }, + }, + }, + }; + let json = serde_json::to_string(&config).unwrap(); + assert!(json.contains("\"clientId\":42")); + assert!(json.contains("\"name\":\"SecretsResolve\"")); + } +} +``` + +- [ ] **Step 2: Verify tests pass** + +Run: `cargo test core::tests` +Expected: PASS (2 tests) + +- [ ] **Step 3: Commit** + +```bash +git add src/core.rs +git commit -m "feat: add Core trait, ClientConfig, InvokeConfig, CoreWrapper" +``` + +--- + +### Task 4: Domain Types + +**Files:** +- Create: `src/types.rs` + +This is the largest file — all domain types ported from Go's `types.go`. The Go version uses manual JSON marshal/unmarshal for tagged unions; Rust uses native `#[serde(tag, content)]` enums. + +- [ ] **Step 1: Write all simple struct types** + +Create `src/types.rs` with all struct types, string enums, and constants. The full content is: + +```rust +use serde::{Deserialize, Serialize}; + +// --- Error message type --- + +pub type ErrorMessage = String; + +// --- Address --- + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct AddressFieldDetails { + pub street: String, + pub city: String, + pub country: String, + pub zip: String, + pub state: String, +} + +// --- Documents & Files --- + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct DocumentCreateParams { + pub name: String, + pub content: Vec, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct FileAttributes { + pub name: String, + pub id: String, + pub size: u32, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct FileCreateParams { + pub name: String, + pub content: Vec, + pub section_id: String, + pub field_id: String, +} + +// --- Environments --- + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct EnvironmentVariable { + pub name: String, + pub value: String, + pub masked: bool, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct GetVariablesResponse { + pub variables: Vec, +} + +// --- Password generation --- + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct GeneratePasswordResponse { + pub password: String, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub enum SeparatorType { + Digits, + DigitsAndSymbols, + Spaces, + Hyphens, + Underscores, + Periods, + Commas, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub enum WordListType { + FullWords, + Syllables, + ThreeLetters, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct PasswordRecipeMemorableInner { + pub separator_type: SeparatorType, + pub capitalize: bool, + pub word_list_type: WordListType, + pub word_count: u32, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct PasswordRecipePinInner { + pub length: u32, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct PasswordRecipeRandomInner { + pub include_digits: bool, + pub include_symbols: bool, + pub length: u32, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(tag = "type", content = "parameters")] +pub enum PasswordRecipe { + Memorable(PasswordRecipeMemorableInner), + Pin(PasswordRecipePinInner), + Random(PasswordRecipeRandomInner), +} + +// --- SSH Keys --- + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct SSHKeyAttributes { + pub public_key: String, + pub fingerprint: String, + pub key_type: String, +} + +// --- OTP --- + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct OTPFieldDetails { + #[serde(skip_serializing_if = "Option::is_none")] + pub code: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub error_message: Option, +} + +// --- Item field details (tagged enum) --- + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(tag = "type", content = "content")] +pub enum ItemFieldDetails { + Otp(OTPFieldDetails), + SshKey(SSHKeyAttributes), + Address(AddressFieldDetails), +} + +// --- Item categories --- + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub enum ItemCategory { + Login, + SecureNote, + CreditCard, + CryptoWallet, + Identity, + Password, + Document, + ApiCredentials, + BankAccount, + Database, + DriverLicense, + Email, + MedicalRecord, + Membership, + OutdoorLicense, + Passport, + Rewards, + Router, + Server, + SshKey, + SocialSecurityNumber, + SoftwareLicense, + Person, + Unsupported, +} + +// --- Item field types --- + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub enum ItemFieldType { + Text, + Concealed, + CreditCardType, + CreditCardNumber, + Phone, + Url, + Totp, + Email, + Reference, + SshKey, + Menu, + MonthYear, + Address, + Date, + Unsupported, +} + +// --- Item state --- + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub enum ItemState { + Active, + Archived, +} + +// --- Autofill --- + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub enum AutofillBehavior { + AnywhereOnWebsite, + ExactDomain, + Never, +} + +// --- Website --- + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct Website { + pub url: String, + pub label: String, + pub autofill_behavior: AutofillBehavior, +} + +// --- Item field --- + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct ItemField { + pub id: String, + pub title: String, + #[serde(skip_serializing_if = "Option::is_none")] + pub section_id: Option, + pub field_type: ItemFieldType, + pub value: String, + #[serde(skip_serializing_if = "Option::is_none")] + pub details: Option, +} + +// --- Item section --- + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct ItemSection { + pub id: String, + pub title: String, +} + +// --- Item file --- + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct ItemFile { + pub attributes: FileAttributes, + pub section_id: String, + pub field_id: String, +} + +// --- Item --- + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct Item { + pub id: String, + pub title: String, + pub category: ItemCategory, + pub vault_id: String, + pub fields: Vec, + pub sections: Vec, + pub notes: String, + pub tags: Vec, + pub websites: Vec, + pub version: u32, + pub files: Vec, + #[serde(skip_serializing_if = "Option::is_none")] + pub document: Option, + pub created_at: String, + pub updated_at: String, +} + +// --- Item create params --- + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct ItemCreateParams { + pub category: ItemCategory, + pub vault_id: String, + pub title: String, + #[serde(skip_serializing_if = "Option::is_none")] + pub fields: Option>, + #[serde(skip_serializing_if = "Option::is_none")] + pub sections: Option>, + #[serde(skip_serializing_if = "Option::is_none")] + pub notes: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub tags: Option>, + #[serde(skip_serializing_if = "Option::is_none")] + pub websites: Option>, + #[serde(skip_serializing_if = "Option::is_none")] + pub files: Option>, + #[serde(skip_serializing_if = "Option::is_none")] + pub document: Option, +} + +// --- Item overview --- + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct ItemOverview { + pub id: String, + pub title: String, + pub category: ItemCategory, + pub vault_id: String, + pub websites: Vec, + pub tags: Vec, + pub created_at: String, + pub updated_at: String, + pub state: ItemState, +} + +// --- Item list filter --- + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct ItemListFilterByStateInner { + pub active: bool, + pub archived: bool, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(tag = "type", content = "content")] +pub enum ItemListFilter { + ByState(ItemListFilterByStateInner), +} + +// --- Item sharing --- + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub enum ItemShareDuration { + OneHour, + OneDay, + SevenDays, + FourteenDays, + ThirtyDays, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub enum AllowedType { + Authenticated, + Public, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub enum AllowedRecipientType { + Email, + Domain, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct ItemShareFiles { + pub allowed: bool, + pub max_size: u32, + #[serde(skip_serializing_if = "Option::is_none")] + pub allowed_types: Option>, + #[serde(skip_serializing_if = "Option::is_none")] + pub allowed_recipient_types: Option>, + #[serde(skip_serializing_if = "Option::is_none")] + pub max_expiry: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub default_expiry: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub max_views: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct ItemShareAccountPolicy { + pub max_expiry: ItemShareDuration, + pub default_expiry: ItemShareDuration, + #[serde(skip_serializing_if = "Option::is_none")] + pub max_views: Option, + pub allowed_types: Vec, + pub allowed_recipient_types: Vec, + pub files: ItemShareFiles, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct ValidRecipientEmailInner { + pub email: String, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct ValidRecipientDomainInner { + pub domain: String, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(tag = "type", content = "parameters")] +pub enum ValidRecipient { + Email(ValidRecipientEmailInner), + Domain(ValidRecipientDomainInner), +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct ItemShareParams { + #[serde(skip_serializing_if = "Option::is_none")] + pub recipients: Option>, + #[serde(skip_serializing_if = "Option::is_none")] + pub expire_after: Option, + pub one_time_only: bool, +} + +// --- Batch response types --- + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct BatchResponse { + #[serde(skip_serializing_if = "Option::is_none")] + pub content: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub error: Option, +} + +// --- Item update failure reasons --- + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(tag = "type", content = "message")] +#[serde(rename_all = "camelCase")] +pub enum ItemUpdateFailureReason { + ItemValidationError(ErrorMessage), + ItemStatusPermissionError, + ItemStatusIncorrectItemVersion, + ItemStatusFileNotFound, + ItemStatusTooBig, + ItemNotFound, + Internal(ErrorMessage), +} + +// --- Items batch responses --- + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct ItemsDeleteAllResponse { + pub individual_responses: + std::collections::HashMap>, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub enum ItemsGetAllError { + #[serde(rename = "itemNotFound")] + ItemNotFound, + #[serde(rename = "internal")] + Internal(ErrorMessage), +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct ItemsGetAllResponse { + pub individual_responses: Vec>, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct ItemsUpdateAllResponse { + pub individual_responses: Vec>, +} + +// --- Secrets --- + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct ResolvedReference { + pub secret: String, + pub item_id: String, + pub vault_id: String, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(tag = "type", content = "message")] +#[serde(rename_all = "camelCase")] +pub enum ResolveReferenceError { + Parsing(ErrorMessage), + FieldNotFound, + VaultNotFound, + TooManyVaults, + ItemNotFound, + TooManyItems, + TooManyMatchingFields, + NoMatchingSections, + IncompatibleTOTPQueryParameterField, + #[serde(rename = "unableToGenerateTotpCode")] + UnableToGenerateTOTPCode(ErrorMessage), + #[serde(rename = "sSHKeyMetadataNotFound")] + SSHKeyMetadataNotFound, + UnsupportedFileFormat, + #[serde(rename = "incompatibleSshKeyQueryParameterField")] + IncompatibleSSHKeyQueryParameterField, + UnableToParsePrivateKey, + #[serde(rename = "unableToFormatPrivateKeyToOpenSsh")] + UnableToFormatPrivateKeyToOpenSSH, + Other, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct ResolveAllResponse { + pub individual_responses: + std::collections::HashMap>, +} + +// --- Groups --- + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub enum GroupType { + Owners, + Administrators, + Recovery, + ExternalAccountManagers, + TeamMembers, + UserDefined, + Unsupported, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub enum GroupState { + Active, + Deleted, + Unsupported, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub enum VaultAccessorType { + User, + Group, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct VaultAccess { + pub vault_uuid: String, + pub accessor_type: VaultAccessorType, + pub accessor_uuid: String, + pub permissions: u32, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct Group { + pub id: String, + pub title: String, + pub description: String, + pub group_type: GroupType, + pub state: GroupState, + #[serde(skip_serializing_if = "Option::is_none")] + pub vault_access: Option>, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct GroupAccess { + pub group_id: String, + pub permissions: u32, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct GroupGetParams { + #[serde(skip_serializing_if = "Option::is_none")] + pub vault_permissions: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct GroupVaultAccess { + pub vault_id: String, + pub group_id: String, + pub permissions: u32, +} + +// --- Vaults --- + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub enum VaultType { + Personal, + Everyone, + Transfer, + UserCreated, + Unsupported, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct Vault { + pub id: String, + pub title: String, + pub description: String, + pub vault_type: VaultType, + pub active_item_count: u32, + pub content_version: u32, + pub attribute_version: u32, + #[serde(skip_serializing_if = "Option::is_none")] + pub access: Option>, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct VaultCreateParams { + pub title: String, + #[serde(skip_serializing_if = "Option::is_none")] + pub description: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub allow_admins_access: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct VaultGetParams { + #[serde(skip_serializing_if = "Option::is_none")] + pub accessors: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct VaultListParams { + #[serde(skip_serializing_if = "Option::is_none")] + pub decrypt_details: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct VaultOverview { + pub id: String, + pub title: String, + pub description: String, + pub vault_type: VaultType, + pub active_item_count: u32, + pub content_version: u32, + pub attribute_version: u32, + pub created_at: String, + pub updated_at: String, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct VaultUpdateParams { + #[serde(skip_serializing_if = "Option::is_none")] + pub title: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub description: Option, +} + +// --- Permissions constants --- + +pub mod permissions { + pub const READ_ITEMS: u32 = 32; + pub const REVEAL_ITEM_PASSWORD: u32 = 16; + pub const UPDATE_ITEMS: u32 = 64; + pub const CREATE_ITEMS: u32 = 128; + pub const ARCHIVE_ITEMS: u32 = 256; + pub const DELETE_ITEMS: u32 = 512; + pub const UPDATE_ITEM_HISTORY: u32 = 1024; + pub const SEND_ITEMS: u32 = 1_048_576; + pub const IMPORT_ITEMS: u32 = 2_097_152; + pub const EXPORT_ITEMS: u32 = 4_194_304; + pub const PRINT_ITEMS: u32 = 8_388_608; + pub const MANAGE_VAULT: u32 = 2; + pub const RECOVER_VAULT: u32 = 1; + pub const NO_ACCESS: u32 = 0; +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn password_recipe_serializes_as_tagged_enum() { + let recipe = PasswordRecipe::Random(PasswordRecipeRandomInner { + include_digits: true, + include_symbols: false, + length: 20, + }); + let json = serde_json::to_string(&recipe).unwrap(); + assert!(json.contains(r#""type":"Random"#)); + assert!(json.contains(r#""parameters":#)); + } + + #[test] + fn item_field_details_roundtrip() { + let details = ItemFieldDetails::Otp(OTPFieldDetails { + code: Some("123456".to_string()), + error_message: None, + }); + let json = serde_json::to_string(&details).unwrap(); + let parsed: ItemFieldDetails = serde_json::from_str(&json).unwrap(); + match parsed { + ItemFieldDetails::Otp(otp) => assert_eq!(otp.code.unwrap(), "123456"), + _ => panic!("expected Otp variant"), + } + } + + #[test] + fn valid_recipient_roundtrip() { + let recipient = ValidRecipient::Email(ValidRecipientEmailInner { + email: "test@example.com".to_string(), + }); + let json = serde_json::to_string(&recipient).unwrap(); + assert!(json.contains(r#""type":"Email"#)); + let parsed: ValidRecipient = serde_json::from_str(&json).unwrap(); + match parsed { + ValidRecipient::Email(inner) => assert_eq!(inner.email, "test@example.com"), + _ => panic!("expected Email variant"), + } + } + + #[test] + fn item_list_filter_roundtrip() { + let filter = ItemListFilter::ByState(ItemListFilterByStateInner { + active: true, + archived: false, + }); + let json = serde_json::to_string(&filter).unwrap(); + let parsed: ItemListFilter = serde_json::from_str(&json).unwrap(); + match parsed { + ItemListFilter::ByState(inner) => { + assert!(inner.active); + assert!(!inner.archived); + } + } + } +} +``` + +- [ ] **Step 2: Run tests** + +Run: `cargo test types::tests` +Expected: PASS (4 tests) + +- [ ] **Step 3: Commit** + +```bash +git add src/types.rs +git commit -m "feat: add all domain types with serde support" +``` + +--- + +### Task 5: ExtismCore (WASM Runtime) + +**Files:** +- Create: `src/core_extism.rs` +- Copy: `wasm/core.wasm` from Go SDK + +- [ ] **Step 1: Copy the WASM binary** + +```bash +mkdir -p wasm +cp /tmp/onepassword-sdk-go/internal/wasm/core.wasm wasm/core.wasm +``` + +- [ ] **Step 2: Write `src/core_extism.rs`** + +```rust +use std::sync::Mutex; + +use extism::{host_fn, Manifest, Plugin, PluginBuilder, Wasm}; + +use crate::core::{Core, MESSAGE_LIMIT}; +use crate::errors::SdkError; + +static CORE_WASM: &[u8] = include_bytes!("../wasm/core.wasm"); + +const INVOKE_FUNC: &str = "invoke"; +const INIT_CLIENT_FUNC: &str = "init_client"; +const RELEASE_CLIENT_FUNC: &str = "release_client"; + +pub(crate) struct ExtismCore { + plugin: Mutex, +} + +impl ExtismCore { + pub fn new() -> Result { + let manifest = Manifest::new([Wasm::data(CORE_WASM)]) + .with_allowed_hosts(allowed_1p_hosts().into_iter()); + + let plugin = PluginBuilder::new(manifest) + .with_wasi(true) + .build() + .map_err(|e| SdkError::Plugin(format!("failed to initialize plugin: {e}")))?; + + Ok(Self { + plugin: Mutex::new(plugin), + }) + } +} + +impl Core for ExtismCore { + fn init_client(&self, config: &[u8]) -> Result, SdkError> { + let mut plugin = self.plugin.lock().unwrap(); + let res = plugin + .call::<&[u8], Vec>(INIT_CLIENT_FUNC, config) + .map_err(|e| SdkError::Plugin(e.to_string()))?; + Ok(res) + } + + fn invoke(&self, invoke_config: &[u8]) -> Result, SdkError> { + if invoke_config.len() > MESSAGE_LIMIT { + return Err(SdkError::Config(format!( + "message size exceeds the limit of {} bytes", + MESSAGE_LIMIT + ))); + } + let mut plugin = self.plugin.lock().unwrap(); + let res = plugin + .call::<&[u8], Vec>(INVOKE_FUNC, invoke_config) + .map_err(|e| SdkError::Plugin(e.to_string()))?; + Ok(res) + } + + fn release_client(&self, client_id: &[u8]) { + let mut plugin = self.plugin.lock().unwrap(); + let _ = plugin.call::<&[u8], Vec>(RELEASE_CLIENT_FUNC, client_id); + } +} + +fn allowed_1p_hosts() -> Vec { + [ + "*.1password.com", + "*.1password.ca", + "*.1password.eu", + "*.b5staging.com", + "*.b5dev.com", + "*.b5dev.ca", + "*.b5dev.eu", + "*.b5test.com", + "*.b5test.ca", + "*.b5test.eu", + "*.b5rev.com", + "*.b5local.com", + ] + .iter() + .map(|s| s.to_string()) + .collect() +} +``` + +**Note:** The Extism Rust SDK's API may differ from this sketch. The implementer must check the `extism` crate docs (use context7 or `cargo doc`) for the actual `PluginBuilder`/`Manifest`/`Plugin::call` API signatures. The Go SDK registers host functions for `random_fill_imported` (namespace `op-extism-core`), `unix_time_milliseconds_imported` (namespaces `op-now` and `zxcvbn`), and `utc_offset_seconds` (namespace `op-time`). These must be registered when building the plugin. The exact Rust API for host functions with namespaces needs to be looked up. If the Extism Rust SDK doesn't support namespaced host functions in the same way, this will need adaptation. + +- [ ] **Step 3: Verify it compiles** + +Run: `cargo check` +Expected: Should compile (or reveal Extism API differences to fix) + +- [ ] **Step 4: Commit** + +```bash +git add wasm/core.wasm src/core_extism.rs +git commit -m "feat: add ExtismCore WASM runtime with embedded core.wasm" +``` + +--- + +### Task 6: Client Builder + +**Files:** +- Create: `src/client.rs` + +- [ ] **Step 1: Write the Client and ClientBuilder** + +```rust +use std::collections::HashMap; +use std::sync::Arc; + +use crate::core::{ClientConfig, CoreWrapper, InnerClient, InvokeConfig, Invocation, Parameters}; +use crate::core_extism::ExtismCore; +use crate::errors::{unmarshal_error, SdkError}; +use crate::environments::{EnvironmentsApi, EnvironmentsSource}; +use crate::groups::{GroupsApi, GroupsSource}; +use crate::items::{ItemsApi, ItemsSource}; +use crate::secrets::{SecretsApi, SecretsSource}; +use crate::vaults::{VaultsApi, VaultsSource}; + +pub struct Client { + inner: Arc, +} + +impl Client { + pub fn builder() -> ClientBuilder { + ClientBuilder { + config: ClientConfig::new_default(), + } + } + + pub fn secrets(&self) -> impl SecretsApi + '_ { + SecretsSource::new(&self.inner) + } + + pub fn items(&self) -> impl ItemsApi + '_ { + ItemsSource::new(&self.inner) + } + + pub fn vaults(&self) -> impl VaultsApi + '_ { + VaultsSource::new(&self.inner) + } + + pub fn groups(&self) -> impl GroupsApi + '_ { + GroupsSource::new(&self.inner) + } + + pub fn environments(&self) -> impl EnvironmentsApi + '_ { + EnvironmentsSource::new(&self.inner) + } +} + +impl Drop for Client { + fn drop(&mut self) { + self.inner.core.release_client(self.inner.id); + } +} + +pub struct ClientBuilder { + config: ClientConfig, +} + +impl ClientBuilder { + pub fn service_account_token(mut self, token: &str) -> Self { + self.config.sa_token = token.to_string(); + self + } + + #[cfg(feature = "desktop")] + pub fn desktop_app_integration(mut self, account_name: &str) -> Self { + self.config.account_name = Some(account_name.to_string()); + self + } + + pub fn integration_info(mut self, name: &str, version: &str) -> Self { + self.config.integration_name = name.to_string(); + self.config.integration_version = version.to_string(); + self + } + + pub fn build(self) -> Result { + let has_sa_token = !self.config.sa_token.is_empty(); + let has_desktop = self.config.account_name.is_some(); + + if has_sa_token && has_desktop { + return Err(SdkError::Config( + "cannot use both SA token and desktop app authentication".to_string(), + )); + } + + let core_impl: Box = if has_desktop { + #[cfg(feature = "desktop")] + { + let account_name = self.config.account_name.as_ref().unwrap().clone(); + Box::new(crate::core_shared_lib::SharedLibCore::new(&account_name)?) + } + #[cfg(not(feature = "desktop"))] + { + return Err(SdkError::Config( + "desktop app integration requires the 'desktop' feature".to_string(), + )); + } + } else { + Box::new(ExtismCore::new()?) + }; + + let core = CoreWrapper { inner: core_impl }; + + let client_id = core + .init_client(&self.config) + .map_err(|e| SdkError::Config(format!("error initializing client: {e}")))?; + + let inner = Arc::new(InnerClient { + id: client_id, + config: self.config, + core, + }); + + Ok(Client { inner }) + } +} + +/// Invoke a method on the WASM core, with automatic retry on desktop session expiry. +pub(crate) fn client_invoke( + inner: &InnerClient, + method: &str, + params: HashMap, +) -> Result { + let invoke_config = InvokeConfig { + invocation: Invocation { + client_id: Some(inner.id), + parameters: Parameters { + name: method.to_string(), + parameters: params, + }, + }, + }; + + match inner.core.invoke(&invoke_config) { + Ok(response) => Ok(response), + Err(e) => Err(unmarshal_error(&e.to_string())), + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn builder_rejects_both_auth_methods() { + let mut builder = Client::builder() + .service_account_token("ops_test"); + builder.config.account_name = Some("myaccount".to_string()); + let result = builder.build(); + assert!(result.is_err()); + let err = result.unwrap_err().to_string(); + assert!(err.contains("cannot use both")); + } +} +``` + +- [ ] **Step 2: Run test** + +Run: `cargo test client::tests` +Expected: PASS + +- [ ] **Step 3: Commit** + +```bash +git add src/client.rs +git commit -m "feat: add Client struct and ClientBuilder with auth validation" +``` + +--- + +### Task 7: API Implementations — Secrets + +**Files:** +- Create: `src/secrets.rs` + +- [ ] **Step 1: Write SecretsApi trait and implementation** + +```rust +use std::collections::HashMap; + +use crate::client::client_invoke; +use crate::core::InnerClient; +use crate::errors::SdkError; +use crate::types::{GeneratePasswordResponse, PasswordRecipe, ResolveAllResponse}; + +pub trait SecretsApi { + fn resolve(&self, secret_reference: &str) -> Result; + fn resolve_all(&self, secret_references: &[String]) -> Result; +} + +pub(crate) struct SecretsSource<'a> { + inner: &'a InnerClient, +} + +impl<'a> SecretsSource<'a> { + pub fn new(inner: &'a InnerClient) -> Self { + Self { inner } + } +} + +impl SecretsApi for SecretsSource<'_> { + fn resolve(&self, secret_reference: &str) -> Result { + let mut params = HashMap::new(); + params.insert( + "secret_reference".to_string(), + serde_json::Value::String(secret_reference.to_string()), + ); + let result_string = client_invoke(self.inner, "SecretsResolve", params)?; + let result: String = serde_json::from_str(&result_string)?; + Ok(result) + } + + fn resolve_all(&self, secret_references: &[String]) -> Result { + let mut params = HashMap::new(); + params.insert( + "secret_references".to_string(), + serde_json::to_value(secret_references)?, + ); + let result_string = client_invoke(self.inner, "SecretsResolveAll", params)?; + let result: ResolveAllResponse = serde_json::from_str(&result_string)?; + Ok(result) + } +} + +/// Standalone secret utilities (no client required). +pub struct Secrets; + +impl Secrets { + pub fn validate_secret_reference(secret_reference: &str) -> Result<(), SdkError> { + let core = crate::core_extism::ExtismCore::new()?; + let core_wrapper = crate::core::CoreWrapper { + inner: Box::new(core), + }; + let invoke_config = crate::core::InvokeConfig { + invocation: crate::core::Invocation { + client_id: None, + parameters: crate::core::Parameters { + name: "ValidateSecretReference".to_string(), + parameters: { + let mut m = HashMap::new(); + m.insert( + "secret_reference".to_string(), + serde_json::Value::String(secret_reference.to_string()), + ); + m + }, + }, + }, + }; + core_wrapper.invoke(&invoke_config)?; + Ok(()) + } + + pub fn generate_password( + recipe: PasswordRecipe, + ) -> Result { + let core = crate::core_extism::ExtismCore::new()?; + let core_wrapper = crate::core::CoreWrapper { + inner: Box::new(core), + }; + let invoke_config = crate::core::InvokeConfig { + invocation: crate::core::Invocation { + client_id: None, + parameters: crate::core::Parameters { + name: "GeneratePassword".to_string(), + parameters: { + let mut m = HashMap::new(); + m.insert("recipe".to_string(), serde_json::to_value(&recipe)?); + m + }, + }, + }, + }; + let result_string = core_wrapper.invoke(&invoke_config)?; + let result: GeneratePasswordResponse = serde_json::from_str(&result_string)?; + Ok(result) + } +} +``` + +- [ ] **Step 2: Commit** + +```bash +git add src/secrets.rs +git commit -m "feat: add SecretsApi with resolve, resolve_all, and standalone utils" +``` + +--- + +### Task 8: API Implementations — Items, ItemsFiles, ItemsShares + +**Files:** +- Create: `src/items.rs` +- Create: `src/items_files.rs` +- Create: `src/items_shares.rs` + +- [ ] **Step 1: Write `src/items.rs`** + +```rust +use std::collections::HashMap; + +use crate::client::client_invoke; +use crate::core::InnerClient; +use crate::errors::SdkError; +use crate::items_files::{ItemsFilesApi, ItemsFilesSource}; +use crate::items_shares::{ItemsSharesApi, ItemsSharesSource}; +use crate::types::*; + +pub trait ItemsApi { + fn create(&self, params: ItemCreateParams) -> Result; + fn create_all( + &self, + vault_id: &str, + params: &[ItemCreateParams], + ) -> Result; + fn get(&self, vault_id: &str, item_id: &str) -> Result; + fn get_all( + &self, + vault_id: &str, + item_ids: &[String], + ) -> Result; + fn put(&self, item: Item) -> Result; + fn delete(&self, vault_id: &str, item_id: &str) -> Result<(), SdkError>; + fn delete_all( + &self, + vault_id: &str, + item_ids: &[String], + ) -> Result; + fn archive(&self, vault_id: &str, item_id: &str) -> Result<(), SdkError>; + fn list( + &self, + vault_id: &str, + filters: &[ItemListFilter], + ) -> Result, SdkError>; + fn shares(&self) -> impl ItemsSharesApi + '_; + fn files(&self) -> impl ItemsFilesApi + '_; +} + +pub(crate) struct ItemsSource<'a> { + inner: &'a InnerClient, +} + +impl<'a> ItemsSource<'a> { + pub fn new(inner: &'a InnerClient) -> Self { + Self { inner } + } +} + +impl ItemsApi for ItemsSource<'_> { + fn create(&self, params: ItemCreateParams) -> Result { + let mut p = HashMap::new(); + p.insert("params".to_string(), serde_json::to_value(¶ms)?); + let result_string = client_invoke(self.inner, "ItemsCreate", p)?; + Ok(serde_json::from_str(&result_string)?) + } + + fn create_all( + &self, + vault_id: &str, + params: &[ItemCreateParams], + ) -> Result { + let mut p = HashMap::new(); + p.insert( + "vault_id".to_string(), + serde_json::Value::String(vault_id.to_string()), + ); + p.insert("params".to_string(), serde_json::to_value(params)?); + let result_string = client_invoke(self.inner, "ItemsCreateAll", p)?; + Ok(serde_json::from_str(&result_string)?) + } + + fn get(&self, vault_id: &str, item_id: &str) -> Result { + let mut p = HashMap::new(); + p.insert( + "vault_id".to_string(), + serde_json::Value::String(vault_id.to_string()), + ); + p.insert( + "item_id".to_string(), + serde_json::Value::String(item_id.to_string()), + ); + let result_string = client_invoke(self.inner, "ItemsGet", p)?; + Ok(serde_json::from_str(&result_string)?) + } + + fn get_all( + &self, + vault_id: &str, + item_ids: &[String], + ) -> Result { + let mut p = HashMap::new(); + p.insert( + "vault_id".to_string(), + serde_json::Value::String(vault_id.to_string()), + ); + p.insert("item_ids".to_string(), serde_json::to_value(item_ids)?); + let result_string = client_invoke(self.inner, "ItemsGetAll", p)?; + Ok(serde_json::from_str(&result_string)?) + } + + fn put(&self, item: Item) -> Result { + let mut p = HashMap::new(); + p.insert("item".to_string(), serde_json::to_value(&item)?); + let result_string = client_invoke(self.inner, "ItemsPut", p)?; + Ok(serde_json::from_str(&result_string)?) + } + + fn delete(&self, vault_id: &str, item_id: &str) -> Result<(), SdkError> { + let mut p = HashMap::new(); + p.insert( + "vault_id".to_string(), + serde_json::Value::String(vault_id.to_string()), + ); + p.insert( + "item_id".to_string(), + serde_json::Value::String(item_id.to_string()), + ); + client_invoke(self.inner, "ItemsDelete", p)?; + Ok(()) + } + + fn delete_all( + &self, + vault_id: &str, + item_ids: &[String], + ) -> Result { + let mut p = HashMap::new(); + p.insert( + "vault_id".to_string(), + serde_json::Value::String(vault_id.to_string()), + ); + p.insert("item_ids".to_string(), serde_json::to_value(item_ids)?); + let result_string = client_invoke(self.inner, "ItemsDeleteAll", p)?; + Ok(serde_json::from_str(&result_string)?) + } + + fn archive(&self, vault_id: &str, item_id: &str) -> Result<(), SdkError> { + let mut p = HashMap::new(); + p.insert( + "vault_id".to_string(), + serde_json::Value::String(vault_id.to_string()), + ); + p.insert( + "item_id".to_string(), + serde_json::Value::String(item_id.to_string()), + ); + client_invoke(self.inner, "ItemsArchive", p)?; + Ok(()) + } + + fn list( + &self, + vault_id: &str, + filters: &[ItemListFilter], + ) -> Result, SdkError> { + let mut p = HashMap::new(); + p.insert( + "vault_id".to_string(), + serde_json::Value::String(vault_id.to_string()), + ); + p.insert("filters".to_string(), serde_json::to_value(filters)?); + let result_string = client_invoke(self.inner, "ItemsList", p)?; + Ok(serde_json::from_str(&result_string)?) + } + + fn shares(&self) -> impl ItemsSharesApi + '_ { + ItemsSharesSource::new(self.inner) + } + + fn files(&self) -> impl ItemsFilesApi + '_ { + ItemsFilesSource::new(self.inner) + } +} +``` + +- [ ] **Step 2: Write `src/items_files.rs`** + +```rust +use std::collections::HashMap; + +use crate::client::client_invoke; +use crate::core::InnerClient; +use crate::errors::SdkError; +use crate::types::*; + +pub trait ItemsFilesApi { + fn attach(&self, item: Item, file_params: FileCreateParams) -> Result; + fn read( + &self, + vault_id: &str, + item_id: &str, + attr: FileAttributes, + ) -> Result, SdkError>; + fn delete(&self, item: Item, section_id: &str, field_id: &str) -> Result; + fn replace_document( + &self, + item: Item, + doc_params: DocumentCreateParams, + ) -> Result; +} + +pub(crate) struct ItemsFilesSource<'a> { + inner: &'a InnerClient, +} + +impl<'a> ItemsFilesSource<'a> { + pub fn new(inner: &'a InnerClient) -> Self { + Self { inner } + } +} + +impl ItemsFilesApi for ItemsFilesSource<'_> { + fn attach(&self, item: Item, file_params: FileCreateParams) -> Result { + let mut p = HashMap::new(); + p.insert("item".to_string(), serde_json::to_value(&item)?); + p.insert("file_params".to_string(), serde_json::to_value(&file_params)?); + let result_string = client_invoke(self.inner, "ItemsFilesAttach", p)?; + Ok(serde_json::from_str(&result_string)?) + } + + fn read( + &self, + vault_id: &str, + item_id: &str, + attr: FileAttributes, + ) -> Result, SdkError> { + let mut p = HashMap::new(); + p.insert( + "vault_id".to_string(), + serde_json::Value::String(vault_id.to_string()), + ); + p.insert( + "item_id".to_string(), + serde_json::Value::String(item_id.to_string()), + ); + p.insert("attr".to_string(), serde_json::to_value(&attr)?); + let result_string = client_invoke(self.inner, "ItemsFilesRead", p)?; + let result: Vec = serde_json::from_str(&result_string)?; + Ok(result) + } + + fn delete(&self, item: Item, section_id: &str, field_id: &str) -> Result { + let mut p = HashMap::new(); + p.insert("item".to_string(), serde_json::to_value(&item)?); + p.insert( + "section_id".to_string(), + serde_json::Value::String(section_id.to_string()), + ); + p.insert( + "field_id".to_string(), + serde_json::Value::String(field_id.to_string()), + ); + let result_string = client_invoke(self.inner, "ItemsFilesDelete", p)?; + Ok(serde_json::from_str(&result_string)?) + } + + fn replace_document( + &self, + item: Item, + doc_params: DocumentCreateParams, + ) -> Result { + let mut p = HashMap::new(); + p.insert("item".to_string(), serde_json::to_value(&item)?); + p.insert("doc_params".to_string(), serde_json::to_value(&doc_params)?); + let result_string = client_invoke(self.inner, "ItemsFilesReplaceDocument", p)?; + Ok(serde_json::from_str(&result_string)?) + } +} +``` + +- [ ] **Step 3: Write `src/items_shares.rs`** + +```rust +use std::collections::HashMap; + +use crate::client::client_invoke; +use crate::core::InnerClient; +use crate::errors::SdkError; +use crate::types::*; + +pub trait ItemsSharesApi { + fn get_account_policy( + &self, + vault_id: &str, + item_id: &str, + ) -> Result; + fn validate_recipients( + &self, + policy: ItemShareAccountPolicy, + recipients: &[String], + ) -> Result, SdkError>; + fn create( + &self, + item: Item, + policy: ItemShareAccountPolicy, + params: ItemShareParams, + ) -> Result; +} + +pub(crate) struct ItemsSharesSource<'a> { + inner: &'a InnerClient, +} + +impl<'a> ItemsSharesSource<'a> { + pub fn new(inner: &'a InnerClient) -> Self { + Self { inner } + } +} + +impl ItemsSharesApi for ItemsSharesSource<'_> { + fn get_account_policy( + &self, + vault_id: &str, + item_id: &str, + ) -> Result { + let mut p = HashMap::new(); + p.insert( + "vault_id".to_string(), + serde_json::Value::String(vault_id.to_string()), + ); + p.insert( + "item_id".to_string(), + serde_json::Value::String(item_id.to_string()), + ); + let result_string = client_invoke(self.inner, "ItemsSharesGetAccountPolicy", p)?; + Ok(serde_json::from_str(&result_string)?) + } + + fn validate_recipients( + &self, + policy: ItemShareAccountPolicy, + recipients: &[String], + ) -> Result, SdkError> { + let mut p = HashMap::new(); + p.insert("policy".to_string(), serde_json::to_value(&policy)?); + p.insert("recipients".to_string(), serde_json::to_value(recipients)?); + let result_string = + client_invoke(self.inner, "ItemsSharesValidateRecipients", p)?; + Ok(serde_json::from_str(&result_string)?) + } + + fn create( + &self, + item: Item, + policy: ItemShareAccountPolicy, + params: ItemShareParams, + ) -> Result { + let mut p = HashMap::new(); + p.insert("item".to_string(), serde_json::to_value(&item)?); + p.insert("policy".to_string(), serde_json::to_value(&policy)?); + p.insert("params".to_string(), serde_json::to_value(¶ms)?); + let result_string = client_invoke(self.inner, "ItemsSharesCreate", p)?; + Ok(serde_json::from_str(&result_string)?) + } +} +``` + +- [ ] **Step 4: Commit** + +```bash +git add src/items.rs src/items_files.rs src/items_shares.rs +git commit -m "feat: add ItemsApi, ItemsFilesApi, and ItemsSharesApi" +``` + +--- + +### Task 9: API Implementations — Vaults, Groups, Environments + +**Files:** +- Create: `src/vaults.rs` +- Create: `src/groups.rs` +- Create: `src/environments.rs` + +- [ ] **Step 1: Write `src/vaults.rs`** + +```rust +use std::collections::HashMap; + +use crate::client::client_invoke; +use crate::core::InnerClient; +use crate::errors::SdkError; +use crate::types::*; + +pub trait VaultsApi { + fn create(&self, params: VaultCreateParams) -> Result; + fn list(&self, params: Option) -> Result, SdkError>; + fn get_overview(&self, vault_id: &str) -> Result; + fn get(&self, vault_id: &str, params: VaultGetParams) -> Result; + fn update(&self, vault_id: &str, params: VaultUpdateParams) -> Result; + fn delete(&self, vault_id: &str) -> Result<(), SdkError>; + fn grant_group_permissions( + &self, + vault_id: &str, + group_permissions: &[GroupAccess], + ) -> Result<(), SdkError>; + fn update_group_permissions( + &self, + group_permissions: &[GroupVaultAccess], + ) -> Result<(), SdkError>; + fn revoke_group_permissions( + &self, + vault_id: &str, + group_id: &str, + ) -> Result<(), SdkError>; +} + +pub(crate) struct VaultsSource<'a> { + inner: &'a InnerClient, +} + +impl<'a> VaultsSource<'a> { + pub fn new(inner: &'a InnerClient) -> Self { + Self { inner } + } +} + +impl VaultsApi for VaultsSource<'_> { + fn create(&self, params: VaultCreateParams) -> Result { + let mut p = HashMap::new(); + p.insert("params".to_string(), serde_json::to_value(¶ms)?); + let result_string = client_invoke(self.inner, "VaultsCreate", p)?; + Ok(serde_json::from_str(&result_string)?) + } + + fn list(&self, params: Option) -> Result, SdkError> { + let mut p = HashMap::new(); + p.insert("params".to_string(), serde_json::to_value(¶ms)?); + let result_string = client_invoke(self.inner, "VaultsList", p)?; + Ok(serde_json::from_str(&result_string)?) + } + + fn get_overview(&self, vault_id: &str) -> Result { + let mut p = HashMap::new(); + p.insert( + "vault_id".to_string(), + serde_json::Value::String(vault_id.to_string()), + ); + let result_string = client_invoke(self.inner, "VaultsGetOverview", p)?; + Ok(serde_json::from_str(&result_string)?) + } + + fn get(&self, vault_id: &str, params: VaultGetParams) -> Result { + let mut p = HashMap::new(); + p.insert( + "vault_id".to_string(), + serde_json::Value::String(vault_id.to_string()), + ); + p.insert("vault_params".to_string(), serde_json::to_value(¶ms)?); + let result_string = client_invoke(self.inner, "VaultsGet", p)?; + Ok(serde_json::from_str(&result_string)?) + } + + fn update(&self, vault_id: &str, params: VaultUpdateParams) -> Result { + let mut p = HashMap::new(); + p.insert( + "vault_id".to_string(), + serde_json::Value::String(vault_id.to_string()), + ); + p.insert("params".to_string(), serde_json::to_value(¶ms)?); + let result_string = client_invoke(self.inner, "VaultsUpdate", p)?; + Ok(serde_json::from_str(&result_string)?) + } + + fn delete(&self, vault_id: &str) -> Result<(), SdkError> { + let mut p = HashMap::new(); + p.insert( + "vault_id".to_string(), + serde_json::Value::String(vault_id.to_string()), + ); + client_invoke(self.inner, "VaultsDelete", p)?; + Ok(()) + } + + fn grant_group_permissions( + &self, + vault_id: &str, + group_permissions: &[GroupAccess], + ) -> Result<(), SdkError> { + let mut p = HashMap::new(); + p.insert( + "vault_id".to_string(), + serde_json::Value::String(vault_id.to_string()), + ); + p.insert( + "group_permissions_list".to_string(), + serde_json::to_value(group_permissions)?, + ); + client_invoke(self.inner, "VaultsGrantGroupPermissions", p)?; + Ok(()) + } + + fn update_group_permissions( + &self, + group_permissions: &[GroupVaultAccess], + ) -> Result<(), SdkError> { + let mut p = HashMap::new(); + p.insert( + "group_permissions_list".to_string(), + serde_json::to_value(group_permissions)?, + ); + client_invoke(self.inner, "VaultsUpdateGroupPermissions", p)?; + Ok(()) + } + + fn revoke_group_permissions( + &self, + vault_id: &str, + group_id: &str, + ) -> Result<(), SdkError> { + let mut p = HashMap::new(); + p.insert( + "vault_id".to_string(), + serde_json::Value::String(vault_id.to_string()), + ); + p.insert( + "group_id".to_string(), + serde_json::Value::String(group_id.to_string()), + ); + client_invoke(self.inner, "VaultsRevokeGroupPermissions", p)?; + Ok(()) + } +} +``` + +- [ ] **Step 2: Write `src/groups.rs`** + +```rust +use std::collections::HashMap; + +use crate::client::client_invoke; +use crate::core::InnerClient; +use crate::errors::SdkError; +use crate::types::*; + +pub trait GroupsApi { + fn get(&self, group_id: &str, params: GroupGetParams) -> Result; +} + +pub(crate) struct GroupsSource<'a> { + inner: &'a InnerClient, +} + +impl<'a> GroupsSource<'a> { + pub fn new(inner: &'a InnerClient) -> Self { + Self { inner } + } +} + +impl GroupsApi for GroupsSource<'_> { + fn get(&self, group_id: &str, params: GroupGetParams) -> Result { + let mut p = HashMap::new(); + p.insert( + "group_id".to_string(), + serde_json::Value::String(group_id.to_string()), + ); + p.insert("group_params".to_string(), serde_json::to_value(¶ms)?); + let result_string = client_invoke(self.inner, "GroupsGet", p)?; + Ok(serde_json::from_str(&result_string)?) + } +} +``` + +- [ ] **Step 3: Write `src/environments.rs`** + +```rust +use std::collections::HashMap; + +use crate::client::client_invoke; +use crate::core::InnerClient; +use crate::errors::SdkError; +use crate::types::GetVariablesResponse; + +pub trait EnvironmentsApi { + fn get_variables(&self, environment_id: &str) -> Result; +} + +pub(crate) struct EnvironmentsSource<'a> { + inner: &'a InnerClient, +} + +impl<'a> EnvironmentsSource<'a> { + pub fn new(inner: &'a InnerClient) -> Self { + Self { inner } + } +} + +impl EnvironmentsApi for EnvironmentsSource<'_> { + fn get_variables(&self, environment_id: &str) -> Result { + let mut p = HashMap::new(); + p.insert( + "environment_id".to_string(), + serde_json::Value::String(environment_id.to_string()), + ); + let result_string = client_invoke(self.inner, "EnvironmentsGetVariables", p)?; + Ok(serde_json::from_str(&result_string)?) + } +} +``` + +- [ ] **Step 4: Verify full crate compiles** + +Run: `cargo check` +Expected: PASS (no desktop feature, so shared_lib module is excluded) + +- [ ] **Step 5: Run all tests** + +Run: `cargo test` +Expected: PASS + +- [ ] **Step 6: Commit** + +```bash +git add src/vaults.rs src/groups.rs src/environments.rs +git commit -m "feat: add VaultsApi, GroupsApi, and EnvironmentsApi" +``` + +--- + +### Task 10: SharedLibCore (Desktop App Integration) + +**Files:** +- Create: `src/core_shared_lib.rs` + +- [ ] **Step 1: Write `src/core_shared_lib.rs`** + +This file uses `#[allow(unsafe_code)]` for FFI operations. It uses `libloading` for cross-platform dlopen/LoadLibrary. + +```rust +#![allow(unsafe_code)] + +use std::ffi::c_void; +use std::path::PathBuf; + +use libloading::{Library, Symbol}; +use serde::{Deserialize, Serialize}; + +use crate::core::Core; +use crate::errors::SdkError; + +#[derive(Serialize)] +struct Request<'a> { + kind: &'a str, + account_name: &'a str, + payload: &'a [u8], +} + +#[derive(Deserialize)] +struct Response { + success: bool, + payload: Vec, +} + +type SendMessageFn = unsafe extern "C" fn( + msg_ptr: *const u8, + msg_len: usize, + out_buf: *mut *mut u8, + out_len: *mut usize, + out_cap: *mut usize, +) -> i32; + +type FreeResponseFn = unsafe extern "C" fn(buf: *mut u8, len: usize, cap: usize); + +pub(crate) struct SharedLibCore { + account_name: String, + _library: Library, + send_message: SendMessageFn, + free_response: FreeResponseFn, +} + +// SAFETY: The shared library functions are thread-safe according to 1Password's documentation. +// The Go SDK also uses them across goroutines. +unsafe impl Send for SharedLibCore {} +unsafe impl Sync for SharedLibCore {} + +impl SharedLibCore { + pub fn new(account_name: &str) -> Result { + let lib_path = find_1password_lib_path()?; + + let library = unsafe { + Library::new(&lib_path) + .map_err(|e| SdkError::SharedLib(format!("failed to open library: {e}")))? + }; + + let send_message: SendMessageFn = unsafe { + let sym: Symbol = library + .get(b"op_sdk_ipc_send_message") + .map_err(|e| SdkError::SharedLib(format!("failed to load send_message: {e}")))?; + *sym + }; + + let free_response: FreeResponseFn = unsafe { + let sym: Symbol = library + .get(b"op_sdk_ipc_free_response") + .map_err(|e| SdkError::SharedLib(format!("failed to load free_message: {e}")))?; + *sym + }; + + Ok(Self { + account_name: account_name.to_string(), + _library: library, + send_message, + free_response, + }) + } + + fn call_shared_library(&self, kind: &str, payload: &[u8]) -> Result, SdkError> { + let request = Request { + kind, + account_name: &self.account_name, + payload, + }; + let input = serde_json::to_vec(&request)?; + + let mut out_buf: *mut u8 = std::ptr::null_mut(); + let mut out_len: usize = 0; + let mut out_cap: usize = 0; + + let ret_code = unsafe { + (self.send_message)( + input.as_ptr(), + input.len(), + &mut out_buf, + &mut out_len, + &mut out_cap, + ) + }; + + error_from_return_code(ret_code)?; + + let resp_bytes = unsafe { std::slice::from_raw_parts(out_buf, out_len).to_vec() }; + + unsafe { + (self.free_response)(out_buf, out_len, out_cap); + } + + let response: Response = serde_json::from_slice(&resp_bytes) + .map_err(|e| SdkError::SharedLib(format!("failed to parse response: {e}")))?; + + if response.success { + Ok(response.payload) + } else { + Err(SdkError::SharedLib( + String::from_utf8_lossy(&response.payload).into_owned(), + )) + } + } +} + +impl Core for SharedLibCore { + fn init_client(&self, config: &[u8]) -> Result, SdkError> { + self.call_shared_library("init_client", config) + } + + fn invoke(&self, invoke_config: &[u8]) -> Result, SdkError> { + self.call_shared_library("invoke", invoke_config) + } + + fn release_client(&self, client_id: &[u8]) { + let _ = self.call_shared_library("release_client", client_id); + } +} + +fn find_1password_lib_path() -> Result { + let home = dirs_next::home_dir() + .or_else(|| std::env::var("HOME").ok().map(PathBuf::from)) + .unwrap_or_default(); + + let locations: Vec = if cfg!(target_os = "macos") { + vec![ + PathBuf::from("/Applications/1Password.app/Contents/Frameworks/libop_sdk_ipc_client.dylib"), + home.join("Applications/1Password.app/Contents/Frameworks/libop_sdk_ipc_client.dylib"), + ] + } else if cfg!(target_os = "linux") { + vec![ + PathBuf::from("/usr/bin/1password/libop_sdk_ipc_client.so"), + PathBuf::from("/opt/1Password/libop_sdk_ipc_client.so"), + PathBuf::from("/snap/bin/1password/libop_sdk_ipc_client.so"), + ] + } else if cfg!(target_os = "windows") { + vec![ + home.join(r"AppData\Local\1Password\op_sdk_ipc_client.dll"), + PathBuf::from(r"C:\Program Files\1Password\app\8\op_sdk_ipc_client.dll"), + PathBuf::from(r"C:\Program Files (x86)\1Password\app\8\op_sdk_ipc_client.dll"), + home.join(r"AppData\Local\1Password\app\8\op_sdk_ipc_client.dll"), + ] + } else { + return Err(SdkError::SharedLib(format!( + "unsupported OS: {}", + std::env::consts::OS + ))); + }; + + for path in &locations { + if path.exists() { + return Ok(path.clone()); + } + } + + Err(SdkError::SharedLib( + "1Password desktop application not found".to_string(), + )) +} + +fn error_from_return_code(ret_code: i32) -> Result<(), SdkError> { + if ret_code == 0 { + return Ok(()); + } + + let msg = if cfg!(target_os = "macos") { + match ret_code { + -3 => "desktop app connection channel is closed. Make sure Settings > Developer > Integrate with other apps is enabled".to_string(), + -7 => "connection was unexpectedly dropped by the desktop app. Make sure the desktop app is running".to_string(), + _ => format!("an internal error occurred. Return code: {ret_code}"), + } + } else { + match ret_code { + -2 => "desktop app connection channel is closed. Make sure Settings > Developer > Integrate with other apps is enabled".to_string(), + -5 => "connection was unexpectedly dropped by the desktop app. Make sure the desktop app is running".to_string(), + _ => format!("an internal error occurred. Return code: {ret_code}"), + } + }; + + Err(SdkError::SharedLib(msg)) +} +``` + +**Note:** The `dirs_next` crate is used for `home_dir()`. Add it to `Cargo.toml`: + +```toml +[dependencies] +# ... existing deps ... +dirs-next = { version = "2", optional = true } + +[features] +desktop = ["dep:libloading", "dep:dirs-next"] +``` + +Alternatively, use `std::env::var("HOME")` directly and skip the extra dep. The implementer should decide. + +- [ ] **Step 2: Verify it compiles with the desktop feature** + +Run: `cargo check --features desktop` +Expected: PASS + +- [ ] **Step 3: Commit** + +```bash +git add src/core_shared_lib.rs +git commit -m "feat: add SharedLibCore for desktop app integration" +``` + +--- + +### Task 11: Examples + +**Files:** +- Create: `examples/service_account.rs` +- Create: `examples/desktop_app.rs` + +- [ ] **Step 1: Write `examples/service_account.rs`** + +```rust +use onepassword_sdk::{Client, SecretsApi}; + +fn main() { + let token = std::env::var("OP_SERVICE_ACCOUNT_TOKEN") + .expect("Set OP_SERVICE_ACCOUNT_TOKEN environment variable"); + + let client = Client::builder() + .service_account_token(&token) + .integration_info("My Rust App", "v1.0.0") + .build() + .expect("Failed to create client"); + + let secret = client + .secrets() + .resolve("op://vault/item/field") + .expect("Failed to resolve secret"); + + println!("Secret: {secret}"); +} +``` + +- [ ] **Step 2: Write `examples/desktop_app.rs`** + +```rust +#[cfg(feature = "desktop")] +fn main() { + use onepassword_sdk::{Client, SecretsApi}; + + let client = Client::builder() + .desktop_app_integration("my-account") + .integration_info("My Rust App", "v1.0.0") + .build() + .expect("Failed to create client"); + + let secret = client + .secrets() + .resolve("op://vault/item/field") + .expect("Failed to resolve secret"); + + println!("Secret: {secret}"); +} + +#[cfg(not(feature = "desktop"))] +fn main() { + eprintln!("This example requires the 'desktop' feature: cargo run --example desktop_app --features desktop"); +} +``` + +- [ ] **Step 3: Commit** + +```bash +git add examples/ +git commit -m "feat: add service_account and desktop_app examples" +``` + +--- + +### Task 12: CI Workflow + +**Files:** +- Create: `.github/workflows/ci.yml` + +- [ ] **Step 1: Write `.github/workflows/ci.yml`** + +```yaml +name: CI + +on: + pull_request: + push: + branches: [main] + +jobs: + check: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: dtolnay/rust-toolchain@stable + with: + toolchain: "1.93.1" + components: rustfmt, clippy + + - name: Check formatting + run: cargo fmt --check + + - name: Clippy + run: cargo clippy --all-features -- -D warnings + + - name: Test + run: cargo test + + - name: Test (desktop feature) + run: cargo test --features desktop + + deny: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: EmbarkStudios/cargo-deny-action@v2 +``` + +- [ ] **Step 2: Commit** + +```bash +git add .github/workflows/ci.yml +git commit -m "ci: add fmt, clippy, test, and cargo-deny checks" +``` + +--- + +### Task 13: Final Verification + +- [ ] **Step 1: Run fmt** + +Run: `cargo fmt --check` +Expected: PASS + +- [ ] **Step 2: Run clippy** + +Run: `cargo clippy -- -D warnings` +Expected: PASS (fix any warnings) + +- [ ] **Step 3: Run all tests** + +Run: `cargo test` +Expected: PASS + +- [ ] **Step 4: Run clippy with desktop feature** + +Run: `cargo clippy --features desktop -- -D warnings` +Expected: PASS + +- [ ] **Step 5: Verify the crate compiles with all features** + +Run: `cargo build --all-features` +Expected: PASS + +- [ ] **Step 6: Final commit (if any fixes were needed)** + +```bash +git add -A +git commit -m "fix: address clippy and formatting issues" +``` From 0c2481f17f038b2879d7f91fd15b32104a4d3c0f Mon Sep 17 00:00:00 2001 From: Matthew Kern Date: Mon, 30 Mar 2026 17:06:32 -0700 Subject: [PATCH 03/25] feat: add project scaffolding, error types, core trait, and domain types --- .gitignore | 4 + CLAUDE.md | 27 + Cargo.lock | 3225 +++++++++++++++++++++++++++++++++++++++++++ Cargo.toml | 22 + deny.toml | 31 + rust-toolchain.toml | 3 + src/core.rs | 152 ++ src/errors.rs | 87 ++ src/lib.rs | 10 + src/types.rs | 676 +++++++++ 10 files changed, 4237 insertions(+) create mode 100644 .gitignore create mode 100644 CLAUDE.md create mode 100644 Cargo.lock create mode 100644 Cargo.toml create mode 100644 deny.toml create mode 100644 rust-toolchain.toml create mode 100644 src/core.rs create mode 100644 src/errors.rs create mode 100644 src/lib.rs create mode 100644 src/types.rs diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..614cea5 --- /dev/null +++ b/.gitignore @@ -0,0 +1,4 @@ +/target +.DS_Store +.idea/ +*.swp diff --git a/CLAUDE.md b/CLAUDE.md new file mode 100644 index 0000000..0603fba --- /dev/null +++ b/CLAUDE.md @@ -0,0 +1,27 @@ +# 1Password Rust SDK + +## Build Commands + +- `cargo fmt --check` — check formatting +- `cargo clippy -- -D warnings` — lint +- `cargo test` — run tests +- `cargo build` — build (default features) +- `cargo build --features desktop` — build with desktop app integration + +## Conventions + +- Edition 2024, Rust 1.93.1 +- `#![deny(unsafe_code)]` at crate root; `#[allow(unsafe_code)]` only on FFI modules +- `thiserror` for error types +- `serde` for all JSON serialization +- Inline `#[cfg(test)] mod tests` blocks +- Conventional commits: `type(scope): description` +- Run `cargo fmt --check && cargo clippy -- -D warnings && cargo test` before pushing +- Do NOT add `Co-Authored-By: Claude` lines to commit messages + +## Architecture + +Typed wrapper around an opaque WASM core binary. All API calls serialize params to JSON, +call `Core::invoke()`, and deserialize the response. Two core backends: +- `ExtismCore` (default) — embedded WASM via Extism +- `SharedLibCore` (feature: `desktop`) — native shared library from 1Password desktop app diff --git a/Cargo.lock b/Cargo.lock new file mode 100644 index 0000000..511d233 --- /dev/null +++ b/Cargo.lock @@ -0,0 +1,3225 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "addr2line" +version = "0.25.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1b5d307320b3181d6d7954e663bd7c774a838b8220fe0593c86d9fb09f498b4b" +dependencies = [ + "gimli", +] + +[[package]] +name = "adler2" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa" + +[[package]] +name = "aho-corasick" +version = "1.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301" +dependencies = [ + "memchr", +] + +[[package]] +name = "allocator-api2" +version = "0.2.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923" + +[[package]] +name = "ambient-authority" +version = "0.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e9d4ee0d472d1cd2e28c97dfa124b3d8d992e10eb0a035f33f5d12e3a177ba3b" + +[[package]] +name = "android_system_properties" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311" +dependencies = [ + "libc", +] + +[[package]] +name = "anyhow" +version = "1.0.102" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c" + +[[package]] +name = "arbitrary" +version = "1.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c3d036a3c4ab069c7b410a2ce876bd74808d2d0888a82667669f8e783a898bf1" + +[[package]] +name = "async-trait" +version = "0.1.89" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "autocfg" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8" + +[[package]] +name = "base64" +version = "0.22.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6" + +[[package]] +name = "bitflags" +version = "2.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "843867be96c8daad0d758b57df9392b6d8d271134fce549de6ce169ff98a92af" + +[[package]] +name = "bitmaps" +version = "2.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "031043d04099746d8db04daf1fa424b2bc8bd69d92b25962dcde24da39ab64a2" +dependencies = [ + "typenum", +] + +[[package]] +name = "block-buffer" +version = "0.10.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71" +dependencies = [ + "generic-array", +] + +[[package]] +name = "bumpalo" +version = "3.20.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d20789868f4b01b2f2caec9f5c4e0213b41e3e5702a50157d699ae31ced2fcb" +dependencies = [ + "allocator-api2", +] + +[[package]] +name = "bytemuck" +version = "1.25.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c8efb64bd706a16a1bdde310ae86b351e4d21550d98d056f22f8a7f7a2183fec" + +[[package]] +name = "bytes" +version = "1.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33" + +[[package]] +name = "cap-fs-ext" +version = "3.4.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d5528f85b1e134ae811704e41ef80930f56e795923f866813255bc342cc20654" +dependencies = [ + "cap-primitives", + "cap-std", + "io-lifetimes", + "windows-sys 0.59.0", +] + +[[package]] +name = "cap-primitives" +version = "3.4.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6cf3aea8a5081171859ef57bc1606b1df6999df4f1110f8eef68b30098d1d3a" +dependencies = [ + "ambient-authority", + "fs-set-times", + "io-extras", + "io-lifetimes", + "ipnet", + "maybe-owned", + "rustix 1.1.4", + "rustix-linux-procfs", + "windows-sys 0.59.0", + "winx", +] + +[[package]] +name = "cap-rand" +version = "3.4.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8144c22e24bbcf26ade86cb6501a0916c46b7e4787abdb0045a467eb1645a1d" +dependencies = [ + "ambient-authority", + "rand", +] + +[[package]] +name = "cap-std" +version = "3.4.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6dc3090992a735d23219de5c204927163d922f42f575a0189b005c62d37549a" +dependencies = [ + "cap-primitives", + "io-extras", + "io-lifetimes", + "rustix 1.1.4", +] + +[[package]] +name = "cap-time-ext" +version = "3.4.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "def102506ce40c11710a9b16e614af0cde8e76ae51b1f48c04b8d79f4b671a80" +dependencies = [ + "ambient-authority", + "cap-primitives", + "iana-time-zone", + "once_cell", + "rustix 1.1.4", + "winx", +] + +[[package]] +name = "cbindgen" +version = "0.29.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "befbfd072a8e81c02f8c507aefce431fe5e7d051f83d48a23ffc9b9fe5a11799" +dependencies = [ + "heck", + "indexmap", + "log", + "proc-macro2", + "quote", + "serde", + "serde_json", + "syn", + "tempfile", + "toml", +] + +[[package]] +name = "cc" +version = "1.2.58" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e1e928d4b69e3077709075a938a05ffbedfa53a84c8f766efbf8220bb1ff60e1" +dependencies = [ + "find-msvc-tools", + "jobserver", + "libc", + "shlex", +] + +[[package]] +name = "cfg-if" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801" + +[[package]] +name = "chrono" +version = "0.4.44" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c673075a2e0e5f4a1dde27ce9dee1ea4558c7ffe648f576438a20ca1d2acc4b0" +dependencies = [ + "iana-time-zone", + "num-traits", + "windows-link", +] + +[[package]] +name = "cobs" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0fa961b519f0b462e3a3b4a34b64d119eeaca1d59af726fe450bbba07a9fc0a1" +dependencies = [ + "thiserror 2.0.18", +] + +[[package]] +name = "core-foundation-sys" +version = "0.8.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b" + +[[package]] +name = "cpp_demangle" +version = "0.4.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2bb79cb74d735044c972aae58ed0aaa9a837e85b01106a54c39e42e97f62253" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "cpufeatures" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280" +dependencies = [ + "libc", +] + +[[package]] +name = "cranelift-assembler-x64" +version = "0.128.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "50a04121a197fde2fe896f8e7cac9812fc41ed6ee9c63e1906090f9f497845f6" +dependencies = [ + "cranelift-assembler-x64-meta", +] + +[[package]] +name = "cranelift-assembler-x64-meta" +version = "0.128.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a09e699a94f477303820fb2167024f091543d6240783a2d3b01a3f21c42bc744" +dependencies = [ + "cranelift-srcgen", +] + +[[package]] +name = "cranelift-bforest" +version = "0.128.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f07732c662a9755529e332d86f8c5842171f6e98ba4d5976a178043dad838654" +dependencies = [ + "cranelift-entity", +] + +[[package]] +name = "cranelift-bitset" +version = "0.128.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "18391da761cf362a06def7a7cf11474d79e55801dd34c2e9ba105b33dc0aef88" +dependencies = [ + "serde", + "serde_derive", +] + +[[package]] +name = "cranelift-codegen" +version = "0.128.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b3a09b3042c69810d255aef59ddc3b3e4c0644d1d90ecfd6e3837798cc88a3c" +dependencies = [ + "bumpalo", + "cranelift-assembler-x64", + "cranelift-bforest", + "cranelift-bitset", + "cranelift-codegen-meta", + "cranelift-codegen-shared", + "cranelift-control", + "cranelift-entity", + "cranelift-isle", + "gimli", + "hashbrown 0.15.5", + "log", + "pulley-interpreter", + "regalloc2", + "rustc-hash", + "serde", + "smallvec", + "target-lexicon", + "wasmtime-internal-math", +] + +[[package]] +name = "cranelift-codegen-meta" +version = "0.128.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "75817926ec812241889208d1b190cadb7fedded4592a4bb01b8524babb9e4849" +dependencies = [ + "cranelift-assembler-x64-meta", + "cranelift-codegen-shared", + "cranelift-srcgen", + "heck", + "pulley-interpreter", +] + +[[package]] +name = "cranelift-codegen-shared" +version = "0.128.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "859158f87a59476476eda3884d883c32e08a143cf3d315095533b362a3250a63" + +[[package]] +name = "cranelift-control" +version = "0.128.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "03b65a9aec442d715cbf54d14548b8f395476c09cef7abe03e104a378291ab88" +dependencies = [ + "arbitrary", +] + +[[package]] +name = "cranelift-entity" +version = "0.128.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8334c99a7e86060c24028732efd23bac84585770dcb752329c69f135d64f2fc1" +dependencies = [ + "cranelift-bitset", + "serde", + "serde_derive", +] + +[[package]] +name = "cranelift-frontend" +version = "0.128.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "43ac6c095aa5b3e845d7ca3461e67e2b65249eb5401477a5ff9100369b745111" +dependencies = [ + "cranelift-codegen", + "log", + "smallvec", + "target-lexicon", +] + +[[package]] +name = "cranelift-isle" +version = "0.128.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "69d3d992870ed4f0f2e82e2175275cb3a123a46e9660c6558c46417b822c91fa" + +[[package]] +name = "cranelift-native" +version = "0.128.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ee32e36beaf80f309edb535274cfe0349e1c5cf5799ba2d9f42e828285c6b52e" +dependencies = [ + "cranelift-codegen", + "libc", + "target-lexicon", +] + +[[package]] +name = "cranelift-srcgen" +version = "0.128.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "903adeaf4938e60209a97b53a2e4326cd2d356aab9764a1934630204bae381c9" + +[[package]] +name = "crc32fast" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "crossbeam-deque" +version = "0.8.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51" +dependencies = [ + "crossbeam-epoch", + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-epoch" +version = "0.9.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e" +dependencies = [ + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-utils" +version = "0.8.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28" + +[[package]] +name = "crypto-common" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a" +dependencies = [ + "generic-array", + "typenum", +] + +[[package]] +name = "debugid" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bef552e6f588e446098f6ba40d89ac146c8c7b64aade83c051ee00bb5d2bc18d" +dependencies = [ + "uuid", +] + +[[package]] +name = "digest" +version = "0.10.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292" +dependencies = [ + "block-buffer", + "crypto-common", +] + +[[package]] +name = "directories-next" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "339ee130d97a610ea5a5872d2bbb130fdf68884ff09d3028b81bec8a1ac23bbc" +dependencies = [ + "cfg-if", + "dirs-sys-next", +] + +[[package]] +name = "dirs-sys-next" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4ebda144c4fe02d1f7ea1a7d9641b6fc6b580adcfa024ae48797ecdeb6825b4d" +dependencies = [ + "libc", + "redox_users", + "winapi", +] + +[[package]] +name = "displaydoc" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "either" +version = "1.15.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719" + +[[package]] +name = "embedded-io" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ef1a6892d9eef45c8fa6b9e0086428a2cca8491aca8f787c534a3d6d0bcb3ced" + +[[package]] +name = "embedded-io" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "edd0f118536f44f5ccd48bcb8b111bdc3de888b58c74639dfb034a357d0f206d" + +[[package]] +name = "encoding_rs" +version = "0.8.35" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "75030f3c4f45dafd7586dd6780965a8c7e8e285a5ecb86713e63a79c5b2766f3" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "equivalent" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f" + +[[package]] +name = "errno" +version = "0.3.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb" +dependencies = [ + "libc", + "windows-sys 0.61.2", +] + +[[package]] +name = "extism" +version = "1.21.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed8c5859bdab81d2eb4cd963eeacd8031d353b1ffb2fde43ee9179a0d6295120" +dependencies = [ + "anyhow", + "async-trait", + "cbindgen", + "extism-convert", + "extism-manifest", + "glob", + "libc", + "serde", + "serde_json", + "sha2", + "toml", + "tracing", + "tracing-subscriber", + "ureq", + "url", + "uuid", + "wasi-common", + "wasmtime", + "wiggle", +] + +[[package]] +name = "extism-convert" +version = "1.21.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec1a8eac059a1730a21aa47f99a0c2075ba0ab88fd0c4e52e35027cf99cdf3e7" +dependencies = [ + "anyhow", + "base64", + "bytemuck", + "extism-convert-macros", + "prost", + "rmp-serde", + "serde", + "serde_json", +] + +[[package]] +name = "extism-convert-macros" +version = "1.21.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "848f105dd6e1af2ea4bb4a76447658e8587167df3c4e4658c4258e5b14a5b051" +dependencies = [ + "manyhow", + "proc-macro-crate", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "extism-manifest" +version = "1.21.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "953a22ad322939ae4567ec73a34913a3a43dcbdfa648b8307d38fe56bb3a0acd" +dependencies = [ + "base64", + "serde", + "serde_json", +] + +[[package]] +name = "fallible-iterator" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2acce4a10f12dc2fb14a218589d4f1f62ef011b2d0cc4b3cb1bba8e94da14649" + +[[package]] +name = "fastrand" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be" + +[[package]] +name = "fd-lock" +version = "4.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ce92ff622d6dadf7349484f42c93271a0d49b7cc4d466a936405bacbe10aa78" +dependencies = [ + "cfg-if", + "rustix 1.1.4", + "windows-sys 0.59.0", +] + +[[package]] +name = "find-msvc-tools" +version = "0.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582" + +[[package]] +name = "fixedbitset" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80" + +[[package]] +name = "flate2" +version = "1.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c" +dependencies = [ + "crc32fast", + "miniz_oxide", +] + +[[package]] +name = "foldhash" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2" + +[[package]] +name = "form_urlencoded" +version = "1.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf" +dependencies = [ + "percent-encoding", +] + +[[package]] +name = "fs-set-times" +version = "0.20.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "94e7099f6313ecacbe1256e8ff9d617b75d1bcb16a6fddef94866d225a01a14a" +dependencies = [ + "io-lifetimes", + "rustix 1.1.4", + "windows-sys 0.59.0", +] + +[[package]] +name = "futures" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b147ee9d1f6d097cef9ce628cd2ee62288d963e16fb287bd9286455b241382d" +dependencies = [ + "futures-channel", + "futures-core", + "futures-io", + "futures-sink", + "futures-task", + "futures-util", +] + +[[package]] +name = "futures-channel" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "07bbe89c50d7a535e539b8c17bc0b49bdb77747034daa8087407d655f3f7cc1d" +dependencies = [ + "futures-core", + "futures-sink", +] + +[[package]] +name = "futures-core" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7e3450815272ef58cec6d564423f6e755e25379b217b0bc688e295ba24df6b1d" + +[[package]] +name = "futures-io" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cecba35d7ad927e23624b22ad55235f2239cfa44fd10428eecbeba6d6a717718" + +[[package]] +name = "futures-sink" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c39754e157331b013978ec91992bde1ac089843443c49cbc7f46150b0fad0893" + +[[package]] +name = "futures-task" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "037711b3d59c33004d3856fbdc83b99d4ff37a24768fa1be9ce3538a1cde4393" + +[[package]] +name = "futures-util" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "389ca41296e6190b48053de0321d02a77f32f8a5d2461dd38762c0593805c6d6" +dependencies = [ + "futures-channel", + "futures-core", + "futures-io", + "futures-sink", + "futures-task", + "memchr", + "pin-project-lite", + "slab", +] + +[[package]] +name = "fxprof-processed-profile" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "25234f20a3ec0a962a61770cfe39ecf03cb529a6e474ad8cff025ed497eda557" +dependencies = [ + "bitflags", + "debugid", + "rustc-hash", + "serde", + "serde_derive", + "serde_json", +] + +[[package]] +name = "generic-array" +version = "0.14.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a" +dependencies = [ + "typenum", + "version_check", +] + +[[package]] +name = "getrandom" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0" +dependencies = [ + "cfg-if", + "libc", + "wasi", +] + +[[package]] +name = "getrandom" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd" +dependencies = [ + "cfg-if", + "libc", + "r-efi 5.3.0", + "wasip2", +] + +[[package]] +name = "getrandom" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0de51e6874e94e7bf76d726fc5d13ba782deca734ff60d5bb2fb2607c7406555" +dependencies = [ + "cfg-if", + "libc", + "r-efi 6.0.0", + "wasip2", + "wasip3", +] + +[[package]] +name = "gimli" +version = "0.32.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e629b9b98ef3dd8afe6ca2bd0f89306cec16d43d907889945bc5d6687f2f13c7" +dependencies = [ + "fallible-iterator", + "indexmap", + "stable_deref_trait", +] + +[[package]] +name = "glob" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280" + +[[package]] +name = "hashbrown" +version = "0.15.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1" +dependencies = [ + "foldhash", + "serde", +] + +[[package]] +name = "hashbrown" +version = "0.16.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100" + +[[package]] +name = "heck" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" + +[[package]] +name = "http" +version = "1.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3ba2a386d7f85a81f119ad7498ebe444d2e22c2af0b86b069416ace48b3311a" +dependencies = [ + "bytes", + "itoa", +] + +[[package]] +name = "httparse" +version = "1.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87" + +[[package]] +name = "iana-time-zone" +version = "0.1.65" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470" +dependencies = [ + "android_system_properties", + "core-foundation-sys", + "iana-time-zone-haiku", + "js-sys", + "log", + "wasm-bindgen", + "windows-core", +] + +[[package]] +name = "iana-time-zone-haiku" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f" +dependencies = [ + "cc", +] + +[[package]] +name = "icu_collections" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4c6b649701667bbe825c3b7e6388cb521c23d88644678e83c0c4d0a621a34b43" +dependencies = [ + "displaydoc", + "potential_utf", + "yoke", + "zerofrom", + "zerovec", +] + +[[package]] +name = "icu_locale_core" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "edba7861004dd3714265b4db54a3c390e880ab658fec5f7db895fae2046b5bb6" +dependencies = [ + "displaydoc", + "litemap", + "tinystr", + "writeable", + "zerovec", +] + +[[package]] +name = "icu_normalizer" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5f6c8828b67bf8908d82127b2054ea1b4427ff0230ee9141c54251934ab1b599" +dependencies = [ + "icu_collections", + "icu_normalizer_data", + "icu_properties", + "icu_provider", + "smallvec", + "zerovec", +] + +[[package]] +name = "icu_normalizer_data" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7aedcccd01fc5fe81e6b489c15b247b8b0690feb23304303a9e560f37efc560a" + +[[package]] +name = "icu_properties" +version = "2.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "020bfc02fe870ec3a66d93e677ccca0562506e5872c650f893269e08615d74ec" +dependencies = [ + "icu_collections", + "icu_locale_core", + "icu_properties_data", + "icu_provider", + "zerotrie", + "zerovec", +] + +[[package]] +name = "icu_properties_data" +version = "2.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "616c294cf8d725c6afcd8f55abc17c56464ef6211f9ed59cccffe534129c77af" + +[[package]] +name = "icu_provider" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85962cf0ce02e1e0a629cc34e7ca3e373ce20dda4c4d7294bbd0bf1fdb59e614" +dependencies = [ + "displaydoc", + "icu_locale_core", + "writeable", + "yoke", + "zerofrom", + "zerotrie", + "zerovec", +] + +[[package]] +name = "id-arena" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954" + +[[package]] +name = "idna" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de" +dependencies = [ + "idna_adapter", + "smallvec", + "utf8_iter", +] + +[[package]] +name = "idna_adapter" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344" +dependencies = [ + "icu_normalizer", + "icu_properties", +] + +[[package]] +name = "im-rc" +version = "15.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "af1955a75fa080c677d3972822ec4bad316169ab1cfc6c257a942c2265dbe5fe" +dependencies = [ + "bitmaps", + "rand_core", + "rand_xoshiro", + "sized-chunks", + "typenum", + "version_check", +] + +[[package]] +name = "indexmap" +version = "2.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7714e70437a7dc3ac8eb7e6f8df75fd8eb422675fc7678aff7364301092b1017" +dependencies = [ + "equivalent", + "hashbrown 0.16.1", + "serde", + "serde_core", +] + +[[package]] +name = "io-extras" +version = "0.18.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2285ddfe3054097ef4b2fe909ef8c3bcd1ea52a8f0d274416caebeef39f04a65" +dependencies = [ + "io-lifetimes", + "windows-sys 0.59.0", +] + +[[package]] +name = "io-lifetimes" +version = "2.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "06432fb54d3be7964ecd3649233cddf80db2832f47fec34c01f65b3d9d774983" + +[[package]] +name = "ipnet" +version = "2.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d98f6fed1fde3f8c21bc40a1abb88dd75e67924f9cffc3ef95607bad8017f8e2" + +[[package]] +name = "itertools" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285" +dependencies = [ + "either", +] + +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + +[[package]] +name = "ittapi" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6b996fe614c41395cdaedf3cf408a9534851090959d90d54a535f675550b64b1" +dependencies = [ + "anyhow", + "ittapi-sys", + "log", +] + +[[package]] +name = "ittapi-sys" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52f5385394064fa2c886205dba02598013ce83d3e92d33dbdc0c52fe0e7bf4fc" +dependencies = [ + "cc", +] + +[[package]] +name = "jobserver" +version = "0.1.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9afb3de4395d6b3e67a780b6de64b51c978ecf11cb9a462c66be7d4ca9039d33" +dependencies = [ + "getrandom 0.3.4", + "libc", +] + +[[package]] +name = "js-sys" +version = "0.3.92" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cc4c90f45aa2e6eacbe8645f77fdea542ac97a494bcd117a67df9ff4d611f995" +dependencies = [ + "once_cell", + "wasm-bindgen", +] + +[[package]] +name = "lazy_static" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe" + +[[package]] +name = "leb128" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "884e2677b40cc8c339eaefcb701c32ef1fd2493d71118dc0ca4b6a736c93bd67" + +[[package]] +name = "leb128fmt" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2" + +[[package]] +name = "libc" +version = "0.2.183" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b5b646652bf6661599e1da8901b3b9522896f01e736bad5f723fe7a3a27f899d" + +[[package]] +name = "libloading" +version = "0.8.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d7c4b02199fee7c5d21a5ae7d8cfa79a6ef5bb2fc834d6e9058e89c825efdc55" +dependencies = [ + "cfg-if", + "windows-link", +] + +[[package]] +name = "libm" +version = "0.2.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981" + +[[package]] +name = "libredox" +version = "0.1.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7ddbf48fd451246b1f8c2610bd3b4ac0cc6e149d89832867093ab69a17194f08" +dependencies = [ + "libc", +] + +[[package]] +name = "linux-raw-sys" +version = "0.4.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab" + +[[package]] +name = "linux-raw-sys" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53" + +[[package]] +name = "litemap" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6373607a59f0be73a39b6fe456b8192fcc3585f602af20751600e974dd455e77" + +[[package]] +name = "log" +version = "0.4.29" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897" + +[[package]] +name = "mach2" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d640282b302c0bb0a2a8e0233ead9035e3bed871f0b7e81fe4a1ec829765db44" +dependencies = [ + "libc", +] + +[[package]] +name = "manyhow" +version = "0.11.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b33efb3ca6d3b07393750d4030418d594ab1139cee518f0dc88db70fec873587" +dependencies = [ + "manyhow-macros", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "manyhow-macros" +version = "0.11.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "46fce34d199b78b6e6073abf984c9cf5fd3e9330145a93ee0738a7443e371495" +dependencies = [ + "proc-macro-utils", + "proc-macro2", + "quote", +] + +[[package]] +name = "matchers" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d1525a2a28c7f4fa0fc98bb91ae755d1e2d1505079e05539e35bc876b5d65ae9" +dependencies = [ + "regex-automata", +] + +[[package]] +name = "maybe-owned" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4facc753ae494aeb6e3c22f839b158aebd4f9270f55cd3c79906c45476c47ab4" + +[[package]] +name = "memchr" +version = "2.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79" + +[[package]] +name = "memfd" +version = "0.6.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ad38eb12aea514a0466ea40a80fd8cc83637065948eb4a426e4aa46261175227" +dependencies = [ + "rustix 1.1.4", +] + +[[package]] +name = "miniz_oxide" +version = "0.8.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316" +dependencies = [ + "adler2", + "simd-adler32", +] + +[[package]] +name = "nu-ansi-term" +version = "0.50.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5" +dependencies = [ + "windows-sys 0.61.2", +] + +[[package]] +name = "num-traits" +version = "0.2.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" +dependencies = [ + "autocfg", +] + +[[package]] +name = "object" +version = "0.37.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff76201f031d8863c38aa7f905eca4f53abbfa15f609db4277d44cd8938f33fe" +dependencies = [ + "crc32fast", + "hashbrown 0.15.5", + "indexmap", + "memchr", +] + +[[package]] +name = "once_cell" +version = "1.21.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50" + +[[package]] +name = "onepassword-sdk" +version = "0.4.1-beta.1" +dependencies = [ + "chrono", + "extism", + "getrandom 0.2.17", + "libloading", + "serde", + "serde_json", + "thiserror 2.0.18", +] + +[[package]] +name = "percent-encoding" +version = "2.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220" + +[[package]] +name = "petgraph" +version = "0.6.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b4c5cc86750666a3ed20bdaf5ca2a0344f9c67674cae0515bec2da16fbaa47db" +dependencies = [ + "fixedbitset", + "indexmap", +] + +[[package]] +name = "pin-project-lite" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd" + +[[package]] +name = "pkg-config" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c" + +[[package]] +name = "postcard" +version = "1.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6764c3b5dd454e283a30e6dfe78e9b31096d9e32036b5d1eaac7a6119ccb9a24" +dependencies = [ + "cobs", + "embedded-io 0.4.0", + "embedded-io 0.6.1", + "serde", +] + +[[package]] +name = "potential_utf" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b73949432f5e2a09657003c25bca5e19a0e9c84f8058ca374f49e0ebe605af77" +dependencies = [ + "zerovec", +] + +[[package]] +name = "ppv-lite86" +version = "0.2.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9" +dependencies = [ + "zerocopy", +] + +[[package]] +name = "prettyplease" +version = "0.2.37" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b" +dependencies = [ + "proc-macro2", + "syn", +] + +[[package]] +name = "proc-macro-crate" +version = "3.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e67ba7e9b2b56446f1d419b1d807906278ffa1a658a8a5d8a39dcb1f5a78614f" +dependencies = [ + "toml_edit", +] + +[[package]] +name = "proc-macro-utils" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eeaf08a13de400bc215877b5bdc088f241b12eb42f0a548d3390dc1c56bb7071" +dependencies = [ + "proc-macro2", + "quote", + "smallvec", +] + +[[package]] +name = "proc-macro2" +version = "1.0.106" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "prost" +version = "0.14.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d2ea70524a2f82d518bce41317d0fae74151505651af45faf1ffbd6fd33f0568" +dependencies = [ + "bytes", + "prost-derive", +] + +[[package]] +name = "prost-derive" +version = "0.14.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "27c6023962132f4b30eb4c172c91ce92d933da334c59c23cddee82358ddafb0b" +dependencies = [ + "anyhow", + "itertools", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "pulley-interpreter" +version = "41.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e9812652c1feb63cf39f8780cecac154a32b22b3665806c733cd4072547233a4" +dependencies = [ + "cranelift-bitset", + "log", + "pulley-macros", + "wasmtime-internal-math", +] + +[[package]] +name = "pulley-macros" +version = "41.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "56000349b6896e3d44286eb9c330891237f40b27fd43c1ccc84547d0b463cb40" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "quote" +version = "1.0.45" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "r-efi" +version = "5.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f" + +[[package]] +name = "r-efi" +version = "6.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf" + +[[package]] +name = "rand" +version = "0.8.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404" +dependencies = [ + "libc", + "rand_chacha", + "rand_core", +] + +[[package]] +name = "rand_chacha" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88" +dependencies = [ + "ppv-lite86", + "rand_core", +] + +[[package]] +name = "rand_core" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" +dependencies = [ + "getrandom 0.2.17", +] + +[[package]] +name = "rand_xoshiro" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6f97cdb2a36ed4183de61b2f824cc45c9f1037f28afe0a322e9fff4c108b5aaa" +dependencies = [ + "rand_core", +] + +[[package]] +name = "rayon" +version = "1.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "368f01d005bf8fd9b1206fb6fa653e6c4a81ceb1466406b81792d87c5677a58f" +dependencies = [ + "either", + "rayon-core", +] + +[[package]] +name = "rayon-core" +version = "1.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91" +dependencies = [ + "crossbeam-deque", + "crossbeam-utils", +] + +[[package]] +name = "redox_users" +version = "0.4.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba009ff324d1fc1b900bd1fdb31564febe58a8ccc8a6fdbb93b543d33b13ca43" +dependencies = [ + "getrandom 0.2.17", + "libredox", + "thiserror 1.0.69", +] + +[[package]] +name = "regalloc2" +version = "0.13.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "08effbc1fa53aaebff69521a5c05640523fab037b34a4a2c109506bc938246fa" +dependencies = [ + "allocator-api2", + "bumpalo", + "hashbrown 0.15.5", + "log", + "rustc-hash", + "smallvec", +] + +[[package]] +name = "regex-automata" +version = "0.4.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f" +dependencies = [ + "aho-corasick", + "memchr", + "regex-syntax", +] + +[[package]] +name = "regex-syntax" +version = "0.8.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dc897dd8d9e8bd1ed8cdad82b5966c3e0ecae09fb1907d58efaa013543185d0a" + +[[package]] +name = "ring" +version = "0.17.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7" +dependencies = [ + "cc", + "cfg-if", + "getrandom 0.2.17", + "libc", + "untrusted", + "windows-sys 0.52.0", +] + +[[package]] +name = "rmp" +version = "0.8.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4ba8be72d372b2c9b35542551678538b562e7cf86c3315773cae48dfbfe7790c" +dependencies = [ + "num-traits", +] + +[[package]] +name = "rmp-serde" +version = "1.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72f81bee8c8ef9b577d1681a70ebbc962c232461e397b22c208c43c04b67a155" +dependencies = [ + "rmp", + "serde", +] + +[[package]] +name = "rustc-demangle" +version = "0.1.27" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b50b8869d9fc858ce7266cce0194bd74df58b9d0e3f6df3a9fc8eb470d95c09d" + +[[package]] +name = "rustc-hash" +version = "2.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "94300abf3f1ae2e2b8ffb7b58043de3d399c73fa6f4b73826402a5c457614dbe" + +[[package]] +name = "rustix" +version = "0.38.44" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fdb5bc1ae2baa591800df16c9ca78619bf65c0488b41b96ccec5d11220d8c154" +dependencies = [ + "bitflags", + "errno", + "libc", + "linux-raw-sys 0.4.15", + "windows-sys 0.59.0", +] + +[[package]] +name = "rustix" +version = "1.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190" +dependencies = [ + "bitflags", + "errno", + "libc", + "linux-raw-sys 0.12.1", + "windows-sys 0.61.2", +] + +[[package]] +name = "rustix-linux-procfs" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2fc84bf7e9aa16c4f2c758f27412dc9841341e16aa682d9c7ac308fe3ee12056" +dependencies = [ + "once_cell", + "rustix 1.1.4", +] + +[[package]] +name = "rustls" +version = "0.23.37" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "758025cb5fccfd3bc2fd74708fd4682be41d99e5dff73c377c0646c6012c73a4" +dependencies = [ + "log", + "once_cell", + "ring", + "rustls-pki-types", + "rustls-webpki", + "subtle", + "zeroize", +] + +[[package]] +name = "rustls-pki-types" +version = "1.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "be040f8b0a225e40375822a563fa9524378b9d63112f53e19ffff34df5d33fdd" +dependencies = [ + "zeroize", +] + +[[package]] +name = "rustls-webpki" +version = "0.103.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "df33b2b81ac578cabaf06b89b0631153a3f416b0a886e8a7a1707fb51abbd1ef" +dependencies = [ + "ring", + "rustls-pki-types", + "untrusted", +] + +[[package]] +name = "rustversion" +version = "1.0.22" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d" + +[[package]] +name = "ryu" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f" + +[[package]] +name = "semver" +version = "1.0.27" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2" +dependencies = [ + "serde", + "serde_core", +] + +[[package]] +name = "serde" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e" +dependencies = [ + "serde_core", + "serde_derive", +] + +[[package]] +name = "serde_core" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "serde_json" +version = "1.0.149" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + +[[package]] +name = "serde_spanned" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "876ac351060d4f882bb1032b6369eb0aef79ad9df1ea8bc404874d8cc3d0cd98" +dependencies = [ + "serde_core", +] + +[[package]] +name = "serde_yaml" +version = "0.9.34+deprecated" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6a8b1a1a2ebf674015cc02edccce75287f1a0130d394307b36743c2f5d504b47" +dependencies = [ + "indexmap", + "itoa", + "ryu", + "serde", + "unsafe-libyaml", +] + +[[package]] +name = "sha2" +version = "0.10.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283" +dependencies = [ + "cfg-if", + "cpufeatures", + "digest", +] + +[[package]] +name = "sharded-slab" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6" +dependencies = [ + "lazy_static", +] + +[[package]] +name = "shlex" +version = "1.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" + +[[package]] +name = "simd-adler32" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "703d5c7ef118737c72f1af64ad2f6f8c5e1921f818cdcb97b8fe6fc69bf66214" + +[[package]] +name = "sized-chunks" +version = "0.6.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "16d69225bde7a69b235da73377861095455d298f2b970996eec25ddbb42b3d1e" +dependencies = [ + "bitmaps", + "typenum", +] + +[[package]] +name = "slab" +version = "0.4.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5" + +[[package]] +name = "smallvec" +version = "1.15.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03" +dependencies = [ + "serde", +] + +[[package]] +name = "stable_deref_trait" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596" + +[[package]] +name = "subtle" +version = "2.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292" + +[[package]] +name = "syn" +version = "2.0.117" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "synstructure" +version = "0.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "system-interface" +version = "0.27.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cc4592f674ce18521c2a81483873a49596655b179f71c5e05d10c1fe66c78745" +dependencies = [ + "bitflags", + "cap-fs-ext", + "cap-std", + "fd-lock", + "io-lifetimes", + "rustix 0.38.44", + "windows-sys 0.59.0", + "winx", +] + +[[package]] +name = "target-lexicon" +version = "0.13.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca" + +[[package]] +name = "tempfile" +version = "3.27.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd" +dependencies = [ + "fastrand", + "getrandom 0.4.2", + "once_cell", + "rustix 1.1.4", + "windows-sys 0.61.2", +] + +[[package]] +name = "termcolor" +version = "1.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755" +dependencies = [ + "winapi-util", +] + +[[package]] +name = "thiserror" +version = "1.0.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52" +dependencies = [ + "thiserror-impl 1.0.69", +] + +[[package]] +name = "thiserror" +version = "2.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4" +dependencies = [ + "thiserror-impl 2.0.18", +] + +[[package]] +name = "thiserror-impl" +version = "1.0.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "thiserror-impl" +version = "2.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "thread_local" +version = "1.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f60246a4944f24f6e018aa17cdeffb7818b76356965d03b07d6a9886e8962185" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "tinystr" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42d3e9c45c09de15d06dd8acf5f4e0e399e85927b7f00711024eb7ae10fa4869" +dependencies = [ + "displaydoc", + "zerovec", +] + +[[package]] +name = "toml" +version = "0.9.12+spec-1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf92845e79fc2e2def6a5d828f0801e29a2f8acc037becc5ab08595c7d5e9863" +dependencies = [ + "indexmap", + "serde_core", + "serde_spanned", + "toml_datetime 0.7.5+spec-1.1.0", + "toml_parser", + "toml_writer", + "winnow 0.7.15", +] + +[[package]] +name = "toml_datetime" +version = "0.7.5+spec-1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "92e1cfed4a3038bc5a127e35a2d360f145e1f4b971b551a2ba5fd7aedf7e1347" +dependencies = [ + "serde_core", +] + +[[package]] +name = "toml_datetime" +version = "1.1.0+spec-1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "97251a7c317e03ad83774a8752a7e81fb6067740609f75ea2b585b569a59198f" +dependencies = [ + "serde_core", +] + +[[package]] +name = "toml_edit" +version = "0.25.8+spec-1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "16bff38f1d86c47f9ff0647e6838d7bb362522bdf44006c7068c2b1e606f1f3c" +dependencies = [ + "indexmap", + "toml_datetime 1.1.0+spec-1.1.0", + "toml_parser", + "winnow 1.0.1", +] + +[[package]] +name = "toml_parser" +version = "1.1.0+spec-1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2334f11ee363607eb04df9b8fc8a13ca1715a72ba8662a26ac285c98aabb4011" +dependencies = [ + "winnow 1.0.1", +] + +[[package]] +name = "toml_writer" +version = "1.1.0+spec-1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d282ade6016312faf3e41e57ebbba0c073e4056dab1232ab1cb624199648f8ed" + +[[package]] +name = "tracing" +version = "0.1.44" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100" +dependencies = [ + "log", + "pin-project-lite", + "tracing-attributes", + "tracing-core", +] + +[[package]] +name = "tracing-attributes" +version = "0.1.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "tracing-core" +version = "0.1.36" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a" +dependencies = [ + "once_cell", + "valuable", +] + +[[package]] +name = "tracing-log" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3" +dependencies = [ + "log", + "once_cell", + "tracing-core", +] + +[[package]] +name = "tracing-subscriber" +version = "0.3.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cb7f578e5945fb242538965c2d0b04418d38ec25c79d160cd279bf0731c8d319" +dependencies = [ + "matchers", + "nu-ansi-term", + "once_cell", + "regex-automata", + "sharded-slab", + "smallvec", + "thread_local", + "tracing", + "tracing-core", + "tracing-log", +] + +[[package]] +name = "typenum" +version = "1.19.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb" + +[[package]] +name = "unicode-ident" +version = "1.0.24" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75" + +[[package]] +name = "unicode-width" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254" + +[[package]] +name = "unicode-xid" +version = "0.2.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853" + +[[package]] +name = "unsafe-libyaml" +version = "0.2.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "673aac59facbab8a9007c7f6108d11f63b603f7cabff99fabf650fea5c32b861" + +[[package]] +name = "untrusted" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1" + +[[package]] +name = "ureq" +version = "3.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dea7109cdcd5864d4eeb1b58a1648dc9bf520360d7af16ec26d0a9354bafcfc0" +dependencies = [ + "base64", + "flate2", + "log", + "percent-encoding", + "rustls", + "rustls-pki-types", + "ureq-proto", + "utf8-zero", + "webpki-roots", +] + +[[package]] +name = "ureq-proto" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e994ba84b0bd1b1b0cf92878b7ef898a5c1760108fe7b6010327e274917a808c" +dependencies = [ + "base64", + "http", + "httparse", + "log", +] + +[[package]] +name = "url" +version = "2.5.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed" +dependencies = [ + "form_urlencoded", + "idna", + "percent-encoding", + "serde", +] + +[[package]] +name = "utf8-zero" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8c0a043c9540bae7c578c88f91dda8bd82e59ae27c21baca69c8b191aaf5a6e" + +[[package]] +name = "utf8_iter" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be" + +[[package]] +name = "uuid" +version = "1.23.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5ac8b6f42ead25368cf5b098aeb3dc8a1a2c05a3eee8a9a1a68c640edbfc79d9" +dependencies = [ + "getrandom 0.4.2", + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "valuable" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65" + +[[package]] +name = "version_check" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" + +[[package]] +name = "wasi" +version = "0.11.1+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b" + +[[package]] +name = "wasi-common" +version = "41.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f49ffbbd04665d04028f66aee8f24ae7a1f46063f59a28fddfa52ca3091754a2" +dependencies = [ + "anyhow", + "async-trait", + "bitflags", + "cap-fs-ext", + "cap-rand", + "cap-std", + "cap-time-ext", + "fs-set-times", + "io-extras", + "io-lifetimes", + "log", + "rustix 1.1.4", + "system-interface", + "thiserror 2.0.18", + "tracing", + "wasmtime", + "wiggle", + "windows-sys 0.61.2", +] + +[[package]] +name = "wasip2" +version = "1.0.2+wasi-0.2.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9517f9239f02c069db75e65f174b3da828fe5f5b945c4dd26bd25d89c03ebcf5" +dependencies = [ + "wit-bindgen", +] + +[[package]] +name = "wasip3" +version = "0.4.0+wasi-0.3.0-rc-2026-01-06" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5428f8bf88ea5ddc08faddef2ac4a67e390b88186c703ce6dbd955e1c145aca5" +dependencies = [ + "wit-bindgen", +] + +[[package]] +name = "wasm-bindgen" +version = "0.2.115" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6523d69017b7633e396a89c5efab138161ed5aafcbc8d3e5c5a42ae38f50495a" +dependencies = [ + "cfg-if", + "once_cell", + "rustversion", + "wasm-bindgen-macro", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-macro" +version = "0.2.115" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4e3a6c758eb2f701ed3d052ff5737f5bfe6614326ea7f3bbac7156192dc32e67" +dependencies = [ + "quote", + "wasm-bindgen-macro-support", +] + +[[package]] +name = "wasm-bindgen-macro-support" +version = "0.2.115" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "921de2737904886b52bcbb237301552d05969a6f9c40d261eb0533c8b055fedf" +dependencies = [ + "bumpalo", + "proc-macro2", + "quote", + "syn", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-shared" +version = "0.2.115" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a93e946af942b58934c604527337bad9ae33ba1d5c6900bbb41c2c07c2364a93" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "wasm-compose" +version = "0.243.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "af801b6f36459023eaec63fdbaedad2fd5a4ab7dc74ecc110a8b5d375c5775e4" +dependencies = [ + "anyhow", + "heck", + "im-rc", + "indexmap", + "log", + "petgraph", + "serde", + "serde_derive", + "serde_yaml", + "smallvec", + "wasm-encoder 0.243.0", + "wasmparser 0.243.0", + "wat", +] + +[[package]] +name = "wasm-encoder" +version = "0.243.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c55db9c896d70bd9fa535ce83cd4e1f2ec3726b0edd2142079f594fc3be1cb35" +dependencies = [ + "leb128fmt", + "wasmparser 0.243.0", +] + +[[package]] +name = "wasm-encoder" +version = "0.244.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "990065f2fe63003fe337b932cfb5e3b80e0b4d0f5ff650e6985b1048f62c8319" +dependencies = [ + "leb128fmt", + "wasmparser 0.244.0", +] + +[[package]] +name = "wasm-encoder" +version = "0.245.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f9dca005e69bf015e45577e415b9af8c67e8ee3c0e38b5b0add5aa92581ed5c" +dependencies = [ + "leb128fmt", + "wasmparser 0.245.1", +] + +[[package]] +name = "wasm-metadata" +version = "0.244.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bb0e353e6a2fbdc176932bbaab493762eb1255a7900fe0fea1a2f96c296cc909" +dependencies = [ + "anyhow", + "indexmap", + "wasm-encoder 0.244.0", + "wasmparser 0.244.0", +] + +[[package]] +name = "wasmparser" +version = "0.243.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f6d8db401b0528ec316dfbe579e6ab4152d61739cfe076706d2009127970159d" +dependencies = [ + "bitflags", + "hashbrown 0.15.5", + "indexmap", + "semver", + "serde", +] + +[[package]] +name = "wasmparser" +version = "0.244.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe" +dependencies = [ + "bitflags", + "hashbrown 0.15.5", + "indexmap", + "semver", +] + +[[package]] +name = "wasmparser" +version = "0.245.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4f08c9adee0428b7bddf3890fc27e015ac4b761cc608c822667102b8bfd6995e" +dependencies = [ + "bitflags", + "indexmap", + "semver", +] + +[[package]] +name = "wasmprinter" +version = "0.243.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eb2b6035559e146114c29a909a3232928ee488d6507a1504d8934e8607b36d7b" +dependencies = [ + "anyhow", + "termcolor", + "wasmparser 0.243.0", +] + +[[package]] +name = "wasmtime" +version = "41.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e2a83182bf04af87571b4c642300479501684f26bab5597f68f68cded5b098fd" +dependencies = [ + "addr2line", + "anyhow", + "async-trait", + "bitflags", + "bumpalo", + "cc", + "cfg-if", + "encoding_rs", + "futures", + "fxprof-processed-profile", + "gimli", + "hashbrown 0.15.5", + "indexmap", + "ittapi", + "libc", + "log", + "mach2", + "memfd", + "object", + "once_cell", + "postcard", + "pulley-interpreter", + "rayon", + "rustix 1.1.4", + "semver", + "serde", + "serde_derive", + "serde_json", + "smallvec", + "target-lexicon", + "tempfile", + "wasm-compose", + "wasm-encoder 0.243.0", + "wasmparser 0.243.0", + "wasmtime-environ", + "wasmtime-internal-cache", + "wasmtime-internal-component-macro", + "wasmtime-internal-component-util", + "wasmtime-internal-cranelift", + "wasmtime-internal-fiber", + "wasmtime-internal-jit-debug", + "wasmtime-internal-jit-icache-coherence", + "wasmtime-internal-math", + "wasmtime-internal-slab", + "wasmtime-internal-unwinder", + "wasmtime-internal-versioned-export-macros", + "wasmtime-internal-winch", + "wat", + "windows-sys 0.61.2", +] + +[[package]] +name = "wasmtime-environ" +version = "41.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cb201c41aa23a3642365cfb2e4a183573d85127a3c9d528f56b9997c984541ab" +dependencies = [ + "anyhow", + "cpp_demangle", + "cranelift-bitset", + "cranelift-entity", + "gimli", + "indexmap", + "log", + "object", + "postcard", + "rustc-demangle", + "semver", + "serde", + "serde_derive", + "smallvec", + "target-lexicon", + "wasm-encoder 0.243.0", + "wasmparser 0.243.0", + "wasmprinter", + "wasmtime-internal-component-util", +] + +[[package]] +name = "wasmtime-internal-cache" +version = "41.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fb5b3069d1a67ba5969d0eb1ccd7e141367d4e713f4649aa90356c98e8f19bea" +dependencies = [ + "base64", + "directories-next", + "log", + "postcard", + "rustix 1.1.4", + "serde", + "serde_derive", + "sha2", + "toml", + "wasmtime-environ", + "windows-sys 0.61.2", + "zstd", +] + +[[package]] +name = "wasmtime-internal-component-macro" +version = "41.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c924400db7b6ca996fef1b23beb0f41d5c809836b1ec60fc25b4057e2d25d9b" +dependencies = [ + "anyhow", + "proc-macro2", + "quote", + "syn", + "wasmtime-internal-component-util", + "wasmtime-internal-wit-bindgen", + "wit-parser 0.243.0", +] + +[[package]] +name = "wasmtime-internal-component-util" +version = "41.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d3f65daf4bf3d74ca2fbbe20af0589c42e2b398a073486451425d94fd4afef4" + +[[package]] +name = "wasmtime-internal-cranelift" +version = "41.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "633e889cdae76829738db0114ab3b02fce51ea4a1cd9675a67a65fce92e8b418" +dependencies = [ + "cfg-if", + "cranelift-codegen", + "cranelift-control", + "cranelift-entity", + "cranelift-frontend", + "cranelift-native", + "gimli", + "itertools", + "log", + "object", + "pulley-interpreter", + "smallvec", + "target-lexicon", + "thiserror 2.0.18", + "wasmparser 0.243.0", + "wasmtime-environ", + "wasmtime-internal-math", + "wasmtime-internal-unwinder", + "wasmtime-internal-versioned-export-macros", +] + +[[package]] +name = "wasmtime-internal-fiber" +version = "41.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "deb126adc5d0c72695cfb77260b357f1b81705a0f8fa30b3944e7c2219c17341" +dependencies = [ + "cc", + "cfg-if", + "libc", + "rustix 1.1.4", + "wasmtime-environ", + "wasmtime-internal-versioned-export-macros", + "windows-sys 0.61.2", +] + +[[package]] +name = "wasmtime-internal-jit-debug" +version = "41.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e66ff7f90a8002187691ff6237ffd09f954a0ebb9de8b2ff7f5c62632134120" +dependencies = [ + "cc", + "object", + "rustix 1.1.4", + "wasmtime-internal-versioned-export-macros", +] + +[[package]] +name = "wasmtime-internal-jit-icache-coherence" +version = "41.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4b96df23179ae16d54fb3a420f84ffe4383ec9dd06fad3e5bc782f85f66e8e08" +dependencies = [ + "anyhow", + "cfg-if", + "libc", + "windows-sys 0.61.2", +] + +[[package]] +name = "wasmtime-internal-math" +version = "41.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "86d1380926682b44c383e9a67f47e7a95e60c6d3fa8c072294dab2c7de6168a0" +dependencies = [ + "libm", +] + +[[package]] +name = "wasmtime-internal-slab" +version = "41.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b63cbea1c0192c7feb7c0dfb35f47166988a3742f29f46b585ef57246c65764" + +[[package]] +name = "wasmtime-internal-unwinder" +version = "41.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f25c392c7e5fb891a7416e3c34cfbd148849271e8c58744fda875dde4bec4d6a" +dependencies = [ + "cfg-if", + "cranelift-codegen", + "log", + "object", + "wasmtime-environ", +] + +[[package]] +name = "wasmtime-internal-versioned-export-macros" +version = "41.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "70f8b9796a3f0451a7b702508b303d654de640271ac80287176de222f187a237" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "wasmtime-internal-winch" +version = "41.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c0063e61f1d0b2c20e9cfc58361a6513d074a23c80b417aac3033724f51648a0" +dependencies = [ + "cranelift-codegen", + "gimli", + "log", + "object", + "target-lexicon", + "wasmparser 0.243.0", + "wasmtime-environ", + "wasmtime-internal-cranelift", + "winch-codegen", +] + +[[package]] +name = "wasmtime-internal-wit-bindgen" +version = "41.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "587699ca7cae16b4a234ffcc834f37e75675933d533809919b52975f5609e2ef" +dependencies = [ + "anyhow", + "bitflags", + "heck", + "indexmap", + "wit-parser 0.243.0", +] + +[[package]] +name = "wast" +version = "35.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2ef140f1b49946586078353a453a1d28ba90adfc54dde75710bc1931de204d68" +dependencies = [ + "leb128", +] + +[[package]] +name = "wast" +version = "245.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "28cf1149285569120b8ce39db8b465e8a2b55c34cbb586bd977e43e2bc7300bf" +dependencies = [ + "bumpalo", + "leb128fmt", + "memchr", + "unicode-width", + "wasm-encoder 0.245.1", +] + +[[package]] +name = "wat" +version = "1.245.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cd48d1679b6858988cb96b154dda0ec5bbb09275b71db46057be37332d5477be" +dependencies = [ + "wast 245.0.1", +] + +[[package]] +name = "webpki-roots" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "22cfaf3c063993ff62e73cb4311efde4db1efb31ab78a3e5c457939ad5cc0bed" +dependencies = [ + "rustls-pki-types", +] + +[[package]] +name = "wiggle" +version = "41.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a69a60bcbe1475c5dc9ec89210ade54823d44f742e283cba64f98f89697c4cec" +dependencies = [ + "anyhow", + "bitflags", + "thiserror 2.0.18", + "tracing", + "wasmtime", + "wiggle-macro", + "witx", +] + +[[package]] +name = "wiggle-generate" +version = "41.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "21f3dc0fd4dcfc7736434bb216179a2147835309abc09bf226736a40d484548f" +dependencies = [ + "anyhow", + "heck", + "proc-macro2", + "quote", + "syn", + "witx", +] + +[[package]] +name = "wiggle-macro" +version = "41.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fea2aea744eded58ae092bf57110c27517dab7d5a300513ff13897325c5c5021" +dependencies = [ + "proc-macro2", + "quote", + "syn", + "wiggle-generate", +] + +[[package]] +name = "winapi" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" +dependencies = [ + "winapi-i686-pc-windows-gnu", + "winapi-x86_64-pc-windows-gnu", +] + +[[package]] +name = "winapi-i686-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" + +[[package]] +name = "winapi-util" +version = "0.1.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22" +dependencies = [ + "windows-sys 0.61.2", +] + +[[package]] +name = "winapi-x86_64-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" + +[[package]] +name = "winch-codegen" +version = "41.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c55de3ac5b8bd71e5f6c87a9e511dd3ceb194bdb58183c6a7bf21cd8c0e46fbc" +dependencies = [ + "anyhow", + "cranelift-assembler-x64", + "cranelift-codegen", + "gimli", + "regalloc2", + "smallvec", + "target-lexicon", + "thiserror 2.0.18", + "wasmparser 0.243.0", + "wasmtime-environ", + "wasmtime-internal-cranelift", + "wasmtime-internal-math", +] + +[[package]] +name = "windows-core" +version = "0.62.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb" +dependencies = [ + "windows-implement", + "windows-interface", + "windows-link", + "windows-result", + "windows-strings", +] + +[[package]] +name = "windows-implement" +version = "0.60.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "windows-interface" +version = "0.59.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "windows-link" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" + +[[package]] +name = "windows-result" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-strings" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-sys" +version = "0.52.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d" +dependencies = [ + "windows-targets", +] + +[[package]] +name = "windows-sys" +version = "0.59.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b" +dependencies = [ + "windows-targets", +] + +[[package]] +name = "windows-sys" +version = "0.61.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-targets" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" +dependencies = [ + "windows_aarch64_gnullvm", + "windows_aarch64_msvc", + "windows_i686_gnu", + "windows_i686_gnullvm", + "windows_i686_msvc", + "windows_x86_64_gnu", + "windows_x86_64_gnullvm", + "windows_x86_64_msvc", +] + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" + +[[package]] +name = "windows_i686_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" + +[[package]] +name = "windows_i686_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" + +[[package]] +name = "windows_i686_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" + +[[package]] +name = "winnow" +version = "0.7.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "df79d97927682d2fd8adb29682d1140b343be4ac0f08fd68b7765d9c059d3945" + +[[package]] +name = "winnow" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09dac053f1cd375980747450bfc7250c264eaae0583872e845c0c7cd578872b5" +dependencies = [ + "memchr", +] + +[[package]] +name = "winx" +version = "0.36.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f3fd376f71958b862e7afb20cfe5a22830e1963462f3a17f49d82a6c1d1f42d" +dependencies = [ + "bitflags", + "windows-sys 0.59.0", +] + +[[package]] +name = "wit-bindgen" +version = "0.51.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5" +dependencies = [ + "wit-bindgen-rust-macro", +] + +[[package]] +name = "wit-bindgen-core" +version = "0.51.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ea61de684c3ea68cb082b7a88508a8b27fcc8b797d738bfc99a82facf1d752dc" +dependencies = [ + "anyhow", + "heck", + "wit-parser 0.244.0", +] + +[[package]] +name = "wit-bindgen-rust" +version = "0.51.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b7c566e0f4b284dd6561c786d9cb0142da491f46a9fbed79ea69cdad5db17f21" +dependencies = [ + "anyhow", + "heck", + "indexmap", + "prettyplease", + "syn", + "wasm-metadata", + "wit-bindgen-core", + "wit-component", +] + +[[package]] +name = "wit-bindgen-rust-macro" +version = "0.51.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c0f9bfd77e6a48eccf51359e3ae77140a7f50b1e2ebfe62422d8afdaffab17a" +dependencies = [ + "anyhow", + "prettyplease", + "proc-macro2", + "quote", + "syn", + "wit-bindgen-core", + "wit-bindgen-rust", +] + +[[package]] +name = "wit-component" +version = "0.244.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2" +dependencies = [ + "anyhow", + "bitflags", + "indexmap", + "log", + "serde", + "serde_derive", + "serde_json", + "wasm-encoder 0.244.0", + "wasm-metadata", + "wasmparser 0.244.0", + "wit-parser 0.244.0", +] + +[[package]] +name = "wit-parser" +version = "0.243.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "df983a8608e513d8997f435bb74207bf0933d0e49ca97aa9d8a6157164b9b7fc" +dependencies = [ + "anyhow", + "id-arena", + "indexmap", + "log", + "semver", + "serde", + "serde_derive", + "serde_json", + "unicode-xid", + "wasmparser 0.243.0", +] + +[[package]] +name = "wit-parser" +version = "0.244.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736" +dependencies = [ + "anyhow", + "id-arena", + "indexmap", + "log", + "semver", + "serde", + "serde_derive", + "serde_json", + "unicode-xid", + "wasmparser 0.244.0", +] + +[[package]] +name = "witx" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e366f27a5cabcddb2706a78296a40b8fcc451e1a6aba2fc1d94b4a01bdaaef4b" +dependencies = [ + "anyhow", + "log", + "thiserror 1.0.69", + "wast 35.0.2", +] + +[[package]] +name = "writeable" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9edde0db4769d2dc68579893f2306b26c6ecfbe0ef499b013d731b7b9247e0b9" + +[[package]] +name = "yoke" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72d6e5c6afb84d73944e5cedb052c4680d5657337201555f9f2a16b7406d4954" +dependencies = [ + "stable_deref_trait", + "yoke-derive", + "zerofrom", +] + +[[package]] +name = "yoke-derive" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b659052874eb698efe5b9e8cf382204678a0086ebf46982b79d6ca3182927e5d" +dependencies = [ + "proc-macro2", + "quote", + "syn", + "synstructure", +] + +[[package]] +name = "zerocopy" +version = "0.8.48" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eed437bf9d6692032087e337407a86f04cd8d6a16a37199ed57949d415bd68e9" +dependencies = [ + "zerocopy-derive", +] + +[[package]] +name = "zerocopy-derive" +version = "0.8.48" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "70e3cd084b1788766f53af483dd21f93881ff30d7320490ec3ef7526d203bad4" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "zerofrom" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5" +dependencies = [ + "zerofrom-derive", +] + +[[package]] +name = "zerofrom-derive" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502" +dependencies = [ + "proc-macro2", + "quote", + "syn", + "synstructure", +] + +[[package]] +name = "zeroize" +version = "1.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b97154e67e32c85465826e8bcc1c59429aaaf107c1e4a9e53c8d8ccd5eff88d0" + +[[package]] +name = "zerotrie" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2a59c17a5562d507e4b54960e8569ebee33bee890c70aa3fe7b97e85a9fd7851" +dependencies = [ + "displaydoc", + "yoke", + "zerofrom", +] + +[[package]] +name = "zerovec" +version = "0.11.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6c28719294829477f525be0186d13efa9a3c602f7ec202ca9e353d310fb9a002" +dependencies = [ + "yoke", + "zerofrom", + "zerovec-derive", +] + +[[package]] +name = "zerovec-derive" +version = "0.11.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eadce39539ca5cb3985590102671f2567e659fca9666581ad3411d59207951f3" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "zmij" +version = "1.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa" + +[[package]] +name = "zstd" +version = "0.13.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e91ee311a569c327171651566e07972200e76fcfe2242a4fa446149a3881c08a" +dependencies = [ + "zstd-safe", +] + +[[package]] +name = "zstd-safe" +version = "7.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f49c4d5f0abb602a93fb8736af2a4f4dd9512e36f7f570d66e65ff867ed3b9d" +dependencies = [ + "zstd-sys", +] + +[[package]] +name = "zstd-sys" +version = "2.0.16+zstd.1.5.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "91e19ebc2adc8f83e43039e79776e3fda8ca919132d68a1fed6a5faca2683748" +dependencies = [ + "cc", + "pkg-config", +] diff --git a/Cargo.toml b/Cargo.toml new file mode 100644 index 0000000..9dfbcf0 --- /dev/null +++ b/Cargo.toml @@ -0,0 +1,22 @@ +[package] +name = "onepassword-sdk" +version = "0.4.1-beta.1" +edition = "2024" +publish = false +license = "MIT" +description = "1Password SDK for Rust" + +[features] +default = [] +desktop = ["dep:libloading"] + +[dependencies] +chrono = { version = "0.4", default-features = false, features = ["clock"] } +extism = "1" +getrandom = "0.2" +libloading = { version = "0.8", optional = true } +serde = { version = "1", features = ["derive"] } +serde_json = "1" +thiserror = "2" + +[dev-dependencies] diff --git a/deny.toml b/deny.toml new file mode 100644 index 0000000..e5a215c --- /dev/null +++ b/deny.toml @@ -0,0 +1,31 @@ +[graph] +all-features = true + +[advisories] +unmaintained = "warn" + +[bans] +multiple-versions = "warn" +wildcards = "deny" + +[licenses] +allow = [ + "MIT", + "Apache-2.0", + "BSD-2-Clause", + "BSD-3-Clause", + "ISC", + "Unicode-3.0", + "Unicode-DFS-2016", + "OpenSSL", + "Zlib", +] +confidence-threshold = 0.8 + +[[licenses.exceptions]] +allow = ["MPL-2.0"] +crate = "webpki-roots" + +[sources] +unknown-registry = "deny" +unknown-git = "deny" diff --git a/rust-toolchain.toml b/rust-toolchain.toml new file mode 100644 index 0000000..ee43e83 --- /dev/null +++ b/rust-toolchain.toml @@ -0,0 +1,3 @@ +[toolchain] +channel = "1.93.1" +components = ["rustfmt", "clippy"] diff --git a/src/core.rs b/src/core.rs new file mode 100644 index 0000000..2bbceaf --- /dev/null +++ b/src/core.rs @@ -0,0 +1,152 @@ +use std::collections::HashMap; + +use serde::Serialize; + +use crate::errors::SdkError; + +pub(crate) const SDK_LANGUAGE: &str = "Rust"; +pub(crate) const DEFAULT_REQUEST_LIBRARY: &str = "reqwest"; +pub(crate) const MESSAGE_LIMIT: usize = 50 * 1024 * 1024; + +pub(crate) trait Core: Send + Sync { + fn init_client(&self, config: &[u8]) -> Result, SdkError>; + fn invoke(&self, invoke_config: &[u8]) -> Result, SdkError>; + fn release_client(&self, client_id: &[u8]); +} + +#[derive(Debug, Serialize)] +pub(crate) struct ClientConfig { + #[serde(rename = "serviceAccountToken")] + pub sa_token: String, + #[serde(rename = "programmingLanguage")] + pub language: String, + #[serde(rename = "sdkVersion")] + pub sdk_version: String, + #[serde(rename = "integrationName")] + pub integration_name: String, + #[serde(rename = "integrationVersion")] + pub integration_version: String, + #[serde(rename = "requestLibraryName")] + pub request_library_name: String, + #[serde(rename = "requestLibraryVersion")] + pub request_library_version: String, + #[serde(rename = "os")] + pub system_os: String, + #[serde(rename = "osVersion")] + pub system_os_version: String, + #[serde(rename = "architecture")] + pub system_arch: String, + #[serde(skip_serializing_if = "Option::is_none")] + pub account_name: Option, +} + +impl ClientConfig { + pub fn new_default() -> Self { + Self { + sa_token: String::new(), + language: SDK_LANGUAGE.to_string(), + sdk_version: env!("CARGO_PKG_VERSION").to_string(), + integration_name: "Unknown".to_string(), + integration_version: "Unknown".to_string(), + request_library_name: DEFAULT_REQUEST_LIBRARY.to_string(), + request_library_version: "0.0.0".to_string(), + system_os: std::env::consts::OS.to_string(), + system_os_version: "0.0.0".to_string(), + system_arch: std::env::consts::ARCH.to_string(), + account_name: None, + } + } +} + +#[derive(Debug, Serialize)] +pub(crate) struct InvokeConfig { + pub invocation: Invocation, +} + +#[derive(Debug, Serialize)] +pub(crate) struct Invocation { + #[serde(rename = "clientId", skip_serializing_if = "Option::is_none")] + pub client_id: Option, + pub parameters: Parameters, +} + +#[derive(Debug, Serialize)] +pub(crate) struct Parameters { + pub name: String, + pub parameters: HashMap, +} + +/// Wraps a Core implementation and handles JSON marshaling/unmarshaling. +pub(crate) struct CoreWrapper { + pub inner: Box, +} + +impl CoreWrapper { + pub fn init_client(&self, config: &ClientConfig) -> Result { + let config_bytes = serde_json::to_vec(config)?; + let res = self.inner.init_client(&config_bytes)?; + let id: u64 = serde_json::from_slice(&res)?; + Ok(id) + } + + pub fn invoke(&self, invoke_config: &InvokeConfig) -> Result { + let input = serde_json::to_vec(invoke_config)?; + if input.len() > MESSAGE_LIMIT { + return Err(SdkError::Config(format!( + "message size exceeds the limit of {} bytes", + MESSAGE_LIMIT + ))); + } + let res = self.inner.invoke(&input)?; + Ok(String::from_utf8_lossy(&res).into_owned()) + } + + pub fn release_client(&self, client_id: u64) { + if let Ok(id_bytes) = serde_json::to_vec(&client_id) { + self.inner.release_client(&id_bytes); + } + } +} + +/// The inner client state shared by all API implementations. +pub(crate) struct InnerClient { + pub id: u64, + pub config: ClientConfig, + pub core: CoreWrapper, +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn default_config_has_correct_language() { + let config = ClientConfig::new_default(); + assert_eq!(config.language, "Rust"); + assert_eq!(config.system_os, std::env::consts::OS); + assert_eq!(config.system_arch, std::env::consts::ARCH); + } + + #[test] + fn invoke_config_serializes_correctly() { + let config = InvokeConfig { + invocation: Invocation { + client_id: Some(42), + parameters: Parameters { + name: "SecretsResolve".to_string(), + parameters: { + let mut m = HashMap::new(); + m.insert( + "secret_reference".to_string(), + serde_json::Value::String("op://vault/item/field".to_string()), + ); + m + }, + }, + }, + }; + let json = serde_json::to_string(&config).unwrap(); + assert!(json.contains("\"clientId\":42")); + assert!(json.contains("\"name\":\"SecretsResolve\"")); + } +} diff --git a/src/errors.rs b/src/errors.rs new file mode 100644 index 0000000..93f7c1f --- /dev/null +++ b/src/errors.rs @@ -0,0 +1,87 @@ +use serde::Deserialize; + +#[derive(Debug, thiserror::Error)] +pub enum SdkError { + #[error("1Password SDK error: {message}")] + Core { name: String, message: String }, + + #[error("serialization error: {0}")] + Serialization(#[from] serde_json::Error), + + #[error("WASM plugin error: {0}")] + Plugin(String), + + #[error("configuration error: {0}")] + Config(String), + + #[error("desktop session expired: {0}")] + DesktopSessionExpired(String), + + #[error("rate limit exceeded: {0}")] + RateLimitExceeded(String), + + #[error("shared library error: {0}")] + SharedLib(String), +} + +#[derive(Deserialize)] +struct CoreError { + name: String, + message: String, +} + +/// Deserialize a JSON error string from the WASM core into an SdkError. +pub(crate) fn unmarshal_error(err: &str) -> SdkError { + match serde_json::from_str::(err) { + Ok(core_err) => match core_err.name.as_str() { + "DesktopSessionExpired" => SdkError::DesktopSessionExpired(core_err.message), + "RateLimitExceeded" => SdkError::RateLimitExceeded(core_err.message), + _ => SdkError::Core { + name: core_err.name, + message: core_err.message, + }, + }, + Err(_) => SdkError::Core { + name: "Unknown".to_string(), + message: err.to_string(), + }, + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn unmarshal_core_error() { + let err = unmarshal_error(r#"{"name":"SomeError","message":"something broke"}"#); + match err { + SdkError::Core { name, message } => { + assert_eq!(name, "SomeError"); + assert_eq!(message, "something broke"); + } + _ => panic!("expected Core error"), + } + } + + #[test] + fn unmarshal_session_expired() { + let err = unmarshal_error(r#"{"name":"DesktopSessionExpired","message":"session gone"}"#); + assert!(matches!(err, SdkError::DesktopSessionExpired(_))); + } + + #[test] + fn unmarshal_rate_limit() { + let err = unmarshal_error(r#"{"name":"RateLimitExceeded","message":"slow down"}"#); + assert!(matches!(err, SdkError::RateLimitExceeded(_))); + } + + #[test] + fn unmarshal_invalid_json() { + let err = unmarshal_error("not json at all"); + match err { + SdkError::Core { message, .. } => assert_eq!(message, "not json at all"), + _ => panic!("expected Core error for invalid JSON"), + } + } +} diff --git a/src/lib.rs b/src/lib.rs new file mode 100644 index 0000000..36c0fc6 --- /dev/null +++ b/src/lib.rs @@ -0,0 +1,10 @@ +#![deny(unsafe_code)] + +#[allow(dead_code)] +mod core; +#[allow(dead_code)] +mod errors; +mod types; + +pub use errors::SdkError; +pub use types::*; diff --git a/src/types.rs b/src/types.rs new file mode 100644 index 0000000..29d6336 --- /dev/null +++ b/src/types.rs @@ -0,0 +1,676 @@ +use serde::{Deserialize, Serialize}; + +pub type ErrorMessage = String; + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct AddressFieldDetails { + pub street: String, + pub city: String, + pub country: String, + pub zip: String, + pub state: String, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct DocumentCreateParams { + pub name: String, + pub content: Vec, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct FileAttributes { + pub name: String, + pub id: String, + pub size: u32, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct FileCreateParams { + pub name: String, + pub content: Vec, + pub section_id: String, + pub field_id: String, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct EnvironmentVariable { + pub name: String, + pub value: String, + pub masked: bool, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct GetVariablesResponse { + pub variables: Vec, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct GeneratePasswordResponse { + pub password: String, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub enum SeparatorType { + Digits, + DigitsAndSymbols, + Spaces, + Hyphens, + Underscores, + Periods, + Commas, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub enum WordListType { + FullWords, + Syllables, + ThreeLetters, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct PasswordRecipeMemorableInner { + pub separator_type: SeparatorType, + pub capitalize: bool, + pub word_list_type: WordListType, + pub word_count: u32, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct PasswordRecipePinInner { + pub length: u32, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct PasswordRecipeRandomInner { + pub include_digits: bool, + pub include_symbols: bool, + pub length: u32, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(tag = "type", content = "parameters")] +pub enum PasswordRecipe { + Memorable(PasswordRecipeMemorableInner), + Pin(PasswordRecipePinInner), + Random(PasswordRecipeRandomInner), +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct SSHKeyAttributes { + pub public_key: String, + pub fingerprint: String, + pub key_type: String, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct OTPFieldDetails { + #[serde(skip_serializing_if = "Option::is_none")] + pub code: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub error_message: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(tag = "type", content = "content")] +pub enum ItemFieldDetails { + Otp(OTPFieldDetails), + SshKey(SSHKeyAttributes), + Address(AddressFieldDetails), +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub enum ItemCategory { + Login, + SecureNote, + CreditCard, + CryptoWallet, + Identity, + Password, + Document, + ApiCredentials, + BankAccount, + Database, + DriverLicense, + Email, + MedicalRecord, + Membership, + OutdoorLicense, + Passport, + Rewards, + Router, + Server, + SshKey, + SocialSecurityNumber, + SoftwareLicense, + Person, + Unsupported, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub enum ItemFieldType { + Text, + Concealed, + CreditCardType, + CreditCardNumber, + Phone, + Url, + Totp, + Email, + Reference, + SshKey, + Menu, + MonthYear, + Address, + Date, + Unsupported, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub enum ItemState { + Active, + Archived, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub enum AutofillBehavior { + AnywhereOnWebsite, + ExactDomain, + Never, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct Website { + pub url: String, + pub label: String, + pub autofill_behavior: AutofillBehavior, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct ItemField { + pub id: String, + pub title: String, + #[serde(skip_serializing_if = "Option::is_none")] + pub section_id: Option, + pub field_type: ItemFieldType, + pub value: String, + #[serde(skip_serializing_if = "Option::is_none")] + pub details: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct ItemSection { + pub id: String, + pub title: String, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct ItemFile { + pub attributes: FileAttributes, + pub section_id: String, + pub field_id: String, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct Item { + pub id: String, + pub title: String, + pub category: ItemCategory, + pub vault_id: String, + pub fields: Vec, + pub sections: Vec, + pub notes: String, + pub tags: Vec, + pub websites: Vec, + pub version: u32, + pub files: Vec, + #[serde(skip_serializing_if = "Option::is_none")] + pub document: Option, + pub created_at: String, + pub updated_at: String, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct ItemCreateParams { + pub category: ItemCategory, + pub vault_id: String, + pub title: String, + #[serde(skip_serializing_if = "Option::is_none")] + pub fields: Option>, + #[serde(skip_serializing_if = "Option::is_none")] + pub sections: Option>, + #[serde(skip_serializing_if = "Option::is_none")] + pub notes: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub tags: Option>, + #[serde(skip_serializing_if = "Option::is_none")] + pub websites: Option>, + #[serde(skip_serializing_if = "Option::is_none")] + pub files: Option>, + #[serde(skip_serializing_if = "Option::is_none")] + pub document: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct ItemOverview { + pub id: String, + pub title: String, + pub category: ItemCategory, + pub vault_id: String, + pub websites: Vec, + pub tags: Vec, + pub created_at: String, + pub updated_at: String, + pub state: ItemState, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct ItemListFilterByStateInner { + pub active: bool, + pub archived: bool, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(tag = "type", content = "content")] +pub enum ItemListFilter { + ByState(ItemListFilterByStateInner), +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub enum ItemShareDuration { + OneHour, + OneDay, + SevenDays, + FourteenDays, + ThirtyDays, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub enum AllowedType { + Authenticated, + Public, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub enum AllowedRecipientType { + Email, + Domain, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct ItemShareFiles { + pub allowed: bool, + pub max_size: u32, + #[serde(skip_serializing_if = "Option::is_none")] + pub allowed_types: Option>, + #[serde(skip_serializing_if = "Option::is_none")] + pub allowed_recipient_types: Option>, + #[serde(skip_serializing_if = "Option::is_none")] + pub max_expiry: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub default_expiry: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub max_views: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct ItemShareAccountPolicy { + pub max_expiry: ItemShareDuration, + pub default_expiry: ItemShareDuration, + #[serde(skip_serializing_if = "Option::is_none")] + pub max_views: Option, + pub allowed_types: Vec, + pub allowed_recipient_types: Vec, + pub files: ItemShareFiles, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct ValidRecipientEmailInner { + pub email: String, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct ValidRecipientDomainInner { + pub domain: String, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(tag = "type", content = "parameters")] +pub enum ValidRecipient { + Email(ValidRecipientEmailInner), + Domain(ValidRecipientDomainInner), +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct ItemShareParams { + #[serde(skip_serializing_if = "Option::is_none")] + pub recipients: Option>, + #[serde(skip_serializing_if = "Option::is_none")] + pub expire_after: Option, + pub one_time_only: bool, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct BatchResponse { + #[serde(skip_serializing_if = "Option::is_none")] + pub content: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub error: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(tag = "type", content = "message")] +#[serde(rename_all = "camelCase")] +pub enum ItemUpdateFailureReason { + ItemValidationError(ErrorMessage), + ItemStatusPermissionError, + ItemStatusIncorrectItemVersion, + ItemStatusFileNotFound, + ItemStatusTooBig, + ItemNotFound, + Internal(ErrorMessage), +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct ItemsDeleteAllResponse { + pub individual_responses: + std::collections::HashMap>, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub enum ItemsGetAllError { + #[serde(rename = "itemNotFound")] + ItemNotFound, + #[serde(rename = "internal")] + Internal(ErrorMessage), +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct ItemsGetAllResponse { + pub individual_responses: Vec>, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct ItemsUpdateAllResponse { + pub individual_responses: Vec>, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct ResolvedReference { + pub secret: String, + pub item_id: String, + pub vault_id: String, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(tag = "type", content = "message")] +#[serde(rename_all = "camelCase")] +pub enum ResolveReferenceError { + Parsing(ErrorMessage), + FieldNotFound, + VaultNotFound, + TooManyVaults, + ItemNotFound, + TooManyItems, + TooManyMatchingFields, + NoMatchingSections, + IncompatibleTOTPQueryParameterField, + #[serde(rename = "unableToGenerateTotpCode")] + UnableToGenerateTOTPCode(ErrorMessage), + #[serde(rename = "sSHKeyMetadataNotFound")] + SSHKeyMetadataNotFound, + UnsupportedFileFormat, + #[serde(rename = "incompatibleSshKeyQueryParameterField")] + IncompatibleSSHKeyQueryParameterField, + UnableToParsePrivateKey, + #[serde(rename = "unableToFormatPrivateKeyToOpenSsh")] + UnableToFormatPrivateKeyToOpenSSH, + Other, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct ResolveAllResponse { + pub individual_responses: + std::collections::HashMap>, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub enum GroupType { + Owners, + Administrators, + Recovery, + ExternalAccountManagers, + TeamMembers, + UserDefined, + Unsupported, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub enum GroupState { + Active, + Deleted, + Unsupported, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub enum VaultAccessorType { + User, + Group, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct VaultAccess { + pub vault_uuid: String, + pub accessor_type: VaultAccessorType, + pub accessor_uuid: String, + pub permissions: u32, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct Group { + pub id: String, + pub title: String, + pub description: String, + pub group_type: GroupType, + pub state: GroupState, + #[serde(skip_serializing_if = "Option::is_none")] + pub vault_access: Option>, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct GroupAccess { + pub group_id: String, + pub permissions: u32, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct GroupGetParams { + #[serde(skip_serializing_if = "Option::is_none")] + pub vault_permissions: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct GroupVaultAccess { + pub vault_id: String, + pub group_id: String, + pub permissions: u32, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub enum VaultType { + Personal, + Everyone, + Transfer, + UserCreated, + Unsupported, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct Vault { + pub id: String, + pub title: String, + pub description: String, + pub vault_type: VaultType, + pub active_item_count: u32, + pub content_version: u32, + pub attribute_version: u32, + #[serde(skip_serializing_if = "Option::is_none")] + pub access: Option>, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct VaultCreateParams { + pub title: String, + #[serde(skip_serializing_if = "Option::is_none")] + pub description: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub allow_admins_access: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct VaultGetParams { + #[serde(skip_serializing_if = "Option::is_none")] + pub accessors: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct VaultListParams { + #[serde(skip_serializing_if = "Option::is_none")] + pub decrypt_details: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct VaultOverview { + pub id: String, + pub title: String, + pub description: String, + pub vault_type: VaultType, + pub active_item_count: u32, + pub content_version: u32, + pub attribute_version: u32, + pub created_at: String, + pub updated_at: String, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct VaultUpdateParams { + #[serde(skip_serializing_if = "Option::is_none")] + pub title: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub description: Option, +} + +pub mod permissions { + pub const READ_ITEMS: u32 = 32; + pub const REVEAL_ITEM_PASSWORD: u32 = 16; + pub const UPDATE_ITEMS: u32 = 64; + pub const CREATE_ITEMS: u32 = 128; + pub const ARCHIVE_ITEMS: u32 = 256; + pub const DELETE_ITEMS: u32 = 512; + pub const UPDATE_ITEM_HISTORY: u32 = 1024; + pub const SEND_ITEMS: u32 = 1_048_576; + pub const IMPORT_ITEMS: u32 = 2_097_152; + pub const EXPORT_ITEMS: u32 = 4_194_304; + pub const PRINT_ITEMS: u32 = 8_388_608; + pub const MANAGE_VAULT: u32 = 2; + pub const RECOVER_VAULT: u32 = 1; + pub const NO_ACCESS: u32 = 0; +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn password_recipe_serializes_as_tagged_enum() { + let recipe = PasswordRecipe::Random(PasswordRecipeRandomInner { + include_digits: true, + include_symbols: false, + length: 20, + }); + let json = serde_json::to_string(&recipe).unwrap(); + assert!(json.contains("\"type\":\"Random\"")); + assert!(json.contains("\"parameters\":")); + } + + #[test] + fn item_field_details_roundtrip() { + let details = ItemFieldDetails::Otp(OTPFieldDetails { + code: Some("123456".to_string()), + error_message: None, + }); + let json = serde_json::to_string(&details).unwrap(); + let parsed: ItemFieldDetails = serde_json::from_str(&json).unwrap(); + match parsed { + ItemFieldDetails::Otp(otp) => assert_eq!(otp.code.unwrap(), "123456"), + _ => panic!("expected Otp variant"), + } + } + + #[test] + fn valid_recipient_roundtrip() { + let recipient = ValidRecipient::Email(ValidRecipientEmailInner { + email: "test@example.com".to_string(), + }); + let json = serde_json::to_string(&recipient).unwrap(); + assert!(json.contains("\"type\":\"Email\"")); + let parsed: ValidRecipient = serde_json::from_str(&json).unwrap(); + match parsed { + ValidRecipient::Email(inner) => assert_eq!(inner.email, "test@example.com"), + _ => panic!("expected Email variant"), + } + } + + #[test] + fn item_list_filter_roundtrip() { + let filter = ItemListFilter::ByState(ItemListFilterByStateInner { + active: true, + archived: false, + }); + let json = serde_json::to_string(&filter).unwrap(); + let parsed: ItemListFilter = serde_json::from_str(&json).unwrap(); + match parsed { + ItemListFilter::ByState(inner) => { + assert!(inner.active); + assert!(!inner.archived); + } + } + } +} From 24b792a51e33949fdf92c930f698e7481aebc31f Mon Sep 17 00:00:00 2001 From: Matthew Kern Date: Mon, 30 Mar 2026 17:12:22 -0700 Subject: [PATCH 04/25] feat: add ExtismCore WASM runtime with embedded core.wasm Implements the Core trait using the Extism SDK with the embedded 9MB WASM binary. Registers required host functions (random_fill, unix_time_milliseconds, utc_offset_seconds) in their respective namespaces and configures allowed 1Password hosts. --- src/core_extism.rs | 160 +++++++++++++++++++++++++++++++++++++++++++++ src/lib.rs | 2 + wasm/core.wasm | Bin 0 -> 9509477 bytes 3 files changed, 162 insertions(+) create mode 100644 src/core_extism.rs create mode 100644 wasm/core.wasm diff --git a/src/core_extism.rs b/src/core_extism.rs new file mode 100644 index 0000000..30d995c --- /dev/null +++ b/src/core_extism.rs @@ -0,0 +1,160 @@ +use std::sync::Mutex; + +use extism::{Manifest, Plugin, PluginBuilder, UserData, ValType, Wasm}; + +use crate::core::{Core, MESSAGE_LIMIT}; +use crate::errors::SdkError; + +static CORE_WASM: &[u8] = include_bytes!("../wasm/core.wasm"); + +/// Allowed 1Password hosts that the WASM core may connect to. +const ALLOWED_HOSTS: &[&str] = &[ + "*.1password.com", + "*.1password.ca", + "*.1password.eu", + "*.b5staging.com", + "*.b5dev.com", + "*.b5dev.ca", + "*.b5dev.eu", + "*.b5test.com", + "*.b5test.ca", + "*.b5test.eu", + "*.b5rev.com", + "*.b5local.com", +]; + +/// ExtismCore implements the [`Core`] trait using an embedded WASM binary +/// loaded through the Extism runtime. +pub(crate) struct ExtismCore { + plugin: Mutex, +} + +impl ExtismCore { + /// Create a new `ExtismCore` by loading the embedded WASM binary and + /// registering required host functions. + pub fn new() -> Result { + let wasm = Wasm::data(CORE_WASM); + let manifest = + Manifest::new([wasm]).with_allowed_hosts(ALLOWED_HOSTS.iter().map(|h| h.to_string())); + + let no_data: UserData<()> = UserData::new(()); + + let plugin = PluginBuilder::new(manifest) + .with_wasi(true) + // random_fill_imported: fills a buffer with crypto-random bytes + // Takes I32 (length), returns I64 (pointer to allocated memory) + .with_function_in_namespace( + "op-extism-core", + "random_fill_imported", + [ValType::I32], + [ValType::I64], + no_data.clone(), + random_fill, + ) + // unix_time_milliseconds_imported in "op-now" namespace + .with_function_in_namespace( + "op-now", + "unix_time_milliseconds_imported", + [], + [ValType::I64], + no_data.clone(), + unix_time_milliseconds, + ) + // unix_time_milliseconds_imported in "zxcvbn" namespace + .with_function_in_namespace( + "zxcvbn", + "unix_time_milliseconds_imported", + [], + [ValType::I64], + no_data.clone(), + unix_time_milliseconds, + ) + // utc_offset_seconds in "op-time" namespace + .with_function_in_namespace( + "op-time", + "utc_offset_seconds", + [], + [ValType::I64], + no_data, + utc_offset_seconds, + ) + .build() + .map_err(|e| SdkError::Plugin(format!("failed to initialize WASM plugin: {e}")))?; + + Ok(Self { + plugin: Mutex::new(plugin), + }) + } +} + +impl Core for ExtismCore { + fn init_client(&self, config: &[u8]) -> Result, SdkError> { + let mut plugin = self.plugin.lock().unwrap(); + let res = plugin + .call::<&[u8], &[u8]>("init_client", config) + .map_err(|e| SdkError::Plugin(e.to_string()))?; + Ok(res.to_vec()) + } + + fn invoke(&self, invoke_config: &[u8]) -> Result, SdkError> { + if invoke_config.len() > MESSAGE_LIMIT { + return Err(SdkError::Config(format!( + "message size exceeds the limit of {} bytes", + MESSAGE_LIMIT + ))); + } + let mut plugin = self.plugin.lock().unwrap(); + let res = plugin + .call::<&[u8], &[u8]>("invoke", invoke_config) + .map_err(|e| SdkError::Plugin(e.to_string()))?; + Ok(res.to_vec()) + } + + fn release_client(&self, client_id: &[u8]) { + let mut plugin = self.plugin.lock().unwrap(); + let _ = plugin.call::<&[u8], &[u8]>("release_client", client_id); + } +} + +/// Host function: generate cryptographically random bytes. +/// +/// The WASM core calls this with a length (I32) and expects back a pointer (I64) +/// to the allocated memory block containing the random bytes. +fn random_fill( + plugin: &mut extism::CurrentPlugin, + inputs: &[extism::Val], + outputs: &mut [extism::Val], + _user_data: UserData<()>, +) -> Result<(), extism::Error> { + let length = inputs[0].unwrap_i32() as u32; + let mut buf = vec![0u8; length as usize]; + getrandom::getrandom(&mut buf) + .map_err(|e| extism::Error::msg(format!("getrandom failed: {e}")))?; + let handle = plugin.memory_new(&buf)?; + outputs[0] = plugin.memory_to_val(handle); + Ok(()) +} + +/// Host function: return current Unix timestamp in milliseconds. +fn unix_time_milliseconds( + _plugin: &mut extism::CurrentPlugin, + _inputs: &[extism::Val], + outputs: &mut [extism::Val], + _user_data: UserData<()>, +) -> Result<(), extism::Error> { + let now = chrono::Utc::now().timestamp_millis(); + outputs[0] = extism::Val::I64(now); + Ok(()) +} + +/// Host function: return the local timezone's UTC offset in seconds. +fn utc_offset_seconds( + _plugin: &mut extism::CurrentPlugin, + _inputs: &[extism::Val], + outputs: &mut [extism::Val], + _user_data: UserData<()>, +) -> Result<(), extism::Error> { + let offset_secs = chrono::Local::now().offset().local_minus_utc(); + outputs[0] = extism::Val::I64(offset_secs as i64); + Ok(()) +} diff --git a/src/lib.rs b/src/lib.rs index 36c0fc6..92e524a 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -3,6 +3,8 @@ #[allow(dead_code)] mod core; #[allow(dead_code)] +mod core_extism; +#[allow(dead_code)] mod errors; mod types; diff --git a/wasm/core.wasm b/wasm/core.wasm new file mode 100644 index 0000000000000000000000000000000000000000..f502ba45cdcebbf1f278baac884d09b8e2d18999 GIT binary patch literal 9509477 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%0A0fkh&JHbqKX0|qG|SoNDjC0;j=S8S&AX}DZ!!E4 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%0Djiec^)R;iFL+S#x&FYtWX7o!9)Au^o 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 I7K&=bWP^P)%fwf)+ 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