dsh-cmtoken-oauth 1.5.2 → 1.6.0

package/README.md

@@ -1,21 +1,24 @@
 # dsh-cmtoken-oauth
 
-DeepSeek Harness（DSH）插件：在 **DSH 设置页**内一键认证广东移动 MaaS（cmtoken），自动发现并接入模型，无需手动填写 API Key 或模型列表。
+DeepSeek Harness（DSH）插件：在 **DSH 设置页**内一键认证中国移动算力豆平台（komect，`ai.soho.komect.com`），扫码一次即完成认证、密钥管理与用量查询，自动发现并接入模型，无需手动填写 API Key 或模型列表。
+
+> v1.6.0 起认证通道迁移：旧 cmtoken OAuth Device Grant（广东移动 MaaS）已由 **komect API key 通道**取代——扫码登录 order-center 后经单向桥接换取密钥管理会话，自动创建/复用名为 **DSH** 的 API key（`lx_sk_`，长期有效，无需刷新令牌），模型规格（上下文窗口 / 最大输出 / 图片支持）由平台接口动态提供。
 
 ## 功能
 
-- **一键认证**：基于 OAuth 2.0 Device Authorization Grant（RFC 8628）+ PKCE (S256)，扫码或输入用户码即可完成，无需配置脚本。
+- **一键认证（一次扫码全搞定）**：扫码登录 order-center → 自动桥接密钥管理会话 → 自动创建/复用专属 **DSH** API key → 拉取模型列表写入 `llm-pi-ai` 的 `providers.cmtoken` 配置（merge，不影响其他 provider）。
+- **算力豆用量**：设置页直接显示生效中套餐的剩余/总额算力豆与到期时间（来自 order-center 用量接口）；会话失效时提示重新扫码。
 - **内联二维码**：认证流程内置 QR 生成（零依赖），无需额外安装二维码工具。
-- **自动发现模型**：认证成功后自动拉取可用模型列表，写入 `llm-pi-ai` 的 `providers.cmtoken` 配置（merge，不影响其他 provider）。
-- **原生视觉**：视觉模型（Qwen3.8 27B / Qwen3.x / Kimi K2.x 非 code / MiniMax M3）写入配置时自动声明 `input: ["text","image"]` 模态，DSH 直接放行图片输入（经持久附件服务直达模型），粘贴/拖入图片即可用。
+- **自动发现模型 + 动态规格**：认证成功后拉取可用模型，上下文窗口 / 最大输出 / 图片支持均按平台返回值写入，不再依赖硬编码表。
+- **原生视觉**：平台声明支持图片的模型（qwen38-27b / Qwen3.6-35B / Kimi K2.5/K2.6 等）写入配置时自动声明 `input: ["text","image"]` 模态，DSH 直接放行图片输入（经持久附件服务直达模型），粘贴/拖入图片即可用。
 - **粘贴/拖图（普通模型直接收图）**：纯文本模型（如 deepseekv4-flash）贴图/拖图时，client 端拦截并把图片（自动压缩到 ~1080p：长边 ≤1920）存到 `~/.dsh/cmtoken-pastes/`——**输入框和会话气泡不出现路径文本**：输入框上方显示「cmtoken识图」胶囊缩略图条（与输入卡片左对齐，✕ 可撤回），发送时刻由 host 的 `agent/pre-step` 钩子把 `[Image: 路径]` 追加到最后一条用户消息（仅模型上下文可见）。识图延迟到模型按需调用 `cmtoken_read_image` 工具时完成；粘贴后 30 分钟内未随消息发出的图片自动放弃注入。视觉模型不接管，保留原生缩略图体验。
 - **视觉回退模型可选**：设置 → cmtoken 认证页可指定识图引擎（默认「自动」按优先级 qwen38 > qwen3.x > kimi k2.x 非 code > minimax-m3），选择持久化在 `~/.dsh/cmtoken-oauth.json`，工具与判定路由均遵循。
 - **视觉回退工具**：注册 `cmtoken_read_image` 工具——任何模型把图片路径（本地路径或 http(s) URL）交给工具，host 侧自动选用优先级最高的视觉模型识图，返回结构化取证（概述 / 全文转写 / 版面 / 语义 / 不确定项）。无需外部识图服务，凭据与配额都在 cmtoken 体系内。
 - **可选包装路由（默认关闭）**：profile 插件 config 设 `visionRoute: true` 可注册 `cmtoken-vision` 分组——把纯文本模型镜像成声明图片输入的条目，贴图以真实图片气泡进入会话、请求时自动转证据文本。需要图片气泡原样展示的会话可开启。
-- **自动配置上下文**：按模型名称关键词自动匹配各模型的上下文与最大输出长度（DeepSeek V4 / MiniMax M3 / Qwen / GLM / Kimi / MiniMax 2.x / hy 等），无需手动填写。
-- **安全存储**：token 存入 DSH 凭据服务（OS keyring / env），不落盘明文。
-- **自动续期 / 注销**：令牌临近过期自动 refresh；可随时注销清空凭据。
-- **订购算力豆套餐**：设置页内一键跳转广东移动 H5 订购页，直达算力豆套餐购买。
+- **自动配置上下文**：上下文与最大输出按平台 `getApiKeyModels` 返回值动态写入，无需手动维护。
+- **安全存储**：API key 与会话存入 DSH 凭据服务（OS keyring / env），不落盘明文。
+- **注销**：可随时注销清空凭据（API key 在平台上保留，可再次扫码复用）。
+- **算力豆套餐**：设置页内一键跳转算力豆用量/订购页。
 
 零第三方运行时依赖（仅使用 Node 内置模块）。
 
@@ -69,6 +72,21 @@ lib/client.js   web：设置页「cmtoken 认证」向导（视觉模型标 👁
 lib/qr-core.cjs 内联 QR 编码器（输出 SVG）
 ```
 
+## 变更记录
+
+### 1.5.3（2026-09-11）
+
+- 修复 DSH 0.1.5+（desktop 0.1.5-rc.1 起）下插件树加载失败：
+  `cannot get property "webServer" without inject`。
+- 根因：新版 `connection.rpc.handle(channel, handler)` 在注册时执行
+  `owner.webServer.register(route)`，而 `owner` 恒为 connection 插件自身的 ctx
+  （其 inject 只有 `credentials`），第三方插件调用必然抛错。
+- 改法：在 `ctx.inject(['webServer'])` 子上下文用
+  `ctx.webServer.register({ kind: 'prefix', path: '/cmtoken-oauth', handler })`
+  自注册 RPC 前缀路由，并沿用 connection 的
+  `client-request` / `server-response` 信封协议，客户端代码无需改动；
+  另加 loopback 来源校验。
+
 ## License
 
 MIT

package/lib/client.js

@@ -12,7 +12,7 @@ window.__ModuleLoader__.load({
 
 		// ==================== 工具 ====================
 		const CHANNEL = "/cmtoken-oauth";
-		const ORDER_URL = "https://wap.gd.10086.cn/ech/h5/token-prduct/index.html";
+		const ORDER_URL = "https://ai.soho.komect.com/ai/llm/order-center/public/pages/token-usage?business=workbuddy";
 		function unwrap(r) { if (r && r.ok) return r.value; throw new Error(r && r.error ? r.error.message : "未知错误"); }
 
 		// ==================== 样式 ====================
@@ -122,7 +122,7 @@ window.__ModuleLoader__.load({
 				catch (e) { setError(e.message || String(e)); }
 			};
 
-			const authenticated = !!(status && status.configured && !status.expired);
+			const authenticated = !!(status && status.configured);
 
 			// 未认证时自动开始认证（设置页一打开就出二维码）
 			useEffect(() => {
@@ -137,17 +137,15 @@ window.__ModuleLoader__.load({
 			if (phase === "loading") {
 				authCard = react.createElement("div", { className: "co-card" },
 					react.createElement("div", { className: "co-card-title" }, "认证"),
-					react.createElement("p", { className: "co-hint" }, "支持广东移动模型服务为 DSH 提供一键认证，令牌无需手动刷新。"),
+					react.createElement("p", { className: "co-hint" }, "中国移动算力豆（komect）一键认证：扫码即自动创建专属 DSH API key，长期有效，无需刷新令牌。"),
 					react.createElement("div", { className: "co-hint" }, "加载中…"));
 			} else if (phase === "qr" && flow) {
 				authCard = react.createElement("div", { className: "co-card" },
 					react.createElement("div", { className: "co-card-title" }, "认证"),
-					react.createElement("p", { className: "co-hint" }, "支持广东移动模型服务为 DSH 提供一键认证，令牌无需手动刷新。"),
+					react.createElement("p", { className: "co-hint" }, "中国移动算力豆（komect）一键认证：扫码即自动创建专属 DSH API key，长期有效，无需刷新令牌。"),
 					react.createElement("div", { className: "co-qr" },
 						react.createElement("div", { dangerouslySetInnerHTML: { __html: flow.qr_svg } }),
-						react.createElement("div", { className: "co-code" }, flow.user_code),
-						react.createElement("div", { className: "co-url" }, flow.verification_uri),
-						react.createElement("div", { className: "co-hint" }, "手机扫码完成授权，有效期 " + Math.round((flow.expires_in || 600) / 60) + " 分钟")
+						react.createElement("div", { className: "co-hint" }, "扫码登录中国移动账号，一次扫码完成认证与用量关联，约 " + Math.round(flow.expires_in || 180) + " 秒内有效")
 					),
 					react.createElement("div", { className: "co-status" },
 						react.createElement("span", { className: "co-dot" }),
@@ -155,36 +153,48 @@ window.__ModuleLoader__.load({
 			} else if (phase === "done") {
 				authCard = react.createElement("div", { className: "co-card" },
 					react.createElement("div", { className: "co-card-title" }, "认证"),
-					react.createElement("p", { className: "co-hint" }, "支持广东移动模型服务为 DSH 提供一键认证，令牌无需手动刷新。"),
+					react.createElement("p", { className: "co-hint" }, "中国移动算力豆（komect）一键认证：扫码即自动创建专属 DSH API key，长期有效，无需刷新令牌。"),
 					react.createElement("div", { className: "co-auth-ok" }, "✅ 已认证" + (models.length ? "，已接入 " + models.length + " 个模型" : "")),
 					react.createElement("div", { className: "co-row" },
-						react.createElement(Button, { variant: "outline", size: "md", onClick: doRefresh }, "刷新令牌"),
+						react.createElement(Button, { variant: "outline", size: "md", onClick: doRefresh }, "刷新模型与用量"),
 						react.createElement(Button, { variant: "outline", size: "md", onClick: begin }, "重新认证")));
 			} else if (phase === "error") {
 				authCard = react.createElement("div", { className: "co-card" },
 					react.createElement("div", { className: "co-card-title" }, "认证"),
-					react.createElement("p", { className: "co-hint" }, "支持广东移动模型服务为 DSH 提供一键认证，令牌无需手动刷新。"),
+					react.createElement("p", { className: "co-hint" }, "中国移动算力豆（komect）一键认证：扫码即自动创建专属 DSH API key，长期有效，无需刷新令牌。"),
 					react.createElement("div", { className: "co-err" }, "❌ " + (error || "认证失败")),
 					react.createElement("div", { className: "co-row" },
 						react.createElement(Button, { variant: "primary", size: "md", onClick: () => { setPhase("ok"); setError(null); } }, "返回重试")));
 			} else if (authenticated) {
 				authCard = react.createElement("div", { className: "co-card" },
 					react.createElement("div", { className: "co-card-title" }, "认证"),
-					react.createElement("p", { className: "co-hint" }, "支持广东移动模型服务为 DSH 提供一键认证，令牌无需手动刷新。"),
+					react.createElement("p", { className: "co-hint" }, "中国移动算力豆（komect）一键认证：扫码即自动创建专属 DSH API key，长期有效，无需刷新令牌。"),
 					react.createElement("div", { className: "co-auth-ok" },
 						"✅ 已认证",
-						status && status.expiresAt ? react.createElement("span", { className: "co-hint" },
-							status.expired ? "令牌已过期" : "剩余约 " + Math.max(0, Math.round((status.expiresAt - Date.now()) / 60000)) + " 分钟") : null),
+						status && status.sessionExpired ? react.createElement("span", { className: "co-hint" }, "（管理会话已过期，重新扫码可刷新模型列表）") : null),
 					react.createElement("div", { className: "co-row" },
-						react.createElement(Button, { variant: "outline", size: "md", onClick: doRefresh }, "刷新令牌"),
+						react.createElement(Button, { variant: "outline", size: "md", onClick: doRefresh }, "刷新模型与用量"),
 						react.createElement(Button, { variant: "outline", size: "md", onClick: begin }, "重新认证")));
 			} else {
 				authCard = react.createElement("div", { className: "co-card" },
 					react.createElement("div", { className: "co-card-title" }, "认证"),
-					react.createElement("p", { className: "co-hint" }, "支持广东移动模型服务为 DSH 提供一键认证，令牌无需手动刷新。"),
+					react.createElement("p", { className: "co-hint" }, "中国移动算力豆（komect）一键认证：扫码即自动创建专属 DSH API key，长期有效，无需刷新令牌。"),
 					react.createElement("div", { className: "co-hint" }, "准备二维码…"));
 			}
 
+			// ---- 卡片：算力豆用量 ----
+			const usageCard = status && status.usageLinked
+				? react.createElement("div", { className: "co-card" },
+					react.createElement("div", { className: "co-card-title" }, "算力豆用量"),
+					status.usageExpired
+						? react.createElement("p", { className: "co-hint" }, "用量会话已失效，点击「重新认证」再扫一次码即可恢复查询。")
+						: (status.usage && status.usage.length
+							? status.usage.map((u, i) => react.createElement("div", { key: i, className: "co-row", style: { justifyContent: "space-between" } },
+								react.createElement("span", null, u.name),
+								react.createElement("span", { className: "co-hint" },
+									u.remain + " / " + u.total + " 豆" + (u.expireTime ? " · " + u.expireTime + " 到期" : ""))))
+							: react.createElement("p", { className: "co-hint" }, "暂无生效中的算力豆套餐。")))
+				: null;
 			// ---- 卡片：视觉识图 ----
 			const visionCard = status && status.visionModels && status.visionModels.length > 0
 				? react.createElement("div", { className: "co-card" },
@@ -209,6 +219,7 @@ window.__ModuleLoader__.load({
 			return react.createElement("div", { className: "dsh-co" },
 				react.createElement("h3", null, "cmtoken 模型服务"),
 				authCard,
+				usageCard,
 				visionCard,
 				planCard,
 				phase !== "error" && error ? react.createElement("div", { className: "co-err" }, error) : null);

package/lib/index.js

@@ -21,146 +21,162 @@ export const inject = ['connection', 'settings', 'credentials', 'tools', 'llm',
 
 export const Config = z.object({});
 
-// ---------------- 协议常量（分析报告第 4 节） ----------------
-const OAUTH_BASE = 'https://agentlink.idaas.cmpassport.com/oauth2-service';
-const CLIENT_ID = '00a60e3140284b408d51a436ecce121d';
-const DEVICE_GRANT = 'urn:ietf:params:oauth:grant-type:device_code';
-const DEFAULT_API_BASE = 'https://maas.gd.chinamobile.com:36007/ai/uifm/open/v1';
-const DISCOVERY_URL = DEFAULT_API_BASE + '/models';
-const TIMEOUT = 900_000;
+// ---------------- 协议常量 ----------------
+// 旧通道（广东移动 MaaS OAuth Device Grant）已由 komect API-key 通道取代（见下）。
 
 const API_KEY_ENV = 'CMTOKEN_API_KEY';
 const REFRESH_ENV = 'CMTOKEN_REFRESH_TOKEN';
 const EXPIRES_ENV = 'CMTOKEN_EXPIRES';
+const SESSION_ENV = 'KOMECT_SESSION'; // 新通道管理会话（模型发现用）
+const ORDER_SESSION_ENV = 'KOMECT_ORDER_SESSION'; // order-center 用量查询会话
+
+// ---------------- 算力豆用量（order-center，可选关联） ----------------
+// 用量页（/ai/llm/order-center/public/pages/token-usage）逆向所得：
+//   GET  {ORDER}/sso/qrcode?business=workbuddy → {uuid, qr_code_url, expire, poll_interval_ms}
+//   POST {ORDER}/sso/qrcode/status {uuid}      → {state:'0'|'1'|'2'|'-1'|'-3', order_session, phone}
+//   POST {ORDER}/token/usage {order_session, page, page_size}
+//        → {orderBenefitList:[{commodityName, remainBalance, totalBalance, expireTime, benefitStatus}]}
+// 余额单位：1 算力豆 = 10000（900 豆套餐 totalBalance=9000000）。
+// 注意：order-center 与 API key 页是两套会话，需各自扫码；本功能为可选关联。
+const ORDER_BASE = 'https://ai.soho.komect.com/ai/llm/order-center/public/client/v1';
+const ORDER_QR_TTL_MS = 180_000;
+const pendingOrder = new Map();
+
+async function orderPost(path, body, timeout = 20_000) {
+  const res = await fetch(`${ORDER_BASE}${path}`, {
+    method: 'POST',
+    signal: AbortSignal.timeout(timeout),
+    headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+    body: JSON.stringify(body ?? {}),
+  });
+  const json = await res.json().catch(() => undefined);
+  if (json?.code === 3004) throw new Error('用量会话已失效，请重新扫码关联');
+  if (!res.ok || json?.code !== 0) {
+    throw new Error(`order-center ${path} 失败 ${res.status}: ${String(json?.message ?? '').slice(0, 200) || 'unknown'}`);
+  }
+  return json.data;
+}
 
-// 单用户 Web 场景：进行中的设备码流程保存在模块级（keyed by requestId）
-const pending = new Map();
-
-const scope = () => `profile model.completion identity:device:${os.hostname()}`;
+/** 桥接：order_session → api-key/link → sso_token → sso-login → {session, expires}。 */
+async function bridgeManagementSession(orderSession) {
+  const linkData = await orderPost('/api-key/link', { order_session: orderSession });
+  const link = linkData?.link;
+  const ssoToken = typeof link === 'string' ? new URL(link).searchParams.get('token') : null;
+  if (!ssoToken) throw new Error('桥接失败：api-key/link 未返回有效 token');
+  const data = await komect('/api-keys/sso-login', { method: 'POST', body: { sso_token: ssoToken } });
+  if (!data?.management_session) throw new Error('桥接失败：sso-login 未返回管理会话');
+  return { session: data.management_session, expires: (data.expires_at ?? 0) * 1000 || null };
+}
 
-function makePkce() {
-  const verifier = randomBytes(32).toString('base64url');
-  const challenge = createHash('sha256').update(verifier).digest('base64url');
-  const state = randomBytes(16).toString('base64url');
-  return { verifier, challenge, state };
+/** order_session → 算力豆余额摘要（豆单位，1 豆 = 10000）。 */
+async function fetchUsageSummary(orderSession) {
+  const data = await orderPost('/token/usage', { order_session: orderSession, page: 1, page_size: 20 });
+  const list = Array.isArray(data?.orderBenefitList) ? data.orderBenefitList : [];
+  return list
+    .filter((b) => b && b.benefitStatus === '生效中')
+    .map((b) => ({
+      name: b.commodityName ?? b.prodName ?? '算力豆套餐',
+      remain: Number(b.remainBalance) / 10_000,
+      total: Number(b.totalBalance) / 10_000,
+      expireTime: b.expireTime ?? null,
+    }));
 }
 
-async function requestDeviceCode() {
-  const { verifier, challenge, state } = makePkce();
-  const res = await fetch(`${OAUTH_BASE}/oauth/device/code`, {
-    method: 'POST',
-    signal: AbortSignal.timeout(TIMEOUT),
+// ---------------- 新通道：komect（ai.soho.komect.com，默认） ----------------
+// API key 管理页（https://ai.soho.komect.com/ai/llm/api-key-page/）逆向所得：
+//   扫码登录：POST {USER}/api-keys/login/qr → {uuid, qr_code_url, poll_interval_ms}
+//   轮询：    POST {USER}/api-keys/login/qr/status {uuid} → {state: '0'|'1'|'2', session}
+//             state 2 时 session = {management_session(lx_km_), expires_at(epoch 秒), ...}
+//   密钥管理（Bearer management_session）：
+//             GET    /api-keys                       → {items:[{id,name,masked_key,revealable}], limit, masked_phone}
+//             POST   /api-keys {name}                → 创建
+//             POST   /api-keys/{id}/reveal           → {api_key}（lx_sk_ 明文；仅新建可 reveal）
+//             DELETE /api-keys/{id}
+//   模型发现：POST {GW}/models/getApiKeyModels（Bearer management_session）
+//             → [{modelName, name, extInfo:{limits:{max_input_tokens,max_output_tokens},
+//                supports_images, thinking}}]
+//   推理网关：{GW} OpenAI 兼容（Bearer lx_sk_）
+const USER_BASE = 'https://ai.soho.komect.com/ai/llm/agent';
+const GW_BASE = 'https://ai.soho.komect.com/ai/llm/gw/v1';
+const DSH_KEY_NAME = 'DSH'; // 一键认证专用密钥名：只认/只建这个名字的密钥
+
+/** komect 用户服务请求封装；ok 时返回 data，失败抛错。 */
+async function komect(path, { method = 'GET', token, body, timeout = 20_000 } = {}) {
+  const res = await fetch(`${USER_BASE}${path}`, {
+    method,
+    signal: AbortSignal.timeout(timeout),
     headers: {
-      'Content-Type': 'application/x-www-form-urlencoded',
       Accept: 'application/json',
-      'x-request-id': randomUUID(),
+      ...(body !== undefined ? { 'Content-Type': 'application/json' } : {}),
+      ...(token ? { Authorization: `Bearer ${token}` } : {}),
     },
-    body: new URLSearchParams({
-      response_type: 'device_code',
-      client_id: CLIENT_ID,
-      scope: scope(),
-      code_challenge: challenge,
-      code_challenge_method: 'S256',
-      state,
-    }),
+    ...(body !== undefined ? { body: JSON.stringify(body) } : {}),
   });
-  if (!res.ok) throw new Error(`设备码申请失败: ${await res.text()}`);
-  const json = await res.json();
-  if (!json.device_code || !json.user_code || !json.verification_uri) {
-    throw new Error(json.error_description ?? json.error ?? '设备码响应不完整');
+  const json = await res.json().catch(() => undefined);
+  if (res.status === 401 || json?.code === 3004) {
+    throw new Error('komect 管理会话已失效，请重新扫码认证');
+  }
+  if (!res.ok || json?.code !== 0) {
+    throw new Error(`komect ${path} 失败 ${res.status}: ${String(json?.message ?? '').slice(0, 200) || 'unknown'}`);
   }
-  return { ...json, verifier };
+  return json.data;
 }
 
-/** 单次令牌轮询；成功返回 Token，pending 返回 null，失败抛错。 */
-async function pollOnce(deviceCode, verifier) {
-  let res;
-  try {
-    res = await fetch(`${OAUTH_BASE}/oauth/device/token`, {
-      method: 'POST',
-      signal: AbortSignal.timeout(TIMEOUT),
-      headers: { 'Content-Type': 'application/x-www-form-urlencoded', Accept: 'application/json' },
-      body: new URLSearchParams({
-        grant_type: DEVICE_GRANT,
-        client_id: CLIENT_ID,
-        device_code: deviceCode,
-        code_verifier: verifier,
-      }),
-    });
-  } catch {
-    return { status: 'pending' }; // 网络抖动 → 当 pending
+/** 确保「DSH」密钥存在并返回明文：只认 DSH 名；不存在则创建；存在但不可 reveal（旧密钥取不回原文）则删除重建。 */
+async function ensureDshApiKey(session) {
+  const list = await komect('/api-keys', { token: session });
+  const items = Array.isArray(list?.items) ? list.items : [];
+  const existing = items.find((it) => it?.name === DSH_KEY_NAME);
+  let item = existing;
+  if (existing && existing.revealable !== true) {
+    // 旧 DSH 密钥拿不回明文：它是本插件命名约定专属的，删除重建
+    await komect(`/api-keys/${encodeURIComponent(existing.id)}`, { method: 'DELETE', token: session });
+    item = undefined;
   }
-  const json = await res.json().catch(() => undefined);
-  if (res.ok) {
-    if (!json?.access_token || !json.refresh_token || !json.expires_in) {
-      throw new Error('令牌响应不完整');
+  if (!item) {
+    if ((list?.limit ?? 10) > 0 && items.length >= (list?.limit ?? 10)) {
+      // 配额已满且没有可复用的 DSH：报错提示（不删别人的密钥）
+      throw new Error(`密钥已达上限（${items.length}/${list?.limit}），请到 API key 管理页删除不需要的密钥后重试`);
     }
-    return {
-      status: 'ok',
-      token: {
-        access: json.access_token,
-        refresh: json.refresh_token,
-        expires: Date.now() + json.expires_in * 1000,
-        resourceUrl: json.resource_url,
-      },
-    };
+    item = await komect('/api-keys', { method: 'POST', token: session, body: { name: DSH_KEY_NAME } });
   }
-  if (json?.error === 'authorization_pending') return { status: 'pending' };
-  if (json?.error === 'slow_down') return { status: 'slow_down' };
-  throw new Error(json?.error_description ?? json?.error ?? '令牌请求失败');
+  const revealed = await komect(`/api-keys/${encodeURIComponent(item.id)}/reveal`, { method: 'POST', token: session });
+  const apiKey = revealed?.api_key;
+  if (typeof apiKey !== 'string' || !apiKey.startsWith('lx_sk_')) {
+    throw new Error('komect 密钥 reveal 失败：未返回有效的 lx_sk_ 密钥');
+  }
+  return apiKey;
 }
 
-async function refreshToken(refresh) {
-  const res = await fetch(`${OAUTH_BASE}/oauth/device/token`, {
+/** komect 模型发现：动态读取 limits 与图片支持，不再依赖硬编码 MODEL_SPECS。 */
+async function fetchKomectModels(session) {
+  const res = await fetch(`${GW_BASE}/models/getApiKeyModels`, {
     method: 'POST',
-    signal: AbortSignal.timeout(TIMEOUT),
-    headers: { 'Content-Type': 'application/x-www-form-urlencoded', Accept: 'application/json' },
-    body: new URLSearchParams({
-      grant_type: 'refresh_token',
-      client_id: CLIENT_ID,
-      refresh_token: refresh,
-    }),
+    signal: AbortSignal.timeout(20_000),
+    headers: { Accept: 'application/json', Authorization: `Bearer ${session}` },
   });
-  const json = await res.json();
-  if (!res.ok || json.error) throw new Error(json?.error_description ?? json?.error ?? '刷新失败');
-  return {
-    access: json.access_token,
-    refresh: json.refresh_token || refresh,
-    expires: Date.now() + json.expires_in * 1000,
-    resourceUrl: json.resource_url,
-  };
+  const json = await res.json().catch(() => undefined);
+  if (res.status === 401) throw new Error('komect 管理会话已失效，请重新扫码认证');
+  if (!res.ok || json?.code !== 0 || !Array.isArray(json?.data)) {
+    throw new Error(`komect 模型发现失败 ${res.status}: ${String(json?.message ?? '').slice(0, 200) || 'unknown'}`);
+  }
+  return json.data
+    .filter((m) => typeof m?.modelName === 'string' && m?.modelType === 'llm')
+    .map((m) => ({
+      id: m.modelName,
+      name: m.name ?? m.modelName,
+      contextWindow: m.extInfo?.limits?.max_input_tokens ?? DEFAULT_MODEL_SPEC.contextWindow,
+      maxTokens: m.extInfo?.limits?.max_output_tokens ?? DEFAULT_MODEL_SPEC.maxTokens,
+      // 图片准入以服务端 supports_images 声明为准
+      input: m.extInfo?.supports_images === true ? ['text', 'image'] : ['text'],
+    }));
 }
 
-// 根据模型名称关键词匹配「输入（上下文）/ 输出（最大生成）」规格。
-// 规格优先级：已知关键词匹配 > 发现接口自带值 > 通用默认值。
-const MODEL_SPECS = [
-  // DeepSeek V4 系列：deepseek-v4-pro（1M）/ deepseek-v4-flash（中台仅 512k）
-  { match: (n) => n.includes('deepseek') && n.includes('v4') && n.includes('flash'), contextWindow: 524_288, maxTokens: 393_216 },
-  { match: (n) => n.includes('deepseek') && n.includes('v4'), contextWindow: 1_048_576, maxTokens: 393_216 },
-  // MiniMax-M3（支持图片）
-  { match: (n) => n.includes('minimax') && /m3/.test(n), contextWindow: 1_048_576, maxTokens: 131_072 },
-  // Qwen 开源系列：qwen36-35b / qwen38-27b（支持图片）
-  { match: (n) => n.includes('qwen36') || n.includes('qwen38'), contextWindow: 262_144, maxTokens: 65_536 },
-  // Qwen 闭源系列：Qwen3.x-flash / plus / max（支持图片）
-  { match: (n) => n.includes('qwen'), contextWindow: 1_048_576, maxTokens: 65_536 },
-  // 智谱 GLM：glm-5.2 / glm-5.3
-  { match: (n) => n.includes('glm'), contextWindow: 1_048_576, maxTokens: 131_072 },
-  // MiniMax 2.x 系列：M2.7-highspeed / MiniMax M2.5
-  { match: (n) => n.startsWith('m2') || (n.includes('minimax') && /m2/.test(n)), contextWindow: 204_800, maxTokens: 65_536 },
-  // hy3 / hy3-preview 等
-  { match: (n) => /hy/.test(n), contextWindow: 262_144, maxTokens: 65_536 },
-];
 
+// 模型规格默认值：komect 通道正常情况下由 getApiKeyModels 动态提供，
+// 仅在发现接口失败时兜底使用。
 const DEFAULT_MODEL_SPEC = { contextWindow: 262_144, maxTokens: 65_536 };
 
-function modelSpecFor(id) {
-  const n = String(id).toLowerCase().replace(/[-_\s.]+/g, '');
-  for (const spec of MODEL_SPECS) {
-    if (spec.match(n)) return spec;
-  }
-  return DEFAULT_MODEL_SPEC;
-}
-
 // ---------------- 视觉（图片）能力判定与回退优先级 ----------------
 // 视觉模型优先级（值越小越优先，0 表示不支持图片）：
 //   1) Qwen3.8 27B（qwen38-27b 等）—— 最优先
@@ -187,119 +203,210 @@ function modelInputModalities(id) {
   return supportsVision(id) ? ['text', 'image'] : ['text'];
 }
 
-async function fetchModels(access, discoveryUrl) {
-  const res = await fetch(discoveryUrl || DISCOVERY_URL, {
-    signal: AbortSignal.timeout(15_000),
-    headers: { Accept: 'application/json', Authorization: `Bearer ${access}` },
-  });
-  if (!res.ok) {
-    const text = (await res.text()).slice(0, 200);
-    if (res.status === 403 && /订阅套餐|订阅已过期|余额不足/.test(text)) {
-      throw new Error('订阅错误：' + text);
-    }
-    throw new Error(`模型发现失败 ${res.status}: ${text}`);
-  }
-  const json = await res.json();
-  const list = Array.isArray(json.models) ? json.models : Array.isArray(json.data) ? json.data : [];
-  return list.map((m) => {
-    // 已知模型按名称关键词配置最大上下文；其余回退到发现接口值或通用默认
-    const spec = modelSpecFor(m.id);
-    return {
-      id: m.id,
-      name: m.name ?? m.id,
-      contextWindow: spec.contextWindow,
-      maxTokens: spec.maxTokens,
-    };
-  });
-}
-
 function errorResult(e) {
   const message = e instanceof Error ? e.message : String(e);
   return { ok: false, error: { code: 'bad-request', message, details: {} } };
 }
 
+/**
+ * DSH 0.1.5+ 兼容的 RPC 传输层。
+ *
+ * 旧版通过 `ctx.connection.rpc.handle(channel, handler)` 注册通道；新版
+ * connection 服务把路由挂到「调用方 fiber」的 webServer 上
+ * （dsh-client-connection/lib/index.js `owner.webServer.register(route)`），
+ * 而 owner 恒为 connection 插件自身的 ctx（其 inject 只有 credentials），
+ * 因此第三方插件调用必然抛 `cannot get property "webServer" without inject`。
+ *
+ * 改为在声明了 webServer 的子上下文里自注册一条 prefix 路由，并沿用
+ * connection 的 RPC 信封协议（client-request / server-response），
+ * 客户端代码无需改动。
+ */
+function registerHttpRpc(ctx, channel, dispatch) {
+  const webServer = ctx.get?.('webServer') ?? ctx.webServer;
+  if (webServer === undefined || typeof webServer.register !== 'function') {
+    ctx.logger?.warn?.(`[cmtoken-oauth] webServer 服务不可用，${channel} 通道未注册`);
+    return () => {};
+  }
+  const isLoopback = (req) => {
+    const addr = req.socket?.remoteAddress ?? '';
+    return addr === '127.0.0.1' || addr === '::1' || addr === '::ffff:127.0.0.1';
+  };
+  return webServer.register({
+    name: 'cmtoken-oauth-rpc',
+    kind: 'prefix',
+    path: channel,
+    handler: async (req, res) => {
+      const reply = (status, payload) => {
+        res.writeHead(status, { 'content-type': 'application/json' });
+        res.end(payload === undefined ? '' : JSON.stringify(payload));
+      };
+      if (req.method !== 'POST' || !isLoopback(req)) return reply(404);
+      let endpoint;
+      try {
+        const pathname = new URL(req.url ?? '/', 'http://dsh.internal').pathname;
+        if (!pathname.startsWith(channel + '/')) return reply(404);
+        endpoint = decodeURIComponent(pathname.slice(channel.length + 1));
+      } catch {
+        return reply(400);
+      }
+      if (endpoint === '' || endpoint.includes('/')) return reply(404);
+
+      const abort = new AbortController();
+      res.on('close', () => { if (!res.writableEnded) abort.abort(); });
+      const chunks = [];
+      try {
+        for await (const chunk of req) chunks.push(chunk);
+      } catch {
+        return reply(400);
+      }
+      let envelope;
+      try {
+        envelope = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+      } catch {
+        return reply(400);
+      }
+      const rpcId = typeof envelope?.rpcId === 'string' ? envelope.rpcId : 'unknown';
+      const method = typeof envelope?.method === 'string' ? envelope.method : endpoint;
+      let result;
+      try {
+        result = await dispatch(method, envelope?.payload, abort.signal);
+      } catch (e) {
+        result = errorResult(e);
+      }
+      if (result === null || typeof result !== 'object' || typeof result.ok !== 'boolean') {
+        result = { ok: true, value: result ?? {} };
+      }
+      reply(200, { type: 'server-response', rpcId, result });
+    },
+  });
+}
+
 function registerRpc(ctx) {
-  return ctx.connection.rpc.handle('/cmtoken-oauth', async (endpoint, rawPayload, signal) => {
+  return registerHttpRpc(ctx, '/cmtoken-oauth', async (endpoint, rawPayload, signal) => {
     try {
       if (signal?.aborted) throw new Error('请求已取消。');
       const payload = (rawPayload && typeof rawPayload === 'object') ? rawPayload : {};
 
       switch (endpoint) {
-        // ---- 开始认证：申请设备码 + 生成二维码 ----
+        // ---- 开始认证：order-center 扫码（一次扫码同时获得用量查询 + 密钥管理） ----
         case 'begin': {
-          const dc = await requestDeviceCode();
-          const url = dc.verification_uri_complete ?? dc.verification_uri;
+          const res = await fetch(`${ORDER_BASE}/sso/qrcode?business=workbuddy`, {
+            signal: AbortSignal.timeout(20_000),
+            headers: { Accept: 'application/json' },
+          });
+          const json = await res.json().catch(() => undefined);
+          const dc = json?.data;
+          if (!res.ok || json?.code !== 0 || !dc?.uuid || !dc.qr_code_url) {
+            throw new Error('二维码获取失败，请重试');
+          }
           const id = randomUUID();
-          pending.set(id, { device_code: dc.device_code, verifier: dc.verifier, expires_at: Date.now() + (dc.expires_in ?? 600) * 1000 });
+          pendingOrder.set(id, { uuid: dc.uuid, expires_at: Date.now() + (dc.expire ? dc.expire * 1000 : ORDER_QR_TTL_MS) });
           return {
             ok: true,
             value: {
               requestId: id,
-              qr_svg: qrSvg(url),
-              verification_uri: url,
-              verification_uri_complete: dc.verification_uri_complete,
-              user_code: dc.user_code,
-              interval: dc.interval ?? 2,
-              expires_in: dc.expires_in ?? 600,
+              qr_svg: qrSvg(dc.qr_code_url),
+              interval: Math.max(1, Math.round((dc.poll_interval_ms ?? 1500) / 1000)),
+              expires_in: dc.expire ?? Math.round(ORDER_QR_TTL_MS / 1000),
             },
           };
         }
 
-        // ---- 轮询令牌（client 按 interval 调用）；成功即自动发现模型 + 写配置 ----
+        // ---- 轮询扫码状态；成功即：桥接密钥管理会话 → 取/建 DSH 密钥 → 发现模型 → 写配置 ----
         case 'poll': {
           const rid = payload.requestId;
-          const rec = pending.get(rid);
+          const rec = pendingOrder.get(rid);
           if (!rec) return { ok: false, error: { code: 'bad-request', message: '认证流程已失效，请重新开始', details: {} } };
           if (Date.now() > rec.expires_at) {
-            pending.delete(rid);
-            return { ok: false, error: { code: 'timeout', message: '授权超时（未在有效期内完成扫码），请重新开始', details: {} } };
+            pendingOrder.delete(rid);
+            return { ok: false, error: { code: 'timeout', message: '二维码已过期（未在有效期内完成扫码），请重新开始', details: {} } };
+          }
+          const st = await orderPost('/sso/qrcode/status', { uuid: rec.uuid });
+          const state = String(st?.state ?? '');
+          if (state === '0') return { ok: true, value: { status: 'pending' } };
+          if (state === '1') return { ok: true, value: { status: 'pending', scanned: true } };
+          if (state === '-1' || state === '-3') {
+            pendingOrder.delete(rid);
+            return { ok: false, error: { code: 'bad-request', message: '扫码认证失败（' + (st?.state_desc ?? state) + '），请重新扫码', details: {} } };
           }
-          const r = await pollOnce(rec.device_code, rec.verifier);
-          if (r.status === 'pending') return { ok: true, value: { status: 'pending' } };
-          if (r.status === 'slow_down') return { ok: true, value: { status: 'slow_down' } };
-          // 成功：发现模型 + 写配置 + 存凭据
-          pending.delete(rid);
-          const token = r.token;
+          if (state !== '2' || !st?.order_session) {
+            pendingOrder.delete(rid);
+            return { ok: false, error: { code: 'bad-request', message: '扫码认证未完成，请刷新二维码重试', details: {} } };
+          }
+          // 扫码成功：order_session → 桥接管理会话 → DSH 密钥 → 模型 → 写配置
+          pendingOrder.delete(rid);
+          const orderSession = st.order_session;
+          await ctx.credentials.set(credentialRef(ORDER_SESSION_ENV), orderSession);
+
+          // 用量（失败不阻断主流程）
+          let usage = null;
+          try {
+            usage = await fetchUsageSummary(orderSession);
+          } catch (e) {
+            ctx.logger?.warn?.('[cmtoken-oauth] 算力豆用量获取失败: ' + String(e?.message || e));
+          }
+
+          // 桥接：order_session → api-key/link → sso_token → sso-login → management_session
+          const { session, expires } = await bridgeManagementSession(orderSession);
+          const apiKey = await ensureDshApiKey(session);
           let models = [];
           try {
-            models = await fetchModels(token.access, payload.discoveryUrl);
+            models = await fetchKomectModels(session);
           } catch (e) {
-            // 模型发现失败：凭据照存，配置给最小模型集，报错提示
-            ctx.logger?.warn?.('[cmtoken-oauth] 模型发现失败: ' + String(e.message || e));
-            models = [{ id: 'deepseekv4-flash', name: 'deepseekv4-flash', contextWindow: 192000, maxTokens: 8192 }];
+            // 模型发现失败：密钥照存，配置给最小模型集，报错提示
+            ctx.logger?.warn?.('[cmtoken-oauth] komect 模型发现失败: ' + String(e.message || e));
+            models = [{ id: 'deepseekv4-flash-guangdong', name: 'DeepSeek V4 Flash', contextWindow: 512_000, maxTokens: 512_000, input: ['text'] }];
           }
-          await writeConfigAndCreds(ctx, token, models);
+          await writeConfigAndCreds(ctx, { apiKey, session, expires }, models);
           return {
             ok: true,
             value: {
               status: 'ok',
-              // input 模态一并返回，client 用它给视觉模型打标
               models: models.map((m) => ({ ...m, input: m.input ?? modelInputModalities(m.id) })),
-              baseURL: token.resourceUrl || DEFAULT_API_BASE,
+              baseURL: GW_BASE,
+              keyName: DSH_KEY_NAME,
+              usage,
+              maskedPhone: st.phone ?? null,
             },
           };
         }
 
-        // ---- 认证状态 ----
+        // ---- 认证状态（含算力豆用量） ----
         case 'status': {
-          // 先触发一次按需自动刷新：用户一旦查看状态，若 access 已过期/临期
-          // 且有有效 refresh token，立即刷新，避免只靠粗粒度定时器漏刷。
-          await autoRefresh(ctx).catch((e) => ctx.logger?.warn?.('[cmtoken-oauth] 状态查询时自动刷新失败: ' + String(e?.message || e)));
           const creds = ctx.credentials;
           const apiInfo = await creds?.describe(credentialRef(API_KEY_ENV)).catch(() => undefined);
-          const refreshInfo = await creds?.describe(credentialRef(REFRESH_ENV)).catch(() => undefined);
+          const sessInfo = await creds?.describe(credentialRef(SESSION_ENV)).catch(() => undefined);
+          const orderInfo = await creds?.describe(credentialRef(ORDER_SESSION_ENV)).catch(() => undefined);
           const expRaw = await creds?.resolve(credentialRef(EXPIRES_ENV)).catch(() => undefined);
           const expires = expRaw ? Number(expRaw.value) : NaN;
+          // 用量：order_session 有效时实时取，失败标记过期（不阻断状态查询）
+          let usage = null;
+          let usageExpired = false;
+          if (orderInfo?.configured) {
+            const osRes = await creds?.resolve(credentialRef(ORDER_SESSION_ENV)).catch(() => undefined);
+            if (osRes) {
+              try {
+                usage = await fetchUsageSummary(osRes.value);
+              } catch {
+                usageExpired = true; // 会话失效，重新扫码即可
+              }
+            }
+          }
           const candidates = visionModelCandidates(ctx);
           const cfg = await readPluginConfig();
           return {
             ok: true,
             value: {
               configured: !!(apiInfo?.configured),
-              hasRefresh: !!(refreshInfo?.configured),
-              expiresAt: Number.isFinite(expires) && expires > 0 ? expires : null,
-              expired: Number.isFinite(expires) && expires > 0 ? Date.now() > expires : null,
-              // 视觉回退模型：候选（按优先级升序）+ 当前选择（null = 自动）
+              hasSession: !!(sessInfo?.configured),
+              usageLinked: !!(orderInfo?.configured),
+              usage,
+              usageExpired,
+              // 管理会话过期只影响「重新发现模型」，API key 本身长期有效
+              sessionExpiresAt: Number.isFinite(expires) && expires > 0 ? expires : null,
+              sessionExpired: Number.isFinite(expires) && expires > 0 ? Date.now() > expires : null,
+              keyName: DSH_KEY_NAME,
+              baseURL: GW_BASE,
               visionModels: candidates,
               visionModel: candidates.some((c) => c.id === cfg.visionModel) ? cfg.visionModel : null,
             },
@@ -322,20 +429,24 @@ function registerRpc(ctx) {
           return { ok: true, value: { visionModel: hit.id } };
         }
 
-        // ---- 刷新令牌 ----
+        // ---- 刷新：order_session 有效则重新桥接 + 重新发现模型 ----
         case 'refresh': {
-          const ref = await ctx.credentials?.resolve(credentialRef(REFRESH_ENV));
-          if (!ref) return { ok: false, error: { code: 'bad-request', message: '没有可用的刷新令牌', details: {} } };
-          const token = await refreshToken(ref.value);
-          await ctx.credentials.set(credentialRef(API_KEY_ENV), token.access);
-          await ctx.credentials.set(credentialRef(REFRESH_ENV), token.refresh);
-          await ctx.credentials.set(credentialRef(EXPIRES_ENV), String(token.expires));
-          return { ok: true, value: { expiresAt: token.expires } };
+          const osRes = await ctx.credentials?.resolve(credentialRef(ORDER_SESSION_ENV));
+          if (!osRes) return { ok: false, error: { code: 'bad-request', message: '没有可用的扫码会话，请重新扫码认证（API key 本身不受影响）', details: {} } };
+          let usage = null;
+          try { usage = await fetchUsageSummary(osRes.value); } catch { /* 会话失效不阻断 */ }
+          const { session, expires } = await bridgeManagementSession(osRes.value);
+          const models = await fetchKomectModels(session);
+          const apiKey = await ensureDshApiKey(session);
+          await writeConfigAndCreds(ctx, { apiKey, session, expires }, models);
+          return { ok: true, value: { models: models.length, usage } };
         }
 
         // ---- 注销（清除凭据，保留 provider 配置） ----
         case 'logout': {
           await ctx.credentials?.unset(credentialRef(API_KEY_ENV)).catch(() => {});
+          await ctx.credentials?.unset(credentialRef(SESSION_ENV)).catch(() => {});
+          await ctx.credentials?.unset(credentialRef(ORDER_SESSION_ENV)).catch(() => {});
           await ctx.credentials?.unset(credentialRef(REFRESH_ENV)).catch(() => {});
           await ctx.credentials?.unset(credentialRef(EXPIRES_ENV)).catch(() => {});
           return { ok: true, value: {} };
@@ -347,23 +458,24 @@ function registerRpc(ctx) {
     } catch (e) {
       return errorResult(e);
     }
-  }, { authority: 'loopback' });
+  });
 }
 
-async function writeConfigAndCreds(ctx, token, models) {
+async function writeConfigAndCreds(ctx, { apiKey, session, expires }, models) {
   // 1) 凭据（OS keyring / 凭据服务，apiKeyEnv 引用）
-  await ctx.credentials.set(credentialRef(API_KEY_ENV), token.access);
-  await ctx.credentials.set(credentialRef(REFRESH_ENV), token.refresh);
-  await ctx.credentials.set(credentialRef(EXPIRES_ENV), String(token.expires));
+  //    API key（lx_sk_）长期有效；session 为管理会话（模型发现用），过期仅需重新扫码
+  if (apiKey) await ctx.credentials.set(credentialRef(API_KEY_ENV), apiKey);
+  if (session) await ctx.credentials.set(credentialRef(SESSION_ENV), session);
+  if (expires) await ctx.credentials.set(credentialRef(EXPIRES_ENV), String(expires));
 
   // 2) llm-pi-ai provider 配置（merge 进现有 providers，保留其他路由）
   const section = {
     providers: {
       cmtoken: {
-        displayName: 'cmtoken',
+        displayName: 'komect 算力豆',
         apiKeyEnv: API_KEY_ENV,
         api: 'openai-completions',
-        baseURL: token.resourceUrl || DEFAULT_API_BASE,
+        baseURL: GW_BASE,
         models: models.map((m) => ({
           id: m.id,
           name: m.name,
@@ -383,55 +495,6 @@ async function writeConfigAndCreds(ctx, token, models) {
   }
 }
 
-// ---------------- 自动刷新令牌 ----------------
-// 定时器只负责「保底」：每个短周期检查一次；同时 status 查询也会触发按需自动刷新，
-// 因此只要 token 过期且 refresh token 仍有效，就会在过期后迅速被刷新，而不是等 2 小时。
-const AUTO_REFRESH_INTERVAL_MS = 60_000; // 每 1 分钟检查一次（轻量，剩余充足时直接返回）
-const AUTO_REFRESH_THRESHOLD_MS = 60 * 60_000; // 剩余 <1 小时即提前刷新（token 生命周期 ~5 小时，从容轮换）
-const REFRESH_COOLDOWN_MS = 60_000; // 刷新失败后冷却 1 分钟再试
-let lastRefreshAttempt = 0;
-
-/** 检查凭据：若 access 快过期且有 refresh，则自动刷新并更新凭据。 */
-async function autoRefresh(ctx) {
-  const creds = ctx.credentials;
-  if (!creds) return;
-  const refRes = await creds.resolve(credentialRef(REFRESH_ENV)).catch(() => undefined);
-  if (!refRes) return; // 没有 refresh token（未认证或已注销）
-
-  // 失败冷却：上次刷新失败后 REFRESH_COOLDOWN_MS 内不重试，避免无限循环
-  const now = Date.now();
-  if (now - lastRefreshAttempt < REFRESH_COOLDOWN_MS) return;
-
-  const expRes = await creds.resolve(credentialRef(EXPIRES_ENV)).catch(() => undefined);
-  const expires = expRes ? Number(expRes.value) : NaN;
-  if (!Number.isFinite(expires) || expires <= 0) return;
-  const remaining = expires - now;
-  // 剩余还多 → 不用刷；过期超过 7 天 → refresh 大概率已失效，放弃自动刷（需重新认证）
-  if (remaining > AUTO_REFRESH_THRESHOLD_MS) return;
-  if (remaining < -7 * 24 * 3600_000) return;
-
-  try {
-    const token = await refreshToken(refRes.value);
-    await creds.set(credentialRef(API_KEY_ENV), token.access);
-    await creds.set(credentialRef(REFRESH_ENV), token.refresh);
-    await creds.set(credentialRef(EXPIRES_ENV), String(token.expires));
-    lastRefreshAttempt = 0;
-    ctx.logger?.info?.('[cmtoken-oauth] 令牌已自动刷新，新过期时间: ' + new Date(token.expires).toISOString());
-  } catch (e) {
-    lastRefreshAttempt = Date.now();
-    ctx.logger?.warn?.('[cmtoken-oauth] 自动刷新失败（冷却 ' + REFRESH_COOLDOWN_MS / 60000 + ' 分钟）: ' + String(e?.message || e));
-  }
-}
-
-/** 启动自动刷新定时器；返回清理函数。 */
-function startAutoRefresh(ctx) {
-  const timer = setInterval(() => {
-    void autoRefresh(ctx).catch((e) => ctx.logger?.warn?.('[cmtoken-oauth] 自动刷新异常: ' + String(e?.message || e)));
-  }, AUTO_REFRESH_INTERVAL_MS);
-  timer.unref?.();
-  return () => clearInterval(timer);
-}
-
 // ---------------- 视觉回退：cmtoken_read_image 工具 ----------------
 // DSH 的图片准入以模型声明的 input 模态为准：文本模型收图直接报 UNSUPPORTED_CONTENT，
 // rc8 没有原生的"改投视觉模型"路由。本工具补上这条通路：任何在用模型把图片路径交给
@@ -593,7 +656,7 @@ async function describeImage({ baseURL, apiKey, model, dataUri, focus, signal })
   }
   if (!res.ok) {
     const text = (await res.text().catch(() => '')).slice(0, 300);
-    if (res.status === 401) throw new Error('cmtoken 访问令牌无效，请在设置 → cmtoken 认证里重新认证');
+    if (res.status === 401) throw new Error('komect API key 无效，请在设置 → cmtoken 认证里重新认证');
     if (res.status === 403 && /订阅套餐|订阅已过期|余额不足/.test(text)) throw new Error('订阅错误：' + text);
     throw new Error(`视觉模型识图失败 ${res.status}: ${text}`);
   }
@@ -609,7 +672,7 @@ function registerVisionTool(ctx) {
   const tool = {
     name: VISION_TOOL_NAME,
     description:
-      '通过 cmtoken 视觉模型读取图片，仅作为纯文本模型的视觉补足：当前模型原生支持识图（input 声明含 image 或可用 read_image）时不要调用本工具，直接看图即可。当对话中出现当前模型无法查看的图片时使用，典型形态是 [Image: <本地路径>] 行（粘贴/拖入的图片由插件自动落盘）或裸的本地绝对路径、http(s) URL：截图、照片、图表、扫描件等。返回结构化取证结果（summary、ocr_full_text、layout、semantics、uncertainty），请引用证据而不是猜测。需要已完成 cmtoken 一键认证。',
+      '通过 cmtoken 视觉模型读取图片。当对话中出现当前模型无法查看的图片时使用，典型形态是 [Image: <本地路径>] 行（粘贴/拖入的图片由插件自动落盘）或裸的本地绝对路径、http(s) URL：截图、照片、图表、扫描件等。返回结构化取证结果（summary、ocr_full_text、layout、semantics、uncertainty），请引用证据而不是猜测。需要已完成 cmtoken 一键认证。',
     parameters: {
       type: 'object',
       properties: {
@@ -631,10 +694,8 @@ function registerVisionTool(ctx) {
       const model = await resolveVisionModel(ctx);
       if (!model) throw new Error('cmtoken 未配置视觉模型：请先在 DSH 设置 → cmtoken 认证完成一键认证');
 
-      // 识图前先按需刷新令牌（复用自动续期逻辑），避免用过期 access 调用
-      await autoRefresh(ctx).catch(() => {});
       const key = await ctx.credentials?.resolve(credentialRef(API_KEY_ENV));
-      if (!key) throw new Error('cmtoken 访问令牌不可用：请先在 DSH 设置 → cmtoken 认证完成一键认证');
+      if (!key) throw new Error('komect API key 不可用：请先在 DSH 设置 → cmtoken 认证完成一键认证');
 
       const bytes = await loadImageBytes(source, exec?.signal);
       if (bytes.length === 0) throw new Error('图片内容为空');
@@ -646,7 +707,7 @@ function registerVisionTool(ctx) {
 
       const signals = [AbortSignal.timeout(VISION_TOOL_TIMEOUT_MS)];
       if (exec?.signal) signals.push(exec.signal);
-      const baseURL = ctx.settings?.get?.(settingsNamespace('llm-pi-ai'))?.providers?.cmtoken?.baseURL || DEFAULT_API_BASE;
+      const baseURL = ctx.settings?.get?.(settingsNamespace('llm-pi-ai'))?.providers?.cmtoken?.baseURL || GW_BASE;
       const evidence = await describeImage({
         baseURL,
         apiKey: key.value,
@@ -734,10 +795,9 @@ async function evidenceForBlock(ctx, block, signal, cache) {
     }
     const model = await resolveVisionModel(ctx);
     if (!model) throw new Error('cmtoken 未配置视觉模型，请先完成一键认证');
-    await autoRefresh(ctx).catch(() => {});
     const keyRes = await ctx.credentials?.resolve(credentialRef(API_KEY_ENV));
-    if (!keyRes) throw new Error('cmtoken 访问令牌不可用，请重新认证');
-    const baseURL = ctx.settings?.get?.(settingsNamespace('llm-pi-ai'))?.providers?.cmtoken?.baseURL || DEFAULT_API_BASE;
+    if (!keyRes) throw new Error('komect API key 不可用，请重新认证');
+    const baseURL = ctx.settings?.get?.(settingsNamespace('llm-pi-ai'))?.providers?.cmtoken?.baseURL || GW_BASE;
     const signals = [AbortSignal.timeout(VISION_TOOL_TIMEOUT_MS)];
     if (signal) signals.push(signal);
     const evidence = await describeImage({
@@ -825,16 +885,13 @@ function modelLabelToName(label) {
   return s.replace(/\s*\(视觉回退\)\s*$/i, '').trim();
 }
 
-/** 在已认证模型列表里查找（id 或显示名）。只做「相等」匹配（忽略大小写与分隔符），
- * 绝不做子串包含——否则其他 provider 的同名系模型（如 zai-coding-cn 的
- * glm-5.3-flash 包含 cmtoken 组 "glm-5" 的字样）会被误判为 cmtoken 模型而遭到
- * 拖图接管，违背「本插件只服务 cmtoken 提供方」的设计边界；找不到返回 undefined。 */
+/** 在已认证模型列表里查找（id 或显示名，忽略大小写；兜底子串匹配）；找不到返回 undefined。 */
 function findConfiguredModel(ctx, name) {
   if (!name) return undefined;
   const models = ctx.settings?.get?.(settingsNamespace('llm-pi-ai'))?.providers?.cmtoken?.models ?? [];
-  const norm = (s) => String(s ?? '').toLowerCase().replace(/[-_\s.]+/g, '');
-  const target = norm(name);
-  return models.find((m) => norm(m.id) === target || norm(m.name) === target);
+  const lower = String(name).toLowerCase();
+  return models.find((m) => String(m.id).toLowerCase() === lower || String(m.name ?? '').toLowerCase() === lower)
+    ?? models.find((m) => lower.includes(String(m.id).toLowerCase()) || lower.includes(String(m.name ?? '').toLowerCase()));
 }
 
 // ---------------- 视觉回退模型选择（~/.dsh/cmtoken-oauth.json） ----------------
@@ -862,12 +919,13 @@ async function writePluginConfig(patch) {
   return cfg;
 }
 
-/** 已认证模型里的视觉模型，按回退优先级升序。 */
+/** 已认证模型里的视觉模型：以发现接口的 input 模态声明为准（supports_images），
+ *  同能力时按回退优先级（visionRank）排序；无声明时回退名称启发（兼容旧配置）。 */
 function visionModelCandidates(ctx) {
   const models = ctx.settings?.get?.(settingsNamespace('llm-pi-ai'))?.providers?.cmtoken?.models ?? [];
   return models
-    .map((m) => ({ id: m.id, name: m.name ?? m.id, rank: visionRank(m.id) }))
-    .filter((m) => m.rank > 0)
+    .filter((m) => (Array.isArray(m.input) ? m.input.includes('image') : supportsVision(m.id)))
+    .map((m) => ({ id: m.id, name: m.name ?? m.id, rank: visionRank(m.id) || 99 }))
     .sort((a, b) => a.rank - b.rank);
 }
 
@@ -1080,25 +1138,26 @@ function registerVisionAdapter(ctx) {
 
 export function apply(ctx, cfg = {}) {
   let removeRpc = () => {};
-  let stopTimer = () => {};
   let disposeVisionAdapter = () => {};
+  // 在声明了 webServer 的子上下文里注册 RPC 前缀路由（DSH 0.1.5+）。
+  const rpcScope = ctx.inject(['webServer'], (scope) => {
+    removeRpc = registerRpc(scope);
+  });
+  void rpcScope;
   ctx.effect(() => {
-    removeRpc = registerRpc(ctx);
-    stopTimer = startAutoRefresh(ctx);
     registerVisionTool(ctx);
     registerPasteRoute(ctx);
     registerPasteInjection(ctx);
     // 视觉回退包装分组（cmtoken-vision）默认关闭：粘贴识图已覆盖纯文本模型，
     // 需要真实图片气泡的会话可在 profile 的插件 config 里设 visionRoute: true。
     if (cfg.visionRoute === true) disposeVisionAdapter = registerVisionAdapter(ctx);
-    // 启动时立即补刷一次：若停机期间 access 过期、但 refresh 仍有效，马上恢复，
-    // 不必等 60 秒定时器；失败只记日志，不影响启动。
-    void autoRefresh(ctx).catch((e) => ctx.logger?.warn?.('[cmtoken-oauth] 启动补刷失败: ' + String(e?.message || e)));
     return () => {
       removeRpc();
-      stopTimer();
       disposeVisionAdapter();
     };
   }, 'cmtoken-oauth: host service');
-  ctx.logger?.info?.('[cmtoken-oauth] host 服务已启动（自动刷新已开启：启动即补刷 + 每 1 分钟检查 + status 查询按需触发，剩余 <1 小时或已过期即刷新）');
+  ctx.logger?.info?.('[cmtoken-oauth] host 服务已启动（komect API-key 通道：密钥长期有效，无需定时刷新）');
 }
+
+
+

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-cmtoken-oauth",
-  "version": "1.5.2",
-  "description": "DeepSeek Harness 插件：在 DSH 设置页一键完成广东移动 MaaS（cmtoken）的 OAuth 2.0 Device Grant + PKCE 认证，自动发现模型并写入 llm-pi-ai provider 配置（视觉模型自动声明图片输入模态）；粘贴识图让纯文本模型直接收图（Qwen3.8 / Qwen3.x / Kimi K2.x / MiniMax M3 自动识读），另有 cmtoken_read_image 工具与可选的 cmtoken-vision 包装路由；凭据安全保存并自动续期。零第三方运行时依赖。",
+  "version": "1.6.0",
+  "description": "DeepSeek Harness 插件：在 DSH 设置页一键完成中国移动算力豆平台（komect）扫码认证——一次扫码自动桥接密钥管理会话、创建专属 DSH API key（lx_sk_，长期有效）、发现模型（上下文/输出/图片支持由平台动态提供）并写入 llm-pi-ai provider 配置，同时展示算力豆用量余额；粘贴识图让纯文本模型直接收图，另有 cmtoken_read_image 工具与可选的 cmtoken-vision 包装路由。零第三方运行时依赖。",
   "type": "module",
   "main": "./lib/index.js",
   "types": "./lib/types/index.d.ts",