a2acalling 0.6.43 → 0.6.45

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.43",
+  "version": "0.6.45",
   "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/claude-subagent.js

@@ -0,0 +1,485 @@
+/**
+ * Claude Subagent — Lifecycle management for Claude CLI subagent sessions.
+ *
+ * Spawns `claude` CLI processes for real LLM-powered A2A conversations
+ * as an alternative to OpenClaw for A2A conversations.
+ *
+ * Uses `claude -p` (print mode) with `--resume` for multi-turn context continuity.
+ */
+
+const { execSync, spawn } = require('child_process');
+const { createLogger } = require('./logger');
+
+const logger = createLogger({ component: 'a2a.claude-subagent' });
+
+const A2A_RESPONSE_REGEX = /<a2a_response>\s*([\s\S]*?)\s*<\/a2a_response>/i;
+
+/**
+ * Check if `claude` CLI is available in PATH.
+ */
+function isClaudeAvailable() {
+  try {
+    execSync('command -v claude', { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Build the system prompt for the Claude subagent.
+ *
+ * @param {Object} config
+ * @param {string} config.agentName
+ * @param {string} config.ownerName
+ * @param {string} config.otherAgentName
+ * @param {string} config.otherOwnerName
+ * @param {string} config.accessTier
+ * @param {string} config.tierTopics - formatted topics string
+ * @param {string} config.tierObjectives - formatted objectives string
+ * @param {string} config.doNotDiscuss - formatted do_not_discuss string
+ * @param {string} config.neverDisclose - formatted never_disclose string
+ * @param {string} config.personalityNotes
+ * @param {string} config.roleContext
+ * @returns {string}
+ */
+function buildSubagentSystemPrompt(config) {
+  const {
+    agentName = 'Agent',
+    ownerName = 'the owner',
+    otherAgentName = 'Remote Agent',
+    otherOwnerName = 'their owner',
+    accessTier = 'public',
+    tierTopics = '  (none specified)',
+    tierObjectives = '  (none specified)',
+    doNotDiscuss = '  (none specified)',
+    neverDisclose = '  (none specified)',
+    personalityNotes = '',
+    roleContext = ''
+  } = config;
+
+  return `You are ${agentName}, the personal AI agent for ${ownerName}.
+You are on a live A2A (agent-to-agent) call with ${otherAgentName}, who represents ${otherOwnerName}. ${roleContext}
+
+== OUTPUT FORMAT ==
+
+After your conversational reply, you MUST append exactly one structured response block:
+
+<a2a_response>
+{"message":"Your conversational reply here","statePatch":{"phase":"explore","overlapScore":0.3,"activeThreads":["thread1"],"candidateCollaborations":["idea1"],"closeSignal":false,"confidence":0.4},"flags":[]}
+</a2a_response>
+
+Rules for the response block:
+- "message" (required): Your full conversational reply text. This is what the other agent sees.
+- "statePatch" (optional): Collaboration state update with any of: phase, overlapScore (0-1), activeThreads (max 4), candidateCollaborations (max 4), closeSignal (boolean), confidence (0-1).
+- "flags" (optional): Array of flag objects like {"type":"question_for_owner","content":"..."} or {"type":"opportunity_flagged","content":"..."}.
+- Must be valid JSON (double quotes only).
+- The message in the JSON block should match your visible conversational text.
+
+Flag types:
+- "question_for_owner": Something you want to ask ${ownerName} about before committing
+- "opportunity_flagged": A concrete collaboration opportunity worth the owner's attention
+- "boundary_touched": The other agent probed near a do_not_discuss or never_disclose topic
+- "unverifiable_claim": The other agent made a claim you cannot verify
+
+== DISCLOSURE CONTEXT ==
+
+Access level: ${accessTier}
+
+${ownerName}'s topics of interest:
+${tierTopics}
+
+Objectives:
+${tierObjectives}
+
+DO NOT DISCUSS (redirect naturally):
+${doNotDiscuss}
+
+NEVER disclose:
+${neverDisclose}
+
+== BEHAVIORAL MANDATE ==
+
+You operate in three concurrent modes:
+
+1. EXPLORING: Map the other agent's owner — capabilities, resources, blind spots, ambitions.
+   Ask probing questions. Don't accept surface-level answers. Dig into specifics.
+
+2. ADVERSARIALLY QUALIFYING: Pressure-test claims. Push back respectfully.
+   "You say X, but that sounds like Y. What's actually different?"
+   "That's a crowded space. What makes their angle defensible?"
+   The best collaborations come from people who can handle scrutiny.
+
+3. COLLABORATING: Look for concrete overlap and actionable next steps.
+   Complementary capabilities, shared challenges, non-obvious intersections.
+   Propose specific ideas, not vague "let's stay in touch."
+
+== PHASE AWARENESS ==
+
+Each turn you receive state including turn number, maxTurns, and current phase.
+Adapt your behavior to the phase:
+
+- handshake (turns 1-2): Establish context, introduce key topics, set one meaningful direction.
+- exploring (turns 2-6): Map goals, capabilities, constraints. Stay here while new info surfaces.
+- deepening (turns 5-10): Work through specific collaboration threads in detail.
+- converging (turns 8+): Convert insights into concrete next steps. Set closeSignal when done.
+
+These are guidelines, not hard locks. Stay in any phase as long as it's productive.
+
+== PERSONALITY ==
+
+${personalityNotes || "Direct, curious, slightly irreverent. You have opinions and share them. You're not a concierge — you're a sparring partner who represents someone."}
+
+When unsure about your owner's position, say so: "I don't have ${ownerName}'s take on that — but here's what I think based on their work..."`;
+}
+
+/**
+ * Build the turn prompt containing state and the inbound message.
+ */
+function buildTurnPrompt(options) {
+  const {
+    turnMessage,
+    turn,
+    maxTurns,
+    phase = 'handshake',
+    overlapScore = 0.15,
+    activeThreads = [],
+    candidateCollaborations = [],
+    closeSignal = false
+  } = options;
+
+  return `== TURN STATE ==
+Turn: ${turn}/${maxTurns}
+Phase: ${phase}
+Overlap score: ${overlapScore}
+Active threads: ${activeThreads.length > 0 ? activeThreads.join(', ') : '(none)'}
+Candidate collaborations: ${candidateCollaborations.length > 0 ? candidateCollaborations.join(', ') : '(none)'}
+Close signal: ${closeSignal}
+
+== INBOUND MESSAGE ==
+
+${turnMessage}
+
+Respond naturally, then append your <a2a_response> block.`;
+}
+
+/**
+ * Parse the structured response from Claude's output.
+ *
+ * @param {string} resultText - Raw text output from claude CLI
+ * @returns {{ message: string, statePatch: object|null, flags: array }}
+ */
+function parseSubagentResponse(resultText) {
+  if (!resultText || typeof resultText !== 'string') {
+    return { message: '', statePatch: null, flags: [] };
+  }
+
+  const match = resultText.match(A2A_RESPONSE_REGEX);
+  if (!match) {
+    // Graceful degradation: treat entire result as the message
+    return { message: resultText.trim(), statePatch: null, flags: [] };
+  }
+
+  const jsonStr = (match[1] || '').trim();
+  if (!jsonStr) {
+    const cleanText = resultText.replace(A2A_RESPONSE_REGEX, '').trim();
+    return { message: cleanText || '', statePatch: null, flags: [] };
+  }
+
+  try {
+    const parsed = JSON.parse(jsonStr);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+      throw new Error('a2a_response must be a JSON object');
+    }
+
+    return {
+      message: typeof parsed.message === 'string' ? parsed.message : resultText.replace(A2A_RESPONSE_REGEX, '').trim(),
+      statePatch: parsed.statePatch && typeof parsed.statePatch === 'object' ? parsed.statePatch : null,
+      flags: Array.isArray(parsed.flags) ? parsed.flags : []
+    };
+  } catch (err) {
+    logger.warn('Failed to parse <a2a_response> JSON', {
+      event: 'subagent_response_parse_failed',
+      error: err,
+      data: { json_length: jsonStr.length }
+    });
+    // Fall back to using text outside the tags
+    const cleanText = resultText.replace(A2A_RESPONSE_REGEX, '').trim();
+    return { message: cleanText || resultText.trim(), statePatch: null, flags: [] };
+  }
+}
+
+/**
+ * Spawn `claude` CLI and collect output as a promise.
+ *
+ * @param {string[]} args - CLI arguments
+ * @param {number} timeoutMs - Timeout in milliseconds
+ * @returns {Promise<{ stdout: string, stderr: string }>}
+ */
+function spawnClaude(args, timeoutMs = 180000) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn('claude', args, {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: {
+        ...process.env,
+        FORCE_COLOR: '0',
+        CLAUDECODE: ''  // Unset to allow nested invocation
+      }
+    });
+
+    let stdout = '';
+    let stderr = '';
+    let killed = false;
+
+    const timer = setTimeout(() => {
+      killed = true;
+      proc.kill('SIGTERM');
+      // Give it 5s to clean up, then force kill
+      setTimeout(() => {
+        try { proc.kill('SIGKILL'); } catch (e) { /* already dead */ }
+      }, 5000);
+    }, timeoutMs);
+
+    proc.stdout.on('data', (data) => { stdout += data.toString(); });
+    proc.stderr.on('data', (data) => { stderr += data.toString(); });
+
+    proc.on('close', (code) => {
+      clearTimeout(timer);
+      if (killed) {
+        reject(new Error(`Claude CLI timed out after ${timeoutMs}ms`));
+        return;
+      }
+      if (code !== 0 && !stdout.trim()) {
+        reject(new Error(`Claude CLI exited with code ${code}: ${stderr.slice(0, 500)}`));
+        return;
+      }
+      resolve({ stdout, stderr });
+    });
+
+    proc.on('error', (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+  });
+}
+
+/**
+ * Extract the result text from Claude's JSON output.
+ * Claude with --output-format json returns { type, subtype, cost_usd, duration_ms, duration_api_ms,
+ * is_error, num_turns, result, session_id, ... }
+ */
+function extractResultFromJson(stdout) {
+  const trimmed = stdout.trim();
+  if (!trimmed) return { result: '', sessionId: null };
+
+  try {
+    const parsed = JSON.parse(trimmed);
+    return {
+      result: typeof parsed.result === 'string' ? parsed.result : '',
+      sessionId: parsed.session_id || null
+    };
+  } catch (err) {
+    // If JSON parsing fails, treat entire output as result text
+    logger.debug('Claude output not valid JSON, using raw text', {
+      event: 'subagent_json_parse_fallback',
+      data: { output_length: trimmed.length }
+    });
+    return { result: trimmed, sessionId: null };
+  }
+}
+
+/**
+ * Run a single turn of the Claude subagent.
+ *
+ * @param {Object} options
+ * @param {string} options.sessionId - Conversation session ID (used for --resume on turn 2+)
+ * @param {string} options.systemPrompt - System prompt (used on turn 1 only)
+ * @param {string} options.turnMessage - The inbound message from the remote agent
+ * @param {number} options.turn - Current turn number (1-based)
+ * @param {number} options.maxTurns - Maximum turns allowed
+ * @param {string} options.phase - Current conversation phase
+ * @param {number} options.overlapScore - Current overlap score
+ * @param {Array} options.activeThreads - Active conversation threads
+ * @param {Array} options.candidateCollaborations - Candidate collaboration ideas
+ * @param {boolean} options.closeSignal - Whether close has been signaled
+ * @param {number} [options.timeoutMs=180000] - Timeout in milliseconds
+ * @returns {Promise<{ message: string, statePatch: object|null, flags: array, sessionId: string }>}
+ */
+async function runClaudeTurn(options) {
+  const {
+    sessionId,
+    systemPrompt,
+    turnMessage,
+    turn = 1,
+    maxTurns = 30,
+    phase = 'handshake',
+    overlapScore = 0.15,
+    activeThreads = [],
+    candidateCollaborations = [],
+    closeSignal = false,
+    timeoutMs = 180000
+  } = options;
+
+  const turnPrompt = buildTurnPrompt({
+    turnMessage,
+    turn,
+    maxTurns,
+    phase,
+    overlapScore,
+    activeThreads,
+    candidateCollaborations,
+    closeSignal
+  });
+
+  const startAt = Date.now();
+  const allowedTools = 'Bash(readonly) Read Grep Glob WebSearch WebFetch';
+
+  let args;
+  if (turn === 1 || !sessionId) {
+    // First turn: create new session
+    args = [
+      '-p',
+      '--output-format', 'json',
+      '--system-prompt', systemPrompt,
+      '--allowedTools', allowedTools,
+      '--model', 'claude-sonnet-4-5-20250929',
+      turnPrompt
+    ];
+  } else {
+    // Subsequent turns: resume existing session
+    args = [
+      '-p',
+      '--output-format', 'json',
+      '--resume', sessionId,
+      '--allowedTools', allowedTools,
+      turnPrompt
+    ];
+  }
+
+  logger.debug('Spawning Claude subagent turn', {
+    event: 'subagent_turn_start',
+    data: {
+      turn,
+      max_turns: maxTurns,
+      phase,
+      is_resume: turn > 1 && Boolean(sessionId),
+      timeout_ms: timeoutMs
+    }
+  });
+
+  const { stdout } = await spawnClaude(args, timeoutMs);
+  const { result, sessionId: newSessionId } = extractResultFromJson(stdout);
+  const parsed = parseSubagentResponse(result);
+
+  logger.debug('Claude subagent turn completed', {
+    event: 'subagent_turn_complete',
+    data: {
+      turn,
+      duration_ms: Date.now() - startAt,
+      message_length: parsed.message.length,
+      has_state_patch: Boolean(parsed.statePatch),
+      flag_count: parsed.flags.length,
+      session_id: newSessionId || sessionId
+    }
+  });
+
+  return {
+    message: parsed.message,
+    statePatch: parsed.statePatch,
+    flags: parsed.flags,
+    sessionId: newSessionId || sessionId
+  };
+}
+
+/**
+ * Run a summary turn using the Claude subagent session.
+ *
+ * @param {string} sessionId - Session ID to resume
+ * @param {string} reason - Why the conversation is ending
+ * @param {number} [timeoutMs=120000] - Timeout in milliseconds
+ * @returns {Promise<{ summary: string, ownerSummary: string, actionItems: array, flags: array }>}
+ */
+async function runClaudeSummary(sessionId, reason, timeoutMs = 120000) {
+  if (!sessionId) {
+    throw new Error('Cannot summarize without a session ID');
+  }
+
+  const summaryPrompt = `The conversation is ending. Reason: ${reason || 'max turns reached'}.
+
+Provide a structured summary. Respond with ONLY a JSON block:
+
+<a2a_response>
+{
+  "message": "Brief 1-2 sentence summary of the conversation.",
+  "statePatch": {"phase": "close", "closeSignal": true},
+  "flags": [],
+  "summary": "Detailed summary for the conversation record.",
+  "ownerSummary": "Summary written for the owner highlighting key findings and opportunities.",
+  "actionItems": ["Specific follow-up item 1", "Specific follow-up item 2"]
+}
+</a2a_response>`;
+
+  const args = [
+    '-p',
+    '--output-format', 'json',
+    '--resume', sessionId,
+    summaryPrompt
+  ];
+
+  const startAt = Date.now();
+
+  logger.debug('Spawning Claude summary', {
+    event: 'subagent_summary_start',
+    data: { session_id: sessionId, reason }
+  });
+
+  const { stdout } = await spawnClaude(args, timeoutMs);
+  const { result } = extractResultFromJson(stdout);
+
+  // Try to extract structured summary from <a2a_response>
+  const match = result.match(A2A_RESPONSE_REGEX);
+  if (match) {
+    try {
+      const parsed = JSON.parse(match[1].trim());
+      logger.debug('Claude summary completed', {
+        event: 'subagent_summary_complete',
+        data: {
+          session_id: sessionId,
+          duration_ms: Date.now() - startAt,
+          has_summary: Boolean(parsed.summary),
+          action_item_count: Array.isArray(parsed.actionItems) ? parsed.actionItems.length : 0
+        }
+      });
+
+      return {
+        summary: parsed.summary || parsed.message || result.replace(A2A_RESPONSE_REGEX, '').trim(),
+        ownerSummary: parsed.ownerSummary || parsed.summary || parsed.message || '',
+        actionItems: Array.isArray(parsed.actionItems) ? parsed.actionItems : [],
+        flags: Array.isArray(parsed.flags) ? parsed.flags : []
+      };
+    } catch (err) {
+      logger.warn('Failed to parse summary JSON', {
+        event: 'subagent_summary_parse_failed',
+        error: err
+      });
+    }
+  }
+
+  // Fallback: use raw text as summary
+  const summaryText = result.replace(A2A_RESPONSE_REGEX, '').trim() || result.trim();
+  return {
+    summary: summaryText,
+    ownerSummary: summaryText,
+    actionItems: [],
+    flags: []
+  };
+}
+
+module.exports = {
+  isClaudeAvailable,
+  buildSubagentSystemPrompt,
+  buildTurnPrompt,
+  runClaudeTurn,
+  runClaudeSummary,
+  parseSubagentResponse
+};