Address review feedback: simplify to bounded availability check

Per review on #220:
- Revert the docker-tunnel-proxy rule callback to its original inline form
  and drop the per-request DOCKER_PROXY_SETTING_TIMEOUT_MS timeout. The 3s
  Docker-availability timeout already bounds the network monitor (which
  awaits isDockerAvailable), so this still fails open: only requests in the
  first few seconds of a wedged-Docker startup wait, then everything works.
- Move the timeout duration into TimeoutError/withTimeout so every timeout
  reports "Timeout after <n>ms"; isDockerAvailable's catch returns to its
  original one-line form.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: komen205

src/interceptors/docker/docker-interception-services.ts

@@ -21,16 +21,11 @@ import {
     stopDockerTunnel,
 } from './docker-tunnel-proxy';
 import { ensureDockerInjectionVolumeExists } from './docker-data-injection';
-import { TimeoutError, withTimeout } from '../../util/promise';
+import { withTimeout } from '../../util/promise';
 
 let dockerAvailableCache: Promise<boolean> | undefined;
 
 const DOCKER_AVAILABILITY_TIMEOUT_MS = 3_000;
-const DOCKER_PROXY_SETTING_TIMEOUT_MS = 250;
-
-type DockerNetworkRouteMonitor = {
-    dockerRoutedAliases: ReadonlySet<string>
-};
 
 export const isDockerAvailable = (options: { logError?: boolean } = {}) => {
     if (dockerAvailableCache) return dockerAvailableCache;
@@ -48,12 +43,7 @@ export const isDockerAvailable = (options: { logError?: boolean } = {}) => {
             }
         })
         .catch((error) => {
-            if (options.logError) {
-                const errorMessage = error instanceof TimeoutError
-                    ? `timed out after ${DOCKER_AVAILABILITY_TIMEOUT_MS}ms`
-                    : error.message;
-                console.warn('Docker not available:', errorMessage);
-            }
+            if (options.logError) console.warn('Docker not available:', error.message);
             return false;
         });
 
@@ -66,48 +56,6 @@ export const isDockerAvailable = (options: { logError?: boolean } = {}) => {
 
 const IPv4_IPv6_PREFIX = "::ffff:";
 
-// This proxy setting is included in the default passthrough rules, so it can run for
-// browser/Android/etc traffic too. It must fail open quickly if Docker is unavailable.
-export function getDockerTunnelProxySetting(
-    proxyPort: number,
-    networkMonitor: Promise<DockerNetworkRouteMonitor | undefined>,
-    options: { timeoutMs?: number } = {}
-): ProxySettingCallback {
-    const timeoutMs = options.timeoutMs ?? DOCKER_PROXY_SETTING_TIMEOUT_MS;
-    let hasLoggedTimeout = false;
-    let hasLoggedFailure = false;
-
-    return async ({ hostname }: { hostname: any }) => {
-        hostname = hostname.startsWith(IPv4_IPv6_PREFIX)
-            ? hostname.slice(IPv4_IPv6_PREFIX.length)
-            : hostname;
-
-        const monitor = await withTimeout(timeoutMs, networkMonitor).catch((error) => {
-            if (error instanceof TimeoutError) {
-                if (!hasLoggedTimeout) {
-                    hasLoggedTimeout = true;
-                    console.warn(
-                        `Docker route lookup timed out after ${timeoutMs}ms; skipping Docker tunnel routing`
-                    );
-                }
-            } else {
-                if (!hasLoggedFailure) {
-                    hasLoggedFailure = true;
-                    logError(error);
-                }
-            }
-
-            return undefined;
-        });
-
-        if (monitor?.dockerRoutedAliases.has(hostname)) {
-            return {
-                proxyUrl: `socks5://127.0.0.1:${await getDockerTunnelPort(proxyPort)}`
-            };
-        }
-    };
-}
-
 // On shutdown, clean up every container & image that we created, disappearing
 // into the mist as if we were never here...
 // (Those images/containers are unusable without us, so leaving them breaks things).
@@ -146,10 +94,17 @@ export async function startDockerInterceptionServices(
 
     const networkMonitor = monitorDockerNetworkAliases(proxyPort);
 
-    ruleParameters[`docker-tunnel-proxy-${proxyPort}`] = getDockerTunnelProxySetting(
-        proxyPort,
-        networkMonitor
-    );
+    ruleParameters[`docker-tunnel-proxy-${proxyPort}`] = async ({ hostname }: { hostname: any }) => {
+        hostname = hostname.startsWith(IPv4_IPv6_PREFIX)
+            ? hostname.slice(IPv4_IPv6_PREFIX.length)
+            : hostname;
+
+        if ((await networkMonitor)?.dockerRoutedAliases.has(hostname)) {
+            return {
+                proxyUrl: `socks5://127.0.0.1:${await getDockerTunnelPort(proxyPort)}`
+            };
+        }
+    };
     console.log(`Created docker-tunnel-proxy-${proxyPort}`);
 
     await Promise.all([

src/util/promise.ts

@@ -23,8 +23,11 @@ export async function waitUntil<T extends unknown>(
 }
 
 export class TimeoutError extends CustomError {
-    constructor() {
-        super('Timeout', { code: 'timeout' });
+    constructor(timeoutMs?: number) {
+        super(
+            timeoutMs === undefined ? 'Timeout' : `Timeout after ${timeoutMs}ms`,
+            { code: 'timeout' }
+        );
     }
 }
 
@@ -35,6 +38,6 @@ export async function withTimeout<T>(
     return Promise.race([
         promise,
         delay(timeoutMs, { unref: true })
-            .then(() => { throw new TimeoutError(); })
+            .then(() => { throw new TimeoutError(timeoutMs); })
     ]);
 }