@jingyi0605/codingns4dsh 0.2.0-beta.1 → 0.2.0-rc.2

package/data/build/dist/client/features/peer-host.js

@@ -1,89 +1,632 @@
-import { startPeerHostConnectionButton } from '../peer-host-connection-button.js';
+import { createElement } from 'react';
 import { startPeerHostManagementPanel } from '../peer-host-management-panel.js';
-import { startPeerHostNativeNavigation, startPeerHostNativeSession } from '../peer-host-native-session-ui.js';
 import { createPeerHostManagementApi } from '../peer-host-management-api.js';
-import { createPeerHostWebSocketFactory } from '../peer-host-scoped-client.js';
-/** PeerHost Client 模块的边界声明；实际连接资源在后续任务中装配。 */
+import { DSH_PEER_HOST_PREBOOT_SHIM_GLOBAL, readDshPeerHostPrebootShimMode, readDshPeerHostPrebootShimState } from '../../bootstrap/dsh-peer-host-preboot-shim.js';
+import { dshSettingsNoteStyle, dshThemeColor } from '../theme.js';
+import { createVirtualSessionId, createVirtualWorkspaceId, parseVirtualSessionId } from '../../shared/index.js';
+import { decodeNativeResponseBytes, isDshNativeRemoteMethod } from '../../host/modules/peer-host/peer-host-native-protocol.js';
+import { createPeerHostNativeProjection } from '../peer-host-native-projection.js';
+import { installPeerHostNativeStoreProjection, refreshPeerHostNativeSessions } from '../peer-host-native-store-projection.js';
+import { startPeerHostWorkspaceTag } from '../peer-host-workspace-tag.js';
+import { startPeerHostWorkspaceTab } from '../peer-host-workspace-tab.js';
+import { registerPeerHostAggregateRefresh, requestPeerHostAggregateRefresh } from '../peer-host-aggregate-refresh.js';
+import { useCodingNsTranslator } from '../locale.js';
+import { publishSessionAdapter } from '../session-adapter-cache.js';
+/** 聚合刷新周期；远端资源只影响自身节点，刷新失败不改变本机界面。 */
+const PEER_HOST_AGGREGATE_REFRESH_MS = 30_000;
+/** 新建会话尚未出现在聚合摘要时，临时保留其远端作用域的最长时间。 */
+const PEER_HOST_PENDING_SESSION_SCOPE_TTL_MS = 30_000;
+/** PeerHost Client 模块的边界声明；远端凭据和目标连接始终由 Host 侧持有。 */
 export const peerHostFeature = {
     descriptor: {
         name: 'peerHost',
         version: '0.1.0',
         enabledByDefault: false,
-        // PeerHost 暂停启用，待 Host-to-Host/relay 在真实 DSH 环境完成验收后再开放。
-        disabled: true,
         dependencies: [],
         runtime: 'client',
         requires: [
+            // 页面 Transport 不可包装（shim 未注入或形状未知）时只停用 PeerHost，
+            // 不再提示"请刷新"——这属于结构不支持，刷新不会改变结果。
+            { capability: 'peer-host.client-preboot-transport', required: false, fallback: 'disable' },
             { capability: 'peer-host.native-navigation', required: false, fallback: 'degrade' },
             { capability: 'peer-host.remote-web-context-fallback', required: false, fallback: 'degrade' },
         ],
         ui: {
-            label: '管理其他 DSH Host',
-            description: 'PeerHost 暂时停用，待 Host-to-Host 能力完成验收后再启用。',
+            label: 'Manage other DSH Hosts',
+            labelKey: 'feature.peerHost.label',
+            description: 'Aggregate sessions from multiple Hosts',
+            descriptionKey: 'feature.peerHost.description',
             order: 50,
             defaultOpen: false,
         },
     },
     start: async (context) => {
-        const controller = startPeerHostConnectionButton();
-        context.resources.add(() => controller.dispose());
-        const panel = startPeerHostManagementPanel({ rpc: context.services.rpc });
+        const shim = globalThis[DSH_PEER_HOST_PREBOOT_SHIM_GLOBAL];
+        const projection = createPeerHostNativeProjection();
+        const transport = shim === undefined ? undefined : createPeerHostPageTransport(projection);
+        if (shim !== undefined) {
+            shim.activate(transport.hooks);
+            context.resources.add(() => { shim.deactivate(); });
+            // 原生侧栏在插件 apply 时按引用捕获 `workspaces.list`，只能就地投影这个对象；
+            // 没有 shim 就没有原生 Remote 路由，此时不注入，避免出现点不开的远端条目。
+            context.resources.add(installPeerHostNativeStoreProjection({ uiContext: context.services.uiContext, projection }));
+            // Desktop 的 Transport 只有 `{ ownsHost, streamBaseUrl }`，shim 不提供 `rpc`，
+            // 因此 DSH 用原生 `createWebConnectionRpc` 建立了 Connection。这里在 Connection
+            // 就绪后就地补聚合分流：`rpc.call` 上放行聚合请求，本机流在 Remote 服务的
+            // `openRemoteStream` 处原样落回 DSH 自己的实现（含 uplink 与原生 mux）。
+            if (shim.getMode?.() === 'desktop') {
+                const route = installPeerHostConnectionRouting({
+                    ...(context.services.uiContext === undefined ? {} : { uiContext: context.services.uiContext }),
+                    ...(context.services.remote === undefined ? {} : { remote: context.services.remote }),
+                    hooks: transport.hooks,
+                    matchesScope: transport.matchesScope,
+                    decorateLocalResult: (method, result) => method === 'session/list' ? mergeSessionListResult(result, projection) : result,
+                });
+                if (route !== undefined)
+                    context.resources.add(route);
+            }
+        }
+        const panel = startPeerHostManagementPanel({ rpc: context.services.rpc, locale: context.services.locale });
         context.resources.add(() => panel.dispose());
         const management = createPeerHostManagementApi(context.services.rpc);
-        let endpoint = null;
-        let results = null;
-        let aggregateError;
-        try {
-            ;
-            [endpoint, results] = await Promise.all([management.webSocketEndpoint(), management.aggregate()]);
-        }
-        catch (error) {
-            aggregateError = error;
+        // 工作区标签：远端工作区不再把 Host 名写进标题文本，改由彩色标签表达归属。
+        const tag = startPeerHostWorkspaceTag();
+        context.resources.add(() => tag.dispose());
+        // 原生"添加工作区"对话框保持主体不变，只额外挂一个"远程 HOST"标签页。
+        const workspaceTab = startPeerHostWorkspaceTab({
+            api: management,
+            onWorkspaceAdded: () => refresh(),
+            locale: context.services.locale,
+        });
+        context.resources.add(() => workspaceTab.dispose());
+        // 虚拟会话必须进入原生 SessionManager 目录（否则 sessions.retain 解析失败），
+        // 因此聚合变化后触发一次原生列表刷新，由页面 Transport 在 session/list 响应里补齐。
+        const refresh = async () => {
             try {
-                endpoint = await management.webSocketEndpoint();
+                const aggregate = await management.aggregate();
+                tag.setAggregate(aggregate);
+                if (transport?.setAggregate(aggregate) === true) {
+                    await refreshPeerHostNativeSessions(context.services.uiContext);
+                }
             }
             catch {
-                endpoint = null;
+                // 单个 Host 的摘要失败由聚合层降级，不阻断本机原生工作区与会话。
+            }
+        };
+        // 归档入口等原生操作完成后可以立刻请求刷新，而不必等待下一个周期。
+        context.resources.add(registerPeerHostAggregateRefresh(refresh));
+        await refresh();
+        const timer = setInterval(() => { void refresh(); }, PEER_HOST_AGGREGATE_REFRESH_MS);
+        const onVisibilityChange = () => {
+            if (typeof document !== 'undefined' && document.visibilityState === 'visible')
+                void refresh();
+        };
+        if (typeof document !== 'undefined')
+            document.addEventListener('visibilitychange', onVisibilityChange);
+        context.resources.add(() => {
+            clearInterval(timer);
+            if (typeof document !== 'undefined')
+                document.removeEventListener('visibilitychange', onVisibilityChange);
+        });
+    },
+    settingsPanel: PeerHostPanel,
+};
+/** 将 DSH preboot shim 绑定到当前页面的 Host RPC；不调用 Connection.rpc，避免递归。 */
+export function createPeerHostPageTransport(projection = createPeerHostNativeProjection()) {
+    const fetchImpl = typeof globalThis.fetch === 'function' ? globalThis.fetch.bind(globalThis) : undefined;
+    const scopes = new Map();
+    const remoteHostScopes = new Map();
+    const request = async (channel, endpoint, payload, signal) => {
+        if (fetchImpl === undefined)
+            throw new Error('当前页面没有 fetch');
+        const body = JSON.stringify({ type: 'client-request', rpcId: createRequestId(), method: endpoint, payload });
+        const paths = [`${channel.replace(/\/$/u, '')}/${endpoint.replace(/^\//u, '')}`, `/api${channel.replace(/\/$/u, '')}/${endpoint.replace(/^\//u, '')}`];
+        let response;
+        for (const path of paths) {
+            response = await fetchImpl(path, { method: 'POST', headers: { 'content-type': 'application/json' }, body, ...(signal === undefined ? {} : { signal }) });
+            if (response.status !== 404 && response.status !== 405)
+                break;
+        }
+        if (response === undefined || !response.ok)
+            throw new Error(`transport failure: HTTP ${response?.status ?? 500}`);
+        const envelope = await response.json();
+        return envelope.result;
+    };
+    const codingNsCall = async (endpoint, payload, signal) => {
+        const result = asRecord(await request('/codingns', endpoint, payload, signal));
+        if (result?.ok === true)
+            return result.value;
+        const error = asRecord(result?.error);
+        const failure = new Error(typeof error?.message === 'string' ? error.message : `CodingNS RPC 失败: ${endpoint}`);
+        // 保留稳定错误码，让 DSH 的 Remote 失败装上原始 code 而不是退化成 carrierFailure。
+        if (typeof error?.code === 'string')
+            failure.code = error.code;
+        throw failure;
+    };
+    const findScope = (value) => {
+        if (typeof value === 'string') {
+            const session = scopes.get(value);
+            if (session !== undefined)
+                return session;
+            const workspace = scopes.get(value);
+            if (workspace !== undefined)
+                return workspace;
+            return undefined;
+        }
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                const found = findScope(item);
+                if (found !== undefined)
+                    return found;
             }
+            return undefined;
         }
-        let socketFactory;
-        if (endpoint !== null) {
+        const object = asRecord(value);
+        if (object === null)
+            return undefined;
+        for (const item of Object.values(object)) {
+            const found = findScope(item);
+            if (found !== undefined)
+                return found;
+        }
+        return undefined;
+    };
+    const cliEndpoint = (channel, endpoint) => {
+        if (channel === '/codingns' && endpoint.startsWith('cli/'))
+            return endpoint;
+        if (channel === '/api' && endpoint.startsWith('codingns/cli/'))
+            return endpoint.slice('codingns/'.length);
+        return undefined;
+    };
+    const rewriteCliPayload = (value, scope, key = '') => {
+        if (typeof value === 'string') {
+            const parsed = parseVirtualSessionId(value);
+            const isSessionField = key === 'sessionId' || key === 'parentSessionId' || key === 'childSessionId';
+            return isSessionField && parsed !== null && parsed.hostId === (scope.targetHostId ?? scope.hostId) ? parsed.sessionId : value;
+        }
+        if (Array.isArray(value))
+            return value.map((item) => rewriteCliPayload(item, scope, key));
+        const record = asRecord(value);
+        if (record === null)
+            return value;
+        return Object.fromEntries(Object.entries(record).map(([childKey, child]) => [childKey, rewriteCliPayload(child, scope, childKey)]));
+    };
+    const remoteCliRpc = async (scope, endpoint, payload, signal) => {
+        if (scope.targetHostId === null)
+            throw new Error('PeerHost CLI 请求缺少目标 Host');
+        const response = asRecord(await codingNsCall('peerHost/request', {
+            peerHostId: scope.targetHostId,
+            scope,
+            path: `/api/codingns/${endpoint}`,
+            method: 'POST',
+            body: JSON.stringify({ rpcId: createRequestId(), method: endpoint, payload: rewriteCliPayload(payload, scope) }),
+        }, signal));
+        const status = typeof response?.status === 'number' ? response.status : 500;
+        const body = typeof response?.body === 'string' ? response.body : '';
+        if (status < 200 || status >= 300)
+            throw new Error(`远端 Host CLI RPC 失败: HTTP ${status}`);
+        try {
+            const envelope = asRecord(JSON.parse(body));
+            return envelope?.result;
+        }
+        catch {
+            throw new Error('远端 Host CLI RPC 响应不是 JSON');
+        }
+    };
+    const mergeRemoteAdapterMap = async (localResult, signal) => {
+        const localEnvelope = asRecord(localResult);
+        if (localEnvelope?.ok !== true || !Array.isArray(localEnvelope.value))
+            return localResult;
+        const rows = [...localEnvelope.value];
+        for (const [targetHostId, scope] of remoteHostScopes) {
             try {
-                socketFactory = createPeerHostWebSocketFactory(endpoint);
+                const remoteEnvelope = asRecord(await remoteCliRpc(scope, 'cli/session/adapter-map', {}, signal));
+                if (remoteEnvelope?.ok !== true || !Array.isArray(remoteEnvelope.value))
+                    continue;
+                for (const raw of remoteEnvelope.value) {
+                    const row = asRecord(raw);
+                    const sessionId = typeof row?.sessionId === 'string' ? row.sessionId : '';
+                    const adapterId = typeof row?.adapterId === 'string' ? row.adapterId : '';
+                    if (sessionId !== '' && adapterId !== '')
+                        rows.push({ sessionId: createVirtualSessionId(targetHostId, sessionId), adapterId });
+                }
             }
             catch {
-                endpoint = null;
-                aggregateError = new Error('PeerHost 实时通道端点不可用');
+                // 旧版目标 Host 没有 CLI 映射时保留本机结果，远端会话仍可打开。
             }
         }
-        const session = startPeerHostNativeSession({
-            controller: context.services.peerHostSession,
-            client: context.services.peerHost,
-            ...(socketFactory === undefined ? {} : { socketFactory }),
-        });
-        context.resources.add(() => session.close());
-        const navigation = startPeerHostNativeNavigation({
-            controller: context.services.peerHostSession,
-            onSelect: async (scope) => {
-                const selected = await context.services.peerHostSession.select({
-                    hostId: scope.hostId,
-                    targetHostId: scope.targetHostId,
-                    workspaceId: scope.workspaceId,
-                    sessionId: scope.sessionId,
-                });
-                await session.open(selected);
-            },
-        });
-        context.resources.add(() => navigation.dispose());
-        if (results !== null)
-            navigation.refresh(results);
-        else
-            navigation.setStatus({
-                status: 'degraded',
-                reason: aggregateError instanceof Error && aggregateError.message === 'PeerHost 实时通道端点不可用'
-                    ? aggregateError.message
-                    : 'PeerHost 聚合摘要暂不可用',
+        return { ...localEnvelope, value: rows };
+    };
+    const openRemoteStream = (method, payload, scope, signal) => (async function* () {
+        const opened = asRecord(await codingNsCall('peerHost/nativeStream', { method, payload, scope }, signal));
+        const streamId = typeof opened?.streamId === 'string' ? opened.streamId : '';
+        if (streamId === '')
+            throw new Error('PeerHost 原生 Remote 未返回 streamId');
+        try {
+            while (!(signal?.aborted ?? false)) {
+                const next = asRecord(await codingNsCall('peerHost/nativeStreamNext', { streamId, scope }, signal));
+                if (next?.done === true)
+                    return;
+                yield decodeNativeResponseBytes(next?.value);
+            }
+            signal?.throwIfAborted();
+        }
+        finally {
+            await codingNsCall('peerHost/nativeStreamClose', { streamId, scope }).catch(() => undefined);
+        }
+    })();
+    const pendingSessionScopes = new Map();
+    const forgetPendingSession = (sessionId) => {
+        const pending = pendingSessionScopes.get(sessionId);
+        if (pending === undefined)
+            return undefined;
+        clearTimeout(pending.timer);
+        pendingSessionScopes.delete(sessionId);
+        return pending;
+    };
+    const rememberCreatedSession = (scope, value) => {
+        const sessionId = asRecord(value)?.sessionId;
+        if (typeof sessionId !== 'string')
+            return;
+        const parsed = parseVirtualSessionId(sessionId);
+        if (parsed === null)
+            return;
+        // 只接受目标 Host 自己编码回来的虚拟 ID，避免把别的 Host 的会话挂到当前作用域。
+        if (parsed.hostId !== (scope.targetHostId ?? scope.hostId))
+            return;
+        const created = { ...scope, sessionId: parsed.sessionId };
+        const expiresAt = Date.now() + PEER_HOST_PENDING_SESSION_SCOPE_TTL_MS;
+        const previous = forgetPendingSession(sessionId);
+        if (previous !== undefined && scopes.get(sessionId) === previous.scope)
+            scopes.delete(sessionId);
+        const timer = setTimeout(() => {
+            const pending = pendingSessionScopes.get(sessionId);
+            if (pending === undefined || pending.expiresAt !== expiresAt)
+                return;
+            pendingSessionScopes.delete(sessionId);
+            // 聚合确认后 scopes 会持有新的对象；只清理仍由 pending 持有的旧作用域。
+            if (scopes.get(sessionId) === pending.scope)
+                scopes.delete(sessionId);
+        }, PEER_HOST_PENDING_SESSION_SCOPE_TTL_MS);
+        timer.unref?.();
+        pendingSessionScopes.set(sessionId, { scope: created, expiresAt, timer });
+        scopes.set(sessionId, created);
+    };
+    const hooks = {
+        rpc: async ({ method, payload, signal }) => {
+            const value = asRecord(payload);
+            const channel = typeof value?.channel === 'string' ? value.channel : '/codingns';
+            const body = value?.payload;
+            const cli = cliEndpoint(channel, method);
+            if (cli === 'cli/session/adapter-map') {
+                return await mergeRemoteAdapterMap(await request(channel, method, body, signal), signal);
+            }
+            if (cli !== undefined) {
+                const scope = findScope(body);
+                if (scope !== undefined && scope.targetHostId !== null) {
+                    try {
+                        return await remoteCliRpc(scope, cli, body, signal);
+                    }
+                    catch (error) {
+                        return { ok: false, error: { code: 'gateway/internal', message: error instanceof Error ? error.message : String(error) } };
+                    }
+                }
+            }
+            if (channel === '/api' && isDshNativeRemoteMethod(method)) {
+                const scope = findScope(body);
+                if (scope !== undefined && scope.targetHostId !== null) {
+                    // DSH 的 client 契约要求 unary 结果是 `{ok, value}` / `{ok:false, error}` 信封：
+                    // 返回裸值会让网关在 `rebuiltFailure(result.error)` 读 undefined.code 而崩成 carrierFailure。
+                    try {
+                        const created = decodeNativeResponseBytes(await codingNsCall('peerHost/native', { method, payload: body, scope }, signal));
+                        if (method === 'session/create' || method === 'session/fork') {
+                            rememberCreatedSession(scope, created);
+                            // 侧栏按聚合摘要里的 workspace.sessionIds 归组，新会话只有在刷新后的摘要里
+                            // 才会挂到远端工作区。不立刻刷新，它会先落在"未分组/本机默认工作区"，
+                            // 看起来像新建到了本机。刷新失败不影响创建结果。
+                            void Promise.resolve(requestPeerHostAggregateRefresh()).catch(() => undefined);
+                        }
+                        return { ok: true, value: created };
+                    }
+                    catch (error) {
+                        const code = error.code;
+                        return {
+                            ok: false,
+                            error: { code: typeof code === 'string' ? code : 'gateway/internal', message: error instanceof Error ? error.message : String(error) },
+                        };
+                    }
+                }
+            }
+            const result = await request(channel, method, body, signal);
+            // 原生会话目录必须认识远端会话，否则点击时会因 sessions.retain 解析失败而打不开。
+            if (channel === '/api' && method === 'session/list')
+                return mergeSessionListResult(result, projection);
+            return result;
+        },
+        openStream: ({ method, payload, signal }) => {
+            const value = asRecord(payload);
+            const channel = typeof value?.channel === 'string' ? value.channel : '/api';
+            const body = value?.payload;
+            if (channel === '/api' && isDshNativeRemoteMethod(method)) {
+                const scope = findScope(body);
+                if (scope !== undefined && scope.targetHostId !== null) {
+                    return openRemoteStream(method, body, scope, signal);
+                }
+            }
+            // 本机流（含 $events 等非白名单流）必须回到 DSH Gateway：本地 baseline 不能
+            // 走 PeerHost，否则原生 workspace/session Store 会整体停在 loading。
+            if (channel !== '/api')
+                throw new Error('CODINGNS_BASELINE_STREAM');
+            return openDshGatewayStream(method, body, signal);
+        },
+        fetch: (input, init) => {
+            if (fetchImpl === undefined)
+                return Promise.reject(new Error('当前页面没有 fetch'));
+            return fetchImpl(input, init);
+        },
+    };
+    return {
+        hooks,
+        /** 该请求是否落在某个远端 Host 的作用域内；Desktop 连接路由用它决定是否分流。 */
+        matchesScope(value) {
+            const scope = findScope(value);
+            return scope !== undefined && scope.targetHostId !== null;
+        },
+        setAggregate(aggregate) {
+            scopes.clear();
+            remoteHostScopes.clear();
+            for (const host of aggregate) {
+                if (host.targetHostId !== null) {
+                    remoteHostScopes.set(host.targetHostId, { hostId: host.hostId, targetHostId: host.targetHostId, workspaceId: '__aggregate__', sessionId: null, scopeGeneration: 0 });
+                }
+                for (const workspace of host.workspaces) {
+                    const virtualHostId = host.targetHostId ?? host.hostId;
+                    const virtualWorkspaceId = createVirtualWorkspaceId(virtualHostId, workspace.workspaceId);
+                    const workspaceScope = { hostId: host.hostId, targetHostId: host.targetHostId, workspaceId: workspace.workspaceId, sessionId: null, scopeGeneration: 0 };
+                    scopes.set(virtualWorkspaceId, workspaceScope);
+                    // 归档会话也要能解析作用域：取消归档请求按虚拟会话 ID 路由到目标 Host。
+                    for (const session of [...workspace.sessions, ...(workspace.archivedSessions ?? [])]) {
+                        if (session.scope.sessionId === null)
+                            continue;
+                        scopes.set(createVirtualSessionId(virtualHostId, session.scope.sessionId), { ...workspaceScope, sessionId: session.scope.sessionId });
+                    }
+                }
+            }
+            // 刚创建、尚未进入聚合的会话要保住作用域；聚合里已存在的以聚合为准。
+            // 一旦聚合确认，pending 记录立即清掉；之后远端删除会随下一次聚合重建自然移除。
+            const now = Date.now();
+            for (const [sessionId, pending] of [...pendingSessionScopes]) {
+                if (scopes.has(sessionId)) {
+                    forgetPendingSession(sessionId);
+                    continue;
+                }
+                if (pending.expiresAt <= now) {
+                    forgetPendingSession(sessionId);
+                    continue;
+                }
+                scopes.set(sessionId, pending.scope);
+            }
+            return projection.setAggregate(aggregate);
+        },
+    };
+}
+/**
+ * Desktop 拓扑下把 PeerHost 聚合路由挂到 DSH 原生 Connection 上。
+ *
+ * Desktop 的页面 Transport 只有 `{ ownsHost, streamBaseUrl }`，DSH 因此用原生
+ * `createWebConnectionRpc(transport.fetch)` 建立 `connection.rpc`。shim 不接管这个
+ * `rpc`，所以聚合分流必须在这里就地补齐：
+ *
+ * - `rpc.call`：聚合范围内的请求交给页面 Transport；其余原样委派原生 `call`，
+ *   因此 multipart 附件解析、rpcId 校验等原生语义完全保留。本机 `session/list`
+ *   需要并入虚拟会话，否则远端会话进不了原生会话目录。
+ * - `remote.openRemoteStream`：聚合流交给页面 Transport；本机流原样落回 DSH 自己的
+ *   实现，`connection.rpc.open` 始终保持 undefined，网关的 mux 启动与重连判断
+ *   因此完全没被改动。
+ */
+export function installPeerHostConnectionRouting(options) {
+    const connection = readConnectionHandle(options.uiContext);
+    const rpc = connection?.rpc;
+    const remote = readRemoteService(options.remote);
+    if (rpc === undefined || remote === undefined)
+        return undefined;
+    const originalCall = typeof rpc.call === 'function' ? rpc.call : undefined;
+    if (originalCall === undefined)
+        return undefined;
+    const originalCallRemote = remote.openRemoteStream;
+    const isPeerScoped = (channel, endpoint, payload) => channel === '/api'
+        && isDshNativeRemoteMethod(endpoint)
+        && options.matchesScope(payload);
+    const isPeerCli = (channel, endpoint, payload) => {
+        const cliEndpoint = channel === '/codingns' && endpoint.startsWith('cli/')
+            ? endpoint
+            : channel === '/api' && endpoint.startsWith('codingns/cli/')
+                ? endpoint.slice('codingns/'.length)
+                : undefined;
+        return cliEndpoint !== undefined && (cliEndpoint === 'cli/session/adapter-map' || options.matchesScope(payload));
+    };
+    rpc.call = async (channel, endpoint, payload, signal) => {
+        if (isPeerScoped(channel, endpoint, payload) || isPeerCli(channel, endpoint, payload)) {
+            return await options.hooks.rpc({ method: endpoint, payload: { channel, payload }, ...(signal === undefined ? {} : { signal }) });
+        }
+        const result = await originalCall.call(rpc, channel, endpoint, payload, signal);
+        return options.decorateLocalResult === undefined ? result : options.decorateLocalResult(endpoint, result);
+    };
+    // 聚合流在 `openRemoteStream` 层拦截：本机流原样落回 DSH 自己的实现（原生
+    // RemoteStreamMuxClient），因此 uplink 与重连行为都不受影响；也不要动
+    // `connection.rpc.open`，否则网关会认为本页自带流通道而不再启动/重连 mux。
+    const patchedOpenRemoteStream = (endpoint, payload, signal, uplink, noConnection) => {
+        if (typeof options.hooks.openStream === 'function' && isPeerScoped('/api', endpoint, payload)) {
+            return options.hooks.openStream({ method: endpoint, payload: { channel: '/api', payload, uplink }, ...(signal === undefined ? {} : { signal }) });
+        }
+        return originalCallRemote.call(remote, endpoint, payload, signal, uplink, noConnection);
+    };
+    try {
+        remote.openRemoteStream = patchedOpenRemoteStream;
+    }
+    catch {
+        // 服务对象被冻结时不要留下半接管状态：unary 分流同样回滚。
+        rpc.call = originalCall;
+        return undefined;
+    }
+    return () => {
+        rpc.call = originalCall;
+        if (remote.openRemoteStream === patchedOpenRemoteStream)
+            remote.openRemoteStream = originalCallRemote;
+    };
+}
+function readRemoteService(remote) {
+    if (typeof remote !== 'object' || remote === null)
+        return undefined;
+    const openRemoteStream = remote.openRemoteStream;
+    return typeof openRemoteStream === 'function' ? remote : undefined;
+}
+/** 聚合范围判定复用页面 Transport 的作用域解析，避免两处白名单漂移。 */
+function readConnectionHandle(uiContext) {
+    if (uiContext === undefined)
+        return undefined;
+    try {
+        const connection = uiContext.get('connection');
+        return typeof connection === 'object' && connection !== null ? connection : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** 把虚拟会话摘要并入 session/list 结果；形状不符时保持本机结果不变。 */
+function mergeSessionListResult(result, projection) {
+    const envelope = asRecord(result);
+    if (envelope?.ok !== true)
+        return result;
+    const value = asRecord(envelope.value);
+    if (value === null || !Array.isArray(value.items))
+        return result;
+    const virtual = projection.sessions();
+    if (virtual.length === 0)
+        return result;
+    const known = new Set(value.items.flatMap((item) => {
+        const id = asRecord(item)?.sessionId;
+        return typeof id === 'string' ? [id] : [];
+    }));
+    for (const session of virtual) {
+        if (session.adapterId !== undefined)
+            publishSessionAdapter(session.sessionId, session.adapterId);
+    }
+    const items = [...value.items, ...virtual.filter((session) => !known.has(session.sessionId))];
+    return { ...envelope, value: { ...value, items } };
+}
+function createRequestId() {
+    return typeof globalThis.crypto?.randomUUID === 'function' ? globalThis.crypto.randomUUID() : `${Date.now()}-${Math.random()}`;
+}
+function asRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value) ? value : null;
+}
+/** 打开当前页面 DSH Gateway 的单个 Remote 流；协议与 dsh-api-gateway 保持一致。 */
+function openDshGatewayStream(endpoint, payload, signal) {
+    const streamId = `codingns_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+    return (async function* () {
+        const WebSocketCtor = globalThis.WebSocket;
+        if (typeof WebSocketCtor !== 'function')
+            throw new Error('当前页面没有可用 WebSocket');
+        const transport = globalThis.__DSH_TRANSPORT__;
+        const base = transport?.streamBaseUrl ?? (typeof globalThis.location === 'object' ? globalThis.location.href : 'http://localhost/');
+        const socketUrl = new URL('/api/remote.mux', base);
+        if (socketUrl.protocol === 'http:')
+            socketUrl.protocol = 'ws:';
+        else if (socketUrl.protocol === 'https:')
+            socketUrl.protocol = 'wss:';
+        const socket = new WebSocketCtor(socketUrl.href);
+        const frames = [];
+        let wake;
+        let ended = false;
+        let failure;
+        const notify = () => { const resolve = wake; wake = undefined; resolve?.(); };
+        const onMessage = (event) => {
+            try {
+                const frame = JSON.parse(String(event.data));
+                if (frame.streamId !== streamId)
+                    return;
+                if (frame.type === 'end')
+                    ended = true;
+                else if (frame.type === 'error')
+                    failure = new Error(typeof frame.error?.message === 'string' ? frame.error.message : 'DSH Remote stream 失败');
+                else if (frame.type === 'item')
+                    frames.push(frame.value);
+                notify();
+            }
+            catch (error) {
+                failure = error instanceof Error ? error : new Error(String(error));
+                notify();
+            }
+        };
+        const onError = () => { failure = new Error('DSH Remote stream WebSocket 失败'); notify(); };
+        const onAbort = () => { failure = signal?.reason instanceof Error ? signal.reason : new Error('DSH Remote stream 已取消'); notify(); };
+        socket.addEventListener('message', onMessage);
+        socket.addEventListener('error', onError);
+        signal?.addEventListener('abort', onAbort, { once: true });
+        try {
+            await new Promise((resolve, reject) => {
+                const opened = () => resolve();
+                const failed = () => reject(new Error('DSH Remote stream WebSocket 打开失败'));
+                socket.addEventListener('open', opened, { once: true });
+                socket.addEventListener('error', failed, { once: true });
             });
-    },
-};
+            signal?.throwIfAborted();
+            socket.send(JSON.stringify({ type: 'open', streamId, endpoint, payload }));
+            while (!ended || frames.length > 0) {
+                if (failure !== undefined)
+                    throw failure;
+                if (frames.length === 0) {
+                    if (ended)
+                        break;
+                    await new Promise((resolve) => { wake = resolve; });
+                }
+                while (frames.length > 0)
+                    yield frames.shift();
+            }
+            if (failure !== undefined)
+                throw failure;
+        }
+        finally {
+            signal?.removeEventListener('abort', onAbort);
+            socket.close(1000, 'stream closed');
+        }
+    })();
+}
+/** Desktop 壳的页面判据；与 shim 的拓扑识别保持同一组特征。 */
+function isDesktopTopologyPage() {
+    if (globalThis.dshDesktopBoot !== undefined)
+        return true;
+    try {
+        return globalThis.location?.protocol?.toLowerCase() === 'dsh-app:';
+    }
+    catch {
+        return false;
+    }
+}
+/** PeerHost 启用状态说明；安装动作发生在启动页 preboot 阶段。 */
+function PeerHostPanel({ services, enabled }) {
+    const t = useCodingNsTranslator(services.locale);
+    // shim 状态在启用变化后可能改变（刚激活为 active），每次渲染都重读全局。
+    const state = readDshPeerHostPrebootShimState();
+    const mode = readDshPeerHostPrebootShimMode();
+    const desktop = mode === 'desktop' || isDesktopTopologyPage();
+    const structural = state === 'external' || state === 'not-installed';
+    const message = state === 'external'
+        ? t('peerHost.stateExternal')
+        : state === 'not-installed'
+            ? desktop
+                ? t('peerHost.stateNotInstalledDesktop')
+                : t('peerHost.stateNotInstalledWeb')
+            : state === 'requires-reload'
+                ? t('peerHost.stateRequiresReload')
+                : state === 'active'
+                    ? t('peerHost.stateActive')
+                    : t('peerHost.statePending');
+    return createElement('div', {
+        role: structural ? 'alert' : 'status',
+        'aria-disabled': !enabled,
+        style: { ...dshSettingsNoteStyle, color: structural ? dshThemeColor.error : dshThemeColor.labelSecondary, opacity: enabled ? 1 : 0.65 },
+    }, message);
+}
 //# sourceMappingURL=peer-host.js.map