@ebony-vinyl/dsh-our-free-model 2.8.0 → 2.8.2

package/src/egress.js

@@ -54,6 +54,8 @@ import tls from 'node:tls'
 import http from 'node:http'
 import os from 'node:os'
 import path from 'node:path'
+import { Readable } from 'node:stream'
+import { pipeline } from 'node:stream/promises'
 import { randomBytes, timingSafeEqual } from 'node:crypto'
 import { lookup } from 'node:dns/promises'
 import { spawn } from 'node:child_process'
@@ -90,11 +92,100 @@ const HOP_BY_HOP = new Set(['connection', 'keep-alive', 'proxy-authenticate', 'p
  */
 let activeRelay = null
 
+/**
+ * The OpenCode lane's own proxy address, or null. This is the seam issue #708's
+ * "zen quota bypass" reduces to: the free tier's usage ceiling is counted per
+ * egress IP, so moving *this lane's* requests through a different exit is the
+ * one lever that actually moves the counter. The plugin supports it two ways —
+ * the same `HTTP_PROXY`/`HTTPS_PROXY`/`NO_PROXY` environment variables the
+ * issue used, and an explicit per-lane address set from the settings page —
+ * and never rotates anything on its own.
+ */
+let freeLaneProxy = null
+
+/** The parsed lane proxy, for the settings page to display. */
+export function freeLaneProxyActive() {
+  return freeLaneProxy !== null
+}
+
+/**
+ * Point the OpenCode lane at one proxy address (`setFreeLaneProxy`).
+ *
+ * Accepts http/https/socks5/socks5h URLs — the same schemes the global egress
+ * outlet speaks — or null/'' to clear. Invalid addresses throw: a typo'd proxy
+ * must fail loudly at save time, not on the first turn.
+ */
+export function setFreeLaneProxy(url) {
+  const text = String(url ?? '').trim()
+  if (text === '') {
+    freeLaneProxy = null
+    return
+  }
+  const parsed = new URL(text)
+  if (!CLIENT_SCHEMES.has(parsed.protocol)) {
+    throw new Error(`unsupported proxy scheme "${parsed.protocol}" — use http, https, socks5 or socks5h`)
+  }
+  freeLaneProxy = parsed
+}
+
+/**
+ * The proxy address the environment names for this lane (`envProxyFor`), or
+ * null. Exactly the three variables issue #708 used: `HTTPS_PROXY` (this
+ * lane's targets are https), falling back to `HTTP_PROXY`, minus anything
+ * `NO_PROXY` excludes. Only opencode.ai is ever matched here — the lane's own
+ * host — so a broad `NO_PROXY` cannot silently un-proxy the plugin's other
+ * traffic (those never consulted the environment to begin with).
+ */
+export function envProxyFor(hostname) {
+  const noProxy = String(process.env.NO_PROXY ?? process.env.no_proxy ?? '')
+  if (noProxy.trim() === '*') return undefined
+  const host = String(hostname ?? '').toLowerCase()
+  for (const entry of noProxy.split(',').map(item => item.trim().toLowerCase()).filter(Boolean)) {
+    const bare = entry.replace(/^\./, '')
+    if (host === bare || host.endsWith(`.${bare}`)) return undefined
+  }
+  const https = process.env.HTTPS_PROXY ?? process.env.https_proxy ?? process.env.httpsproxy
+  if (https) return new URL(String(https))
+  const httpProxy = process.env.HTTP_PROXY ?? process.env.http_proxy ?? process.env.httpproxy
+  if (httpProxy) return new URL(String(httpProxy))
+  return undefined
+}
+
 /** True when requests will be rewritten onto the relay instead of going out direct. */
 export function egressActive() {
   return activeRelay !== null
 }
 
+/**
+ * Which exit the OpenCode lane would use right now, and what that exit's
+ * public address is (`laneProxyEcho`) — the settings page's "测试出口" button.
+ * The echo service is third-party on purpose: nothing here dials the free
+ * lane's gateway, so a test never spends quota. When the effective exit is the
+ * environment's or a custom address, the echo request dials through it (the
+ * same `openTunnel` the relay uses); a direct exit answers without a proxy.
+ */
+export async function laneProxyEcho({ signal, timeoutMs = 8000 } = {}) {
+  const target = new URL('https://api.ipify.org/?format=json')
+  const proxy = freeLaneProxy ?? envProxyFor(target.hostname) ?? null
+  const controller = new AbortController()
+  const timer = setTimeout(() => controller.abort(), timeoutMs)
+  timer.unref?.()
+  signal?.addEventListener('abort', () => controller.abort(), { once: true })
+  try {
+    let response
+    if (proxy !== null) {
+      response = await laneProxiedFetch(target.href, { headers: { accept: 'application/json' }, signal: controller.signal }, proxy)
+    } else {
+      response = await fetch(target, { headers: { accept: 'application/json' }, signal: controller.signal, redirect: 'error' })
+    }
+    if (!response.ok) throw new Error(`the echo answered HTTP ${response.status}`)
+    const payload = await response.json()
+    return { ip: String(payload.ip ?? ''), proxied: proxy !== null, source: freeLaneProxy !== null ? 'custom' : proxy !== null ? 'env' : 'direct' }
+  } finally {
+    clearTimeout(timer)
+  }
+}
+
 /**
  * `fetch`, through the outlet when one is running and straight out when not.
  *
@@ -112,12 +203,49 @@ export async function egressFetch(url, init) {
   const officialFreeLane = targetUrl.protocol === 'https:' && targetUrl.hostname === 'opencode.ai'
     && (targetUrl.port === '' || targetUrl.port === '443') && targetUrl.pathname.startsWith('/inference/')
   const transport = process.env.OUR_FREE_MODEL_FREE_TRANSPORT ?? 'auto'
-  if (officialFreeLane && transport !== 'node') {
+  if (officialFreeLane) {
+    // Lane exit priority: the user's per-lane address first (issue #708's
+    // method, made explicit), then the global egress outlet, then the
+    // environment's HTTP(S)_PROXY, then direct. A per-lane address deliberately
+    // bypasses the global outlet: the point of setting one is that this lane
+    // exits somewhere else than everything else.
+    const laneProxy = freeLaneProxy ?? (relay !== null ? new URL(`http://ofm:${relay.key}@${RELAY_HOST}:${relay.port}`) : envProxyFor(targetUrl.hostname) ?? null)
+    const isPost = (init?.method ?? (url instanceof Request ? url.method : 'GET')).toUpperCase() !== 'GET'
+    if (transport === 'node') {
+      if (relay !== null && relay.dead) throw new Error('the configured egress relay is not running')
+      if (laneProxy !== null) return laneProxiedFetch(url, init, laneProxy)
+      return fetch(url, init)
+    }
     if (transport !== 'auto' && transport !== 'bun') throw new Error('OUR_FREE_MODEL_FREE_TRANSPORT must be auto, bun, or node')
+    // The GET listing may ride Node: it is a read, not an inference turn, and
+    // a machine without Bun must still be able to learn the roster (a missing
+    // Bun used to blind the whole catalog). Only the POST inference keeps the
+    // Bun requirement — the upstream fingerprints its client there.
+    //
+    // The read still leaves through the lane's own exit. An address chosen to
+    // move this lane is not un-chosen by the request being a GET: borrowing the
+    // real one for the roster would advertise a different client than the turns
+    // use. The global relay already carries it (its HTTP path, below); a custom
+    // or environment address needs the tunnel here.
+    if (!isPost) {
+      if (laneProxy !== null && freeLaneProxy !== null) return laneProxiedFetch(url, init, laneProxy)
+      if (laneProxy !== null && relay === null) return laneProxiedFetch(url, init, laneProxy)
+      if (relay !== null) return relayFetch(url, init, relay)
+      return fetch(url, init)
+    }
     const executable = findBunExecutable()
-    if (!executable) throw new Error('OpenCode free inference requires a local Bun executable; install Bun or set OUR_FREE_MODEL_BUN to its executable path (OUR_FREE_MODEL_FREE_TRANSPORT=node restores the legacy transport)')
+    if (!executable) {
+      // This sentence is the user's only answer until they install Bun, so it
+      // carries the fix inline, bilingually, without an "upstream failed" wrap.
+      const error = new Error('OpenCode 免费车道推理需要本机 Bun：请安装 Bun（https://bun.sh 或 npm i -g bun）后重试，或把 Bun 可执行文件路径写入 OUR_FREE_MODEL_BUN 环境变量。/ Install Bun or set OUR_FREE_MODEL_BUN to its executable path (OUR_FREE_MODEL_FREE_TRANSPORT=node restores the legacy transport).')
+      error.laneConfig = true
+      throw error
+    }
     if (relay?.dead) throw new Error('the configured egress relay is not running')
-    const proxy = relay ? `http://ofm:${relay.key}@${RELAY_HOST}:${relay.port}` : undefined
+    // With no explicit proxy, the Bun worker inherits this process's
+    // HTTP_PROXY/HTTPS_PROXY/NO_PROXY — Bun honors them natively, which is
+    // exactly the configuration issue #708's script used.
+    const proxy = freeLaneProxy !== null || relay !== null ? laneProxy?.href : undefined
     if (url instanceof Request) {
       const request = new Request(url, init)
       const body = request.body ? new Uint8Array(await request.arrayBuffer()) : undefined
@@ -126,6 +254,11 @@ export async function egressFetch(url, init) {
     return bunFetch(url, init, { executable, proxy })
   }
   if (relay === null) return fetch(url, init)
+  return relayFetch(url, init, relay)
+}
+
+/** Rewrite one request onto the loopback relay (`egressFetch`'s second half). */
+function relayFetch(url, init, relay) {
   const request = url instanceof Request ? new Request(url, init) : null
   const target = new URL(request ? request.url : String(url))
   if (target.protocol !== 'http:' && target.protocol !== 'https:') {
@@ -141,6 +274,74 @@ export async function egressFetch(url, init) {
   return fetch(`http://${RELAY_HOST}:${relay.port}${target.pathname}${target.search}`, { ...outgoing, headers })
 }
 
+/**
+ * One proxied request dialled in-process (`laneProxiedFetch`).
+ *
+ * The Bun worker's fetch accepts a `proxy` per request; Node's own fetch does
+ * not, and the global relay is process-wide by design. When the lane's exit
+ * has to differ from the process's — a custom lane address, or the
+ * environment's `HTTP(S)_PROXY` on the `node` transport — this is the seam:
+ * the same `openTunnel` the relay uses dials the proxy, the one-shot agent
+ * hands the socket to `http.request`, and the response streams back as a
+ * plain `Response`. Streaming cadence, abort semantics and `redirect: 'error'`
+ * match what `postStreamed` expects of `fetch`.
+ */
+async function laneProxiedFetch(url, init, proxyUrl) {
+  const target = new URL(url instanceof Request ? url.url : String(url))
+  if (target.protocol !== 'http:' && target.protocol !== 'https:') {
+    throw new Error(`the lane proxy only carries http(s) targets, got "${target.protocol}"`)
+  }
+  const socket = await openTunnel(target, { kind: 'url', url: proxyUrl })
+  const agent = new http.Agent({ keepAlive: false })
+  agent.createConnection = () => socket
+  const request = url instanceof Request ? new Request(url, init) : null
+  const headers = new Headers(request?.headers ?? init?.headers ?? {})
+  headers.set('host', target.host)
+  headers.delete('transfer-encoding')
+  const headerObject = {}
+  for (const [name, value] of headers.entries()) headerObject[name] = value
+  const outgoing = http.request({
+    method: request?.method ?? init?.method ?? 'GET',
+    path: `${target.pathname}${target.search}`,
+    headers: headerObject,
+    agent,
+  })
+  const signal = init?.signal ?? request?.signal
+  const tear = () => { outgoing.destroy(); socket.destroy() }
+  const onAbort = () => tear()
+  signal?.addEventListener('abort', onAbort, { once: true })
+  try {
+    const upstream = await new Promise((resolve, reject) => {
+      outgoing.on('response', resolve)
+      outgoing.on('error', reject)
+      const body = request?.body ?? init?.body ?? null
+      if (body === null || body === undefined) { outgoing.end(); return }
+      if (typeof body === 'string' || body instanceof Uint8Array) { outgoing.end(body); return }
+      // Node streams the request body through the same tunnel; flow control
+      // belongs to the two pipes. A pipeline error destroys both sides.
+      pipeline(body, outgoing, () => {})
+    })
+    const responseHeaders = new Headers()
+    for (const [name, value] of Object.entries(upstream.headers)) {
+      if (HOP_BY_HOP.has(name)) continue
+      for (const entry of Array.isArray(value) ? value : [value]) responseHeaders.append(name, String(entry))
+    }
+    // The one-shot tunnel lives exactly as long as the response: finished,
+    // destroyed or cancelled by the consumer, the socket goes with it.
+    upstream.on('close', () => socket.destroy())
+    const webBody = Readable.toWeb(upstream, { strategy: { highWaterMark: 64 * 1024 } })
+    return new Response(webBody, { status: upstream.statusCode ?? 502, statusText: upstream.statusMessage, headers: responseHeaders })
+  } catch (error) {
+    tear()
+    if (signal?.aborted === true || error?.name === 'AbortError') {
+      throw new DOMException('The operation was aborted.', 'AbortError')
+    }
+    throw error
+  } finally {
+    signal?.removeEventListener('abort', onAbort)
+  }
+}
+
 /**
  * Start the relay for the current settings; throws with a message the settings
  * page can show when the configuration cannot run.