notplants.bsky.social / git-remote-pds
⚘ use your pds as a git remote if you want to ⚘
5
fork

Configure Feed

Select the types of activity you want to include in your feed.

finish rename

notplants fdd6195a ec9e745b

+90 -90
+23 -23
Cargo.lock
··· 840 840 ] 841 841 842 842 [[package]] 843 + name = "git-remote-pds" 844 + version = "0.1.0" 845 + dependencies = [ 846 + "anyhow", 847 + "atproto-identity", 848 + "atproto-oauth", 849 + "axum", 850 + "base64", 851 + "chrono", 852 + "clap", 853 + "elliptic-curve", 854 + "p256", 855 + "reqwest", 856 + "serde", 857 + "serde_json", 858 + "tempfile", 859 + "tokio", 860 + "tracing", 861 + "tracing-subscriber", 862 + "ulid", 863 + ] 864 + 865 + [[package]] 843 866 name = "group" 844 867 version = "0.13.0" 845 868 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 1513 1536 "redox_syscall", 1514 1537 "smallvec", 1515 1538 "windows-link", 1516 - ] 1517 - 1518 - [[package]] 1519 - name = "pds-git-remote" 1520 - version = "0.1.0" 1521 - dependencies = [ 1522 - "anyhow", 1523 - "atproto-identity", 1524 - "atproto-oauth", 1525 - "axum", 1526 - "base64", 1527 - "chrono", 1528 - "clap", 1529 - "elliptic-curve", 1530 - "p256", 1531 - "reqwest", 1532 - "serde", 1533 - "serde_json", 1534 - "tempfile", 1535 - "tokio", 1536 - "tracing", 1537 - "tracing-subscriber", 1538 - "ulid", 1539 1539 ] 1540 1540 1541 1541 [[package]]
+1 -1
Cargo.toml
··· 1 1 [package] 2 - name = "pds-git-remote" 2 + name = "git-remote-pds" 3 3 version = "0.1.0" 4 4 edition = "2024" 5 5
+1 -1
README.md
··· 83 83 84 84 ## Authentication 85 85 86 - git-remote-pds supports two ways to authenticate with a PDS. Credentials are stored per-handle in `~/.config/pds-git-remote/auth.json`. If you have multiple accounts, each handle has its own credential — git-remote-pds uses the matching handle from the `pds://handle/repo` URL. 86 + git-remote-pds supports two ways to authenticate with a PDS. Credentials are stored per-handle in `~/.config/git-remote-pds/auth.json`. If you have multiple accounts, each handle has its own credential — git-remote-pds uses the matching handle from the `pds://handle/repo` URL. 87 87 88 88 ### OAuth login (recommended) 89 89
+1 -1
e2e-tests/pds-dev/README.md
··· 1 1 # Local PDS for development 2 2 3 - Scripts for running an AT Protocol PDS server locally via Docker, used for integration testing of `pds-git-remote`. 3 + Scripts for running an AT Protocol PDS server locally via Docker, used for integration testing of `git-remote-pds`. 4 4 5 5 ## Quick start 6 6
+1 -1
e2e-tests/pds-dev/run-e2e.sh
··· 46 46 # run E2E tests 47 47 echo "" 48 48 echo "=== Running E2E tests ===" 49 - cargo test -p pds-git-remote --features e2e -- --test-threads=1 49 + cargo test -p git-remote-pds --features e2e -- --test-threads=1 50 50 51 51 echo "" 52 52 echo "=== All E2E tests passed ==="
+2 -2
e2e-tests/playwright-tests/conftest.py
··· 1 - """Pytest fixtures for pds-git-remote OAuth playwright tests. 1 + """Pytest fixtures for git-remote-pds OAuth playwright tests. 2 2 3 3 Provides test configuration, binary location, PDS session tokens, 4 4 and a shared Playwright browser context. ··· 64 64 @pytest.fixture(scope="session") 65 65 def auth_config_dir(): 66 66 """Create a temporary config directory for auth.json during tests.""" 67 - tmpdir = tempfile.mkdtemp(prefix="pds-git-remote-test-config-") 67 + tmpdir = tempfile.mkdtemp(prefix="git-remote-pds-test-config-") 68 68 yield tmpdir 69 69 # cleanup 70 70 import shutil
+8 -8
e2e-tests/playwright-tests/test_oauth_push.py
··· 1 - """End-to-end tests for pds-git-remote OAuth login and push. 1 + """End-to-end tests for git-remote-pds OAuth login and push. 2 2 3 3 Tests: 4 4 1. OAuth login via browser (Playwright automates PDS consent) ··· 145 145 146 146 # verify credentials were stored 147 147 auth_json_path = os.path.join( 148 - auth_config_dir, ".config", "pds-git-remote", "auth.json" 148 + auth_config_dir, ".config", "git-remote-pds", "auth.json" 149 149 ) 150 150 assert os.path.isfile(auth_json_path), ( 151 151 f"auth.json not found at {auth_json_path}" ··· 173 173 repo_name = f"playwright-test-{int(time.time())}" 174 174 175 175 # create a temp git repo with a test file 176 - repo_dir = tempfile.mkdtemp(prefix="pds-git-remote-push-test-") 176 + repo_dir = tempfile.mkdtemp(prefix="git-remote-pds-push-test-") 177 177 env = os.environ.copy() 178 178 env["HOME"] = auth_config_dir 179 179 env["PATH"] = debug_dir + ":" + env.get("PATH", "") ··· 214 214 print(f"Push successful to {pds_remote}") 215 215 216 216 # verify by cloning back with createSession token 217 - clone_dir = tempfile.mkdtemp(prefix="pds-git-remote-clone-test-") 217 + clone_dir = tempfile.mkdtemp(prefix="git-remote-pds-clone-test-") 218 218 clone_env = os.environ.copy() 219 219 clone_env["PATH"] = debug_dir + ":" + clone_env.get("PATH", "") 220 220 clone_env["PDS_ACCESS_TOKEN"] = pds_tokens["access_jwt"] ··· 257 257 # read the stored auth.json and expire the token 258 258 import json 259 259 auth_json_path = os.path.join( 260 - auth_config_dir, ".config", "pds-git-remote", "auth.json" 260 + auth_config_dir, ".config", "git-remote-pds", "auth.json" 261 261 ) 262 262 assert os.path.isfile(auth_json_path), ( 263 263 f"auth.json not found — test_oauth_login must run first" ··· 282 282 283 283 # create a repo and push — this should trigger token refresh 284 284 repo_name = f"playwright-refresh-{int(time.time())}" 285 - repo_dir = tempfile.mkdtemp(prefix="pds-git-remote-refresh-test-") 285 + repo_dir = tempfile.mkdtemp(prefix="git-remote-pds-refresh-test-") 286 286 env = os.environ.copy() 287 287 env["HOME"] = auth_config_dir 288 288 env["PATH"] = debug_dir + ":" + env.get("PATH", "") ··· 354 354 # create a unique repo name 355 355 repo_name = f"playwright-incr-{int(time.time())}" 356 356 357 - repo_dir = tempfile.mkdtemp(prefix="pds-git-remote-incr-test-") 357 + repo_dir = tempfile.mkdtemp(prefix="git-remote-pds-incr-test-") 358 358 env = os.environ.copy() 359 359 env["HOME"] = auth_config_dir 360 360 env["PATH"] = debug_dir + ":" + env.get("PATH", "") ··· 409 409 print("Incremental push successful") 410 410 411 411 # verify by cloning back 412 - clone_dir = tempfile.mkdtemp(prefix="pds-git-remote-incr-clone-") 412 + clone_dir = tempfile.mkdtemp(prefix="git-remote-pds-incr-clone-") 413 413 clone_env = os.environ.copy() 414 414 clone_env["PATH"] = debug_dir + ":" + clone_env.get("PATH", "") 415 415 clone_env["PDS_ACCESS_TOKEN"] = pds_tokens["access_jwt"]
+2 -2
e2e-tests/remote-test/MANUAL-TEST.md
··· 7 7 1. Build the binary: 8 8 9 9 ```bash 10 - cd pds-git-remote 10 + cd git-remote-pds 11 11 cargo build 12 12 ``` 13 13 ··· 130 130 PDS_URL=https://YOUR-PDS-URL \ 131 131 PDS_HANDLE=YOUR-HANDLE \ 132 132 PDS_PASSWORD=your-password \ 133 - bash pds-git-remote/e2e-tests/remote-test/run.sh 133 + bash git-remote-pds/e2e-tests/remote-test/run.sh 134 134 ```
+1 -1
e2e-tests/remote-test/run-dpop.sh
··· 64 64 65 65 # ── build the binary ───────────────────────────────────────────────── 66 66 echo "=== Building git-remote-pds ===" 67 - cargo build -p pds-git-remote --quiet 67 + cargo build -p git-remote-pds --quiet 68 68 BINARY="$(cargo metadata --format-version 1 --no-deps \ 69 69 | python3 -c 'import sys,json; print(json.load(sys.stdin)["target_directory"])')/debug/git-remote-pds" 70 70
+1 -1
e2e-tests/remote-test/run.sh
··· 54 54 55 55 # ── build the binary ───────────────────────────────────────────────── 56 56 echo "=== Building git-remote-pds ===" 57 - cargo build -p pds-git-remote --quiet 57 + cargo build -p git-remote-pds --quiet 58 58 BINARY="$(cargo metadata --format-version 1 --no-deps \ 59 59 | python3 -c 'import sys,json; print(json.load(sys.stdin)["target_directory"])')/debug/git-remote-pds" 60 60
+6 -6
nix.md
··· 3 3 ## Try it without installing 4 4 5 5 ```bash 6 - nix run git+https://codeberg.org/notplants/pds-git-remote 6 + nix run git+https://codeberg.org/notplants/git-remote-pds 7 7 ``` 8 8 9 9 ## Imperative install (user profile) 10 10 11 11 ```bash 12 - nix profile install git+https://codeberg.org/notplants/pds-git-remote 12 + nix profile install git+https://codeberg.org/notplants/git-remote-pds 13 13 ``` 14 14 15 15 Persists across reboots but lives outside your system configuration. ··· 23 23 { 24 24 inputs = { 25 25 # ... 26 - pds-git-remote = { 27 - url = "git+https://codeberg.org/notplants/pds-git-remote"; 26 + git-remote-pds = { 27 + url = "git+https://codeberg.org/notplants/git-remote-pds"; 28 28 inputs.nixpkgs.follows = "nixpkgs"; 29 29 }; 30 30 }; ··· 35 35 36 36 ```nix 37 37 environment.systemPackages = [ 38 - inputs.pds-git-remote.packages.${pkgs.system}.default 38 + inputs.git-remote-pds.packages.${pkgs.system}.default 39 39 ]; 40 40 ``` 41 41 ··· 47 47 48 48 ```nix 49 49 home.packages = [ 50 - inputs.pds-git-remote.packages.${pkgs.system}.default 50 + inputs.git-remote-pds.packages.${pkgs.system}.default 51 51 ]; 52 52 ```
+9 -9
plans/e2e-testing.md
··· 1 - # E2E Testing for pds-git-remote against Local PDS 1 + # E2E Testing for git-remote-pds against Local PDS 2 2 3 3 ## Context 4 4 5 - Phases 1-3.1 of pds-git-remote are implemented: core types, PDS client, bundle operations, push flow, and local PDS dev scripts. But the push tests only verify offline logic (empty repos, unreachable PDS, bundle creation). We need end-to-end tests that actually login to a PDS, upload blobs, write records, and verify the full push round-trip works. 5 + Phases 1-3.1 of git-remote-pds are implemented: core types, PDS client, bundle operations, push flow, and local PDS dev scripts. But the push tests only verify offline logic (empty repos, unreachable PDS, bundle creation). We need end-to-end tests that actually login to a PDS, upload blobs, write records, and verify the full push round-trip works. 6 6 7 7 ## Approach 8 8 9 9 ### 1. Add `e2e` feature flag to Cargo.toml 10 10 11 - **File:** `crates/pds-git-remote/Cargo.toml` 11 + **File:** `crates/git-remote-pds/Cargo.toml` 12 12 13 13 Add a `[features]` section with a marker feature: 14 14 ```toml ··· 20 20 21 21 ### 2. Create E2E test file 22 22 23 - **File:** `crates/pds-git-remote/tests/e2e_tests.rs` (new) 23 + **File:** `crates/git-remote-pds/tests/e2e_tests.rs` (new) 24 24 25 25 Gated with `#![cfg(feature = "e2e")]` at the module level. 26 26 ··· 50 50 1. `reset.sh` — clean slate 51 51 2. `start.sh` — start PDS, wait for health check 52 52 3. `create-account.sh` — create test account 53 - 4. `cargo test -p pds-git-remote --features e2e -- --test-threads=1` 53 + 4. `cargo test -p git-remote-pds --features e2e -- --test-threads=1` 54 54 5. `stop.sh` on exit (via `trap`, unless `--keep` flag passed) 55 55 56 56 Tests run serialized (`--test-threads=1`) since they share one PDS account. ··· 59 59 60 60 | File | Action | 61 61 |------|--------| 62 - | `crates/pds-git-remote/Cargo.toml` | Add `[features]` section | 63 - | `crates/pds-git-remote/tests/e2e_tests.rs` | New: 5 E2E tests + helpers | 62 + | `crates/git-remote-pds/Cargo.toml` | Add `[features]` section | 63 + | `crates/git-remote-pds/tests/e2e_tests.rs` | New: 5 E2E tests + helpers | 64 64 | `scripts/pds-dev/run-e2e.sh` | New: harness script | 65 65 66 66 ## Verification 67 67 68 - - `cargo test -p pds-git-remote --quiet` — existing 26 tests still pass (E2E tests not compiled) 69 - - `cargo test -p pds-git-remote --features e2e --quiet` — compiles E2E tests, skips gracefully if no PDS 68 + - `cargo test -p git-remote-pds --quiet` — existing 26 tests still pass (E2E tests not compiled) 69 + - `cargo test -p git-remote-pds --features e2e --quiet` — compiles E2E tests, skips gracefully if no PDS 70 70 - `./scripts/pds-dev/run-e2e.sh` — full E2E suite against real PDS (requires Docker) 71 71 - `cargo test -p lichen-cms -p lichen-server --quiet` — workspace unaffected
+5 -5
plans/oauth-plan.md
··· 1 - # OAuth Integration Plan for pds-git-remote 1 + # OAuth Integration Plan for git-remote-pds 2 2 3 3 ## Background 4 4 5 - pds-git-remote currently authenticates via AT Protocol's `com.atproto.server.createSession` endpoint (handle + app password). Credentials are stored as plaintext JSON in `~/.config/pds-git-remote/auth.json`. There is no token refresh logic — the stored `refresh_jwt` is never used. This works for development but has clear production shortcomings: plaintext secrets on disk, no session renewal, and requiring users to manage app passwords. 5 + git-remote-pds currently authenticates via AT Protocol's `com.atproto.server.createSession` endpoint (handle + app password). Credentials are stored as plaintext JSON in `~/.config/git-remote-pds/auth.json`. There is no token refresh logic — the stored `refresh_jwt` is never used. This works for development but has clear production shortcomings: plaintext secrets on disk, no session renewal, and requiring users to manage app passwords. 6 6 7 7 This document explores two distinct integration angles inspired by git-credential-oauth, evaluates their complexity and tradeoffs, and recommends a sequencing strategy. 8 8 ··· 34 34 35 35 ### Concept 36 36 37 - Instead of storing AT Protocol credentials in a custom `auth.json` file, store them through the standard Git credential helper infrastructure. This means pds-git-remote would call `git credential fill` / `git credential approve` / `git credential reject` to retrieve and persist tokens, leveraging whatever credential backend the user has configured (OS keychain, `git-credential-cache`, `pass`, etc.). 37 + Instead of storing AT Protocol credentials in a custom `auth.json` file, store them through the standard Git credential helper infrastructure. This means git-remote-pds would call `git credential fill` / `git credential approve` / `git credential reject` to retrieve and persist tokens, leveraging whatever credential backend the user has configured (OS keychain, `git-credential-cache`, `pass`, etc.). 38 38 39 39 ### What This Would Look Like 40 40 ··· 85 85 86 86 ### Concept 87 87 88 - Replace password-based `createSession` authentication with AT Protocol's native OAuth flow. Instead of users providing their handle and app password, pds-git-remote would open a browser, the user would authorize the application on their PDS, and pds-git-remote would receive scoped OAuth tokens. 88 + Replace password-based `createSession` authentication with AT Protocol's native OAuth flow. Instead of users providing their handle and app password, git-remote-pds would open a browser, the user would authorize the application on their PDS, and git-remote-pds would receive scoped OAuth tokens. 89 89 90 90 ### How AT Protocol OAuth Works 91 91 ··· 108 108 109 109 ### What It Would Require 110 110 111 - 1. **Client metadata document** — Host a JSON file at a public HTTPS URL (e.g., `https://pds-git-remote.example.com/oauth-client-metadata.json`) describing the application. For native/CLI apps, a `http://127.0.0.1` redirect URI is standard. Alternatively, use the `did:web:` client ID scheme if available. 111 + 1. **Client metadata document** — Host a JSON file at a public HTTPS URL (e.g., `https://git-remote-pds.example.com/oauth-client-metadata.json`) describing the application. For native/CLI apps, a `http://127.0.0.1` redirect URI is standard. Alternatively, use the `did:web:` client ID scheme if available. 112 112 113 113 2. **DPoP implementation** — Generate an ES256 keypair per session. Sign a DPoP proof JWT for every token request and every authenticated API call. Handle server-issued nonce rotation. This is the most complex piece. 114 114
+5 -5
plans/plan.md
··· 1 - # pds-git-remote 1 + # git-remote-pds 2 2 3 3 A Rust crate providing PDS-backed git remote functionality — uses AT Protocol PDS as a git backup backend via incremental bundles. 4 4 ··· 8 8 9 9 ## Overview 10 10 11 - `pds-git-remote` is a new crate in the lichen workspace (`crates/pds-git-remote`). It provides: 11 + `git-remote-pds` is a new crate in the lichen workspace (`crates/git-remote-pds`). It provides: 12 12 13 13 1. **A library** — core types, PDS API client, bundle operations, and push/pull logic that lichen-cms (and other crates) can call directly 14 14 2. **A git remote helper binary** (`git-remote-pds`) — so developers can `git push pds main` from the CLI ··· 51 51 52 52 Foundation layer — types that model the PDS state record and an HTTP client for the PDS XRPC API. 53 53 54 - - [x] create crate skeleton (`crates/pds-git-remote`, add to workspace `Cargo.toml`) 54 + - [x] create crate skeleton (`crates/git-remote-pds`, add to workspace `Cargo.toml`) 55 55 - [x] define core types in `types.rs`: 56 56 - `GitRef { name, sha }` 57 57 - `BundleEntry { parts (blob CIDs), prerequisites, tips, total_size, created_at }` ··· 166 166 - `push <src>:<dst>` → create bundle, upload, update state 167 167 - [x] implement CLI auth in `auth.rs`: 168 168 - `pds-git auth login` → login via createSession, cache token locally 169 - - token storage in `~/.config/pds-git-remote/auth.json` 169 + - token storage in `~/.config/git-remote-pds/auth.json` 170 170 - env var auth (`PDS_ACCESS_TOKEN`/`PDS_DID` or `PDS_HANDLE`/`PDS_PASSWORD`) 171 171 - [x] add `clap`-based CLI for auth subcommands 172 172 - [x] end-to-end test: init repo, add remote, push, clone elsewhere, verify content matches ··· 184 184 - `status()` → `{ ahead, behind, last_push }` — compare local vs remote state 185 185 - `compact()` — replace bundle chain with single full bundle 186 186 - [ ] integrate with `lichen-git`: 187 - - `git_push` placeholder in `lichen-git/src/git.rs` can call into `pds-git-remote` 187 + - `git_push` placeholder in `lichen-git/src/git.rs` can call into `git-remote-pds` 188 188 - auto-commit flow triggers `PdsBackup::push()` on a debounce timer 189 189 - [ ] add settings support: 190 190 - extend `lichen-git` settings or add `[pds_backup]` section to site config
+2 -2
src/auth.rs
··· 1 1 //! Credential storage and authentication resolution. 2 2 //! 3 - //! Stores AT Protocol credentials at `~/.config/pds-git-remote/auth.json`. 3 + //! Stores AT Protocol credentials at `~/.config/git-remote-pds/auth.json`. 4 4 //! Provides `resolve_auth` for the remote helper to find credentials from 5 5 //! env vars or stored config. 6 6 ··· 55 55 let home = std::env::var("HOME").unwrap_or_else(|_| ".".to_string()); 56 56 PathBuf::from(home) 57 57 .join(".config") 58 - .join("pds-git-remote") 58 + .join("git-remote-pds") 59 59 .join("auth.json") 60 60 } 61 61
+1 -1
src/lib.rs
··· 1 - //! pds-git-remote: PDS-backed git remote via incremental bundles. 1 + //! git-remote-pds: PDS-backed git remote via incremental bundles. 2 2 //! 3 3 //! Uses AT Protocol PDS as a git backup backend. Stores repositories 4 4 //! as chains of incremental git bundles uploaded as PDS blobs, tracked
+4 -4
src/main.rs
··· 111 111 112 112 /// Handles `auth oauth-login` — browser-based OAuth login with DPoP. 113 113 async fn handle_oauth_login(handle: &str, pds_url: Option<&str>, port: u16) { 114 - if let Err(e) = pds_git_remote::oauth_login::oauth_login(handle, pds_url, port).await { 114 + if let Err(e) = git_remote_pds::oauth_login::oauth_login(handle, pds_url, port).await { 115 115 eprintln!("OAuth login failed: {}", e); 116 116 std::process::exit(1); 117 117 } ··· 132 132 } 133 133 }; 134 134 135 - match pds_git_remote::auth::login_and_store(pds_url, handle, &password).await { 135 + match git_remote_pds::auth::login_and_store(pds_url, handle, &password).await { 136 136 Ok(cred) => { 137 137 eprintln!("logged in as {} ({})", cred.handle, cred.did); 138 138 } ··· 145 145 146 146 /// Handles `auth status` — prints stored credentials with details. 147 147 fn handle_status() { 148 - match pds_git_remote::auth::load_config() { 148 + match git_remote_pds::auth::load_config() { 149 149 Ok(config) => { 150 150 if config.credentials.is_empty() { 151 151 eprintln!("no stored credentials"); ··· 198 198 199 199 /// Handles `auth logout` — removes stored credential. 200 200 fn handle_logout(handle: &str) { 201 - match pds_git_remote::auth::logout(handle) { 201 + match git_remote_pds::auth::logout(handle) { 202 202 Ok(true) => { 203 203 eprintln!("logged out {}", handle); 204 204 }
+5 -5
src/remote_helper.rs
··· 4 4 //! between standard git commands and the PDS-backed bundle storage. 5 5 //! All diagnostic output goes to stderr; stdout is protocol-only. 6 6 7 - use pds_git_remote::auth; 8 - use pds_git_remote::fetch::{download_and_apply, find_new_bundles, read_remote_state}; 9 - use pds_git_remote::identity; 10 - use pds_git_remote::pds_client::PdsClient; 11 - use pds_git_remote::push; 7 + use git_remote_pds::auth; 8 + use git_remote_pds::fetch::{download_and_apply, find_new_bundles, read_remote_state}; 9 + use git_remote_pds::identity; 10 + use git_remote_pds::pds_client::PdsClient; 11 + use git_remote_pds::push; 12 12 13 13 /// Parses a `pds://handle/repo-name` URL into (handle, repo_name). 14 14 fn parse_pds_url(url: &str) -> Result<(String, String), String> {
+2 -2
tests/bundle_tests.rs
··· 6 6 use std::path::Path; 7 7 use tokio::fs; 8 8 9 - use pds_git_remote::bundle::{ 9 + use git_remote_pds::bundle::{ 10 10 apply_bundle, create_full_bundle, create_incremental_bundle, verify_bundle, 11 11 }; 12 - use pds_git_remote::chunk::{chunk_bytes, reassemble_chunks}; 12 + use git_remote_pds::chunk::{chunk_bytes, reassemble_chunks}; 13 13 14 14 /// Helper: write a file inside a directory. 15 15 async fn write_file(dir: &Path, name: &str, content: &str) {
+7 -7
tests/e2e_tests.rs
··· 3 3 //! Gated behind the `e2e` feature flag. Requires a running PDS at 4 4 //! localhost:3000 with a test account created via e2e-tests/pds-dev/. 5 5 //! 6 - //! Run with: cargo test -p pds-git-remote --features e2e -- --test-threads=1 6 + //! Run with: cargo test -p git-remote-pds --features e2e -- --test-threads=1 7 7 #![cfg(feature = "e2e")] 8 8 9 9 use std::path::Path; 10 10 11 - use pds_git_remote::auth::{self, AuthConfig, StoredCredential}; 12 - use pds_git_remote::fetch::{FetchResult, clone_repo, fetch_repo}; 13 - use pds_git_remote::pds_client::PdsClient; 14 - use pds_git_remote::push::{PushResult, push}; 15 - use pds_git_remote::types::COLLECTION; 11 + use git_remote_pds::auth::{self, AuthConfig, StoredCredential}; 12 + use git_remote_pds::fetch::{FetchResult, clone_repo, fetch_repo}; 13 + use git_remote_pds::pds_client::PdsClient; 14 + use git_remote_pds::push::{PushResult, push}; 15 + use git_remote_pds::types::COLLECTION; 16 16 use tokio::fs; 17 17 18 18 const PDS_URL: &str = "http://localhost:3000"; ··· 319 319 let (client, did) = login_client().await; 320 320 321 321 // upload some arbitrary bytes 322 - let data = b"hello from pds-git-remote e2e test!".to_vec(); 322 + let data = b"hello from git-remote-pds e2e test!".to_vec(); 323 323 let blob_ref = client 324 324 .upload_blob(data.clone()) 325 325 .await
+3 -3
tests/push_tests.rs
··· 6 6 use std::path::Path; 7 7 use tokio::fs; 8 8 9 - use pds_git_remote::bundle::create_full_bundle; 10 - use pds_git_remote::pds_client::PdsClient; 11 - use pds_git_remote::push::push; 9 + use git_remote_pds::bundle::create_full_bundle; 10 + use git_remote_pds::pds_client::PdsClient; 11 + use git_remote_pds::push::push; 12 12 13 13 /// Helper: write a file inside a directory. 14 14 async fn write_file(dir: &Path, name: &str, content: &str) {