a2acalling 0.6.75 → 0.6.76

package/.claude/worktrees/agent-a5b87d75/native/macos/src-tauri/Cargo.toml

@@ -0,0 +1,25 @@
+[package]
+name = "a2a-callbook"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+name = "a2a_callbook_lib"
+crate-type = ["lib", "cdylib", "staticlib"]
+
+[build-dependencies]
+tauri-build = { version = "2", features = [] }
+
+[dependencies]
+tauri = { version = "2", features = ["tray-icon"] }
+tauri-plugin-shell = "2"
+tauri-plugin-notification = "2"
+tauri-plugin-deep-link = "2"
+tauri-plugin-window-state = "2"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+reqwest = { version = "0.12", default-features = false, features = ["json", "rustls-tls", "stream"] }
+tokio = { version = "1", features = ["full"] }
+dirs = "6"
+futures-util = "0.3"
+tauri-plugin-updater = "2"

package/.claude/worktrees/agent-a5b87d75/native/macos/src-tauri/build.rs

@@ -0,0 +1,3 @@
+fn main() {
+    tauri_build::build()
+}

package/.claude/worktrees/agent-a5b87d75/native/macos/src-tauri/capabilities/default.json

@@ -0,0 +1,26 @@
+{
+  "$schema": "https://raw.githubusercontent.com/tauri-apps/tauri/dev/crates/tauri-utils/schema.json",
+  "identifier": "default",
+  "description": "Default capabilities for A2A Callbook",
+  "windows": ["main"],
+  "permissions": [
+    "core:default",
+    "shell:allow-open",
+    "notification:default",
+    "notification:allow-is-permission-granted",
+    "notification:allow-request-permission",
+    "notification:allow-notify",
+    "deep-link:default",
+    "window-state:default",
+    {
+      "identifier": "shell:allow-execute",
+      "allow": [
+        {
+          "name": "binaries/a2a-server",
+          "sidecar": true,
+          "args": true
+        }
+      ]
+    }
+  ]
+}

package/.claude/worktrees/agent-a5b87d75/native/macos/src-tauri/entitlements.plist

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>com.apple.security.cs.allow-jit</key>
+    <true/>
+    <key>com.apple.security.network.client</key>
+    <true/>
+    <key>com.apple.security.cs.allow-unsigned-executable-memory</key>
+    <true/>
+    <key>com.apple.security.cs.disable-library-validation</key>
+    <true/>
+</dict>
+</plist>

package/.claude/worktrees/agent-a5b87d75/native/macos/src-tauri/src/discovery.rs

@@ -0,0 +1,221 @@
+use serde::{Deserialize, Serialize};
+use std::path::PathBuf;
+use std::time::Duration;
+
+const DEFAULT_PORTS: &[u16] = &[80, 3001, 8080, 8443, 9001];
+const PROBE_TIMEOUT: Duration = Duration::from_millis(800);
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct DiscoveryResult {
+    pub port: Option<u16>,
+    pub source: String, // "config" | "scan" | "none"
+    pub onboarding_complete: bool,
+}
+
+#[derive(Debug, Deserialize)]
+struct A2AConfig {
+    onboarding: Option<OnboardingConfig>,
+    agent: Option<AgentConfig>,
+}
+
+#[derive(Debug, Deserialize)]
+struct OnboardingConfig {
+    #[serde(alias = "serverPort")]
+    server_port: Option<u16>,
+    step: Option<String>,
+    version: Option<u16>,
+}
+
+#[derive(Debug, Deserialize)]
+struct AgentConfig {
+    hostname: Option<String>,
+}
+
+fn parse_port_from_hostname(hostname: &str) -> Option<u16> {
+    let trimmed = hostname.trim();
+    if trimmed.is_empty() {
+        return None;
+    }
+
+    // Allow values like:
+    // - 149.28.213.47:3007
+    // - localhost:3007
+    // - http://localhost:3007
+    // - [::1]:3007
+    let without_scheme = trimmed.split("://").nth(1).unwrap_or(trimmed);
+    let host_segment = without_scheme.split('/').next().unwrap_or(without_scheme);
+
+    if host_segment.starts_with('[') {
+        let end = host_segment.find(']')?;
+        let remainder = &host_segment[end + 1..];
+        let port_str = remainder.strip_prefix(':')?;
+        return port_str.parse::<u16>().ok();
+    }
+
+    // Bare IPv6 literals contain multiple colons and no explicit port delimiter.
+    if host_segment.matches(':').count() > 1 {
+        return None;
+    }
+
+    let (_, port_str) = host_segment.rsplit_once(':')?;
+    if !port_str.chars().all(|ch| ch.is_ascii_digit()) {
+        return None;
+    }
+
+    port_str.parse::<u16>().ok()
+}
+
+/// Read likely server ports from ~/.config/openclaw/a2a-config.json.
+/// We prefer explicit onboarding server_port, then agent.hostname port.
+pub fn read_config_ports() -> Vec<u16> {
+    let config_dir = std::env::var("A2A_CONFIG_DIR")
+        .or_else(|_| std::env::var("OPENCLAW_CONFIG_DIR"))
+        .map(PathBuf::from)
+        .unwrap_or_else(|_| {
+            dirs::home_dir()
+                .unwrap_or_else(|| PathBuf::from("/tmp"))
+                .join(".config")
+                .join("openclaw")
+        });
+
+    let config_path = config_dir.join("a2a-config.json");
+    let content = match std::fs::read_to_string(config_path) {
+        Ok(data) => data,
+        Err(_) => return vec![],
+    };
+    let config: A2AConfig = match serde_json::from_str(&content) {
+        Ok(parsed) => parsed,
+        Err(_) => return vec![],
+    };
+
+    let mut ports = Vec::new();
+
+    if let Some(port) = config.onboarding.and_then(|ob| ob.server_port) {
+        ports.push(port);
+    }
+
+    if let Some(port) = config
+        .agent
+        .and_then(|agent| agent.hostname)
+        .and_then(|hostname| parse_port_from_hostname(&hostname))
+    {
+        if !ports.contains(&port) {
+            ports.push(port);
+        }
+    }
+
+    ports
+}
+
+/// Check if onboarding has been completed by reading config.
+pub fn is_onboarding_complete() -> bool {
+    let config_dir = std::env::var("A2A_CONFIG_DIR")
+        .or_else(|_| std::env::var("OPENCLAW_CONFIG_DIR"))
+        .map(PathBuf::from)
+        .unwrap_or_else(|_| {
+            dirs::home_dir()
+                .unwrap_or_else(|| PathBuf::from("/tmp"))
+                .join(".config")
+                .join("openclaw")
+        });
+
+    let config_path = config_dir.join("a2a-config.json");
+    let content = match std::fs::read_to_string(config_path) {
+        Ok(data) => data,
+        Err(_) => return false,
+    };
+    let config: A2AConfig = match serde_json::from_str(&content) {
+        Ok(parsed) => parsed,
+        Err(_) => return false,
+    };
+
+    config
+        .onboarding
+        .map(|ob| ob.version == Some(2) && ob.step.as_deref() == Some("complete"))
+        .unwrap_or(false)
+}
+
+/// Probe a single port — returns true if a2a server responds
+async fn probe_port(port: u16) -> bool {
+    let client = reqwest::Client::builder()
+        .timeout(PROBE_TIMEOUT)
+        .build();
+
+    let client = match client {
+        Ok(c) => c,
+        Err(_) => return false,
+    };
+
+    for host in ["127.0.0.1", "localhost"] {
+        let url = format!("http://{}:{}/api/a2a/ping", host, port);
+        let ok = match client.get(&url).send().await {
+            Ok(resp) => {
+                if !resp.status().is_success() {
+                    false
+                } else {
+                    match resp.text().await {
+                        Ok(body) => body.contains("\"pong\":true"),
+                        Err(_) => false,
+                    }
+                }
+            }
+            Err(_) => false,
+        };
+
+        if ok {
+            return true;
+        }
+    }
+
+    false
+}
+
+/// Discover the running a2a server.
+/// If `sidecar_port` is provided, check it first before config/scan fallback.
+pub async fn discover_server(sidecar_port: Option<u16>) -> DiscoveryResult {
+    let onboarding_complete = is_onboarding_complete();
+
+    // 0. Check sidecar port first (highest priority)
+    if let Some(port) = sidecar_port {
+        if probe_port(port).await {
+            return DiscoveryResult {
+                port: Some(port),
+                source: "sidecar".to_string(),
+                onboarding_complete,
+            };
+        }
+    }
+
+    let config_ports = read_config_ports();
+
+    // 1. Try config-derived ports
+    for &port in &config_ports {
+        if probe_port(port).await {
+            return DiscoveryResult {
+                port: Some(port),
+                source: "config".to_string(),
+                onboarding_complete,
+            };
+        }
+    }
+
+    // 2. Scan default ports (skip those already checked from config)
+    for &port in DEFAULT_PORTS {
+        if config_ports.contains(&port) {
+            continue;
+        }
+        if probe_port(port).await {
+            return DiscoveryResult {
+                port: Some(port),
+                source: "scan".to_string(),
+                onboarding_complete,
+            };
+        }
+    }
+
+    DiscoveryResult {
+        port: None,
+        source: "none".to_string(),
+        onboarding_complete,
+    }
+}

package/.claude/worktrees/agent-a5b87d75/native/macos/src-tauri/src/health.rs

@@ -0,0 +1,67 @@
+use std::sync::atomic::{AtomicBool, AtomicU16, Ordering};
+use std::time::Duration;
+use tauri::{Emitter, Manager};
+
+static CONNECTED: AtomicBool = AtomicBool::new(false);
+static CURRENT_PORT: AtomicU16 = AtomicU16::new(0);
+
+pub fn is_connected() -> bool {
+    CONNECTED.load(Ordering::Relaxed)
+}
+
+pub fn current_port() -> u16 {
+    CURRENT_PORT.load(Ordering::Relaxed)
+}
+
+pub fn set_connected(port: u16) {
+    CURRENT_PORT.store(port, Ordering::Relaxed);
+    CONNECTED.store(true, Ordering::Relaxed);
+}
+
+pub fn set_disconnected() {
+    CONNECTED.store(false, Ordering::Relaxed);
+}
+
+/// Start background health check loop — emits "server-status" events
+pub fn start_health_monitor(app: tauri::AppHandle) {
+    tauri::async_runtime::spawn(async move {
+        let handle = app;
+        loop {
+            tokio::time::sleep(Duration::from_secs(3)).await;
+
+            let port = CURRENT_PORT.load(Ordering::Relaxed);
+            if port == 0 {
+                continue;
+            }
+
+            let url = format!("http://127.0.0.1:{}/api/a2a/ping", port);
+            let client = match reqwest::Client::builder()
+                .timeout(Duration::from_millis(1500))
+                .build() {
+                Ok(c) => c,
+                Err(_) => continue,
+            };
+
+            let ok = match client.get(&url).send().await {
+                Ok(resp) => resp.status().is_success(),
+                Err(_) => false,
+            };
+
+            let was_connected = CONNECTED.swap(ok, Ordering::Relaxed);
+
+            // Only emit on state change
+            if ok != was_connected {
+                let _ = handle.emit("server-status", serde_json::json!({
+                    "connected": ok,
+                    "port": port
+                }));
+                // Navigate back to loader page on disconnect so reconnection UI is shown
+                if !ok {
+                    if let Some(window) = handle.get_webview_window("main") {
+                        let _ = window.navigate("tauri://localhost".parse().unwrap());
+                    }
+                }
+            }
+        }
+    });
+}

package/.claude/worktrees/agent-a5b87d75/native/macos/src-tauri/src/lib.rs

@@ -0,0 +1,256 @@
+use tauri::{Manager, RunEvent, WindowEvent};
+use tauri::menu::{Menu, MenuItem, Submenu, PredefinedMenuItem, AboutMetadata};
+use tauri::tray::{MouseButton, MouseButtonState, TrayIconBuilder, TrayIconEvent};
+use tauri_plugin_deep_link::DeepLinkExt;
+
+mod discovery;
+mod health;
+mod notifications;
+mod server;
+mod updater;
+
+#[tauri::command]
+async fn discover_server(app: tauri::AppHandle) -> Result<discovery::DiscoveryResult, String> {
+    let sidecar_port = app
+        .try_state::<server::SidecarState>()
+        .map(|state| state.port())
+        .filter(|&p| p > 0);
+
+    let result = discovery::discover_server(sidecar_port).await;
+    if let Some(port) = result.port {
+        health::set_connected(port);
+    }
+    Ok(result)
+}
+
+#[tauri::command]
+fn start_server(app: tauri::AppHandle) -> Result<server::StartResult, String> {
+    Ok(server::start_sidecar(&app))
+}
+
+#[tauri::command]
+fn restart_server(app: tauri::AppHandle) -> Result<server::StartResult, String> {
+    let result = server::restart_sidecar(&app);
+    if result.success {
+        if let Some(port) = result.port {
+            health::set_connected(port);
+        }
+    }
+    Ok(result)
+}
+
+#[tauri::command]
+async fn check_update(app: tauri::AppHandle, force: bool) -> Result<(), String> {
+    updater::check_for_update(app, force).await;
+    Ok(())
+}
+
+#[tauri::command]
+async fn install_update(app: tauri::AppHandle) -> Result<(), String> {
+    updater::install_update(app).await
+}
+
+fn build_menu(app: &tauri::AppHandle) -> tauri::Result<Menu<tauri::Wry>> {
+    let about = PredefinedMenuItem::about(app, Some("About A2A Callbook"), Some(AboutMetadata {
+        name: Some("A2A Callbook".into()),
+        version: Some(env!("CARGO_PKG_VERSION").into()),
+        ..Default::default()
+    }))?;
+    let quit = PredefinedMenuItem::quit(app, Some("Quit A2A Callbook"))?;
+    let hide = PredefinedMenuItem::hide(app, Some("Hide A2A Callbook"))?;
+    let preferences = MenuItem::with_id(app, "preferences", "Preferences\u{2026}", true, Some("CmdOrCtrl+,"))?;
+    let separator = PredefinedMenuItem::separator(app)?;
+
+    let app_menu = Submenu::with_items(app, "A2A Callbook", true, &[
+        &about, &separator, &preferences, &separator, &hide, &separator, &quit,
+    ])?;
+
+    // View menu with tab shortcuts
+    let contacts = MenuItem::with_id(app, "tab-contacts", "Contacts", true, Some("CmdOrCtrl+1"))?;
+    let calls = MenuItem::with_id(app, "tab-calls", "Calls", true, Some("CmdOrCtrl+2"))?;
+    let settings = MenuItem::with_id(app, "tab-settings", "Settings", true, Some("CmdOrCtrl+3"))?;
+    let invites = MenuItem::with_id(app, "tab-invites", "Invites", true, Some("CmdOrCtrl+4"))?;
+    let logs = MenuItem::with_id(app, "tab-logs", "Logs", true, Some("CmdOrCtrl+5"))?;
+    let sep2 = PredefinedMenuItem::separator(app)?;
+    let refresh = MenuItem::with_id(app, "refresh", "Refresh", true, Some("CmdOrCtrl+R"))?;
+    let check_updates = MenuItem::with_id(app, "check-updates", "Check for Updates\u{2026}", true, None::<&str>)?;
+    let restart = MenuItem::with_id(app, "restart-server", "Restart Server", true, None::<&str>)?;
+
+    let view_menu = Submenu::with_items(app, "View", true, &[
+        &contacts, &calls, &settings, &invites, &logs, &sep2, &refresh, &check_updates, &restart,
+    ])?;
+
+    // Edit menu (standard macOS)
+    let copy = PredefinedMenuItem::copy(app, None)?;
+    let paste = PredefinedMenuItem::paste(app, None)?;
+    let cut = PredefinedMenuItem::cut(app, None)?;
+    let select_all = PredefinedMenuItem::select_all(app, None)?;
+    let edit_menu = Submenu::with_items(app, "Edit", true, &[
+        &cut, &copy, &paste, &select_all,
+    ])?;
+
+    let window_menu = Submenu::with_items(app, "Window", true, &[
+        &PredefinedMenuItem::minimize(app, None)?,
+        &PredefinedMenuItem::close_window(app, Some("Hide Window"))?,
+    ])?;
+
+    Menu::with_items(app, &[&app_menu, &edit_menu, &view_menu, &window_menu])
+}
+
+#[cfg_attr(mobile, tauri::mobile_entry_point)]
+pub fn run() {
+    let app = tauri::Builder::default()
+        .plugin(tauri_plugin_shell::init())
+        .plugin(tauri_plugin_notification::init())
+        .plugin(tauri_plugin_deep_link::init())
+        .plugin(tauri_plugin_window_state::Builder::new().build())
+        .plugin(tauri_plugin_updater::Builder::new().build())
+        .manage(server::SidecarState::new())
+        .manage(updater::UpdateCheckState::new())
+        .invoke_handler(tauri::generate_handler![discover_server, start_server, restart_server, check_update, install_update])
+        .setup(|app| {
+            let menu = build_menu(app.handle())?;
+            app.set_menu(menu)?;
+
+            // Handle menu events
+            let app_handle = app.handle().clone();
+            app.on_menu_event(move |_app, event| {
+                let id = event.id().0.as_str();
+                let tab = match id {
+                    "tab-contacts" => Some("contacts"),
+                    "tab-calls" => Some("calls"),
+                    "tab-logs" => Some("logs"),
+                    "tab-settings" => Some("settings"),
+                    "tab-invites" => Some("invites"),
+                    "preferences" => Some("settings"),
+                    "refresh" => {
+                        if let Some(window) = app_handle.get_webview_window("main") {
+                            let _ = window.eval("window.location.reload()");
+                        }
+                        None
+                    }
+                    "check-updates" => {
+                        let handle = app_handle.clone();
+                        tauri::async_runtime::spawn(async move {
+                            updater::check_for_update(handle, true).await;
+                        });
+                        None
+                    }
+                    "restart-server" => {
+                        let result = server::restart_sidecar(&app_handle);
+                        if result.success {
+                            if let Some(port) = result.port {
+                                health::set_connected(port);
+                            }
+                        }
+                        None
+                    }
+                    _ => None,
+                };
+
+                if let Some(tab_name) = tab {
+                    if let Some(window) = app_handle.get_webview_window("main") {
+                        let js = format!("window.location.hash = '{}'", tab_name);
+                        let _ = window.eval(&js);
+                    }
+                }
+            });
+
+            // Start the bundled A2A server sidecar
+            let start_result = server::start_sidecar(app.handle());
+            if start_result.success {
+                if let Some(port) = start_result.port {
+                    health::set_connected(port);
+                }
+            }
+
+            // Start background health monitor
+            health::start_health_monitor(app.handle().clone());
+
+            // Start server-driven event listener for native notifications.
+            notifications::start_event_stream_listener(app.handle().clone());
+
+            // A2A-100: Background update check after app launch (non-blocking)
+            let update_handle = app.handle().clone();
+            tauri::async_runtime::spawn(async move {
+                // Small delay to let the app finish loading before checking
+                tokio::time::sleep(std::time::Duration::from_secs(5)).await;
+                updater::check_for_update(update_handle, false).await;
+            });
+
+            // Menu bar tray icon
+            let show = MenuItem::with_id(app, "show", "Show A2A Callbook", true, None::<&str>)?;
+            let tray_quit = MenuItem::with_id(app, "tray-quit", "Quit", true, None::<&str>)?;
+            let tray_menu = Menu::with_items(app, &[&show, &tray_quit])?;
+
+            let _tray = TrayIconBuilder::new()
+                .tooltip("A2A Callbook")
+                .menu(&tray_menu)
+                .on_menu_event(|app, event| {
+                    match event.id().0.as_str() {
+                        "show" => {
+                            if let Some(window) = app.get_webview_window("main") {
+                                let _ = window.show();
+                                let _ = window.set_focus();
+                            }
+                        }
+                        "tray-quit" => {
+                            app.exit(0);
+                        }
+                        _ => {}
+                    }
+                })
+                .on_tray_icon_event(|tray, event| {
+                    if let TrayIconEvent::Click { button: MouseButton::Left, button_state: MouseButtonState::Up, .. } = event {
+                        let app = tray.app_handle();
+                        if let Some(window) = app.get_webview_window("main") {
+                            let _ = window.show();
+                            let _ = window.set_focus();
+                        }
+                    }
+                })
+                .build(app)?;
+
+            // Handle a2a:// deep links
+            let deep_link_handle = app.handle().clone();
+            app.deep_link().on_open_url(move |event| {
+                let urls = event.urls();
+                for url in urls {
+                    let url_str = url.to_string();
+                    // a2a://host/callbook/CODE or a2a://host/fed_TOKEN
+                    if let Some(window) = deep_link_handle.get_webview_window("main") {
+                        let _ = window.show();
+                        let _ = window.set_focus();
+                        // Pass URL to the SPA via JS
+                        let js = format!(
+                            "window.__A2A_DEEP_LINK = '{}'; \
+                             window.dispatchEvent(new CustomEvent('a2a-deep-link', {{ detail: '{}' }}))",
+                            url_str.replace('\\', "\\\\").replace('\'', "\\'"),
+                            url_str.replace('\\', "\\\\").replace('\'', "\\'")
+                        );
+                        let _ = window.eval(&js);
+                    }
+                }
+            });
+
+            Ok(())
+        })
+        .build(tauri::generate_context!())
+        .expect("error building A2A Callbook");
+
+    // Cmd+W hides window instead of quitting; kill sidecar on exit
+    app.run(|app_handle, event| {
+        match &event {
+            RunEvent::WindowEvent { label, event: WindowEvent::CloseRequested { api, .. }, .. } => {
+                api.prevent_close();
+                if let Some(window) = app_handle.get_webview_window(label) {
+                    let _ = window.hide();
+                }
+            }
+            RunEvent::Exit => {
+                server::kill_sidecar(app_handle);
+            }
+            _ => {}
+        }
+    });
+}

package/.claude/worktrees/agent-a5b87d75/native/macos/src-tauri/src/main.rs

@@ -0,0 +1,6 @@
+// Prevents additional console window on Windows in release
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
+
+fn main() {
+    a2a_callbook_lib::run()
+}