a2acalling 0.6.75 → 0.6.76

package/.claude/worktrees/agent-a0a8dd02/native/macos/src-tauri/src/notifications.rs

@@ -0,0 +1,180 @@
+use futures_util::StreamExt;
+use std::sync::atomic::{AtomicU64, AtomicUsize, Ordering};
+use std::time::Duration;
+use tauri::Manager;
+use tauri_plugin_notification::NotificationExt;
+
+static LAST_EVENT_ID: AtomicU64 = AtomicU64::new(0);
+static UNREAD_COUNT: AtomicUsize = AtomicUsize::new(0);
+
+#[derive(Debug, serde::Deserialize)]
+struct DashboardEvent {
+    id: Option<u64>,
+    #[serde(rename = "type")]
+    event_type: Option<String>,
+    payload: Option<serde_json::Value>,
+}
+
+fn maybe_set_dock_badge(app: &tauri::AppHandle, count: usize) {
+    // Best effort: use the main window badge API. On macOS this maps to Dock badge label/count.
+    if let Some(window) = app.get_webview_window("main") {
+        let _ = window.set_badge_count(if count == 0 { None } else { Some(count as i64) });
+    }
+}
+
+fn show_notification(app: &tauri::AppHandle, title: &str, body: &str) {
+    let _ = app.notification().builder().title(title).body(body).show();
+}
+
+fn process_dashboard_event(app: &tauri::AppHandle, raw: &str) {
+    let parsed: DashboardEvent = match serde_json::from_str(raw) {
+        Ok(value) => value,
+        Err(_) => return,
+    };
+
+    if let Some(id) = parsed.id {
+        let current = LAST_EVENT_ID.load(Ordering::Relaxed);
+        if id > current {
+            LAST_EVENT_ID.store(id, Ordering::Relaxed);
+        }
+    }
+
+    let event_type = parsed.event_type.unwrap_or_default();
+    let payload = parsed.payload.unwrap_or_else(|| serde_json::json!({}));
+
+    if event_type == "call.inbound" {
+        let caller = payload
+            .get("caller_name")
+            .and_then(|v| v.as_str())
+            .unwrap_or("Unknown agent");
+        show_notification(
+            app,
+            &format!("Inbound call from {}", caller),
+            "Open A2A Callbook to respond.",
+        );
+        let unread = UNREAD_COUNT.fetch_add(1, Ordering::Relaxed) + 1;
+        maybe_set_dock_badge(app, unread);
+        return;
+    }
+
+    if event_type == "summary.completed" {
+        let contact = payload
+            .get("contact_name")
+            .and_then(|v| v.as_str())
+            .unwrap_or("conversation");
+        show_notification(
+            app,
+            "Summary complete",
+            &format!("Conversation with {} has a summary.", contact),
+        );
+        let unread = UNREAD_COUNT.fetch_add(1, Ordering::Relaxed) + 1;
+        maybe_set_dock_badge(app, unread);
+        return;
+    }
+}
+
+/// Connect to server-driven dashboard SSE and map events to native notifications.
+pub fn start_event_stream_listener(app: tauri::AppHandle) {
+    tauri::async_runtime::spawn(async move {
+        // Wait for initial discovery attempt.
+        tokio::time::sleep(Duration::from_secs(2)).await;
+
+        loop {
+            if !crate::health::is_connected() {
+                tokio::time::sleep(Duration::from_secs(2)).await;
+                continue;
+            }
+            let port = crate::health::current_port();
+            if port == 0 {
+                tokio::time::sleep(Duration::from_secs(2)).await;
+                continue;
+            }
+
+            let url = format!("http://127.0.0.1:{}/api/a2a/dashboard/events?replay=50", port);
+            let client = match reqwest::Client::builder()
+                .timeout(Duration::from_secs(30))
+                .build()
+            {
+                Ok(c) => c,
+                Err(_) => {
+                    tokio::time::sleep(Duration::from_secs(2)).await;
+                    continue;
+                }
+            };
+
+            let mut req = client
+                .get(&url)
+                .header("Accept", "text/event-stream");
+            let last_id = LAST_EVENT_ID.load(Ordering::Relaxed);
+            if last_id > 0 {
+                req = req.header("Last-Event-ID", last_id.to_string());
+            }
+
+            let response = match req.send().await {
+                Ok(resp) => resp,
+                Err(_) => {
+                    tokio::time::sleep(Duration::from_secs(2)).await;
+                    continue;
+                }
+            };
+            if !response.status().is_success() {
+                tokio::time::sleep(Duration::from_secs(3)).await;
+                continue;
+            }
+
+            // On first connect we intentionally suppress replay notifications.
+            // IDs are still tracked so reconnects can resume reliably.
+            let mut suppress_replay_notifications = LAST_EVENT_ID.load(Ordering::Relaxed) == 0;
+            let mut stream = response.bytes_stream();
+            let mut buffer = String::new();
+            let mut data_lines: Vec<String> = Vec::new();
+
+            while let Some(chunk) = stream.next().await {
+                let bytes = match chunk {
+                    Ok(value) => value,
+                    Err(_) => break,
+                };
+                let piece = String::from_utf8_lossy(&bytes);
+                buffer.push_str(&piece);
+
+                while let Some(pos) = buffer.find('\n') {
+                    let mut line: String = buffer.drain(..=pos).collect();
+                    line = line.trim_end_matches('\n').trim_end_matches('\r').to_string();
+
+                    if line.is_empty() {
+                        if !data_lines.is_empty() {
+                            let data = data_lines.join("\n");
+                            if !suppress_replay_notifications {
+                                process_dashboard_event(&app, &data);
+                            }
+                            data_lines.clear();
+                        }
+                        continue;
+                    }
+                    if line.starts_with(':') {
+                        if line.starts_with(": connected") {
+                            suppress_replay_notifications = false;
+                        }
+                        continue;
+                    }
+                    if let Some(rest) = line.strip_prefix("id:") {
+                        let value = rest.trim();
+                        if let Ok(parsed) = value.parse::<u64>() {
+                            let current = LAST_EVENT_ID.load(Ordering::Relaxed);
+                            if parsed > current {
+                                LAST_EVENT_ID.store(parsed, Ordering::Relaxed);
+                            }
+                        }
+                        continue;
+                    }
+                    if let Some(rest) = line.strip_prefix("data:") {
+                        data_lines.push(rest.trim().to_string());
+                    }
+                }
+            }
+
+            // Connection dropped: reconnect with jitter.
+            tokio::time::sleep(Duration::from_millis(900)).await;
+        }
+    });
+}

package/.claude/worktrees/agent-a0a8dd02/native/macos/src-tauri/src/server.rs

@@ -0,0 +1,306 @@
+use serde::Serialize;
+use std::process::Command;
+use std::sync::atomic::{AtomicBool, AtomicU16, AtomicU32, Ordering};
+use std::sync::Mutex;
+use std::time::{Duration, Instant};
+use tauri::{Emitter, Manager};
+use tauri_plugin_shell::process::{CommandChild, CommandEvent};
+use tauri_plugin_shell::ShellExt;
+
+const MAX_CRASH_COUNT: u32 = 5;
+const STABLE_THRESHOLD: Duration = Duration::from_secs(60);
+const MAX_BACKOFF_MS: u64 = 30_000;
+
+#[derive(Debug, Serialize)]
+pub struct StartResult {
+    pub success: bool,
+    pub message: String,
+    pub port: Option<u16>,
+    pub source: String, // "sidecar" | "external" | "none"
+}
+
+/// Holds the sidecar child process, port, and crash recovery state.
+pub struct SidecarState {
+    pub child: Mutex<Option<CommandChild>>,
+    pub port: AtomicU16,
+    pub crash_count: AtomicU32,
+    pub shutting_down: AtomicBool,
+    last_start: Mutex<Option<Instant>>,
+}
+
+impl SidecarState {
+    pub fn new() -> Self {
+        SidecarState {
+            child: Mutex::new(None),
+            port: AtomicU16::new(0),
+            crash_count: AtomicU32::new(0),
+            shutting_down: AtomicBool::new(false),
+            last_start: Mutex::new(None),
+        }
+    }
+
+    pub fn port(&self) -> u16 {
+        self.port.load(Ordering::Relaxed)
+    }
+}
+
+/// Calculate exponential backoff: 1s, 2s, 4s, 8s, 16s (capped at 30s).
+fn backoff_ms(crash_count: u32) -> u64 {
+    let exponent = crash_count.saturating_sub(1).min(4);
+    let ms = 1000u64 << exponent;
+    ms.min(MAX_BACKOFF_MS)
+}
+
+/// Pick a port for the sidecar: prefer config, then OS-assigned.
+fn pick_port() -> u16 {
+    let config_ports = crate::discovery::read_config_ports();
+    if let Some(&port) = config_ports.first() {
+        return port;
+    }
+    // Let the OS pick an available port
+    std::net::TcpListener::bind("127.0.0.1:0")
+        .and_then(|l| l.local_addr())
+        .map(|addr| addr.port())
+        .unwrap_or(3001)
+}
+
+/// Start the A2A server via Tauri sidecar (bundled binary).
+pub fn start_sidecar(app: &tauri::AppHandle) -> StartResult {
+    let port = pick_port();
+    let port_str = port.to_string();
+
+    let sidecar_cmd = match app.shell().sidecar("a2a-server") {
+        Ok(cmd) => cmd,
+        Err(_) => return start_external_server(port),
+    };
+
+    let (rx, child) = match sidecar_cmd
+        .env("PORT", &port_str)
+        .spawn()
+    {
+        Ok(pair) => pair,
+        Err(_) => return start_external_server(port),
+    };
+
+    // Store the child handle and record start time
+    if let Some(state) = app.try_state::<SidecarState>() {
+        state.port.store(port, Ordering::Relaxed);
+        if let Ok(mut guard) = state.child.lock() {
+            *guard = Some(child);
+        }
+        if let Ok(mut guard) = state.last_start.lock() {
+            *guard = Some(Instant::now());
+        }
+    }
+
+    // Monitor sidecar stdout/stderr and detect exit for crash recovery
+    spawn_sidecar_monitor(app.clone(), rx);
+
+    StartResult {
+        success: true,
+        message: format!("Sidecar server starting on port {}...", port),
+        port: Some(port),
+        source: "sidecar".to_string(),
+    }
+}
+
+/// Monitor sidecar output and process exit for crash recovery.
+fn spawn_sidecar_monitor(
+    app: tauri::AppHandle,
+    mut rx: tokio::sync::mpsc::Receiver<CommandEvent>,
+) {
+    tauri::async_runtime::spawn(async move {
+        while let Some(event) = rx.recv().await {
+            match event {
+                CommandEvent::Stdout(line) => {
+                    let text = String::from_utf8_lossy(&line);
+                    let _ = app.emit(
+                        "sidecar-log",
+                        serde_json::json!({
+                            "stream": "stdout",
+                            "line": text.trim_end()
+                        }),
+                    );
+                }
+                CommandEvent::Stderr(line) => {
+                    let text = String::from_utf8_lossy(&line);
+                    let _ = app.emit(
+                        "sidecar-log",
+                        serde_json::json!({
+                            "stream": "stderr",
+                            "line": text.trim_end()
+                        }),
+                    );
+                }
+                CommandEvent::Terminated(payload) => {
+                    handle_sidecar_exit(&app, payload.code);
+                    break;
+                }
+                CommandEvent::Error(msg) => {
+                    let _ = app.emit(
+                        "sidecar-log",
+                        serde_json::json!({
+                            "stream": "stderr",
+                            "line": format!("[sidecar error] {}", msg)
+                        }),
+                    );
+                }
+                _ => {}
+            }
+        }
+    });
+}
+
+/// Handle unexpected sidecar exit with auto-restart and exponential backoff.
+fn handle_sidecar_exit(app: &tauri::AppHandle, exit_code: Option<i32>) {
+    let state = match app.try_state::<SidecarState>() {
+        Some(s) => s,
+        None => return,
+    };
+
+    // Don't restart during intentional shutdown
+    if state.shutting_down.load(Ordering::Relaxed) {
+        return;
+    }
+
+    // Clear the dead child from state
+    if let Ok(mut guard) = state.child.lock() {
+        guard.take();
+    }
+
+    // Reset crash counter if server ran long enough (60s of stable operation)
+    if let Ok(guard) = state.last_start.lock() {
+        if let Some(start_time) = *guard {
+            if start_time.elapsed() >= STABLE_THRESHOLD {
+                state.crash_count.store(0, Ordering::Relaxed);
+            }
+        }
+    }
+
+    let crashes = state.crash_count.fetch_add(1, Ordering::Relaxed) + 1;
+
+    crate::health::set_disconnected();
+
+    let _ = app.emit(
+        "server-status",
+        serde_json::json!({
+            "connected": false,
+            "crashed": true,
+            "crashCount": crashes,
+            "exitCode": exit_code
+        }),
+    );
+
+    // Stop restarting after too many consecutive crashes
+    if crashes >= MAX_CRASH_COUNT {
+        let _ = app.emit(
+            "server-status",
+            serde_json::json!({
+                "connected": false,
+                "crashed": true,
+                "crashCount": crashes,
+                "fatal": true,
+                "message": "Server crashed too many times. Use View > Restart Server to try again."
+            }),
+        );
+        return;
+    }
+
+    // Schedule restart with exponential backoff
+    let delay = backoff_ms(crashes);
+    let app_clone = app.clone();
+    tauri::async_runtime::spawn(async move {
+        tokio::time::sleep(Duration::from_millis(delay)).await;
+
+        if let Some(st) = app_clone.try_state::<SidecarState>() {
+            if st.shutting_down.load(Ordering::Relaxed) {
+                return;
+            }
+        }
+
+        let result = start_sidecar(&app_clone);
+        if result.success {
+            if let Some(port) = result.port {
+                crate::health::set_connected(port);
+            }
+        }
+    });
+}
+
+/// Restart the sidecar — kills existing process, resets crash counter, starts fresh.
+pub fn restart_sidecar(app: &tauri::AppHandle) -> StartResult {
+    kill_sidecar(app);
+
+    if let Some(state) = app.try_state::<SidecarState>() {
+        state.crash_count.store(0, Ordering::Relaxed);
+        state.shutting_down.store(false, Ordering::Relaxed);
+    }
+
+    start_sidecar(app)
+}
+
+/// Kill the running sidecar process (called on app exit or restart).
+pub fn kill_sidecar(app: &tauri::AppHandle) {
+    if let Some(state) = app.try_state::<SidecarState>() {
+        state.shutting_down.store(true, Ordering::Relaxed);
+        if let Ok(mut guard) = state.child.lock() {
+            if let Some(child) = guard.take() {
+                let _ = child.kill();
+            }
+        }
+    }
+}
+
+// ── External CLI fallback ──
+
+/// Find the `a2a` CLI binary on PATH
+fn find_a2a_binary() -> Option<String> {
+    let result = Command::new("which").arg("a2a").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 via external CLI (fallback when sidecar unavailable).
+fn start_external_server(port: u16) -> StartResult {
+    let binary = match find_a2a_binary() {
+        Some(b) => b,
+        None => {
+            return StartResult {
+                success: false,
+                message: "Could not find bundled sidecar or 'a2a' CLI. Is a2acalling installed? Run: npm install -g a2acalling".to_string(),
+                port: None,
+                source: "none".to_string(),
+            };
+        }
+    };
+
+    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!("External server starting on port {}...", port),
+            port: Some(port),
+            source: "external".to_string(),
+        },
+        Err(err) => StartResult {
+            success: false,
+            message: format!("Failed to start server: {}", err),
+            port: None,
+            source: "none".to_string(),
+        },
+    }
+}

package/.claude/worktrees/agent-a0a8dd02/native/macos/src-tauri/src/updater.rs

@@ -0,0 +1,124 @@
+use serde::Serialize;
+use std::sync::Mutex;
+use std::time::{Duration, Instant};
+use tauri::{Emitter, Manager};
+use tauri_plugin_updater::UpdaterExt;
+
+const CHECK_INTERVAL: Duration = Duration::from_secs(3600); // 1 hour
+
+/// Shared state tracking last update check time.
+pub struct UpdateCheckState {
+    last_check: Mutex<Option<Instant>>,
+}
+
+impl UpdateCheckState {
+    pub fn new() -> Self {
+        Self {
+            last_check: Mutex::new(None),
+        }
+    }
+
+    /// Returns true if enough time has passed since the last check.
+    fn should_check(&self) -> bool {
+        let guard = self.last_check.lock().unwrap();
+        match *guard {
+            Some(last) => last.elapsed() >= CHECK_INTERVAL,
+            None => true,
+        }
+    }
+
+    fn mark_checked(&self) {
+        let mut guard = self.last_check.lock().unwrap();
+        *guard = Some(Instant::now());
+    }
+}
+
+#[derive(Clone, Serialize)]
+pub struct UpdateStatus {
+    pub available: bool,
+    pub version: Option<String>,
+    pub body: Option<String>,
+    pub error: Option<String>,
+}
+
+/// Check for updates in the background. Emits "update-status" event to frontend.
+/// Respects rate limit unless `force` is true (for manual checks).
+pub async fn check_for_update(app: tauri::AppHandle, force: bool) {
+    let state = app.state::<UpdateCheckState>();
+
+    if !force && !state.should_check() {
+        return;
+    }
+
+    state.mark_checked();
+
+    let updater = match app.updater() {
+        Ok(u) => u,
+        Err(e) => {
+            let _ = app.emit("update-status", UpdateStatus {
+                available: false,
+                version: None,
+                body: None,
+                error: Some(format!("Updater init failed: {}", e)),
+            });
+            return;
+        }
+    };
+
+    match updater.check().await {
+        Ok(Some(update)) => {
+            let _ = app.emit("update-status", UpdateStatus {
+                available: true,
+                version: Some(update.version.clone()),
+                body: update.body.clone(),
+                error: None,
+            });
+        }
+        Ok(None) => {
+            let _ = app.emit("update-status", UpdateStatus {
+                available: false,
+                version: None,
+                body: None,
+                error: None,
+            });
+        }
+        Err(e) => {
+            let _ = app.emit("update-status", UpdateStatus {
+                available: false,
+                version: None,
+                body: None,
+                error: Some(format!("{}", e)),
+            });
+        }
+    }
+}
+
+/// Download and install the available update. Emits progress events.
+pub async fn install_update(app: tauri::AppHandle) -> Result<(), String> {
+    let updater = app.updater().map_err(|e| format!("Updater init failed: {}", e))?;
+
+    let update = updater
+        .check()
+        .await
+        .map_err(|e| format!("Check failed: {}", e))?
+        .ok_or_else(|| "No update available".to_string())?;
+
+    // A2A-100: Download with progress events
+    let app_clone = app.clone();
+    update
+        .download_and_install(
+            move |chunk_length, content_length| {
+                let _ = app_clone.emit("update-download-progress", serde_json::json!({
+                    "chunkLength": chunk_length,
+                    "contentLength": content_length
+                }));
+            },
+            || {
+                // Download finished — restart will happen after this returns
+            },
+        )
+        .await
+        .map_err(|e| format!("Install failed: {}", e))?;
+
+    Ok(())
+}

package/.claude/worktrees/agent-a0a8dd02/native/macos/src-tauri/tauri.conf.json

@@ -0,0 +1,58 @@
+{
+  "$schema": "https://raw.githubusercontent.com/tauri-apps/tauri/dev/crates/tauri-config-schema/schema.json",
+  "productName": "A2A Callbook",
+  "version": "0.6.74",
+  "identifier": "com.openclaw.a2a-callbook",
+  "build": {
+    "frontendDist": "../index.html"
+  },
+  "app": {
+    "windows": [
+      {
+        "title": "A2A Callbook",
+        "width": 1024,
+        "height": 720,
+        "minWidth": 480,
+        "minHeight": 600,
+        "resizable": true
+      }
+    ]
+  },
+  "bundle": {
+    "active": true,
+    "targets": [
+      "dmg",
+      "app",
+      "updater"
+    ],
+    "externalBin": [
+      "binaries/a2a-server"
+    ],
+    "icon": [
+      "icons/32x32.png",
+      "icons/128x128.png",
+      "icons/128x128@2x.png"
+    ],
+    "macOS": {
+      "minimumSystemVersion": "12.0",
+      "frameworks": [],
+      "entitlements": "entitlements.plist"
+    }
+  },
+  "plugins": {
+    "deep-link": {
+      "desktop": {
+        "schemes": [
+          "a2a"
+        ]
+      }
+    },
+    "updater": {
+      "endpoints": [
+        "https://github.com/onthegonow/a2a_calling/releases/latest/download/latest.json"
+      ],
+      "pubkey": "PLACEHOLDER_REPLACE_WITH_ACTUAL_PUBLIC_KEY",
+      "dialog": false
+    }
+  }
+}