@twinsearth/dsh-2xray 0.1.0 → 0.1.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.1.1 — 2026-10-29
+
+### 修复
+
+- 插件启用时报 `cannot get property "subprocess" without inject`：Cordis 会拦截未声明 `inject` 的服务属性读取。改为 `ctx.get('subprocess')` 反射查询，并把 launcher 改为首次 spawn 时惰性解析；服务晚挂载或缺失时分别使用服务 / `child_process` 兜底，不再阻断启用。
+
 ## 0.1.0 — 2026-10-29
 
 首个发布版本（npm：`@twinsearth/dsh-2xray`）。

package/index.js

@@ -1,5 +1,5 @@
 import { normalizeConfig } from './lib/config.js'
-import { createLauncher } from './lib/process.js'
+import { createLazyLauncher } from './lib/process.js'
 import { RouteManager } from './lib/route.js'
 import { Supervisor } from './lib/supervisor.js'
 import { createLogger } from './lib/log.js'
@@ -49,7 +49,7 @@ export function apply(ctx, rawConfig) {
       logger.info('使用旧字段 publicKey 配置 REALITY；xray 会同时读取 password，两者都写可兼容新旧版本')
     }  }
 
-  const launcher = createLauncher(ctx, { logger })
+  const launcher = createLazyLauncher(ctx, { logger })
   const route = new RouteManager({ logger })
   const control =
     config.control.enabled

package/lib/process.js

@@ -3,6 +3,28 @@ import { setTimeout as delay } from 'node:timers/promises'
 
 const COLLECT_BYTES = 64 * 1024
 
+/**
+ * Resolve the subprocess service without tripping Cordis' inject guard.
+ *
+ * Reading `ctx.subprocess` directly throws
+ * `cannot get property "subprocess" without inject` on a fiber that did not
+ * declare it; `ctx.get(name)` is the reflective lookup and returns undefined
+ * instead. The service stays optional because a profile without
+ * `dsh-subprocess-local` still gets the `child_process` fallback.
+ */
+function resolveSubprocess(ctx) {
+  if (!ctx) return undefined
+  try {
+    if (typeof ctx.get === 'function') {
+      const service = ctx.get('subprocess')
+      if (service) return service
+    }
+  } catch {
+    // inactive or guarded context: fall through to the fallback launcher
+  }
+  return undefined
+}
+
 /**
  * A launcher hides whether the child runs through `ctx.subprocess` (Windows Job
  * Object, process-tree containment, DSH's environment scrub) or through a bare
@@ -16,7 +38,7 @@ const COLLECT_BYTES = 64 * 1024
  *   pid?: number
  */
 export function createLauncher(ctx, { logger } = {}) {
-  const service = ctx?.subprocess
+  const service = resolveSubprocess(ctx)
   if (service && typeof service.spawn === 'function' && typeof service.resolveExecutable === 'function') {
     return createServiceLauncher(service)
   }
@@ -24,6 +46,27 @@ export function createLauncher(ctx, { logger } = {}) {
   return createNodeLauncher()
 }
 
+/**
+ * Resolve the launcher lazily at first spawn instead of at activation: the
+ * subprocess provider may mount after this plugin's fiber, and a strict
+ * `inject` dependency would stop the plugin from activating at all.
+ */
+export function createLazyLauncher(ctx, options) {
+  let inner
+  const resolve = () => (inner ??= createLauncher(ctx, options))
+  return {
+    get kind() {
+      return resolve().kind
+    },
+    resolveExecutable(command, env, signal) {
+      return resolve().resolveExecutable(command, env, signal)
+    },
+    spawn(spec) {
+      return resolve().spawn(spec)
+    },
+  }
+}
+
 function createServiceLauncher(service) {
   return {
     kind: 'ctx.subprocess',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@twinsearth/dsh-2xray",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "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",

package/scripts/release-check.mjs

@@ -18,7 +18,7 @@ const check = (name, ok, detail = '') => checks.push({ name, ok, detail })
 const pkg = JSON.parse(readFileSync(join(ROOT, 'package.json'), 'utf8'))
 
 check('name is @twinsearth/dsh-2xray', pkg.name === '@twinsearth/dsh-2xray', pkg.name)
-check('version is 0.1.0', pkg.version === '0.1.0', pkg.version)
+check('version is semver', /^\d+\.\d+\.\d+$/.test(pkg.version), pkg.version)
 check('publishable', pkg.private !== true, `private=${pkg.private}`)
 check('license MIT', pkg.license === 'MIT', String(pkg.license))
 check('type module', pkg.type === 'module', String(pkg.type))

package/test/process.test.js

@@ -0,0 +1,49 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { createLauncher, createLazyLauncher } from '../lib/process.js'
+
+const logger = { warn() {} }
+
+test('a context that guards service properties never throws at activation', () => {
+  const guarded = { get: () => undefined }
+  Object.defineProperty(guarded, 'subprocess', {
+    get() {
+      throw new Error('cannot get property "subprocess" without inject')
+    },
+  })
+  assert.doesNotThrow(() => createLauncher(guarded, { logger }))
+  assert.equal(createLauncher(guarded, { logger }).kind, 'child_process')
+})
+
+test('ctx.get is used when it returns the service', () => {
+  const service = { spawn() {}, resolveExecutable() {} }
+  const ctx = { get: (name) => (name === 'subprocess' ? service : undefined) }
+  assert.equal(createLauncher(ctx, { logger }).kind, 'ctx.subprocess')
+})
+
+test('a context without ctx.get falls back to child_process', () => {
+  assert.equal(createLauncher({}, { logger }).kind, 'child_process')
+  assert.equal(createLauncher(undefined, { logger }).kind, 'child_process')
+})
+
+test('the lazy launcher resolves at first use, so a later-mounted service is seen', () => {
+  let service
+  const ctx = { get: () => service }
+  const lazy = createLazyLauncher(ctx, { logger })
+  service = {
+    spawn() {
+      return {
+        pid: 7,
+        done: Promise.resolve({ exitCode: 0, signal: null }),
+        terminate: async () => {},
+        waitForExit: async () => {},
+        collected: {},
+      }
+    },
+    resolveExecutable() {},
+  }
+  assert.equal(lazy.kind, 'ctx.subprocess')
+  const handle = lazy.spawn({ argv: ['x'], cwd: '.', graceMs: 1, env: {} })
+  assert.equal(handle.kind, 'ctx.subprocess')
+  assert.equal(handle.pid, 7)
+})