Support private ips

Author: ericdallo

src/bridge/api.ts

@@ -15,7 +15,7 @@ import type {
   SessionResponse,
 } from './types';
 import type { Protocol } from './utils';
-import { resolveBaseUrl } from './utils';
+import { localNetworkFetchOptions, resolveBaseUrl } from './utils';
 
 export class EcaRemoteApi {
   private baseUrl: string;
@@ -57,7 +57,9 @@ export class EcaRemoteApi {
     const { method = 'GET', body, auth = true, allowStatus = [] } = options;
     const hasBody = body !== undefined;
 
-    const res = await fetch(`${this.baseUrl}${path}`, {
+    const url = `${this.baseUrl}${path}`;
+    const res = await fetch(url, {
+      ...localNetworkFetchOptions(url),
       method,
       headers: auth ? this.headers(hasBody) : (hasBody ? { 'Content-Type': 'application/json' } : undefined),
       ...(hasBody ? { body: JSON.stringify(body) } : {}),

src/bridge/sse.ts

@@ -9,6 +9,8 @@
  * the client assumes the connection is dead and triggers onDisconnect.
  */
 
+import { localNetworkFetchOptions } from './utils';
+
 export interface SSEEvent {
   event: string;
   data: string;
@@ -65,6 +67,7 @@ export class SSEClient {
     this.abortController = new AbortController();
 
     const response = await fetch(this.url, {
+      ...localNetworkFetchOptions(this.url),
       headers: { 'Authorization': `Bearer ${this.password}` },
       signal: this.abortController.signal,
     });

src/bridge/utils.ts

@@ -8,17 +8,26 @@
 
 export type Protocol = 'http' | 'https';
 
+/** RFC 1918 + loopback regex — matches private/local network hosts. */
+const LOCAL_NETWORK_RE =
+  /^(192\.168\.|10\.|172\.(1[6-9]|2\d|3[01])\.|127\.|localhost)/i;
+
+/**
+ * Returns true when `host` targets a private/local network address.
+ * Used for protocol defaults and Chrome Local Network Access hints.
+ */
+export function isLocalNetworkHost(host: string): boolean {
+  return LOCAL_NETWORK_RE.test(host);
+}
+
 /**
  * Resolve the HTTP protocol for a given host string.
  * When an explicit protocol is provided it is used as-is;
- * otherwise localhost / 127.0.0.1 → http, everything else → https.
+ * otherwise private/loopback addresses → http, everything else → https.
  */
 export function resolveProtocol(host: string, protocol?: Protocol): Protocol {
   if (protocol) return protocol;
-  if (host.startsWith('localhost') || host.startsWith('127.0.0.1')) {
-    return 'http';
-  }
-  return 'https';
+  return isLocalNetworkHost(host) ? 'http' : 'https';
 }
 
 /**
@@ -28,12 +37,36 @@ export function resolveBaseUrl(host: string, protocol?: Protocol): string {
   return `${resolveProtocol(host, protocol)}://${host}/api/v1`;
 }
 
+/**
+ * Build extra fetch options for Chrome Local Network Access (LNA).
+ *
+ * When the target URL points to a private/local address, returns
+ * `{ targetAddressSpace: "local" }` so Chrome surfaces its LNA
+ * permission prompt instead of silently blocking the request.
+ *
+ * @see https://developer.chrome.com/blog/local-network-access
+ */
+export function localNetworkFetchOptions(url: string): RequestInit {
+  try {
+    const host = new URL(url).hostname;
+    if (isLocalNetworkHost(host)) {
+      return { targetAddressSpace: 'local' } as RequestInit;
+    }
+  } catch {
+    // invalid URL — ignore
+  }
+  return {};
+}
+
 /**
  * Fetch with an abort-based timeout.
  *
  * Wraps the standard `fetch` and aborts the request if it exceeds
  * `timeoutMs` milliseconds. The AbortError can be caught upstream
  * to show a user-friendly timeout message.
+ *
+ * Automatically adds `targetAddressSpace: "local"` for private-network
+ * URLs to cooperate with Chrome's Local Network Access restrictions.
  */
 export async function fetchWithTimeout(
   url: string,
@@ -43,7 +76,11 @@ export async function fetchWithTimeout(
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), timeoutMs);
   try {
-    return await fetch(url, { ...init, signal: controller.signal });
+    return await fetch(url, {
+      ...localNetworkFetchOptions(url),
+      ...init,
+      signal: controller.signal,
+    });
   } finally {
     clearTimeout(timer);
   }