a2acalling 0.6.44 → 0.6.46

package/native/macos/src-tauri/src/lib.rs

@@ -0,0 +1,185 @@
+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;
+
+#[tauri::command]
+async fn discover_server() -> Result<discovery::DiscoveryResult, String> {
+    let result = discovery::discover_server().await;
+    if let Some(port) = result.port {
+        health::set_connected(port);
+    }
+    Ok(result)
+}
+
+#[tauri::command]
+fn start_server() -> Result<server::StartResult, String> {
+    Ok(server::start_server())
+}
+
+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 logs = MenuItem::with_id(app, "tab-logs", "Logs", true, Some("CmdOrCtrl+3"))?;
+    let settings = MenuItem::with_id(app, "tab-settings", "Settings", true, Some("CmdOrCtrl+4"))?;
+    let invites = MenuItem::with_id(app, "tab-invites", "Invites", true, Some("CmdOrCtrl+5"))?;
+    let sep2 = PredefinedMenuItem::separator(app)?;
+    let refresh = MenuItem::with_id(app, "refresh", "Refresh", true, Some("CmdOrCtrl+R"))?;
+
+    let view_menu = Submenu::with_items(app, "View", true, &[
+        &contacts, &calls, &logs, &settings, &invites, &sep2, &refresh,
+    ])?;
+
+    // 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())
+        .invoke_handler(tauri::generate_handler![discover_server, start_server])
+        .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
+                    }
+                    _ => 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 background health monitor
+            health::start_health_monitor(app.handle().clone());
+
+            // Start notification poller
+            notifications::start_notification_poller(app.handle().clone());
+
+            // 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
+    app.run(|app_handle, event| {
+        if let RunEvent::WindowEvent { label, event: WindowEvent::CloseRequested { api, .. }, .. } = &event {
+            api.prevent_close();
+            if let Some(window) = app_handle.get_webview_window(label) {
+                let _ = window.hide();
+            }
+        }
+    });
+}

package/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()
+}

package/native/macos/src-tauri/src/notifications.rs

@@ -0,0 +1,101 @@
+use std::collections::HashSet;
+use std::sync::Mutex;
+use std::time::Duration;
+use tauri::Manager;
+use tauri_plugin_notification::NotificationExt;
+
+static SEEN_CALLS: Mutex<Option<HashSet<String>>> = Mutex::new(None);
+
+#[derive(Debug, serde::Deserialize)]
+struct CallsResponse {
+    success: bool,
+    calls: Option<Vec<Conversation>>,
+}
+
+#[derive(Debug, serde::Deserialize)]
+struct Conversation {
+    id: String,
+    contact_name: Option<String>,
+    summary: Option<String>,
+    status: Option<String>,
+    started_at: Option<String>,
+}
+
+/// Poll for new inbound calls and fire native notifications
+pub fn start_notification_poller(app: tauri::AppHandle) {
+    // Initialize seen set
+    {
+        let mut seen = SEEN_CALLS.lock().unwrap();
+        *seen = Some(HashSet::new());
+    }
+
+    tokio::spawn(async move {
+        // Wait for initial server discovery
+        tokio::time::sleep(Duration::from_secs(10)).await;
+
+        loop {
+            tokio::time::sleep(Duration::from_secs(15)).await;
+
+            let port = crate::health::current_port();
+            if port == 0 || !crate::health::is_connected() {
+                continue;
+            }
+
+            let url = format!(
+                "http://127.0.0.1:{}/api/a2a/dashboard/calls?status=active",
+                port
+            );
+
+            let client = reqwest::Client::builder()
+                .timeout(Duration::from_secs(5))
+                .build();
+
+            let client = match client {
+                Ok(c) => c,
+                Err(_) => continue,
+            };
+
+            let resp = match client.get(&url).send().await {
+                Ok(r) => r,
+                Err(_) => continue,
+            };
+
+            let data: CallsResponse = match resp.json().await {
+                Ok(d) => d,
+                Err(_) => continue,
+            };
+
+            if !data.success {
+                continue;
+            }
+
+            let conversations = data.calls.unwrap_or_default();
+            let mut seen = SEEN_CALLS.lock().unwrap();
+            let seen_set = seen.as_mut().unwrap();
+
+            for conv in &conversations {
+                if seen_set.contains(&conv.id) {
+                    continue;
+                }
+                seen_set.insert(conv.id.clone());
+
+                let caller = conv.contact_name.as_deref().unwrap_or("Unknown agent");
+                let summary = conv.summary.as_deref().unwrap_or("New inbound call");
+
+                let _ = app.notification()
+                    .builder()
+                    .title(&format!("Inbound call from {}", caller))
+                    .body(summary)
+                    .show();
+            }
+
+            // Prevent unbounded memory growth — cap at 1000 entries
+            if seen_set.len() > 1000 {
+                seen_set.clear();
+                for conv in &conversations {
+                    seen_set.insert(conv.id.clone());
+                }
+            }
+        }
+    });
+}

package/native/macos/src-tauri/src/server.rs

@@ -0,0 +1,67 @@
+use serde::Serialize;
+use std::process::Command;
+
+#[derive(Debug, Serialize)]
+pub struct StartResult {
+    pub success: bool,
+    pub message: String,
+}
+
+/// Find the `a2a` CLI binary
+fn find_a2a_binary() -> Option<String> {
+    // Check common locations
+    let candidates = [
+        "a2a",  // In PATH
+    ];
+
+    for candidate in &candidates {
+        let result = Command::new("which")
+            .arg(candidate)
+            .output();
+
+        if let Ok(output) = result {
+            if output.status.success() {
+                let path = String::from_utf8_lossy(&output.stdout).trim().to_string();
+                if !path.is_empty() {
+                    return Some(path);
+                }
+            }
+        }
+    }
+
+    None
+}
+
+/// Start the a2a server as a detached process
+pub fn start_server() -> StartResult {
+    let binary = match find_a2a_binary() {
+        Some(b) => b,
+        None => {
+            return StartResult {
+                success: false,
+                message: "Could not find 'a2a' CLI. Is a2acalling installed? Run: npm install -g a2acalling".to_string(),
+            };
+        }
+    };
+
+    let port = crate::discovery::read_config_port().unwrap_or(3001);
+    let port_str = port.to_string();
+
+    let result = Command::new(&binary)
+        .args(["server", "--port", &port_str])
+        .stdout(std::process::Stdio::null())
+        .stderr(std::process::Stdio::null())
+        .stdin(std::process::Stdio::null())
+        .spawn();
+
+    match result {
+        Ok(_child) => StartResult {
+            success: true,
+            message: format!("Server starting on port {}...", port),
+        },
+        Err(err) => StartResult {
+            success: false,
+            message: format!("Failed to start server: {}", err),
+        },
+    }
+}

package/native/macos/src-tauri/tauri.conf.json

@@ -0,0 +1,48 @@
+{
+  "$schema": "https://raw.githubusercontent.com/tauri-apps/tauri/dev/crates/tauri-config-schema/schema.json",
+  "productName": "A2A Callbook",
+  "version": "0.1.0",
+  "identifier": "com.openclaw.a2a-callbook",
+  "build": {
+    "frontendDist": "../index.html"
+  },
+  "app": {
+    "windows": [
+      {
+        "title": "A2A Callbook",
+        "width": 1024,
+        "height": 720,
+        "minWidth": 480,
+        "minHeight": 600,
+        "resizable": true
+      }
+    ],
+    "security": {
+      "dangerousRemoteUrlAccess": [
+        { "url": "http://127.0.0.1:**" },
+        { "url": "http://localhost:**" }
+      ]
+    }
+  },
+  "bundle": {
+    "active": true,
+    "targets": ["dmg", "app"],
+    "icon": [
+      "icons/32x32.png",
+      "icons/128x128.png",
+      "icons/128x128@2x.png",
+      "icons/icon.icns"
+    ],
+    "macOS": {
+      "minimumSystemVersion": "12.0",
+      "frameworks": []
+    }
+  },
+  "plugins": {
+    "deep-link": {
+      "desktop": {
+        "schemes": ["a2a"]
+      }
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "a2acalling",
-  "version": "0.6.44",
+  "version": "0.6.46",
   "description": "Agent-to-agent calling for OpenClaw - A2A agent communication",
   "main": "src/index.js",
   "bin": {

package/scripts/postinstall.js

@@ -43,7 +43,56 @@ const result = spawnSync(process.execPath, [cliPath, 'quickstart'], {
 
 if (result.error) {
   // Don't fail the install — the agent will get onboarding when it runs `a2a`.
+  installMacOSApp();
   process.exit(0);
 }
 
+installMacOSApp();
 process.exit(result.status || 0);
+
+// Download and install the native macOS app from GitHub Releases
+function installMacOSApp() {
+  const os = require('os');
+  const fs = require('fs');
+
+  if (os.platform() !== 'darwin') return;
+
+  try {
+    const version = require('../package.json').version;
+    const appDir = path.join(os.homedir(), 'Applications');
+    const appPath = path.join(appDir, 'A2A Callbook.app');
+
+    // Skip if already installed at same version
+    const plistPath = path.join(appPath, 'Contents', 'Info.plist');
+    if (fs.existsSync(plistPath)) {
+      try {
+        const plist = fs.readFileSync(plistPath, 'utf8');
+        if (plist.includes(version)) {
+          return; // Same version already installed
+        }
+      } catch (_) {}
+    }
+
+    const tarUrl = `https://github.com/onthegonow/a2a_calling/releases/download/v${version}/A2A-Callbook-${version}.app.tar.gz`;
+    const tmpFile = path.join(os.tmpdir(), `a2a-callbook-${version}.tar.gz`);
+
+    // Download
+    const { execFileSync } = require('child_process');
+    execFileSync('curl', ['-sL', '-o', tmpFile, tarUrl], { timeout: 30000 });
+
+    if (!fs.existsSync(tmpFile) || fs.statSync(tmpFile).size < 1000) {
+      return; // Download failed or too small — skip silently
+    }
+
+    // Ensure ~/Applications exists
+    fs.mkdirSync(appDir, { recursive: true });
+
+    // Extract
+    execFileSync('tar', ['-xzf', tmpFile, '-C', appDir], { timeout: 15000 });
+
+    // Cleanup
+    try { fs.unlinkSync(tmpFile); } catch (_) {}
+  } catch (_) {
+    // Silently fail — native app is optional
+  }
+}

package/src/lib/disclosure.js

@@ -608,6 +608,8 @@ Use ALL available context to build a reasonable disclosure profile. If truly not
 
   const jsonBlock = `\`\`\`json
 {
+  "owner_name": "The human owner's real name (extracted from USER.md, git config, etc.)",
+  "agent_name": "The agent's display name (extracted from USER.md or workspace context)",
   "tiers": {
     "public": {
       "topics": [