dsh-remote-bridge 2.5.2 → 2.6.1

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。
@@ -2926,7 +3123,7 @@ function createDsh02ApiProxy(host, options = {}) {
 }
 //#endregion
 //#region src/shared/version.ts
-const PLUGIN_VERSION = "2.5.2";
+const PLUGIN_VERSION = "2.6.1";
 //#endregion
 //#region src/host/capabilities.ts
 /**
@@ -3000,6 +3197,7 @@ const BRIDGE_CAPABILITIES = [
 	"model-catalog-v1",
 	"plugin-inventory-v1",
 	"plugin-toggle-v1",
+	"settings-namespaces-v1",
 	"approvals-v1",
 	"questions-v1",
 	"turn-failure-v1",
@@ -3978,7 +4176,7 @@ function normalizeDshEvent(frame, fallback, time = Date.now()) {
 			}
 		};
 	}
-	if (payloadType === "session/event" && typeof payload.sessionId === "string" && isRecord$1(payload.event)) {
+	if (payloadType === "session/event" && typeof payload.sessionId === "string" && isRecord$2(payload.event)) {
 		const event = payload.event;
 		const eventType = typeof event.type === "string" ? event.type : "unknown";
 		const seq = typeof event.seq === "number" ? event.seq : void 0;
@@ -3988,9 +4186,9 @@ function normalizeDshEvent(frame, fallback, time = Date.now()) {
 			...seq === void 0 ? {} : { seq }
 		};
 		const assistantData = event.data;
-		if (eventType === "assistant/chunk" && isRecord$1(assistantData)) {
+		if (eventType === "assistant/chunk" && isRecord$2(assistantData)) {
 			const rawChunk = assistantData.chunk;
-			if (isRecord$1(rawChunk)) {
+			if (isRecord$2(rawChunk)) {
 				const kind = rawChunk.type === "text-delta" ? "text" : rawChunk.type === "reasoning-delta" ? "reasoning" : void 0;
 				if (kind !== void 0 && typeof rawChunk.text === "string" && typeof rawChunk.index === "number") return {
 					id: frame.rpcId,
@@ -4008,7 +4206,7 @@ function normalizeDshEvent(frame, fallback, time = Date.now()) {
 			}
 		}
 		if (eventType === "user/message" || eventType === "assistant/message") {
-			const eventData = isRecord$1(event.data) ? event.data : {};
+			const eventData = isRecord$2(event.data) ? event.data : {};
 			return {
 				id: frame.rpcId,
 				type: "chat.message.committed",
@@ -4022,8 +4220,8 @@ function normalizeDshEvent(frame, fallback, time = Date.now()) {
 			};
 		}
 		if (eventType === "deliverables/presented") {
-			const data = isRecord$1(payload.event) ? payload.event.data : void 0;
-			const files = isRecord$1(data) && Array.isArray(data.files) ? data.files : [];
+			const data = isRecord$2(payload.event) ? payload.event.data : void 0;
+			const files = isRecord$2(data) && Array.isArray(data.files) ? data.files : [];
 			return {
 				id: `${payload.sessionId}:deliverables:${seq ?? files.length}`,
 				type: "chat.deliverables.presented",
@@ -4051,7 +4249,7 @@ function normalizeDshEvent(frame, fallback, time = Date.now()) {
 					};
 				}
 			}
-			const turnReason = eventType === "turn/end" && isRecord$1(event.data) ? event.data.reason : void 0;
+			const turnReason = eventType === "turn/end" && isRecord$2(event.data) ? event.data.reason : void 0;
 			return {
 				id: frame.rpcId,
 				type: eventType === "turn/start" ? "chat.turn.start" : "chat.turn.end",
@@ -4111,12 +4309,12 @@ function normalizeDshEvent(frame, fallback, time = Date.now()) {
 * 用本地化文案「API 密钥无效」顶上。这里保持原样转发，不替客户端猜。
 */
 function turnFailureOf(event) {
-	const reason = isRecord$1(event.data) ? event.data.reason : void 0;
-	if (!isRecord$1(reason)) return void 0;
+	const reason = isRecord$2(event.data) ? event.data.reason : void 0;
+	if (!isRecord$2(reason)) return void 0;
 	const kind = reason.kind;
 	if (kind === "error") {
 		const error = reason.error;
-		if (!isRecord$1(error)) return { message: String(error ?? "本轮运行失败") };
+		if (!isRecord$2(error)) return { message: String(error ?? "本轮运行失败") };
 		const code = typeof error.code === "string" ? error.code : void 0;
 		const message = typeof error.message === "string" ? error.message : JSON.stringify(error);
 		return code === void 0 ? { message } : {
@@ -4124,13 +4322,13 @@ function turnFailureOf(event) {
 			code
 		};
 	}
-	if (kind === "aborted" && isRecord$1(reason.reason) && reason.reason.kind === "hook" && reason.reason.reason === "deepseek-account/signed-out") return {
+	if (kind === "aborted" && isRecord$2(reason.reason) && reason.reason.kind === "hook" && reason.reason.reason === "deepseek-account/signed-out") return {
 		message: "Stopped because you signed out of DeepSeek.",
 		code: "ACCOUNT_SIGNED_OUT",
 		stopped: true
 	};
 }
-function isRecord$1(value) {
+function isRecord$2(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function matchRoot(roots, cwd) {
@@ -4216,13 +4414,13 @@ function findToolCallDetail(events, callId) {
 	if (callId === void 0) return void 0;
 	for (let index = events.length - 1; index >= 0; index -= 1) {
 		const candidate = events[index];
-		if (!isRecord$1(candidate)) continue;
-		const event = isRecord$1(candidate.event) ? candidate.event : candidate;
-		if (event.type !== "tool/call" || !isRecord$1(event.data)) continue;
+		if (!isRecord$2(candidate)) continue;
+		const event = isRecord$2(candidate.event) ? candidate.event : candidate;
+		if (event.type !== "tool/call" || !isRecord$2(event.data)) continue;
 		const data = event.data;
 		if ((typeof data.callId === "string" ? data.callId : typeof data.id === "string" ? data.id : void 0) !== callId) continue;
 		const args = decodeToolArguments(data.arguments);
-		if (isRecord$1(args) && typeof args.command === "string") return args.command;
+		if (isRecord$2(args) && typeof args.command === "string") return args.command;
 		if (typeof args === "string") return args;
 		if (args !== void 0) return JSON.stringify(args, null, 2);
 	}
@@ -4467,7 +4665,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 +4679,8 @@ var WorkspaceDatabase = class {
 					name,
 					scopes,
 					rootIds,
-					createdAt: now
+					createdAt: now,
+					nameSource
 				}
 			};
 		} catch (error) {
@@ -4508,9 +4708,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 +4791,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) {
@@ -4616,9 +4887,62 @@ var WorkspaceDatabase = class {
 	* 干净的办法制造这种行，而它不该走生产代码路径 —— 所以显式开一个测试专用入口，
 	* 并起一个自见其明的名字，免得有人把它当成正常 API。
 	*/
+	/**
+	* 仅供测试：把某台设备的「最后使用时间/创建时间」拨到过去。
+	*
+	* 生产路径没法造出「30 天没动过」的设备（认证一次就刷新 `last_seen_at`），而
+	* `pruneInactiveDevices` 的核心语义恰恰只在这种时间跨度上才看得见。与
+	* `markRevokedForTest` 同样的理由：显式开一个自见其明的测试入口，别让人误当 API。
+	*/
+	backdateDeviceForTest(id, options) {
+		if (options.lastSeenAt !== void 0) this.db.prepare("UPDATE devices SET last_seen_at = ? WHERE id = ?").run(options.lastSeenAt, id);
+		if (options.createdAt !== void 0) this.db.prepare("UPDATE devices SET created_at = ? WHERE id = ?").run(options.createdAt, id);
+	}
 	markRevokedForTest(id) {
 		this.db.prepare("UPDATE devices SET revoked_at = ? WHERE id = ?").run(Date.now(), id);
 	}
+	/**
+	* 按「最后使用时间」批量清掉长期没动过的设备。
+	*
+	* 「最后使用」取 `last_seen_at`（每次令牌认证成功都会刷新），从没认证过的设备退回
+	* `created_at` —— 否则一条配好就再没开过的设备会永远躲过清理，而那恰恰是用户最想
+	* 一键清掉的那类（换手机、临时配对、旧测试探针）。
+	*
+	* 与 `purgeRevokedDevices` 的区别：后者清的是历史遗留的「标记式撤销」脏行，这里清的是
+	* **仍然有效、但已经不用了**的设备 —— 用户的原话是「一键清理多少天未使用设备」。
+	*
+	* 语义边界（故意这么定）：
+	* - 只删设备行 + 级联的 `device_roots`，不碰审计（审计的 `actor_id` 不是外键）；
+	* - **不删本机正在用的那台**（`keepDeviceId`）：调用方就是它，删掉自己会让当前
+	*   客户端立刻 401，看起来像「点一下清理把手机踢下线了」；
+	* - 天数被夹在 1..3650，避免 `0` 或负数变成「清空所有设备」；
+	* - 返回真正删掉的条数，0 也是一次合法结果。
+	*/
+	pruneInactiveDevices(olderThanDays, options = {}) {
+		const days = Math.min(3650, Math.max(1, Math.trunc(olderThanDays)));
+		const cutoff = Date.now() - days * 24 * 60 * 60 * 1e3;
+		const rows = this.db.prepare("SELECT id, name FROM devices WHERE COALESCE(last_seen_at, created_at) < ? AND id IS NOT ?").all(cutoff, options.keepDeviceId ?? null);
+		if (rows.length === 0) {
+			this.devicesRevisionCounter += 1;
+			return 0;
+		}
+		this.db.exec("BEGIN IMMEDIATE");
+		try {
+			const statement = this.db.prepare("DELETE FROM devices WHERE id = ?");
+			for (const row of rows) statement.run(row.id);
+			this.audit("admin", "loopback-admin", "device.prune", void 0, void 0, {
+				olderThanDays: days,
+				pruned: rows.length,
+				names: rows.map((row) => row.name)
+			}, options.requestId);
+			this.db.exec("COMMIT");
+		} catch (error) {
+			this.db.exec("ROLLBACK");
+			throw error;
+		}
+		this.devicesRevisionCounter += 1;
+		return rows.length;
+	}
 	purgeRevokedDevices() {
 		if (this.db.prepare("SELECT id FROM devices WHERE revoked_at IS NOT NULL").all().length === 0) {
 			this.devicesRevisionCounter += 1;
@@ -4752,6 +5076,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 约束。 */
@@ -4794,12 +5121,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();
 }
@@ -5448,6 +5797,176 @@ function probeHostServices(host, pluginVersion) {
 	};
 }
 //#endregion
+//#region src/host/im-command.ts
+/**
+* `/tunnel` —— 从即时通讯（微信 / 飞书 / 钉钉 / 企业微信 …）里远程开隧道并取回配置文本。
+*
+* ## 为什么需要它
+*
+* 用户常见的困境是「人已经出门，才发现电脑上的 Cloudflare 隧道没开，配置文本也没发给自己」。
+* 此时公网入口不存在，WebUI 与 App 都够不着这台机器 —— 唯一的反向通道是 IM 机器人的
+* **长连接**（手机/IM 云 → 本机主动连出去，不需要任何入站端口）。
+*
+* 本模块只做一件事：注册一条 `/tunnel` 命令，把「开隧道 + 生成 DSH1 配置文本」的结果
+* 直接作为聊天消息回给发送者。**不做停止、不做改配置、不读任何文件** —— 攻击面刻意压到
+* 「最多被人开一次隧道」，而隧道本身不授予任何数据面权限（数据面仍要设备令牌）。
+*
+* ## 门禁在哪里（重要）
+*
+* 本命令**自己不做身份校验**，它依赖 IM 插件在派发命令之前执行的访问策略：
+* `@xmanrui/dsh-im` 的每个机器人都有 `canExecuteCommands` / `defaultCanExecuteCommands`，
+* 非白名单发送者的 `/xxx` 根本到不了这里（`lib/index.js` 的 access policy 判定）。因此
+* 部署侧的必要条件是：**机器人保持 allowlist 模式，且只把自己加进白名单**。
+* 这条约束写在 README「远程开隧道」一节与 SECURITY.md 里，别只在代码注释里说。
+*
+* ## 为什么直接调宿主 API 而不是走 HTTP 自调用
+*
+* 「已开隧道」这一状态下，`/manage` 管理面被判据 0 整体关门（`auth.ts` 的
+* `TUNNEL_MODE_ADMIN_DISABLED`），`/manage/config/text` 必然 403 —— 走 HTTP 就取不到
+* 配置文本。命令在插件进程内执行，与路由共用同一个隧道管理器与同一套建配置逻辑，
+* 天然绕开这个自锁，且不需要为它额外豁免任何端点。
+*
+* @module dsh-remote-bridge/im-command
+*/
+/** 命令名（不带斜杠）。 */
+const TUNNEL_COMMAND_NAME = "tunnel";
+/** 命令描述：会出现在 IM 的 `/help` 里。 */
+const TUNNEL_COMMAND_DESCRIPTION = "开启 Cloudflare 隧道并返回一行配置文本（DSH1:…）";
+/** 把结果拼成聊天消息。 */
+function formatTunnelReply(result) {
+	return [
+		"云隧道已开启。",
+		`地址：${result.url}`,
+		`设备名：${result.deviceName}`,
+		"配置文本（一行，复制后粘贴到 App 的「导入配置」）：",
+		result.text
+	].join("\n");
+}
+/**
+* 创建 `/tunnel` 的命令定义（不注册，纯数据，便于单测）。
+*
+* 参数只接受空串：本命令刻意**不接受**任何开关，避免出现「`/tunnel stop`」这种需要
+* 额外鉴权语义的入口。带参数一律回用法说明。
+*/
+function createTunnelCommand(deps) {
+	/** 同一时刻只允许一次开隧道（IM 侧重发、双端同时发都可能撞上）。 */
+	let inFlight = false;
+	return {
+		name: TUNNEL_COMMAND_NAME,
+		description: TUNNEL_COMMAND_DESCRIPTION,
+		input: { hint: "（无需参数）" },
+		async handler(invocation) {
+			if (invocation.rawInput.trim().length > 0) return {
+				kind: "error",
+				text: "用法：/tunnel（不需要参数）"
+			};
+			if (inFlight) return {
+				kind: "error",
+				text: "上一次开隧道还没结束，请稍等几秒再发一次。"
+			};
+			inFlight = true;
+			try {
+				const result = await deps.openTunnel();
+				deps.logger?.info(`[dsh-remote-bridge] /tunnel 已开启隧道 ${result.url}`);
+				return {
+					kind: "success",
+					text: formatTunnelReply(result)
+				};
+			} catch (cause) {
+				const message = cause instanceof Error ? cause.message : String(cause);
+				deps.logger?.warn(cause instanceof Error ? cause : new Error(message));
+				return {
+					kind: "error",
+					text: `开隧道失败：${message}`
+				};
+			} finally {
+				inFlight = false;
+			}
+		}
+	};
+}
+/**
+* 注册 `/tunnel` 并返回注销函数。
+*
+* 注册是**全局层**（不是 agent 子层），所以任何 IM 会话、任何工作区里都能用 ——
+* 这正是本命令的用途：开机时人不在电脑边。是否允许某个人执行，由 IM 插件的
+* 访问策略决定（见模块头注释）。
+*/
+function registerTunnelCommand(registry, deps) {
+	return registry.register(createTunnelCommand(deps));
+}
+/**
+* ## 为什么除命令之外还要一个工具
+*
+* `@xmanrui/dsh-im` 5.4.0 的斜杠命令表是**封闭的**：内置 31 条，另外只把
+* `/compact` `/clear` `/permission` 三条委派给宿主（`lib/index.js` 里
+* `executeCommand("/compact")` 等固定字面量），**没有**「未知命令转交宿主命令表」的通用派发，
+* 也从不调用 `commands.list`。所以在 IM 里发 `/tunnel` 到不了上面那个命令处理函数 ——
+* 它会当成一句普通消息交给智能体。
+*
+* 于是 IM 侧真正可用的入口是**工具**：用户用自然语言说一句（「帮我开隧道，把配置发我」），
+* 智能体调用本工具，结果直接回到聊天里。命令与工具共用同一个 `openTunnel()`，
+* 语义完全一致；两者的差别只是「谁来触发」。
+*/
+/** 工具名（模型可见）。 */
+const TUNNEL_TOOL_NAME = "open_tunnel_config";
+/**
+* 模型可见描述。
+*
+* 写英文是惯例（工具描述面向模型，与仓内其他描述同语言），并显式写清
+* 「用户说开隧道/取配置文本时调用」，否则模型倾向于自己用 bash 拼一条 curl。
+*/
+const TUNNEL_TOOL_DESCRIPTION = "Open the Cloudflare quick tunnel for this DSH host and return a one-line DSH1: config text that a phone app can paste to connect. Use it whenever the user asks to start the tunnel, to get the config text, or says they are away from the computer and need remote access. It never stops the tunnel and never touches files.";
+/** 创建工具定义（不注册，便于单测）。 */
+function createTunnelTool(deps) {
+	return {
+		name: TUNNEL_TOOL_NAME,
+		description: TUNNEL_TOOL_DESCRIPTION,
+		parameters: {},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					url: {
+						type: "string",
+						required: true
+					},
+					text: {
+						type: "string",
+						required: true
+					},
+					deviceName: {
+						type: "string",
+						required: true
+					}
+				},
+				required: true
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: `Tunnel is up at ${value.url}`
+			}, {
+				type: "text",
+				text: value.text
+			}]
+		},
+		async execute() {
+			const result = await deps.openTunnel();
+			deps.logger?.info(`[dsh-remote-bridge] ${TUNNEL_TOOL_NAME} 已开启隧道 ${result.url}`);
+			return {
+				url: result.url,
+				text: result.text,
+				deviceName: result.deviceName
+			};
+		}
+	};
+}
+/** 注册工具并返回注销函数。注册是全局层：任何会话（含 IM 会话）都能调用。 */
+function registerTunnelTool(registry, deps) {
+	return registry.register(createTunnelTool(deps));
+}
+//#endregion
 //#region src/host/retention.ts
 /**
 * 数据保留（retention）调度器：把**会无限增长的两张表**按时间清掉。
@@ -6165,7 +6684,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);
@@ -6308,6 +6827,129 @@ async function inspectResolvedPath(root, wirePath) {
 	};
 }
 //#endregion
+//#region src/host/settings-namespace.ts
+/**
+* 通用设置命名空间的纯逻辑：写允许策略、密钥脱敏、ops 校验与响应投影。
+*
+* 为什么单独成文件（2.6.0）：这一层不碰任何内核 RPC，全部可以纯单测；
+* 而 `settings-adapter.ts` 已贴着 `AGENTS.md` §3.2 的 600 行单文件预算。
+* 拆出来之后两边都不再挤，adapter 只保留「调内核 + 映射错误」的那几行。
+*
+* 契约见 `docs/api/openapi.yaml` 的 SettingsNamespace* 与 `docs/project/API.md`
+* 的「通用设置命名空间」一节；安全判据的理由见 `docs/project/SECURITY.md`。
+*/
+const MAX_OPS = 32;
+/**
+* 键名兜底脱敏正则。
+*
+* **不是主要机制**：内核 `settings.describe()` 已经用 `redactSecrets: true` 读过一遍，
+* role('secret') 的字段不会随响应出网（见 dsh-api-settings-controller 的
+* `namespaceView`/`describe`）。这里是第二道保险 —— 万一某个自定义 schema 漏标了
+* role('secret')，或者凭据被写进了普通字段，桥也不会把它端给手机。
+*
+* `apiKeyEnv` 是环境变量**名**不是密钥值，一并遮蔽是刻意的：名字本身能暴露
+* 「这台机器用哪家 key」，而 App 读设置根本不需要这个名字。
+*/
+const SECRET_KEY = /^(apiKey|secret|token|password|credential|apiKeyEnv)$/i;
+/**
+* 写允许策略：`ui-*`（界面类插件设置）与 `*locale`（语言/区域）默认可写。
+*
+* 其余一律默认只读，尤其是能改「模型、权限、子代理」的命名空间 —— 手机一旦
+* 丢了或被恶意 App 拿到令牌，改模型等于把请求引到攻击者的端点，改权限等于
+* 把审批闸门拆掉。需要放行时由部署者显式配 `settingsWriteNamespaces`。
+*/
+function isSettingsNamespaceWriteAllowed(ns, extra = []) {
+	if (ns.startsWith("ui-") || ns.endsWith("locale")) return true;
+	return extra.some((pattern) => pattern.endsWith("*") ? ns.startsWith(pattern.slice(0, -1)) : ns === pattern);
+}
+/**
+* 单个命名空间不可写的原因。
+*
+* 宿主设置文档整体只读优先报 `HOST_READONLY`：那与 ns 策略无关，修策略也没用。
+*/
+function settingsNamespaceReason(hostWritable, ns, extra = []) {
+	if (!hostWritable) return "HOST_READONLY";
+	if (!isSettingsNamespaceWriteAllowed(ns, extra)) return "HIGH_RISK_NAMESPACE";
+}
+/**
+* 递归遮蔽密钥：键名命中 {@link SECRET_KEY}，或路径整体命中内核给出的
+* `secrets[].path`（前者是兜底，后者才是权威）。
+*
+* 路径按 `\u0000` 拼接比较，避免 `['a.b']` 与 `['a','b']` 混淆；
+* 数组下标也进路径，密钥恰好是数组元素时同样能命中。
+*/
+function redactSettingsSecrets(value, secretPaths = []) {
+	const exact = new Set(secretPaths.map((path) => path.join("\0")));
+	return walk(value, []);
+	function walk(current, path) {
+		if (path.length > 0 && exact.has(path.join("\0"))) return "***";
+		if (typeof current === "string") {
+			const key = path.at(-1);
+			return key !== void 0 && SECRET_KEY.test(key) ? "***" : current;
+		}
+		if (Array.isArray(current)) return current.map((item, index) => walk(item, [...path, String(index)]));
+		if (isRecord$1(current)) return Object.fromEntries(Object.entries(current).map(([key, item]) => [key, walk(item, [...path, key])]));
+		return current;
+	}
+}
+/** 校验并规范化请求里的 `ops`；结构不合法一律 400 `SETTINGS_OPS_INVALID`。 */
+function parseSettingsNamespaceOps(input) {
+	if (!Array.isArray(input) || input.length === 0 || input.length > MAX_OPS) throw new ApiError(400, "SETTINGS_OPS_INVALID", `ops must be an array of 1 to ${MAX_OPS} operations.`);
+	return input.map((raw, index) => {
+		const where = `ops[${index}]`;
+		if (!isRecord$1(raw)) throw invalid(`${where} must be an object.`);
+		if (raw.op !== "set" && raw.op !== "unset") throw invalid(`${where}.op must be "set" or "unset".`);
+		if (!Array.isArray(raw.path) || raw.path.some((segment) => typeof segment !== "string")) throw invalid(`${where}.path must be an array of strings.`);
+		const path = [...raw.path];
+		if (raw.op === "unset") return {
+			op: "unset",
+			path
+		};
+		if (!Object.hasOwn(raw, "value")) throw invalid(`${where}.value is required for "set".`);
+		return {
+			op: "set",
+			path,
+			value: raw.value
+		};
+	});
+}
+/** 审计用字段清单：只记路径，**绝不记值**。根路径（空数组）不产生字段名。 */
+function settingsNamespaceOpFields(ops) {
+	return [...new Set(ops.map((op) => op.path.join(".")).filter((field) => field !== ""))];
+}
+/** 本次写入是否碰到了密钥位（审计 `credentialChanged`）；只看路径，不看值。 */
+function settingsNamespaceCredentialChanged(ops, secrets) {
+	if (secrets === void 0 || secrets.length === 0) return false;
+	const exact = new Set(secrets.map((secret) => secret.path.join("\0")));
+	return ops.some((op) => exact.has(op.path.join("\0")));
+}
+/** 内核视图 → 对外视图：叠加写策略并脱敏。 */
+function projectSettingsNamespace(view, hostWritable, extra = []) {
+	const writable = hostWritable && isSettingsNamespaceWriteAllowed(view.ns, extra);
+	const secretPaths = (view.secrets ?? []).map((secret) => secret.path);
+	const project = (value) => redactSettingsSecrets(value, secretPaths);
+	const reason = settingsNamespaceReason(hostWritable, view.ns, extra);
+	return {
+		ns: view.ns,
+		revision: view.revision,
+		...view.schema === void 0 ? {} : { schema: view.schema },
+		value: project(view.value),
+		...view.base === void 0 ? {} : { base: project(view.base) },
+		...view.user === void 0 ? {} : { user: project(view.user) },
+		...view.autoGenerate === void 0 ? {} : { autoGenerate: view.autoGenerate },
+		...view.applies === void 0 ? {} : { applies: view.applies },
+		...view.secrets === void 0 ? {} : { secrets: view.secrets },
+		writable,
+		...reason === void 0 ? {} : { reason }
+	};
+}
+function invalid(message) {
+	return new ApiError(400, "SETTINGS_OPS_INVALID", message);
+}
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
 //#region src/host/wire-json.ts
 /**
 * 出网 JSON 的安全序列化：把**孤立 UTF-16 代理项**换成 U+FFFD。
@@ -6532,12 +7174,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") {
@@ -6653,10 +7301,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;
@@ -6667,6 +7316,27 @@ var ApiRouter = class {
 			sendJson(res, 200, await this.options.settings.catalog());
 			return;
 		}
+		if (method === "GET" && pathname === "/api/v1/settings/namespaces") {
+			this.options.auth.requireScope(principal, "settings.read");
+			sendJson(res, 200, await this.options.settings.describeNamespaces());
+			return;
+		}
+		const settingsNamespaceRoute = pathname.match(/^\/api\/v1\/settings\/namespaces\/([^/]+)$/);
+		if (settingsNamespaceRoute !== null && method === "PATCH") {
+			this.options.auth.requireScope(principal, "settings.write");
+			const ns = decodePathSegment(settingsNamespaceRoute[1]);
+			const body = await readJson(req, 256e3);
+			const record = typeof body === "object" && body !== null ? body : {};
+			const ops = parseSettingsNamespaceOps(record.ops);
+			const entry = await this.options.settings.mutateNamespace(ns, ops, settingsExpectedRevision(record.expectedRevision));
+			this.audit(principal, "settings.namespace.mutate", void 0, void 0, requestId, {
+				ns,
+				fields: settingsNamespaceOpFields(ops),
+				credentialChanged: settingsNamespaceCredentialChanged(ops, entry.secrets)
+			});
+			sendJson(res, 200, entry);
+			return;
+		}
 		if (method === "GET" && pathname === "/api/v1/settings/plugins") {
 			this.options.auth.requireScope(principal, "settings.read");
 			const inventory = await readPluginInventory();
@@ -6698,11 +7368,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;
@@ -6727,9 +7398,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") {
@@ -7049,12 +7723,26 @@ var ApiRouter = class {
 			sendJson(res, 200, { items: this.options.database.listDevices() });
 			return;
 		}
+		if (method === "POST" && pathname === "/manage/devices/prune") {
+			const raw = (await readJson(req, 64e3)).olderThanDays;
+			if (typeof raw !== "number" || !Number.isFinite(raw) || !Number.isInteger(raw) || raw < 1 || raw > 3650) throw new ApiError(400, "INVALID_OLDER_THAN_DAYS", "olderThanDays must be an integer between 1 and 3650.");
+			sendJson(res, 200, { pruned: this.options.database.pruneInactiveDevices(raw, { requestId }) });
+			return;
+		}
 		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") {
@@ -7130,44 +7818,9 @@ var ApiRouter = class {
 		}
 		if (this.options.tunnels !== void 0 && method === "POST" && pathname === "/manage/cloudflare/create") {
 			const createBody = await readJson(req, 64e3).catch(() => ({}));
-			const wantConfig = createBody.configText === true;
-			const binDir = this.options.cloudflaredBinDir;
-			let exe;
-			try {
-				exe = await ensureCloudflared(binDir ?? this.options.database.dataDir, (a) => {
-					this.options.tunnels.reportActivity(a);
-				});
-			} catch (cause) {
-				this.options.tunnels.clearActivity();
-				throw new ApiError(502, "TUNNEL_DOWNLOAD_FAILED", "Failed to download or unpack cloudflared. Check the network and retry, or set CLOUDFLARED_MIRROR.", {
-					errorKey: "tunnelErrorDownload",
-					...cause instanceof Error ? { reason: sanitizeDownloadError(cause.message) } : {}
-				});
-			}
-			const port = this.options.remote.status().configuredPort ?? 3090;
-			const state = await this.options.tunnels.startQuick(exe, port);
-			let configText;
-			let resolvedUrl = state.url;
-			if (wantConfig) {
-				const tunnelUrl = state.url ?? await this.options.tunnels.waitForUrl();
-				resolvedUrl = tunnelUrl;
-				if (tunnelUrl !== null) configText = this.buildConfigText({
-					endpoints: [{
-						label: readOptionalText(createBody.endpointLabel) ?? "云隧道",
-						baseUrl: tunnelUrl
-					}],
-					...createBody.rootIds === void 0 ? {} : { rootIds: createBody.rootIds },
-					...createBody.deviceName === void 0 ? {} : { deviceName: createBody.deviceName }
-				}, requestId);
-			}
-			this.options.tunnels.clearActivity();
-			this.options.database.audit("admin", "loopback-admin", "cloudflare.create", void 0, void 0, {}, requestId);
-			const responseState = resolvedUrl === state.url ? state : {
+			const { state, configText } = await this.createTunnel(createBody, requestId, "loopback-admin");
+			sendJson(res, 201, configText === void 0 ? state : {
 				...state,
-				url: resolvedUrl
-			};
-			sendJson(res, 201, configText === void 0 ? responseState : {
-				...responseState,
 				configText
 			});
 			return;
@@ -7181,6 +7834,99 @@ var ApiRouter = class {
 		throw new ApiError(404, "ROUTE_NOT_FOUND", "The requested management route does not exist.");
 	}
 	/**
+	* 打开隧道并（可选）顺带产出配置文本 —— HTTP `POST /manage/cloudflare/create` 与
+	* IM `/tunnel` 命令**共用**这一条实现。
+	*
+	* 抽出来的原因：两条入口的前半段完全一致（确保 cloudflared → startQuick → 等随机域名 →
+	* 建配置文本），差别只在「谁在调用」——HTTP 侧要先把请求体读干净（流会随时间关闭），
+	* 命令侧没有请求体。复制一份会让「一键出令牌」在两条路径上慢慢漂移。
+	*
+	* @param createBody - 已解析的请求体（HTTP 侧）或 `{ configText: true }`（命令侧）。
+	* @param requestId - 审计与配对记录共用的请求 ID。
+	* @param actorLabel - 审计里的操作者标签：`loopback-admin`（本机管理面）或 `im-command`。
+	* @returns 合并了「等到地址」的 state，以及（wantConfig 且拿到地址时）配置文本。
+	*/
+	async createTunnel(createBody, requestId, actorLabel) {
+		const wantConfig = createBody.configText === true;
+		const binDir = this.options.cloudflaredBinDir;
+		let exe;
+		try {
+			exe = await ensureCloudflared(binDir ?? this.options.database.dataDir, (a) => {
+				this.options.tunnels.reportActivity(a);
+			});
+		} catch (cause) {
+			this.options.tunnels.clearActivity();
+			throw new ApiError(502, "TUNNEL_DOWNLOAD_FAILED", "Failed to download or unpack cloudflared. Check the network and retry, or set CLOUDFLARED_MIRROR.", {
+				errorKey: "tunnelErrorDownload",
+				...cause instanceof Error ? { reason: sanitizeDownloadError(cause.message) } : {}
+			});
+		}
+		const port = this.options.remote.status().configuredPort ?? 3090;
+		const state = await this.options.tunnels.startQuick(exe, port);
+		let configText;
+		let resolvedUrl = state.url;
+		if (wantConfig) {
+			const tunnelUrl = state.url ?? await this.options.tunnels.waitForUrl();
+			resolvedUrl = tunnelUrl;
+			if (tunnelUrl !== null) configText = this.buildConfigText({
+				endpoints: [{
+					label: readOptionalText(createBody.endpointLabel) ?? "云隧道",
+					baseUrl: tunnelUrl
+				}],
+				...createBody.rootIds === void 0 ? {} : { rootIds: createBody.rootIds },
+				...createBody.deviceName === void 0 ? {} : { deviceName: createBody.deviceName }
+			}, requestId);
+		}
+		this.options.tunnels.clearActivity();
+		this.options.database.audit("admin", actorLabel, "cloudflare.create", void 0, void 0, {}, requestId);
+		return {
+			state: resolvedUrl === state.url ? state : {
+				...state,
+				url: resolvedUrl
+			},
+			...configText === void 0 ? {} : { configText }
+		};
+	}
+	/**
+	* IM `/tunnel` 命令的宿主侧入口：开隧道并返回一行可粘贴的配置文本。
+	*
+	* 与 HTTP 路径的两点差别：
+	*
+	* 1. **隧道已在运行时直接复用当前地址**，不重复 spawn（第二次 `startQuick` 会撞
+	*    `TUNNEL_ALREADY_RUNNING`，而用户在 IM 里连发两条是很常见的）。
+	* 2. 配置文本的 endpoint 只用隧道地址，设备名缺省由 `buildConfigText` 决定 —— 命令
+	*    不接受参数，所以没有 `endpointLabel` / `rootIds` 的透传面。
+	*
+	* @throws 当 12 秒内没拿到公网地址，或 cloudflared 下载失败时。
+	*/
+	async openTunnelForCommand() {
+		const tunnels = this.options.tunnels;
+		if (tunnels === void 0) throw new Error("隧道功能未启用。");
+		const requestId = randomUUID();
+		const current = tunnels.publicState;
+		if (current.running === true && current.url !== null) {
+			const reused = this.buildConfigText({ endpoints: [{
+				label: "云隧道",
+				baseUrl: current.url
+			}] }, requestId);
+			this.options.database.audit("admin", "im-command", "cloudflare.create", void 0, void 0, { reused: true }, requestId);
+			return {
+				url: current.url,
+				text: reused.text,
+				deviceName: reused.deviceName
+			};
+		}
+		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 : DEFAULT_DEVICE_NAME;
+		return {
+			url: state.url,
+			text,
+			deviceName
+		};
+	}
+	/**
 	* 隧道状态视图。
 	*
 	* **这里不做脱敏，因为用不上**：判据 1 已经把 Cloudflare 边缘头（`Cf-Connecting-IP` /
@@ -7213,10 +7959,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,
@@ -7529,16 +8278,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();
@@ -7572,6 +8316,17 @@ function optionalInteger(value) {
 	if (!Number.isSafeInteger(parsed) || parsed < 0) throw new ApiError(400, "NUMBER_INVALID", "A query parameter must be a non-negative integer.");
 	return parsed;
 }
+/**
+* 请求体里的 `expectedRevision`。
+*
+* 不复用 `optionalInteger()`：它读的是查询串（字符串）且错误码是 `NUMBER_INVALID`；
+* 这里是 JSON 数字，非法时属于「ops 请求体不合法」，契约要求 `SETTINGS_OPS_INVALID`。
+*/
+function settingsExpectedRevision(value) {
+	if (value === void 0) return void 0;
+	if (!Number.isSafeInteger(value) || value < 0) throw new ApiError(400, "SETTINGS_OPS_INVALID", "expectedRevision must be a non-negative integer.");
+	return value;
+}
 function commandName(line) {
 	return /^\/([a-z][a-z0-9_-]*)/u.exec(line)?.[1] ?? "unknown";
 }
@@ -8395,6 +9150,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 上下文的复用窗口。
@@ -8407,8 +9305,78 @@ const PROVIDER_CONTEXT_TTL_MS = 1e3;
 const PROVIDER_CONTEXT_CACHE_LIMIT = 128;
 var DshSettingsAdapter = class {
 	api;
-	constructor(api) {
+	options;
+	/**
+	* @param options.writeNamespaces 额外允许手机端写入的设置命名空间（精确 ns 或
+	*   `前缀*`），与内置策略（`ui-*` / 以 `locale` 结尾）叠加；默认为空。
+	* @param options.allowPrivateProviderHosts 允许供应商 `baseURL` 指向的私网 / 回环
+	*   host 白名单（默认空 = 一律拒绝）。要连本地 LLM 的部署方显式填，理由见
+	*   `provider-url-policy.ts` 文件头。
+	*/
+	constructor(api, options = {}) {
 		this.api = api;
+		this.options = options;
+	}
+	/**
+	* 列出全部设置命名空间（通用设置面的读侧）。
+	*
+	* 与 `listProviders()` 的区别：它不理解任何 provider 语义，原样透出内核按插件
+	* 划分的命名空间，由手机端按 `schema` 自己长表单 —— 新装插件不必等 App 发版。
+	*/
+	async describeNamespaces() {
+		const described = unwrapDsh(await this.settingsService().describe({
+			rpcId: randomUUID(),
+			payload: {}
+		}));
+		return {
+			writable: described.writable,
+			namespaces: described.namespaces.map((view) => projectSettingsNamespace(view, described.writable, this.writeNamespaces))
+		};
+	}
+	/**
+	* 按路径改一个命名空间（通用设置面的写侧）。
+	*
+	* 校验顺序是刻意的：ns 策略 → ops 结构 → 内核 describe（host 可写性）→ mutate。
+	* 先验策略既省一次内核往返，也保证「高危命名空间」无论 ops 怎么错都先得到 403。
+	*/
+	async mutateNamespace(ns, ops, expectedRevision) {
+		if (!isSettingsNamespaceWriteAllowed(ns, this.writeNamespaces)) throw new ApiError(403, "SETTINGS_NAMESPACE_READONLY", `The settings namespace "${ns}" is not writable from this bridge.`, {
+			ns,
+			reason: "HIGH_RISK_NAMESPACE"
+		});
+		const normalized = parseSettingsNamespaceOps(ops);
+		const described = unwrapDsh(await this.settingsService().describe({
+			rpcId: randomUUID(),
+			payload: {}
+		}));
+		if (!described.writable) throw new ApiError(409, "SETTINGS_READ_ONLY", "DSH settings are read-only.");
+		let mutated;
+		try {
+			mutated = unwrapDsh(await this.settingsService().mutate({
+				rpcId: randomUUID(),
+				payload: {
+					ns,
+					ops: normalized,
+					...expectedRevision === void 0 ? {} : { expectedRevision }
+				}
+			}));
+		} catch (error) {
+			throw mapSettingsMutationError(error);
+		}
+		return projectSettingsNamespace(mutated, described.writable, this.writeNamespaces);
+	}
+	get writeNamespaces() {
+		return this.options.writeNamespaces ?? [];
+	}
+	/** 交给地址策略的选项；集中一处，三个入口不会各配各的。 */
+	get baseURLOptions() {
+		return { allowPrivateHosts: this.options.allowPrivateProviderHosts ?? [] };
+	}
+	/** 内核 settings 服务缺失时给 503（而不是把 `TypeError` 漏成 500）。 */
+	settingsService() {
+		const settings = this.api.settings;
+		if (settings === void 0) throw new ApiError(503, "SETTINGS_UNAVAILABLE", "The DSH settings service is not available.");
+		return settings;
 	}
 	async listProviders() {
 		const [directoryResponse, settingsResponse, catalogResponse] = await Promise.all([
@@ -8491,11 +9459,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",
@@ -8505,6 +9482,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]
@@ -8514,6 +9492,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",
@@ -8556,11 +9538,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({
@@ -8607,6 +9590,7 @@ var DshSettingsAdapter = class {
 			}
 		}));
 		this.invalidateProviderContext(id);
+		return { baseURLHost };
 	}
 	async removeProvider(providerId, expectedRevision) {
 		const context = await this.providerContext(providerId);
@@ -8625,18 +9609,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）。
@@ -8695,10 +9696,38 @@ 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` 的错误翻成契约错误码。
+*
+* `unwrapDsh()` 的通用映射只认 `busy` / `locked` 为 409，所以内核的
+* `settings/conflict` 会落到 400 `DSH_SETTINGS_CONFLICT` —— 这里按契约改回
+* 409 `SETTINGS_CONFLICT`（客户端据此提示「刷新后重试」而不是「参数不对」）。
+* `settings/rejected` 是 ops 在 schema 上不合法，落回 400 `SETTINGS_OPS_INVALID`。
+*/
+function mapSettingsMutationError(error) {
+	if (!(error instanceof ApiError)) return error;
+	if (error.code.includes("SETTINGS") && error.code.includes("CONFLICT")) return new ApiError(409, "SETTINGS_CONFLICT", "Settings changed since they were read; refresh and retry.", error.details);
+	if (error.code.includes("SETTINGS") && error.code.includes("REJECTED")) return new ApiError(400, "SETTINGS_OPS_INVALID", error.message, error.details);
+	return error;
+}
 function projectConfig(profile, inheritedModels) {
 	const baseURL = text(profile?.baseURL);
 	const api = text(profile?.api);
@@ -8780,6 +9809,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
 /**
@@ -8857,7 +9918,10 @@ async function apply(ctx, config = {}) {
 		agents: ctx.agents,
 		commands: ctx.commands
 	});
-	const settings = new DshSettingsAdapter(apiProxy);
+	const settings = new DshSettingsAdapter(apiProxy, {
+		writeNamespaces: config.settingsWriteNamespaces ?? [],
+		allowPrivateProviderHosts: config.allowPrivateProviderHosts ?? []
+	});
 	let hostServiceReport;
 	try {
 		hostServiceReport = probeHostServices(ctx, PLUGIN_VERSION);
@@ -8908,6 +9972,34 @@ async function apply(ctx, config = {}) {
 		path: IMAGE_ROUTE,
 		handler: imageRoute
 	}]);
+	try {
+		ctx.effect(() => registerTunnelCommand(ctx.commands, {
+			openTunnel: () => router.openTunnelForCommand(),
+			logger: {
+				info: (message) => ctx.logger.info(message),
+				warn: (error) => ctx.logger.warn(error)
+			}
+		}), "dsh-remote-bridge /tunnel command");
+	} catch (error) {
+		ctx.logger.warn(/* @__PURE__ */ new Error(`dsh-remote-bridge: /tunnel command registration failed (ignored): ${String(error)}`));
+	}
+	let toolsService;
+	try {
+		toolsService = reflect?.get?.("tools", false);
+	} catch {
+		toolsService = void 0;
+	}
+	if (toolsService !== void 0) try {
+		ctx.effect(() => registerTunnelTool(toolsService, {
+			openTunnel: () => router.openTunnelForCommand(),
+			logger: {
+				info: (message) => ctx.logger.info(message),
+				warn: (error) => ctx.logger.warn(error)
+			}
+		}), "dsh-remote-bridge open_tunnel_config tool");
+	} catch (error) {
+		ctx.logger.warn(/* @__PURE__ */ new Error(`dsh-remote-bridge: open_tunnel_config registration failed (ignored): ${String(error)}`));
+	}
 	ctx.effect(() => async () => {
 		disposeEmbedded();
 		await remote.stop();