starred/yaak-mountain-loop
1
0
Fork 0
mirror of https://github.com/mountain-loop/yaak.git synced 2026-04-21 16:21:25 +02:00
Code Issues 8 Packages Projects Releases 10 Wiki Activity

Add transport-agnostic RPC layer for proxy app

Browse Source 
Introduces yaak-rpc (shared RPC infrastructure) and yaak-proxy-lib
(proxy app logic decoupled from any frontend). A single Tauri command
dispatches all RPC calls through a typed router, with TypeScript types
auto-generated via ts-rs and a generic rpc() function for type-safe
calls from the frontend.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
This commit is contained in:
Gregory Schier
2026-03-08 11:27:51 -07:00
parent 4c37e62146
commit 6f8c4c06bb
11 changed files with 332 additions and 67 deletions
Download Patch File Download Diff File Expand all files Collapse all files

65
crates-tauri/yaak-app-proxy/src/lib.rs
View File

@@ -1,66 +1,25 @@
use log::error;
use serde::Serialize;
use std::sync::Mutex;
use tauri::{RunEvent, State};
use yaak_proxy::ProxyHandle;
use yaak_proxy_lib::ProxyCtx;
use yaak_rpc::RpcRouter;
use yaak_window::window::CreateWindowConfig;
#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct ProxyMetadata {
name: String,
version: String,
}
#[derive(Default)]
struct ProxyState {
handle: Mutex<Option<ProxyHandle>>,
}
#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct ProxyStartResult {
port: u16,
already_running: bool,
}
#[tauri::command]
fn proxy_metadata(app_handle: tauri::AppHandle) -> ProxyMetadata {
ProxyMetadata {
name: app_handle.package_info().name.clone(),
version: app_handle.package_info().version.to_string(),
}
}
#[tauri::command]
fn proxy_start(
state: State<'_, ProxyState>,
port: Option<u16>,
) -> Result<ProxyStartResult, String> {
let mut handle = state.handle.lock().map_err(|_| "failed to lock proxy state".to_string())?;
if let Some(existing) = handle.as_ref() {
return Ok(ProxyStartResult { port: existing.port, already_running: true });
}
let proxy_handle = yaak_proxy::start_proxy(port.unwrap_or(0))?;
let started_port = proxy_handle.port;
*handle = Some(proxy_handle);
Ok(ProxyStartResult { port: started_port, already_running: false })
}
#[tauri::command]
fn proxy_stop(state: State<'_, ProxyState>) -> Result<bool, String> {
let mut handle = state.handle.lock().map_err(|_| "failed to lock proxy state".to_string())?;
Ok(handle.take().is_some())
fn rpc(
router: State<'_, RpcRouter<ProxyCtx>>,
ctx: State<'_, ProxyCtx>,
cmd: String,
payload: serde_json::Value,
) -> Result<serde_json::Value, String> {
router.dispatch(&cmd, payload, &ctx).map_err(|e| e.message)
}
pub fn run() {
tauri::Builder::default()
.plugin(tauri_plugin_os::init())
.manage(ProxyState::default())
.invoke_handler(tauri::generate_handler![proxy_metadata, proxy_start, proxy_stop])
.manage(ProxyCtx::new())
.manage(yaak_proxy_lib::build_router())
.invoke_handler(tauri::generate_handler![rpc])
.build(tauri::generate_context!())
.expect("error while building yaak proxy tauri application")
.run(|app_handle, event| {