┌─────────────────────────────────────────────────────────────────┐
│                    Your App.exe (Tauri)                          │
├─────────────────────────────────────────────────────────────────┤
│  Frontend (React/Vue/Svelte)                                     │
│  └── UI, state management, event handling                        │
├─────────────────────────────────────────────────────────────────┤
│  Rust Backend                                                    │
│  ├── Spawn `claude` CLI process                                  │
│  ├── Parse streaming JSON from stdout                            │
│  └── Emit events to frontend                                     │
└──────────────────────┬──────────────────────────────────────────┘
                       │ spawn process
                       ▼
┌─────────────────────────────────────────────────────────────────┐
│  claude (user's installed Claude Code CLI)                       │
│  --print --output-format stream-json --verbose                   │
│  --mcp-config mcp-config.json                                    │
└──────────────────────┬──────────────────────────────────────────┘
                       │ stdio (MCP protocol)
                       ▼
┌─────────────────────────────────────────────────────────────────┐
│  Your App.exe --mcp (same binary, MCP server mode)               │
│  └── Custom tools for your application                           │
└─────────────────────────────────────────────────────────────────┘

claude --print --output-format stream-json --verbose "Your prompt here"

claude --print \
  --output-format stream-json \
  --verbose \
  --mcp-config "path/to/mcp-config.json" \
  --allowedTools "mcp__your-server__*" \
  --system-prompt "Custom system prompt" \
  --resume <session-id> \
  "user prompt here"

// Session initialization
{"type": "system", "session_id": "abc123", ...}

// Assistant text response
{"type": "assistant", "message": {"content": [{"type": "text", "text": "Hello!"}]}}

// Tool use
{"type": "assistant", "message": {"content": [{"type": "tool_use", "name": "tool_name", ...}]}}

// Final result
{"type": "result", "session_id": "abc123", ...}

[package]
name = "your-app"
version = "0.1.0"
edition = "2021"

[dependencies]
tokio = { version = "1", features = ["full"] }
serde = { version = "1", features = ["derive"] }
serde_json = "1"

use std::process::Stdio;
use tokio::process::Command;
use tokio::io::{BufReader, AsyncBufReadExt};
use serde::{Deserialize, Serialize};

#[derive(Debug, Deserialize)]
#[serde(tag = "type")]
enum ClaudeEvent {
    #[serde(rename = "system")]
    System { session_id: String },
    #[serde(rename = "assistant")]
    Assistant { message: AssistantMessage },
    #[serde(rename = "result")]
    Result { session_id: String },
}

#[derive(Debug, Deserialize)]
struct AssistantMessage {
    content: Vec<ContentBlock>,
}

#[derive(Debug, Deserialize)]
#[serde(tag = "type")]
enum ContentBlock {
    #[serde(rename = "text")]
    Text { text: String },
    #[serde(rename = "tool_use")]
    ToolUse { id: String, name: String },
}

pub struct ClaudeRunner {
    session_id: Option<String>,
    mcp_config_path: Option<String>,
}

impl ClaudeRunner {
    pub fn new() -> Self {
        Self {
            session_id: None,
            mcp_config_path: None,
        }
    }

    pub fn with_mcp_config(mut self, path: String) -> Self {
        self.mcp_config_path = Some(path);
        self
    }

    pub async fn send_message<F>(
        &mut self,
        prompt: &str,
        mut on_event: F,
    ) -> Result<(), Box<dyn std::error::Error>>
    where
        F: FnMut(ClaudeEvent),
    {
        let mut args = vec![
            "--print".to_string(),
            "--output-format".to_string(),
            "stream-json".to_string(),
            "--verbose".to_string(),
        ];

        // Add MCP config if specified
        if let Some(ref config_path) = self.mcp_config_path {
            args.push("--mcp-config".to_string());
            args.push(config_path.clone());
        }

        // Resume session if we have one
        if let Some(ref session_id) = self.session_id {
            args.push("--resume".to_string());
            args.push(session_id.clone());
        }

        args.push(prompt.to_string());

        let mut child = Command::new("claude")
            .args(&args)
            .stdout(Stdio::piped())
            .stderr(Stdio::null())
            .spawn()?;

        let stdout = child.stdout.take().unwrap();
        let reader = BufReader::new(stdout);
        let mut lines = reader.lines();

        while let Some(line) = lines.next_line().await? {
            if let Ok(event) = serde_json::from_str::<ClaudeEvent>(&line) {
                // Save session_id for future resume
                match &event {
                    ClaudeEvent::System { session_id } |
                    ClaudeEvent::Result { session_id } => {
                        self.session_id = Some(session_id.clone());
                    }
                    _ => {}
                }
                on_event(event);
            }
        }

        child.wait().await?;
        Ok(())
    }
}

use tauri::{AppHandle, Manager};

#[tauri::command]
async fn send_message(
    app: AppHandle,
    prompt: String,
) -> Result<(), String> {
    let mut runner = ClaudeRunner::new()
        .with_mcp_config("path/to/mcp-config.json".to_string());

    runner
        .send_message(&prompt, |event| {
            // Emit events to frontend
            let _ = app.emit_all("claude-event", &event);
        })
        .await
        .map_err(|e| e.to_string())
}

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

interface ClaudeEvent {
  type: "system" | "assistant" | "result";
  session_id?: string;
  message?: {
    content: Array<{ type: string; text?: string }>;
  };
}

listen<ClaudeEvent>("claude-event", (event) => {
  const data = event.payload;

  if (data.type === "assistant" && data.message) {
    for (const block of data.message.content) {
      if (block.type === "text") {
        console.log("Claude:", block.text);
      }
    }
  }
});

[dependencies]
# ... your existing dependencies ...

# MCP server support
rmcp = { version = "0.3", features = ["server", "macros", "transport-io"] }
schemars = "0.8"

# For screenshot/image support (optional)
xcap = "0.4"                    # Cross-platform screen capture
base64 = "0.22"                 # Base64 encoding
image = { version = "0.25", default-features = false, features = ["png", "webp"] }

// src-tauri/src/main.rs
#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]

mod mcp_server;

#[tokio::main]
async fn main() {
    // Check for --mcp flag BEFORE initializing Tauri
    if std::env::args().any(|arg| arg == "--mcp") {
        // Run as MCP server (stdio mode)
        if let Err(e) = mcp_server::run_mcp_server().await {
            eprintln!("MCP server error: {}", e);
            std::process::exit(1);
        }
        return;
    }

    // Normal Tauri app initialization
    your_app_lib::run();
}

// src-tauri/src/mcp_server.rs
use std::io::Cursor;
use anyhow::Result;
use base64::{Engine as _, engine::general_purpose::STANDARD as BASE64};
use image::ImageFormat;
use rmcp::{
    handler::server::{router::tool::ToolRouter, tool::Parameters},
    model::*,
    schemars, tool, tool_handler, tool_router, ServerHandler, ServiceExt,
};
use xcap::Monitor;

// Define tool input schemas
#[derive(serde::Deserialize, schemars::JsonSchema)]
struct SetEmotionRequest {
    /// The emotion to display (happy, sad, excited, thinking)
    emotion: String,
    /// Duration in milliseconds (default: 5000)
    #[serde(default)]
    duration_ms: Option<u32>,
}

#[derive(serde::Deserialize, schemars::JsonSchema)]
struct MoveToRequest {
    /// Target position: "left", "right", "center", or x-coordinate
    target: String,
}

#[derive(serde::Deserialize, schemars::JsonSchema)]
struct CaptureScreenshotRequest {
    /// Optional description of what to look for
    #[serde(default)]
    description: Option<String>,
}

// MCP Server with tool router
pub struct MascotService {
    tool_router: ToolRouter<MascotService>,
}

#[tool_router]
impl MascotService {
    fn new() -> Self {
        Self {
            tool_router: Self::tool_router(),
        }
    }

    // Tool returning text (simple case)
    #[tool(description = "Set the mascot's emotional expression")]
    async fn set_emotion(&self, Parameters(req): Parameters<SetEmotionRequest>) -> String {
        let duration = req.duration_ms.unwrap_or(5000);
        format!("Emotion set to '{}' for {}ms", req.emotion, duration)
    }

    #[tool(description = "Move the mascot to a screen position")]
    async fn move_to(&self, Parameters(req): Parameters<MoveToRequest>) -> String {
        format!("Moving to: {}", req.target)
    }

    // Tool returning image content (advanced case)
    #[tool(description = "Capture a screenshot of the user's screen")]
    async fn capture_screenshot(
        &self,
        Parameters(req): Parameters<CaptureScreenshotRequest>,
    ) -> Result<CallToolResult, rmcp::ErrorData> {
        let desc = req.description.unwrap_or_else(|| "general view".to_string());

        let make_error = |msg: String| {
            rmcp::ErrorData::new(
                rmcp::model::ErrorCode::INTERNAL_ERROR,
                msg,
                None::<serde_json::Value>,
            )
        };

        // Get primary monitor
        let monitors = Monitor::all()
            .map_err(|e| make_error(format!("Failed to get monitors: {}", e)))?;
        let monitor = monitors.into_iter().next()
            .ok_or_else(|| make_error("No monitors found".to_string()))?;

        // Capture screen
        let image = monitor.capture_image()
            .map_err(|e| make_error(format!("Failed to capture: {}", e)))?;

        // Resize if too large (MCP has ~1MB limit)
        let (w, h) = (image.width(), image.height());
        let max_dim = 1920u32;
        let resized = if w > max_dim || h > max_dim {
            let scale = max_dim as f32 / w.max(h) as f32;
            image::imageops::resize(
                &image,
                (w as f32 * scale) as u32,
                (h as f32 * scale) as u32,
                image::imageops::FilterType::Triangle,
            )
        } else {
            image::imageops::resize(&image, w, h, image::imageops::FilterType::Triangle)
        };

        // Encode as WebP (smaller than PNG)
        let mut webp_data = Cursor::new(Vec::new());
        resized.write_to(&mut webp_data, ImageFormat::WebP)
            .map_err(|e| make_error(format!("Failed to encode: {}", e)))?;

        // Base64 encode and return as image content
        let base64_data = BASE64.encode(webp_data.into_inner());

        Ok(CallToolResult::success(vec![
            Content::text(format!("Screenshot captured (looking for: {})", desc)),
            Content::image(base64_data, "image/webp"),
        ]))
    }
}

#[tool_handler]
impl ServerHandler for MascotService {
    fn get_info(&self) -> ServerInfo {
        ServerInfo {
            capabilities: ServerCapabilities::builder().enable_tools().build(),
            ..Default::default()
        }
    }
}

pub async fn run_mcp_server() -> Result<()> {
    let transport = (tokio::io::stdin(), tokio::io::stdout());
    let service = MascotService::new().serve(transport).await?;
    service.waiting().await?;
    Ok(())
}

{
  "mcpServers": {
    "mascot": {
      "command": "path/to/YourApp.exe",
      "args": ["--mcp"]
    }
  }
}

use std::path::PathBuf;

fn generate_mcp_config(app_exe_path: &PathBuf) -> serde_json::Value {
    serde_json::json!({
        "mcpServers": {
            "mascot": {
                "command": app_exe_path.to_string_lossy(),
                "args": ["--mcp"]
            }
        }
    })
}

// In your Tauri setup
let exe_path = std::env::current_exe().expect("Failed to get exe path");
let config = generate_mcp_config(&exe_path);
let config_path = app_data_dir.join("mcp-config.json");
std::fs::write(&config_path, serde_json::to_string_pretty(&config)?)?;

# Create certificate
$cert = New-SelfSignedCertificate `
  -Type CodeSigningCert `
  -Subject "CN=Your Dev Certificate" `
  -CertStoreLocation "Cert:\CurrentUser\My" `
  -NotAfter (Get-Date).AddYears(5)

# Export to .pfx
$password = ConvertTo-SecureString -String "devpass" -Force -AsPlainText
Export-PfxCertificate -Cert $cert -FilePath ".\dev-cert.pfx" -Password $password

// scripts/sign.rs
use std::process::Command;
use std::path::Path;
use std::fs;

fn find_signtool() -> Option<String> {
    let sdk_path = r"C:\Program Files (x86)\Windows Kits\10\bin";

    let mut versions: Vec<_> = fs::read_dir(sdk_path)
        .ok()?
        .filter_map(|e| e.ok())
        .map(|e| e.file_name().to_string_lossy().to_string())
        .filter(|n| n.starts_with("10."))
        .collect();

    versions.sort();
    versions.reverse();

    for version in versions {
        let signtool = format!(r"{}\{}\x64\signtool.exe", sdk_path, version);
        if Path::new(&signtool).exists() {
            return Some(signtool);
        }
    }
    None
}

fn main() {
    let signtool = find_signtool().expect("signtool.exe not found");
    let cert_path = "dev-cert.pfx";
    let password = "devpass";

    let artifacts = fs::read_dir("artifacts")
        .expect("artifacts directory not found")
        .filter_map(|e| e.ok())
        .filter(|e| e.path().extension().map_or(false, |ext| ext == "exe"));

    for entry in artifacts {
        let path = entry.path();
        println!("Signing {:?}...", path);

        Command::new(&signtool)
            .args([
                "sign",
                "/f", cert_path,
                "/p", password,
                "/fd", "sha256",
                path.to_str().unwrap(),
            ])
            .status()
            .expect("Failed to sign");
    }

    println!("Signing complete!");
}

# Cargo.toml
[[bin]]
name = "sign"
path = "scripts/sign.rs"

# Build (single executable handles both GUI and MCP modes)
cargo build --release -p your-app

# Sign
cargo run --bin sign

# Code signing certificates
*.pfx
*.p12

# Build outputs
target/
artifacts/

your-app/
├── src/                      # Frontend (if using Tauri)
├── src-tauri/                # Tauri Rust backend
│   ├── src/
│   │   ├── main.rs           # Entry point with --mcp detection
│   │   ├── lib.rs
│   │   ├── claude_runner.rs  # Claude CLI integration
│   │   └── mcp_server.rs     # MCP server (same binary)
│   └── Cargo.toml
├── scripts/
│   └── sign.rs               # Signing utility
├── artifacts/                # Build outputs (gitignored)
├── dev-cert.pfx              # Dev certificate (gitignored)
└── Cargo.toml                # Workspace root

// Save after each conversation
self.session_id = Some(result.session_id);

// Resume later
args.push("--resume".to_string());
args.push(session_id);

match Command::new("claude").spawn() {
    Ok(child) => { /* proceed */ }
    Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
        return Err("Claude Code CLI not found. Please install from https://claude.ai/download".into());
    }
    Err(e) => return Err(e.into()),
}

use tokio::sync::mpsc;

let (tx, mut rx) = mpsc::channel(100);

// Spawn reader task
tokio::spawn(async move {
    while let Some(line) = lines.next_line().await.unwrap() {
        if let Ok(event) = serde_json::from_str(&line) {
            tx.send(event).await.unwrap();
        }
    }
});

// Consume in main task
while let Some(event) = rx.recv().await {
    app.emit_all("claude-event", &event)?;
}

# Cargo.toml
[profile.release]
opt-level = "z"     # Optimize for size
lto = true          # Link-time optimization
codegen-units = 1   # Single codegen unit
strip = true        # Strip symbols

codex exec --json --full-auto --skip-git-repo-check "Your prompt here"

codex exec resume <thread-id> --json --full-auto --skip-git-repo-check "follow-up prompt"

// Thread initialization
{"type": "thread.started", "thread_id": "abc123"}

// Turn lifecycle
{"type": "turn.started", "turn_id": "xyz789"}
{"type": "turn.completed", "turn_id": "xyz789"}

// Content items
{"type": "item.started", "item": {"type": "message", "content": [...]}}
{"type": "item.completed", "item": {"type": "message", "content": [...]}}

// Tool calls
{"type": "item.started", "item": {"type": "tool_call", "name": "tool_name", "arguments": {...}}}

// MCP tool calls
{"type": "item.completed", "item": {"type": "mcp_tool_call", "server": "mascot", "tool": "set_emotion", ...}}

// Errors
{"type": "turn.failed", "error": "Something went wrong"}
{"type": "error", "message": "Error details"}

#[derive(Debug, Deserialize)]
#[serde(tag = "type")]
pub enum CodexStreamEvent {
    #[serde(rename = "thread.started")]
    ThreadStarted { thread_id: Option<String> },

    #[serde(rename = "turn.started")]
    TurnStarted { turn_id: Option<String> },

    #[serde(rename = "turn.completed")]
    TurnCompleted { turn_id: Option<String> },

    #[serde(rename = "turn.failed")]
    TurnFailed { error: Option<String> },

    #[serde(rename = "item.started")]
    ItemStarted { item: Option<CodexItem> },

    #[serde(rename = "item.completed")]
    ItemCompleted { item: Option<CodexItem> },

    #[serde(rename = "error")]
    Error { message: Option<String> },
}

#[derive(Debug, Deserialize)]
#[serde(tag = "type")]
pub enum CodexItem {
    #[serde(rename = "message")]
    Message { content: Vec<CodexContent> },

    #[serde(rename = "tool_call")]
    ToolCall { name: Option<String>, arguments: Option<serde_json::Value> },

    #[serde(rename = "mcp_tool_call")]
    McpToolCall {
        server: Option<String>,
        tool: Option<String>,
        arguments: Option<serde_json::Value>,
        result: Option<serde_json::Value>,
    },
}

[mcp_servers.mascot]
command = "C:\\path\\to\\your-mcp-server.exe"
args = []

fn write_codex_mcp_config(mcp_exe_path: &str) -> Result<(), String> {
    let home = dirs::home_dir().ok_or("Could not find home directory")?;
    let config_path = home.join(".codex").join("config.toml");

    // Create directory if needed
    std::fs::create_dir_all(config_path.parent().unwrap())
        .map_err(|e| format!("Failed to create .codex directory: {}", e))?;

    // Escape backslashes for TOML
    let escaped_path = mcp_exe_path.replace('\\', "\\\\");

    let config = format!(
        "[mcp_servers.mascot]\ncommand = \"{}\"\nargs = []\n",
        escaped_path
    );

    std::fs::write(&config_path, config)
        .map_err(|e| format!("Failed to write config: {}", e))?;

    Ok(())
}

codex exec --json --full-auto \
  --config model="\"gpt-4o\"" \
  --config model_reasoning_effort="\"high\"" \
  "Your prompt"

codex exec --json --full-auto --image "/path/to/image.png" "Describe this image"

fn save_image_to_temp(base64_data: &str, index: usize) -> Result<PathBuf, String> {
    use base64::{engine::general_purpose::STANDARD, Engine};

    let image_data = STANDARD.decode(base64_data)
        .map_err(|e| format!("Failed to decode: {}", e))?;

    let temp_path = std::env::temp_dir()
        .join(format!("app-image-{}.png", index));

    std::fs::write(&temp_path, &image_data)
        .map_err(|e| format!("Failed to write: {}", e))?;

    Ok(temp_path)
}