headroom-opencode 0.37.0 → 0.39.0

package/README.md

@@ -53,6 +53,22 @@ export default async function plugin(input) {
 - exposes the `headroom_retrieve` tool.
 - publishes `HEADROOM_PROXY_URL` in the plugin output env.
 - defaults to `http://127.0.0.1:8787` when no proxy URL is supplied.
+- skips routing for hosts listed in `excludeHosts` (or `HEADROOM_OPENCODE_EXCLUDE_HOSTS`); those requests go straight upstream with no compression or telemetry.
+
+To keep a provider off the proxy, list its host. An entry matches the host and all of its subdomains, and `.example.com` / `*.example.com` are accepted as spellings of `example.com`:
+
+```jsonc
+// opencode.json
+{
+  "plugin": [["/path/to/headroom/providers/opencode/_dist/entry.opencode.js", { "excludeHosts": ["opencode.ai"] }]]
+}
+```
+
+or, for `headroom wrap opencode` and spawned Node child processes, set the environment variable before launching:
+
+```bash
+HEADROOM_OPENCODE_EXCLUDE_HOSTS="opencode.ai,.corp.internal" headroom wrap opencode
+```
 
 ## Retrieve Tool
 
@@ -100,6 +116,7 @@ The provider config exposes these as `headroom/<model>` and defaults to `headroo
 | Variable | Used by | Description |
 |---|---|---|
 | `HEADROOM_PROXY_URL` | Native plugin | Proxy URL used by `HeadroomPlugin` |
+| `HEADROOM_OPENCODE_EXCLUDE_HOSTS` | Native plugin | Comma-separated hosts (and their subdomains) that bypass the proxy; the `excludeHosts` plugin option takes precedence |
 | `OPENCODE_CONFIG_CONTENT` | OpenCode wrapper | Generated OpenCode provider, model, and MCP config |
 
 ## License

package/dist/{chunk-UD4AB5X6.js → chunk-6I5ODRCW.js}

@@ -79,6 +79,7 @@ var BASE_URL_HEADER = "x-headroom-base-url";
 var ORIGINAL_PATH_HEADER = "x-headroom-original-path";
 var PROJECT_HEADER = "x-headroom-project";
 var PROXY_ENV = "HEADROOM_OPENCODE_TRANSPORT_PROXY_URL";
+var EXCLUDE_HOSTS_ENV = "HEADROOM_OPENCODE_EXCLUDE_HOSTS";
 var STATE_KEY = /* @__PURE__ */ Symbol.for("headroom.opencode.transport");
 function getState() {
   return globalThis[STATE_KEY];
@@ -100,17 +101,26 @@ function withNodeImportOption(existing, shim) {
   }
   return parts.join(" ");
 }
-function withShimEnv(env, proxyUrl) {
+function withExcludeHostsEnv(env, excludeHosts) {
+  if (excludeHosts.length > 0) {
+    env[EXCLUDE_HOSTS_ENV] = excludeHosts.join(",");
+  } else {
+    delete env[EXCLUDE_HOSTS_ENV];
+  }
+}
+function withShimEnv(env, proxyUrl, excludeHosts) {
   const nextEnv = { ...env ?? process.env };
   nextEnv[PROXY_ENV] = proxyUrl;
+  withExcludeHostsEnv(nextEnv, excludeHosts);
   const shim = shimImportSpecifier();
   if (shim) {
     nextEnv.NODE_OPTIONS = withNodeImportOption(nextEnv.NODE_OPTIONS, shim);
   }
   return nextEnv;
 }
-function installProcessEnv(proxyUrl) {
+function installProcessEnv(proxyUrl, excludeHosts) {
   process.env[PROXY_ENV] = proxyUrl;
+  withExcludeHostsEnv(process.env, excludeHosts);
   const shim = shimImportSpecifier();
   if (shim) {
     process.env.NODE_OPTIONS = withNodeImportOption(process.env.NODE_OPTIONS, shim);
@@ -119,11 +129,11 @@ function installProcessEnv(proxyUrl) {
 function isOptions(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value) && !(value instanceof URL);
 }
-function injectOptionsEnv(args, optionIndex, proxyUrl) {
+function injectOptionsEnv(args, optionIndex, state) {
   const nextArgs = [...args];
   const callback = typeof nextArgs.at(-1) === "function" ? nextArgs.pop() : void 0;
   const existing = isOptions(nextArgs[optionIndex]) ? { ...nextArgs[optionIndex] } : {};
-  existing.env = withShimEnv(existing.env, proxyUrl);
+  existing.env = withShimEnv(existing.env, state.proxyUrl, state.excludeHosts);
   if (isOptions(nextArgs[optionIndex])) {
     nextArgs[optionIndex] = existing;
   } else {
@@ -141,7 +151,7 @@ function wrapSpawn(originalSpawn) {
       return Reflect.apply(originalSpawn, this, args);
     }
     const optionIndex = Array.isArray(args[1]) ? 2 : 1;
-    return Reflect.apply(originalSpawn, this, injectOptionsEnv(args, optionIndex, state.proxyUrl));
+    return Reflect.apply(originalSpawn, this, injectOptionsEnv(args, optionIndex, state));
   };
 }
 function wrapExec(originalExec) {
@@ -150,7 +160,7 @@ function wrapExec(originalExec) {
     if (!state) {
       return Reflect.apply(originalExec, this, args);
     }
-    return Reflect.apply(originalExec, this, injectOptionsEnv(args, 1, state.proxyUrl));
+    return Reflect.apply(originalExec, this, injectOptionsEnv(args, 1, state));
   };
 }
 function wrapExecFile(originalExecFile) {
@@ -160,7 +170,7 @@ function wrapExecFile(originalExecFile) {
       return Reflect.apply(originalExecFile, this, args);
     }
     const optionIndex = Array.isArray(args[1]) ? 2 : 1;
-    return Reflect.apply(originalExecFile, this, injectOptionsEnv(args, optionIndex, state.proxyUrl));
+    return Reflect.apply(originalExecFile, this, injectOptionsEnv(args, optionIndex, state));
   };
 }
 function wrapFork(originalFork) {
@@ -170,7 +180,7 @@ function wrapFork(originalFork) {
       return Reflect.apply(originalFork, this, args);
     }
     const optionIndex = Array.isArray(args[1]) ? 2 : 1;
-    return Reflect.apply(originalFork, this, injectOptionsEnv(args, optionIndex, state.proxyUrl));
+    return Reflect.apply(originalFork, this, injectOptionsEnv(args, optionIndex, state));
   };
 }
 function normalizeProxyUrl(proxyUrl) {
@@ -180,7 +190,21 @@ function isLoopback(hostname3) {
   const normalized = hostname3.toLowerCase().replace(/^\[|\]$/g, "");
   return normalized === "localhost" || normalized === "127.0.0.1" || normalized === "::1";
 }
-function shouldRoute(url2, proxy) {
+function normalizeExcludeHosts(entries) {
+  const hosts = /* @__PURE__ */ new Set();
+  for (const entry of typeof entries === "string" ? entries.split(",") : entries) {
+    const host = String(entry).trim().toLowerCase().replace(/^(\*\.|\.)/, "");
+    if (host) {
+      hosts.add(host);
+    }
+  }
+  return [...hosts];
+}
+function isExcludedHost(hostname3, excludeHosts) {
+  const normalized = hostname3.toLowerCase().replace(/^\[|\]$/g, "");
+  return excludeHosts.some((host) => normalized === host || normalized.endsWith(`.${host}`));
+}
+function shouldRoute(url2, proxy, excludeHosts) {
   if (url2.protocol !== "http:" && url2.protocol !== "https:") {
     return false;
   }
@@ -190,6 +214,9 @@ function shouldRoute(url2, proxy) {
   if (url2.origin === proxy.origin) {
     return false;
   }
+  if (isExcludedHost(url2.hostname, excludeHosts)) {
+    return false;
+  }
   return true;
 }
 function routedUrl(upstream, proxy) {
@@ -243,9 +270,9 @@ function mergeFetchHeaders(input, init, upstream, originalPath = void 0, project
   }
   return headers;
 }
-function withRoutedFetchInput(input, init, proxy, project) {
+function withRoutedFetchInput(input, init, proxy, project, excludeHosts) {
   const upstream = requestUrl(input);
-  if (!shouldRoute(upstream, proxy)) {
+  if (!shouldRoute(upstream, proxy, excludeHosts)) {
     return [input, init];
   }
   const { url: nextUrl, originalPath } = routedUrlForOpenCode(upstream, proxy);
@@ -313,8 +340,8 @@ function headersForNodeRequest(options, upstream, originalPath, project) {
   });
   return result;
 }
-function routedNodeOptions(parts, proxy, project) {
-  if (!parts.url || !shouldRoute(parts.url, proxy)) {
+function routedNodeOptions(parts, proxy, project, excludeHosts) {
+  if (!parts.url || !shouldRoute(parts.url, proxy, excludeHosts)) {
     return void 0;
   }
   const { url: nextUrl, originalPath } = routedUrlForOpenCode(parts.url, proxy);
@@ -355,7 +382,7 @@ function wrapRequest(originalHttpRequest, originalHttpsRequest, originalRequest)
     }
     const proxy = normalizeProxyUrl(state.proxyUrl);
     const parts = splitNodeArgs(args);
-    const nextOptions = routedNodeOptions(parts, proxy, state.project);
+    const nextOptions = routedNodeOptions(parts, proxy, state.project, state.excludeHosts);
     if (!nextOptions) {
       return Reflect.apply(originalRequest, this, args);
     }
@@ -377,7 +404,7 @@ function wrapHttp2Connect(originalConnect) {
     if (state) {
       const proxy = normalizeProxyUrl(state.proxyUrl);
       const upstream = authority instanceof URL ? authority : new URL(String(authority));
-      if (shouldRoute(upstream, proxy)) {
+      if (shouldRoute(upstream, proxy, state.excludeHosts)) {
         throw new Error(
           `Headroom OpenCode wrap blocked direct HTTP/2 connection to ${upstream.origin}. Use fetch, http, or https so traffic can be routed through Headroom.`
         );
@@ -387,19 +414,22 @@ function wrapHttp2Connect(originalConnect) {
   };
 }
 function installHeadroomTransport(options) {
+  const excludeHosts = normalizeExcludeHosts(options.excludeHosts ?? process.env[EXCLUDE_HOSTS_ENV] ?? "");
   const existing = getState();
   if (existing) {
     existing.refs += 1;
     existing.proxyUrl = options.proxyUrl;
     existing.project = options.project;
+    existing.excludeHosts = excludeHosts;
     existing.debug = Boolean(options.debug);
-    installProcessEnv(options.proxyUrl);
+    installProcessEnv(options.proxyUrl, excludeHosts);
     return () => uninstallHeadroomTransport();
   }
   const state = {
     refs: 1,
     proxyUrl: options.proxyUrl,
     project: options.project,
+    excludeHosts,
     debug: Boolean(options.debug),
     originalFetch: globalThis.fetch,
     originalHttpRequest: http.request,
@@ -413,14 +443,14 @@ function installHeadroomTransport(options) {
     originalChildFork: childProcess.fork
   };
   setState(state);
-  installProcessEnv(options.proxyUrl);
+  installProcessEnv(options.proxyUrl, excludeHosts);
   globalThis.fetch = async (...args) => {
     const current = getState();
     if (!current) {
       return state.originalFetch(...args);
     }
     const proxy = normalizeProxyUrl(current.proxyUrl);
-    const [nextInput, nextInit] = withRoutedFetchInput(args[0], args[1], proxy, current.project);
+    const [nextInput, nextInit] = withRoutedFetchInput(args[0], args[1], proxy, current.project, current.excludeHosts);
     return state.originalFetch(nextInput, nextInit);
   };
   http.request = wrapRequest(state.originalHttpRequest, state.originalHttpsRequest, state.originalHttpRequest);
@@ -12894,6 +12924,7 @@ var HeadroomPlugin = async (input, options = {}) => {
   const uninstallTransport = installHeadroomTransport({
     proxyUrl,
     project,
+    excludeHosts: pluginOptions.excludeHosts,
     debug: pluginOptions.debug
   });
   return {
@@ -12932,4 +12963,4 @@ export {
   HeadroomPlugin,
   plugin_default
 };
-//# sourceMappingURL=chunk-UD4AB5X6.js.map
+//# sourceMappingURL=chunk-6I5ODRCW.js.map