dsh-remote-bridge 2.6.0 → 2.7.0

package/lib/index.js

@@ -19,6 +19,23 @@ const DEVICE_SCOPES = [
 	"settings.read",
 	"settings.write"
 ];
+/**
+* 授予新设备时的默认权限（**五个非破坏性权限**）。
+*
+* 刻意不含 `files.delete` 与 `settings.write`：这两个是破坏性权限，应当是用户显式
+* 要求才授予。`settings.write` 尤其危险 —— 拿到它就能改供应商 `baseURL`，把模型
+* 请求连同真实凭据引到任意地址（SEC-H11），所以它绝不能是默认值。
+*
+* 三条路径必须共用这一份，否则「同一个产品里三处默认权限不一样」这种缺陷会反复
+* 复发：服务端生成配置文本时的缺省、Web UI 配对码面板的初始勾选、隧道一键路径。
+*/
+const DEFAULT_DEVICE_SCOPES = [
+	"chat.read",
+	"chat.write",
+	"files.read",
+	"files.write",
+	"settings.read"
+];
 const ADMIN_PRINCIPAL = {
 	kind: "admin",
 	id: "loopback-admin",
@@ -26,6 +43,164 @@ const ADMIN_PRINCIPAL = {
 	rootIds: "all"
 };
 //#endregion
+//#region src/host/device-identity.ts
+/**
+* 设备身份的自动识别：从请求头推断「这是台什么设备」。
+*
+* ## 为什么需要它
+*
+* 起因（用户 2026-10-23 反馈）：鸿蒙手机在设备表里被登记成「Android 设备」。
+* 根因是配置文本路径的 `deviceName` 缺省值硬编码成 `'Android 设备'` ——
+* 那条路径**在生成配置文本时**就把设备行写进库了，而那时桥对「将来谁来用
+* 这个令牌」一无所知。桌面端/隧道一键生成的配置全顶包这个名字，设备表里
+* 躺着 8 条一模一样的「Android 设备」，谁也认不出谁。
+*
+* 正确的时序是「先有连接，再有身份」：配对时桥只知道「有个设备要连」，
+* 真正的平台与型号要等设备**第一次发请求**时才知道。所以这里做两件事：
+*
+* 1. 定义一个结构化上报头（`X-Dsh-Device: <platform>/<model>`），客户端
+*    愿意报就报 —— 这是唯一准确的信息源。
+* 2. 客户端没报时，从 `User-Agent` 兜底推断平台。型号在 UA 里常常拿不到，
+*    拿不到就**留空**，不猜。
+*
+* ## 为什么不用 UA 硬解析型号
+*
+* okhttp（安卓）与 ArkWeb（鸿蒙）默认 UA 里都**没有**机型。硬从 UA 抠一个
+* 型号出来只会得到错的东西，而错的型号比没有型号更糟：用户会以为那是真的。
+* 所以 UA 只用于判平台，型号只认结构化上报。
+*
+* ## 安全边界
+*
+* 这两个字段是**客户端自称**的，不是可信身份。它们只用于界面显示与排查，
+* 绝不参与任何授权判断（授权只看 `scopes` / `rootIds`）。因此这里对长度与
+* 字符集做裁剪（防止往界面里塞控制字符或超长串），但不做「验真」。
+*/
+/** 已知平台。`unknown` 表示「认出来了但不属于下面任何一个」，不是「没认出来」。 */
+const DEVICE_PLATFORMS = [
+	"android",
+	"harmonyos",
+	"ios",
+	"ipados",
+	"web",
+	"windows",
+	"macos",
+	"linux"
+];
+/** 型号的最大长度。超过就截断 —— 它只用于显示，不需要完整。 */
+const MAX_MODEL_LENGTH = 60;
+/** 结构化上报头。格式 `platform/model`，model 可省。 */
+const DEVICE_HEADER = "x-dsh-device";
+/**
+* 配对时设备名的占位值。
+*
+* **刻意平台无关**：此前这里（以及隧道路径）硬编码成 `'Android 设备'`，于是
+* 鸿蒙、iOS、桌面上配对的设备全被登记成安卓。桥在生成配置文本时根本不知道
+* 将来是谁来用这个令牌，所以占位名不该声称任何平台。
+*
+* 与 `database.ts` 的 `exchangePairing` 兜底（`'Mobile device'`）取同一个值：
+* 两条路都是「我还不知道这是啥」，不该给出两个不同的说法。
+*
+* 这个占位名会被标记为 `nameSource: 'default'`，设备第一次带身份连上来时
+* 自动换成「平台 · 型号」—— 所以它通常只在设备表里短暂出现。
+*/
+const DEFAULT_DEVICE_NAME = "Mobile device";
+function isPlatform(value) {
+	return DEVICE_PLATFORMS.includes(value);
+}
+/**
+* 清洗型号：去掉控制字符、压缩空白、裁剪长度。
+*
+* 不做 HTML 转义 —— 那是渲染层的事，在这一层转义会让「存进库里的值与
+* 客户端报的不一样」，排查时反而更难对上。React 默认转义文本节点。
+*/
+function cleanModel(raw) {
+	const stripped = raw.replace(/[\u0000-\u001f\u007f]/g, " ").replace(/\s+/g, " ").trim();
+	if (stripped === "") return void 0;
+	return stripped.length > MAX_MODEL_LENGTH ? stripped.slice(0, MAX_MODEL_LENGTH) : stripped;
+}
+/**
+* 从结构化上报头解析。
+*
+* 格式宽松：`android/Pixel 9`、`harmonyos`（只报平台）、`harmonyos/ICL-AL10`。
+* 平台必须在白名单里，否则整条丢弃 —— 一个自造的 `platform` 值会让界面
+* 显示一个不存在的平台标签，不如不显示。
+*/
+function parseDeviceHeader(raw) {
+	if (raw === void 0) return {};
+	const value = raw.trim();
+	if (value === "") return {};
+	const slash = value.indexOf("/");
+	const platform = (slash === -1 ? value : value.slice(0, slash)).trim().toLowerCase();
+	if (!isPlatform(platform)) return {};
+	const model = slash === -1 ? void 0 : cleanModel(value.slice(slash + 1));
+	return model === void 0 ? { platform } : {
+		platform,
+		model
+	};
+}
+/**
+* 从 User-Agent 兜底推断平台。
+*
+* 顺序有讲究：鸿蒙的 UA 里同时含 `Linux` 与 `Android`（兼容串），必须先判
+* 鸿蒙再判安卓，否则鸿蒙会被认成安卓 —— 那正是这次要修的那个错误。
+*/
+function parseUserAgent(raw) {
+	if (raw === void 0) return {};
+	const ua = raw.trim();
+	if (ua === "") return {};
+	if (/harmonyos|openharmony|arkweb/i.test(ua)) return { platform: "harmonyos" };
+	if (/ipad/i.test(ua)) return { platform: "ipados" };
+	if (/iphone|ipod/i.test(ua)) return { platform: "ios" };
+	const android = /android[^;)]*;\s*([^;)]+?)\s*[;)]/i.exec(ua);
+	if (/android/i.test(ua)) {
+		const model = android === null ? void 0 : cleanModel(android[1] ?? "");
+		return model === void 0 ? { platform: "android" } : {
+			platform: "android",
+			model
+		};
+	}
+	if (/windows nt/i.test(ua)) return { platform: "windows" };
+	if (/macintosh|mac os x/i.test(ua)) return { platform: "macos" };
+	if (/x11|linux/i.test(ua)) return { platform: "linux" };
+	return {};
+}
+/**
+* 解析一次请求的设备身份。结构化头优先，UA 只补缺。
+*
+* 「补缺」而不是「合并」：客户端明确报了 `harmonyos` 时，UA 里那个兼容用的
+* `Android` 不该把它盖掉。
+*/
+function parseDeviceIdentity(headers) {
+	const header = headers[DEVICE_HEADER];
+	const declared = parseDeviceHeader(Array.isArray(header) ? header[0] : header);
+	const fallback = parseUserAgent(Array.isArray(headers["user-agent"]) ? headers["user-agent"][0] : headers["user-agent"]);
+	return {
+		...declared.platform !== void 0 ? { platform: declared.platform } : fallback.platform === void 0 ? {} : { platform: fallback.platform },
+		...declared.model !== void 0 ? { model: declared.model } : fallback.model === void 0 ? {} : { model: fallback.model }
+	};
+}
+/**
+* 用探测到的身份拼一个设备显示名，格式 `平台 · 型号`（与用户手工改的
+* `HarmonyOS · ICL-AL10` 一致）。拿不到平台时返回 `undefined` —— 调用方
+* 应当保留原名字，而不是塞一个更糟的占位。
+*/
+function describeDevice(identity) {
+	const platform = identity.platform;
+	if (platform === void 0) return void 0;
+	const label = PLATFORM_LABEL[platform];
+	return identity.model === void 0 ? label : `${label} · ${identity.model}`;
+}
+const PLATFORM_LABEL = {
+	android: "Android",
+	harmonyos: "HarmonyOS",
+	ios: "iOS",
+	ipados: "iPadOS",
+	web: "Web",
+	windows: "Windows",
+	macos: "macOS",
+	linux: "Linux"
+};
+//#endregion
 //#region src/host/errors.ts
 var ApiError = class extends Error {
 	status;
@@ -563,15 +738,37 @@ var AuthService = class {
 			this.authFailuresByPeer[peer].consume(key);
 			throw new ApiError(401, "TOKEN_INVALID", "The device token is invalid or revoked.");
 		}
+		const renamed = this.recordIdentity(req, device);
 		return {
 			kind: "device",
 			id: device.id,
-			name: device.name,
+			name: renamed ?? device.name,
 			scopes: new Set(device.scopes),
 			rootIds: new Set(device.rootIds)
 		};
 	}
 	/**
+	* 把本次请求探测到的身份记进库，并（在允许时）更新设备显示名。
+	*
+	* 吞掉一切异常的理由见调用点注释：设备名是显示信息，不该成为连接的前置条件。
+	*
+	* @returns 改名成功时的新名字；没改名（或探测不到）时 `undefined`。
+	*/
+	recordIdentity(req, device) {
+		try {
+			const identity = parseDeviceIdentity(req.headers);
+			if (identity.platform === void 0 && identity.model === void 0) return void 0;
+			const suggestedName = describeDevice(identity);
+			return this.database.recordDeviceIdentity(device.id, {
+				...identity.platform === void 0 ? {} : { platform: identity.platform },
+				...identity.model === void 0 ? {} : { model: identity.model },
+				...suggestedName === void 0 ? {} : { suggestedName }
+			}) ? suggestedName : void 0;
+		} catch {
+			return;
+		}
+	}
+	/**
 	* `/manage/**` 的守门人。
 	*
 	* @param options.allowTunnelMode - 只有「隧道状态下读/停隧道」这几个端点会传 true。
@@ -2551,6 +2748,92 @@ function readArchivedSessionIds(registry) {
 	return value.filter((item) => typeof item === "string");
 }
 /**
+* 容量元数据的缓存寿命。
+*
+* 与内核 `dsh-llm` 的 `DEFAULT_MODELS_MAX_AGE_MS = 600000` 对齐：那边是模型
+* **列表**的新鲜度，这边是**单个模型容量**的新鲜度，同一批配置变动（改
+* baseURL、换 API key、升级内核）会同时让两者失效，跟齐一个数量级最不容易
+* 出现「列表变了容量没变」的错配。
+*/
+const MODEL_CAPACITY_TTL_MS = 6e5;
+/** 缓存条目上限；只是防内存无界，正常部署里 provider×model 远小于这个数。 */
+const MODEL_CAPACITY_CACHE_LIMIT = 512;
+const modelCapacityCache = /* @__PURE__ */ new Map();
+/**
+* 把一个模型条目的容量字段补齐。
+*
+* **为什么不能直接从 `modelCatalog()` 拿**：0.2.x 的 `ModelCatalogModel` 只有
+* `{ id, name, description?, reasoning? }` —— 目录里没有 `contextWindow` /
+* `maxTokens` / `inputModalities`。这三个只在 `LlmResolvedModelInfo` 里，得走
+* `llm.resolveModelInfo(provider, model)`。目录条目自带容量是 1.x 的旧形状。
+*
+* 失败一律退回「不填」：模型选择器少显示一行容量，比整张目录报错好得多。
+* 注意**不缓存失败**——一次瞬时 RPC 抖动不该让某个模型十分钟没有容量。
+*/
+async function modelCapacityOf(host, provider, model, signal) {
+	const key = `${provider}\u0000${model}`;
+	const cached = modelCapacityCache.get(key);
+	if (cached !== void 0 && Date.now() - cached.at < MODEL_CAPACITY_TTL_MS) return cached.capacity;
+	let capacity = {};
+	try {
+		const info = await host.llm.resolveModelInfo(provider, model, signal);
+		const contextWindow = info?.context?.contextWindow;
+		const maxTokens = info?.defaultMaxTokens;
+		capacity = {
+			...typeof contextWindow === "number" && contextWindow > 0 ? { contextWindow } : {},
+			...typeof maxTokens === "number" && maxTokens > 0 ? { maxTokens } : {}
+		};
+	} catch {
+		return {};
+	}
+	if (modelCapacityCache.size >= MODEL_CAPACITY_CACHE_LIMIT) {
+		const oldest = modelCapacityCache.keys().next();
+		if (oldest.done !== true) modelCapacityCache.delete(oldest.value);
+	}
+	modelCapacityCache.set(key, {
+		at: Date.now(),
+		capacity
+	});
+	return capacity;
+}
+/**
+* 给一张 provider group 列表补容量字段。
+*
+* 并发查而不是串行：目录动辄几十个模型，串行 RPC 会把模型选择器拖成几秒空白。
+* 单个模型失败不影响其他模型（`modelCapacityOf` 内部吞掉）。
+*
+* 对**形状**宽容：`groups` 是 `unknown`（内核给什么形状就是什么形状，我们只
+* 投影自己认识的字段），认不出来的条目原样透传，保证向前兼容。
+*/
+async function enrichModelGroups(host, groups, signal) {
+	return Promise.all(groups.map(async (group) => {
+		if (typeof group !== "object" || group === null) return group;
+		const view = group;
+		const providerId = typeof view.id === "string" ? view.id : void 0;
+		if (providerId === void 0 || !Array.isArray(view.models)) return group;
+		const models = await Promise.all(view.models.map(async (model) => {
+			if (typeof model !== "object" || model === null) return model;
+			const entry = model;
+			const modelId = typeof entry.id === "string" ? entry.id : void 0;
+			if (modelId === void 0) return model;
+			const capacity = await modelCapacityOf(host, providerId, modelId, signal);
+			const filled = {
+				...entry.contextWindow === void 0 && capacity.contextWindow !== void 0 ? { contextWindow: capacity.contextWindow } : {},
+				...entry.maxTokens === void 0 && capacity.maxTokens !== void 0 ? { maxTokens: capacity.maxTokens } : {}
+			};
+			if (filled.contextWindow === void 0 && filled.maxTokens === void 0) return model;
+			return {
+				...model,
+				...filled
+			};
+		}));
+		return {
+			...group,
+			models
+		};
+	}));
+}
+/**
 * Build the `apiProxy` replacement out of 0.2.x host services.
 *
 * Every method keeps the old `{ rpcId, payload }` request shape and the old
@@ -2745,10 +3028,12 @@ function createDsh02ApiProxy(host, options = {}) {
 				} catch {}
 				const catalog = await host.sessionController.modelCatalog();
 				const selection = (await host.sessionController.projections({ sessionId }, signal))?.values?.["modelSelection"];
+				const current = selection?.next ?? selection?.lastUsed ?? catalog.default;
+				const groups = Array.isArray(catalog.groups) ? catalog.groups : [];
 				return {
-					current: selection?.next ?? selection?.lastUsed ?? catalog.default,
+					current,
 					routable: Array.isArray(catalog.routableProviders) && catalog.routableProviders.length > 0,
-					groups: Array.isArray(catalog.groups) ? catalog.groups : [],
+					groups: await enrichModelGroups(host, groups, signal),
 					failures: Array.isArray(catalog.failures) ? catalog.failures.map((entry) => ({
 						provider: typeof entry.id === "string" ? entry.id : String(entry.name ?? ""),
 						message: typeof entry.message === "string" ? entry.message : ""
@@ -2909,7 +3194,7 @@ function createDsh02ApiProxy(host, options = {}) {
 			models: () => call("llm.models", async (signal) => {
 				const view = await host.sessionController.modelCatalog();
 				return {
-					groups: Array.isArray(view.groups) ? view.groups : [],
+					groups: await enrichModelGroups(host, Array.isArray(view.groups) ? view.groups : [], signal),
 					failures: Array.isArray(view.failures) ? view.failures : []
 				};
 			}),
@@ -2926,7 +3211,7 @@ function createDsh02ApiProxy(host, options = {}) {
 }
 //#endregion
 //#region src/shared/version.ts
-const PLUGIN_VERSION = "2.6.0";
+const PLUGIN_VERSION = "2.7.0";
 //#endregion
 //#region src/host/capabilities.ts
 /**
@@ -3000,6 +3285,7 @@ const BRIDGE_CAPABILITIES = [
 	"model-catalog-v1",
 	"plugin-inventory-v1",
 	"plugin-toggle-v1",
+	"settings-namespaces-v1",
 	"approvals-v1",
 	"questions-v1",
 	"turn-failure-v1",
@@ -3440,9 +3726,10 @@ var DshChatAdapter = class {
 	}
 	async createSessionInWorkspace(principal, workspaceId, options) {
 		if ((await this.listWorkspaces(principal)).find((item) => item.id === workspaceId) === void 0) throw new ApiError(404, "WORKSPACE_NOT_FOUND", "The DSH workspace is not visible to this device.");
+		const sessionId = options.sessionId ?? (options.reuseBlank === false ? void 0 : await this.blankSessionInWorkspace(workspaceId, options.agentPreset));
 		const payload = {
 			workspaceId,
-			...options.sessionId === void 0 ? {} : { sessionId: options.sessionId },
+			...sessionId === void 0 ? {} : { sessionId },
 			...options.agentPreset === void 0 ? {} : { agentPreset: options.agentPreset }
 		};
 		const value = unwrapDsh(await this.api.sessions.create({
@@ -3455,9 +3742,11 @@ var DshChatAdapter = class {
 		};
 	}
 	async createSession(principal, rootId, relativePath, options) {
+		const resolved = await resolveAuthorizedPath(this.requireAuthorizedRoot(principal, rootId).realPath, relativePath);
+		const sessionId = options.sessionId ?? (options.reuseBlank === false ? void 0 : await this.blankSessionAtPath(resolved.absolutePath, options.agentPreset));
 		const payload = {
-			cwd: (await resolveAuthorizedPath(this.requireAuthorizedRoot(principal, rootId).realPath, relativePath)).absolutePath,
-			...options.sessionId === void 0 ? {} : { sessionId: options.sessionId },
+			cwd: resolved.absolutePath,
+			...sessionId === void 0 ? {} : { sessionId },
 			...options.agentPreset === void 0 ? {} : { agentPreset: options.agentPreset }
 		};
 		const value = unwrapDsh(await this.api.sessions.create({
@@ -3469,6 +3758,69 @@ var DshChatAdapter = class {
 			...value.agentPreset === void 0 ? {} : { agentPreset: value.agentPreset }
 		};
 	}
+	/**
+	* 挑一个可复用的空白会话 —— DSH 0.2.1 起桌面端的「New Session 回到空白会话」语义。
+	*
+	* **内核自己不做这件事。** `sessionController.create` 只有调用方显式传了 `sessionId`
+	* 才会走 `claim` / `reuseLive` 去复用；不传就无条件 `createMinted` 新建一个。
+	* 「跳过 preset 不匹配的空白会话」那层挑选写在**客户端**（`dsh-client-ui-workspace`
+	* 的 `connectWorkspace` → `createInWorkspace`）里，而桥走 REST 直连内核，没有这一层 ——
+	* 于是手机端每点一次「新会话」就多一个空白会话，攒成一串永远没人用的空壳。
+	*
+	* 这里把客户端那条判据原样搬过来（`blank && cwd 匹配 && 未归档 && preset 匹配`），
+	* 取用顺序也照抄：**按内核返回的列表顺序取第一个**，不自己按时间排序 —— 同一份数据
+	* 在桌面与手机上应当落到同一条会话上，桥没有理由发明第三种顺序。
+	*
+	* preset 的口径也与内核一致：空白会话**没声明** preset 时对任何预设都算可用
+	* （只有 `typeof listed === 'string'` 才比较）。「没声明」不等于「声明了别的」——
+	* 把前者当成不匹配会让所有老会话都挑不中。
+	*/
+	reusableBlankId(sessions, archived, agentPreset, matches) {
+		for (const session of sessions) {
+			if (!session.blank || archived.has(session.sessionId) || !matches(session)) continue;
+			const listed = session.agentPreset ?? session.projections?.values["agentPreset"];
+			if (agentPreset !== void 0 && typeof listed === "string" && listed !== agentPreset) continue;
+			return session.sessionId;
+		}
+	}
+	/**
+	* 工作区维度上找一个可复用的空白会话。
+	*
+	* 归属判据用**内核自己的两个字段**：`session.cwd === workspace.path` 且
+	* `workspace.sessionIds` 含它 —— 与客户端 `createInWorkspace` 逐字同义。
+	* 这里重新拉一次原始 workspace 列表（而不是复用 `listWorkspaces` 的投影结果），
+	* 因为 `ChatWorkspaceView` 刻意不含 `sessionIds` 与绝对路径。
+	*/
+	async blankSessionInWorkspace(workspaceId, agentPreset) {
+		const [sessionsResponse, workspaceResponse] = await Promise.all([this.api.sessions.list({
+			rpcId: randomUUID(),
+			payload: {}
+		}), this.api.workspace.list({
+			rpcId: randomUUID(),
+			payload: {}
+		})]);
+		const workspaceValue = unwrapDsh(workspaceResponse);
+		const summary = workspaceValue.items.find((item) => item.workspaceId === workspaceId);
+		if (summary === void 0) return void 0;
+		return this.reusableBlankId(unwrapDsh(sessionsResponse).items, new Set(workspaceValue.archivedSessionIds), agentPreset, (session) => session.cwd === summary.path && summary.sessionIds.includes(session.sessionId));
+	}
+	/**
+	* 绝对路径维度上找一个可复用的空白会话（老客户端的 `rootId` + `path` 入口）。
+	*
+	* 这里没有 workspace 摘要可用，判据就只剩「同一 cwd」—— 与客户端按 workspace
+	* 挑选相比少了两道（`sessionIds` 归属、workspace 存在性），但那两道在
+	* `rootId` + `path` 这条路上本来就由授权根解析替代了。
+	*/
+	async blankSessionAtPath(cwd, agentPreset) {
+		const [sessionsResponse, workspaceResponse] = await Promise.all([this.api.sessions.list({
+			rpcId: randomUUID(),
+			payload: {}
+		}), this.api.workspace.list({
+			rpcId: randomUUID(),
+			payload: {}
+		})]);
+		return this.reusableBlankId(unwrapDsh(sessionsResponse).items, new Set(unwrapDsh(workspaceResponse).archivedSessionIds), agentPreset, (session) => session.cwd === cwd);
+	}
 	async history(principal, sessionId, options) {
 		await this.requireSession(principal, sessionId);
 		const payload = {
@@ -4467,7 +4819,8 @@ var WorkspaceDatabase = class {
 			const scopes = parseScopes(row.scopes_json);
 			const rootIds = JSON.parse(row.roots_json);
 			this.db.prepare("UPDATE pairings SET used_at = ? WHERE code_hash = ?").run(now, row.code_hash);
-			this.db.prepare("INSERT INTO devices(id,name,token_hash,scopes_json,created_at) VALUES(?,?,?,?,?)").run(id, name, hashSecret(token), JSON.stringify(scopes), now);
+			const nameSource = options.nameSource ?? "declared";
+			this.db.prepare("INSERT INTO devices(id,name,token_hash,scopes_json,created_at,name_source) VALUES(?,?,?,?,?,?)").run(id, name, hashSecret(token), JSON.stringify(scopes), now, nameSource);
 			const grant = this.db.prepare("INSERT INTO device_roots(device_id,root_id) VALUES(?,?)");
 			for (const rootId of rootIds) grant.run(id, rootId);
 			this.audit("device", id, "pairing.exchange", void 0, void 0, { name }, options.requestId);
@@ -4480,7 +4833,8 @@ var WorkspaceDatabase = class {
 					name,
 					scopes,
 					rootIds,
-					createdAt: now
+					createdAt: now,
+					nameSource
 				}
 			};
 		} catch (error) {
@@ -4508,9 +4862,79 @@ var WorkspaceDatabase = class {
 			scopes: parseScopes(row.scopes_json),
 			rootIds: rootRows.map((item) => item.root_id),
 			createdAt: row.created_at,
-			...touchLastSeen ? { lastSeenAt: now } : row.last_seen_at === null ? {} : { lastSeenAt: row.last_seen_at }
+			...touchLastSeen ? { lastSeenAt: now } : row.last_seen_at === null ? {} : { lastSeenAt: row.last_seen_at },
+			...identityFields(row)
 		};
 	}
+	/**
+	* 记录一次探测到的设备身份，必要时顺手把占位名改成「平台 · 型号」。
+	*
+	* 时序说明：配对时桥只知道「有个设备要连」，真正的平台与型号要等设备
+	* **第一次发请求**才拿得到。所以这个方法由认证路径调用（见 `auth.ts`
+	* 的 `principal`），而不是配对路径。
+	*
+	* ## 什么时候改名
+	*
+	* 只有 `name_source` 是 `default`（配对时的占位名）或 `detected`（上次自动
+	* 生成的）才改名。`declared`（用户手工改的）**永不动** —— 用户起的名比机器
+	* 猜的准，而且他能改一次就能改第二次，但机器每次连接都覆盖就再也留不住了。
+	*
+	* 老库的 `name_source` 是 NULL：那些行里的名字多半是硬编码的「Android 设备」，
+	* 但**也可能是用户手工改过的**（此前没有任何改名通道，所以实际上只有占位名；
+	* 不过万一有人直接改过库，我们不能替他决定）。保守起见把 NULL 当作
+	* `declared` 处理 —— 名字不动，只补 platform/model 两列。
+	*
+	* ## 为什么不做成「每次请求都写库」
+	*
+	* 调用方只在**探测结果与库里不同**时才调这里（见 `auth.ts`），所以正常情况
+	* 下一台设备一生只写一次。这不是性能考虑，而是避免把一次读请求变成写请求：
+	* 写请求会碰 WAL、会影响 `devicesRevisionCounter`，进而触发全体客户端重拉设备表。
+	*
+	* @returns 是否真的改了库（调用方据此决定要不要递增设备版本号）。
+	*/
+	recordDeviceIdentity(id, identity) {
+		const row = this.db.prepare("SELECT platform, model, name_source, name FROM devices WHERE id = ? AND revoked_at IS NULL").get(id);
+		if (row === void 0) return false;
+		const platform = identity.platform ?? row.platform;
+		const model = identity.model ?? row.model;
+		const source = row.name_source ?? "declared";
+		const mayRename = source === "default" || source === "detected";
+		const suggested = identity.suggestedName;
+		const rename = mayRename && suggested !== void 0 && suggested !== row.name;
+		const platformChanged = platform !== row.platform;
+		const modelChanged = model !== row.model;
+		if (!platformChanged && !modelChanged && !rename) return false;
+		this.db.prepare("UPDATE devices SET platform = ?, model = ?, name = ?, name_source = ? WHERE id = ?").run(platform ?? null, model ?? null, rename ? suggested : row.name, rename ? "detected" : row.name_source ?? "declared", id);
+		this.devicesRevisionCounter += 1;
+		return true;
+	}
+	/**
+	* 用户手工改名。
+	*
+	* 一旦走这条路，`name_source` 就变成 `declared`，此后任何自动探测都**不再**
+	* 覆盖它。这是「用户意图优先于机器推断」的唯一实现点，所以单独一个方法而不是
+	* 塞进 `updateDevice`：权限变更与改名是两件不同的事，审计动作也不该混。
+	*/
+	renameDevice(id, name, options = {}) {
+		const trimmed = name.trim().slice(0, 120);
+		if (trimmed === "") throw new ApiError(400, "BODY_INVALID", "name must not be empty.");
+		this.db.exec("BEGIN IMMEDIATE");
+		try {
+			if (this.db.prepare("UPDATE devices SET name = ?, name_source = 'declared' WHERE id = ? AND revoked_at IS NULL").run(trimmed, id).changes === 0) throw new ApiError(404, "DEVICE_NOT_FOUND", "The active device does not exist.");
+			this.audit("admin", "loopback-admin", "device.rename", void 0, void 0, {
+				deviceId: id,
+				name: trimmed
+			}, options.requestId);
+			this.db.exec("COMMIT");
+		} catch (error) {
+			this.db.exec("ROLLBACK");
+			throw error;
+		}
+		this.devicesRevisionCounter += 1;
+		const device = this.getActiveDevice(id);
+		if (device === void 0) throw new ApiError(404, "DEVICE_NOT_FOUND", "The active device does not exist.");
+		return device;
+	}
 	listDevices() {
 		const rows = this.db.prepare("SELECT * FROM devices WHERE revoked_at IS NULL ORDER BY created_at DESC").all();
 		const rootQuery = this.db.prepare("SELECT root_id FROM device_roots WHERE device_id = ? ORDER BY root_id");
@@ -4521,7 +4945,8 @@ var WorkspaceDatabase = class {
 			rootIds: rootQuery.all(row.id).map((item) => item.root_id),
 			createdAt: row.created_at,
 			...row.last_seen_at === null ? {} : { lastSeenAt: row.last_seen_at },
-			...row.revoked_at === null ? {} : { revokedAt: row.revoked_at }
+			...row.revoked_at === null ? {} : { revokedAt: row.revoked_at },
+			...identityFields(row)
 		}));
 	}
 	isDeviceActive(id) {
@@ -4805,6 +5230,9 @@ var WorkspaceDatabase = class {
       CREATE INDEX IF NOT EXISTS trash_root_idx ON trash(root_id, created_at DESC);
     `);
 		if (!this.hasRootColumn("builtin")) this.db.exec("ALTER TABLE roots ADD COLUMN builtin INTEGER NOT NULL DEFAULT 0");
+		if (!this.hasDeviceColumn("platform")) this.db.exec("ALTER TABLE devices ADD COLUMN platform TEXT");
+		if (!this.hasDeviceColumn("model")) this.db.exec("ALTER TABLE devices ADD COLUMN model TEXT");
+		if (!this.hasDeviceColumn("name_source")) this.db.exec("ALTER TABLE devices ADD COLUMN name_source TEXT");
 		if (this.rootsPathIsUnique()) this.dropRootsUniqueConstraint();
 	}
 	/** `roots.real_path` 上是否还带 UNIQUE 约束。 */
@@ -4847,12 +5275,34 @@ var WorkspaceDatabase = class {
 	}
 	/** `roots` 表是否已有指定列。 */
 	hasRootColumn(column) {
-		return this.db.prepare("PRAGMA table_info(roots)").all().some((entry) => entry.name === column);
+		return this.hasColumn("roots", column);
+	}
+	/** `devices` 表是否已有指定列。 */
+	hasDeviceColumn(column) {
+		return this.hasColumn("devices", column);
+	}
+	hasColumn(table, column) {
+		return this.db.prepare(`PRAGMA table_info(${table})`).all().some((entry) => entry.name === column);
 	}
 };
 function hashSecret(secret) {
 	return createHash("sha256").update(secret, "utf8").digest("hex");
 }
+/**
+* 把库里三列身份摊成 `DeviceView` 的可选字段。
+*
+* 老库这三列是 NULL —— 此时**整个键都不写**，而不是写 `platform: undefined`：
+* 前者在 JSON 里不存在（老客户端忽略未知字段，新客户端看到 `undefined`），
+* 后者会被 `JSON.stringify` 丢掉，两种结果一样，但省略更诚实。
+*/
+function identityFields(row) {
+	const source = row.name_source;
+	return {
+		...row.platform === null || row.platform === void 0 ? {} : { platform: row.platform },
+		...row.model === null || row.model === void 0 ? {} : { model: row.model },
+		...source === "default" || source === "detected" || source === "declared" ? { nameSource: source } : {}
+	};
+}
 function normalizePairingCode(code) {
 	return code.replace(/[^A-Za-z0-9]/g, "").toUpperCase();
 }
@@ -6051,6 +6501,40 @@ function defaultDisplayName() {
 //#endregion
 //#region src/host/plugin-inventory.ts
 /**
+* 插件清单（plugin inventory）。
+*
+* ## 为什么需要它
+*
+* 用户在手机上使用时的反馈是「功能单调点，无法查看装的插件情况」：想知道这台机器上
+* 装了哪些插件、有没有出问题的，必须回到电脑前的 WebUI。
+*
+* 而插件的 API 面（`/api/v1`）此前有 10 个端点，**没有任何一个与插件相关**；
+* loopback 管理面（`/manage/status`）也只回 `remote` / `roots` / `devices`。
+* 于是这个信息在远程侧完全不可见。本模块补上这个缺口。
+*
+* ## 数据源为什么是这两个文件
+*
+* DSH 把每个 profile 的插件状态放在两个地方，缺一不可：
+*
+* - `<profiledir>/package.json` 的 `dependencies`：**装了哪些包**（含版本声明）；
+* - 同一个 `package.json` 的 `dsh.profile.bundles`：**实际加载了哪些包**。
+*
+* 两者之差是有意义的信息，而不是噪声：
+*
+* - 在 `dependencies` 里但不在 `bundles` 里 → **装了但没启用**（例如用户装了备用插件先不加载）；
+* - 在 `bundles` 里但 `node_modules` 下找不到 → **声明加载却缺失**，这通常意味着启动会出问题，
+*   是用户最需要被提前告知的状态。
+*
+* 另外，`node_modules/<name>/package.json` 里的 `version` 才是**实际装上的版本**。
+* 只看 `dependencies` 的 `^0.4.5` 无法回答「我现在跑的是哪个版本」。
+*
+* ## 安全边界
+*
+* 本模块只读两个位置的文件，并把结果**限制为**「包名 + 版本 + 状态」三种信息，
+* 不回传任何文件内容、绝对路径之外的系统信息、或 `.env` / 凭据相关内容。
+* `profilePath` 会返回，因为用户需要它来定位问题，且它本来就是本机路径。
+*/
+/**
 * 读包清单时的并发上限。
 *
 * 为什么不是 `Promise.all` 全放：`names` 的长度由用户装了多少插件决定，
@@ -6364,6 +6848,40 @@ function unavailable(profile, profilePath, reason) {
 		items: []
 	};
 }
+/**
+* 启用 / 停用插件（「插件」页的写操作）。
+*
+* ## 为什么不是调 `dsh plugin`
+*
+* `dsh plugin <anything>` 会**原样转发给 pnpm**。实测踩过一次：本想查
+* `dsh plugin enable --help`，结果 pnpm 直接进入安装流程（打出 `Packages: +4 -85`）——
+* 它在**动依赖树**。启用/停用插件根本不需要碰依赖（包已经在 `node_modules` 里了），
+* 走 pnpm 等于为了挪一个字符串去重算整棵依赖，风险与收益完全不成比例。
+*
+* ## 真正该改的是什么
+*
+* 只改 **`dsh.profile.bundles` 数组**。内核源码注释写明：
+*
+* > stack its patch layers (bundle layers in `dsh.profile.bundles` order …)
+*
+* 也就是说这个数组**就是加载清单，且顺序即加载顺序**。加一个名字 = 启用，
+* 删一个名字 = 停用。依赖声明（`dependencies`）原封不动 —— 包仍在磁盘上，
+* 随时可以再启用，不必重新下载。
+*
+* ## 三道安全阀
+*
+* 1. **拒绝改官方包**（`@deepseek-ai/` 前缀）：它们随 DSH 主包安装、不由 profile 管理，
+*    改了 bundles 也加载不出来，反而把清单搞成与实际不符。
+* 2. **写前必备份**：`package.json.bak-<时间戳>` 落在同目录。profile 的 package.json
+*    一旦写坏，dsh 下次**起不来**，而用户此刻在手机上、够不着电脑 —— 备份是唯一退路。
+* 3. **先写临时文件再 rename**：`rename` 在同分区是原子的。直接写原文件的话，
+*    写到一半断电/被杀会留下一个残缺的 JSON，后果同上。
+*
+* ## 必须重启才生效
+*
+* bundles 只在**启动时**读一次。改了文件不等于改了运行中的进程 —— 这一点会原样
+* 回给调用方（`restartRequired: true`），由界面明确告诉用户，别让人以为点了没反应。
+*/
 var PluginToggleError = class extends Error {
 	code;
 	constructor(code, message) {
@@ -6388,7 +6906,7 @@ async function togglePlugin(name, enable, input = {}) {
 	const profilePath = path.join(resolveDshHome(input), "profiles", profile);
 	const manifestPath = path.join(profilePath, "package.json");
 	const raw = await readFile(manifestPath, "utf8").catch(() => null);
-	if (raw === null) throw new PluginToggleError("MANIFEST_UNREADABLE", `Cannot read ${manifestPath}`);
+	if (raw === null) throw new PluginToggleError("MANIFEST_UNREADABLE", `Cannot read the manifest of profile "${profile}".`);
 	let manifest;
 	try {
 		manifest = JSON.parse(raw);
@@ -6878,12 +7396,18 @@ var ApiRouter = class {
 				scopes: [...principal.scopes],
 				rootIds: "all"
 			});
-			else sendJson(res, 200, {
-				id: principal.id,
-				name: principal.name,
-				scopes: [...principal.scopes],
-				rootIds: [...principal.rootIds]
-			});
+			else {
+				const stored = this.options.database.getActiveDevice(principal.id);
+				sendJson(res, 200, {
+					id: principal.id,
+					name: principal.name,
+					scopes: [...principal.scopes],
+					rootIds: [...principal.rootIds],
+					...stored?.platform === void 0 ? {} : { platform: stored.platform },
+					...stored?.model === void 0 ? {} : { model: stored.model },
+					...stored?.nameSource === void 0 ? {} : { nameSource: stored.nameSource }
+				});
+			}
 			return;
 		}
 		if (method === "GET" && pathname === "/api/v1/roots") {
@@ -6999,10 +7523,11 @@ var ApiRouter = class {
 					...typeof body.apiKey === "string" ? { apiKey: body.apiKey } : {},
 					...Number.isSafeInteger(body.expectedRevision) ? { expectedRevision: body.expectedRevision } : {}
 				};
-				await this.options.settings.createProvider(input);
+				const created = await this.options.settings.createProvider(input);
 				this.audit(principal, "settings.provider.create", void 0, void 0, requestId, {
 					providerId: input.id,
-					credentialChanged: typeof input.apiKey === "string" && input.apiKey.trim() !== ""
+					credentialChanged: typeof input.apiKey === "string" && input.apiKey.trim() !== "",
+					baseURLHost: created.baseURLHost
 				});
 				sendJson(res, 201, await this.options.settings.listProviders());
 				return;
@@ -7065,11 +7590,12 @@ var ApiRouter = class {
 			if (method === "PATCH") {
 				this.options.auth.requireScope(principal, "settings.write");
 				const body = await readJson(req, 1e6);
-				await this.options.settings.updateProvider(providerId, body);
+				const updated = await this.options.settings.updateProvider(providerId, body);
 				this.audit(principal, "settings.provider.update", void 0, void 0, requestId, {
 					providerId,
 					fields: Object.keys(body).filter((field) => field !== "apiKey"),
-					credentialChanged: Object.hasOwn(body, "apiKey")
+					credentialChanged: Object.hasOwn(body, "apiKey"),
+					...updated.baseURLHost === void 0 ? {} : { baseURLHost: updated.baseURLHost }
 				});
 				sendJson(res, 200, await this.options.settings.listProviders());
 				return;
@@ -7094,9 +7620,12 @@ var ApiRouter = class {
 				...typeof body.api === "string" ? { api: body.api } : {},
 				...typeof body.apiKey === "string" ? { apiKey: body.apiKey } : {}
 			};
-			const models = await this.options.settings.discover(providerId, draft);
-			this.audit(principal, "settings.provider.discover", void 0, void 0, requestId, { providerId });
-			sendJson(res, 200, { models });
+			const discovered = await this.options.settings.discover(providerId, draft);
+			this.audit(principal, "settings.provider.discover", void 0, void 0, requestId, {
+				providerId,
+				...discovered.baseURLHost === void 0 ? {} : { baseURLHost: discovered.baseURLHost }
+			});
+			sendJson(res, 200, { models: discovered.models });
 			return;
 		}
 		if (pathname === "/api/v1/chat/sessions") {
@@ -7116,7 +7645,8 @@ var ApiRouter = class {
 				}
 				const options = {
 					...typeof body.sessionId === "string" ? { sessionId: body.sessionId } : {},
-					...typeof body.agentPreset === "string" ? { agentPreset: body.agentPreset } : {}
+					...typeof body.agentPreset === "string" ? { agentPreset: body.agentPreset } : {},
+					...typeof body.reuseBlank === "boolean" ? { reuseBlank: body.reuseBlank } : {}
 				};
 				const usesWorkspace = typeof body.workspaceId === "string";
 				const usesLegacyPath = typeof body.rootId === "string" && typeof body.path === "string";
@@ -7425,9 +7955,17 @@ var ApiRouter = class {
 		const deviceRoute = pathname.match(/^\/manage\/devices\/([^/]+)$/);
 		if (deviceRoute !== null && method === "PATCH") {
 			const body = await readJson(req, 64e3);
+			const deviceId = decodePathSegment(deviceRoute[1]);
+			if (body.name !== void 0 && typeof body.name !== "string") throw new ApiError(400, "BODY_INVALID", "name must be a string.");
+			if (body.scopes === void 0 && body.rootIds === void 0) {
+				if (body.name === void 0) throw new ApiError(400, "BODY_INVALID", "Either name or the scopes/rootIds pair is required.");
+				sendJson(res, 200, this.options.database.renameDevice(deviceId, body.name, { requestId }));
+				return;
+			}
 			const scopes = validateScopes(body.scopes);
 			const rootIds = validateStringArray(body.rootIds, "rootIds");
-			sendJson(res, 200, this.options.database.updateDevice(decodePathSegment(deviceRoute[1]), scopes, rootIds, { requestId }));
+			if (typeof body.name === "string") this.options.database.renameDevice(deviceId, body.name, { requestId });
+			sendJson(res, 200, this.options.database.updateDevice(deviceId, scopes, rootIds, { requestId }));
 			return;
 		}
 		if (deviceRoute !== null && method === "DELETE") {
@@ -7604,7 +8142,7 @@ var ApiRouter = class {
 		const { state, configText } = await this.createTunnel({ configText: true }, requestId, "im-command");
 		if (configText === void 0 || state.url === null) throw new Error("隧道已启动，但 12 秒内没拿到公网地址。稍等片刻再发一次 /tunnel 可复用当前地址。");
 		const text = typeof configText.text === "string" ? configText.text : "";
-		const deviceName = typeof configText.deviceName === "string" ? configText.deviceName : "Android 设备";
+		const deviceName = typeof configText.deviceName === "string" ? configText.deviceName : DEFAULT_DEVICE_NAME;
 		return {
 			url: state.url,
 			text,
@@ -7644,10 +8182,13 @@ var ApiRouter = class {
 		if (endpoints.length === 0) throw new ApiError(400, "NO_ENDPOINT", "No usable local address was detected. Provide endpoints explicitly.");
 		const scopes = body.scopes === void 0 ? [...DEFAULT_CONFIG_SCOPES] : validateScopes(body.scopes);
 		const rootIds = body.rootIds === void 0 ? this.options.database.listRoots().map((root) => root.id) : validateStringArray(body.rootIds, "rootIds");
-		const deviceName = readOptionalText(body.deviceName) ?? "Android 设备";
+		const deviceName = readOptionalText(body.deviceName) ?? "Mobile device";
 		const displayName = readOptionalText(body.displayName) ?? defaultDisplayName();
 		const pairing = this.options.database.createPairing(rootIds, scopes, void 0, { requestId });
-		const exchanged = this.options.database.exchangePairing(pairing.code, deviceName, { requestId });
+		const exchanged = this.options.database.exchangePairing(pairing.code, deviceName, {
+			requestId,
+			...readOptionalText(body.deviceName) === void 0 ? { nameSource: "default" } : { nameSource: "declared" }
+		});
 		return {
 			text: encodeConfigText({
 				displayName,
@@ -7960,16 +8501,11 @@ function validateStringArray(value, name) {
 /**
 * 生成配置文本时的默认设备权限。
 *
-* 刻意**不含** `files.delete` 与 `settings.write`：这两个是破坏性权限，应当是用户显式
-* 要求才授予，而不是因为「生成了一段配置文本」就顺手给了。需要时可在请求里显式传 scopes。
+* 定义已上移到 `shared/contracts.ts` 的 `DEFAULT_DEVICE_SCOPES`：Web UI 的配对码面板
+* 原先默认勾满七档（含 `settings.write`），与服务端这里的五档缺省互相矛盾 ——
+* 同一份默认值散落两处正是它跑偏的原因。
 */
-const DEFAULT_CONFIG_SCOPES = [
-	"chat.read",
-	"chat.write",
-	"files.read",
-	"files.write",
-	"settings.read"
-];
+const DEFAULT_CONFIG_SCOPES = DEFAULT_DEVICE_SCOPES;
 function readOptionalText(value) {
 	if (typeof value !== "string") return null;
 	const text = value.trim();
@@ -8837,6 +9373,149 @@ function failResponse(res, error) {
 	res.end(body);
 }
 //#endregion
+//#region src/host/provider-url-policy.ts
+/**
+* 供应商 `baseURL` 的地址策略（SEC-H11）。
+*
+* 为什么需要这一层：`discover` / `createProvider` / `updateProvider` 三个入口都把
+* 客户端给的 `baseURL` 原样交给内核，内核会**带着该供应商已配置的真实凭据**去请求它。
+* 攻击者只要持 `settings.write`，就能把 baseURL 指向自己的服务器，收到
+* `Authorization: Bearer <真实 key>` —— 这是最直接的一次性凭据窃取；同一机制也可
+* 用作 SSRF 探内网。
+*
+* 两条独立的闸门：
+* 1. **协议白名单**：只放 `http:` / `https:`。`file:`、`ftp:`、`gopher:` 之类没有任何
+*    正当用途，却是把「一次 HTTP 请求」变成别的语义的经典手法。
+* 2. **私网地址**：默认拒绝 RFC1918 / 回环 / 链路本地（含云元数据 `169.254.169.254`）。
+*    本地 LLM（ollama、LM Studio 常见于 `127.0.0.1:11434`）是正当用例，因此由部署方
+*    用插件配置 `allowPrivateProviderHosts` 显式放行，而不是默认开口子。
+*
+* 判定只看**字面量**，不做 DNS 解析：解析后校验会引入 TOCTOU（校验时是公网 IP、
+* 请求时 DNS 换成内网），反而给出「已校验」的错觉。真正挡住 DNS 重绑定的做法是
+* 在连接层固定已解析地址，那超出本层职责；这里选择把攻击面收窄到「攻击者必须控制
+* 一个公网域名」，并让审计记下目标 host 以便事后追查。
+*/
+/** 私网 / 保留地址判定需要的最小区间，够覆盖本机、家庭网络与云元数据。 */
+const PRIVATE_V4 = [
+	[0, 16777215],
+	[167772160, 184549375],
+	[1681915904, 1686110207],
+	[2130706432, 2147483647],
+	[2851995648, 2852061183],
+	[2886729728, 2887778303],
+	[3232235520, 3232301055]
+];
+/**
+* 校验并归一化 `baseURL`，返回可用于审计的 `host[:port]`。
+*
+* 抛 400 `PROVIDER_BASE_URL_INVALID`（形状/协议不合法）或
+* 403 `PROVIDER_BASE_URL_FORBIDDEN`（指向私网且未放行）。两个码分开是刻意的：
+* 前者是客户端填错，后者是策略拒绝，客户端不该把它们当同一类错误处理。
+*
+* 返回值带端口：审计要能回答「凭据被打到哪个地址」，而同一台内网主机上
+* `:11434`（ollama）与 `:8080`（随便什么）是不同的东西。
+*/
+function validateProviderBaseURL(raw, options = {}) {
+	const trimmed = raw.trim();
+	if (trimmed === "") throw new ApiError(400, "PROVIDER_BASE_URL_REQUIRED", "baseURL is required.");
+	let url;
+	try {
+		url = new URL(trimmed);
+	} catch {
+		throw new ApiError(400, "PROVIDER_BASE_URL_INVALID", "baseURL must be an absolute URL.");
+	}
+	if (url.protocol !== "http:" && url.protocol !== "https:") throw new ApiError(400, "PROVIDER_BASE_URL_INVALID", "baseURL must use http or https.");
+	if (url.hostname === "") throw new ApiError(400, "PROVIDER_BASE_URL_INVALID", "baseURL must include a host.");
+	const host = url.hostname.replace(/^\[|\]$/g, "").toLowerCase();
+	const target = url.port === "" ? host : `${host}:${url.port}`;
+	if (!isPrivateHost(host)) return target;
+	if ((options.allowPrivateHosts ?? []).some((entry) => {
+		const candidate = entry.trim().toLowerCase();
+		if (candidate === "") return false;
+		return candidate.includes(":") ? candidate === target : candidate === host;
+	})) return target;
+	throw new ApiError(403, "PROVIDER_BASE_URL_FORBIDDEN", "baseURL points at a private or loopback address; the deployment must allow it explicitly.", { host: target });
+}
+/**
+* 判断 host 是否落在私网 / 回环 / 链路本地范围。
+*
+* 只认 IPv4 点分十进制、IPv6 字面量与 `localhost`。**不解析域名**：一个指向
+* `127.0.0.1` 的公网域名会从这里漏过去 —— 这是本层刻意的边界，见文件头注释。
+*/
+function isPrivateHost(host) {
+	const lower = host.toLowerCase();
+	if (lower === "localhost" || lower.endsWith(".localhost")) return true;
+	if (lower.includes(":")) return isPrivateIPv6(lower);
+	const v4 = parseIPv4(lower);
+	if (v4 === void 0) return false;
+	return PRIVATE_V4.some(([from, to]) => v4 >= from && v4 <= to);
+}
+function parseIPv4(host) {
+	const parts = host.split(".");
+	if (parts.length !== 4) return void 0;
+	let value = 0;
+	for (const part of parts) {
+		if (!/^\d{1,3}$/.test(part)) return void 0;
+		const octet = Number(part);
+		if (octet > 255) return void 0;
+		value = value * 256 + octet;
+	}
+	return value;
+}
+function isPrivateIPv6(host) {
+	if (host === "::1" || host === "::") return true;
+	if (/^f[cd][0-9a-f]{2}:/.test(host)) return true;
+	if (/^fe[89ab][0-9a-f]:/.test(host)) return true;
+	const embedded = embeddedIPv4(host);
+	if (embedded !== void 0) return isPrivateHost(embedded);
+	return false;
+}
+/**
+* 从 IPv6 字面量里取出内嵌的 IPv4 点分形式（仅 `::ffff:0:0/96` 与 `::/96` 两种），
+* 没有则返回 `undefined`。
+*
+* 为什么要自己解析：`new URL()` 会把 `::ffff:127.0.0.1` 归一化成十六进制形式
+* `::ffff:7f00:1`，所以只匹配点分十进制等于没挡；而标准库没有暴露「前 80 位是否
+* 为零」的判断，为这一处引依赖不划算。
+*
+* 解析失败一律返回 `undefined`（按公网处理），与 `isPrivateHost` 对未知输入的态度一致。
+*/
+function embeddedIPv4(host) {
+	let normalized = host;
+	const dotted = /(\d{1,3}(?:\.\d{1,3}){3})$/.exec(host);
+	if (dotted !== null) {
+		const v4 = parseIPv4(dotted[1]);
+		if (v4 === void 0) return void 0;
+		const hi = (v4 >>> 16 & 65535).toString(16);
+		const lo = (v4 & 65535).toString(16);
+		normalized = `${host.slice(0, dotted.index)}${hi}:${lo}`;
+	}
+	const [head, tail] = normalized.includes("::") ? normalized.split("::", 2) : [normalized, void 0];
+	const headGroups = head === void 0 || head === "" ? [] : head.split(":");
+	const tailGroups = tail === void 0 || tail === "" ? [] : tail.split(":");
+	const missing = 8 - headGroups.length - tailGroups.length;
+	if (tail === void 0 ? headGroups.length !== 8 : missing < 0) return void 0;
+	const groups = [
+		...headGroups,
+		...tail === void 0 ? [] : Array(missing).fill("0"),
+		...tailGroups
+	];
+	if (groups.length !== 8) return void 0;
+	const parsed = [];
+	for (const group of groups) {
+		if (!/^[0-9a-f]{1,4}$/.test(group)) return void 0;
+		parsed.push(Number.parseInt(group, 16));
+	}
+	if (!(parsed.slice(0, 5).every((value) => value === 0) && (parsed[5] === 65535 || parsed[5] === 0))) return void 0;
+	const v4 = (parsed[6] << 16 | parsed[7]) >>> 0;
+	return [
+		24,
+		16,
+		8,
+		0
+	].map((shift) => v4 >>> shift & 255).join(".");
+}
+//#endregion
 //#region src/host/settings-adapter.ts
 /**
 * provider 上下文的复用窗口。
@@ -8853,6 +9532,9 @@ var DshSettingsAdapter = class {
 	/**
 	* @param options.writeNamespaces 额外允许手机端写入的设置命名空间（精确 ns 或
 	*   `前缀*`），与内置策略（`ui-*` / 以 `locale` 结尾）叠加；默认为空。
+	* @param options.allowPrivateProviderHosts 允许供应商 `baseURL` 指向的私网 / 回环
+	*   host 白名单（默认空 = 一律拒绝）。要连本地 LLM 的部署方显式填，理由见
+	*   `provider-url-policy.ts` 文件头。
 	*/
 	constructor(api, options = {}) {
 		this.api = api;
@@ -8909,6 +9591,10 @@ var DshSettingsAdapter = class {
 	get writeNamespaces() {
 		return this.options.writeNamespaces ?? [];
 	}
+	/** 交给地址策略的选项；集中一处，三个入口不会各配各的。 */
+	get baseURLOptions() {
+		return { allowPrivateHosts: this.options.allowPrivateProviderHosts ?? [] };
+	}
 	/** 内核 settings 服务缺失时给 503（而不是把 `TypeError` 漏成 500）。 */
 	settingsService() {
 		const settings = this.api.settings;
@@ -8996,11 +9682,20 @@ var DshSettingsAdapter = class {
 			payload: {}
 		}));
 	}
+	/**
+	* 更新供应商配置。
+	*
+	* 返回 `baseURLHost`（仅当本次 patch 动了 `baseURL` 时存在）供路由层写审计：
+	* 攻击者可以用 discover 把凭据发到任意地址，事后必须能从审计里看出「打了哪」。
+	* 只记 host 不记完整 URL —— path/query 可能带凭据，审计表不该成为新的泄露点。
+	*/
 	async updateProvider(providerId, patch) {
 		const context = await this.providerContext(providerId);
 		if (!context.writable) throw new ApiError(409, "SETTINGS_READ_ONLY", "DSH settings are read-only.");
 		if (context.entry.settingsNs === "") throw new ApiError(409, "PROVIDER_NOT_CONFIGURABLE", "This provider has no writable settings section.");
 		const ops = [];
+		let baseURLHost;
+		const previousHost = hostOf(effectiveBaseURL(context));
 		for (const field of [
 			"displayName",
 			"baseURL",
@@ -9010,6 +9705,7 @@ var DshSettingsAdapter = class {
 		]) {
 			if (!(field in patch)) continue;
 			const value = patch[field];
+			if (field === "baseURL" && typeof value === "string" && value.trim() !== "") baseURLHost = validateProviderBaseURL(value, this.baseURLOptions);
 			ops.push(value === null || value === "" ? {
 				op: "unset",
 				path: [...context.entry.settingsPath, field]
@@ -9019,6 +9715,10 @@ var DshSettingsAdapter = class {
 				value
 			});
 		}
+		if (baseURLHost !== void 0 && previousHost !== "" && baseURLHost !== previousHost && !(typeof patch.apiKey === "string" && patch.apiKey.trim() !== "") && await this.providerHoldsCredential(providerId, context)) throw new ApiError(403, "PROVIDER_BASE_URL_REPOINT_FORBIDDEN", "Changing baseURL of a provider that already holds a credential requires supplying a new apiKey.", {
+			previousHost,
+			host: baseURLHost
+		});
 		if (patch.models !== void 0) {
 			if (patch.models === null) ops.push({
 				op: "unset",
@@ -9061,11 +9761,12 @@ var DshSettingsAdapter = class {
 			}));
 		}
 		this.invalidateProviderContext(providerId);
+		return baseURLHost === void 0 ? {} : { baseURLHost };
 	}
 	async createProvider(input) {
 		const id = input.id.trim();
 		if (!/^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/.test(id)) throw new ApiError(400, "PROVIDER_ID_INVALID", "Provider ids must use lowercase letters, digits, and single hyphens, starting with a letter.");
-		if (input.baseURL.trim() === "") throw new ApiError(400, "PROVIDER_BASE_URL_REQUIRED", "baseURL is required.");
+		const baseURLHost = validateProviderBaseURL(input.baseURL, this.baseURLOptions);
 		if (input.models.length === 0) throw new ApiError(400, "PROVIDER_MODELS_REQUIRED", "At least one model is required.");
 		validateModels(input.models);
 		const [directoryResponse, settingsResponse] = await Promise.all([this.api.llm.providers({
@@ -9112,6 +9813,7 @@ var DshSettingsAdapter = class {
 			}
 		}));
 		this.invalidateProviderContext(id);
+		return { baseURLHost };
 	}
 	async removeProvider(providerId, expectedRevision) {
 		const context = await this.providerContext(providerId);
@@ -9130,18 +9832,35 @@ var DshSettingsAdapter = class {
 		}));
 		this.invalidateProviderContext(providerId);
 	}
+	/**
+	* 发现供应商可用模型。
+	*
+	* `draft.baseURL` 是**临时覆盖**（不写配置），但内核会带着该供应商已配置的真实
+	* 凭据去请求它 —— 这正是 SEC-H11 的窃取路径：攻击者把自己的服务器填进来即可收到
+	* `Authorization: Bearer <真实 key>`。因此临时覆盖与持久化写入过同一道地址策略。
+	*
+	* 返回 `baseURLHost` 供路由层审计；不传 `baseURL` 时（用配置里的地址）同样返回，
+	* 这样「打了哪个地址」在任何情况下都能追溯。
+	*/
 	async discover(providerId, draft) {
+		const context = await this.providerContext(providerId);
+		const override = draft.baseURL === void 0 || draft.baseURL === "" ? void 0 : validateProviderBaseURL(draft.baseURL, this.baseURLOptions);
 		const payload = {
-			settingsNs: (await this.providerContext(providerId)).entry.settingsNs,
+			settingsNs: context.entry.settingsNs,
 			provider: providerId,
 			...draft.baseURL === void 0 || draft.baseURL === "" ? {} : { baseURL: draft.baseURL },
 			...draft.api === void 0 || draft.api === "" ? {} : { api: draft.api },
 			...draft.apiKey === void 0 || draft.apiKey === "" ? {} : { apiKey: draft.apiKey }
 		};
-		return unwrapDsh(await this.api.llm.discoverModels({
+		const models = unwrapDsh(await this.api.llm.discoverModels({
 			rpcId: randomUUID(),
 			payload
 		})).models;
+		const configured = effectiveBaseURL(context);
+		return {
+			models,
+			...override !== void 0 ? { baseURLHost: override } : configured === "" ? {} : { baseURLHost: hostOf(configured) }
+		};
 	}
 	/**
 	* 取一个 provider 的上下文（目录条目 + 设置命名空间 + 当前 profile）。
@@ -9200,9 +9919,23 @@ var DshSettingsAdapter = class {
 			entry,
 			writable: settings.writable,
 			namespace,
-			profile: recordAt(namespace?.value, entry.settingsPath)
+			profile: recordAt(namespace?.value, entry.settingsPath),
+			baseProfile: recordAt(namespace?.base, entry.settingsPath)
 		};
 	}
+	/**
+	* 该供应商当前是否已经存了凭据。
+	*
+	* 单独一次 `credentials.describe` 只在「要换 baseURL host」时才调 —— 那是罕见路径，
+	* 而正常保存（改 models / 显示名 / 协议）不该为此多付一次内核往返。
+	*/
+	async providerHoldsCredential(providerId, context) {
+		const ref = text(context.profile?.apiKeyEnv) ?? keyRef(providerId);
+		return unwrapDsh(await this.api.credentials.describe({
+			rpcId: randomUUID(),
+			payload: { refs: [ref] }
+		})).credentials[ref]?.configured === true;
+	}
 };
 /**
 * 把内核 `settings.mutate` 的错误翻成契约错误码。
@@ -9299,6 +10032,38 @@ function positiveInteger(value) {
 function keyRef(provider) {
 	return provider === "deepseek-official" ? "DEEPSEEK_API_KEY" : `${provider.toUpperCase().replace(/[^A-Z0-9]+/g, "_")}_API_KEY`;
 }
+/**
+* 取一个供应商**当前生效**的 baseURL。
+*
+* 三层回退的顺序是刻意的：
+* 1. `value`（`SettingsNamespaceView.value`）是内核合并后的生效值，首选；
+* 2. `base` 是内核给出的基线 —— 用户没覆盖过 baseURL 时，生效地址只在这里；
+* 3. 适配器目录的 `defaultBaseURL` 是最后兜底（内置供应商走它）。
+*
+* 只看第 1 层会把「用基线地址的供应商」误判成「地址未知」，从而让重定向闸门
+* 对它静默失效 —— 那正是攻击者想要的。
+*/
+function effectiveBaseURL(context) {
+	const fromValue = text(context.profile?.baseURL);
+	if (fromValue !== void 0) return fromValue;
+	const fromBase = text(context.baseProfile?.baseURL);
+	if (fromBase !== void 0) return fromBase;
+	return text(context.entry.defaultBaseURL) ?? "";
+}
+/**
+* 取 URL 的 `host[:port]` 供审计用；解析失败时返回原串。
+*
+* 只用于「配置里的地址」（已经过地址策略或来自适配器目录），所以不需要再校验，
+* 但也不能因为一个畸形配置让 discover 整体失败 —— 审计字段缺失不该阻断业务。
+*/
+function hostOf(value) {
+	try {
+		const url = new URL(value);
+		return url.port === "" ? url.hostname.toLowerCase() : `${url.hostname.toLowerCase()}:${url.port}`;
+	} catch {
+		return value;
+	}
+}
 //#endregion
 //#region src/index.ts
 /**
@@ -9376,7 +10141,10 @@ async function apply(ctx, config = {}) {
 		agents: ctx.agents,
 		commands: ctx.commands
 	});
-	const settings = new DshSettingsAdapter(apiProxy, { writeNamespaces: config.settingsWriteNamespaces ?? [] });
+	const settings = new DshSettingsAdapter(apiProxy, {
+		writeNamespaces: config.settingsWriteNamespaces ?? [],
+		allowPrivateProviderHosts: config.allowPrivateProviderHosts ?? []
+	});
 	let hostServiceReport;
 	try {
 		hostServiceReport = probeHostServices(ctx, PLUGIN_VERSION);