dsh-model-proxy-switch 0.0.0-stage → 1.0.0

package/index.js

@@ -0,0 +1,341 @@
+/**
+ * Model proxy switch.
+ *
+ * While enabled, this plugin installs a process-wide outbound HTTP proxy
+ * policy, so the requests Node's fetch would send direct (model API, model
+ * discovery, web search, MCP over HTTP) are routed through the configured
+ * proxy instead. Disabling it restores the launcher's original routing.
+ *
+ * The proxy address follows the operating system's proxy setting by default
+ * (Windows: the "Internet Settings" registry values), falling back to the
+ * plugin's configured URL when detection finds nothing. An optional host
+ * allowlist narrows routing to named domains only — loopback always stays
+ * direct either way.
+ *
+ * The harness reads proxy names from its launch environment only: the
+ * launcher resolves and installs the policy before the first plugin loads, so
+ * writing `process.env` later changes nothing on its own. The policy installer
+ * is vendored under `vendor/`, with its `undici` dependency in this package's
+ * `node_modules/`: the harness's installation-scope module resolution only
+ * reaches packages installed inside the profile, and this one is linked from
+ * outside it.
+ *
+ * The switch is exposed to the browser half through a Typert remote
+ * (`modelProxy.status` / `setEnabled` / `setHosts`), and its position is
+ * remembered in the harness home so a restart keeps the last choice.
+ */
+import { execFileSync } from 'node:child_process'
+import { appendFileSync, readFileSync, writeFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+import { installProxyFromEnvironment } from './vendor/http-proxy.js'
+
+export const name = 'model-proxy'
+
+const DEFAULTS = {
+  proxy: 'auto',
+  bypass: 'localhost,127.0.0.1,::1',
+  hosts: '',
+}
+
+const PACKAGE = 'dsh-model-proxy-switch'
+const SERVICE = 'modelProxy'
+
+const HOME = process.env.DSH_HOME || join(homedir(), '.dsh')
+
+/** Append one line to the plugin's own diagnostic log, best effort. */
+function diag(message) {
+  try {
+    appendFileSync(join(HOME, 'model-proxy.log'), `${new Date().toISOString()} ${message}\n`)
+  } catch {
+    // Diagnostics must never break the plugin.
+  }
+}
+
+diag('module loaded')
+
+//#region system proxy detection
+function readRegistryValue(name) {
+  try {
+    const out = execFileSync(
+      'reg',
+      ['query', 'HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings', '/v', name],
+      { encoding: 'utf8', timeout: 5000, windowsHide: true, stdio: ['ignore', 'pipe', 'ignore'] },
+    )
+    const match = new RegExp(`${name}\\s+REG_(?:SZ|DWORD)\\s+(\\S+)`).exec(out)
+    return match?.[1]
+  } catch {
+    return undefined
+  }
+}
+
+/**
+ * Read the operating system's HTTP proxy address.
+ *
+ * Windows stores it under HKCU Internet Settings: `ProxyServer` is either one
+ * `host:port` for every protocol or a semicolon list of `scheme=host:port`
+ * entries, and `ProxyEnable` says whether apps should follow it. This plugin
+ * is itself an explicit opt-in, so the recorded address is used whenever it
+ * is present; `enabled` only changes how the panel labels the source.
+ *
+ * @returns `{ url, enabled }` with an http(s):// URL, or undefined when
+ *   nothing usable is recorded.
+ */
+function detectSystemProxy() {
+  if (process.platform !== 'win32') return undefined
+  try {
+    const server = readRegistryValue('ProxyServer')
+    if (!server) return undefined
+    const byScheme = {}
+    for (const part of server.split(';')) {
+      const eq = part.indexOf('=')
+      if (eq > 0) byScheme[part.slice(0, eq).trim().toLowerCase()] = part.slice(eq + 1).trim()
+    }
+    const picked = byScheme.https ?? byScheme.http ?? (Object.keys(byScheme).length === 0 ? server.trim() : undefined)
+    if (!picked) return undefined
+    const url = picked.includes('://') ? picked : `http://${picked}`
+    return { url, enabled: readRegistryValue('ProxyEnable') === '0x1' }
+  } catch (error) {
+    diag(`system proxy detection failed: ${error?.message ?? error}`)
+    return undefined
+  }
+}
+//#endregion
+
+/** The launch environment is a Map of name to `{ value }`, not a plain object. */
+function proxyEnvironment(proxy, bypass) {
+  return new Map([
+    ['http_proxy', { value: proxy }],
+    ['https_proxy', { value: proxy }],
+    ['all_proxy', { value: proxy }],
+    ['no_proxy', { value: bypass }],
+  ])
+}
+
+function stateFile() {
+  return join(HOME, 'model-proxy.json')
+}
+
+function readState(fallback) {
+  try {
+    const parsed = JSON.parse(readFileSync(stateFile(), 'utf8'))
+    return {
+      enabled: typeof parsed?.enabled === 'boolean' ? parsed.enabled : fallback.enabled,
+      hosts: typeof parsed?.hosts === 'string' ? parsed.hosts : fallback.hosts,
+    }
+  } catch {
+    return fallback
+  }
+}
+
+function writeState(state) {
+  try {
+    writeFileSync(stateFile(), `${JSON.stringify(state, null, 2)}\n`, 'utf8')
+  } catch {
+    // A read-only home must not break the switch for this run.
+  }
+}
+
+//#region typert face
+const codec = (typeSymbol, parse) => ({ mode: 'strict', typeSymbol: `${PACKAGE}#${typeSymbol}`, create: () => ({ parse }) })
+const booleanValue = codec('Boolean', (value) => {
+  if (typeof value !== 'boolean') throw new Error(`Expected a boolean, got ${typeof value}`)
+  return value
+})
+const hostsValue = codec('Hosts', (value) => {
+  if (typeof value !== 'string') throw new Error(`Expected a string, got ${typeof value}`)
+  if (value.length > 2048) throw new Error('Host list is too long')
+  return value
+})
+const jsonResult = codec('ModelProxyStatus', (value) => value)
+
+const methodDescriptor = (method, parameters) => ({
+  id: `${PACKAGE}#${SERVICE}/${method}`,
+  service: SERVICE,
+  namespace: SERVICE,
+  method,
+  invocation: { kind: 'direct' },
+  result: jsonResult,
+  parameters,
+})
+const jsonParameter = (name, parameterCodec) => ({ name, wire: name, source: 'json', codec: parameterCodec })
+
+const descriptors = [
+  methodDescriptor('status', []),
+  methodDescriptor('setEnabled', [jsonParameter('enabled', booleanValue)]),
+  methodDescriptor('setHosts', [jsonParameter('hosts', hostsValue)]),
+]
+//#endregion
+
+export function apply(ctx, config) {
+  const configuredProxy = String(config?.proxy ?? DEFAULTS.proxy).trim()
+  const bypass = String(config?.bypass ?? DEFAULTS.bypass).trim()
+  const state = readState({ enabled: true, hosts: String(config?.hosts ?? DEFAULTS.hosts) })
+
+  let enabled = state.enabled
+  let hosts = state.hosts
+  let dispose = undefined
+  /** The proxy actually installed, and where it came from. */
+  let activeProxy = undefined
+  let proxySource = 'none'
+
+  /**
+   * Detection spawns a `reg` child process, so reads are cached briefly:
+   * status calls (panel refresh) share one read per TTL, while explicit user
+   * actions always force a fresh read.
+   */
+  const DETECTION_TTL_MS = 10_000
+  let detectionCache = { at: 0, value: undefined }
+
+  /**
+   * Resolve which proxy URL would be installed right now. `auto` follows the
+   * operating system's recorded proxy address so swapping proxy software
+   * needs no edit here.
+   */
+  function resolveProxy(options = {}) {
+    if (configuredProxy !== '' && configuredProxy.toLowerCase() !== 'auto') {
+      return { url: configuredProxy, source: 'config' }
+    }
+    const now = Date.now()
+    if (!options.fresh && detectionCache.value !== undefined && now - detectionCache.at < DETECTION_TTL_MS) {
+      return detectionCache.value
+    }
+    const detected = detectSystemProxy()
+    const value =
+      detected === undefined
+        ? { url: undefined, source: 'none' }
+        : { url: detected.url, source: detected.enabled ? 'system' : 'registry' }
+    detectionCache = { at: now, value }
+    return value
+  }
+
+  const install = async () => {
+    if (!enabled || dispose !== undefined) return
+    // Explicit actions (switch on, host-list save, startup) read fresh.
+    const { url, source } = resolveProxy({ fresh: true })
+    if (url === undefined) {
+      activeProxy = undefined
+      proxySource = 'none'
+      diag('install skipped: no system proxy detected and no fallback configured')
+      return
+    }
+    let scheme
+    try {
+      scheme = new URL(url).protocol
+    } catch {
+      diag(`install refused: unparseable proxy URL ${JSON.stringify(url)}`)
+      return
+    }
+    if (scheme !== 'http:' && scheme !== 'https:') {
+      diag(`install refused: unsupported ${scheme} proxy`)
+      return
+    }
+    dispose = await installProxyFromEnvironment(
+      proxyEnvironment(url, bypass),
+      (message) => diag(`policy: ${message}`),
+      { hosts },
+    )
+    activeProxy = url
+    proxySource = source
+    diag(`policy installed: ${url} (${source}), hosts=${hosts === '' ? '<all>' : hosts}`)
+  }
+
+  const uninstall = async () => {
+    if (dispose === undefined) return
+    const pending = dispose
+    dispose = undefined
+    await pending()
+    diag('policy disposed')
+  }
+
+  ctx.effect(async () => {
+    try {
+      await install()
+    } catch (error) {
+      diag(`install failed: ${error?.stack ?? error}`)
+      console.warn('[model-proxy] install failed', error)
+    }
+    return async () => {
+      try {
+        await uninstall()
+      } catch (error) {
+        diag(`uninstall failed: ${error?.stack ?? error}`)
+      }
+    }
+  })
+
+  /**
+   * Re-read the proxy source and bring the installed policy in line with it.
+   * Detection used to run only at install time, so flipping the system proxy
+   * afterwards left the panel showing a stale address and label.
+   */
+  const reconcile = async () => {
+    const resolved = resolveProxy()
+    if (!enabled) {
+      activeProxy = resolved.url
+      proxySource = resolved.source
+      return
+    }
+    if (dispose !== undefined && resolved.url === activeProxy) {
+      // Same address, only the provenance changed (system proxy flipped).
+      if (resolved.source !== 'none') proxySource = resolved.source
+      return
+    }
+    if (dispose !== undefined) await uninstall()
+    activeProxy = resolved.url
+    proxySource = resolved.source
+    if (resolved.url !== undefined) await install()
+  }
+
+  const snapshot = () => ({ enabled, proxy: activeProxy, proxySource, hosts })
+
+  const service = {
+    status: () => {
+      diag('remote status()')
+      return reconcile().then(snapshot)
+    },
+    setEnabled(next) {
+      diag(`remote setEnabled(${next})`)
+      enabled = next
+      writeState({ enabled, hosts })
+      return (next ? install() : uninstall()).then(snapshot)
+    },
+    setHosts(next) {
+      const trimmed = next.trim()
+      diag(`remote setHosts(${JSON.stringify(trimmed)})`)
+      hosts = trimmed
+      writeState({ enabled, hosts })
+      const swap = async () => {
+        if (dispose === undefined) return
+        await uninstall()
+        await install()
+      }
+      return swap().then(snapshot)
+    },
+  }
+
+  ctx.inject(['typert'], (inner) => {
+    try {
+      // The gateway validates the service by reading its `typertRemote`
+      // binding, normally created by extending TypertRemoteService from
+      // @deepseek-ai/dsh-typert-protocol. That package is unreachable from a
+      // link-installed bundle, so the binding is constructed inline: a frozen
+      // { service, serviceKey, namespace } triple is the whole contract.
+      Object.assign(service, {
+        typertRemote: Object.freeze({ service, serviceKey: SERVICE, namespace: SERVICE }),
+      })
+      inner.provide(SERVICE, service)
+      inner.typert.register({
+        package: PACKAGE,
+        face: 'host',
+        schemas: [],
+        model: { services: [], events: [], objects: [] },
+        invocations: descriptors,
+      })
+      diag('typert face registered')
+    } catch (error) {
+      diag(`typert registration failed: ${error?.stack ?? error}`)
+      console.warn('[model-proxy] remote registration failed; the switch keeps its last state', error)
+    }
+  })
+}

package/locale/en.json

@@ -0,0 +1,25 @@
+{
+  "meta": {
+    "title": "Model Proxy Switch",
+    "description": "Sidebar switch: routes model API and model-list requests through a local HTTP proxy (follows the system proxy by default); off restores direct connections."
+  },
+  "nav": "Proxy",
+  "title": "Model proxy",
+  "summary": "Routes model API and model-list requests through an HTTP proxy while on; off means direct.",
+  "stateOn": "On",
+  "stateOff": "Off",
+  "label": "Use proxy",
+  "proxy": "Proxy URL",
+  "sourceSystem": "from system settings",
+  "sourceRegistry": "from registry (system proxy off)",
+  "sourceConfig": "from plugin config",
+  "sourceNone": "no system proxy detected",
+  "hostsLabel": "Only proxy these hosts",
+  "hostsHint": "Comma-separated; empty means every external address. Example: api.wufannao.cc.cd",
+  "save": "Save",
+  "saved": "Saved",
+  "scope": "Process-wide switch: model discovery, model calls, web search and MCP share this route. Loopback always stays direct.",
+  "saving": "Switching…",
+  "readFailed": "Could not read the state",
+  "writeFailed": "Switch failed"
+}

package/locale/zh.json

@@ -0,0 +1,25 @@
+{
+  "meta": {
+    "title": "模型代理开关",
+    "description": "侧栏开关：让模型 API、获取模型列表等出网请求走本地 HTTP 代理（默认跟随系统代理设置），关闭即恢复直连。"
+  },
+  "nav": "代理",
+  "title": "模型代理",
+  "summary": "让模型 API、获取模型列表等出网请求走 HTTP 代理；关闭即直连。",
+  "stateOn": "已开启",
+  "stateOff": "已关闭",
+  "label": "使用代理",
+  "proxy": "代理地址",
+  "sourceSystem": "跟随系统代理",
+  "sourceRegistry": "注册表记录（系统代理未开启）",
+  "sourceConfig": "插件配置",
+  "sourceNone": "未检测到系统代理",
+  "hostsLabel": "只对这些域名走代理",
+  "hostsHint": "逗号分隔，留空表示所有外部地址。例：api.wufannao.cc.cd",
+  "save": "保存",
+  "saved": "已保存",
+  "scope": "开关作用于整个宿主进程的出网请求：获取模型列表、模型调用、网页搜索、MCP 都走同一条链路；本机回环始终直连。",
+  "saving": "正在切换…",
+  "readFailed": "读取状态失败",
+  "writeFailed": "切换失败"
+}

package/package.json

@@ -1,6 +1,57 @@
 {
   "name": "dsh-model-proxy-switch",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "private": false,
+  "description": "Sidebar switch that routes model API and model-list requests through an HTTP proxy (follows the system proxy by default); off restores direct connections. Optional per-host allowlist.",
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "deepseek-harness",
+    "cordis-plugin",
+    "proxy",
+    "http-proxy",
+    "model"
+  ],
+  "license": "MIT",
+  "type": "module",
+  "main": "index.js",
+  "exports": {
+    ".": "./index.js",
+    "./client": "./client.js",
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./locale/*.json": "./locale/*.json",
+    "./icon": "./icon.svg",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "index.js",
+    "client.js",
+    "cordis.patch.yml",
+    "locale/*.json",
+    "icon.svg",
+    "vendor/",
+    "README.md"
+  ],
+  "icon": "./icon.svg",
+  "engines": {
+    "node": ">=22",
+    "dsh": ">=0.2.0-0 <0.3.0-0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/qinghuan50/dsh-model-proxy-switch.git"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "immediately": true,
+      "inject": [
+        "@deepseek-ai/dsh-client-ui-sidebar",
+        "@deepseek-ai/dsh-client-locale"
+      ]
+    }
+  }
+}