dsh-remote-bridge 2.8.2 → 2.9.1

package/lib/index.d.ts

@@ -785,6 +785,23 @@ interface AttachmentStoreLike {
     data: Uint8Array;
   }>;
 }
+/**
+ * 内核的 `SessionAddress` 判别联合（`dsh-api-session-controller` 的
+ * types.d.ts:406-414）。普通会话用 `kind:'session'`，**子会话必须**用
+ * `kind:'subagent'` 并带上父会话 id —— 内核在 `validateAddress()` 里对
+ * `{kind:'session'}` 且 header.origin==='subagent' 直接抛
+ * `session/agent-busy: "subagent Sessions require their durable parent address"`。
+ * 也就是说：子会话历史一直是可读的，只是必须按内核要的地址形状去问。
+ */
+type SessionAddressLike = {
+  kind: 'session';
+  sessionId: string;
+} | {
+  kind: 'subagent';
+  parentSessionId: string;
+  childSessionId: string;
+  mode: 'one-shot' | 'continuable' | 'unknown';
+};
 interface SessionControllerLike {
   list(request: {
     cursor?: string;
@@ -808,10 +825,7 @@ interface SessionControllerLike {
    * a well-formed but *empty* page — a silent failure, not an error.
    */
   follow(request: {
-    address: {
-      kind: 'session';
-      sessionId: string;
-    };
+    address: SessionAddressLike;
     maxMessages?: number;
     /**
      * Assistant presentation frames are opt-in: without `assistantStream: true`
@@ -860,10 +874,7 @@ interface SessionControllerLike {
    * `beforeSeq` is optional and acts as an earlier boundary.
    */
   page(request: {
-    address: {
-      kind: 'session';
-      sessionId: string;
-    };
+    address: SessionAddressLike;
     throughSeq: number;
     beforeSeq?: number;
     maxMessages?: number;
@@ -1286,12 +1297,20 @@ interface DshApiProxy {
       sessionId: string;
       agentPreset?: string;
     }>>;
+    /**
+     * 读历史。`parentSessionId` + `subagentMode` 是本桥的**扩展字段**（内核契约里
+     * 没有）：带上它们表示「这是 parentSessionId 名下的子会话」，底层据此把地址
+     * 拼成 `kind:'subagent'`（内核只认这个形状，拿 childSessionId 冒充普通
+     * sessionId 会被 validateAddress() 拒掉）。不带就是普通会话，行为一字不变。
+     */
     history(request: {
       rpcId: string;
       payload: {
         sessionId: string;
         beforeSeq?: number;
         maxMessages?: number;
+        parentSessionId?: string;
+        subagentMode?: 'one-shot' | 'continuable' | 'unknown';
       };
     }): Promise<RpcResponse<{
       events: unknown[];
@@ -1928,6 +1947,51 @@ declare class DshChatAdapter {
     truncated?: boolean;
     historyFormatVersion?: number;
   }>;
+  /**
+   * 读**子会话**（subagent / 团队成员）的历史 —— 受成员关系校验的只读窄口。
+   *
+   * ## 为什么需要一条单独的路径
+   *
+   * 内核 0.2.x 把子会话也列在 `sessions.list` 里、并标 `origin: 'subagent'`，
+   * 而桥在 `dsh-0.2-bridge.ts` 的 `sessions.list` 把它们**整批滤掉**（内核拒绝
+   * 把子会话当普通会话激活，暴露出来只会得到「点开就崩」的行）。`requireSession()`
+   * 的可见性判定正是建立在 `listSessions()` 上的，于是任何 `{subagentId}` 打进来
+   * 都是 404 —— 手机端「团队面板里点成员/子会话看内容」因此根本走不通。
+   *
+   * 三条路可选：拆掉 `origin` 过滤（把「点开就崩」的行放回列表，回归风险最大）、
+   * 放宽 `requireSession`（等于给所有会话开一条后门，最危险）、或者**单开一条
+   * 自带授权规则的窄口**。本实现选第三条：授权判定不依赖会话列表，改用**内核自己
+   * 发布的投影**来证明成员关系。
+   *
+   * ## 授权是怎么成立的（两步，缺一不可）
+   *
+   * ① **Lead 必须可见**：`requireSession(leadSessionId)` 走的是完全没变的既有规则
+   *    （设备 scope + 授权根 + 归档状态）。子会话能读，前提是它的 Lead 本来就能读。
+   * ② **成员关系必须由内核背书**：读 Lead 的会话投影，要求 `subagentId` 出现在
+   *    `subagentCatalog[].id`（或 `agentTeam.members[].id`，两者在内核里指向同一批
+   *    Session）里。这份目录是内核为这个 Lead 亲手发布的，不是我们维护的白名单，
+   *    所以「猜一个 sessionId 来读别人会话」在这里不成立 —— 猜不中就是 404。
+   *
+   * 通过这两步之后才直读历史。注意 ③ **刻意不再调 `requireSession`**：那正是会
+   * 必然 404 的那一步，授权已在 ①② 完成，③ 纯粹是取数据。
+   *
+   * ## 为什么只读
+   *
+   * 写子会话（给成员发消息、改它的模型/权限）会让「谁在指挥谁」变得含混：官方 Web 端
+   * 同样不允许人类直接写成员会话，一切经由 Lead 的模型工具。这条窄口只开放 `events`
+   * 读取，`POST` 一律 405。
+   */
+  subagentHistory(principal: Principal, leadSessionId: string, subagentId: string, options: {
+    beforeSeq?: number;
+    maxMessages?: number;
+  }): Promise<{
+    events: unknown[];
+    hasMore: boolean;
+    projections?: unknown;
+    bytes?: number;
+    truncated?: boolean;
+    historyFormatVersion?: number;
+  }>;
   prompt(principal: Principal, sessionId: string, parts: PromptContentPart[], mode: 'queue' | 'steer', clientTimeZone?: string, locale?: HandoffLocale): Promise<{
     accepted: true;
     command?: unknown;

package/lib/index.js

@@ -2998,22 +2998,30 @@ function createDsh02ApiProxy(host, options = {}) {
 			create: (request) => call("sessions.create", (signal) => host.sessionController.create(request.payload)),
 			history: (request) => call("sessions.history", async (signal) => {
 				const { sessionId, maxMessages, beforeSeq } = request.payload;
+				const parentSessionId = request.payload.parentSessionId;
+				const subagentMode = request.payload.subagentMode;
+				const address = typeof parentSessionId === "string" && parentSessionId !== "" ? {
+					kind: "subagent",
+					parentSessionId,
+					childSessionId: sessionId,
+					mode: subagentMode === "one-shot" || subagentMode === "continuable" ? subagentMode : "unknown"
+				} : {
+					kind: "session",
+					sessionId
+				};
 				const controller = new AbortController();
 				if (signal.aborted) controller.abort();
 				else signal.addEventListener("abort", () => controller.abort(), { once: true });
 				try {
 					const snapshot = (await host.sessionController.follow({
-						address: {
-							kind: "session",
-							sessionId
-						},
+						address,
 						...maxMessages === void 0 ? {} : { maxMessages }
 					}, controller.signal)[Symbol.asyncIterator]().next()).value;
 					if (snapshot === void 0 || snapshot.type !== "snapshot") return {
 						events: [],
 						hasMore: false
 					};
-					const projections = projectionsOf(snapshot) ?? await readSessionProjections(host, sessionId, controller.signal);
+					const projections = projectionsOf(snapshot) ?? (address.kind === "session" ? await readSessionProjections(host, sessionId, controller.signal) : void 0);
 					const withProjections = (payload) => projections === void 0 ? payload : {
 						...payload,
 						projections
@@ -3023,10 +3031,7 @@ function createDsh02ApiProxy(host, options = {}) {
 						hasMore: snapshot.hasMore === true
 					});
 					const page = await host.sessionController.page({
-						address: {
-							kind: "session",
-							sessionId
-						},
+						address,
 						throughSeq: snapshot.cursor,
 						beforeSeq,
 						...maxMessages === void 0 ? {} : { maxMessages }
@@ -3294,7 +3299,7 @@ function createDsh02ApiProxy(host, options = {}) {
 }
 //#endregion
 //#region src/shared/version.ts
-const PLUGIN_VERSION = "2.8.2";
+const PLUGIN_VERSION = "2.9.1";
 //#endregion
 //#region src/host/capabilities.ts
 /**
@@ -3358,6 +3363,7 @@ const BRIDGE_CAPABILITIES = [
 	"session-archive-v1",
 	"session-archive-list-v1",
 	"history-v1",
+	"subagent-history-v1",
 	"turn-cancel-v1",
 	"session-config-v1",
 	"commands-v1",
@@ -3911,6 +3917,85 @@ var DshChatAdapter = class {
 			historyFormatVersion: 1
 		};
 	}
+	/**
+	* 读**子会话**（subagent / 团队成员）的历史 —— 受成员关系校验的只读窄口。
+	*
+	* ## 为什么需要一条单独的路径
+	*
+	* 内核 0.2.x 把子会话也列在 `sessions.list` 里、并标 `origin: 'subagent'`，
+	* 而桥在 `dsh-0.2-bridge.ts` 的 `sessions.list` 把它们**整批滤掉**（内核拒绝
+	* 把子会话当普通会话激活，暴露出来只会得到「点开就崩」的行）。`requireSession()`
+	* 的可见性判定正是建立在 `listSessions()` 上的，于是任何 `{subagentId}` 打进来
+	* 都是 404 —— 手机端「团队面板里点成员/子会话看内容」因此根本走不通。
+	*
+	* 三条路可选：拆掉 `origin` 过滤（把「点开就崩」的行放回列表，回归风险最大）、
+	* 放宽 `requireSession`（等于给所有会话开一条后门，最危险）、或者**单开一条
+	* 自带授权规则的窄口**。本实现选第三条：授权判定不依赖会话列表，改用**内核自己
+	* 发布的投影**来证明成员关系。
+	*
+	* ## 授权是怎么成立的（两步，缺一不可）
+	*
+	* ① **Lead 必须可见**：`requireSession(leadSessionId)` 走的是完全没变的既有规则
+	*    （设备 scope + 授权根 + 归档状态）。子会话能读，前提是它的 Lead 本来就能读。
+	* ② **成员关系必须由内核背书**：读 Lead 的会话投影，要求 `subagentId` 出现在
+	*    `subagentCatalog[].id`（或 `agentTeam.members[].id`，两者在内核里指向同一批
+	*    Session）里。这份目录是内核为这个 Lead 亲手发布的，不是我们维护的白名单，
+	*    所以「猜一个 sessionId 来读别人会话」在这里不成立 —— 猜不中就是 404。
+	*
+	* 通过这两步之后才直读历史。注意 ③ **刻意不再调 `requireSession`**：那正是会
+	* 必然 404 的那一步，授权已在 ①② 完成，③ 纯粹是取数据。
+	*
+	* ## 为什么只读
+	*
+	* 写子会话（给成员发消息、改它的模型/权限）会让「谁在指挥谁」变得含混：官方 Web 端
+	* 同样不允许人类直接写成员会话，一切经由 Lead 的模型工具。这条窄口只开放 `events`
+	* 读取，`POST` 一律 405。
+	*/
+	async subagentHistory(principal, leadSessionId, subagentId, options) {
+		await this.requireSession(principal, leadSessionId);
+		const baseline = unwrapDsh(await this.api.sessions.projections({
+			rpcId: randomUUID(),
+			payload: { sessionId: leadSessionId }
+		}));
+		if (baseline === null || baseline === void 0) throw new ApiError(404, "SUBAGENT_NOT_FOUND", "Session projections are unavailable, cannot verify membership.");
+		const values = baseline.values ?? {};
+		const members = /* @__PURE__ */ new Set();
+		const modes = /* @__PURE__ */ new Map();
+		const catalog = values["subagentCatalog"];
+		if (Array.isArray(catalog)) for (const entry of catalog) {
+			if (typeof entry !== "object" || entry === null) continue;
+			const record = entry;
+			const id = typeof record["id"] === "string" ? record["id"] : record["sessionId"];
+			if (typeof id !== "string" || id === "") continue;
+			members.add(id);
+			const mode = record["mode"];
+			if (mode === "one-shot" || mode === "continuable" || mode === "unknown") modes.set(id, mode);
+		}
+		const team = values["agentTeam"];
+		if (typeof team === "object" && team !== null) {
+			const teamMembers = team["members"];
+			if (Array.isArray(teamMembers)) for (const entry of teamMembers) {
+				if (typeof entry !== "object" || entry === null) continue;
+				const id = entry["id"];
+				if (typeof id === "string" && id !== "") members.add(id);
+			}
+		}
+		if (!members.has(subagentId)) throw new ApiError(404, "SUBAGENT_NOT_FOUND", "The session is not a member of this team.");
+		const payload = {
+			sessionId: subagentId,
+			parentSessionId: leadSessionId,
+			subagentMode: modes.get(subagentId) ?? "unknown",
+			...options.beforeSeq === void 0 ? {} : { beforeSeq: options.beforeSeq },
+			...options.maxMessages === void 0 ? {} : { maxMessages: options.maxMessages }
+		};
+		return {
+			...applyHistoryBudget(unwrapDsh(await this.api.sessions.history({
+				rpcId: randomUUID(),
+				payload
+			}))),
+			historyFormatVersion: 1
+		};
+	}
 	async prompt(principal, sessionId, parts, mode, clientTimeZone, locale) {
 		await this.requireSession(principal, sessionId);
 		const hasText = parts.some((part) => part.type === "text" && part.text.trim() !== "");
@@ -9991,6 +10076,22 @@ var ApiRouter = class {
 				return;
 			}
 		}
+		const subagentHistoryRoute = pathname.match(/^\/api\/v1\/chat\/sessions\/([^/]+)\/subagents\/([^/]+)\/messages$/);
+		if (subagentHistoryRoute !== null) {
+			const leadSessionId = decodePathSegment(subagentHistoryRoute[1]);
+			const subagentId = decodePathSegment(subagentHistoryRoute[2]);
+			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.subagentHistory(principal, leadSessionId, subagentId, {
+					...beforeSeq === void 0 ? {} : { beforeSeq },
+					...maxMessages === void 0 ? {} : { maxMessages }
+				}));
+				return;
+			}
+			throw new ApiError(405, "METHOD_NOT_ALLOWED", "Subagent history is read-only.");
+		}
 		const attachmentRoute = pathname.match(/^\/api\/v1\/attachments\/([^/]+)$/);
 		if (attachmentRoute !== null && method === "GET") {
 			this.options.auth.requireScope(principal, "files.read");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-remote-bridge",
-  "version": "2.8.2",
+  "version": "2.9.1",
   "description": "Versioned REST bridge for DeepSeek Harness: remote access for trusted clients (chat, files, devices) plus a Phone-settings panel inside the DSH WebUI.",
   "type": "module",
   "packageManager": "pnpm@11.19.0",

package/screenshots.json

@@ -1,6 +1,8 @@
 [
   "assets/screenshots/panel-roots.png",
   "assets/screenshots/panel-remote.png",
+  "assets/screenshots/panel-tunnel.png",
   "assets/screenshots/panel-devices.png",
+  "assets/screenshots/panel-plugins.png",
   "assets/screenshots/panel-app-download.png"
 ]