From a634edccf9c3800694542982598ba82ffe945f9c Mon Sep 17 00:00:00 2001 From: Trezy Date: Thu, 19 Mar 2026 21:16:57 -0500 Subject: [PATCH 1/6] wasm infra --- Cargo.lock | 1459 ++++++++++++++++- Cargo.toml | 5 + .../postgres/20260319000001_plugin_tables.sql | 60 + .../sqlite/20260319000001_plugin_tables.sql | 60 + src/config.rs | 9 + src/external_auth/mod.rs | 4 + src/external_auth/routes.rs | 114 ++ src/external_auth/sync.rs | 55 + src/lib.rs | 3 + src/lua/atproto_api.rs | 2 + src/lua/db_api.rs | 2 + src/lua/execute.rs | 2 + src/lua/http_api.rs | 2 + src/main.rs | 40 + src/plugin/encryption.rs | 111 ++ src/plugin/host/http.rs | 133 ++ src/plugin/host/kv.rs | 104 ++ src/plugin/host/logging.rs | 70 + src/plugin/host/lookup.rs | 67 + src/plugin/host/mod.rs | 41 + src/plugin/host/secrets.rs | 33 + src/plugin/loader.rs | 201 +++ src/plugin/mod.rs | 41 + src/plugin/runtime.rs | 27 + src/plugin/types.rs | 98 ++ src/server.rs | 1 + tests/common/app.rs | 2 + tests/lua_atproto_api.rs | 2 + tests/lua_db_api.rs | 2 + tests/plugin_integration.rs | 73 + 30 files changed, 2777 insertions(+), 46 deletions(-) create mode 100644 migrations/postgres/20260319000001_plugin_tables.sql create mode 100644 migrations/sqlite/20260319000001_plugin_tables.sql create mode 100644 src/external_auth/mod.rs create mode 100644 src/external_auth/routes.rs create mode 100644 src/external_auth/sync.rs create mode 100644 src/plugin/encryption.rs create mode 100644 src/plugin/host/http.rs create mode 100644 src/plugin/host/kv.rs create mode 100644 src/plugin/host/logging.rs create mode 100644 src/plugin/host/lookup.rs create mode 100644 src/plugin/host/mod.rs create mode 100644 src/plugin/host/secrets.rs create mode 100644 src/plugin/loader.rs create mode 100644 src/plugin/mod.rs create mode 100644 src/plugin/runtime.rs create mode 100644 src/plugin/types.rs create mode 100644 tests/plugin_integration.rs diff --git a/Cargo.lock b/Cargo.lock index 49e7225..9c9026a 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2,12 +2,68 @@ # It is not intended for manual editing. version = 4 +[[package]] +name = "addr2line" +version = "0.24.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dfbe277e56a376000877090da837660b4427aad530e3028d44e0bffe4f89a1c1" +dependencies = [ + "gimli", +] + [[package]] name = "adler2" version = "2.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa" +[[package]] +name = "aead" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d122413f284cf2d62fb1b7db97e02edb8cda96d769b16e443a4f6195e35662b0" +dependencies = [ + "crypto-common", + "generic-array", +] + +[[package]] +name = "aes" +version = "0.8.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0" +dependencies = [ + "cfg-if", + "cipher", + "cpufeatures", +] + +[[package]] +name = "aes-gcm" +version = "0.10.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "831010a0f742e1209b3bcea8fab6a8e149051ba6099432c8cb2cc117dec3ead1" +dependencies = [ + "aead", + "aes", + "cipher", + "ctr", + "ghash", + "subtle", +] + +[[package]] +name = "ahash" +version = "0.8.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75" +dependencies = [ + "cfg-if", + "once_cell", + "version_check", + "zerocopy", +] + [[package]] name = "aho-corasick" version = "1.1.4" @@ -23,6 +79,12 @@ 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" @@ -38,6 +100,21 @@ version = "1.0.101" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5f0e0fee31ef5ed1ba1316088939cea399010ed7731dba877ed44aeb407a75ea" +[[package]] +name = "ar_archive_writer" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7eb93bbb63b9c227414f6eb3a0adfddca591a8ce1e9b60661bb08969b87e340b" +dependencies = [ + "object 0.37.3", +] + +[[package]] +name = "arbitrary" +version = "1.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c3d036a3c4ab069c7b410a2ce876bd74808d2d0888a82667669f8e783a898bf1" + [[package]] name = "arc-swap" version = "1.8.2" @@ -168,7 +245,7 @@ dependencies = [ "atrium-common", "atrium-identity", "atrium-xrpc", - "base64", + "base64 0.22.1", "chrono", "dashmap", "ecdsa", @@ -330,6 +407,12 @@ dependencies = [ "match-lookup", ] +[[package]] +name = "base64" +version = "0.21.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567" + [[package]] name = "base64" version = "0.22.1" @@ -375,6 +458,9 @@ name = "bumpalo" version = "3.19.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5dd9dc738b7a8311c7ade152424974d8115f2cdad61e8dab8dac9f2362298510" +dependencies = [ + "allocator-api2", +] [[package]] name = "byteorder" @@ -388,6 +474,84 @@ 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.52.0", +] + +[[package]] +name = "cap-net-ext" +version = "3.4.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "20a158160765c6a7d0d8c072a53d772e4cb243f38b04bfcf6b4939cfbe7482e7" +dependencies = [ + "cap-primitives", + "cap-std", + "rustix 1.1.3", + "smallvec", +] + +[[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.3", + "rustix-linux-procfs", + "windows-sys 0.52.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 0.8.5", +] + +[[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.3", +] + +[[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.3", + "winx", +] + [[package]] name = "cc" version = "1.2.55" @@ -461,6 +625,16 @@ dependencies = [ "unsigned-varint", ] +[[package]] +name = "cipher" +version = "0.4.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad" +dependencies = [ + "crypto-common", + "inout", +] + [[package]] name = "cmake" version = "0.1.57" @@ -470,6 +644,15 @@ dependencies = [ "cc", ] +[[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 = "compression-codecs" version = "0.4.37" @@ -514,7 +697,7 @@ version = "0.18.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4ddef33a339a91ea89fb53151bd0a4689cfce27055c291dfa69945475d22c747" dependencies = [ - "base64", + "base64 0.22.1", "hkdf", "hmac", "percent-encoding", @@ -550,6 +733,15 @@ dependencies = [ "memchr", ] +[[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" @@ -559,6 +751,113 @@ dependencies = [ "libc", ] +[[package]] +name = "cranelift-bforest" +version = "0.116.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e15d04a0ce86cb36ead88ad68cf693ffd6cda47052b9e0ac114bc47fd9cd23c4" +dependencies = [ + "cranelift-entity", +] + +[[package]] +name = "cranelift-bitset" +version = "0.116.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7c6e3969a7ce267259ce244b7867c5d3bc9e65b0a87e81039588dfdeaede9f34" +dependencies = [ + "serde", + "serde_derive", +] + +[[package]] +name = "cranelift-codegen" +version = "0.116.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2c22032c4cb42558371cf516bb47f26cdad1819d3475c133e93c49f50ebf304e" +dependencies = [ + "bumpalo", + "cranelift-bforest", + "cranelift-bitset", + "cranelift-codegen-meta", + "cranelift-codegen-shared", + "cranelift-control", + "cranelift-entity", + "cranelift-isle", + "gimli", + "hashbrown 0.14.5", + "log", + "regalloc2", + "rustc-hash", + "serde", + "smallvec", + "target-lexicon", +] + +[[package]] +name = "cranelift-codegen-meta" +version = "0.116.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c904bc71c61b27fc57827f4a1379f29de64fe95653b620a3db77d59655eee0b8" +dependencies = [ + "cranelift-codegen-shared", +] + +[[package]] +name = "cranelift-codegen-shared" +version = "0.116.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "40180f5497572f644ce88c255480981ae2ec1d7bb4d8e0c0136a13b87a2f2ceb" + +[[package]] +name = "cranelift-control" +version = "0.116.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "26d132c6d0bd8a489563472afc171759da0707804a65ece7ceb15a8c6d7dd5ef" +dependencies = [ + "arbitrary", +] + +[[package]] +name = "cranelift-entity" +version = "0.116.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4b2d0d9618275474fbf679dd018ac6e009acbd6ae6850f6a67be33fb3b00b323" +dependencies = [ + "cranelift-bitset", + "serde", + "serde_derive", +] + +[[package]] +name = "cranelift-frontend" +version = "0.116.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4fac41e16729107393174b0c9e3730fb072866100e1e64e80a1a963b2e484d57" +dependencies = [ + "cranelift-codegen", + "log", + "smallvec", + "target-lexicon", +] + +[[package]] +name = "cranelift-isle" +version = "0.116.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1ca20d576e5070044d0a72a9effc2deacf4d6aa650403189d8ea50126483944d" + +[[package]] +name = "cranelift-native" +version = "0.116.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8dee82f3f1f2c4cba9177f1cc5e350fe98764379bcd29340caa7b01f85076c7" +dependencies = [ + "cranelift-codegen", + "libc", + "target-lexicon", +] + [[package]] name = "crc" version = "3.4.0" @@ -598,6 +897,16 @@ dependencies = [ "crossbeam-utils", ] +[[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" @@ -647,9 +956,19 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a" dependencies = [ "generic-array", + "rand_core 0.6.4", "typenum", ] +[[package]] +name = "ctr" +version = "0.9.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0369ee1ad671834580515889b80f2ea915f23b8be8d0daa4bbaf2ac5c7590835" +dependencies = [ + "cipher", +] + [[package]] name = "dashmap" version = "6.1.0" @@ -708,6 +1027,15 @@ version = "0.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "092966b41edc516079bdf31ec78a2e0588d1d0c08f78b91d8307215928642b2b" +[[package]] +name = "debugid" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bef552e6f588e446098f6ba40d89ac146c8c7b64aade83c051ee00bb5d2bc18d" +dependencies = [ + "uuid", +] + [[package]] name = "der" version = "0.7.10" @@ -740,6 +1068,47 @@ dependencies = [ "subtle", ] +[[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" +version = "4.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ca3aa72a6f96ea37bbc5aa912f6788242832f75369bdfdadcb0e38423f100059" +dependencies = [ + "dirs-sys", +] + +[[package]] +name = "dirs-sys" +version = "0.3.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1b1d1d91c932ef41c0f2663aa8b0ca0342d444d842c06914aa0a7e352d0bada6" +dependencies = [ + "libc", + "redox_users", + "winapi", +] + +[[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" @@ -806,6 +1175,18 @@ dependencies = [ "zeroize", ] +[[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" @@ -892,12 +1273,29 @@ dependencies = [ "pin-project-lite", ] +[[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.3", + "windows-sys 0.52.0", +] + [[package]] name = "ff" version = "0.13.1" @@ -971,6 +1369,17 @@ 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.3", + "windows-sys 0.52.0", +] + [[package]] name = "fs_extra" version = "1.3.0" @@ -1078,25 +1487,47 @@ dependencies = [ ] [[package]] -name = "generic-array" -version = "0.14.7" +name = "fxhash" +version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a" +checksum = "c31b6d751ae2c7f11320402d34e41349dd1016f8d5d45e48c4312bc8625af50c" dependencies = [ - "typenum", - "version_check", - "zeroize", + "byteorder", ] [[package]] -name = "getrandom" -version = "0.2.17" +name = "fxprof-processed-profile" +version = "0.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0" +checksum = "27d12c0aed7f1e24276a241aadc4cb8ea9f83000f34bc062b7cc2d51e3b0fabd" dependencies = [ - "cfg-if", - "js-sys", - "libc", + "bitflags", + "debugid", + "fxhash", + "serde", + "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", + "zeroize", +] + +[[package]] +name = "getrandom" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0" +dependencies = [ + "cfg-if", + "js-sys", + "libc", "wasi", "wasm-bindgen", ] @@ -1126,6 +1557,27 @@ dependencies = [ "wasip3", ] +[[package]] +name = "ghash" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0d8a4362ccb29cb0b265253fb0a2728f592895ee6854fd9bc13f2ffda266ff1" +dependencies = [ + "opaque-debug", + "polyval", +] + +[[package]] +name = "gimli" +version = "0.31.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "07e28edb80900c19c28f1072f2e8aeca7fa06b23cd4169cefe1af5aa3260783f" +dependencies = [ + "fallible-iterator", + "indexmap", + "stable_deref_trait", +] + [[package]] name = "group" version = "0.13.0" @@ -1171,6 +1623,8 @@ dependencies = [ name = "happyview" version = "0.1.0" dependencies = [ + "aes-gcm", + "anyhow", "arc-swap", "atrium-api", "atrium-common", @@ -1179,7 +1633,7 @@ dependencies = [ "atrium-xrpc", "axum", "axum-extra", - "base64", + "base64 0.22.1", "bytes", "chrono", "ciborium", @@ -1205,6 +1659,7 @@ dependencies = [ "serial_test", "sha2", "sqlx", + "thiserror 2.0.18", "tokio", "tokio-rustls", "tokio-tungstenite", @@ -1214,6 +1669,8 @@ dependencies = [ "tracing-subscriber", "urlencoding", "uuid", + "wasmtime", + "wasmtime-wasi", "webpki-roots 0.26.11", "wiremock", ] @@ -1223,6 +1680,9 @@ name = "hashbrown" version = "0.14.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1" +dependencies = [ + "ahash", +] [[package]] name = "hashbrown" @@ -1233,6 +1693,7 @@ dependencies = [ "allocator-api2", "equivalent", "foldhash", + "serde", ] [[package]] @@ -1453,7 +1914,7 @@ version = "0.1.20" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "96547c2556ec9d12fb1578c4eaf448b04993e7fb79cbaad930a656880a6bdfa0" dependencies = [ - "base64", + "base64 0.22.1", "bytes", "futures-channel", "futures-util", @@ -1616,6 +2077,31 @@ dependencies = [ "serde_core", ] +[[package]] +name = "inout" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01" +dependencies = [ + "generic-array", +] + +[[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.52.0", +] + +[[package]] +name = "io-lifetimes" +version = "2.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "06432fb54d3be7964ecd3649233cddf80db2832f47fec34c01f65b3d9d774983" + [[package]] name = "ipconfig" version = "0.3.2" @@ -1655,12 +2141,41 @@ dependencies = [ "serde", ] +[[package]] +name = "itertools" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569" +dependencies = [ + "either", +] + [[package]] name = "itoa" version = "1.0.17" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2" +[[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" @@ -1721,7 +2236,7 @@ version = "9.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5a87cc7a48537badeae96744432de36f4be2b4a34a05a5ef32e9dd8a1c169dde" dependencies = [ - "base64", + "base64 0.22.1", "js-sys", "pem", "ring", @@ -1762,6 +2277,12 @@ dependencies = [ "spin", ] +[[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" @@ -1802,6 +2323,12 @@ dependencies = [ "vcpkg", ] +[[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.11.0" @@ -1857,6 +2384,15 @@ dependencies = [ "which", ] +[[package]] +name = "mach2" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d640282b302c0bb0a2a8e0233ead9035e3bed871f0b7e81fe4a1ec829765db44" +dependencies = [ + "libc", +] + [[package]] name = "match-lookup" version = "0.1.2" @@ -1883,6 +2419,12 @@ version = "0.8.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "47e1ffaa40ddd1f3ed91f717a33c8c0ee23fff369e3aa8772b9605cc1d22f4c3" +[[package]] +name = "maybe-owned" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4facc753ae494aeb6e3c22f839b158aebd4f9270f55cd3c79906c45476c47ab4" + [[package]] name = "md-5" version = "0.10.6" @@ -1899,6 +2441,15 @@ 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.3", +] + [[package]] name = "mime" version = "0.3.17" @@ -2128,6 +2679,27 @@ dependencies = [ "libc", ] +[[package]] +name = "object" +version = "0.36.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "62948e14d923ea95ea2c7c86c71013138b66525b86bdc08d2dcc262bdb497b87" +dependencies = [ + "crc32fast", + "hashbrown 0.15.5", + "indexmap", + "memchr", +] + +[[package]] +name = "object" +version = "0.37.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff76201f031d8863c38aa7f905eca4f53abbfa15f609db4277d44cd8938f33fe" +dependencies = [ + "memchr", +] + [[package]] name = "once_cell" version = "1.21.3" @@ -2138,6 +2710,12 @@ dependencies = [ "portable-atomic", ] +[[package]] +name = "opaque-debug" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381" + [[package]] name = "openssl" version = "0.10.75" @@ -2232,13 +2810,19 @@ dependencies = [ "windows-link", ] +[[package]] +name = "paste" +version = "1.0.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a" + [[package]] name = "pem" version = "3.0.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1d30c53c26bc5b31a98cd02d20f25a7c8567146caf63ed593a9d87b2775291be" dependencies = [ - "base64", + "base64 0.22.1", "serde_core", ] @@ -2296,12 +2880,36 @@ version = "0.3.32" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c" +[[package]] +name = "polyval" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9d1fe60d06143b2430aa532c94cfe9e29783047f06c0d7fd359a9a51b729fa25" +dependencies = [ + "cfg-if", + "cpufeatures", + "opaque-debug", + "universal-hash", +] + [[package]] name = "portable-atomic" version = "1.13.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49" +[[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" @@ -2354,6 +2962,28 @@ dependencies = [ "unicode-ident", ] +[[package]] +name = "psm" +version = "0.1.30" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3852766467df634d74f0b2d7819bf8dc483a0eb2e3b0f50f756f9cfe8b0d18d8" +dependencies = [ + "ar_archive_writer", + "cc", +] + +[[package]] +name = "pulley-interpreter" +version = "29.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "62d95f8575df49a2708398182f49a888cf9dc30210fb1fd2df87c889edcee75d" +dependencies = [ + "cranelift-bitset", + "log", + "sptr", + "wasmtime-math", +] + [[package]] name = "quote" version = "1.0.44" @@ -2428,6 +3058,26 @@ dependencies = [ "getrandom 0.3.4", ] +[[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_syscall" version = "0.5.18" @@ -2446,6 +3096,31 @@ dependencies = [ "bitflags", ] +[[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.11.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dc06e6b318142614e4a48bc725abbf08ff166694835c43c9dae5a9009704639a" +dependencies = [ + "allocator-api2", + "bumpalo", + "hashbrown 0.15.5", + "log", + "rustc-hash", + "smallvec", +] + [[package]] name = "regex" version = "1.12.3" @@ -2481,7 +3156,7 @@ version = "0.12.28" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "eddd3ca559203180a307f12d114c268abf583f59b03cb906fd0b3ff8646c1147" dependencies = [ - "base64", + "base64 0.22.1", "bytes", "encoding_rs", "futures-core", @@ -2565,12 +3240,31 @@ dependencies = [ "zeroize", ] +[[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.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d" +[[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.52.0", +] + [[package]] name = "rustix" version = "1.1.3" @@ -2580,10 +3274,20 @@ dependencies = [ "bitflags", "errno", "libc", - "linux-raw-sys", + "linux-raw-sys 0.11.0", "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.3", +] + [[package]] name = "rustls" version = "0.23.36" @@ -2705,6 +3409,10 @@ 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" @@ -2793,6 +3501,15 @@ dependencies = [ "serde_core", ] +[[package]] +name = "serde_spanned" +version = "0.6.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bf41e0cfaf7226dca15e8197172c295a782857fcb97fad1808a166870dee75a3" +dependencies = [ + "serde", +] + [[package]] name = "serde_urlencoded" version = "0.7.1" @@ -2862,6 +3579,15 @@ dependencies = [ "lazy_static", ] +[[package]] +name = "shellexpand" +version = "2.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7ccc8076840c4da029af4f87e4e8daeb0fca6b87bbb02e10cb60b791450e11e4" +dependencies = [ + "dirs", +] + [[package]] name = "shlex" version = "1.3.0" @@ -2960,6 +3686,12 @@ dependencies = [ "der", ] +[[package]] +name = "sptr" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3b9b39299b249ad65f3b7e96443bad61c02ca5cd3589f46cb6d610a0fd6c0d6a" + [[package]] name = "sqlx" version = "0.8.6" @@ -2979,7 +3711,7 @@ version = "0.8.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ee6798b1838b6a0f69c007c133b8df5866302197e404e8b6ee8ed3e3a5e68dc6" dependencies = [ - "base64", + "base64 0.22.1", "bytes", "chrono", "crc", @@ -3055,7 +3787,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "aa003f0038df784eb8fecbbac13affe3da23b45194bd57dba231c8f48199c526" dependencies = [ "atoi", - "base64", + "base64 0.22.1", "bitflags", "byteorder", "bytes", @@ -3098,7 +3830,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "db58fcd5a53cf07c184b154801ff91347e4c30d17a3562a635ff028ad5deda46" dependencies = [ "atoi", - "base64", + "base64 0.22.1", "bitflags", "byteorder", "chrono", @@ -3229,12 +3961,34 @@ dependencies = [ "libc", ] +[[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.52.0", + "winx", +] + [[package]] name = "tagptr" version = "0.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7b2093cf4c8eb1e67749a6762251bc9cd836b6fc171623bd0a9d324d37af2417" +[[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.25.0" @@ -3244,10 +3998,19 @@ dependencies = [ "fastrand", "getrandom 0.4.1", "once_cell", - "rustix", + "rustix 1.1.3", "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" @@ -3442,23 +4205,64 @@ dependencies = [ ] [[package]] -name = "tower" -version = "0.5.3" +name = "toml" +version = "0.8.23" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ebe5ef63511595f1344e2d5cfa636d973292adc0eec1f0ad45fae9f0851ab1d4" +checksum = "dc1beb996b9d83529a9e75c17a1686767d148d70663143c7854d8b4a09ced362" dependencies = [ - "futures-core", - "futures-util", - "pin-project-lite", - "sync_wrapper", - "tokio", - "tower-layer", - "tower-service", - "tracing", + "serde", + "serde_spanned", + "toml_datetime", + "toml_edit", ] [[package]] -name = "tower-http" +name = "toml_datetime" +version = "0.6.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "22cddaf88f4fbc13c51aebbf5f8eceb5c7c5a9da2ac40a13519eb5b0a0e8f11c" +dependencies = [ + "serde", +] + +[[package]] +name = "toml_edit" +version = "0.22.27" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41fe8c660ae4257887cf66394862d21dbca4a6ddd26f04a3560410406a2f819a" +dependencies = [ + "indexmap", + "serde", + "serde_spanned", + "toml_datetime", + "toml_write", + "winnow", +] + +[[package]] +name = "toml_write" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d99f8c9a7727884afe522e9bd5edbfc91a3312b36a77b5fb8926e4c31a41801" + +[[package]] +name = "tower" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ebe5ef63511595f1344e2d5cfa636d973292adc0eec1f0ad45fae9f0851ab1d4" +dependencies = [ + "futures-core", + "futures-util", + "pin-project-lite", + "sync_wrapper", + "tokio", + "tower-layer", + "tower-service", + "tracing", +] + +[[package]] +name = "tower-http" version = "0.6.8" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d4e6559d53cc268e5031cd8429d05415bc4cb4aefc4aa5d6cc35fbf5b924a1f8" @@ -3654,12 +4458,28 @@ version = "0.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7df058c713841ad818f1dc5d3fd88063241cc61f49f5fbea4b951e8cf5a8d71d" +[[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 = "universal-hash" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc1de2c688dc15305988b563c3854064043356019f97a4b46276fe734c4f07ea" +dependencies = [ + "crypto-common", + "subtle", +] + [[package]] name = "unsigned-varint" version = "0.8.0" @@ -3829,6 +4649,16 @@ dependencies = [ "unicode-ident", ] +[[package]] +name = "wasm-encoder" +version = "0.221.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dc8444fe4920de80a4fe5ab564fff2ae58b6b73166b89751f8c6c93509da32e5" +dependencies = [ + "leb128", + "wasmparser 0.221.3", +] + [[package]] name = "wasm-encoder" version = "0.244.0" @@ -3836,7 +4666,17 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "990065f2fe63003fe337b932cfb5e3b80e0b4d0f5ff650e6985b1048f62c8319" dependencies = [ "leb128fmt", - "wasmparser", + "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]] @@ -3847,8 +4687,21 @@ checksum = "bb0e353e6a2fbdc176932bbaab493762eb1255a7900fe0fea1a2f96c296cc909" dependencies = [ "anyhow", "indexmap", - "wasm-encoder", - "wasmparser", + "wasm-encoder 0.244.0", + "wasmparser 0.244.0", +] + +[[package]] +name = "wasmparser" +version = "0.221.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d06bfa36ab3ac2be0dee563380147a5b81ba10dd8885d7fbbc9eb574be67d185" +dependencies = [ + "bitflags", + "hashbrown 0.15.5", + "indexmap", + "semver", + "serde", ] [[package]] @@ -3863,6 +4716,343 @@ dependencies = [ "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.221.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7343c42a97f2926c7819ff81b64012092ae954c5d83ddd30c9fcdefd97d0b283" +dependencies = [ + "anyhow", + "termcolor", + "wasmparser 0.221.3", +] + +[[package]] +name = "wasmtime" +version = "29.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "11976a250672556d1c4c04c6d5d7656ac9192ac9edc42a4587d6c21460010e69" +dependencies = [ + "addr2line", + "anyhow", + "async-trait", + "bitflags", + "bumpalo", + "cc", + "cfg-if", + "encoding_rs", + "fxprof-processed-profile", + "gimli", + "hashbrown 0.14.5", + "indexmap", + "ittapi", + "libc", + "log", + "mach2", + "memfd", + "object 0.36.7", + "once_cell", + "paste", + "postcard", + "psm", + "pulley-interpreter", + "rayon", + "rustix 0.38.44", + "semver", + "serde", + "serde_derive", + "serde_json", + "smallvec", + "sptr", + "target-lexicon", + "trait-variant", + "wasm-encoder 0.221.3", + "wasmparser 0.221.3", + "wasmtime-asm-macros", + "wasmtime-cache", + "wasmtime-component-macro", + "wasmtime-component-util", + "wasmtime-cranelift", + "wasmtime-environ", + "wasmtime-fiber", + "wasmtime-jit-debug", + "wasmtime-jit-icache-coherence", + "wasmtime-math", + "wasmtime-slab", + "wasmtime-versioned-export-macros", + "wasmtime-winch", + "wat", + "windows-sys 0.59.0", +] + +[[package]] +name = "wasmtime-asm-macros" +version = "29.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1f178b0d125201fbe9f75beaf849bd3e511891f9e45ba216a5b620802ccf64f2" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "wasmtime-cache" +version = "29.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b1161c8f62880deea07358bc40cceddc019f1c81d46007bc390710b2fe24ffc" +dependencies = [ + "anyhow", + "base64 0.21.7", + "directories-next", + "log", + "postcard", + "rustix 0.38.44", + "serde", + "serde_derive", + "sha2", + "toml", + "windows-sys 0.59.0", + "zstd", +] + +[[package]] +name = "wasmtime-component-macro" +version = "29.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d74de6592ed945d0a602f71243982a304d5d02f1e501b638addf57f42d57dfaf" +dependencies = [ + "anyhow", + "proc-macro2", + "quote", + "syn", + "wasmtime-component-util", + "wasmtime-wit-bindgen", + "wit-parser 0.221.3", +] + +[[package]] +name = "wasmtime-component-util" +version = "29.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "707dc7b3c112ab5a366b30cfe2fb5b2f8e6a0f682f16df96a5ec582bfe6f056e" + +[[package]] +name = "wasmtime-cranelift" +version = "29.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "366be722674d4bf153290fbcbc4d7d16895cc82fb3e869f8d550ff768f9e9e87" +dependencies = [ + "anyhow", + "cfg-if", + "cranelift-codegen", + "cranelift-control", + "cranelift-entity", + "cranelift-frontend", + "cranelift-native", + "gimli", + "itertools", + "log", + "object 0.36.7", + "smallvec", + "target-lexicon", + "thiserror 1.0.69", + "wasmparser 0.221.3", + "wasmtime-environ", + "wasmtime-versioned-export-macros", +] + +[[package]] +name = "wasmtime-environ" +version = "29.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cdadc1af7097347aa276a4f008929810f726b5b46946971c660b6d421e9994ad" +dependencies = [ + "anyhow", + "cpp_demangle", + "cranelift-bitset", + "cranelift-entity", + "gimli", + "indexmap", + "log", + "object 0.36.7", + "postcard", + "rustc-demangle", + "semver", + "serde", + "serde_derive", + "smallvec", + "target-lexicon", + "wasm-encoder 0.221.3", + "wasmparser 0.221.3", + "wasmprinter", + "wasmtime-component-util", +] + +[[package]] +name = "wasmtime-fiber" +version = "29.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ccba90d4119f081bca91190485650730a617be1fff5228f8c4757ce133d21117" +dependencies = [ + "anyhow", + "cc", + "cfg-if", + "rustix 0.38.44", + "wasmtime-asm-macros", + "wasmtime-versioned-export-macros", + "windows-sys 0.59.0", +] + +[[package]] +name = "wasmtime-jit-debug" +version = "29.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3e7b61488a5ee00c35c8c22de707c36c0aecacf419a3be803a6a2ba5e860f56a" +dependencies = [ + "object 0.36.7", + "rustix 0.38.44", + "wasmtime-versioned-export-macros", +] + +[[package]] +name = "wasmtime-jit-icache-coherence" +version = "29.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec5e8552e01692e6c2e5293171704fed8abdec79d1a6995a0870ab190e5747d1" +dependencies = [ + "anyhow", + "cfg-if", + "libc", + "windows-sys 0.59.0", +] + +[[package]] +name = "wasmtime-math" +version = "29.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29210ec2aa25e00f4d54605cedaf080f39ec01a872c5bd520ad04c67af1dde17" +dependencies = [ + "libm", +] + +[[package]] +name = "wasmtime-slab" +version = "29.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fcb5821a96fa04ac14bc7b158bb3d5cd7729a053db5a74dad396cd513a5e5ccf" + +[[package]] +name = "wasmtime-versioned-export-macros" +version = "29.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "86ff86db216dc0240462de40c8290887a613dddf9685508eb39479037ba97b5b" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "wasmtime-wasi" +version = "29.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8d1be69bfcab1bdac74daa7a1f9695ab992b9c8e21b9b061e7d66434097e0ca4" +dependencies = [ + "anyhow", + "async-trait", + "bitflags", + "bytes", + "cap-fs-ext", + "cap-net-ext", + "cap-rand", + "cap-std", + "cap-time-ext", + "fs-set-times", + "futures", + "io-extras", + "io-lifetimes", + "rustix 0.38.44", + "system-interface", + "thiserror 1.0.69", + "tokio", + "tracing", + "trait-variant", + "url", + "wasmtime", + "wiggle", + "windows-sys 0.59.0", +] + +[[package]] +name = "wasmtime-winch" +version = "29.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fdbabfb8f20502d5e1d81092b9ead3682ae59988487aafcd7567387b7a43cf8f" +dependencies = [ + "anyhow", + "cranelift-codegen", + "gimli", + "object 0.36.7", + "target-lexicon", + "wasmparser 0.221.3", + "wasmtime-cranelift", + "wasmtime-environ", + "winch-codegen", +] + +[[package]] +name = "wasmtime-wit-bindgen" +version = "29.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8358319c2dd1e4db79e3c1c5d3a5af84956615343f9f89f4e4996a36816e06e6" +dependencies = [ + "anyhow", + "heck", + "indexmap", + "wit-parser 0.221.3", +] + +[[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 = "web-sys" version = "0.3.85" @@ -3908,7 +5098,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d3fabb953106c3c8eea8306e4393700d7657561cb43122571b172bbfb7c7ba1d" dependencies = [ "env_home", - "rustix", + "rustix 1.1.3", "winsafe", ] @@ -3928,6 +5118,97 @@ version = "1.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "72069c3113ab32ab29e5584db3c6ec55d416895e60715417b5b883a357c3e471" +[[package]] +name = "wiggle" +version = "29.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4b9af35bc9629c52c261465320a9a07959164928b4241980ba1cf923b9e6751d" +dependencies = [ + "anyhow", + "async-trait", + "bitflags", + "thiserror 1.0.69", + "tracing", + "wasmtime", + "wiggle-macro", +] + +[[package]] +name = "wiggle-generate" +version = "29.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2cf267dd05673912c8138f4b54acabe6bd53407d9d1536f0fadb6520dd16e101" +dependencies = [ + "anyhow", + "heck", + "proc-macro2", + "quote", + "shellexpand", + "syn", + "witx", +] + +[[package]] +name = "wiggle-macro" +version = "29.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "08c5c473d4198e6c2d377f3809f713ff0c110cab88a0805ae099a82119ee250c" +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 = "29.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2f849ef2c5f46cb0a20af4b4487aaa239846e52e2c03f13fa3c784684552859c" +dependencies = [ + "anyhow", + "cranelift-codegen", + "gimli", + "regalloc2", + "smallvec", + "target-lexicon", + "thiserror 1.0.69", + "wasmparser 0.221.3", + "wasmtime-cranelift", + "wasmtime-environ", +] + [[package]] name = "windows-core" version = "0.62.2" @@ -4016,6 +5297,15 @@ dependencies = [ "windows-targets 0.52.6", ] +[[package]] +name = "windows-sys" +version = "0.59.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b" +dependencies = [ + "windows-targets 0.52.6", +] + [[package]] name = "windows-sys" version = "0.60.2" @@ -4220,6 +5510,15 @@ version = "0.53.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650" +[[package]] +name = "winnow" +version = "0.7.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "df79d97927682d2fd8adb29682d1140b343be4ac0f08fd68b7765d9c059d3945" +dependencies = [ + "memchr", +] + [[package]] name = "winreg" version = "0.50.0" @@ -4236,6 +5535,16 @@ version = "0.0.19" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d135d17ab770252ad95e9a872d365cf3090e3be864a34ab46f48555993efc904" +[[package]] +name = "winx" +version = "0.36.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f3fd376f71958b862e7afb20cfe5a22830e1963462f3a17f49d82a6c1d1f42d" +dependencies = [ + "bitflags", + "windows-sys 0.52.0", +] + [[package]] name = "wiremock" version = "0.6.5" @@ -4243,7 +5552,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "08db1edfb05d9b3c1542e521aea074442088292f00b5f28e435c714a98f85031" dependencies = [ "assert-json-diff", - "base64", + "base64 0.22.1", "deadpool", "futures", "http", @@ -4276,7 +5585,7 @@ checksum = "ea61de684c3ea68cb082b7a88508a8b27fcc8b797d738bfc99a82facf1d752dc" dependencies = [ "anyhow", "heck", - "wit-parser", + "wit-parser 0.244.0", ] [[package]] @@ -4323,10 +5632,28 @@ dependencies = [ "serde", "serde_derive", "serde_json", - "wasm-encoder", + "wasm-encoder 0.244.0", "wasm-metadata", - "wasmparser", - "wit-parser", + "wasmparser 0.244.0", + "wit-parser 0.244.0", +] + +[[package]] +name = "wit-parser" +version = "0.221.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "896112579ed56b4a538b07a3d16e562d101ff6265c46b515ce0c701eef16b2ac" +dependencies = [ + "anyhow", + "id-arena", + "indexmap", + "log", + "semver", + "serde", + "serde_derive", + "serde_json", + "unicode-xid", + "wasmparser 0.221.3", ] [[package]] @@ -4344,7 +5671,19 @@ dependencies = [ "serde_derive", "serde_json", "unicode-xid", - "wasmparser", + "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]] @@ -4464,3 +5803,31 @@ 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 index 94f4bf2..3226c6e 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -5,6 +5,8 @@ edition = "2024" default-run = "happyview" [dependencies] +aes-gcm = "0.10" +anyhow = "1" arc-swap = "1" atrium-oauth = { version = "0.1", features = ["default-client"] } atrium-identity = "0.1" @@ -37,6 +39,7 @@ sqlx = { version = "0.8", features = ["runtime-tokio", "tls-rustls", "postgres", tokio = { version = "1", features = ["full"] } tokio-rustls = "0.26" tokio-tungstenite = { version = "0.26", features = ["rustls-tls-webpki-roots"] } +thiserror = "2" tower = { version = "0.5", features = ["util"] } tower-http = { version = "0.6", features = ["cors", "fs", "trace"] } http-body-util = "0.1" @@ -47,6 +50,8 @@ tracing = "0.1" tracing-subscriber = { version = "0.3", features = ["env-filter", "json"] } urlencoding = "2.1.3" webpki-roots = "0.26" +wasmtime = { version = "29", features = ["async"] } +wasmtime-wasi = "29" regex = "1.12.3" [[bin]] diff --git a/migrations/postgres/20260319000001_plugin_tables.sql b/migrations/postgres/20260319000001_plugin_tables.sql new file mode 100644 index 0000000..7a6ae8b --- /dev/null +++ b/migrations/postgres/20260319000001_plugin_tables.sql @@ -0,0 +1,60 @@ +-- Plugin registry +CREATE TABLE plugins ( + id TEXT PRIMARY KEY, + source TEXT NOT NULL CHECK (source IN ('file', 'url')), + url TEXT, + sha256 TEXT, + enabled BOOLEAN NOT NULL DEFAULT true, + loaded_at TIMESTAMPTZ, + api_version TEXT NOT NULL +); + +-- Plugin configuration +CREATE TABLE plugin_configs ( + plugin_id TEXT PRIMARY KEY REFERENCES plugins(id) ON DELETE CASCADE, + config JSONB NOT NULL DEFAULT '{}', + updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +-- External account tokens (encrypted) +CREATE TABLE external_account_tokens ( + id TEXT PRIMARY KEY, + did TEXT NOT NULL, + plugin_id TEXT NOT NULL REFERENCES plugins(id) ON DELETE CASCADE, + account_id TEXT NOT NULL, + access_token BYTEA NOT NULL, + refresh_token BYTEA, + token_type TEXT, + scope TEXT, + expires_at TIMESTAMPTZ, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + UNIQUE(did, plugin_id) +); + +-- Deduplication keys for sync records +CREATE TABLE plugin_dedup_keys ( + plugin_id TEXT NOT NULL REFERENCES plugins(id) ON DELETE CASCADE, + did TEXT NOT NULL, + dedup_key TEXT NOT NULL, + record_uri TEXT NOT NULL, + updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + PRIMARY KEY (plugin_id, did, dedup_key) +); + +-- KV storage for plugins (scoped per plugin + context) +CREATE TABLE plugin_kv ( + plugin_id TEXT NOT NULL REFERENCES plugins(id) ON DELETE CASCADE, + scope TEXT NOT NULL, + key TEXT NOT NULL, + value BYTEA NOT NULL, + expires_at TIMESTAMPTZ, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + PRIMARY KEY (plugin_id, scope, key) +); + +-- Index for KV expiration cleanup +CREATE INDEX idx_plugin_kv_expires ON plugin_kv(expires_at) WHERE expires_at IS NOT NULL; + +-- Index for token lookup by DID +CREATE INDEX idx_external_tokens_did ON external_account_tokens(did); diff --git a/migrations/sqlite/20260319000001_plugin_tables.sql b/migrations/sqlite/20260319000001_plugin_tables.sql new file mode 100644 index 0000000..772cd6a --- /dev/null +++ b/migrations/sqlite/20260319000001_plugin_tables.sql @@ -0,0 +1,60 @@ +-- Plugin registry +CREATE TABLE plugins ( + id TEXT PRIMARY KEY, + source TEXT NOT NULL CHECK (source IN ('file', 'url')), + url TEXT, + sha256 TEXT, + enabled INTEGER NOT NULL DEFAULT 1, + loaded_at TEXT, + api_version TEXT NOT NULL +); + +-- Plugin configuration +CREATE TABLE plugin_configs ( + plugin_id TEXT PRIMARY KEY REFERENCES plugins(id) ON DELETE CASCADE, + config TEXT NOT NULL DEFAULT '{}', + updated_at TEXT NOT NULL DEFAULT (datetime('now')) +); + +-- External account tokens (encrypted) +CREATE TABLE external_account_tokens ( + id TEXT PRIMARY KEY, + did TEXT NOT NULL, + plugin_id TEXT NOT NULL REFERENCES plugins(id) ON DELETE CASCADE, + account_id TEXT NOT NULL, + access_token BLOB NOT NULL, + refresh_token BLOB, + token_type TEXT, + scope TEXT, + expires_at TEXT, + created_at TEXT NOT NULL DEFAULT (datetime('now')), + updated_at TEXT NOT NULL DEFAULT (datetime('now')), + UNIQUE(did, plugin_id) +); + +-- Deduplication keys for sync records +CREATE TABLE plugin_dedup_keys ( + plugin_id TEXT NOT NULL REFERENCES plugins(id) ON DELETE CASCADE, + did TEXT NOT NULL, + dedup_key TEXT NOT NULL, + record_uri TEXT NOT NULL, + updated_at TEXT NOT NULL DEFAULT (datetime('now')), + PRIMARY KEY (plugin_id, did, dedup_key) +); + +-- KV storage for plugins (scoped per plugin + context) +CREATE TABLE plugin_kv ( + plugin_id TEXT NOT NULL REFERENCES plugins(id) ON DELETE CASCADE, + scope TEXT NOT NULL, + key TEXT NOT NULL, + value BLOB NOT NULL, + expires_at TEXT, + created_at TEXT NOT NULL DEFAULT (datetime('now')), + PRIMARY KEY (plugin_id, scope, key) +); + +-- Index for KV expiration cleanup +CREATE INDEX idx_plugin_kv_expires ON plugin_kv(expires_at) WHERE expires_at IS NOT NULL; + +-- Index for token lookup by DID +CREATE INDEX idx_external_tokens_did ON external_account_tokens(did); diff --git a/src/config.rs b/src/config.rs index 3c4843e..4fdb91e 100644 --- a/src/config.rs +++ b/src/config.rs @@ -21,6 +21,7 @@ pub struct Config { pub logo_uri: Option, pub tos_uri: Option, pub policy_uri: Option, + pub token_encryption_key: Option<[u8; 32]>, } impl Config { @@ -55,6 +56,13 @@ impl Config { logo_uri: env::var("LOGO_URI").ok(), tos_uri: env::var("TOS_URI").ok(), policy_uri: env::var("POLICY_URI").ok(), + token_encryption_key: env::var("TOKEN_ENCRYPTION_KEY").ok().and_then(|s| { + use base64::Engine; + base64::engine::general_purpose::STANDARD + .decode(&s) + .ok() + .and_then(|bytes| bytes.try_into().ok()) + }), } } @@ -120,6 +128,7 @@ mod tests { logo_uri: None, tos_uri: None, policy_uri: None, + token_encryption_key: None, }; assert_eq!( config.listen_addr(), diff --git a/src/external_auth/mod.rs b/src/external_auth/mod.rs new file mode 100644 index 0000000..15b512d --- /dev/null +++ b/src/external_auth/mod.rs @@ -0,0 +1,4 @@ +mod routes; +mod sync; + +pub use routes::routes; diff --git a/src/external_auth/routes.rs b/src/external_auth/routes.rs new file mode 100644 index 0000000..399c4df --- /dev/null +++ b/src/external_auth/routes.rs @@ -0,0 +1,114 @@ +use axum::{ + Json, Router, + extract::{Path, Query, State}, + response::Redirect, + routing::{get, post}, +}; +use serde::{Deserialize, Serialize}; + +use crate::AppState; +use crate::error::AppError; + +pub fn routes() -> Router { + Router::new() + .route("/providers", get(list_providers)) + .route("/{plugin_id}/authorize", get(authorize)) + .route("/{plugin_id}/callback", get(callback)) + .route("/{plugin_id}/sync", post(sync)) + .route("/{plugin_id}/unlink", post(unlink)) +} + +#[derive(Serialize)] +struct ProviderInfo { + id: String, + name: String, + icon_url: Option, +} + +async fn list_providers( + State(state): State, +) -> Result>, AppError> { + let plugins = state.plugin_registry.list().await; + + let providers: Vec = plugins + .into_iter() + .map(|p| ProviderInfo { + id: p.info.id.clone(), + name: p.info.name.clone(), + icon_url: p.info.icon_url.clone(), + }) + .collect(); + + Ok(Json(providers)) +} + +#[derive(Deserialize)] +struct AuthorizeQuery { + redirect_uri: String, +} + +async fn authorize( + State(state): State, + Path(plugin_id): Path, + Query(query): Query, +) -> Result, AppError> { + let _plugin = state + .plugin_registry + .get(&plugin_id) + .await + .ok_or_else(|| AppError::NotFound(format!("Plugin not found: {}", plugin_id)))?; + + // Generate state parameter for CSRF protection + let state_param = uuid::Uuid::new_v4().to_string(); + + // TODO: Store state in KV, call plugin's get_authorize_url() + // For now, return placeholder + let _ = query.redirect_uri; + + Ok(Json(serde_json::json!({ + "authorize_url": format!("https://example.com/oauth?state={}", state_param), + "state": state_param + }))) +} + +#[derive(Deserialize)] +#[allow(dead_code)] // Fields used when full OAuth flow is implemented +struct CallbackQuery { + code: Option, + state: Option, + error: Option, +} + +async fn callback( + State(_state): State, + Path(_plugin_id): Path, + Query(_query): Query, +) -> Result { + // TODO: Validate state, call plugin's handle_callback(), store tokens + + // For now, redirect to a placeholder + Ok(Redirect::to("/")) +} + +async fn sync( + State(_state): State, + Path(_plugin_id): Path, +) -> Result, AppError> { + // TODO: Call plugin's sync_account(), process SyncRecords + + Ok(Json(serde_json::json!({ + "status": "ok", + "synced": 0 + }))) +} + +async fn unlink( + State(_state): State, + Path(_plugin_id): Path, +) -> Result, AppError> { + // TODO: Delete tokens, delete accountLink record + + Ok(Json(serde_json::json!({ + "status": "ok" + }))) +} diff --git a/src/external_auth/sync.rs b/src/external_auth/sync.rs new file mode 100644 index 0000000..c7ddfd6 --- /dev/null +++ b/src/external_auth/sync.rs @@ -0,0 +1,55 @@ +use crate::db::adapt_sql; +use crate::plugin::SyncRecord; + +#[allow(dead_code)] // Used when full sync flow is implemented +#[derive(Debug, thiserror::Error)] +pub enum SyncError { + #[error("Database error: {0}")] + Database(#[from] sqlx::Error), + #[error("Validation error: {0}")] + Validation(String), + #[error("PDS write error: {0}")] + PdsWrite(String), +} + +/// Process sync records from a plugin +#[allow(dead_code)] // Used when full sync flow is implemented +pub async fn process_sync_records( + db: &sqlx::AnyPool, + db_backend: crate::db::DatabaseBackend, + plugin_id: &str, + user_did: &str, + records: Vec, +) -> Result { + let mut processed = 0; + + for record in records { + // TODO: Validate against lexicon schema + // TODO: Check dedup_key + // TODO: Sign attestation + // TODO: Write to PDS + + // For now, just track dedup key + if let Some(dedup_key) = &record.dedup_key { + let sql = adapt_sql( + "INSERT INTO plugin_dedup_keys (plugin_id, did, dedup_key, record_uri, updated_at) + VALUES (?, ?, ?, ?, datetime('now')) + ON CONFLICT (plugin_id, did, dedup_key) + DO UPDATE SET record_uri = excluded.record_uri, updated_at = excluded.updated_at", + db_backend, + ); + + sqlx::query(&sql) + .bind(plugin_id) + .bind(user_did) + .bind(dedup_key) + .bind("at://placeholder") // TODO: Real URI after PDS write + .execute(db) + .await?; + } + + processed += 1; + } + + Ok(processed) +} diff --git a/src/lib.rs b/src/lib.rs index 3c9592b..782313f 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -5,9 +5,11 @@ pub mod db; pub mod dns; pub mod error; pub mod event_log; +pub mod external_auth; pub mod labeler; pub mod lexicon; pub mod lua; +pub mod plugin; pub mod profile; pub mod rate_limit; pub mod record_refs; @@ -56,6 +58,7 @@ pub struct AppState { pub rate_limiter: Arc, pub oauth: Arc, pub cookie_key: axum_extra::extract::cookie::Key, + pub plugin_registry: Arc, } impl axum::extract::FromRef for axum_extra::extract::cookie::Key { diff --git a/src/lua/atproto_api.rs b/src/lua/atproto_api.rs index 635a6dd..c5ef8bc 100644 --- a/src/lua/atproto_api.rs +++ b/src/lua/atproto_api.rs @@ -222,6 +222,7 @@ mod tests { logo_uri: None, tos_uri: None, policy_uri: None, + token_encryption_key: None, }; let (tx, _) = watch::channel(vec![]); let (labeler_tx, _) = watch::channel(()); @@ -287,6 +288,7 @@ mod tests { cookie_key: axum_extra::extract::cookie::Key::derive_from( b"test-secret-for-tests-only-not-production", ), + plugin_registry: std::sync::Arc::new(crate::plugin::PluginRegistry::new()), } } diff --git a/src/lua/db_api.rs b/src/lua/db_api.rs index 83491a3..72c393d 100644 --- a/src/lua/db_api.rs +++ b/src/lua/db_api.rs @@ -630,6 +630,7 @@ mod tests { logo_uri: None, tos_uri: None, policy_uri: None, + token_encryption_key: None, }; let (tx, _) = watch::channel(vec![]); let (labeler_tx, _) = watch::channel(()); @@ -695,6 +696,7 @@ mod tests { cookie_key: axum_extra::extract::cookie::Key::derive_from( b"test-secret-for-tests-only-not-production", ), + plugin_registry: std::sync::Arc::new(crate::plugin::PluginRegistry::new()), } } diff --git a/src/lua/execute.rs b/src/lua/execute.rs index 6686de1..dfaa697 100644 --- a/src/lua/execute.rs +++ b/src/lua/execute.rs @@ -964,6 +964,7 @@ mod tests { logo_uri: None, tos_uri: None, policy_uri: None, + token_encryption_key: None, }; let (tx, _) = watch::channel(vec![]); let (labeler_tx, _) = watch::channel(()); @@ -1029,6 +1030,7 @@ mod tests { cookie_key: axum_extra::extract::cookie::Key::derive_from( b"test-secret-for-tests-only-not-production", ), + plugin_registry: std::sync::Arc::new(crate::plugin::PluginRegistry::new()), } } diff --git a/src/lua/http_api.rs b/src/lua/http_api.rs index e06ed1b..bfc0b3a 100644 --- a/src/lua/http_api.rs +++ b/src/lua/http_api.rs @@ -104,6 +104,7 @@ mod tests { logo_uri: None, tos_uri: None, policy_uri: None, + token_encryption_key: None, }; let (tx, _) = watch::channel(vec![]); let (labeler_tx, _) = watch::channel(()); @@ -169,6 +170,7 @@ mod tests { cookie_key: axum_extra::extract::cookie::Key::derive_from( b"test-secret-for-tests-only-not-production", ), + plugin_registry: std::sync::Arc::new(crate::plugin::PluginRegistry::new()), } } diff --git a/src/main.rs b/src/main.rs index 10e7ae6..b65e816 100644 --- a/src/main.rs +++ b/src/main.rs @@ -173,6 +173,45 @@ async fn main() { ); } + // Initialize plugin registry + let plugin_registry = Arc::new(happyview::plugin::PluginRegistry::new()); + + // Load plugins from PLUGIN_URLS env var + if let Ok(urls) = std::env::var("PLUGIN_URLS") { + for (id, url, sha256) in happyview::plugin::loader::parse_plugin_urls(&urls) { + match happyview::plugin::loader::load_from_url(&http, &url, sha256.as_deref()).await { + Ok(plugin) => { + tracing::info!(id = %id, "Loaded plugin from URL"); + plugin_registry.register(plugin).await; + } + Err(e) => { + tracing::error!(id = %id, error = %e, "Failed to load plugin"); + } + } + } + } + + // Load plugins from directory + let plugin_dir = std::path::Path::new("./plugins"); + if plugin_dir.exists() + && let Ok(entries) = std::fs::read_dir(plugin_dir) + { + for entry in entries.flatten() { + let path = entry.path(); + if path.is_dir() { + match happyview::plugin::loader::load_from_file(&path).await { + Ok(plugin) => { + tracing::info!(id = %plugin.info.id, "Loaded plugin from file"); + plugin_registry.register(plugin).await; + } + Err(e) => { + tracing::error!(path = %path.display(), error = %e, "Failed to load plugin"); + } + } + } + } + } + // Initialize rate limiter from DB. let rl_state = RateLimiter::load_from_db(&db_pool).await; let rate_limiter = RateLimiter::new(rl_state.enabled, rl_state.global, rl_state.allowlist); @@ -279,6 +318,7 @@ async fn main() { rate_limiter, oauth: Arc::new(oauth_client), cookie_key, + plugin_registry, }; // Sync initial collections to Tap on startup. diff --git a/src/plugin/encryption.rs b/src/plugin/encryption.rs new file mode 100644 index 0000000..c91fd30 --- /dev/null +++ b/src/plugin/encryption.rs @@ -0,0 +1,111 @@ +use aes_gcm::{ + Aes256Gcm, Nonce, + aead::{Aead, KeyInit}, +}; +use rand::RngCore; + +#[derive(Debug, thiserror::Error)] +pub enum EncryptionError { + #[error("Encryption key not configured")] + KeyNotConfigured, + #[error("Encryption failed")] + EncryptionFailed, + #[error("Decryption failed")] + DecryptionFailed, + #[error("Invalid ciphertext format")] + InvalidFormat, +} + +const NONCE_SIZE: usize = 12; + +/// Encrypt data using AES-256-GCM +/// Returns: nonce || ciphertext || tag (concatenated) +pub fn encrypt(key: &[u8; 32], plaintext: &[u8]) -> Result, EncryptionError> { + let cipher = Aes256Gcm::new_from_slice(key).map_err(|_| EncryptionError::EncryptionFailed)?; + + // Generate random nonce + let mut nonce_bytes = [0u8; NONCE_SIZE]; + rand::rng().fill_bytes(&mut nonce_bytes); + let nonce = Nonce::from_slice(&nonce_bytes); + + // Encrypt + let ciphertext = cipher + .encrypt(nonce, plaintext) + .map_err(|_| EncryptionError::EncryptionFailed)?; + + // Concatenate: nonce || ciphertext + let mut result = Vec::with_capacity(NONCE_SIZE + ciphertext.len()); + result.extend_from_slice(&nonce_bytes); + result.extend_from_slice(&ciphertext); + + Ok(result) +} + +/// Decrypt data encrypted with encrypt() +pub fn decrypt(key: &[u8; 32], ciphertext: &[u8]) -> Result, EncryptionError> { + if ciphertext.len() < NONCE_SIZE + 16 { + // Minimum: nonce + auth tag + return Err(EncryptionError::InvalidFormat); + } + + let cipher = Aes256Gcm::new_from_slice(key).map_err(|_| EncryptionError::DecryptionFailed)?; + + let nonce = Nonce::from_slice(&ciphertext[..NONCE_SIZE]); + let encrypted = &ciphertext[NONCE_SIZE..]; + + cipher + .decrypt(nonce, encrypted) + .map_err(|_| EncryptionError::DecryptionFailed) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_encrypt_decrypt_roundtrip() { + let key = [0x42u8; 32]; + let plaintext = b"hello world"; + + let ciphertext = encrypt(&key, plaintext).unwrap(); + assert_ne!(&ciphertext[NONCE_SIZE..], plaintext); + + let decrypted = decrypt(&key, &ciphertext).unwrap(); + assert_eq!(decrypted, plaintext); + } + + #[test] + fn test_different_nonces() { + let key = [0x42u8; 32]; + let plaintext = b"hello world"; + + let ct1 = encrypt(&key, plaintext).unwrap(); + let ct2 = encrypt(&key, plaintext).unwrap(); + + // Same plaintext should produce different ciphertext (different nonces) + assert_ne!(ct1, ct2); + + // Both should decrypt correctly + assert_eq!(decrypt(&key, &ct1).unwrap(), plaintext); + assert_eq!(decrypt(&key, &ct2).unwrap(), plaintext); + } + + #[test] + fn test_invalid_ciphertext() { + let key = [0x42u8; 32]; + + // Too short + assert!(matches!( + decrypt(&key, &[0u8; 10]), + Err(EncryptionError::InvalidFormat) + )); + + // Corrupted + let mut ciphertext = encrypt(&key, b"hello").unwrap(); + ciphertext[NONCE_SIZE] ^= 0xFF; + assert!(matches!( + decrypt(&key, &ciphertext), + Err(EncryptionError::DecryptionFailed) + )); + } +} diff --git a/src/plugin/host/http.rs b/src/plugin/host/http.rs new file mode 100644 index 0000000..0a1733e --- /dev/null +++ b/src/plugin/host/http.rs @@ -0,0 +1,133 @@ +use super::{ + HostContext, MAX_HTTP_REQUESTS, MAX_HTTP_RESPONSE_SIZE, MAX_HTTP_TOTAL_TRANSFER, ResourceUsage, +}; +use serde::{Deserialize, Serialize}; + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct HttpRequest { + pub method: String, + pub url: String, + pub headers: Vec<(String, String)>, + pub body: Option>, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct HttpResponse { + pub status: u16, + pub headers: Vec<(String, String)>, + pub body: Vec, +} + +#[derive(Debug, thiserror::Error)] +pub enum HttpError { + #[error("Too many requests: {0} > {MAX_HTTP_REQUESTS}")] + TooManyRequests(u32), + #[error("Response too large: {0} > {MAX_HTTP_RESPONSE_SIZE}")] + ResponseTooLarge(u64), + #[error("Transfer limit exceeded: {0} > {MAX_HTTP_TOTAL_TRANSFER}")] + TransferLimitExceeded(u64), + #[error("Request failed: {0}")] + RequestFailed(#[from] reqwest::Error), +} + +pub async fn http_request( + ctx: &HostContext, + usage: &mut ResourceUsage, + req: HttpRequest, +) -> Result { + // Check request count limit + usage.http_requests += 1; + if usage.http_requests > MAX_HTTP_REQUESTS { + return Err(HttpError::TooManyRequests(usage.http_requests)); + } + + // Build request + let method = req.method.parse().unwrap_or(reqwest::Method::GET); + let mut builder = ctx.http_client.request(method, &req.url); + + for (name, value) in &req.headers { + builder = builder.header(name, value); + } + + if let Some(body) = req.body { + usage.http_bytes_transferred += body.len() as u64; + builder = builder.body(body); + } + + // Check transfer limit before sending + if usage.http_bytes_transferred > MAX_HTTP_TOTAL_TRANSFER { + return Err(HttpError::TransferLimitExceeded( + usage.http_bytes_transferred, + )); + } + + // Execute request + let response = builder.send().await?; + let status = response.status().as_u16(); + + let headers: Vec<(String, String)> = response + .headers() + .iter() + .map(|(k, v)| (k.to_string(), v.to_str().unwrap_or("").to_string())) + .collect(); + + let body = response.bytes().await?; + + // Check response size + if body.len() as u64 > MAX_HTTP_RESPONSE_SIZE { + return Err(HttpError::ResponseTooLarge(body.len() as u64)); + } + + usage.http_bytes_transferred += body.len() as u64; + if usage.http_bytes_transferred > MAX_HTTP_TOTAL_TRANSFER { + return Err(HttpError::TransferLimitExceeded( + usage.http_bytes_transferred, + )); + } + + Ok(HttpResponse { + status, + headers, + body: body.to_vec(), + }) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_http_request_limit_check() { + let mut usage = ResourceUsage { + http_requests: MAX_HTTP_REQUESTS, + ..Default::default() + }; + + // Verify the limit check would fail + usage.http_requests += 1; + assert!(usage.http_requests > MAX_HTTP_REQUESTS); + } + + #[test] + fn test_http_transfer_limit_check() { + let mut usage = ResourceUsage { + http_bytes_transferred: MAX_HTTP_TOTAL_TRANSFER, + ..Default::default() + }; + + // Adding more would exceed limit + usage.http_bytes_transferred += 1; + assert!(usage.http_bytes_transferred > MAX_HTTP_TOTAL_TRANSFER); + } + + #[test] + fn test_http_response_struct() { + let response = HttpResponse { + status: 200, + headers: vec![("content-type".into(), "application/json".into())], + body: b"{}".to_vec(), + }; + assert_eq!(response.status, 200); + assert_eq!(response.headers.len(), 1); + } +} diff --git a/src/plugin/host/kv.rs b/src/plugin/host/kv.rs new file mode 100644 index 0000000..930d893 --- /dev/null +++ b/src/plugin/host/kv.rs @@ -0,0 +1,104 @@ +use super::{HostContext, MAX_KV_SIZE_PER_USER, ResourceUsage}; +use crate::db::adapt_sql; + +#[derive(Debug, thiserror::Error)] +pub enum KvError { + #[error("Storage quota exceeded: {0} > {MAX_KV_SIZE_PER_USER}")] + QuotaExceeded(u64), + #[error("Database error: {0}")] + Database(#[from] sqlx::Error), +} + +pub async fn kv_get(ctx: &HostContext, key: &str) -> Result>, KvError> { + let sql = adapt_sql( + "SELECT value FROM plugin_kv + WHERE plugin_id = ? AND scope = ? AND key = ? + AND (expires_at IS NULL OR expires_at > datetime('now'))", + ctx.db_backend, + ); + + let result: Option<(Vec,)> = sqlx::query_as(&sql) + .bind(&ctx.plugin_id) + .bind(&ctx.scope) + .bind(key) + .fetch_optional(&ctx.db) + .await?; + + Ok(result.map(|(v,)| v)) +} + +pub async fn kv_set( + ctx: &HostContext, + usage: &mut ResourceUsage, + key: &str, + value: Vec, + ttl_secs: Option, +) -> Result<(), KvError> { + // Check quota (simple check - full implementation would sum all keys) + usage.kv_bytes_used += value.len() as u64; + if usage.kv_bytes_used > MAX_KV_SIZE_PER_USER { + return Err(KvError::QuotaExceeded(usage.kv_bytes_used)); + } + + let expires_at = ttl_secs + .map(|secs| (chrono::Utc::now() + chrono::Duration::seconds(secs as i64)).to_rfc3339()); + + // Upsert + let sql = adapt_sql( + "INSERT INTO plugin_kv (plugin_id, scope, key, value, expires_at, created_at) + VALUES (?, ?, ?, ?, ?, datetime('now')) + ON CONFLICT (plugin_id, scope, key) + DO UPDATE SET value = excluded.value, expires_at = excluded.expires_at", + ctx.db_backend, + ); + + sqlx::query(&sql) + .bind(&ctx.plugin_id) + .bind(&ctx.scope) + .bind(key) + .bind(&value) + .bind(expires_at) + .execute(&ctx.db) + .await?; + + Ok(()) +} + +pub async fn kv_delete(ctx: &HostContext, key: &str) -> Result<(), KvError> { + let sql = adapt_sql( + "DELETE FROM plugin_kv WHERE plugin_id = ? AND scope = ? AND key = ?", + ctx.db_backend, + ); + + sqlx::query(&sql) + .bind(&ctx.plugin_id) + .bind(&ctx.scope) + .bind(key) + .execute(&ctx.db) + .await?; + + Ok(()) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_quota_exceeded_check() { + let mut usage = ResourceUsage { + kv_bytes_used: MAX_KV_SIZE_PER_USER, + ..Default::default() + }; + + // Adding more would exceed quota + usage.kv_bytes_used += 1; + assert!(usage.kv_bytes_used > MAX_KV_SIZE_PER_USER); + } + + #[test] + fn test_kv_error_display() { + let err = KvError::QuotaExceeded(2_000_000); + assert!(err.to_string().contains("exceeded")); + } +} diff --git a/src/plugin/host/logging.rs b/src/plugin/host/logging.rs new file mode 100644 index 0000000..db051d1 --- /dev/null +++ b/src/plugin/host/logging.rs @@ -0,0 +1,70 @@ +use std::str::FromStr; +use tracing::{debug, error, info, warn}; + +/// Log level for plugin logging +#[derive(Debug, Clone, Copy, Default)] +pub enum LogLevel { + Debug, + #[default] + Info, + Warn, + Error, +} + +impl FromStr for LogLevel { + type Err = std::convert::Infallible; + + fn from_str(s: &str) -> Result { + Ok(match s.to_lowercase().as_str() { + "debug" => Self::Debug, + "info" => Self::Info, + "warn" | "warning" => Self::Warn, + "error" => Self::Error, + _ => Self::Info, + }) + } +} + +/// Log a message from a plugin +pub fn log(plugin_id: &str, level: LogLevel, message: &str) { + match level { + LogLevel::Debug => debug!(plugin = %plugin_id, "{}", message), + LogLevel::Info => info!(plugin = %plugin_id, "{}", message), + LogLevel::Warn => warn!(plugin = %plugin_id, "{}", message), + LogLevel::Error => error!(plugin = %plugin_id, "{}", message), + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_log_level_from_str_known_values() { + assert!(matches!("debug".parse::(), Ok(LogLevel::Debug))); + assert!(matches!("DEBUG".parse::(), Ok(LogLevel::Debug))); + assert!(matches!("info".parse::(), Ok(LogLevel::Info))); + assert!(matches!("INFO".parse::(), Ok(LogLevel::Info))); + assert!(matches!("warn".parse::(), Ok(LogLevel::Warn))); + assert!(matches!("warning".parse::(), Ok(LogLevel::Warn))); + assert!(matches!("WARN".parse::(), Ok(LogLevel::Warn))); + assert!(matches!("error".parse::(), Ok(LogLevel::Error))); + assert!(matches!("ERROR".parse::(), Ok(LogLevel::Error))); + } + + #[test] + fn test_log_level_from_str_unknown_defaults_to_info() { + assert!(matches!("trace".parse::(), Ok(LogLevel::Info))); + assert!(matches!("".parse::(), Ok(LogLevel::Info))); + assert!(matches!("unknown".parse::(), Ok(LogLevel::Info))); + } + + #[test] + fn test_log_does_not_panic() { + // Verify log() runs without panicking for each level + log("test-plugin", LogLevel::Debug, "debug message"); + log("test-plugin", LogLevel::Info, "info message"); + log("test-plugin", LogLevel::Warn, "warn message"); + log("test-plugin", LogLevel::Error, "error message"); + } +} diff --git a/src/plugin/host/lookup.rs b/src/plugin/host/lookup.rs new file mode 100644 index 0000000..704e79b --- /dev/null +++ b/src/plugin/host/lookup.rs @@ -0,0 +1,67 @@ +use super::HostContext; +use crate::db::adapt_sql; +use crate::plugin::StrongRef; + +#[derive(Debug, thiserror::Error)] +pub enum LookupError { + #[error("Database error: {0}")] + Database(#[from] sqlx::Error), + #[error("Invalid external ID field path")] + InvalidFieldPath, +} + +/// Look up a record by external ID +/// +/// # Arguments +/// * `collection` - Lexicon collection ID (e.g., "games.gamesgamesgamesgames.game") +/// * `external_id_field` - JSON path to external ID field (e.g., "externalIds.steam") +/// * `external_id_value` - Value to match +pub async fn lookup_record( + ctx: &HostContext, + collection: &str, + external_id_field: &str, + external_id_value: &str, +) -> Result, LookupError> { + // Validate field path (basic check) + if external_id_field.is_empty() || external_id_field.contains("..") { + return Err(LookupError::InvalidFieldPath); + } + + // Build JSON path for query + let json_path = format!("$.{}", external_id_field); + + let sql = adapt_sql( + "SELECT uri, cid FROM records + WHERE collection = ? + AND json_extract(record, ?) = ? + LIMIT 1", + ctx.db_backend, + ); + + let result: Option<(String, String)> = sqlx::query_as(&sql) + .bind(collection) + .bind(&json_path) + .bind(external_id_value) + .fetch_optional(&ctx.db) + .await?; + + Ok(result.map(|(uri, cid)| StrongRef { uri, cid })) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_invalid_field_path_empty() { + // Can't test async without runtime, but we can verify error types exist + let err = LookupError::InvalidFieldPath; + assert!(err.to_string().contains("Invalid")); + } + + #[test] + fn test_lookup_error_display() { + let err = LookupError::InvalidFieldPath; + assert_eq!(err.to_string(), "Invalid external ID field path"); + } +} diff --git a/src/plugin/host/mod.rs b/src/plugin/host/mod.rs new file mode 100644 index 0000000..f00fe4f --- /dev/null +++ b/src/plugin/host/mod.rs @@ -0,0 +1,41 @@ +mod http; +mod kv; +mod logging; +mod lookup; +mod secrets; + +pub use http::*; +pub use kv::*; +pub use logging::*; +pub use lookup::*; +pub use secrets::*; + +use std::collections::HashMap; +use std::sync::Arc; + +/// Context passed to all host function calls +pub struct HostContext { + pub plugin_id: String, + pub scope: String, // user DID or OAuth state + pub secrets: HashMap, + pub config: serde_json::Value, + pub db: sqlx::AnyPool, + pub db_backend: crate::db::DatabaseBackend, + pub http_client: reqwest::Client, + pub lexicons: Arc, +} + +/// Resource usage tracking for limits +#[derive(Default)] +pub struct ResourceUsage { + pub http_requests: u32, + pub http_bytes_transferred: u64, + pub kv_bytes_used: u64, +} + +/// Resource limits from spec +pub const MAX_HTTP_REQUESTS: u32 = 100; +pub const MAX_HTTP_RESPONSE_SIZE: u64 = 100 * 1024 * 1024; // 100 MB +pub const MAX_HTTP_TOTAL_TRANSFER: u64 = 500 * 1024 * 1024; // 500 MB +pub const MAX_HTTP_CONCURRENT: usize = 5; +pub const MAX_KV_SIZE_PER_USER: u64 = 1024 * 1024; // 1 MB diff --git a/src/plugin/host/secrets.rs b/src/plugin/host/secrets.rs new file mode 100644 index 0000000..465b8f5 --- /dev/null +++ b/src/plugin/host/secrets.rs @@ -0,0 +1,33 @@ +use super::HostContext; + +/// Get a secret value by name (from pre-loaded secrets map) +pub fn get_secret(ctx: &HostContext, name: &str) -> Option { + ctx.secrets.get(name).cloned() +} + +#[cfg(test)] +mod tests { + use std::collections::HashMap; + + #[test] + fn test_get_existing_secret() { + let mut secrets: HashMap = HashMap::new(); + secrets.insert("API_KEY".to_string(), "abc123".to_string()); + assert_eq!(secrets.get("API_KEY").cloned(), Some("abc123".to_string())); + } + + #[test] + fn test_get_missing_secret() { + let secrets: HashMap = HashMap::new(); + assert_eq!(secrets.get("MISSING").cloned(), None); + } + + #[test] + fn test_get_secret_case_sensitive() { + let mut secrets: HashMap = HashMap::new(); + secrets.insert("api_key".to_string(), "lower".to_string()); + // Keys are case-sensitive + assert_eq!(secrets.get("API_KEY").cloned(), None); + assert_eq!(secrets.get("api_key").cloned(), Some("lower".to_string())); + } +} diff --git a/src/plugin/loader.rs b/src/plugin/loader.rs new file mode 100644 index 0000000..331808c --- /dev/null +++ b/src/plugin/loader.rs @@ -0,0 +1,201 @@ +use crate::plugin::{LoadedPlugin, PluginInfo, PluginSource}; +use sha2::{Digest, Sha256}; +use std::path::Path; + +const SUPPORTED_API_VERSION: &str = "1"; + +#[derive(Debug, thiserror::Error)] +pub enum LoadError { + #[error("Failed to read plugin file: {0}")] + ReadFile(#[from] std::io::Error), + #[error("Failed to download plugin: {0}")] + Download(#[from] reqwest::Error), + #[error("SHA256 mismatch: expected {expected}, got {actual}")] + Sha256Mismatch { expected: String, actual: String }, + #[error("Failed to parse plugin info: {0}")] + ParseInfo(#[from] serde_json::Error), + #[error("Plugin API version {0} not supported (requires {SUPPORTED_API_VERSION})")] + UnsupportedApiVersion(String), + #[error("Missing required secret: {0}")] + MissingSecret(String), + #[error("WASM validation failed: {0}")] + WasmValidation(String), +} + +/// Load a plugin from a file path +pub async fn load_from_file(path: &Path) -> Result { + let wasm_path = path.join("plugin.wasm"); + let wasm_bytes = tokio::fs::read(&wasm_path).await?; + + // Try to load plugin.toml for metadata override + let toml_path = path.join("plugin.toml"); + let _toml_content = tokio::fs::read_to_string(&toml_path).await.ok(); + + // Extract plugin info by instantiating WASM and calling plugin_info() + // For now, create placeholder - full implementation needs wasmtime integration + let info = extract_plugin_info(&wasm_bytes)?; + + validate_api_version(&info)?; + + Ok(LoadedPlugin { + info, + source: PluginSource::File { + path: path.to_path_buf(), + }, + wasm_bytes, + }) +} + +/// Load a plugin from a URL +pub async fn load_from_url( + client: &reqwest::Client, + url: &str, + expected_sha256: Option<&str>, +) -> Result { + let response = client.get(url).send().await?.error_for_status()?; + let wasm_bytes = response.bytes().await?.to_vec(); + + // Verify SHA256 if provided + if let Some(expected) = expected_sha256 { + let mut hasher = Sha256::new(); + hasher.update(&wasm_bytes); + let actual = hex::encode(hasher.finalize()); + + if actual != expected { + return Err(LoadError::Sha256Mismatch { + expected: expected.to_string(), + actual, + }); + } + } + + let info = extract_plugin_info(&wasm_bytes)?; + validate_api_version(&info)?; + + Ok(LoadedPlugin { + info, + source: PluginSource::Url { + url: url.to_string(), + sha256: expected_sha256.map(String::from), + }, + wasm_bytes, + }) +} + +/// Extract plugin info by instantiating WASM and calling plugin_info() +fn extract_plugin_info(wasm_bytes: &[u8]) -> Result { + // TODO: Full implementation with wasmtime + // For now, this is a placeholder that will be filled in when we integrate wasmtime calls + + // Validate it's valid WASM + wasmtime::Module::validate(&wasmtime::Engine::default(), wasm_bytes) + .map_err(|e| LoadError::WasmValidation(e.to_string()))?; + + // Return placeholder - real implementation calls plugin_info() export + Ok(PluginInfo { + id: "placeholder".into(), + name: "Placeholder".into(), + version: "0.0.0".into(), + api_version: SUPPORTED_API_VERSION.into(), + icon_url: None, + required_secrets: vec![], + config_schema: None, + }) +} + +fn validate_api_version(info: &PluginInfo) -> Result<(), LoadError> { + // Parse as integer for comparison + let plugin_version: u32 = info.api_version.parse().unwrap_or(0); + let supported_version: u32 = SUPPORTED_API_VERSION.parse().unwrap_or(1); + + if plugin_version > supported_version { + return Err(LoadError::UnsupportedApiVersion(info.api_version.clone())); + } + + Ok(()) +} + +/// Validate that all required secrets are present +pub fn validate_secrets( + info: &PluginInfo, + available_secrets: &std::collections::HashMap, +) -> Result<(), LoadError> { + for secret in &info.required_secrets { + if !available_secrets.contains_key(secret) { + return Err(LoadError::MissingSecret(secret.clone())); + } + } + Ok(()) +} + +/// Parse PLUGIN_URLS environment variable +/// Format: id|url|sha256:hash,id|url|sha256:hash,... +pub fn parse_plugin_urls(env_value: &str) -> Vec<(String, String, Option)> { + env_value + .split(',') + .filter_map(|entry| { + let parts: Vec<&str> = entry.trim().split('|').collect(); + if parts.len() >= 2 { + let id = parts[0].to_string(); + let url = parts[1].to_string(); + let sha256 = parts + .get(2) + .and_then(|s| s.strip_prefix("sha256:").map(String::from)); + Some((id, url, sha256)) + } else { + None + } + }) + .collect() +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_parse_plugin_urls() { + let input = + "steam|https://example.com/steam.wasm|sha256:abc123,gog|https://example.com/gog.wasm"; + let result = parse_plugin_urls(input); + + assert_eq!(result.len(), 2); + assert_eq!( + result[0], + ( + "steam".into(), + "https://example.com/steam.wasm".into(), + Some("abc123".into()) + ) + ); + assert_eq!( + result[1], + ("gog".into(), "https://example.com/gog.wasm".into(), None) + ); + } + + #[test] + fn test_validate_api_version() { + let info = PluginInfo { + id: "test".into(), + name: "Test".into(), + version: "1.0.0".into(), + api_version: "1".into(), + icon_url: None, + required_secrets: vec![], + config_schema: None, + }; + + assert!(validate_api_version(&info).is_ok()); + + let future_info = PluginInfo { + api_version: "99".into(), + ..info + }; + + assert!(matches!( + validate_api_version(&future_info), + Err(LoadError::UnsupportedApiVersion(_)) + )); + } +} diff --git a/src/plugin/mod.rs b/src/plugin/mod.rs new file mode 100644 index 0000000..ec10134 --- /dev/null +++ b/src/plugin/mod.rs @@ -0,0 +1,41 @@ +pub mod encryption; +pub mod host; +pub mod loader; +mod runtime; +mod types; + +pub use runtime::WasmRuntime; +pub use types::*; + +use std::collections::HashMap; +use std::sync::Arc; +use tokio::sync::RwLock; + +/// Registry of loaded plugins +#[derive(Default)] +pub struct PluginRegistry { + plugins: RwLock>>, +} + +impl PluginRegistry { + pub fn new() -> Self { + Self::default() + } + + pub async fn register(&self, plugin: LoadedPlugin) { + let id = plugin.info.id.clone(); + self.plugins.write().await.insert(id, Arc::new(plugin)); + } + + pub async fn get(&self, id: &str) -> Option> { + self.plugins.read().await.get(id).cloned() + } + + pub async fn list(&self) -> Vec> { + self.plugins.read().await.values().cloned().collect() + } + + pub async fn remove(&self, id: &str) -> Option> { + self.plugins.write().await.remove(id) + } +} diff --git a/src/plugin/runtime.rs b/src/plugin/runtime.rs new file mode 100644 index 0000000..97f7278 --- /dev/null +++ b/src/plugin/runtime.rs @@ -0,0 +1,27 @@ +use wasmtime::*; + +/// WASM runtime for executing plugins +pub struct WasmRuntime { + engine: Engine, +} + +impl WasmRuntime { + pub fn new() -> Result { + let mut config = Config::new(); + config.async_support(true); + + let engine = Engine::new(&config)?; + + Ok(Self { engine }) + } + + pub fn engine(&self) -> &Engine { + &self.engine + } +} + +impl Default for WasmRuntime { + fn default() -> Self { + Self::new().expect("Failed to create WASM runtime") + } +} diff --git a/src/plugin/types.rs b/src/plugin/types.rs new file mode 100644 index 0000000..b8b23be --- /dev/null +++ b/src/plugin/types.rs @@ -0,0 +1,98 @@ +use serde::{Deserialize, Serialize}; + +/// Plugin metadata returned by plugin_info() +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct PluginInfo { + pub id: String, + pub name: String, + pub version: String, + pub api_version: String, + #[serde(skip_serializing_if = "Option::is_none")] + pub icon_url: Option, + #[serde(default)] + pub required_secrets: Vec, + #[serde(skip_serializing_if = "Option::is_none")] + pub config_schema: Option, +} + +/// OAuth callback parameters passed to handle_callback() +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct CallbackParams { + pub code: Option, + pub state: Option, + pub error: Option, + #[serde(flatten)] + pub extra: std::collections::HashMap, +} + +/// Tokens returned by handle_callback() and refresh_tokens() +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct TokenSet { + pub access_token: String, + #[serde(skip_serializing_if = "Option::is_none")] + pub refresh_token: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub expires_at: Option>, + pub token_type: String, +} + +/// Error returned by plugin functions +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct PluginError { + pub code: PluginErrorCode, + pub message: String, + #[serde(default)] + pub retryable: bool, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum PluginErrorCode { + UserDenied, + InvalidToken, + ServiceUnavailable, + InvalidResponse, + Unknown, +} + +/// External profile returned by get_profile() +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct ExternalProfile { + pub account_id: String, + #[serde(skip_serializing_if = "Option::is_none")] + pub display_name: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub profile_url: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub avatar_url: Option, +} + +/// Record returned by sync_account() - lexicon-aware +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct SyncRecord { + pub collection: String, + pub record: serde_json::Value, + #[serde(skip_serializing_if = "Option::is_none")] + pub dedup_key: Option, +} + +/// Strong reference to an AT Protocol record +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct StrongRef { + pub uri: String, + pub cid: String, +} + +/// Plugin source - file or URL +#[derive(Debug, Clone)] +pub enum PluginSource { + File { path: std::path::PathBuf }, + Url { url: String, sha256: Option }, +} + +/// Loaded plugin with runtime state +pub struct LoadedPlugin { + pub info: PluginInfo, + pub source: PluginSource, + pub wasm_bytes: Vec, +} diff --git a/src/server.rs b/src/server.rs index b385546..b997382 100644 --- a/src/server.rs +++ b/src/server.rs @@ -67,6 +67,7 @@ pub fn router(state: AppState) -> Router { .route("/settings/logo", get(crate::admin::settings::serve_logo)) .nest("/admin", admin::admin_routes(state.clone())) .nest("/auth", crate::auth::routes::routes()) + .nest("/external-auth", crate::external_auth::routes()) .route("/oauth/client-metadata.json", get(client_metadata)) .route("/xrpc/app.bsky.actor.getProfile", get(get_profile)) .route( diff --git a/tests/common/app.rs b/tests/common/app.rs index 80c8b4f..4a03a6f 100644 --- a/tests/common/app.rs +++ b/tests/common/app.rs @@ -51,6 +51,7 @@ impl TestApp { logo_uri: None, tos_uri: None, policy_uri: None, + token_encryption_key: None, }; let sql = adapt_sql( @@ -129,6 +130,7 @@ impl TestApp { cookie_key: axum_extra::extract::cookie::Key::derive_from( b"test-secret-that-is-at-least-32-bytes-long", ), + plugin_registry: std::sync::Arc::new(happyview::plugin::PluginRegistry::new()), }; let router = server::router(state.clone()); diff --git a/tests/lua_atproto_api.rs b/tests/lua_atproto_api.rs index 12413cc..30f6d66 100644 --- a/tests/lua_atproto_api.rs +++ b/tests/lua_atproto_api.rs @@ -33,6 +33,7 @@ async fn test_state_with_pool(pool: sqlx::AnyPool, backend: DatabaseBackend) -> logo_uri: None, tos_uri: None, policy_uri: None, + token_encryption_key: None, }; let (tx, _) = watch::channel(vec![]); let (labeler_tx, _) = watch::channel(()); @@ -83,6 +84,7 @@ async fn test_state_with_pool(pool: sqlx::AnyPool, backend: DatabaseBackend) -> ), oauth: std::sync::Arc::new(oauth), cookie_key: axum_extra::extract::cookie::Key::derive_from(b"test-secret"), + plugin_registry: std::sync::Arc::new(happyview::plugin::PluginRegistry::new()), } } diff --git a/tests/lua_db_api.rs b/tests/lua_db_api.rs index 57682e6..14b9e62 100644 --- a/tests/lua_db_api.rs +++ b/tests/lua_db_api.rs @@ -36,6 +36,7 @@ async fn test_state_with_pool(pool: sqlx::AnyPool, backend: DatabaseBackend) -> logo_uri: None, tos_uri: None, policy_uri: None, + token_encryption_key: None, }; let (tx, _) = watch::channel(vec![]); let (labeler_tx, _) = watch::channel(()); @@ -86,6 +87,7 @@ async fn test_state_with_pool(pool: sqlx::AnyPool, backend: DatabaseBackend) -> ), oauth: std::sync::Arc::new(oauth), cookie_key: axum_extra::extract::cookie::Key::derive_from(b"test-secret"), + plugin_registry: std::sync::Arc::new(happyview::plugin::PluginRegistry::new()), } } diff --git a/tests/plugin_integration.rs b/tests/plugin_integration.rs new file mode 100644 index 0000000..14f1707 --- /dev/null +++ b/tests/plugin_integration.rs @@ -0,0 +1,73 @@ +//! Integration tests for the plugin system +//! +//! Note: These tests require a valid WASM plugin to test against. +//! For now, we test the infrastructure without actual WASM execution. + +use happyview::plugin::{LoadedPlugin, PluginInfo, PluginRegistry, PluginSource}; + +#[tokio::test] +async fn test_plugin_registry_crud() { + let registry = PluginRegistry::new(); + + // Create test plugin + let plugin = LoadedPlugin { + info: PluginInfo { + id: "test-plugin".into(), + name: "Test Plugin".into(), + version: "1.0.0".into(), + api_version: "1".into(), + icon_url: None, + required_secrets: vec![], + config_schema: None, + }, + source: PluginSource::File { + path: "/tmp/test".into(), + }, + wasm_bytes: vec![], + }; + + // Register + registry.register(plugin).await; + + // Get + let retrieved = registry.get("test-plugin").await; + assert!(retrieved.is_some()); + assert_eq!(retrieved.unwrap().info.name, "Test Plugin"); + + // List + let all = registry.list().await; + assert_eq!(all.len(), 1); + + // Remove + let removed = registry.remove("test-plugin").await; + assert!(removed.is_some()); + + // Verify removed + assert!(registry.get("test-plugin").await.is_none()); +} + +#[tokio::test] +async fn test_plugin_registry_multiple() { + let registry = PluginRegistry::new(); + + for i in 0..5 { + let plugin = LoadedPlugin { + info: PluginInfo { + id: format!("plugin-{}", i), + name: format!("Plugin {}", i), + version: "1.0.0".into(), + api_version: "1".into(), + icon_url: None, + required_secrets: vec![], + config_schema: None, + }, + source: PluginSource::File { + path: "/tmp/test".into(), + }, + wasm_bytes: vec![], + }; + registry.register(plugin).await; + } + + assert_eq!(registry.list().await.len(), 5); +} -- 2.51.2 From 5519fe67b45b98370e4eddce81c6d082b240a574 Mon Sep 17 00:00:00 2001 From: Trezy Date: Fri, 20 Mar 2026 07:32:03 -0500 Subject: [PATCH 2/6] fix: delete auth redirect cookie before redirecting --- src/auth/routes.rs | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/auth/routes.rs b/src/auth/routes.rs index 161c04b..ebaa218 100644 --- a/src/auth/routes.rs +++ b/src/auth/routes.rs @@ -99,9 +99,11 @@ async fn callback( session_cookie.set_same_site(axum_extra::extract::cookie::SameSite::None); session_cookie.set_secure(true); // Required when SameSite=None - // Remove the redirect cookie + // Remove the redirect cookie (must match attributes from login) let mut redirect_removal = Cookie::from(REDIRECT_COOKIE_NAME); redirect_removal.set_path("/"); + redirect_removal.set_same_site(axum_extra::extract::cookie::SameSite::None); + redirect_removal.set_secure(true); let jar = jar.add(session_cookie).remove(redirect_removal); Ok((jar, Redirect::to(&redirect_url))) -- 2.51.2 From b0d9af355cc5c24fa7de5c00d468441034372c26 Mon Sep 17 00:00:00 2001 From: Trezy Date: Fri, 20 Mar 2026 12:30:29 -0500 Subject: [PATCH 3/6] feat: complete plugin sync pipeline with auth, tokens, and PDS writes --- Cargo.lock | 1 + Cargo.toml | 1 + docs/plugins.md | 51 ++ ...60320100000_create_external_auth_state.sql | 12 + ...60320100000_create_external_auth_state.sql | 12 + plugins/steam/.gitignore | 1 + plugins/steam/Cargo.lock | 107 +++ plugins/steam/Cargo.toml | 15 + plugins/steam/src/lib.rs | 738 ++++++++++++++++++ src/external_auth/mod.rs | 3 + src/external_auth/pds_write.rs | 127 +++ src/external_auth/routes.rs | 212 ++++- src/external_auth/state.rs | 108 +++ src/external_auth/tokens.rs | 198 +++++ src/lib.rs | 2 + src/lua/atproto_api.rs | 4 + src/lua/db_api.rs | 4 + src/lua/execute.rs | 4 + src/lua/http_api.rs | 4 + src/main.rs | 22 + src/plugin/attestation.rs | 331 ++++++++ src/plugin/executor.rs | 483 ++++++++++++ src/plugin/host/bindings.rs | 438 +++++++++++ src/plugin/host/lookup.rs | 31 + src/plugin/host/mod.rs | 2 + src/plugin/loader.rs | 116 ++- src/plugin/memory.rs | 193 +++++ src/plugin/mod.rs | 6 + src/plugin/runtime.rs | 35 + src/plugin/sync.rs | 312 ++++++++ src/plugin/types.rs | 3 + tests/common/app.rs | 4 + tests/fixtures/test_plugin/.gitignore | 1 + tests/fixtures/test_plugin/Cargo.lock | 7 + tests/fixtures/test_plugin/Cargo.toml | 11 + tests/fixtures/test_plugin/src/lib.rs | 105 +++ tests/lua_atproto_api.rs | 4 + tests/lua_db_api.rs | 4 + tests/plugin_executor.rs | 224 ++++++ 39 files changed, 3902 insertions(+), 34 deletions(-) create mode 100644 docs/plugins.md create mode 100644 migrations/postgres/20260320100000_create_external_auth_state.sql create mode 100644 migrations/sqlite/20260320100000_create_external_auth_state.sql create mode 100644 plugins/steam/.gitignore create mode 100644 plugins/steam/Cargo.lock create mode 100644 plugins/steam/Cargo.toml create mode 100644 plugins/steam/src/lib.rs create mode 100644 src/external_auth/pds_write.rs create mode 100644 src/external_auth/state.rs create mode 100644 src/external_auth/tokens.rs create mode 100644 src/plugin/attestation.rs create mode 100644 src/plugin/executor.rs create mode 100644 src/plugin/host/bindings.rs create mode 100644 src/plugin/memory.rs create mode 100644 src/plugin/sync.rs create mode 100644 tests/fixtures/test_plugin/.gitignore create mode 100644 tests/fixtures/test_plugin/Cargo.lock create mode 100644 tests/fixtures/test_plugin/Cargo.toml create mode 100644 tests/fixtures/test_plugin/src/lib.rs create mode 100644 tests/plugin_executor.rs diff --git a/Cargo.lock b/Cargo.lock index 9c9026a..52298e4 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1637,6 +1637,7 @@ dependencies = [ "bytes", "chrono", "ciborium", + "cid", "dashmap", "dotenvy", "futures-util", diff --git a/Cargo.toml b/Cargo.toml index 3226c6e..72963a8 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -24,6 +24,7 @@ jose-jwk = { version = "0.1", default-features = false, features = ["p256"] } jsonwebtoken = "9" bytes = "1" chrono = { version = "0.4", features = ["serde"] } +cid = "0.11" ciborium = "0.2" k256 = { version = "0.13", features = ["ecdsa"] } multibase = "0.9" diff --git a/docs/plugins.md b/docs/plugins.md new file mode 100644 index 0000000..095fd17 --- /dev/null +++ b/docs/plugins.md @@ -0,0 +1,51 @@ +# HappyView Plugin System + +HappyView supports WASM plugins for extending functionality. The first plugin type is external auth providers (Steam, GOG, Epic, etc.). + +## Configuration + +### Environment Variables + +- `TOKEN_ENCRYPTION_KEY`: Base64-encoded 32-byte key for encrypting OAuth tokens (required for external auth) +- `PLUGIN_URLS`: Comma-separated list of plugins to load from URLs + +### PLUGIN_URLS Format + +``` +id|url|sha256:hash,id|url|sha256:hash +``` + +Example: +``` +PLUGIN_URLS=steam|https://github.com/org/plugins/releases/download/v1.0.0/steam.wasm|sha256:abc123 +``` + +### File-based Plugins + +Place plugins in the `./plugins/` directory: + +``` +plugins/ + steam/ + plugin.wasm + plugin.toml +``` + +## API Endpoints + +- `GET /external-auth/providers` - List available auth providers +- `GET /external-auth/{plugin_id}/authorize?redirect_uri=...` - Start auth flow +- `GET /external-auth/{plugin_id}/callback` - OAuth callback +- `POST /external-auth/{plugin_id}/sync` - Sync account data +- `POST /external-auth/{plugin_id}/unlink` - Unlink account + +## Plugin Development + +See the [Plugin Development Guide](./plugin-development.md) for creating custom plugins. + +## Security + +- OAuth tokens are encrypted at rest using AES-256-GCM +- Plugins run in a sandboxed WASM environment +- Plugins can only access host functions (HTTP, KV, secrets, logging) +- KV storage is scoped per-plugin and per-user diff --git a/migrations/postgres/20260320100000_create_external_auth_state.sql b/migrations/postgres/20260320100000_create_external_auth_state.sql new file mode 100644 index 0000000..9e28dd9 --- /dev/null +++ b/migrations/postgres/20260320100000_create_external_auth_state.sql @@ -0,0 +1,12 @@ +-- OAuth state for external auth flows (e.g., Steam OpenID) +CREATE TABLE external_auth_state ( + state TEXT PRIMARY KEY, + did TEXT NOT NULL, + plugin_id TEXT NOT NULL, + redirect_uri TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + expires_at TIMESTAMPTZ NOT NULL +); + +-- Index for cleanup of expired state +CREATE INDEX idx_external_auth_state_expires ON external_auth_state(expires_at); diff --git a/migrations/sqlite/20260320100000_create_external_auth_state.sql b/migrations/sqlite/20260320100000_create_external_auth_state.sql new file mode 100644 index 0000000..0034169 --- /dev/null +++ b/migrations/sqlite/20260320100000_create_external_auth_state.sql @@ -0,0 +1,12 @@ +-- OAuth state for external auth flows (e.g., Steam OpenID) +CREATE TABLE external_auth_state ( + state TEXT PRIMARY KEY, + did TEXT NOT NULL, + plugin_id TEXT NOT NULL, + redirect_uri TEXT NOT NULL, + created_at TEXT NOT NULL DEFAULT (datetime('now')), + expires_at TEXT NOT NULL +); + +-- Index for cleanup of expired state +CREATE INDEX idx_external_auth_state_expires ON external_auth_state(expires_at); diff --git a/plugins/steam/.gitignore b/plugins/steam/.gitignore new file mode 100644 index 0000000..b83d222 --- /dev/null +++ b/plugins/steam/.gitignore @@ -0,0 +1 @@ +/target/ diff --git a/plugins/steam/Cargo.lock b/plugins/steam/Cargo.lock new file mode 100644 index 0000000..6895834 --- /dev/null +++ b/plugins/steam/Cargo.lock @@ -0,0 +1,107 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + +[[package]] +name = "memchr" +version = "2.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79" + +[[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 = "quote" +version = "1.0.45" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924" +dependencies = [ + "proc-macro2", +] + +[[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 = "steam-plugin" +version = "0.1.0" +dependencies = [ + "serde", + "serde_json", +] + +[[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 = "unicode-ident" +version = "1.0.24" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75" + +[[package]] +name = "zmij" +version = "1.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa" diff --git a/plugins/steam/Cargo.toml b/plugins/steam/Cargo.toml new file mode 100644 index 0000000..3bed82e --- /dev/null +++ b/plugins/steam/Cargo.toml @@ -0,0 +1,15 @@ +[package] +name = "steam-plugin" +version = "0.1.0" +edition = "2021" + +[lib] +crate-type = ["cdylib"] + +[dependencies] +serde = { version = "1", default-features = false, features = ["derive", "alloc"] } +serde_json = { version = "1", default-features = false, features = ["alloc"] } + +[profile.release] +opt-level = "s" +lto = true diff --git a/plugins/steam/src/lib.rs b/plugins/steam/src/lib.rs new file mode 100644 index 0000000..cd41de1 --- /dev/null +++ b/plugins/steam/src/lib.rs @@ -0,0 +1,738 @@ +// Steam Plugin for HappyView +// Uses OpenID 2.0 for authentication and Steam Web API for data + +#![cfg_attr(target_arch = "wasm32", no_std)] +#![allow(static_mut_refs)] + +#[cfg(target_arch = "wasm32")] +extern crate alloc; + +#[cfg(target_arch = "wasm32")] +use alloc::{format, string::String, string::ToString, vec::Vec}; + +#[cfg(target_arch = "wasm32")] +use core::alloc::{GlobalAlloc, Layout}; + +use serde::{Deserialize, Serialize}; + +// ============================================================================ +// Memory Management (WASM only) +// ============================================================================ + +#[cfg(target_arch = "wasm32")] +struct BumpAllocator; + +#[cfg(target_arch = "wasm32")] +const HEAP_SIZE: usize = 131072; // 128KB + +#[cfg(target_arch = "wasm32")] +static mut HEAP: [u8; HEAP_SIZE] = [0; HEAP_SIZE]; + +#[cfg(target_arch = "wasm32")] +static mut HEAP_POS: usize = 0; + +#[cfg(target_arch = "wasm32")] +unsafe impl GlobalAlloc for BumpAllocator { + unsafe fn alloc(&self, layout: Layout) -> *mut u8 { + let size = layout.size(); + let align = layout.align(); + let pos = (HEAP_POS + align - 1) & !(align - 1); + if pos + size > HEAP_SIZE { + return core::ptr::null_mut(); + } + HEAP_POS = pos + size; + HEAP.as_mut_ptr().add(pos) + } + + unsafe fn dealloc(&self, _ptr: *mut u8, _layout: Layout) { + // No-op for bump allocator + } +} + +#[cfg(target_arch = "wasm32")] +#[global_allocator] +static ALLOCATOR: BumpAllocator = BumpAllocator; + +#[cfg(target_arch = "wasm32")] +#[panic_handler] +fn panic(_info: &core::panic::PanicInfo) -> ! { + loop {} +} + +// ============================================================================ +// Host Function Imports +// ============================================================================ + +#[cfg(target_arch = "wasm32")] +extern "C" { + fn host_http_request(req_ptr: i32, req_len: i32) -> i64; + fn host_get_secret(name_ptr: i32, name_len: i32) -> i64; +} + +// ============================================================================ +// Memory Exports +// ============================================================================ + +#[no_mangle] +pub extern "C" fn alloc(size: u32) -> u32 { + #[cfg(target_arch = "wasm32")] + { + let layout = Layout::from_size_align(size as usize, 1).unwrap(); + unsafe { ALLOCATOR.alloc(layout) as u32 } + } + #[cfg(not(target_arch = "wasm32"))] + { + let _ = size; + 0 + } +} + +#[no_mangle] +pub extern "C" fn dealloc(_ptr: u32, _size: u32) { + // No-op for bump allocator +} + +// ============================================================================ +// Helper Functions +// ============================================================================ + +fn return_json(s: &str) -> i64 { + let ptr = alloc(s.len() as u32); + if ptr == 0 { + return 0; + } + #[cfg(target_arch = "wasm32")] + unsafe { + core::ptr::copy_nonoverlapping(s.as_ptr(), ptr as *mut u8, s.len()); + } + ((ptr as i64) << 32) | (s.len() as i64) +} + +fn return_ok(value: &T) -> i64 { + let json = serde_json::to_string(&Response::Ok(value)).unwrap_or_default(); + return_json(&json) +} + +fn return_error(code: &str, message: &str, retryable: bool) -> i64 { + let err = ErrorResponse { + code: code.into(), + message: message.into(), + retryable, + }; + let json = serde_json::to_string(&Response::<()>::Err(err)).unwrap_or_default(); + return_json(&json) +} + +#[cfg(target_arch = "wasm32")] +fn read_input(ptr: u32, len: u32) -> Option> { + if len == 0 || len > 1024 * 1024 { + return None; + } + let slice = unsafe { core::slice::from_raw_parts(ptr as *const u8, len as usize) }; + Some(slice.to_vec()) +} + +#[cfg(target_arch = "wasm32")] +fn read_host_response(packed: i64) -> Option> { + if packed == 0 { + return None; + } + let ptr = (packed >> 32) as u32; + let len = (packed & 0xFFFFFFFF) as u32; + if len == 0 || len > 10 * 1024 * 1024 { + return None; + } + let slice = unsafe { core::slice::from_raw_parts(ptr as *const u8, len as usize) }; + Some(slice.to_vec()) +} + +#[cfg(target_arch = "wasm32")] +fn get_secret(name: &str) -> Option { + let packed = unsafe { host_get_secret(name.as_ptr() as i32, name.len() as i32) }; + let bytes = read_host_response(packed)?; + // Host returns JSON: {"ok": "value"} or {"error": ...} + let resp: Response = serde_json::from_slice(&bytes).ok()?; + match resp { + Response::Ok(val) => Some(val), + Response::Err(_) => None, + } +} + +#[cfg(target_arch = "wasm32")] +fn http_get(url: &str) -> Result { + let req = HttpRequest { + method: "GET".into(), + url: url.into(), + headers: alloc::vec![], + body: None, + }; + let req_json = serde_json::to_string(&req).map_err(|e| format!("serialize: {}", e))?; + let packed = unsafe { host_http_request(req_json.as_ptr() as i32, req_json.len() as i32) }; + let bytes = read_host_response(packed).ok_or("no response")?; + let resp: Response = + serde_json::from_slice(&bytes).map_err(|e| format!("parse: {}", e))?; + match resp { + Response::Ok(r) => r.body.ok_or_else(|| "empty body".into()), + Response::Err(e) => Err(e.message), + } +} + +#[cfg(target_arch = "wasm32")] +fn http_post(url: &str, body: &str, content_type: &str) -> Result { + let req = HttpRequest { + method: "POST".into(), + url: url.into(), + headers: alloc::vec![("Content-Type".into(), content_type.into())], + body: Some(body.into()), + }; + let req_json = serde_json::to_string(&req).map_err(|e| format!("serialize: {}", e))?; + let packed = unsafe { host_http_request(req_json.as_ptr() as i32, req_json.len() as i32) }; + let bytes = read_host_response(packed).ok_or("no response")?; + let resp: Response = + serde_json::from_slice(&bytes).map_err(|e| format!("parse: {}", e))?; + match resp { + Response::Ok(r) => r.body.ok_or_else(|| "empty body".into()), + Response::Err(e) => Err(e.message), + } +} + +// ============================================================================ +// Types +// ============================================================================ + +#[derive(Serialize, Deserialize)] +#[serde(untagged)] +enum Response { + Ok(T), + Err(ErrorResponse), +} + +#[derive(Serialize, Deserialize)] +struct ErrorResponse { + code: String, + message: String, + retryable: bool, +} + +#[derive(Serialize, Deserialize)] +struct PluginInfo { + id: String, + name: String, + version: String, + api_version: String, + icon_url: Option, + required_secrets: Vec, + config_schema: Option, +} + +#[derive(Serialize, Deserialize)] +struct AuthorizeInput { + state: String, + redirect_uri: String, + config: serde_json::Value, +} + +#[derive(Serialize, Deserialize)] +struct CallbackInput { + code: Option, + state: String, + config: serde_json::Value, + #[serde(flatten)] + extra: serde_json::Map, +} + +#[derive(Serialize, Deserialize)] +struct TokenSet { + access_token: String, + token_type: String, + expires_at: Option, + refresh_token: Option, +} + +#[derive(Serialize, Deserialize)] +struct ProfileInput { + access_token: String, + config: serde_json::Value, +} + +#[derive(Serialize, Deserialize)] +struct ExternalProfile { + account_id: String, + display_name: Option, + profile_url: Option, + avatar_url: Option, +} + +#[derive(Serialize, Deserialize)] +struct SyncInput { + access_token: String, + config: serde_json::Value, +} + +#[derive(Serialize, Deserialize)] +struct SyncRecord { + collection: String, + record: serde_json::Value, + dedup_key: Option, + /// Whether HappyView should add an attestation signature + sign: bool, +} + +#[derive(Serialize, Deserialize)] +struct HttpRequest { + method: String, + url: String, + headers: Vec<(String, String)>, + body: Option, +} + +#[derive(Serialize, Deserialize)] +struct HttpResponse { + status: u16, + headers: Vec<(String, String)>, + body: Option, +} + +// Steam API types +#[derive(Deserialize)] +struct SteamOwnedGamesResponse { + response: SteamOwnedGames, +} + +#[derive(Deserialize)] +#[allow(dead_code)] +struct SteamOwnedGames { + game_count: Option, + games: Option>, +} + +#[derive(Deserialize)] +#[allow(dead_code)] +struct SteamGame { + appid: u64, + name: Option, + playtime_forever: Option, + img_icon_url: Option, + playtime_2weeks: Option, +} + +#[derive(Deserialize)] +struct SteamPlayerSummary { + response: SteamPlayersResponse, +} + +#[derive(Deserialize)] +struct SteamPlayersResponse { + players: Vec, +} + +#[derive(Deserialize)] +struct SteamPlayer { + steamid: String, + personaname: Option, + profileurl: Option, + avatarfull: Option, +} + +// ============================================================================ +// Steam OpenID 2.0 Constants +// ============================================================================ + +const STEAM_OPENID_URL: &str = "https://steamcommunity.com/openid/login"; +const STEAM_API_BASE: &str = "https://api.steampowered.com"; + +// ============================================================================ +// Plugin Exports +// ============================================================================ + +#[no_mangle] +pub extern "C" fn plugin_info() -> i64 { + let info = PluginInfo { + id: "steam".into(), + name: "Steam".into(), + version: "0.1.0".into(), + api_version: "1".into(), + icon_url: Some("https://store.steampowered.com/favicon.ico".into()), + required_secrets: alloc::vec!["API_KEY".into()], + config_schema: None, + }; + return_ok(&info) +} + +#[no_mangle] +pub extern "C" fn get_authorize_url(ptr: u32, len: u32) -> i64 { + #[cfg(target_arch = "wasm32")] + { + let bytes = match read_input(ptr, len) { + Some(b) => b, + None => return return_error("INVALID_INPUT", "Failed to read input", false), + }; + + let input: AuthorizeInput = match serde_json::from_slice(&bytes) { + Ok(i) => i, + Err(e) => return return_error("INVALID_INPUT", &format!("Parse error: {}", e), false), + }; + + // Build OpenID 2.0 authentication URL + // Steam uses claimed_id and identity as the same value for authentication + let params = [ + ("openid.ns", "http://specs.openid.net/auth/2.0"), + ("openid.mode", "checkid_setup"), + ( + "openid.return_to", + &format!("{}?state={}", input.redirect_uri, input.state), + ), + ("openid.realm", &input.redirect_uri), + ( + "openid.identity", + "http://specs.openid.net/auth/2.0/identifier_select", + ), + ( + "openid.claimed_id", + "http://specs.openid.net/auth/2.0/identifier_select", + ), + ]; + + let query: String = params + .iter() + .map(|(k, v)| format!("{}={}", k, urlencod(v))) + .collect::>() + .join("&"); + + let url = format!("{}?{}", STEAM_OPENID_URL, query); + return_ok(&url) + } + + #[cfg(not(target_arch = "wasm32"))] + { + let _ = (ptr, len); + return_error("NOT_WASM", "Only runs in WASM", false) + } +} + +#[no_mangle] +pub extern "C" fn handle_callback(ptr: u32, len: u32) -> i64 { + #[cfg(target_arch = "wasm32")] + { + let bytes = match read_input(ptr, len) { + Some(b) => b, + None => return return_error("INVALID_INPUT", "Failed to read input", false), + }; + + let input: CallbackInput = match serde_json::from_slice(&bytes) { + Ok(i) => i, + Err(e) => return return_error("INVALID_INPUT", &format!("Parse error: {}", e), false), + }; + + // Extract Steam ID from openid.claimed_id + // Format: https://steamcommunity.com/openid/id/76561198012345678 + let claimed_id = input + .extra + .get("openid.claimed_id") + .and_then(|v| v.as_str()); + + let steam_id = match claimed_id { + Some(id) => { + if let Some(pos) = id.rfind('/') { + &id[pos + 1..] + } else { + return return_error("INVALID_RESPONSE", "Invalid claimed_id format", false); + } + } + None => { + return return_error("INVALID_RESPONSE", "Missing openid.claimed_id", false); + } + }; + + // Verify the OpenID response with Steam + // Build verification request by changing mode to check_authentication + // and POSTing all params back to Steam + let mut verify_params: Vec<(&str, &str)> = Vec::new(); + verify_params.push(("openid.mode", "check_authentication")); + + // Add all openid.* params from the callback (except mode) + for (key, value) in &input.extra { + if key.starts_with("openid.") && key != "openid.mode" { + if let Some(v) = value.as_str() { + verify_params.push((key.as_str(), v)); + } + } + } + + // Build POST body + let verify_body: String = verify_params + .iter() + .map(|(k, v)| format!("{}={}", k, urlencod(v))) + .collect::>() + .join("&"); + + // POST to Steam for verification + let verify_result = http_post( + STEAM_OPENID_URL, + &verify_body, + "application/x-www-form-urlencoded", + ); + + match verify_result { + Ok(response_body) => { + // Steam returns key-value pairs, one per line + // We need to find "is_valid:true" + if !response_body.contains("is_valid:true") { + return return_error( + "VERIFICATION_FAILED", + "Steam OpenID verification failed", + false, + ); + } + } + Err(e) => { + return return_error( + "VERIFICATION_ERROR", + &format!("Failed to verify with Steam: {}", e), + true, + ); + } + } + + // Return the Steam ID as the "access_token" + // Since Steam uses OpenID 2.0 (not OAuth), there's no real token + // We store the Steam ID so we can use it with our API key + let tokens = TokenSet { + access_token: steam_id.into(), + token_type: "SteamID".into(), + expires_at: None, + refresh_token: None, + }; + + return_ok(&tokens) + } + + #[cfg(not(target_arch = "wasm32"))] + { + let _ = (ptr, len); + return_error("NOT_WASM", "Only runs in WASM", false) + } +} + +#[no_mangle] +pub extern "C" fn refresh_tokens(ptr: u32, len: u32) -> i64 { + // Steam doesn't use OAuth tokens - the Steam ID is permanent + #[cfg(target_arch = "wasm32")] + { + let bytes = match read_input(ptr, len) { + Some(b) => b, + None => return return_error("INVALID_INPUT", "Failed to read input", false), + }; + + #[derive(Deserialize)] + struct RefreshInput { + refresh_token: String, + #[allow(dead_code)] + config: serde_json::Value, + } + + let input: RefreshInput = match serde_json::from_slice(&bytes) { + Ok(i) => i, + Err(e) => return return_error("INVALID_INPUT", &format!("Parse error: {}", e), false), + }; + + // Just return the same Steam ID - it doesn't expire + let tokens = TokenSet { + access_token: input.refresh_token, + token_type: "SteamID".into(), + expires_at: None, + refresh_token: None, + }; + + return_ok(&tokens) + } + + #[cfg(not(target_arch = "wasm32"))] + { + let _ = (ptr, len); + return_error("NOT_WASM", "Only runs in WASM", false) + } +} + +#[no_mangle] +pub extern "C" fn get_profile(ptr: u32, len: u32) -> i64 { + #[cfg(target_arch = "wasm32")] + { + let bytes = match read_input(ptr, len) { + Some(b) => b, + None => return return_error("INVALID_INPUT", "Failed to read input", false), + }; + + let input: ProfileInput = match serde_json::from_slice(&bytes) { + Ok(i) => i, + Err(e) => return return_error("INVALID_INPUT", &format!("Parse error: {}", e), false), + }; + + let api_key = match get_secret("API_KEY") { + Some(k) => k, + None => return return_error("MISSING_SECRET", "API_KEY not configured", false), + }; + + let steam_id = &input.access_token; + let url = format!( + "{}/ISteamUser/GetPlayerSummaries/v2/?key={}&steamids={}", + STEAM_API_BASE, api_key, steam_id + ); + + let body = match http_get(&url) { + Ok(b) => b, + Err(e) => return return_error("HTTP_ERROR", &e, true), + }; + + let resp: SteamPlayerSummary = match serde_json::from_str(&body) { + Ok(r) => r, + Err(e) => { + return return_error("INVALID_RESPONSE", &format!("Parse error: {}", e), false) + } + }; + + let player = match resp.response.players.first() { + Some(p) => p, + None => return return_error("NOT_FOUND", "Player not found", false), + }; + + let profile = ExternalProfile { + account_id: player.steamid.clone(), + display_name: player.personaname.clone(), + profile_url: player.profileurl.clone(), + avatar_url: player.avatarfull.clone(), + }; + + return_ok(&profile) + } + + #[cfg(not(target_arch = "wasm32"))] + { + let _ = (ptr, len); + return_error("NOT_WASM", "Only runs in WASM", false) + } +} + +#[no_mangle] +pub extern "C" fn sync_account(ptr: u32, len: u32) -> i64 { + #[cfg(target_arch = "wasm32")] + { + let bytes = match read_input(ptr, len) { + Some(b) => b, + None => return return_error("INVALID_INPUT", "Failed to read input", false), + }; + + let input: SyncInput = match serde_json::from_slice(&bytes) { + Ok(i) => i, + Err(e) => return return_error("INVALID_INPUT", &format!("Parse error: {}", e), false), + }; + + let api_key = match get_secret("API_KEY") { + Some(k) => k, + None => return return_error("MISSING_SECRET", "API_KEY not configured", false), + }; + + let steam_id = &input.access_token; + let url = format!( + "{}/IPlayerService/GetOwnedGames/v1/?key={}&steamid={}&include_appinfo=true&include_played_free_games=true", + STEAM_API_BASE, api_key, steam_id + ); + + let body = match http_get(&url) { + Ok(b) => b, + Err(e) => return return_error("HTTP_ERROR", &e, true), + }; + + let resp: SteamOwnedGamesResponse = match serde_json::from_str(&body) { + Ok(r) => r, + Err(e) => { + return return_error("INVALID_RESPONSE", &format!("Parse error: {}", e), false) + } + }; + + let games = resp.response.games.unwrap_or_default(); + + let mut records: Vec = Vec::new(); + + for game in games { + let appid_str = game.appid.to_string(); + + // 1. Create actor.game record (ownership) + // HappyView will resolve game reference and add attestation signature + let game_record = serde_json::json!({ + "$type": "games.gamesgamesgamesgames.actor.game", + "game": { + "platform": "steam", + "externalId": &appid_str, + }, + "platform": "steam", + "createdAt": chrono_now(), + }); + + records.push(SyncRecord { + collection: "games.gamesgamesgamesgames.actor.game".into(), + record: game_record, + dedup_key: Some(format!("steam:game:{}", game.appid)), + sign: true, + }); + + // 2. Create actor.stats record (playtime) + // HappyView will add attestation signature + if let Some(playtime) = game.playtime_forever { + if playtime > 0 { + let stats_record = serde_json::json!({ + "$type": "games.gamesgamesgamesgames.actor.stats", + "game": { + "platform": "steam", + "externalId": &appid_str, + }, + "source": "steam", + "playtime": playtime, + "createdAt": chrono_now(), + }); + + records.push(SyncRecord { + collection: "games.gamesgamesgamesgames.actor.stats".into(), + record: stats_record, + dedup_key: Some(format!("steam:stats:{}", game.appid)), + sign: true, + }); + } + } + } + + return_ok(&records) + } + + #[cfg(not(target_arch = "wasm32"))] + { + let _ = (ptr, len); + return_error("NOT_WASM", "Only runs in WASM", false) + } +} + +// ============================================================================ +// Utility Functions +// ============================================================================ + +fn urlencod(s: &str) -> String { + let mut result = String::new(); + for c in s.chars() { + match c { + 'a'..='z' | 'A'..='Z' | '0'..='9' | '-' | '_' | '.' | '~' => { + result.push(c); + } + _ => { + for b in c.to_string().as_bytes() { + result.push_str(&format!("%{:02X}", b)); + } + } + } + } + result +} + +fn chrono_now() -> String { + // Simple ISO 8601 timestamp - in real impl would use proper time + "2024-01-01T00:00:00Z".into() +} diff --git a/src/external_auth/mod.rs b/src/external_auth/mod.rs index 15b512d..f36de91 100644 --- a/src/external_auth/mod.rs +++ b/src/external_auth/mod.rs @@ -1,4 +1,7 @@ +mod pds_write; mod routes; +pub mod state; mod sync; +pub mod tokens; pub use routes::routes; diff --git a/src/external_auth/pds_write.rs b/src/external_auth/pds_write.rs new file mode 100644 index 0000000..ae43e20 --- /dev/null +++ b/src/external_auth/pds_write.rs @@ -0,0 +1,127 @@ +//! Write sync records to user's PDS. + +use serde_json::{Value, json}; + +use crate::AppState; +use crate::error::AppError; +use crate::plugin::sync::ProcessedRecord; +use crate::repo; + +/// Result of writing a record to PDS +#[derive(Debug)] +#[allow(dead_code)] +pub struct WriteResult { + pub uri: String, + pub cid: String, +} + +/// Write processed records to the user's PDS. +/// +/// Returns the number of successfully written records. +pub async fn write_records_to_pds( + state: &AppState, + user_did: &str, + records: Vec, +) -> Result, AppError> { + let session = repo::get_oauth_session(state, user_did).await?; + + let mut results = Vec::with_capacity(records.len()); + + for record in records { + // Generate rkey from dedup_key or create a timestamp-based one + let rkey = record + .dedup_key + .as_ref() + .map(|k| sanitize_rkey(k)) + .unwrap_or_else(generate_tid); + + // Build the putRecord request + let body = json!({ + "repo": user_did, + "collection": record.collection, + "rkey": rkey, + "record": record.record, + }); + + let resp = + repo::pds_post_json_raw(state, &session, "com.atproto.repo.putRecord", &body).await?; + + if resp.status().is_success() { + let bytes = resp + .bytes() + .await + .map_err(|e| AppError::Internal(format!("failed to read PDS response: {e}")))?; + + let pds_result: Value = serde_json::from_slice(&bytes) + .map_err(|e| AppError::Internal(format!("invalid PDS JSON: {e}")))?; + + if let (Some(uri), Some(cid)) = ( + pds_result.get("uri").and_then(|v| v.as_str()), + pds_result.get("cid").and_then(|v| v.as_str()), + ) { + results.push(WriteResult { + uri: uri.to_string(), + cid: cid.to_string(), + }); + } + } else { + let bytes = resp.bytes().await.unwrap_or_default(); + let body_str = String::from_utf8_lossy(&bytes); + tracing::warn!( + collection = %record.collection, + rkey = %rkey, + error = %body_str, + "Failed to write record to PDS" + ); + // Continue with other records even if one fails + } + } + + Ok(results) +} + +/// Sanitize a dedup_key to be a valid rkey. +/// rkey must be 1-512 chars, alphanumeric plus .-_:~ +fn sanitize_rkey(key: &str) -> String { + let sanitized: String = key + .chars() + .filter(|c| c.is_ascii_alphanumeric() || matches!(c, '.' | '-' | '_' | ':' | '~')) + .take(512) + .collect(); + + if sanitized.is_empty() { + generate_tid() + } else { + sanitized + } +} + +/// Generate a TID (timestamp-based ID) for use as rkey. +fn generate_tid() -> String { + use std::time::{SystemTime, UNIX_EPOCH}; + + let now = SystemTime::now() + .duration_since(UNIX_EPOCH) + .unwrap() + .as_micros(); + + // TID is base32-sortable encoding of microseconds since epoch + // Using a simplified version here + format!("{:0>13}", base32_encode(now as u64)) +} + +fn base32_encode(mut n: u64) -> String { + const ALPHABET: &[u8] = b"234567abcdefghijklmnopqrstuvwxyz"; + let mut result = String::new(); + + if n == 0 { + return "2".to_string(); + } + + while n > 0 { + result.insert(0, ALPHABET[(n % 32) as usize] as char); + n /= 32; + } + + result +} diff --git a/src/external_auth/routes.rs b/src/external_auth/routes.rs index 399c4df..86f59c2 100644 --- a/src/external_auth/routes.rs +++ b/src/external_auth/routes.rs @@ -5,9 +5,15 @@ use axum::{ routing::{get, post}, }; use serde::{Deserialize, Serialize}; +use std::collections::HashMap; +use std::sync::Arc; use crate::AppState; +use crate::auth::Claims; use crate::error::AppError; +use crate::external_auth::{pds_write, state, tokens}; +use crate::plugin::PluginExecutor; +use crate::plugin::sync::SyncProcessor; pub fn routes() -> Router { Router::new() @@ -48,11 +54,12 @@ struct AuthorizeQuery { } async fn authorize( - State(state): State, + State(app_state): State, Path(plugin_id): Path, Query(query): Query, + claims: Claims, ) -> Result, AppError> { - let _plugin = state + let _plugin = app_state .plugin_registry .get(&plugin_id) .await @@ -61,12 +68,46 @@ async fn authorize( // Generate state parameter for CSRF protection let state_param = uuid::Uuid::new_v4().to_string(); - // TODO: Store state in KV, call plugin's get_authorize_url() - // For now, return placeholder - let _ = query.redirect_uri; + // Store state -> user mapping for callback validation + state::store_state( + &app_state.db, + app_state.db_backend, + &state_param, + claims.did(), + &plugin_id, + &query.redirect_uri, + ) + .await + .map_err(|e| AppError::Internal(e.to_string()))?; + + // Get plugin config (empty for now, could come from DB) + let config = serde_json::Value::Null; + + // Load secrets from environment + let secrets = load_plugin_secrets(&plugin_id); + + // Create executor and instance + let executor = PluginExecutor::new( + app_state.wasm_runtime.clone(), + app_state.plugin_registry.clone(), + app_state.db.clone(), + app_state.db_backend, + app_state.http.clone(), + Arc::new(app_state.lexicons.clone()), + ); + + let mut instance = executor + .instantiate(&plugin_id, &state_param, secrets, config.clone()) + .await + .map_err(|e| AppError::Internal(e.to_string()))?; + + let authorize_url = instance + .call_get_authorize_url(&state_param, &query.redirect_uri, &config) + .await + .map_err(|e| AppError::Internal(e.to_string()))?; Ok(Json(serde_json::json!({ - "authorize_url": format!("https://example.com/oauth?state={}", state_param), + "authorize_url": authorize_url, "state": state_param }))) } @@ -80,35 +121,166 @@ struct CallbackQuery { } async fn callback( - State(_state): State, - Path(_plugin_id): Path, - Query(_query): Query, + State(app_state): State, + Path(plugin_id): Path, + Query(query): Query, ) -> Result { - // TODO: Validate state, call plugin's handle_callback(), store tokens + // Validate required parameters + let code = query.code.ok_or_else(|| { + AppError::BadRequest(query.error.unwrap_or_else(|| "Missing code".into())) + })?; + let state_param = query + .state + .ok_or_else(|| AppError::BadRequest("Missing state".into()))?; + + // Validate state and get user DID + redirect_uri + let stored_state = state::consume_state(&app_state.db, app_state.db_backend, &state_param) + .await + .map_err(|_| AppError::BadRequest("Invalid or expired state".into()))?; + + // Verify plugin_id matches + if stored_state.plugin_id != plugin_id { + return Err(AppError::BadRequest("Plugin ID mismatch".into())); + } + + let config = serde_json::Value::Null; + let secrets = load_plugin_secrets(&plugin_id); + + let executor = PluginExecutor::new( + app_state.wasm_runtime.clone(), + app_state.plugin_registry.clone(), + app_state.db.clone(), + app_state.db_backend, + app_state.http.clone(), + Arc::new(app_state.lexicons.clone()), + ); + + let mut instance = executor + .instantiate(&plugin_id, &stored_state.did, secrets, config.clone()) + .await + .map_err(|e| AppError::Internal(e.to_string()))?; + + let token_set = instance + .call_handle_callback(&code, &state_param, &config) + .await + .map_err(|e| AppError::Internal(e.to_string()))?; + + // Get profile to get the account_id + let profile = instance + .call_get_profile(&token_set.access_token, &config) + .await + .map_err(|e| AppError::Internal(e.to_string()))?; + + // Format expires_at as RFC3339 string + let expires_at = token_set.expires_at.map(|dt| dt.to_rfc3339()); - // For now, redirect to a placeholder - Ok(Redirect::to("/")) + // Store encrypted tokens + tokens::store_tokens( + &app_state.db, + app_state.db_backend, + app_state.config.token_encryption_key.as_ref(), + &stored_state.did, + &plugin_id, + &profile.account_id, + &token_set.access_token, + token_set.refresh_token.as_deref(), + Some(&token_set.token_type), + None, // scope not in TokenSet + expires_at.as_deref(), + ) + .await + .map_err(|e| AppError::Internal(e.to_string()))?; + + // Redirect to the original redirect_uri + Ok(Redirect::to(&stored_state.redirect_uri)) } async fn sync( - State(_state): State, - Path(_plugin_id): Path, + State(app_state): State, + Path(plugin_id): Path, + claims: Claims, ) -> Result, AppError> { - // TODO: Call plugin's sync_account(), process SyncRecords + let user_did = claims.did(); + + let config = serde_json::Value::Null; + let secrets = load_plugin_secrets(&plugin_id); + + let executor = PluginExecutor::new( + app_state.wasm_runtime.clone(), + app_state.plugin_registry.clone(), + app_state.db.clone(), + app_state.db_backend, + app_state.http.clone(), + Arc::new(app_state.lexicons.clone()), + ); + + let mut instance = executor + .instantiate(&plugin_id, user_did, secrets, config.clone()) + .await + .map_err(|e| AppError::Internal(e.to_string()))?; + + // Get decrypted access token from DB + let stored = tokens::get_tokens( + &app_state.db, + app_state.db_backend, + app_state.config.token_encryption_key.as_ref(), + user_did, + &plugin_id, + ) + .await + .map_err(|e| AppError::Internal(e.to_string()))?; + + let mut records = instance + .call_sync_account(&stored.access_token, &config) + .await + .map_err(|e| AppError::Internal(e.to_string()))?; + + // Resolve game references from database + crate::plugin::sync::resolve_game_references(&app_state.db, app_state.db_backend, &mut records) + .await; + + // Process records: sign those with sign=true + let signer = app_state.attestation_signer.as_deref(); + let processor = SyncProcessor::new(signer, user_did.to_string()); + let processed = processor + .process_records(records) + .map_err(|e| AppError::Internal(e.to_string()))?; + + let processed_count = processed.len(); + + // Write processed records to user's PDS + let write_results = pds_write::write_records_to_pds(&app_state, user_did, processed).await?; Ok(Json(serde_json::json!({ "status": "ok", - "synced": 0 + "processed": processed_count, + "written": write_results.len() }))) } async fn unlink( - State(_state): State, - Path(_plugin_id): Path, + State(app_state): State, + Path(plugin_id): Path, + claims: Claims, ) -> Result, AppError> { - // TODO: Delete tokens, delete accountLink record + let user_did = claims.did(); + + // Delete tokens + let deleted = tokens::delete_tokens(&app_state.db, app_state.db_backend, user_did, &plugin_id) + .await + .map_err(|e| AppError::Internal(e.to_string()))?; + + // TODO: Delete accountLink record from user's PDS Ok(Json(serde_json::json!({ - "status": "ok" + "status": "ok", + "was_linked": deleted }))) } + +fn load_plugin_secrets(plugin_id: &str) -> HashMap { + let prefix = format!("PLUGIN_{}_", plugin_id.to_uppercase()); + std::env::vars() + .filter_map(|(k, v)| k.strip_prefix(&prefix).map(|name| (name.to_string(), v))) + .collect() +} diff --git a/src/external_auth/state.rs b/src/external_auth/state.rs new file mode 100644 index 0000000..8507973 --- /dev/null +++ b/src/external_auth/state.rs @@ -0,0 +1,108 @@ +//! OAuth state management for external auth flows. +//! +//! Stores state -> (user_did, plugin_id, redirect_uri) mappings +//! to validate callbacks and associate external accounts with users. + +use crate::db::{DatabaseBackend, adapt_sql, now_rfc3339}; + +#[derive(Debug, thiserror::Error)] +pub enum StateError { + #[error("Database error: {0}")] + Database(#[from] sqlx::Error), + #[error("State not found or expired")] + NotFound, +} + +/// Stored OAuth state +#[derive(Debug, Clone)] +pub struct StoredState { + pub did: String, + pub plugin_id: String, + pub redirect_uri: String, +} + +/// Store OAuth state for an auth flow. +/// +/// State expires after 10 minutes. +pub async fn store_state( + db: &sqlx::AnyPool, + backend: DatabaseBackend, + state: &str, + did: &str, + plugin_id: &str, + redirect_uri: &str, +) -> Result<(), StateError> { + let now = now_rfc3339(); + + // Expire in 10 minutes + let expires_at = chrono::Utc::now() + chrono::Duration::minutes(10); + let expires_str = expires_at.to_rfc3339(); + + let sql = adapt_sql( + "INSERT INTO external_auth_state (state, did, plugin_id, redirect_uri, created_at, expires_at) VALUES (?, ?, ?, ?, ?, ?)", + backend, + ); + + sqlx::query(&sql) + .bind(state) + .bind(did) + .bind(plugin_id) + .bind(redirect_uri) + .bind(&now) + .bind(&expires_str) + .execute(db) + .await?; + + Ok(()) +} + +/// Retrieve and consume OAuth state. +/// +/// Returns the stored state if found and not expired, then deletes it. +pub async fn consume_state( + db: &sqlx::AnyPool, + backend: DatabaseBackend, + state: &str, +) -> Result { + let now = now_rfc3339(); + + // Get state if not expired + let sql = adapt_sql( + "SELECT did, plugin_id, redirect_uri FROM external_auth_state WHERE state = ? AND expires_at > ?", + backend, + ); + + let row: Option<(String, String, String)> = sqlx::query_as(&sql) + .bind(state) + .bind(&now) + .fetch_optional(db) + .await?; + + let (did, plugin_id, redirect_uri) = row.ok_or(StateError::NotFound)?; + + // Delete the state (one-time use) + let delete_sql = adapt_sql("DELETE FROM external_auth_state WHERE state = ?", backend); + sqlx::query(&delete_sql).bind(state).execute(db).await?; + + Ok(StoredState { + did, + plugin_id, + redirect_uri, + }) +} + +/// Clean up expired state entries. +pub async fn cleanup_expired( + db: &sqlx::AnyPool, + backend: DatabaseBackend, +) -> Result { + let now = now_rfc3339(); + + let sql = adapt_sql( + "DELETE FROM external_auth_state WHERE expires_at <= ?", + backend, + ); + let result = sqlx::query(&sql).bind(&now).execute(db).await?; + + Ok(result.rows_affected()) +} diff --git a/src/external_auth/tokens.rs b/src/external_auth/tokens.rs new file mode 100644 index 0000000..fbb5b62 --- /dev/null +++ b/src/external_auth/tokens.rs @@ -0,0 +1,198 @@ +//! External account token storage with encryption. + +use crate::db::{DatabaseBackend, adapt_sql, now_rfc3339}; +use crate::plugin::encryption::{EncryptionError, decrypt, encrypt}; + +/// Row type for token query results +type TokenRow = ( + String, + Vec, + Option>, + Option, + Option, + Option, +); + +#[derive(Debug, thiserror::Error)] +pub enum TokenError { + #[error("Database error: {0}")] + Database(#[from] sqlx::Error), + #[error("Encryption error: {0}")] + Encryption(#[from] EncryptionError), + #[error("Token encryption key not configured")] + KeyNotConfigured, + #[error("Token not found")] + NotFound, +} + +/// Stored external account token set +#[derive(Debug, Clone)] +pub struct StoredTokens { + pub account_id: String, + pub access_token: String, + pub refresh_token: Option, + pub token_type: Option, + pub scope: Option, + pub expires_at: Option, +} + +/// Store tokens for an external account link +#[allow(clippy::too_many_arguments)] +pub async fn store_tokens( + db: &sqlx::AnyPool, + backend: DatabaseBackend, + encryption_key: Option<&[u8; 32]>, + did: &str, + plugin_id: &str, + account_id: &str, + access_token: &str, + refresh_token: Option<&str>, + token_type: Option<&str>, + scope: Option<&str>, + expires_at: Option<&str>, +) -> Result<(), TokenError> { + let key = encryption_key.ok_or(TokenError::KeyNotConfigured)?; + + let encrypted_access = encrypt(key, access_token.as_bytes())?; + let encrypted_refresh = refresh_token + .map(|t| encrypt(key, t.as_bytes())) + .transpose()?; + + let id = uuid::Uuid::new_v4().to_string(); + let now = now_rfc3339(); + + let sql = adapt_sql( + "INSERT INTO external_account_tokens (id, did, plugin_id, account_id, access_token, refresh_token, token_type, scope, expires_at, created_at, updated_at) + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) + ON CONFLICT (did, plugin_id) + DO UPDATE SET account_id = excluded.account_id, access_token = excluded.access_token, refresh_token = excluded.refresh_token, token_type = excluded.token_type, scope = excluded.scope, expires_at = excluded.expires_at, updated_at = excluded.updated_at", + backend, + ); + + sqlx::query(&sql) + .bind(&id) + .bind(did) + .bind(plugin_id) + .bind(account_id) + .bind(&encrypted_access) + .bind(encrypted_refresh.as_deref()) + .bind(token_type) + .bind(scope) + .bind(expires_at) + .bind(&now) + .bind(&now) + .execute(db) + .await?; + + Ok(()) +} + +/// Retrieve decrypted tokens for an external account +pub async fn get_tokens( + db: &sqlx::AnyPool, + backend: DatabaseBackend, + encryption_key: Option<&[u8; 32]>, + did: &str, + plugin_id: &str, +) -> Result { + let key = encryption_key.ok_or(TokenError::KeyNotConfigured)?; + + let sql = adapt_sql( + "SELECT account_id, access_token, refresh_token, token_type, scope, expires_at FROM external_account_tokens WHERE did = ? AND plugin_id = ?", + backend, + ); + + let row: Option = sqlx::query_as(&sql) + .bind(did) + .bind(plugin_id) + .fetch_optional(db) + .await?; + + let (account_id, encrypted_access, encrypted_refresh, token_type, scope, expires_at) = + row.ok_or(TokenError::NotFound)?; + + let access_token = String::from_utf8(decrypt(key, &encrypted_access)?) + .map_err(|_| EncryptionError::DecryptionFailed)?; + + let refresh_token = encrypted_refresh + .map(|enc| { + decrypt(key, &enc).and_then(|dec| { + String::from_utf8(dec).map_err(|_| EncryptionError::DecryptionFailed) + }) + }) + .transpose()?; + + Ok(StoredTokens { + account_id, + access_token, + refresh_token, + token_type, + scope, + expires_at, + }) +} + +/// Delete tokens for an external account link +pub async fn delete_tokens( + db: &sqlx::AnyPool, + backend: DatabaseBackend, + did: &str, + plugin_id: &str, +) -> Result { + let sql = adapt_sql( + "DELETE FROM external_account_tokens WHERE did = ? AND plugin_id = ?", + backend, + ); + + let result = sqlx::query(&sql) + .bind(did) + .bind(plugin_id) + .execute(db) + .await?; + + Ok(result.rows_affected() > 0) +} + +/// Check if an external account is linked +pub async fn is_linked( + db: &sqlx::AnyPool, + backend: DatabaseBackend, + did: &str, + plugin_id: &str, +) -> Result { + let sql = adapt_sql( + "SELECT 1 FROM external_account_tokens WHERE did = ? AND plugin_id = ?", + backend, + ); + + let exists: Option<(i32,)> = sqlx::query_as(&sql) + .bind(did) + .bind(plugin_id) + .fetch_optional(db) + .await?; + + Ok(exists.is_some()) +} + +/// Get the external account ID for a linked account +pub async fn get_account_id( + db: &sqlx::AnyPool, + backend: DatabaseBackend, + did: &str, + plugin_id: &str, +) -> Result, TokenError> { + let sql = adapt_sql( + "SELECT account_id FROM external_account_tokens WHERE did = ? AND plugin_id = ?", + backend, + ); + + let row: Option<(String,)> = sqlx::query_as(&sql) + .bind(did) + .bind(plugin_id) + .fetch_optional(db) + .await?; + + Ok(row.map(|(id,)| id)) +} + +// Integration tests for token storage are in tests/e2e_external_auth.rs diff --git a/src/lib.rs b/src/lib.rs index 782313f..7a0ae7a 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -59,6 +59,8 @@ pub struct AppState { pub oauth: Arc, pub cookie_key: axum_extra::extract::cookie::Key, pub plugin_registry: Arc, + pub wasm_runtime: Arc, + pub attestation_signer: Option>, } impl axum::extract::FromRef for axum_extra::extract::cookie::Key { diff --git a/src/lua/atproto_api.rs b/src/lua/atproto_api.rs index c5ef8bc..757fd53 100644 --- a/src/lua/atproto_api.rs +++ b/src/lua/atproto_api.rs @@ -289,6 +289,10 @@ mod tests { b"test-secret-for-tests-only-not-production", ), plugin_registry: std::sync::Arc::new(crate::plugin::PluginRegistry::new()), + wasm_runtime: std::sync::Arc::new( + crate::plugin::WasmRuntime::new().expect("wasm runtime"), + ), + attestation_signer: None, } } diff --git a/src/lua/db_api.rs b/src/lua/db_api.rs index 72c393d..6fad7b1 100644 --- a/src/lua/db_api.rs +++ b/src/lua/db_api.rs @@ -697,6 +697,10 @@ mod tests { b"test-secret-for-tests-only-not-production", ), plugin_registry: std::sync::Arc::new(crate::plugin::PluginRegistry::new()), + wasm_runtime: std::sync::Arc::new( + crate::plugin::WasmRuntime::new().expect("wasm runtime"), + ), + attestation_signer: None, } } diff --git a/src/lua/execute.rs b/src/lua/execute.rs index dfaa697..d15f091 100644 --- a/src/lua/execute.rs +++ b/src/lua/execute.rs @@ -1031,6 +1031,10 @@ mod tests { b"test-secret-for-tests-only-not-production", ), plugin_registry: std::sync::Arc::new(crate::plugin::PluginRegistry::new()), + wasm_runtime: std::sync::Arc::new( + crate::plugin::WasmRuntime::new().expect("wasm runtime"), + ), + attestation_signer: None, } } diff --git a/src/lua/http_api.rs b/src/lua/http_api.rs index bfc0b3a..6ed1464 100644 --- a/src/lua/http_api.rs +++ b/src/lua/http_api.rs @@ -171,6 +171,10 @@ mod tests { b"test-secret-for-tests-only-not-production", ), plugin_registry: std::sync::Arc::new(crate::plugin::PluginRegistry::new()), + wasm_runtime: std::sync::Arc::new( + crate::plugin::WasmRuntime::new().expect("wasm runtime"), + ), + attestation_signer: None, } } diff --git a/src/main.rs b/src/main.rs index b65e816..d019fa7 100644 --- a/src/main.rs +++ b/src/main.rs @@ -176,6 +176,26 @@ async fn main() { // Initialize plugin registry let plugin_registry = Arc::new(happyview::plugin::PluginRegistry::new()); + // Initialize WASM runtime + let wasm_runtime = + Arc::new(happyview::plugin::WasmRuntime::new().expect("Failed to create WASM runtime")); + + // Initialize attestation signer (optional) + let attestation_signer = match happyview::plugin::attestation::load_from_env() { + Ok(Some(signer)) => { + tracing::info!("Attestation signing enabled"); + Some(Arc::new(signer)) + } + Ok(None) => { + tracing::info!("Attestation signing disabled (no ATTESTATION_PRIVATE_KEY)"); + None + } + Err(e) => { + tracing::error!(error = %e, "Failed to load attestation signer"); + None + } + }; + // Load plugins from PLUGIN_URLS env var if let Ok(urls) = std::env::var("PLUGIN_URLS") { for (id, url, sha256) in happyview::plugin::loader::parse_plugin_urls(&urls) { @@ -319,6 +339,8 @@ async fn main() { oauth: Arc::new(oauth_client), cookie_key, plugin_registry, + wasm_runtime, + attestation_signer, }; // Sync initial collections to Tap on startup. diff --git a/src/plugin/attestation.rs b/src/plugin/attestation.rs new file mode 100644 index 0000000..883e611 --- /dev/null +++ b/src/plugin/attestation.rs @@ -0,0 +1,331 @@ +//! Attestation signing for plugin records. +//! +//! Implements the ATProtocol attestation spec: +//! - Computes CID with $sig metadata for replay protection +//! - Signs using ECDSA (P-256 or K-256) +//! - Adds inline signatures to records + +use cid::Cid; +use k256::ecdsa::{Signature, SigningKey, signature::Signer}; +use serde_json::{Map, Value}; +use sha2::{Digest, Sha256}; +use std::sync::Arc; + +// Multihash code for SHA2-256 +const SHA2_256_CODE: u64 = 0x12; +// DAG-CBOR codec +const DAG_CBOR_CODEC: u64 = 0x71; + +/// Attestation signer for HappyView +pub struct AttestationSigner { + /// The signing key (K-256/secp256k1) + signing_key: SigningKey, + /// The key identifier (e.g., "did:web:happyview.example#attestation") + key_id: String, + /// The signature type identifier + sig_type: String, +} + +#[derive(Debug, thiserror::Error)] +pub enum AttestationError { + #[error("Failed to encode record: {0}")] + Encoding(String), + #[error("Failed to sign: {0}")] + Signing(String), + #[error("Invalid key: {0}")] + InvalidKey(String), + #[error("Record missing required field: {0}")] + MissingField(String), +} + +impl AttestationSigner { + /// Create a new signer from a hex-encoded private key + pub fn from_hex( + private_key_hex: &str, + key_id: String, + sig_type: String, + ) -> Result { + let key_bytes = hex::decode(private_key_hex) + .map_err(|e| AttestationError::InvalidKey(format!("invalid hex: {}", e)))?; + + let signing_key = SigningKey::from_bytes((&key_bytes[..]).into()) + .map_err(|e| AttestationError::InvalidKey(format!("invalid key: {}", e)))?; + + Ok(Self { + signing_key, + key_id, + sig_type, + }) + } + + /// Create a new signer with a test key (for testing only) + #[cfg(test)] + pub fn for_testing(key_id: String, sig_type: String) -> Self { + // Fixed test key (32 bytes of 0x01) - DO NOT USE IN PRODUCTION + let test_key_bytes = [0x01u8; 32]; + let signing_key = + SigningKey::from_bytes((&test_key_bytes[..]).into()).expect("valid test key"); + Self { + signing_key, + key_id, + sig_type, + } + } + + /// Get the public key in compressed format (for verification) + pub fn public_key_bytes(&self) -> Vec { + use k256::ecdsa::VerifyingKey; + let verifying_key = VerifyingKey::from(&self.signing_key); + verifying_key.to_encoded_point(true).as_bytes().to_vec() + } + + /// Sign a record and add the signature to the signatures array. + /// + /// # Arguments + /// * `record` - The record to sign (will be modified to add signature) + /// * `repository_did` - The DID of the repository (for replay protection) + /// + /// # Returns + /// The CID of the signed content + pub fn sign_record( + &self, + record: &mut Value, + repository_did: &str, + ) -> Result { + let obj = record + .as_object_mut() + .ok_or_else(|| AttestationError::Encoding("record must be an object".into()))?; + + // Remove existing signatures for CID computation + let existing_signatures = obj.remove("signatures"); + + // Inject $sig metadata for CID computation + let sig_metadata = serde_json::json!({ + "$type": &self.sig_type, + "repository": repository_did, + }); + obj.insert("$sig".to_string(), sig_metadata); + + // Encode to CBOR (DAG-CBOR canonical form) + let cbor_bytes = self.encode_dag_cbor(obj)?; + + // Compute CID (sha2-256, dag-cbor codec) + let cid = self.compute_cid(&cbor_bytes); + + // Remove $sig (it's only for CID computation) + obj.remove("$sig"); + + // Sign the CID bytes + let signature = self.sign_cid(&cid)?; + + // Create inline signature object + let inline_sig = serde_json::json!({ + "$type": &self.sig_type, + "key": &self.key_id, + "signature": { + "$bytes": base64::Engine::encode(&base64::engine::general_purpose::STANDARD, &signature) + } + }); + + // Add to signatures array + let signatures = obj + .entry("signatures") + .or_insert_with(|| Value::Array(vec![])); + + if let Value::Array(arr) = signatures { + // Restore any existing signatures + if let Some(Value::Array(existing)) = existing_signatures { + for sig in existing { + arr.push(sig); + } + } + arr.push(inline_sig); + } + + Ok(cid) + } + + /// Encode a JSON object to DAG-CBOR canonical form + fn encode_dag_cbor(&self, obj: &Map) -> Result, AttestationError> { + // Convert to ciborium Value and encode + // DAG-CBOR requires deterministic key ordering (lexicographic) + let cbor_value = json_to_cbor(&Value::Object(obj.clone())); + + let mut buf = Vec::new(); + ciborium::into_writer(&cbor_value, &mut buf) + .map_err(|e| AttestationError::Encoding(format!("CBOR encoding failed: {}", e)))?; + + Ok(buf) + } + + /// Compute CID from CBOR bytes (sha2-256, dag-cbor codec) + fn compute_cid(&self, cbor_bytes: &[u8]) -> Cid { + // SHA2-256 hash + let digest = Sha256::digest(cbor_bytes); + + // Create multihash: varint(code) || varint(size) || digest + let mut multihash_bytes = Vec::new(); + // SHA2-256 code (0x12) + multihash_bytes.push(SHA2_256_CODE as u8); + // Digest size (32 bytes) + multihash_bytes.push(32u8); + // The digest + multihash_bytes.extend_from_slice(&digest); + + let multihash = + cid::multihash::Multihash::<64>::from_bytes(&multihash_bytes).expect("valid multihash"); + + // CID v1 with dag-cbor codec + Cid::new_v1(DAG_CBOR_CODEC, multihash) + } + + /// Sign a CID using ECDSA with low-S normalization + fn sign_cid(&self, cid: &Cid) -> Result, AttestationError> { + let cid_bytes = cid.to_bytes(); + + // Sign using k256 ECDSA (automatically uses low-S) + let signature: Signature = self.signing_key.sign(&cid_bytes); + + Ok(signature.to_bytes().to_vec()) + } +} + +/// Convert JSON Value to ciborium Value with deterministic ordering +fn json_to_cbor(value: &Value) -> ciborium::Value { + match value { + Value::Null => ciborium::Value::Null, + Value::Bool(b) => ciborium::Value::Bool(*b), + Value::Number(n) => { + if let Some(i) = n.as_i64() { + ciborium::Value::Integer(i.into()) + } else if let Some(u) = n.as_u64() { + ciborium::Value::Integer(u.into()) + } else if let Some(f) = n.as_f64() { + ciborium::Value::Float(f) + } else { + ciborium::Value::Null + } + } + Value::String(s) => { + // Check for $bytes encoding (base64) + ciborium::Value::Text(s.clone()) + } + Value::Array(arr) => ciborium::Value::Array(arr.iter().map(json_to_cbor).collect()), + Value::Object(obj) => { + // Handle special $bytes encoding for binary data + if obj.len() == 1 + && let Some(Value::String(b64)) = obj.get("$bytes") + && let Ok(bytes) = + base64::Engine::decode(&base64::engine::general_purpose::STANDARD, b64) + { + return ciborium::Value::Bytes(bytes); + } + + // Sort keys lexicographically for deterministic encoding + let mut pairs: Vec<_> = obj + .iter() + .map(|(k, v)| (ciborium::Value::Text(k.clone()), json_to_cbor(v))) + .collect(); + pairs.sort_by(|a, b| { + if let (ciborium::Value::Text(ka), ciborium::Value::Text(kb)) = (&a.0, &b.0) { + ka.cmp(kb) + } else { + std::cmp::Ordering::Equal + } + }); + + ciborium::Value::Map(pairs) + } + } +} + +/// Shared attestation signer for the application +pub type SharedAttestationSigner = Arc; + +/// Load attestation signer from environment variables +pub fn load_from_env() -> Result, AttestationError> { + let private_key = match std::env::var("ATTESTATION_PRIVATE_KEY") { + Ok(k) => k, + Err(_) => return Ok(None), // No key configured, attestation disabled + }; + + let key_id = std::env::var("ATTESTATION_KEY_ID") + .unwrap_or_else(|_| "did:web:localhost#attestation".to_string()); + + let sig_type = std::env::var("ATTESTATION_SIG_TYPE") + .unwrap_or_else(|_| "games.gamesgamesgamesgames.attestation".to_string()); + + Ok(Some(AttestationSigner::from_hex( + &private_key, + key_id, + sig_type, + )?)) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_sign_record() { + let signer = AttestationSigner::for_testing( + "did:web:test.example#signing".to_string(), + "test.signature".to_string(), + ); + + let mut record = serde_json::json!({ + "$type": "games.gamesgamesgamesgames.actor.game", + "game": {"platform": "steam", "externalId": "440"}, + "platform": "steam", + "createdAt": "2024-01-01T00:00:00Z" + }); + + let cid = signer + .sign_record(&mut record, "did:plc:testuser") + .expect("signing should succeed"); + + // Verify signature was added + let signatures = record["signatures"].as_array().expect("signatures array"); + assert_eq!(signatures.len(), 1); + + let sig = &signatures[0]; + assert_eq!(sig["$type"], "test.signature"); + assert_eq!(sig["key"], "did:web:test.example#signing"); + assert!(sig["signature"]["$bytes"].is_string()); + + // CID should be valid + assert!(!cid.to_bytes().is_empty()); + } + + #[test] + fn test_deterministic_cid() { + let signer = AttestationSigner::for_testing( + "did:web:test.example#signing".to_string(), + "test.signature".to_string(), + ); + + // Same record should produce same CID (before signature) + let record1 = serde_json::json!({ + "a": 1, + "b": 2, + "c": {"nested": true} + }); + + let record2 = serde_json::json!({ + "c": {"nested": true}, + "a": 1, + "b": 2 + }); + + let mut r1 = record1.clone(); + let mut r2 = record2.clone(); + + let cid1 = signer.sign_record(&mut r1, "did:plc:test").unwrap(); + let cid2 = signer.sign_record(&mut r2, "did:plc:test").unwrap(); + + // Different signatures (random nonce in ECDSA) but... + // Actually the CIDs should be the same since they're computed before signing + // and the key ordering is normalized + assert_eq!(cid1, cid2); + } +} diff --git a/src/plugin/executor.rs b/src/plugin/executor.rs new file mode 100644 index 0000000..5a4d46a --- /dev/null +++ b/src/plugin/executor.rs @@ -0,0 +1,483 @@ +// src/plugin/executor.rs + +use crate::db::DatabaseBackend; +use crate::lexicon::LexiconRegistry; +use crate::plugin::host::{PluginState, register_host_functions}; +use crate::plugin::memory::{ + PluginEnvelopeError, PluginResponse, dealloc_guest, read_from_guest, write_to_guest, +}; +use crate::plugin::runtime::{DEFAULT_FUEL, WasmRuntime}; +use crate::plugin::{ExternalProfile, PluginInfo, PluginRegistry, SyncRecord, TokenSet}; +use std::collections::HashMap; +use std::sync::Arc; +use thiserror::Error; +use wasmtime::{Instance, Linker, Memory, Store, TypedFunc}; + +#[derive(Debug, Error)] +pub enum ExecutionError { + #[error("Plugin not found: {0}")] + PluginNotFound(String), + + #[error("WASM instantiation failed: {0}")] + Instantiation(#[source] anyhow::Error), + + #[error("Memory allocation failed")] + MemoryAllocation, + + #[error("Plugin function trapped: {0}")] + Trap(#[source] wasmtime::Error), + + #[error("Invalid response from plugin: {0}")] + InvalidResponse(String), + + #[error("Plugin returned error: {code} - {message}")] + PluginError { + code: String, + message: String, + retryable: bool, + }, + + #[error("Resource limit exceeded: {0}")] + ResourceLimit(String), + + #[error("Timeout (fuel exhausted)")] + Timeout, + + #[error("Missing export: {0}")] + MissingExport(String), +} + +impl From for ExecutionError { + fn from(e: PluginEnvelopeError) -> Self { + ExecutionError::PluginError { + code: e.code, + message: e.message, + retryable: e.retryable, + } + } +} + +/// Single-use wrapper around a WASM instance +#[allow(dead_code)] +pub struct PluginInstance { + pub(crate) store: Store, + pub(crate) instance: Instance, + pub(crate) memory: Memory, + pub(crate) alloc: TypedFunc, + pub(crate) dealloc: TypedFunc<(u32, u32), ()>, +} + +impl PluginInstance { + /// Call plugin_info() - no input required + pub async fn call_plugin_info(&mut self) -> Result { + let func = self + .instance + .get_typed_func::<(), i64>(&mut self.store, "plugin_info") + .map_err(|_| ExecutionError::MissingExport("plugin_info".into()))?; + + self.store + .set_fuel(DEFAULT_FUEL) + .map_err(ExecutionError::Trap)?; + + let packed = func + .call_async(&mut self.store, ()) + .await + .map_err(Self::classify_error)?; + + // Unpack i64: upper 32 bits = ptr, lower 32 bits = len + let ptr = (packed >> 32) as u32; + let len = (packed & 0xFFFFFFFF) as u32; + + let bytes = + read_from_guest(&self.store, ptr, len).map_err(|_| ExecutionError::MemoryAllocation)?; + + dealloc_guest(&mut self.store, ptr, len) + .await + .map_err(|_| ExecutionError::MemoryAllocation)?; + + let response: PluginResponse = serde_json::from_slice(&bytes) + .map_err(|e| ExecutionError::InvalidResponse(e.to_string()))?; + + response.into_result().map_err(ExecutionError::from) + } + + /// Call get_authorize_url(state, redirect_uri, config) + pub async fn call_get_authorize_url( + &mut self, + state: &str, + redirect_uri: &str, + config: &serde_json::Value, + ) -> Result { + let input = serde_json::json!({ + "state": state, + "redirect_uri": redirect_uri, + "config": config + }); + self.call_plugin_function("get_authorize_url", &input).await + } + + /// Call handle_callback(code, state, config) + pub async fn call_handle_callback( + &mut self, + code: &str, + state: &str, + config: &serde_json::Value, + ) -> Result { + let input = serde_json::json!({ + "code": code, + "state": state, + "config": config + }); + self.call_plugin_function("handle_callback", &input).await + } + + /// Call refresh_tokens(refresh_token, config) + pub async fn call_refresh_tokens( + &mut self, + refresh_token: &str, + config: &serde_json::Value, + ) -> Result { + let input = serde_json::json!({ + "refresh_token": refresh_token, + "config": config + }); + self.call_plugin_function("refresh_tokens", &input).await + } + + /// Call get_profile(access_token, config) + pub async fn call_get_profile( + &mut self, + access_token: &str, + config: &serde_json::Value, + ) -> Result { + let input = serde_json::json!({ + "access_token": access_token, + "config": config + }); + self.call_plugin_function("get_profile", &input).await + } + + /// Call sync_account(access_token, config) + pub async fn call_sync_account( + &mut self, + access_token: &str, + config: &serde_json::Value, + ) -> Result, ExecutionError> { + let input = serde_json::json!({ + "access_token": access_token, + "config": config + }); + self.call_plugin_function("sync_account", &input).await + } + + /// Generic helper for plugin functions with input and typed output + async fn call_plugin_function( + &mut self, + name: &str, + input: &serde_json::Value, + ) -> Result { + let input_bytes = serde_json::to_vec(input) + .map_err(|e| ExecutionError::InvalidResponse(e.to_string()))?; + + let func = self + .instance + .get_typed_func::<(u32, u32), i64>(&mut self.store, name) + .map_err(|_| ExecutionError::MissingExport(name.into()))?; + + self.store + .set_fuel(DEFAULT_FUEL) + .map_err(ExecutionError::Trap)?; + + let (input_ptr, input_len) = write_to_guest(&mut self.store, &input_bytes) + .await + .map_err(|_| ExecutionError::MemoryAllocation)?; + + let packed = func + .call_async(&mut self.store, (input_ptr, input_len)) + .await + .map_err(Self::classify_error)?; + + // Unpack i64: upper 32 bits = ptr, lower 32 bits = len + let ptr = (packed >> 32) as u32; + let len = (packed & 0xFFFFFFFF) as u32; + + let bytes = + read_from_guest(&self.store, ptr, len).map_err(|_| ExecutionError::MemoryAllocation)?; + + dealloc_guest(&mut self.store, ptr, len) + .await + .map_err(|_| ExecutionError::MemoryAllocation)?; + + let response: PluginResponse = serde_json::from_slice(&bytes) + .map_err(|e| ExecutionError::InvalidResponse(e.to_string()))?; + + response.into_result().map_err(ExecutionError::from) + } + + /// Classify a wasmtime error as Timeout or Trap + fn classify_error(e: wasmtime::Error) -> ExecutionError { + if e.to_string().contains("fuel") { + ExecutionError::Timeout + } else { + ExecutionError::Trap(e) + } + } +} + +/// Factory for creating plugin instances +pub struct PluginExecutor { + runtime: Arc, + registry: Arc, + db: sqlx::AnyPool, + db_backend: DatabaseBackend, + http_client: reqwest::Client, + lexicons: Arc, +} + +impl PluginExecutor { + pub fn new( + runtime: Arc, + registry: Arc, + db: sqlx::AnyPool, + db_backend: DatabaseBackend, + http_client: reqwest::Client, + lexicons: Arc, + ) -> Self { + Self { + runtime, + registry, + db, + db_backend, + http_client, + lexicons, + } + } + + /// Instantiate a plugin with the given scope + pub async fn instantiate( + &self, + plugin_id: &str, + scope: &str, + secrets: HashMap, + config: serde_json::Value, + ) -> Result { + // Get plugin from registry + let plugin = self + .registry + .get(plugin_id) + .await + .ok_or_else(|| ExecutionError::PluginNotFound(plugin_id.to_string()))?; + + // Compile module + let module = self + .runtime + .compile(&plugin.wasm_bytes) + .map_err(ExecutionError::Instantiation)?; + + // Create linker with host functions + let mut linker = Linker::new(self.runtime.engine()); + register_host_functions(&mut linker).map_err(ExecutionError::Instantiation)?; + + // Create store with initial state (memory/alloc/dealloc set to None) + // Note: db is Option in PluginState + let state = PluginState { + plugin_id: plugin_id.to_string(), + scope: scope.to_string(), + secrets, + config, + db: Some(self.db.clone()), + db_backend: self.db_backend, + http_client: self.http_client.clone(), + lexicons: self.lexicons.clone(), + usage: Default::default(), + memory: None, + alloc: None, + dealloc: None, + }; + + let mut store = Store::new(self.runtime.engine(), state); + store + .set_fuel(DEFAULT_FUEL) + .map_err(ExecutionError::Instantiation)?; + + // Instantiate module + let instance = linker + .instantiate_async(&mut store, &module) + .await + .map_err(ExecutionError::Instantiation)?; + + // Get memory export + let memory = instance + .get_memory(&mut store, "memory") + .ok_or_else(|| ExecutionError::MissingExport("memory".into()))?; + + // Get alloc/dealloc exports + let alloc = instance + .get_typed_func::(&mut store, "alloc") + .map_err(|_| ExecutionError::MissingExport("alloc".into()))?; + let dealloc = instance + .get_typed_func::<(u32, u32), ()>(&mut store, "dealloc") + .map_err(|_| ExecutionError::MissingExport("dealloc".into()))?; + + // Store memory/alloc/dealloc in state + store.data_mut().memory = Some(memory); + store.data_mut().alloc = Some(alloc.clone()); + store.data_mut().dealloc = Some(dealloc.clone()); + + Ok(PluginInstance { + store, + instance, + memory, + alloc, + dealloc, + }) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_execution_error_plugin_not_found() { + let err = ExecutionError::PluginNotFound("steam".into()); + assert!(err.to_string().contains("steam")); + assert!(err.to_string().contains("not found")); + } + + #[test] + fn test_execution_error_timeout() { + let err = ExecutionError::Timeout; + assert!( + err.to_string().to_lowercase().contains("timeout") || err.to_string().contains("fuel") + ); + } + + #[test] + fn test_plugin_error_conversion() { + let plugin_err = PluginEnvelopeError { + code: "AUTH_FAILED".into(), + message: "Bad token".into(), + retryable: true, + }; + let exec_err: ExecutionError = plugin_err.into(); + match exec_err { + ExecutionError::PluginError { + code, + message, + retryable, + } => { + assert_eq!(code, "AUTH_FAILED"); + assert_eq!(message, "Bad token"); + assert!(retryable); + } + _ => panic!("Wrong error variant"), + } + } + + #[test] + fn test_all_error_variants_have_display() { + let errors: Vec = vec![ + ExecutionError::PluginNotFound("test".into()), + ExecutionError::MemoryAllocation, + ExecutionError::InvalidResponse("bad json".into()), + ExecutionError::ResourceLimit("too many requests".into()), + ExecutionError::Timeout, + ExecutionError::MissingExport("plugin_info".into()), + ]; + for err in errors { + assert!(!err.to_string().is_empty()); + } + } + + #[test] + fn test_plugin_executor_new_signature() { + // Verify PluginExecutor::new exists with expected signature (compile-time check) + fn _check_signature( + _runtime: std::sync::Arc, + _registry: std::sync::Arc, + _db: sqlx::AnyPool, + _db_backend: crate::db::DatabaseBackend, + _http_client: reqwest::Client, + _lexicons: std::sync::Arc, + ) -> PluginExecutor { + PluginExecutor::new( + _runtime, + _registry, + _db, + _db_backend, + _http_client, + _lexicons, + ) + } + } + + #[test] + fn test_plugin_instance_struct_exists() { + // Verify PluginInstance struct has expected fields (compile-time check) + fn _check_fields(instance: PluginInstance) { + let _ = instance.store; + let _ = instance.instance; + let _ = instance.memory; + let _ = instance.alloc; + let _ = instance.dealloc; + } + } + + #[test] + fn test_plugin_instance_has_expected_methods() { + // Compile-time check that methods exist with expected signatures + fn _check_call_plugin_info<'a>( + inst: &'a mut PluginInstance, + ) -> impl std::future::Future> + 'a + { + inst.call_plugin_info() + } + + fn _check_call_get_authorize_url<'a>( + inst: &'a mut PluginInstance, + state: &'a str, + redirect_uri: &'a str, + config: &'a serde_json::Value, + ) -> impl std::future::Future> + 'a { + inst.call_get_authorize_url(state, redirect_uri, config) + } + + fn _check_call_handle_callback<'a>( + inst: &'a mut PluginInstance, + code: &'a str, + state: &'a str, + config: &'a serde_json::Value, + ) -> impl std::future::Future> + 'a + { + inst.call_handle_callback(code, state, config) + } + + fn _check_call_refresh_tokens<'a>( + inst: &'a mut PluginInstance, + refresh_token: &'a str, + config: &'a serde_json::Value, + ) -> impl std::future::Future> + 'a + { + inst.call_refresh_tokens(refresh_token, config) + } + + fn _check_call_get_profile<'a>( + inst: &'a mut PluginInstance, + access_token: &'a str, + config: &'a serde_json::Value, + ) -> impl std::future::Future> + 'a + { + inst.call_get_profile(access_token, config) + } + + fn _check_call_sync_account<'a>( + inst: &'a mut PluginInstance, + access_token: &'a str, + config: &'a serde_json::Value, + ) -> impl std::future::Future, ExecutionError>> + 'a + { + inst.call_sync_account(access_token, config) + } + } +} diff --git a/src/plugin/host/bindings.rs b/src/plugin/host/bindings.rs new file mode 100644 index 0000000..36e1303 --- /dev/null +++ b/src/plugin/host/bindings.rs @@ -0,0 +1,438 @@ +use std::collections::HashMap; +use std::sync::Arc; +use wasmtime::{Linker, Memory, TypedFunc}; + +/// State stored in wasmtime's Store during plugin execution +pub struct PluginState { + pub plugin_id: String, + pub scope: String, + pub secrets: HashMap, + pub config: serde_json::Value, + pub db: Option, + pub db_backend: crate::db::DatabaseBackend, + pub http_client: reqwest::Client, + pub lexicons: Arc, + pub usage: super::ResourceUsage, + pub memory: Option, + pub alloc: Option>, + pub dealloc: Option>, +} + +/// Check that a memory access is within bounds +fn check_bounds(offset: usize, length: usize, mem_size: usize) -> Result<(usize, usize), ()> { + if length == 0 { + return Ok((offset, offset)); + } + let end = offset.checked_add(length).ok_or(())?; + if end > mem_size { + return Err(()); + } + Ok((offset, end)) +} + +/// Register all host functions with the linker +pub fn register_host_functions(linker: &mut Linker) -> Result<(), wasmtime::Error> { + // Sync functions + linker.func_wrap("env", "host_log", host_log)?; + linker.func_wrap("env", "host_get_secret", host_get_secret)?; + + // Async functions - HTTP + linker.func_wrap_async( + "env", + "host_http_request", + |mut caller: wasmtime::Caller<'_, PluginState>, (req_ptr, req_len): (i32, i32)| { + Box::new(async move { host_http_request_impl(&mut caller, req_ptr, req_len).await }) + }, + )?; + + // Async functions - KV + linker.func_wrap_async( + "env", + "host_kv_get", + |mut caller: wasmtime::Caller<'_, PluginState>, (key_ptr, key_len): (i32, i32)| { + Box::new(async move { host_kv_get_impl(&mut caller, key_ptr, key_len).await }) + }, + )?; + + linker.func_wrap_async( + "env", + "host_kv_set", + |mut caller: wasmtime::Caller<'_, PluginState>, + (key_ptr, key_len, val_ptr, val_len, ttl): (i32, i32, i32, i32, i32)| { + Box::new(async move { + host_kv_set_impl(&mut caller, key_ptr, key_len, val_ptr, val_len, ttl).await + }) + }, + )?; + + linker.func_wrap_async( + "env", + "host_kv_delete", + |mut caller: wasmtime::Caller<'_, PluginState>, (key_ptr, key_len): (i32, i32)| { + Box::new(async move { host_kv_delete_impl(&mut caller, key_ptr, key_len).await }) + }, + )?; + + // Async functions - Record lookup + linker.func_wrap_async( + "env", + "host_lookup_record", + |mut caller: wasmtime::Caller<'_, PluginState>, (req_ptr, req_len): (i32, i32)| { + Box::new(async move { host_lookup_record_impl(&mut caller, req_ptr, req_len).await }) + }, + )?; + + Ok(()) +} + +/// Read a string from guest memory +fn read_guest_string( + caller: &wasmtime::Caller<'_, PluginState>, + ptr: i32, + len: i32, +) -> Option { + let memory = caller.data().memory?; + let mem_data = memory.data(caller); + let (start, end) = check_bounds(ptr as usize, len as usize, mem_data.len()).ok()?; + std::str::from_utf8(&mem_data[start..end]) + .ok() + .map(String::from) +} + +/// Read raw bytes from guest memory +fn read_guest_bytes( + caller: &wasmtime::Caller<'_, PluginState>, + ptr: i32, + len: i32, +) -> Option> { + let memory = caller.data().memory?; + let mem_data = memory.data(caller); + let (start, end) = check_bounds(ptr as usize, len as usize, mem_data.len()).ok()?; + Some(mem_data[start..end].to_vec()) +} + +/// Write response data to guest memory, returning packed (ptr << 32) | len +async fn write_guest_response(caller: &mut wasmtime::Caller<'_, PluginState>, data: &[u8]) -> i64 { + let memory = match caller.data().memory { + Some(m) => m, + None => return 0, + }; + let alloc = match &caller.data().alloc { + Some(a) => a.clone(), + None => return 0, + }; + + let len = data.len() as u32; + let ptr = match alloc.call_async(&mut *caller, len).await { + Ok(p) if p != 0 => p, + _ => return 0, + }; + + let mem_data = memory.data_mut(caller); + if check_bounds(ptr as usize, len as usize, mem_data.len()).is_err() { + return 0; + } + + mem_data[ptr as usize..(ptr as usize + len as usize)].copy_from_slice(data); + ((ptr as i64) << 32) | (len as i64) +} + +/// Host function: log a message from the plugin +fn host_log( + caller: wasmtime::Caller<'_, PluginState>, + level_ptr: i32, + level_len: i32, + msg_ptr: i32, + msg_len: i32, +) { + let memory = match caller.data().memory { + Some(m) => m, + None => return, + }; + + let mem_data = memory.data(&caller); + let mem_size = mem_data.len(); + + let (level_start, level_end) = + match check_bounds(level_ptr as usize, level_len as usize, mem_size) { + Ok(bounds) => bounds, + Err(_) => return, + }; + + let (msg_start, msg_end) = match check_bounds(msg_ptr as usize, msg_len as usize, mem_size) { + Ok(bounds) => bounds, + Err(_) => return, + }; + + let level = std::str::from_utf8(&mem_data[level_start..level_end]).unwrap_or("info"); + let msg = std::str::from_utf8(&mem_data[msg_start..msg_end]).unwrap_or(""); + + let plugin_id = &caller.data().plugin_id; + let log_level: super::LogLevel = level.parse().unwrap_or_default(); + super::log(plugin_id, log_level, msg); +} + +/// Host function: get a secret value by name +/// Returns a packed i64: (ptr << 32) | len, or 0 on error +fn host_get_secret( + mut caller: wasmtime::Caller<'_, PluginState>, + name_ptr: i32, + name_len: i32, +) -> i64 { + let memory = match caller.data().memory { + Some(m) => m, + None => return 0, + }; + let alloc = match &caller.data().alloc { + Some(a) => a.clone(), + None => return 0, + }; + + let mem_data = memory.data(&caller); + let mem_size = mem_data.len(); + + let (name_start, name_end) = match check_bounds(name_ptr as usize, name_len as usize, mem_size) + { + Ok(bounds) => bounds, + Err(_) => return 0, + }; + + let name = match std::str::from_utf8(&mem_data[name_start..name_end]) { + Ok(s) => s, + Err(_) => return 0, + }; + + let value = match caller.data().secrets.get(name) { + Some(v) => v.clone(), + None => return 0, + }; + + let len = value.len() as u32; + let ptr = match alloc.call(&mut caller, len) { + Ok(p) if p != 0 => p, + _ => return 0, + }; + + let mem_data = memory.data_mut(&mut caller); + if check_bounds(ptr as usize, len as usize, mem_data.len()).is_err() { + return 0; + } + + mem_data[ptr as usize..(ptr as usize + len as usize)].copy_from_slice(value.as_bytes()); + + ((ptr as i64) << 32) | (len as i64) +} + +// ============================================================================ +// Async host function implementations +// ============================================================================ + +/// Build a HostContext from PluginState, requires db to be present +fn build_host_context(state: &PluginState) -> Option { + let db = state.db.clone()?; + Some(super::HostContext { + plugin_id: state.plugin_id.clone(), + scope: state.scope.clone(), + secrets: state.secrets.clone(), + config: state.config.clone(), + db, + db_backend: state.db_backend, + http_client: state.http_client.clone(), + lexicons: state.lexicons.clone(), + }) +} + +/// Host function: make an HTTP request +async fn host_http_request_impl( + caller: &mut wasmtime::Caller<'_, PluginState>, + req_ptr: i32, + req_len: i32, +) -> i64 { + let req_bytes = match read_guest_bytes(caller, req_ptr, req_len) { + Some(b) => b, + None => return 0, + }; + + let request: super::HttpRequest = match serde_json::from_slice(&req_bytes) { + Ok(r) => r, + Err(_) => return 0, + }; + + let ctx = match build_host_context(caller.data()) { + Some(c) => c, + None => return 0, + }; + + let result = { + let usage = &mut caller.data_mut().usage; + super::http_request(&ctx, usage, request).await + }; + + let response_bytes = match result { + Ok(resp) => serde_json::to_vec(&serde_json::json!({"ok": resp})).unwrap_or_default(), + Err(e) => serde_json::to_vec(&serde_json::json!({ + "error": {"code": "HTTP_ERROR", "message": e.to_string(), "retryable": false} + })) + .unwrap_or_default(), + }; + + write_guest_response(caller, &response_bytes).await +} + +/// Host function: get a value from KV store +async fn host_kv_get_impl( + caller: &mut wasmtime::Caller<'_, PluginState>, + key_ptr: i32, + key_len: i32, +) -> i64 { + let key = match read_guest_string(caller, key_ptr, key_len) { + Some(k) => k, + None => return 0, + }; + + let ctx = match build_host_context(caller.data()) { + Some(c) => c, + None => return 0, + }; + + let result = super::kv_get(&ctx, &key).await; + + let response_bytes = match result { + Ok(Some(value)) => { + serde_json::to_vec(&serde_json::json!({"ok": value})).unwrap_or_default() + } + Ok(None) => return 0, + Err(e) => serde_json::to_vec(&serde_json::json!({ + "error": {"code": "KV_ERROR", "message": e.to_string(), "retryable": false} + })) + .unwrap_or_default(), + }; + + write_guest_response(caller, &response_bytes).await +} + +/// Host function: set a value in KV store +async fn host_kv_set_impl( + caller: &mut wasmtime::Caller<'_, PluginState>, + key_ptr: i32, + key_len: i32, + val_ptr: i32, + val_len: i32, + ttl: i32, +) -> i32 { + let key = match read_guest_string(caller, key_ptr, key_len) { + Some(k) => k, + None => return -1, + }; + let value = match read_guest_bytes(caller, val_ptr, val_len) { + Some(v) => v, + None => return -1, + }; + + let ttl_secs = if ttl > 0 { Some(ttl as u32) } else { None }; + + let ctx = match build_host_context(caller.data()) { + Some(c) => c, + None => return -1, + }; + + let usage = &mut caller.data_mut().usage; + match super::kv_set(&ctx, usage, &key, value, ttl_secs).await { + Ok(()) => 0, + Err(_) => -1, + } +} + +/// Host function: delete a value from KV store +async fn host_kv_delete_impl( + caller: &mut wasmtime::Caller<'_, PluginState>, + key_ptr: i32, + key_len: i32, +) -> i32 { + let key = match read_guest_string(caller, key_ptr, key_len) { + Some(k) => k, + None => return -1, + }; + + let ctx = match build_host_context(caller.data()) { + Some(c) => c, + None => return -1, + }; + + match super::kv_delete(&ctx, &key).await { + Ok(()) => 0, + Err(_) => -1, + } +} + +/// Host function: look up an AT Protocol record +async fn host_lookup_record_impl( + caller: &mut wasmtime::Caller<'_, PluginState>, + req_ptr: i32, + req_len: i32, +) -> i64 { + let req_bytes = match read_guest_bytes(caller, req_ptr, req_len) { + Some(b) => b, + None => return 0, + }; + + let request: super::LookupRequest = match serde_json::from_slice(&req_bytes) { + Ok(r) => r, + Err(_) => return 0, + }; + + let ctx = match build_host_context(caller.data()) { + Some(c) => c, + None => return 0, + }; + + let result = super::lookup_record_by_request(&ctx, request).await; + + let response_bytes = match result { + Ok(record) => serde_json::to_vec(&serde_json::json!({"ok": record})).unwrap_or_default(), + Err(e) => serde_json::to_vec(&serde_json::json!({ + "error": {"code": "LOOKUP_ERROR", "message": e.to_string(), "retryable": false} + })) + .unwrap_or_default(), + }; + + write_guest_response(caller, &response_bytes).await +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_plugin_state_fields_exist() { + fn _check_fields(state: &PluginState) { + let _ = &state.plugin_id; + let _ = &state.scope; + let _ = &state.secrets; + let _ = &state.config; + let _ = &state.usage; + let _ = &state.memory; + let _ = &state.alloc; + let _ = &state.dealloc; + } + } + + #[test] + fn test_pack_ptr_len() { + let ptr: u32 = 0x1000; + let len: u32 = 0x0100; + let packed: i64 = ((ptr as i64) << 32) | (len as i64); + let unpacked_ptr = (packed >> 32) as u32; + let unpacked_len = (packed & 0xFFFFFFFF) as u32; + assert_eq!(unpacked_ptr, ptr); + assert_eq!(unpacked_len, len); + } + + #[test] + fn test_bounds_check_helper() { + assert!(check_bounds(0, 10, 100).is_ok()); + assert!(check_bounds(90, 10, 100).is_ok()); + assert!(check_bounds(91, 10, 100).is_err()); + assert!(check_bounds(0, 0, 100).is_ok()); + } +} diff --git a/src/plugin/host/lookup.rs b/src/plugin/host/lookup.rs index 704e79b..ec0c034 100644 --- a/src/plugin/host/lookup.rs +++ b/src/plugin/host/lookup.rs @@ -1,3 +1,5 @@ +use serde::Deserialize; + use super::HostContext; use crate::db::adapt_sql; use crate::plugin::StrongRef; @@ -10,6 +12,13 @@ pub enum LookupError { InvalidFieldPath, } +#[derive(Debug, Deserialize)] +pub struct LookupRequest { + pub collection: String, + pub external_id_field: String, + pub external_id_value: String, +} + /// Look up a record by external ID /// /// # Arguments @@ -48,6 +57,19 @@ pub async fn lookup_record( Ok(result.map(|(uri, cid)| StrongRef { uri, cid })) } +pub async fn lookup_record_by_request( + ctx: &HostContext, + request: LookupRequest, +) -> Result, LookupError> { + lookup_record( + ctx, + &request.collection, + &request.external_id_field, + &request.external_id_value, + ) + .await +} + #[cfg(test)] mod tests { use super::*; @@ -64,4 +86,13 @@ mod tests { let err = LookupError::InvalidFieldPath; assert_eq!(err.to_string(), "Invalid external ID field path"); } + + #[test] + fn test_lookup_request_deserialize() { + let json = r#"{"collection": "games.example.game", "external_id_field": "externalIds.steam", "external_id_value": "123"}"#; + let req: LookupRequest = serde_json::from_str(json).unwrap(); + assert_eq!(req.collection, "games.example.game"); + assert_eq!(req.external_id_field, "externalIds.steam"); + assert_eq!(req.external_id_value, "123"); + } } diff --git a/src/plugin/host/mod.rs b/src/plugin/host/mod.rs index f00fe4f..5556627 100644 --- a/src/plugin/host/mod.rs +++ b/src/plugin/host/mod.rs @@ -1,9 +1,11 @@ +mod bindings; mod http; mod kv; mod logging; mod lookup; mod secrets; +pub use bindings::{PluginState, register_host_functions}; pub use http::*; pub use kv::*; pub use logging::*; diff --git a/src/plugin/loader.rs b/src/plugin/loader.rs index 331808c..a4f9374 100644 --- a/src/plugin/loader.rs +++ b/src/plugin/loader.rs @@ -1,6 +1,11 @@ +use crate::plugin::host::{PluginState, register_host_functions}; +use crate::plugin::memory::PluginResponse; +use crate::plugin::runtime::DEFAULT_FUEL; use crate::plugin::{LoadedPlugin, PluginInfo, PluginSource}; use sha2::{Digest, Sha256}; +use std::collections::HashMap; use std::path::Path; +use wasmtime::{Config, Engine, Linker, Module, Store}; const SUPPORTED_API_VERSION: &str = "1"; @@ -84,23 +89,106 @@ pub async fn load_from_url( /// Extract plugin info by instantiating WASM and calling plugin_info() fn extract_plugin_info(wasm_bytes: &[u8]) -> Result { - // TODO: Full implementation with wasmtime - // For now, this is a placeholder that will be filled in when we integrate wasmtime calls + match tokio::runtime::Handle::try_current() { + Ok(handle) => { + tokio::task::block_in_place(|| handle.block_on(extract_plugin_info_async(wasm_bytes))) + } + Err(_) => { + let rt = tokio::runtime::Runtime::new().map_err(|e| { + LoadError::WasmValidation(format!("failed to create runtime: {}", e)) + })?; + rt.block_on(extract_plugin_info_async(wasm_bytes)) + } + } +} + +/// Async implementation of plugin info extraction via WASM instantiation +async fn extract_plugin_info_async(wasm_bytes: &[u8]) -> Result { + // Create async-enabled engine with fuel + let mut config = Config::new(); + config.async_support(true); + config.consume_fuel(true); + let engine = Engine::new(&config).map_err(|e| LoadError::WasmValidation(e.to_string()))?; - // Validate it's valid WASM - wasmtime::Module::validate(&wasmtime::Engine::default(), wasm_bytes) + let module = + Module::new(&engine, wasm_bytes).map_err(|e| LoadError::WasmValidation(e.to_string()))?; + + // Create linker with host functions + let mut linker = Linker::new(&engine); + register_host_functions(&mut linker).map_err(|e| LoadError::WasmValidation(e.to_string()))?; + + // Create minimal state - no db needed for plugin_info() + let state = PluginState { + plugin_id: "loading".into(), + scope: "".into(), + secrets: HashMap::new(), + config: serde_json::Value::Null, + db: None, // Not needed for plugin_info + db_backend: crate::db::DatabaseBackend::Sqlite, + http_client: reqwest::Client::new(), + lexicons: std::sync::Arc::new(crate::lexicon::LexiconRegistry::new()), + usage: Default::default(), + memory: None, + alloc: None, + dealloc: None, + }; + + let mut store = Store::new(&engine, state); + store + .set_fuel(DEFAULT_FUEL) .map_err(|e| LoadError::WasmValidation(e.to_string()))?; - // Return placeholder - real implementation calls plugin_info() export - Ok(PluginInfo { - id: "placeholder".into(), - name: "Placeholder".into(), - version: "0.0.0".into(), - api_version: SUPPORTED_API_VERSION.into(), - icon_url: None, - required_secrets: vec![], - config_schema: None, - }) + // Instantiate + let instance = linker + .instantiate_async(&mut store, &module) + .await + .map_err(|e| LoadError::WasmValidation(format!("instantiation failed: {}", e)))?; + + // Get memory and alloc/dealloc + let memory = instance + .get_memory(&mut store, "memory") + .ok_or_else(|| LoadError::WasmValidation("missing memory export".into()))?; + let alloc = instance + .get_typed_func::(&mut store, "alloc") + .map_err(|_| LoadError::WasmValidation("missing alloc export".into()))?; + let dealloc = instance + .get_typed_func::<(u32, u32), ()>(&mut store, "dealloc") + .map_err(|_| LoadError::WasmValidation("missing dealloc export".into()))?; + + // Store in state + store.data_mut().memory = Some(memory); + store.data_mut().alloc = Some(alloc); + store.data_mut().dealloc = Some(dealloc); + + // Call plugin_info + let func = instance + .get_typed_func::<(), i64>(&mut store, "plugin_info") + .map_err(|_| LoadError::WasmValidation("missing plugin_info export".into()))?; + + let packed = func + .call_async(&mut store, ()) + .await + .map_err(|e| LoadError::WasmValidation(format!("plugin_info failed: {}", e)))?; + + // Unpack i64: upper 32 bits = ptr, lower 32 bits = len + let ptr = (packed >> 32) as u32; + let len = (packed & 0xFFFFFFFF) as u32; + + // Read result from memory + let mem_data = memory.data(&store); + if (ptr as usize) + (len as usize) > mem_data.len() { + return Err(LoadError::WasmValidation( + "plugin_info returned out of bounds pointer".into(), + )); + } + let bytes = mem_data[ptr as usize..(ptr as usize + len as usize)].to_vec(); + + // Parse response + let response: PluginResponse = serde_json::from_slice(&bytes)?; + + response + .into_result() + .map_err(|e| LoadError::WasmValidation(format!("plugin error: {}", e.message))) } fn validate_api_version(info: &PluginInfo) -> Result<(), LoadError> { diff --git a/src/plugin/memory.rs b/src/plugin/memory.rs new file mode 100644 index 0000000..dd19b59 --- /dev/null +++ b/src/plugin/memory.rs @@ -0,0 +1,193 @@ +use crate::plugin::host::PluginState; +use serde::{Deserialize, Serialize}; +use thiserror::Error; +use wasmtime::Store; + +/// Error returned from a plugin via JSON envelope. +/// Uses a string code for flexibility in parsing arbitrary error codes from plugins. +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct PluginEnvelopeError { + pub code: String, + pub message: String, + #[serde(default)] + pub retryable: bool, +} + +impl std::fmt::Display for PluginEnvelopeError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "{}: {}", self.code, self.message) + } +} + +impl std::error::Error for PluginEnvelopeError {} + +/// JSON envelope for plugin responses. +/// Plugins return either `{"ok": result}` or `{"error": {...}}`. +#[derive(Debug, Deserialize)] +#[serde(untagged)] +pub enum PluginResponse { + Ok { ok: T }, + Error { error: PluginEnvelopeError }, +} + +impl PluginResponse { + pub fn into_result(self) -> Result { + match self { + PluginResponse::Ok { ok } => Ok(ok), + PluginResponse::Error { error } => Err(error), + } + } +} + +#[derive(Debug, Error)] +pub enum MemoryError { + #[error("Memory allocation failed: alloc returned 0")] + AllocationFailed, + #[error( + "Memory access out of bounds: offset {offset} + length {length} exceeds memory size {size}" + )] + OutOfBounds { + offset: usize, + length: usize, + size: usize, + }, + #[error("WASM trap during memory operation: {0}")] + Trap(#[from] wasmtime::Error), +} + +/// Write data to WASM guest memory by calling alloc and copying bytes. +/// Returns (ptr, len) tuple on success. +pub async fn write_to_guest( + store: &mut Store, + data: &[u8], +) -> Result<(u32, u32), MemoryError> { + let len = data.len() as u32; + if len == 0 { + return Ok((0, 0)); + } + + let alloc = store + .data() + .alloc + .as_ref() + .ok_or(MemoryError::AllocationFailed)? + .clone(); + let memory = store.data().memory.ok_or(MemoryError::AllocationFailed)?; + + let ptr = alloc.call_async(&mut *store, len).await?; + if ptr == 0 { + return Err(MemoryError::AllocationFailed); + } + + let mem_size = memory.data_size(&*store); + let start = ptr as usize; + let end = start + .checked_add(len as usize) + .ok_or(MemoryError::OutOfBounds { + offset: start, + length: len as usize, + size: mem_size, + })?; + + if end > mem_size { + return Err(MemoryError::OutOfBounds { + offset: start, + length: len as usize, + size: mem_size, + }); + } + + memory.data_mut(&mut *store)[start..end].copy_from_slice(data); + Ok((ptr, len)) +} + +/// Read data from WASM guest memory at the given pointer and length. +pub fn read_from_guest( + store: &Store, + ptr: u32, + len: u32, +) -> Result, MemoryError> { + if len == 0 { + return Ok(Vec::new()); + } + + let memory = store.data().memory.ok_or(MemoryError::AllocationFailed)?; + let mem_size = memory.data_size(store); + let start = ptr as usize; + let end = start + .checked_add(len as usize) + .ok_or(MemoryError::OutOfBounds { + offset: start, + length: len as usize, + size: mem_size, + })?; + + if end > mem_size { + return Err(MemoryError::OutOfBounds { + offset: start, + length: len as usize, + size: mem_size, + }); + } + + Ok(memory.data(store)[start..end].to_vec()) +} + +/// Deallocate guest memory by calling the dealloc function. +pub async fn dealloc_guest( + store: &mut Store, + ptr: u32, + len: u32, +) -> Result<(), MemoryError> { + if len == 0 { + return Ok(()); + } + + let dealloc = store + .data() + .dealloc + .as_ref() + .ok_or(MemoryError::AllocationFailed)? + .clone(); + dealloc.call_async(&mut *store, (ptr, len)).await?; + Ok(()) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_memory_error_display() { + let err = MemoryError::AllocationFailed; + assert!(err.to_string().contains("alloc")); + + let err = MemoryError::OutOfBounds { + offset: 100, + length: 50, + size: 120, + }; + assert!(err.to_string().contains("100")); + } + + #[test] + fn test_plugin_response_ok_parses() { + let json = r#"{"ok": "hello"}"#; + let resp: PluginResponse = serde_json::from_str(json).unwrap(); + let result = resp.into_result(); + assert!(result.is_ok()); + assert_eq!(result.unwrap(), "hello"); + } + + #[test] + fn test_plugin_response_error_parses() { + let json = + r#"{"error": {"code": "AUTH_FAILED", "message": "Invalid token", "retryable": true}}"#; + let resp: PluginResponse = serde_json::from_str(json).unwrap(); + let result = resp.into_result(); + assert!(result.is_err()); + let err = result.unwrap_err(); + assert_eq!(err.code, "AUTH_FAILED"); + assert!(err.retryable); + } +} diff --git a/src/plugin/mod.rs b/src/plugin/mod.rs index ec10134..ce5e4a2 100644 --- a/src/plugin/mod.rs +++ b/src/plugin/mod.rs @@ -1,9 +1,15 @@ +pub mod attestation; pub mod encryption; +pub mod executor; pub mod host; pub mod loader; +pub mod memory; mod runtime; +pub mod sync; mod types; +pub use executor::{ExecutionError, PluginExecutor, PluginInstance}; +pub use memory::{MemoryError, PluginEnvelopeError, PluginResponse}; pub use runtime::WasmRuntime; pub use types::*; diff --git a/src/plugin/runtime.rs b/src/plugin/runtime.rs index 97f7278..547dc75 100644 --- a/src/plugin/runtime.rs +++ b/src/plugin/runtime.rs @@ -1,5 +1,8 @@ use wasmtime::*; +/// Default fuel for plugin execution (≈100ms CPU time) +pub const DEFAULT_FUEL: u64 = 10_000_000; + /// WASM runtime for executing plugins pub struct WasmRuntime { engine: Engine, @@ -9,6 +12,7 @@ impl WasmRuntime { pub fn new() -> Result { let mut config = Config::new(); config.async_support(true); + config.consume_fuel(true); let engine = Engine::new(&config)?; @@ -18,6 +22,11 @@ impl WasmRuntime { pub fn engine(&self) -> &Engine { &self.engine } + + /// Compile a WASM module + pub fn compile(&self, wasm_bytes: &[u8]) -> Result { + Module::new(&self.engine, wasm_bytes) + } } impl Default for WasmRuntime { @@ -25,3 +34,29 @@ impl Default for WasmRuntime { Self::new().expect("Failed to create WASM runtime") } } + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_fuel_constant_value() { + // 10M fuel ≈ 100ms CPU time per spec + assert_eq!(DEFAULT_FUEL, 10_000_000); + } + + #[test] + fn test_runtime_has_fuel_enabled() { + let runtime = WasmRuntime::new().expect("Failed to create runtime"); + // We can verify fuel is enabled by checking we can set it on a store + let mut store = wasmtime::Store::new(runtime.engine(), ()); + assert!(store.set_fuel(1000).is_ok()); + } + + #[test] + fn test_compile_invalid_wasm_fails() { + let runtime = WasmRuntime::new().expect("Failed to create runtime"); + let result = runtime.compile(b"not valid wasm"); + assert!(result.is_err()); + } +} diff --git a/src/plugin/sync.rs b/src/plugin/sync.rs new file mode 100644 index 0000000..9aca8e9 --- /dev/null +++ b/src/plugin/sync.rs @@ -0,0 +1,312 @@ +//! SyncRecord processing pipeline. +//! +//! Processes records returned by plugin sync_account(): +//! - Signs records that have `sign: true` +//! - Resolves game references +//! - Prepares records for writing to PDS + +use super::attestation::{AttestationError, AttestationSigner}; +use super::types::SyncRecord; +use crate::db::{DatabaseBackend, adapt_sql}; +use serde_json::Value; + +/// Processed record ready for storage +#[derive(Debug, Clone)] +pub struct ProcessedRecord { + /// The collection (lexicon ID) + pub collection: String, + /// The processed record with signatures added + pub record: Value, + /// Deduplication key + pub dedup_key: Option, + /// CID of the signed content (if signed) + pub content_cid: Option, +} + +/// Error during sync record processing +#[derive(Debug, thiserror::Error)] +pub enum SyncError { + #[error("Attestation signing failed: {0}")] + Attestation(#[from] AttestationError), + + #[error("Game reference resolution failed: {0}")] + GameResolution(String), + + #[error("Invalid record: {0}")] + InvalidRecord(String), +} + +/// Process a batch of SyncRecords from a plugin +pub struct SyncProcessor<'a> { + /// Attestation signer (optional - if None, signing is skipped) + signer: Option<&'a AttestationSigner>, + /// Repository DID for the user (used in $sig for replay protection) + repository_did: String, +} + +impl<'a> SyncProcessor<'a> { + /// Create a new sync processor + pub fn new(signer: Option<&'a AttestationSigner>, repository_did: String) -> Self { + Self { + signer, + repository_did, + } + } + + /// Process a batch of SyncRecords + pub fn process_records( + &self, + records: Vec, + ) -> Result, SyncError> { + let mut processed = Vec::with_capacity(records.len()); + + for record in records { + processed.push(self.process_record(record)?); + } + + Ok(processed) + } + + /// Process a single SyncRecord + fn process_record(&self, sync_record: SyncRecord) -> Result { + let mut record = sync_record.record; + + // Resolve game references if present + self.resolve_game_ref(&mut record)?; + + // Sign if requested and signer is available + let content_cid = if sync_record.sign { + if let Some(signer) = self.signer { + let cid = signer.sign_record(&mut record, &self.repository_did)?; + Some(cid.to_string()) + } else { + tracing::warn!( + collection = %sync_record.collection, + "Record requested signing but no signer configured" + ); + None + } + } else { + None + }; + + Ok(ProcessedRecord { + collection: sync_record.collection, + record, + dedup_key: sync_record.dedup_key, + content_cid, + }) + } + + /// Resolve game references in a record + /// + /// Looks for game references like `{"platform": "steam", "externalId": "440"}` + /// and attempts to resolve them to AT URIs. + fn resolve_game_ref(&self, record: &mut Value) -> Result<(), SyncError> { + // Look for "game" field with platform/externalId structure + if let Some(obj) = record.as_object_mut() + && let Some(game_ref) = obj.get("game") + && let Some(game_obj) = game_ref.as_object() + && game_obj.contains_key("platform") + && game_obj.contains_key("externalId") + && !game_obj.contains_key("uri") + { + // Unresolved reference - log for debugging + let platform = game_obj + .get("platform") + .and_then(|v| v.as_str()) + .unwrap_or("unknown"); + let external_id = game_obj + .get("externalId") + .and_then(|v| v.as_str()) + .unwrap_or("unknown"); + + tracing::debug!( + platform = %platform, + external_id = %external_id, + "Game reference left unresolved - resolution not yet implemented" + ); + } + + Ok(()) + } +} + +/// Helper to create a sync processor with common setup +pub fn create_processor<'a>( + signer: Option<&'a AttestationSigner>, + user_did: &str, +) -> SyncProcessor<'a> { + SyncProcessor::new(signer, user_did.to_string()) +} + +/// Resolve game references in records by looking up in the database. +/// +/// Looks for `game: {platform: "steam", externalId: "440"}` and converts to +/// `game: {uri: "at://...", cid: "..."}` if found. +pub async fn resolve_game_references( + db: &sqlx::AnyPool, + backend: DatabaseBackend, + records: &mut [SyncRecord], +) { + for record in records.iter_mut() { + let Some(obj) = record.record.as_object_mut() else { + continue; + }; + let Some(game_ref) = obj.get("game").cloned() else { + continue; + }; + let Some(game_obj) = game_ref.as_object() else { + continue; + }; + + // Check for unresolved reference + if !game_obj.contains_key("platform") + || !game_obj.contains_key("externalId") + || game_obj.contains_key("uri") + { + continue; + } + + let platform = game_obj + .get("platform") + .and_then(|v| v.as_str()) + .unwrap_or(""); + let external_id = game_obj + .get("externalId") + .and_then(|v| v.as_str()) + .unwrap_or(""); + + if let Some((uri, cid)) = + lookup_game_by_external_id(db, backend, platform, external_id).await + { + obj.insert( + "game".to_string(), + serde_json::json!({ + "uri": uri, + "cid": cid + }), + ); + tracing::debug!( + platform = %platform, + external_id = %external_id, + uri = %uri, + "Resolved game reference" + ); + } else { + tracing::debug!( + platform = %platform, + external_id = %external_id, + "Game not found in database, leaving reference unresolved" + ); + } + } +} + +/// Look up a game by external ID (e.g., Steam app ID). +/// +/// Returns (uri, cid) if found. +async fn lookup_game_by_external_id( + db: &sqlx::AnyPool, + backend: DatabaseBackend, + platform: &str, + external_id: &str, +) -> Option<(String, String)> { + // Build JSON path based on platform + // Looking for records where: record.externalIds. = external_id + let json_path = match backend { + DatabaseBackend::Sqlite => { + format!("json_extract(record, '$.externalIds.{}')", platform) + } + DatabaseBackend::Postgres => { + format!("record->'externalIds'->>'{}'", platform) + } + }; + + let sql = adapt_sql( + &format!( + "SELECT uri, cid FROM records WHERE collection = 'games.gamesgamesgamesgames.game' AND {} = ? LIMIT 1", + json_path + ), + backend, + ); + + let result: Option<(String, String)> = sqlx::query_as(&sql) + .bind(external_id) + .fetch_optional(db) + .await + .ok() + .flatten(); + + result +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_process_unsigned_record() { + let processor = SyncProcessor::new(None, "did:plc:testuser".to_string()); + + let records = vec![SyncRecord { + collection: "test.collection".into(), + record: serde_json::json!({ + "$type": "test.collection", + "data": "hello" + }), + dedup_key: Some("test:1".into()), + sign: false, + }]; + + let processed = processor.process_records(records).unwrap(); + assert_eq!(processed.len(), 1); + assert_eq!(processed[0].collection, "test.collection"); + assert!(processed[0].content_cid.is_none()); + } + + #[test] + fn test_process_signed_record() { + let signer = + AttestationSigner::for_testing("did:web:test#key".into(), "test.signature".into()); + let processor = SyncProcessor::new(Some(&signer), "did:plc:testuser".to_string()); + + let records = vec![SyncRecord { + collection: "games.gamesgamesgamesgames.actor.game".into(), + record: serde_json::json!({ + "$type": "games.gamesgamesgamesgames.actor.game", + "game": {"platform": "steam", "externalId": "440"}, + "platform": "steam", + "createdAt": "2024-01-01T00:00:00Z" + }), + dedup_key: Some("steam:game:440".into()), + sign: true, + }]; + + let processed = processor.process_records(records).unwrap(); + assert_eq!(processed.len(), 1); + assert!(processed[0].content_cid.is_some()); + + // Verify signatures array was added + let signatures = processed[0].record["signatures"].as_array(); + assert!(signatures.is_some()); + assert_eq!(signatures.unwrap().len(), 1); + } + + #[test] + fn test_sign_requested_but_no_signer() { + let processor = SyncProcessor::new(None, "did:plc:testuser".to_string()); + + let records = vec![SyncRecord { + collection: "test.collection".into(), + record: serde_json::json!({"data": "hello"}), + dedup_key: None, + sign: true, // Requested but no signer + }]; + + let processed = processor.process_records(records).unwrap(); + assert_eq!(processed.len(), 1); + // No error, but no CID either + assert!(processed[0].content_cid.is_none()); + } +} diff --git a/src/plugin/types.rs b/src/plugin/types.rs index b8b23be..f4debaf 100644 --- a/src/plugin/types.rs +++ b/src/plugin/types.rs @@ -74,6 +74,9 @@ pub struct SyncRecord { pub record: serde_json::Value, #[serde(skip_serializing_if = "Option::is_none")] pub dedup_key: Option, + /// Whether HappyView should add an attestation signature to this record + #[serde(default)] + pub sign: bool, } /// Strong reference to an AT Protocol record diff --git a/tests/common/app.rs b/tests/common/app.rs index 4a03a6f..3bed538 100644 --- a/tests/common/app.rs +++ b/tests/common/app.rs @@ -131,6 +131,10 @@ impl TestApp { b"test-secret-that-is-at-least-32-bytes-long", ), plugin_registry: std::sync::Arc::new(happyview::plugin::PluginRegistry::new()), + wasm_runtime: std::sync::Arc::new( + happyview::plugin::WasmRuntime::new().expect("wasm runtime"), + ), + attestation_signer: None, }; let router = server::router(state.clone()); diff --git a/tests/fixtures/test_plugin/.gitignore b/tests/fixtures/test_plugin/.gitignore new file mode 100644 index 0000000..b83d222 --- /dev/null +++ b/tests/fixtures/test_plugin/.gitignore @@ -0,0 +1 @@ +/target/ diff --git a/tests/fixtures/test_plugin/Cargo.lock b/tests/fixtures/test_plugin/Cargo.lock new file mode 100644 index 0000000..aa024b4 --- /dev/null +++ b/tests/fixtures/test_plugin/Cargo.lock @@ -0,0 +1,7 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "test-plugin" +version = "0.1.0" diff --git a/tests/fixtures/test_plugin/Cargo.toml b/tests/fixtures/test_plugin/Cargo.toml new file mode 100644 index 0000000..6420be3 --- /dev/null +++ b/tests/fixtures/test_plugin/Cargo.toml @@ -0,0 +1,11 @@ +[package] +name = "test-plugin" +version = "0.1.0" +edition = "2021" + +[lib] +crate-type = ["cdylib"] + +[profile.release] +opt-level = "s" +lto = true diff --git a/tests/fixtures/test_plugin/src/lib.rs b/tests/fixtures/test_plugin/src/lib.rs new file mode 100644 index 0000000..edad480 --- /dev/null +++ b/tests/fixtures/test_plugin/src/lib.rs @@ -0,0 +1,105 @@ +// Only compile for WASM targets +#![cfg_attr(target_arch = "wasm32", no_std)] +#![allow(static_mut_refs)] + +#[cfg(target_arch = "wasm32")] +extern crate alloc; + +#[cfg(target_arch = "wasm32")] +use core::alloc::{GlobalAlloc, Layout}; + +// Simple bump allocator for WASM +#[cfg(target_arch = "wasm32")] +struct BumpAllocator; + +#[cfg(target_arch = "wasm32")] +const HEAP_SIZE: usize = 65536; +#[cfg(target_arch = "wasm32")] +static mut HEAP: [u8; HEAP_SIZE] = [0; HEAP_SIZE]; +#[cfg(target_arch = "wasm32")] +static mut HEAP_POS: usize = 0; + +#[cfg(target_arch = "wasm32")] +unsafe impl GlobalAlloc for BumpAllocator { + unsafe fn alloc(&self, layout: Layout) -> *mut u8 { + let size = layout.size(); + let align = layout.align(); + + // Align up + let pos = (HEAP_POS + align - 1) & !(align - 1); + if pos + size > HEAP_SIZE { + return core::ptr::null_mut(); + } + + HEAP_POS = pos + size; + HEAP.as_mut_ptr().add(pos) + } + + unsafe fn dealloc(&self, _ptr: *mut u8, _layout: Layout) { + // No-op for bump allocator + } +} + +#[cfg(target_arch = "wasm32")] +#[global_allocator] +static ALLOCATOR: BumpAllocator = BumpAllocator; + +#[cfg(target_arch = "wasm32")] +#[panic_handler] +fn panic(_info: &core::panic::PanicInfo) -> ! { + loop {} +} + +// Memory exports +#[no_mangle] +pub extern "C" fn alloc(size: u32) -> u32 { + let layout = Layout::from_size_align(size as usize, 1).unwrap(); + unsafe { ALLOCATOR.alloc(layout) as u32 } +} + +#[no_mangle] +pub extern "C" fn dealloc(_ptr: u32, _size: u32) { + // No-op for bump allocator +} + +// Helper to return a string as packed i64: (ptr << 32) | len +fn return_json(s: &str) -> i64 { + let ptr = alloc(s.len() as u32); + if ptr == 0 { + return 0; + } + unsafe { + core::ptr::copy_nonoverlapping(s.as_ptr(), ptr as *mut u8, s.len()); + } + ((ptr as i64) << 32) | (s.len() as i64) +} + +#[no_mangle] +pub extern "C" fn plugin_info() -> i64 { + return_json(r#"{"ok":{"id":"test","name":"Test Plugin","version":"1.0.0","api_version":"1","required_secrets":[],"icon_url":null,"config_schema":null}}"#) +} + +#[no_mangle] +pub extern "C" fn get_authorize_url(_ptr: u32, _len: u32) -> i64 { + return_json(r#"{"ok":"https://example.com/oauth?state=test"}"#) +} + +#[no_mangle] +pub extern "C" fn handle_callback(_ptr: u32, _len: u32) -> i64 { + return_json(r#"{"ok":{"access_token":"test-token","token_type":"Bearer","expires_at":null,"refresh_token":null}}"#) +} + +#[no_mangle] +pub extern "C" fn refresh_tokens(_ptr: u32, _len: u32) -> i64 { + return_json(r#"{"ok":{"access_token":"refreshed-token","token_type":"Bearer","expires_at":null,"refresh_token":null}}"#) +} + +#[no_mangle] +pub extern "C" fn get_profile(_ptr: u32, _len: u32) -> i64 { + return_json(r#"{"ok":{"account_id":"12345","display_name":"Test User","profile_url":null,"avatar_url":null}}"#) +} + +#[no_mangle] +pub extern "C" fn sync_account(_ptr: u32, _len: u32) -> i64 { + return_json(r#"{"ok":[]}"#) +} diff --git a/tests/lua_atproto_api.rs b/tests/lua_atproto_api.rs index 30f6d66..33b29b2 100644 --- a/tests/lua_atproto_api.rs +++ b/tests/lua_atproto_api.rs @@ -85,6 +85,10 @@ async fn test_state_with_pool(pool: sqlx::AnyPool, backend: DatabaseBackend) -> oauth: std::sync::Arc::new(oauth), cookie_key: axum_extra::extract::cookie::Key::derive_from(b"test-secret"), plugin_registry: std::sync::Arc::new(happyview::plugin::PluginRegistry::new()), + wasm_runtime: std::sync::Arc::new( + happyview::plugin::WasmRuntime::new().expect("wasm runtime"), + ), + attestation_signer: None, } } diff --git a/tests/lua_db_api.rs b/tests/lua_db_api.rs index 14b9e62..8fe4b4f 100644 --- a/tests/lua_db_api.rs +++ b/tests/lua_db_api.rs @@ -88,6 +88,10 @@ async fn test_state_with_pool(pool: sqlx::AnyPool, backend: DatabaseBackend) -> oauth: std::sync::Arc::new(oauth), cookie_key: axum_extra::extract::cookie::Key::derive_from(b"test-secret"), plugin_registry: std::sync::Arc::new(happyview::plugin::PluginRegistry::new()), + wasm_runtime: std::sync::Arc::new( + happyview::plugin::WasmRuntime::new().expect("wasm runtime"), + ), + attestation_signer: None, } } diff --git a/tests/plugin_executor.rs b/tests/plugin_executor.rs new file mode 100644 index 0000000..71cc06a --- /dev/null +++ b/tests/plugin_executor.rs @@ -0,0 +1,224 @@ +// tests/plugin_executor.rs + +use happyview::db::DatabaseBackend; +use happyview::lexicon::LexiconRegistry; +use happyview::plugin::{ + ExecutionError, LoadedPlugin, PluginExecutor, PluginInfo, PluginRegistry, PluginSource, + WasmRuntime, +}; +use std::collections::HashMap; +use std::sync::Arc; + +type Secrets = HashMap; + +async fn create_test_executor() -> (PluginExecutor, Arc) { + // Create in-memory database + sqlx::any::install_default_drivers(); + let db = sqlx::AnyPool::connect("sqlite::memory:") + .await + .expect("Failed to create test database"); + + let runtime = Arc::new(WasmRuntime::new().expect("Failed to create runtime")); + let registry = Arc::new(PluginRegistry::new()); + let lexicons = Arc::new(LexiconRegistry::new()); + let http_client = reqwest::Client::new(); + + let executor = PluginExecutor::new( + runtime, + registry.clone(), + db, + DatabaseBackend::Sqlite, + http_client, + lexicons, + ); + + (executor, registry) +} + +fn load_test_plugin() -> LoadedPlugin { + let wasm_bytes = std::fs::read( + "tests/fixtures/test_plugin/target/wasm32-unknown-unknown/release/test_plugin.wasm", + ) + .expect( + "Test plugin not built. Run: cd tests/fixtures/test_plugin && cargo build --target wasm32-unknown-unknown --release", + ); + + LoadedPlugin { + info: PluginInfo { + id: "test".into(), + name: "Test Plugin".into(), + version: "1.0.0".into(), + api_version: "1".into(), + icon_url: None, + required_secrets: vec![], + config_schema: None, + }, + source: PluginSource::File { + path: "tests/fixtures/test_plugin".into(), + }, + wasm_bytes, + } +} + +#[tokio::test] +async fn test_plugin_info() { + let (executor, registry) = create_test_executor().await; + let plugin = load_test_plugin(); + registry.register(plugin).await; + + let mut instance = executor + .instantiate( + "test", + "user:did:plc:test", + Secrets::new(), + serde_json::Value::Null, + ) + .await + .expect("Failed to instantiate"); + + let info = instance + .call_plugin_info() + .await + .expect("Failed to get info"); + + assert_eq!(info.id, "test"); + assert_eq!(info.name, "Test Plugin"); + assert_eq!(info.version, "1.0.0"); +} + +#[tokio::test] +async fn test_get_authorize_url() { + let (executor, registry) = create_test_executor().await; + let plugin = load_test_plugin(); + registry.register(plugin).await; + + let mut instance = executor + .instantiate("test", "state:123", Secrets::new(), serde_json::Value::Null) + .await + .expect("Failed to instantiate"); + + let url = instance + .call_get_authorize_url( + "state123", + "https://app.example/callback", + &serde_json::Value::Null, + ) + .await + .expect("Failed to get URL"); + + assert!(url.starts_with("https://")); +} + +#[tokio::test] +async fn test_handle_callback() { + let (executor, registry) = create_test_executor().await; + let plugin = load_test_plugin(); + registry.register(plugin).await; + + let mut instance = executor + .instantiate( + "test", + "user:did:plc:test", + Secrets::new(), + serde_json::Value::Null, + ) + .await + .expect("Failed to instantiate"); + + let tokens = instance + .call_handle_callback("code123", "state123", &serde_json::Value::Null) + .await + .expect("Failed to handle callback"); + + assert_eq!(tokens.access_token, "test-token"); + assert_eq!(tokens.token_type, "Bearer"); +} + +#[tokio::test] +async fn test_refresh_tokens() { + let (executor, registry) = create_test_executor().await; + let plugin = load_test_plugin(); + registry.register(plugin).await; + + let mut instance = executor + .instantiate( + "test", + "user:did:plc:test", + Secrets::new(), + serde_json::Value::Null, + ) + .await + .expect("Failed to instantiate"); + + let tokens = instance + .call_refresh_tokens("old-refresh-token", &serde_json::Value::Null) + .await + .expect("Failed to refresh tokens"); + + assert_eq!(tokens.access_token, "refreshed-token"); +} + +#[tokio::test] +async fn test_get_profile() { + let (executor, registry) = create_test_executor().await; + let plugin = load_test_plugin(); + registry.register(plugin).await; + + let mut instance = executor + .instantiate( + "test", + "user:did:plc:test", + Secrets::new(), + serde_json::Value::Null, + ) + .await + .expect("Failed to instantiate"); + + let profile = instance + .call_get_profile("test-token", &serde_json::Value::Null) + .await + .expect("Failed to get profile"); + + assert_eq!(profile.account_id, "12345"); + assert_eq!(profile.display_name, Some("Test User".into())); +} + +#[tokio::test] +async fn test_sync_account() { + let (executor, registry) = create_test_executor().await; + let plugin = load_test_plugin(); + registry.register(plugin).await; + + let mut instance = executor + .instantiate( + "test", + "user:did:plc:test", + Secrets::new(), + serde_json::Value::Null, + ) + .await + .expect("Failed to instantiate"); + + let records = instance + .call_sync_account("test-token", &serde_json::Value::Null) + .await + .expect("Failed to sync account"); + + assert!(records.is_empty()); // Test plugin returns empty array +} + +#[tokio::test] +async fn test_plugin_not_found() { + let (executor, _registry) = create_test_executor().await; + + let result = executor + .instantiate( + "nonexistent", + "scope", + Secrets::new(), + serde_json::Value::Null, + ) + .await; + + assert!(matches!(result, Err(ExecutionError::PluginNotFound(_)))); +} -- 2.51.2 From 1677721f922bc1c99c8264303f9e9e628a102fa9 Mon Sep 17 00:00:00 2001 From: Trezy Date: Fri, 20 Mar 2026 15:09:09 -0500 Subject: [PATCH 4/6] feat: external auth infra --- src/external_auth/routes.rs | 104 +++++ src/external_auth/tokens.rs | 36 ++ src/main.rs | 7 +- src/plugin/mod.rs | 67 ++- src/plugin/types.rs | 8 + web/next.config.ts | 1 + .../app/dashboard/settings/accounts/page.tsx | 435 ++++++++++++++++++ web/src/components/app-sidebar.tsx | 3 + web/src/lib/api.ts | 55 +++ web/src/types/external-accounts.ts | 51 ++ 10 files changed, 764 insertions(+), 3 deletions(-) create mode 100644 web/src/app/dashboard/settings/accounts/page.tsx create mode 100644 web/src/types/external-accounts.ts diff --git a/src/external_auth/routes.rs b/src/external_auth/routes.rs index 86f59c2..601c217 100644 --- a/src/external_auth/routes.rs +++ b/src/external_auth/routes.rs @@ -18,8 +18,10 @@ use crate::plugin::sync::SyncProcessor; pub fn routes() -> Router { Router::new() .route("/providers", get(list_providers)) + .route("/accounts", get(list_accounts)) .route("/{plugin_id}/authorize", get(authorize)) .route("/{plugin_id}/callback", get(callback)) + .route("/{plugin_id}/connect", post(connect_with_config)) .route("/{plugin_id}/sync", post(sync)) .route("/{plugin_id}/unlink", post(unlink)) } @@ -29,6 +31,9 @@ struct ProviderInfo { id: String, name: String, icon_url: Option, + auth_type: String, + #[serde(skip_serializing_if = "Option::is_none")] + config_schema: Option, } async fn list_providers( @@ -42,12 +47,25 @@ async fn list_providers( id: p.info.id.clone(), name: p.info.name.clone(), icon_url: p.info.icon_url.clone(), + auth_type: p.info.auth_type.clone(), + config_schema: p.info.config_schema.clone(), }) .collect(); Ok(Json(providers)) } +async fn list_accounts( + State(app_state): State, + claims: Claims, +) -> Result>, AppError> { + let accounts = tokens::list_linked_accounts(&app_state.db, app_state.db_backend, claims.did()) + .await + .map_err(|e| AppError::Internal(e.to_string()))?; + + Ok(Json(accounts)) +} + #[derive(Deserialize)] struct AuthorizeQuery { redirect_uri: String, @@ -195,6 +213,92 @@ async fn callback( Ok(Redirect::to(&stored_state.redirect_uri)) } +/// Connect with user-provided config (for API key auth type) +#[derive(Deserialize)] +struct ConnectConfigBody { + /// User-provided configuration matching the plugin's config_schema + config: serde_json::Value, +} + +async fn connect_with_config( + State(app_state): State, + Path(plugin_id): Path, + claims: Claims, + Json(body): Json, +) -> Result, AppError> { + let user_did = claims.did(); + + let plugin = app_state + .plugin_registry + .get(&plugin_id) + .await + .ok_or_else(|| AppError::NotFound(format!("Plugin not found: {}", plugin_id)))?; + + // Verify this is an API key plugin + if plugin.info.auth_type != "api_key" { + return Err(AppError::BadRequest( + "This endpoint is only for API key authentication".into(), + )); + } + + let secrets = load_plugin_secrets(&plugin_id); + + let executor = PluginExecutor::new( + app_state.wasm_runtime.clone(), + app_state.plugin_registry.clone(), + app_state.db.clone(), + app_state.db_backend, + app_state.http.clone(), + Arc::new(app_state.lexicons.clone()), + ); + + // For API key auth, we pass the user's config to handle_callback + // The "code" is empty since there's no OAuth flow + let mut instance = executor + .instantiate(&plugin_id, user_did, secrets, body.config.clone()) + .await + .map_err(|e| AppError::Internal(e.to_string()))?; + + // Call handle_callback with the config as the callback params + // The plugin will extract the api_key from the config + let token_set = instance + .call_handle_callback("", "", &body.config) + .await + .map_err(|e| AppError::Internal(e.to_string()))?; + + // Get profile to get the account_id + let profile = instance + .call_get_profile(&token_set.access_token, &body.config) + .await + .map_err(|e| AppError::Internal(e.to_string()))?; + + // Format expires_at as RFC3339 string + let expires_at = token_set.expires_at.map(|dt| dt.to_rfc3339()); + + // Store encrypted tokens + tokens::store_tokens( + &app_state.db, + app_state.db_backend, + app_state.config.token_encryption_key.as_ref(), + user_did, + &plugin_id, + &profile.account_id, + &token_set.access_token, + token_set.refresh_token.as_deref(), + Some(&token_set.token_type), + None, + expires_at.as_deref(), + ) + .await + .map_err(|e| AppError::Internal(e.to_string()))?; + + Ok(Json(serde_json::json!({ + "status": "connected", + "account_id": profile.account_id, + "display_name": profile.display_name + }))) +} + async fn sync( State(app_state): State, Path(plugin_id): Path, diff --git a/src/external_auth/tokens.rs b/src/external_auth/tokens.rs index fbb5b62..4ce15ae 100644 --- a/src/external_auth/tokens.rs +++ b/src/external_auth/tokens.rs @@ -195,4 +195,40 @@ pub async fn get_account_id( Ok(row.map(|(id,)| id)) } +/// Summary of a linked external account (without tokens) +#[derive(Debug, Clone, serde::Serialize)] +pub struct LinkedAccountSummary { + pub plugin_id: String, + pub account_id: String, + pub created_at: String, + pub updated_at: String, +} + +/// List all linked external accounts for a user +pub async fn list_linked_accounts( + db: &sqlx::AnyPool, + backend: DatabaseBackend, + did: &str, +) -> Result, TokenError> { + let sql = adapt_sql( + "SELECT plugin_id, account_id, created_at, updated_at FROM external_account_tokens WHERE did = ? ORDER BY created_at DESC", + backend, + ); + + let rows: Vec<(String, String, String, String)> = + sqlx::query_as(&sql).bind(did).fetch_all(db).await?; + + Ok(rows + .into_iter() + .map( + |(plugin_id, account_id, created_at, updated_at)| LinkedAccountSummary { + plugin_id, + account_id, + created_at, + updated_at, + }, + ) + .collect()) +} + // Integration tests for token storage are in tests/e2e_external_auth.rs diff --git a/src/main.rs b/src/main.rs index d019fa7..cb4df4b 100644 --- a/src/main.rs +++ b/src/main.rs @@ -173,8 +173,11 @@ async fn main() { ); } - // Initialize plugin registry - let plugin_registry = Arc::new(happyview::plugin::PluginRegistry::new()); + // Initialize plugin registry (with DB for persistence) + let plugin_registry = Arc::new(happyview::plugin::PluginRegistry::with_db( + db_pool.clone(), + db_backend, + )); // Initialize WASM runtime let wasm_runtime = diff --git a/src/plugin/mod.rs b/src/plugin/mod.rs index ce5e4a2..a19e564 100644 --- a/src/plugin/mod.rs +++ b/src/plugin/mod.rs @@ -13,14 +13,26 @@ pub use memory::{MemoryError, PluginEnvelopeError, PluginResponse}; pub use runtime::WasmRuntime; pub use types::*; +use crate::db::{DatabaseBackend, adapt_sql, now_rfc3339}; use std::collections::HashMap; use std::sync::Arc; use tokio::sync::RwLock; /// Registry of loaded plugins -#[derive(Default)] pub struct PluginRegistry { plugins: RwLock>>, + db: Option, + db_backend: DatabaseBackend, +} + +impl Default for PluginRegistry { + fn default() -> Self { + Self { + plugins: RwLock::new(HashMap::new()), + db: None, + db_backend: DatabaseBackend::Sqlite, + } + } } impl PluginRegistry { @@ -28,11 +40,64 @@ impl PluginRegistry { Self::default() } + /// Create a registry backed by a database for persistence + pub fn with_db(db: sqlx::AnyPool, db_backend: DatabaseBackend) -> Self { + Self { + plugins: RwLock::new(HashMap::new()), + db: Some(db), + db_backend, + } + } + pub async fn register(&self, plugin: LoadedPlugin) { let id = plugin.info.id.clone(); + + // Persist to database if configured + if let Some(db) = &self.db + && let Err(e) = self.persist_plugin(db, &plugin).await + { + tracing::error!(plugin_id = %id, error = %e, "Failed to persist plugin to database"); + } + self.plugins.write().await.insert(id, Arc::new(plugin)); } + async fn persist_plugin( + &self, + db: &sqlx::AnyPool, + plugin: &LoadedPlugin, + ) -> Result<(), sqlx::Error> { + let (source, url, sha256) = match &plugin.source { + PluginSource::File { path } => ("file", Some(path.display().to_string()), None), + PluginSource::Url { url, sha256 } => ("url", Some(url.clone()), sha256.clone()), + }; + + let now = now_rfc3339(); + let sql = adapt_sql( + "INSERT INTO plugins (id, source, url, sha256, enabled, loaded_at, api_version) + VALUES (?, ?, ?, ?, 1, ?, ?) + ON CONFLICT (id) DO UPDATE SET + source = excluded.source, + url = excluded.url, + sha256 = excluded.sha256, + loaded_at = excluded.loaded_at, + api_version = excluded.api_version", + self.db_backend, + ); + + sqlx::query(&sql) + .bind(&plugin.info.id) + .bind(source) + .bind(url) + .bind(sha256) + .bind(&now) + .bind(&plugin.info.api_version) + .execute(db) + .await?; + + Ok(()) + } + pub async fn get(&self, id: &str) -> Option> { self.plugins.read().await.get(id).cloned() } diff --git a/src/plugin/types.rs b/src/plugin/types.rs index f4debaf..0062f67 100644 --- a/src/plugin/types.rs +++ b/src/plugin/types.rs @@ -11,10 +11,18 @@ pub struct PluginInfo { pub icon_url: Option, #[serde(default)] pub required_secrets: Vec, + /// Authentication type: "oauth2", "openid", "api_key" + #[serde(default = "default_auth_type")] + pub auth_type: String, + /// JSON Schema describing user-provided configuration (e.g., API keys) #[serde(skip_serializing_if = "Option::is_none")] pub config_schema: Option, } +fn default_auth_type() -> String { + "oauth2".to_string() +} + /// OAuth callback parameters passed to handle_callback() #[derive(Debug, Clone, Serialize, Deserialize)] pub struct CallbackParams { diff --git a/web/next.config.ts b/web/next.config.ts index 0afe59b..93e2742 100644 --- a/web/next.config.ts +++ b/web/next.config.ts @@ -21,6 +21,7 @@ if (process.env.NODE_ENV === "production") { { source: "/health", destination: `${apiBase}/health` }, { source: "/config", destination: `${apiBase}/config` }, { source: "/oauth/:path*", destination: `${apiBase}/oauth/:path*` }, + { source: "/external-auth/:path*", destination: `${apiBase}/external-auth/:path*` }, ], afterFiles: [], fallback: [], diff --git a/web/src/app/dashboard/settings/accounts/page.tsx b/web/src/app/dashboard/settings/accounts/page.tsx new file mode 100644 index 0000000..65c3400 --- /dev/null +++ b/web/src/app/dashboard/settings/accounts/page.tsx @@ -0,0 +1,435 @@ +"use client"; + +import { useCallback, useEffect, useState } from "react"; +import { Link2, Unlink, RefreshCw, ExternalLink, Key } from "lucide-react"; + +import { + getExternalProviders, + getLinkedAccounts, + authorizeExternal, + syncExternal, + unlinkExternal, + connectWithConfig, +} from "@/lib/api"; +import type { ExternalProvider, LinkedAccount } from "@/types/external-accounts"; +import { Input } from "@/components/ui/input"; +import { Label } from "@/components/ui/label"; +import { SiteHeader } from "@/components/site-header"; +import { Button } from "@/components/ui/button"; +import { Badge } from "@/components/ui/badge"; +import { + ResponsiveDialog, + ResponsiveDialogClose, + ResponsiveDialogContent, + ResponsiveDialogDescription, + ResponsiveDialogFooter, + ResponsiveDialogHeader, + ResponsiveDialogTitle, +} from "@/components/ui/responsive-dialog"; +import { + Table, + TableBody, + TableCell, + TableHead, + TableHeader, + TableRow, +} from "@/components/ui/table"; +import { + Card, + CardContent, + CardDescription, + CardHeader, + CardTitle, +} from "@/components/ui/card"; + +export default function LinkedAccountsPage() { + const [providers, setProviders] = useState([]); + const [accounts, setAccounts] = useState([]); + const [error, setError] = useState(null); + const [unlinkId, setUnlinkId] = useState(null); + const [unlinking, setUnlinking] = useState(false); + const [syncing, setSyncing] = useState(null); + const [syncResult, setSyncResult] = useState<{ pluginId: string; written: number } | null>(null); + // API key config dialog state + const [configProvider, setConfigProvider] = useState(null); + const [configValues, setConfigValues] = useState>({}); + const [connecting, setConnecting] = useState(false); + + const load = useCallback(async () => { + try { + const [providerList, accountList] = await Promise.all([ + getExternalProviders(), + getLinkedAccounts(), + ]); + setProviders(providerList); + setAccounts(accountList); + setError(null); + } catch (e) { + setError(e instanceof Error ? e.message : String(e)); + } + }, []); + + useEffect(() => { + load(); + }, [load]); + + async function handleConnect(pluginId: string) { + const provider = providers.find((p) => p.id === pluginId); + if (!provider) return; + + // For API key auth, show config dialog instead of redirecting + if (provider.auth_type === "api_key" && provider.config_schema) { + setConfigProvider(provider); + setConfigValues({}); + return; + } + + // For OAuth/OpenID, redirect to provider + try { + const redirectUri = window.location.href; + const result = await authorizeExternal(pluginId, redirectUri); + window.location.href = result.authorize_url; + } catch (e) { + setError(e instanceof Error ? e.message : String(e)); + } + } + + async function handleConfigSubmit() { + if (!configProvider) return; + + setConnecting(true); + setError(null); + try { + await connectWithConfig(configProvider.id, configValues); + setConfigProvider(null); + setConfigValues({}); + load(); + } catch (e) { + setError(e instanceof Error ? e.message : String(e)); + } finally { + setConnecting(false); + } + } + + async function handleSync(pluginId: string) { + setSyncing(pluginId); + setSyncResult(null); + try { + const result = await syncExternal(pluginId); + setSyncResult({ pluginId, written: result.written }); + setError(null); + } catch (e) { + setError(e instanceof Error ? e.message : String(e)); + } finally { + setSyncing(null); + } + } + + async function handleUnlink(pluginId: string) { + setUnlinking(true); + try { + await unlinkExternal(pluginId); + setUnlinkId(null); + load(); + } catch (e) { + setError(e instanceof Error ? e.message : String(e)); + } finally { + setUnlinking(false); + } + } + + // Build a map of linked accounts by plugin_id + const linkedByPlugin = new Map(accounts.map((a) => [a.plugin_id, a])); + + return ( + <> + +
+ {error &&

{error}

} + + {syncResult && ( +
+

+ Sync complete: {syncResult.written} records written to your PDS +

+
+ )} + +
+

External Account Providers

+

+ Connect external platforms to sync data to your AT Protocol repository. +

+
+ + {providers.length === 0 ? ( + + + No Providers Available + + No external account plugins are currently loaded. Contact your + administrator to install plugins. + + + + ) : ( +
+ {providers.map((provider) => { + const linked = linkedByPlugin.get(provider.id); + const isSyncing = syncing === provider.id; + + return ( + + +
+ + {provider.icon_url && ( + + )} + {provider.name} + + {linked && ( + + Connected + + )} +
+ + + {linked ? ( +
+
+ Account ID:{" "} + {linked.account_id} +
+
+ Connected {new Date(linked.created_at).toLocaleDateString()} +
+
+ + +
+
+ ) : ( + + )} + + + ); + })} +
+ )} + + {accounts.length > 0 && ( + <> +
+

Connected Accounts

+

+ Your linked external accounts and their sync status. +

+
+ +
+ + + + Provider + Account ID + Connected + Last Updated + + + + + {accounts.map((account) => { + const provider = providers.find( + (p) => p.id === account.plugin_id + ); + const isSyncing = syncing === account.plugin_id; + + return ( + + + {provider?.name ?? account.plugin_id} + + + {account.account_id} + + + {new Date(account.created_at).toLocaleString()} + + + {new Date(account.updated_at).toLocaleString()} + + +
+ + +
+ + + ); + })} + +
+
+ + )} +
+ + { + if (!open) setUnlinkId(null); + }} + > + + + Unlink account? + + This will disconnect your external account and remove the stored + credentials. You can reconnect at any time. + + + {unlinkId && ( +

+ Provider:{" "} + + {providers.find((p) => p.id === unlinkId)?.name ?? unlinkId} + +

+ )} + + + + + + + + + + {/* API Key / Config Dialog */} + { + if (!open) { + setConfigProvider(null); + setConfigValues({}); + } + }} + > + + + + {configProvider?.icon_url && ( + + )} + Connect {configProvider?.name} + + + Enter your credentials to connect this account. + + + + {configProvider?.config_schema && ( +
+ {Object.entries(configProvider.config_schema.properties).map( + ([key, prop]) => ( +
+ + + setConfigValues((prev) => ({ + ...prev, + [key]: e.target.value, + })) + } + /> + {prop.description && ( +

+ {prop.description} +

+ )} +
+ ) + )} +
+ )} + + + + + + + + + + + ); +} diff --git a/web/src/components/app-sidebar.tsx b/web/src/components/app-sidebar.tsx index 19f5a05..4aa842f 100644 --- a/web/src/components/app-sidebar.tsx +++ b/web/src/components/app-sidebar.tsx @@ -14,6 +14,7 @@ import { IconTag, IconChevronRight, IconShield, + IconLink, } from "@tabler/icons-react" import Image from "next/image" import Link from "next/link" @@ -51,6 +52,7 @@ const navItems = [ const settingsSubItems = [ { title: "Users", url: "/dashboard/settings/users", icon: IconUsers, requiredPermissions: ["users:read"] }, + { title: "Linked Accounts", url: "/dashboard/settings/accounts", icon: IconLink, requiredPermissions: [] as string[] }, { title: "ENV Variables", url: "/dashboard/settings/env-variables", icon: IconVariable, requiredPermissions: ["script-variables:read"] }, { title: "API Keys", url: "/dashboard/settings/api-keys", icon: IconKey, requiredPermissions: ["api-keys:read"] }, { title: "Labelers", url: "/dashboard/settings/labelers", icon: IconTag, requiredPermissions: ["labelers:read"] }, @@ -70,6 +72,7 @@ export function AppSidebar({ }) const visibleSettingsItems = settingsSubItems.filter((item) => + item.requiredPermissions.length === 0 || item.requiredPermissions.some((perm) => hasPermission(perm)) ) diff --git a/web/src/lib/api.ts b/web/src/lib/api.ts index 4c9822b..1a6eafe 100644 --- a/web/src/lib/api.ts +++ b/web/src/lib/api.ts @@ -10,6 +10,14 @@ import type { EventsListResponse } from "@/types/events" import type { ScriptVariableSummary } from "@/types/script-variables" import type { LabelerSummary } from "@/types/labelers" import type { RateLimitsResponse } from "@/types/rate-limits" +import type { + ExternalProvider, + LinkedAccount, + AuthorizeResponse, + SyncResponse, + UnlinkResponse, + ConnectResponse, +} from "@/types/external-accounts" export type { ApiKeySummary, CreateApiKeyResponse } from "@/types/api-keys" export type { CollectionStat, StatsResponse } from "@/types/stats" @@ -24,6 +32,16 @@ export type { ScriptVariableSummary } from "@/types/script-variables" export type { LabelerSummary } from "@/types/labelers" export type { RecordLabel } from "@/types/records" export type { AllowlistEntry, RateLimitsResponse } from "@/types/rate-limits" +export type { + ExternalProvider, + LinkedAccount, + AuthorizeResponse, + SyncResponse, + UnlinkResponse, + ConnectResponse, + ConfigSchema, + ConfigProperty, +} from "@/types/external-accounts" export class ApiError extends Error { status: number @@ -374,3 +392,40 @@ export function getEvents( `/admin/events${qs ? `?${qs}` : ""}`, ) } + +// External Accounts +export function getExternalProviders() { + return apiFetch("/external-auth/providers") +} + +export function getLinkedAccounts() { + return apiFetch("/external-auth/accounts") +} + +export function authorizeExternal(pluginId: string, redirectUri: string) { + const params = new URLSearchParams({ redirect_uri: redirectUri }) + return apiFetch( + `/external-auth/${encodeURIComponent(pluginId)}/authorize?${params}`, + ) +} + +export function syncExternal(pluginId: string) { + return apiFetch( + `/external-auth/${encodeURIComponent(pluginId)}/sync`, + { method: "POST" }, + ) +} + +export function unlinkExternal(pluginId: string) { + return apiFetch( + `/external-auth/${encodeURIComponent(pluginId)}/unlink`, + { method: "POST" }, + ) +} + +export function connectWithConfig(pluginId: string, config: Record) { + return apiFetch( + `/external-auth/${encodeURIComponent(pluginId)}/connect`, + { method: "POST", body: JSON.stringify({ config }) }, + ) +} diff --git a/web/src/types/external-accounts.ts b/web/src/types/external-accounts.ts new file mode 100644 index 0000000..0e1de5d --- /dev/null +++ b/web/src/types/external-accounts.ts @@ -0,0 +1,51 @@ +export interface ExternalProvider { + id: string + name: string + icon_url: string | null + auth_type: "oauth2" | "openid" | "api_key" + config_schema?: ConfigSchema +} + +/** JSON Schema for plugin configuration */ +export interface ConfigSchema { + type: "object" + required?: string[] + properties: Record +} + +export interface ConfigProperty { + type: "string" | "number" | "boolean" + title?: string + description?: string + format?: "password" | "uri" | "email" + default?: unknown +} + +export interface LinkedAccount { + plugin_id: string + account_id: string + created_at: string + updated_at: string +} + +export interface AuthorizeResponse { + authorize_url: string + state: string +} + +export interface SyncResponse { + status: string + processed: number + written: number +} + +export interface UnlinkResponse { + status: string + was_linked: boolean +} + +export interface ConnectResponse { + status: string + account_id: string + display_name: string | null +} -- 2.51.2 From 3842d07aef1b46b1de6e9d45dd4adf2ece04d42f Mon Sep 17 00:00:00 2001 From: Trezy Date: Fri, 20 Mar 2026 15:09:30 -0500 Subject: [PATCH 5/6] fix: remove sqlite db from git --- .gitignore | 1 + src/plugin/loader.rs | 1 + tests/plugin_executor.rs | 1 + tests/plugin_integration.rs | 2 ++ 4 files changed, 5 insertions(+) diff --git a/.gitignore b/.gitignore index 0f30717..c12f691 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,5 @@ .DS_Store +/data /target .env web/node_modules/ diff --git a/src/plugin/loader.rs b/src/plugin/loader.rs index a4f9374..7ca71b8 100644 --- a/src/plugin/loader.rs +++ b/src/plugin/loader.rs @@ -271,6 +271,7 @@ mod tests { api_version: "1".into(), icon_url: None, required_secrets: vec![], + auth_type: "oauth2".into(), config_schema: None, }; diff --git a/tests/plugin_executor.rs b/tests/plugin_executor.rs index 71cc06a..570f078 100644 --- a/tests/plugin_executor.rs +++ b/tests/plugin_executor.rs @@ -51,6 +51,7 @@ fn load_test_plugin() -> LoadedPlugin { api_version: "1".into(), icon_url: None, required_secrets: vec![], + auth_type: "oauth2".into(), config_schema: None, }, source: PluginSource::File { diff --git a/tests/plugin_integration.rs b/tests/plugin_integration.rs index 14f1707..a8f0ea4 100644 --- a/tests/plugin_integration.rs +++ b/tests/plugin_integration.rs @@ -18,6 +18,7 @@ async fn test_plugin_registry_crud() { api_version: "1".into(), icon_url: None, required_secrets: vec![], + auth_type: "oauth2".into(), config_schema: None, }, source: PluginSource::File { @@ -59,6 +60,7 @@ async fn test_plugin_registry_multiple() { api_version: "1".into(), icon_url: None, required_secrets: vec![], + auth_type: "oauth2".into(), config_schema: None, }, source: PluginSource::File { -- 2.51.2 From d116ec00c037b15fc2a25446c7fc010d496252b8 Mon Sep 17 00:00:00 2001 From: Trezy Date: Fri, 20 Mar 2026 15:45:48 -0500 Subject: [PATCH 6/6] chore: move plugins to their own repo --- plugins/steam/.gitignore | 1 - plugins/steam/Cargo.lock | 107 ------ plugins/steam/Cargo.toml | 15 - plugins/steam/src/lib.rs | 738 --------------------------------------- 4 files changed, 861 deletions(-) delete mode 100644 plugins/steam/.gitignore delete mode 100644 plugins/steam/Cargo.lock delete mode 100644 plugins/steam/Cargo.toml delete mode 100644 plugins/steam/src/lib.rs diff --git a/plugins/steam/.gitignore b/plugins/steam/.gitignore deleted file mode 100644 index b83d222..0000000 --- a/plugins/steam/.gitignore +++ /dev/null @@ -1 +0,0 @@ -/target/ diff --git a/plugins/steam/Cargo.lock b/plugins/steam/Cargo.lock deleted file mode 100644 index 6895834..0000000 --- a/plugins/steam/Cargo.lock +++ /dev/null @@ -1,107 +0,0 @@ -# This file is automatically @generated by Cargo. -# It is not intended for manual editing. -version = 4 - -[[package]] -name = "itoa" -version = "1.0.18" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" - -[[package]] -name = "memchr" -version = "2.8.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79" - -[[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 = "quote" -version = "1.0.45" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924" -dependencies = [ - "proc-macro2", -] - -[[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 = "steam-plugin" -version = "0.1.0" -dependencies = [ - "serde", - "serde_json", -] - -[[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 = "unicode-ident" -version = "1.0.24" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75" - -[[package]] -name = "zmij" -version = "1.0.21" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa" diff --git a/plugins/steam/Cargo.toml b/plugins/steam/Cargo.toml deleted file mode 100644 index 3bed82e..0000000 --- a/plugins/steam/Cargo.toml +++ /dev/null @@ -1,15 +0,0 @@ -[package] -name = "steam-plugin" -version = "0.1.0" -edition = "2021" - -[lib] -crate-type = ["cdylib"] - -[dependencies] -serde = { version = "1", default-features = false, features = ["derive", "alloc"] } -serde_json = { version = "1", default-features = false, features = ["alloc"] } - -[profile.release] -opt-level = "s" -lto = true diff --git a/plugins/steam/src/lib.rs b/plugins/steam/src/lib.rs deleted file mode 100644 index cd41de1..0000000 --- a/plugins/steam/src/lib.rs +++ /dev/null @@ -1,738 +0,0 @@ -// Steam Plugin for HappyView -// Uses OpenID 2.0 for authentication and Steam Web API for data - -#![cfg_attr(target_arch = "wasm32", no_std)] -#![allow(static_mut_refs)] - -#[cfg(target_arch = "wasm32")] -extern crate alloc; - -#[cfg(target_arch = "wasm32")] -use alloc::{format, string::String, string::ToString, vec::Vec}; - -#[cfg(target_arch = "wasm32")] -use core::alloc::{GlobalAlloc, Layout}; - -use serde::{Deserialize, Serialize}; - -// ============================================================================ -// Memory Management (WASM only) -// ============================================================================ - -#[cfg(target_arch = "wasm32")] -struct BumpAllocator; - -#[cfg(target_arch = "wasm32")] -const HEAP_SIZE: usize = 131072; // 128KB - -#[cfg(target_arch = "wasm32")] -static mut HEAP: [u8; HEAP_SIZE] = [0; HEAP_SIZE]; - -#[cfg(target_arch = "wasm32")] -static mut HEAP_POS: usize = 0; - -#[cfg(target_arch = "wasm32")] -unsafe impl GlobalAlloc for BumpAllocator { - unsafe fn alloc(&self, layout: Layout) -> *mut u8 { - let size = layout.size(); - let align = layout.align(); - let pos = (HEAP_POS + align - 1) & !(align - 1); - if pos + size > HEAP_SIZE { - return core::ptr::null_mut(); - } - HEAP_POS = pos + size; - HEAP.as_mut_ptr().add(pos) - } - - unsafe fn dealloc(&self, _ptr: *mut u8, _layout: Layout) { - // No-op for bump allocator - } -} - -#[cfg(target_arch = "wasm32")] -#[global_allocator] -static ALLOCATOR: BumpAllocator = BumpAllocator; - -#[cfg(target_arch = "wasm32")] -#[panic_handler] -fn panic(_info: &core::panic::PanicInfo) -> ! { - loop {} -} - -// ============================================================================ -// Host Function Imports -// ============================================================================ - -#[cfg(target_arch = "wasm32")] -extern "C" { - fn host_http_request(req_ptr: i32, req_len: i32) -> i64; - fn host_get_secret(name_ptr: i32, name_len: i32) -> i64; -} - -// ============================================================================ -// Memory Exports -// ============================================================================ - -#[no_mangle] -pub extern "C" fn alloc(size: u32) -> u32 { - #[cfg(target_arch = "wasm32")] - { - let layout = Layout::from_size_align(size as usize, 1).unwrap(); - unsafe { ALLOCATOR.alloc(layout) as u32 } - } - #[cfg(not(target_arch = "wasm32"))] - { - let _ = size; - 0 - } -} - -#[no_mangle] -pub extern "C" fn dealloc(_ptr: u32, _size: u32) { - // No-op for bump allocator -} - -// ============================================================================ -// Helper Functions -// ============================================================================ - -fn return_json(s: &str) -> i64 { - let ptr = alloc(s.len() as u32); - if ptr == 0 { - return 0; - } - #[cfg(target_arch = "wasm32")] - unsafe { - core::ptr::copy_nonoverlapping(s.as_ptr(), ptr as *mut u8, s.len()); - } - ((ptr as i64) << 32) | (s.len() as i64) -} - -fn return_ok(value: &T) -> i64 { - let json = serde_json::to_string(&Response::Ok(value)).unwrap_or_default(); - return_json(&json) -} - -fn return_error(code: &str, message: &str, retryable: bool) -> i64 { - let err = ErrorResponse { - code: code.into(), - message: message.into(), - retryable, - }; - let json = serde_json::to_string(&Response::<()>::Err(err)).unwrap_or_default(); - return_json(&json) -} - -#[cfg(target_arch = "wasm32")] -fn read_input(ptr: u32, len: u32) -> Option> { - if len == 0 || len > 1024 * 1024 { - return None; - } - let slice = unsafe { core::slice::from_raw_parts(ptr as *const u8, len as usize) }; - Some(slice.to_vec()) -} - -#[cfg(target_arch = "wasm32")] -fn read_host_response(packed: i64) -> Option> { - if packed == 0 { - return None; - } - let ptr = (packed >> 32) as u32; - let len = (packed & 0xFFFFFFFF) as u32; - if len == 0 || len > 10 * 1024 * 1024 { - return None; - } - let slice = unsafe { core::slice::from_raw_parts(ptr as *const u8, len as usize) }; - Some(slice.to_vec()) -} - -#[cfg(target_arch = "wasm32")] -fn get_secret(name: &str) -> Option { - let packed = unsafe { host_get_secret(name.as_ptr() as i32, name.len() as i32) }; - let bytes = read_host_response(packed)?; - // Host returns JSON: {"ok": "value"} or {"error": ...} - let resp: Response = serde_json::from_slice(&bytes).ok()?; - match resp { - Response::Ok(val) => Some(val), - Response::Err(_) => None, - } -} - -#[cfg(target_arch = "wasm32")] -fn http_get(url: &str) -> Result { - let req = HttpRequest { - method: "GET".into(), - url: url.into(), - headers: alloc::vec![], - body: None, - }; - let req_json = serde_json::to_string(&req).map_err(|e| format!("serialize: {}", e))?; - let packed = unsafe { host_http_request(req_json.as_ptr() as i32, req_json.len() as i32) }; - let bytes = read_host_response(packed).ok_or("no response")?; - let resp: Response = - serde_json::from_slice(&bytes).map_err(|e| format!("parse: {}", e))?; - match resp { - Response::Ok(r) => r.body.ok_or_else(|| "empty body".into()), - Response::Err(e) => Err(e.message), - } -} - -#[cfg(target_arch = "wasm32")] -fn http_post(url: &str, body: &str, content_type: &str) -> Result { - let req = HttpRequest { - method: "POST".into(), - url: url.into(), - headers: alloc::vec![("Content-Type".into(), content_type.into())], - body: Some(body.into()), - }; - let req_json = serde_json::to_string(&req).map_err(|e| format!("serialize: {}", e))?; - let packed = unsafe { host_http_request(req_json.as_ptr() as i32, req_json.len() as i32) }; - let bytes = read_host_response(packed).ok_or("no response")?; - let resp: Response = - serde_json::from_slice(&bytes).map_err(|e| format!("parse: {}", e))?; - match resp { - Response::Ok(r) => r.body.ok_or_else(|| "empty body".into()), - Response::Err(e) => Err(e.message), - } -} - -// ============================================================================ -// Types -// ============================================================================ - -#[derive(Serialize, Deserialize)] -#[serde(untagged)] -enum Response { - Ok(T), - Err(ErrorResponse), -} - -#[derive(Serialize, Deserialize)] -struct ErrorResponse { - code: String, - message: String, - retryable: bool, -} - -#[derive(Serialize, Deserialize)] -struct PluginInfo { - id: String, - name: String, - version: String, - api_version: String, - icon_url: Option, - required_secrets: Vec, - config_schema: Option, -} - -#[derive(Serialize, Deserialize)] -struct AuthorizeInput { - state: String, - redirect_uri: String, - config: serde_json::Value, -} - -#[derive(Serialize, Deserialize)] -struct CallbackInput { - code: Option, - state: String, - config: serde_json::Value, - #[serde(flatten)] - extra: serde_json::Map, -} - -#[derive(Serialize, Deserialize)] -struct TokenSet { - access_token: String, - token_type: String, - expires_at: Option, - refresh_token: Option, -} - -#[derive(Serialize, Deserialize)] -struct ProfileInput { - access_token: String, - config: serde_json::Value, -} - -#[derive(Serialize, Deserialize)] -struct ExternalProfile { - account_id: String, - display_name: Option, - profile_url: Option, - avatar_url: Option, -} - -#[derive(Serialize, Deserialize)] -struct SyncInput { - access_token: String, - config: serde_json::Value, -} - -#[derive(Serialize, Deserialize)] -struct SyncRecord { - collection: String, - record: serde_json::Value, - dedup_key: Option, - /// Whether HappyView should add an attestation signature - sign: bool, -} - -#[derive(Serialize, Deserialize)] -struct HttpRequest { - method: String, - url: String, - headers: Vec<(String, String)>, - body: Option, -} - -#[derive(Serialize, Deserialize)] -struct HttpResponse { - status: u16, - headers: Vec<(String, String)>, - body: Option, -} - -// Steam API types -#[derive(Deserialize)] -struct SteamOwnedGamesResponse { - response: SteamOwnedGames, -} - -#[derive(Deserialize)] -#[allow(dead_code)] -struct SteamOwnedGames { - game_count: Option, - games: Option>, -} - -#[derive(Deserialize)] -#[allow(dead_code)] -struct SteamGame { - appid: u64, - name: Option, - playtime_forever: Option, - img_icon_url: Option, - playtime_2weeks: Option, -} - -#[derive(Deserialize)] -struct SteamPlayerSummary { - response: SteamPlayersResponse, -} - -#[derive(Deserialize)] -struct SteamPlayersResponse { - players: Vec, -} - -#[derive(Deserialize)] -struct SteamPlayer { - steamid: String, - personaname: Option, - profileurl: Option, - avatarfull: Option, -} - -// ============================================================================ -// Steam OpenID 2.0 Constants -// ============================================================================ - -const STEAM_OPENID_URL: &str = "https://steamcommunity.com/openid/login"; -const STEAM_API_BASE: &str = "https://api.steampowered.com"; - -// ============================================================================ -// Plugin Exports -// ============================================================================ - -#[no_mangle] -pub extern "C" fn plugin_info() -> i64 { - let info = PluginInfo { - id: "steam".into(), - name: "Steam".into(), - version: "0.1.0".into(), - api_version: "1".into(), - icon_url: Some("https://store.steampowered.com/favicon.ico".into()), - required_secrets: alloc::vec!["API_KEY".into()], - config_schema: None, - }; - return_ok(&info) -} - -#[no_mangle] -pub extern "C" fn get_authorize_url(ptr: u32, len: u32) -> i64 { - #[cfg(target_arch = "wasm32")] - { - let bytes = match read_input(ptr, len) { - Some(b) => b, - None => return return_error("INVALID_INPUT", "Failed to read input", false), - }; - - let input: AuthorizeInput = match serde_json::from_slice(&bytes) { - Ok(i) => i, - Err(e) => return return_error("INVALID_INPUT", &format!("Parse error: {}", e), false), - }; - - // Build OpenID 2.0 authentication URL - // Steam uses claimed_id and identity as the same value for authentication - let params = [ - ("openid.ns", "http://specs.openid.net/auth/2.0"), - ("openid.mode", "checkid_setup"), - ( - "openid.return_to", - &format!("{}?state={}", input.redirect_uri, input.state), - ), - ("openid.realm", &input.redirect_uri), - ( - "openid.identity", - "http://specs.openid.net/auth/2.0/identifier_select", - ), - ( - "openid.claimed_id", - "http://specs.openid.net/auth/2.0/identifier_select", - ), - ]; - - let query: String = params - .iter() - .map(|(k, v)| format!("{}={}", k, urlencod(v))) - .collect::>() - .join("&"); - - let url = format!("{}?{}", STEAM_OPENID_URL, query); - return_ok(&url) - } - - #[cfg(not(target_arch = "wasm32"))] - { - let _ = (ptr, len); - return_error("NOT_WASM", "Only runs in WASM", false) - } -} - -#[no_mangle] -pub extern "C" fn handle_callback(ptr: u32, len: u32) -> i64 { - #[cfg(target_arch = "wasm32")] - { - let bytes = match read_input(ptr, len) { - Some(b) => b, - None => return return_error("INVALID_INPUT", "Failed to read input", false), - }; - - let input: CallbackInput = match serde_json::from_slice(&bytes) { - Ok(i) => i, - Err(e) => return return_error("INVALID_INPUT", &format!("Parse error: {}", e), false), - }; - - // Extract Steam ID from openid.claimed_id - // Format: https://steamcommunity.com/openid/id/76561198012345678 - let claimed_id = input - .extra - .get("openid.claimed_id") - .and_then(|v| v.as_str()); - - let steam_id = match claimed_id { - Some(id) => { - if let Some(pos) = id.rfind('/') { - &id[pos + 1..] - } else { - return return_error("INVALID_RESPONSE", "Invalid claimed_id format", false); - } - } - None => { - return return_error("INVALID_RESPONSE", "Missing openid.claimed_id", false); - } - }; - - // Verify the OpenID response with Steam - // Build verification request by changing mode to check_authentication - // and POSTing all params back to Steam - let mut verify_params: Vec<(&str, &str)> = Vec::new(); - verify_params.push(("openid.mode", "check_authentication")); - - // Add all openid.* params from the callback (except mode) - for (key, value) in &input.extra { - if key.starts_with("openid.") && key != "openid.mode" { - if let Some(v) = value.as_str() { - verify_params.push((key.as_str(), v)); - } - } - } - - // Build POST body - let verify_body: String = verify_params - .iter() - .map(|(k, v)| format!("{}={}", k, urlencod(v))) - .collect::>() - .join("&"); - - // POST to Steam for verification - let verify_result = http_post( - STEAM_OPENID_URL, - &verify_body, - "application/x-www-form-urlencoded", - ); - - match verify_result { - Ok(response_body) => { - // Steam returns key-value pairs, one per line - // We need to find "is_valid:true" - if !response_body.contains("is_valid:true") { - return return_error( - "VERIFICATION_FAILED", - "Steam OpenID verification failed", - false, - ); - } - } - Err(e) => { - return return_error( - "VERIFICATION_ERROR", - &format!("Failed to verify with Steam: {}", e), - true, - ); - } - } - - // Return the Steam ID as the "access_token" - // Since Steam uses OpenID 2.0 (not OAuth), there's no real token - // We store the Steam ID so we can use it with our API key - let tokens = TokenSet { - access_token: steam_id.into(), - token_type: "SteamID".into(), - expires_at: None, - refresh_token: None, - }; - - return_ok(&tokens) - } - - #[cfg(not(target_arch = "wasm32"))] - { - let _ = (ptr, len); - return_error("NOT_WASM", "Only runs in WASM", false) - } -} - -#[no_mangle] -pub extern "C" fn refresh_tokens(ptr: u32, len: u32) -> i64 { - // Steam doesn't use OAuth tokens - the Steam ID is permanent - #[cfg(target_arch = "wasm32")] - { - let bytes = match read_input(ptr, len) { - Some(b) => b, - None => return return_error("INVALID_INPUT", "Failed to read input", false), - }; - - #[derive(Deserialize)] - struct RefreshInput { - refresh_token: String, - #[allow(dead_code)] - config: serde_json::Value, - } - - let input: RefreshInput = match serde_json::from_slice(&bytes) { - Ok(i) => i, - Err(e) => return return_error("INVALID_INPUT", &format!("Parse error: {}", e), false), - }; - - // Just return the same Steam ID - it doesn't expire - let tokens = TokenSet { - access_token: input.refresh_token, - token_type: "SteamID".into(), - expires_at: None, - refresh_token: None, - }; - - return_ok(&tokens) - } - - #[cfg(not(target_arch = "wasm32"))] - { - let _ = (ptr, len); - return_error("NOT_WASM", "Only runs in WASM", false) - } -} - -#[no_mangle] -pub extern "C" fn get_profile(ptr: u32, len: u32) -> i64 { - #[cfg(target_arch = "wasm32")] - { - let bytes = match read_input(ptr, len) { - Some(b) => b, - None => return return_error("INVALID_INPUT", "Failed to read input", false), - }; - - let input: ProfileInput = match serde_json::from_slice(&bytes) { - Ok(i) => i, - Err(e) => return return_error("INVALID_INPUT", &format!("Parse error: {}", e), false), - }; - - let api_key = match get_secret("API_KEY") { - Some(k) => k, - None => return return_error("MISSING_SECRET", "API_KEY not configured", false), - }; - - let steam_id = &input.access_token; - let url = format!( - "{}/ISteamUser/GetPlayerSummaries/v2/?key={}&steamids={}", - STEAM_API_BASE, api_key, steam_id - ); - - let body = match http_get(&url) { - Ok(b) => b, - Err(e) => return return_error("HTTP_ERROR", &e, true), - }; - - let resp: SteamPlayerSummary = match serde_json::from_str(&body) { - Ok(r) => r, - Err(e) => { - return return_error("INVALID_RESPONSE", &format!("Parse error: {}", e), false) - } - }; - - let player = match resp.response.players.first() { - Some(p) => p, - None => return return_error("NOT_FOUND", "Player not found", false), - }; - - let profile = ExternalProfile { - account_id: player.steamid.clone(), - display_name: player.personaname.clone(), - profile_url: player.profileurl.clone(), - avatar_url: player.avatarfull.clone(), - }; - - return_ok(&profile) - } - - #[cfg(not(target_arch = "wasm32"))] - { - let _ = (ptr, len); - return_error("NOT_WASM", "Only runs in WASM", false) - } -} - -#[no_mangle] -pub extern "C" fn sync_account(ptr: u32, len: u32) -> i64 { - #[cfg(target_arch = "wasm32")] - { - let bytes = match read_input(ptr, len) { - Some(b) => b, - None => return return_error("INVALID_INPUT", "Failed to read input", false), - }; - - let input: SyncInput = match serde_json::from_slice(&bytes) { - Ok(i) => i, - Err(e) => return return_error("INVALID_INPUT", &format!("Parse error: {}", e), false), - }; - - let api_key = match get_secret("API_KEY") { - Some(k) => k, - None => return return_error("MISSING_SECRET", "API_KEY not configured", false), - }; - - let steam_id = &input.access_token; - let url = format!( - "{}/IPlayerService/GetOwnedGames/v1/?key={}&steamid={}&include_appinfo=true&include_played_free_games=true", - STEAM_API_BASE, api_key, steam_id - ); - - let body = match http_get(&url) { - Ok(b) => b, - Err(e) => return return_error("HTTP_ERROR", &e, true), - }; - - let resp: SteamOwnedGamesResponse = match serde_json::from_str(&body) { - Ok(r) => r, - Err(e) => { - return return_error("INVALID_RESPONSE", &format!("Parse error: {}", e), false) - } - }; - - let games = resp.response.games.unwrap_or_default(); - - let mut records: Vec = Vec::new(); - - for game in games { - let appid_str = game.appid.to_string(); - - // 1. Create actor.game record (ownership) - // HappyView will resolve game reference and add attestation signature - let game_record = serde_json::json!({ - "$type": "games.gamesgamesgamesgames.actor.game", - "game": { - "platform": "steam", - "externalId": &appid_str, - }, - "platform": "steam", - "createdAt": chrono_now(), - }); - - records.push(SyncRecord { - collection: "games.gamesgamesgamesgames.actor.game".into(), - record: game_record, - dedup_key: Some(format!("steam:game:{}", game.appid)), - sign: true, - }); - - // 2. Create actor.stats record (playtime) - // HappyView will add attestation signature - if let Some(playtime) = game.playtime_forever { - if playtime > 0 { - let stats_record = serde_json::json!({ - "$type": "games.gamesgamesgamesgames.actor.stats", - "game": { - "platform": "steam", - "externalId": &appid_str, - }, - "source": "steam", - "playtime": playtime, - "createdAt": chrono_now(), - }); - - records.push(SyncRecord { - collection: "games.gamesgamesgamesgames.actor.stats".into(), - record: stats_record, - dedup_key: Some(format!("steam:stats:{}", game.appid)), - sign: true, - }); - } - } - } - - return_ok(&records) - } - - #[cfg(not(target_arch = "wasm32"))] - { - let _ = (ptr, len); - return_error("NOT_WASM", "Only runs in WASM", false) - } -} - -// ============================================================================ -// Utility Functions -// ============================================================================ - -fn urlencod(s: &str) -> String { - let mut result = String::new(); - for c in s.chars() { - match c { - 'a'..='z' | 'A'..='Z' | '0'..='9' | '-' | '_' | '.' | '~' => { - result.push(c); - } - _ => { - for b in c.to_string().as_bytes() { - result.push_str(&format!("%{:02X}", b)); - } - } - } - } - result -} - -fn chrono_now() -> String { - // Simple ISO 8601 timestamp - in real impl would use proper time - "2024-01-01T00:00:00Z".into() -} -- 2.51.2