a2acalling 0.6.75 → 0.6.76

package/.claude/worktrees/agent-acefedbd/.claude/worktrees/agent-a1418bc4/src/lib/openclaw-integration.js

@@ -0,0 +1,339 @@
+/**
+ * OpenClaw Integration for A2A
+ * 
+ * Provides owner-context summarization using OpenClaw's agent system.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { createLogger } = require('./logger');
+const { buildUnifiedSummaryPrompt } = require('./summary-prompt');
+
+const logger = createLogger({ component: 'a2a.openclaw-integration' });
+
+/**
+ * Load owner context from OpenClaw workspace files
+ * @param {string} workspaceDir - Path to workspace
+ * @param {Object} options
+ * @param {string[]} options.tierGoals - Goals from config tier (takes priority over USER.md)
+ */
+function loadOwnerContext(workspaceDir = process.cwd(), options = {}) {
+  const context = {
+    goals: [],
+    interests: [],
+    context: '',
+    user: null,
+    memory: null
+  };
+
+  // Tier goals from config take priority
+  if (options.tierGoals && options.tierGoals.length > 0) {
+    context.goals = [...options.tierGoals];
+  }
+
+  // Load USER.md
+  const userPath = path.join(workspaceDir, 'USER.md');
+  if (fs.existsSync(userPath)) {
+    context.user = fs.readFileSync(userPath, 'utf8');
+    // Extract goals from USER.md (fallback if no tier goals from config)
+    if (context.goals.length === 0) {
+      const goalsMatch = context.user.match(/##\s*(?:Goals|Current|Seeking)[^\n]*\n([\s\S]*?)(?=\n##|$)/i);
+      if (goalsMatch) {
+        context.goals = goalsMatch[1]
+          .split('\n')
+          .filter(l => l.trim().startsWith('-') || l.trim().startsWith('*'))
+          .map(l => l.replace(/^[\s\-\*]+/, '').trim())
+          .filter(Boolean);
+      }
+    }
+    // Extract interests
+    const interestsMatch = context.user.match(/##\s*(?:Interests|Projects)[^\n]*\n([\s\S]*?)(?=\n##|$)/i);
+    if (interestsMatch) {
+      context.interests = interestsMatch[1]
+        .split('\n')
+        .filter(l => l.trim().startsWith('-') || l.trim().startsWith('*'))
+        .map(l => l.replace(/^[\s\-\*]+/, '').trim())
+        .filter(Boolean);
+    }
+  }
+
+  // Load recent memory
+  const memoryDir = path.join(workspaceDir, 'memory');
+  if (fs.existsSync(memoryDir)) {
+    const files = fs.readdirSync(memoryDir)
+      .filter(f => f.endsWith('.md'))
+      .sort()
+      .reverse()
+      .slice(0, 3); // Last 3 memory files
+    
+    context.memory = files.map(f => {
+      const content = fs.readFileSync(path.join(memoryDir, f), 'utf8');
+      return `## ${f}\n${content}`;
+    }).join('\n\n');
+  }
+
+  // Load MEMORY.md if exists
+  const mainMemoryPath = path.join(workspaceDir, 'MEMORY.md');
+  if (fs.existsSync(mainMemoryPath)) {
+    const mainMemory = fs.readFileSync(mainMemoryPath, 'utf8');
+    context.memory = mainMemory + '\n\n' + (context.memory || '');
+  }
+
+  return context;
+}
+
+/**
+ * Build summary prompt for agent
+ * 
+ * Philosophy: A2A is collaborative AND adversarial. Each agent tries
+ * to maximize value for their owner while finding genuine mutual wins.
+ * Track the exchange balance AND surface partnership opportunities.
+ */
+function buildSummaryPrompt(messages, ownerContext, callerInfo = {}) {
+  // Build transcript in unified format
+  const transcript = messages.map(m => ({
+    direction: m.direction,
+    content: m.content
+  }));
+
+  // Map ownerContext (which has .user, .goals, .interests from USER.md) into unified format
+  const unifiedOwnerContext = {
+    agentName: null,
+    ownerName: null,
+    goals: ownerContext?.goals || []
+  };
+
+  return buildUnifiedSummaryPrompt({
+    transcript,
+    callerInfo: {
+      name: callerInfo.name || null,
+      owner: callerInfo.owner || null,
+      context: callerInfo.context || null
+    },
+    ownerContext: unifiedOwnerContext
+  });
+}
+
+/**
+ * Create an OpenClaw summarizer that uses exec to call the agent
+ * This works by writing a prompt file and using openclaw's CLI
+ */
+function createExecSummarizer(workspaceDir = process.cwd()) {
+  const { execSync } = require('child_process');
+  
+  return async function(messages, callerInfo = {}) {
+    const ownerContext = loadOwnerContext(workspaceDir);
+    const prompt = buildSummaryPrompt(messages, ownerContext, callerInfo);
+    
+    // Write prompt to temp file
+    const tmpFile = `/tmp/a2a-summary-${Date.now()}.txt`;
+    fs.writeFileSync(tmpFile, prompt);
+    
+    try {
+      // Call openclaw CLI to get agent response
+      // This assumes openclaw has a way to do single-shot prompts
+      const result = execSync(
+        `cat "${tmpFile}" | openclaw prompt --json 2>/dev/null || echo '{}'`,
+        { encoding: 'utf8', timeout: 30000 }
+      );
+      
+      // Parse JSON from response
+      const jsonMatch = result.match(/\{[\s\S]*\}/);
+      if (jsonMatch) {
+        return JSON.parse(jsonMatch[0]);
+      }
+      
+      return {
+        summary: result.slice(0, 500),
+        ownerSummary: null,
+        relevance: 'unknown',
+        goalsTouched: [],
+        actionItems: [],
+        followUp: null,
+        notes: null
+      };
+    } catch (err) {
+      logger.error('Exec summarizer failed', {
+        event: 'exec_summary_failed',
+        trace_id: callerInfo?.trace_id || callerInfo?.traceId || null,
+        error: err,
+        error_code: 'OPENCLAW_EXEC_SUMMARIZER_FAILED',
+        hint: 'Verify `openclaw prompt --json` is available and returns valid JSON.',
+        data: {
+          workspace_dir: workspaceDir
+        }
+      });
+      return { summary: null };
+    } finally {
+      // Cleanup
+      try { fs.unlinkSync(tmpFile); } catch (e) {}
+    }
+  };
+}
+
+/**
+ * Create a summarizer that posts to a local HTTP endpoint
+ * OpenClaw can expose an internal summarization endpoint
+ */
+function createHttpSummarizer(endpoint = 'http://localhost:3000/api/summarize') {
+  const http = require('http');
+  const https = require('https');
+  
+  return async function(messages, callerInfo = {}) {
+    const ownerContext = loadOwnerContext();
+    const prompt = buildSummaryPrompt(messages, ownerContext, callerInfo);
+    
+    return new Promise((resolve) => {
+      const url = new URL(endpoint);
+      const client = url.protocol === 'https:' ? https : http;
+      
+      const req = client.request({
+        hostname: url.hostname,
+        port: url.port,
+        path: url.pathname,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        timeout: 30000
+      }, (res) => {
+        let data = '';
+        res.on('data', chunk => data += chunk);
+        res.on('end', () => {
+          try {
+            resolve(JSON.parse(data));
+          } catch (e) {
+            resolve({ summary: data.slice(0, 500) });
+          }
+        });
+      });
+      
+      req.on('error', (err) => {
+        logger.error('HTTP summarizer failed', {
+          event: 'http_summary_failed',
+          trace_id: callerInfo?.trace_id || callerInfo?.traceId || null,
+          error: err,
+          error_code: 'OPENCLAW_HTTP_SUMMARIZER_FAILED',
+          hint: 'Check summarizer endpoint reachability and response format.',
+          data: {
+            endpoint
+          }
+        });
+        resolve({ summary: null });
+      });
+      
+      req.write(JSON.stringify({ prompt, messages, callerInfo }));
+      req.end();
+    });
+  };
+}
+
+/**
+ * Create a summarizer using sessions_send to the main OpenClaw session
+ * This is the preferred method when running inside OpenClaw
+ */
+function createSessionSummarizer(gatewayUrl, gatewayToken) {
+  const http = require('http');
+  const https = require('https');
+  
+  return async function(messages, callerInfo = {}) {
+    const ownerContext = loadOwnerContext();
+    const prompt = buildSummaryPrompt(messages, ownerContext, callerInfo);
+    
+    // Send to OpenClaw gateway's internal API
+    return new Promise((resolve) => {
+      const url = new URL(gatewayUrl || 'http://localhost:3000');
+      const client = url.protocol === 'https:' ? https : http;
+      
+      const req = client.request({
+        hostname: url.hostname,
+        port: url.port,
+        path: '/api/internal/summarize',
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${gatewayToken || process.env.OPENCLAW_TOKEN}`
+        },
+        timeout: 60000
+      }, (res) => {
+        let data = '';
+        res.on('data', chunk => data += chunk);
+        res.on('end', () => {
+          try {
+            const result = JSON.parse(data);
+            resolve(result.summary || result);
+          } catch (e) {
+            resolve({ summary: data.slice(0, 500) });
+          }
+        });
+      });
+      
+      req.on('error', (err) => {
+        logger.error('Session summarizer failed', {
+          event: 'session_summary_failed',
+          trace_id: callerInfo?.trace_id || callerInfo?.traceId || null,
+          error: err,
+          error_code: 'OPENCLAW_SESSION_SUMMARIZER_FAILED',
+          hint: 'Verify OpenClaw gateway URL/token and /api/internal/summarize availability.',
+          data: {
+            gateway_url: gatewayUrl || 'http://localhost:3000'
+          }
+        });
+        resolve({ summary: null });
+      });
+      
+      req.write(JSON.stringify({ prompt }));
+      req.end();
+    });
+  };
+}
+
+/**
+ * Auto-detect best summarizer based on environment
+ */
+function createAutoSummarizer(options = {}) {
+  const workspaceDir = options.workspaceDir || process.env.OPENCLAW_WORKSPACE || process.cwd();
+  
+  // If gateway URL provided, use session summarizer
+  if (options.gatewayUrl || process.env.OPENCLAW_GATEWAY_URL) {
+    logger.info('Using session summarizer', {
+      event: 'summary_mode_selected',
+      data: {
+        mode: 'session'
+      }
+    });
+    return createSessionSummarizer(
+      options.gatewayUrl || process.env.OPENCLAW_GATEWAY_URL,
+      options.gatewayToken || process.env.OPENCLAW_TOKEN
+    );
+  }
+  
+  // If HTTP endpoint provided, use that
+  if (options.summaryEndpoint) {
+    logger.info('Using HTTP summarizer', {
+      event: 'summary_mode_selected',
+      data: {
+        mode: 'http',
+        endpoint: options.summaryEndpoint
+      }
+    });
+    return createHttpSummarizer(options.summaryEndpoint);
+  }
+  
+  // Fall back to exec summarizer
+  logger.info('Using exec summarizer', {
+    event: 'summary_mode_selected',
+    data: {
+      mode: 'exec',
+      workspace_dir: workspaceDir
+    }
+  });
+  return createExecSummarizer(workspaceDir);
+}
+
+module.exports = {
+  loadOwnerContext,
+  buildSummaryPrompt,
+  createExecSummarizer,
+  createHttpSummarizer,
+  createSessionSummarizer,
+  createAutoSummarizer
+};

package/.claude/worktrees/agent-acefedbd/.claude/worktrees/agent-a1418bc4/src/lib/pid-file.js

@@ -0,0 +1,103 @@
+/**
+ * PID File Management
+ *
+ * Writes/reads/removes a PID file for the A2A server process.
+ * Used by server.js on startup and cli.js for pre-start cleanup.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const CONFIG_DIR = process.env.A2A_CONFIG_DIR ||
+  process.env.OPENCLAW_CONFIG_DIR ||
+  path.join(process.env.HOME || '/tmp', '.config', 'openclaw');
+
+const PID_FILE = path.join(CONFIG_DIR, 'a2a-server.pid');
+
+function writePidFile(pid) {
+  try {
+    if (!fs.existsSync(CONFIG_DIR)) {
+      fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    fs.writeFileSync(PID_FILE, String(pid) + '\n', { mode: 0o600 });
+  } catch (e) {
+    // Best effort — don't crash the server if PID file write fails
+  }
+}
+
+function readPidFile() {
+  try {
+    const content = fs.readFileSync(PID_FILE, 'utf8').trim();
+    const pid = parseInt(content, 10);
+    return Number.isFinite(pid) && pid > 0 ? pid : null;
+  } catch (e) {
+    return null;
+  }
+}
+
+function removePidFile() {
+  try {
+    fs.rmSync(PID_FILE, { force: true });
+  } catch (e) {
+    // Best effort
+  }
+}
+
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Kill the server process recorded in the PID file.
+ * Returns { killed: boolean, pid: number|null }.
+ */
+function killExistingServer() {
+  const pid = readPidFile();
+  if (!pid) return { killed: false, pid: null };
+
+  if (!isProcessAlive(pid)) {
+    // Stale PID file — clean up
+    removePidFile();
+    return { killed: false, pid };
+  }
+
+  try {
+    process.kill(pid, 'SIGTERM');
+  } catch (e) {
+    removePidFile();
+    return { killed: false, pid };
+  }
+
+  // Wait up to 3s for graceful exit
+  const start = Date.now();
+  while (Date.now() - start < 3000) {
+    if (!isProcessAlive(pid)) {
+      removePidFile();
+      return { killed: true, pid };
+    }
+    spawnSync('sleep', ['0.1'], { timeout: 500 });
+  }
+
+  // Force kill
+  try {
+    process.kill(pid, 'SIGKILL');
+  } catch (e) {}
+
+  removePidFile();
+  return { killed: true, pid };
+}
+
+module.exports = {
+  writePidFile,
+  readPidFile,
+  removePidFile,
+  isProcessAlive,
+  killExistingServer,
+  PID_FILE
+};

package/.claude/worktrees/agent-acefedbd/.claude/worktrees/agent-a1418bc4/src/lib/port-scanner.js

@@ -0,0 +1,83 @@
+/**
+ * Port Scanner Utility
+ *
+ * Zero-dependency port availability checker using Node's net module.
+ * Used by the server to find an open port at startup.
+ */
+
+const net = require('net');
+
+/**
+ * Attempt to bind a port and return a structured result.
+ * Useful for distinguishing "already in use" from "permission denied".
+ *
+ * @param {number} port
+ * @param {string} [host='0.0.0.0']
+ * @returns {Promise<{ ok: boolean, code?: string, message?: string }>}
+ */
+function tryBindPort(port, host = '0.0.0.0') {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    server.once('error', (err) => resolve({ ok: false, code: err && err.code ? String(err.code) : 'ERROR', message: err ? String(err.message || '') : '' }));
+    server.once('listening', () => server.close(() => resolve({ ok: true })));
+    server.listen(port, host);
+  });
+}
+
+/**
+ * Check if a port is available on the given host for binding by the current user.
+ * @param {number} port
+ * @param {string} [host='0.0.0.0']
+ * @returns {Promise<boolean>}
+ */
+function isPortAvailable(port, host = '0.0.0.0') {
+  return tryBindPort(port, host).then((res) => Boolean(res && res.ok));
+}
+
+/**
+ * Find the first available port from a list of candidates.
+ * @param {number[]} candidates - Ports to try in order
+ * @param {string} [host='0.0.0.0']
+ * @returns {Promise<number|null>} - First available port, or null if all busy
+ */
+async function findAvailablePort(candidates, host = '0.0.0.0') {
+  for (const port of candidates) {
+    if (await isPortAvailable(port, host)) return port;
+  }
+  return null;
+}
+
+/**
+ * Check whether a TCP listener exists on the given host/port.
+ * This does NOT require binding privileges; it simply attempts to connect.
+ *
+ * @param {number} port
+ * @param {string} [host='127.0.0.1']
+ * @param {object} [options]
+ * @param {number} [options.timeoutMs=400]
+ * @returns {Promise<{ listening: boolean, code?: string, message?: string }>}
+ */
+function isPortListening(port, host = '127.0.0.1', options = {}) {
+  const timeoutMs = Number.parseInt(String(options.timeoutMs || 400), 10) || 400;
+
+  return new Promise((resolve) => {
+    const socket = net.connect({ host, port });
+    let settled = false;
+
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      try { socket.destroy(); } catch (e) {}
+      resolve(result);
+    };
+
+    socket.setTimeout(timeoutMs, () => finish({ listening: false, code: 'ETIMEDOUT', message: 'connect_timeout' }));
+    socket.once('connect', () => finish({ listening: true }));
+    socket.once('error', (err) => {
+      const code = err && err.code ? String(err.code) : 'ERROR';
+      finish({ listening: false, code, message: err ? String(err.message || '') : '' });
+    });
+  });
+}
+
+module.exports = { tryBindPort, isPortAvailable, isPortListening, findAvailablePort };