ComputerConnection/tauri

Tauri Development: $ARGUMENTS

Tauri patterns for NEXUS desktop app development.

---

NEXUS Tauri Structure

~/nexus/
├── src/                    # React frontend
├── src-tauri/
│   ├── src/
│   │   ├── main.rs        # Entry point
│   │   ├── lib.rs         # Command handlers
│   │   └── [modules]/     # Feature modules
│   ├── Cargo.toml         # Rust dependencies
│   ├── tauri.conf.json    # Tauri config
│   └── capabilities/      # Permissions

---

Common Patterns

1. Add a Tauri Command

Rust side (src-tauri/src/lib.rs):

#[tauri::command]
fn my_command(arg: String) -> Result<String, String> {
    // Do something
    Ok(format!("Result: {}", arg))
}

// Register in builder:
.invoke_handler(tauri::generate_handler![my_command])

Frontend side:

import { invoke } from '@tauri-apps/api/core';

const result = await invoke<string>('my_command', { arg: 'value' });

2. Async Commands

#[tauri::command]
async fn async_command() -> Result<Data, String> {
    // Async work
    tokio::time::sleep(Duration::from_secs(1)).await;
    Ok(Data::default())
}

3. State Management

struct AppState {
    db: Mutex<Database>,
}

#[tauri::command]
fn with_state(state: State<AppState>) -> Result<(), String> {
    let db = state.db.lock().unwrap();
    // Use db
    Ok(())
}

// In main:
.manage(AppState { db: Mutex::new(Database::new()) })

4. Events (Backend → Frontend)

Emit from Rust:

#[tauri::command]
fn start_process(window: Window) {
    window.emit("progress", Payload { percent: 50 }).unwrap();
}

Listen in React:

import { listen } from '@tauri-apps/api/event';

useEffect(() => {
    const unlisten = listen('progress', (event) => {
        console.log(event.payload);
    });
    return () => { unlisten.then(f => f()); };
}, []);

5. File System Access

use std::fs;
use tauri::api::path::app_data_dir;

#[tauri::command]
fn read_config(app: AppHandle) -> Result<String, String> {
    let path = app_data_dir(&app.config())
        .ok_or("No app data dir")?
        .join("config.json");
    fs::read_to_string(path).map_err(|e| e.to_string())
}

6. Window Management

#[tauri::command]
fn open_settings(app: AppHandle) {
    tauri::WindowBuilder::new(
        &app,
        "settings",
        tauri::WindowUrl::App("settings.html".into())
    )
    .title("Settings")
    .build()
    .unwrap();
}

---

NEXUS-Specific Patterns

Terminal Integration (xterm)

NEXUS uses xterm.js. Backend PTY handling:

use portable_pty::{CommandBuilder, PtySize, native_pty_system};

#[tauri::command]
async fn spawn_terminal() -> Result<TerminalId, String> {
    let pty_system = native_pty_system();
    let pair = pty_system.openpty(PtySize {
        rows: 24,
        cols: 80,
        ..Default::default()
    }).map_err(|e| e.to_string())?;

    // Store and return ID
}

WebSocket for Real-time

NEXUS uses WebSockets for agent communication:

// Consider using tauri-plugin-websocket or custom implementation

Node Graph State (XYFlow)

Persist graph state:

#[tauri::command]
fn save_graph(graph: GraphState, app: AppHandle) -> Result<(), String> {
    let path = app_data_dir(&app.config())
        .ok_or("No dir")?
        .join("graphs")
        .join(format!("{}.json", graph.id));

    let json = serde_json::to_string_pretty(&graph)
        .map_err(|e| e.to_string())?;

    std::fs::write(path, json).map_err(|e| e.to_string())
}

---

Development Commands

# Dev mode (hot reload)
cd ~/nexus && npm run tauri:dev

# Build for production
npm run tauri:build

# Check Rust errors without full build
cd src-tauri && cargo check

# Add Rust dependency
cd src-tauri && cargo add [package]

# Update Tauri
cd src-tauri && cargo update

---

Debugging

Frontend

• Browser devtools: Right-click → Inspect (in dev mode)
• Console logs appear in devtools

Backend (Rust)

// Add to commands for debugging
println!("Debug: {:?}", value);
dbg!(&value);

// Or use tracing
tracing::info!("Something happened");

View logs:

# Logs appear in terminal where you ran tauri:dev

IPC Issues

// Wrap invoke calls to debug
const safeInvoke = async (cmd: string, args?: object) => {
    console.log(`Invoking ${cmd}`, args);
    try {
        const result = await invoke(cmd, args);
        console.log(`Result:`, result);
        return result;
    } catch (e) {
        console.error(`Error in ${cmd}:`, e);
        throw e;
    }
};

---

Common Issues

"Command not found"

• Did you add it to generate_handler![]?
• Did you restart dev server after Rust changes?

Serialization Errors

• Ensure types implement Serialize/Deserialize
• Check that frontend types match Rust types

Permission Denied

• Check capabilities/ for required permissions
• File system access needs explicit capability

Window Not Opening

• Check window label uniqueness
• Verify URL path exists

---

Performance Tips

1. Heavy Rust work: Use async commands + tokio::spawn
2. Large data: Stream via events instead of single invoke
3. Frequent updates: Batch events, don't emit per-item
4. File watching: Use notify crate, emit on changes

---

Output

Based on $ARGUMENTS:

1. Identify the pattern needed
2. Show relevant code examples
3. Point to existing NEXUS code if applicable
4. Provide copy-paste ready snippets