feat: add A2A gateway support (activated by A2A_PEERS env var)

- Add openclaw-a2a-gateway extension to Dockerfile
- Add a2a-proxy.cjs for port routing (7860 proxy → 7861 OpenClaw, 18800 A2A)
- Modify sync_hf.py: port 7861, A2A config only when A2A_PEERS is set
- No impact when A2A_PEERS is not set (proxy transparently forwards)

Dockerfile

@@ -52,6 +52,14 @@ RUN echo "[build][layer2] Clone + install + build..." && START=$(date +%s) \
   && echo "[build] version: $(cat /app/openclaw/.version)" \
   && echo "[build][layer2] Total clone+install+build: $(($(date +%s) - START))s"
 
+# ── Layer 2.5: A2A Gateway Extension (optional, activated by A2A_PEERS env) ──
+RUN echo "[build][layer2.5] Cloning A2A gateway extension..." && START=$(date +%s) \
+  && git clone --depth 1 https://github.com/win4r/openclaw-a2a-gateway.git /app/openclaw/extensions/a2a-gateway \
+  && cd /app/openclaw/extensions/a2a-gateway \
+  && npm install --production \
+  && echo "[build] A2A gateway installed: $(ls node_modules | wc -l) packages" \
+  && echo "[build][layer2.5] A2A gateway: $(($(date +%s) - START))s"
+
 # ── Layer 3 (node): Scripts + Config ──────────────────────────────────────────
 COPY --chown=node:node scripts /home/node/scripts
 COPY --chown=node:node openclaw.json /home/node/scripts/openclaw.json.default

scripts/a2a-proxy.cjs

@@ -0,0 +1,134 @@
+/**
+ * a2a-proxy.cjs — Reverse proxy on port 7860
+ *
+ * Routes:
+ *   /.well-known/*  → A2A gateway (port 18800)
+ *   /a2a/*          → A2A gateway (port 18800)
+ *   /api/state      → local state JSON (for Office frontend polling)
+ *   everything else → OpenClaw (port 7861)
+ */
+'use strict';
+
+const http = require('http');
+const url = require('url');
+
+const LISTEN_PORT = 7860;
+const OPENCLAW_PORT = 7861;
+const A2A_PORT = 18800;
+const AGENT_NAME = process.env.AGENT_NAME || 'Agent';
+
+let currentState = {
+  state: 'syncing',
+  detail: `${AGENT_NAME} is starting...`,
+  progress: 0,
+  updated_at: new Date().toISOString()
+};
+
+// Poll OpenClaw health to track state
+async function pollOpenClawHealth() {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5000);
+    const resp = await fetch(`http://127.0.0.1:${OPENCLAW_PORT}/`, {
+      signal: controller.signal
+    });
+    clearTimeout(timeout);
+    currentState = {
+      state: resp.ok ? 'idle' : 'error',
+      detail: resp.ok ? `${AGENT_NAME} is running` : `HTTP ${resp.status}`,
+      progress: resp.ok ? 100 : 0,
+      updated_at: new Date().toISOString()
+    };
+  } catch (_) {
+    currentState = {
+      state: 'syncing',
+      detail: `${AGENT_NAME} is starting...`,
+      progress: 0,
+      updated_at: new Date().toISOString()
+    };
+  }
+}
+
+setInterval(pollOpenClawHealth, 5000);
+pollOpenClawHealth();
+
+function proxyRequest(req, res, targetPort) {
+  const options = {
+    hostname: '127.0.0.1',
+    port: targetPort,
+    path: req.url,
+    method: req.method,
+    headers: { ...req.headers, host: `127.0.0.1:${targetPort}` }
+  };
+
+  const proxy = http.request(options, (proxyRes) => {
+    res.writeHead(proxyRes.statusCode, proxyRes.headers);
+    proxyRes.pipe(res, { end: true });
+  });
+
+  proxy.on('error', (err) => {
+    if (!res.headersSent) {
+      res.writeHead(502, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'Backend unavailable', target: targetPort }));
+    }
+  });
+
+  req.pipe(proxy, { end: true });
+}
+
+const server = http.createServer((req, res) => {
+  const pathname = url.parse(req.url).pathname;
+
+  // A2A routes → A2A gateway
+  if (pathname.startsWith('/.well-known/') || pathname.startsWith('/a2a/')) {
+    return proxyRequest(req, res, A2A_PORT);
+  }
+
+  // State endpoint for Office frontend polling
+  if (pathname === '/api/state' || pathname === '/status') {
+    res.writeHead(200, {
+      'Content-Type': 'application/json',
+      'Access-Control-Allow-Origin': '*'
+    });
+    return res.end(JSON.stringify(currentState));
+  }
+
+  // Everything else → OpenClaw
+  proxyRequest(req, res, OPENCLAW_PORT);
+});
+
+// Handle WebSocket upgrades
+server.on('upgrade', (req, socket, head) => {
+  const pathname = url.parse(req.url).pathname;
+  const targetPort = (pathname.startsWith('/.well-known/') || pathname.startsWith('/a2a/'))
+    ? A2A_PORT
+    : OPENCLAW_PORT;
+
+  const options = {
+    hostname: '127.0.0.1',
+    port: targetPort,
+    path: req.url,
+    method: req.method,
+    headers: { ...req.headers, host: `127.0.0.1:${targetPort}` }
+  };
+
+  const proxy = http.request(options);
+  proxy.on('upgrade', (proxyRes, proxySocket, proxyHead) => {
+    socket.write(
+      `HTTP/1.1 101 Switching Protocols\r\n` +
+      Object.entries(proxyRes.headers).map(([k, v]) => `${k}: ${v}`).join('\r\n') +
+      '\r\n\r\n'
+    );
+    proxySocket.write(head);
+    proxySocket.pipe(socket);
+    socket.pipe(proxySocket);
+  });
+  proxy.on('error', () => socket.end());
+  proxy.end();
+});
+
+server.listen(LISTEN_PORT, '0.0.0.0', () => {
+  console.log(`[a2a-proxy] Listening on port ${LISTEN_PORT}`);
+  console.log(`[a2a-proxy] OpenClaw → :${OPENCLAW_PORT}, A2A → :${A2A_PORT}`);
+  console.log(`[a2a-proxy] Agent: ${AGENT_NAME}`);
+});

scripts/entrypoint.sh

@@ -64,6 +64,12 @@ if [ -f /app/openclaw/.version ]; then
   echo "[entrypoint] OpenClaw version: $OPENCLAW_VERSION"
 fi
 
+# ── Start A2A proxy on port 7860 (OpenClaw moves to 7861) ─────────────────
+echo "[entrypoint] Starting A2A proxy on port 7860..."
+node /home/node/scripts/a2a-proxy.cjs &
+A2A_PROXY_PID=$!
+echo "[entrypoint] A2A proxy PID: $A2A_PROXY_PID"
+
 # ── Start OpenClaw via sync_hf.py ─────────────────────────────────────────
 echo "[entrypoint] Starting OpenClaw via sync_hf.py..."
 exec python3 -u /home/node/scripts/sync_hf.py

scripts/sync_hf.py

@@ -71,6 +71,10 @@ ZHIPU_API_KEY = os.environ.get("ZHIPU_API_KEY", "")
 # Gateway token (default: huggingclaw; override via GATEWAY_TOKEN env var)
 GATEWAY_TOKEN = os.environ.get("GATEWAY_TOKEN", "huggingclaw")
 
+# A2A configuration (optional; only activated when A2A_PEERS is set)
+AGENT_NAME = os.environ.get("AGENT_NAME", "HuggingClaw")
+A2A_PEERS = os.environ.get("A2A_PEERS", "")  # comma-separated peer URLs
+
 # Default model for new conversations (infer from provider if not set)
 OPENCLAW_DEFAULT_MODEL = os.environ.get("OPENCLAW_DEFAULT_MODEL") or (
     "openai/gpt-5-nano" if OPENAI_API_KEY
@@ -378,7 +382,7 @@ class OpenClawFullSync:
             with open(config_path, "w") as f:
                 json.dump({
                     "gateway": {
-                        "mode": "local", "bind": "lan", "port": 7860,
+                        "mode": "local", "bind": "lan", "port": 7861,
                         "trustedProxies": ["0.0.0.0/0"],
                         "controlUi": {
                             "allowInsecureAuth": True,
@@ -436,7 +440,7 @@ class OpenClawFullSync:
             data["gateway"] = {
                 "mode": "local",
                 "bind": "lan",
-                "port": 7860,
+                "port": 7861,
                 "auth": {"token": GATEWAY_TOKEN},
                 "trustedProxies": ["0.0.0.0/0"],
                 "controlUi": {
@@ -445,7 +449,7 @@ class OpenClawFullSync:
                     "allowedOrigins": allowed_origins
                 }
             }
-            print(f"[SYNC] Set gateway config (auth=token, origins={len(allowed_origins)})")
+            print(f"[SYNC] Set gateway config (port=7861, auth=token, origins={len(allowed_origins)})")
 
             # Ensure agents defaults
             data.setdefault("agents", {}).setdefault("defaults", {}).setdefault("model", {})
@@ -490,14 +494,47 @@ class OpenClawFullSync:
             data.setdefault("models", {})["providers"] = providers
             data["agents"]["defaults"]["model"]["primary"] = OPENCLAW_DEFAULT_MODEL
 
-            # Plugin whitelist (only load telegram + whatsapp to speed up startup)
+            # Plugin whitelist
             data.setdefault("plugins", {}).setdefault("entries", {})
-            data["plugins"]["allow"] = ["telegram", "whatsapp"]
+            plugin_allow = ["telegram", "whatsapp"]
+            if A2A_PEERS:
+                plugin_allow.append("a2a-gateway")
+            data["plugins"]["allow"] = plugin_allow
             if "telegram" not in data["plugins"]["entries"]:
                 data["plugins"]["entries"]["telegram"] = {"enabled": True}
             elif isinstance(data["plugins"]["entries"]["telegram"], dict):
                 data["plugins"]["entries"]["telegram"]["enabled"] = True
 
+            # ── A2A Gateway Plugin Configuration (only if A2A_PEERS is set) ──
+            if A2A_PEERS:
+                peers = []
+                for peer_url in A2A_PEERS.split(","):
+                    peer_url = peer_url.strip()
+                    if not peer_url:
+                        continue
+                    name = peer_url.split("//")[-1].split(".")[0].split("-")[-1].capitalize()
+                    peers.append({
+                        "name": name,
+                        "agentCardUrl": f"{peer_url}/.well-known/agent-card.json"
+                    })
+                    print(f"[SYNC] A2A peer: {name} → {peer_url}")
+
+                data["plugins"]["entries"]["a2a-gateway"] = {
+                    "enabled": True,
+                    "config": {
+                        "agentCard": {
+                            "name": AGENT_NAME,
+                            "description": f"{AGENT_NAME} - HuggingClaw A2A Agent",
+                            "skills": [{"id": "chat", "name": "chat", "description": "Chat bridge"}]
+                        },
+                        "server": {"host": "0.0.0.0", "port": 18800},
+                        "security": {"inboundAuth": "none"},
+                        "routing": {"defaultAgentId": "main"},
+                        "peers": peers
+                    }
+                }
+                print(f"[SYNC] A2A gateway configured: name={AGENT_NAME}, port=18800, peers={len(peers)}")
+
             # ── Telegram channel defaults (open DM policy for HF Spaces) ──
             # Personal bot on HF Spaces — no need for strict pairing.
             tg_ch = data.setdefault("channels", {}).setdefault("telegram", {})