squad-openclaw 2026.3.1301 → 2026.3.1401

package/dist/index.js

@@ -140,21 +140,26 @@ function updatePlugin(pluginDirName, configDir) {
     registryDelete(`plugin:${pluginDirName}`);
   }
 }
-function startWatcher(configDir, onFsChange) {
-  const watcher = chokidar.watch(configDir, {
+function startWatcher(configDir, onFsChange, options = {}) {
+  const watcherOptions = {
     persistent: true,
     usePolling: false,
     ignoreInitial: true,
     awaitWriteFinish: { stabilityThreshold: 300 },
     depth: 4,
-    ignored: [
-      // Ignore heavy directories that aren't relevant
-      "**/node_modules/**",
-      "**/dist/**",
-      "**/.git/**",
-      "**/data/**"
-    ]
+    ignored: ["**/node_modules/**", "**/dist/**", "**/.git/**", "**/data/**"]
+  };
+  const generalWatcher = chokidar.watch(configDir, {
+    ...watcherOptions,
+    ignored: [...watcherOptions.ignored, "**/extensions/**"]
   });
+  const pluginManifestWatcher = chokidar.watch(
+    path.join(configDir, "extensions", "*", "openclaw.plugin.json"),
+    watcherOptions
+  );
+  const watchers = [generalWatcher, pluginManifestWatcher];
+  let stopped = false;
+  let fatalErrorReported = false;
   const emitFsChange = (action, filePath) => {
     if (!onFsChange) return;
     const rel = path.relative(configDir, filePath);
@@ -237,12 +242,31 @@ function startWatcher(configDir, onFsChange) {
       return;
     }
   };
-  watcher.on("add", (fp) => handleChange(fp, "add"));
-  watcher.on("change", (fp) => handleChange(fp, "change"));
-  watcher.on("unlink", (fp) => handleChange(fp, "unlink"));
-  watcher.on("addDir", handleAddDir);
-  watcher.on("unlinkDir", handleUnlinkDir);
-  return () => {
+  const onWatcherError = (error) => {
+    const normalized = error instanceof Error ? error : new Error(String(error));
+    console.error(`[squad-openclaw] watcher error: ${normalized.message}`);
+    stop();
+    try {
+      if (!fatalErrorReported) {
+        fatalErrorReported = true;
+        options.onFatalError?.(normalized);
+      }
+    } catch (callbackError) {
+      const callbackMessage = callbackError instanceof Error ? callbackError.message : String(callbackError);
+      console.warn(`[squad-openclaw] watcher fatal-error callback failed: ${callbackMessage}`);
+    }
+  };
+  for (const watcher of watchers) {
+    watcher.on("add", (fp) => handleChange(fp, "add"));
+    watcher.on("change", (fp) => handleChange(fp, "change"));
+    watcher.on("unlink", (fp) => handleChange(fp, "unlink"));
+    watcher.on("addDir", handleAddDir);
+    watcher.on("unlinkDir", handleUnlinkDir);
+    watcher.on("error", onWatcherError);
+  }
+  const stop = () => {
+    if (stopped) return;
+    stopped = true;
     for (const timer of debounceTimers.values()) {
       clearTimeout(timer);
     }
@@ -251,8 +275,11 @@ function startWatcher(configDir, onFsChange) {
       clearTimeout(timer);
     }
     fsDebounceTimers.clear();
-    watcher.close();
+    for (const watcher of watchers) {
+      void watcher.close();
+    }
   };
+  return stop;
 }
 
 // src/filesystem.ts
@@ -779,6 +806,110 @@ function registryList(type) {
   if (!type) return all;
   return all.filter((e) => e.type === type);
 }
+var DEFAULT_MEDIA_SCAN_MAX_ENTRIES = 5e3;
+var DEFAULT_MEDIA_SCAN_MAX_DEPTH = 6;
+var DEFAULT_MEDIA_SCAN_MAX_DURATION_MS = 2500;
+var ENTITY_RUNTIME_STATE_KEY = "__squadOpenclawEntityRuntimeState_v1";
+function readPositiveIntEnv(envName, fallback, min, max) {
+  const raw = process.env[envName];
+  if (!raw) return fallback;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed)) return fallback;
+  const rounded = Math.floor(parsed);
+  if (rounded < min) return min;
+  if (rounded > max) return max;
+  return rounded;
+}
+function readMediaScanLimits() {
+  return {
+    maxEntries: readPositiveIntEnv(
+      "SQUAD_MEDIA_SCAN_MAX_ENTRIES",
+      DEFAULT_MEDIA_SCAN_MAX_ENTRIES,
+      1,
+      1e6
+    ),
+    maxDepth: readPositiveIntEnv(
+      "SQUAD_MEDIA_SCAN_MAX_DEPTH",
+      DEFAULT_MEDIA_SCAN_MAX_DEPTH,
+      1,
+      64
+    ),
+    maxDurationMs: readPositiveIntEnv(
+      "SQUAD_MEDIA_SCAN_MAX_DURATION_MS",
+      DEFAULT_MEDIA_SCAN_MAX_DURATION_MS,
+      200,
+      6e5
+    )
+  };
+}
+function getEntityRuntimeState() {
+  const globalState = globalThis;
+  if (!globalState[ENTITY_RUNTIME_STATE_KEY]) {
+    globalState[ENTITY_RUNTIME_STATE_KEY] = {
+      stopWatcher: null,
+      watcherConfigDir: null,
+      processSignalCleanup: null,
+      shutdownHookApis: /* @__PURE__ */ new WeakSet()
+    };
+  }
+  return globalState[ENTITY_RUNTIME_STATE_KEY];
+}
+function stopEntityWatcher() {
+  const runtime = getEntityRuntimeState();
+  if (!runtime.stopWatcher) return;
+  try {
+    runtime.stopWatcher();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`[squad-openclaw] watcher stop failed: ${message}`);
+  } finally {
+    runtime.stopWatcher = null;
+    runtime.watcherConfigDir = null;
+  }
+}
+function ensureProcessSignalHandlers() {
+  const runtime = getEntityRuntimeState();
+  runtime.processSignalCleanup?.();
+  const onProcessSignal = () => {
+    stopEntityWatcher();
+  };
+  process.on("SIGTERM", onProcessSignal);
+  process.on("SIGINT", onProcessSignal);
+  runtime.processSignalCleanup = () => {
+    process.off("SIGTERM", onProcessSignal);
+    process.off("SIGINT", onProcessSignal);
+  };
+}
+function registerShutdownHook(api) {
+  if (!api || typeof api !== "object") return;
+  const runtime = getEntityRuntimeState();
+  if (runtime.shutdownHookApis.has(api)) return;
+  const maybeApi = api;
+  if (typeof maybeApi.onShutdown !== "function") return;
+  maybeApi.onShutdown(() => {
+    stopEntityWatcher();
+  });
+  runtime.shutdownHookApis.add(api);
+}
+function startOrRestartWatcher(configDir, onFsChange, onWatcherError) {
+  const runtime = getEntityRuntimeState();
+  stopEntityWatcher();
+  runtime.stopWatcher = startWatcher(configDir, onFsChange, {
+    onFatalError: (error) => {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`[squad-openclaw] file watcher stopped after fatal error: ${message}`);
+      runtime.stopWatcher = null;
+      runtime.watcherConfigDir = null;
+      try {
+        onWatcherError?.(error);
+      } catch (callbackError) {
+        const callbackMessage = callbackError instanceof Error ? callbackError.message : String(callbackError);
+        console.warn(`[squad-openclaw] watcher error callback failed: ${callbackMessage}`);
+      }
+    }
+  });
+  runtime.watcherConfigDir = configDir;
+}
 var IDENTITY_NAME_RE = /\*\*Name:\*\*\s*\n?\s*(.+?)(?=\n|$)/;
 function parseIdentityName(content) {
   const match = content.match(IDENTITY_NAME_RE);
@@ -990,9 +1121,48 @@ function getMimeType(filename) {
 function scanMedia(configDir) {
   const now = Date.now();
   const mediaDir = path5.join(configDir, "media");
-  scanMediaDir(mediaDir, now);
+  const limits = readMediaScanLimits();
+  const budget = {
+    visitedEntries: 0,
+    maxEntries: limits.maxEntries,
+    maxDepth: limits.maxDepth,
+    deadlineMs: Date.now() + limits.maxDurationMs,
+    truncatedByEntries: false,
+    truncatedByDepth: false,
+    truncatedByTimeout: false
+  };
+  scanMediaDir(mediaDir, now, 0, budget);
+  if (budget.truncatedByEntries || budget.truncatedByDepth || budget.truncatedByTimeout) {
+    const reasons = [];
+    if (budget.truncatedByEntries) reasons.push(`max entries (${budget.maxEntries})`);
+    if (budget.truncatedByDepth) reasons.push(`max depth (${budget.maxDepth})`);
+    if (budget.truncatedByTimeout) reasons.push(`time budget (${limits.maxDurationMs}ms)`);
+    console.warn(
+      `[squad-openclaw] media scan truncated after ${budget.visitedEntries} entries: ${reasons.join(", ")}. Tune SQUAD_MEDIA_SCAN_MAX_ENTRIES/SQUAD_MEDIA_SCAN_MAX_DEPTH/SQUAD_MEDIA_SCAN_MAX_DURATION_MS if needed.`
+    );
+  }
+}
+function shouldStopMediaScan(budget) {
+  if (Date.now() > budget.deadlineMs) {
+    budget.truncatedByTimeout = true;
+    return true;
+  }
+  return false;
+}
+function claimMediaEntry(budget) {
+  if (budget.visitedEntries >= budget.maxEntries) {
+    budget.truncatedByEntries = true;
+    return false;
+  }
+  budget.visitedEntries += 1;
+  return true;
 }
-function scanMediaDir(dirPath, now) {
+function scanMediaDir(dirPath, now, depth, budget) {
+  if (shouldStopMediaScan(budget)) return;
+  if (depth > budget.maxDepth) {
+    budget.truncatedByDepth = true;
+    return;
+  }
   let entries;
   try {
     entries = fs5.readdirSync(dirPath, { withFileTypes: true });
@@ -1000,10 +1170,12 @@ function scanMediaDir(dirPath, now) {
     return;
   }
   for (const entry of entries) {
+    if (shouldStopMediaScan(budget)) return;
     if (entry.name.startsWith(".")) continue;
     const entryPath = path5.join(dirPath, entry.name);
     if (isSensitivePath(entryPath)) continue;
     if (entry.isDirectory()) {
+      if (!claimMediaEntry(budget)) return;
       registrySet({
         id: entryPath,
         type: "directory",
@@ -1016,8 +1188,13 @@ function scanMediaDir(dirPath, now) {
         created_at: now,
         updated_at: now
       });
-      scanMediaDir(entryPath, now);
+      if (depth >= budget.maxDepth) {
+        budget.truncatedByDepth = true;
+        continue;
+      }
+      scanMediaDir(entryPath, now, depth + 1, budget);
     } else if (entry.isFile()) {
+      if (!claimMediaEntry(budget)) return;
       const mimeType = getMimeType(entry.name);
       let size;
       let mtime = now;
@@ -1050,7 +1227,7 @@ function fullScan(configDir) {
   scanTools(configDir);
   scanMedia(configDir);
 }
-function registerEntityTools(api, onFsChange) {
+function registerEntityTools(api, onFsChange, options = {}) {
   const configDir = getOpenclawStateDir();
   api.registerTool({
     name: "entity_list",
@@ -1119,22 +1296,19 @@ function registerEntityTools(api, onFsChange) {
       };
     }
   });
+  stopEntityWatcher();
   try {
     fullScan(configDir);
   } catch (err2) {
     console.error("[squad-openclaw] Initial scan failed:", err2);
   }
-  let stopWatcher = null;
   try {
-    stopWatcher = startWatcher(configDir, onFsChange);
+    startOrRestartWatcher(configDir, onFsChange, options.onWatcherError);
   } catch (err2) {
     console.error("[squad-openclaw] Watcher failed to start:", err2);
   }
-  const cleanup = () => {
-    stopWatcher?.();
-  };
-  process.on("SIGTERM", cleanup);
-  process.on("SIGINT", cleanup);
+  ensureProcessSignalHandlers();
+  registerShutdownHook(api);
 }
 
 // src/version.ts
@@ -2390,7 +2564,23 @@ function registerSquadSharedApi(api, onFsChange) {
       console.warn(`[squad-openclaw] ${label} registration failed: ${errorMessage(err2)}`);
     }
   };
-  registerStep("entity tools", () => registerEntityTools(api, onFsChange));
+  const handleEntityWatcherError = (error) => {
+    const snapshot = recordPluginFailure(
+      "WATCHER_FATAL_ERROR",
+      errorMessage(error),
+      "Check inotify/file descriptor limits and run squad.plugin.recover after the host is stable."
+    );
+    console.error(`[squad-openclaw] entity watcher fatal error: ${errorMessage(error)}`);
+    if (isPluginExecutionBlocked(snapshot)) {
+      console.warn(
+        `[squad-openclaw] plugin moved to ${snapshot.state} after watcher failure (${snapshot.reasonCode ?? "NO_REASON"})`
+      );
+    }
+  };
+  registerStep(
+    "entity tools",
+    () => registerEntityTools(api, onFsChange, { onWatcherError: handleEntityWatcherError })
+  );
   registerStep("filesystem tools", () => registerFilesystemTools(api));
   registerStep("version methods", () => registerVersionMethods(api));
   registerStep("question methods", () => registerQuestionMethods(api));
@@ -2866,7 +3056,79 @@ async function runStartupMigrations(api) {
 }
 
 // src/http-routes.ts
+import crypto5 from "crypto";
+import fs15 from "fs";
+import path15 from "path";
+import { WebSocket as NodeWebSocket2 } from "ws";
+
+// src/relay-client.ts
+import { WebSocket as NodeWebSocket } from "ws";
+import crypto4 from "crypto";
+import fs14 from "fs";
+import path14 from "path";
+
+// src/e2e-crypto.ts
 import crypto2 from "crypto";
+
+// src/device-keys.ts
+import crypto3 from "crypto";
+import fs13 from "fs";
+import path13 from "path";
+var RELAY_DATA_DIR = path13.join(getOpenclawStateDir(), "squad-ceo-data", "relay");
+var RELAY_STATE_PATH = path13.join(RELAY_DATA_DIR, "squad-relay.json");
+var PENDING_APPROVAL_PATH = path13.join(RELAY_DATA_DIR, "pending-approval.json");
+function toBase64Url(buf) {
+  return buf.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+
+// src/relay-client.ts
+function readOperatorToken() {
+  const stateDir = getOpenclawStateDir();
+  const configPath = path14.join(stateDir, "openclaw.json");
+  try {
+    const raw = fs14.readFileSync(configPath, "utf-8");
+    const config = JSON.parse(raw);
+    return config?.gateway?.auth?.token ?? config?.gateway?.remote?.token ?? config?.gateway?.token ?? null;
+  } catch {
+    return null;
+  }
+}
+function readGatewayLocalWsConfig() {
+  const defaults = {
+    port: 18789,
+    // Try IPv4, hostname, then IPv6 loopback.
+    hosts: ["127.0.0.1", "localhost", "[::1]"]
+  };
+  const stateDir = getOpenclawStateDir();
+  const configPath = path14.join(stateDir, "openclaw.json");
+  try {
+    const raw = fs14.readFileSync(configPath, "utf-8");
+    const config = JSON.parse(raw);
+    const parsedPort = Number(config?.gateway?.port);
+    if (Number.isFinite(parsedPort) && parsedPort > 0) {
+      defaults.port = parsedPort;
+    }
+  } catch {
+  }
+  return defaults;
+}
+function signDeviceIdentity(keys, clientId, clientMode, role, scopes, token, challengeNonce) {
+  const signedAtMs = Date.now();
+  const nonce = challengeNonce || crypto4.randomBytes(16).toString("hex");
+  const scopeStr = scopes.join(",");
+  const payload = `v2|${keys.deviceId}|${clientId}|${clientMode}|${role}|${scopeStr}|${signedAtMs}|${token ?? ""}|${nonce}`;
+  const privateKey = crypto4.createPrivateKey(keys.privateKeyPem);
+  const signature = crypto4.sign(null, Buffer.from(payload), privateKey);
+  return {
+    id: keys.deviceId,
+    publicKey: keys.publicKey,
+    signature: toBase64Url(signature),
+    signedAt: signedAtMs,
+    nonce
+  };
+}
+
+// src/http-routes.ts
 var DEFAULT_ALLOWED_ORIGINS = [
   "https://squad.ceo",
   "https://www.squad.ceo",
@@ -2888,9 +3150,13 @@ var PAIRING_STATUS_METHODS = [
 var PROOF_MAX_SKEW_MS = 5 * 60 * 1e3;
 var DEFAULT_PAIRING_TTL_MS = 15 * 60 * 1e3;
 var NONCE_TTL_MS = 10 * 60 * 1e3;
+var BROWSER_SESSION_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
+var BROWSER_SESSION_COOKIE_NAME = "squad_browser_session";
 var ED25519_SPKI_PREFIX = Buffer.from("302a300506032b6570032100", "hex");
 var INTERNAL_ROUTE_TIMEOUT_MS = readTimeoutMs("SQUAD_INTERNAL_ROUTE_TIMEOUT_MS", 1e4);
 var PAIRING_GATEWAY_CALL_TIMEOUT_MS = readTimeoutMs("SQUAD_PAIRING_GATEWAY_CALL_TIMEOUT_MS", 4e3);
+var BROWSER_SESSION_DIR = path15.join(getOpenclawStateDir(), "squad-ceo-data", "browser-sessions");
+var BROWSER_SESSION_STORE_PATH = path15.join(BROWSER_SESSION_DIR, "sessions.json");
 function errorMessage2(error) {
   return error instanceof Error ? error.message : String(error);
 }
@@ -2922,6 +3188,7 @@ function withCors(request, response, allowMethods = "GET, POST, OPTIONS") {
   const allowedOrigin = resolveAllowedOrigin(origin);
   if (allowedOrigin) {
     headers.set("Access-Control-Allow-Origin", allowedOrigin);
+    headers.set("Access-Control-Allow-Credentials", "true");
     headers.set("Access-Control-Allow-Methods", allowMethods);
     headers.set("Access-Control-Allow-Headers", "Content-Type");
     headers.set("Vary", "Origin");
@@ -2937,8 +3204,16 @@ function jsonError(request, code, message, status = 500, extra = {}) {
 }
 function resolveAllowedOrigin(origin) {
   if (!origin) return null;
+  try {
+    const url = new URL(origin);
+    const hostname = url.hostname.toLowerCase();
+    if (url.protocol === "http:" && (hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname === "[::1]")) {
+      return origin;
+    }
+  } catch {
+  }
   const configured = process.env.SQUAD_ALLOWED_ORIGINS ? process.env.SQUAD_ALLOWED_ORIGINS.split(",").map((item) => item.trim()).filter(Boolean) : [];
-  const allowed = configured.length > 0 ? configured : DEFAULT_ALLOWED_ORIGINS;
+  const allowed = [.../* @__PURE__ */ new Set([...DEFAULT_ALLOWED_ORIGINS, ...configured])];
   return allowed.includes(origin) ? origin : null;
 }
 function isTailnetContext(request) {
@@ -2970,6 +3245,71 @@ function firstHeaderToken(value) {
   const first = value.split(",")[0]?.trim();
   return first ? first : null;
 }
+function parseCookieHeader(cookieHeader) {
+  const cookies = /* @__PURE__ */ new Map();
+  if (!cookieHeader) return cookies;
+  for (const segment of cookieHeader.split(";")) {
+    const trimmed = segment.trim();
+    if (!trimmed) continue;
+    const separator = trimmed.indexOf("=");
+    if (separator <= 0) continue;
+    const name = trimmed.slice(0, separator).trim();
+    const value = trimmed.slice(separator + 1).trim();
+    if (!name) continue;
+    try {
+      cookies.set(name, decodeURIComponent(value));
+    } catch {
+      cookies.set(name, value);
+    }
+  }
+  return cookies;
+}
+function isSecureRequest(request) {
+  const protocol = firstHeaderToken(request.headers.get("x-forwarded-proto"))?.toLowerCase();
+  if (protocol === "https" || protocol === "wss") return true;
+  try {
+    return new URL(request.url).protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+function buildBrowserSessionCookie(request, sessionId) {
+  const secure = isSecureRequest(request);
+  const sameSite = secure ? "SameSite=None" : "SameSite=Lax";
+  const parts = [
+    `${BROWSER_SESSION_COOKIE_NAME}=${encodeURIComponent(sessionId)}`,
+    "Path=/",
+    "HttpOnly",
+    sameSite,
+    `Max-Age=${Math.floor(BROWSER_SESSION_TTL_MS / 1e3)}`
+  ];
+  if (secure) {
+    parts.push("Secure");
+  }
+  return parts.join("; ");
+}
+function browserSessionStoreToObject(store) {
+  return Object.fromEntries(store.entries());
+}
+function loadBrowserSessions() {
+  try {
+    const raw = fs15.readFileSync(BROWSER_SESSION_STORE_PATH, "utf8");
+    const parsed = JSON.parse(raw);
+    const now = Date.now();
+    const entries = Object.entries(parsed).filter(([, record]) => typeof record?.sessionId === "string" && typeof record?.deviceId === "string" && typeof record?.publicKey === "string" && typeof record?.privateKeyPem === "string" && typeof record?.createdAt === "number" && typeof record?.lastSeenAt === "number" && typeof record?.expiresAt === "number" && record.expiresAt > now);
+    return new Map(entries);
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+}
+function persistBrowserSessions(store) {
+  fs15.mkdirSync(BROWSER_SESSION_DIR, { recursive: true });
+  fs15.writeFileSync(
+    BROWSER_SESSION_STORE_PATH,
+    JSON.stringify(browserSessionStoreToObject(store), null, 2),
+    { mode: 384 }
+  );
+}
 function readObjectHeader(request, name) {
   const headers = request.headers;
   if (!headers || typeof headers !== "object") return null;
@@ -2980,6 +3320,29 @@ function readObjectHeader(request, name) {
   if (typeof value === "string") return value;
   return value == null ? null : String(value);
 }
+async function readRequestBodyRecord(request) {
+  const contentType = request.headers.get("content-type")?.toLowerCase() ?? "";
+  if (contentType.includes("application/json")) {
+    return await request.json();
+  }
+  if (contentType.includes("application/x-www-form-urlencoded") || contentType.includes("multipart/form-data")) {
+    const form = await request.formData();
+    const record = {};
+    for (const [key, value] of form.entries()) {
+      const normalized = typeof value === "string" ? value : value.name;
+      const existing = record[key];
+      if (existing === void 0) {
+        record[key] = normalized;
+      } else if (Array.isArray(existing)) {
+        existing.push(normalized);
+      } else {
+        record[key] = [existing, normalized];
+      }
+    }
+    return record;
+  }
+  return {};
+}
 async function toFetchRequest(incoming) {
   if (incoming && typeof incoming.method === "string" && typeof incoming.url === "string" && typeof incoming.headers?.get === "function") {
     return incoming;
@@ -3022,6 +3385,66 @@ async function toFetchRequest(incoming) {
   }
   return new Request(absoluteUrl, { method, headers, body });
 }
+async function readIncomingBody(incoming) {
+  const method = typeof incoming.method === "string" ? incoming.method.toUpperCase() : "GET";
+  if (method === "GET" || method === "HEAD") return void 0;
+  const bodyValue = incoming.body;
+  if (typeof bodyValue === "string") return bodyValue;
+  if (bodyValue instanceof Uint8Array) return Buffer.from(bodyValue).toString("utf8");
+  if (bodyValue instanceof ArrayBuffer) return Buffer.from(bodyValue).toString("utf8");
+  const on = incoming.on;
+  if (typeof on !== "function") return void 0;
+  return await new Promise((resolve, reject) => {
+    const chunks = [];
+    const addChunk = (chunk) => {
+      if (typeof chunk === "string") {
+        chunks.push(Buffer.from(chunk));
+        return;
+      }
+      if (chunk instanceof Uint8Array) {
+        chunks.push(Buffer.from(chunk));
+        return;
+      }
+      if (chunk instanceof ArrayBuffer) {
+        chunks.push(Buffer.from(chunk));
+      }
+    };
+    on.call(incoming, "data", addChunk);
+    on.call(incoming, "end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+    on.call(incoming, "error", (error) => reject(error));
+  });
+}
+async function toRouteRequest(incoming) {
+  if (incoming && typeof incoming.method === "string" && typeof incoming.url === "string" && typeof incoming.headers?.get === "function") {
+    return incoming;
+  }
+  const requestLike = incoming;
+  const body = await readIncomingBody(requestLike);
+  if (body === void 0) {
+    return toFetchRequest(requestLike);
+  }
+  return toFetchRequest({
+    method: typeof requestLike.method === "string" ? requestLike.method : "POST",
+    url: typeof requestLike.url === "string" ? requestLike.url : typeof requestLike.originalUrl === "string" ? requestLike.originalUrl : "/",
+    originalUrl: typeof requestLike.originalUrl === "string" ? requestLike.originalUrl : void 0,
+    headers: requestLike.headers,
+    body
+  });
+}
+async function writeNodeResponse(outgoing, response) {
+  outgoing.statusCode = response.status;
+  const setHeader = typeof outgoing.setHeader === "function" ? outgoing.setHeader.bind(outgoing) : null;
+  if (setHeader) {
+    for (const [key, value] of response.headers.entries()) {
+      setHeader(key, value);
+    }
+  }
+  const body = response.body ? Buffer.from(await response.arrayBuffer()) : Buffer.alloc(0);
+  const end = typeof outgoing.end === "function" ? outgoing.end.bind(outgoing) : null;
+  if (end) {
+    end(body.length > 0 ? body : void 0);
+  }
+}
 function getRequestUrl(request) {
   try {
     return new URL(request.url);
@@ -3051,10 +3474,25 @@ function base64UrlEncode(bytes) {
 function encodeUtf8(value) {
   return new TextEncoder().encode(value);
 }
+function generateBrowserSessionDevice() {
+  const { publicKey, privateKey } = crypto5.generateKeyPairSync("ed25519");
+  const pubDer = publicKey.export({ type: "spki", format: "der" });
+  const rawPub = pubDer.subarray(pubDer.length - 32);
+  return {
+    deviceId: crypto5.createHash("sha256").update(rawPub).digest("hex"),
+    publicKey: base64UrlEncode(rawPub),
+    privateKeyPem: privateKey.export({ type: "pkcs8", format: "pem" })
+  };
+}
+function signBrowserSessionPayload(privateKeyPem, payload) {
+  const privateKey = crypto5.createPrivateKey(privateKeyPem);
+  const signature = crypto5.sign(null, Buffer.from(payload, "utf8"), privateKey);
+  return base64UrlEncode(signature);
+}
 function normalizeDevicePublicKeyBase64Url(publicKey) {
   try {
     if (publicKey.includes("BEGIN")) {
-      const spki = crypto2.createPublicKey(publicKey).export({
+      const spki = crypto5.createPublicKey(publicKey).export({
         type: "spki",
         format: "der"
       });
@@ -3074,7 +3512,7 @@ function deriveDeviceIdFromPublicKey(publicKey) {
     if (!normalized) return null;
     const raw = decodeBase64Url(normalized);
     if (raw.length !== 32) return null;
-    return crypto2.createHash("sha256").update(raw).digest("hex");
+    return crypto5.createHash("sha256").update(raw).digest("hex");
   } catch {
     return null;
   }
@@ -3083,7 +3521,7 @@ function verifyEd25519Signature(publicKey, payload, signatureBase64Url) {
   try {
     const normalized = normalizeDevicePublicKeyBase64Url(publicKey);
     if (!normalized) return false;
-    const key = crypto2.createPublicKey({
+    const key = crypto5.createPublicKey({
       key: Buffer.concat([ED25519_SPKI_PREFIX, decodeBase64Url(normalized)]),
       type: "spki",
       format: "der"
@@ -3095,7 +3533,7 @@ function verifyEd25519Signature(publicKey, payload, signatureBase64Url) {
         return Buffer.from(signatureBase64Url, "base64");
       }
     })();
-    return crypto2.verify(null, Buffer.from(payload, "utf8"), key, signature);
+    return crypto5.verify(null, Buffer.from(payload, "utf8"), key, signature);
   } catch {
     return false;
   }
@@ -3113,11 +3551,24 @@ function canonicalizeP256Jwk(value) {
 }
 function computeDeviceIdFromJwk(jwk) {
   const canonical = JSON.stringify(jwk);
-  return crypto2.createHash("sha256").update(canonical).digest("hex");
+  return crypto5.createHash("sha256").update(canonical).digest("hex");
 }
 function buildProofPayload(action, deviceId, nonce, signedAt, origin) {
   return `squad.${action}|${deviceId}|${nonce}|${signedAt}|${origin}`;
 }
+function buildGatewayConnectPayload(params) {
+  return [
+    "v2",
+    params.deviceId,
+    params.clientId,
+    params.clientMode,
+    params.role,
+    params.scopes.join(","),
+    String(params.signedAtMs),
+    "",
+    params.nonce
+  ].join("|");
+}
 async function verifyBrowserProof(payload, origin, action, usedProofNonces) {
   const deviceId = pickString(payload.deviceId);
   const signature = pickString(payload.signature);
@@ -3194,14 +3645,14 @@ async function verifyBrowserProof(payload, origin, action, usedProofNonces) {
       };
     }
     try {
-      const key = await crypto2.webcrypto.subtle.importKey(
+      const key = await crypto5.webcrypto.subtle.importKey(
         "jwk",
         jwk,
         { name: "ECDSA", namedCurve: "P-256" },
         false,
         ["verify"]
       );
-      verified = await crypto2.webcrypto.subtle.verify(
+      verified = await crypto5.webcrypto.subtle.verify(
         { name: "ECDSA", hash: "SHA-256" },
         key,
         decodeBase64Url(signature),
@@ -3299,8 +3750,50 @@ function registerTailnetInternalRoutes(api) {
   const pendingPairings = /* @__PURE__ */ new Map();
   const proofNonces = /* @__PURE__ */ new Map();
   const rateLimitBucket = /* @__PURE__ */ new Map();
+  const browserSessions = loadBrowserSessions();
   let preferredPairingRequestMethod = null;
   let preferredPairingStatusMethod = null;
+  const persistBrowserSessionsSafe = () => {
+    try {
+      persistBrowserSessions(browserSessions);
+    } catch (error) {
+      console.warn(`[squad-openclaw] failed to persist browser sessions: ${errorMessage2(error)}`);
+    }
+  };
+  const getOrCreateBrowserSession = (request) => {
+    const now = Date.now();
+    const cookies = parseCookieHeader(request.headers.get("cookie"));
+    const sessionId = cookies.get(BROWSER_SESSION_COOKIE_NAME) ?? null;
+    const existing = sessionId ? browserSessions.get(sessionId) ?? null : null;
+    if (existing && existing.expiresAt > now) {
+      const next = {
+        ...existing,
+        lastSeenAt: now,
+        expiresAt: now + BROWSER_SESSION_TTL_MS
+      };
+      browserSessions.set(existing.sessionId, next);
+      persistBrowserSessionsSafe();
+      return {
+        record: next,
+        setCookie: buildBrowserSessionCookie(request, next.sessionId)
+      };
+    }
+    const createdSessionId = crypto5.randomBytes(32).toString("hex");
+    const device = generateBrowserSessionDevice();
+    const created = {
+      sessionId: createdSessionId,
+      ...device,
+      createdAt: now,
+      lastSeenAt: now,
+      expiresAt: now + BROWSER_SESSION_TTL_MS
+    };
+    browserSessions.set(createdSessionId, created);
+    persistBrowserSessionsSafe();
+    return {
+      record: created,
+      setCookie: buildBrowserSessionCookie(request, createdSessionId)
+    };
+  };
   const cleanupCaches = () => {
     const now = Date.now();
     for (const [key, value] of pendingPairings) {
@@ -3312,13 +3805,171 @@ function registerTailnetInternalRoutes(api) {
     for (const [key, bucket] of rateLimitBucket) {
       if (bucket.resetAt <= now) rateLimitBucket.delete(key);
     }
+    let sessionsDirty = false;
+    for (const [key, record] of browserSessions) {
+      if (record.expiresAt <= now) {
+        browserSessions.delete(key);
+        sessionsDirty = true;
+      }
+    }
+    if (sessionsDirty) {
+      persistBrowserSessionsSafe();
+    }
+  };
+  const callGatewayMethodViaLocalWs = async (method, params) => {
+    const { port, hosts } = readGatewayLocalWsConfig();
+    const operatorToken = readOperatorToken();
+    if (!operatorToken) {
+      throw new Error("Gateway auth token missing");
+    }
+    const relayStatePath = path15.join(getOpenclawStateDir(), "squad-ceo-data", "relay", "squad-relay.json");
+    let deviceKeys = loadBrowserSessions().get("__relay_fallback__");
+    if (!deviceKeys) {
+      const relayDevice = (() => {
+        try {
+          const raw = fs15.readFileSync(relayStatePath, "utf8");
+          const parsed = JSON.parse(raw);
+          const keys = parsed.deviceKeys;
+          if (typeof keys?.deviceId === "string" && typeof keys?.publicKey === "string" && typeof keys?.privateKeyPem === "string") {
+            return keys;
+          }
+        } catch {
+        }
+        return generateBrowserSessionDevice();
+      })();
+      deviceKeys = {
+        sessionId: "__relay_fallback__",
+        deviceId: relayDevice.deviceId,
+        publicKey: relayDevice.publicKey,
+        privateKeyPem: relayDevice.privateKeyPem,
+        createdAt: Date.now(),
+        lastSeenAt: Date.now(),
+        expiresAt: Date.now() + BROWSER_SESSION_TTL_MS
+      };
+      browserSessions.set(deviceKeys.sessionId, deviceKeys);
+    }
+    let lastError = null;
+    for (const host of hosts) {
+      try {
+        const result = await new Promise((resolve, reject) => {
+          const ws = new NodeWebSocket2(`ws://${host}:${port}`);
+          const connectId = `connect-${crypto5.randomUUID()}`;
+          const requestId = `request-${crypto5.randomUUID()}`;
+          const scopes = ["operator.admin", "operator.read", "operator.write"];
+          let settled = false;
+          const finish = (fn) => {
+            if (settled) return;
+            settled = true;
+            clearTimeout(timer);
+            fn();
+          };
+          const timer = setTimeout(() => {
+            finish(() => {
+              try {
+                ws.close();
+              } catch {
+              }
+              reject(new Error(`gateway local call timed out for ${method}`));
+            });
+          }, PAIRING_GATEWAY_CALL_TIMEOUT_MS);
+          ws.on("message", (data) => {
+            let msg;
+            try {
+              msg = JSON.parse(data.toString());
+            } catch {
+              return;
+            }
+            if (msg.type === "event" && msg.event === "connect.challenge") {
+              const payload = asRecord4(msg.payload);
+              const nonce = pickString(payload?.nonce);
+              const connectMsg = {
+                type: "req",
+                id: connectId,
+                method: "connect",
+                params: {
+                  minProtocol: 3,
+                  maxProtocol: 3,
+                  client: {
+                    id: "cli",
+                    version: "0.1.0",
+                    platform: "plugin",
+                    mode: "gateway"
+                  },
+                  role: "operator",
+                  scopes,
+                  auth: { token: operatorToken },
+                  device: signDeviceIdentity(
+                    {
+                      deviceId: deviceKeys.deviceId,
+                      publicKey: deviceKeys.publicKey,
+                      privateKeyPem: deviceKeys.privateKeyPem
+                    },
+                    "cli",
+                    "gateway",
+                    "operator",
+                    scopes,
+                    operatorToken,
+                    nonce
+                  )
+                }
+              };
+              ws.send(JSON.stringify(connectMsg));
+              return;
+            }
+            if (msg.type === "res" && msg.id === connectId) {
+              if (msg.ok) {
+                ws.send(JSON.stringify({ type: "req", id: requestId, method, params }));
+              } else {
+                const errorPayload = asRecord4(msg.error);
+                const message = pickString(errorPayload?.message) ?? pickString(errorPayload?.error) ?? pickString(msg.error) ?? "Gateway connect rejected";
+                finish(() => reject(new Error(message)));
+              }
+              return;
+            }
+            if (msg.type === "res" && msg.id === requestId) {
+              if (msg.ok) {
+                finish(() => {
+                  try {
+                    ws.close();
+                  } catch {
+                  }
+                  resolve(msg.payload);
+                });
+              } else {
+                const errorPayload = asRecord4(msg.error);
+                const message = pickString(errorPayload?.message) ?? pickString(errorPayload?.error) ?? pickString(msg.error) ?? "Gateway request failed";
+                finish(() => reject(new Error(message)));
+              }
+            }
+          });
+          ws.on("error", (error) => {
+            finish(() => reject(error));
+          });
+          ws.on("close", (code, reason) => {
+            if (settled) return;
+            finish(() => reject(new Error(`gateway closed (${code}): ${reason.toString()}`)));
+          });
+        });
+        return result;
+      } catch (error) {
+        lastError = error;
+      }
+    }
+    throw lastError instanceof Error ? lastError : new Error(errorMessage2(lastError));
   };
   const callGatewayMethod = async (method, params) => {
-    return withTimeout(
-      callGatewayAny({}, api, method, params),
-      PAIRING_GATEWAY_CALL_TIMEOUT_MS,
-      `pairing gateway call ${method}`
-    );
+    try {
+      return await withTimeout(
+        callGatewayAny({}, api, method, params),
+        PAIRING_GATEWAY_CALL_TIMEOUT_MS,
+        `pairing gateway call ${method}`
+      );
+    } catch (error) {
+      if (error instanceof Error && error.message === "Gateway method invocation API unavailable in plugin context") {
+        return callGatewayMethodViaLocalWs(method, params);
+      }
+      throw error;
+    }
   };
   const requestPairingFromGateway = async () => {
     const methods = preferredPairingRequestMethod ? [preferredPairingRequestMethod, ...PAIRING_REQUEST_METHODS.filter((m) => m !== preferredPairingRequestMethod)] : [...PAIRING_REQUEST_METHODS];
@@ -3348,6 +3999,45 @@ function registerTailnetInternalRoutes(api) {
       details ? `PAIRING_REQUEST_UNAVAILABLE: ${details}` : "PAIRING_REQUEST_UNAVAILABLE: No pairing request method supported"
     );
   };
+  const issuePairingRequestResponse = async (request, deviceId, setCookie = null) => {
+    const forwardedFor = request.headers.get("x-forwarded-for") ?? "unknown";
+    const ipKey = `ip:${forwardedFor}`;
+    const deviceKey = `device:${deviceId}`;
+    if (isRateLimited(rateLimitBucket, ipKey, 20, 6e4) || isRateLimited(rateLimitBucket, deviceKey, 8, 6e4)) {
+      return jsonError(request, "RATE_LIMITED", "Too many pairing requests", 429);
+    }
+    try {
+      const pairing = await requestPairingFromGateway();
+      pendingPairings.set(pairing.requestId, {
+        requestId: pairing.requestId,
+        deviceId,
+        createdAt: Date.now(),
+        expiresAt: pairing.expiresAt
+      });
+      const response = withCors(
+        request,
+        json({
+          ok: true,
+          requestId: pairing.requestId,
+          approveCommand: `openclaw devices approve ${pairing.requestId}`,
+          expiresAt: pairing.expiresAt
+        })
+      );
+      if (setCookie) {
+        response.headers.append("Set-Cookie", setCookie);
+      }
+      return response;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return jsonError(
+        request,
+        "PAIRING_REQUEST_UNAVAILABLE",
+        message.replace(/^PAIRING_REQUEST_UNAVAILABLE:\s*/i, ""),
+        501,
+        { nextStep: "openclaw devices list --json" }
+      );
+    }
+  };
   const readPairingStatusFromGateway = async (requestId) => {
     const methods = preferredPairingStatusMethod ? [preferredPairingStatusMethod, ...PAIRING_STATUS_METHODS.filter((m) => m !== preferredPairingStatusMethod)] : [...PAIRING_STATUS_METHODS];
     for (const method of methods) {
@@ -3365,10 +4055,10 @@ function registerTailnetInternalRoutes(api) {
   };
   const handleRequest = async (request) => {
     const url = getRequestUrl(request);
-    const path13 = url.pathname;
+    const path16 = url.pathname;
     cleanupCaches();
     let pluginState = getPluginSafetySnapshot();
-    if (request.method === "OPTIONS" && path13.startsWith("/squad-internal/")) {
+    if (request.method === "OPTIONS" && path16.startsWith("/squad-internal/")) {
       const origin = ensureOriginAllowed(request);
       if (!origin) {
         return new Response(null, { status: 403 });
@@ -3386,7 +4076,7 @@ function registerTailnetInternalRoutes(api) {
         })
       );
     }
-    if (request.method === "GET" && path13 === "/squad-internal/health") {
+    if (request.method === "GET" && path16 === "/squad-internal/health") {
       if (!isTailnetContext(request)) {
         return jsonError(request, "TAILNET_REQUIRED", "Tailnet context required", 403);
       }
@@ -3403,7 +4093,7 @@ function registerTailnetInternalRoutes(api) {
         })
       );
     }
-    if (request.method === "GET" && path13 === "/squad-internal/plugin/status") {
+    if (request.method === "GET" && path16 === "/squad-internal/plugin/status") {
       if (!isTailnetContext(request)) {
         return jsonError(request, "TAILNET_REQUIRED", "Tailnet context required", 403);
       }
@@ -3418,7 +4108,7 @@ function registerTailnetInternalRoutes(api) {
         })
       );
     }
-    if (request.method === "POST" && path13 === "/squad-internal/plugin/recover") {
+    if (request.method === "POST" && path16 === "/squad-internal/plugin/recover") {
       if (!isTailnetContext(request)) {
         return jsonError(request, "TAILNET_REQUIRED", "Tailnet context required", 403);
       }
@@ -3451,7 +4141,7 @@ function registerTailnetInternalRoutes(api) {
       pluginState = result.snapshot;
       return withCors(request, json({ ok: true, plugin: pluginState, message: result.message }));
     }
-    if (request.method === "POST" && path13 === "/squad-internal/plugin/disable") {
+    if (request.method === "POST" && path16 === "/squad-internal/plugin/disable") {
       if (!isTailnetContext(request)) {
         return jsonError(request, "TAILNET_REQUIRED", "Tailnet context required", 403);
       }
@@ -3477,7 +4167,7 @@ function registerTailnetInternalRoutes(api) {
       pluginState = setPluginManualDisabled(reasonCode, reasonMessage, remediation);
       return withCors(request, json({ ok: true, plugin: pluginState }));
     }
-    if (path13.startsWith("/squad-internal/") && isPluginExecutionBlocked(pluginState)) {
+    if (path16.startsWith("/squad-internal/") && isPluginExecutionBlocked(pluginState)) {
       const code = pluginBlockedCode(pluginState);
       return jsonError(
         request,
@@ -3487,7 +4177,75 @@ function registerTailnetInternalRoutes(api) {
         { plugin: pluginState }
       );
     }
-    if (request.method === "POST" && path13 === "/squad-internal/pairing/request") {
+    if (request.method === "POST" && path16 === "/squad-internal/browser-session/connect-proof") {
+      const origin = ensureOriginAllowed(request);
+      if (!origin) {
+        return jsonError(request, "ORIGIN_NOT_ALLOWED", "Origin is not allowed", 403);
+      }
+      if (!isTailnetContext(request)) {
+        return jsonError(request, "TAILNET_REQUIRED", "Tailnet context required", 403);
+      }
+      const forwardedFor = request.headers.get("x-forwarded-for") ?? "unknown";
+      if (isRateLimited(rateLimitBucket, `connect-proof:${forwardedFor}`, 120, 6e4)) {
+        return jsonError(request, "RATE_LIMITED", "Too many connect proof requests", 429);
+      }
+      let body;
+      try {
+        body = await readRequestBodyRecord(request);
+      } catch {
+        return jsonError(request, "INVALID_REQUEST", "Invalid request body", 400);
+      }
+      const nonce = pickString(body.nonce);
+      const clientId = pickString(body.clientId) ?? "cli";
+      const clientMode = pickString(body.clientMode) ?? "ui";
+      const role = pickString(body.role) ?? "operator";
+      const scopesRaw = Array.isArray(body.scopes) ? body.scopes : typeof body.scopes === "string" ? [body.scopes] : [];
+      const scopes = scopesRaw.filter((value) => typeof value === "string" && value.trim().length > 0);
+      if (!nonce) {
+        return jsonError(request, "INVALID_REQUEST", "nonce is required", 400);
+      }
+      const session = getOrCreateBrowserSession(request);
+      const signedAt = Date.now();
+      const payload = buildGatewayConnectPayload({
+        deviceId: session.record.deviceId,
+        clientId,
+        clientMode,
+        role,
+        scopes,
+        signedAtMs: signedAt,
+        nonce
+      });
+      const signature = signBrowserSessionPayload(session.record.privateKeyPem, payload);
+      const response = withCors(
+        request,
+        json({
+          ok: true,
+          device: {
+            id: session.record.deviceId,
+            publicKey: session.record.publicKey,
+            signature,
+            nonce,
+            signedAt
+          }
+        })
+      );
+      if (session.setCookie) {
+        response.headers.append("Set-Cookie", session.setCookie);
+      }
+      return response;
+    }
+    if (request.method === "POST" && path16 === "/squad-internal/browser-session/pairing/request") {
+      const origin = ensureOriginAllowed(request);
+      if (!origin) {
+        return jsonError(request, "ORIGIN_NOT_ALLOWED", "Origin is not allowed", 403);
+      }
+      if (!isTailnetContext(request)) {
+        return jsonError(request, "TAILNET_REQUIRED", "Tailnet context required", 403);
+      }
+      const session = getOrCreateBrowserSession(request);
+      return issuePairingRequestResponse(request, session.record.deviceId, session.setCookie);
+    }
+    if (request.method === "POST" && path16 === "/squad-internal/pairing/request") {
       const origin = ensureOriginAllowed(request);
       if (!origin) {
         return jsonError(request, "ORIGIN_NOT_ALLOWED", "Origin is not allowed", 403);
@@ -3505,41 +4263,9 @@ function registerTailnetInternalRoutes(api) {
       if (!proofCheck.ok) {
         return jsonError(request, proofCheck.code, proofCheck.message, proofCheck.status);
       }
-      const forwardedFor = request.headers.get("x-forwarded-for") ?? "unknown";
-      const ipKey = `ip:${forwardedFor}`;
-      const deviceKey = `device:${proofCheck.deviceId}`;
-      if (isRateLimited(rateLimitBucket, ipKey, 20, 6e4) || isRateLimited(rateLimitBucket, deviceKey, 8, 6e4)) {
-        return jsonError(request, "RATE_LIMITED", "Too many pairing requests", 429);
-      }
-      try {
-        const pairing = await requestPairingFromGateway();
-        pendingPairings.set(pairing.requestId, {
-          requestId: pairing.requestId,
-          deviceId: proofCheck.deviceId,
-          createdAt: Date.now(),
-          expiresAt: pairing.expiresAt
-        });
-        return withCors(
-          request,
-          json({
-            ok: true,
-            requestId: pairing.requestId,
-            approveCommand: `openclaw devices approve ${pairing.requestId}`,
-            expiresAt: pairing.expiresAt
-          })
-        );
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return jsonError(
-          request,
-          "PAIRING_REQUEST_UNAVAILABLE",
-          message.replace(/^PAIRING_REQUEST_UNAVAILABLE:\s*/i, ""),
-          501,
-          { nextStep: "openclaw devices list --json" }
-        );
-      }
+      return issuePairingRequestResponse(request, proofCheck.deviceId);
     }
-    if (request.method === "GET" && path13 === "/squad-internal/pairing/status") {
+    if (request.method === "GET" && path16 === "/squad-internal/pairing/status") {
       const origin = ensureOriginAllowed(request);
       if (!origin) {
         return jsonError(request, "ORIGIN_NOT_ALLOWED", "Origin is not allowed", 403);
@@ -3572,20 +4298,30 @@ function registerTailnetInternalRoutes(api) {
     }
     return new Response("Not Found", { status: 404 });
   };
-  const handle = async (incoming) => {
+  const handle = async (incoming, outgoing) => {
     let request;
     try {
-      request = await toFetchRequest(incoming);
+      request = await toRouteRequest(incoming);
     } catch (error) {
       console.warn(`[squad-openclaw] failed to normalize internal request: ${errorMessage2(error)}`);
-      return new Response("Bad Request", { status: 400 });
+      const response = new Response("Bad Request", { status: 400 });
+      if (outgoing) {
+        await writeNodeResponse(outgoing, response);
+        return true;
+      }
+      return response;
     }
     try {
-      return await withTimeout(
+      const response = await withTimeout(
         handleRequest(request),
         INTERNAL_ROUTE_TIMEOUT_MS,
         `internal route ${request.method} ${getRequestUrl(request).pathname}`
       );
+      if (outgoing) {
+        await writeNodeResponse(outgoing, response);
+        return true;
+      }
+      return response;
     } catch (error) {
       if (error instanceof TimeoutError) {
         const snapshot2 = recordPluginFailure(
@@ -3594,13 +4330,18 @@ function registerTailnetInternalRoutes(api) {
           "Investigate internal route hangs and run squad.plugin.recover after remediation."
         );
         console.warn(`[squad-openclaw] ${error.operation}`);
-        return jsonError(
+        const response2 = jsonError(
           request,
           snapshot2.state === "QUARANTINED_AUTO" ? "PLUGIN_QUARANTINED" : "ROUTE_TIMEOUT",
           `Internal route timed out after ${error.timeoutMs}ms`,
           snapshot2.state === "QUARANTINED_AUTO" ? 503 : 504,
           snapshot2.state === "QUARANTINED_AUTO" ? { plugin: snapshot2 } : {}
         );
+        if (outgoing) {
+          await writeNodeResponse(outgoing, response2);
+          return true;
+        }
+        return response2;
       }
       const snapshot = recordPluginFailure(
         "INTERNAL_ROUTE_ERROR",
@@ -3608,25 +4349,52 @@ function registerTailnetInternalRoutes(api) {
         "Inspect internal route failures and run squad.plugin.recover after remediation."
       );
       console.warn(`[squad-openclaw] internal route failure: ${errorMessage2(error)}`);
-      return jsonError(
+      const response = jsonError(
         request,
         snapshot.state === "QUARANTINED_AUTO" ? "PLUGIN_QUARANTINED" : "INTERNAL_ROUTE_ERROR",
         "Internal route failed unexpectedly",
         snapshot.state === "QUARANTINED_AUTO" ? 503 : 500,
         snapshot.state === "QUARANTINED_AUTO" ? { plugin: snapshot } : {}
       );
+      if (outgoing) {
+        await writeNodeResponse(outgoing, response);
+        return true;
+      }
+      return response;
     }
   };
   if (typeof api.registerHttpHandler === "function") {
     api.registerHttpHandler(handle);
   } else if (typeof api.registerHttpRoute === "function") {
-    api.registerHttpRoute("/squad-internal/health", handle);
-    api.registerHttpRoute("/squad-internal/plugin/status", handle);
-    api.registerHttpRoute("/squad-internal/plugin/recover", handle);
-    api.registerHttpRoute("/squad-internal/plugin/disable", handle);
-    api.registerHttpRoute("/squad-internal/pairing/request", handle);
-    api.registerHttpRoute("/squad-internal/pairing/status", handle);
-    api.registerHttpRoute("/squad-internal/*", handle);
+    if (api.registerHttpRoute.length <= 1) {
+      const registerRoute = (path16, match = "exact") => {
+        api.registerHttpRoute({
+          path: path16,
+          handler: handle,
+          auth: "plugin",
+          match
+        });
+      };
+      registerRoute("/squad-internal/health");
+      registerRoute("/squad-internal/plugin/status");
+      registerRoute("/squad-internal/plugin/recover");
+      registerRoute("/squad-internal/plugin/disable");
+      registerRoute("/squad-internal/browser-session/connect-proof");
+      registerRoute("/squad-internal/browser-session/pairing/request");
+      registerRoute("/squad-internal/pairing/request");
+      registerRoute("/squad-internal/pairing/status");
+      registerRoute("/squad-internal/*", "prefix");
+    } else {
+      api.registerHttpRoute("/squad-internal/health", handle);
+      api.registerHttpRoute("/squad-internal/plugin/status", handle);
+      api.registerHttpRoute("/squad-internal/plugin/recover", handle);
+      api.registerHttpRoute("/squad-internal/plugin/disable", handle);
+      api.registerHttpRoute("/squad-internal/browser-session/connect-proof", handle);
+      api.registerHttpRoute("/squad-internal/browser-session/pairing/request", handle);
+      api.registerHttpRoute("/squad-internal/pairing/request", handle);
+      api.registerHttpRoute("/squad-internal/pairing/status", handle);
+      api.registerHttpRoute("/squad-internal/*", handle);
+    }
   } else if (typeof api.registerHttpMiddleware === "function") {
     api.registerHttpMiddleware(handle);
   } else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squad-openclaw",
-  "version": "2026.3.1301",
+  "version": "2026.3.1401",
   "description": "Entity registry, filesystem tools, and version management plugin for OpenClaw gateway",
   "type": "module",
   "main": "./dist/index.js",