@wwkit/opm 1.0.14 → 1.0.15

package/README.md

@@ -67,6 +67,7 @@ pnpm opm <command> [args] [options]
 | `ftp <action>` | FTP 文件管理（上传/rsync/下载） |
 | `ensure <runtime> [version]` | 确保运行时已安装（node/php/python） |
 | `ping <host|proxy|registry>` | 验证主机、代理或所有 registry 的可访问性 |
+| `env <action>` | 环境变量管理（list/get/set，跨平台：Unix profile / Windows user 级注册表） |
 | `config [section]` | 查看常用配置（proxy + 各 registry 段，段名动态生成） |
 | `opencode <action>` | opencode 运维命令（安装/升级/清理/env）；裸 `opm opencode` 启动 TUI |
 | `harness <action>` | @wwkit/harness 插件管理（安装/升级/list/status/env/dir） |
@@ -532,6 +533,37 @@ opm ping registry -d                   # 输出完整 JSON 数组
 > `opm ping proxy` 从 `proxy.active` 解析代理 URL，提取主机名后 ping。
 > `opm ping registry` 遍历所有含 `registry` 配置的工具，并行 ping 各 active 地址的主机。
 
+### env
+
+```bash
+opm env list                         # 列出 opm 管理的环境变量（含配置文件路径）
+opm env list --all                   # 追加 process.env 全量，每条标注 managed: true/false
+opm env get PATH                     # 根据 key 取值（先查 opm 管理源，回退 process.env）
+opm env set FOO bar                  # 设置环境变量（替换已存在的）
+opm env set MY_API_KEY secret123     # 设置 API 密钥
+opm env search api                   # 按关键词匹配 key 或 value（忽略大小写）
+opm env search api --all             # 同时搜索 process.env
+opm env help                         # 通用介绍
+```
+
+输出格式：默认输出**简化文本**（list/search 按来源分组：`配置文件路径` 行 + `key = value` 行；get/set 输出单行 `key = value`）；加 `-j/--json` 输出完整 JSON。
+
+```bash
+opm env list                         # 简化文本（按来源分组）
+opm env list --json                  # JSON 数组
+opm env get PATH                     # 简化：PATH = /usr/bin:/bin
+opm env get PATH --json              # JSON 对象（含 source/scope）
+opm env set FOO bar                  # 简化：FOO = bar
+opm env set FOO bar --json           # JSON 对象（含 written/source）
+opm env search api                   # 简化：匹配项按来源分组
+opm env search api --json            # JSON 数组
+```
+
+> `list`/`search` 默认只作用于 `opm env set` 管理的变量（Unix 的 `# >>> wwkit NAME >>>` 标记块 / Windows manifest）；`--all` 在其基础上追加 `process.env` 全量，并给每条标注 `managed: true/false` 与来源。
+> `search <keyword>` 匹配 key 或 value 是否包含关键词（忽略大小写），可用 `-q/--query` 替代位置参数。
+> 跨平台：Unix 读写 shell profile（`.zshrc`/`.bashrc`/`.profile`/fish config），用 `# >>> wwkit NAME >>>` 标记块管理；Windows 用 `setx` 写 user 级注册表（`HKCU\Environment`），`list` 用 `reg query` 读取。
+> Windows 上 `setx` 不留标记，opm 通过 `~/.config/opm/env-managed.json` 记录哪些 user 级变量由 opm 管理；`set` 始终写入 user 级（无需管理员权限）。
+
 ### opencode
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wwkit/opm",
-  "version": "1.0.14",
+  "version": "1.0.15",
   "author": "bluesliu <langcai163@163.com>",
   "description": "Unified CLI — package management (npm/pip/dnf/apt) + config view + opencode maintenance",
   "type": "module",
@@ -35,7 +35,16 @@
     "basic-ftp": "^6.2.1",
     "extract-zip": "^2.0.1",
     "systeminformation": "^5.23.0",
-    "@wwkit/shared": "1.0.18"
+    "@wwkit/shared": "1.0.20"
+  },
+  "devDependencies": {
+    "jest": "^29.7.0"
+  },
+  "jest": {
+    "transform": {},
+    "testMatch": [
+      "**/tests/**/*.test.js"
+    ]
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
@@ -45,8 +54,8 @@
     "postinstall": "node scripts/postinstall.js",
     "check": "node --check bin/index.js",
     "start": "node bin/index.js",
-    "test": "node --test \"tests/**/*.test.js\"",
-    "test:all": "node --test \"tests/**/*.test.js\"",
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js --no-cache tests",
+    "test:all": "node --experimental-vm-modules node_modules/jest/bin/jest.js --no-cache tests",
     "doc": "node -e \"import('./src/cli/doc.js').then(m => m.generateDocHtml({ open: false }))\"",
     "release": "node ../../packages/shared/bin/release-pkg.js"
   }

package/src/binaries/base.js

@@ -17,7 +17,7 @@ import path from 'node:path'
 import { parseFlags } from '../cli/helpers/args.js'
 import { output } from '../formatter.js'
 import { getActiveRegistry, setActiveRegistry, getPresets, getActiveProxy, getUserConfigDir } from '../config.js'
-import { fetchText, downloadToFile } from '../managers/http.js'
+import { fetchText, downloadToFile } from '@wwkit/shared'
 import { getOs, OS_TYPES } from './platform.js'
 import { find as findExe } from './exefinder.js'
 import { verify as verifyDeps } from './depchecker.js'

package/src/cli/groups/env.js

@@ -0,0 +1,451 @@
+/**
+ * env 命令组 — 跨平台环境变量便捷管理
+ *
+ * 用法：
+ *   opm env list [--all]      列出 opm 管理的环境变量（含配置文件路径）；--all 追加 process.env 全量
+ *   opm env get <key>         根据 key 取值（先查 opm 管理的配置源，回退 process.env）
+ *   opm env set <key> <value> 设置值（替换已存在的）
+ *   opm env help              通用介绍
+ *
+ * 跨平台策略（复用 @wwkit/shared 的 Shell）：
+ *   Unix:    读写 shell profile（bash/zsh/fish），用 `# >>> wwkit NAME >>>` 标记块管理
+ *   Windows: setx 写 user 级注册表；list 用 reg query 读取；用 manifest 文件
+ *            （~/.config/opm/env-managed.json）识别哪些 user 级变量由 opm 管理
+ *            （setx 不留标记，无法从注册表本身区分）
+ */
+
+import fs from 'node:fs'
+import path from 'node:path'
+import { spawnSync } from 'node:child_process'
+import { Shell } from '@wwkit/shared'
+import { parseFlags } from '../helpers/args.js'
+import { output } from '../../formatter.js'
+import { getUserConfigDir } from '../../config.js'
+
+/** Windows 注册表环境变量键路径 */
+const WIN_USER_KEY = 'HKCU\\Environment'
+
+/** manifest 文件名（Windows 记录 opm 管理的 user 级变量 key） */
+const MANIFEST_FILE = 'env-managed.json'
+
+/**
+ * 反转 Shell.setEnvVar 的转义（[$`\\"] → \\$&）
+ * @param {string} s
+ * @returns {string}
+ */
+function unescapeEnvValue(s) {
+  return s.replace(/\\([$`\\"])/g, '$1')
+}
+
+/**
+ * 从一行 export/set 语句中提取变量值
+ * @param {string} line
+ * @param {string} key
+ * @returns {string|null}
+ */
+function parseEnvLine(line, key) {
+  const exportQuoted = line.match(new RegExp(`^export\\s+${key}="(.*)"\\s*$`))
+  if (exportQuoted) return unescapeEnvValue(exportQuoted[1])
+  const fishQuoted = line.match(new RegExp(`^set -gx\\s+${key}\\s+"(.*)"\\s*$`))
+  if (fishQuoted) return unescapeEnvValue(fishQuoted[1])
+  const exportBare = line.match(new RegExp(`^export\\s+${key}=(\\S+)\\s*$`))
+  if (exportBare) return exportBare[1]
+  const fishBare = line.match(new RegExp(`^set -gx\\s+${key}\\s+(\\S+)\\s*$`))
+  if (fishBare) return fishBare[1]
+  return null
+}
+
+/**
+ * 解析 profile 文件内容中的 wwkit 标记块，提取 opm 管理的环境变量
+ * @param {string} content
+ * @returns {{ key: string, value: string }[]}
+ */
+export function parseEnvBlocks(content) {
+  if (!content) return []
+  const lines = content.split('\n')
+  const result = []
+  let i = 0
+  while (i < lines.length) {
+    const marker = lines[i].match(/^# >>> wwkit (\S+) >>>/)
+    if (marker) {
+      const key = marker[1]
+      // 块体：标记行之后到下一个 wwkit 标记或 EOF 之间的非空非注释行
+      let j = i + 1
+      while (j < lines.length && lines[j].trim() === '') j++
+      if (j < lines.length && !lines[j].startsWith('# >>> wwkit')) {
+        const value = parseEnvLine(lines[j], key)
+        if (value !== null) result.push({ key, value })
+      }
+      i = j + 1
+    } else {
+      i++
+    }
+  }
+  return result
+}
+
+/**
+ * 解析 Windows `reg query` 输出，提取环境变量条目
+ * @param {string} output
+ * @returns {{ key: string, type: string, value: string }[]}
+ */
+export function parseRegOutput(output) {
+  if (!output) return []
+  const result = []
+  for (const line of output.split(/\r?\n/)) {
+    const m = line.match(/^\s+(\S+)\s+(REG_\S+)\s+(.*)$/)
+    if (m) result.push({ key: m[1], type: m[2], value: m[3] })
+  }
+  return result
+}
+
+/**
+ * 校验环境变量名合法性（字母/下划线开头，后接字母数字下划线）
+ * @param {string} key
+ * @returns {boolean}
+ */
+export function isValidEnvKey(key) {
+  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(key)
+}
+
+export class EnvGroup {
+  /**
+   * @param {{ shell?: Shell, configDir?: string }} [opts] - shell/configDir 注入用于测试
+   */
+  constructor(opts = {}) {
+    this.name = 'env'
+    this.desc = 'Manage environment variables (list/get/set) across platforms'
+    this.shell = opts.shell || new Shell()
+    this.configDir = opts.configDir || ''
+  }
+
+  /** @returns {string} manifest 文件绝对路径 */
+  _manifestPath() {
+    const dir = this.configDir || getUserConfigDir()
+    return path.join(dir, MANIFEST_FILE)
+  }
+
+  /**
+   * 读取 manifest 中的 opm 管理 key 集合（Windows 用）
+   * @returns {Set<string>}
+   */
+  _readManifest() {
+    try {
+      const raw = fs.readFileSync(this._manifestPath(), 'utf8')
+      const data = JSON.parse(raw)
+      return new Set(Array.isArray(data.keys) ? data.keys : [])
+    } catch {
+      return new Set()
+    }
+  }
+
+  /**
+   * 将 key 登记到 manifest（Windows set 时调用）
+   * @param {string} key
+   */
+  _addManagedKey(key) {
+    const keys = this._readManifest()
+    keys.add(key)
+    const dir = this.configDir || getUserConfigDir()
+    fs.mkdirSync(dir, { recursive: true })
+    fs.writeFileSync(this._manifestPath(), JSON.stringify({ keys: [...keys] }, null, 2), 'utf8')
+  }
+
+  /**
+   * 列出 opm 管理的环境变量（默认 list 的数据源）
+   * Unix: 解析所有 profile 的 wwkit 标记块
+   * Windows: 读 manifest → 查 user 级注册表当前值
+   * @returns {object[]}
+   */
+  _managedItems() {
+    return this.shell.isWindows ? this._listWindowsManaged() : this._listUnix()
+  }
+
+  _listUnix() {
+    const items = []
+    for (const { path: profilePath, syntax } of this.shell.getProfiles()) {
+      let content = ''
+      try {
+        content = fs.readFileSync(profilePath, 'utf8')
+      } catch {}
+      for (const { key, value } of parseEnvBlocks(content)) {
+        items.push({ key, value, scope: 'user', source: profilePath, syntax })
+      }
+    }
+    return items
+  }
+
+  _listWindowsManaged() {
+    const managedKeys = this._readManifest()
+    if (managedKeys.size === 0) return []
+    const userVars = this._regQuery(WIN_USER_KEY)
+    const byKey = new Map(userVars.map((v) => [v.key, v]))
+    const items = []
+    for (const key of managedKeys) {
+      const v = byKey.get(key)
+      if (v) {
+        items.push({ key, value: v.value, scope: 'user', source: 'registry (user)', type: v.type })
+      } else {
+        // manifest 登记过但注册表中已不存在（外部删除）——标注缺失
+        items.push({ key, value: null, scope: 'user', source: 'registry (user)', missing: true })
+      }
+    }
+    return items
+  }
+
+  _regQuery(keyPath) {
+    try {
+      const result = spawnSync('reg', ['query', keyPath], {
+        encoding: 'utf8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+      })
+      if (result.status !== 0) return []
+      return parseRegOutput(result.stdout || '')
+    } catch {
+      return []
+    }
+  }
+
+  /**
+   * --all：opm 管理的 ∪ process.env 全量，每条标注 managed
+   * @returns {object[]}
+   */
+  _listAll() {
+    const managedItems = this._managedItems()
+    const seen = new Set()
+    const items = []
+    for (const m of managedItems) {
+      items.push({ key: m.key, value: m.value, managed: true, source: m.source, scope: m.scope })
+      seen.add(m.key)
+    }
+    for (const [key, value] of Object.entries(process.env)) {
+      if (!seen.has(key)) {
+        items.push({ key, value, managed: false, source: 'process.env' })
+        seen.add(key)
+      }
+    }
+    return items
+  }
+
+  async run(argv) {
+    const [action, ...rest] = argv
+
+    if (!action || action === '-h' || action === '--help' || action === 'help') {
+      this.printHelp()
+      return
+    }
+
+    const parsed = parseFlags(rest)
+
+    switch (action) {
+      case 'list':
+        return this._list(parsed)
+      case 'get':
+        return this._get(parsed)
+      case 'set':
+        return this._set(parsed)
+      case 'search':
+        return this._search(parsed)
+      default:
+        console.error(`Unknown action: ${action}`)
+        this.printHelp()
+        process.exit(1)
+    }
+  }
+
+  /**
+   * 是否输出 JSON（--json / -j）
+   * @param {{ flags: object, positional: string[] }} parsed
+   * @returns {boolean}
+   */
+  _useJson(parsed) {
+    return parsed.flags.json === 'true' || parsed.flags.j === 'true'
+  }
+
+  /**
+   * 统一输出：--json 走 JSON，否则走 plain 格式化函数
+   * @param {{ flags: object, positional: string[] }} parsed
+   * @param {*} data - JSON 输出数据
+   * @param {() => string} plain - 简化字符串输出函数
+   */
+  _out(parsed, data, plain) {
+    if (this._useJson(parsed)) {
+      output(data)
+    } else {
+      console.log(plain())
+    }
+  }
+
+  /**
+   * list 简化格式：按 source 分组，每组标题为来源，下面 key = value 行
+   * @param {object[]} items
+   * @returns {string}
+   */
+  _formatListPlain(items) {
+    const groups = []
+    const groupMap = new Map()
+    for (const item of items) {
+      const source = item.source || 'unknown'
+      if (!groupMap.has(source)) {
+        const g = { source, entries: [] }
+        groupMap.set(source, g)
+        groups.push(g)
+      }
+      groupMap.get(source).entries.push(item)
+    }
+    return groups
+      .map((g) => [
+        g.source,
+        ...g.entries.map((e) => `${e.key} = ${e.value === null || e.value === undefined ? '(not set)' : e.value}`),
+      ].join('\n'))
+      .join('\n\n')
+  }
+
+  /**
+   * 列出环境变量
+   * 默认: 只显示 opm 管理的（Unix 标记块 / Windows manifest）
+   * --all: 追加 process.env 全量，每条标注 managed: true/false
+   * 输出: 默认简化文本（按 source 分组），--json 输出 JSON
+   * @param {{ flags: object, positional: string[] }} parsed
+   */
+  async _list(parsed) {
+    const all = parsed.flags.all === 'true' || parsed.flags.a === 'true'
+    const items = all ? this._listAll() : this._managedItems()
+    this._out(parsed, items, () => this._formatListPlain(items))
+  }
+
+  /**
+   * 根据 key 取值：先查 opm 管理的配置源，回退 process.env
+   * 输出: 默认 `key = value`（未找到 `key = (not found)`），--json 输出 JSON
+   * @param {{ flags: object, positional: string[] }} parsed
+   */
+  async _get(parsed) {
+    const key = parsed.positional[0] || parsed.flags.k || parsed.flags.key || ''
+    if (!key) {
+      console.error('Usage: opm env get <key>')
+      console.error('Missing required <key>')
+      process.exit(1)
+    }
+
+    const configured = this._managedItems()
+    const hit = configured.find((e) => e.key === key)
+    if (hit) {
+      this._out(parsed, { key, value: hit.value, found: true, source: hit.source, scope: hit.scope }, () => `${key} = ${hit.value}`)
+      return
+    }
+
+    if (process.env[key] !== undefined) {
+      const value = process.env[key]
+      this._out(parsed, { key, value, found: true, source: 'process.env' }, () => `${key} = ${value}`)
+      return
+    }
+
+    this._out(parsed, { key, value: null, found: false }, () => `${key} = (not found)`)
+  }
+
+  /**
+   * 设置环境变量（替换已存在的）
+   * Unix: 写入 shell profile 标记块；Windows: setx 写 user 级注册表 + manifest 登记
+   * @param {{ flags: object, positional: string[] }} parsed
+   */
+  async _set(parsed) {
+    const key = parsed.positional[0] || parsed.flags.k || parsed.flags.key || ''
+    const value = parsed.positional[1] ?? parsed.flags.v ?? parsed.flags.value ?? ''
+
+    if (!key) {
+      console.error('Usage: opm env set <key> <value>')
+      console.error('Missing required <key>')
+      process.exit(1)
+    }
+    if (!isValidEnvKey(key)) {
+      console.error(`Invalid env key: "${key}" (must start with letter/underscore, only letters/digits/underscore)`)
+      process.exit(1)
+    }
+    if (parsed.positional.length < 2 && !(parsed.flags.v || parsed.flags.value)) {
+      console.error('Usage: opm env set <key> <value>')
+      console.error('Missing required <value>')
+      process.exit(1)
+    }
+
+    const written = this.shell.setEnvVar(key, value)
+    if (this.shell.isWindows) {
+      this._addManagedKey(key)
+    }
+    const source = this.shell.isWindows
+      ? 'registry (user)'
+      : this.shell.getProfiles().map((p) => p.path)
+    const result = { key, value, written, source }
+    this._out(parsed, result, () => `${key} = ${value}${written ? '' : ' (no change)'}`)
+  }
+
+  /**
+   * 按关键词搜索环境变量（匹配 key 或 value，忽略大小写）
+   * 默认: 在 opm 管理的变量中搜索；--all 扩展至 process.env 全量
+   * 输出: 默认简化文本（按 source 分组），--json 输出 JSON
+   * @param {{ flags: object, positional: string[] }} parsed
+   */
+  async _search(parsed) {
+    const keyword = parsed.positional[0] || parsed.flags.q || parsed.flags.query || ''
+    if (!keyword) {
+      console.error('Usage: opm env search <keyword>')
+      console.error('Missing required <keyword>')
+      process.exit(1)
+    }
+
+    const all = parsed.flags.all === 'true' || parsed.flags.a === 'true'
+    const source = all ? this._listAll() : this._managedItems()
+    const kw = keyword.toLowerCase()
+    const matches = source.filter((e) => {
+      const k = String(e.key).toLowerCase()
+      const v = e.value === null || e.value === undefined ? '' : String(e.value).toLowerCase()
+      return k.includes(kw) || v.includes(kw)
+    })
+    this._out(parsed, matches, () => this._formatListPlain(matches))
+  }
+
+  printHelp() {
+    console.log(`
+Usage: opm env <action> [args] [options]
+
+Actions:
+  list [--all]            List opm-managed env vars with their config file path
+                          (default: only vars set via "opm env set";
+                           --all appends all process.env vars, each tagged managed: true/false)
+  get <key>               Get value by key (checks opm-managed sources first, then process.env)
+  set <key> <value>       Set value, replacing any existing one
+                          (Unix: shell profile marker block; Windows: setx user-level registry)
+  search <keyword> [--all]  Search env vars whose key or value contains keyword (case-insensitive)
+                          (default: opm-managed vars; --all also searches process.env)
+  help                    Show this help
+
+Options:
+  -k, --key <name>        Key (alternative to positional for get/set)
+  -v, --value <val>       Value (alternative to positional for set)
+  -q, --query <kw>        Keyword (alternative to positional for search)
+  -a, --all               Also list all process.env vars (tagged managed: true/false)
+  -j, --json              Output JSON (default: plain text)
+  -h, --help              Show this help
+
+Output:
+  default (no -j)         Plain text: list groups by source then "key = value" lines;
+                          get/set print a single "key = value" line
+  -j / --json             JSON object/array with full metadata
+
+Platform behavior:
+  Unix     read/write shell profiles (.zshrc/.bashrc/.profile/fish config)
+           via "# >>> wwkit NAME >>>" marker blocks
+  Windows  read/write user-level registry (HKCU\\Environment); writes via setx;
+           opm-managed keys tracked in ~/.config/opm/env-managed.json
+
+Examples:
+  opm env list
+  opm env list --all              # all process.env vars, tagged managed
+  opm env get PATH
+  opm env set FOO bar
+  opm env set MY_API_KEY secret123
+  opm env search api              # match key or value containing "api" (case-insensitive)
+  opm env search api --all        # also search process.env
+  opm env help
+`)
+  }
+}

package/src/cli/groups/ping.js

@@ -18,6 +18,9 @@ import { getActiveProxy, getActiveRegistry, getConfig } from '../../config.js'
 
 const shell = new Shell()
 
+// 跨平台 null device（curl -o 丢弃输出体）
+const NULL_DEV = process.platform === 'win32' ? 'NUL' : '/dev/null'
+
 /**
  * 从 URL 或 deb 行中提取主机名和端口（用于 ping 目标）
  * @param {string} url
@@ -47,8 +50,9 @@ function isUrl(addr) {
 }
 
 // HTTP 状态码 → 可达性判断：2xx/3xx 视为可达，allowlist 中的状态码
-// 虽非成功响应但证明服务器已响应（如 404 表示主机/代理存活）
-const REACHABLE_ALLOWLIST = [404]
+// 虽非成功响应但证明服务器已响应（如 404 表示主机/代理存活，
+// 429 表示临时限流，服务器实际存活）
+const REACHABLE_ALLOWLIST = [404, 429]
 
 function httpReachable(httpCode) {
   return (httpCode >= 200 && httpCode < 400) || REACHABLE_ALLOWLIST.includes(httpCode)
@@ -85,7 +89,16 @@ function checkByPing(host, count) {
       ? ['-n', String(count), '-w', '2000', host]
       : ['-c', String(count), '-W', '2', host]
 
-    const child = spawn('ping', args, { stdio: ['pipe', 'pipe', 'pipe'] })
+    let child
+    try {
+      child = spawn('ping', args, { stdio: ['pipe', 'pipe', 'pipe'], shell: true })
+    } catch {
+      resolve({
+        reachable: false, sent: count, received: 0, loss: count,
+        lossPercent: 100, rttMin: '', rttAvg: '', rttMax: '', raw: 'ping command failed to execute',
+      })
+      return
+    }
     let stdout = ''
     let stderr = ''
     child.stdout.on('data', (d) => { stdout += d })
@@ -154,10 +167,19 @@ function checkByPing(host, count) {
  */
 function checkByCurl(url, proxy) {
   return new Promise((resolve) => {
-    const args = ['-k', '-L', '-s', '-o', '/dev/null', '-w', '%{http_code} %{time_total}', '--connect-timeout', '2', '--max-time', '5']
+    const args = ['-k', '-L', '-s', '-o', NULL_DEV, '-w', '%{http_code} %{time_total}', '--connect-timeout', '2', '--max-time', '5']
     if (proxy) args.push('-x', proxy)
     args.push(url)
-    const child = spawn('curl', args, { stdio: ['pipe', 'pipe', 'pipe'] })
+    let child
+    try {
+      child = spawn('curl', args, { stdio: ['pipe', 'pipe', 'pipe'], shell: true })
+    } catch {
+      resolve({
+        reachable: false, sent: 1, received: 0, loss: 1,
+        lossPercent: 100, rttMin: '', rttAvg: '', rttMax: '', raw: 'curl failed to execute',
+      })
+      return
+    }
     let stdout = ''
     let stderr = ''
     child.stdout.on('data', (d) => { stdout += d })
@@ -204,7 +226,16 @@ function checkByWget(url, proxy) {
       args.push('-e', `use_proxy=yes`, '-e', `https_proxy=${proxy}`, '-e', `http_proxy=${proxy}`)
     }
     args.push(url)
-    const child = spawn('wget', args, { stdio: ['pipe', 'pipe', 'pipe'] })
+    let child
+    try {
+      child = spawn('wget', args, { stdio: ['pipe', 'pipe', 'pipe'], shell: true })
+    } catch {
+      resolve({
+        reachable: false, sent: 1, received: 0, loss: 1,
+        lossPercent: 100, rttMin: '', rttAvg: '', rttMax: '', raw: 'wget failed to execute',
+      })
+      return
+    }
     let stdout = ''
     let stderr = ''
     child.stdout.on('data', (d) => { stdout += d })
@@ -271,7 +302,7 @@ async function checkReachability(address, tool, count, proxy) {
   return { reachable: false, sent: 0, received: 0, loss: 0, lossPercent: 0, rttMin: '', rttAvg: '', rttMax: '', raw: 'No tool available' }
 }
 
-export { checkReachability, extractHostPort }
+export { checkReachability, extractHostPort, httpReachable }
 
 export class PingGroup {
   constructor() {
@@ -298,12 +329,9 @@ export class PingGroup {
     const n = (isNaN(count) || count < 1) ? 4 : count
     const detail = !!(parsed.flags.d || parsed.flags.detail)
 
-    let proxy = ''
-    if ('p' in parsed.flags || 'proxy' in parsed.flags) {
-      let raw = parsed.flags.proxy || parsed.flags.p || ''
-      if (raw === 'true') raw = ''
-      proxy = raw || getActiveProxy()
-    }
+    let proxy = parsed.flags.proxy || parsed.flags.p || ''
+    if (proxy === 'true') proxy = ''
+    if (!proxy) proxy = getActiveProxy()
 
     if (target === 'proxy') {
       return this._pingProxy(n, detail, tool)
@@ -318,7 +346,8 @@ export class PingGroup {
     }
 
     if (proxy) {
-      const usable = await this._checkProxyUsable(proxy, tool, n)
+      const testUrl = isUrl(target) ? target : undefined
+      const usable = await this._checkProxyUsable(proxy, tool, n, testUrl)
       if (!usable.ok) {
         console.error(`[opm] Proxy not usable: ${usable.reason}`)
         process.exit(1)
@@ -331,12 +360,16 @@ export class PingGroup {
   }
 
   /**
-   * 检查代理是否可用：通过代理访问 npm active registry 测试
+   * 检查代理是否可用：通过代理访问指定 URL 测试
+   * @param {string} proxyUrl - 代理地址
+   * @param {string} tool - 检测工具
+   * @param {number} count - ping 包数量
+   * @param {string} [testUrl] - 测试 URL（默认 npm active registry）
    * @returns {{ ok: boolean, reason: string }}
    */
-  async _checkProxyUsable(proxyUrl, tool, count) {
-    const testUrl = getActiveRegistry('npm')
-    const result = await checkReachability(testUrl, tool, count, proxyUrl)
+  async _checkProxyUsable(proxyUrl, tool, count, testUrl) {
+    const url = testUrl || getActiveRegistry('npm')
+    const result = await checkReachability(url, tool, count, proxyUrl)
     if (result.proxyAuthRequired) {
       return { ok: false, reason: 'authentication required (HTTP 407)' }
     }
@@ -376,7 +409,13 @@ export class PingGroup {
     const tools = getRegistryTools()
 
     if (proxy) {
-      const usable = await this._checkProxyUsable(proxy, tool, 1)
+      // 用首个可用 registry URL 作为代理可用性测试目标（而非硬编码 npm）
+      let testUrl = ''
+      for (const t of tools) {
+        const u = getActiveRegistry(t)
+        if (u) { testUrl = u; break }
+      }
+      const usable = await this._checkProxyUsable(proxy, tool, 1, testUrl)
       if (!usable.ok) {
         console.error(`[opm] Proxy not usable: ${usable.reason}`)
         process.exit(1)
@@ -459,7 +498,8 @@ Actions:
 
 Options:
   -c, --count <n>          Number of packets to send (ping only; default: 4)
-  -p, --proxy <url>        Record proxy used for the check (informational)
+  -p, --proxy <url>        Proxy address for the check (overrides config proxy.active;
+                           routes curl/wget requests through the proxy and pre-validates usability)
   -d, --detail             Output full JSON details (default: compact [{tool, address, proxy, reachable}])
   -h, --help               Show this help
 

package/src/cli/index.js

@@ -21,6 +21,7 @@ import { EnsureGroup } from './groups/ensure.js'
 import { PingGroup } from './groups/ping.js'
 import { ProcGroup } from './groups/proc.js'
 import { OverlayGroup } from './groups/overlay.js'
+import { EnvGroup } from './groups/env.js'
 import { FtpGroup } from '../tools/ftp/index.js'
 import { GitGroup } from '../tools/git/index.js'
 import { ShareGroup } from '../tools/share/index.js'
@@ -66,6 +67,7 @@ const GROUPS = {
   ping: new PingGroup(),
   proc: new ProcGroup(),
   overlay: new OverlayGroup(),
+  env: new EnvGroup(),
 }
 
 class CLI {

package/src/index.js

@@ -23,6 +23,7 @@ export { DockerGroup } from './cli/groups/docker.js'
 export { PingGroup } from './cli/groups/ping.js'
 export { ProcGroup } from './cli/groups/proc.js'
 export { OverlayGroup } from './cli/groups/overlay.js'
+export { EnvGroup, parseEnvBlocks, parseRegOutput, isValidEnvKey } from './cli/groups/env.js'
 export { FtpGroup } from './tools/ftp/index.js'
 export { GitGroup } from './tools/git/index.js'
 export { ShareGroup } from './tools/share/index.js'
@@ -62,7 +63,7 @@ export {
 } from './presets.js'
 export { PROXY_PRESETS } from './proxy-presets.js'
 export { output } from './formatter.js'
-export { downloadToFile, fetchText } from './managers/http.js'
+export { downloadToFile, fetchText } from '@wwkit/shared'
 export {
   getConfig, getSection, copyBuiltinConfig, getActiveRegistry, setActiveRegistry,
   getUserConfigDir, getUserConfigFile, getActiveProxy,

package/src/managers/brew.js

@@ -166,6 +166,7 @@ export class BrewManager extends PackageManager {
   _execInherit(args, opts = {}) {
     const result = spawnSync(this._brewBin(), args, {
       stdio: 'inherit',
+      shell: true,
       env: this._buildEnv(opts.proxy),
     })
     if (result.error) {

package/src/managers/bun.js

@@ -2,7 +2,7 @@
  * bun 包管理器实现
  *
  * Bun 是全栈 JS 工具链（runtime + 包管理器 + 打包器）。
- * 包管理命令通过 bun CLI 实现，源查询通过 HTTP 直接查 npm registry。
+ * 包管理命令通过 bun CLI 实现，源查询通过共享 fetchText 查 npm registry。
  * 镜像通过 BUN_CONFIG_REGISTRY 环境变量传递给 bun 命令。
  */
 
@@ -11,6 +11,7 @@ import fs from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
 import { PackageManager } from './base.js'
+import { fetchText } from '@wwkit/shared'
 import { getActiveRegistry, setActiveRegistry } from '../config.js'
 
 export class BunManager extends PackageManager {
@@ -108,52 +109,24 @@ export class BunManager extends PackageManager {
 
   /**
    * 通过 HTTP 查询 npm registry 获取包元数据
+   * 使用共享 fetchText（支持 HTTP/SOCKS5 代理隧道，与 pip/composer 一致）
    * @param {string} pkgName
    * @param {{ proxy?: string }} [opts]
    * @returns {Promise<object|null>}
    * @private
    */
   async _fetchRegistryMetadata(pkgName, opts = {}) {
-    const registry = getActiveRegistry('bun').replace(/\/$/, '')
+    const registry = (getActiveRegistry('bun') || 'https://registry.npmjs.org').replace(/\/$/, '')
     const url = `${registry}/${encodeURIComponent(pkgName).replace('%40', '@')}`
     try {
-      const { default: http } = await import('node:http')
-      const { default: https } = await import('node:https')
-      const client = url.startsWith('https') ? https : http
-      const proxyAgent = opts.proxy ? await this._getProxyAgent(opts.proxy) : null
-      return new Promise((resolve) => {
-        const req = client.get(url, { agent: proxyAgent }, (res) => {
-          let data = ''
-          res.on('data', (chunk) => (data += chunk))
-          res.on('end', () => {
-            try {
-              resolve(JSON.parse(data))
-            } catch {
-              resolve(null)
-            }
-          })
-        })
-        req.on('error', () => resolve(null))
-        req.setTimeout(15000, () => {
-          req.destroy()
-          resolve(null)
-        })
-      })
+      const text = await fetchText(url, { proxy: opts.proxy })
+      if (!text) return null
+      return JSON.parse(text)
     } catch {
       return null
     }
   }
 
-  /**
-   * 获取 proxy agent（简化实现，仅支持 http proxy）
-   * @param {string} proxy
-   * @returns {Promise<undefined>}
-   * @private
-   */
-  async _getProxyAgent(proxy) {
-    return undefined
-  }
-
   async getVersion() {
     try {
       const version = this._exec(['--version'], { allowNonZero: true }).trim()

package/src/managers/composer.js

@@ -14,7 +14,7 @@ import fs from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
 import { PackageManager } from './base.js'
-import { fetchText } from './http.js'
+import { fetchText } from '@wwkit/shared'
 import { getActiveRegistry, setActiveRegistry } from '../config.js'
 
 export class ComposerManager extends PackageManager {

package/src/managers/pip.js

@@ -9,7 +9,7 @@ import { execSync, spawnSync } from 'node:child_process'
 import path from 'node:path'
 import { URL } from 'node:url'
 import { PackageManager } from './base.js'
-import { fetchText } from './http.js'
+import { fetchText } from '@wwkit/shared'
 import { getActiveRegistry, setActiveRegistry } from '../config.js'
 
 export class PipManager extends PackageManager {

package/src/managers/proc.js

@@ -52,7 +52,13 @@ export async function getPortMap() {
   const args = shell.isWindows ? ['-ano'] : ['-tlnp']
 
   return new Promise((resolve) => {
-    const child = spawn(fallback, args, { stdio: ['pipe', 'pipe', 'pipe'] })
+    let child
+    try {
+      child = spawn(fallback, args, { stdio: ['pipe', 'pipe', 'pipe'], shell: true })
+    } catch {
+      resolve(map)
+      return
+    }
     let stdout = ''
     child.stdout.on('data', (d) => { stdout += d })
     child.on('close', () => {

package/src/managers/http.js

@@ -1,432 +0,0 @@
-/**
- * 共享 HTTP 拉取工具（支持代理隧道）
- *
- * 提取自 pip 管理器的 _fetchText 实现，供各包管理器复用：
- * 无代理时使用 native fetch；有代理时根据代理协议建立隧道：
- *   - http(s)://  HTTP 代理：HTTPS 目标走 CONNECT 隧道，HTTP 目标直接以绝对 URI 转发
- *   - socks5(h):// Socks5 代理：握手后隧道转发（支持无认证 / username-password 认证）
- * 支持自动跟随重定向（最多 5 次）。
- */
-
-import fs from 'node:fs'
-import http from 'node:http'
-import net from 'node:net'
-import https from 'node:https'
-import tls from 'node:tls'
-
-/**
- * 建立裸 TCP 连接
- * @param {string} host
- * @param {number} port
- * @param {number} timeout
- * @returns {Promise<import('node:net').Socket>}
- * @private
- */
-function openTcp(host, port, timeout) {
-  return new Promise((resolve, reject) => {
-    const socket = net.connect({ host, port })
-    socket.setTimeout(timeout)
-    socket.setNoDelay(true)
-    socket.once('connect', () => {
-      socket.setTimeout(0)
-      resolve(socket)
-    })
-    socket.once('error', reject)
-    socket.once('timeout', () => {
-      socket.destroy()
-      reject(new Error('tcp connect timeout'))
-    })
-  })
-}
-
-/**
- * 对已连接的 socket 执行 TLS 握手
- * @param {import('node:net').Socket} socket
- * @param {string} host - SNI
- * @param {number} timeout
- * @returns {Promise<import('node:tls').TLSSocket>}
- * @private
- */
-function wrapTls(socket, host, timeout) {
-  return new Promise((resolve, reject) => {
-    const tlsSocket = tls.connect({ socket, servername: host, timeout }, () => {
-      tlsSocket.setTimeout(0)
-      resolve(tlsSocket)
-    })
-    tlsSocket.once('error', (err) => {
-      socket.destroy()
-      reject(err)
-    })
-    tlsSocket.once('timeout', () => {
-      tlsSocket.destroy()
-      reject(new Error('tls handshake timeout'))
-    })
-  })
-}
-
-/**
- * 通过 HTTP 代理建立 CONNECT 隧道
- * @param {URL} proxyUrl
- * @param {string} host
- * @param {number} port
- * @param {number} timeout
- * @returns {Promise<import('node:net').Socket>}
- * @private
- */
-function httpConnect(proxyUrl, host, port, timeout) {
-  return new Promise((resolve, reject) => {
-    const req = http.request({
-      host: proxyUrl.hostname,
-      port: proxyUrl.port || 80,
-      method: 'CONNECT',
-      path: `${host}:${port}`,
-      timeout
-    })
-    req.once('connect', (res, socket) => {
-      if (res.statusCode !== 200) {
-        socket.destroy()
-        reject(new Error(`CONNECT failed: ${res.statusCode}`))
-        return
-      }
-      socket.setTimeout(0)
-      resolve(socket)
-    })
-    req.once('error', reject)
-    req.once('timeout', () => {
-      req.destroy()
-      reject(new Error('CONNECT timeout'))
-    })
-    req.end()
-  })
-}
-
-/**
- * 通过 Socks5 代理建立隧道（RFC 1928）
- *
- * 支持三种地址类型（DOMAIN/IPv4/IPv6）与两种认证方式：
- * 无认证（0x00）、username/password（0x02，RFC 1929）。
- * 代理 URL 带用户名密码时自动使用 0x02 认证。
- *
- * @param {URL} proxyUrl - socks5://host:port 或 socks5://user:pass@host:port
- * @param {string} host - 目标主机名
- * @param {number} port - 目标端口
- * @param {number} timeout
- * @returns {Promise<import('node:net').Socket>}
- * @private
- */
-function socks5Connect(proxyUrl, host, port, timeout) {
-  const auth = proxyUrl.username
-    ? {
-        user: decodeURIComponent(proxyUrl.username),
-        pass: decodeURIComponent(proxyUrl.password || '')
-      }
-    : null
-
-  return openTcp(proxyUrl.hostname, proxyUrl.port || 1080, timeout).then(
-    (socket) =>
-      new Promise((resolve, reject) => {
-        const fail = (err) => {
-          socket.destroy()
-          reject(err instanceof Error ? err : new Error(String(err)))
-        }
-
-        const methods = auth ? [0x00, 0x02] : [0x00]
-        socket.write(Buffer.from([0x05, methods.length, ...methods]))
-
-        let stage = 'greeting'
-        let buf = Buffer.alloc(0)
-
-        const sendConnect = () => {
-          stage = 'connect'
-          const hostBuf = Buffer.from(host, 'utf8')
-          const req = Buffer.alloc(7 + hostBuf.length)
-          req[0] = 0x05
-          req[1] = 0x01
-          req[2] = 0x00
-          req[3] = 0x03
-          req[4] = hostBuf.length
-          hostBuf.copy(req, 5)
-          req.writeUInt16BE(port, 5 + hostBuf.length)
-          socket.write(req)
-        }
-
-        const onData = (chunk) => {
-          buf = Buffer.concat([buf, chunk])
-          try {
-            if (stage === 'greeting') {
-              if (buf.length < 2) return
-              const method = buf.readUInt8(1)
-              buf = buf.subarray(2)
-              if (method === 0xff) {
-                throw new Error('socks5: no acceptable auth method')
-              }
-              if (method === 0x02) {
-                if (!auth) {
-                  throw new Error('socks5: server requires auth, but none provided')
-                }
-                const userBuf = Buffer.from(auth.user, 'utf8')
-                const passBuf = Buffer.from(auth.pass, 'utf8')
-                const req = Buffer.alloc(3 + userBuf.length + passBuf.length)
-                req[0] = 0x01
-                req[1] = userBuf.length
-                userBuf.copy(req, 2)
-                req[2 + userBuf.length] = passBuf.length
-                passBuf.copy(req, 3 + userBuf.length)
-                socket.write(req)
-                stage = 'auth'
-                return
-              }
-              sendConnect()
-              return
-            }
-            if (stage === 'auth') {
-              if (buf.length < 2) return
-              if (buf.readUInt8(1) !== 0x00) {
-                throw new Error('socks5: username/password auth failed')
-              }
-              buf = buf.subarray(2)
-              sendConnect()
-              return
-            }
-            if (stage === 'connect') {
-              if (buf.length < 4) return
-              if (buf.readUInt8(0) !== 0x05) {
-                throw new Error('socks5: invalid reply version')
-              }
-              const rep = buf.readUInt8(1)
-              if (rep !== 0x00) {
-                throw new Error(`socks5: connect failed with code ${rep}`)
-              }
-              const atyp = buf.readUInt8(3)
-              let addrLen
-              if (atyp === 0x01) addrLen = 4
-              else if (atyp === 0x03) addrLen = buf.readUInt8(4) + 1
-              else if (atyp === 0x04) addrLen = 16
-              else {
-                throw new Error('socks5: invalid address type')
-              }
-              const total = 4 + addrLen + 2
-              if (buf.length < total) return
-              cleanup()
-              socket.setTimeout(0)
-              resolve(socket)
-            }
-          } catch (err) {
-            cleanup()
-            fail(err)
-          }
-        }
-
-        const cleanup = () => {
-          socket.removeListener('data', onData)
-          socket.removeListener('error', onError)
-          socket.removeListener('timeout', onTimeout)
-        }
-
-        const onError = (err) => {
-          cleanup()
-          fail(err)
-        }
-
-        const onTimeout = () => {
-          cleanup()
-          fail(new Error('socks5: timeout'))
-        }
-
-        socket.setTimeout(timeout)
-        socket.on('data', onData)
-        socket.on('error', onError)
-        socket.on('timeout', onTimeout)
-      })
-  )
-}
-
-/**
- * 建立到目标主机的隧道 socket（HTTPS 目标会完成 TLS 握手）
- *
- * @param {URL} proxyUrl - 代理 URL
- * @param {string} scheme - 代理协议（http/https/socks5/socks5h）
- * @param {string} host - 目标主机名
- * @param {number} port - 目标端口
- * @param {boolean} isHttps - 目标是否为 HTTPS
- * @param {number} timeout - 超时（ms）
- * @returns {Promise<import('node:net').Socket>}
- * @private
- */
-function tunnelConnect(proxyUrl, scheme, host, port, isHttps, timeout) {
-  if (scheme === 'socks5' || scheme === 'socks5h') {
-    return socks5Connect(proxyUrl, host, port, timeout).then((socket) =>
-      isHttps ? wrapTls(socket, host, timeout) : socket
-    )
-  }
-  if (scheme === 'http' || scheme === 'https') {
-    if (isHttps) {
-      return httpConnect(proxyUrl, host, port, timeout).then((socket) =>
-        wrapTls(socket, host, timeout)
-      )
-    }
-    return openTcp(proxyUrl.hostname, proxyUrl.port || 80, timeout)
-  }
-  return Promise.reject(new Error(`Unsupported proxy scheme: ${scheme}`))
-}
-
-/**
- * 通过代理或直连把 URL 内容流式下载到文件
- *
- * @param {string} url - 请求 URL
- * @param {string} destPath - 目标文件路径
- * @param {{ proxy?: string, timeout?: number, onProgress?: (pct: number) => void }} [opts]
- * @returns {Promise<void>}
- */
-export async function downloadToFile(url, destPath, { proxy, timeout = 600000, onProgress } = {}) {
-  const target = new URL(url)
-  const isHttps = target.protocol === 'https:'
-  const targetPort = target.port || (isHttps ? 443 : 80)
-
-  if (!proxy) {
-    await new Promise((resolve, reject) => {
-      const proto = isHttps ? https : http
-      const req = proto.get(url, { timeout }, (res) => {
-        if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
-          res.resume()
-          const next = new URL(res.headers.location, url).href
-          downloadToFile(next, destPath, { proxy, timeout, onProgress }).then(resolve, reject)
-          return
-        }
-        if (res.statusCode !== 200) {
-          reject(new Error(`HTTP ${res.statusCode}: ${url}`))
-          return
-        }
-        pipeToFile(res, destPath, url, onProgress).then(resolve, reject)
-      })
-      req.on('error', reject)
-      req.on('timeout', () => { req.destroy(); reject(new Error(`下载超时: ${url}`)) })
-    })
-    return
-  }
-
-  const proxyUrl = new URL(proxy)
-  const scheme = proxyUrl.protocol.replace(/:$/, '')
-
-  await new Promise((resolve, reject) => {
-    tunnelConnect(proxyUrl, scheme, target.hostname, targetPort, isHttps, timeout)
-      .then((socket) => {
-        const isProxiedPlainHttp = !isHttps && (scheme === 'http' || scheme === 'https')
-        const req = http.request({
-          createConnection: () => socket,
-          method: 'GET',
-          path: isProxiedPlainHttp ? url : target.pathname + target.search,
-          headers: { Host: target.host },
-          timeout,
-        }, (res) => {
-          if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
-            res.resume()
-            const next = new URL(res.headers.location, url).href
-            downloadToFile(next, destPath, { proxy, timeout, onProgress }).then(resolve, reject)
-            return
-          }
-          if (res.statusCode !== 200) {
-            reject(new Error(`HTTP ${res.statusCode}: ${url}`))
-            return
-          }
-          pipeToFile(res, destPath, url, onProgress).then(resolve, reject)
-        })
-        req.on('error', reject)
-        req.on('timeout', () => { req.destroy(); reject(new Error(`下载超时: ${url}`)) })
-        req.end()
-      })
-      .catch(reject)
-  })
-}
-
-/**
- * 把响应流写入文件（附进度回调）
- * @private
- */
-function pipeToFile(res, destPath, url, onProgress) {
-  return new Promise((resolve, reject) => {
-    const file = fs.createWriteStream(destPath)
-    const total = parseInt(res.headers['content-length'] || '0', 10)
-    let written = 0
-    let lastPct = 0
-    res.on('data', (chunk) => {
-      written += chunk.length
-      if (total > 0 && onProgress) {
-        const pct = Math.floor(written * 100 / total)
-        if (pct >= lastPct + 10 || written === total) {
-          lastPct = pct
-          onProgress(pct)
-        }
-      }
-    })
-    res.pipe(file)
-    file.on('finish', () => { file.close(); resolve() })
-    file.on('error', reject)
-    res.on('error', reject)
-  })
-}
-
-/**
- * 通过代理或直连获取 URL 文本内容
- *
- * @param {string} url - 请求 URL
- * @param {{ proxy?: string, timeout?: number, maxRedirects?: number }} [opts] - 选项
- * @returns {Promise<string|null>}
- */
-export async function fetchText(url, { proxy, timeout = 15000, maxRedirects = 5 } = {}) {
-  if (!proxy) {
-    try {
-      const resp = await fetch(url, { signal: AbortSignal.timeout(timeout) })
-      if (!resp.ok) return null
-      return await resp.text()
-    } catch {
-      return null
-    }
-  }
-
-  const target = new URL(url)
-  const proxyUrl = new URL(proxy)
-  const isHttps = target.protocol === 'https:'
-  const targetPort = target.port || (isHttps ? 443 : 80)
-  const scheme = proxyUrl.protocol.replace(/:$/, '')
-
-  return new Promise((resolve) => {
-    if (maxRedirects <= 0) {
-      resolve(null)
-      return
-    }
-
-    tunnelConnect(proxyUrl, scheme, target.hostname, targetPort, isHttps, timeout)
-      .then((socket) => {
-        // HTTP 目标走 HTTP 代理时，需要发送绝对 URI（RFC 7230 5.3.2）
-        const isProxiedPlainHttp = !isHttps && (scheme === 'http' || scheme === 'https')
-
-        const req = http.request({
-          createConnection: () => socket,
-          method: 'GET',
-          path: isProxiedPlainHttp ? url : target.pathname + target.search,
-          headers: { Host: target.host },
-          timeout
-        }, (response) => {
-          if (response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
-            const redirectUrl = new URL(response.headers.location, url).href
-            fetchText(redirectUrl, { proxy, timeout, maxRedirects: maxRedirects - 1 }).then(resolve)
-            return
-          }
-          if (response.statusCode < 200 || response.statusCode >= 300) {
-            resolve(null)
-            return
-          }
-          let data = ''
-          response.setEncoding('utf8')
-          response.on('data', (chunk) => { data += chunk })
-          response.on('end', () => resolve(data))
-        })
-
-        req.on('error', () => resolve(null))
-        req.on('timeout', () => { req.destroy(); resolve(null) })
-        req.end()
-      })
-      .catch(() => resolve(null))
-  })
-}