dsh-connect-trae 3.5.1 → 3.6.0

package/CHANGELOG.md

@@ -1,5 +1,55 @@
 # Changelog
 
+## 3.6.0 (2026-10-16)
+
+> **多个账号可以并存了。** 本版新增**账号导入 / 导出**：不再需要每次把某台机器的登录凭据
+> 手工写进默认路径来顶掉上一个账号 —— 导出一份 JSON、在另一处导入即可。同时补上
+> `#39` 那条诊断：上游没下发 function 配置时，报错不再读起来像本地故障。
+
+这是一次 **minor** 升级（新增用户可见的界面与能力）。
+
+### 新增
+
+- **账号导入 / 导出（issue #37）**：账号区新增一行「导入 / 导出账号」，
+  - **导出**：勾选若干账号 → 下载一个 JSON 文件（`trae-accounts-YYYY-MM-DD.json`）；
+  - **导入**：选择文件 → **脱敏预览**（只显示账号标识与「是否有 Token」，不显示凭据）→ 勾选 → 导入；
+  - 文件格式与同族 `dsh-connect-workbuddy` **互通**（顶层 snake_case：`access_token` / `refresh_token` /
+    `uid` / `nickname` / `domain` / `expiresAt`(毫秒) / `refreshExpiresAt` / `auth_raw`），
+    所以两边导出的文件可以互相导入。
+  - **顺带把存储升级成多账号**：本插件原先每个区域只保存**一个**凭据，导入的第二个账号无处可放。
+    现改为**每区域一个文件保存凭据数组**（格式版本 1→2），**旧文件仍可读**、在下一次写入时自动升级。
+  - 导入按钮在**未登录时也可用** —— 一台从没登录过的机器，正是最需要导入别处导出的文件的时候。
+
+  > **区域门禁是正向匹配**：导入文件里的 `domain` 是文件作者可控的值，而本插件「认不出就当作国内版」
+  > 的规则对**上游下发**的数据是对的、对**导入文件**是危险的（伪造域名会被塞进国内版）。
+  > 因此导入走一条**只认正向识别**的通道：空值、认不出的值、以及明确属于另一区域的值一律**跳过并计数**，
+  > 绝不静默落库。国内版与国际版是两个并行的供应商栈，跨区导入会导致跨区计费。
+
+### 修复
+
+- **修复一个会导致账号丢失的写入缺陷（本次实现导入功能时发现）**：本插件的刷新路径原先把
+  「刚刷新好的那一个凭据」当作**整个文件**写回。在单凭据时代这没问题；一旦一个区域能保存多个账号
+  （正是导入带来的），**刷新一个账号就会把同区域的其他账号全部删掉**。
+  已改为**读-改-写**：只替换被刷新账号自己那一条，其余条目原样保留。回归测试专门钉住了这一点。
+
+- **上游未下发 function 配置时，报错读起来不再像本地故障（issue #39）**：
+  - 报告者遇到的现象是每次调用都返回 `2001 no function config found for appId=…`，
+    他据此排查了一圈本地凭据与插件版本，最后才发现问题在服务端 —— 上游的
+    `get_detail_param` 当时对**每个** SOLO function 都返回空的 `config_info_list`，随后**自行恢复**。
+  - 现在（a）`2001` 有了明确文案：**「上游尚未下发本通道的 function 配置（这是上游侧的状态，
+    不是本地凭据或配置问题）」**；（b）当**所有** function 都返回 200 却一条配置都没有时，
+    目录读取会抛出专用的 `TraeEmptySoloDirectory`，把「上游没下发」与「所有 function 都请求失败」
+    区分开。两者都不暗示需要重新登录，因为这个条件是**会自行恢复**的。
+
+### 测试
+
+- 新增 4 个测试文件、共 34 例：导入导出格式（解析 / 脱敏预览 / 往返 / 区域门禁）、
+  导入路由（HTTP 边界上的伪造区域拒绝、导入前重新解析文件而非信任预览）、
+  存储升级与**刷新不吞账号**、以及端到端的「一处导出 → 另一处导入」。
+- 区域门禁做了**变异验证**：把门禁改成 fail-open（正是同族插件 `#42` 修过的那个缺陷）后，
+  格式层与路由层**各有用例变红**；把毫秒单位改成错误的换算同样被抓住。
+- 全仓 **655** 例测试通过，类型检查通过。
+
 ## 3.5.1 (2026-10-16)
 
 > **DeepSeek-V4 四个模型行不再必然报 4001。** 本版修一处 wire 名单合并的方向错误：

package/README.md

@@ -42,6 +42,7 @@
 - **识图能力跟随 Trae 自身的标注** —— Trae 把某个模型标为 `multimodal` 时，插件直接按多模态对外声明，无需你在卡片上逐一手勾（issue #16）。判据是「**你手动勾选的 ∪ Trae 标注多模态的**」：Trae 明确标 `false` 或未标注的模型保持纯文本，你可以照旧手动为它们打开图片输入。卡片上被自动开启的那一行显示为已勾选且只读，并说明原因。详见下方「图片输入（识图）」。
 - **多账号切换** —— 支持重新读取 Token 列表并选择账号；Token 不写入 DSH 设置。**你的选择会被记住并长期生效**：插件不会因为某个账号额度用尽、或检测到另一个可用账号就自作主张替你切换（换账号意味着换人计费）。所以当绑定的账号额度耗尽时，卡片会**明确告诉你**，并把本机其他还有额度的账号连同其可用积分数列出来，由你一键切换——而不是让面板一直空着、也不自动把你切走。「刷新账号与 Token」每次都会回报结果（找到几个账号、当前仍绑定谁），不会再「点了没反应」。下拉里显示的是产品名（`Trae` / `TRAE SOLO` / 国际版），便于分辨凭据来自哪个安装。
 - **跟随 Trae 当前登录的账号** —— 你在 Trae 桌面端**退出并换登录**后，卡片会检测到「插件绑定的账号」与「Trae 现在登录的账号」不一致，并给出一行提示与**一键切换**（复用账号下拉的同一次写入，不引入第二条切换路径）。想让插件**自动跟随**，可打开设置卡片里的「跟随 Trae 当前登录的账号」开关：此后每次配置生效都会把 `accounts.<region>` 重绑到 App 当前登录的账号。**该开关默认关闭**——已有配置保持原来的严格绑定，自动换绑意味着换人计费，必须由你主动勾选；未勾选时上面那行提示就是你的手动通道。（issue #29）
+- **账号导入 / 导出** —— 不用再为了用第二个账号而把凭据手工写进默认路径、顶掉上一个。在卡片账号区的「导入 / 导出账号」里：**导出**勾选若干账号下载一份 JSON；**导入**选择文件后先看**脱敏预览**（只显示账号标识与「是否有 Token」，不含凭据本身）再勾选导入。文件格式与同族 `dsh-connect-workbuddy` **互通**，两边导出的文件可以互相导入。导入按账号去重（同一账号再导入即覆盖更新），**认不出所属区域或因缺 Token 的记录会被跳过并计数**——国内版与国际版是两条并行计费通道，跨区导入会导致跨区计费，所以这里只认同能**正向识别**的区域。导出文件里是**有效 Token，请当作密码保管**。（issue #37）
 - **只读用量与模型管理** —— 国内版查看 Work 积分与通用积分，国际版查看订阅/试用状态；刷新/启用 Trae 模型；只读查询不消耗额度。
 - **积分临近到期会提醒** —— 剩余额度只回答「还有多少」，回答不了「**哪一笔先到期**」；提醒条按到期紧迫程度逐级加重（**7 天 → 24 小时 → 已过期**），写明金额、套餐数和最早到期时间，避免只盯总额时悄悄丢掉最先到期的额度。国内版在用量页与输入框积分面板两处都显示（国际版是订阅制，没有逐包到期数据）。
 - **一键测试启用模型** —— 给**已启用**的每个模型发一条最小消息（一句 `ping`、不带工具），逐个告诉你能不能真的应答：**可用** / **需要更高档位**（Trae `1005`，你的套餐不覆盖）/ **上游不提供**（`4001`，SOLO 通道没有这个模型）/ **被限流**（`4011`，Trae 限了这条通道）/ **登录凭据被拒** / **本次未测出**。最后一项是一等公民：超时、断连、代理、5xx **一律不算「不可用」**——只有上游明确的拒绝才算负面结论。**这是插件里唯一消耗额度的操作**（签到改变的是账号状态，不消耗），只在你点击时运行，结果只留在当前会话里不写入设置。

package/lib/client.js

@@ -48,6 +48,17 @@ window.__ModuleLoader__.load({
 		* account row.
 		*/
 		const TRAE_CHECKIN_PATH = "/plugins/dsh-connect-trae/checkin";
+		/**
+		* Plugin-owned account transfer endpoint: batch export and import of a region's
+		* stored credentials (issue #37).
+		*
+		* One route with an `action` query parameter (`export` | `preview` | `import`),
+		* mirroring the sibling `dsh-connect-workbuddy` plugin's transfer route so the
+		* two cards behave the same way for a user who has both installed. The vault
+		* document never leaves the Host: the browser receives parsed answers, and a
+		* preview carries display fields only — never token material.
+		*/
+		const TRAE_TRANSFER_PATH = "/plugins/dsh-connect-trae/transfer";
 		/** Query parameter naming the region a card request addresses. */
 		const TRAE_REGION_PARAM = "region";
 		/** Every region, in card tab order. */
@@ -60,6 +71,18 @@ window.__ModuleLoader__.load({
 			return `${path}?${TRAE_REGION_PARAM}=${region}`;
 		}
 		/**
+		* Address one region's transfer route with its step, e.g.
+		* `/plugins/dsh-connect-trae/transfer?region=cn&action=export`.
+		*
+		* Separate from {@link withTraeRegion} because this route carries a second
+		* query parameter: a caller that appended `&action=` by hand would be one typo
+		* away from a 400, which is exactly the failure the sibling workbuddy plugin
+		* hit (#42) when five requests dropped that parameter.
+		*/
+		function withTraeTransferAction(path, region, action) {
+			return `${path}?${TRAE_REGION_PARAM}=${region}&action=${action}`;
+		}
+		/**
 		* Peel ONE `{get(): T}` live reference, the shape DSH 0.1.7 delivers a
 		* volatile-marked settings field as (see {@link unwrapVolatileDeep}).
 		*/
@@ -482,6 +505,32 @@ window.__ModuleLoader__.load({
 .dsm-trae-expiry-week{border-color:var(--dsw-alias-border-l2,#3a3d45);background:var(--dsw-alias-bg-layer-3,#2c2f36);color:var(--dsw-alias-label-primary,#e6e6e6)}
 .dsm-trae-expiry-lapsed{border-color:var(--dsw-alias-border-l2,#3a3d45);background:var(--dsw-alias-bg-layer-3,#2c2f36);color:var(--dsw-alias-label-tertiary,#999)}
 .dsm-trae-expiry-detail{font-size:11px;line-height:16px;opacity:.8}
+/* Account import / export (issue #37). A sub-block of the accounts section:
+   the transfer row, plus the two dialogs it opens in place. The file input is
+   hidden rather than absent — the button opens the system picker, and the input
+   must stay mounted to be clicked. */
+.dsm-trae-transfer{margin-top:12px;padding-top:10px;border-top:1px solid var(--dsw-alias-border-l2,rgba(127,127,127,.2))}
+.dsm-trae-transfer-label{margin:0 0 6px;font-size:11px;line-height:16px;color:var(--dsw-alias-label-secondary,GrayText)}
+.dsm-trae-transfer-actions{display:flex;flex-wrap:wrap;gap:8px}
+.dsm-trae-transfer-file{display:none}
+.dsm-trae-transfer-status{margin:6px 0 0;font-size:11px;line-height:16px}
+.dsm-trae-transfer-ok{color:var(--dsw-alias-state-success-primary,#16a34a)}
+.dsm-trae-transfer-error{color:var(--dsw-alias-state-error-primary,#dc2626)}
+.dsm-trae-transfer-dialog{
+  margin-top:8px;padding:10px;border:1px solid var(--dsw-alias-border-l2,rgba(127,127,127,.28));
+  border-radius:8px;font-size:12px;line-height:18px;
+}
+.dsm-trae-transfer-dialog>p{margin:0 0 6px}
+.dsm-trae-transfer-list{list-style:none;margin:6px 0;padding:0;max-height:180px;overflow:auto}
+.dsm-trae-transfer-list label{display:flex;align-items:center;gap:6px;padding:2px 0;cursor:pointer}
+.dsm-trae-transfer-list input{flex:none}
+.dsm-trae-transfer-dialog-actions{display:flex;flex-wrap:wrap;gap:8px;margin-top:8px}
+/* A text-button rather than a boxed one: "select all" is a shortcut inside the
+   dialog, and a third button would compete with the two that act. */
+.dsm-trae-transfer-link{
+  margin-top:6px;padding:0;border:0;background:none;cursor:pointer;
+  color:var(--dsw-alias-brand-primary,#2563eb);font-size:11px;line-height:16px;
+}
 .dsm-trae-models-hint{margin:4px 0 0;color:var(--dsw-alias-label-tertiary,#999);font-size:11px;line-height:16px}
 /* Verdict badge. Only a real refusal is coloured as a warning; an unknown
    verdict stays neutral because an inconclusive probe is not evidence against
@@ -785,6 +834,368 @@ window.__ModuleLoader__.load({
 			});
 		}
 		//#endregion
+		//#region src/client/AccountTransfer.tsx
+		/**
+		* The card's account-transfer section: batch export and import of a region's
+		* stored credentials, in the file format shared with sibling credential
+		* managers for the same upstream (the `dsh-connect-workbuddy` family).
+		*
+		* Modelled on that plugin's `AccountTransfer`, deliberately: the two plugins
+		* share one external-presentation language, and a user who has imported
+		* accounts in one should recognise the flow in the other. The shape is a single
+		* section owning all of its state (busy / result line / error), with the export
+		* dialog (pick accounts → download JSON) and the import dialog (pick file →
+		* desensitised preview → tick → import) split the same way.
+		*
+		* Two properties are load-bearing and must not be relaxed:
+		*  - The preview carries display fields and a `hasToken` boolean only. Tokens
+		*    never enter the browser at all until the user explicitly exports a chosen
+		*    account, and the Host re-parses the file on import rather than trusting
+		*    anything this component says about it.
+		*  - Import is offered even when the region has NO account: a machine that has
+		*    never signed in is exactly where importing someone else's export matters
+		*    most. Only EXPORT needs an existing account to select.
+		*
+		* The download uses `<a download>` on a Blob because the card runs inside the
+		* settings iframe and has no host save dialog; a same-origin anchor download is
+		* the reliable path there.
+		*
+		* @module dsh-connect-trae/client/AccountTransfer
+		*/
+		/** How long the veil may wait for the card's re-read before it comes down. */
+		const REFRESH_SETTLE_TIMEOUT_MS = 5e3;
+		/** Build the default export file name: trae-accounts-YYYY-MM-DD.json. */
+		function exportFileName() {
+			const pad = (value) => String(value).padStart(2, "0");
+			const now = /* @__PURE__ */ new Date();
+			return `trae-accounts-${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}.json`;
+		}
+		/** Download a JSON value as a local file (no host save dialog inside the iframe). */
+		function downloadJson(fileName, data) {
+			const blob = new Blob([JSON.stringify(data, null, 2)], { type: "application/json" });
+			const url = URL.createObjectURL(blob);
+			const anchor = document.createElement("a");
+			anchor.href = url;
+			anchor.download = fileName;
+			document.body.appendChild(anchor);
+			anchor.click();
+			anchor.remove();
+			URL.revokeObjectURL(url);
+		}
+		/** Resolve once `value` settles, or after `timeoutMs` — whichever comes first. */
+		async function settlesWithin(value, timeoutMs) {
+			await Promise.race([Promise.resolve(value).catch(() => void 0), new Promise((resolve) => {
+				setTimeout(resolve, timeoutMs);
+			})]);
+		}
+		function AccountTransfer({ t, region, accounts, onChanged }) {
+			const [phase, setPhase] = (0, react.useState)({ kind: "idle" });
+			const [dialog, setDialog] = (0, react.useState)(void 0);
+			const [selected, setSelected] = (0, react.useState)(/* @__PURE__ */ new Set());
+			const [preview, setPreview] = (0, react.useState)(void 0);
+			const [importSelected, setImportSelected] = (0, react.useState)(/* @__PURE__ */ new Set());
+			const fileInput = (0, react.useRef)(null);
+			/**
+			* The text of the file the user just picked, held here rather than re-read
+			* from the input at import time: the picker is a bare system dialog that
+			* closes immediately, so between preview and confirm no dialog holds the
+			* File. Re-reading `fileInput.current.files` would also break the moment
+			* anything clears the input — and it must be cleared after every pick, or
+			* choosing the SAME file twice fires no change event.
+			*/
+			const importText = (0, react.useRef)("");
+			const mounted = (0, react.useRef)(true);
+			(0, react.useEffect)(() => {
+				mounted.current = true;
+				return () => {
+					mounted.current = false;
+				};
+			}, []);
+			const closeDialog = () => {
+				setDialog(void 0);
+				setSelected(/* @__PURE__ */ new Set());
+				setPreview(void 0);
+				setImportSelected(/* @__PURE__ */ new Set());
+			};
+			const runExport = async () => {
+				if (selected.size === 0) return;
+				setPhase({ kind: "exporting" });
+				try {
+					const response = await fetch(withTraeTransferAction(TRAE_TRANSFER_PATH, region, "export"), {
+						method: "POST",
+						headers: {
+							"content-type": "application/json",
+							accept: "application/json"
+						},
+						credentials: "same-origin",
+						body: JSON.stringify({ accountIds: [...selected] })
+					});
+					const body = await response.json();
+					if (!mounted.current) return;
+					if (!response.ok || !Array.isArray(body.accounts)) {
+						setPhase({
+							kind: "error",
+							message: body.error ?? `HTTP ${response.status}`
+						});
+						return;
+					}
+					const fileName = exportFileName();
+					downloadJson(fileName, body.accounts);
+					closeDialog();
+					setPhase({
+						kind: "done",
+						message: t("row.transferExported", {
+							count: body.accounts.length,
+							fileName
+						})
+					});
+				} catch (error) {
+					if (mounted.current) setPhase({
+						kind: "error",
+						message: error instanceof Error ? error.message : String(error)
+					});
+				}
+			};
+			const readImportFile = async (file) => {
+				setPhase({ kind: "importing" });
+				try {
+					const text = await file.text();
+					importText.current = text;
+					const response = await fetch(withTraeTransferAction(TRAE_TRANSFER_PATH, region, "preview"), {
+						method: "POST",
+						headers: {
+							"content-type": "application/json",
+							accept: "application/json"
+						},
+						credentials: "same-origin",
+						body: JSON.stringify({ text })
+					});
+					const body = await response.json();
+					if (!mounted.current) return;
+					if (!response.ok || !Array.isArray(body.accounts)) {
+						setPhase({
+							kind: "error",
+							message: body.error ?? `HTTP ${response.status}`
+						});
+						return;
+					}
+					setPreview(body);
+					setImportSelected(new Set(body.accounts.filter((entry) => entry.hasToken).map((entry) => entry.index)));
+					setPhase({ kind: "idle" });
+				} catch (error) {
+					if (mounted.current) setPhase({
+						kind: "error",
+						message: error instanceof Error ? error.message : String(error)
+					});
+				}
+			};
+			const runImport = async () => {
+				if (preview === void 0 || importSelected.size === 0 || importText.current === "") return;
+				setPhase({ kind: "importing" });
+				try {
+					const response = await fetch(withTraeTransferAction(TRAE_TRANSFER_PATH, region, "import"), {
+						method: "POST",
+						headers: {
+							"content-type": "application/json",
+							accept: "application/json"
+						},
+						credentials: "same-origin",
+						body: JSON.stringify({
+							text: importText.current,
+							indexes: [...importSelected]
+						})
+					});
+					const body = await response.json();
+					if (!mounted.current) return;
+					if (!response.ok || typeof body.imported !== "number") {
+						setPhase({
+							kind: "error",
+							message: body.error ?? `HTTP ${response.status}`
+						});
+						return;
+					}
+					closeDialog();
+					const message = t("row.transferImported", {
+						imported: body.imported,
+						skipped: body.skipped ?? 0
+					});
+					setPhase({
+						kind: "refreshing",
+						message
+					});
+					await settlesWithin(onChanged?.(), REFRESH_SETTLE_TIMEOUT_MS);
+					if (!mounted.current) return;
+					setPhase({
+						kind: "done",
+						message
+					});
+				} catch (error) {
+					if (mounted.current) setPhase({
+						kind: "error",
+						message: error instanceof Error ? error.message : String(error)
+					});
+				}
+			};
+			const busy = phase.kind === "exporting" || phase.kind === "importing" || phase.kind === "refreshing";
+			const veilMessage = phase.kind === "exporting" ? t("row.transferExporting") : phase.kind === "importing" || phase.kind === "refreshing" ? t("row.transferImporting") : "";
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("section", {
+				className: "dsm-trae-transfer",
+				"aria-label": t("row.transferTitle"),
+				children: [
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)(BusyOverlay, {
+						visible: busy,
+						message: veilMessage,
+						...busy ? { hint: t("row.transferVeilHint") } : {}
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+						className: "dsm-trae-transfer-label",
+						children: t("row.transferTitle")
+					}),
+					phase.kind === "done" ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+						className: "dsm-trae-transfer-status dsm-trae-transfer-ok",
+						children: phase.message
+					}) : phase.kind === "error" ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+						className: "dsm-trae-transfer-status dsm-trae-transfer-error",
+						children: t("row.transferError", { message: phase.message })
+					}) : null,
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						className: "dsm-trae-transfer-actions",
+						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+							type: "button",
+							className: "dsm-btn dsm-btn-outline",
+							disabled: busy || accounts.length === 0,
+							onClick: () => {
+								setSelected(/* @__PURE__ */ new Set());
+								setDialog("export");
+							},
+							children: t("row.transferExport")
+						}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+							type: "button",
+							className: "dsm-btn dsm-btn-outline",
+							disabled: busy,
+							onClick: () => {
+								fileInput.current?.click();
+							},
+							children: t("row.transferImport")
+						})]
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
+						ref: fileInput,
+						type: "file",
+						accept: "application/json,.json",
+						className: "dsm-trae-transfer-file",
+						onChange: (event) => {
+							const file = event.target.files?.[0];
+							event.target.value = "";
+							if (file !== void 0) {
+								setPreview(void 0);
+								setImportSelected(/* @__PURE__ */ new Set());
+								setDialog("import");
+								readImportFile(file);
+							}
+						}
+					}),
+					dialog === "export" ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						className: "dsm-trae-transfer-dialog",
+						role: "dialog",
+						"aria-label": t("row.transferExport"),
+						children: [
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", { children: t("row.transferExportPick", { total: accounts.length }) }),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+								className: "dsm-trae-hint",
+								children: t("row.transferHint")
+							}),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("ul", {
+								className: "dsm-trae-transfer-list",
+								children: accounts.map((account) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)("li", { children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("label", { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
+									type: "checkbox",
+									checked: selected.has(account.id),
+									onChange: (event) => {
+										const next = new Set(selected);
+										if (event.target.checked) next.add(account.id);
+										else next.delete(account.id);
+										setSelected(next);
+									}
+								}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", { children: account.accountName })] }) }, account.id))
+							}),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+								className: "dsm-trae-transfer-dialog-actions",
+								children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+									type: "button",
+									className: "dsm-btn",
+									disabled: selected.size === 0,
+									onClick: () => {
+										runExport();
+									},
+									children: t("row.transferExportConfirm", { count: selected.size })
+								}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+									type: "button",
+									className: "dsm-btn dsm-btn-outline",
+									onClick: closeDialog,
+									children: t("row.transferCancel")
+								})]
+							}),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+								type: "button",
+								className: "dsm-trae-transfer-link",
+								onClick: () => setSelected(new Set(accounts.map((account) => account.id))),
+								children: t("row.transferSelectAll")
+							})
+						]
+					}) : null,
+					dialog === "import" ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+						className: "dsm-trae-transfer-dialog",
+						role: "dialog",
+						"aria-label": t("row.transferImport"),
+						children: preview === void 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", { children: t("row.transferReading") }) : /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", { children: t("row.transferImportPick", { total: preview.total }) }),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("ul", {
+								className: "dsm-trae-transfer-list",
+								children: preview.accounts.map((entry) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)("li", { children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("label", { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
+									type: "checkbox",
+									checked: importSelected.has(entry.index),
+									disabled: !entry.hasToken,
+									onChange: (event) => {
+										const next = new Set(importSelected);
+										if (event.target.checked) next.add(entry.index);
+										else next.delete(entry.index);
+										setImportSelected(next);
+									}
+								}), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", { children: [
+									entry.nickname || entry.uid || t("row.transferUnnamed"),
+									entry.email === "" ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
+										className: "dsm-trae-hint",
+										children: [" · ", entry.email]
+									}),
+									entry.hasToken ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
+										className: "dsm-trae-hint",
+										children: [" · ", t("row.transferNoToken")]
+									})
+								] })] }) }, entry.index))
+							}),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+								className: "dsm-trae-transfer-dialog-actions",
+								children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+									type: "button",
+									className: "dsm-btn",
+									disabled: importSelected.size === 0,
+									onClick: () => {
+										runImport();
+									},
+									children: t("row.transferImportConfirm", { count: importSelected.size })
+								}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+									type: "button",
+									className: "dsm-btn dsm-btn-outline",
+									onClick: closeDialog,
+									children: t("row.transferCancel")
+								})]
+							})
+						] })
+					}) : null
+				]
+			});
+		}
+		//#endregion
 		//#region src/client/plan-text.ts
 		/**
 		* The international region's "what plan is this account on" text.
@@ -2246,6 +2657,21 @@ window.__ModuleLoader__.load({
 											className: "dsm-trae-usage-note",
 											role: "status",
 											children: rescanNote
+										}),
+										/* @__PURE__ */ (0, react_jsx_runtime.jsx)(AccountTransfer, {
+											t,
+											region: activeRegion,
+											accounts: status.status === "signed-in" ? status.accounts.map((account) => ({
+												id: account.id,
+												accountName: account.accountName
+											})) : [],
+											onChanged: async () => {
+												const fresh = await refreshUsage(activeRegion);
+												if (fresh !== void 0) setStatusByRegion((current) => ({
+													...current,
+													[activeRegion]: fresh
+												}));
+											}
 										})
 									]
 								}),
@@ -3225,6 +3651,25 @@ window.__ModuleLoader__.load({
 			"row.refreshing": "Refreshing…",
 			"row.accountsTitle": "Trae account",
 			"row.accountsHint": "Sign-ins detected on this machine. Tokens are never shown or saved.",
+			"row.transferTitle": "Import & export accounts",
+			"row.transferExport": "Export selected",
+			"row.transferImport": "Import from file",
+			"row.transferCancel": "Cancel",
+			"row.transferSelectAll": "Select all",
+			"row.transferExportPick": "Choose which of the {total} accounts to export.",
+			"row.transferExportConfirm": "Export {count}",
+			"row.transferExported": "Exported {count} account(s) to {fileName}.",
+			"row.transferExporting": "Preparing the export…",
+			"row.transferImportPick": "This file holds {total} record(s). Untick anything you do not want to add.",
+			"row.transferImportConfirm": "Import {count}",
+			"row.transferImported": "Imported {imported} account(s), skipped {skipped}.",
+			"row.transferImporting": "Importing…",
+			"row.transferReading": "Reading the file…",
+			"row.transferHint": "The exported file contains live tokens — treat it as a password. Records belonging to the other region are skipped.",
+			"row.transferError": "Import/export failed: {message}",
+			"row.transferVeilHint": "The account list refreshes when this finishes.",
+			"row.transferUnnamed": "Unnamed account",
+			"row.transferNoToken": "no token, will be skipped",
 			"row.accountsRescan": "Detect accounts again",
 			"row.accountsScanning": "Detecting…",
 			"row.accountsNone": "This region reports no usable account.",
@@ -3372,6 +3817,25 @@ window.__ModuleLoader__.load({
 			"row.refreshing": "正在刷新…",
 			"row.accountsTitle": "Trae 账号",
 			"row.accountsHint": "本机检测到的登录账号；Token 不会显示或保存。",
+			"row.transferTitle": "导入 / 导出账号",
+			"row.transferExport": "导出所选",
+			"row.transferImport": "从文件导入",
+			"row.transferCancel": "取消",
+			"row.transferSelectAll": "全选",
+			"row.transferExportPick": "从这 {total} 个账号中选择要导出的。",
+			"row.transferExportConfirm": "导出 {count} 个",
+			"row.transferExported": "已导出 {count} 个账号到 {fileName}。",
+			"row.transferExporting": "正在准备导出…",
+			"row.transferImportPick": "该文件包含 {total} 条记录，取消勾选不想添加的。",
+			"row.transferImportConfirm": "导入 {count} 个",
+			"row.transferImported": "已导入 {imported} 个账号，跳过 {skipped} 个。",
+			"row.transferImporting": "正在导入…",
+			"row.transferReading": "正在读取文件…",
+			"row.transferHint": "导出的文件里是有效 Token，请当作密码保管。属于另一区域的记录会被跳过。",
+			"row.transferError": "导入/导出失败：{message}",
+			"row.transferVeilHint": "完成后账号列表会自动刷新。",
+			"row.transferUnnamed": "未命名账号",
+			"row.transferNoToken": "无 Token，将被跳过",
 			"row.accountsRescan": "重新检测账号",
 			"row.accountsScanning": "正在检测…",
 			"row.accountsNone": "该区域没有可列出的账号。",

package/lib/index.d.ts

@@ -698,6 +698,22 @@ declare class TraeCredentialStore {
    * fallback, for the same reason {@link current} refuses to fall back.
    */
   credentialOf(accountId: string): Promise<TraeCredential | undefined>;
+  /**
+   * Store imported credentials (issue #37), replacing any entry with the same
+   * account id and leaving every other entry alone.
+   *
+   * Why an additive write rather than the refresh path: an imported credential
+   * has NO desktop file behind it, so unlike a refresh result it cannot be
+   * rediscovered from the machine. If it were written the way a refresh is —
+   * as the whole document — importing account B would delete account A, and a
+   * later refresh would delete both. `readAll`'s desktop-first preference is
+   * therefore also not enough on its own: these entries survive only because
+   * `readOwns` reads them back and the dedupe keeps the longest-lived copy.
+   *
+   * Returns the account ids actually written, so the caller can report how many
+   * landed without re-reading the store.
+   */
+  importAccounts(credentials: readonly Omit<TraeCredential, 'source'>[]): Promise<string[]>;
   resolve(): Promise<TraeCredential>;
   status(): Promise<{
     state: 'signed-in' | 'signed-out';

package/lib/index.js

@@ -829,6 +829,24 @@ const TRAE_ACCOUNT_STATUS_PATH = "/plugins/dsh-connect-trae/account-status";
 * account row.
 */
 const TRAE_CHECKIN_PATH = "/plugins/dsh-connect-trae/checkin";
+/**
+* Plugin-owned account transfer endpoint: batch export and import of a region's
+* stored credentials (issue #37).
+*
+* One route with an `action` query parameter (`export` | `preview` | `import`),
+* mirroring the sibling `dsh-connect-workbuddy` plugin's transfer route so the
+* two cards behave the same way for a user who has both installed. The vault
+* document never leaves the Host: the browser receives parsed answers, and a
+* preview carries display fields only — never token material.
+*/
+const TRAE_TRANSFER_PATH = "/plugins/dsh-connect-trae/transfer";
+/** Read the transfer action off a request URL; unknown/absent means undefined. */
+function transferActionOf(url) {
+	const at = url.indexOf("?");
+	if (at === -1) return void 0;
+	const value = new URLSearchParams(url.slice(at + 1)).get("action");
+	return value === "export" || value === "preview" || value === "import" ? value : void 0;
+}
 /** Query parameter naming the region a card request addresses. */
 const TRAE_REGION_PARAM = "region";
 /** Every region, in card tab order. */
@@ -1581,7 +1599,24 @@ function regionOfCredential(credential) {
 //#region src/auth.ts
 /** Host used for CLI tokens, which carry no host claim of their own. */
 const CLI_DEFAULT_HOST = "https://api.trae.cn";
-const OWN_VERSION = 1;
+/**
+* On-disk format of the plugin-owned per-region file.
+*
+* Version 1 held exactly ONE credential (`{ version, credential }`), which was
+* enough while every account came from a Trae install the plugin can discover
+* itself. Import (issue #37) breaks that assumption: a user can hold several
+* accounts as transferable files, and they have to live somewhere. Version 2
+* keeps the same per-region file but stores `{ version, credentials: [...] }`
+* instead, so the file stays the unit of region isolation (see
+* {@link traeOwnAuthPath}) while holding as many accounts as were imported.
+*
+* Version 1 remains READ (see {@link parseOwn}), so an existing install keeps
+* working and upgrades itself the next time a credential is written; it is
+* never written again.
+*/
+const OWN_VERSION = 2;
+/** The superseded single-credential layout, still read for migration. */
+const OWN_VERSION_SINGLE = 1;
 const TRAE_AUTH_FILENAME = ".trae-auth.json";
 /** Prefix of the plugin-owned per-region credential copies. */
 const TRAE_OWN_PREFIX = ".trae-auth";
@@ -1644,27 +1679,68 @@ function traeAccountId(credential) {
 	const stable = `${credential.edition}\0${credential.userId || credential.accountName || "unknown"}`;
 	return createHash("sha256").update(stable).digest("hex").slice(0, 24);
 }
+/** One stored credential, validated. Returns undefined for a malformed row. */
+function credentialOfStored(stored) {
+	if (typeof stored !== "object" || stored === null || Array.isArray(stored)) return void 0;
+	const record = stored;
+	const edition = record["edition"];
+	if (edition !== "cn" && edition !== "sg" && edition !== "solo" && edition !== "solo-sg") return void 0;
+	return normalizeTraeCredential({
+		token: record["accessToken"],
+		refreshToken: record["refreshToken"],
+		userId: record["userId"],
+		host: record["host"],
+		userRegion: record["userRegion"],
+		account: record["accountName"] === void 0 ? void 0 : { username: record["accountName"] },
+		expiredAt: record["expiresAtMs"],
+		refreshExpiredAt: record["refreshExpiredAtMs"]
+	}, edition, "dsh");
+}
+/**
+* Read the plugin-owned file into its stored credentials.
+*
+* Accepts BOTH layouts: version 2 (`credentials: [...]`, the import-capable
+* shape) and the superseded version 1 (`credential: {...}`). A version-1 file
+* keeps working until the next write upgrades it, so no migration step is
+* needed and an older install's file is never rejected. A malformed row is
+* dropped rather than failing the whole file — one bad imported account must
+* not hide the rest.
+*/
 function parseOwn(text) {
 	try {
 		const document = JSON.parse(text);
-		if (document.version !== OWN_VERSION || typeof document.credential !== "object" || document.credential === null) return void 0;
-		const stored = document.credential;
-		const edition = stored["edition"];
-		if (edition !== "cn" && edition !== "sg" && edition !== "solo" && edition !== "solo-sg") return void 0;
-		return normalizeTraeCredential({
-			token: stored["accessToken"],
-			refreshToken: stored["refreshToken"],
-			userId: stored["userId"],
-			host: stored["host"],
-			userRegion: stored["userRegion"],
-			account: stored["accountName"] === void 0 ? void 0 : { username: stored["accountName"] },
-			expiredAt: stored["expiresAtMs"],
-			refreshExpiredAt: stored["refreshExpiresAtMs"]
-		}, edition, "dsh");
+		if (document.version === OWN_VERSION) {
+			if (!Array.isArray(document.credentials)) return [];
+			return document.credentials.map(credentialOfStored).filter((value) => value !== void 0);
+		}
+		if (document.version === OWN_VERSION_SINGLE) {
+			const single = credentialOfStored(document.credential);
+			return single === void 0 ? [] : [single];
+		}
+		return [];
 	} catch {
-		return;
+		return [];
 	}
 }
+/**
+* Write the plugin-owned file: every credential of the region, in the version-2
+* array layout.
+*
+* One writer for both paths that persist to this file (a refresh, and an
+* import) so the read-modify-write in `refreshNow` and the additive write in
+* {@link TraeCredentialStore.importAccounts} cannot drift apart. Always writes
+* `OWN_VERSION`, which is what upgrades a version-1 file on its first write.
+*/
+async function writeOwn(path, credentials) {
+	const document = {
+		version: OWN_VERSION,
+		credentials: credentials.map((credential) => ({ ...credential }))
+	};
+	await writeFileAtomic(path, `${JSON.stringify(document, null, 2)}\n`, {
+		mode: 384,
+		dirMode: 448
+	});
+}
 var TraeCredentialStore = class {
 	storagePathOverride;
 	edition;
@@ -1832,6 +1908,46 @@ var TraeCredentialStore = class {
 		if (accountId === "") return void 0;
 		return (await this.readAll()).find((credential) => traeAccountId(credential) === accountId);
 	}
+	/**
+	* Store imported credentials (issue #37), replacing any entry with the same
+	* account id and leaving every other entry alone.
+	*
+	* Why an additive write rather than the refresh path: an imported credential
+	* has NO desktop file behind it, so unlike a refresh result it cannot be
+	* rediscovered from the machine. If it were written the way a refresh is —
+	* as the whole document — importing account B would delete account A, and a
+	* later refresh would delete both. `readAll`'s desktop-first preference is
+	* therefore also not enough on its own: these entries survive only because
+	* `readOwns` reads them back and the dedupe keeps the longest-lived copy.
+	*
+	* Returns the account ids actually written, so the caller can report how many
+	* landed without re-reading the store.
+	*/
+	async importAccounts(credentials) {
+		if (credentials.length === 0) return [];
+		const ownPath = this.ownAuthPath();
+		const written = [];
+		await withFileLock(ownPath, async () => {
+			const existing = await readFile(ownPath, "utf8").then(parseOwn, () => []);
+			const byId = /* @__PURE__ */ new Map();
+			for (const item of existing) byId.set(traeAccountId(item), item);
+			for (const credential of credentials) {
+				const stored = {
+					...credential,
+					source: "dsh"
+				};
+				const id = traeAccountId(stored);
+				byId.set(id, stored);
+				written.push(id);
+			}
+			await writeOwn(ownPath, [...byId.values()]);
+		});
+		if (written.length > 0) {
+			this.accountId = written[written.length - 1];
+			this.inflight = void 0;
+		}
+		return written;
+	}
 	async resolve() {
 		const credential = await this.current();
 		if (credential === void 0) throw new Error(`trae: no signed-in account found (${this.candidates().map((item) => item.path).join(" or ")})`);
@@ -1976,8 +2092,7 @@ var TraeCredentialStore = class {
 	async readOwns() {
 		const copies = [];
 		for (const path of this.ownCandidates()) try {
-			const parsed = parseOwn(await readFile(path, "utf8"));
-			if (parsed !== void 0) copies.push(parsed);
+			copies.push(...parseOwn(await readFile(path, "utf8")));
 		} catch {}
 		return copies;
 	}
@@ -1999,13 +2114,11 @@ var TraeCredentialStore = class {
 			};
 			const ownPath = this.ownAuthPath();
 			await withFileLock(ownPath, async () => {
-				await writeFileAtomic(ownPath, `${JSON.stringify({
-					version: OWN_VERSION,
-					credential: refreshed
-				}, null, 2)}\n`, {
-					mode: 384,
-					dirMode: 448
-				});
+				const existing = await readFile(ownPath, "utf8").then(parseOwn, () => []);
+				const refreshedId = traeAccountId(refreshed);
+				const entries = existing.filter((item) => traeAccountId(item) !== refreshedId);
+				entries.push(refreshed);
+				await writeOwn(ownPath, entries);
 			});
 			return refreshed;
 		} catch (error) {
@@ -2926,6 +3039,23 @@ function wireCreditMultiplier(config) {
 	if (typeof data !== "object" || data === null) return void 0;
 	return finitePositive$1(data["rate"]);
 }
+/**
+* Thrown by {@link TraeSoloUpstreamClient.fetchModels} when every requested
+* directory function answered HTTP 200 but with an EMPTY `config_info_list`
+* (no rows at all), so the aggregate roster is empty. This is issue #39's root
+* signal: the upstream has published NO SOLO function config for this account /
+* route. It is a server-side, usually transient gap — the reporter's roster
+* returned empty and later self-resolved with rows per function — NOT a local
+* credential, plugin or account fault, and not something to re-login for. The
+* caller can catch this type to tell "the upstream published no config" apart
+* from "all directory functions errored" (which surfaces as a generic failure).
+*/
+var TraeEmptySoloDirectory = class extends Error {
+	name = "TraeEmptySoloDirectory";
+	constructor() {
+		super("Trae’s server returned NO SOLO function config (an empty directory for every requested function) — an upstream-side gap that usually clears on its own; retry later instead of re-checking credentials or the plugin");
+	}
+};
 var TraeSoloUpstreamClient = class {
 	options;
 	fetchImpl;
@@ -2982,7 +3112,10 @@ var TraeSoloUpstreamClient = class {
 			this.collectModels(list, directoryFunction, byId);
 		}
 		const models = [...byId.values()];
-		if (models.length === 0) throw new Error(`Trae SOLO models response contained no models (${failures.join("; ") || "empty directory"})`);
+		if (models.length === 0) {
+			if (failures.length === 0) throw new TraeEmptySoloDirectory();
+			throw new Error(`Trae SOLO models response contained no models (${failures.join("; ")})`);
+		}
 		return models;
 	}
 	/** Merge one function's config list into the shared catalogue (first wins). */
@@ -3208,9 +3341,20 @@ function decodeTraeEvent(event) {
 *    two different statements, and a user hits the second without touching the
 *    first (issue #33).
 *  - `4023` — the model name is unknown on the route that was asked.
+*  - `2001` — the upstream has not published its function config for the route
+*    that was asked. Evidence is issue #39: on a live CN account every SOLO
+*    function's `get_detail_param` answered HTTP 200 with `config_info_list:
+*    []` (an empty directory), and each chat call failed with
+*    `{"code":2001,"message":"no function config found for appId=...,
+*    function=solo_work_remote"}` (and the variant `[LLMUtilsChat.resolveByUsage]
+*    function is empty, cannot resolve model by usage=`). The roster came back
+*    empty and then self-resolved later with rows per function, so this is a
+*    TRANSIENT server-side gap the user can wait out or retry — never a local
+*    credential, plugin or account fault, and not something to re-login for.
 */
 const TRAE_ERROR_HINTS = {
 	1005: "Trae requires a paid plan for this model; the current account's plan does not cover it",
+	2001: "Trae has not published its function config for this route (an upstream condition, not a local credential or config problem)",
 	4001: "Trae does not serve this model under the SOLO function the request used (config_name rejected)",
 	4008: "Trae reports the account's SOLO quota is exhausted for this request",
 	4011: "Trae throttled the SOLO channel for this account (a rate limit, not the credit balance)",
@@ -4796,6 +4940,268 @@ var TraeUsageClient = class {
 	}
 };
 //#endregion
+//#region src/transfer.ts
+/**
+* Account transfer: the export / import file format shared with sibling
+* credential managers for the same upstream (dsh-connect-workbuddy ships the
+* identical contract so export files interoperate).
+*
+* 参考：通行实现 —— 文件是一个 JSON 数组，每项为一条凭据记录，顶层字段
+*   snake_case（`access_token` / `refresh_token` / `uid` / `nickname` /
+*   `email` / `domain` / `expiresAt`(ms) / `refreshExpiresAt`(ms) /
+*   `auth_raw`），导入按 account id 去重（同 id 覆盖），缺 `access_token`
+*   的记录跳过；预览只回脱敏字段（含 `hasToken` 布尔量），不回明文。解析
+*   函数不依赖文件系统，便于无 UI 环境单测；落库由 Host 侧的 store 完成。
+*
+* 互通 / 单位边界：`expiresAt` 一族按契约是**毫秒**。workbuddy 的 vault 文档
+*   存的是秒，需要在导出/导入边界换算；trae 的 `TraeCredential.expiresAtMs`
+*   （见 auth.ts 的 `timeToMs`）**本身就是毫秒**，所以这里**不做任何
+*   乘除**——刻意与 workbuddy 不同，读者对比两文件时不要误以为换算被漏掉了。
+*   导出时 `auth_raw` 直接携带原始认证文档（桌面 storage 文档或 `{auth,
+*   account}` 双键块），供写入桌面认证文件的工具原样消费。
+*
+* @module dsh-connect-trae/transfer
+*/
+/**
+* Parse transfer-file text: a JSON array, every element an object.
+*
+* The error strings carry the position (1-based item number) because a file
+* from another tool can be big, and "第 N 项" is what lets the user find the
+* broken record in their editor.
+*/
+function parseTransferFile(text) {
+	if (text.trim() === "") throw new Error("transfer file is empty");
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch (error) {
+		throw new Error("transfer file is not valid JSON: " + (error instanceof Error ? error.message : String(error)));
+	}
+	if (!Array.isArray(parsed)) throw new Error("transfer file must be a JSON array of account records");
+	for (const [index, item] of parsed.entries()) if (typeof item !== "object" || item === null || Array.isArray(item)) throw new Error("transfer file item " + (index + 1) + " is not an account object");
+	return parsed;
+}
+/** One string field of a record, tolerating the sibling format's odd shapes. */
+function displayString(value) {
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	return "";
+}
+/** Whether a record carries a usable token (a non-empty string). */
+function hasToken(record) {
+	const token = record["access_token"];
+	return typeof token === "string" && token !== "";
+}
+/**
+* The transfer file's desensitized preview: display fields only.
+*
+* Fields come from EXTERNAL files, so a display field may hold an object or an
+* array (a sibling tool can store the desktop app's encrypted-wrapper nickname
+* verbatim); every preview field is normalized to a string or emptied rather
+* than letting a non-renderable value reach the card.
+*/
+function previewTransferFile(text) {
+	const records = parseTransferFile(text);
+	return {
+		accounts: records.map((record, index) => ({
+			index,
+			uid: displayString(record["uid"]),
+			nickname: displayString(record["nickname"]),
+			email: displayString(record["email"]),
+			hasToken: hasToken(record)
+		})),
+		total: records.length
+	};
+}
+/**
+* Positive-match region claim for an IMPORTED record: the record's own
+* `userRegion` claim wins, the host suffix is the fallback, and anything
+* unrecognised (empty, misspelt, or other-region) yields `undefined` — never a
+* default.
+*
+* This is the security-critical difference from `regionOfCredential`, which
+* classifies anything unrecognised as `cn` as a last resort (via the edition
+* label). That fallback is right for upstream-sourced data, whose host/region
+* came out of the real Trae install, but wrong for an import whose values are
+* simply whatever the file's author wrote: a spoofed or misspelt `domain`
+* would otherwise be admitted into the CN vault and cross-bill the CN provider
+* stack with a credential that belongs to no real CN account. So this helper
+* reuses `regionOfUserRegion` / `regionOfHost` — both of which already return
+* `undefined` on unrecognised input — and deliberately does NOT consult the
+* edition fallback.
+*/
+function knownRegionOfCredential(credential) {
+	return regionOfUserRegion(credential.userRegion) ?? regionOfHost(credential.host);
+}
+/**
+* Project one credential into the shared transfer record shape.
+*
+* `expiresAt` / `refreshExpiresAt` are emitted in epoch MILLISECONDS — the
+* transfer contract's unit. Unlike workbuddy — whose vault stored seconds and
+* had to convert here — trae's `expiresAtMs` is already milliseconds, so the
+* value is carried through verbatim (documented above; do not rescale).
+* `auth_raw` carries the original auth document so a tool that writes desktop
+* auth files can consume it verbatim.
+*/
+function traeTransferRecordOf(credential, authRawDocument) {
+	return {
+		access_token: credential.accessToken,
+		...credential.refreshToken !== void 0 && credential.refreshToken !== "" ? { refresh_token: credential.refreshToken } : {},
+		...credential.userId !== "" ? { uid: credential.userId } : {},
+		...credential.accountName !== void 0 ? { nickname: credential.accountName } : {},
+		...credential.host !== "" ? { domain: credential.host } : {},
+		...credential.expiresAtMs > 0 ? { expiresAt: credential.expiresAtMs } : {},
+		...credential.refreshExpiresAtMs === void 0 ? {} : { refreshExpiresAt: credential.refreshExpiresAtMs },
+		auth_raw: authRawDocument
+	};
+}
+/** The `userId` claim from a record: the flat `uid`, else recovered from `auth_raw`. */
+function userIdOfRaw(record) {
+	const flat = displayString(record["uid"]);
+	if (flat !== "") return flat;
+	const root = rawRoot(record["auth_raw"]);
+	if (root === void 0) return "";
+	return displayString(root["userId"]) ?? "";
+}
+/** The `accountName` claim: the flat `nickname`, else recovered from `auth_raw`. */
+function accountNameOfRaw(record) {
+	const flat = displayString(record["nickname"]);
+	if (flat !== "") return flat;
+	const root = rawRoot(record["auth_raw"]);
+	if (root === void 0) return void 0;
+	const fromAccount = displayString((typeof root["account"] === "object" && root["account"] !== null ? root["account"] : void 0)?.["username"]);
+	if (fromAccount !== "") return fromAccount;
+	return displayString(root["username"]);
+}
+/** The raw `userRegion` claim string from `auth_raw` (object `{region}` or bare value). */
+function userRegionOfRaw(raw) {
+	const root = rawRoot(raw);
+	if (root === void 0) return void 0;
+	const value = root["userRegion"];
+	const claim = typeof value === "object" && value !== null && !Array.isArray(value) ? value["region"] : value;
+	return typeof claim === "string" && claim.trim() !== "" ? claim.trim() : void 0;
+}
+/**
+* A record's `auth_raw` root, tolerating both the nested `{auth, account}` block
+* this plugin exports and a raw desktop storage document: `account` may be a
+* sub-object (the block shape) or absent (flat document shape).
+*/
+function rawRoot(raw) {
+	if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return void 0;
+	return raw;
+}
+/**
+* Edition derived from an imported record's `domain` host, positively.
+*
+* The shared transfer format has no edition field (only `domain`), so a
+* re-import must re-derive the routing label from the host. Only the two base
+* editions are ever assigned — a flat `domain` + `uid` cannot distinguish the
+* SOLO variants — so this is inherently lossy for SOLO accounts; that is
+* acceptable because the region gate (see `mergeTransferRecords`) never
+* consults edition, and the account id's edition component only affects whether
+* a re-imported account converges on the same stored id (which it does as long
+* as the host is positively classified).
+*/
+function editionOfDomain(host) {
+	const region = regionOfHost(host);
+	if (region === "ai") return "sg";
+	if (region === "cn") return "cn";
+}
+/**
+* Project one transfer record into a credential, or undefined when the record
+* carries no token (the importer's skip rule).
+*
+* `userId` empty is tolerated at THIS layer because a token-only record still
+* describes a usable credential; the Host's region gate decides whether it is
+* representable, and the store's account id (`edition \0 userId || accountName`)
+* decides whether it is addressable. An unopenable `auth_raw` is ignored — the
+* flat fields are the contract, `auth_raw` is extra fidelity for the write-back
+* path.
+*
+* `edition` is restored positively from the domain host (see `editionOfDomain`),
+* defaulting to `cn` ONLY as a neutral placeholder when the host is not
+* classifiable — this is safe because the region gate never consults edition,
+* and such a record is always `skipped` there before edition could matter.
+*/
+function credentialOfTransferRecord(record) {
+	const accessToken = record["access_token"];
+	if (typeof accessToken !== "string" || accessToken === "") return void 0;
+	const refreshToken = typeof record["refresh_token"] === "string" ? record["refresh_token"] : "";
+	const expiresAtMs = typeof record["expiresAt"] === "number" && Number.isFinite(record["expiresAt"]) && record["expiresAt"] > 0 ? record["expiresAt"] : 0;
+	const refreshExpiresAtMs = typeof record["refreshExpiresAt"] === "number" && Number.isFinite(record["refreshExpiresAt"]) && record["refreshExpiresAt"] > 0 ? record["refreshExpiresAt"] : void 0;
+	const userId = userIdOfRaw(record);
+	const accountName = accountNameOfRaw(record);
+	const host = typeof record["domain"] === "string" ? record["domain"] : "";
+	const edition = editionOfDomain(host) ?? "cn";
+	const userRegion = userRegionOfRaw(record["auth_raw"]);
+	return {
+		accessToken,
+		...refreshToken === "" ? {} : { refreshToken },
+		userId,
+		...accountName === void 0 ? {} : { accountName },
+		host,
+		...userRegion === void 0 ? {} : { userRegion },
+		expiresAtMs,
+		...refreshExpiresAtMs === void 0 ? {} : { refreshExpiresAtMs },
+		edition
+	};
+}
+/** Default gate so the merge is secure even when the caller omits the judge. */
+const defaultRegionJudge = knownRegionOfCredential;
+/**
+* Pure merge: fold selected records into a CHANGES map keyed by account id.
+*
+* Mirrors the sibling merger's contract: a record with the same account id
+* OVERWRITES the stored entry (the imported tokens replace what is stored —
+* re-importing a re-login must refresh it; the write layer stores the record
+* atomically, so "overwrite" needs no knowledge of the incumbent), and a
+* record without a token is skipped. The region gate lives HERE rather than in
+* the route so it is testable without a Host.
+*
+* The region gate is a POSITIVE match: a record is kept only when its OWN
+* region claim is positively known to equal the target region. `regionOfCredential`
+* classifies anything unrecognised as `cn`, which is fine for upstream-sourced
+* data but WRONG for an imported file whose host/region are author-controlled —
+* a spoofed or misspelt value would otherwise be admitted into the CN vault.
+* Here the injected `knownRegionOfCredential` (defaulting to the exported
+* positive-match helper, which never consults the edition fallback) returns
+* `undefined` for an empty, unrecognised, or other-region claim, and such a
+* record counts as `skipped` rather than being silently imported cross-region.
+*
+* The caller writes one store file per map entry, so a selection that is
+* already stored rewrites those files with identical content — idempotent,
+* and the steady state of importing the same file twice.
+*/
+function mergeTransferRecords(records, indexes, region, knownRegionOfCredential = defaultRegionJudge) {
+	const changes = /* @__PURE__ */ new Map();
+	let imported = 0;
+	let skipped = 0;
+	for (const index of indexes) {
+		const record = records[index];
+		if (record === void 0) {
+			skipped += 1;
+			continue;
+		}
+		const credential = credentialOfTransferRecord(record);
+		if (credential === void 0) {
+			skipped += 1;
+			continue;
+		}
+		if (knownRegionOfCredential(credential) !== region) {
+			skipped += 1;
+			continue;
+		}
+		const id = traeAccountId(credential);
+		changes.set(id, credential);
+		imported += 1;
+	}
+	return {
+		changes,
+		imported,
+		skipped
+	};
+}
+//#endregion
 //#region src/web-status.ts
 /**
 * The upstream's business code for "该设备今日已参与签到" — this DEVICE already
@@ -4880,6 +5286,35 @@ async function readAccountBody(req) {
 	if (typeof accountId !== "string" || accountId.trim() === "") throw new Error("body must carry an accountId string");
 	return accountId.trim();
 }
+/**
+* Read a transfer-file POST body: the raw file TEXT plus the record indexes the
+* user selected, or (for `export`) the account ids to include.
+*
+* The ceiling is much larger than the other readers' because this body IS a
+* user-chosen file rather than a couple of ids — a credential export from a
+* sibling tool can legitimately be hundreds of kilobytes. It is still bounded so
+* a malformed or hostile request cannot make the Host buffer without limit.
+*/
+async function readTransferBody(req) {
+	const chunks = [];
+	let size = 0;
+	for await (const chunk of req) {
+		const buffer = chunk;
+		size += buffer.byteLength;
+		if (size > 4194304) throw new Error("request body too large");
+		chunks.push(buffer);
+	}
+	const text = Buffer.concat(chunks).toString("utf8").trim();
+	if (text === "") return {};
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch {
+		throw new Error("invalid JSON body");
+	}
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new Error("body must be a JSON object");
+	return parsed;
+}
 /** Loopback browser origins only; other devices are refused until trusted origins exist. */
 function loopbackOrigin(req) {
 	const origin = req.headers.origin;
@@ -5250,6 +5685,67 @@ function registerTraeUsageRoute(ctx, deps) {
 				}
 			}
 		});
+		/**
+		* Batch credential export / import (issue #37).
+		*
+		* The Host owns every byte of the credential store; the browser only receives
+		* parsed answers. `preview` necessarily returns identifiers the card shows
+		* (uid / nickname / email) plus a `hasToken` boolean — never a token — and
+		* `import` re-parses the file server-side rather than trusting the preview,
+		* so a tampered browser cannot smuggle in a record the preview never showed.
+		*/
+		const disposeTransfer = ctx.webServer.register({
+			kind: "exact",
+			path: TRAE_TRANSFER_PATH,
+			handler: async (req, res) => {
+				if (req.method !== "POST") return json(res, 405, { error: "method not allowed" });
+				if (!loopbackOrigin(req)) return json(res, 403, { error: "origin-not-trusted" });
+				const region = requestRegion(req, res);
+				if (region === void 0) return;
+				const action = transferActionOf(req.url ?? "");
+				if (action === void 0) return json(res, 400, { error: "unknown transfer action" });
+				try {
+					const body = await readTransferBody(req);
+					if (action === "export") {
+						const wanted = new Set(Array.isArray(body["accountIds"]) ? body["accountIds"].filter((id) => typeof id === "string") : []);
+						const store = deps.store(region);
+						const records = [];
+						for (const account of await store.accounts()) {
+							if (!wanted.has(account.id)) continue;
+							const credential = await store.credentialOf(account.id).catch(() => void 0);
+							if (credential === void 0) continue;
+							records.push(traeTransferRecordOf(credential, {
+								auth: {
+									accessToken: credential.accessToken,
+									...credential.refreshToken === void 0 ? {} : { refreshToken: credential.refreshToken },
+									expiresAt: credential.expiresAtMs > 0 ? Math.floor(credential.expiresAtMs / 1e3) : 0,
+									...credential.refreshExpiresAtMs === void 0 ? {} : { refreshExpiresAt: Math.floor(credential.refreshExpiresAtMs / 1e3) },
+									host: credential.host,
+									...credential.userRegion === void 0 ? {} : { userRegion: credential.userRegion }
+								},
+								account: {
+									userId: credential.userId,
+									...credential.accountName === void 0 ? {} : { username: credential.accountName },
+									edition: credential.edition
+								}
+							}));
+						}
+						return json(res, 200, { accounts: records });
+					}
+					const text = typeof body["text"] === "string" ? body["text"] : "";
+					if (action === "preview") return json(res, 200, previewTransferFile(text));
+					const indexes = Array.isArray(body["indexes"]) ? body["indexes"].filter((index) => typeof index === "number" && Number.isInteger(index)) : [];
+					const { changes, imported, skipped } = mergeTransferRecords(parseTransferFile(text), indexes, region);
+					if (changes.size > 0) await deps.store(region).importAccounts([...changes.values()]);
+					json(res, 200, {
+						imported,
+						skipped
+					});
+				} catch (error) {
+					json(res, 400, { error: safeMessage(error) });
+				}
+			}
+		});
 		const disposeRefresh = ctx.webServer.register({
 			kind: "exact",
 			path: TRAE_MODELS_REFRESH_PATH,
@@ -5387,6 +5883,7 @@ function registerTraeUsageRoute(ctx, deps) {
 		return () => {
 			disposeCheckin();
 			disposeRefresh();
+			disposeTransfer();
 			disposeModelsTest();
 			disposeAccounts();
 			disposeAccountCredits();

package/package.json

@@ -2,7 +2,7 @@
   "name": "dsh-connect-trae",
   "displayName": "DSH Connect Trae",
   "description": "把本机登录的 Trae 模型接入 DeepSeek Harness：国内版与国际版双供应商并行，提供用量/积分概览与每日签到领取。",
-  "version": "3.5.1",
+  "version": "3.6.0",
   "author": "dingminhua",
   "copyright": "Copyright (c) 2026 LaoDing",
   "license": "MIT",