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

package/lib/tools.js

@@ -0,0 +1,106 @@
+import { loadHarnessModule } from './route.js'
+
+/**
+ * Model-facing tools for the control plane. Registered lazily and optionally:
+ * a profile without the `tools` service, or a layout where `@deepseek-ai/dsh-tools`
+ * cannot be resolved, keeps the proxy working and just skips the tools.
+ *
+ * `defineTool` is imported from the harness installation because the tool
+ * registry validates and renders through that exact module instance.
+ */
+export async function installTools({ ctx, supervisor, logger, loadToolsModule = loadHarnessModule }) {
+  if (typeof ctx.inject !== 'function') {
+    logger?.debug?.('ctx.inject 不可用，跳过 xray_* 工具注册')
+    return false
+  }
+  const found = await loadToolsModule('@deepseek-ai/dsh-tools')
+  const defineTool = found?.module?.defineTool
+  if (typeof defineTool !== 'function') {
+    logger?.warn?.('找不到 @deepseek-ai/dsh-tools，xray_* 工具未注册；插件其余功能不受影响')
+    return false
+  }
+
+  ctx.inject(['tools'], (child) => {
+    try {
+      child.tools.register(
+        defineTool({
+          name: 'xray_status',
+          description:
+            'Show the Xray proxy supervisor status: process state, route takeover, functional probe, active node and control-plane reachability. Read-only.',
+          parameters: {},
+          output: {
+            schema: { type: 'string' },
+            render: (_args, value) => [{ type: 'text', text: String(value) }],
+          },
+          async execute() {
+            return JSON.stringify(supervisor.snapshot(), null, 2)
+          },
+        }),
+      )
+
+      child.tools.register(
+        defineTool({
+          name: 'xray_validate_config',
+          description:
+            'Validate the Xray config generated from the current settings with `xray run -test`, without starting, stopping or restarting the proxy. Read-only pre-flight; returns { ok, detail, configHash }.',
+          parameters: {},
+          output: {
+            schema: { type: 'string' },
+            render: (_args, value) => [{ type: 'text', text: String(value) }],
+          },
+          async execute() {
+            return JSON.stringify(await supervisor.validateConfig())
+          },
+        }),
+      )
+
+      child.tools.register(
+        defineTool({
+          name: 'xray_switch_node',
+          description:
+            'Switch the active Xray outbound to a configured node without restarting the process. The local inbound and the harness proxy policy stay untouched. Returns the pinned outbound tag.',
+          parameters: {
+            node: {
+              type: 'string',
+              required: true,
+              description: 'Node id or outbound tag from the plugin config, e.g. "hk-01" or "proxy-hk-01".',
+            },
+          },
+          output: {
+            schema: { type: 'string' },
+            render: (_args, value) => [{ type: 'text', text: String(value) }],
+          },
+          async execute(args) {
+            const activeNode = await supervisor.switchNode(args.node)
+            return JSON.stringify({ activeNode })
+          },
+        }),
+      )
+
+      child.tools.register(
+        defineTool({
+          name: 'xray_stats',
+          description:
+            'Read cumulative traffic counters per configured node (uplink/downlink bytes since Xray started). Counters are not a rate; pass reset=true to zero them after reading.',
+          parameters: {
+            reset: {
+              type: 'boolean',
+              description: 'Reset the counters after this read. Defaults to false.',
+            },
+          },
+          output: {
+            schema: { type: 'string' },
+            render: (_args, value) => [{ type: 'text', text: String(value) }],
+          },
+          async execute(args) {
+            return JSON.stringify(await supervisor.queryStats({ reset: args.reset === true }))
+          },
+        }),
+      )
+      logger?.info?.('已注册 xray_status / xray_switch_node / xray_stats 工具')
+    } catch (error) {
+      logger?.warn?.(`注册 xray_* 工具失败：${String(error)}`)
+    }
+  })
+  return true
+}

package/lib/xray-config.js

@@ -0,0 +1,225 @@
+/**
+ * Pure builder for the xray-core client config. No I/O, no logging of secrets:
+ * the caller writes the result to disk and only ever logs its hash.
+ *
+ * Single node (the legacy `server.*` shape): one VLESS outbound and a
+ * catch-all routing rule straight to it — the same config this plugin has
+ * always produced.
+ *
+ * Multiple nodes (`nodes[]`): one outbound per node plus a balancer. The
+ * balancer is the runtime switch point: `RoutingService.OverrideBalancerTarget`
+ * pins it to one outbound without touching the process. Outbound configs are
+ * static because `HandlerService.AddOutbound` would require protobuf-encoding
+ * `OutboundHandlerConfig` (TypedMessage sender/proxy settings) on the Node
+ * side, which is far more fragile than a two-string override.
+ *
+ * The control plane (`control.enabled`) adds the standard API inbound plus the
+ * `api` routing rule, and optionally the stats counters.
+ */
+
+const PRIVATE_IP_RULES = ['geoip:private']
+const API_TAG = 'api'
+
+function escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}
+
+function buildOutbound(node) {
+  const users = [{ id: node.uuid, encryption: 'none' }]
+  if (node.flow) users[0].flow = node.flow
+
+  const streamSettings = {
+    network: node.network === 'tcp' ? 'raw' : node.network,
+    security: node.security,
+  }
+
+  if (node.security === 'reality') {
+    streamSettings.realitySettings = {
+      serverName: node.serverName,
+      fingerprint: node.fingerprint,
+      shortId: node.shortId,
+      spiderX: node.spiderX,
+      show: false,
+    }
+    // Write both spellings: current Xray reads `password` and new configs use
+    // it, older builds still parse `publicKey`. Never write both empty.
+    if (node.password) streamSettings.realitySettings.password = node.password
+    if (node.publicKey) streamSettings.realitySettings.publicKey = node.publicKey
+  } else if (node.security === 'tls') {
+    streamSettings.tlsSettings = {
+      serverName: node.serverName,
+      fingerprint: node.fingerprint,
+    }
+  }
+
+  return {
+    tag: node.tag,
+    protocol: 'vless',
+    settings: {
+      vnext: [
+        {
+          address: node.address,
+          port: node.port,
+          users,
+        },
+      ],
+    },
+    streamSettings,
+    // Vision already carries XUDP; mux only adds latency here.
+    mux: { enabled: false },
+  }
+}
+
+/**
+ * Build the xray-core JSON config.
+ *
+ * @param {object} config - normalized config from `normalizeConfig()`.
+ * @returns {object} xray-core configuration object.
+ */
+export function buildXrayConfig(config) {
+  const { inbound, routing, log, control } = config
+  const nodes = config.nodes
+
+  const inbounds = []
+  const primaryProtocol = inbound.protocol === 'socks' ? 'socks' : 'http'
+  inbounds.push({
+    tag: `${primaryProtocol}-in`,
+    listen: inbound.host,
+    port: inbound.port,
+    protocol: primaryProtocol,
+    settings: primaryProtocol === 'socks' ? { auth: 'noauth', udp: false } : {},
+    sniffing:
+      primaryProtocol === 'socks'
+        ? { enabled: true, destOverride: ['http', 'tls'], routeOnly: false }
+        : { enabled: false },
+  })
+
+  if (inbound.socks.enabled) {
+    inbounds.push({
+      tag: 'socks-in',
+      listen: inbound.socks.host,
+      port: inbound.socks.port,
+      protocol: 'socks',
+      settings: { auth: 'noauth', udp: inbound.socks.udp },
+      // Sniffing only ever belongs to an inbound. `routeOnly: false` resets the
+      // destination to the recovered domain so the proxy outbound can resolve
+      // it remotely instead of the client resolving it locally.
+      sniffing: { enabled: true, destOverride: ['http', 'tls'], routeOnly: false },
+    })
+  }
+
+  if (control.enabled) {
+    inbounds.push({
+      tag: API_TAG,
+      listen: control.host,
+      port: control.port,
+      protocol: 'dokodemo-door',
+      settings: { address: '127.0.0.1' },
+    })
+  }
+
+  const proxyOutbounds = nodes.map((node) => buildOutbound(node))
+  const outbounds = [
+    ...proxyOutbounds,
+    {
+      tag: 'direct',
+      protocol: 'freedom',
+      settings: {},
+      streamSettings: {
+        sockopt: {
+          // Direct domains resolve through the system resolver, which is where
+          // split-horizon/VPN/internal DNS lives. Proxy traffic keeps local DNS
+          // at zero because the proxy outbound resolves remotely.
+          domainStrategy: 'AsIs',
+        },
+      },
+    },
+    { tag: 'block', protocol: 'blackhole' },
+  ]
+
+  const rules = []
+  if (control.enabled) {
+    rules.push({ type: 'field', inboundTag: [API_TAG], outboundTag: API_TAG })
+  }
+  if (routing.blockAds) {
+    rules.push({ type: 'field', domain: ['geosite:category-ads-all'], outboundTag: 'block' })
+  }
+  rules.push({ type: 'field', ip: PRIVATE_IP_RULES, outboundTag: 'direct' })
+
+  const bypassDomains = dedupe(routing.bypassDomains)
+  if (bypassDomains.length > 0) {
+    // A trailing dot entry matches the domain and every subdomain in Xray's
+    // domain matcher; `geosite:cn` is opt-in because a catch-all would
+    // otherwise make the second routing pass unreachable.
+    rules.push({ type: 'field', domain: bypassDomains.map((entry) => `domain:${entry}`), outboundTag: 'direct' })
+  }
+
+  if (routing.geositeCn) {
+    rules.push({ type: 'field', domain: ['geosite:cn'], outboundTag: 'direct' })
+  }
+
+  const balancers = []
+  if (nodes.length > 1) {
+    balancers.push({
+      tag: control.balancerTag,
+      // Every node is a candidate; the runtime override pins one, and until an
+      // override lands the strategy picks deterministically enough to be
+      // usable.
+      selector: nodes.map((node) => `^${escapeRegExp(node.tag)}$`),
+      strategy: { type: 'random' },
+    })
+    rules.push({ type: 'field', network: 'tcp,udp', balancerTag: control.balancerTag })
+  } else {
+    rules.push({ type: 'field', network: 'tcp,udp', outboundTag: nodes[0].tag })
+  }
+
+  const policy = {
+    levels: { '0': { handshake: 8, connIdle: 600 } },
+  }
+  if (control.enabled && control.stats) {
+    policy.system = {
+      statsInboundUplink: true,
+      statsInboundDownlink: true,
+      statsOutboundUplink: true,
+      statsOutboundDownlink: true,
+    }
+  }
+
+  const built = {
+    log: {
+      loglevel: log.level,
+      access: 'none',
+      dnsLog: false,
+    },
+    // Keep connections alive past the harness' 300s stream idle watchdog so
+    // Xray never sends the clean FIN that becomes a non-retryable
+    // STREAM_CLOSED in the model provider.
+    policy,
+    inbounds,
+    outbounds,
+    routing: {
+      domainStrategy: 'AsIs',
+      rules,
+      ...(balancers.length > 0 ? { balancers } : {}),
+    },
+  }
+
+  if (control.enabled) {
+    built.api = { tag: API_TAG, services: control.services }
+    if (control.stats) built.stats = {}
+  }
+
+  return built
+}
+
+function dedupe(entries) {
+  const seen = new Set()
+  const out = []
+  for (const raw of entries ?? []) {
+    const entry = String(raw).trim()
+    if (!entry || seen.has(entry)) continue
+    seen.add(entry)
+    out.push(entry)
+  }
+  return out
+}

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Xray Proxy",
+    "description": "Supervises an xray-core child process and routes the harness' global HTTP(S) traffic through its local inbound."
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Xray 代理",
+    "description": "托管 xray-core 子进程，并把 DSH 进程内的全局 HTTP(S) 流量导入它的本地入站。"
+  }
+}

package/package.json

@@ -1,6 +1,44 @@
 {
   "name": "@twinsearth/dsh-2xray",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "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",
+  "main": "index.js",
+  "exports": {
+    ".": "./index.js",
+    "./package.json": "./package.json",
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./locale/*.json": "./locale/*.json",
+    "./icon": "./icon.svg"
+  },
+  "files": [
+    "index.js",
+    "lib/*.js",
+    "lib/control/*.js",
+    "cordis.patch.yml",
+    "locale/*.json",
+    "icon.svg",
+    "bin/*",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE",
+    "docs/*.md",
+    "examples/*.json",
+    "scripts/*.mjs",
+    "test/*.js"
+  ],
+  "scripts": {
+    "test": "node --test --test-isolation=none test/*.test.js",
+    "check": "node scripts/release-check.mjs"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "license": "MIT",
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  }
+}

package/scripts/check-config.mjs

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+/**
+ * Build a config for a JSON config file and validate it with a real xray binary:
+ *
+ *   node scripts/check-config.mjs --config my.json --xray C:\path\to\xray.exe
+ *
+ * `--security none --network tcp --flow ""` in the JSON downgrades the stream
+ * for old binaries that predate REALITY. The generated file is written to the
+ * OS temp directory and printed so the exact bytes can be inspected.
+ */
+import { mkdtempSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { spawnSync } from 'node:child_process'
+import { normalizeConfig } from '../lib/config.js'
+import { buildXrayConfig } from '../lib/xray-config.js'
+
+const args = process.argv.slice(2)
+const getArg = (name) => {
+  const index = args.indexOf(name)
+  return index === -1 ? undefined : args[index + 1]
+}
+
+const configPath = getArg('--config')
+const xray = getArg('--xray') ?? process.env.XRAY_BIN
+if (!configPath || !xray) {
+  console.error('usage: node scripts/check-config.mjs --config <json> --xray <path>')
+  process.exit(2)
+}
+
+const { readFileSync } = await import('node:fs')
+const raw = JSON.parse(readFileSync(configPath, 'utf8'))
+const result = normalizeConfig(raw)
+if (result.errors.length > 0) {
+  for (const error of result.errors) console.error(`${error.field}: ${error.message}`)
+  process.exit(3)
+}
+
+const built = buildXrayConfig(result.config)
+if (args.includes('--legacy')) {
+  // Pre-1.8 binaries call the raw transport "tcp" and reject "raw".
+  for (const outbound of built.outbounds) {
+    if (outbound.streamSettings?.network === 'raw') outbound.streamSettings.network = 'tcp'
+  }
+}
+const dir = mkdtempSync(join(tmpdir(), 'dsh-xray-check-'))
+const file = join(dir, 'xray-config.json')
+writeFileSync(file, `${JSON.stringify(built, null, 2)}\n`, { mode: 0o600 })
+console.log(`config: ${file}`)
+
+const outcome = spawnSync(xray, ['run', '-test', '-c', file], { stdio: 'inherit' })
+if (outcome.status !== 0) {
+  console.error(`xray run -test exited ${outcome.status ?? outcome.error?.code ?? 'unknown'}`)
+  process.exit(1)
+}
+console.log('Configuration OK.')

package/scripts/parse-share-link.mjs

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+/**
+ * Convert one or more `vless://` share links (the text a QR code carries) into
+ * the `nodes[]` JSON this plugin accepts:
+ *
+ *   node scripts/parse-share-link.mjs "vless://uuid@host:443?security=reality&..."
+ *
+ * Paste the printed array under `nodes:` in cordis.patch.yml, or pass the link
+ * directly as `shareLink: "<link>"` and let the plugin parse it at load time.
+ */
+import { parseShareLinks } from '../lib/share-link.js'
+
+const links = process.argv.slice(2)
+if (links.length === 0) {
+  console.error('usage: node scripts/parse-share-link.mjs <vless://...> [more links]')
+  process.exit(2)
+}
+
+const { nodes, errors, warnings } = parseShareLinks(links)
+for (const warning of warnings) console.error(`warning: ${warning}`)
+for (const error of errors) console.error(`error: ${error.field}: ${error.message}`)
+if (nodes.length > 0) console.log(JSON.stringify(nodes, null, 2))
+if (errors.length > 0) process.exitCode = 1

package/scripts/probe-routing.mjs

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+/**
+ * Real-runtime routing probe (run it under the DSH runtime, see docs/EVIDENCE.md):
+ *
+ *   ELECTRON_RUN_AS_NODE=1 "E:\DS\DeepSeek Harness.exe" scripts/probe-routing.mjs
+ *
+ * It starts a fake local HTTP proxy, installs the plugin's route manager
+ * against it, and asserts:
+ *   1. globalThis.fetch is proxied (absolute-form request line reaches the proxy,
+ *      and a name that cannot resolve directly still gets a response);
+ *   2. loopback traffic bypasses the proxy (origin-form request line);
+ *   3. restore hands the dispatcher back (the same direct fetch then fails to
+ *      resolve, i.e. it is no longer tunnelled).
+ *
+ * Exits non-zero on the first failed assertion.
+ */
+import http from 'node:http'
+import { RouteManager } from '../lib/route.js'
+
+const logger = { info() {}, warn() {}, error() {}, debug() {} }
+const failures = []
+const check = (label, condition) => {
+  console.log(`${condition ? 'PASS' : 'FAIL'} ${label}`)
+  if (!condition) failures.push(label)
+}
+
+const seen = []
+const server = http.createServer((req, res) => {
+  seen.push(req.url)
+  res.writeHead(200, { 'content-type': 'text/plain' })
+  res.end('via-local-proxy')
+})
+const port = await new Promise((resolve) => server.listen(0, '127.0.0.1', () => resolve(server.address().port)))
+console.log(`fake proxy on 127.0.0.1:${port}`)
+
+const route = new RouteManager({ logger })
+const snapshot = await route.install({ proxyUrl: `http://127.0.0.1:${port}` })
+check('route installed through the harness policy', snapshot.installed && snapshot.mode === 'harness')
+
+try {
+  const proxied = await fetch('http://probe.invalid/x')
+  const body = await proxied.text()
+  check('proxied fetch got the proxy answer', proxied.status === 200 && body === 'via-local-proxy')
+  check('proxy saw an absolute-form request line', seen.at(-1) === 'http://probe.invalid/x')
+
+  await fetch(`http://127.0.0.1:${port}/direct`)
+  check('loopback traffic bypassed the proxy', seen.at(-1) === '/direct')
+} catch (error) {
+  check(`proxied fetch threw: ${error.message}`, false)
+}
+
+await route.restore()
+try {
+  await fetch('http://probe.invalid/y')
+  check('post-restore fetch is direct again', false)
+} catch (error) {
+  check('post-restore fetch is direct again (ENOTFOUND)', error.cause?.code === 'ENOTFOUND')
+}
+server.close()
+
+if (failures.length > 0) {
+  console.error(`\n${failures.length} check(s) failed`)
+  process.exitCode = 1
+} else {
+  console.log('\nall routing checks passed')
+}

package/scripts/release-check.mjs

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+/**
+ * Release self-check: identity, allow-list, secrets, packaging and doc gates.
+ *
+ *   node scripts/release-check.mjs
+ *
+ * Exit 0 = all checks pass. Every check is printed as JSON so the release
+ * evidence can quote it verbatim.
+ */
+import { readFileSync, readdirSync, statSync } from 'node:fs'
+import { join, relative } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const ROOT = fileURLToPath(new URL('../', import.meta.url))
+const checks = []
+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 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))
+check('bundle patch declared', pkg.dsh?.bundle?.patch === './cordis.patch.yml', String(pkg.dsh?.bundle?.patch))
+
+const patch = readFileSync(join(ROOT, 'cordis.patch.yml'), 'utf8')
+check('patch row name matches package', patch.includes(pkg.name), 'cordis.patch.yml')
+check('patch has an id', /^\s*-\s*id:\s*\S+/m.test(patch), 'cordis.patch.yml')
+
+const readme = readFileSync(join(ROOT, 'README.md'), 'utf8')
+check('README title is DSH-2Xray', readme.startsWith('# DSH-2Xray'), readme.split('\n')[0])
+const changelog = readFileSync(join(ROOT, 'CHANGELOG.md'), 'utf8')
+check('CHANGELOG has this version', changelog.includes(`## ${pkg.version}`), pkg.version)
+
+// ---- allow-list ----------------------------------------------------------
+const allow = readFileSync(join(ROOT, 'release', 'allow-list.txt'), 'utf8')
+  .split('\n')
+  .map((line) => line.trim())
+  .filter((line) => line && !line.startsWith('#'))
+
+function globToRegExp(glob) {
+  let out = '^'
+  for (let index = 0; index < glob.length; index++) {
+    const char = glob[index]
+    if (char === '*') {
+      if (glob[index + 1] === '*') {
+        out += '.*'
+        index++
+      } else out += '[^/]*'
+    } else if ('\\^$+.()|{}[]'.includes(char)) out += `\\${char}`
+    else out += char
+  }
+  return new RegExp(`${out}$`)
+}
+const allowPatterns = allow.map(globToRegExp)
+const isAllowed = (rel) => allowPatterns.some((pattern) => pattern.test(rel))
+
+const IGNORED = [/^node_modules\//, /^\.git\//, /^\.tmp\//, /^dist\//, /^release\//, /^\.github\//, /^\.gitignore$/]
+
+function walk(dir, out = []) {
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const absolute = join(dir, entry.name)
+    const rel = relative(ROOT, absolute).split('\\').join('/')
+    if (IGNORED.some((pattern) => pattern.test(rel))) continue
+    if (entry.isDirectory()) walk(absolute, out)
+    else if (entry.isFile()) out.push(rel)
+  }
+  return out
+}
+
+const files = walk(ROOT)
+const outside = files.filter((file) => !isAllowed(file))
+check('every packaged file is allow-listed', outside.length === 0, outside.join(', ') || `${files.length} files`)
+
+for (const required of ['index.js', 'package.json', 'cordis.patch.yml', 'README.md', 'CHANGELOG.md', 'LICENSE', 'lib/supervisor.js', 'lib/control/grpc.js', 'locale/en.json', 'locale/zh.json', 'icon.svg']) {
+  check(`required file ${required}`, files.includes(required))
+}
+
+// ---- secrets -------------------------------------------------------------
+const SECRET_PATTERNS = [
+  [/npm_[A-Za-z0-9]{36,}/, 'npm token'],
+  [/github_pat_[A-Za-z0-9_]{20,}/, 'GitHub PAT'],
+  [/ghp_[A-Za-z0-9]{30,}/, 'GitHub token'],
+  [/-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----/, 'private key'],
+]
+const leaks = []
+for (const file of files) {
+  if (!/\.(js|mjs|json|md|yml|yaml|txt)$/.test(file)) continue
+  const absolute = join(ROOT, file)
+  if (statSync(absolute).size > 1024 * 1024) continue
+  const text = readFileSync(absolute, 'utf8')
+  for (const [pattern, label] of SECRET_PATTERNS) {
+    if (pattern.test(text)) leaks.push(`${file}: ${label}`)
+  }
+}
+check('no secrets in packaged files', leaks.length === 0, leaks.join(', ') || 'clean')
+
+const binFiles = files.filter((file) => file.startsWith('bin/'))
+check('no xray binary committed', binFiles.every((file) => file.endsWith('README.md')), binFiles.join(', ') || 'none')
+
+const failures = checks.filter((entry) => !entry.ok)
+console.log(JSON.stringify({ ok: failures.length === 0, package: `${pkg.name}@${pkg.version}`, files: files.length, checks }, null, 2))
+if (failures.length > 0) process.exitCode = 1