a2acalling 0.6.44 → 0.6.46

package/docs/plans/2026-02-16-bugfixes-22-24.md

@@ -0,0 +1,246 @@
+# Bugfix Plan: A2A-22 + A2A-24
+
+> **For Claude:** Execute these fixes on branch `fix/bugs-22-23-24` in `/root/a2acalling`
+
+**Goal:** Fix quickstart onboarding gaps (identity, disclosure levels, goals) and surface network warnings during quickstart.
+
+**A2A-23 is already fixed** in commit d3fe14e. This plan covers A2A-22 and A2A-24 only.
+
+---
+
+## Bug A2A-22: Quickstart onboarding gaps
+
+### Fix 1: Disclosure levels inverted on friends/family tiers
+
+**File:** `bin/cli.js` ~line 546-553 (inside `handleDisclosureSubmit`)
+
+**Problem:** Friends and family tiers are set to `disclosure: 'minimal'` when they should be more open than public.
+
+**Fix:** Change disclosure levels to escalate: public→'minimal', friends→'standard', family→'full'.
+
+```javascript
+// BEFORE (broken):
+config.setTier('public', { topics: ..., disclosure: 'public' });
+config.setTier('friends', { topics: ..., disclosure: 'minimal' });
+config.setTier('family', { topics: ..., disclosure: 'minimal' });
+
+// AFTER (fixed):
+config.setTier('public', { topics: ..., disclosure: 'minimal' });
+config.setTier('friends', { topics: ..., disclosure: 'standard' });
+config.setTier('family', { topics: ..., disclosure: 'full' });
+```
+
+**Rationale:** Public tier should be most restrictive (minimal). Friends get more (standard). Family gets full disclosure. This matches the trust hierarchy.
+
+### Fix 2: Extract identity from disclosure submission
+
+**File:** `bin/cli.js` ~line 564-568 (inside `handleDisclosureSubmit`)
+
+**Problem:** Agent name defaults to 'my-agent', owner name is set to agent name. The disclosure manifest often contains the real owner name in `personality_notes` or the submission JSON, but it's never extracted.
+
+**Fix:** After parsing the disclosure JSON, extract identity fields:
+1. Check if the submission JSON has `agent_name` or `owner_name` fields (the extraction prompt should request these)
+2. Fall back to extracting from `personality_notes` (often contains "I'm [Name]" or similar)
+3. Fall back to the OS username
+4. Use extracted values for config and token creation
+
+In `handleDisclosureSubmit`, after line ~527 where `result` is validated, add:
+
+```javascript
+// Extract identity from disclosure submission
+const ownerName = result.owner_name
+  || result.manifest?.owner_name
+  || extractNameFromPersonality(result.manifest?.personality_notes)
+  || process.env.USER
+  || 'Agent Owner';
+
+const agentName = args.flags.name
+  || result.agent_name
+  || config.getAgent().name
+  || process.env.A2A_AGENT_NAME
+  || `${ownerName}'s Agent`;
+
+// Save identity to config
+config.setAgent({ name: agentName, owner_name: ownerName });
+```
+
+Add a helper function (before `handleDisclosureSubmit`):
+
+```javascript
+function extractNameFromPersonality(notes) {
+  if (!notes || typeof notes !== 'string') return null;
+  // Look for patterns like "I'm Ben", "My name is Ben", "Owner: Ben"
+  const patterns = [
+    /(?:I'm|I am|My name is|Name:|Owner:)\s+([A-Z][a-z]+(?:\s+[A-Z][a-z]+)?)/,
+    /^([A-Z][a-z]+(?:\s+[A-Z][a-z]+)?)\s+(?:is|here|speaking)/
+  ];
+  for (const p of patterns) {
+    const m = notes.match(p);
+    if (m && m[1]) return m[1].trim();
+  }
+  return null;
+}
+```
+
+### Fix 3: Use extracted identity in token creation
+
+**File:** `bin/cli.js` ~line 572-582
+
+**Problem:** Token uses `agentName` as both name and owner, with hardcoded goals.
+
+**Fix:** Use the extracted `ownerName` for the token owner field:
+
+```javascript
+// BEFORE:
+const { token } = store.create({
+  name: agentName,
+  owner: agentName,  // wrong — should be owner name
+  ...
+});
+
+// AFTER:
+const { token } = store.create({
+  name: agentName,
+  owner: ownerName,
+  ...
+});
+```
+
+### Fix 4: Sync disclosure objectives to token goals
+
+**File:** `bin/cli.js` ~line 579
+
+**Problem:** Token goals are hardcoded `['grow-network', 'find-collaborators', 'build-in-public']` instead of derived from disclosure.
+
+**Fix:** Extract objectives from the disclosure manifest and use them as goals:
+
+```javascript
+// Extract goals from disclosure objectives
+const disclosureObjectives = (result.manifest?.objectives || [])
+  .map(o => typeof o === 'string' ? o : (o && o.objective || ''))
+  .map(s => s.trim().toLowerCase().replace(/\s+/g, '-').slice(0, 60))
+  .filter(Boolean);
+
+const tokenGoals = disclosureObjectives.length > 0
+  ? disclosureObjectives.slice(0, 5)
+  : ['grow-network', 'find-collaborators', 'build-in-public'];
+```
+
+Then use `tokenGoals` in the store.create call:
+```javascript
+allowedGoals: tokenGoals,
+```
+
+Also sync goals to tier config:
+```javascript
+config.setTier('public', {
+  topics: getTierTopics(tiersData.public),
+  goals: tokenGoals,
+  disclosure: 'minimal'
+});
+```
+
+### Fix 5: Update extraction prompt to request identity fields
+
+**File:** `src/lib/disclosure.js` — the `buildExtractionPrompt` function
+
+**Problem:** The extraction prompt tells the agent what to scan but doesn't ask for `owner_name` or `agent_name` fields in the JSON output.
+
+**Fix:** Add `owner_name` and `agent_name` to the required JSON schema in the prompt. Look for the JSON structure section and add:
+
+```
+"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)",
+```
+
+---
+
+## Bug A2A-24: Surface network warnings during quickstart
+
+### Fix 6: Add connectivity check after server start
+
+**File:** `bin/cli.js` — quickstart command, after server start (~line 2017-2019)
+
+**Problem:** The verify URL is printed but never executed. No connectivity feedback.
+
+**Fix:** After the server starts and the verify URL is printed, actually run the connectivity check:
+
+```javascript
+// After line: console.log(`\n  Verify: curl -s ${verifyUrl}`);
+// Add actual verification:
+const http = require('http');
+const verifyOk = await new Promise(resolve => {
+  const req = http.request({
+    hostname: '127.0.0.1',
+    port: serverPort,
+    path: '/api/a2a/ping',
+    method: 'GET',
+    timeout: 2000
+  }, (res) => {
+    res.resume();
+    resolve(res.statusCode === 200);
+  });
+  req.on('error', () => resolve(false));
+  req.on('timeout', () => { req.destroy(); resolve(false); });
+  req.end();
+});
+
+if (verifyOk) {
+  console.log('  ✅ Local connectivity verified');
+} else {
+  console.log('  ⚠️  Local server check failed — server may still be starting');
+}
+```
+
+### Fix 7: Surface invite-host warnings during quickstart
+
+**File:** `bin/cli.js` — quickstart command, after server start
+
+**Problem:** `resolveInviteHost()` returns warnings about NAT/firewall, but they're only shown during `a2a create`, not during quickstart.
+
+**Fix:** After `publicHost` is set in quickstart, call `resolveInviteHost` and print its warnings:
+
+```javascript
+// After publicHost is determined, resolve and show warnings
+try {
+  const { resolveInviteHost } = require('../src/lib/invite-host');
+  const resolved = await resolveInviteHost({
+    hostname: publicHost,
+    port: serverPort
+  });
+  if (resolved.warnings && resolved.warnings.length) {
+    console.log('\n  ━━━ Network Warnings ━━━');
+    for (const w of resolved.warnings) {
+      console.warn(`  ⚠️  ${w}`);
+    }
+  }
+} catch (_) {}
+```
+
+### Fix 8: Add non-standard port warning with reverse proxy guidance
+
+**File:** `bin/cli.js` — quickstart, already partially handled
+
+**Assessment:** Looking at the code at lines 2008-2014, this is already partially implemented — when the user chooses 'continue' on a non-standard port, it prints a brief reminder about reverse proxy setup. But it could be more prominent.
+
+**Fix:** Enhance the existing warning. After the "Running on port X (non-standard)" message, add:
+
+```javascript
+console.log('');
+console.log('  ⚠️  Remote agents using your invite URL will try port 80 by default.');
+console.log('  Without a reverse proxy, inbound calls on port 80 will fail silently.');
+```
+
+---
+
+## Commit Strategy
+
+1. First commit: A2A-22 fixes (disclosure levels, identity extraction, goals sync)
+2. Second commit: A2A-24 fixes (connectivity check, network warnings)
+3. Run `npm test` after each commit to verify no regressions
+
+## Testing
+
+After all fixes:
+- `npm test` — all 269+ tests must pass
+- Manual verification of the logic changes (the reviewer should trace through the code paths)

package/native/macos/index.html

@@ -0,0 +1,172 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>A2A Callbook</title>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'IBM Plex Sans', sans-serif;
+      background: linear-gradient(180deg, #eef3f8 0%, #f8f9fb 100%);
+      color: #1a1a2e;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      min-height: 100vh;
+    }
+    .status-card {
+      background: #fff;
+      border: 1px solid #d0d7de;
+      border-radius: 12px;
+      padding: 48px;
+      text-align: center;
+      max-width: 420px;
+      box-shadow: 0 2px 8px rgba(0,0,0,0.06);
+    }
+    h1 { font-size: 20px; font-weight: 600; margin-bottom: 8px; }
+    .subtitle { color: #666; font-size: 14px; margin-bottom: 24px; }
+    .status-indicator {
+      display: inline-block;
+      width: 10px; height: 10px;
+      border-radius: 50%;
+      margin-right: 8px;
+      vertical-align: middle;
+    }
+    .status-indicator.searching { background: #f59e0b; animation: pulse 1.5s infinite; }
+    .status-indicator.disconnected { background: #ef4444; }
+    .status-indicator.connected { background: #22c55e; }
+    @keyframes pulse { 0%,100% { opacity: 1; } 50% { opacity: 0.4; } }
+    .status-text { font-size: 14px; margin-bottom: 24px; color: #444; }
+    .port-info { font-size: 12px; color: #888; margin-bottom: 16px; font-family: monospace; }
+    button {
+      background: #1466c1; color: #fff; border: none; border-radius: 8px;
+      padding: 10px 24px; font-size: 14px; cursor: pointer; margin: 4px;
+      font-family: inherit;
+    }
+    button:hover { background: #1052a0; }
+    button.secondary {
+      background: transparent; color: #1466c1; border: 1px solid #1466c1;
+    }
+    button.secondary:hover { background: #eef3f8; }
+    #error-detail { color: #ef4444; font-size: 12px; margin-top: 12px; display: none; }
+  </style>
+</head>
+<body>
+  <div class="status-card">
+    <h1>A2A Callbook</h1>
+    <p class="subtitle">Agent-to-agent communication dashboard</p>
+
+    <div id="status-searching">
+      <p class="status-text">
+        <span class="status-indicator searching"></span>
+        Looking for a2a server...
+      </p>
+      <p class="port-info" id="port-info">Scanning ports: 3001, 80, 8080, 8443, 9001</p>
+    </div>
+
+    <div id="status-not-found" style="display:none;">
+      <p class="status-text">
+        <span class="status-indicator disconnected"></span>
+        Server not running
+      </p>
+      <p class="port-info" id="last-port">No a2a server found on common ports</p>
+      <button id="btn-start">Start Server</button>
+      <button id="btn-retry" class="secondary">Retry</button>
+      <p id="error-detail"></p>
+    </div>
+
+    <div id="status-connected" style="display:none;">
+      <p class="status-text">
+        <span class="status-indicator connected"></span>
+        Connected to server
+      </p>
+      <p class="port-info" id="connected-port"></p>
+    </div>
+  </div>
+
+  <script>
+    const { invoke } = window.__TAURI__.core;
+
+    async function checkServer() {
+      show('status-searching');
+      try {
+        const result = await invoke('discover_server');
+        if (result.port) {
+          show('status-connected');
+          document.getElementById('connected-port').textContent =
+            `localhost:${result.port}`;
+          // Navigate to live SPA
+          setTimeout(() => {
+            window.location.href =
+              `http://127.0.0.1:${result.port}/api/a2a/dashboard/` +
+              (window.__TAB_HASH || '');
+          }, 400);
+        } else {
+          show('status-not-found');
+        }
+      } catch (err) {
+        show('status-not-found');
+        const detail = document.getElementById('error-detail');
+        detail.textContent = err;
+        detail.style.display = 'block';
+      }
+    }
+
+    function show(id) {
+      ['status-searching', 'status-not-found', 'status-connected']
+        .forEach(s => document.getElementById(s).style.display = 'none');
+      document.getElementById(id).style.display = 'block';
+    }
+
+    document.getElementById('btn-start')?.addEventListener('click', async () => {
+      try {
+        await invoke('start_server');
+        // Wait for server to boot, then retry
+        setTimeout(checkServer, 2000);
+      } catch (err) {
+        const detail = document.getElementById('error-detail');
+        detail.textContent = `Failed to start: ${err}`;
+        detail.style.display = 'block';
+      }
+    });
+
+    document.getElementById('btn-retry')?.addEventListener('click', checkServer);
+
+    // Start discovery on load
+    checkServer();
+
+    // Listen for server disconnect/reconnect from Tauri backend
+    const { listen } = window.__TAURI__.event;
+
+    listen('server-status', (event) => {
+      const { connected, port } = event.payload;
+      if (!connected) {
+        showReconnectionOverlay();
+      } else {
+        hideReconnectionOverlay();
+      }
+    });
+
+    function showReconnectionOverlay() {
+      if (document.getElementById('reconnect-overlay')) return;
+      const overlay = document.createElement('div');
+      overlay.id = 'reconnect-overlay';
+      overlay.innerHTML = `
+        <div style="position:fixed;top:0;left:0;right:0;z-index:9999;
+          background:#fef3c7;border-bottom:2px solid #f59e0b;padding:12px 24px;
+          text-align:center;font-family:-apple-system,sans-serif;font-size:14px;color:#92400e;">
+          <span style="display:inline-block;width:8px;height:8px;border-radius:50%;
+            background:#f59e0b;margin-right:8px;animation:pulse 1.5s infinite;vertical-align:middle;"></span>
+          Server disconnected — Reconnecting...
+        </div>`;
+      document.body.appendChild(overlay);
+    }
+
+    function hideReconnectionOverlay() {
+      const overlay = document.getElementById('reconnect-overlay');
+      if (overlay) overlay.remove();
+    }
+  </script>
+</body>
+</html>

package/native/macos/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "a2a-callbook-macos",
+  "version": "0.1.0",
+  "private": true,
+  "scripts": {
+    "tauri": "cargo tauri"
+  }
+}

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

@@ -0,0 +1,23 @@
+[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 = [] }
+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"] }
+tokio = { version = "1", features = ["full"] }
+dirs = "6"

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

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

package/native/macos/src-tauri/capabilities/default.json

@@ -0,0 +1,16 @@
+{
+  "$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"
+  ]
+}

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

@@ -0,0 +1,86 @@
+use serde::{Deserialize, Serialize};
+use std::path::PathBuf;
+use std::time::Duration;
+
+const DEFAULT_PORTS: &[u16] = &[3001, 80, 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"
+}
+
+#[derive(Debug, Deserialize)]
+struct A2AConfig {
+    onboarding: Option<OnboardingConfig>,
+}
+
+#[derive(Debug, Deserialize)]
+struct OnboardingConfig {
+    server_port: Option<u16>,
+}
+
+/// Read port from ~/.config/openclaw/a2a-config.json
+pub fn read_config_port() -> Option<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 = std::fs::read_to_string(config_path).ok()?;
+    let config: A2AConfig = serde_json::from_str(&content).ok()?;
+    config.onboarding?.server_port
+}
+
+/// Probe a single port — returns true if a2a server responds
+async fn probe_port(port: u16) -> bool {
+    let url = format!("http://127.0.0.1:{}/api/a2a/ping", port);
+    let client = reqwest::Client::builder()
+        .timeout(PROBE_TIMEOUT)
+        .build();
+
+    let client = match client {
+        Ok(c) => c,
+        Err(_) => return false,
+    };
+
+    match client.get(&url).send().await {
+        Ok(resp) => resp.status().is_success(),
+        Err(_) => false,
+    }
+}
+
+/// Discover the running a2a server
+pub async fn discover_server() -> DiscoveryResult {
+    // 1. Try config port first
+    if let Some(port) = read_config_port() {
+        if probe_port(port).await {
+            return DiscoveryResult {
+                port: Some(port),
+                source: "config".to_string(),
+            };
+        }
+    }
+
+    // 2. Scan default ports
+    for &port in DEFAULT_PORTS {
+        if probe_port(port).await {
+            return DiscoveryResult {
+                port: Some(port),
+                source: "scan".to_string(),
+            };
+        }
+    }
+
+    DiscoveryResult {
+        port: None,
+        source: "none".to_string(),
+    }
+}

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

@@ -0,0 +1,64 @@
+use std::sync::atomic::{AtomicBool, AtomicU16, Ordering};
+use std::sync::Arc;
+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);
+}
+
+/// Start background health check loop — emits "server-status" events
+pub fn start_health_monitor(app: tauri::AppHandle) {
+    let handle = Arc::new(app);
+    tokio::spawn(async move {
+        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());
+                    }
+                }
+            }
+        }
+    });
+}