@twinsearth/dsh-2xray 0.0.0-stage → 0.1.1

package/lib/control/protobuf.js

@@ -0,0 +1,143 @@
+/**
+ * Minimal protobuf wire-format codec for the three Xray control-plane messages
+ * this plugin needs. Zero dependencies: shipping @grpc/grpc-js + proto-loader
+ * would add a second copy of a large dependency tree to every profile for a
+ * handful of string fields.
+ *
+ * Covered:
+ *   xray.app.router.command.OverrideBalancerTargetRequest { string balancerTag = 1; string target = 2 }
+ *   xray.app.router.command.GetBalancerInfoRequest  { string tag = 1 }
+ *   xray.app.router.command.GetBalancerInfoResponse { BalancerMsg balancer = 1 }
+ *   xray.app.stats.command.QueryStatsRequest  { repeated string patterns = 1; bool reset = 2 }
+ *   xray.app.stats.command.QueryStatsResponse { repeated Stat stat = 1 }
+ *   xray.app.stats.command.Stat { string name = 1; int64 value = 2 }
+ */
+
+export function encodeVarint(value) {
+  let n = BigInt(value)
+  if (n < 0n) throw new RangeError('protobuf varint must be non-negative')
+  const bytes = []
+  while (n > 0x7fn) {
+    bytes.push(Number(n & 0x7fn) | 0x80)
+    n >>= 7n
+  }
+  bytes.push(Number(n))
+  return Buffer.from(bytes)
+}
+
+function readVarint(buffer, start) {
+  let result = 0n
+  let shift = 0n
+  let position = start
+  for (;;) {
+    if (position >= buffer.length) throw new Error('protobuf: truncated varint')
+    const byte = buffer[position++]
+    result |= BigInt(byte & 0x7f) << shift
+    if ((byte & 0x80) === 0) break
+    shift += 7n
+    if (shift > 70n) throw new Error('protobuf: varint too long')
+  }
+  return [result, position]
+}
+
+function fieldKey(field, wireType) {
+  return encodeVarint((BigInt(field) << 3n) | BigInt(wireType))
+}
+
+export function encodeStringField(field, value) {
+  const bytes = Buffer.from(String(value), 'utf8')
+  return Buffer.concat([fieldKey(field, 2), encodeVarint(bytes.length), bytes])
+}
+
+export function encodeMessageField(field, bytes) {
+  return Buffer.concat([fieldKey(field, 2), encodeVarint(bytes.length), bytes])
+}
+
+export function encodeBoolField(field, value) {
+  return Buffer.concat([fieldKey(field, 0), encodeVarint(value ? 1 : 0)])
+}
+
+/** Decode one message into `{ field, wire, value }` entries (value is BigInt for varints). */
+export function decodeFields(buffer) {
+  const fields = []
+  let position = 0
+  while (position < buffer.length) {
+    let tag
+    ;[tag, position] = readVarint(buffer, position)
+    const field = Number(tag >> 3n)
+    const wire = Number(tag & 7n)
+    if (wire === 0) {
+      let value
+      ;[value, position] = readVarint(buffer, position)
+      fields.push({ field, wire, value })
+    } else if (wire === 2) {
+      let length
+      ;[length, position] = readVarint(buffer, position)
+      const end = position + Number(length)
+      if (end > buffer.length) throw new Error('protobuf: truncated length-delimited field')
+      fields.push({ field, wire, value: buffer.subarray(position, end) })
+      position = end
+    } else if (wire === 1) {
+      position += 8
+    } else if (wire === 5) {
+      position += 4
+    } else {
+      throw new Error(`protobuf: unsupported wire type ${wire}`)
+    }
+  }
+  return fields
+}
+
+function stringOf(fields, field) {
+  const entry = fields.find((item) => item.field === field && item.wire === 2)
+  return entry === undefined ? undefined : entry.value.toString('utf8')
+}
+
+function messageOf(fields, field) {
+  const entry = fields.find((item) => item.field === field && item.wire === 2)
+  return entry === undefined ? undefined : entry.value
+}
+
+export function encodeOverrideBalancer({ balancerTag, target }) {
+  return Buffer.concat([encodeStringField(1, balancerTag), encodeStringField(2, target)])
+}
+
+export function encodeGetBalancerInfo({ tag }) {
+  return encodeStringField(1, tag)
+}
+
+export function decodeBalancerInfo(buffer) {
+  const balancer = messageOf(decodeFields(buffer), 1)
+  if (balancer === undefined) return { overrideTarget: undefined, principleTargets: [] }
+  const fields = decodeFields(balancer)
+  const override = messageOf(fields, 5)
+  const principle = messageOf(fields, 6)
+  return {
+    overrideTarget: override === undefined ? undefined : stringOf(decodeFields(override), 2),
+    principleTargets:
+      principle === undefined
+        ? []
+        : decodeFields(principle)
+            .filter((item) => item.field === 1 && item.wire === 2)
+            .map((item) => item.value.toString('utf8')),
+  }
+}
+
+export function encodeQueryStats({ patterns = [], reset = false }) {
+  const parts = patterns.map((pattern) => encodeStringField(1, pattern))
+  if (reset) parts.push(encodeBoolField(2, true))
+  return Buffer.concat(parts)
+}
+
+export function decodeQueryStats(buffer) {
+  const stats = []
+  for (const entry of decodeFields(buffer)) {
+    if (entry.field !== 1 || entry.wire !== 2) continue
+    const fields = decodeFields(entry.value)
+    const name = stringOf(fields, 1)
+    const value = fields.find((item) => item.field === 2 && item.wire === 0)?.value ?? 0n
+    if (name === undefined) continue
+    stats.push({ name, value: Number(value) })
+  }
+  return stats
+}

package/lib/health.js

@@ -0,0 +1,109 @@
+import net from 'node:net'
+import http from 'node:http'
+import { setTimeout as delay } from 'node:timers/promises'
+
+/** One TCP connect attempt; resolves false on error or timeout, never throws. */
+export function tcpConnect(host, port, timeoutMs) {
+  return new Promise((resolve) => {
+    let settled = false
+    const socket = net.connect({ host, port })
+    const finish = (ok) => {
+      if (settled) return
+      settled = true
+      socket.destroy()
+      resolve(ok)
+    }
+    socket.setTimeout(Math.max(50, timeoutMs), () => finish(false))
+    socket.once('connect', () => finish(true))
+    socket.once('error', () => finish(false))
+  })
+}
+
+/** Sleep that returns early when the signal aborts. */
+export async function cancellableDelay(ms, signal) {
+  if (!signal) return delay(ms)
+  if (signal.aborted) return
+  await Promise.race([
+    delay(ms),
+    new Promise((resolve) => {
+      signal.addEventListener('abort', resolve, { once: true })
+    }),
+  ])
+}
+
+/**
+ * Poll the inbound port until it accepts a connection or the budget runs out.
+ * This is the hard readiness gate: the global dispatcher is never pointed at a
+ * port that has not answered a real TCP connect.
+ */
+export async function waitForPort({ host, port, timeoutMs, intervalMs = 100, signal }) {
+  const deadline = Date.now() + timeoutMs
+  while (Date.now() < deadline) {
+    if (signal?.aborted) return false
+    if (await tcpConnect(host, port, 500)) return true
+    await cancellableDelay(intervalMs, signal)
+  }
+  return false
+}
+
+/** Whether a loopback port can be bound right now. */
+export function portIsFree(host, port) {
+  return new Promise((resolve) => {
+    const server = net.createServer()
+    server.unref()
+    server.once('error', () => resolve(false))
+    server.listen({ host, port, exclusive: true }, () => {
+      server.close(() => resolve(true))
+    })
+  })
+}
+
+/**
+ * End-to-end probe: ask the local inbound for a small URL through the proxy
+ * and require a non-error status. This is the only check that proves the
+ * upstream (uuid / flow / SNI / shortId / key) actually works; a TCP connect
+ * alone only proves the inbound is listening.
+ *
+ * @returns {Promise<{ ok: boolean, status?: number, error?: string }>}
+ */
+export function httpProxyProbe({ host, port, url, timeoutMs }) {
+  return new Promise((resolve) => {
+    let target
+    try {
+      target = new URL(url)
+    } catch (error) {
+      resolve({ ok: false, error: `invalid probe url: ${String(error)}` })
+      return
+    }
+    let settled = false
+    const finish = (value) => {
+      if (settled) return
+      settled = true
+      resolve(value)
+    }
+    const request = http.request(
+      {
+        host,
+        port,
+        method: 'GET',
+        // Absolute-form request line: the HTTP inbound proxies this.
+        path: target.href,
+        headers: { host: target.host, connection: 'close' },
+        timeout: timeoutMs,
+      },
+      (response) => {
+        response.resume()
+        const status = response.statusCode ?? 0
+        finish({ ok: status >= 200 && status < 400, status })
+      },
+    )
+    request.on('timeout', () => {
+      request.destroy(new Error('probe timeout'))
+      finish({ ok: false, error: 'timeout' })
+    })
+    request.on('error', (error) => {
+      finish({ ok: false, error: error?.code ?? error?.message ?? 'request failed' })
+    })
+    request.end()
+  })
+}

package/lib/log.js

@@ -0,0 +1,20 @@
+/** Thin adapter over the cordis logger so tests can run without a context. */
+export function createLogger(ctx) {
+  const base = ctx?.logger
+  const emit = (level, args) => {
+    try {
+      if (base && typeof base[level] === 'function') base[level](...args)
+      else if (level === 'debug') console.log(...args)
+      else console[level](...args)
+    } catch {
+      // a logger failure must never break the plugin
+    }
+  }
+  return {
+    info: (...args) => emit('info', args),
+    warn: (...args) => emit('warn', args),
+    error: (...args) => emit('error', args),
+    debug: (...args) => emit('debug', args),
+    raw: base,
+  }
+}

package/lib/paths.js

@@ -0,0 +1,65 @@
+import { createHash } from 'node:crypto'
+import { chmodSync, mkdirSync, renameSync, rmSync, writeFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { dirname, join } from 'node:path'
+
+/**
+ * The harness home. `DSH_HOME` is the documented override; the desktop app
+ * keeps everything under `~/.dsh`.
+ */
+export function resolveDshHome() {
+  const fromEnv = process.env.DSH_HOME?.trim()
+  if (fromEnv) return fromEnv
+  return join(homedir(), '.dsh')
+}
+
+/**
+ * Resolve the plugin data directory and create it with restrictive
+ * permissions. The directory holds the generated xray config, which carries
+ * the VLESS uuid and the REALITY key.
+ *
+ * @param {object} config - normalized config.
+ * @returns {string} absolute data directory.
+ */
+export function resolveDataDir(config) {
+  const dir = config.binary.dataDir?.trim()
+    ? config.binary.dataDir.trim()
+    : join(resolveDshHome(), 'xray-proxy')
+  mkdirSync(dir, { recursive: true, mode: 0o700 })
+  try {
+    chmodSync(dir, 0o700)
+  } catch {
+    // Windows ignores POSIX modes; access is governed by the user's profile.
+  }
+  return dir
+}
+
+export function atomicWriteFile(file, content, mode = 0o600) {
+  const dir = dirname(file)
+  mkdirSync(dir, { recursive: true, mode: 0o700 })
+  const temp = `${file}.${process.pid}.${Date.now()}.tmp`
+  try {
+    writeFileSync(temp, content, { mode })
+    try {
+      chmodSync(temp, mode)
+    } catch {
+      // see resolveDataDir
+    }
+    renameSync(temp, file)
+  } catch (error) {
+    try {
+      rmSync(temp, { force: true })
+    } catch {
+      // best effort
+    }
+    throw error
+  }
+}
+
+export function atomicWriteJson(file, value, mode = 0o600) {
+  atomicWriteFile(file, `${JSON.stringify(value, null, 2)}\n`, mode)
+}
+
+export function sha256(text) {
+  return createHash('sha256').update(text).digest('hex')
+}

package/lib/process.js

@@ -0,0 +1,197 @@
+import { spawn, spawnSync } from 'node:child_process'
+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
+ * `child_process` fallback for compositions without the service.
+ *
+ * Every returned handle has the same small surface:
+ *   done: Promise<{ exitCode, signal, error? }>
+ *   stderrTail(): string
+ *   terminate(): Promise<void>
+ *   waitForExit(): Promise<void>
+ *   pid?: number
+ */
+export function createLauncher(ctx, { logger } = {}) {
+  const service = resolveSubprocess(ctx)
+  if (service && typeof service.spawn === 'function' && typeof service.resolveExecutable === 'function') {
+    return createServiceLauncher(service)
+  }
+  logger?.warn?.('ctx.subprocess 不可用，退化为 child_process 启动；Windows 上将无法保证 Job Object 级别的进程树清理')
+  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',
+    resolveExecutable(command) {
+      return service.resolveExecutable(command, process.env, undefined)
+    },
+    spawn({ argv, cwd, graceMs, env }) {
+      const handle = service.spawn({
+        argv,
+        cwd,
+        stdio: {
+          stdin: 'ignore',
+          stdout: { maxBytes: COLLECT_BYTES },
+          stderr: { maxBytes: COLLECT_BYTES },
+        },
+        graceMs,
+        env,
+      })
+      const done = Promise.resolve(handle.done).then(
+        (outcome) => ({ exitCode: outcome?.exitCode ?? null, signal: outcome?.signal ?? null }),
+        (error) => ({ exitCode: null, signal: null, error }),
+      )
+      const readTail = (which) => {
+        try {
+          return handle.collected?.[which]?.readFrom(0)?.text ?? ''
+        } catch {
+          return ''
+        }
+      }
+      return {
+        kind: 'ctx.subprocess',
+        get pid() {
+          return typeof handle.pid === 'number' ? handle.pid : undefined
+        },
+        done,
+        stdoutTail: () => readTail('stdout'),
+        stderrTail: () => readTail('stderr'),
+        terminate() {
+          return Promise.resolve(handle.terminate()).catch(() => {})
+        },
+        waitForExit() {
+          return Promise.resolve(handle.waitForExit()).catch(() => {})
+        },
+      }
+    },
+  }
+}
+
+function createNodeLauncher() {
+  return {
+    kind: 'child_process',
+    async resolveExecutable(command) {
+      return command
+    },
+    spawn({ argv, cwd, graceMs, env }) {
+      const child = spawn(argv[0], argv.slice(1), {
+        cwd,
+        env: env ?? process.env,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        windowsHide: true,
+      })
+      let stderr = ''
+      let stdout = ''
+      child.stderr?.on('data', (chunk) => {
+        stderr += chunk.toString('utf8')
+        if (stderr.length > COLLECT_BYTES) stderr = stderr.slice(-COLLECT_BYTES)
+      })
+      child.stdout?.on('data', (chunk) => {
+        stdout += chunk.toString('utf8')
+        if (stdout.length > COLLECT_BYTES) stdout = stdout.slice(-COLLECT_BYTES)
+      })
+
+      let settled = false
+      let resolveExit
+      const exited = new Promise((resolve) => {
+        resolveExit = resolve
+      })
+      const settle = (value) => {
+        if (settled) return
+        settled = true
+        resolveExit(value)
+      }
+      child.once('error', (error) => settle({ exitCode: null, signal: null, error }))
+      child.once('exit', (code, signal) => settle({ exitCode: code, signal }))
+
+      let terminating
+      return {
+        kind: 'child_process',
+        get pid() {
+          return child.pid
+        },
+        done: exited,
+        stdoutTail: () => stdout,
+        stderrTail: () => stderr,
+        terminate() {
+          if (terminating) return terminating
+          terminating = (async () => {
+            if (child.exitCode !== null || child.signalCode !== null) return
+            if (process.platform === 'win32') {
+              if (typeof child.pid === 'number') {
+                spawnSync('taskkill', ['/pid', String(child.pid), '/T', '/F'], { windowsHide: true })
+              }
+              await Promise.race([exited, delay(1500).then(() => {})])
+              return
+            }
+            try {
+              child.kill('SIGTERM')
+            } catch {
+              // already gone
+            }
+            const exitedInTime = await Promise.race([exited.then(() => true), delay(graceMs).then(() => false)])
+            if (!exitedInTime) {
+              try {
+                child.kill('SIGKILL')
+              } catch {
+                // already gone
+              }
+            }
+          })()
+          return terminating
+        },
+        waitForExit() {
+          return exited.then(() => {})
+        },
+      }
+    },
+  }
+}