a2acalling 0.6.50 → 0.6.51

package/native/macos/src-tauri/Cargo.toml

@@ -11,13 +11,14 @@ crate-type = ["lib", "cdylib", "staticlib"]
 tauri-build = { version = "2", features = [] }
 
 [dependencies]
-tauri = { version = "2", features = [] }
+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"] }
+reqwest = { version = "0.12", default-features = false, features = ["json", "rustls-tls", "stream"] }
 tokio = { version = "1", features = ["full"] }
 dirs = "6"
+futures-util = "0.3"

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

@@ -110,8 +110,8 @@ pub fn run() {
             // Start background health monitor
             health::start_health_monitor(app.handle().clone());
 
-            // Start notification poller
-            notifications::start_notification_poller(app.handle().clone());
+            // Start server-driven event listener for native notifications.
+            notifications::start_event_stream_listener(app.handle().clone());
 
             // Menu bar tray icon
             let show = MenuItem::with_id(app, "show", "Show A2A Callbook", true, None::<&str>)?;

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

@@ -1,101 +1,180 @@
-use std::collections::HashSet;
-use std::sync::Mutex;
+use futures_util::StreamExt;
+use std::sync::atomic::{AtomicU64, AtomicUsize, Ordering};
 use std::time::Duration;
 use tauri::Manager;
 use tauri_plugin_notification::NotificationExt;
 
-static SEEN_CALLS: Mutex<Option<HashSet<String>>> = Mutex::new(None);
+static LAST_EVENT_ID: AtomicU64 = AtomicU64::new(0);
+static UNREAD_COUNT: AtomicUsize = AtomicUsize::new(0);
 
 #[derive(Debug, serde::Deserialize)]
-struct CallsResponse {
-    success: bool,
-    calls: Option<Vec<Conversation>>,
+struct DashboardEvent {
+    id: Option<u64>,
+    #[serde(rename = "type")]
+    event_type: Option<String>,
+    payload: Option<serde_json::Value>,
 }
 
-#[derive(Debug, serde::Deserialize)]
-struct Conversation {
-    id: String,
-    contact_name: Option<String>,
-    summary: Option<String>,
-    status: Option<String>,
-    started_at: Option<String>,
+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();
 }
 
-/// 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());
+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) {
     tokio::spawn(async move {
-        // Wait for initial server discovery
-        tokio::time::sleep(Duration::from_secs(10)).await;
+        // Wait for initial discovery attempt.
+        tokio::time::sleep(Duration::from_secs(2)).await;
 
         loop {
-            tokio::time::sleep(Duration::from_secs(15)).await;
-
+            if !crate::health::is_connected() {
+                tokio::time::sleep(Duration::from_secs(2)).await;
+                continue;
+            }
             let port = crate::health::current_port();
-            if port == 0 || !crate::health::is_connected() {
+            if port == 0 {
+                tokio::time::sleep(Duration::from_secs(2)).await;
                 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 {
+            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(_) => 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,
+                Err(_) => {
+                    tokio::time::sleep(Duration::from_secs(2)).await;
+                    continue;
+                }
             };
 
-            if !data.success {
-                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 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) {
+            let response = match req.send().await {
+                Ok(resp) => resp,
+                Err(_) => {
+                    tokio::time::sleep(Duration::from_secs(2)).await;
                     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();
+            };
+            if !response.status().is_success() {
+                tokio::time::sleep(Duration::from_secs(3)).await;
+                continue;
             }
 
-            // 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());
+            // 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/native/macos/src-tauri/tauri.conf.json

@@ -16,13 +16,7 @@
         "minHeight": 600,
         "resizable": true
       }
-    ],
-    "security": {
-      "dangerousRemoteUrlAccess": [
-        { "url": "http://127.0.0.1:**" },
-        { "url": "http://localhost:**" }
-      ]
-    }
+    ]
   },
   "bundle": {
     "active": true,
@@ -30,8 +24,7 @@
     "icon": [
       "icons/32x32.png",
       "icons/128x128.png",
-      "icons/128x128@2x.png",
-      "icons/icon.icns"
+      "icons/128x128@2x.png"
     ],
     "macOS": {
       "minimumSystemVersion": "12.0",

package/package.json

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

package/scripts/postinstall.js

@@ -44,12 +44,10 @@ const result = spawnSync(process.execPath, [cliPath, 'quickstart'], {
 if (result.error) {
   // Don't fail the install — the agent will get onboarding when it runs `a2a`.
   installSkillFiles();
-  installMacOSApp();
   process.exit(0);
 }
 
 installSkillFiles();
-installMacOSApp();
 process.exit(result.status || 0);
 
 // Best-effort: install Claude Code + Codex skills into the workspace
@@ -61,50 +59,3 @@ function installSkillFiles() {
     // Silent — skills can be installed later with `a2a skills`
   }
 }
-
-// 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/dashboard/public/app.js

@@ -11,9 +11,17 @@ const state = {
   invites: [],
   logs: [],
   logStats: null,
-  trace: null
+  trace: null,
+  realtime: {
+    connected: false,
+    lastEventId: null
+  }
 };
 
+let dashboardEventSource = null;
+let reconnectTimer = null;
+let refreshTimer = null;
+
 function showNotice(message) {
   const el = document.getElementById('notice');
   el.textContent = message;
@@ -23,6 +31,143 @@ function showNotice(message) {
   }, 3500);
 }
 
+function scheduleRealtimeRefresh() {
+  clearTimeout(refreshTimer);
+  refreshTimer = setTimeout(() => {
+    Promise.all([
+      loadContacts().catch(() => {}),
+      loadCalls().catch(() => {})
+    ]).catch(() => {});
+  }, 250);
+}
+
+function notifyRealtime(title, body) {
+  const safeTitle = String(title || '').trim();
+  if (!safeTitle) return;
+  const safeBody = String(body || '').trim();
+  if (typeof window.Notification === 'undefined') return;
+  if (Notification.permission === 'granted') {
+    try {
+      // In A2A.app WebView this maps to native macOS notifications.
+      new Notification(safeTitle, safeBody ? { body: safeBody } : undefined);
+    } catch (err) {
+      // Ignore notification errors.
+    }
+    return;
+  }
+  if (Notification.permission !== 'denied') {
+    Notification.requestPermission().catch(() => {});
+  }
+}
+
+function handleRealtimeEvent(eventData) {
+  const type = String(eventData?.type || '').trim();
+  const payload = eventData?.payload || {};
+  if (!type) return;
+
+  if (type === 'call.inbound') {
+    const caller = payload.caller_name || 'Unknown agent';
+    showNotice(`Inbound call: ${caller}`);
+    notifyRealtime(`Inbound call from ${caller}`, 'Open A2A Callbook to respond.');
+    scheduleRealtimeRefresh();
+    return;
+  }
+
+  if (type === 'summary.completed') {
+    const contact = payload.contact_name || 'conversation';
+    showNotice(`Summary complete: ${contact}`);
+    notifyRealtime('Summary complete', `Conversation with ${contact} has a summary.`);
+    scheduleRealtimeRefresh();
+    return;
+  }
+
+  if (type === 'contact.status.changed') {
+    const contactId = String(payload.contact_id || '');
+    const status = String(payload.status || '');
+    if (contactId && status) {
+      state.contacts = (state.contacts || []).map((contact) => {
+        if (String(contact.id) !== contactId) return contact;
+        return { ...contact, status };
+      });
+      renderContacts();
+      renderContactDetail();
+    } else {
+      scheduleRealtimeRefresh();
+    }
+    return;
+  }
+
+  if (type === 'invite.used') {
+    showNotice('Callbook install link used');
+    loadCallbookDevices().catch(() => {});
+    return;
+  }
+
+  if (type === 'call.updated') {
+    scheduleRealtimeRefresh();
+    return;
+  }
+}
+
+function connectRealtimeEvents() {
+  clearTimeout(reconnectTimer);
+  if (dashboardEventSource) {
+    dashboardEventSource.close();
+    dashboardEventSource = null;
+  }
+
+  const qs = new URLSearchParams();
+  if (state.realtime.lastEventId) {
+    qs.set('since', String(state.realtime.lastEventId));
+  }
+  const endpoint = `/api/a2a/dashboard/events${qs.toString() ? `?${qs.toString()}` : ''}`;
+  const source = new EventSource(endpoint);
+  dashboardEventSource = source;
+
+  source.onopen = () => {
+    state.realtime.connected = true;
+  };
+
+  source.onerror = () => {
+    state.realtime.connected = false;
+    if (dashboardEventSource === source) {
+      dashboardEventSource.close();
+      dashboardEventSource = null;
+    }
+    reconnectTimer = setTimeout(connectRealtimeEvents, 1500);
+  };
+
+  const onAnyEvent = (evt) => {
+    let payload = null;
+    try {
+      payload = evt?.data ? JSON.parse(evt.data) : null;
+    } catch (_) {
+      payload = null;
+    }
+    if (!payload || typeof payload !== 'object') return;
+    if (payload.id) {
+      state.realtime.lastEventId = String(payload.id);
+    } else if (evt?.lastEventId) {
+      state.realtime.lastEventId = String(evt.lastEventId);
+    }
+    handleRealtimeEvent(payload);
+  };
+
+  source.onmessage = onAnyEvent;
+  source.addEventListener('call.inbound', onAnyEvent);
+  source.addEventListener('call.updated', onAnyEvent);
+  source.addEventListener('summary.completed', onAnyEvent);
+  source.addEventListener('invite.used', onAnyEvent);
+  source.addEventListener('contact.status.changed', onAnyEvent);
+}
+
+window.addEventListener('beforeunload', () => {
+  if (dashboardEventSource) {
+    dashboardEventSource.close();
+    dashboardEventSource = null;
+  }
+});
+
 async function request(path, options = {}) {
   const res = await fetch(`/api/a2a/dashboard${path}`, {
     headers: { 'Content-Type': 'application/json', ...(options.headers || {}) },
@@ -1365,6 +1510,7 @@ async function bootstrap() {
       loadLogs()
     ]);
     showNotice('Dashboard loaded');
+    connectRealtimeEvents();
 
     setInterval(() => {
       loadAutoUpdateStatus().catch(() => {});

package/src/lib/conversations.js

@@ -18,9 +18,10 @@ const DB_FILENAME = 'a2a-conversations.db';
 const logger = createLogger({ component: 'a2a.conversations' });
 
 class ConversationStore {
-  constructor(configDir = DEFAULT_CONFIG_DIR) {
+  constructor(configDir = DEFAULT_CONFIG_DIR, options = {}) {
     this.configDir = configDir;
     this.dbPath = path.join(configDir, DB_FILENAME);
+    this.eventStore = options.eventStore || null;
     this.db = null;
     this._ensureDir();
   }
@@ -253,6 +254,19 @@ class ConversationStore {
       VALUES (?, ?, ?, ?, ?, ?, ?, 'active')
     `).run(id, contactId, contactName, tokenId, direction, now, now);
 
+    if (this.eventStore && this.eventStore.isAvailable && this.eventStore.isAvailable()) {
+      this.eventStore.emitEvent('call.updated', {
+        conversation_id: id,
+        status: 'active',
+        direction,
+        contact_id: contactId || null,
+        contact_name: contactName || null
+      }, {
+        conversationId: id,
+        contactId: contactId || null
+      });
+    }
+
     return { id, resumed: false };
   }
 
@@ -284,6 +298,14 @@ class ConversationStore {
       WHERE id = ?
     `).run(now, conversationId);
 
+    if (this.eventStore && this.eventStore.isAvailable && this.eventStore.isAvailable()) {
+      this.eventStore.emitEvent('call.updated', {
+        conversation_id: conversationId,
+        status: 'active',
+        direction
+      }, { conversationId });
+    }
+
     return { id, timestamp: now };
   }
 
@@ -450,6 +472,31 @@ class ConversationStore {
       `).run(now, conversationId);
     }
 
+    if (this.eventStore && this.eventStore.isAvailable && this.eventStore.isAvailable()) {
+      this.eventStore.emitEvent('call.updated', {
+        conversation_id: conversationId,
+        status: 'concluded',
+        contact_id: conversation.contact_id || null,
+        contact_name: conversation.contact_name || null
+      }, {
+        conversationId,
+        contactId: conversation.contact_id || null
+      });
+
+      if (summary || ownerSummary) {
+        this.eventStore.emitEvent('summary.completed', {
+          conversation_id: conversationId,
+          contact_id: conversation.contact_id || null,
+          contact_name: conversation.contact_name || null,
+          has_summary: Boolean(summary),
+          has_owner_summary: Boolean(ownerSummary)
+        }, {
+          conversationId,
+          contactId: conversation.contact_id || null
+        });
+      }
+    }
+
     return { 
       success: true, 
       conversationId,
@@ -472,6 +519,13 @@ class ConversationStore {
       WHERE id = ?
     `).run(now, conversationId);
 
+    if (this.eventStore && this.eventStore.isAvailable && this.eventStore.isAvailable()) {
+      this.eventStore.emitEvent('call.updated', {
+        conversation_id: conversationId,
+        status: 'timeout'
+      }, { conversationId });
+    }
+
     return { success: true };
   }