feat(remote): implement Orbit WS transport and provider rename

Author: Dimillian

docs/mobile-ios-cloudflare-blueprint.md

@@ -19,7 +19,22 @@ This document is the canonical implementation plan for shipping CodexMonitor on
 ## Current State (Important)
 
 - Tauri app is desktop-first with `#[cfg_attr(mobile, tauri::mobile_entry_point)]` already present in `src-tauri/src/lib.rs`.
-- `src-tauri/src/remote_backend.rs` currently uses raw TCP `host:port` and optional token auth.
+- `remote_backend` has been refactored into pluggable transport modules:
+  - `src-tauri/src/remote_backend/mod.rs`
+  - `src-tauri/src/remote_backend/protocol.rs`
+  - `src-tauri/src/remote_backend/transport.rs`
+  - `src-tauri/src/remote_backend/tcp_transport.rs`
+  - `src-tauri/src/remote_backend/orbit_ws_transport.rs`
+- Current transport behavior:
+  - TCP transport remains intact (existing remote path preserved).
+  - Orbit WS transport is implemented for connect/read/write + request/response routing.
+  - Reconnect/backoff and replay/resync hardening are still pending.
+- Remote provider settings baseline is implemented:
+  - `remoteBackendProvider`: `"tcp" | "orbit"`
+  - `remoteBackendHost`, `remoteBackendToken`
+  - `orbitDeploymentMode`, `orbitWsUrl`, `orbitAuthUrl`
+  - `orbitRunnerName`, `orbitAutoStartRunner`
+  - `orbitUseAccess`, `orbitAccessClientId`, `orbitAccessClientSecretRef`
 - Remote notification forwarding currently handles only:
   - `app-server-event`
   - `terminal-output`
@@ -89,7 +104,7 @@ Advanced setup for users who want full control.
 
 Target: keep existing `call_remote(...)` callsites while replacing transport internals.
 
-Proposed structure:
+Implemented structure:
 
 - `src-tauri/src/remote_backend/mod.rs`
 - `src-tauri/src/remote_backend/protocol.rs`
@@ -105,21 +120,33 @@ Proposed structure:
 - `close()`
 - `status()`
 
-## 2) Add Orbit configuration to settings model
+Current status:
+
+- Done: transport split + provider routing + Orbit WS connect/read/write path.
+- Pending: reconnect strategy, backoff policy, replay/resync contract integration.
+
+## 2) Add bridge configuration to settings model
 
 Extend `AppSettings` in `src-tauri/src/types.rs` and UI types in `src/types.ts`.
 
-Add section:
+Implemented baseline fields:
 
-- `remoteBridgeProvider`: `"tcp" | "orbit"`
-- `orbitDeploymentMode`: `"hosted" | "self_hosted"`
-- `orbitWsUrl` (required for self-host; optional/derived for hosted)
-- `orbitAuthUrl` (required for self-host; optional/derived for hosted)
+- `remoteBackendProvider`: `"tcp" | "orbit"`
+- `remoteBackendHost`
+- `remoteBackendToken`
+- `orbitDeploymentMode`
+- `orbitWsUrl`
+- `orbitAuthUrl`
 - `orbitRunnerName`
-- `orbitAutoStartRunner` (bool)
-- `orbitUseAccess` (bool, self-host optional)
-- `orbitAccessClientId` (non-secret allowed)
-- `orbitAccessClientSecretRef` (secret reference only)
+- `orbitAutoStartRunner`
+- `orbitUseAccess`
+- `orbitAccessClientId`
+- `orbitAccessClientSecretRef`
+
+Planned next (not yet implemented in settings model):
+
+- deployment/auth/pairing metadata required for full hosted/self-host Orbit UX
+- secure-storage integration for secret material lifecycle (set/reset/rotation)
 
 Keep secrets out of plain `settings.json` where possible.
 
@@ -446,7 +473,7 @@ cargo test
 
 1. Milestone A: iOS compile baseline + mobile-safe stubs.
 2. Milestone B: Orbit integration baseline (hosted + self-host config paths).
-3. Milestone C: `remote_backend` transport refactor + Orbit transport + runner Orbit mode.
+3. Milestone C: `remote_backend` transport refactor + Orbit WS transport + runner Orbit mode.
 4. Milestone D: daemon parity closure for mobile scope (excluding terminal/dictation).
 5. Milestone E: Settings UX/service manager + pairing UX.
 6. Milestone F: full E2E validation and TestFlight beta.

memory/decisions.md

@@ -211,3 +211,31 @@ Type: decision
 Event: Remote backend was a single TCP-specific module with no transport-level provider split.
 Action: Refactored `src-tauri/src/remote_backend.rs` into `remote_backend/{mod,protocol,transport,tcp_transport,cloudflare_ws_transport}.rs`, added `remoteBackendProvider` + Cloudflare settings fields, kept TCP behavior as default, and added a Cloudflare transport stub that returns a clear not-implemented error.
 Rule: Keep remote transport wiring behind `RemoteTransport` and use provider selection in settings so new bridge transports can be added without touching command callsites.
+
+## 2026-02-07 17:58
+Context: Cloudflare transport implementation pass
+Type: decision
+Event: Cloudflare transport stub blocked real remote bridge connectivity testing.
+Action: Implemented `cloudflare_ws_transport` with real WebSocket connect/read/write loops via `tokio-tungstenite`, shared incoming dispatch/pending-response handling, URL normalization to `/ws/{sessionId}`, and transport-level disconnect propagation.
+Rule: New remote transports should reuse shared dispatch/disconnect helpers and preserve the same request/response semantics as TCP transport.
+
+## 2026-02-07 18:00
+Context: Mobile Cloudflare blueprint canonicalization
+Type: decision
+Event: Blueprint still referenced pre-refactor remote backend structure and outdated settings keys after transport work landed.
+Action: Updated `docs/mobile-ios-cloudflare-blueprint.md` to reflect implemented remote backend module split, Cloudflare WS transport status, current provider settings fields, and remaining reconnect/replay hardening work.
+Rule: Keep blueprint "Current State" and backend/settings sections synchronized with merged transport architecture before starting new milestone work.
+
+## 2026-02-07 18:09
+Context: Orbit-only provider canonicalization
+Type: decision
+Event: Backend/provider/settings naming still reflected Cloudflare-specific labels after Orbit-only direction was finalized.
+Action: Renamed remote transport/provider/settings model to Orbit (`orbit_ws_transport`, `RemoteBackendProvider::Orbit`, `orbit*` settings), retained serde aliases for legacy Cloudflare config keys, and updated the mobile blueprint/todo notes to Orbit-first language.
+Rule: Keep runtime/provider naming Orbit-first while preserving narrow backward-compatible aliases only for persisted legacy settings.
+
+## 2026-02-07 18:13
+Context: Orbit-only feature branch compatibility policy
+Type: preference
+Event: User requested removing all unreleased Cloudflare fallback/backport compatibility paths and tests.
+Action: Removed provider/url/session legacy compatibility aliases, removed legacy session URL injection logic, and deleted backport-focused tests from remote backend and settings models.
+Rule: For this unreleased Orbit workstream, keep settings and transport strictly canonical without backward-compat adapters.

memory/todo.md

@@ -2,7 +2,7 @@
 
 ## Open
 - [ ] 2026-02-07: Implement Orbit-only mobile remote foundation: Orbit transport in `remote_backend`, runner Orbit mode, hosted/self-host settings + pairing UX, and iOS keychain-backed auth storage.
-- [ ] 2026-02-07: Implement Cloudflare WebSocket transport internals behind `remoteBackendProvider=cloudflare` (handshake/auth/send/subscribe/reconnect/replay) and wire settings UX for worker/session inputs.
+- [ ] 2026-02-07: Harden Orbit WS transport with explicit reconnect/backoff + replay/resync handling for mobile reconnect flows.
 
 ## Done
 - [x] 2026-02-07: Restored Sentry frontend reporting removed in `83a37da` (`@sentry/react`, `Sentry.init`, captureException callsites, and metrics instrumentation).
@@ -14,3 +14,6 @@
 - [x] 2026-02-07: Replace daemon `local_usage_snapshot` temporary implementation by sharing real local usage scanner logic in `shared/local_usage_core.rs`.
 - [x] 2026-02-07: Eliminate app/daemon duplication for git/github/prompt/codex utility behavior via shared cores (`git_ui_core`, `prompts_core`, `codex_aux_core`).
 - [x] 2026-02-07: Move remaining duplicated workspace-action logic (`add_clone`, `apply_worktree_changes`, `open_workspace_in`, `get_open_app_icon`) into shared core helpers.
+- [x] 2026-02-07: Implement Cloudflare WebSocket transport internals behind `remoteBackendProvider=cloudflare` (connect/read/write/pending-response flow) while preserving TCP behavior and callsites.
+- [x] 2026-02-07: Migrate remote provider naming/settings from Cloudflare-specific keys to Orbit (`orbit` provider + `orbit*` settings).
+- [x] 2026-02-07: Remove unreleased Cloudflare backward-compat aliases and backport tests to keep Orbit implementation canonical-only.

src-tauri/Cargo.lock

@@ -30,6 +30,8 @@ tauri-plugin-process = "2"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 tokio = { version = "1", features = ["fs", "net", "io-util", "process", "rt", "sync", "time"] }
+futures-util = "0.3"
+tokio-tungstenite = { version = "0.24", features = ["rustls-tls-webpki-roots"] }
 uuid = { version = "1", features = ["v4"] }
 tauri-plugin-dialog = "2"
 git2 = "0.20.3"

src-tauri/Cargo.toml

@@ -1,4 +1,4 @@
-mod cloudflare_ws_transport;
+mod orbit_ws_transport;
 mod protocol;
 mod tcp_transport;
 mod transport;
@@ -13,7 +13,7 @@ use tokio::sync::Mutex;
 use crate::state::AppState;
 use crate::types::{BackendMode, RemoteBackendProvider};
 
-use self::cloudflare_ws_transport::CloudflareWsTransport;
+use self::orbit_ws_transport::OrbitWsTransport;
 use self::protocol::{build_request_line, DEFAULT_REMOTE_HOST, DISCONNECTED_MESSAGE};
 use self::tcp_transport::TcpTransport;
 use self::transport::{PendingMap, RemoteTransport, RemoteTransportConfig, RemoteTransportKind};
@@ -121,7 +121,7 @@ async fn ensure_remote_backend(state: &AppState, app: AppHandle) -> Result<Remot
 
     let transport: Box<dyn RemoteTransport> = match transport_config.kind() {
         RemoteTransportKind::Tcp => Box::new(TcpTransport),
-        RemoteTransportKind::CloudflareWs => Box::new(CloudflareWsTransport),
+        RemoteTransportKind::OrbitWs => Box::new(OrbitWsTransport),
     };
     let connection = transport.connect(app, transport_config).await?;
 
@@ -164,28 +164,37 @@ fn resolve_transport_config(
                 auth_token: settings.remote_backend_token.clone(),
             })
         }
-        RemoteBackendProvider::Cloudflare => {
-            let worker_url = settings
-                .cloudflare_worker_url
+        RemoteBackendProvider::Orbit => {
+            let ws_url = settings
+                .orbit_ws_url
                 .as_ref()
                 .map(|value| value.trim().to_string())
                 .filter(|value| !value.is_empty())
-                .ok_or_else(|| {
-                    "Cloudflare provider requires cloudflareWorkerUrl in app settings.".to_string()
-                })?;
-            let session_id = settings
-                .cloudflare_session_id
-                .as_ref()
-                .map(|value| value.trim().to_string())
-                .filter(|value| !value.is_empty())
-                .ok_or_else(|| {
-                    "Cloudflare provider requires cloudflareSessionId in app settings.".to_string()
-                })?;
-            Ok(RemoteTransportConfig::CloudflareWs {
-                worker_url,
-                session_id,
+                .ok_or_else(|| "Orbit provider requires orbitWsUrl in app settings.".to_string())?;
+            Ok(RemoteTransportConfig::OrbitWs {
+                ws_url,
                 auth_token: settings.remote_backend_token.clone(),
             })
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::resolve_transport_config;
+    use crate::remote_backend::transport::RemoteTransportConfig;
+    use crate::types::{AppSettings, RemoteBackendProvider};
+
+    #[test]
+    fn resolve_orbit_transport_uses_orbit_ws_url() {
+        let mut settings = AppSettings::default();
+        settings.remote_backend_provider = RemoteBackendProvider::Orbit;
+        settings.orbit_ws_url = Some("https://orbit.example/ws/live".to_string());
+
+        let config = resolve_transport_config(&settings).expect("transport config");
+        let RemoteTransportConfig::OrbitWs { ws_url, .. } = config else {
+            panic!("expected orbit transport config");
+        };
+        assert_eq!(ws_url, "https://orbit.example/ws/live");
+    }
+}