@chenacc/agentbridge 0.1.0 → 0.1.2

package/src/config.js

@@ -2,13 +2,81 @@ import os from "node:os";
 import path from "node:path";
 import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 
-function firstLanAddress() {
-  for (const entries of Object.values(os.networkInterfaces())) {
+/**
+ * Adapter names that never reach the phone, or only reach it over an overlay.
+ *
+ * A Windows laptop normally carries several phantom adapters: Hyper-V switches,
+ * WSL, "本地连接*" (Wi-Fi Direct), Bluetooth PAN and — with Tailscale installed
+ * but logged out — a 169.254.x.x link-local fallback. `os.networkInterfaces()`
+ * returns them in no meaningful order, so taking the first one can hand the
+ * phone an address with no route to anything. That is exactly what shipped in
+ * 0.1.0: the QR encoded the logged-out Tailscale adapter.
+ */
+const OVERLAY_ADAPTER_HINTS = ["tailscale", "zerotier", "wireguard", "hamachi", "radmin", "vpn"];
+const VIRTUAL_ADAPTER_HINTS = [
+  "vethernet", "hyper-v", "wsl", "vmware", "virtualbox", "docker", "npcap",
+  "loopback", "bluetooth", "蓝牙", "wi-fi direct", "wifi direct", "tap-", "utun",
+];
+const PHYSICAL_ADAPTER_HINTS = ["wlan", "wi-fi", "wifi", "无线", "ethernet", "以太网", "en0", "eth", "enp", "ens", "本地连接"];
+
+/**
+ * How usable an address is from another device, 0 meaning "not at all".
+ *
+ * Loopback and 169.254 link-local are hard zeros: a link-local address means the
+ * adapter never got a lease, so nothing outside the cable can reach it. Private
+ * RFC 1918 ranges are the intended path, 100.64/10 (Tailscale's CGNAT range) is
+ * reachable only from a phone that is also on the tailnet, and a plain public
+ * address on a NIC still beats nothing.
+ */
+function addressScore(address) {
+  const [a, b] = address.split(".").map(Number);
+  if (!Number.isInteger(a) || !Number.isInteger(b)) return 0;
+  if (a === 0 || a === 127 || a >= 224) return 0;
+  if (a === 169 && b === 254) return 0;
+  if (a === 192 && b === 168) return 100;
+  if (a === 10) return 95;
+  if (a === 172 && b >= 16 && b <= 31) return 90;
+  if (a === 100 && b >= 64 && b <= 127) return 60;
+  return 50;
+}
+
+function adapterScore(name = "") {
+  const lower = String(name).toLowerCase();
+  // Hosted-network names such as "本地连接* 10" carry an asterisk; the star is what
+  // distinguishes them from the plain "本地连接" of a real Ethernet card.
+  if (lower.includes("*")) return -120;
+  if (OVERLAY_ADAPTER_HINTS.some((hint) => lower.includes(hint))) return -40;
+  if (VIRTUAL_ADAPTER_HINTS.some((hint) => lower.includes(hint))) return -120;
+  if (PHYSICAL_ADAPTER_HINTS.some((hint) => lower.includes(hint))) return 25;
+  return 0;
+}
+
+/**
+ * Every IPv4 address a phone could plausibly open, best first.
+ *
+ * Exported for tests: the failure this guards against depends on the machine's
+ * adapter list, which no CI runner reproduces.
+ */
+export function rankLanAddresses(interfaces = os.networkInterfaces()) {
+  const ranked = [];
+  for (const [name, entries] of Object.entries(interfaces)) {
     for (const entry of entries ?? []) {
-      if (entry.family === "IPv4" && !entry.internal) return entry.address;
+      // `family` is "IPv4" on modern Node and 4 on older builds.
+      if (entry.family !== "IPv4" && entry.family !== 4) continue;
+      if (entry.internal) continue;
+      // A zero address score is a hard no: a friendly adapter name cannot make a
+      // link-local or loopback address routable.
+      const score = addressScore(entry.address) + adapterScore(name);
+      if (addressScore(entry.address) === 0 || score <= 0) continue;
+      ranked.push({ name, address: entry.address, score });
     }
   }
-  return "127.0.0.1";
+  // A stable sort keeps the OS order for equally scored adapters.
+  return ranked.sort((left, right) => right.score - left.score);
+}
+
+function firstLanAddress(interfaces) {
+  return rankLanAddresses(interfaces)[0]?.address ?? "127.0.0.1";
 }
 
 function parseProjects(raw, workspace) {
@@ -98,6 +166,10 @@ export function loadConfig(env = process.env, workspace = process.cwd()) {
     pairingTtlMs: Number.parseInt(env.AGENTBRIDGE_PAIRING_TTL_MS ?? "300000", 10),
     sessionTtlMs: Number.parseInt(env.AGENTBRIDGE_SESSION_TTL_MS ?? "259200000", 10),
     machineName: env.AGENTBRIDGE_MACHINE_NAME ?? os.hostname(),
+    // Set by the DSH plugin when it spawns the bridge itself. It lets the plugin
+    // recognise its own child in /api/health and restart it to change the public
+    // address, without ever touching a bridge the user started by hand.
+    autostart: env.AGENTBRIDGE_AUTOSTART === "1",
     // Outbound notifications: unset webhook means the feature is simply off.
     notifyWebhook: pick(env, "AGENTBRIDGE_NOTIFY_WEBHOOK", notifyFile.webhook),
     notifyFormat: pick(env, "AGENTBRIDGE_NOTIFY_FORMAT", notifyFile.format ?? "json").toLowerCase(),
@@ -105,8 +177,8 @@ export function loadConfig(env = process.env, workspace = process.cwd()) {
     // PushPlus-style services need the token inside the request body.
     notifyToken: pick(env, "AGENTBRIDGE_NOTIFY_TOKEN", notifyFile.token),
     // Some providers (PushPlus) also take a delivery channel, e.g. `clawbot`.
-    notifyChannel: pick(env, "AGENTBRIDGE_NOTIFY_CHANNEL", notifyFile.channel),
-    // Per-bridge mute, toggled from the phone; persisted so it survives a restart.
+    notifyChannel: pick(env, "AGENTBRIDGE_NOTIFY_CHANNEL", notifyFile.channel),
+    // Per-bridge mute, toggled from the phone; persisted so it survives a restart.
     notifyMuted: notifyFile.muted === true,
     // Opt-in: putting the access key into a third-party chat is a real disclosure,
     // so the notification link stays keyless unless the operator asks for it.

package/src/server.js

@@ -390,7 +390,17 @@ export async function createBridge(options = {}) {
     const url = new URL(req.url, `http://${req.headers.host ?? "localhost"}`);
     try {
       if (req.method === "GET" && url.pathname === "/api/health") {
-        return json(res, shuttingDown ? 503 : 200, { ok: !shuttingDown, shuttingDown, lastSeq: eventStore.lastSeq });
+        // The advertised origin is public information (it is printed inside every
+        // QR code), and exposing it here is what lets the DSH plugin notice that a
+        // running bridge still advertises a stale address.
+        return json(res, shuttingDown ? 503 : 200, {
+          ok: !shuttingDown,
+          shuttingDown,
+          lastSeq: eventStore.lastSeq,
+          advertisedOrigin: config.advertisedOrigin,
+          accessKeyRequired: Boolean(config.accessKey),
+          autostart: config.autostart === true,
+        });
       }
 
       if (shuttingDown) throw Object.assign(new Error("AgentBridge is shutting down"), { statusCode: 503, code: "BRIDGE_SHUTTING_DOWN" });
@@ -946,6 +956,13 @@ export async function startBridge() {
   });
   console.log(`AgentBridge running at http://127.0.0.1:${bridge.config.port}`);
   console.log(`WeChat scan target: ${bridge.getCurrentPairing().url}`);
+  // Silence here used to mean a QR encoding an address the phone could never reach.
+  if (new URL(bridge.config.advertisedOrigin).hostname === "127.0.0.1") {
+    console.warn(
+      "No routable LAN address found, so the QR code points at loopback and a phone cannot open it. "
+      + "Connect the machine to Wi-Fi/Ethernet, or set AGENTBRIDGE_PUBLIC_ORIGIN to the address the phone should use.",
+    );
+  }
   return bridge;
 }