dsh-remote-bridge 0.0.0-stage → 2.2.0

package/lib/index.js

@@ -0,0 +1,4008 @@
+import path from "node:path";
+import { createHash, randomBytes, randomUUID } from "node:crypto";
+import { chmod, copyFile, lstat, mkdir, open, readFile, readdir, readlink, realpath, rename, rm, stat, symlink, unlink, writeFile } from "node:fs/promises";
+import { createReadStream, mkdirSync } from "node:fs";
+import { DatabaseSync } from "node:sqlite";
+import { pipeline } from "node:stream/promises";
+import { isIP } from "node:net";
+import os, { hostname, networkInterfaces } from "node:os";
+import { createServer } from "node:http";
+import { WebSocket, WebSocketServer } from "ws";
+//#region src/shared/contracts.ts
+const DEVICE_SCOPES = [
+	"chat.read",
+	"chat.write",
+	"files.read",
+	"files.write",
+	"files.delete",
+	"settings.read",
+	"settings.write"
+];
+const ADMIN_PRINCIPAL = {
+	kind: "admin",
+	id: "loopback-admin",
+	scopes: new Set(DEVICE_SCOPES),
+	rootIds: "all"
+};
+//#endregion
+//#region src/host/errors.ts
+var ApiError = class extends Error {
+	status;
+	code;
+	details;
+	constructor(status, code, message, details) {
+		super(message);
+		this.status = status;
+		this.code = code;
+		this.details = details;
+		this.name = "ApiError";
+	}
+};
+function asApiError(error) {
+	if (error instanceof ApiError) return error;
+	return new ApiError(500, "INTERNAL_ERROR", "An internal server error occurred.");
+}
+//#endregion
+//#region src/host/rate-limit.ts
+var FixedWindowLimiter = class {
+	limit;
+	windowMs;
+	buckets = /* @__PURE__ */ new Map();
+	constructor(limit, windowMs) {
+		this.limit = limit;
+		this.windowMs = windowMs;
+	}
+	consume(key) {
+		const now = Date.now();
+		const current = this.buckets.get(key);
+		if (current === void 0 || current.resetAt <= now) {
+			this.buckets.set(key, {
+				count: 1,
+				resetAt: now + this.windowMs
+			});
+			this.sweep(now);
+			return;
+		}
+		current.count += 1;
+		if (current.count > this.limit) throw new ApiError(429, "RATE_LIMITED", "Too many requests. Try again later.", { retryAfterMs: current.resetAt - now });
+	}
+	sweep(now) {
+		if (this.buckets.size < 2048) return;
+		for (const [key, bucket] of this.buckets) if (bucket.resetAt <= now) this.buckets.delete(key);
+	}
+};
+//#endregion
+//#region src/host/auth.ts
+var AuthService = class {
+	database;
+	authFailures = new FixedWindowLimiter(20, 3e5);
+	pairingAttempts = new FixedWindowLimiter(10, 6e5);
+	requests = new FixedWindowLimiter(120, 6e4);
+	constructor(database) {
+		this.database = database;
+	}
+	principal(req, options = {}) {
+		const remote = requestAddress(req);
+		this.requests.consume(remote);
+		if (options.allowAdmin === true && req.headers["x-dsh-workspace-admin"] === "1" && isLoopbackAddress(remote) && isLoopbackOrigin(req.headers.origin)) return ADMIN_PRINCIPAL;
+		const authorization = req.headers.authorization;
+		if (authorization === void 0 || !authorization.startsWith("Bearer ")) {
+			this.authFailures.consume(remote);
+			throw new ApiError(401, "AUTH_REQUIRED", "A valid Bearer token is required.");
+		}
+		const token = authorization.slice(7).trim();
+		const device = token === "" ? void 0 : this.database.authenticate(token);
+		if (device === void 0) {
+			this.authFailures.consume(remote);
+			throw new ApiError(401, "TOKEN_INVALID", "The device token is invalid or revoked.");
+		}
+		return {
+			kind: "device",
+			id: device.id,
+			name: device.name,
+			scopes: new Set(device.scopes),
+			rootIds: new Set(device.rootIds)
+		};
+	}
+	requireAdmin(req) {
+		if (!isLoopbackAddress(requestAddress(req)) || !isLoopbackOrigin(req.headers.origin)) throw new ApiError(403, "ADMIN_LOOPBACK_REQUIRED", "This operation is available only from the local machine.");
+		return ADMIN_PRINCIPAL;
+	}
+	requireScope(principal, scope) {
+		if (!principal.scopes.has(scope)) throw new ApiError(403, "SCOPE_REQUIRED", `The ${scope} scope is required.`);
+	}
+	requireRoot(principal, rootId) {
+		if (principal.rootIds !== "all" && !principal.rootIds.has(rootId)) throw new ApiError(403, "ROOT_FORBIDDEN", "This device is not authorized for the requested root.");
+	}
+};
+function requestAddress(req) {
+	return req.socket.remoteAddress ?? "unknown";
+}
+function isLoopbackAddress(address) {
+	const normalized = address.toLowerCase().split("%")[0];
+	return normalized === "127.0.0.1" || normalized === "::1" || normalized === "::ffff:127.0.0.1";
+}
+function isLoopbackOrigin(origin) {
+	if (origin === void 0) return true;
+	try {
+		const hostname = new URL(origin).hostname.toLowerCase();
+		return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]" || hostname === "::1";
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/host/path-policy.ts
+const WINDOWS_RESERVED = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\..*)?$/i;
+function validateRelativePath(value) {
+	if (typeof value !== "string") throw new ApiError(400, "PATH_INVALID", "Relative path must be a string.");
+	if (value.includes("\0")) throw new ApiError(400, "PATH_INVALID", "Relative path contains a null byte.");
+	if (value.includes("\\")) throw new ApiError(400, "PATH_INVALID", "Wire paths must use forward slashes.");
+	if (value.startsWith("/") || value.startsWith("//") || /^[A-Za-z]:/.test(value)) throw new ApiError(400, "PATH_INVALID", "Absolute, drive-letter, and UNC paths are forbidden.");
+	if (value === "") return [];
+	const segments = value.split("/");
+	for (const segment of segments) {
+		if (segment === "" || segment === "." || segment === "..") throw new ApiError(400, "PATH_INVALID", "Relative path contains an empty or forbidden segment.");
+		if (process.platform === "win32") {
+			if (segment.includes(":") || /[. ]$/.test(segment) || WINDOWS_RESERVED.test(segment)) throw new ApiError(400, "PATH_INVALID", "Relative path contains a name unsupported on Windows.");
+		}
+	}
+	return segments;
+}
+async function canonicalRoot(input) {
+	let canonical;
+	try {
+		canonical = await realpath(path.resolve(input));
+	} catch {
+		throw new ApiError(400, "ROOT_INVALID", "The authorized root does not exist or cannot be resolved.");
+	}
+	if (!(await stat(canonical)).isDirectory()) throw new ApiError(400, "ROOT_INVALID", "The authorized root must be a directory.");
+	return canonical;
+}
+async function resolveAuthorizedPath(root, relativePath, options = {}) {
+	const segments = validateRelativePath(relativePath);
+	let current = root;
+	if (segments.length === 0) return {
+		absolutePath: root,
+		exists: true,
+		leafIsLink: false
+	};
+	for (let index = 0; index < segments.length; index += 1) {
+		current = path.join(current, segments[index]);
+		let info;
+		try {
+			info = await lstat(current);
+		} catch (error) {
+			const code = error.code;
+			const isLeaf = index === segments.length - 1;
+			if (code === "ENOENT" && isLeaf && options.allowMissingLeaf === true) return {
+				absolutePath: current,
+				exists: false,
+				leafIsLink: false
+			};
+			if (code === "ENOENT") throw new ApiError(404, "PATH_NOT_FOUND", "The requested path does not exist.");
+			throw error;
+		}
+		const isLeaf = index === segments.length - 1;
+		if (info.isSymbolicLink()) {
+			if (!isLeaf || options.allowLeafLink !== true) throw new ApiError(403, "LINK_TRAVERSAL_FORBIDDEN", "Symbolic links and junctions cannot be traversed.");
+			return {
+				absolutePath: current,
+				exists: true,
+				leafIsLink: true
+			};
+		}
+		if (!isLeaf && !info.isDirectory()) throw new ApiError(400, "PATH_NOT_DIRECTORY", "An intermediate path segment is not a directory.");
+	}
+	if (!isPathInside(root, current)) throw new ApiError(403, "PATH_OUTSIDE_ROOT", "The path escaped its authorized root.");
+	return {
+		absolutePath: current,
+		exists: true,
+		leafIsLink: false
+	};
+}
+function isPathInside(root, candidate) {
+	const relative = path.relative(root, candidate);
+	return relative === "" || !relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative);
+}
+function wireRelative(root, candidate) {
+	if (!isPathInside(root, candidate)) return void 0;
+	return path.relative(root, candidate).split(path.sep).join("/");
+}
+function parentWirePath(relativePath) {
+	const segments = validateRelativePath(relativePath);
+	segments.pop();
+	return segments.join("/");
+}
+//#endregion
+//#region src/host/chat-adapter.ts
+var DshChatAdapter = class {
+	api;
+	database;
+	commandServices;
+	sessionRootIds = /* @__PURE__ */ new Map();
+	sessionRootLookups = /* @__PURE__ */ new Map();
+	pendingApprovals = /* @__PURE__ */ new Map();
+	constructor(api, database, commandServices) {
+		this.api = api;
+		this.database = database;
+		this.commandServices = commandServices;
+	}
+	async listSessions(principal) {
+		const [sessionsResponse, workspaceResponse] = await Promise.all([this.api.sessions.list({
+			rpcId: randomUUID(),
+			payload: {}
+		}), this.api.workspace.list({
+			rpcId: randomUUID(),
+			payload: {}
+		})]);
+		const value = unwrapDsh(sessionsResponse);
+		const workspaceValue = unwrapDsh(workspaceResponse);
+		const workspaces = this.visibleWorkspaces(principal, workspaceValue.items);
+		const archivedSessionIds = new Set(workspaceValue.archivedSessionIds);
+		const roots = this.authorizedRoots(principal);
+		const visible = [];
+		for (const session of value.items) {
+			if (archivedSessionIds.has(session.sessionId)) continue;
+			const match = session.cwd === void 0 ? void 0 : matchRoot(roots, session.cwd);
+			if (match === void 0) continue;
+			const workspace = workspaces.find((item) => item.rootId === match.root.id && item.path === match.relative);
+			const title = sessionTitle(session);
+			visible.push({
+				id: session.sessionId,
+				rootId: match.root.id,
+				cwd: match.relative,
+				updatedAt: session.updatedAt,
+				running: session.running,
+				blank: session.blank,
+				...title === void 0 ? {} : { title },
+				...workspace === void 0 ? {} : {
+					workspaceId: workspace.id,
+					workspaceTitle: workspace.title
+				},
+				...session.agentPreset === void 0 ? {} : { agentPreset: session.agentPreset },
+				...session.parentSessionId === void 0 ? {} : { parentSessionId: session.parentSessionId },
+				...session.origin === void 0 ? {} : { origin: session.origin },
+				...this.hasPendingApproval(session.sessionId) ? { pendingInteraction: "approval" } : {}
+			});
+		}
+		return visible;
+	}
+	async listWorkspaces(principal) {
+		const value = unwrapDsh(await this.api.workspace.list({
+			rpcId: randomUUID(),
+			payload: {}
+		}));
+		return this.visibleWorkspaces(principal, value.items);
+	}
+	async createWorkspace(principal, rootId, relativePath) {
+		const root = this.requireAuthorizedRoot(principal, rootId);
+		const resolved = await resolveAuthorizedPath(root.realPath, relativePath);
+		if (!(await lstat(resolved.absolutePath)).isDirectory()) throw new ApiError(400, "WORKSPACE_PATH_NOT_DIRECTORY", "A DSH workspace must use an existing directory.");
+		const value = unwrapDsh(await this.api.workspace.create({
+			rpcId: randomUUID(),
+			payload: { path: resolved.absolutePath }
+		}));
+		const path = wireRelative(root.realPath, value.workspace.path);
+		if (path === void 0) throw new ApiError(403, "WORKSPACE_OUTSIDE_ROOT", "The created DSH workspace is outside the authorized root.");
+		return {
+			id: value.workspace.workspaceId,
+			title: value.workspace.title,
+			rootId: root.id,
+			path,
+			createdAt: value.workspace.createdAt,
+			updatedAt: value.workspace.updatedAt
+		};
+	}
+	async renameWorkspace(principal, workspaceId, title) {
+		const workspace = await this.requireWorkspace(principal, workspaceId);
+		const normalized = title.trim();
+		if (normalized === "") throw new ApiError(400, "WORKSPACE_TITLE_INVALID", "The workspace title cannot be empty.");
+		const value = unwrapDsh(await this.api.workspace.rename({
+			rpcId: randomUUID(),
+			payload: {
+				workspaceId,
+				title: normalized
+			}
+		}));
+		const renamed = this.visibleWorkspaces(principal, [value.workspace])[0];
+		if (renamed === void 0) throw new ApiError(403, "WORKSPACE_OUTSIDE_ROOT", "The renamed DSH workspace is outside the authorized roots.");
+		return {
+			...renamed,
+			rootId: workspace.rootId,
+			path: workspace.path
+		};
+	}
+	async deleteWorkspace(principal, workspaceId) {
+		await this.requireWorkspace(principal, workspaceId);
+		unwrapDsh(await this.api.workspace.delete({
+			rpcId: randomUUID(),
+			payload: { workspaceId }
+		}));
+	}
+	async listAgentPresets() {
+		return unwrapDsh(await this.api.agentPresets.list({
+			rpcId: randomUUID(),
+			payload: {}
+		})).presets.map((preset) => ({
+			id: preset.id,
+			name: preset.name?.trim() || preset.id,
+			...preset.description === void 0 ? {} : { description: preset.description },
+			trust: preset.trust,
+			isDefault: preset.isDefault,
+			available: preset.broken === void 0
+		}));
+	}
+	async selectAgentPreset(principal, sessionId, agentPreset) {
+		const session = await this.requireSession(principal, sessionId);
+		const requested = agentPreset.trim();
+		if (requested === "") throw new ApiError(400, "AGENT_PRESET_INVALID", "agentPreset is required.");
+		if (!session.blank) throw new ApiError(409, "AGENT_PRESET_LOCKED", "This session has already started. Its Agent preset can no longer be changed.");
+		return unwrapDsh(await this.api.agentPresets.select({
+			rpcId: randomUUID(),
+			payload: {
+				sessionId,
+				agentPreset: requested
+			}
+		})).agentPreset;
+	}
+	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 payload = {
+			workspaceId,
+			...options.sessionId === void 0 ? {} : { sessionId: options.sessionId },
+			...options.agentPreset === void 0 ? {} : { agentPreset: options.agentPreset }
+		};
+		const value = unwrapDsh(await this.api.sessions.create({
+			rpcId: randomUUID(),
+			payload
+		}));
+		return {
+			id: value.sessionId,
+			...value.agentPreset === void 0 ? {} : { agentPreset: value.agentPreset }
+		};
+	}
+	async createSession(principal, rootId, relativePath, options) {
+		const payload = {
+			cwd: (await resolveAuthorizedPath(this.requireAuthorizedRoot(principal, rootId).realPath, relativePath)).absolutePath,
+			...options.sessionId === void 0 ? {} : { sessionId: options.sessionId },
+			...options.agentPreset === void 0 ? {} : { agentPreset: options.agentPreset }
+		};
+		const value = unwrapDsh(await this.api.sessions.create({
+			rpcId: randomUUID(),
+			payload
+		}));
+		return {
+			id: value.sessionId,
+			...value.agentPreset === void 0 ? {} : { agentPreset: value.agentPreset }
+		};
+	}
+	async history(principal, sessionId, options) {
+		await this.requireSession(principal, sessionId);
+		const payload = {
+			sessionId,
+			...options.beforeSeq === void 0 ? {} : { beforeSeq: options.beforeSeq },
+			...options.maxMessages === void 0 ? {} : { maxMessages: options.maxMessages }
+		};
+		return unwrapDsh(await this.api.sessions.history({
+			rpcId: randomUUID(),
+			payload
+		}));
+	}
+	async prompt(principal, sessionId, parts, mode, clientTimeZone) {
+		await this.requireSession(principal, sessionId);
+		const hasText = parts.some((part) => part.type === "text" && part.text.trim() !== "");
+		const hasAttachment = parts.some((part) => part.type !== "text");
+		if (!hasText && !hasAttachment) throw new ApiError(400, "MESSAGE_EMPTY", "A message needs non-empty text or at least one attachment.");
+		return unwrapDsh(await this.api.sessions.prompt({
+			rpcId: randomUUID(),
+			payload: {
+				sessionId,
+				mode,
+				content: parts,
+				...clientTimeZone === void 0 ? {} : { clientTimeZone }
+			}
+		}));
+	}
+	/**
+	* 上传一个附件，返回 prompt 可以引用的凭证。
+	*
+	* 为什么需要这一步而不是让客户端直接把字节塞进消息：内核对**文件**类型要求的是
+	* `receiptId`（由上传换取），只有**图片**才允许内联 base64。
+	*/
+	async uploadAttachment(principal, sessionId, data, name) {
+		await this.requireSession(principal, sessionId);
+		return unwrapDsh(await this.api.sessions.uploadAttachment({
+			rpcId: randomUUID(),
+			payload: {
+				sessionId,
+				data,
+				...name === void 0 ? {} : { name }
+			}
+		}));
+	}
+	/**
+	* 取回会话历史里某个图片附件的字节。
+	*
+	* 这里不做会话归属校验：附件 id 是内容哈希，拿到 id 就等于拿到内容，
+	* 而且调用方必须已经通过 `files.read` 鉴权并主动持有该 id（它只出现在其有权读取的
+	* 会话事件里）。多一层会话校验并不能提升安全性，却会让「在别的会话里引用同一张图」
+	* 这种正常情况莫名失败。
+	*/
+	async readAttachment(principal, attachmentId) {
+		if (attachmentId.trim() === "") throw new ApiError(400, "BODY_INVALID", "attachmentId is required.");
+		return unwrapDsh(await this.api.sessions.readAttachment({
+			rpcId: randomUUID(),
+			payload: { attachmentId }
+		}));
+	}
+	async cancel(principal, sessionId) {
+		await this.requireSession(principal, sessionId);
+		unwrapDsh(await this.api.sessions.cancel({
+			rpcId: randomUUID(),
+			payload: { sessionId }
+		}));
+	}
+	async renameSession(principal, sessionId, title) {
+		await this.requireSession(principal, sessionId);
+		const normalized = title.trim();
+		if (normalized === "") throw new ApiError(400, "SESSION_TITLE_INVALID", "The session title cannot be empty.");
+		return unwrapDsh(await this.api.sessions.rename({
+			rpcId: randomUUID(),
+			payload: {
+				sessionId,
+				title: normalized
+			}
+		}));
+	}
+	async forkSession(principal, sessionId, atSeq) {
+		await this.requireSession(principal, sessionId);
+		const value = unwrapDsh(await this.api.sessions.fork({
+			rpcId: randomUUID(),
+			payload: {
+				sessionId,
+				...atSeq === void 0 ? {} : { atSeq }
+			}
+		}));
+		if (!await this.isSessionAuthorized(principal, value.sessionId)) throw new ApiError(403, "SESSION_FORK_OUTSIDE_ROOT", "The forked session is outside the authorized roots.");
+		return value.sessionId;
+	}
+	async archiveSession(principal, sessionId) {
+		await this.requireSession(principal, sessionId);
+		return unwrapDsh(await this.api.workspace.archiveSession({
+			rpcId: randomUUID(),
+			payload: { sessionId }
+		})).archivedSessionIds;
+	}
+	async listPendingApprovals(principal, sessionId) {
+		await this.requireSession(principal, sessionId);
+		const records = [...this.pendingApprovals.values()].filter((item) => item.sessionId === sessionId);
+		if (records.length === 0) return [];
+		let history = [];
+		if (records.some((item) => item.callId !== void 0)) try {
+			history = unwrapDsh(await this.api.sessions.history({
+				rpcId: randomUUID(),
+				payload: {
+					sessionId,
+					maxMessages: 100
+				}
+			})).events;
+		} catch {}
+		return records.sort((left, right) => left.requestedAt - right.requestedAt).map((record) => publicApproval(record, findToolCallDetail(history, record.callId)));
+	}
+	async decideApproval(principal, sessionId, approvalId, outcome) {
+		await this.requireSession(principal, sessionId);
+		const key = approvalKey(sessionId, approvalId);
+		const pending = this.pendingApprovals.get(key);
+		if (pending === void 0) throw new ApiError(409, "APPROVAL_NOT_PENDING", "This approval is no longer pending.");
+		if (!(await this.api.respond({
+			type: "client-response",
+			rpcId: pending.rpcId,
+			result: {
+				ok: true,
+				value: {
+					sessionId,
+					approvalId,
+					outcome
+				}
+			}
+		})).accepted) {
+			this.pendingApprovals.delete(key);
+			throw new ApiError(409, "APPROVAL_NOT_PENDING", "This approval is no longer pending.");
+		}
+		this.pendingApprovals.delete(key);
+		return publicApproval(pending);
+	}
+	async models(principal, sessionId) {
+		await this.requireSession(principal, sessionId);
+		return unwrapDsh(await this.api.sessions.models({
+			rpcId: randomUUID(),
+			payload: { sessionId }
+		}));
+	}
+	async selectModel(principal, sessionId, selection) {
+		await this.requireSession(principal, sessionId);
+		if (selection.provider.trim() === "" || selection.model.trim() === "") throw new ApiError(400, "MODEL_SELECTION_INVALID", "provider and model are required.");
+		const payload = {
+			sessionId,
+			provider: selection.provider,
+			model: selection.model,
+			...selection.reasoningEffort === void 0 ? {} : { reasoningEffort: selection.reasoningEffort }
+		};
+		return unwrapDsh(await this.api.sessions.selectModel({
+			rpcId: randomUUID(),
+			payload
+		})).selected;
+	}
+	async listCommands(principal, sessionId) {
+		const agent = await this.commandAgent(principal, sessionId);
+		if (agent === void 0) return [];
+		return this.commandServices.commands.list(agent).map((command) => ({
+			name: command.name,
+			description: command.description,
+			...command.input === void 0 ? {} : { input: { hint: command.input.hint } }
+		}));
+	}
+	async executeCommand(principal, sessionId, line) {
+		const normalized = line.trimEnd();
+		if (normalized.length === 0 || normalized.length > 16384 || normalized.includes("\0")) throw new ApiError(400, "COMMAND_INVALID", "The command line must contain 1 to 16384 characters and no null bytes.");
+		const match = /^\/([a-z][a-z0-9_-]*)(?=$|[\t\n\r ])/u.exec(normalized);
+		if (match === null) throw new ApiError(400, "COMMAND_INVALID", "A slash command must start with a valid command name.");
+		const agent = await this.commandAgent(principal, sessionId);
+		if (agent === void 0) throw new ApiError(409, "COMMANDS_UNAVAILABLE", "The session could not be activated for command execution.");
+		if (!this.commandServices.commands.list(agent).some((command) => command.name === match[1])) throw new ApiError(404, "COMMAND_NOT_FOUND", "The command is not available for this session.");
+		try {
+			const execution = await this.commandServices.commands.execute(agent, normalized, new AbortController().signal);
+			if (execution === void 0) throw new ApiError(404, "COMMAND_NOT_FOUND", "The command is no longer available for this session.");
+			return {
+				commandId: String(execution.commandId),
+				result: {
+					kind: execution.result.kind,
+					...execution.result.text === void 0 ? {} : { text: execution.result.text },
+					...execution.result.sourceEventSeq === void 0 ? {} : { sourceEventSeq: execution.result.sourceEventSeq }
+				}
+			};
+		} catch (error) {
+			if (error instanceof ApiError) throw error;
+			throw new ApiError(409, "COMMAND_FAILED", error instanceof Error ? error.message : String(error));
+		}
+	}
+	async isSessionAuthorized(principal, sessionId) {
+		const rootId = await this.sessionRootId(sessionId);
+		return rootId !== void 0 && (principal.rootIds === "all" || principal.rootIds.has(rootId));
+	}
+	startEvents(signal, emit) {
+		const run = async (kind) => {
+			const stream = this.api.events[kind]({
+				rpcId: randomUUID(),
+				payload: {}
+			}, signal);
+			for await (const frame of stream) {
+				if (signal.aborted) break;
+				this.captureApproval(frame, kind);
+				emit(normalizeDshEvent(frame, kind));
+			}
+		};
+		run("mux").catch(() => void 0);
+		run("host").catch(() => void 0);
+	}
+	captureApproval(frame, kind) {
+		if (kind !== "mux") return;
+		const payload = frame.payload;
+		if (payload.type === "approval/requested" && typeof payload.sessionId === "string" && typeof payload.approvalId === "string" && typeof payload.toolName === "string") {
+			const key = approvalKey(payload.sessionId, payload.approvalId);
+			const previous = this.pendingApprovals.get(key);
+			this.pendingApprovals.set(key, {
+				rpcId: frame.rpcId,
+				sessionId: payload.sessionId,
+				approvalId: payload.approvalId,
+				toolName: redactApprovalText(payload.toolName, 120),
+				...typeof payload.callId === "string" ? { callId: payload.callId } : {},
+				...typeof payload.reason === "string" ? { reason: payload.reason } : {},
+				requestedAt: previous?.requestedAt ?? Date.now()
+			});
+			return;
+		}
+		if (payload.type === "approval/resolved" && typeof payload.sessionId === "string" && typeof payload.approvalId === "string") this.pendingApprovals.delete(approvalKey(payload.sessionId, payload.approvalId));
+	}
+	hasPendingApproval(sessionId) {
+		for (const item of this.pendingApprovals.values()) if (item.sessionId === sessionId) return true;
+		return false;
+	}
+	/**
+	* Resolve the Agent backing a session for command work.
+	*
+	* Returns `undefined` when the session exists but cannot be activated. 0.2.x
+	* rejects activation for a Session owned by a subagent, so that outcome is a
+	* property of the session rather than a failure of this call: the caller
+	* decides whether it means "no commands" (listing) or an error (execution).
+	*/
+	async commandAgent(principal, sessionId) {
+		await this.requireSession(principal, sessionId);
+		const services = this.commandServices;
+		if (services === void 0) throw new ApiError(503, "COMMANDS_UNAVAILABLE", "This DSH composition does not expose the command runtime.");
+		let agent = services.agents.get(sessionId);
+		if (agent !== void 0) return agent;
+		try {
+			unwrapDsh(await this.api.sessions.models({
+				rpcId: randomUUID(),
+				payload: { sessionId }
+			}));
+		} catch {}
+		return services.agents.get(sessionId);
+	}
+	async requireSession(principal, sessionId) {
+		const session = (await this.listSessions(principal)).find((item) => item.id === sessionId);
+		if (session === void 0) throw new ApiError(404, "SESSION_NOT_FOUND", "The session is not visible to this device.");
+		return session;
+	}
+	async requireWorkspace(principal, workspaceId) {
+		const workspace = (await this.listWorkspaces(principal)).find((item) => item.id === workspaceId);
+		if (workspace === void 0) throw new ApiError(404, "WORKSPACE_NOT_FOUND", "The DSH workspace is not visible to this device.");
+		return workspace;
+	}
+	visibleWorkspaces(principal, items) {
+		const roots = this.authorizedRoots(principal);
+		const visible = [];
+		for (const workspace of items) {
+			const match = matchRoot(roots, workspace.path);
+			if (match === void 0) continue;
+			visible.push({
+				id: workspace.workspaceId,
+				title: workspace.title,
+				rootId: match.root.id,
+				path: match.relative,
+				createdAt: workspace.createdAt,
+				updatedAt: workspace.updatedAt
+			});
+		}
+		return visible;
+	}
+	requireAuthorizedRoot(principal, rootId) {
+		if (principal.rootIds !== "all" && !principal.rootIds.has(rootId)) throw new ApiError(403, "ROOT_FORBIDDEN", "This device is not authorized for the requested root.");
+		const root = this.database.getRoot(rootId);
+		if (root === void 0) throw new ApiError(404, "ROOT_NOT_FOUND", "The authorized root does not exist.");
+		return root;
+	}
+	authorizedRoots(principal) {
+		const all = this.database.listRoots();
+		return principal.rootIds === "all" ? all : all.filter((root) => principal.rootIds.has(root.id));
+	}
+	async sessionRootId(sessionId) {
+		const cached = this.sessionRootIds.get(sessionId);
+		if (cached !== void 0) {
+			if (this.database.getRoot(cached) !== void 0) return cached;
+			this.sessionRootIds.delete(sessionId);
+		}
+		const pending = this.sessionRootLookups.get(sessionId);
+		if (pending !== void 0) return pending;
+		const lookup = (async () => {
+			const session = unwrapDsh(await this.api.sessions.list({
+				rpcId: randomUUID(),
+				payload: {}
+			})).items.find((item) => item.sessionId === sessionId);
+			if (session?.cwd === void 0) return void 0;
+			const match = matchRoot(this.database.listRoots(), session.cwd);
+			if (match === void 0) return void 0;
+			this.sessionRootIds.set(sessionId, match.root.id);
+			return match.root.id;
+		})();
+		this.sessionRootLookups.set(sessionId, lookup);
+		try {
+			return await lookup;
+		} finally {
+			if (this.sessionRootLookups.get(sessionId) === lookup) this.sessionRootLookups.delete(sessionId);
+		}
+	}
+};
+function unwrapDsh(response) {
+	if (response.result.ok) return response.result.value;
+	const error = response.result.error;
+	throw new ApiError(error.code.includes("not-found") ? 404 : error.code.includes("busy") || error.code.includes("locked") ? 409 : 400, `DSH_${error.code.replaceAll("-", "_").toUpperCase()}`, error.message);
+}
+function normalizeDshEvent(frame, fallback, time = Date.now()) {
+	const payload = frame.payload;
+	const payloadType = typeof payload.type === "string" ? payload.type : fallback;
+	if (payloadType === "approval/requested" && typeof payload.sessionId === "string" && typeof payload.approvalId === "string" && typeof payload.toolName === "string") return {
+		id: `${payload.approvalId}:requested`,
+		type: "chat.approval.requested",
+		time,
+		data: {
+			sessionId: payload.sessionId,
+			approvalId: payload.approvalId,
+			toolName: payload.toolName,
+			risk: approvalRisk(typeof payload.reason === "string" ? payload.reason : void 0)
+		}
+	};
+	if (payloadType === "approval/resolved" && typeof payload.sessionId === "string" && typeof payload.approvalId === "string") return {
+		id: `${payload.approvalId}:resolved`,
+		type: "chat.approval.resolved",
+		time,
+		data: {
+			sessionId: payload.sessionId,
+			approvalId: payload.approvalId,
+			...typeof payload.outcome === "string" ? { outcome: payload.outcome } : {}
+		}
+	};
+	if (payloadType === "session/event" && typeof payload.sessionId === "string" && isRecord$1(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;
+		const base = {
+			sessionId: payload.sessionId,
+			eventType,
+			...seq === void 0 ? {} : { seq }
+		};
+		const assistantData = event.data;
+		if (eventType === "assistant/chunk" && isRecord$1(assistantData)) {
+			const rawChunk = assistantData.chunk;
+			if (isRecord$1(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,
+					type: "chat.message.delta",
+					time,
+					data: {
+						...base,
+						kind,
+						text: rawChunk.text,
+						index: rawChunk.index,
+						...typeof assistantData.turn === "number" ? { turn: assistantData.turn } : {},
+						...typeof assistantData.step === "number" ? { step: assistantData.step } : {}
+					}
+				};
+			}
+		}
+		if (eventType === "user/message" || eventType === "assistant/message") {
+			const eventData = isRecord$1(event.data) ? event.data : {};
+			return {
+				id: frame.rpcId,
+				type: "chat.message.committed",
+				time,
+				data: {
+					...base,
+					role: eventType === "user/message" ? "user" : "assistant",
+					...typeof eventData.turn === "number" ? { turn: eventData.turn } : {},
+					...typeof eventData.step === "number" ? { step: eventData.step } : {}
+				}
+			};
+		}
+		if (eventType === "turn/start" || eventType === "turn/end") return {
+			id: frame.rpcId,
+			type: eventType === "turn/start" ? "chat.turn.start" : "chat.turn.end",
+			time,
+			data: base
+		};
+		return {
+			id: frame.rpcId,
+			type: "chat.session.event",
+			time,
+			data: base
+		};
+	}
+	if (payloadType === "host/session-status" && typeof payload.sessionId === "string") return {
+		id: frame.rpcId,
+		type: "chat.session.status",
+		time,
+		data: {
+			sessionId: payload.sessionId,
+			running: payload.running === true
+		}
+	};
+	if (payloadType === "host/remote-event" && payload.event === "agent-preset/selected" && Array.isArray(payload.args)) {
+		const [sessionId, agentPreset] = payload.args;
+		if (typeof sessionId === "string" && typeof agentPreset === "string") return {
+			id: frame.rpcId,
+			type: "chat.agent-preset.selected",
+			time,
+			data: {
+				sessionId,
+				agentPreset
+			}
+		};
+	}
+	return {
+		id: frame.rpcId,
+		type: `chat.${payloadType}`,
+		time,
+		data: payload
+	};
+}
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function matchRoot(roots, cwd) {
+	for (const root of roots) {
+		const relative = wireRelative(root.realPath, cwd);
+		if (relative !== void 0) return {
+			root,
+			relative
+		};
+	}
+}
+function sessionTitle(session) {
+	const title = session.projections?.values.title;
+	return typeof title === "string" && title.trim() !== "" ? title : void 0;
+}
+function approvalKey(sessionId, approvalId) {
+	return `${sessionId}\u0000${approvalId}`;
+}
+function approvalRisk(reason) {
+	return reason?.toLowerCase().includes("danger-full-access") === true ? "full-access" : "standard";
+}
+function publicApproval(record, detail) {
+	const reason = record.reason === void 0 ? void 0 : redactApprovalText(record.reason, 500);
+	const safeDetail = detail === void 0 ? void 0 : redactApprovalText(detail, 1200);
+	return {
+		id: record.approvalId,
+		sessionId: record.sessionId,
+		toolName: redactApprovalText(record.toolName, 120),
+		...reason === void 0 || reason === "" ? {} : { reason },
+		...safeDetail === void 0 || safeDetail === "" ? {} : { detail: safeDetail },
+		risk: approvalRisk(record.reason),
+		requestedAt: record.requestedAt
+	};
+}
+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;
+		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 (typeof args === "string") return args;
+		if (args !== void 0) return JSON.stringify(args, null, 2);
+	}
+}
+function decodeToolArguments(value) {
+	if (typeof value !== "string") return value;
+	try {
+		return JSON.parse(value);
+	} catch {
+		return value;
+	}
+}
+function redactApprovalText(value, maxLength = 1200) {
+	let redacted = value;
+	redacted = redacted.replace(/\bBearer\s+[^\s"']+/gi, "Bearer [REDACTED]");
+	redacted = redacted.replace(/\b(?:sk|as_sk|ghp|github_pat)[-_][A-Za-z0-9_-]{8,}\b/gi, "[REDACTED]");
+	redacted = redacted.replace(/(["']?(?:api[_-]?key|access[_-]?token|auth[_-]?token|token|secret|password|passwd|credential)["']?\s*[=:]\s*)(["'])(.*?)\2/gi, "$1$2[REDACTED]$2");
+	redacted = redacted.replace(/((?:api[_-]?key|access[_-]?token|auth[_-]?token|token|secret|password|passwd|credential)\s*[=:]\s*)[^\s,;"']+/gi, "$1[REDACTED]");
+	redacted = redacted.replace(/([?&](?:api[_-]?key|access[_-]?token|token|secret|password)=)[^&#\s]+/gi, "$1[REDACTED]");
+	return redacted.length <= maxLength ? redacted : `${redacted.slice(0, Math.max(0, maxLength - 1))}…`;
+}
+//#endregion
+//#region src/host/database.ts
+var WorkspaceDatabase = class {
+	dataDir;
+	trashDir;
+	db;
+	constructor(dataDir) {
+		this.dataDir = path.resolve(dataDir);
+		this.trashDir = path.join(this.dataDir, "trash");
+		mkdirSync(this.trashDir, { recursive: true });
+		this.db = new DatabaseSync(path.join(this.dataDir, "workspace.sqlite"));
+		this.db.exec("PRAGMA journal_mode=WAL; PRAGMA foreign_keys=ON; PRAGMA busy_timeout=5000;");
+		this.migrate();
+	}
+	close() {
+		this.db.close();
+	}
+	getSetting(key) {
+		return this.db.prepare("SELECT value FROM settings WHERE key = ?").get(key)?.value;
+	}
+	setSetting(key, value) {
+		this.db.prepare("INSERT INTO settings(key,value) VALUES(?,?) ON CONFLICT(key) DO UPDATE SET value=excluded.value").run(key, value);
+	}
+	async addRoot(inputPath, label) {
+		const realPath = await canonicalRoot(inputPath);
+		const duplicate = this.db.prepare("SELECT * FROM roots WHERE real_path = ?").get(realPath);
+		if (duplicate !== void 0) return rootFromRow(duplicate);
+		const id = randomUUID();
+		const createdAt = Date.now();
+		const resolvedLabel = label?.trim() || path.basename(realPath) || realPath;
+		this.db.prepare("INSERT INTO roots(id,label,real_path,created_at) VALUES(?,?,?,?)").run(id, resolvedLabel, realPath, createdAt);
+		this.audit("admin", "loopback-admin", "root.add", id, void 0, { label: resolvedLabel });
+		return {
+			id,
+			label: resolvedLabel,
+			realPath,
+			createdAt
+		};
+	}
+	listRoots() {
+		return this.db.prepare("SELECT * FROM roots ORDER BY created_at, id").all().map(rootFromRow);
+	}
+	getRoot(id) {
+		const row = this.db.prepare("SELECT * FROM roots WHERE id = ?").get(id);
+		return row === void 0 ? void 0 : rootFromRow(row);
+	}
+	removeRoot(id) {
+		if (this.db.prepare("DELETE FROM roots WHERE id = ?").run(id).changes === 0) throw new ApiError(404, "ROOT_NOT_FOUND", "The authorized root does not exist.");
+		this.audit("admin", "loopback-admin", "root.remove", id);
+	}
+	createPairing(rootIds, scopes, ttlMs = 6e5) {
+		assertScopes(scopes);
+		for (const rootId of rootIds) if (this.getRoot(rootId) === void 0) throw new ApiError(404, "ROOT_NOT_FOUND", `Unknown root ${rootId}.`);
+		const raw = randomBytes(5).toString("hex").toUpperCase();
+		const code = `${raw.slice(0, 5)}-${raw.slice(5)}`;
+		const expiresAt = Date.now() + ttlMs;
+		this.db.prepare("INSERT INTO pairings(code_hash,scopes_json,roots_json,expires_at,created_at) VALUES(?,?,?,?,?)").run(hashSecret(normalizePairingCode(code)), JSON.stringify(scopes), JSON.stringify(rootIds), expiresAt, Date.now());
+		this.audit("admin", "loopback-admin", "pairing.create", void 0, void 0, {
+			rootIds,
+			scopes,
+			expiresAt
+		});
+		return {
+			code,
+			expiresAt
+		};
+	}
+	exchangePairing(code, deviceName) {
+		const normalized = normalizePairingCode(code);
+		const now = Date.now();
+		this.db.exec("BEGIN IMMEDIATE");
+		try {
+			const row = this.db.prepare("SELECT code_hash,scopes_json,roots_json,expires_at,used_at FROM pairings WHERE code_hash = ?").get(hashSecret(normalized));
+			if (row === void 0 || row.used_at !== null || row.expires_at < now) throw new ApiError(401, "PAIRING_INVALID", "The pairing code is invalid, expired, or already used.");
+			const token = randomBytes(32).toString("base64url");
+			const id = randomUUID();
+			const name = deviceName.trim().slice(0, 120) || "Mobile device";
+			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 grant = this.db.prepare("INSERT INTO device_roots(device_id,root_id) VALUES(?,?)");
+			for (const rootId of rootIds) grant.run(id, rootId);
+			this.db.exec("COMMIT");
+			const device = {
+				id,
+				name,
+				scopes,
+				rootIds,
+				createdAt: now
+			};
+			this.audit("device", id, "pairing.exchange", void 0, void 0, { name });
+			return {
+				token,
+				device
+			};
+		} catch (error) {
+			this.db.exec("ROLLBACK");
+			throw error;
+		}
+	}
+	authenticate(token) {
+		const row = this.db.prepare("SELECT * FROM devices WHERE token_hash = ? AND revoked_at IS NULL").get(hashSecret(token));
+		if (row === void 0) return void 0;
+		return this.hydrateDevice(row, true);
+	}
+	getActiveDevice(id) {
+		const row = this.db.prepare("SELECT * FROM devices WHERE id = ? AND revoked_at IS NULL").get(id);
+		return row === void 0 ? void 0 : this.hydrateDevice(row, false);
+	}
+	hydrateDevice(row, touchLastSeen) {
+		const rootRows = this.db.prepare("SELECT root_id FROM device_roots WHERE device_id = ? ORDER BY root_id").all(row.id);
+		const now = Date.now();
+		if (touchLastSeen) this.db.prepare("UPDATE devices SET last_seen_at = ? WHERE id = ?").run(now, row.id);
+		return {
+			id: row.id,
+			name: row.name,
+			tokenHash: row.token_hash,
+			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 }
+		};
+	}
+	listDevices() {
+		const rows = this.db.prepare("SELECT * FROM devices ORDER BY created_at DESC").all();
+		const rootQuery = this.db.prepare("SELECT root_id FROM device_roots WHERE device_id = ? ORDER BY root_id");
+		return rows.map((row) => ({
+			id: row.id,
+			name: row.name,
+			scopes: parseScopes(row.scopes_json),
+			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 }
+		}));
+	}
+	isDeviceActive(id) {
+		return this.db.prepare("SELECT 1 AS active FROM devices WHERE id = ? AND revoked_at IS NULL").get(id) !== void 0;
+	}
+	updateDevice(id, scopes, rootIds) {
+		assertScopes(scopes);
+		for (const rootId of rootIds) if (this.getRoot(rootId) === void 0) throw new ApiError(404, "ROOT_NOT_FOUND", `Unknown root ${rootId}.`);
+		this.db.exec("BEGIN IMMEDIATE");
+		try {
+			if (this.db.prepare("UPDATE devices SET scopes_json = ? WHERE id = ? AND revoked_at IS NULL").run(JSON.stringify(scopes), id).changes === 0) throw new ApiError(404, "DEVICE_NOT_FOUND", "The active device does not exist.");
+			this.db.prepare("DELETE FROM device_roots WHERE device_id = ?").run(id);
+			const grant = this.db.prepare("INSERT INTO device_roots(device_id,root_id) VALUES(?,?)");
+			for (const rootId of rootIds) grant.run(id, rootId);
+			this.db.exec("COMMIT");
+		} catch (error) {
+			this.db.exec("ROLLBACK");
+			throw error;
+		}
+		this.audit("admin", "loopback-admin", "device.update", void 0, void 0, {
+			deviceId: id,
+			scopes,
+			rootIds
+		});
+		const device = this.listDevices().find((item) => item.id === id);
+		if (device === void 0) throw new ApiError(404, "DEVICE_NOT_FOUND", "The device does not exist.");
+		return device;
+	}
+	revokeDevice(id) {
+		if (this.db.prepare("UPDATE devices SET revoked_at = ? WHERE id = ? AND revoked_at IS NULL").run(Date.now(), id).changes === 0) throw new ApiError(404, "DEVICE_NOT_FOUND", "The active device does not exist.");
+		this.audit("admin", "loopback-admin", "device.revoke", void 0, void 0, { deviceId: id });
+	}
+	insertTrash(record) {
+		this.db.prepare("INSERT INTO trash(id,root_id,relative_path,payload_path,kind,size,digest,created_at,status) VALUES(?,?,?,?,?,?,?,?,?)").run(record.id, record.rootId, record.relativePath, record.payloadPath, record.kind, record.size, record.digest, record.createdAt, record.status);
+	}
+	updateTrashStatus(id, status) {
+		this.db.prepare("UPDATE trash SET status = ? WHERE id = ?").run(status, id);
+	}
+	getTrash(id) {
+		const row = this.db.prepare("SELECT * FROM trash WHERE id = ?").get(id);
+		return row === void 0 ? void 0 : trashFromRow(row);
+	}
+	listTrash(rootIds) {
+		return this.db.prepare("SELECT * FROM trash WHERE status != ? ORDER BY created_at DESC").all("restored").map(trashFromRow).filter((item) => rootIds === void 0 || rootIds.has(item.rootId));
+	}
+	deleteTrashRecord(id) {
+		this.db.prepare("DELETE FROM trash WHERE id = ?").run(id);
+	}
+	audit(actorType, actorId, action, rootId, relativePath, details = {}, requestId) {
+		this.db.prepare("INSERT INTO audit(id,time,request_id,actor_type,actor_id,action,root_id,relative_path,details_json) VALUES(?,?,?,?,?,?,?,?,?)").run(randomUUID(), Date.now(), requestId ?? null, actorType, actorId, action, rootId ?? null, relativePath ?? null, JSON.stringify(details));
+	}
+	listAudit(limit = 200) {
+		return this.db.prepare("SELECT id,time,request_id AS requestId,actor_type AS actorType,actor_id AS actorId,action,root_id AS rootId,relative_path AS relativePath,details_json AS detailsJson FROM audit ORDER BY time DESC LIMIT ?").all(Math.min(Math.max(limit, 1), 1e3));
+	}
+	readIdempotent(deviceId, key) {
+		const row = this.db.prepare("SELECT status,response_json FROM idempotency WHERE device_id = ? AND key = ?").get(deviceId, key);
+		return row === void 0 ? void 0 : {
+			status: row.status,
+			body: JSON.parse(row.response_json)
+		};
+	}
+	saveIdempotent(deviceId, key, status, body) {
+		this.db.prepare("INSERT OR IGNORE INTO idempotency(device_id,key,status,response_json,created_at) VALUES(?,?,?,?,?)").run(deviceId, key, status, JSON.stringify(body), Date.now());
+	}
+	migrate() {
+		this.db.exec(`
+      CREATE TABLE IF NOT EXISTS settings(key TEXT PRIMARY KEY, value TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS roots(
+        id TEXT PRIMARY KEY, label TEXT NOT NULL, real_path TEXT NOT NULL UNIQUE, created_at INTEGER NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS devices(
+        id TEXT PRIMARY KEY, name TEXT NOT NULL, token_hash TEXT NOT NULL UNIQUE,
+        scopes_json TEXT NOT NULL, created_at INTEGER NOT NULL, last_seen_at INTEGER, revoked_at INTEGER
+      );
+      CREATE TABLE IF NOT EXISTS device_roots(
+        device_id TEXT NOT NULL REFERENCES devices(id) ON DELETE CASCADE,
+        root_id TEXT NOT NULL REFERENCES roots(id) ON DELETE CASCADE,
+        PRIMARY KEY(device_id, root_id)
+      );
+      CREATE TABLE IF NOT EXISTS pairings(
+        code_hash TEXT PRIMARY KEY, scopes_json TEXT NOT NULL, roots_json TEXT NOT NULL,
+        expires_at INTEGER NOT NULL, created_at INTEGER NOT NULL, used_at INTEGER
+      );
+      CREATE TABLE IF NOT EXISTS trash(
+        id TEXT PRIMARY KEY, root_id TEXT NOT NULL, relative_path TEXT NOT NULL,
+        payload_path TEXT NOT NULL, kind TEXT NOT NULL, size INTEGER NOT NULL,
+        digest TEXT NOT NULL, created_at INTEGER NOT NULL, status TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS audit(
+        id TEXT PRIMARY KEY, time INTEGER NOT NULL, request_id TEXT, actor_type TEXT NOT NULL,
+        actor_id TEXT NOT NULL, action TEXT NOT NULL, root_id TEXT, relative_path TEXT, details_json TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS idempotency(
+        device_id TEXT NOT NULL, key TEXT NOT NULL, status INTEGER NOT NULL,
+        response_json TEXT NOT NULL, created_at INTEGER NOT NULL, PRIMARY KEY(device_id,key)
+      );
+      CREATE INDEX IF NOT EXISTS audit_time_idx ON audit(time DESC);
+      CREATE INDEX IF NOT EXISTS trash_root_idx ON trash(root_id, created_at DESC);
+    `);
+	}
+};
+function hashSecret(secret) {
+	return createHash("sha256").update(secret, "utf8").digest("hex");
+}
+function normalizePairingCode(code) {
+	return code.replace(/[^A-Za-z0-9]/g, "").toUpperCase();
+}
+function parseScopes(value) {
+	const parsed = JSON.parse(value);
+	if (!Array.isArray(parsed)) return [];
+	return parsed.filter((scope) => DEVICE_SCOPES.includes(scope));
+}
+function assertScopes(scopes) {
+	if (scopes.some((scope) => !DEVICE_SCOPES.includes(scope))) throw new ApiError(400, "SCOPE_INVALID", "The request contains an unknown device scope.");
+}
+function rootFromRow(row) {
+	return {
+		id: row.id,
+		label: row.label,
+		realPath: row.real_path,
+		createdAt: row.created_at
+	};
+}
+function trashFromRow(row) {
+	return {
+		id: String(row.id),
+		rootId: String(row.root_id),
+		relativePath: String(row.relative_path),
+		payloadPath: String(row.payload_path),
+		kind: String(row.kind),
+		size: Number(row.size),
+		digest: String(row.digest),
+		createdAt: Number(row.created_at),
+		status: String(row.status)
+	};
+}
+//#endregion
+//#region src/host/dsh-0.2-bridge.ts
+/**
+* DSH 0.2.x host-service bridge.
+*
+* dsh-workspace 1.x was written against the DSH `ctx.apiProxy` seam — a
+* client-shaped RPC facade that the old `@deepseek-ai/dsh-host-apiproxy`
+* package published to plugins. DSH 0.1.2-alpha.3 replaced that package with
+* `@deepseek-ai/dsh-api-gateway` (Cordis service `typertGateway`, mounted as the
+* `typert-gateway` row), so no package publishes `apiProxy` any more and this
+* plugin could never activate on 0.2.x.
+*
+* The controllers behind that facade did not go away: they now register
+* directly as host services (`ctx.sessionController`, `ctx.workspaceController`,
+* `ctx.settingsController`, `ctx.credentialsController`, `ctx.agentPresets`,
+* `ctx.llm`, `ctx.workspaceRegistry`). This module rebuilds the old `apiProxy`
+* shape on top of them, so `chat-adapter.ts` / `settings-adapter.ts` stay
+* untouched.
+*
+* The plugin deliberately does not import any `@deepseek-ai/*` package at
+* runtime (see docs/project/COMPATIBILITY.md): every host service below is
+* consumed through a structural type and injected by the running Host.
+*/
+/**
+* 容错读取一个 cordis 服务。
+*
+* 为什么需要它：读一个没人提供的注入属性，cordis 会抛
+* `cannot get property "x" without inject`。这个异常**不能**让插件整个激活失败 ——
+* 一个可选能力缺席，凭什么把会话、消息、设置这些无关功能一起拖下水。
+*
+* 代价要说清楚：返回 `null` 意味着这条能力在这套 profile 上就是没有。
+* 调用方必须自己给出可读的错误（见 readAttachment），而不是让用户看到一个
+* 语焉不详的 500。
+*/
+function optionalService(host, name) {
+	try {
+		return host[name];
+	} catch {
+		return null;
+	}
+}
+function ok(value) {
+	return { result: {
+		ok: true,
+		value
+	} };
+}
+/**
+* Normalize a thrown host error into the `{ code, message }` shape that
+* `unwrapDsh` reads. 0.2.x throws `RemoteError`-alikes carrying a namespaced
+* `code` (e.g. `session/not-found`); older code paths used short codes, so both
+* spellings are preserved and callers keep matching on substrings.
+*/
+function toRpcError(error) {
+	if (error && typeof error === "object") {
+		const candidate = error;
+		return {
+			code: typeof candidate.code === "string" && candidate.code.length > 0 ? candidate.code : typeof candidate.name === "string" && candidate.name.length > 0 ? candidate.name : "internal",
+			message: typeof candidate.message === "string" && candidate.message.length > 0 ? candidate.message : String(error)
+		};
+	}
+	return {
+		code: "internal",
+		message: String(error)
+	};
+}
+/** Run one host call and wrap its outcome or failure in the old envelope. */
+async function call(run) {
+	try {
+		return ok(await run());
+	} catch (error) {
+		return { result: {
+			ok: false,
+			error: toRpcError(error)
+		} };
+	}
+}
+/**
+* Replay-free fan-out of host facts into the `{ rpcId, payload }` frames the
+* old `apiProxy` streams produced. Subscribers only observe frames emitted
+* after they attach, matching the old streams' live-only semantics.
+*/
+var FrameHub = class {
+	listeners = /* @__PURE__ */ new Set();
+	push(payload) {
+		const frame = {
+			rpcId: randomUUID(),
+			payload
+		};
+		for (const listener of this.listeners) try {
+			listener(frame);
+		} catch {}
+	}
+	subscribe(signal) {
+		const queue = [];
+		let wake;
+		let closed = false;
+		const onFrame = (frame) => {
+			if (closed) return;
+			queue.push(frame);
+			wake?.();
+		};
+		this.listeners.add(onFrame);
+		const detach = () => {
+			if (closed) return;
+			closed = true;
+			this.listeners.delete(onFrame);
+			wake?.();
+		};
+		signal.addEventListener("abort", detach, { once: true });
+		return { async *[Symbol.asyncIterator]() {
+			try {
+				while (!closed && !signal.aborted) {
+					if (queue.length === 0) {
+						await new Promise((resolve) => {
+							wake = resolve;
+						});
+						wake = void 0;
+						continue;
+					}
+					yield queue.shift();
+				}
+			} finally {
+				detach();
+			}
+		} };
+	}
+};
+/**
+* Relays live session frames into the old `session/event` shape.
+*
+* 0.2.x has no process-wide session event stream: both durable events and the
+* in-flight assistant stream arrive per session through `follow()`. The plugin's
+* event pipeline instead consumes one mux carrying `session/event` frames, so
+* this relay keeps a follow subscription for each *running* session and fans its
+* frames out. Without it the client never sees streamed assistant text — the
+* transcript would only appear once a message had been committed and re-read.
+*/
+var SessionEventRelay = class {
+	host;
+	mux;
+	limit;
+	active = /* @__PURE__ */ new Map();
+	constructor(host, mux, limit = 8) {
+		this.host = host;
+		this.mux = mux;
+		this.limit = limit;
+	}
+	/** Start following one session; idempotent per session. */
+	attach(sessionId) {
+		if (this.active.has(sessionId)) return;
+		if (this.active.size >= this.limit) return;
+		const controller = new AbortController();
+		this.active.set(sessionId, controller);
+		this.pump(sessionId, controller.signal).catch(() => {
+			this.detach(sessionId);
+		});
+	}
+	/** Stop following one session. */
+	detach(sessionId) {
+		const controller = this.active.get(sessionId);
+		if (controller === void 0) return;
+		this.active.delete(sessionId);
+		controller.abort();
+	}
+	/** Stop every subscription (plugin teardown). */
+	detachAll() {
+		for (const sessionId of [...this.active.keys()]) this.detach(sessionId);
+	}
+	async pump(sessionId, signal) {
+		const stream = this.host.sessionController.follow({
+			address: {
+				kind: "session",
+				sessionId
+			},
+			assistantStream: true
+		}, signal);
+		let turn;
+		let step;
+		for await (const rawFrame of stream) {
+			if (signal.aborted) break;
+			const frame = rawFrame;
+			if (frame.type === "event") {
+				this.mux.push({
+					type: "session/event",
+					sessionId,
+					event: frame.event
+				});
+				continue;
+			}
+			if (frame.type !== "assistant-stream" || frame.frame === void 0) continue;
+			const inner = frame.frame;
+			if (inner.type === "start") {
+				turn = typeof inner.turn === "number" ? inner.turn : void 0;
+				step = typeof inner.step === "number" ? inner.step : void 0;
+				continue;
+			}
+			if (inner.type !== "chunk") continue;
+			this.mux.push({
+				type: "session/event",
+				sessionId,
+				event: {
+					type: "assistant/chunk",
+					seq: typeof inner.index === "number" ? inner.index : 0,
+					time: typeof inner.time === "number" ? inner.time : Date.now(),
+					data: {
+						chunk: inner.chunk,
+						...turn === void 0 ? {} : { turn },
+						...step === void 0 ? {} : { step }
+					}
+				}
+			});
+		}
+	}
+};
+/**
+* 0.2.x answers approvals through the Cordis waterfall `approval/request`,
+* whose listener claims a pending question by returning an outcome, while
+* `approval/asked` / `approval/decided` remain log-only audit session events.
+* The old `apiProxy` instead handed the client a `rpcId` and accepted the
+* decision back through `respond({ type: 'client-response' })`.
+*
+* This bridge joins the two: it claims a request, publishes the familiar
+* `approval/requested` frame carrying a bridge-minted `approvalId`, and settles
+* when the client answers through `respond()`. An unanswered request delegates
+* to the next answerer (the official WebUI) by calling `next()`, so installing
+* this plugin never removes the built-in approval surface.
+*/
+var ApprovalBridge = class {
+	host;
+	mux;
+	pending = /* @__PURE__ */ new Map();
+	constructor(host, mux) {
+		this.host = host;
+		this.mux = mux;
+	}
+	/** Register the answerer once, during plugin activation. */
+	attach() {
+		this.host.on("approval/request", async (...args) => {
+			const req = args[0];
+			const next = args[args.length - 1];
+			const sessionId = sessionIdOfAgent(req.agent);
+			const toolName = typeof req.toolName === "string" ? req.toolName : void 0;
+			if (sessionId === void 0 || toolName === void 0) return next();
+			const approvalId = randomUUID();
+			const rpcId = randomUUID();
+			const outcome = await new Promise((resolve) => {
+				let done = false;
+				const settle = (value) => {
+					if (done) return;
+					done = true;
+					resolve(value);
+				};
+				this.pending.set(rpcId, { settle });
+				req.signal?.addEventListener("abort", () => {
+					this.pending.delete(rpcId);
+					if (done) return;
+					done = true;
+					resolve("delegate");
+				}, { once: true });
+				this.mux.push({
+					type: "approval/requested",
+					sessionId,
+					approvalId,
+					rpcId,
+					toolName,
+					...typeof req.callId === "string" ? { callId: req.callId } : {},
+					...typeof req.reason === "string" ? { reason: req.reason } : {}
+				});
+			});
+			this.pending.delete(rpcId);
+			this.mux.push({
+				type: "approval/resolved",
+				sessionId,
+				approvalId,
+				...outcome === "delegate" ? {} : { outcome }
+			});
+			if (outcome === "delegate") return next();
+			return outcome;
+		});
+	}
+	async respond(message) {
+		const entry = this.pending.get(message.rpcId);
+		if (entry === void 0) return {
+			accepted: false,
+			reason: "not-pending"
+		};
+		const value = message.result.value;
+		const outcome = value && typeof value === "object" ? value.outcome : void 0;
+		if (outcome !== "allowed-once" && outcome !== "rejected") return {
+			accepted: false,
+			reason: "bad-response"
+		};
+		entry.settle(outcome);
+		return { accepted: true };
+	}
+};
+/** Best-effort projection of an Agent identity to its session id. */
+function sessionIdOfAgent(agent) {
+	if (!agent || typeof agent !== "object") return void 0;
+	const candidate = agent;
+	if (typeof candidate.sessionId === "string") return candidate.sessionId;
+	if (candidate.session && typeof candidate.session === "object" && typeof candidate.session.id === "string") return candidate.session.id;
+}
+/** Best-effort projection of a session view to its session id. */
+function sessionIdOf(summary) {
+	if (!summary || typeof summary !== "object") return void 0;
+	const id = summary.sessionId;
+	return typeof id === "string" ? id : void 0;
+}
+/**
+* Build the `apiProxy` replacement out of 0.2.x host services.
+*
+* Every method keeps the old `{ rpcId, payload }` request shape and the old
+* `{ result: { ok, value } }` envelope, because that is the contract
+* `chat-adapter.ts` and `settings-adapter.ts` are written against.
+*
+* @param host - host services resolved from the plugin context.
+* @returns a `SettingsApiProxy` (i.e. `DshApiProxy` plus the settings surfaces).
+*/
+function createDsh02ApiProxy(host) {
+	const mux = new FrameHub();
+	const hostFrames = new FrameHub();
+	const attachmentStore = optionalService(host, "attachments");
+	const fileUploadService = optionalService(host, "fileUploads");
+	const approvals = new ApprovalBridge(host, mux);
+	approvals.attach();
+	const relay = new SessionEventRelay(host, mux);
+	host.on("api-session/added", (summary) => {
+		const sessionId = sessionIdOf(summary);
+		if (sessionId === void 0) return;
+		hostFrames.push({
+			type: "session/added",
+			sessionId,
+			summary,
+			session: summary
+		});
+		if (summary.running === true) relay.attach(sessionId);
+	});
+	host.on("api-session/removed", (sessionId) => {
+		if (typeof sessionId !== "string") return;
+		relay.detach(sessionId);
+		hostFrames.push({
+			type: "session/removed",
+			sessionId
+		});
+	});
+	host.on("api-session/status", (sessionId, running) => {
+		if (typeof sessionId !== "string") return;
+		if (running === true) relay.attach(sessionId);
+		else relay.detach(sessionId);
+		hostFrames.push({
+			type: "host/session-status",
+			sessionId,
+			running
+		});
+	});
+	host.on("agent-preset/selected", (sessionId, agentPreset) => {
+		if (typeof sessionId !== "string" || typeof agentPreset !== "string") return;
+		hostFrames.push({
+			type: "host/remote-event",
+			event: "agent-preset/selected",
+			args: [sessionId, agentPreset]
+		});
+	});
+	/** Ask the host for the Agent backing a session before agent-scoped calls. */
+	async function agentFor(sessionId) {
+		const agent = await host.sessionController.resolveAgent(sessionId);
+		if (agent === void 0 || agent === null) throw Object.assign(/* @__PURE__ */ new Error(`no live Agent for session ${sessionId}`), { code: "session/agent-unavailable" });
+		return agent;
+	}
+	return {
+		respond: (message) => approvals.respond(message),
+		sessions: {
+			list: (request) => call(async () => {
+				const page = await host.sessionController.list(request.payload, new AbortController().signal);
+				const items = Array.isArray(page.items) ? page.items.filter((item) => item.origin !== "subagent") : page.items;
+				return {
+					...page,
+					items
+				};
+			}),
+			create: (request) => call(() => host.sessionController.create(request.payload)),
+			history: (request) => call(async () => {
+				const { sessionId, maxMessages } = request.payload;
+				const controller = new AbortController();
+				try {
+					const snapshot = (await host.sessionController.follow({
+						address: {
+							kind: "session",
+							sessionId
+						},
+						...maxMessages === void 0 ? {} : { maxMessages }
+					}, controller.signal)[Symbol.asyncIterator]().next()).value;
+					if (snapshot === void 0 || snapshot.type !== "snapshot") return {
+						events: [],
+						hasMore: false
+					};
+					return {
+						events: Array.isArray(snapshot.records) ? [...snapshot.records] : [],
+						hasMore: snapshot.hasMore === true
+					};
+				} finally {
+					controller.abort();
+				}
+			}),
+			prompt: (request) => call(async () => {
+				const requestId = randomUUID();
+				const receiptIds = request.payload.content.filter((part) => part.type === "file").map((part) => part.receiptId);
+				const binding = receiptIds.length === 0 ? void 0 : await (async () => {
+					if (fileUploadService == null) throw new Error("FILE_UPLOADS_UNAVAILABLE: this DSH build provides no ctx.fileUploads service, so file attachments cannot be sent");
+					return fileUploadService.bindPrompt(await agentFor(request.payload.sessionId), receiptIds, requestId);
+				})();
+				await host.sessionController.prompt({
+					requestId,
+					...request.payload
+				}, new AbortController().signal);
+				binding?.commit();
+				return { accepted: true };
+			}),
+			uploadAttachment: (request) => call(async () => {
+				const { sessionId, data, name } = request.payload;
+				if (fileUploadService == null) throw new Error("FILE_UPLOADS_UNAVAILABLE: this DSH build provides no ctx.fileUploads service, so file attachments cannot be sent");
+				return {
+					receiptId: (await fileUploadService.upload(await agentFor(sessionId), name === void 0 || name === "" ? { data } : {
+						data,
+						name
+					}, new AbortController().signal)).receiptId,
+					name: name ?? null
+				};
+			}),
+			readAttachment: (request) => call(async () => {
+				if (attachmentStore == null) throw new Error("ATTACHMENT_STORE_UNAVAILABLE: this DSH build provides no ctx.attachments service, so stored image bytes cannot be read");
+				const stored = await attachmentStore.readImage({ attachmentId: request.payload.attachmentId }, new AbortController().signal);
+				return {
+					bytes: stored.data,
+					mediaType: stored.ref.mediaType
+				};
+			}),
+			cancel: (request) => call(() => host.sessionController.cancel(request.payload)),
+			rename: (request) => call(() => host.sessionController.rename(request.payload)),
+			fork: (request) => call(() => host.sessionController.fork(request.payload)),
+			models: (request) => call(async () => {
+				const { sessionId } = request.payload;
+				try {
+					await host.sessionController.resolveAgent(sessionId);
+				} catch {}
+				const catalog = await host.sessionController.modelCatalog();
+				const selection = (await host.sessionController.projections({ sessionId }, new AbortController().signal))?.values?.["modelSelection"];
+				return {
+					current: selection?.pending ?? selection?.lastUsed ?? catalog.default,
+					routable: Array.isArray(catalog.routableProviders) && catalog.routableProviders.length > 0,
+					groups: Array.isArray(catalog.groups) ? catalog.groups : [],
+					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 : ""
+					})) : []
+				};
+			}),
+			selectModel: (request) => call(() => host.sessionController.selectModel(request.payload))
+		},
+		workspace: {
+			list: () => call(async () => {
+				return {
+					items: host.workspaceRegistry.list().map((row) => ({
+						workspaceId: row.id,
+						path: row.path,
+						title: row.title,
+						sessionIds: [...row.sessionIds ?? []],
+						createdAt: row.createdAt,
+						updatedAt: row.updatedAt
+					})),
+					archivedSessionIds: []
+				};
+			}),
+			create: (request) => call(() => host.workspaceController.create(request.payload)),
+			rename: (request) => call(() => host.workspaceController.rename(request.payload)),
+			delete: (request) => call(async () => {
+				await host.workspaceController.delete(request.payload);
+				return { deleted: true };
+			}),
+			archiveSession: (request) => call(() => host.workspaceController.archiveSession(request.payload))
+		},
+		agentPresets: {
+			list: () => call(async () => {
+				const withTrust = (rows) => rows.map((row) => ({
+					...row,
+					trust: row.trust ?? "system"
+				}));
+				const roster = await host.agentPresets.remoteExportList();
+				if (roster && typeof roster === "object") {
+					const view = roster;
+					if (Array.isArray(view.presets)) return {
+						presets: withTrust(view.presets),
+						authorable: view.authorable === true,
+						hasDocument: view.hasDocument === true
+					};
+				}
+				return {
+					presets: withTrust(await host.agentPresets.list()),
+					authorable: false,
+					hasDocument: false
+				};
+			}),
+			select: (request) => call(async () => {
+				const agent = await agentFor(request.payload.sessionId);
+				return { agentPreset: await host.agentPresets.select(agent, request.payload.agentPreset) };
+			})
+		},
+		settings: {
+			describe: () => call(() => host.settingsController.describe()),
+			mutate: (request) => call(() => host.settingsController.mutate(request.payload.ns, request.payload.ops, request.payload.expectedRevision))
+		},
+		credentials: {
+			describe: (request) => call(async () => {
+				return { credentials: await host.credentialsController.describe(request.payload.refs) };
+			}),
+			set: (request) => call(async () => {
+				await host.credentialsController.set(request.payload.ref, request.payload.value);
+				return {};
+			}),
+			unset: (request) => call(async () => {
+				await host.credentialsController.unset(request.payload.ref);
+				return {};
+			})
+		},
+		llm: {
+			providers: () => call(async () => {
+				const directory = host.llm.listConfigurableProviders();
+				const live = new Set(host.llm.listProviders().map((entry) => entry.id));
+				return { providers: directory.map((entry) => ({
+					provider: entry.provider,
+					displayName: entry.displayName,
+					settingsNs: entry.settingsNs,
+					settingsPath: [...entry.settingsPath],
+					active: live.has(entry.provider),
+					...entry.declared === void 0 ? {} : { declared: entry.declared }
+				})) };
+			}),
+			models: () => call(async () => {
+				const view = await host.sessionController.modelCatalog();
+				return {
+					groups: Array.isArray(view.groups) ? view.groups : [],
+					failures: Array.isArray(view.failures) ? view.failures : []
+				};
+			}),
+			discoverModels: (request) => call(async () => {
+				const { settingsNs, ...rest } = request.payload;
+				return { models: [...await host.llm.discoverModels(settingsNs, rest)] };
+			})
+		},
+		events: {
+			mux: (request, signal) => mux.subscribe(signal),
+			host: (request, signal) => hostFrames.subscribe(signal)
+		}
+	};
+}
+//#endregion
+//#region src/host/event-bus.ts
+var WorkspaceEventBus = class {
+	listeners = /* @__PURE__ */ new Set();
+	emit(event) {
+		for (const listener of this.listeners) listener(event);
+	}
+	subscribe(listener) {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+};
+//#endregion
+//#region src/host/file-service.ts
+var FileService = class {
+	database;
+	emit;
+	constructor(database, emit) {
+		this.database = database;
+		this.emit = emit;
+	}
+	async list(root, relativePath, limit = 200, cursor) {
+		const resolved = await resolveAuthorizedPath(root.realPath, relativePath);
+		if (!(await stat(resolved.absolutePath)).isDirectory()) throw new ApiError(400, "PATH_NOT_DIRECTORY", "The requested path is not a directory.");
+		const names = await readdir(resolved.absolutePath);
+		names.sort((left, right) => left.localeCompare(right));
+		const after = cursor === void 0 ? void 0 : decodeCursor(cursor);
+		const afterIndex = after === void 0 ? 0 : names.findIndex((name) => name > after);
+		const start = after === void 0 ? 0 : afterIndex === -1 ? names.length : afterIndex;
+		const pageSize = Math.min(Math.max(limit, 1), 500);
+		const selected = names.slice(start, start + pageSize);
+		const entries = [];
+		for (const name of selected) {
+			const absolute = path.join(resolved.absolutePath, name);
+			const info = await lstat(absolute);
+			const childPath = relativePath === "" ? name : `${relativePath}/${name}`;
+			entries.push({
+				name,
+				path: childPath,
+				kind: kindOf(info),
+				size: info.isFile() ? info.size : 0,
+				modifiedAt: info.mtimeMs,
+				writable: (info.mode & 128) !== 0
+			});
+		}
+		const last = selected.at(-1);
+		return {
+			path: relativePath,
+			entries,
+			...start + selected.length < names.length && last !== void 0 ? { nextCursor: encodeCursor(last) } : {}
+		};
+	}
+	async inspectContent(root, relativePath) {
+		if (relativePath === "") throw new ApiError(400, "PATH_NOT_FILE", "The root directory has no file content.");
+		const resolved = await resolveAuthorizedPath(root.realPath, relativePath);
+		const info = await lstat(resolved.absolutePath);
+		if (!info.isFile()) throw new ApiError(400, "PATH_NOT_FILE", "Only regular files have readable content.");
+		const etag = await fileEtag(resolved.absolutePath);
+		return {
+			absolutePath: resolved.absolutePath,
+			size: info.size,
+			modifiedAt: info.mtimeMs,
+			etag,
+			contentType: contentTypeFor$1(relativePath)
+		};
+	}
+	streamContent(descriptor, range) {
+		return createReadStream(descriptor.absolutePath, range);
+	}
+	async writeContent(root, relativePath, content, conditions) {
+		if (relativePath === "") throw new ApiError(400, "PATH_NOT_FILE", "A root directory cannot be overwritten.");
+		const resolved = await resolveAuthorizedPath(root.realPath, relativePath, { allowMissingLeaf: true });
+		const parent = await resolveAuthorizedPath(root.realPath, parentWirePath(relativePath));
+		if (!(await stat(parent.absolutePath)).isDirectory()) throw new ApiError(400, "PATH_NOT_DIRECTORY", "The destination parent is not a directory.");
+		let mode = 384;
+		if (resolved.exists) {
+			const info = await lstat(resolved.absolutePath);
+			if (!info.isFile()) throw new ApiError(400, "PATH_NOT_FILE", "Only regular files can be overwritten.");
+			if (conditions.ifNoneMatch === "*") throw new ApiError(412, "PATH_ALREADY_EXISTS", "The file already exists.");
+			if (conditions.ifMatch === void 0) throw new ApiError(428, "ETAG_REQUIRED", "If-Match is required when overwriting a file.");
+			const currentEtag = await fileEtag(resolved.absolutePath);
+			if (conditions.ifMatch !== currentEtag) throw new ApiError(412, "ETAG_MISMATCH", "The file changed after it was read.", { currentEtag });
+			mode = info.mode;
+		} else if (conditions.ifNoneMatch !== "*") throw new ApiError(428, "CREATE_CONDITION_REQUIRED", "If-None-Match: * is required when creating file content.");
+		const temp = path.join(parent.absolutePath, `.${path.basename(resolved.absolutePath)}.dsh-${randomUUID()}.tmp`);
+		try {
+			const handle = await open(temp, "wx", mode);
+			try {
+				await handle.writeFile(content);
+				await handle.sync();
+			} finally {
+				await handle.close();
+			}
+			if (resolved.exists) {
+				const currentEtag = await fileEtag(resolved.absolutePath);
+				if (conditions.ifMatch !== currentEtag) throw new ApiError(412, "ETAG_MISMATCH", "The file changed while the replacement was prepared.", { currentEtag });
+			}
+			await replaceFile(temp, resolved.absolutePath, resolved.exists);
+		} catch (error) {
+			await rm(temp, { force: true }).catch(() => void 0);
+			throw error;
+		}
+		const info = await stat(resolved.absolutePath);
+		const etag = await fileEtag(resolved.absolutePath);
+		this.notify("file.changed", root.id, relativePath, {
+			etag,
+			size: info.size
+		});
+		return {
+			etag,
+			size: info.size,
+			modifiedAt: info.mtimeMs
+		};
+	}
+	async createEntry(root, relativePath, kind) {
+		if (relativePath === "") throw new ApiError(400, "PATH_INVALID", "A root already exists.");
+		const resolved = await resolveAuthorizedPath(root.realPath, relativePath, { allowMissingLeaf: true });
+		if (resolved.exists) throw new ApiError(409, "PATH_ALREADY_EXISTS", "The destination already exists.");
+		await resolveAuthorizedPath(root.realPath, parentWirePath(relativePath));
+		if (kind === "directory") await mkdir(resolved.absolutePath);
+		else await writeFile(resolved.absolutePath, /* @__PURE__ */ new Uint8Array(), {
+			flag: "wx",
+			mode: 384
+		});
+		const info = await lstat(resolved.absolutePath);
+		const name = validateRelativePath(relativePath).at(-1);
+		this.notify("file.created", root.id, relativePath, { kind });
+		return {
+			name,
+			path: relativePath,
+			kind,
+			size: info.isFile() ? info.size : 0,
+			modifiedAt: info.mtimeMs,
+			writable: (info.mode & 128) !== 0
+		};
+	}
+	async moveEntry(root, sourcePath, destinationPath) {
+		if (sourcePath === "" || destinationPath === "") throw new ApiError(400, "PATH_INVALID", "The root itself cannot be moved.");
+		const source = await resolveAuthorizedPath(root.realPath, sourcePath, { allowLeafLink: true });
+		const destination = await resolveAuthorizedPath(root.realPath, destinationPath, { allowMissingLeaf: true });
+		if (destination.exists) throw new ApiError(409, "PATH_ALREADY_EXISTS", "The destination already exists.");
+		await resolveAuthorizedPath(root.realPath, parentWirePath(destinationPath));
+		if (destination.absolutePath.startsWith(`${source.absolutePath}${path.sep}`)) throw new ApiError(400, "MOVE_INVALID", "A directory cannot be moved inside itself.");
+		try {
+			await rename(source.absolutePath, destination.absolutePath);
+		} catch (error) {
+			if (error.code !== "EXDEV") throw error;
+			await copyVerified(source.absolutePath, destination.absolutePath);
+			await removeEntry(source.absolutePath);
+		}
+		this.notify("file.moved", root.id, sourcePath, { destinationPath });
+	}
+	async trashEntry(root, relativePath) {
+		if (relativePath === "") throw new ApiError(400, "PATH_INVALID", "An authorized root cannot be moved to trash.");
+		const source = await resolveAuthorizedPath(root.realPath, relativePath, { allowLeafLink: true });
+		const info = await lstat(source.absolutePath);
+		const id = randomUUID();
+		const itemDir = path.join(this.database.trashDir, root.id, id);
+		const staging = path.join(itemDir, "staging");
+		const payload = path.join(itemDir, "payload");
+		await mkdir(itemDir, { recursive: true });
+		const digest = await treeDigest(source.absolutePath);
+		const record = {
+			id,
+			rootId: root.id,
+			relativePath,
+			payloadPath: payload,
+			kind: kindOf(info),
+			size: await treeSize(source.absolutePath),
+			digest,
+			createdAt: Date.now(),
+			status: "moving"
+		};
+		this.database.insertTrash(record);
+		try {
+			try {
+				await rename(source.absolutePath, payload);
+			} catch (error) {
+				if (error.code !== "EXDEV") throw error;
+				await copyEntry(source.absolutePath, staging);
+				if (await treeDigest(staging) !== digest) throw new ApiError(500, "TRASH_VERIFY_FAILED", "The cross-volume trash copy failed verification.");
+				await rename(staging, payload);
+				this.database.updateTrashStatus(id, "committed");
+				await removeEntry(source.absolutePath);
+			}
+			this.database.updateTrashStatus(id, "trashed");
+		} catch (error) {
+			this.database.updateTrashStatus(id, "failed");
+			throw error;
+		}
+		this.notify("file.trashed", root.id, relativePath, { trashId: id });
+		return trashView({
+			...record,
+			status: "trashed"
+		});
+	}
+	listTrash(rootIds) {
+		return this.database.listTrash(rootIds).map(trashView);
+	}
+	async restoreTrash(root, trashId) {
+		const record = this.database.getTrash(trashId);
+		if (record === void 0 || record.rootId !== root.id || record.status === "restored") throw new ApiError(404, "TRASH_NOT_FOUND", "The trash item does not exist for this root.");
+		const destination = await resolveAuthorizedPath(root.realPath, record.relativePath, { allowMissingLeaf: true });
+		if (destination.exists) throw new ApiError(409, "RESTORE_CONFLICT", "The original path is already occupied.");
+		await resolveAuthorizedPath(root.realPath, parentWirePath(record.relativePath));
+		try {
+			await rename(record.payloadPath, destination.absolutePath);
+		} catch (error) {
+			if (error.code !== "EXDEV") throw error;
+			await copyVerified(record.payloadPath, destination.absolutePath);
+			await removeEntry(record.payloadPath);
+		}
+		this.database.updateTrashStatus(trashId, "restored");
+		await rm(path.dirname(record.payloadPath), {
+			recursive: true,
+			force: true
+		}).catch(() => void 0);
+		this.notify("file.restored", root.id, record.relativePath, { trashId });
+	}
+	async purgeTrash(trashId) {
+		const record = this.database.getTrash(trashId);
+		if (record === void 0) throw new ApiError(404, "TRASH_NOT_FOUND", "The trash item does not exist.");
+		await rm(path.dirname(record.payloadPath), {
+			recursive: true,
+			force: true
+		});
+		this.database.deleteTrashRecord(trashId);
+	}
+	notify(type, rootId, relativePath, extra) {
+		this.emit({
+			id: randomUUID(),
+			type,
+			time: Date.now(),
+			data: {
+				rootId,
+				path: relativePath,
+				...extra
+			}
+		});
+	}
+};
+async function fileEtag(filePath) {
+	const hash = createHash("sha256");
+	await pipeline(createReadStream(filePath), hash);
+	return `"sha256-${hash.digest("base64url")}"`;
+}
+async function replaceFile(temp, destination, destinationExists) {
+	try {
+		await rename(temp, destination);
+		return;
+	} catch (error) {
+		const code = error.code;
+		if (!destinationExists || code !== "EEXIST" && code !== "EPERM" && code !== "EACCES") throw error;
+	}
+	const backup = `${destination}.dsh-backup-${randomUUID()}`;
+	await rename(destination, backup);
+	try {
+		await rename(temp, destination);
+		await unlink(backup);
+	} catch (error) {
+		await rename(backup, destination).catch(() => void 0);
+		throw error;
+	}
+}
+async function copyVerified(source, destination) {
+	const expected = await treeDigest(source);
+	try {
+		await copyEntry(source, destination);
+		if (await treeDigest(destination) !== expected) throw new ApiError(500, "COPY_VERIFY_FAILED", "The copied entry failed digest verification.");
+	} catch (error) {
+		await rm(destination, {
+			recursive: true,
+			force: true
+		}).catch(() => void 0);
+		throw error;
+	}
+}
+async function copyEntry(source, destination) {
+	const info = await lstat(source);
+	if (info.isSymbolicLink()) {
+		await symlink(await readlink(source), destination, process.platform === "win32" ? "junction" : void 0);
+		return;
+	}
+	if (info.isDirectory()) {
+		await mkdir(destination, { mode: info.mode });
+		for (const name of await readdir(source)) await copyEntry(path.join(source, name), path.join(destination, name));
+		await chmod(destination, info.mode).catch(() => void 0);
+		return;
+	}
+	if (info.isFile()) {
+		await copyFile(source, destination);
+		await chmod(destination, info.mode).catch(() => void 0);
+		return;
+	}
+	throw new ApiError(400, "FILE_TYPE_UNSUPPORTED", "This filesystem entry type cannot be copied safely.");
+}
+async function removeEntry(target) {
+	const info = await lstat(target);
+	if (info.isDirectory() && !info.isSymbolicLink()) await rm(target, { recursive: true });
+	else await unlink(target);
+}
+async function treeDigest(target) {
+	const hash = createHash("sha256");
+	await appendDigest(hash, target, "");
+	return hash.digest("hex");
+}
+async function appendDigest(hash, target, relative) {
+	const info = await lstat(target);
+	const kind = kindOf(info);
+	hash.update(`${kind}\0${relative}\0${info.mode}\0`);
+	if (info.isSymbolicLink()) {
+		hash.update(await readlink(target));
+		return;
+	}
+	if (info.isFile()) {
+		await pipeline(createReadStream(target), hash, { end: false });
+		return;
+	}
+	if (info.isDirectory()) {
+		const names = await readdir(target);
+		names.sort();
+		for (const name of names) await appendDigest(hash, path.join(target, name), relative === "" ? name : `${relative}/${name}`);
+	}
+}
+async function treeSize(target) {
+	const info = await lstat(target);
+	if (info.isFile()) return info.size;
+	if (!info.isDirectory() || info.isSymbolicLink()) return 0;
+	let total = 0;
+	for (const name of await readdir(target)) total += await treeSize(path.join(target, name));
+	return total;
+}
+function kindOf(info) {
+	if (info.isSymbolicLink()) return "symlink";
+	if (info.isDirectory()) return "directory";
+	if (info.isFile()) return "file";
+	return "other";
+}
+function contentTypeFor$1(filePath) {
+	const extension = path.extname(filePath).toLowerCase();
+	if ([
+		".ts",
+		".tsx",
+		".js",
+		".jsx",
+		".mjs",
+		".cjs",
+		".json",
+		".md",
+		".txt",
+		".css",
+		".html",
+		".xml",
+		".yml",
+		".yaml",
+		".toml",
+		".ini",
+		".sh",
+		".ps1",
+		".py",
+		".go",
+		".rs",
+		".java",
+		".kt"
+	].includes(extension)) return extension === ".json" ? "application/json; charset=utf-8" : "text/plain; charset=utf-8";
+	return "application/octet-stream";
+}
+function encodeCursor(name) {
+	return Buffer.from(name, "utf8").toString("base64url");
+}
+function decodeCursor(cursor) {
+	try {
+		return Buffer.from(cursor, "base64url").toString("utf8");
+	} catch {
+		throw new ApiError(400, "CURSOR_INVALID", "The directory cursor is invalid.");
+	}
+}
+function trashView(record) {
+	return {
+		id: record.id,
+		rootId: record.rootId,
+		path: record.relativePath,
+		kind: record.kind,
+		size: record.size,
+		createdAt: record.createdAt,
+		status: record.status
+	};
+}
+function normalizeListenerHost(value) {
+	if (typeof value !== "string" || value.trim() === "" || isIP(value.trim()) === 0) throw new ApiError(400, "LISTENER_HOST_INVALID", "host must be a numeric IPv4 or IPv6 address.");
+	return value.trim();
+}
+function normalizeListenerPort(value, allowZero = false) {
+	if (!Number.isInteger(value) || value < (allowZero ? 0 : 1) || value > 65535) throw new ApiError(400, "LISTENER_PORT_INVALID", `port must be between ${allowZero ? 0 : 1} and 65535.`);
+	return value;
+}
+function loopbackFor(host) {
+	return isIP(host) === 6 ? "::1" : "127.0.0.1";
+}
+//#endregion
+//#region src/host/config-text.ts
+/** 只用于展示与日志的地址类型标签。 */
+const KIND_LABEL = {
+	LAN: "局域网",
+	VIRTUAL_NET: "虚拟网",
+	WAN: "公网",
+	UNKNOWN: "未知网络"
+};
+const SORT_RANK = {
+	LAN: 0,
+	VIRTUAL_NET: 1,
+	WAN: 2,
+	UNKNOWN: 3
+};
+/** 默认监听端口 —— 与 `DEFAULT_PORT` 在脚本里保持一致。 */
+const DEFAULT_PORT = 3090;
+/**
+* 按 Kotlin `EndpointKind.infer` 的规则粗分类地址。
+*
+* 只用于标签与排序；真实可用性始终由客户端探活决定。
+*/
+function classifyHost(host) {
+	const value = String(host ?? "").toLowerCase();
+	if (value === "localhost" || value === "127.0.0.1" || value === "::1" || value.endsWith(".local")) return "LAN";
+	const octets = value.split(".").map(Number);
+	if (octets.length !== 4 || octets.some((n) => !Number.isInteger(n) || n < 0 || n > 255)) return "UNKNOWN";
+	const [a, b] = octets;
+	if (a === 10) return "LAN";
+	if (a === 192 && b === 168) return "LAN";
+	if (a === 172 && b >= 16 && b <= 31) return "LAN";
+	if (a === 100 && b >= 64 && b <= 127) return "VIRTUAL_NET";
+	if (a === 169 && b === 254) return "LAN";
+	return "WAN";
+}
+/**
+* 枚举本机可用于对外连接的 IPv4 地址。
+*
+* 排除 loopback（`address.internal`）与 169.254.* —— 后者只在没有 DHCP 时出现，
+* 塞给用户只会造成「为什么这个地址连不上」的困惑。
+*/
+function detectEndpoints(port = DEFAULT_PORT) {
+	const seen = /* @__PURE__ */ new Set();
+	const found = [];
+	for (const [iface, addresses] of Object.entries(networkInterfaces())) for (const address of addresses ?? []) {
+		if (address.family !== "IPv4" || address.internal) continue;
+		if (address.address.startsWith("169.254.")) continue;
+		if (seen.has(address.address)) continue;
+		seen.add(address.address);
+		const kind = classifyHost(address.address);
+		found.push({
+			kind,
+			iface,
+			baseUrl: `http://${address.address}:${port}`,
+			label: `${KIND_LABEL[kind]}（${iface}）`
+		});
+	}
+	found.sort((a, b) => SORT_RANK[a.kind] - SORT_RANK[b.kind] || a.iface.localeCompare(b.iface));
+	return found.map(({ kind, label, baseUrl }) => ({
+		kind,
+		label,
+		baseUrl
+	}));
+}
+function trimOrNull(value) {
+	if (value === void 0 || value === null) return null;
+	const text = String(value).trim();
+	return text === "" ? null : text;
+}
+/** 剥掉 `/api/v1` 后缀 —— 它是 DshClient 的接口前缀，不是地址的一部分。 */
+function normalizeBaseUrl(raw) {
+	let value = String(raw ?? "").trim().replace(/\/+$/, "");
+	if (value.toLowerCase().endsWith("/api/v1")) value = value.slice(0, -7).replace(/\/+$/, "");
+	if (/^https?:\/\//i.test(value)) return value.replace(/^http:\/\//i, "http://").replace(/^https:\/\//i, "https://");
+	return value;
+}
+/**
+* 编码成 `DSH1:` 文本。
+*
+* 键顺序与「空值不写键」的规则必须与 Kotlin 端一致 —— 见文件头说明。
+*/
+function encodeConfigText(payload) {
+	const endpoints = payload.endpoints.map((endpoint) => ({
+		label: endpoint.label.trim(),
+		baseUrl: normalizeBaseUrl(endpoint.baseUrl)
+	}));
+	if (endpoints.length === 0) throw new Error("至少需要一个地址才能生成配置文本");
+	const wire = {
+		displayName: payload.displayName.trim(),
+		endpoints
+	};
+	const token = trimOrNull(payload.token);
+	if (token !== null) wire.token = token;
+	const deviceName = trimOrNull(payload.deviceName);
+	if (deviceName !== null) wire.deviceName = deviceName;
+	const scopes = payload.scopes.map((scope) => scope.trim()).filter((scope) => scope !== "");
+	if (scopes.length > 0) wire.scopes = scopes;
+	const body = JSON.stringify(wire);
+	return `DSH1:${Buffer.from(body, "utf8").toString("base64url")}`;
+}
+/** 本机显示名：主机名的首段，为空时退回一个中性名字。 */
+function defaultDisplayName() {
+	const name = hostname().split(".")[0]?.trim();
+	return name && name !== "" ? name : "电脑";
+}
+//#endregion
+//#region src/host/plugin-inventory.ts
+/**
+* 解析当前 profile 名。
+*
+* 依次尝试：`DSH_PROFILE` 环境变量 → `--profile=<name>` → `--profile <name>`。
+* 都拿不到时返回 null（调用方不要猜，猜错会读到另一个 profile 的清单）。
+*/
+function resolveProfileName(input = {}) {
+	const env = input.env ?? process.env;
+	const argv = input.argv ?? process.argv;
+	const fromEnv = env.DSH_PROFILE?.trim();
+	if (fromEnv) return fromEnv;
+	for (const arg of argv) if (arg.startsWith("--profile=")) {
+		const value = arg.slice(10).trim();
+		if (value) return value;
+	}
+	const index = argv.indexOf("--profile");
+	if (index >= 0) {
+		const value = argv[index + 1]?.trim();
+		if (value && !value.startsWith("-")) return value;
+	}
+	return null;
+}
+/** 解析 `$DSH_HOME`，缺省为 `~/.dsh`。 */
+function resolveDshHome(input = {}) {
+	const configured = (input.env ?? process.env).DSH_HOME?.trim();
+	if (configured) return configured;
+	return path.join(input.homeDir ?? os.homedir(), ".dsh");
+}
+async function readJson$1(file) {
+	try {
+		return JSON.parse(await readFile(file, "utf8"));
+	} catch {
+		return null;
+	}
+}
+function stringRecord(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return {};
+	const out = {};
+	for (const [key, raw] of Object.entries(value)) if (typeof raw === "string") out[key] = raw;
+	return out;
+}
+function stringArray(value) {
+	if (!Array.isArray(value)) return [];
+	return value.filter((item) => typeof item === "string");
+}
+/**
+* 读取插件清单。
+*
+* 任何读取失败都不抛异常，而是返回 `available: false` 与 `reason` ——
+* 一个只读的信息端点不该因为文件缺失就让整个请求 500，用户更需要看到「读不到，原因是什么」。
+*/
+async function readPluginInventory(input = {}) {
+	const profile = resolveProfileName(input);
+	if (!profile) return unavailable(null, null, "PROFILE_UNKNOWN");
+	const dshHome = resolveDshHome(input);
+	const profilePath = path.join(dshHome, "profiles", profile);
+	const manifest = await readJson$1(path.join(profilePath, "package.json"));
+	if (!manifest) return unavailable(profile, profilePath, "MANIFEST_UNREADABLE");
+	const dependencies = stringRecord(manifest.dependencies);
+	const dshSection = typeof manifest.dsh === "object" && manifest.dsh !== null ? manifest.dsh : {};
+	const bundles = stringArray((typeof dshSection.profile === "object" && dshSection.profile !== null ? dshSection.profile : {}).bundles);
+	const names = [.../* @__PURE__ */ new Set([...Object.keys(dependencies), ...bundles])].sort();
+	const items = [];
+	for (const name of names) {
+		const installed = await readInstalledVersion(profilePath, name);
+		const loaded = bundles.includes(name);
+		const declared = dependencies[name] ?? null;
+		const official = name.startsWith("@deepseek-ai/");
+		items.push({
+			name,
+			declared,
+			installed,
+			loaded,
+			official,
+			state: resolveState({
+				loaded,
+				installed,
+				official
+			})
+		});
+	}
+	return {
+		profile,
+		profilePath,
+		available: true,
+		reason: null,
+		loadedCount: items.filter((item) => item.loaded).length,
+		problemCount: items.filter((item) => item.state === "declared-missing" || item.state === "installed-not-loaded").length,
+		items
+	};
+}
+/**
+* 判定条目状态。
+*
+* 顺序很重要：**先判「官方包 + 未落盘」**，否则它们会被判成 `declared-missing` ——
+* 这正是在真实机器上踩到的问题（5 个官方内核包一次性变成假警报）。
+*/
+function resolveState(input) {
+	if (!input.loaded) return "installed-not-loaded";
+	if (input.installed) return "loaded";
+	if (input.official) return "runtime-provided";
+	return "declared-missing";
+}
+/** 读 `node_modules/<name>/package.json` 的 version；包名含 scope 时要按路径展开。 */
+async function readInstalledVersion(profilePath, packageName) {
+	const modulePath = path.join(profilePath, "node_modules", ...packageName.split("/"));
+	const version = (await readJson$1(path.join(modulePath, "package.json")))?.version;
+	return typeof version === "string" && version.trim() ? version : null;
+}
+function unavailable(profile, profilePath, reason) {
+	return {
+		profile,
+		profilePath,
+		available: false,
+		reason,
+		loadedCount: 0,
+		problemCount: 0,
+		items: []
+	};
+}
+//#endregion
+//#region src/host/root-resolver.ts
+/**
+* 在授权根集合里找出包含该绝对路径的那一个（**纯字符串匹配，不触碰文件系统**）。
+*
+* 多个根相互嵌套时取**最长**的那个 —— 否则外层根会把内层根下的文件解析成更长的相对路径，
+* 虽然仍能读到同一文件，但会绕过内层根更严格的授权语义。
+*
+* 注意这只是粗筛：字符串前缀相等不代表真实落在根内（根内可能存在指向外部的符号链接）。
+* 真正的安全校验由 [inspectResolvedPath] 经 `resolveAuthorizedPath` 完成。
+*/
+function matchAuthorizedRoot(absolutePath, roots) {
+	let best;
+	for (const root of roots) {
+		const relative = wireRelative(root.realPath, absolutePath);
+		if (relative === void 0) continue;
+		if (best === void 0 || root.realPath.length > best.root.realPath.length) best = {
+			root,
+			relative
+		};
+	}
+	return best === void 0 ? void 0 : {
+		rootId: best.root.id,
+		path: best.relative
+	};
+}
+const CONTENT_TYPES = {
+	".md": "text/markdown",
+	".txt": "text/plain",
+	".json": "application/json",
+	".kt": "text/plain",
+	".ts": "text/plain",
+	".js": "text/plain",
+	".yml": "text/plain",
+	".yaml": "text/plain",
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".gif": "image/gif",
+	".pdf": "application/pdf",
+	".zip": "application/zip"
+};
+function contentTypeFor(wirePath) {
+	return CONTENT_TYPES[path.extname(wirePath).toLowerCase()] ?? null;
+}
+/**
+* 确认该路径确实可访问，并返回可外传的元数据。
+*
+* 安全校验交给 `resolveAuthorizedPath`（它逐段 `lstat` 并拒绝路径中的符号链接），
+* 因此这里既不重复实现校验，也不会因为字符串匹配的局限而放行越界访问。
+*
+* 不存在 → `404 PATH_NOT_FOUND`；目录不会被当成错误（会话里提到的路径可能是目录，
+* 用户点开它远比收到一个 400 更合理）。
+*/
+async function inspectResolvedPath(root, wirePath) {
+	const resolved = await resolveAuthorizedPath(root.realPath, wirePath);
+	const info = await lstat(resolved.absolutePath);
+	if (info.isDirectory()) return {
+		rootId: root.id,
+		path: wirePath,
+		kind: "directory",
+		size: null,
+		modifiedAt: info.mtimeMs,
+		contentType: null
+	};
+	if (!info.isFile()) throw new ApiError(400, "PATH_NOT_FILE", "Only regular files and directories can be resolved.");
+	return {
+		rootId: root.id,
+		path: wirePath,
+		kind: "file",
+		size: info.size,
+		modifiedAt: info.mtimeMs,
+		contentType: contentTypeFor(wirePath)
+	};
+}
+//#endregion
+//#region src/shared/version.ts
+const PLUGIN_VERSION = "2.2.0";
+//#endregion
+//#region src/host/router.ts
+var ApiRouter = class {
+	options;
+	constructor(options) {
+		this.options = options;
+	}
+	async handle(req, res, stripPrefix = "") {
+		const requestId = header(req, "x-request-id") || randomUUID();
+		setCors(req, res);
+		res.setHeader("X-Request-Id", requestId);
+		if (req.method === "OPTIONS") {
+			res.writeHead(204);
+			res.end();
+			return;
+		}
+		try {
+			const rawUrl = req.url ?? "/";
+			const url = new URL(rawUrl, "http://workspace.local");
+			if (stripPrefix !== "" && url.pathname.startsWith(stripPrefix)) url.pathname = url.pathname.slice(stripPrefix.length) || "/";
+			await this.dispatch(req, res, url, requestId);
+		} catch (error) {
+			if (res.headersSent) {
+				res.destroy(error instanceof Error ? error : void 0);
+				return;
+			}
+			const apiError = asApiError(error);
+			sendJson(res, apiError.status, { error: {
+				code: apiError.code,
+				message: apiError.message,
+				requestId,
+				...apiError.details === void 0 ? {} : { details: apiError.details }
+			} });
+		}
+	}
+	async dispatch(req, res, url, requestId) {
+		const method = req.method ?? "GET";
+		const pathname = url.pathname.replace(/\/$/, "") || "/";
+		if (method === "GET" && pathname === "/api/v1/healthz") {
+			sendJson(res, 200, {
+				ok: true,
+				version: "v1",
+				pluginVersion: PLUGIN_VERSION
+			});
+			return;
+		}
+		if (method === "POST" && pathname === "/api/v1/pairings/exchange") {
+			this.options.auth.pairingAttempts.consume(requestAddress(req));
+			const body = await readJson(req, 16384);
+			if (typeof body.code !== "string" || typeof body.deviceName !== "string") throw new ApiError(400, "BODY_INVALID", "code and deviceName are required strings.");
+			sendJson(res, 201, this.options.database.exchangePairing(body.code, body.deviceName));
+			return;
+		}
+		if (pathname.startsWith("/manage")) {
+			this.options.auth.requireAdmin(req);
+			await this.dispatchManagement(req, res, url, requestId);
+			return;
+		}
+		const principal = this.options.auth.principal(req, { allowAdmin: true });
+		if (method === "GET" && pathname === "/api/v1/devices/self") {
+			if (principal.kind === "admin") sendJson(res, 200, {
+				id: principal.id,
+				name: "Local administrator",
+				scopes: [...principal.scopes],
+				rootIds: "all"
+			});
+			else sendJson(res, 200, {
+				id: principal.id,
+				name: principal.name,
+				scopes: [...principal.scopes],
+				rootIds: [...principal.rootIds]
+			});
+			return;
+		}
+		if (method === "GET" && pathname === "/api/v1/roots") {
+			this.options.auth.requireScope(principal, "files.read");
+			sendJson(res, 200, { items: this.authorizedRoots(principal).map(({ id, label, createdAt }) => ({
+				id,
+				label,
+				createdAt
+			})) });
+			return;
+		}
+		if (method === "GET" && pathname === "/api/v1/roots/resolve") {
+			this.options.auth.requireScope(principal, "files.read");
+			const requested = url.searchParams.get("path")?.trim() ?? "";
+			if (requested === "") throw new ApiError(400, "BODY_INVALID", "path is required.");
+			if (!path.isAbsolute(requested)) throw new ApiError(400, "PATH_NOT_ABSOLUTE", "path must be an absolute path.");
+			const match = matchAuthorizedRoot(path.resolve(requested), this.authorizedRoots(principal));
+			if (match === void 0) throw new ApiError(404, "PATH_OUTSIDE_ROOTS", "The path is not inside any root this device may access.");
+			sendJson(res, 200, await inspectResolvedPath(this.requireRoot(principal, match.rootId), match.path));
+			return;
+		}
+		const rootRoute = pathname.match(/^\/api\/v1\/roots\/([^/]+)\/(entries|content)$/);
+		if (rootRoute !== null) {
+			const rootId = decodeURIComponent(rootRoute[1]);
+			const resource = rootRoute[2];
+			const root = this.requireRoot(principal, rootId);
+			if (resource === "entries") {
+				await this.dispatchEntries(req, res, url, principal, root, requestId);
+				return;
+			}
+			await this.dispatchContent(req, res, url, principal, root, requestId);
+			return;
+		}
+		if (method === "GET" && pathname === "/api/v1/trash") {
+			this.options.auth.requireScope(principal, "files.read");
+			const rootIds = principal.rootIds === "all" ? void 0 : principal.rootIds;
+			sendJson(res, 200, { items: this.options.files.listTrash(rootIds) });
+			return;
+		}
+		const restoreRoute = pathname.match(/^\/api\/v1\/trash\/([^/]+)\/restore$/);
+		if (method === "POST" && restoreRoute !== null) {
+			this.options.auth.requireScope(principal, "files.delete");
+			const record = this.options.database.getTrash(decodeURIComponent(restoreRoute[1]));
+			if (record === void 0) throw new ApiError(404, "TRASH_NOT_FOUND", "The trash item does not exist.");
+			const root = this.requireRoot(principal, record.rootId);
+			await this.options.files.restoreTrash(root, record.id);
+			this.audit(principal, "trash.restore", root.id, record.relativePath, requestId);
+			sendJson(res, 200, { restored: true });
+			return;
+		}
+		if (pathname === "/api/v1/chat/workspaces") {
+			if (method === "GET") {
+				this.options.auth.requireScope(principal, "chat.read");
+				sendJson(res, 200, { items: await this.options.chat.listWorkspaces(principal) });
+				return;
+			}
+			if (method === "POST") {
+				this.options.auth.requireScope(principal, "chat.write");
+				const body = await readJson(req, 64e3);
+				if (typeof body.rootId !== "string" || typeof body.path !== "string") throw new ApiError(400, "BODY_INVALID", "rootId and path are required strings.");
+				const workspace = await this.options.chat.createWorkspace(principal, body.rootId, body.path);
+				this.audit(principal, "chat.workspace.create", body.rootId, body.path, requestId, { workspaceId: workspace.id });
+				sendJson(res, 201, { workspace });
+				return;
+			}
+		}
+		const workspaceRoute = pathname.match(/^\/api\/v1\/chat\/workspaces\/([^/]+)$/);
+		if (workspaceRoute !== null) {
+			const workspaceId = decodeURIComponent(workspaceRoute[1]);
+			if (method === "PATCH") {
+				this.options.auth.requireScope(principal, "chat.write");
+				const body = await readJson(req, 64e3);
+				if (typeof body.title !== "string") throw new ApiError(400, "BODY_INVALID", "title is required.");
+				const workspace = await this.options.chat.renameWorkspace(principal, workspaceId, body.title);
+				this.audit(principal, "chat.workspace.rename", workspace.rootId, workspace.path, requestId, { workspaceId });
+				sendJson(res, 200, { workspace });
+				return;
+			}
+			if (method === "DELETE") {
+				this.options.auth.requireScope(principal, "chat.write");
+				await this.options.chat.deleteWorkspace(principal, workspaceId);
+				this.audit(principal, "chat.workspace.delete", void 0, void 0, requestId, { workspaceId });
+				sendJson(res, 200, { deleted: true });
+				return;
+			}
+		}
+		if (method === "GET" && pathname === "/api/v1/chat/agent-presets") {
+			this.options.auth.requireScope(principal, "chat.read");
+			sendJson(res, 200, { items: await this.options.chat.listAgentPresets() });
+			return;
+		}
+		if (pathname === "/api/v1/settings/providers") {
+			if (method === "GET") {
+				this.options.auth.requireScope(principal, "settings.read");
+				sendJson(res, 200, await this.options.settings.listProviders());
+				return;
+			}
+			if (method === "POST") {
+				this.options.auth.requireScope(principal, "settings.write");
+				const body = await readJson(req, 1e6);
+				if (typeof body.id !== "string" || typeof body.baseURL !== "string" || typeof body.api !== "string" || !Array.isArray(body.models)) throw new ApiError(400, "BODY_INVALID", "id, baseURL, api, and models are required.");
+				const input = {
+					id: body.id,
+					baseURL: body.baseURL,
+					api: body.api,
+					models: body.models,
+					...typeof body.displayName === "string" ? { displayName: body.displayName } : {},
+					...typeof body.apiKey === "string" ? { apiKey: body.apiKey } : {},
+					...Number.isSafeInteger(body.expectedRevision) ? { expectedRevision: body.expectedRevision } : {}
+				};
+				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() !== ""
+				});
+				sendJson(res, 201, await this.options.settings.listProviders());
+				return;
+			}
+		}
+		if (method === "GET" && pathname === "/api/v1/settings/models") {
+			this.options.auth.requireScope(principal, "settings.read");
+			sendJson(res, 200, await this.options.settings.catalog());
+			return;
+		}
+		if (method === "GET" && pathname === "/api/v1/settings/plugins") {
+			this.options.auth.requireScope(principal, "settings.read");
+			sendJson(res, 200, await readPluginInventory());
+			return;
+		}
+		const providerRoute = pathname.match(/^\/api\/v1\/settings\/providers\/([^/]+)$/);
+		if (providerRoute !== null) {
+			const providerId = decodeURIComponent(providerRoute[1]);
+			if (method === "PATCH") {
+				this.options.auth.requireScope(principal, "settings.write");
+				const body = await readJson(req, 1e6);
+				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")
+				});
+				sendJson(res, 200, await this.options.settings.listProviders());
+				return;
+			}
+			if (method === "DELETE") {
+				this.options.auth.requireScope(principal, "settings.write");
+				const expectedRevision = optionalInteger(url.searchParams.get("expectedRevision"));
+				await this.options.settings.removeProvider(providerId, expectedRevision);
+				this.audit(principal, "settings.provider.remove", void 0, void 0, requestId, { providerId });
+				res.writeHead(204);
+				res.end();
+				return;
+			}
+		}
+		const discoverProviderRoute = pathname.match(/^\/api\/v1\/settings\/providers\/([^/]+)\/discover$/);
+		if (method === "POST" && discoverProviderRoute !== null) {
+			this.options.auth.requireScope(principal, "settings.write");
+			const providerId = decodeURIComponent(discoverProviderRoute[1]);
+			const body = await readJson(req, 64e3);
+			const draft = {
+				...typeof body.baseURL === "string" ? { baseURL: body.baseURL } : {},
+				...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 });
+			return;
+		}
+		if (pathname === "/api/v1/chat/sessions") {
+			if (method === "GET") {
+				this.options.auth.requireScope(principal, "chat.read");
+				sendJson(res, 200, { items: await this.options.chat.listSessions(principal) });
+				return;
+			}
+			if (method === "POST") {
+				this.options.auth.requireScope(principal, "chat.write");
+				const body = await readJson(req, 64e3);
+				const cached = this.readIdempotent(principal, body.clientRequestId);
+				if (cached !== void 0) {
+					sendJson(res, cached.status, cached.body);
+					return;
+				}
+				const options = {
+					...typeof body.sessionId === "string" ? { sessionId: body.sessionId } : {},
+					...typeof body.agentPreset === "string" ? { agentPreset: body.agentPreset } : {}
+				};
+				const usesWorkspace = typeof body.workspaceId === "string";
+				const usesLegacyPath = typeof body.rootId === "string" && typeof body.path === "string";
+				if (!usesWorkspace && !usesLegacyPath) throw new ApiError(400, "BODY_INVALID", "workspaceId or rootId with path is required.");
+				const response = { session: usesWorkspace ? await this.options.chat.createSessionInWorkspace(principal, body.workspaceId, options) : await this.options.chat.createSession(principal, body.rootId, body.path, options) };
+				this.saveIdempotent(principal, body.clientRequestId, 201, response);
+				this.audit(principal, "chat.session.create", usesLegacyPath ? body.rootId : void 0, usesLegacyPath ? body.path : void 0, requestId, usesWorkspace ? { workspaceId: body.workspaceId } : {});
+				sendJson(res, 201, response);
+				return;
+			}
+		}
+		const sessionRoute = pathname.match(/^\/api\/v1\/chat\/sessions\/([^/]+)$/);
+		if (method === "PATCH" && sessionRoute !== null) {
+			this.options.auth.requireScope(principal, "chat.write");
+			const sessionId = decodeURIComponent(sessionRoute[1]);
+			const body = await readJson(req, 64e3);
+			if (typeof body.title !== "string") throw new ApiError(400, "BODY_INVALID", "title is required.");
+			const result = await this.options.chat.renameSession(principal, sessionId, body.title);
+			this.audit(principal, "chat.session.rename", void 0, void 0, requestId, { sessionId });
+			sendJson(res, 200, result);
+			return;
+		}
+		const forkSessionRoute = pathname.match(/^\/api\/v1\/chat\/sessions\/([^/]+)\/fork$/);
+		if (method === "POST" && forkSessionRoute !== null) {
+			this.options.auth.requireScope(principal, "chat.write");
+			const sessionId = decodeURIComponent(forkSessionRoute[1]);
+			const body = await readJson(req, 16384);
+			const atSeq = body.atSeq === void 0 ? void 0 : body.atSeq;
+			if (atSeq !== void 0 && (!Number.isSafeInteger(atSeq) || atSeq < 0)) throw new ApiError(400, "BODY_INVALID", "atSeq must be a non-negative integer.");
+			const forkedSessionId = await this.options.chat.forkSession(principal, sessionId, atSeq);
+			this.audit(principal, "chat.session.fork", void 0, void 0, requestId, {
+				sessionId,
+				forkedSessionId
+			});
+			sendJson(res, 201, { sessionId: forkedSessionId });
+			return;
+		}
+		const archiveSessionRoute = pathname.match(/^\/api\/v1\/chat\/sessions\/([^/]+)\/archive$/);
+		if (method === "POST" && archiveSessionRoute !== null) {
+			this.options.auth.requireScope(principal, "chat.write");
+			const sessionId = decodeURIComponent(archiveSessionRoute[1]);
+			await this.options.chat.archiveSession(principal, sessionId);
+			this.audit(principal, "chat.session.archive", void 0, void 0, requestId, { sessionId });
+			sendJson(res, 200, { archived: true });
+			return;
+		}
+		const messagesRoute = pathname.match(/^\/api\/v1\/chat\/sessions\/([^/]+)\/messages$/);
+		if (messagesRoute !== null) {
+			const sessionId = decodeURIComponent(messagesRoute[1]);
+			if (method === "GET") {
+				this.options.auth.requireScope(principal, "chat.read");
+				const beforeSeq = optionalInteger(url.searchParams.get("beforeSeq"));
+				const maxMessages = optionalInteger(url.searchParams.get("maxMessages"));
+				sendJson(res, 200, await this.options.chat.history(principal, sessionId, {
+					...beforeSeq === void 0 ? {} : { beforeSeq },
+					...maxMessages === void 0 ? {} : { maxMessages }
+				}));
+				return;
+			}
+			if (method === "POST") {
+				this.options.auth.requireScope(principal, "chat.write");
+				const body = await readJson(req, 12e6);
+				const cached = this.readIdempotent(principal, body.clientRequestId);
+				if (cached !== void 0) {
+					sendJson(res, cached.status, cached.body);
+					return;
+				}
+				const parts = readPromptParts(body);
+				const mode = body.mode === "steer" ? "steer" : "queue";
+				const response = { message: await this.options.chat.prompt(principal, sessionId, parts, mode, typeof body.clientTimeZone === "string" ? body.clientTimeZone : void 0) };
+				this.saveIdempotent(principal, body.clientRequestId, 202, response);
+				this.audit(principal, "chat.message.submit", void 0, void 0, requestId, {
+					sessionId,
+					mode
+				});
+				sendJson(res, 202, response);
+				return;
+			}
+		}
+		const attachmentRoute = pathname.match(/^\/api\/v1\/attachments\/([^/]+)$/);
+		if (attachmentRoute !== null && method === "GET") {
+			this.options.auth.requireScope(principal, "files.read");
+			const attachmentId = decodeURIComponent(attachmentRoute[1]);
+			const { bytes, mediaType } = await this.options.chat.readAttachment(principal, attachmentId);
+			res.statusCode = 200;
+			res.setHeader("Content-Type", mediaType);
+			res.setHeader("Content-Length", String(bytes.byteLength));
+			res.setHeader("Cache-Control", "private, max-age=31536000, immutable");
+			res.end(Buffer.from(bytes));
+			return;
+		}
+		const attachmentsRoute = pathname.match(/^\/api\/v1\/chat\/sessions\/([^/]+)\/attachments$/);
+		if (attachmentsRoute !== null && method === "POST") {
+			this.options.auth.requireScope(principal, "chat.write");
+			const body = await readJson(req, 24e6);
+			if (typeof body.data !== "string" || body.data === "") throw new ApiError(400, "BODY_INVALID", "data (base64) is required.");
+			const name = typeof body.name === "string" && body.name.trim() !== "" ? body.name.trim() : void 0;
+			sendJson(res, 201, await this.options.chat.uploadAttachment(principal, decodeURIComponent(attachmentsRoute[1]), body.data, name));
+			return;
+		}
+		const commandsRoute = pathname.match(/^\/api\/v1\/chat\/sessions\/([^/]+)\/commands$/);
+		if (commandsRoute !== null) {
+			const sessionId = decodeURIComponent(commandsRoute[1]);
+			if (method === "GET") {
+				this.options.auth.requireScope(principal, "chat.read");
+				sendJson(res, 200, { items: await this.options.chat.listCommands(principal, sessionId) });
+				return;
+			}
+			if (method === "POST") {
+				this.options.auth.requireScope(principal, "chat.write");
+				const body = await readJson(req, 32768);
+				if (typeof body.line !== "string") throw new ApiError(400, "BODY_INVALID", "line is required.");
+				const execution = await this.options.chat.executeCommand(principal, sessionId, body.line);
+				this.audit(principal, "chat.command.execute", void 0, void 0, requestId, {
+					sessionId,
+					command: commandName(body.line)
+				});
+				sendJson(res, 200, { execution });
+				return;
+			}
+		}
+		const approvalsRoute = pathname.match(/^\/api\/v1\/chat\/sessions\/([^/]+)\/approvals$/);
+		if (method === "GET" && approvalsRoute !== null) {
+			this.options.auth.requireScope(principal, "chat.read");
+			const sessionId = decodeURIComponent(approvalsRoute[1]);
+			sendJson(res, 200, { items: await this.options.chat.listPendingApprovals(principal, sessionId) });
+			return;
+		}
+		const approvalDecisionRoute = pathname.match(/^\/api\/v1\/chat\/sessions\/([^/]+)\/approvals\/([^/]+)\/decision$/);
+		if (method === "POST" && approvalDecisionRoute !== null) {
+			this.options.auth.requireScope(principal, "chat.write");
+			const sessionId = decodeURIComponent(approvalDecisionRoute[1]);
+			const approvalId = decodeURIComponent(approvalDecisionRoute[2]);
+			const body = await readJson(req, 16384);
+			if (body.outcome !== "allowed-once" && body.outcome !== "rejected") throw new ApiError(400, "BODY_INVALID", "outcome must be allowed-once or rejected.");
+			const approval = await this.options.chat.decideApproval(principal, sessionId, approvalId, body.outcome);
+			this.audit(principal, "chat.approval.decide", void 0, void 0, requestId, {
+				sessionId,
+				approvalId,
+				outcome: body.outcome,
+				toolName: approval.toolName,
+				risk: approval.risk
+			});
+			sendJson(res, 202, { accepted: true });
+			return;
+		}
+		const sessionModelsRoute = pathname.match(/^\/api\/v1\/chat\/sessions\/([^/]+)\/model(?:s)?$/);
+		if (sessionModelsRoute !== null) {
+			const sessionId = decodeURIComponent(sessionModelsRoute[1]);
+			if (method === "GET") {
+				this.options.auth.requireScope(principal, "chat.read");
+				sendJson(res, 200, await this.options.chat.models(principal, sessionId));
+				return;
+			}
+			if (method === "PUT" && pathname.endsWith("/model")) {
+				this.options.auth.requireScope(principal, "chat.write");
+				const body = await readJson(req, 64e3);
+				if (typeof body.provider !== "string" || typeof body.model !== "string") throw new ApiError(400, "BODY_INVALID", "provider and model are required strings.");
+				const selected = await this.options.chat.selectModel(principal, sessionId, {
+					provider: body.provider,
+					model: body.model,
+					...typeof body.reasoningEffort === "string" ? { reasoningEffort: body.reasoningEffort } : {}
+				});
+				this.audit(principal, "chat.model.select", void 0, void 0, requestId, {
+					sessionId,
+					provider: selected.provider,
+					model: selected.model,
+					...selected.reasoningEffort === void 0 ? {} : { reasoningEffort: selected.reasoningEffort }
+				});
+				sendJson(res, 200, { selected });
+				return;
+			}
+		}
+		const sessionAgentPresetRoute = pathname.match(/^\/api\/v1\/chat\/sessions\/([^/]+)\/agent-preset$/);
+		if (method === "PUT" && sessionAgentPresetRoute !== null) {
+			this.options.auth.requireScope(principal, "chat.write");
+			const sessionId = decodeURIComponent(sessionAgentPresetRoute[1]);
+			const body = await readJson(req, 64e3);
+			if (typeof body.agentPreset !== "string") throw new ApiError(400, "BODY_INVALID", "agentPreset is required.");
+			const agentPreset = await this.options.chat.selectAgentPreset(principal, sessionId, body.agentPreset);
+			this.audit(principal, "chat.agent-preset.select", void 0, void 0, requestId, {
+				sessionId,
+				agentPreset
+			});
+			sendJson(res, 200, { agentPreset });
+			return;
+		}
+		const cancelRoute = pathname.match(/^\/api\/v1\/chat\/runs\/([^/]+)\/cancel$/);
+		if (method === "POST" && cancelRoute !== null) {
+			this.options.auth.requireScope(principal, "chat.write");
+			const sessionId = decodeURIComponent(cancelRoute[1]);
+			await this.options.chat.cancel(principal, sessionId);
+			this.audit(principal, "chat.run.cancel", void 0, void 0, requestId, { sessionId });
+			sendJson(res, 202, { accepted: true });
+			return;
+		}
+		throw new ApiError(404, "ROUTE_NOT_FOUND", "The requested API route does not exist.");
+	}
+	async dispatchManagement(req, res, url, requestId) {
+		const method = req.method ?? "GET";
+		const pathname = url.pathname.replace(/\/$/, "");
+		if (method === "GET" && pathname === "/manage/status") {
+			const operationId = url.searchParams.get("operationId") ?? void 0;
+			sendJson(res, 200, {
+				...this.options.remote.status(operationId),
+				roots: this.options.database.listRoots(),
+				devices: this.options.database.listDevices()
+			});
+			return;
+		}
+		if (method === "GET" && pathname === "/manage/roots") {
+			sendJson(res, 200, { items: this.options.database.listRoots() });
+			return;
+		}
+		if (method === "POST" && pathname === "/manage/roots") {
+			const body = await readJson(req, 64e3);
+			if (typeof body.path !== "string") throw new ApiError(400, "BODY_INVALID", "path is required.");
+			sendJson(res, 201, await this.options.database.addRoot(body.path, typeof body.label === "string" ? body.label : void 0));
+			return;
+		}
+		const rootRoute = pathname.match(/^\/manage\/roots\/([^/]+)$/);
+		if (method === "DELETE" && rootRoute !== null) {
+			this.options.database.removeRoot(decodeURIComponent(rootRoute[1]));
+			res.writeHead(204);
+			res.end();
+			return;
+		}
+		if (method === "GET" && pathname === "/manage/devices") {
+			sendJson(res, 200, { items: this.options.database.listDevices() });
+			return;
+		}
+		const deviceRoute = pathname.match(/^\/manage\/devices\/([^/]+)$/);
+		if (deviceRoute !== null && method === "PATCH") {
+			const body = await readJson(req, 64e3);
+			const scopes = validateScopes(body.scopes);
+			const rootIds = validateStringArray(body.rootIds, "rootIds");
+			sendJson(res, 200, this.options.database.updateDevice(decodeURIComponent(deviceRoute[1]), scopes, rootIds));
+			return;
+		}
+		if (deviceRoute !== null && method === "DELETE") {
+			this.options.database.revokeDevice(decodeURIComponent(deviceRoute[1]));
+			res.writeHead(204);
+			res.end();
+			return;
+		}
+		if (method === "POST" && pathname === "/manage/pairings") {
+			const body = await readJson(req, 64e3);
+			sendJson(res, 201, this.options.database.createPairing(validateStringArray(body.rootIds, "rootIds"), validateScopes(body.scopes)));
+			return;
+		}
+		if (method === "POST" && pathname === "/manage/config/text") {
+			const body = await readJson(req, 64e3);
+			const port = Number.isInteger(body.port) && Number(body.port) > 0 && Number(body.port) < 65536 ? Number(body.port) : DEFAULT_PORT;
+			const endpoints = readRequestedEndpoints(body.endpoints) ?? detectEndpoints(port);
+			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 displayName = readOptionalText(body.displayName) ?? defaultDisplayName();
+			const pairing = this.options.database.createPairing(rootIds, scopes);
+			const exchanged = this.options.database.exchangePairing(pairing.code, deviceName);
+			sendJson(res, 201, {
+				text: encodeConfigText({
+					displayName,
+					endpoints,
+					token: exchanged.token,
+					deviceName,
+					scopes
+				}),
+				displayName,
+				deviceName,
+				endpoints,
+				deviceId: exchanged.device.id
+			});
+			return;
+		}
+		if (method === "POST" && pathname === "/manage/remote/enable") {
+			const body = await readJson(req, 64e3);
+			const operation = this.options.remote.enable(validateStringArray(body.rootIds, "rootIds"), validateScopes(body.scopes));
+			res.setHeader("Connection", "close");
+			sendJson(res, 202, operation);
+			return;
+		}
+		if (method === "POST" && pathname === "/manage/remote/disable") {
+			const operation = this.options.remote.disable();
+			res.setHeader("Connection", "close");
+			sendJson(res, 202, operation);
+			return;
+		}
+		if (method === "PUT" && pathname === "/manage/remote/listener") {
+			const body = await readJson(req, 16384);
+			const operation = this.options.remote.configure(typeof body.host === "string" ? body.host : "", body.port);
+			res.setHeader("Connection", "close");
+			sendJson(res, 202, operation);
+			return;
+		}
+		if (method === "GET" && pathname === "/manage/audit") {
+			sendJson(res, 200, { items: this.options.database.listAudit(optionalInteger(url.searchParams.get("limit")) ?? 200) });
+			return;
+		}
+		const purgeRoute = pathname.match(/^\/manage\/trash\/([^/]+)$/);
+		if (method === "DELETE" && purgeRoute !== null) {
+			await this.options.files.purgeTrash(decodeURIComponent(purgeRoute[1]));
+			this.options.database.audit("admin", "loopback-admin", "trash.purge", void 0, void 0, {}, requestId);
+			res.writeHead(204);
+			res.end();
+			return;
+		}
+		throw new ApiError(404, "ROUTE_NOT_FOUND", "The requested management route does not exist.");
+	}
+	async dispatchEntries(req, res, url, principal, root, requestId) {
+		const method = req.method ?? "GET";
+		if (method === "GET") {
+			this.options.auth.requireScope(principal, "files.read");
+			sendJson(res, 200, await this.options.files.list(root, url.searchParams.get("path") ?? "", optionalInteger(url.searchParams.get("limit")) ?? 200, url.searchParams.get("cursor") ?? void 0));
+			return;
+		}
+		if (method === "POST") {
+			this.options.auth.requireScope(principal, "files.write");
+			const body = await readJson(req, 64e3);
+			if (typeof body.path !== "string" || body.kind !== "file" && body.kind !== "directory") throw new ApiError(400, "BODY_INVALID", "path and a file/directory kind are required.");
+			const entry = await this.options.files.createEntry(root, body.path, body.kind);
+			this.audit(principal, "file.create", root.id, body.path, requestId, { kind: body.kind });
+			sendJson(res, 201, entry);
+			return;
+		}
+		if (method === "PATCH") {
+			this.options.auth.requireScope(principal, "files.write");
+			const body = await readJson(req, 64e3);
+			if (typeof body.path !== "string" || typeof body.destinationPath !== "string") throw new ApiError(400, "BODY_INVALID", "path and destinationPath are required.");
+			await this.options.files.moveEntry(root, body.path, body.destinationPath);
+			this.audit(principal, "file.move", root.id, body.path, requestId, { destinationPath: body.destinationPath });
+			sendJson(res, 200, { moved: true });
+			return;
+		}
+		if (method === "DELETE") {
+			this.options.auth.requireScope(principal, "files.delete");
+			const relativePath = url.searchParams.get("path");
+			if (relativePath === null) throw new ApiError(400, "PATH_REQUIRED", "The path query parameter is required.");
+			const item = await this.options.files.trashEntry(root, relativePath);
+			this.audit(principal, "file.trash", root.id, relativePath, requestId, { trashId: item.id });
+			sendJson(res, 200, item);
+			return;
+		}
+		throw new ApiError(405, "METHOD_NOT_ALLOWED", "The method is not supported for entries.");
+	}
+	async dispatchContent(req, res, url, principal, root, requestId) {
+		const relativePath = url.searchParams.get("path");
+		if (relativePath === null) throw new ApiError(400, "PATH_REQUIRED", "The path query parameter is required.");
+		if (req.method === "GET") {
+			this.options.auth.requireScope(principal, "files.read");
+			const descriptor = await this.options.files.inspectContent(root, relativePath);
+			const range = parseRange(req.headers.range, descriptor.size);
+			res.setHeader("Accept-Ranges", "bytes");
+			res.setHeader("ETag", descriptor.etag);
+			res.setHeader("Last-Modified", new Date(descriptor.modifiedAt).toUTCString());
+			res.setHeader("Content-Type", descriptor.contentType);
+			res.setHeader("Content-Disposition", `inline; filename*=UTF-8''${encodeURIComponent(relativePath.split("/").at(-1) ?? "file")}`);
+			if (range === void 0) {
+				res.writeHead(200, { "Content-Length": descriptor.size });
+				this.options.files.streamContent(descriptor).pipe(res);
+			} else {
+				res.writeHead(206, {
+					"Content-Length": range.end - range.start + 1,
+					"Content-Range": `bytes ${range.start}-${range.end}/${descriptor.size}`
+				});
+				this.options.files.streamContent(descriptor, range).pipe(res);
+			}
+			return;
+		}
+		if (req.method === "PUT") {
+			this.options.auth.requireScope(principal, "files.write");
+			const content = await readBytes(req, this.options.maxUploadBytes);
+			const result = await this.options.files.writeContent(root, relativePath, content, {
+				...req.headers["if-match"] === void 0 ? {} : { ifMatch: String(req.headers["if-match"]) },
+				...req.headers["if-none-match"] === void 0 ? {} : { ifNoneMatch: String(req.headers["if-none-match"]) }
+			});
+			this.audit(principal, "file.write", root.id, relativePath, requestId, {
+				size: result.size,
+				etag: result.etag
+			});
+			res.setHeader("ETag", result.etag);
+			sendJson(res, 200, result);
+			return;
+		}
+		throw new ApiError(405, "METHOD_NOT_ALLOWED", "The method is not supported for content.");
+	}
+	requireRoot(principal, rootId) {
+		this.options.auth.requireRoot(principal, rootId);
+		const root = this.options.database.getRoot(rootId);
+		if (root === void 0) throw new ApiError(404, "ROOT_NOT_FOUND", "The authorized root does not exist.");
+		return root;
+	}
+	authorizedRoots(principal) {
+		const roots = this.options.database.listRoots();
+		return principal.rootIds === "all" ? roots : roots.filter((root) => principal.rootIds.has(root.id));
+	}
+	audit(principal, action, rootId, relativePath, requestId, details = {}) {
+		this.options.database.audit(principal.kind, principal.id, action, rootId, relativePath, details, requestId);
+	}
+	readIdempotent(principal, key) {
+		if (principal.kind !== "device" || typeof key !== "string" || key === "") return void 0;
+		return this.options.database.readIdempotent(principal.id, key);
+	}
+	saveIdempotent(principal, key, status, body) {
+		if (principal.kind === "device" && typeof key === "string" && key !== "") this.options.database.saveIdempotent(principal.id, key, status, body);
+	}
+};
+async function readJson(req, maxBytes) {
+	const bytes = await readBytes(req, maxBytes);
+	if (bytes.length === 0) return {};
+	try {
+		return JSON.parse(Buffer.from(bytes).toString("utf8"));
+	} catch {
+		throw new ApiError(400, "JSON_INVALID", "The request body is not valid JSON.");
+	}
+}
+async function readBytes(req, maxBytes) {
+	const declared = Number(req.headers["content-length"] ?? 0);
+	if (Number.isFinite(declared) && declared > maxBytes) throw new ApiError(413, "BODY_TOO_LARGE", "The request body is too large.");
+	const chunks = [];
+	let total = 0;
+	for await (const chunk of req) {
+		const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+		total += buffer.length;
+		if (total > maxBytes) throw new ApiError(413, "BODY_TOO_LARGE", "The request body is too large.");
+		chunks.push(buffer);
+	}
+	return Buffer.concat(chunks);
+}
+function sendJson(res, status, body) {
+	const encoded = Buffer.from(JSON.stringify(body));
+	res.writeHead(status, {
+		"Content-Type": "application/json; charset=utf-8",
+		"Content-Length": encoded.length
+	});
+	res.end(encoded);
+}
+function setCors(req, res) {
+	const origin = req.headers.origin;
+	if (origin !== void 0) {
+		res.setHeader("Access-Control-Allow-Origin", origin);
+		res.setHeader("Vary", "Origin");
+	}
+	res.setHeader("Access-Control-Allow-Headers", "Authorization, Content-Type, If-Match, If-None-Match, X-Request-Id, X-Dsh-Workspace-Admin");
+	res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, PATCH, DELETE, OPTIONS");
+	res.setHeader("Access-Control-Expose-Headers", "ETag, Content-Range, X-Request-Id");
+	res.setHeader("Cache-Control", "no-store");
+}
+function validateScopes(value) {
+	const values = validateStringArray(value, "scopes");
+	if (values.some((item) => !DEVICE_SCOPES.includes(item))) throw new ApiError(400, "SCOPE_INVALID", "The request contains an unknown device scope.");
+	return [...new Set(values)];
+}
+/**
+* 把请求体解析成 prompt 内容片段。
+*
+* **向后兼容是硬要求**：旧客户端只发 `{"text":"..."}`，新客户端发 `{"content":[...]}`。
+* 两种都必须能用 —— 否则一次服务端升级就会让所有还在用旧版的人发不出消息。
+*
+* 这里逐项校验而不是直接透传：`content` 里的 `type` 是判别器，透传非法结构给内核
+* 只会换来一个更难懂的报错。
+*/
+function readPromptParts(body) {
+	if (body.content === void 0) {
+		if (typeof body.text !== "string") throw new ApiError(400, "BODY_INVALID", "text or content is required.");
+		return [{
+			type: "text",
+			text: body.text
+		}];
+	}
+	if (!Array.isArray(body.content) || body.content.length === 0) throw new ApiError(400, "BODY_INVALID", "content must be a non-empty array.");
+	return body.content.map((raw, index) => {
+		if (typeof raw !== "object" || raw === null) throw new ApiError(400, "BODY_INVALID", `content[${index}] must be an object.`);
+		const part = raw;
+		if (part.type === "text") {
+			if (typeof part.text !== "string") throw new ApiError(400, "BODY_INVALID", `content[${index}].text is required.`);
+			return {
+				type: "text",
+				text: part.text
+			};
+		}
+		if (part.type === "image") {
+			if (typeof part.mediaType !== "string" || typeof part.data !== "string") throw new ApiError(400, "BODY_INVALID", `content[${index}] needs mediaType and data.`);
+			return {
+				type: "image",
+				mediaType: part.mediaType,
+				data: part.data,
+				...typeof part.name === "string" && part.name !== "" ? { name: part.name } : {}
+			};
+		}
+		if (part.type === "file") {
+			if (typeof part.receiptId !== "string" || part.receiptId === "") throw new ApiError(400, "BODY_INVALID", `content[${index}].receiptId is required.`);
+			return {
+				type: "file",
+				receiptId: part.receiptId
+			};
+		}
+		throw new ApiError(400, "BODY_INVALID", `content[${index}].type is not supported.`);
+	});
+}
+function validateStringArray(value, name) {
+	if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) throw new ApiError(400, "BODY_INVALID", `${name} must be an array of strings.`);
+	return [...new Set(value)];
+}
+/**
+* 生成配置文本时的默认设备权限。
+*
+* 刻意**不含** `files.delete` 与 `settings.write`：这两个是破坏性权限，应当是用户显式
+* 要求才授予，而不是因为「生成了一段配置文本」就顺手给了。需要时可在请求里显式传 scopes。
+*/
+const DEFAULT_CONFIG_SCOPES = [
+	"chat.read",
+	"chat.write",
+	"files.read",
+	"files.write",
+	"settings.read"
+];
+function readOptionalText(value) {
+	if (typeof value !== "string") return null;
+	const text = value.trim();
+	return text === "" ? null : text;
+}
+/**
+* 读取请求里显式给出的地址列表；没给或格式不对时返回 null（调用方改用自动探测）。
+*
+* 这里对空数组也返回 null —— 「用户明确说一个地址都不要」不是有意义的输入。
+*/
+function readRequestedEndpoints(value) {
+	if (!Array.isArray(value) || value.length === 0) return null;
+	const endpoints = [];
+	for (const item of value) {
+		if (typeof item !== "object" || item === null) throw new ApiError(400, "BODY_INVALID", "endpoints must be an array of objects.");
+		const baseUrl = readOptionalText(item.baseUrl);
+		if (baseUrl === null) throw new ApiError(400, "BODY_INVALID", "Each endpoint requires a non-empty baseUrl.");
+		const label = readOptionalText(item.label) ?? baseUrl;
+		const host = baseUrl.replace(/^https?:\/\//i, "").split("/")[0]?.split(":")[0] ?? "";
+		endpoints.push({
+			label,
+			baseUrl,
+			kind: classifyHost(host)
+		});
+	}
+	return endpoints;
+}
+function optionalInteger(value) {
+	if (value === null || value === "") return void 0;
+	const parsed = Number(value);
+	if (!Number.isSafeInteger(parsed) || parsed < 0) throw new ApiError(400, "NUMBER_INVALID", "A query parameter must be a non-negative integer.");
+	return parsed;
+}
+function commandName(line) {
+	return /^\/([a-z][a-z0-9_-]*)/u.exec(line)?.[1] ?? "unknown";
+}
+function parseRange(value, size) {
+	if (value === void 0) return void 0;
+	const match = /^bytes=(\d*)-(\d*)$/.exec(value);
+	if (match === null) throw new ApiError(416, "RANGE_INVALID", "Only a single byte range is supported.");
+	let start;
+	let end;
+	if (match[1] === "") {
+		const suffix = Number(match[2]);
+		if (!Number.isSafeInteger(suffix) || suffix <= 0) throw new ApiError(416, "RANGE_INVALID", "The byte range is invalid.");
+		start = Math.max(0, size - suffix);
+		end = size - 1;
+	} else {
+		start = Number(match[1]);
+		end = match[2] === "" ? size - 1 : Number(match[2]);
+	}
+	if (start < 0 || end < start || start >= size) throw new ApiError(416, "RANGE_INVALID", "The byte range is outside the file.");
+	return {
+		start,
+		end: Math.min(end, size - 1)
+	};
+}
+function header(req, name) {
+	const value = req.headers[name];
+	return Array.isArray(value) ? value[0] : value;
+}
+//#endregion
+//#region src/host/server.ts
+var RemoteApiServer = class {
+	options;
+	server;
+	host = "127.0.0.1";
+	actualPort;
+	configuredHost;
+	configuredPort;
+	remoteEnabled = false;
+	operations = /* @__PURE__ */ new Map();
+	sockets = /* @__PURE__ */ new Map();
+	webSockets = new WebSocketServer({
+		noServer: true,
+		clientTracking: false
+	});
+	eventsAbort = new AbortController();
+	unsubscribeEvents;
+	broadcastQueue = Promise.resolve();
+	changing = false;
+	constructor(options) {
+		this.options = options;
+		const fallbackHost = normalizeListenerHost(options.remoteHost ?? "0.0.0.0");
+		const fallbackPort = normalizeListenerPort(options.port, true);
+		this.configuredHost = readStoredHost(options.database, fallbackHost);
+		this.configuredPort = readStoredPort(options.database, fallbackPort);
+		this.actualPort = this.configuredPort;
+	}
+	async start() {
+		this.remoteEnabled = this.options.database.getSetting("remote_enabled") === "true";
+		const requestedHost = this.remoteEnabled ? this.configuredHost : loopbackFor(this.configuredHost);
+		try {
+			await this.bind(requestedHost, this.configuredPort);
+		} catch (error) {
+			if (!this.remoteEnabled) throw error;
+			this.remoteEnabled = false;
+			this.options.database.setSetting("remote_enabled", "false");
+			await this.bind(loopbackFor(this.configuredHost), this.configuredPort);
+		}
+		this.unsubscribeEvents = this.options.events.subscribe((event) => {
+			this.broadcastQueue = this.broadcastQueue.then(() => this.broadcast(event)).catch(() => void 0);
+		});
+		this.options.chat.startEvents(this.eventsAbort.signal, (event) => {
+			this.options.events.emit(event);
+		});
+	}
+	async stop() {
+		this.eventsAbort.abort();
+		this.unsubscribeEvents?.();
+		this.unsubscribeEvents = void 0;
+		await this.broadcastQueue;
+		await this.closeCurrent();
+		this.webSockets.close();
+	}
+	status(operationId) {
+		const operation = operationId === void 0 ? void 0 : this.operations.get(operationId);
+		return {
+			host: this.host,
+			port: this.actualPort,
+			configuredHost: this.configuredHost,
+			configuredPort: this.configuredPort,
+			remoteEnabled: this.remoteEnabled,
+			...operation === void 0 ? {} : { operation: publicOperation(operation) }
+		};
+	}
+	enable(rootIds, scopes) {
+		return this.scheduleChange({
+			kind: "enable",
+			targetHost: this.configuredHost,
+			targetPort: this.configuredPort,
+			nextRemoteEnabled: true,
+			rootIds,
+			scopes
+		});
+	}
+	disable() {
+		return this.scheduleChange({
+			kind: "disable",
+			targetHost: loopbackFor(this.configuredHost),
+			targetPort: this.configuredPort,
+			nextRemoteEnabled: false
+		});
+	}
+	configure(host, port) {
+		if (this.remoteEnabled) throw new ApiError(409, "REMOTE_ENABLED", "Disable remote access before changing the listener address.");
+		const configuredHost = normalizeListenerHost(host);
+		const configuredPort = normalizeListenerPort(port);
+		return this.scheduleChange({
+			kind: "configure",
+			targetHost: loopbackFor(configuredHost),
+			targetPort: configuredPort,
+			nextRemoteEnabled: false,
+			configuredHost,
+			configuredPort
+		});
+	}
+	scheduleChange(input) {
+		if (this.changing) throw new ApiError(409, "LISTENER_CHANGE_PENDING", "A listener change is already in progress.");
+		const operation = {
+			id: randomUUID(),
+			state: "pending",
+			...input
+		};
+		this.operations.set(operation.id, operation);
+		this.changing = true;
+		setTimeout(() => {
+			this.performChange(operation);
+		}, 75);
+		return publicOperation(operation);
+	}
+	async performChange(operation) {
+		const previousHost = this.host;
+		const previousPort = this.actualPort;
+		try {
+			if (previousHost !== operation.targetHost || previousPort !== operation.targetPort) await this.rebind(operation.targetHost, operation.targetPort, previousHost, previousPort);
+			if (operation.configuredHost !== void 0 && operation.configuredPort !== void 0) {
+				this.configuredHost = operation.configuredHost;
+				this.configuredPort = operation.configuredPort;
+				this.options.database.setSetting("listener_host", this.configuredHost);
+				this.options.database.setSetting("listener_port", String(this.configuredPort));
+			}
+			this.remoteEnabled = operation.nextRemoteEnabled;
+			this.options.database.setSetting("remote_enabled", String(this.remoteEnabled));
+			if (this.remoteEnabled) {
+				const pairing = this.options.database.createPairing(operation.rootIds ?? [], operation.scopes ?? []);
+				operation.pairingCode = pairing.code;
+				operation.pairingExpiresAt = pairing.expiresAt;
+			}
+			operation.state = "succeeded";
+			this.options.database.audit("admin", "loopback-admin", `listener.${operation.kind}`, void 0, void 0, {
+				host: operation.kind === "configure" ? operation.configuredHost : operation.targetHost,
+				port: operation.targetPort
+			});
+		} catch (error) {
+			operation.state = "failed";
+			operation.code = listenerErrorCode(error);
+			operation.message = error instanceof Error ? error.message : String(error);
+		} finally {
+			this.changing = false;
+			this.trimOperations();
+		}
+	}
+	async rebind(targetHost, targetPort, previousHost, previousPort) {
+		if (targetPort !== previousPort) {
+			const replacement = await this.createBoundServer(targetHost, targetPort);
+			await this.closeCurrent();
+			this.server = replacement.server;
+			this.host = targetHost;
+			this.actualPort = replacement.port;
+			return;
+		}
+		await this.closeCurrent();
+		try {
+			await this.bind(targetHost, targetPort);
+		} catch (error) {
+			await this.bind(previousHost, previousPort);
+			throw error;
+		}
+	}
+	async bind(host, port) {
+		const bound = await this.createBoundServer(host, port);
+		this.server = bound.server;
+		this.host = host;
+		this.actualPort = bound.port;
+	}
+	async createBoundServer(host, port) {
+		const server = createServer((req, res) => {
+			this.options.handle(req, res).catch((error) => failResponse(res, error));
+		});
+		server.requestTimeout = 3e4;
+		server.headersTimeout = 1e4;
+		server.keepAliveTimeout = 5e3;
+		server.maxHeadersCount = 100;
+		server.on("upgrade", (req, socket, head) => {
+			this.handleUpgrade(req, socket, head);
+		});
+		await new Promise((resolve, reject) => {
+			const onError = (error) => reject(error);
+			server.once("error", onError);
+			server.listen(port, host, () => {
+				server.off("error", onError);
+				resolve();
+			});
+		});
+		return {
+			server,
+			port: server.address().port
+		};
+	}
+	async closeCurrent() {
+		const server = this.server;
+		if (server === void 0) return;
+		this.server = void 0;
+		for (const socket of this.sockets.keys()) socket.close(1012, "Listener rebinding");
+		this.sockets.clear();
+		await new Promise((resolve) => {
+			server.close(() => resolve());
+			server.closeAllConnections();
+		});
+	}
+	handleUpgrade(req, socket, head) {
+		try {
+			if (new URL(req.url ?? "/", "http://workspace.local").pathname !== "/api/v1/events") {
+				socket.destroy();
+				return;
+			}
+			const protocolToken = parseProtocolToken(req.headers["sec-websocket-protocol"]);
+			if (protocolToken !== void 0) req.headers.authorization = `Bearer ${protocolToken}`;
+			const principal = this.options.auth.principal(req, { allowAdmin: true });
+			this.webSockets.handleUpgrade(req, socket, head, (webSocket) => {
+				this.sockets.set(webSocket, principal);
+				webSocket.on("close", () => {
+					this.sockets.delete(webSocket);
+				});
+				webSocket.on("error", () => {
+					this.sockets.delete(webSocket);
+				});
+				webSocket.send(JSON.stringify({
+					id: randomUUID(),
+					type: "connection.ready",
+					time: Date.now(),
+					data: {}
+				}));
+			});
+		} catch {
+			socket.destroy();
+		}
+	}
+	async broadcast(event) {
+		for (const [socket, principal] of this.sockets) {
+			if (socket.readyState !== WebSocket.OPEN) continue;
+			let currentPrincipal = principal;
+			if (principal.kind === "device") {
+				const device = this.options.database.getActiveDevice(principal.id);
+				if (device === void 0) {
+					socket.close(4001, "Device revoked");
+					continue;
+				}
+				currentPrincipal = {
+					kind: "device",
+					id: device.id,
+					name: device.name,
+					scopes: new Set(device.scopes),
+					rootIds: new Set(device.rootIds)
+				};
+				this.sockets.set(socket, currentPrincipal);
+			}
+			if (!await this.eventAllowed(currentPrincipal, event)) continue;
+			socket.send(JSON.stringify(event));
+		}
+	}
+	async eventAllowed(principal, event) {
+		if (event.type.startsWith("file.") && !principal.scopes.has("files.read")) return false;
+		if (event.type.startsWith("chat.") && !principal.scopes.has("chat.read")) return false;
+		const rootId = typeof event.data.rootId === "string" ? event.data.rootId : void 0;
+		if (rootId !== void 0 && principal.rootIds !== "all" && !principal.rootIds.has(rootId)) return false;
+		const sessionId = typeof event.data.sessionId === "string" ? event.data.sessionId : void 0;
+		if (sessionId !== void 0) return this.options.chat.isSessionAuthorized(principal, sessionId);
+		return rootId !== void 0 || principal.kind === "admin";
+	}
+	trimOperations() {
+		while (this.operations.size > 20) {
+			const first = this.operations.keys().next().value;
+			if (first === void 0) break;
+			this.operations.delete(first);
+		}
+	}
+};
+function attachEmbeddedRoutes(webServer, router, remote) {
+	const disposers = [webServer.register({
+		kind: "prefix",
+		path: "/dsh-workspace-api",
+		handler: (req, res) => router.handle(req, res, "/dsh-workspace-api")
+	})];
+	return () => {
+		for (const dispose of disposers.reverse()) dispose();
+	};
+}
+function publicOperation(operation) {
+	return {
+		id: operation.id,
+		state: operation.state,
+		targetHost: operation.targetHost,
+		targetPort: operation.targetPort,
+		...operation.code === void 0 ? {} : { code: operation.code },
+		...operation.message === void 0 ? {} : { message: operation.message },
+		...operation.pairingCode === void 0 ? {} : { pairingCode: operation.pairingCode },
+		...operation.pairingExpiresAt === void 0 ? {} : { pairingExpiresAt: operation.pairingExpiresAt }
+	};
+}
+function listenerErrorCode(error) {
+	const code = typeof error === "object" && error !== null && "code" in error ? String(error.code) : "";
+	if (code === "EADDRINUSE") return "LISTENER_ADDRESS_IN_USE";
+	if (code === "EADDRNOTAVAIL" || code === "ENODEV") return "LISTENER_ADDRESS_UNAVAILABLE";
+	if (code === "EACCES") return "LISTENER_PERMISSION_DENIED";
+	return "LISTENER_CHANGE_FAILED";
+}
+function readStoredHost(database, fallback) {
+	const stored = database.getSetting("listener_host");
+	if (stored === void 0) return fallback;
+	try {
+		return normalizeListenerHost(stored);
+	} catch {
+		database.setSetting("listener_host", fallback);
+		return fallback;
+	}
+}
+function readStoredPort(database, fallback) {
+	const stored = database.getSetting("listener_port");
+	if (stored === void 0) return fallback;
+	try {
+		return normalizeListenerPort(Number(stored), fallback === 0);
+	} catch {
+		database.setSetting("listener_port", String(fallback));
+		return fallback;
+	}
+}
+function parseProtocolToken(value) {
+	const joined = Array.isArray(value) ? value.join(",") : value;
+	if (joined === void 0) return void 0;
+	return joined.split(",").map((item) => item.trim()).find((item) => item.startsWith("bearer."))?.slice(7);
+}
+function failResponse(res, error) {
+	if (res.headersSent) {
+		res.destroy(error instanceof Error ? error : void 0);
+		return;
+	}
+	const body = Buffer.from(JSON.stringify({ error: {
+		code: "INTERNAL_ERROR",
+		message: "An internal server error occurred.",
+		requestId: randomUUID()
+	} }));
+	res.writeHead(500, {
+		"Content-Type": "application/json",
+		"Content-Length": body.length
+	});
+	res.end(body);
+}
+//#endregion
+//#region src/host/settings-adapter.ts
+var DshSettingsAdapter = class {
+	api;
+	constructor(api) {
+		this.api = api;
+	}
+	async listProviders() {
+		const [directoryResponse, settingsResponse, catalogResponse] = await Promise.all([
+			this.api.llm.providers({
+				rpcId: randomUUID(),
+				payload: {}
+			}),
+			this.api.settings.describe({
+				rpcId: randomUUID(),
+				payload: {}
+			}),
+			this.api.llm.models({
+				rpcId: randomUUID(),
+				payload: {}
+			})
+		]);
+		const directory = unwrapDsh(directoryResponse);
+		const settings = unwrapDsh(settingsResponse);
+		const catalog = unwrapDsh(catalogResponse);
+		const namespaces = new Map(settings.namespaces.map((item) => [item.ns, item]));
+		const customNamespace = namespaces.get("llm-pi-ai");
+		const protocols = protocolChoices(customNamespace);
+		const rows = directory.providers.map((entry) => {
+			const namespace = namespaces.get(entry.settingsNs);
+			const profile = mergeRecords(recordAt(namespace?.base, entry.settingsPath), recordAt(namespace?.value, entry.settingsPath));
+			const userProfile = recordAt(namespace?.user, entry.settingsPath);
+			const ref = text(profile?.apiKeyEnv) ?? keyRef(entry.provider);
+			return {
+				entry,
+				namespace,
+				profile,
+				configured: profile !== void 0,
+				removable: userProfile !== void 0,
+				ref
+			};
+		});
+		const refs = [...new Set(rows.map((row) => row.ref))];
+		const described = refs.length === 0 ? { credentials: {} } : unwrapDsh(await this.api.credentials.describe({
+			rpcId: randomUUID(),
+			payload: { refs }
+		}));
+		return {
+			writable: settings.writable,
+			revisionByNamespace: Object.fromEntries(settings.namespaces.map((item) => [item.ns, item.revision])),
+			customProvider: {
+				available: customNamespace !== void 0 && protocols.length > 0,
+				protocols,
+				...customNamespace === void 0 ? {} : { revision: customNamespace.revision }
+			},
+			providers: rows.map(({ entry, profile, configured, removable, ref }) => {
+				const credential = described.credentials[ref] ?? {
+					configured: false,
+					writable: false
+				};
+				const inheritedModels = catalog.groups.find((group) => group.id === entry.provider)?.models;
+				return {
+					id: entry.provider,
+					displayName: text(profile?.displayName) ?? entry.displayName,
+					active: entry.active,
+					...entry.declared === void 0 ? {} : { declared: entry.declared },
+					configurable: entry.settingsNs !== "",
+					configured,
+					removable,
+					credential: {
+						ref,
+						...credential
+					},
+					config: projectConfig(profile, inheritedModels)
+				};
+			})
+		};
+	}
+	async catalog() {
+		return unwrapDsh(await this.api.llm.models({
+			rpcId: randomUUID(),
+			payload: {}
+		}));
+	}
+	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 = [];
+		for (const field of [
+			"displayName",
+			"baseURL",
+			"api",
+			"thinking",
+			"reasoningEffort"
+		]) {
+			if (!(field in patch)) continue;
+			const value = patch[field];
+			ops.push(value === null || value === "" ? {
+				op: "unset",
+				path: [...context.entry.settingsPath, field]
+			} : {
+				op: "set",
+				path: [...context.entry.settingsPath, field],
+				value
+			});
+		}
+		if (patch.models !== void 0) {
+			validateModels(patch.models);
+			ops.push({
+				op: "set",
+				path: [...context.entry.settingsPath, "models"],
+				value: patch.models
+			});
+		}
+		const ref = text(context.profile?.apiKeyEnv) ?? keyRef(providerId);
+		if (context.entry.settingsPath.length > 0 && context.profile === void 0) ops.unshift({
+			op: "set",
+			path: [...context.entry.settingsPath, "apiKeyEnv"],
+			value: ref
+		});
+		if (ops.length > 0) unwrapDsh(await this.api.settings.mutate({
+			rpcId: randomUUID(),
+			payload: {
+				ns: context.entry.settingsNs,
+				ops,
+				...patch.expectedRevision === void 0 ? {} : { expectedRevision: patch.expectedRevision }
+			}
+		}));
+		if (patch.apiKey !== void 0) {
+			if (patch.apiKey === null || patch.apiKey === "") unwrapDsh(await this.api.credentials.unset({
+				rpcId: randomUUID(),
+				payload: { ref }
+			}));
+			else unwrapDsh(await this.api.credentials.set({
+				rpcId: randomUUID(),
+				payload: {
+					ref,
+					value: patch.apiKey
+				}
+			}));
+		}
+	}
+	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.");
+		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({
+			rpcId: randomUUID(),
+			payload: {}
+		}), this.api.settings.describe({
+			rpcId: randomUUID(),
+			payload: {}
+		})]);
+		const directory = unwrapDsh(directoryResponse);
+		const settings = unwrapDsh(settingsResponse);
+		if (!settings.writable) throw new ApiError(409, "SETTINGS_READ_ONLY", "DSH settings are read-only.");
+		const namespace = settings.namespaces.find((item) => item.ns === "llm-pi-ai");
+		if (namespace === void 0) throw new ApiError(409, "CUSTOM_PROVIDERS_UNAVAILABLE", "This DSH installation does not expose custom providers.");
+		if (directory.providers.some((provider) => provider.provider === id)) throw new ApiError(409, "PROVIDER_EXISTS", "A provider with this id already exists.");
+		if (!protocolChoices(namespace).includes(input.api)) throw new ApiError(400, "PROVIDER_PROTOCOL_INVALID", "The selected API protocol is not supported by this DSH installation.");
+		const key = input.apiKey?.trim() ?? "";
+		const ref = keyRef(id);
+		const displayName = input.displayName?.trim() ?? "";
+		const profile = {
+			...displayName === "" ? {} : { displayName },
+			...key === "" ? {} : { apiKeyEnv: ref },
+			api: input.api,
+			baseURL: input.baseURL.trim(),
+			models: input.models
+		};
+		unwrapDsh(await this.api.settings.mutate({
+			rpcId: randomUUID(),
+			payload: {
+				ns: "llm-pi-ai",
+				ops: [{
+					op: "set",
+					path: ["providers", id],
+					value: profile
+				}],
+				...input.expectedRevision === void 0 ? {} : { expectedRevision: input.expectedRevision }
+			}
+		}));
+		if (key !== "") unwrapDsh(await this.api.credentials.set({
+			rpcId: randomUUID(),
+			payload: {
+				ref,
+				value: key
+			}
+		}));
+	}
+	async removeProvider(providerId, expectedRevision) {
+		const context = await this.providerContext(providerId);
+		if (!context.writable) throw new ApiError(409, "SETTINGS_READ_ONLY", "DSH settings are read-only.");
+		if (context.entry.settingsPath.length === 0) throw new ApiError(409, "PROVIDER_REQUIRED", "The built-in provider can be reset but not removed.");
+		unwrapDsh(await this.api.settings.mutate({
+			rpcId: randomUUID(),
+			payload: {
+				ns: context.entry.settingsNs,
+				ops: [{
+					op: "unset",
+					path: context.entry.settingsPath
+				}],
+				...expectedRevision === void 0 ? {} : { expectedRevision }
+			}
+		}));
+	}
+	async discover(providerId, draft) {
+		const payload = {
+			settingsNs: (await this.providerContext(providerId)).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({
+			rpcId: randomUUID(),
+			payload
+		})).models;
+	}
+	async providerContext(providerId) {
+		const [directoryResponse, settingsResponse] = await Promise.all([this.api.llm.providers({
+			rpcId: randomUUID(),
+			payload: {}
+		}), this.api.settings.describe({
+			rpcId: randomUUID(),
+			payload: {}
+		})]);
+		const directory = unwrapDsh(directoryResponse);
+		const settings = unwrapDsh(settingsResponse);
+		const entry = directory.providers.find((item) => item.provider === providerId);
+		if (entry === void 0) throw new ApiError(404, "PROVIDER_NOT_FOUND", "The provider is not available in DSH.");
+		const namespace = settings.namespaces.find((item) => item.ns === entry.settingsNs);
+		return {
+			entry,
+			writable: settings.writable,
+			namespace,
+			profile: recordAt(namespace?.value, entry.settingsPath)
+		};
+	}
+};
+function projectConfig(profile, inheritedModels) {
+	const baseURL = text(profile?.baseURL);
+	const api = text(profile?.api);
+	const displayName = text(profile?.displayName);
+	const thinking = text(profile?.thinking);
+	const reasoningEffort = text(profile?.reasoningEffort);
+	const configuredModels = Array.isArray(profile?.models) ? profile.models.filter(isRecord).map((model) => {
+		const name = text(model.name);
+		const contextWindow = positiveInteger(model.contextWindow);
+		const maxTokens = positiveInteger(model.maxTokens);
+		return {
+			id: text(model.id) ?? "",
+			...name === void 0 ? {} : { name },
+			...contextWindow === void 0 ? {} : { contextWindow },
+			...maxTokens === void 0 ? {} : { maxTokens }
+		};
+	}).filter((model) => model.id !== "") : [];
+	const models = configuredModels.length > 0 ? configuredModels : (inheritedModels ?? []).map((model) => ({
+		id: model.id,
+		...model.name === "" ? {} : { name: model.name },
+		...model.contextWindow === void 0 ? {} : { contextWindow: model.contextWindow },
+		...model.maxTokens === void 0 ? {} : { maxTokens: model.maxTokens }
+	}));
+	return {
+		...baseURL === void 0 ? {} : { baseURL },
+		...api === void 0 ? {} : { api },
+		...displayName === void 0 ? {} : { displayName },
+		...thinking === void 0 ? {} : { thinking },
+		...reasoningEffort === void 0 ? {} : { reasoningEffort },
+		models,
+		...configuredModels.length === 0 && models.length > 0 ? { modelsInherited: true } : {}
+	};
+}
+function mergeRecords(base, value) {
+	if (base === void 0) return value;
+	if (value === void 0) return base;
+	return {
+		...base,
+		...value
+	};
+}
+function protocolChoices(namespace) {
+	if (!isRecord(namespace?.schema) || !isRecord(namespace.schema.refs)) return [];
+	const refs = namespace.schema.refs;
+	const node = (id) => refs[String(id)];
+	const root = node(namespace.schema.uid);
+	if (!isRecord(root?.dict)) return [];
+	const profile = node(node(root.dict.providers)?.inner);
+	if (!isRecord(profile?.dict)) return [];
+	const api = node(profile.dict.api);
+	if (api?.type !== "union" || !Array.isArray(api.list)) return [];
+	return api.list.map((item) => node(item)?.value).filter((value) => typeof value === "string");
+}
+function validateModels(models) {
+	const ids = /* @__PURE__ */ new Set();
+	for (const model of models) {
+		if (!isRecord(model) || typeof model.id !== "string" || model.id.trim() === "" || ids.has(model.id)) throw new ApiError(400, "MODEL_CONFIG_INVALID", "Model ids must be non-empty and unique.");
+		ids.add(model.id);
+		for (const value of [model.contextWindow, model.maxTokens]) if (value !== void 0 && (!Number.isSafeInteger(value) || value <= 0)) throw new ApiError(400, "MODEL_CONFIG_INVALID", "Model capacities must be positive integers.");
+	}
+}
+function recordAt(value, path) {
+	let current = value;
+	for (const segment of path) {
+		if (!isRecord(current)) return void 0;
+		current = current[segment];
+	}
+	return isRecord(current) ? current : void 0;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function text(value) {
+	return typeof value === "string" && value !== "" ? value : void 0;
+}
+function positiveInteger(value) {
+	return Number.isSafeInteger(value) && Number(value) > 0 ? Number(value) : void 0;
+}
+function keyRef(provider) {
+	return provider === "deepseek-official" ? "DEEPSEEK_API_KEY" : `${provider.toUpperCase().replace(/[^A-Z0-9]+/g, "_")}_API_KEY`;
+}
+//#endregion
+//#region src/index.ts
+/**
+* 插件身份。
+*
+* 2.0.4 起由 `dsh-workspace` 改名为 `dsh-remote-bridge`：插件实际承担的是
+* 「把 DSH 内核的私有 remote 协议翻译成版本化 REST，供手机端远程访问这台机器」，
+* 外加一个设置中心（根目录 / 远程访问 / 设备 / 回收站 / 审计）。原先的
+* 「workspace」只是其中一页，名字比内容宽。
+*
+* **以下一处刻意不改**，它是已发布客户端依赖的对外契约，改了等于破坏兼容：
+* - REST 前缀 `/dsh-workspace-api`（`src/host/server.ts`）
+*
+* 已发布的 App 把它写死了，改名只动「装的时候叫什么、bundle 叫什么」。
+*
+* 另外两项**已随 2.2.0 删除独立页一并退役**，不再是契约：独立页路径 `/dsh-workspace`
+* （页面已删）、浏览器存储键 `dsh-workspace-device-token`（只被那个页面读写过，现已无人使用）。
+* 另有一项契约不在此处：状态目录 `dshHomePath('dsh-workspace')`（在 `cordis.patch.yml`），
+* 换目录等于清空用户的授权根与回收站。
+*/
+const name = "dsh-remote-bridge";
+/**
+* Host services this plugin needs, for DSH 0.2.x.
+*
+* DSH ≤ 0.1.1 published the client-shaped `apiProxy` facade from
+* `@deepseek-ai/dsh-host-apiproxy`. DSH 0.1.2-alpha.3 replaced that package with
+* `@deepseek-ai/dsh-api-gateway` (service `typertGateway`), which publishes no
+* `apiProxy` — the controllers instead register directly as host services.
+* Injecting those keeps the plugin loadable on 0.2.x, and
+* `./host/dsh-0.2-bridge.ts` rebuilds the old facade on top of them so the
+* chat/settings adapters keep their original contract.
+*/
+const inject = [
+	"sessionController",
+	"workspaceController",
+	"workspaceRegistry",
+	"settingsController",
+	"credentialsController",
+	"agentPresets",
+	"llm",
+	"webServer",
+	"agents",
+	"commands",
+	"fileUploads",
+	"attachments"
+];
+async function apply(ctx, config = {}) {
+	const dataDir = path.resolve(config.dataDir ?? path.join(process.cwd(), ".dsh-workspace"));
+	const port = normalizeListenerPort(config.port ?? 3090, true);
+	const remoteHost = normalizeListenerHost(config.remoteHost ?? "0.0.0.0");
+	const maxUploadBytes = config.maxUploadBytes ?? 20971520;
+	if (!Number.isSafeInteger(maxUploadBytes) || maxUploadBytes < 1) throw new Error("dsh-remote-bridge: maxUploadBytes must be positive");
+	const database = new WorkspaceDatabase(dataDir);
+	const events = new WorkspaceEventBus();
+	const auth = new AuthService(database);
+	const files = new FileService(database, (event) => events.emit(event));
+	const apiProxy = createDsh02ApiProxy(ctx);
+	const chat = new DshChatAdapter(apiProxy, database, {
+		agents: ctx.agents,
+		commands: ctx.commands
+	});
+	const settings = new DshSettingsAdapter(apiProxy);
+	let router;
+	const remote = new RemoteApiServer({
+		port,
+		remoteHost,
+		database,
+		auth,
+		chat,
+		events,
+		handle: (req, res) => router.handle(req, res)
+	});
+	router = new ApiRouter({
+		database,
+		auth,
+		files,
+		chat,
+		settings,
+		remote,
+		maxUploadBytes
+	});
+	try {
+		await remote.start();
+	} catch (error) {
+		database.close();
+		throw error;
+	}
+	const disposeEmbedded = attachEmbeddedRoutes(ctx.webServer, router, remote);
+	ctx.effect(() => async () => {
+		disposeEmbedded();
+		await remote.stop();
+		database.close();
+	}, "dsh-remote-bridge lifecycle");
+	const status = remote.status();
+	ctx.logger.info(`dsh-remote-bridge v${PLUGIN_VERSION}: ${status.host}:${status.port} (${status.remoteEnabled ? "remote enabled" : "loopback only"})`);
+}
+//#endregion
+export { apply, apply as default, inject, name };