a2acalling 0.6.75 → 0.6.76

package/.claude/worktrees/agent-acefedbd/.claude/worktrees/agent-a04dc0fe/src/lib/external-ip.js

@@ -0,0 +1,211 @@
+/**
+ * External IP Resolver (Cached)
+ *
+ * When generating invites, we want a host that other agents can reach.
+ * This module fetches the machine's public (egress) IP from a few
+ * "what is my IP" services and caches the result to avoid repeated
+ * network calls.
+ *
+ * Cache file: ~/.config/openclaw/a2a-external-ip.json (or A2A_CONFIG_DIR)
+ */
+
+const fs = require('fs');
+const path = require('path');
+const http = require('http');
+const https = require('https');
+const net = require('net');
+
+const CONFIG_DIR = process.env.A2A_CONFIG_DIR ||
+  process.env.OPENCLAW_CONFIG_DIR ||
+  path.join(process.env.HOME || '/tmp', '.config', 'openclaw');
+
+const EXTERNAL_IP_CACHE_FILE = path.join(CONFIG_DIR, 'a2a-external-ip.json');
+
+const DEFAULT_SERVICES = [
+  'https://ifconfig.me/ip',
+  'https://api.ipify.org',
+  'https://checkip.amazonaws.com/',
+  'https://icanhazip.com/'
+];
+
+function ensureDir(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+}
+
+function atomicWriteJson(filePath, data) {
+  ensureDir(path.dirname(filePath));
+  const tmpPath = `${filePath}.tmp`;
+  fs.writeFileSync(tmpPath, JSON.stringify(data, null, 2), { mode: 0o600 });
+  fs.renameSync(tmpPath, filePath);
+  try {
+    fs.chmodSync(filePath, 0o600);
+  } catch (err) {
+    // Best effort.
+  }
+}
+
+function readJson(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) return null;
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch (err) {
+    return null;
+  }
+}
+
+function parseIp(text) {
+  const candidate = String(text || '')
+    .trim()
+    .replace(/^"+|"+$/g, '')
+    .split(/\s+/)[0];
+  if (!candidate) return null;
+  return net.isIP(candidate) ? candidate : null;
+}
+
+function requestText(url, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    let parsed;
+    try {
+      parsed = new URL(url);
+    } catch (err) {
+      reject(new Error('invalid_url'));
+      return;
+    }
+
+    const client = parsed.protocol === 'https:' ? https : http;
+    const req = client.request({
+      protocol: parsed.protocol,
+      hostname: parsed.hostname,
+      port: parsed.port || (parsed.protocol === 'https:' ? 443 : 80),
+      method: 'GET',
+      path: parsed.pathname + parsed.search,
+      headers: {
+        'User-Agent': `a2acalling/${process.env.npm_package_version || 'dev'} (external-ip)`
+      },
+      timeout: timeoutMs
+    }, (res) => {
+      let data = '';
+      res.setEncoding('utf8');
+
+      res.on('data', (chunk) => {
+        data += chunk;
+        if (data.length > 4096) {
+          req.destroy(new Error('response_too_large'));
+        }
+      });
+
+      res.on('end', () => resolve({ statusCode: res.statusCode || 0, body: data }));
+    });
+
+    req.on('error', reject);
+    req.on('timeout', () => {
+      req.destroy(new Error('timeout'));
+    });
+
+    req.end();
+  });
+}
+
+async function fetchExternalIp(options = {}) {
+  const timeoutMs = Number.isFinite(options.timeoutMs) ? options.timeoutMs : 2500;
+  const services = Array.isArray(options.services) && options.services.length
+    ? options.services
+    : DEFAULT_SERVICES;
+
+  const attempts = [];
+  let lastError = null;
+  for (const serviceUrl of services) {
+    try {
+      const res = await requestText(serviceUrl, timeoutMs);
+      if (res.statusCode < 200 || res.statusCode >= 300) {
+        throw new Error(`bad_status_${res.statusCode}`);
+      }
+      const ip = parseIp(res.body);
+      if (!ip) {
+        throw new Error('invalid_ip');
+      }
+      attempts.push({ service: serviceUrl, ok: true, statusCode: res.statusCode, ip });
+      return { ip, source: serviceUrl, attempts };
+    } catch (err) {
+      lastError = err;
+      attempts.push({ service: serviceUrl, ok: false, error: err && err.message ? err.message : 'request_failed' });
+    }
+  }
+
+  const msg = lastError ? lastError.message : 'unavailable';
+  const failure = new Error(`external_ip_unavailable:${msg}`);
+  failure.attempts = attempts;
+  throw failure;
+}
+
+/**
+ * Get external IP, using cached result if not stale.
+ *
+ * Returns:
+ *   { ip, checkedAt, source, fromCache, stale }
+ * or:
+ *   { ip: null, error }
+ */
+async function getExternalIp(options = {}) {
+  const ttlMs = Number.isFinite(options.ttlMs)
+    ? options.ttlMs
+    : Number.parseInt(process.env.A2A_EXTERNAL_IP_TTL_MS || '', 10) || (6 * 60 * 60 * 1000);
+  const cacheFile = options.cacheFile || EXTERNAL_IP_CACHE_FILE;
+  const nowMs = Number.isFinite(options.nowMs) ? options.nowMs : Date.now();
+
+  const cached = readJson(cacheFile);
+  if (cached && cached.ip && cached.checked_at) {
+    const cachedIp = parseIp(cached.ip);
+    const checkedAtMs = Date.parse(cached.checked_at);
+    if (cachedIp && Number.isFinite(checkedAtMs)) {
+      const ageMs = Math.max(0, nowMs - checkedAtMs);
+      if (ageMs <= ttlMs && !options.forceRefresh) {
+        return {
+          ip: cachedIp,
+          checkedAt: cached.checked_at,
+          source: cached.source || 'cache',
+          fromCache: true,
+          stale: false
+        };
+      }
+    }
+  }
+
+  try {
+    const { ip, source, attempts } = await fetchExternalIp({
+      timeoutMs: options.timeoutMs,
+      services: options.services
+    });
+    const checkedAt = new Date(nowMs).toISOString();
+    atomicWriteJson(cacheFile, { ip, checked_at: checkedAt, source });
+    return { ip, checkedAt, source, fromCache: false, stale: false, attempts: Array.isArray(attempts) ? attempts : null };
+  } catch (err) {
+    if (cached && cached.ip) {
+      const cachedIp = parseIp(cached.ip);
+      if (cachedIp) {
+        return {
+          ip: cachedIp,
+          checkedAt: cached.checked_at || null,
+          source: cached.source || 'cache',
+          fromCache: true,
+          stale: true,
+          error: err && err.message ? err.message : 'external_ip_unavailable',
+          attempts: err && Array.isArray(err.attempts) ? err.attempts : null
+        };
+      }
+    }
+    return {
+      ip: null,
+      error: err && err.message ? err.message : 'external_ip_unavailable',
+      attempts: err && Array.isArray(err.attempts) ? err.attempts : null
+    };
+  }
+}
+
+module.exports = {
+  EXTERNAL_IP_CACHE_FILE,
+  fetchExternalIp,
+  getExternalIp
+};

package/.claude/worktrees/agent-acefedbd/.claude/worktrees/agent-a04dc0fe/src/lib/invite-host.js

@@ -0,0 +1,223 @@
+/**
+ * Invite Host Resolution
+ *
+ * Goal: produce a host:port that other agents can reach, even when the
+ * local machine's hostname is not publicly resolvable.
+ *
+ * Strategy:
+ * - Prefer explicit env `A2A_HOSTNAME`
+ * - Else use config agent.hostname if present
+ * - Else fall back to OS/env hostname
+ *
+ * If the selected hostname is clearly local/private/unroutable, replace
+ * it with the machine's external IP (cached with TTL).
+ */
+
+const net = require('net');
+const { getExternalIp } = require('./external-ip');
+
+function readIntEnv(name) {
+  const raw = process.env[name];
+  if (!raw) return null;
+  const parsed = Number.parseInt(String(raw), 10);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+function normalizeHostInput(value) {
+  const raw = String(value || '').trim();
+  if (!raw) return '';
+
+  // Accept accidental `http(s)://host:port` input.
+  if (raw.includes('://')) {
+    try {
+      const parsed = new URL(raw);
+      return parsed.host;
+    } catch (err) {
+      // fall through
+    }
+  }
+
+  return raw.replace(/\/+$/, '');
+}
+
+function splitHostPort(rawHost) {
+  const host = normalizeHostInput(rawHost);
+  if (!host) return { hostname: '', port: null };
+
+  // IPv6 in brackets: [::1]:3001
+  const bracketed = host.match(/^\[([^\]]+)\](?::(\d+))?$/);
+  if (bracketed) {
+    return {
+      hostname: bracketed[1],
+      port: bracketed[2] ? Number.parseInt(bracketed[2], 10) : null
+    };
+  }
+
+  const lastColon = host.lastIndexOf(':');
+  if (lastColon !== -1 && host.indexOf(':') === lastColon) {
+    const maybePort = host.slice(lastColon + 1);
+    if (/^\d+$/.test(maybePort)) {
+      return {
+        hostname: host.slice(0, lastColon),
+        port: Number.parseInt(maybePort, 10)
+      };
+    }
+  }
+
+  return { hostname: host, port: null };
+}
+
+function formatHostPort(hostname, port) {
+  const host = String(hostname || '').trim();
+  const p = Number.isFinite(port) ? port : null;
+
+  if (!host) return '';
+  const needsBrackets = net.isIP(host) === 6;
+  const hostPart = needsBrackets ? `[${host}]` : host;
+  // Don't append port 80 (it's the default HTTP port)
+  return (p && p !== 80) ? `${hostPart}:${p}` : hostPart;
+}
+
+function isPrivateIpv4(ip) {
+  const parts = ip.split('.').map(n => Number.parseInt(n, 10));
+  if (parts.length !== 4 || parts.some(n => !Number.isFinite(n) || n < 0 || n > 255)) return false;
+  const [a, b] = parts;
+  if (a === 10) return true;
+  if (a === 127) return true; // loopback
+  if (a === 0) return true; // "this" network
+  if (a === 169 && b === 254) return true; // link-local
+  if (a === 192 && b === 168) return true;
+  if (a === 172 && b >= 16 && b <= 31) return true;
+  // CGNAT 100.64.0.0/10
+  if (a === 100 && b >= 64 && b <= 127) return true;
+  return false;
+}
+
+function isLocalOrUnroutableHost(hostname) {
+  const host = String(hostname || '').trim().toLowerCase();
+  if (!host) return true;
+  if (host === 'localhost' || host === '0.0.0.0') return true;
+  if (host === '::' || host === '::1') return true;
+  if (host.endsWith('.local') || host.endsWith('.lan')) return true;
+
+  const ipType = net.isIP(host);
+  if (ipType === 4) return isPrivateIpv4(host);
+  if (ipType === 6) {
+    // Unique local (fc00::/7), link-local (fe80::/10), loopback.
+    if (host === '::1') return true;
+    if (host.startsWith('fc') || host.startsWith('fd')) return true;
+    if (host.startsWith('fe80:')) return true;
+    return false;
+  }
+
+  // Heuristic: bare hostnames without a dot are commonly local-only.
+  if (!host.includes('.')) return true;
+
+  return false;
+}
+
+function isPublicIpHostname(hostname) {
+  const host = String(hostname || '').trim();
+  const type = net.isIP(host);
+  if (type === 4) return !isPrivateIpv4(host);
+  // For IPv6: if it's a real v6 and not local per heuristic, treat as public.
+  if (type === 6) return !isLocalOrUnroutableHost(host);
+  return false;
+}
+
+async function resolveInviteHost(options = {}) {
+  const config = options.config || null;
+
+  const envHost = normalizeHostInput(process.env.A2A_HOSTNAME);
+  const cfgHost = normalizeHostInput(config && config.getAgent ? (config.getAgent().hostname || '') : '');
+  const fallbackHost = normalizeHostInput(options.fallbackHost);
+  const openclawHost = normalizeHostInput(process.env.OPENCLAW_HOSTNAME);
+  const osHost = normalizeHostInput(process.env.HOSTNAME);
+
+  const candidate = envHost || cfgHost || openclawHost || fallbackHost || osHost || 'localhost';
+  const candidateSource = envHost
+    ? 'env'
+    : cfgHost
+    ? 'config'
+    : openclawHost
+    ? 'openclaw_env'
+    : fallbackHost
+    ? 'fallback'
+    : osHost
+    ? 'os'
+    : 'default';
+
+  const parsed = splitHostPort(candidate);
+  const desiredPort = parsed.port ||
+    Number.parseInt(String(options.defaultPort || ''), 10) ||
+    readIntEnv('PORT') ||
+    readIntEnv('A2A_PORT') ||
+    3001;
+
+  const candidateHostWithPort = formatHostPort(parsed.hostname, desiredPort);
+
+  const warnings = [];
+
+  const ttlMs = Number.isFinite(options.externalIpTtlMs)
+    ? options.externalIpTtlMs
+    : undefined;
+
+  const shouldReplaceWithExternalIp = isLocalOrUnroutableHost(parsed.hostname) ||
+    (
+      options.refreshExternalIp && isPublicIpHostname(parsed.hostname)
+    );
+
+  const alwaysLookupExternalIp = Boolean(options.alwaysLookupExternalIp);
+  const wantsExternalIp = shouldReplaceWithExternalIp || alwaysLookupExternalIp;
+  const warnOnExternalIpFailure = options.warnOnExternalIpFailure !== undefined
+    ? Boolean(options.warnOnExternalIpFailure)
+    : shouldReplaceWithExternalIp;
+
+  const external = wantsExternalIp
+    ? await getExternalIp({
+      ttlMs,
+      timeoutMs: options.externalIpTimeoutMs,
+      services: options.externalIpServices,
+      cacheFile: options.externalIpCacheFile,
+      forceRefresh: Boolean(options.forceRefreshExternalIp)
+    })
+    : null;
+
+  if (shouldReplaceWithExternalIp && external && external.ip) {
+    const finalHost = formatHostPort(external.ip, desiredPort);
+    if (finalHost !== candidateHostWithPort) {
+      warnings.push(
+        `Invite host "${candidateHostWithPort}" looks local/unroutable. Using external IP "${finalHost}" instead.`
+      );
+    }
+    return {
+      host: finalHost,
+      source: 'external_ip',
+      originalHost: candidateHostWithPort,
+      externalIp: external.ip,
+      externalIpInfo: external,
+      warnings
+    };
+  }
+
+  if (wantsExternalIp && (!external || !external.ip) && warnOnExternalIpFailure) {
+    warnings.push(
+      `Invite host "${candidateHostWithPort}" may not be reachable from other machines, and external IP lookup failed. Set A2A_HOSTNAME="your-public-host:port".`
+    );
+  }
+  return {
+    host: candidateHostWithPort,
+    source: candidateSource,
+    originalHost: candidateHostWithPort,
+    externalIpInfo: external,
+    warnings
+  };
+}
+
+module.exports = {
+  normalizeHostInput,
+  splitHostPort,
+  formatHostPort,
+  isLocalOrUnroutableHost,
+  resolveInviteHost
+};

package/.claude/worktrees/agent-acefedbd/.claude/worktrees/agent-a04dc0fe/src/lib/local-request.js

@@ -0,0 +1,69 @@
+/**
+ * Local Request Detection Utilities
+ *
+ * A2A-73: Extracted from dashboard.js and a2a.js to provide a single,
+ * proxy-aware implementation of local request detection. The previous
+ * isLoopbackAddress(req.ip) check was insufficient behind reverse proxies
+ * because Express (without trust proxy) reports the proxy's IP, not the
+ * real client IP.
+ */
+
+'use strict';
+
+/**
+ * Check if an IP address is a loopback address.
+ * Handles IPv4, IPv6, and IPv4-mapped IPv6 formats.
+ */
+function isLoopbackAddress(ip) {
+  if (!ip) return false;
+  if (ip === '::1' || ip === '127.0.0.1' || ip === '::ffff:127.0.0.1') {
+    return true;
+  }
+  // Full 127.0.0.0/8 range is loopback in IPv4
+  if (ip.startsWith('127.')) return true;
+  return ip.startsWith('::ffff:127.');
+}
+
+/**
+ * Determine if a request is a direct local connection (not proxied).
+ *
+ * A2A-73: This is the security-critical check. A request is only considered
+ * "direct local" if ALL of these conditions hold:
+ * 1. Socket remote address is loopback (the TCP connection is local)
+ * 2. Host header targets localhost (not a public hostname)
+ * 3. No proxy-forwarding headers are present (rules out nginx/CDN traffic)
+ *
+ * Without condition 3, any request through a reverse proxy would pass
+ * because the proxy connects from 127.0.0.1 to the backend.
+ */
+function isDirectLocalRequest(req) {
+  const ip = (req && req.socket && req.socket.remoteAddress) ? req.socket.remoteAddress : req.ip;
+  if (!isLoopbackAddress(ip)) return false;
+
+  const rawHost = String(req.headers.host || '').toLowerCase();
+  // Strip port suffix to get the bare hostname for exact matching.
+  // This prevents DNS rebinding via e.g. localhost.evil.com or 127.0.0.1.nip.io.
+  // Negative lookbehind avoids stripping `:1` from bare IPv6 `::1`.
+  const hostname = rawHost.replace(/(?<!:):\d+$/, '');
+  const isLocalHost = hostname === 'localhost' ||
+    hostname === '127.0.0.1' ||
+    hostname === '[::1]' ||
+    hostname === '::1';
+  if (!isLocalHost) return false;
+
+  // A2A-73: Reject requests with any proxy-forwarding header. These indicate
+  // the request was relayed by nginx, a CDN, or another reverse proxy —
+  // even though the socket address is loopback (proxy → backend is local).
+  const forwarded = req.headers['x-forwarded-for'] ||
+    req.headers['x-forwarded-proto'] ||
+    req.headers['x-forwarded-host'] ||
+    req.headers['cf-connecting-ip'] ||
+    req.headers['x-forwarded-by'] ||
+    req.headers['x-real-ip'] ||
+    req.headers['forwarded'];
+  if (forwarded) return false;
+
+  return true;
+}
+
+module.exports = { isLoopbackAddress, isDirectLocalRequest };