dsh-router-core 0.1.0 → 0.2.0

package/lib/types/router/account-pool.d.ts

@@ -0,0 +1,41 @@
+/**
+ * 账号池 —— dsh-router 核心策略：选号、冷却、禁用、错误累计、遍历回退。
+ *
+ * 供应商插件只管「对单个账号调通上游」，账号层面的策略全在这里：
+ *   - 按 poolOrder 排序（未配置的按插件报告顺序追加）
+ *   - 按 poolStrategy 选号：fallback = 取第一个健康；round-robin = 轮转健康号
+ *   - 失败按插件报的 AccountState 处置（冷却/禁用/错误累计），攒够阈值自动冷却
+ *
+ * 天花板：冷却/禁用/错误计数都是**内存态**，重启归零（与旧插件行为一致，
+ * 插件的持久化只存凭证与积分，不存健康）。要跨重启保留得落盘，届时加一个
+ * stateFile 即可，接口不用变。
+ */
+import type { AccountState, SupplierAccountNow } from '../suppliers/contract.ts';
+export declare class AccountPool {
+    private entries;
+    private rrCursor;
+    private entry;
+    /** 是否可服务：未禁用且不在冷却中。 */
+    private healthy;
+    /**
+     * 按策略选一个健康账号。
+     * @param accounts 插件报告的「现在状态」（顺序即插件的自然顺序）
+     * @param poolOrder 用户在面板拖出来的顺序（核心管）
+     * @returns 选中的 uid；无健康账号返回 undefined
+     */
+    pick(accounts: SupplierAccountNow[], poolOrder: string[], strategy: string): string | undefined;
+    /** 记录一次失败：按状态处置（冷却/禁用/错误累计）。 */
+    noteFailure(uid: string, state: AccountState, message: string): void;
+    /** 记录一次成功：清零连续错误。 */
+    noteSuccess(uid: string): void;
+    /** 手动冷却（面板/管理用途）。 */
+    cooldown(uid: string, ms: number, reason: string): void;
+    /** 把核心的冷却/禁用/错误累计叠加到插件报告的「现在状态」上，产出面板态。 */
+    decorate(accounts: SupplierAccountNow[]): Array<SupplierAccountNow & {
+        cooling: boolean;
+        disabled: boolean;
+        err_count: number;
+        until?: string;
+        reason?: string;
+    }>;
+}

package/lib/types/router/index.d.ts

@@ -1,5 +1,6 @@
 import type { ServerResponse } from 'node:http';
 import type { Supplier, ChatRequest, ModelInfo, ModelWithEnabled, SupplierStatus, Combo } from './types.ts';
+import { SupplierConfigStore } from '../supplier-config.ts';
 /** 路由器。 */
 export declare class Router {
     private suppliers;
@@ -7,7 +8,11 @@ export declare class Router {
     private customCombos;
     /** round-robin 轮转游标（按组合 id 记忆）。 */
     private rrCursors;
-    constructor(stateFile?: string);
+    /** 通用供应商配置（连接池顺序/策略、模型启用、别名）。 */
+    private store;
+    /** 模型列表缓存（supplierId → 模型 + 拉取时间）。插件只管拉，不缓存。 */
+    private modelsCache;
+    constructor(stateFile?: string, store?: SupplierConfigStore);
     private loadCombos;
     private saveCombos;
     add(supplier: Supplier): void;
@@ -30,7 +35,22 @@ export declare class Router {
     listModels(): Promise<ModelInfo[]>;
     /** 组合列表（面板用）：用户自定义组合。 */
     combos(): Promise<Combo[]>;
-    /** 可用模型（按供应商分组，仅启用），面板加模型用。 */
+    /**
+     * 取某供应商的模型（核心统一缓存）。
+     *
+     * 模型列表只在这里缓存一次：`/suppliers/:id/models`（供应商详情）和
+     * `/combos`（组合加模型）共用。组合面板**不主动打上游**——它只是读缓存，
+     * 冷启动（缓存还没建）时才拉一次；真正刷新由详情页打开或「获取模型」
+     * 按钮（force）触发。
+     *
+     * 天花板：TTL 60s 是拍的。若上游模型列表变更很频繁，可调小；要彻底实时
+     * 就得让供应商暴露 etag/版本号，目前没有这个需求。
+     */
+    modelsOf(supplierId: string, force?: boolean): Promise<ModelWithEnabled[]>;
+    /** 失效某供应商的模型缓存（增删改模型后调用）。 */
+    invalidateModels(supplierId: string): void;
+    /** 可用模型（按供应商分组，仅启用），面板加模型用。
+     *  各供应商**并行**拉取——串行会把每个上游的延迟累加起来。 */
     supplierModels(): Promise<Array<{
         supplier: {
             id: string;
@@ -41,7 +61,10 @@ export declare class Router {
     }>>;
     private validModels;
     private validStrategy;
-    /** 组合模型统一存裸 id：剥掉 alias/ 前缀（前缀随供应商动态变）。 */
+    /** 组合模型统一存裸 id：剥掉 alias/ 前缀（前缀随供应商动态变）。
+     *  只剥「已知 alias + /」开头的前缀——模型 id 本身可以含斜杠
+     *  （如 nvidia 的 `deepseek-ai/deepseek-v4-flash-0731`），用 lastIndexOf 会把
+     *  命名空间一起吃掉，后面请求必然 404。 */
     private normalizeModelIds;
     /** 创建组合（name 唯一，非 default）。 */
     createCombo(name: string, strategy: string, models: string[]): {
@@ -67,7 +90,23 @@ export declare class Router {
      * - 否则 → 依次尝试供应商，直到某个返回 true（已写响应）或全部返回 false。
      */
     chatCompletions(req: ChatRequest, res: ServerResponse): Promise<void>;
-    /** 把 model 改写为组合选中的模型名后尝试供应商。 */
+    /** 把 model 改写为组合选中的模型名后，遍历供应商 + 账号（策略全在核心）。 */
     private chatWithModel;
+    /**
+     * 单个供应商内遍历账号（核心策略）：选号 → 调 chatOnce → 按返回的
+     * AccountState 处置 → 失败换号；写响应只在成功后发生。
+     *
+     * 流式一旦写出响应头就绑死（上游协议如此，9router 同样如此），所以
+     * 「拿到 ok:true 的流」即视为该账号成功，之后出错不再换号——要能回退
+     * 就得在写头前缓冲判定，代价是首字节延迟，目前未做。
+     */
+    private chatWithSupplier;
+    /** 测试某供应商的某模型是否可用。
+     *  走真实的账号遍历 + chatOnce 路径：账号池回退/冷却由核心实现，自动生效；
+     *  响应丢弃到 sink，限定单一供应商（不跨供应商回退）。 */
+    testModel(supplierId: string, model: string): Promise<{
+        ok: boolean;
+        error?: string;
+    }>;
     dispose(): void;
 }

package/lib/types/router/types.d.ts

@@ -3,7 +3,8 @@
  * 每个供应商提供 OpenAI 兼容的 chat/models，并暴露面板状态。
  * 仿 9router：供应商 = 一种"免费/付费"通道；dsh-router 在其上做路由。
  */
-import type { ServerResponse } from 'node:http';
+import type { ChatOnceResult, SupplierAccountNow } from '../suppliers/contract.ts';
+import type { AccountPool } from './account-pool.ts';
 /** 面板展示的账号状态（脱敏）。 */
 export interface SupplierAccount {
     uid: string;
@@ -49,9 +50,8 @@ export interface ChatRequest {
     model: string;
 }
 /**
- * 供应商接口。chatCompletions 直接向 res 写响应（流式 SSE 或 JSON），
- * 成功返回 true；返回 false 表示"该供应商无健康账号可服务"（触发路由器
- * 轮换到下一个供应商）。写响应后不得再改 res。
+ * 供应商接口。核心负责账号池（选号/冷却/禁用/错误累计/遍历回退），
+ * 供应商只对**单个账号**调一次上游并报告结果，不碰 res。
  */
 export interface Supplier {
     readonly id: string;
@@ -68,13 +68,15 @@ export interface Supplier {
     getAlias(): string;
     /** 用户手动添加的模型 id（可选，/v1/models 用它聚合自定义模型）。 */
     customModelIds?(): string[];
-    chatCompletions(req: ChatRequest, res: ServerResponse): Promise<boolean>;
-    /** 测试模型（验证上游真实可用，必要差异化能力）。 */
-    testModel(id: string): Promise<{
-        ok: boolean;
-        error?: string;
-    }>;
+    /** 账号「现在状态」（从 status() 派生，插件只报它观察到的）。空 = 无账号供应商。 */
+    accounts(): SupplierAccountNow[];
+    /** 对单个账号调一次上游。不遍历账号、不管冷却、不写 res。 */
+    chatOnce(uid: string, req: ChatRequest): Promise<ChatOnceResult>;
+    /** 上次 chatOnce 失败原因（诊断用，可选）。 */
+    lastError?(): string | undefined;
     /** 删除链接（清理凭证；内部能力，js 契约不要求实现）。 */
     removeLink?(uid: string): Promise<boolean>;
     dispose(): void;
+    /** 该供应商的账号池（核心持有：选号/冷却/禁用/错误累计）。 */
+    readonly pool: AccountPool;
 }

package/lib/types/supplier-config.d.ts

@@ -1,12 +1,10 @@
 export type PoolStrategy = 'fallback' | 'round-robin';
-export type CheckinRule = 'all' | 'first';
 export interface SupplierConfig {
     alias: string;
     disabled: string[];
     custom: string[];
     poolOrder: string[];
     poolStrategy: PoolStrategy;
-    checkinRule: CheckinRule;
 }
 /** 通用供应商配置存储。 */
 export declare class SupplierConfigStore {
@@ -22,7 +20,6 @@ export declare class SupplierConfigStore {
     removeCustomModel(supplierId: string, modelId: string): void;
     setPoolOrder(supplierId: string, uids: string[]): void;
     setPoolStrategy(supplierId: string, strategy: string): void;
-    setCheckinRule(supplierId: string, rule: string): void;
     private load;
     private saveLocked;
 }

package/lib/types/suppliers/contract.d.ts

@@ -9,8 +9,7 @@
  * 用户自定义供应商 js 放到 `~/.dsh/profiles/web/suppliers/*.js`，重启后自动加载。
  * 内置供应商与用户 js 同构（差异化能力驱动）。
  */
-import type { ServerResponse } from 'node:http';
-import type { ChatRequest, ModelInfo, SupplierAccount, SupplierStatus } from '../router/types.ts';
+import type { ChatRequest, ModelInfo, SupplierAccount } from '../router/types.ts';
 import type { SupplierConfigStore } from '../supplier-config.ts';
 import type { CredentialStore } from '../credential-store.ts';
 /** 供应商配置：loader 注入的运行时环境。 */
@@ -26,6 +25,58 @@ export interface SupplierEnv {
 }
 /** 通用供应商工厂：一个 js 模块 export 它（或 default export 它），loader 调用得到实例。 */
 export type SupplierFactory = (env: SupplierEnv) => SupplierModule;
+/**
+ * 账户此刻的状态 —— 插件**解读**上游信号后的语义状态。
+ *
+ * 插件只报「现在怎么了」，不说「该怎么办」：冷却多久、是否禁用、要不要换号
+ * 都是核心的策略，见 `AccountState` 各值的处置表（docs/suppliers.md）。
+ *
+ * 天花板：目前是固定枚举。若将来某供应商需要更细的语义，再加值而不是放宽成
+ * 字符串——核心的策略表要能穷举。
+ */
+export type AccountState = 'ok' | 'rate_limit' | 'quota' | 'session_dead' | 'unavailable' | 'transport' | 'unknown'
+/**
+ * 这个模型不属于本供应商（不是账号的失败，也不是上游故障）。
+ * 核心据此**跳过整个供应商**换下一个，而不是记在账号头上——
+ * 否则组合里每有一个别人家的模型，就会给无关账号攒一次错误，攒够阈值
+ * 把它冷却掉（历史上正是这个坑）。
+ */
+ | 'no_such_model';
+/** 面板展示的账号此刻状态（插件只报它观察到的部分，冷却/禁用由核心叠加）。 */
+export interface SupplierAccountNow {
+    uid: string;
+    nickname?: string;
+    credits: number;
+    /** 插件观察到的上游状态。 */
+    state: AccountState;
+    /** 状态的人类可读补充（如上游错误串），可选。 */
+    message?: string;
+}
+/** 插件报的供应商状态（accounts 是「现在状态」，非核心加工后的面板态）。 */
+export interface SupplierStatusNow {
+    id: string;
+    name: string;
+    accounts: SupplierAccountNow[];
+}
+/** 一次上游调用的结果。 */
+export type ChatOnceResult = 
+/** 流式：插件已把上游协议转成 OpenAI SSE，核心只负责 pipe 到 res。 */
+{
+    ok: true;
+    stream: ReadableStream<Uint8Array>;
+}
+/** 非流式：核心写 JSON。 */
+ | {
+    ok: true;
+    status: number;
+    body: string;
+}
+/** 失败：核心据此做冷却/禁用/换号。 */
+ | {
+    ok: false;
+    state: AccountState;
+    message: string;
+};
 /** 供应商模块 —— 契约（核心必须，差异化可选）。 */
 export interface SupplierModule {
     /** 供应商唯一 id（小写字母数字 - _）。 */
@@ -36,18 +87,23 @@ export interface SupplierModule {
     readonly priority?: number;
     /** 图标（URL 或 SVG data URI），面板供应商卡片显示。可选。 */
     readonly icon?: string;
-    status(): SupplierStatus;
+    /** 报账号「现在状态」。冷却/禁用/错误累计由核心叠加，插件不算这些。 */
+    status(): SupplierStatusNow;
     /** 模型来源。`force=true` 时强制刷新来源（核心「获取模型」按钮调用）。 */
     listModels(force?: boolean): Promise<ModelInfo[]> | ModelInfo[];
     /** 默认前缀（可被通用层 alias 覆盖）。 */
     getAlias(): string;
-    chatCompletions(req: ChatRequest, res: ServerResponse): Promise<boolean>;
-    /** 测试模型（验证上游真实可用，必要差异化能力）。 */
-    testModel(id: string): Promise<{
-        ok: boolean;
-        error?: string;
-    }>;
+    /**
+     * 对**单个账号**调一次上游。插件不遍历账号、不管冷却、不写 res——
+     * 选号/回退/健康判定全是核心的活。
+     * 无账号供应商（如 opencode）传空 uid，忽略即可。
+     */
+    chatOnce(uid: string, req: ChatRequest): Promise<ChatOnceResult>;
     dispose(): void;
+    /** 上次 chatOnce 失败的原因（诊断用）。
+     *  测试模型由 dsh-router 核心统一走 chatOnce 路径（账号池回退/冷却自动生效），
+     *  插件只需把失败原因暴露出来供核心汇总；不实现则测试失败时只有通用提示。 */
+    lastError?(): string | undefined;
     /** 生成登录链接（加账号）。有它才显示连接池（账号池）。 */
     generateLoginUrl?(): string | {
         ok: boolean;
@@ -79,19 +135,12 @@ export interface SupplierModule {
     removeLink?(uid: string): Promise<boolean>;
     /** 轮询式登录标记：有它 → 面板隐藏「粘贴回调链接」步骤，登录后直接点完成（后台轮询）。 */
     pollLogin?(): boolean;
-    /** 触发签到。签到规则(all/first)是 dsh-router 通用策略,不在此列。 */
-    checkinNow?(): Promise<{
+    /** 单个链接签到。遍历所有链接 + 结果汇总是 dsh-router 核心的活,插件只管一个 uid。
+     *  status: 'ok'(签到成功) / 'already'(今日已签到) / 'error'(失败)。 */
+    checkinNow?(uid: string): Promise<{
         ok: boolean;
-        total: number;
-        succeeded: number;
-        already?: number;
-        error?: string;
-        results?: Array<{
-            uid: string;
-            ok: boolean;
-            status?: string;
-            message?: string;
-        }>;
+        status: string;
+        message?: string;
     }>;
 }
 /** 供应商账号（复用 router 类型，供 loader 包装）。 */

package/lib/types/suppliers/registry.d.ts

@@ -17,10 +17,11 @@
  *   POST   /suppliers/:id/login                   生成登录链接
  *   POST   /suppliers/:id/login/callback          {callbackUrl}
  *   POST   /suppliers/:id/links/remove            {uid}
- *   GET    /suppliers/:id/checkin/rule            + POST {rule}
- *   POST   /suppliers/:id/checkin                 触发签到
+ *   POST   /suppliers/:id/links/refresh           刷新链接池（积分，核心调 status() 等落地）
+ *   POST   /suppliers/:id/checkin                 签到所有链接（核心遍历 + 汇总）
  */
 import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { Router } from '../router/index.ts';
 import type { SupplierConfigStore } from '../supplier-config.ts';
 import type { LoadedSupplier } from './loader.ts';
 /** webServer 路由形状（与 index.ts 的 WebServerRoute 一致）。 */
@@ -30,4 +31,4 @@ export interface WebServerRoute {
     handler: (req: IncomingMessage, res: ServerResponse) => void | Promise<void>;
 }
 /** 为一个供应商生成端点（通用 + 差异化，返回 route 列表）。 */
-export declare function supplierRoutes(base: string, loaded: LoadedSupplier, store: SupplierConfigStore): WebServerRoute[];
+export declare function supplierRoutes(base: string, loaded: LoadedSupplier, store: SupplierConfigStore, router: Router): WebServerRoute[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-router-core",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "DSH plugin: a simplified 9router (AI routing gateway). Adds a 路由系统 (Routing System) sidebar entry beside 记忆系统; the panel shows suppliers, account pool, combos, and endpoint/API keys.",
   "type": "module",
   "repository": {
@@ -52,6 +52,7 @@
     "build": "rm -rf lib && tsc -p tsconfig.build.json && tsdown && npm run build:client",
     "build:client": "DSH_CLIENT_ID=dsh-router DSH_CLIENT_FILE=client.js vite build -c client/vite.config.ts && DSH_CLIENT_ID=dsh-external/dsh-router DSH_CLIENT_FILE=client-registry.js vite build -c client/vite.config.ts",
     "typecheck": "tsc --noEmit",
+    "test": "node --test \"src/**/*.test.ts\"",
     "bundle": "tsdown",
     "watch": "tsdown --watch"
   },

package/src/client/CombosTab.tsx

@@ -49,15 +49,17 @@ interface ComboForm {
 }
 
 export function CombosTab({ combos, aliases, onRefresh }: CombosTabProps): JSX.Element {
-  /** 当前供应商前缀（单供应商取第一个）。 */
-  const primaryAlias = aliases[0]?.alias ?? ''
-
-  /** 模型 → 所属供应商前缀（按 groups 分组匹配；找不到兜底 primaryAlias）。 */
+  /** 模型 → 所属供应商前缀（按 groups 分组匹配）。
+   *  组合只存裸 id，同名模型可能属于多个供应商，故优先取「已启用」的那个；
+   *  谁都没有的模型显示裸名——不能兜底套第一个供应商的前缀，那样前缀是假的。 */
   const aliasOf = (model: string): string => {
+    for (const g of groups) {
+      if (g.models.some(m => m.id === model && m.enabled)) return g.supplier.alias
+    }
     for (const g of groups) {
       if (g.models.some(m => m.id === model)) return g.supplier.alias
     }
-    return primaryAlias
+    return ''
   }
   const [showForm, setShowForm] = useState(false)
   const [editing, setEditing] = useState<RouterCombo | null>(null)

package/src/client/SupplierDetail.tsx

@@ -39,6 +39,7 @@ const I = {
   edit: 'M4 20h4L19.5 8.5a2.1 2.1 0 0 0-3-3L5 17v3zM13.5 6.5l3 3',
   loading: 'M12 3a9 9 0 1 0 9 9M12 3a9 9 0 0 1 9 9',
   search: 'M11 19a8 8 0 1 0 0-16 8 8 0 0 0 0 16zM21 21l-4.3-4.3',
+  refresh: 'M20.5 12a8.5 8.5 0 1 1-2.6-6.1M20.5 4v5h-5',
 }
 
 interface SupplierDetailProps {
@@ -108,8 +109,8 @@ export function SupplierDetail({ supplier, accounts, statusLoading, onBack, onRe
   const [removeModelTarget, setRemoveModelTarget] = useState<string | null>(null)
   const [poolStrategy, setPoolStrategy] = useState<'fallback' | 'round-robin'>('fallback')
   const [poolOrder, setPoolOrder] = useState<string[]>([])
-  const [checkinRule, setCheckinRule] = useState<'all' | 'first'>('all')
   const [checkingIn, setCheckingIn] = useState(false)
+  const [refreshing, setRefreshing] = useState(false)
   const [dragIndex, setDragIndex] = useState<number | null>(null)
   const mounted = useRef(true)
 
@@ -144,20 +145,17 @@ export function SupplierDetail({ supplier, accounts, statusLoading, onBack, onRe
 
   const loadPoolConfig = useCallback(async (): Promise<void> => {
     try {
-      const [strategyRes, orderRes, ruleRes] = await Promise.all([
+      const [strategyRes, orderRes] = await Promise.all([
         fetch(`${ROUTER_API_BASE}/suppliers/${supplier.id}/pool/strategy`, { cache: 'no-store' }),
         fetch(`${ROUTER_API_BASE}/suppliers/${supplier.id}/pool/order`, { cache: 'no-store' }),
-        fetch(`${ROUTER_API_BASE}/suppliers/${supplier.id}/checkin/rule`, { cache: 'no-store' }),
       ])
-      const [strategyData, orderData, ruleData] = await Promise.all([strategyRes.json(), orderRes.json(), ruleRes.json()]) as [
+      const [strategyData, orderData] = await Promise.all([strategyRes.json(), orderRes.json()]) as [
         { ok: boolean; strategy?: 'fallback' | 'round-robin' },
         { ok: boolean; order?: string[] },
-        { ok: boolean; rule?: 'all' | 'first' },
       ]
       if (mounted.current) {
         if (strategyData.ok && strategyData.strategy) setPoolStrategy(strategyData.strategy)
         if (orderData.ok && Array.isArray(orderData.order)) setPoolOrder(orderData.order)
-        if (ruleData.ok && ruleData.rule) setCheckinRule(ruleData.rule)
       }
     } catch {
       // 连接池配置加载失败不阻断
@@ -209,6 +207,45 @@ export function SupplierDetail({ supplier, accounts, statusLoading, onBack, onRe
     }
   }
 
+  /** 刷新链接池：积分刷一遍 + 全供应商健康探测（最简会话，走真实 chatCompletions
+   *  并按账号池回退，所以「这个供应商还有没有活着的链接」能回答；不按链接细分 —— 那需要
+   *  按 uid 指定账号的管道，会给插件增负）。 */
+  const runRefresh = async (): Promise<void> => {
+    if (refreshing) return
+    setRefreshing(true)
+    let msg = ''
+    try {
+      const response = await fetch(`${ROUTER_API_BASE}/suppliers/${supplier.id}/links/refresh`, { method: 'POST', cache: 'no-store' })
+      const data = await response.json() as { ok: boolean; changed?: boolean; accounts?: unknown[]; error?: string }
+      if (!data.ok) {
+        showToast(data.error ?? '刷新失败')
+        return
+      }
+      // 健康探测：拿一个启用模型跑最简会话；没有启用模型就退回任意第一个
+      const probe = models?.find(m => m.enabled) ?? models?.[0]
+      if (probe === undefined) {
+        msg = `已刷新 ${data.accounts?.length ?? 0} 链接 · 无模型可探测`
+      } else {
+        const probeRes = await fetch(`${ROUTER_API_BASE}/suppliers/${supplier.id}/models/test`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ id: probe.id }),
+          cache: 'no-store',
+        })
+        const probeData = await probeRes.json() as { ok: boolean; error?: string }
+        msg = probeData.ok
+          ? `已刷新 ${data.accounts?.length ?? 0} 链接 · 健康`
+          : `已刷新 ${data.accounts?.length ?? 0} 链接 · 不可用：${probeData.error ?? '未知'}`
+      }
+      showToast(msg)
+      onRefresh()
+    } catch (err) {
+      showToast(`刷新失败：${(err as Error).message}`)
+    } finally {
+      setRefreshing(false)
+    }
+  }
+
   const startLogin = async (): Promise<void> => {
     // API key 供应商：弹窗直接填名字+key，不走 URL 登录
     if (canApiKey) {
@@ -238,15 +275,15 @@ export function SupplierDetail({ supplier, accounts, statusLoading, onBack, onRe
     }
   }
 
-  const completeLogin = async (): Promise<void> => {
-    if (callbackUrl.trim() === '') return
+  const completeLogin = async (poll = false): Promise<void> => {
+    if (!poll && callbackUrl.trim() === '') return
     setBusy(true)
     setError('')
     try {
       const response = await fetch(`${ROUTER_API_BASE}/suppliers/${supplier.id}/login/callback`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ callbackUrl: callbackUrl.trim() }),
+        body: JSON.stringify({ callbackUrl: poll ? '' : callbackUrl.trim() }),
         cache: 'no-store',
       })
       const data = await response.json() as { ok: boolean; error?: string; account?: { uid: string; nickname: string } }
@@ -470,7 +507,7 @@ export function SupplierDetail({ supplier, accounts, statusLoading, onBack, onRe
       const data = await response.json() as { ok: boolean; error?: string }
       if (data.ok) {
         setAlias(aliasDraft.trim())
-        // 同时保存连接池策略 + 签到规则
+        // 同时保存连接池策略
         try {
           await fetch(`${ROUTER_API_BASE}/suppliers/${supplier.id}/pool/strategy`, {
             method: 'POST',
@@ -481,16 +518,6 @@ export function SupplierDetail({ supplier, accounts, statusLoading, onBack, onRe
         } catch {
           // 策略保存失败不阻断前缀保存
         }
-        try {
-          await fetch(`${ROUTER_API_BASE}/suppliers/${supplier.id}/checkin/rule`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ rule: checkinRule }),
-            cache: 'no-store',
-          })
-        } catch {
-          // 签到规则保存失败不阻断前缀保存
-        }
         setShowAlias(false)
       } else {
         setAliasError(data.error ?? '保存失败')
@@ -559,9 +586,16 @@ export function SupplierDetail({ supplier, accounts, statusLoading, onBack, onRe
         <div className="dshr-cardHead">
           <div className="dshr-cardTitle">链接池</div>
           <div className="dshr-cardActions">
+            <button type="button" className="dshr-iconBtn dshr-iconBtn-sm" onClick={() => void runRefresh()} disabled={refreshing || supplierAccounts.length === 0} title="刷新积分并探测健康" aria-label="刷新积分并探测健康">
+              <span className={refreshing ? 'dshr-spin' : undefined}>
+                <Icon d={I.refresh} size={15} />
+              </span>
+            </button>
             {canCheckin && (
-              <button type="button" className="dshr-miniButton" onClick={() => void runCheckin()} disabled={checkingIn || supplierAccounts.length === 0}>
-                {checkingIn ? '签到中…' : '签到'}
+              <button type="button" className="dshr-iconBtn dshr-iconBtn-sm" onClick={() => void runCheckin()} disabled={checkingIn || supplierAccounts.length === 0} title="签到所有链接" aria-label="签到所有链接">
+                <span className={checkingIn ? 'dshr-spin' : undefined}>
+                  <Icon d={I.checkCircle} size={15} />
+                </span>
               </button>
             )}
             {canLogin && (
@@ -792,7 +826,7 @@ export function SupplierDetail({ supplier, accounts, statusLoading, onBack, onRe
         </Modal>
       )}
 
-      {/* ---- 编辑供应商弹窗（前缀 + 连接池策略 + 签到规则） ---- */}
+      {/* ---- 编辑供应商弹窗（前缀 + 连接池策略） ---- */}
       {showAlias && (
         <Modal title="编辑供应商" onClose={() => setShowAlias(false)}>
           <div className="dshr-modalForm">
@@ -818,16 +852,6 @@ export function SupplierDetail({ supplier, accounts, statusLoading, onBack, onRe
                 <option value="round-robin">轮询</option>
               </select>
             </>
-            <label className="dshr-fieldLabel">签到规则</label>
-            <p className="dshr-muted">所有链接 = 签到每个链接；首个链接 = 只签到第一个链接。（dsh-router 通用策略）</p>
-            <select
-              className="dshr-select dshr-input"
-              value={checkinRule}
-              onChange={(e) => setCheckinRule(e.target.value as 'all' | 'first')}
-            >
-              <option value="all">所有链接</option>
-              <option value="first">首个链接</option>
-            </select>
             {aliasError !== '' && <div className="dshr-alert"><strong>出错了</strong><span>{aliasError}</span></div>}
             <div className="dshr-modalActions">
               <button type="button" className="dshr-miniButton" onClick={() => setShowAlias(false)}>取消</button>
@@ -895,7 +919,7 @@ export function SupplierDetail({ supplier, accounts, statusLoading, onBack, onRe
                           <div className="dshr-loginStep"><span className="dshr-loginNum">2</span>登录成功后点「完成添加」，自动获取凭证</div>
                           {error !== '' && <div className="dshr-alert"><strong>出错了</strong><span>{error}</span></div>}
                           <div className="dshr-modalActions">
-                            <button type="button" className="dshr-primaryButton" onClick={() => void completeLogin()} disabled={busy}>
+                            <button type="button" className="dshr-primaryButton" onClick={() => void completeLogin(true)} disabled={busy}>
                               {busy ? '轮询中…' : '完成添加'}
                             </button>
                           </div>

package/src/client/router.css

@@ -430,14 +430,17 @@ html[data-dsh-router-active]:not([data-dsh-taskboard-active]):not([data-dsh-ssh-
 
 .dshr-tabBody {
   display: flex;
+  flex: 1 1 auto;      /* 填满 content;自身滚动 */
   min-width: 0;
   min-height: 0;
   flex-direction: column;
   gap: 14px;
   padding: 14px 18px;
+  overflow-y: auto;
 }
 
 .dshr-card {
+  flex: none;          /* 不参与 flex 伸缩:高度=内容,避免被压缩裁切 */
   min-width: 0;
   border: 1px solid var(--rs-line);
   border-radius: 10px;
@@ -1100,6 +1103,12 @@ html[data-dsh-router-active]:not([data-dsh-taskboard-active]):not([data-dsh-ssh-
 
 .dshr-iconBtn-sm { width: 26px; height: 26px; }
 
+/* 禁用态必须看得出来：纯图标按钮没有文字可读（不像「刷新中…」），
+   只靠 hover 反馈会让人以为还能点。 */
+.dshr-iconBtn:disabled { opacity: .4; cursor: default; }
+
+.dshr-iconBtn:disabled:hover { color: var(--rs-muted); background: transparent; }
+
 /* Require API key 行 */
 .dshr-requireRow {
   display: flex;

package/src/index.ts

@@ -128,7 +128,7 @@ export function apply(rawContext: unknown): void {
   const stateFile = process.env.TW2A_STATE_FILE ?? 'data/state.json'
   const store = new SupplierConfigStore(stateFile)
   const credentials = new CredentialStore(process.env.TW2A_AUTH_DIR ?? join(dirname(stateFile), 'auths'))
-  const router = new Router(stateFile)
+  const router = new Router(stateFile, store)
 
   const keys = new KeysStore(stateFile)
 
@@ -146,7 +146,7 @@ export function apply(rawContext: unknown): void {
   const supplierDisposers = new Map<string, Array<() => void>>()
   const registerSupplierRoutes = (loaded: LoadedSupplier): void => {
     const dis: Array<() => void> = []
-    for (const r of supplierRoutes(ROUTER_API_BASE, loaded, store)) {
+    for (const r of supplierRoutes(ROUTER_API_BASE, loaded, store, router)) {
       dis.push(ctx.webServer.register(r))
     }
     supplierDisposers.set(loaded.supplier.id, dis)