dsh-llm-codebuddy-power 1.0.0

package/lib/cli-login.js

@@ -0,0 +1,2099 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { randomBytes, randomUUID } from "node:crypto";
+import { promises } from "node:fs";
+import { dshHomePath } from "@deepseek-ai/dsh-home-paths";
+import { dirname } from "node:path";
+//#region lib/types/constants.js
+/** CodeBuddy 服务根地址;认证握手与 `/v3/config` 都在此处。 */
+const CODEBUDDY_ENDPOINT = "https://copilot.tencent.com";
+/** 在对话与模型目录请求中上报的 IDE 版本,与官方 CodeBuddy CN 4.11.3 客户端一致。 */
+const CODEBUDDY_IDE_VERSION = "4.11.3";
+/** 官方 IDE 的产品段名称,用于拼接后的 `User-Agent`。 */
+const CODEBUDDY_PRODUCT_NAME = "CodeBuddy";
+/**
+* 官方 IDE 主进程 auth/billing 客户端发送的 User-Agent。
+*
+* 登录与计量请求在 `main.js` 中使用裸 axios 实例(没有拦截器链),因此携带
+* 的是 axios 默认 UA,而不是 CustomFetch 平面使用的 IDE 身份 UA。
+* 实测抓包:`/v2/plugin/auth/*` 与 `/v2/billing/meter/*` 都发送 `axios/1.15.0`。
+*/
+const CODEBUDDY_AXIOS_USER_AGENT = "axios/1.15.0";
+/** 浏览器登录流程等待用户完成的时长,单位 ms。 */
+const LOGIN_TIMEOUT_MS = 600 * 1e3;
+/** 等待浏览器登录完成时的轮询间隔,单位 ms。 */
+const LOGIN_POLL_INTERVAL_MS = 1e3;
+//#endregion
+//#region lib/types/codebuddy.js
+/**
+* CodeBuddy 控制面客户端:浏览器 OAuth 握手、令牌刷新,
+* 以及非 OpenAI 模型目录。
+*
+* 这里的每次调用都以 `{code, msg, data}` 信封而非仅 HTTP 状态码
+* 表达结果,因此返回 200 却带有非零 `code` 即为失败,并
+* 按失败上报。本模块只负责传输:不持有状态,也不做
+* 策略决策,因此登录流程、适配器与 CLI 得以共用
+* 同一份实现。
+*
+* @module dsh-llm-codebuddy-power/codebuddy
+*/
+/**
+* 官方 CodeBuddy CN 4.11.3 客户端在其 CustomFetch 面(chat、catalog)上
+* 发送的组合 IDE `User-Agent`。实测抓包为 `CodeBuddyIDE/4.11.3 CodeBuddy/4.11.3`。
+* @returns IDE user-agent 字符串。
+*/
+function ideUserAgent() {
+	return `CodeBuddyIDE/${CODEBUDDY_IDE_VERSION} ${CODEBUDDY_PRODUCT_NAME}/${CODEBUDDY_IDE_VERSION}`;
+}
+/**
+* 官方 IDE 主进程的认证/计费客户端发送的 `User-Agent`。
+*
+* `main.js` 在一个裸 axios 实例上发起登录与计量请求(无拦截器
+* 链),因此它们携带 axios 默认 UA —— 实测在 `/v2/plugin/auth/*` 与
+* `/v2/billing/meter/*` 上抓到的值为 `axios/1.15.0`。
+* @returns axios user-agent 字符串。
+*/
+function axiosUserAgent() {
+	return CODEBUDDY_AXIOS_USER_AGENT;
+}
+/**
+* 登录握手与计量共用的 axios 面请求头:
+* axios 默认的 `Accept` 与 `User-Agent`,外加每次调用各自的头。
+*
+* 在官方 IDE 中这两个面运行在同一个裸 axios 客户端上,
+* 因此尽管各自的额外头不同,帧结构仍相同。
+* @param extra - 请求专属头(`X-No-*`、`Authorization` 等)。
+* @returns 请求头。
+*/
+function axiosRequestHeaders(extra) {
+	return {
+		"Accept": "application/json, text/plain, */*",
+		"User-Agent": axiosUserAgent(),
+		...extra
+	};
+}
+function delay(ms, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) {
+			reject(/* @__PURE__ */ new Error("aborted"));
+			return;
+		}
+		const timer = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		const onAbort = () => {
+			clearTimeout(timer);
+			reject(/* @__PURE__ */ new Error("aborted"));
+		};
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+/**
+* 发起一次浏览器登录握手。
+* @param signal - 可选取消。
+* @returns 握手状态,以及用户必须打开的 URL。
+* @throws Error 服务拒绝或返回不可用的响应体时。
+*/
+async function requestAuthState(signal) {
+	const response = await fetch(`${CODEBUDDY_ENDPOINT}/v2/plugin/auth/state?platform=ide`, {
+		method: "POST",
+		headers: axiosRequestHeaders({
+			"Content-Type": "application/x-www-form-urlencoded",
+			"X-No-Authorization": "true",
+			"X-No-User-Id": "true",
+			"X-No-Enterprise-Id": "true"
+		}),
+		...signal === void 0 ? {} : { signal }
+	});
+	if (!response.ok) throw new Error(`CodeBuddy auth state request failed (HTTP ${response.status})`);
+	const body = await response.json();
+	if (body.code !== 0 || body.data === void 0) throw new Error(`CodeBuddy auth state request failed: ${body.code} - ${body.msg}`);
+	return body.data;
+}
+/**
+* 轮询,直到用户在浏览器中完成登录。
+*
+* 服务用 code {@link AUTH_PENDING_CODE} 表示“尚未完成”,
+* 它是唯一让循环继续的 code;其他任何 code 都是已决结果,循环
+* 就此结束。传输错误同样结束循环,因为状态可能已被消耗的
+* 握手不得静默重试。
+* @param state - 来自 {@link requestAuthState} 的握手 id。
+* @param signal - 可选取消。
+* @returns 签发的令牌;登录失败或超时时为 `undefined`。
+*/
+async function pollAuthToken(state, signal) {
+	const deadline = Date.now() + LOGIN_TIMEOUT_MS;
+	while (Date.now() < deadline) {
+		await delay(LOGIN_POLL_INTERVAL_MS, signal);
+		let response;
+		try {
+			response = await fetch(`${CODEBUDDY_ENDPOINT}/v2/plugin/auth/token?state=${encodeURIComponent(state)}`, {
+				method: "GET",
+				headers: axiosRequestHeaders({ "X-No-Authorization": "true" }),
+				...signal === void 0 ? {} : { signal }
+			});
+		} catch {
+			return;
+		}
+		if (!response.ok) continue;
+		const body = await response.json();
+		if (body.code === 11217) continue;
+		if (body.code !== 0) return void 0;
+		return body.data;
+	}
+}
+/**
+* 读取已登录账号,其 uid 与企业 id 会成为之后每个请求的必需
+* 请求头。
+* @param state - 令牌所对应的握手 id。
+* @param accessToken - 刚签发的 access token。
+* @param domain - 令牌所对应的租户 domain。
+* @returns 账号信息。
+* @throws Error 服务拒绝或返回不可用的响应体时。
+*/
+async function getLoginAccount(state, accessToken, domain) {
+	const response = await fetch(`${CODEBUDDY_ENDPOINT}/v2/plugin/login/account?state=${encodeURIComponent(state)}`, {
+		method: "GET",
+		headers: axiosRequestHeaders({
+			"Authorization": `Bearer ${accessToken}`,
+			"X-No-User-Id": "true",
+			"X-No-Enterprise-Id": "true",
+			"X-Domain": domain
+		})
+	});
+	if (!response.ok) throw new Error(`CodeBuddy login account request failed (HTTP ${response.status})`);
+	const body = await response.json();
+	if (body.code !== 0 || body.data === void 0) throw new Error(`CodeBuddy login account request failed: ${body.code} - ${body.msg}`);
+	return normalizeAccount(body.data);
+}
+/**
+* 归一化账号,使空字符串字段等同于缺失。
+*
+* 对于租户未披露的字段,CodeBuddy 的账号响应会返回空字符串
+* (而非省略)→ 例如企业账号会带有 `uin: ""`。整条下游链路(storage、
+* auth 状态、设置 UI)只把 `undefined` 当作“不存在”,因此空字符
+* 串会渲染出一行空内容。在此统一裁剪一次即可覆盖所有消费者,
+* 无需各自重复判断。
+* @param account - 来自 wire 的原始账号。
+* @returns 删除可选字符串字段为空值后的账号。
+*/
+function normalizeAccount(account) {
+	const pick = (value) => value === void 0 || value.length === 0 ? void 0 : value;
+	return {
+		uid: account.uid,
+		nickname: account.nickname,
+		...pick(account.uin) === void 0 ? {} : { uin: account.uin },
+		...pick(account.enterpriseId) === void 0 ? {} : { enterpriseId: account.enterpriseId },
+		...pick(account.enterpriseName) === void 0 ? {} : { enterpriseName: account.enterpriseName },
+		...pick(account.enterpriseUserName) === void 0 ? {} : { enterpriseUserName: account.enterpriseUserName },
+		...pick(account.departmentFullName) === void 0 ? {} : { departmentFullName: account.departmentFullName }
+	};
+}
+/**
+* 用 refresh token 换取新的 access token。
+* @param identity - 当前身份,包含正被替换的 access token。
+* @param refreshToken - 要使用的 refresh token。
+* @returns 新令牌;刷新被拒绝时为 `undefined`。
+*/
+async function refreshAccessToken(identity, refreshToken) {
+	const headers = axiosRequestHeaders({
+		"Authorization": `Bearer ${identity.accessToken}`,
+		"X-Domain": identity.domain,
+		"X-User-Id": identity.uid,
+		"X-Refresh-Token": refreshToken,
+		"X-Auth-Refresh-Source": "plugin"
+	});
+	if (identity.enterpriseId !== void 0) headers["X-Enterprise-Id"] = identity.enterpriseId;
+	let response;
+	try {
+		response = await fetch(`${CODEBUDDY_ENDPOINT}/v2/plugin/auth/token/refresh`, {
+			method: "POST",
+			headers
+		});
+	} catch {
+		return;
+	}
+	if (!response.ok) return void 0;
+	const body = await response.json();
+	if (body.code !== 0 || body.data === void 0) return void 0;
+	return body.data;
+}
+/**
+* 一个新的无连字符 uuid;CodeBuddy 各面用作请求 id 与
+* 会话 id 的紧凑形式。
+* @returns 32 个十六进制字符的 id。
+*/
+function compactUuid() {
+	return randomUUID().replace(/-/g, "");
+}
+/**
+* 每个 CustomFetch 面请求(chat、catalog)都携带的共享客户端身份
+* 头,与官方 IDE 4.11.3 的抓包一致:
+* IDE user-agent、SaaS 产品标记、XMLHttpRequest 来源,以及
+* 每个请求一个新生成的紧凑 `X-Request-ID`。
+*
+* CodeBuddy 的安全策略会拒绝任何它不认作自家客户端的 User-Agent
+* (实测:带 harness 标识的 User-Agent 会被以 HTTP 400 / code 11128
+* 拒绝)。提供方自身的产品身份是唯一被接受的载体,因此本函数是
+* chat 与 catalog 两条传输上该身份的唯一来源。
+* @returns 共享身份头,其中 request id 为新生成。
+*/
+function clientIdentityHeaders() {
+	return {
+		"User-Agent": ideUserAgent(),
+		"X-Product": "SaaS",
+		"X-Requested-With": "XMLHttpRequest",
+		"X-Request-ID": compactUuid()
+	};
+}
+/**
+* 读取 CodeBuddy 模型目录。
+*
+* 这是该服务中非 OpenAI 兼容的那一半,也是本插件无法被通用
+* OpenAI 兼容路由取代的原因:该响应会披露每个模型的能力标记与
+* 尺寸,而 `GET /models` 列表不会。
+* @param identityHeaders - 已认证的身份头,由会话构建一次
+*   (`requestIdentity()`),使 chat 与目录共用同一套。
+* @param signal - 可选取消。
+* @returns 目录。
+* @throws Error 服务拒绝或返回不可用的响应体时。
+*/
+async function getConfig(identityHeaders, signal) {
+	const headers = {
+		...identityHeaders,
+		...clientIdentityHeaders(),
+		"Accept": "application/json"
+	};
+	const response = await fetch(`${CODEBUDDY_ENDPOINT}/v3/config`, {
+		method: "GET",
+		headers,
+		...signal === void 0 ? {} : { signal }
+	});
+	if (!response.ok) throw new Error(`CodeBuddy config request failed (HTTP ${response.status})`);
+	const body = await response.json();
+	if (body.code !== 0 || body.data === void 0) throw new Error(`CodeBuddy config request failed: ${body.code} - ${body.msg}`);
+	return body.data;
+}
+//#endregion
+//#region lib/types/atomic-file.js
+/**
+* 插件自有 JSON 文件的写入底座:原子替换 + 按路径串行化。
+*
+* 三个存储(账号、会话选择、每轮积分)都是读-改-写的文件。原子替换让
+* 残缺内容永远不会留在磁盘上被当成一份读不出的记录;按路径排队让并发写入
+* 串行执行 —— 后一次读得到前一次的结果,而不是各自基于同一份旧内容覆盖对方。
+* 集中在这里,使三个存储不会各自实现一遍,也不会各自漏掉队列。
+*
+* @module dsh-llm-codebuddy-power/atomic-file
+*/
+/** 每个文件一条写队列,保存当前队尾。 */
+const queues = /* @__PURE__ */ new Map();
+/**
+* 排队一次针对某文件的写:前一次写完成后才开始执行。
+*
+* 队尾保存的是已消化失败的 promise —— 它的拒绝无人 await,留着会变成未处理的
+* rejection;调用方从返回的 promise 收到同一个失败。
+* @param path - 被写的文件。
+* @param write - 实际写入;在同一路径的写之间串行执行。
+* @returns 本次写入的结果;失败时以该失败拒绝。
+*/
+function queueWrite(path, write) {
+	const next = (queues.get(path) ?? Promise.resolve()).then(write);
+	const settled = next.then(() => void 0, () => void 0);
+	queues.set(path, settled);
+	settled.then(() => {
+		if (queues.get(path) === settled) queues.delete(path);
+	});
+	return next;
+}
+/**
+* 以原子替换写入一个文件,并在支持的文件系统上收紧为仅属主可读。
+*
+* 先写同目录下的临时文件再改名:改名在同一文件系统内是原子的,因此读到的
+* 要么是旧内容要么是新内容,不会是写了一半的内容。
+*
+* 内容是调用方给的字符串而不是由本函数序列化:`JSON.stringify` 的默认输出是一个
+* 字节的重复都没有的紧凑格式,可读性全靠调用方自己插入的换行 —— 需要控制"哪里换行"
+* 的存储因此各自决定格式(见 `session-store.ts` 的逐轮一行)。
+* @param path - 目标文件。
+* @param content - 要写入的完整内容。
+*/
+async function writeFileAtomic(path, content) {
+	await promises.mkdir(dirname(path), { recursive: true });
+	const temp = `${path}.${randomBytes(6).toString("hex")}.tmp`;
+	try {
+		await promises.writeFile(temp, content, {
+			encoding: "utf-8",
+			mode: 384
+		});
+		await promises.rename(temp, path);
+	} catch (error) {
+		await promises.unlink(temp).catch(() => {});
+		throw error;
+	}
+	await promises.chmod(path, 384).catch(() => {});
+}
+/**
+* 以原子替换写入一个 JSON 文件,缩进两格。
+*
+* 缩进是给需要肉眼排查的凭据文件用的(`storage.ts` 的 refresh token 与过期时间),
+* 不是通用默认值:批量记录类文件改用 {@link writeFileAtomic} 自己排版。
+* @param path - 目标文件。
+* @param value - 要序列化的值。
+*/
+async function writeJsonAtomic(path, value) {
+	await writeFileAtomic(path, `${JSON.stringify(value, null, 2)}\n`);
+}
+//#endregion
+//#region lib/types/storage.js
+/**
+* 持久化 OAuth 账号存储,磁盘上仅属主可读。
+*
+* 存储位于 harness home 的规范数据目录
+* (`$DSH_HOME/data/plugins/llm-codebuddy-power/`,通过 harness 所用的同一个
+* `@deepseek-ai/dsh-home-paths` 解析),而不放在插件包内,因此重装不会让
+* 用户退出登录。写入经 [atomic-file.ts](./atomic-file.ts) 做原子替换并按路径串行化:
+* 多个账号的令牌刷新、设置页的增删与 CLI 的调用都在改同一份文件,不串行化时
+* 两个并发写入会各自基于自己读到的旧内容覆盖对方。残缺文件会让用户手里只有
+* 一份读不出的凭据,还无法与“从未登录过”区分开。
+*
+* @module dsh-llm-codebuddy-power/storage
+*/
+/** 空存储:读取不到任何可用内容时的结果。 */
+function emptyStorage() {
+	return { accounts: [] };
+}
+/**
+* 凭据文件的绝对路径。
+*
+* 通过 `@deepseek-ai/dsh-home-paths` 解析,以跟随 harness 自身的 home 优先级
+* (配置路径 > `$DSH_HOME` > `~/.dsh`),绝不会分叉到另行计算的 home。
+* `DSH_CODEBUDDY_AUTH_FILE` 保留作为测试与迁移用的显式逃生口。
+* @returns 绝对凭据路径,优先遵循环境变量覆盖。
+*/
+function getStoragePath() {
+	const override = process.env.DSH_CODEBUDDY_AUTH_FILE;
+	if (override !== void 0 && override.length > 0) return override;
+	return dshHomePath("data", "plugins", "llm-codebuddy-power", "codebuddy-auth.json");
+}
+/**
+* 路径是否仅其属主可读。
+*
+* 与 `@deepseek-ai/dsh-credentials-local` 在加载自己的凭据文档前所做的仅属主
+* 检查一致:只要 group 或 other 的读/写位被置上,即视为文件已暴露,检查
+* 失败。Windows 没有 POSIX 模式,因此在 Windows 上跳过该检查——防护强度
+* 取决于创建与替换 API 所表达的内容,与 dsh-credentials-local 相同。
+* @param path - 凭据文件路径。
+* @returns 文件不存在(尚无可保护内容)或以仅属主权限存在时返回 true;
+*   文件存在且已暴露时返回 false。
+*/
+async function isOwnerOnly(path) {
+	if (process.platform === "win32") return true;
+	let mode;
+	try {
+		mode = (await promises.stat(path)).mode;
+	} catch {
+		return true;
+	}
+	return (mode & 63) === 0;
+}
+/** 账号条目是否携带了成对的令牌、uid 与刷新令牌的到期时刻。 */
+function isAccountEntry(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const entry = value;
+	return typeof entry.auth?.accessToken === "string" && typeof entry.auth.refreshToken === "string" && typeof entry.auth.refreshExpiresAt === "number" && Number.isFinite(entry.auth.refreshExpiresAt) && typeof entry.account?.uid === "string";
+}
+/**
+* 丢弃取值为空字符串的账号字符串字段,把它们当作不存在。
+*
+* 在 `normalizeAccount` 之前写入的较旧凭据可能从 wire 带来 `uin: ""`
+* (以及其他取值为空的可选字符串);这里把它们裁掉,使下游每个消费方的
+* `=== undefined` 判断都成立,而无需各自再加空字符串防护。
+* @param account - 解析后的账号字段。
+* @returns 已移除取值为空的可选字段的账号。
+*/
+function trimEmptyAccountFields(account) {
+	const pick = (v) => v === void 0 || v.length === 0 ? void 0 : v;
+	return {
+		uid: account.uid,
+		nickname: account.nickname,
+		...pick(account.uin) === void 0 ? {} : { uin: account.uin },
+		...pick(account.enterpriseId) === void 0 ? {} : { enterpriseId: account.enterpriseId },
+		...pick(account.enterpriseName) === void 0 ? {} : { enterpriseName: account.enterpriseName },
+		...pick(account.enterpriseUserName) === void 0 ? {} : { enterpriseUserName: account.enterpriseUserName },
+		...pick(account.departmentFullName) === void 0 ? {} : { departmentFullName: account.departmentFullName }
+	};
+}
+/**
+* 把解析出的 JSON 归一化为账号集合。
+*
+* 同时接受当前形态与仅有一个账号的旧形态(顶层 `auth` + `account`):旧文件
+* 迁移成单元素列表,并让那个账号成为默认账号,于是升级不会改变用户下一次
+* 请求用的是谁。`defaultUid` 与 `lastUid` 指向已不存在的账号时丢弃——它们只是
+* 指针,留着会让“有没有默认账号”与实际情况相反。
+* @param parsed - 解析出的 JSON 值。
+* @returns 归一化后的账号集合。
+*/
+function normalizeStorage(parsed) {
+	if (typeof parsed !== "object" || parsed === null) return emptyStorage();
+	const record = parsed;
+	if (Array.isArray(record.accounts)) {
+		const accounts = record.accounts.filter(isAccountEntry).map((entry) => ({
+			auth: entry.auth,
+			account: trimEmptyAccountFields(entry.account)
+		}));
+		const pick = (value) => {
+			if (typeof value !== "string") return void 0;
+			return accounts.some((a) => a.account.uid === value) ? value : void 0;
+		};
+		const defaultUid = pick(record.defaultUid);
+		const lastUid = pick(record.lastUid);
+		return {
+			accounts,
+			...defaultUid === void 0 ? {} : { defaultUid },
+			...lastUid === void 0 ? {} : { lastUid }
+		};
+	}
+	if (!isAccountEntry(record)) return emptyStorage();
+	return {
+		accounts: [{
+			auth: record.auth,
+			account: trimEmptyAccountFields(record.account)
+		}],
+		defaultUid: record.account.uid
+	};
+}
+/**
+* 读取已存储的账号集合。
+*
+* 在读取任何字节之前先检查文件模式:主机上其他用户可读的凭据会被当作不存在
+* 而不是拿来使用,因此丢失仅属主模式的文件(手动 chmod 出错、从别处拷贝)
+* 绝不会被加载。当作不存在也能自愈——下次登录会用 `0o600` 重写该文件。
+* @returns 账号集合;没有可用内容时为空集合。文件缺失、文件损坏与权限不安全
+*   刻意给出相同答案:都表示“此处没有可安全用于认证的东西”,而登录流程是
+*   每一种情况的修复方式。
+*/
+async function loadStorage() {
+	const path = getStoragePath();
+	try {
+		if (!await isOwnerOnly(path)) return emptyStorage();
+		const raw = await promises.readFile(path, "utf-8");
+		return normalizeStorage(JSON.parse(raw));
+	} catch {
+		return emptyStorage();
+	}
+}
+/**
+* 读-改-写账号集合。
+*
+* 读发生在队列内部,因此排队中的后一次改动看得到前一次的结果,而不是各自
+* 基于同一份旧内容。文件此刻无法安全读取时按空集合起手,与 {@link loadStorage}
+* 对同一情况的判断一致。
+* @param change - 由当前集合算出新集合;不得就地修改传入值。
+*/
+async function updateStorage(change) {
+	const path = getStoragePath();
+	await queueWrite(path, async () => {
+		await writeJsonAtomic(path, change(await loadStorage()));
+	});
+}
+/**
+* 插入一个账号,或替换同 uid 账号的凭据。
+*
+* 同 uid 视为重新登录同一个账号:令牌被替换而不是追加成第二个条目,否则
+* 设置页会出现两个同名徽章,退出其中一个还会留下另一个。
+* @param entry - 刚登录得到的账号。
+*/
+async function upsertAccount(entry) {
+	await updateStorage((current) => {
+		const uid = entry.account.uid;
+		const accounts = current.accounts.some((a) => a.account.uid === uid) ? current.accounts.map((a) => a.account.uid === uid ? entry : a) : [...current.accounts, entry];
+		const defaultUid = current.defaultUid ?? (current.accounts.length === 0 ? uid : void 0);
+		return {
+			accounts,
+			...defaultUid === void 0 ? {} : { defaultUid },
+			...current.lastUid === void 0 ? {} : { lastUid: current.lastUid }
+		};
+	});
+}
+/**
+* 移除若干账号,并清掉指向它们的默认账号与“最后一次手动切换”的账号。
+* @param uids - 要移除的账号 uid。
+*/
+async function removeAccounts(uids) {
+	const removed = new Set(uids);
+	await updateStorage((current) => {
+		const accounts = current.accounts.filter((a) => !removed.has(a.account.uid));
+		const gone = (uid) => uid !== void 0 && removed.has(uid) ? void 0 : uid;
+		const defaultUid = gone(current.defaultUid);
+		const lastUid = gone(current.lastUid);
+		return {
+			accounts,
+			...defaultUid === void 0 ? {} : { defaultUid },
+			...lastUid === void 0 ? {} : { lastUid }
+		};
+	});
+}
+/**
+* 指定或取消默认账号。
+* @param uid - 默认账号的 uid;传 `undefined` 取消默认账号。
+*/
+async function setDefaultAccount(uid) {
+	await updateStorage((current) => {
+		const next = {
+			accounts: current.accounts,
+			...current.lastUid === void 0 ? {} : { lastUid: current.lastUid }
+		};
+		if (uid !== void 0 && current.accounts.some((a) => a.account.uid === uid)) next.defaultUid = uid;
+		return next;
+	});
+}
+/**
+* 记下最后一次被手动切换到的账号(没有默认账号时作为兜底)。
+* @param uid - 被切换到的账号 uid。
+*/
+async function setLastAccount(uid) {
+	await updateStorage((current) => ({
+		...current,
+		lastUid: uid
+	}));
+}
+/**
+* 凭据文件的不透明新鲜度令牌:文件每次被重写或删除时它都会变化,因此内存中
+* 的会话能察觉另一个进程(CLI)执行的登录与登出,而不必在什么都没变时
+* 每次调用都重新读取。
+* @returns 一个令牌;没有凭据文件时返回 `undefined`。
+*/
+async function storageFreshness() {
+	let stat;
+	try {
+		stat = await promises.stat(getStoragePath());
+	} catch {
+		return;
+	}
+	return `${stat.mtimeMs}:${stat.size}`;
+}
+//#endregion
+//#region lib/types/login.js
+/**
+* 浏览器 OAuth 登录流程,从发起到凭据落盘。
+*
+* 全程不索取 API key:握手生成一个 `state`,用户在普通浏览器中
+* 登录,然后依据该 state 从服务轮询取出令牌。用户需要做的
+* 只是在一个登录页面上点击完成。
+*
+* @module dsh-llm-codebuddy-power/login
+*/
+/**
+* 由刚签发的令牌与账号信息构建一个可持久化的账号条目。
+*
+* CLI 流程与 Web 认证服务共用,以免两者在存储结构上
+* 产生分歧:两者写入的都是这个对象。
+* @param token - 浏览器登录完成后签发的令牌。
+* @param account - 令牌所对应的已登录账号。
+* @returns 要持久化的账号条目。
+*/
+function buildAccount(token, account) {
+	return {
+		auth: {
+			accessToken: token.accessToken,
+			expiresAt: Date.now() + token.expiresIn * 1e3,
+			refreshToken: token.refreshToken,
+			refreshExpiresAt: Date.now() + token.refreshExpiresIn * 1e3,
+			domain: token.domain
+		},
+		account: {
+			uid: account.uid,
+			nickname: account.nickname,
+			...account.uin === void 0 ? {} : { uin: account.uin },
+			...account.enterpriseId === void 0 ? {} : { enterpriseId: account.enterpriseId },
+			...account.enterpriseName === void 0 ? {} : { enterpriseName: account.enterpriseName },
+			...account.enterpriseUserName === void 0 ? {} : { enterpriseUserName: account.enterpriseUserName },
+			...account.departmentFullName === void 0 ? {} : { departmentFullName: account.departmentFullName }
+		}
+	};
+}
+/**
+* 尽力在用户的默认浏览器中打开 URL。
+*
+* 失败被刻意设为静默:URL 已经打印出来,因此无头或受限
+* 环境仍有可用的前进路径,否则 spawn 错误会被
+* 读作登录失败。
+*/
+function openInBrowser(url) {
+	let command;
+	let args;
+	if (process.platform === "win32") {
+		command = "rundll32";
+		args = ["url.dll,FileProtocolHandler", url];
+	} else {
+		command = process.platform === "darwin" ? "open" : "xdg-open";
+		args = [url];
+	}
+	try {
+		const child = spawn(command, args, {
+			stdio: "ignore",
+			detached: true
+		});
+		child.on("error", () => {});
+		child.unref();
+	} catch {}
+}
+/**
+* 运行完整的浏览器登录流程。
+* @param hooks - 用户交互钩子。
+* @param signal - 可选取消。
+* @returns 已追加到账号列表的账号与已登录昵称。
+* @throws Error 握手失败、用户未及时完成,或
+*   账号无法读取时。
+*/
+async function login(hooks = {}, signal) {
+	const state = await requestAuthState(signal);
+	hooks.onUrl?.(state.authUrl);
+	if (hooks.openBrowser !== false) openInBrowser(state.authUrl);
+	const token = await pollAuthToken(state.state, signal);
+	if (token === void 0) throw new Error("CodeBuddy sign-in did not complete (it was refused, or it timed out).");
+	const account = await getLoginAccount(state.state, token.accessToken, token.domain);
+	const entry = buildAccount(token, account);
+	await upsertAccount(entry);
+	return {
+		account: entry,
+		nickname: account.nickname
+	};
+}
+//#endregion
+//#region lib/types/types.js
+/**
+* 本插件读取的 wire 结构,分属两套互不相关的协议。
+*
+* CodeBuddy 控制平面(`/v2/plugin/auth/*`、`/v3/config`)把每个回复包在
+* `{code, msg, requestId, data}` 中,且不兼容 OpenAI——这正是本插件存在、
+* 而不使用普通 OpenAI 兼容路由的原因。对话平面(`/v2/chat/completions`)
+* 兼容 OpenAI,其 chunk 结构即常见结构。
+*
+* @module dsh-llm-codebuddy-power/types
+*/
+/**
+* 目录是否披露了 harness 所需的容量。
+*
+* harness 要求它提供的每个模型都有正的 `contextWindow` 与输出上限,而
+* CodeBuddy 对非对话模型的条目(补全、改写/跳转、图片生成)两者都不给。
+* 为这些条目编造数字会把不可用的模型以猜测的尺寸放进选择器,因此调用方
+* 改为丢弃它们。放在这里、紧邻 wire 类型,使列表与解析路径不会对哪些条目
+* 可提供产生分歧。
+* @param model - 一个目录条目。
+* @returns 两个容量都存在且为正时返回 true。
+*/
+function hasDisclosedCapacity(model) {
+	return model.maxAllowedSize !== void 0 && model.maxAllowedSize > 0 && model.maxOutputTokens !== void 0 && model.maxOutputTokens > 0;
+}
+/**
+* 插件有意不提供的模型 id,即使目录把它们描述为完全支持对话。
+*
+* CodeBuddy 的目录会列出并非真实模型的默认/别名条目:它们的请求在用量记录
+* 中会落成另一个模型(`default` 别名解析为 `deepseek-v4-flash`),而选择器
+* 会把它显示为独立选项,因此提供它们会误导用户。被屏蔽的 id 只在列表中
+* 滤除;显式指名的 id 仍会走通(服务以 "The requested model is not
+* available" 拒绝),与选择器隐藏服务无法提供选项的做法一致。
+*/
+const BLOCKED_MODEL_IDS = new Set(["default", "codewise-default-model-v2"]);
+/**
+* 某个目录条目 id 是否在屏蔽列表中。
+* @param id - 目录条目 id。
+* @returns 插件不得提供该模型时返回 true。
+*/
+function isBlockedModelId(id) {
+	return BLOCKED_MODEL_IDS.has(id);
+}
+//#endregion
+//#region lib/types/usage.js
+/**
+* CodeBuddy 配额/用量计量器:获取并解析剩余额度。
+*
+* CodeBuddy 对计费面的拆分方式与 gproxy 参考实现相同:企业租户回应
+* `get-enterprise-user-usage`(单个 limit/credit 对),而个人账户回应
+* `get-user-resource`(每个生效套餐一个窗口)。两种结构除了每个 CodeBuddy
+* 请求都携带的认证头之外没有任何共同点,因此传输与解析路径只在已登录账户是否
+* 披露了 `enterpriseId` 这一点上分叉一次。
+*
+* 每个进入 Web 客户端的值都是普通 number/string,因此这里返回的
+* {@link UsageSnapshot} 是自有数据 → 不会有活的会话对象逃出本模块。
+*
+* @module dsh-llm-codebuddy-power/usage
+*/
+/**
+* 每个 CodeBuddy 计量请求携带的认证头。
+*
+* 与官方 IDE 主进程的计量调用(`main.js` 中的 `getPersonalUsage`)一致:
+* 在裸 axios 客户端上运行,请求只发送 `Authorization` + `X-User-Id` 以及
+* axios 自身的帧头 — 不含 `X-Domain`/`X-Enterprise-Id`/`X-Tenant-Id`/
+* `X-Department-Info`。这一点已针对 `/v2/billing/meter/get-user-resource`
+* 做过线上验证(抓包恰好显示 `Accept`、`Content-Type`、`Authorization`、
+* `X-User-Id`、`User-Agent: axios/1.15.0`)。
+* @param identity - 已登录的身份。
+* @returns 请求头。
+*/
+function meterHeaders(identity) {
+	return axiosRequestHeaders({
+		"Content-Type": "application/json",
+		"Authorization": `Bearer ${identity.accessToken}`,
+		"X-User-Id": identity.uid
+	});
+}
+/** 读取一个可能以数字或数字字符串形式到达的数值字段。 */
+function number(value, key) {
+	if (value === null || typeof value !== "object") return void 0;
+	const raw = value[key];
+	if (typeof raw === "number") return Number.isFinite(raw) ? raw : void 0;
+	if (typeof raw === "string") {
+		const parsed = Number(raw);
+		return Number.isFinite(parsed) ? parsed : void 0;
+	}
+}
+/** 读取一个非空字符串字段。 */
+function string(value, key) {
+	if (value === null || typeof value !== "object") return void 0;
+	const raw = value[key];
+	return typeof raw === "string" && raw.length > 0 ? raw : void 0;
+}
+/** 沿一条对象键链穿过 JSON 值,返回叶子值或 undefined。 */
+function pointer(value, path) {
+	let current = value;
+	for (const key of path) {
+		if (current === null || typeof current !== "object") return void 0;
+		current = current[key];
+	}
+	return current;
+}
+/**
+* 把 Unix 时间戳按本地时区格式化为 `YYYY-MM-DD HH:mm:ss`,即个人计量面
+* 为其 `SlicePeriod*` 边界所期望的形式。
+*
+* gproxy 参考实现按 UTC 格式化;只要两个边界采用同一约定,CodeBuddy 服务
+* 都接受,而本地格式化与 IDE 客户端发送的一致,因此这次读取更不容易落在
+* 服务端自身预期之外。
+* @param timestamp - Unix 秒。
+* @returns 格式化后的时间戳。
+*/
+function formatTime(timestamp) {
+	const date = /* @__PURE__ */ new Date(timestamp * 1e3);
+	const pad = (n) => n < 10 ? `0${n}` : String(n);
+	return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
+}
+/**
+* 归一化个人套餐的重置时间戳。
+*
+* CodeBuddy 把套餐的 `CycleEndTime` 上报为其最后一个有效日的结束时刻
+* (`23:59:59`)。这读起来像是“午夜前重置”,但配额实际在次日 `00:00:00`
+* 重置,因此当该值以 `23:59:59` 结尾时,显示值向后一天顺延一秒。其他任何值
+* 原样通过,无法解析的时间戳按原样返回而不是丢弃(有这个数字总比没有好)。
+* @param raw - `CycleEndTime` 字符串,`YYYY-MM-DD HH:mm:ss`。
+* @returns 归一化后的时间戳字符串。
+*/
+function normalizeResetTime(raw) {
+	if (!raw.endsWith("23:59:59")) return raw;
+	const date = new Date(raw.replace(" ", "T"));
+	if (Number.isNaN(date.getTime())) return raw;
+	date.setSeconds(date.getSeconds() + 1);
+	const pad = (n) => n < 10 ? `0${n}` : String(n);
+	return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
+}
+/**
+* 判断某个套餐显示名是否表示一次性赠送额度。
+*
+* CodeBuddy 的个人计量面把推荐/裂变额度命名为“裂变包”,未来任何促销都可能
+* 带有“赠送”;其他一切(试用/可续期主套餐、企业行)都视为主池。显示名是
+* 计量面暴露的唯一区分依据,因此两种写法都会被匹配。
+* @param name - 窗口的显示名。
+* @returns 赠送套餐名返回 true。
+*/
+function isGiftName(name) {
+	return /裂变|赠送/.test(name);
+}
+/**
+* 把有可用容量的窗口聚合成一个池(used/limit 求和)。
+* 容量未披露或非正数的窗口会退出 — 它们仍留在 `windows` 中。
+* @param windows - 候选窗口。
+* @returns 该池,或当没有可用容量的窗口匹配时不返回。
+*/
+function poolOf(windows) {
+	let used = 0;
+	let limit = 0;
+	for (const window of windows) {
+		if (window.used === void 0 || window.limit === void 0 || window.limit <= 0) continue;
+		used += window.used;
+		limit += window.limit;
+	}
+	if (limit <= 0) return void 0;
+	return {
+		used,
+		limit
+	};
+}
+/** 有效的赠送窗口:仍有上限且尚未完全耗尽。 */
+function liveGiftWindows(windows) {
+	return windows.filter((window) => window.used !== void 0 && window.limit !== void 0 && window.limit > 0 && window.used < window.limit);
+}
+/**
+* 构建个人快照的主池/赠送池划分,以及提示框的赠送明细(最早过期的有效赠送
+* 在前,最多 5 个)。
+* @param windows - 已解析的窗口。
+* @returns 该划分,仅当对应池有可用 limit 时才包含 `main`/`gift`。
+*/
+function splitPools(windows) {
+	const mainWindows = [];
+	const giftWindows = [];
+	for (const window of windows) if (isGiftName(window.name)) giftWindows.push(window);
+	else mainWindows.push(window);
+	const main = poolOf(mainWindows);
+	const live = liveGiftWindows(giftWindows);
+	const giftPool = poolOf(live);
+	if (giftPool === void 0) return { ...main === void 0 ? {} : { main } };
+	const soonest = live.toSorted((a, b) => {
+		if (a.resetsAt !== void 0 && b.resetsAt !== void 0) return a.resetsAt.localeCompare(b.resetsAt);
+		if (a.resetsAt !== void 0) return -1;
+		return b.resetsAt === void 0 ? 0 : 1;
+	}).slice(0, 5);
+	return {
+		...main === void 0 ? {} : { main },
+		gift: {
+			used: giftPool.used,
+			limit: giftPool.limit,
+			soonest
+		}
+	};
+}
+/**
+* 解析个人账户的 `get-user-resource` 响应。
+*
+* 视请求经过的网关而定,accounts 数组可能位于多个指针根之下;会按顺序逐一
+* 尝试,以找到的第一个数组为准。每个账户贡献一个以其套餐命名的
+* {@link UsageWindow}(披露了显示名时用显示名,否则用套餐代码),其中 `used`
+* 由 `limit - remaining` 推导(因此超过上限的剩余值会被钳制为零已用,而不是
+* 负数)。
+* @param accounts - 定位到的 accounts 数组。
+* @returns 组装好的快照。
+*/
+function personalUsage(accounts) {
+	const windows = accounts.map((resource, index) => {
+		const limit = number(resource, "CycleCapacitySizePrecise") ?? 0;
+		const left = number(resource, "CycleCapacityRemainPrecise") ?? 0;
+		const used = Math.max(limit - left, 0);
+		const name = string(resource, "PackageName") ?? string(resource, "PackageCode") ?? string(resource, "ResourceId") ?? `resource_${index}`;
+		const rawReset = string(resource, "CycleEndTime");
+		const resetsAt = rawReset === void 0 ? void 0 : normalizeResetTime(rawReset);
+		if (limit <= 0) return {
+			name,
+			...resetsAt === void 0 ? {} : { resetsAt }
+		};
+		return {
+			name,
+			used,
+			limit,
+			...resetsAt === void 0 ? {} : { resetsAt }
+		};
+	});
+	const split = splitPools(windows);
+	const first = windows[0];
+	return {
+		windows,
+		...first?.resetsAt === void 0 ? {} : { primaryResetsAt: first.resetsAt },
+		...split.main === void 0 ? {} : { main: split.main },
+		...split.gift === void 0 ? {} : { gift: split.gift }
+	};
+}
+/**
+* 解析企业租户的 `get-enterprise-user-usage` 响应。
+*
+* 企业计费面在 `data` 下(网关未包装时则在根上)上报单个 `limitNum`/`credit`
+* 对,因此只构建一个窗口。
+* @param data - 承载这些数字的 data 对象。
+* @returns 组装好的快照,或未披露任何 limit 时为 `undefined`。
+*/
+function enterpriseUsage(data) {
+	const limit = number(data, "limitNum");
+	if (limit === void 0) return void 0;
+	const used = number(data, "credit") ?? 0;
+	const reset = string(data, "cycleResetTime");
+	const window = {
+		name: "enterprise",
+		used,
+		limit,
+		...reset === void 0 ? {} : { resetsAt: reset }
+	};
+	const main = poolOf([window]);
+	return {
+		windows: [window],
+		...reset === void 0 ? {} : { primaryResetsAt: reset },
+		...main === void 0 ? {} : { main }
+	};
+}
+/**
+* 把一次计量响应解析为快照。
+*
+* gproxy 参考实现会在其已被观察到使用的每个指针根下尝试个人 `Accounts`
+* 数组,只有在没有任何数组匹配时才回退到企业单窗口解析 → 与发出的请求路径
+* 无关。沿用这一顺序,可以让恰好携带 `enterpriseId` 的个人账户(或反之)
+* 按它实际回应的结构解析,而不是按其凭据暗示的结构解析。
+* @param raw - 已解析的响应体。
+* @returns 组装好的快照,或响应体不含任何可解析内容时为 `undefined`。
+*/
+function parseUsage(raw) {
+	for (const path of [
+		[
+			"data",
+			"Response",
+			"Data",
+			"Accounts"
+		],
+		[
+			"data",
+			"data",
+			"Response",
+			"Data",
+			"Accounts"
+		],
+		[
+			"Response",
+			"Data",
+			"Accounts"
+		]
+	]) {
+		const candidate = pointer(raw, path);
+		if (Array.isArray(candidate)) return personalUsage(candidate);
+		if (candidate === null) return { windows: [] };
+	}
+	return enterpriseUsage(pointer(raw, ["data", "data"]) ?? pointer(raw, ["data"]) ?? raw);
+}
+/**
+* 向计量端点 POST 并解析响应,所有失败模式都退化为 `undefined` 而不抛出。
+*
+* 用量是设置界面上的参考性读取,因此传输故障、非 2xx 状态、无法解析的响应体
+* 或服务端非零 `code` 都意味着“不显示用量” → 绝不会出现坏掉的侧边栏底部。
+* @param identity - 已登录的身份,由会话刷新。
+* @param path - {@link CODEBUDDY_ENDPOINT} 下的计量路径。
+* @param body - JSON 请求体。
+* @param signal - 可选的取消信号。
+* @returns 已解析的快照,或计费面不可达、回应了不可用响应体时为
+*   `undefined`。
+*/
+async function postMeter(identity, path, body, signal) {
+	let response;
+	try {
+		response = await fetch(`${CODEBUDDY_ENDPOINT}${path}`, {
+			method: "POST",
+			headers: meterHeaders(identity),
+			body,
+			...signal === void 0 ? {} : { signal }
+		});
+	} catch {
+		return;
+	}
+	if (!response.ok) return void 0;
+	let raw;
+	try {
+		raw = await response.json();
+	} catch {
+		return;
+	}
+	const envelope = raw;
+	if (envelope !== null && typeof envelope === "object" && envelope.code !== void 0 && envelope.code !== 0) return;
+	return parseUsage(raw);
+}
+/**
+* 获取个人账户的用量:每个生效套餐一个窗口。
+*
+* 请求体与官方 IDE 的 `getPersonalUsage` 完全一致(线上抓取):
+* `PageNumber:1, PageSize:100, ProductCode:"p_tcaca", Status:[0,3]`
+* 以及从当前时刻起 101 年的 `PackageEndTimeRange` 窗口 — 起点是“现在”,
+* 终点是 101 年后,依据 `main.js`(`s = new Date`,
+* `n = s + 101*365*24*60*60*1000`)。
+* @param identity - 已登录的身份,由会话刷新。
+* @param signal - 可选的取消信号。
+* @returns 已解析的快照,或计费面不可达时为 `undefined`。
+*/
+async function fetchPersonalUsage(identity, signal) {
+	const now = /* @__PURE__ */ new Date();
+	const end = new Date(now.getTime() + 101 * 365 * 24 * 60 * 60 * 1e3);
+	return postMeter(identity, "/v2/billing/meter/get-user-resource", JSON.stringify({
+		PageNumber: 1,
+		PageSize: 100,
+		ProductCode: "p_tcaca",
+		Status: [0, 3],
+		PackageEndTimeRangeBegin: formatTime(now.getTime() / 1e3),
+		PackageEndTimeRangeEnd: formatTime(end.getTime() / 1e3)
+	}), signal);
+}
+/**
+* 获取企业租户的用量:单个 `limitNum`/`credit` 对。
+*
+* 企业计费面接受空请求体并在 `data` 下回应,因此该请求就是一次带认证的 POST。
+* @param identity - 已登录的身份,由会话刷新。
+* @param signal - 可选的取消信号。
+* @returns 已解析的快照,或计费面不可达时为 `undefined`。
+*/
+async function fetchEnterpriseUsage(identity, signal) {
+	return postMeter(identity, "/v2/billing/meter/get-enterprise-user-usage", "{}", signal);
+}
+/**
+* 获取并解析 CodeBuddy 用量快照,按账户类型分叉。
+*
+* 视已登录身份是否披露了 `enterpriseId`,委托给 {@link fetchPersonalUsage}
+* 或 {@link fetchEnterpriseUsage}。所有失败模式都解析为 `undefined` 而不抛出;
+* 是否重试由调用方决定。
+* @param identity - 已登录的身份,由会话刷新。
+* @param signal - 可选的取消信号。
+* @returns 已解析的快照,或计费面不可达、回应了不可用响应体时为
+*   `undefined`。
+*/
+async function fetchUsage(identity, signal) {
+	return identity.enterpriseId !== void 0 ? fetchEnterpriseUsage(identity, signal) : fetchPersonalUsage(identity, signal);
+}
+//#endregion
+//#region lib/types/session-store.js
+/**
+* 插件自有的会话信息持久化:按会话一个文件,存该会话选用的账号、用过的账号表与
+* 每轮消耗的积分。
+*
+* 这三件事都是"这个会话自己的事实",因此放在同一个文件里
+* (`$DSH_HOME/data/plugins/llm-codebuddy-power/sessions/<会话id>.json`):读一次
+* 就拿到它们,也不会出现两份记录各自指向不同账号。文件是纯增量记录 —— 缺文件等价于
+* "没选过账号、没有积分"。写入是读-改-写的原子替换,并经 [atomic-file.ts](./atomic-file.ts)
+* 按路径串行化:一轮里画图与聊天会各自累加一次积分,分开读-改-写会丢掉其中一次。
+*
+* 文件只增不删:会话被销毁(一次性子代理跑完即如此)不等于用户删除了会话。
+*
+* **账号在表里存一次,每轮记录只引用它的序号**:同一个账号会在几十轮里反复出现,逐轮
+* 内联昵称是同一份事实的重复副本 —— 实测这让文件大了近一倍。键是文件内部自己编的序号
+* 而不是 uid 的任何截断:一个只在本文件里做引用的键不必携带 uid 的信息,截断反而会
+* 让两个同前缀的账号共用一条记录(把历史轮次张冠李戴),而序号不可能重复。
+*
+* 排版也在这里决定:`credits` 每条一行、`accounts` 每条一行,其余保持缩进。逐条一行
+* 让追加一轮只改动两行,而整个文件一行虽然更小,却让文件不可读、改动无法辨别。
+*
+* @module dsh-llm-codebuddy-power/session-store
+*/
+/** 空信息:文件缺失、损坏或字段不合法时的结果。 */
+function emptyInfo() {
+	return {
+		accounts: {},
+		credits: {}
+	};
+}
+/** 会话信息文件路径:`$DSH_HOME/data/plugins/llm-codebuddy-power/sessions/<会话id>.json`。
+*  插件数据统一放 `data/plugins/<插件名(不带dsh-前缀)>/` 下,`data` 是规范的数据目录。 */
+function sessionInfoPath(sessionId) {
+	return dshHomePath("data", "plugins", "llm-codebuddy-power", "sessions", `${sessionId}.json`);
+}
+/**
+* 账号在账号表里的序号。
+*
+* 序号从 0 起、按首次用到该账号的顺序分配,并保留在表里 —— 记录引用的是序号,因此
+* 序号不能随表内增删而改变,否则已有轮次会指向别的账号。
+* @param table - 当前的账号表。
+* @param uid - 要引用的账号 uid。
+* @returns 该账号的序号;从未用过时是下一个未占用的序号。
+*/
+function accountKeyFor(table, uid) {
+	for (const [key, ref] of Object.entries(table)) if (ref.uid === uid) return key;
+	let next = 0;
+	for (const key of Object.keys(table)) {
+		const n = Number(key);
+		if (Number.isSafeInteger(n) && n >= next) next = n + 1;
+	}
+	return String(next);
+}
+/** 文件读出的账号是否合法(两个事实都得在)。 */
+function isAccountRef(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const ref = value;
+	return typeof ref.uid === "string" && ref.uid.length > 0 && typeof ref.nick === "string" && ref.nick.length > 0;
+}
+/**
+* 文件读出的记录是否合法。
+*
+* `accounts` 与 `credit` 同为必填:一条记录说不出这一轮用的是哪个账号,悬停提示就会
+* 缺一行,那与"没有这条记录"没有区别,因此不完整即整条丢弃。引用还必须能在同一份
+* 文件的账号表里解析到 —— 一个悬空引用渲染不出账号,与缺字段是同一种残缺。
+* 插件尚未发布,磁盘上不存在按旧格式写下的文件,故不保留渐进读取。
+* @param value - 文件里的一条轮次记录。
+* @param table - 同一份文件的账号表。
+* @returns 该记录是否可用。
+*/
+function isCreditRecord(value, table) {
+	if (typeof value !== "object" || value === null) return false;
+	const record = value;
+	return typeof record.credit === "number" && Number.isFinite(record.credit) && Array.isArray(record.accounts) && record.accounts.length > 0 && record.accounts.every((key) => typeof key === "string" && isAccountRef(table[key]));
+}
+/**
+* 读取一个会话的信息。
+* @param sessionId - dsh 会话 id。
+* @returns 该会话选用的账号、用过的账号表与积分记录;缺文件或损坏时返回空信息。
+*/
+async function loadSessionInfo(sessionId) {
+	try {
+		const parsed = JSON.parse(await promises.readFile(sessionInfoPath(sessionId), "utf-8"));
+		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return emptyInfo();
+		const record = parsed;
+		const accounts = {};
+		const rawAccounts = record.accounts;
+		if (typeof rawAccounts === "object" && rawAccounts !== null) {
+			for (const [key, value] of Object.entries(rawAccounts)) if (isAccountRef(value)) accounts[key] = value;
+		}
+		const credits = {};
+		const rawCredits = record.credits;
+		if (typeof rawCredits === "object" && rawCredits !== null) {
+			for (const [turn, value] of Object.entries(rawCredits)) if (isCreditRecord(value, accounts)) credits[turn] = value;
+		}
+		const uid = typeof record.uid === "string" && record.uid.length > 0 ? record.uid : void 0;
+		return {
+			...uid === void 0 ? {} : { uid },
+			accounts,
+			credits
+		};
+	} catch {
+		return emptyInfo();
+	}
+}
+/**
+* 把一份信息渲染成文件内容。
+*
+* 逐条一行而不是缩进展开:条目本身是单行记录,缩进只增加字节而不增加可读性。账号表与
+* 轮次记录各自一行,于是新增一轮只改动两行(diff 可读),而文件整体仍然紧凑。
+* @param info - 要渲染的信息。
+* @returns 完整的文件内容,以换行结尾。
+*/
+function renderSessionInfo(info) {
+	const lines = [];
+	if (info.uid !== void 0) lines.push(`  "uid": ${JSON.stringify(info.uid)},`);
+	const accounts = Object.entries(info.accounts);
+	if (accounts.length === 0) lines.push("  \"accounts\": {},");
+	else {
+		lines.push("  \"accounts\": {");
+		accounts.forEach(([key, ref], index) => {
+			lines.push(`    ${JSON.stringify(key)}: ${JSON.stringify(ref)}${index === accounts.length - 1 ? "" : ","}`);
+		});
+		lines.push("  },");
+	}
+	const credits = Object.entries(info.credits);
+	if (credits.length === 0) lines.push("  \"credits\": {}");
+	else {
+		lines.push("  \"credits\": {");
+		credits.forEach(([turn, record], index) => {
+			lines.push(`    ${JSON.stringify(turn)}: ${JSON.stringify(record)}${index === credits.length - 1 ? "" : ","}`);
+		});
+		lines.push("  }");
+	}
+	return `{\n${lines.join("\n")}\n}\n`;
+}
+/**
+* 读-改-写一个会话的信息(原子替换,文件不存在则新建)。
+*
+* 读发生在队列内部,因此排队中的后一次改动看得到前一次的结果,而不是各自基于同一份
+* 旧内容。文件此刻不可读时按空信息起手,与 {@link loadSessionInfo} 对同一情况的判断一致。
+* @param sessionId - dsh 会话 id。
+* @param change - 由当前信息算出新信息;不得就地修改传入值。
+*/
+async function updateSessionInfo(sessionId, change) {
+	const path = sessionInfoPath(sessionId);
+	await queueWrite(path, async () => {
+		await writeFileAtomic(path, renderSessionInfo(change(await loadSessionInfo(sessionId))));
+	});
+}
+//#endregion
+//#region lib/types/session.js
+/**
+* 已登录会话:按账号解析身份、token 新鲜度与缓存的模型目录。
+*
+* 一个对象同时持有它们,因为它们共享同一种故障模式 → token 过期会导致
+* 目录不可读 → 也因为它们都必须在构建请求之前解析完成。刷新是单飞的,而且是
+* **按账号**单飞:适配器每次流式调用解析一次身份,若不按账号分开,两个账号的
+* 并发调用会互相取到对方的刷新结果,其中一个的 token 永远停留过期。
+*
+* 账号由会话决定:某个会话显式选了账号就用它,否则顺延到派生它的会话(子代理、
+* fork)、默认账号、最后一次手动切换的账号,最后落到列表第一个。目录与计量快照
+* 也按账号分别缓存,因为不同账号的可用模型与额度本就可以不同。
+*
+* @module dsh-llm-codebuddy-power/session
+*/
+/** 提前这么久刷新,而不是正好在记录的过期时刻刷新。 */
+const REFRESH_SKEW_MS = 6e4;
+/**
+* 读到的目录在被再次向服务查询之前复用多久。与官方 CLI 的
+* `PRODUCT_CONFIGURATION_CACHE_TIMEOUT`(48e4 ms)对齐。
+*/
+const CATALOG_TTL_MS = 480 * 1e3;
+/**
+* 计量快照在被再次向真实 CodeBuddy 用量平面查询之前服务多久。浏览器以
+* 短得多的间隔轮询宿主;这个 TTL 就是让那些轮询不落到计量 API 上的那一层。
+*/
+const METER_TTL_MS = 60 * 1e3;
+/** 未登录任何账号时抛出;消息中携带补救方法。 */
+var NotLoggedInError = class extends Error {
+	constructor(detail) {
+		super(detail);
+		this.name = "NotLoggedInError";
+	}
+};
+/**
+* 把一条文件记录里的账号引用按账号表展开。
+*
+* 引用解析不到时返回 `undefined` 而不是抛错:读取路径已经保证不会发生(校验时表已建好),
+* 这里只是让"残缺记录不交给界面"这条规则不依赖上游。
+* @param record - 文件里的一条轮次记录。
+* @param table - 同一份文件的账号表。
+* @returns 展开后的记录;有引用解析不到时为 `undefined`。
+*/
+function resolveCreditRecord(record, table) {
+	const accounts = [];
+	for (const key of record.accounts) {
+		const ref = table[key];
+		if (ref === void 0) return void 0;
+		accounts.push({
+			nickname: ref.nick,
+			uid: ref.uid
+		});
+	}
+	return {
+		credit: record.credit,
+		accounts
+	};
+}
+/**
+* 由 dsh 会话身份推导请求头所需的会话 id。
+*
+* 官方只在请求头里认紧凑 uuid(无 `session-` 前缀、无连字符),而 Web GUI 的会话
+* id 正是 `session-<uuid>`:去掉前缀与连字符后恰好 32 位,因此会话 id 可以直接
+* 换算得到,不必另铸一个随机值 —— 后者一旦承载它的内存状态被丢弃(会话销毁后
+* 又恢复),同一个会话就会换一个 id。
+*
+* 取**最后一个** `session-` 之后的部分,而不是去掉开头那一个:会话 id 还有
+* `<agent-id>-session-<uuid>` 形态,从开头截取会把 agent 名混进结果,产生非
+* 十六进制字符。超过 32 位截断,不足则在**前面**补 `0`,使非 uuid 形态(如计数器式
+* `session-<n>`)也得到定长的合法值;在前面补而不是在后面补,是因为数字只有在
+* 右对齐时才互不重合 —— 在后面补会让 `session-1` 与 `session-10` 得到同一个值。
+* @param sessionId - dsh 会话身份。
+* @returns 32 位紧凑 uuid。
+*/
+function compactConversationId(sessionId) {
+	const at = sessionId.lastIndexOf("session-");
+	const compact = (at === -1 ? sessionId : sessionId.slice(at + 8)).replace(/-/g, "");
+	return compact.length >= 32 ? compact.slice(0, 32) : compact.padStart(32, "0");
+}
+/** 账号状态投影:丢掉取值为空的可选字段,使调用方的 `=== undefined` 判断成立。 */
+function accountInfo(entry) {
+	const a = entry.account;
+	return {
+		uid: a.uid,
+		nickname: a.nickname,
+		loginExpiresAt: entry.auth.refreshExpiresAt,
+		...a.uin === void 0 ? {} : { uin: a.uin },
+		...a.enterpriseId === void 0 ? {} : { enterpriseId: a.enterpriseId },
+		...a.enterpriseName === void 0 ? {} : { enterpriseName: a.enterpriseName },
+		...a.enterpriseUserName === void 0 ? {} : { enterpriseUserName: a.enterpriseUserName },
+		...a.departmentFullName === void 0 ? {} : { departmentFullName: a.departmentFullName }
+	};
+}
+/**
+* 持有单个插件实例的已存账号、每个会话选用的账号与它们的缓存。
+*
+* 内存中没有凭据时会从磁盘重新读取,这正是
+* `dsh plugin --profile web codebuddy-power` 能在不重启的情况下
+* 让*运行中*的 harness 登录的原因。
+*/
+var CodeBuddySession = class {
+	logger;
+	onModelsChanged;
+	storage;
+	/** 内存中 `storage` 所读自的凭据文件的新鲜度标记。 */
+	storageKey;
+	/**
+	* {@link storageKey} 是否足以代表 {@link storage}。
+	*
+	* `undefined` 的新鲜度有两种含义 —— 文件真的不存在,或这一次 `fs.stat` 失败(Windows
+	* 上并发替换文件时会短暂如此)—— 所以它不能单独用来判断“没变”。把它当成“没变”而
+	* `storage` 恰好是空的,账号列表就会被读成空、界面显示“未登录”,而磁盘上凭据完好。
+	*/
+	storageMemoValid = false;
+	/** 上一次加载时账号集合的 uid 列表,用来判断集合本身有没有变。 */
+	storageUids = "";
+	/** 按账号 uid 单飞的令牌刷新。 */
+	refreshing = /* @__PURE__ */ new Map();
+	/** 按账号 uid 缓存的目录;合并目录由它派生,因此它的增删决定合并目录的内容。 */
+	catalogs = /* @__PURE__ */ new Map();
+	/**
+	* 模型 id → 模型,由 {@link catalogs} 派生的并集索引,同 id 保留先到的那份。
+	*
+	* 集合只由**带会话身份的**读取填充(聊天请求、模型面板),并供拿不到会话身份的
+	* 调用方({@link knownModel}、`listModels`)查询:那些调用方无法知道该用哪个账号
+	* 的目录,主动读取只能落在默认账号上 —— 而当前会话用的可能正是另一个账号。
+	*/
+	knownCatalog = /* @__PURE__ */ new Map();
+	/** 按账号 uid 单飞的目录读取。 */
+	catalogReads = /* @__PURE__ */ new Map();
+	/** 按账号 uid 缓存的计量快照;在 {@link METER_TTL_MS} 内直接返回,不访问该平面。 */
+	usageCache = /* @__PURE__ */ new Map();
+	/** 活动会话,以 dsh 会话 id 为键;在 `session/disposed` 时清理。 */
+	tracks = /* @__PURE__ */ new Map();
+	/**
+	* 已读出的会话信息(选用的账号 + 每轮积分),按会话 id。
+	*
+	* 单独于 {@link tracks}:账号选择要在还没有任何回合的会话上就能读到(新建会话后
+	* 立刻切账号,第一条消息就得用它),而 `tracks` 只在 `turn/start` 时才有条目。
+	*/
+	infos = /* @__PURE__ */ new Map();
+	/** 正在从文件读取的会话信息,避免并发重复读。 */
+	infoReads = /* @__PURE__ */ new Map();
+	constructor(logger, onModelsChanged) {
+		this.logger = logger;
+		this.onModelsChanged = onModelsChanged;
+	}
+	/**
+	* 在首次见到某会话时以及每个新轮次,为该会话铸出当前轮的请求 id。轮请求 id
+	* 在 harness 打开一个该会话尚未被观察到的轮次时铸出,因此一个用户
+	* 提示词内的所有模型调用都共享它,即使在运行中途插入了提示词。
+	* @param sessionId - dsh 会话身份。
+	* @param turn - harness 刚打开的轮次。
+	* @param parentSessionId - 该会话派生自的会话(子代理、fork),没有时为 `undefined`。
+	*/
+	observeTurn(sessionId, turn, parentSessionId) {
+		const current = this.tracks.get(sessionId);
+		if (current === void 0) {
+			this.tracks.set(sessionId, {
+				turn,
+				turnRequestId: compactUuid(),
+				credits: /* @__PURE__ */ new Map(),
+				...parentSessionId === void 0 ? {} : { parent: parentSessionId }
+			});
+			return;
+		}
+		if (parentSessionId !== void 0) current.parent = parentSessionId;
+		if (current.turn === turn) return;
+		current.turn = turn;
+		current.turnRequestId = compactUuid();
+	}
+	/**
+	* 在 harness 销毁某会话时丢弃它被跟踪的回合状态与已读出的会话信息,使这两个 map
+	* 不会无界增长。磁盘上的会话信息不随之删除:该事件表示会话对象被销毁,而不是用户
+	* 删除了会话 —— 一次性子代理跑完就会触发它。
+	* @param sessionId - dsh 会话身份。
+	*/
+	forget(sessionId) {
+		this.tracks.delete(sessionId);
+		this.infos.delete(sessionId);
+	}
+	/**
+	* 某会话对应的 CodeBuddy 会话 id。由 dsh 会话身份推导,不依赖跟踪状态:
+	* 同一会话在任何时刻、任何进程里都得到同一个值。
+	* @param sessionId - dsh 会话身份。
+	* @returns 32 位紧凑 uuid。
+	*/
+	conversationIdOf(sessionId) {
+		return compactConversationId(sessionId);
+	}
+	/**
+	* 某会话当前轮的请求 id;该会话尚未被观察到时为 `undefined`。
+	* @param sessionId - dsh 会话身份。
+	* @returns 该轮的请求 id;未被观察到的会话为 `undefined`。
+	*/
+	turnRequestIdOf(sessionId) {
+		return this.tracks.get(sessionId)?.turnRequestId;
+	}
+	/**
+	* 读出某会话的信息(选用的账号 + 每轮积分),进程内缓存一次。
+	*
+	* 首读才碰磁盘:账号解析在每次请求上发生,而一个会话的账号选择不会在运行期间被
+	* 别的进程改动(只有本进程写它),因此缓存到会话被销毁即可。
+	* @param sessionId - dsh 会话身份。
+	* @returns 该会话的信息;文件缺失时为“未选账号、无积分”。
+	*/
+	async infoOf(sessionId) {
+		const cached = this.infos.get(sessionId);
+		if (cached !== void 0) return cached;
+		let pending = this.infoReads.get(sessionId);
+		if (pending === void 0) {
+			pending = loadSessionInfo(sessionId).finally(() => {
+				if (this.infoReads.get(sessionId) === pending) this.infoReads.delete(sessionId);
+			});
+			this.infoReads.set(sessionId, pending);
+		}
+		const info = await pending;
+		this.infos.set(sessionId, info);
+		return info;
+	}
+	/**
+	* 把一次 CodeBuddy 请求的扣分累加到会话当前轮。聊天请求与画图工具都
+	* 调用:一轮内两者都可能发生(顺序不定),扣分相加。记录合并到插件自有的
+	* 会话信息文件(fire-and-forget),重启后仍可读。模型不存——dsh 用量自带。
+	*
+	* 账号一并记录,且只在首次使用时追加(按完整 uid 判定是否已记过):扣分与"哪个账号
+	* 扣的"必须在同一时刻取自同一个事实,悬停时再查当前账号会把一轮里切换过账号的情况说错。
+	*
+	* 序号在落盘的读-改-写内部才分配:它取决于该文件当前的账号表,而那张表只有在队列里
+	* 读到文件之后才知道。内存里因此存解析好的账号(昵称 + 完整 uid),文件里存序号 —— 两者
+	* 形状不同是有意的,文件只该存一次账号,而每次查询都回表解析会让悬停这条热路径多一层查找。
+	* @param sessionId - dsh 会话 id。
+	* @param credit - 本次请求扣的积分。
+	* @param account - 发起本次请求的账号。
+	*/
+	recordCredit(sessionId, credit, account) {
+		const track = this.tracks.get(sessionId);
+		if (track === void 0) return;
+		const turn = track.turn;
+		const existing = track.credits.get(turn);
+		const accounts = existing?.accounts ?? [];
+		const known = accounts.some((entry) => entry.uid === account.uid);
+		const merged = {
+			credit: (existing?.credit ?? 0) + credit,
+			accounts: known ? accounts : [...accounts, {
+				nickname: account.nickname,
+				uid: account.uid
+			}]
+		};
+		track.credits.set(turn, merged);
+		updateSessionInfo(sessionId, (info) => {
+			const table = { ...info.accounts };
+			const keys = merged.accounts.map((entry) => {
+				const key = accountKeyFor(table, entry.uid);
+				table[key] = {
+					uid: entry.uid,
+					nick: entry.nickname
+				};
+				return key;
+			});
+			return {
+				...info,
+				accounts: table,
+				credits: {
+					...info.credits,
+					[String(turn)]: {
+						credit: merged.credit,
+						accounts: keys
+					}
+				}
+			};
+		}).catch((error) => {
+			this.logger?.warn(`dsh-codebuddy: could not persist turn credits: ${String(error)}`);
+		});
+	}
+	/**
+	* 某会话某一轮的积分。内存未命中时回退到会话信息文件(重启恢复),
+	* 并回填缓存。
+	* @param sessionId - dsh 会话身份。
+	* @param turn - 轮次号。
+	* @returns 该记录;该轮没有上报任何积分时为 `undefined`。
+	*/
+	async creditOf(sessionId, turn) {
+		const memory = this.tracks.get(sessionId)?.credits.get(turn);
+		if (memory !== void 0) return memory;
+		const info = await this.infoOf(sessionId);
+		const track = this.tracks.get(sessionId);
+		for (const [key, record] of Object.entries(info.credits)) {
+			const n = Number(key);
+			if (!Number.isSafeInteger(n)) continue;
+			const resolved = resolveCreditRecord(record, info.accounts);
+			if (resolved !== void 0) track?.credits.set(n, resolved);
+		}
+		const record = info.credits[String(turn)];
+		return record === void 0 ? void 0 : resolveCreditRecord(record, info.accounts);
+	}
+	/**
+	* 遗忘内存中的账号与按账号缓存的数值,并广播这次变化。
+	*
+	* 刻意不动 {@link catalogs} 与由它派生的 {@link knownCatalog}:目录内容
+	* (模型、促销、档位)不随凭据或按模型的覆写变化(覆写每次解析都从磁盘重读,
+	* 见 `model-enrich.ts` 的 `loadOverrides`),而清掉它们会把官方列表的并集一起
+	* 打空 —— 本方法也被改覆写与 401 失效调用,那时别的账号已并进来的模型不该消失。
+	* 账号真的增删时由 {@link forgetDepartedAccounts} 按 uid 精确丢弃。
+	*/
+	invalidate() {
+		this.storage = void 0;
+		this.storageMemoValid = false;
+		this.refreshing.clear();
+		this.catalogReads.clear();
+		this.usageCache.clear();
+		this.onModelsChanged?.();
+	}
+	/**
+	* 由当前缓存的各账号目录重建合并目录。
+	*
+	* 账号退出后的处理必须是"重建"而不是"清空":清空会让官方列表塌回默认账号,
+	* 而其余仍登录账号的目录本来就在手上 —— 继续并着才是"退出后重新合并当前已有的
+	* 列表"。重建同时确定性地解决同 id 的归属:只剩下仍在的账号参与竞争。
+	*/
+	reindexKnownCatalog() {
+		this.knownCatalog.clear();
+		for (const catalog of this.catalogs.values()) for (const model of catalog.models) if (!this.knownCatalog.has(model.id)) this.knownCatalog.set(model.id, model);
+	}
+	/**
+	* 丢弃已不在账号集合里的账号的缓存与计量快照,并重建合并目录。
+	*
+	* 按成员判定而不是按文件指纹:指纹会被 {@link invalidate} 置空(改一次覆写也走
+	* 那条路),按指纹清空并集会让别的账号的模型凭空消失;而按成员判定是幂等的 ——
+	* 同一个账号仍在时什么都不丢,重复调用也不会多清一次。
+	*/
+	forgetDepartedAccounts() {
+		const stored = new Set((this.storage?.accounts ?? []).map((entry) => entry.account.uid));
+		let departed = false;
+		for (const uid of [...this.catalogs.keys()]) {
+			if (stored.has(uid)) continue;
+			this.catalogs.delete(uid);
+			departed = true;
+		}
+		for (const uid of [...this.usageCache.keys()]) if (!stored.has(uid)) this.usageCache.delete(uid);
+		if (departed) this.reindexKnownCatalog();
+	}
+	/**
+	* 只要凭据文件自上次读取以来发生了变化就重新读取,使另一个进程
+	* (CLI)执行的登录或登出能在不重启的情况下到达运行中的 harness:已持有的
+	* `storage` 不能比被重写或删除的凭据文件活得更久。
+	*
+	* 重读之后只有**账号集合本身**变了才算一次账号变更,判据是 uid 列表而不是文件
+	* 指纹:指纹每次写文件都变,于是每刷新一次令牌(另一个进程的 `--status` 也会)
+	* 或每记一次“最后切换的账号”都会被当成账号变更,从而丢掉按账号缓存的计量快照并
+	* 广播一次模型变更 —— 那些都不是账号增删。真的增删时才会丢弃已退出账号的缓存并
+	* 重建合并目录:退出一个账号后官方列表应当继续并着其余账号已读到的目录,而不是
+	* 塌回默认账号一个。
+	*/
+	async refreshIfChanged() {
+		const storageKey = await storageFreshness();
+		if (this.storageMemoValid && storageKey !== void 0 && storageKey === this.storageKey) return;
+		this.storageKey = storageKey;
+		this.storage = await loadStorage();
+		this.storageMemoValid = this.storage.accounts.length > 0;
+		const uids = this.storage.accounts.map((account) => account.account.uid).sort().join("\0");
+		if (uids === this.storageUids) return;
+		this.storageUids = uids;
+		this.forgetDepartedAccounts();
+		this.onModelsChanged?.();
+	}
+	/** 账号条目,按 uid 查。 */
+	accountEntry(uid) {
+		return uid === void 0 ? void 0 : this.storage?.accounts.find((a) => a.account.uid === uid);
+	}
+	/**
+	* 该会话自身及其派生祖先显式选用的账号,由近及远。读取某个会话的信息可能要碰盘,
+	* 因此本方法是异步的。
+	*
+	* 走到祖先是因为子代理与 fork 出来的会话在界面上没有自己的账号按钮:它们若不
+	* 沿用父会话,就会静默改用默认账号,把一次派发记到另一个账号头上。
+	*/
+	async accountChain(sessionId) {
+		const chain = [];
+		const seen = /* @__PURE__ */ new Set();
+		let current = sessionId;
+		while (current !== void 0 && !seen.has(current)) {
+			seen.add(current);
+			const uid = (await this.infoOf(current)).uid;
+			if (uid !== void 0) chain.push(uid);
+			current = this.tracks.get(current)?.parent;
+		}
+		return chain;
+	}
+	/**
+	* 该会话此刻生效的账号 uid。
+	*
+	* 顺序:会话(或其派生祖先)显式选用的账号 → 默认账号 → 最后一次手动切换的
+	* 账号 → 列表第一个。指向已退出账号的选择会被跳过,而不是当成“没有账号”;
+	* 全部落空时返回 `undefined`,调用方据此报未登录。
+	*/
+	async accountUidFor(sessionId) {
+		if (sessionId !== void 0) {
+			for (const uid of await this.accountChain(sessionId)) if (this.accountEntry(uid) !== void 0) return uid;
+		}
+		for (const fallback of [this.storage?.defaultUid, this.storage?.lastUid]) if (this.accountEntry(fallback) !== void 0) return fallback;
+		return this.storage?.accounts[0]?.account.uid;
+	}
+	identityOf(entry) {
+		return {
+			accessToken: entry.auth.accessToken,
+			domain: entry.auth.domain,
+			uid: entry.account.uid,
+			...entry.account.enterpriseId === void 0 ? {} : { enterpriseId: entry.account.enterpriseId },
+			...entry.account.departmentFullName === void 0 ? {} : { departmentFullName: entry.account.departmentFullName }
+		};
+	}
+	/** 把刷新后的账号写回内存,并尽力落盘(写不进去也不影响本进程继续使用)。 */
+	async persist(entry) {
+		const accounts = this.storage?.accounts;
+		if (accounts !== void 0) {
+			const at = accounts.findIndex((a) => a.account.uid === entry.account.uid);
+			if (at !== -1) accounts[at] = entry;
+		}
+		try {
+			await updateStorage((current) => ({
+				...current,
+				accounts: current.accounts.map((a) => a.account.uid === entry.account.uid ? entry : a)
+			}));
+		} catch (error) {
+			this.logger?.warn("dsh-codebuddy: refreshed the session but could not persist it");
+			this.logger?.warn(error);
+		}
+	}
+	/**
+	* 已存账号条目,在首次使用、失效之后以及文件被外部改动时从磁盘读取。
+	* @param sessionId - 用哪个会话的账号;会话未选用时按默认账号解析。
+	* @throws NotLoggedInError 未存有任何凭据时。
+	*/
+	async require(sessionId) {
+		await this.refreshIfChanged();
+		const entry = this.accountEntry(await this.accountUidFor(sessionId));
+		if (entry === void 0) throw new NotLoggedInError("CodeBuddy is not signed in. Run `dsh plugin --profile web codebuddy-power` to sign in through your browser; no API key is required.");
+		return entry;
+	}
+	/**
+	* 某账号可用的身份,在访问 token 到达或临近过期时刷新它。同一账号的并发
+	* 调用者共享同一次刷新;不同账号各刷各的。
+	* @param entry - 要解析的账号条目。
+	* @returns 用于认证请求的身份。
+	* @throws NotLoggedInError 刷新 token 本身已过期、只能重新在浏览器登录时。
+	*/
+	async identityFor(entry) {
+		const now = Date.now();
+		if (now < entry.auth.expiresAt - REFRESH_SKEW_MS) return this.identityOf(entry);
+		if (now >= entry.auth.refreshExpiresAt) throw new NotLoggedInError(`The CodeBuddy session for ${entry.account.nickname} has expired. Run \`dsh plugin --profile web codebuddy-power\` to sign in again through your browser.`);
+		const uid = entry.account.uid;
+		let pending = this.refreshing.get(uid);
+		if (pending === void 0) {
+			pending = this.refresh(entry).finally(() => {
+				if (this.refreshing.get(uid) === pending) this.refreshing.delete(uid);
+			});
+			this.refreshing.set(uid, pending);
+		}
+		return pending;
+	}
+	async refresh(entry) {
+		const refreshed = await refreshAccessToken(this.identityOf(entry), entry.auth.refreshToken);
+		if (refreshed === void 0) throw new NotLoggedInError(`Refreshing the CodeBuddy session for ${entry.account.nickname} failed. Run \`dsh plugin --profile web codebuddy-power\` to sign in again through your browser.`);
+		const next = {
+			auth: {
+				accessToken: refreshed.accessToken,
+				expiresAt: Date.now() + refreshed.expiresIn * 1e3,
+				refreshToken: refreshed.refreshToken,
+				refreshExpiresAt: Date.now() + refreshed.refreshExpiresIn * 1e3,
+				domain: refreshed.domain
+			},
+			account: entry.account
+		};
+		await this.persist(next);
+		return this.identityOf(next);
+	}
+	/** 由身份构建每个已认证 CodeBuddy 请求都携带的请求头。 */
+	headersFrom(identity) {
+		const headers = {
+			"Authorization": `Bearer ${identity.accessToken}`,
+			"X-Domain": identity.domain,
+			"X-User-Id": identity.uid
+		};
+		if (identity.enterpriseId !== void 0) {
+			headers["X-Enterprise-Id"] = identity.enterpriseId;
+			headers["X-Tenant-Id"] = identity.enterpriseId;
+		}
+		if (identity.departmentFullName !== void 0) headers["X-Department-Info"] = identity.departmentFullName;
+		return headers;
+	}
+	/**
+	* 每个已认证 CodeBuddy 请求都携带的请求头,以及这些头属于哪个账号。
+	*
+	* 两者在**同一次**身份解析中一起给出:分开解析会有两次账号选择,而账号是每次请求
+	* 解析的(用户可在同一步里切换),两次解析可能落到不同账号上 —— 那样记进这一轮的
+	* 账号名就与实际发出去的请求不符。缩写由落盘侧按同一规则算出,故此处给出完整账号。
+	* @param sessionId - 请求所属的会话;决定用哪个账号,缺省时用默认账号。
+	* @returns 身份请求头与发起该请求的账号。
+	*/
+	async requestIdentity(sessionId) {
+		const entry = await this.require(sessionId);
+		return {
+			headers: this.headersFrom(await this.identityFor(entry)),
+			account: {
+				uid: entry.account.uid,
+				nickname: entry.account.nickname
+			}
+		};
+	}
+	/**
+	* 是否存在凭据,但不要求必须有。
+	* @returns 已存账号可读取且可用时为 true。
+	*/
+	async isLoggedIn() {
+		await this.refreshIfChanged();
+		return (this.storage?.accounts.length ?? 0) > 0;
+	}
+	/**
+	* 已存账号及其默认账号,供设置页与会话切换按钮展示。
+	* @returns 账号列表(顺序与磁盘一致)与默认账号 uid;未登录时列表为空。
+	*/
+	async accountList() {
+		await this.refreshIfChanged();
+		return {
+			accounts: (this.storage?.accounts ?? []).map(accountInfo),
+			...this.storage?.defaultUid === void 0 ? {} : { defaultUid: this.storage.defaultUid }
+		};
+	}
+	/**
+	* 某会话此刻生效的账号 uid。
+	* @param sessionId - dsh 会话身份;缺省时用默认账号。
+	* @returns 账号 uid;一个账号也没有时为 `undefined`。
+	*/
+	async activeUid(sessionId) {
+		await this.refreshIfChanged();
+		return this.accountUidFor(sessionId);
+	}
+	/**
+	* 把某会话的账号切换为指定账号,并把它记为最后一次手动切换的账号。
+	* @param sessionId - dsh 会话身份。
+	* @param uid - 要使用的账号 uid。
+	* @returns 该 uid 是已存账号时为 true;否则不做任何改动并返回 false。
+	*/
+	async activate(sessionId, uid) {
+		await this.refreshIfChanged();
+		if (this.accountEntry(uid) === void 0) return false;
+		const info = await this.infoOf(sessionId);
+		await updateSessionInfo(sessionId, (current) => ({
+			...current,
+			uid
+		}));
+		this.infos.set(sessionId, {
+			...info,
+			uid
+		});
+		await setLastAccount(uid);
+		return true;
+	}
+	/**
+	* CodeBuddy 模型目录,短暂缓存,并在并发读取者之间共享。
+	* @param signal - 底层读取的可选取消信号。
+	* @param sessionId - 用哪个会话的账号;缺省时用默认账号。
+	* @returns 目录中的模型,按服务自身的顺序。
+	*/
+	async models(signal, sessionId) {
+		return (await this.catalogData(signal, sessionId)).models;
+	}
+	/**
+	* 目录及其推广与档位,在同一个 TTL 下按账号一起缓存,并按账号单飞,使列表与
+	* 面板富化共享同一次读取。
+	* @param signal - 底层读取的可选取消信号。
+	* @param sessionId - 用哪个会话的账号;缺省时用默认账号。
+	* @returns 模型、推广与档位。
+	*/
+	async catalogData(signal, sessionId) {
+		await this.refreshIfChanged();
+		const uid = await this.accountUidFor(sessionId);
+		if (uid === void 0) throw new NotLoggedInError("CodeBuddy is not signed in. Run `dsh plugin --profile web codebuddy-power` to sign in through your browser; no API key is required.");
+		const cached = this.catalogs.get(uid);
+		if (cached !== void 0 && Date.now() - cached.readAt < CATALOG_TTL_MS) return cached;
+		let pending = this.catalogReads.get(uid);
+		if (pending === void 0) {
+			pending = this.readCatalog(uid, signal).finally(() => {
+				if (this.catalogReads.get(uid) === pending) this.catalogReads.delete(uid);
+			});
+			this.catalogReads.set(uid, pending);
+		}
+		return pending;
+	}
+	async readCatalog(uid, signal) {
+		const entry = this.accountEntry(uid);
+		if (entry === void 0) throw new NotLoggedInError(`The CodeBuddy account ${uid} is no longer stored.`);
+		const config = await getConfig(this.headersFrom(await this.identityFor(entry)), signal);
+		const models = config.models.filter((model) => typeof model.id === "string" && model.id.length > 0);
+		const catalog = {
+			models,
+			promotions: config.modelPromotions ?? [],
+			tiers: config.modelTiers
+		};
+		if (this.accountEntry(uid) === void 0) return catalog;
+		this.catalogs.set(uid, {
+			...catalog,
+			readAt: Date.now()
+		});
+		let grown = false;
+		for (const model of models) {
+			if (this.knownCatalog.has(model.id)) continue;
+			this.knownCatalog.set(model.id, model);
+			grown = true;
+		}
+		if (grown) this.onModelsChanged?.();
+		return catalog;
+	}
+	/**
+	* 从各账号已读到的目录的并集里查一个模型,**不发起任何请求**。
+	*
+	* 供拿不到会话身份的调用方使用(适配器的 `resolveModel`):它无法知道该用哪个
+	* 账号的目录,主动读取只能落在默认账号上,而当前会话用的可能正是另一个账号 ——
+	* 那会把一个账号独有的模型解析成保守的默认能力(上下文窗口、输出上限、图片输入
+	* 全部按最保守处理)。并集由带会话身份的读取填充,因此这个查询零成本、也不改变
+	* "谁在读目录"这件事。
+	* @param modelId - 模型 id。
+	* @returns 该模型;尚无任何账号读到过它时为 `undefined`。
+	*/
+	knownModel(modelId) {
+		return this.knownCatalog.get(modelId);
+	}
+	/**
+	* 各账号已读到的目录并集里的全部模型。
+	*
+	* 与 {@link knownModel} 同为只读查询:官方模型列表按它取数,因此它既包含默认
+	* 账号的模型(冷启动那一次读取必然先做),也包含其他账号在会话里读过之后并进来
+	* 的模型。顺序按各账号目录并入的先后,而非任何排序 —— 官方列表自行决定呈现顺序。
+	* @returns 并集里的模型。
+	*/
+	knownModels() {
+		return [...this.knownCatalog.values()];
+	}
+	/**
+	* 目录及其推广/档位;读不到时返回空值 —— 供面板使用的
+	* {@link catalogData} 建议性读取孪生体。
+	* @param signal - 可选取消信号。
+	* @param sessionId - 用哪个会话的账号;缺省时用默认账号。
+	* @returns 目录与活动,或空列表。
+	*/
+	async catalogDataOrEmpty(signal, sessionId) {
+		try {
+			return await this.catalogData(signal, sessionId);
+		} catch (error) {
+			if (error instanceof NotLoggedInError) return {
+				models: [],
+				promotions: [],
+				tiers: void 0
+			};
+			this.logger?.warn("dsh-codebuddy: could not read the model catalog");
+			this.logger?.warn(error);
+			return {
+				models: [],
+				promotions: [],
+				tiers: void 0
+			};
+		}
+	}
+	/**
+	* 目录;读不到时返回空列表。
+	*
+	* 列出模型是设置页上的浏览动作,所以失败必须降级为“没有可显示的内容”,
+	* 而不是让页面崩掉。请求路径直接使用 {@link models} 并保留真实失败。
+	* @param signal - 可选取消信号。
+	* @param sessionId - 用哪个会话的账号;缺省时用默认账号。
+	* @returns 目录,或空列表。
+	*/
+	async modelsOrEmpty(signal, sessionId) {
+		try {
+			return await this.models(signal, sessionId);
+		} catch (error) {
+			if (error instanceof NotLoggedInError) return [];
+			this.logger?.warn("dsh-codebuddy: could not read the model catalog");
+			this.logger?.warn(error);
+			return [];
+		}
+	}
+	/**
+	* CodeBuddy 用量/配额快照;读不到时为 `undefined`。
+	*
+	* 用量是界面上的建议性读取,所以计量故障必须降级为“没有可显示的
+	* 内容”而不是向外传播:{@link NotLoggedInError} 表现为未登录状态,
+	* 其他每种失败(传输、解析、刷新过期)都在一条警告之后解析为
+	* `undefined`。身份通过与聊天请求相同的按账号单飞刷新解析,所以并发的计量
+	* 读取绝不会消耗两次刷新 token。
+	* @param sessionId - 用哪个会话的账号;缺省时用默认账号。
+	* @param signal - 可选取消信号。
+	* @returns 该快照;未存有任何凭据或计量平面不可达时为 `undefined`。
+	*/
+	async usage(sessionId, signal) {
+		await this.refreshIfChanged();
+		const entry = this.accountEntry(await this.accountUidFor(sessionId));
+		if (entry === void 0) return void 0;
+		const uid = entry.account.uid;
+		const cached = this.usageCache.get(uid);
+		if (cached !== void 0 && Date.now() - cached.readAt < METER_TTL_MS) return cached.snapshot;
+		let identity;
+		try {
+			identity = await this.identityFor(entry);
+		} catch (error) {
+			if (error instanceof NotLoggedInError) return void 0;
+			this.logger?.warn("dsh-codebuddy: could not resolve identity for usage read");
+			this.logger?.warn(error);
+			return;
+		}
+		const snapshot = await fetchUsage(identity, signal);
+		if (snapshot !== void 0) {
+			this.usageCache.set(uid, {
+				snapshot,
+				readAt: Date.now()
+			});
+			return snapshot;
+		}
+		return cached?.snapshot;
+	}
+};
+//#endregion
+//#region lib/types/cli/login.js
+/**
+* `codebuddy-power`:通过浏览器登录 CodeBuddy,把账号追加到插件读取的账号列表,
+* 并管理那份列表。
+*
+* 刻意作为独立入口而非 harness 内的提示:该流程需要浏览器和
+* 人工,而运行中的 agent 不应为等待它而阻塞模型调用。已在运行
+* 的 harness 会在下一次请求时取用该账号,无需重启。
+*
+* 用法:
+*   codebuddy-power                     登录并追加账号
+*   codebuddy-power --status            列出全部账号与默认账号
+*   codebuddy-power --default <账号>    把某个账号设为默认
+*   codebuddy-power --logout <账号>     退出一个账号
+*   codebuddy-power --logout --all      退出全部账号
+*   codebuddy-power --no-open           只打印 URL,不打开浏览器
+*
+* `<账号>` 可以是 `--status` 列出的序号、账号 uid 或昵称。
+*
+* @module dsh-llm-codebuddy-power/cli/login
+*/
+/**
+* 按 uid、`--status` 列出的序号或昵称定位一个账号。
+*
+* 优先级固定为 uid → 序号 → 昵称:昵称可以重复,而 uid 与序号不会,所以更精确
+* 的写法先被认领。昵称命中多个时不猜,直接报错要求改用前两种写法。
+* @param accounts - 已存账号,顺序与磁盘一致。
+* @param spec - 命令行给出的账号写法。
+* @returns 命中的账号,或失败说明。
+*/
+function lookupAccount(accounts, spec) {
+	const byUid = accounts.find((account) => account.account.uid === spec);
+	if (byUid !== void 0) return { entry: byUid };
+	if (/^\d+$/.test(spec)) {
+		const byIndex = accounts[Number(spec) - 1];
+		if (byIndex !== void 0) return { entry: byIndex };
+	}
+	const byNickname = accounts.filter((account) => account.account.nickname === spec);
+	if (byNickname.length === 1) return { entry: byNickname[0] };
+	if (byNickname.length > 1) return { failure: `The nickname "${spec}" matches ${byNickname.length} accounts; use a uid or an index instead.` };
+	return { failure: `No stored account matches "${spec}". Run --status to list them.` };
+}
+/** 打印全部账号,标出默认账号,再列出默认账号可用的模型。 */
+async function status() {
+	const stored = await loadStorage();
+	const accounts = stored.accounts;
+	if (accounts.length === 0) {
+		console.log("Not signed in. Run `dsh plugin --profile web codebuddy-power` to sign in through your browser.");
+		return 1;
+	}
+	console.log(`Accounts (${accounts.length}):`);
+	accounts.forEach((account, index) => {
+		const enterprise = account.account.enterpriseName === void 0 ? "" : `  [${account.account.enterpriseName}]`;
+		const isDefault = account.account.uid === stored.defaultUid ? "  (default)" : "";
+		console.log(`  ${index + 1}. ${account.account.nickname}${enterprise}  (uid ${account.account.uid})${isDefault}`);
+	});
+	console.log(`Credential: ${getStoragePath()}`);
+	const models = await new CodeBuddySession().modelsOrEmpty();
+	if (models.length === 0) {
+		console.log("Models: none readable (the session may need refreshing)");
+		return 0;
+	}
+	console.log(`Models (${models.length}):`);
+	for (const model of models) {
+		const label = model.credits === void 0 ? model.name : `${model.name} [${model.credits.trim().replace(/\s+credits$/i, "")}]`;
+		const flags = [
+			model.supportsToolCall === true ? "tools" : void 0,
+			model.supportsReasoning === true ? "reasoning" : void 0,
+			model.supportsImages === true ? "images" : void 0,
+			isBlockedModelId(model.id) ? "blocked" : void 0,
+			hasDisclosedCapacity(model) ? void 0 : "no size, not offered"
+		].filter(Boolean).join(", ");
+		console.log(`  ${model.id}  ${label}${flags.length > 0 ? `  (${flags})` : ""}`);
+	}
+	return 0;
+}
+/** 设置默认账号。 */
+async function setDefault(spec) {
+	const found = lookupAccount((await loadStorage()).accounts, spec);
+	if ("failure" in found) {
+		console.error(found.failure);
+		return 1;
+	}
+	await setDefaultAccount(found.entry.account.uid);
+	console.log(`Default account is now ${found.entry.account.nickname} (uid ${found.entry.account.uid}).`);
+	return 0;
+}
+/** 退出一个账号,或 `--all` 时退出全部。 */
+async function logout(spec, all) {
+	const stored = await loadStorage();
+	if (stored.accounts.length === 0) {
+		console.log("Not signed in.");
+		return 0;
+	}
+	let uids;
+	let described;
+	if (all) {
+		uids = stored.accounts.map((account) => account.account.uid);
+		described = `all ${uids.length} account(s)`;
+	} else {
+		if (spec === void 0) {
+			console.error("--logout needs an account (uid, index, or nickname), or --all.");
+			return 1;
+		}
+		const found = lookupAccount(stored.accounts, spec);
+		if ("failure" in found) {
+			console.error(found.failure);
+			return 1;
+		}
+		uids = [found.entry.account.uid];
+		described = `${found.entry.account.nickname} (uid ${found.entry.account.uid})`;
+	}
+	await removeAccounts(uids);
+	console.log(`Signed out: removed ${described}.`);
+	return 0;
+}
+async function main() {
+	const argv = process.argv.slice(2);
+	const args = new Set(argv);
+	/** 取 `--flag` 之后的一个值;没有值时返回 undefined。 */
+	const valueOf = (flag) => {
+		const at = argv.indexOf(flag);
+		return at === -1 ? void 0 : argv[at + 1];
+	};
+	if (args.has("--help") || args.has("-h")) {
+		console.log("Usage: dsh plugin --profile web codebuddy-power [--status | --default <account> | --logout <account> | --logout --all | --no-open]");
+		return 0;
+	}
+	if (args.has("--status")) return status();
+	if (args.has("--default")) {
+		const spec = valueOf("--default");
+		if (spec === void 0) {
+			console.error("--default needs an account (uid, index, or nickname).");
+			return 1;
+		}
+		return setDefault(spec);
+	}
+	if (args.has("--logout")) return logout(valueOf("--logout"), args.has("--all"));
+	const controller = new AbortController();
+	const onSignal = () => {
+		controller.abort();
+	};
+	process.once("SIGINT", onSignal);
+	process.once("SIGTERM", onSignal);
+	try {
+		const result = await login({
+			openBrowser: !args.has("--no-open"),
+			onUrl: (url) => {
+				console.log("Open this URL to sign in to CodeBuddy:");
+				console.log(`  ${url}`);
+				console.log("Waiting for the browser sign-in to complete...");
+			}
+		}, controller.signal);
+		console.log(`Signed in as ${result.nickname}.`);
+		console.log(`Credential written to ${getStoragePath()}`);
+		return 0;
+	} catch (error) {
+		console.error(`Sign-in failed: ${error instanceof Error ? error.message : String(error)}`);
+		return 1;
+	} finally {
+		process.off("SIGINT", onSignal);
+		process.off("SIGTERM", onSignal);
+	}
+}
+main().then((code) => {
+	process.exitCode = code;
+}).catch((error) => {
+	console.error(error);
+	process.exitCode = 1;
+});
+//#endregion
+export {};