@aiwayds/dsh-llm-proxy 0.6.0 → 0.7.1

package/README.md

@@ -21,7 +21,7 @@ LLM 列表命中 > SYSTEM proxy（env 语义）> 直连
 
 ```bash
 # 方式一：作为 npm 插件加入 profile
-dsh plugin add @aiwayds/dsh-llm-proxy   # 或在 settings.yaml 的 plugins 里声明
+dsh plugin add @aiwayds/dsh-llm-proxy
 
 # 方式二：手动 patch 挂载（本包自带 cordis.patch.yml）
 # 在 profile 的 bundles 中插入：

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiwayds/dsh-llm-proxy",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "description": "dsh plugin: SYSTEM proxy (env) + LLM traffic-splitting proxy via a process-global undici routing dispatcher",
   "type": "module",
   "main": "lib/index.js",
@@ -26,6 +26,7 @@
   },
   "files": [
     "lib",
+    "scripts",
     "cordis.patch.yml",
     "src",
     "skills",
@@ -37,7 +38,7 @@
     "check": "tsc --noEmit -p tsconfig.json",
     "pretest": "npm run build",
     "prepare": "npm run build",
-    "test": "node --test test/match.test.mjs test/router.test.mjs test/config.test.mjs test/skill.test.mjs test/dispose.test.mjs test/e2e.test.mjs",
+    "test": "node --test test/match.test.mjs test/router.test.mjs test/config.test.mjs test/skill.test.mjs test/dispose.test.mjs test/e2e.test.mjs && node test/packaged-install.test.mjs",
     "smoke": "node scripts/smoke-boot.mjs",
     "postinstall": "node scripts/link-dsh-closure.mjs"
   },
@@ -47,8 +48,8 @@
   "peerDependencies": {
     "@deepseek-ai/cordis": "4.0.4",
     "@deepseek-ai/schemastery": "3.18.4",
-    "@deepseek-ai/dsh-settings": ">=0.1.7-rc.1",
-    "@deepseek-ai/dsh-skill": ">=0.1.7-rc.1"
+    "@deepseek-ai/dsh-settings": ">=0.2.0-rc.2",
+    "@deepseek-ai/dsh-skill": ">=0.2.0-rc.2"
   },
   "peerDependenciesMeta": {
     "@deepseek-ai/cordis": {
@@ -64,8 +65,8 @@
   "devDependencies": {
     "@deepseek-ai/cordis": "4.0.4",
     "@deepseek-ai/schemastery": "3.18.4",
-    "@deepseek-ai/dsh-settings": "0.1.7-rc.1",
-    "@deepseek-ai/dsh-skill": "0.1.7-rc.1",
+    "@deepseek-ai/dsh-settings": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-skill": "0.2.0-rc.2",
     "@types/node": "^24.0.0",
     "typescript": "^5.9.0"
   },

package/scripts/link-dsh-closure.mjs

@@ -0,0 +1,102 @@
+/**
+ * Postinstall linker: point every `node_modules/@deepseek-ai/*` entry at the
+ * global dsh closure.
+ *
+ * Why this exists: dsh-tui-pi is a plugin that runs *inside* the installed
+ * dsh CLI, and its source imports the `@deepseek-ai/*` packages (cordis,
+ * dsh-session, dsh-settings, schemastery, …). Those packages are **not**
+ * resolvable from the public npm registry in a usable way (their rc.6
+ * versions live only in the dsh install's own node_modules), so the repo
+ * resolves them from the *global dsh closure* —
+ * `$(realpath $(which dsh))/node_modules/@deepseek-ai` — via plain symlinks.
+ *
+ * The contract: ALL `@deepseek-ai/*` resolve to that single closure instance,
+ * so there is exactly one `@deepseek-ai/cordis` in the type graph. Declaring
+ * any of them in package.json made `pnpm install` create a second local copy
+ * in `.pnpm`, which broke the cordis `declare module` augmentation
+ * (`Property 'settings' does not exist on type 'Context'`), so they must stay
+ * *undeclared*. pnpm then treats the closure links as extraneous — and, as
+ * it prunes entries it once managed, the links can still disappear after an
+ * install. This script re-creates them on every `pnpm install` (postinstall).
+ *
+ * It is a no-op (exit 0) when no global dsh install is found — a dev machine
+ * without dsh simply cannot typecheck against dsh types.
+ */
+
+import { execFileSync } from 'node:child_process'
+import { existsSync, mkdirSync, readdirSync, realpathSync, rmSync, symlinkSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const repoRoot = dirname(dirname(fileURLToPath(import.meta.url)))
+// Guard: this postinstall is a dev-machine convenience for THIS repo. A
+// published tarball ships scripts/ (the hook must resolve), but the linker
+// must never touch a consumer's node_modules there — it would delete their
+// @deepseek-ai packages and replace them with symlinks into their global dsh
+// closure. pnpm ≥10 blocks dependency lifecycle scripts by default, but npm
+// would run this — exit silently outside the repo. The repo markers must be
+// things the files allow-list never ships: tsconfig.json (dev typecheck
+// input) and .git.
+if (!existsSync(join(repoRoot, 'tsconfig.json')) || !existsSync(join(repoRoot, '.git'))) {
+  process.exit(0)
+}
+const scopeDir = join(repoRoot, 'node_modules', '@deepseek-ai')
+
+/** The global dsh package's own `node_modules/@deepseek-ai` closure dir. */
+function findDshClosure() {
+  // 0) Explicit override for dev/typecheck against an unreleased dsh line,
+  //    e.g. a scratch closure from: npm i --prefix ~/tmp/dsh-alpha-closure @deepseek-ai/dsh@alpha
+  //    DSH_CLOSURE_DIR=~/tmp/dsh-alpha-closure/node_modules/@deepseek-ai node scripts/link-dsh-closure.mjs
+  const override = process.env.DSH_CLOSURE_DIR
+  if (override !== undefined && override !== "") {
+    const dir = realpathSync(override)
+    if (existsSync(join(dir, "cordis"))) return dir
+    console.warn(`[link-dsh-closure] DSH_CLOSURE_DIR=${override} lacks @deepseek-ai/cordis — ignoring override`)
+  }
+  // 1) Follow the `dsh` bin — the most faithful pointer to the installed CLI
+  //    (`/opt/homebrew/bin/dsh` → …/lib/bin.js → pkg dir → its node_modules).
+  try {
+    const bin = execFileSync('which', ['dsh'], { encoding: 'utf8' }).trim()
+    if (bin !== '') {
+      const real = realpathSync(bin)
+      const closure = join(dirname(dirname(real)), 'node_modules', '@deepseek-ai')
+      if (existsSync(join(closure, 'cordis'))) return closure
+    }
+  } catch { /* dsh not on PATH */ }
+  // 2) Fall back to the global node_modules root — the dsh package's own
+  //    nested closure (what current npm produces for a global install).
+  try {
+    const root = execFileSync('npm', ['root', '-g'], { encoding: 'utf8' }).trim()
+    const nested = join(root, '@deepseek-ai', 'dsh', 'node_modules', '@deepseek-ai')
+    if (existsSync(join(nested, 'cordis'))) return nested
+    // 3) Last resort: npm's flat global layout, where dsh's @deepseek-ai/*
+    //    deps are hoisted straight into <npm root -g>/@deepseek-ai next to
+    //    the dsh package itself.
+    const flat = join(root, '@deepseek-ai')
+    if (existsSync(join(flat, 'cordis'))) return flat
+  } catch { /* npm unavailable */ }
+  return undefined
+}
+
+const closure = findDshClosure()
+if (closure === undefined) {
+  console.warn('[link-dsh-closure] global dsh not found — skipping @deepseek-ai links (dev without dsh)')
+  process.exit(0)
+}
+
+mkdirSync(scopeDir, { recursive: true })
+let linked = 0
+for (const name of readdirSync(closure)) {
+  const target = join(scopeDir, name)
+  const source = join(closure, name)
+  try {
+    // Replace any existing entry (stale symlink, or a local .pnpm copy a
+    // previous install created) with the closure link.
+    rmSync(target, { recursive: true, force: true })
+    symlinkSync(source, target, 'junction')
+    linked++
+  } catch (error) {
+    console.warn(`[link-dsh-closure] failed to link ${name}: ${(error instanceof Error ? error.message : String(error))}`)
+  }
+}
+console.log(`[link-dsh-closure] linked ${linked} @deepseek-ai/* packages from ${closure}`)

package/scripts/smoke-boot.mjs

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+// Boot-smoke: mount the freshly built plugin into a scratch dsh profile
+// (bundle patch + packed tarball) and boot it with the real dsh CLI.
+//
+//   1. npm pack the repo → tarball
+//   2. scratch $DSH_HOME/profiles/smoke with the plugin as a file: dep and a
+//      dsh.profile.bundles entry (same shape as the user's real profiles)
+//   3. npm install — lifecycle scripts ON, i.e. the consumer path. pnpm ≥10
+//      blocks dependency lifecycle scripts by default, which is exactly how
+//      the #2-class tarball breakage (postinstall → unshipped file) stayed
+//      invisible to every pnpm-based install; npm-class clients (the desktop
+//      plugin manager) are the ones that run it.
+//   4. `dsh --profile smoke --dump-config` must compose the plugin into the
+//      tree (mount/patch-layer proof)
+//   5. a real boot under a timeout must load the plugin tree without a
+//      loader error (a healthy boot is silent and survives to the kill
+//      signal; a broken plugin dies within ~1s with the loader error)
+//   6. `dsh plugin --profile smoke remove <pkg>` must reconcile the profile
+//      tree back to stock: the bundles entry spliced, the patch layer
+//      dropped, and the plugin id gone from a fresh --dump-config
+//
+// Coverage notes (empirical, dsh 0.1.1-rc.2 and 0.1.2-alpha.3 hosts):
+// - Everything apply() does synchronously — ctx.skills.registerProvider(),
+//   the entry-config router install, the global dispatcher takeover — is
+//   gated hard: a throw there dies with "plugin tree failed to load".
+// - The ctx.inject(['settings']) listener wiring is NOT judgeable from the
+//   boot: a cordis inject sub-fiber that throws (missing method, rejected
+//   event registration) is contained silently. That seam is gated instead by
+//   `npm run check` against the linked dsh closure (signature-level) plus
+//   the unit suite (semantics-level). The valid settings.yaml section below
+//   exercises the host's one-shot legacy import path as far as the boot can
+//   show (on dsh >= 0.1.7-rc.1 hosts it feeds the entry's volatile config).
+// - The host must match the plugin's target line (CI installs dsh@alpha):
+//   a mismatched older host can boot "cleanly" while the contained inject
+//   error silently drops the settings integration.
+//
+// Exit 0 = mounted and boots clean. Temp dir is kept and printed on failure,
+// removed on success.
+
+import { spawnSync } from 'node:child_process'
+import { existsSync, mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs'
+import { readFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..')
+const pkg = JSON.parse(await readFile(path.join(repoRoot, 'package.json'), 'utf8'))
+const ownName = pkg.name // @aiwayds/dsh-llm-proxy
+
+const work = mkdtempSync(path.join(tmpdir(), 'dsh-llm-proxy-smoke-'))
+const home = path.join(work, 'dsh-home')
+const profile = path.join(home, 'profiles', 'smoke')
+mkdirSync(profile, { recursive: true })
+
+function fail(message, output = '') {
+  console.error(`smoke-boot: FAIL — ${message}`)
+  if (output) console.error(output.split('\n').slice(0, 30).join('\n'))
+  console.error(`smoke-boot: scratch kept at ${work}`)
+  process.exit(1)
+}
+
+const pack = spawnSync('npm', ['pack', '--pack-destination', work], { cwd: repoRoot, encoding: 'utf8' })
+if (pack.status !== 0 || pack.error) fail('npm pack failed', `${pack.stdout}\n${pack.stderr}`)
+const tarball = path.join(work, pack.stdout.trim().split('\n').at(-1))
+
+writeFileSync(path.join(profile, 'cordis.yml'), '# dsh profile root — empty; the tree is composed from the bundle patches\n[]\n')
+writeFileSync(path.join(profile, 'cordis.patch.yml'), '# scratch smoke profile: no extra patch layer\n[]\n')
+writeFileSync(path.join(profile, 'package.json'), JSON.stringify({
+  name: 'dsh-profile-smoke',
+  private: true,
+  dependencies: {
+    [ownName]: `file:${tarball}`,
+  },
+  dsh: {
+    profile: {
+      bundles: [
+        '@deepseek-ai/dsh-base',
+        ownName,
+      ],
+    },
+  },
+}, null, 2) + '\n')
+
+// A user settings.yaml section matching the plugin's entry id: on dsh
+// >= 0.1.7-rc.1 hosts the boot's one-shot legacy import consumes it (all
+// three keys are volatile config fields, so the section imports cleanly and
+// the values land in the profile patch for this entry).
+writeFileSync(path.join(home, 'settings.yaml'), `\
+# smoke: user section consumed by the mounted dsh-llm-proxy plugin
+dsh-llm-proxy:
+  enabled: true
+  systemMode: env
+  llmProxy:
+    - match: "smoke.example.test"
+      proxy: "http://127.0.0.1:1"
+`)
+
+const install = spawnSync('npm', ['install', '--no-audit', '--no-fund', '--loglevel=error'], { cwd: profile, encoding: 'utf8' })
+if (install.status !== 0 || install.error) fail('npm install in the scratch profile failed (lifecycle scripts on — the consumer path)', `${install.stdout}\n${install.stderr}`)
+
+// Consumer stand-down: the linker must not materialize a @deepseek-ai scope
+// dir inside the installed package's own tree (that would shadow the host's
+// bundled closure — the failure mode the optional-peer contract exists for).
+const installedOwn = path.join(profile, 'node_modules', ownName)
+if (existsSync(path.join(installedOwn, 'node_modules', '@deepseek-ai'))) {
+  fail('the closure linker ran inside the consumer profile — it must stand down outside the repo')
+}
+
+const dshEnv = { ...process.env, DSH_HOME: home }
+
+// Phase 1 — mount proof: the composed tree must include the plugin.
+const dump = spawnSync('dsh', ['--profile', 'smoke', '--dump-config'], { cwd: profile, encoding: 'utf8', env: dshEnv })
+if (dump.status !== 0 || dump.error) fail('dsh --dump-config failed on the scratch profile', `${dump.stdout}\n${dump.stderr}`)
+if (!dump.stdout.includes(ownName)) {
+  fail(`the composed profile tree does not contain ${ownName} — the bundle patch insert is broken`, dump.stdout)
+}
+
+// Phase 2 — boot proof: the plugin tree must LOAD without a loader error.
+const bootSeconds = 25
+const boot = spawnSync('dsh', ['--profile', 'smoke'], {
+  cwd: profile,
+  encoding: 'utf8',
+  timeout: bootSeconds * 1000,
+  killSignal: 'SIGKILL',
+  env: dshEnv,
+})
+const output = `${boot.stdout ?? ''}\n${boot.stderr ?? ''}`
+const loaderErrors = [
+  /plugin tree failed to load/,
+  /failed to apply loader entry/,
+  /cannot get property ".*" without inject/,
+  /cannot get required service/,
+  /Cannot find (package|module)/,
+]
+const hit = loaderErrors.filter((re) => re.test(output))
+if (hit.length > 0) {
+  fail('the real host failed to load the plugin tree:', output.split('\n').filter((line) => hit.some((re) => re.test(line)) || /Error/.test(line)).slice(0, 15).join('\n'))
+}
+if (boot.signal !== 'SIGKILL' && boot.status !== 0) {
+  fail(`dsh exited early with code ${boot.status} and no loader error — unexpected`, output)
+}
+
+// Phase 3 — uninstall leg: removal must reconcile the profile tree back to stock.
+const remove = spawnSync('dsh', ['plugin', '--profile', 'smoke', 'remove', ownName], { cwd: profile, encoding: 'utf8', env: dshEnv })
+if (remove.status !== 0 || remove.error) fail('dsh plugin remove failed', `${remove.stdout}\n${remove.stderr}`)
+const dumpAfter = spawnSync('dsh', ['--profile', 'smoke', '--dump-config'], { cwd: profile, encoding: 'utf8', env: dshEnv })
+if (dumpAfter.status !== 0 || dumpAfter.error) fail('dsh --dump-config failed after removal', `${dumpAfter.stdout}\n${dumpAfter.stderr}`)
+if (dumpAfter.stdout.includes('dsh-llm-proxy')) {
+  fail('the composed tree still contains the plugin entry after removal', dumpAfter.stdout)
+}
+
+console.log(`smoke-boot: PASS — ${ownName} composed into the scratch profile tree and booted clean in real dsh (${boot.signal === 'SIGKILL' ? `survived ${bootSeconds}s boot window` : `exited ${boot.status}`}); removal restored the stock tree`)
+rmSync(work, { recursive: true, force: true })