@twinsearth/dsh-2xray 0.2.8 → 0.2.9

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.2.9 — 2026-10-29
+
+### 内核分发
+
+- 新增按平台拆分的可选内核包（`@twinsearth/dsh-2xray-core-<os>-<arch>`），主包通过 `optionalDependencies` 引用，npm 只装当前平台。
+- `resolveBinary()` 新增 `core-package` 来源；未安装时继续回退到插件 `bin/`、数据目录、v2rayN 发现与 PATH。
+- 新增 `tools/build-core-packages.mjs`（官方 zip → npm 包）与 `.github/workflows/core-packages.yml`（下载、`.dgst` 校验、发布；无 `NPM_TOKEN` 时只上传 artifact）。
+
+### 验证
+
+- 真机 xray 26.9.30 对 global / cn-direct / whitelist 三种配置执行 `run -test` 全部通过（含 geodata 与 IPIfNonMatch）。
+
 ## 0.2.8 — 2026-10-29
 
 ### 修复

package/README.md

@@ -328,6 +328,12 @@ v0.2.0 提供两个入口，互不替代：
 | 状态一直 `degraded` + `route-install-failed` | 查日志里的模块解析诊断；必要时确认 DSH 安装目录结构 |
 | `xray_switch_node` 报 `unknown service ... RoutingService` | xray 版本早于 2024-09；升级二进制，或关闭 `control.enabled` 只用 `activeNode` |
 
+### 平台内核包
+
+`@twinsearth/dsh-2xray` 通过 `optionalDependencies` 引用按平台拆分的核心包（例如 `@twinsearth/dsh-2xray-core-win32-x64`），npm 只安装当前平台那一个。本地没有可用内核包时，仍按 `插件 bin/ → 数据目录 → v2rayN 发现 → PATH` 回退，或用 `tools/install-xray-core.mjs` 安装。
+
+维护者用 `tools/build-core-packages.mjs` 从官方 zip 生成平台包；`.github/workflows/core-packages.yml` 会在具备 `NPM_TOKEN` secret 时自动下载、校验并发布各平台包。
+
 ## 路由模式与黑白名单
 
 - `global`（默认）：全部流量走 2Xray。

package/lib/binary.js

@@ -1,5 +1,6 @@
 import { accessSync, constants, existsSync, readdirSync } from 'node:fs'
-import { delimiter, join } from 'node:path'
+import { createRequire } from 'node:module'
+import { delimiter, dirname, join } from 'node:path'
 import { fileURLToPath } from 'node:url'
 
 /** Package root, so a bundle that ships its own `bin/xray(.exe)` is found first. */
@@ -29,6 +30,23 @@ function executableName() {
   return process.platform === 'win32' ? 'xray.exe' : 'xray'
 }
 
+/**
+ * Platform cores are published as separate optional packages so the main
+ * package stays small. npm installs only the matching os/cpu one.
+ */
+export function optionalCorePaths({ platform = process.platform, arch = process.arch, resolvePackage } = {}) {
+  const name = `@twinsearth/dsh-2xray-core-${platform}-${arch}`
+  const resolver = resolvePackage ?? ((specifier) => createRequire(import.meta.url).resolve(specifier))
+  try {
+    const manifest = resolver(`${name}/package.json`)
+    const base = dirname(manifest)
+    const executable = platform === 'win32' ? 'xray.exe' : 'xray'
+    return [...new Set([join(base, 'bin', executable), join(base, 'bin', 'xray')])]
+  } catch {
+    return []
+  }
+}
+
 function isExecutable(file) {
   try {
     accessSync(file, constants.X_OK)
@@ -56,12 +74,16 @@ export async function resolveBinary({
   packageRoot = PACKAGE_ROOT,
   discoveryRoots,
   discoveryOptions = {},
+  resolvePackage,
 }) {
   const candidates = []
   const explicit = config.binary.path?.trim()
   if (explicit) candidates.push({ path: explicit, source: 'config' })
   const fromEnv = process.env.DSH_XRAY_BIN?.trim()
   if (fromEnv) candidates.push({ path: fromEnv, source: 'env' })
+  for (const path of optionalCorePaths({ resolvePackage })) {
+    candidates.push({ path, source: 'core-package' })
+  }
   candidates.push({ path: join(packageRoot, 'bin', executableName()), source: 'bundled' })
   candidates.push({ path: join(packageRoot, 'bin', 'xray'), source: 'bundled' })
   candidates.push({ path: join(dataDir, 'bin', executableName()), source: 'managed' })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@twinsearth/dsh-2xray",
-  "version": "0.2.8",
+  "version": "0.2.9",
   "private": false,
   "description": "DSH-2Xray: supervises xray-core and routes DSH process-wide HTTP(S) traffic through its local inbound, with optional multi-node gRPC control plane",
   "type": "module",
@@ -48,5 +48,8 @@
       ],
       "platform": "web"
     }
+  },
+  "optionalDependencies": {
+    "@twinsearth/dsh-2xray-core-win32-x64": "0.2.9"
   }
 }

package/test/binary.test.js

@@ -3,7 +3,7 @@ import assert from 'node:assert/strict'
 import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
-import { BinaryError, resolveBinary } from '../lib/binary.js'
+import { BinaryError, optionalCorePaths, resolveBinary } from '../lib/binary.js'
 import { normalizeConfig } from '../lib/config.js'
 
 const packageRoot = join('C:', 'plugins', 'dsh-2xray')
@@ -129,3 +129,14 @@ test('discovers a v2rayN layout when nothing else resolves', async () => {
     rmSync(dir, { recursive: true, force: true })
   }
 })
+
+test('optional platform core packages resolve on their own platform', () => {
+  const manifest = join('C:', 'profile', 'node_modules', '@twinsearth', 'dsh-2xray-core-darwin-arm64', 'package.json')
+  const paths = optionalCorePaths({
+    platform: 'darwin',
+    arch: 'arm64',
+    resolvePackage: () => manifest,
+  })
+  assert.deepEqual(paths, [join('C:', 'profile', 'node_modules', '@twinsearth', 'dsh-2xray-core-darwin-arm64', 'bin', 'xray')])
+  assert.deepEqual(optionalCorePaths({ platform: 'darwin', arch: 'arm64', resolvePackage: () => { throw new Error('missing') } }), [])
+})

package/tools/build-core-packages.mjs

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+/**
+ * Turn official Xray-core zips into per-platform npm packages.
+ *
+ * npm installs only the package whose `os`/`cpu` matches, so the main package
+ * can depend on all of them without downloading five cores. CI can run this on
+ * each runner (where GitHub release downloads work); locally it also accepts a
+ * directory of already-downloaded zips.
+ *
+ * Usage:
+ *   node tools/build-core-packages.mjs --zips ./vendor/zips --out ./dist-core --version 0.2.9
+ *
+ * Expected zip names (official release assets):
+ *   Xray-windows-64.zip, Xray-windows-arm64-v8a.zip
+ *   Xray-macos-64.zip, Xray-macos-arm64-v8a.zip
+ *   Xray-linux-64.zip, Xray-linux-arm64-v8a.zip
+ */
+import { copyFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { spawnSync } from 'node:child_process'
+
+const TARGETS = [
+  { zip: 'Xray-windows-64.zip', pkg: 'win32-x64', os: 'win32', cpu: 'x64', exe: 'xray.exe' },
+  { zip: 'Xray-windows-arm64-v8a.zip', pkg: 'win32-arm64', os: 'win32', cpu: 'arm64', exe: 'xray.exe' },
+  { zip: 'Xray-macos-64.zip', pkg: 'darwin-x64', os: 'darwin', cpu: 'x64', exe: 'xray' },
+  { zip: 'Xray-macos-arm64-v8a.zip', pkg: 'darwin-arm64', os: 'darwin', cpu: 'arm64', exe: 'xray' },
+  { zip: 'Xray-linux-64.zip', pkg: 'linux-x64', os: 'linux', cpu: 'x64', exe: 'xray' },
+  { zip: 'Xray-linux-arm64-v8a.zip', pkg: 'linux-arm64', os: 'linux', cpu: 'arm64', exe: 'xray' },
+]
+
+function args() {
+  const parsed = {}
+  for (let index = 2; index < process.argv.length; index += 2) {
+    const key = process.argv[index].replace(/^--/, '')
+    parsed[key] = process.argv[index + 1]
+  }
+  return {
+    zips: parsed.zips ?? './vendor/zips',
+    out: parsed.out ?? './dist-core',
+    version: parsed.version ?? JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version,
+  }
+}
+
+function extract(zip, destination) {
+  const attempts =
+    process.platform === 'win32'
+      ? [['tar', ['-xf', zip, '-C', destination]], ['powershell', ['-NoProfile', '-Command', `Expand-Archive -LiteralPath '${zip}' -DestinationPath '${destination}' -Force`]]]
+      : [['unzip', ['-o', zip, '-d', destination]], ['tar', ['-xf', zip, '-C', destination]]]
+  for (const [command, argv] of attempts) {
+    if (spawnSync(command, argv, { stdio: 'ignore' }).status === 0) return
+  }
+  throw new Error(`could not extract ${zip}`)
+}
+
+function findBinary(dir, name) {
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const full = join(dir, entry.name)
+    if (entry.isFile() && entry.name === name) return full
+    if (entry.isDirectory()) {
+      const nested = findBinary(full, name)
+      if (nested) return nested
+    }
+  }
+  return undefined
+}
+
+const options = args()
+mkdirSync(options.out, { recursive: true })
+const built = []
+for (const target of TARGETS) {
+  const zip = join(options.zips, target.zip)
+  if (!existsSync(zip)) {
+    console.log(`skip ${target.pkg}: ${target.zip} not present`)
+    continue
+  }
+  const workspace = mkdtempSync(join(tmpdir(), `dsh-core-${target.pkg}-`))
+  try {
+    extract(zip, workspace)
+    const binary = findBinary(workspace, target.exe)
+    if (!binary) throw new Error(`${target.exe} not found in ${target.zip}`)
+    const packageName = `@twinsearth/dsh-2xray-core-${target.pkg}`
+    const dir = join(options.out, `dsh-2xray-core-${target.pkg}`)
+    mkdirSync(join(dir, 'bin'), { recursive: true })
+    copyFileSync(binary, join(dir, 'bin', target.exe))
+    writeFileSync(
+      join(dir, 'package.json'),
+      JSON.stringify(
+        {
+          name: packageName,
+          version: options.version,
+          description: `Xray-core binary for ${target.pkg} (DSH-2Xray optional dependency)`,
+          license: 'MPL-2.0',
+          os: [target.os],
+          cpu: [target.cpu],
+          files: ['bin'],
+        },
+        null,
+        2,
+      ) + '\n',
+    )
+    built.push({ name: packageName, dir, size: statSync(join(dir, 'bin', target.exe)).size })
+  } finally {
+    rmSync(workspace, { recursive: true, force: true })
+  }
+}
+
+for (const entry of built) {
+  console.log(`built ${entry.name} (${Math.round(entry.size / 1048576)} MB) -> ${entry.dir}`)
+}
+if (built.length === 0) {
+  console.log(`no zips found in ${options.zips}`)
+  process.exitCode = 1
+}