a2acalling 0.6.49 → 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.49",
+  "version": "0.6.51",
   "description": "Agent-to-agent calling for OpenClaw - A2A agent communication",
   "main": "src/index.js",
   "bin": {

package/scripts/install-skills.js

@@ -0,0 +1,80 @@
+/**
+ * A2A Skill Installer
+ *
+ * Copies Claude Code commands and Codex AGENTS.md into a target project directory.
+ * Idempotent: skips files that already exist with identical content.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const PACKAGE_ROOT = path.join(__dirname, '..');
+
+const SKILL_FILES = [
+  { src: '.claude/commands/a2a-call.md', dest: '.claude/commands/a2a-call.md' },
+  { src: '.claude/commands/a2a-invite.md', dest: '.claude/commands/a2a-invite.md' },
+  { src: '.claude/commands/a2a-contacts.md', dest: '.claude/commands/a2a-contacts.md' },
+  { src: '.claude/commands/a2a-status.md', dest: '.claude/commands/a2a-status.md' },
+  { src: '.claude/commands/a2a-setup.md', dest: '.claude/commands/a2a-setup.md' },
+  { src: '.codex/AGENTS.md', dest: '.codex/AGENTS.md' }
+];
+
+function installSkills(targetDir, options = {}) {
+  const result = { installed: [], skipped: [], errors: [] };
+
+  for (const file of SKILL_FILES) {
+    const srcPath = path.join(PACKAGE_ROOT, file.src);
+    const destPath = path.join(targetDir, file.dest);
+
+    try {
+      if (!fs.existsSync(srcPath)) {
+        result.errors.push({ file: file.src, error: 'Source file not found' });
+        continue;
+      }
+
+      const srcContent = fs.readFileSync(srcPath, 'utf8');
+
+      // Check if identical file already exists
+      if (!options.force && fs.existsSync(destPath)) {
+        const existing = fs.readFileSync(destPath, 'utf8');
+        if (existing === srcContent) {
+          result.skipped.push(file.dest);
+          continue;
+        }
+      }
+
+      // Create directory and write file
+      fs.mkdirSync(path.dirname(destPath), { recursive: true });
+      fs.writeFileSync(destPath, srcContent);
+      result.installed.push(file.dest);
+    } catch (err) {
+      result.errors.push({ file: file.dest, error: err.message });
+    }
+  }
+
+  return result;
+}
+
+// CLI mode: node scripts/install-skills.js [targetDir] [--force]
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  const force = args.includes('--force');
+  const targetDir = args.find(a => !a.startsWith('-')) || process.cwd();
+
+  const result = installSkills(targetDir, { force });
+
+  if (result.installed.length) {
+    console.log(`Installed ${result.installed.length} A2A skill file(s):`);
+    result.installed.forEach(f => console.log(`  + ${f}`));
+  }
+  if (result.skipped.length) {
+    console.log(`Skipped ${result.skipped.length} unchanged file(s)`);
+  }
+  if (result.errors.length) {
+    console.error(`Errors: ${result.errors.length}`);
+    result.errors.forEach(e => console.error(`  ! ${e.file}: ${e.error}`));
+    process.exit(1);
+  }
+}
+
+module.exports = { installSkills, SKILL_FILES };

package/scripts/postinstall.js

@@ -43,56 +43,19 @@ 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();
+  installSkillFiles();
   process.exit(0);
 }
 
-installMacOSApp();
+installSkillFiles();
 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;
-
+// Best-effort: install Claude Code + Codex skills into the workspace
+function installSkillFiles() {
   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
+    const { installSkills } = require('./install-skills');
+    installSkills(initCwd);
+  } catch (e) {
+    // Silent — skills can be installed later with `a2a skills`
   }
 }

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(() => {});