dsh-router-core 0.4.0 → 0.4.2

package/src/client/model-choice.ts

@@ -0,0 +1,37 @@
+/**
+ * 自检面板的「模型」下拉该列哪些 —— 纯函数，不碰 React。
+ *
+ * 为什么不能把端点返回的模型全列出来：那个端点给的是**全部**模型（含用户在
+ * 供应商详情里停用的）。实测某供应商 30 个模型里只有 3 个是启用的 —— 把 30 个都
+ * 塞进下拉，用户会挑到一个自己明明关掉的模型去测，测通了也不代表配置是对的。
+ * 所以只列**可用**的（用户没停用的），与路由实际会用的那批保持一致。
+ *
+ * 顺带把「没有可选模型」拆成两种，因为**用户该做的事不一样**：
+ *   - `none`（一个模型都没有）→ 该去供应商详情拉取模型；
+ *   - `all-disabled`（有模型但全被停用）→ 该去供应商详情把它们打开，
+ *     去拉取是白跑一趟。
+ * 两种共用一句「没有模型」就是把用户往错的方向指。
+ *
+ * `enabled` 缺省按**未停用**读（`!== false`）：这个字段是用户的配置，缺失时不该
+ * 凭空把模型藏起来。
+ */
+
+/** `/suppliers/:id/models` 里的一条模型。 */
+export interface ModelRow {
+  id: string
+  enabled?: boolean
+}
+
+export interface ModelChoice {
+  /** 可用模型的 id，按端点返回的顺序（不重排 —— 端点已经按优先级排过了）。 */
+  ids: string[]
+  /** 没有可选模型时的原因；`undefined` = 有得选。 */
+  empty?: 'none' | 'all-disabled'
+}
+
+/** 从端点答复里挑出可用的模型，并说明「空的」到底是哪一种空。 */
+export function modelChoice(models: readonly ModelRow[]): ModelChoice {
+  const ids = models.filter((m) => m.enabled !== false).map((m) => m.id)
+  if (ids.length > 0) return { ids }
+  return { ids, empty: models.length === 0 ? 'none' : 'all-disabled' }
+}

package/src/client/router-components.test.ts

@@ -0,0 +1,114 @@
+/**
+ * 「路由组件」分组判据测试 —— 锁住三条会静默出错的规则。
+ *
+ * 1. `source` 判据取反：只有 external 是独立安装的 bundle，其余归本地组。
+ * 2. 缺 `source` 的供应商不许被静默丢掉，也不许被误报成独立插件。
+ * 3. 只有 ext 那组 `togglable` —— 供应商在这一页没有可写的开关。
+ *
+ * 这三条错了都不会抛异常，只会显示成「少了一组 / 多了个开关」，所以必须有闸门。
+ */
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { groupRouterComponents, isEmptyComponents, EMPTY_COMPONENTS } from './router-components.ts'
+import type { RouterExtResponse, RouterHealthResponse } from '../shared.ts'
+
+const health = (suppliers: NonNullable<RouterHealthResponse['suppliers']>): RouterHealthResponse => ({ ok: true, suppliers })
+const noExt: RouterExtResponse = { ok: true, enhancers: [] }
+
+test('内置供应商一个都不进这一节（它们是原生「包含的组件」里的行）', () => {
+  const out = groupRouterComponents(health([
+    { id: 'opencode', name: 'OpenCode', source: 'builtin' },
+    { id: 'openrouter', name: 'OpenRouter', source: 'builtin' },
+    { id: 'nvidia', name: 'NVIDIA NIM', source: 'builtin' },
+  ]), noExt)
+  // 重复显示两处 = 用户看到同一个东西两次，且有一处没有开关。
+  assert.deepEqual(out.external, [])
+  assert.deepEqual(out.ext, [])
+})
+
+test('外部供应商插件进「供应商」组（各是独立 bundle，这一页有开关）', () => {
+  const out = groupRouterComponents(health([
+    { id: 'codebuddy', name: 'CodeBuddy', source: 'external' },
+    { id: 'traework', name: 'TRAE SOLO', source: 'external' },
+  ]), noExt)
+  assert.deepEqual(out.external.map((r) => r.key), ['supplier:codebuddy', 'supplier:traework'])
+  assert.equal(out.external.every((r) => r.togglable), true, '供应商在这一页有开关（写 PATCH /suppliers/:id/enabled）')
+})
+
+test('缺 source 的供应商不显示，也不被误报成独立插件', () => {
+  const out = groupRouterComponents(health([{ id: 'mystery', name: 'Mystery' }]), noExt)
+  assert.deepEqual(out.external, [])
+})
+
+test('user 目录投放的供应商也不进这一节（它的对应物是行的覆盖或外部插件）', () => {
+  const out = groupRouterComponents(health([{ id: 'mine', name: 'My Supplier', source: 'user' }]), noExt)
+  assert.deepEqual(out.external, [])
+})
+
+test('扩展插件进 ext 组且唯一可开关；状态按「宁可关着」读', () => {
+  const out = groupRouterComponents(health([]), {
+    ok: true,
+    enhancers: [
+      { id: 'rtk', name: 'RTK', enabled: true, ready: true },
+      { id: 'jev', name: 'JEV' },
+    ],
+  })
+  assert.equal(out.ext.length, 2)
+  assert.equal(out.ext.every((r) => r.togglable), true)
+  assert.deepEqual(out.ext.map((r) => r.enabled), [true, false])
+  assert.deepEqual(out.ext.map((r) => r.ready), [true, false])
+})
+
+test('图标与说明只在该有的时候带上（不塞 undefined 键）', () => {
+  const out = groupRouterComponents(health([{ id: 'loomy', name: 'Loomy', icon: 'data:image/png;base64,x', source: 'external' }]), {
+    ok: true,
+    enhancers: [{ id: 'rtk', name: 'RTK', detail: '本机未装 rtk' }],
+  })
+  const supplier = out.external.at(0)
+  const extRow = out.ext.at(0)
+  assert.ok(supplier !== undefined && extRow !== undefined)
+  assert.equal('icon' in supplier, true)
+  assert.equal('detail' in extRow, true)
+  assert.equal('icon' in extRow, false)
+})
+
+test('两个端点都没有内容时不渲染这一节（不留空标题）', () => {
+  assert.equal(isEmptyComponents(EMPTY_COMPONENTS), true)
+  assert.equal(isEmptyComponents(groupRouterComponents({ ok: true }, { ok: true })), true)
+  assert.equal(isEmptyComponents(groupRouterComponents({ ok: true }, { ok: true, enhancers: [{ id: 'rtk', name: 'RTK' }] })), false)
+})
+
+test('端点报错/缺字段时分组仍是空组，不抛（形状恒定）', () => {
+  const out = groupRouterComponents({ ok: false, error: 'boom' }, { ok: false, error: 'boom' })
+  assert.deepEqual(out, EMPTY_COMPONENTS)
+})
+
+test('供应商的开关状态：缺 enabled 按开着读，关掉的仍列出来（关掉后要能再开）', () => {
+  const out = groupRouterComponents(health([
+    { id: 'codebuddy', name: 'CodeBuddy', source: 'external' },
+    { id: 'traework', name: 'TRAE SOLO', source: 'external', enabled: false },
+  ]), noExt)
+  assert.deepEqual(out.external.map((r) => r.key), ['supplier:codebuddy', 'supplier:traework'],
+    '关掉的供应商不能从列表消失 —— 消失了就再没有可点的开关把它开回来')
+  assert.deepEqual(out.external.map((r) => r.enabled), [true, false])
+})
+
+test('供应商行没有 ready（那是扩展的运行时事实）—— 缺失不得让它变成点不开', () => {
+  const out = groupRouterComponents(health([{ id: 'codebuddy', name: 'CodeBuddy', source: 'external' }]), noExt)
+  const row = out.external.at(0)
+  assert.ok(row !== undefined)
+  assert.equal('ready' in row, false, '供应商不报就绪，别塞一个 undefined 键进去')
+  assert.equal(row.togglable, true)
+})
+
+test('内置扩展不进这一节（它已经是原生「包含的组件」里的一行）', () => {
+  const out = groupRouterComponents({ ok: true }, {
+    ok: true,
+    enhancers: [
+      { id: 'test', name: '插件自检', source: 'builtin' },
+      { id: 'rtk', name: 'RTK' },
+    ],
+  })
+  // 重复显示两处 = 用户看到同一个东西两次，且有一处没有开关。
+  assert.deepEqual(out.ext.map((r) => r.key), ['ext:rtk'])
+})

package/src/client/router-components.ts

@@ -0,0 +1,104 @@
+/**
+ * 官方插件页「路由组件」一节的分组 —— 纯函数，不碰 React。
+ *
+ * 为什么抽出来：这一节唯一有分支的地方就是「一条供应商/扩展归哪组、能不能
+ * 就地开关」（见下两条判据）。留在组件里就只能靠真页面点出来验，抽出来单测，
+ * 判据改错当场变红。
+ *
+ * 数据源是核心**已经在提供**的两个端点，本模块不新增任何 API：
+ *   - `/health` 的 `suppliers[]` 带 `source`（builtin / user / external）
+ *   - `/ext` 的 `enhancers[]` 是核心合并完开关与运行时事实的扩展表
+ */
+import type { RouterExtResponse, RouterHealthResponse } from '../shared.ts'
+
+/** `/health` 里的一条供应商摘要（就地取型，不另抄一份形状）。 */
+export type RouterSupplierSummary = NonNullable<RouterHealthResponse['suppliers']>[number]
+
+/** 一行组件（两组共用同一种形状，渲染时才分叉）。 */
+export interface RouterComponentRow {
+  /** 组内唯一键：`supplier:<id>` / `ext:<id>`。 */
+  key: string
+  name: string
+  icon?: string
+  /** ext 报的就绪状态说明（如「本机未装 rtk」）。 */
+  detail?: string
+  enabled?: boolean
+  ready?: boolean
+  /**
+   * 能否就地开关。**两组都能**：扩展走 `PATCH /router/api/ext`（核心持久化到
+   * `<dataDir>/ext.json`），供应商走 `PATCH /router/api/suppliers/:id/enabled`
+   * （落到 `supplier-config.json`）。两组都是核心持久化的用户开关，核心都据此
+   * 真的停止路由 —— 不是一个只把卡片藏起来的假开关。
+   */
+  togglable: boolean
+}
+
+/**
+ * 这一节要列的两组。
+ *
+ * **为什么没有「内置与本地供应商」组**：内置供应商是 dsh-router-core 自己 patch
+ * 里的**行**（`cordis.patch.yml` insert 了三个子路径模块），已经在宿主的原生
+ * 「包含的组件」里，带着宿主管的开关。在这里再列一遍就是同一个东西显示两处。
+ */
+export interface RouterComponents {
+  /** 独立安装的供应商插件（各是独立 bundle，启停在它们自己的插件页）。 */
+  external: RouterComponentRow[]
+  /** 扩展插件（`router.ext`，开关归核心）。 */
+  ext: RouterComponentRow[]
+}
+
+/** 空组：加载前与加载失败都用它，保证形状恒定。 */
+export const EMPTY_COMPONENTS: RouterComponents = { external: [], ext: [] }
+
+/** 一条外部供应商摘要 → 只读行。 */
+function supplierRow(s: RouterSupplierSummary): RouterComponentRow {
+  return {
+    key: `supplier:${s.id}`,
+    name: s.name,
+    // 缺 `enabled` 按开着读（老核心没这个字段）。关掉的供应商**仍列出来** ——
+    // 面板「扩展」页的形状是「关掉就不出现」，但供应商关掉后如果也消失，这里就
+    // 少了一个可点的开关、再也开不回来。两组刻意不同。
+    enabled: s.enabled !== false,
+    togglable: true,
+    ...(s.icon === undefined ? {} : { icon: s.icon }),
+  }
+}
+
+/**
+ * 把两个端点的答复分成两组。
+ *
+ * 供应商这边只收 `source === 'external'`（独立安装的供应商插件）。`builtin`
+ * 的那三个已经作为**原生行**在宿主的「包含的组件」里显示了（core 自己 patch
+ * insert 的子路径模块，开关是宿主管的那个行开关），`user` 的是用户目录里投放的
+ * js —— 两者都不该在这里出现第二次。`source` 缺失按「不是 external」处理：
+ * 不显示总比把内置的错标成独立插件强。
+ *
+ * 两组都在这一页开关，指向核心的同两个端点（`PATCH /suppliers/:id/enabled` 与
+ * `PATCH /ext`），所以「在哪开关」是一致的：**设置 → 插件 → dsh-router-core**。
+ * 供应商的开关关掉是真的不参与路由（见 Router 的活跃集合），不是只隐藏卡片。
+ */
+export function groupRouterComponents(health: RouterHealthResponse, ext: RouterExtResponse): RouterComponents {
+  const external = (health.suppliers ?? [])
+    .filter((s) => s.source === 'external')
+    .map(supplierRow)
+  // 只列**独立安装**的扩展（`source !== 'builtin'`）。随核心分发的内置扩展已经在
+  // 宿主原生的「包含的组件」里占一行、自带宿主管的开关，在这里再列一遍就是同一个
+  // 东西显示两处 —— 与内置供应商的处理完全一样。
+  const extRows = (ext.enhancers ?? []).filter((e) => e.source !== 'builtin').map((e): RouterComponentRow => ({
+    key: `ext:${e.id}`,
+    name: e.name,
+    // 缺字段一律按「关 / 未就绪」读：没拿到的事实不当真，宁可显示成关着
+    // 让用户自己去开，也不要谎报在跑（`ready` 是运行时事实，猜不得）。
+    enabled: e.enabled === true,
+    ready: e.ready === true,
+    togglable: true,
+    ...(e.icon === undefined ? {} : { icon: e.icon }),
+    ...(e.detail === undefined ? {} : { detail: e.detail }),
+  }))
+  return { external, ext: extRows }
+}
+
+/** 两组加起来一个都没有 → 这一节不渲染（不留空标题）。 */
+export function isEmptyComponents(components: RouterComponents): boolean {
+  return components.external.length === 0 && components.ext.length === 0
+}