@jingyi0605/codingns4dsh 0.2.1-beta.6 → 0.2.1-beta.7

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

@@ -4,13 +4,15 @@ import { randomBytes, randomUUID } from 'node:crypto';
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { CODINGNS_VERSION, DSH_VERSION, isDshVersionCompatible } from '../../shared/contracts/version.js';
 import { PeerHostHandshakeService } from '../modules/peer-host/peer-host-handshake.js';
-import { PeerHostSessionService } from '../modules/peer-host/peer-host-session.js';
+import { isPeerHostTransientStatus, PeerHostSessionService } from '../modules/peer-host/peer-host-session.js';
 import { PeerHostHttpProxyService } from '../modules/peer-host/host-api-proxy-service.js';
 import { EncryptedFilePeerHostCredentialStore, FilePeerHostRecordStore, PeerHostStore, } from '../modules/peer-host/peer-host-store.js';
 import { assistantWorkspaceMatches } from '../../shared/assistant-lifecycle.js';
 import { createVirtualSessionId, createVirtualWorkspaceId, normalizePeerHostColor, parseVirtualSessionId, parseVirtualWorkspaceId } from '../../shared/contracts/peer-host.js';
 import { PeerHostAggregateService } from '../modules/peer-host/peer-host-aggregate-service.js';
+import { PeerHostWorkspaceCache } from '../modules/peer-host/peer-host-workspace-cache.js';
 import { resolveDshNativeDispatch } from '../modules/peer-host/peer-host-native-dispatch.js';
+import { PeerHostNativeStreams } from '../modules/peer-host/peer-host-native-streams.js';
 import { FileAggregateWorkspaceOrderStore, VirtualWorkspaceRegistry } from '../modules/peer-host/peer-host-virtual-registry.js';
 import { CodingNsRpcError } from '../rpc-table.js';
 import { PeerHostWebSocketGateway, PEER_HOST_WS_PATH } from '../modules/peer-host/peer-host-ws-gateway.js';
@@ -27,8 +29,8 @@ import { callPeerCliRpc, callPeerNativeRpc, openPeerNativeStream, readNativeRpcE
 import { createAggregateHostSource } from '../modules/peer-host/peer-host-aggregate-service.js';
 import { encodeNativeResponseBytes, isDshNativeRemoteMethod, rewriteNativeRequestIds, rewriteNativeResponseIds } from '../modules/peer-host/peer-host-native-protocol.js';
 import { resolveCodingNsDebugLevel } from '../../shared/debug.js';
-/** 原生 Remote 流句柄的存活窗口；每次轮询续期，超时仍未再被轮询即回收。 */
-const NATIVE_STREAM_TTL_MS = 600_000;
+import { AssistantPeerNotifications, assistantPeerNotificationWorkspaceIds, assistantPeerNotificationCapabilityKey } from './assistant-peer-notifications.js';
+import { readAssistantNotificationFeed } from '../../shared/assistant-notification-feed.js';
 /** PeerHost Host 模块；配置、握手和目标登录态只在 Host 进程内装配。 */
 export function createPeerHostFeature(options = {}) {
     return {
@@ -61,22 +63,13 @@ export function createPeerHostFeature(options = {}) {
             });
             const sessions = new PeerHostSessionService(store, credentials, options.fetchImpl === undefined ? {} : { fetchImpl: options.fetchImpl });
             const httpProxy = new PeerHostHttpProxyService(store, sessions, options.fetchImpl === undefined ? {} : { fetchImpl: options.fetchImpl });
-            // 旧版 HTTP 代理尚未下传 request.signal；每次读取独立绑定 fetch，避免共享
-            // 代理上的可变信号污染其他界面请求，同时让取消真正中断网络读取。
-            const scopedProxy = (signal) => signal === undefined ? httpProxy : new PeerHostHttpProxyService(store, sessions, {
-                fetchImpl: async (input, init) => {
-                    const closing = new URL(input instanceof Request ? input.url : String(input)).pathname.endsWith('/peerHost/nativeStreamClose');
-                    const requestSignal = closing ? AbortSignal.timeout(5_000) : init?.signal == null ? signal : AbortSignal.any([signal, init.signal]);
-                    requestSignal.throwIfAborted();
-                    return (options.fetchImpl ?? fetch)(input, { ...init, signal: requestSignal });
-                },
-            });
             const aggregate = new PeerHostAggregateService();
+            const workspaceCache = new PeerHostWorkspaceCache(join(stateDirectory, 'peer-host-workspace-cache.json'), ownerUserId);
             const workspaceRegistry = new VirtualWorkspaceRegistry({
                 orderStore: new FileAggregateWorkspaceOrderStore(join(stateDirectory, 'peer-host-workspace-order.json')),
             });
             let workspaceOrderHydrated = false;
-            const nativeStreams = new Map();
+            const nativeStreams = new PeerHostNativeStreams();
             const dshNativeDispatch = resolveDshNativeDispatch(context.services.dshContext);
             const debugLevel = resolveCodingNsDebugLevel();
             const diagnostics = createPeerHostDiagnosticSink({
@@ -99,13 +92,15 @@ export function createPeerHostFeature(options = {}) {
             const localHostId = process.env.CODINGNS4DSH_HOST_ID?.trim() || ownerUserId;
             const localSummarySource = createDshNativeSummarySource(context.services.dshContext, context.services.nativeSessions);
             /**
-             * 聚合前确保目标 Host 已完成握手和认证。
+             * 聚合前确保目标 Host 已完成握手和认证；握手状态若只是临时断线结果，
+             * 则交给真实数据面重新验证，避免已有消息/终端连接被旧状态染灰。
              *
              * PeerHost 的记录状态是运行时缓存，不是登录凭据本身：远端返回 401 后
              * 状态会暂时变成 session_required，下一次聚合必须主动用持久化的 refresh
              * token/账号密码恢复，否则只要没有手工点“测试”，该目标就会永远被跳过。
              */
-            const preparePeerHost = async (input) => {
+            const preparePeerHost = async (input, options = {}) => {
+                const allowTransientStatus = options.allowTransientStatus === true;
                 if (input.status === 'disabled' || input.status === 'identity_changed')
                     return null;
                 let record = input;
@@ -113,17 +108,17 @@ export function createPeerHostFeature(options = {}) {
                     await sessions.refresh(record.id).catch(() => undefined);
                     record = (await store.get(record.id)) ?? record;
                 }
-                else if (record.status !== 'ready') {
-                    // configured/unreachable/version_mismatch 等状态都可能只是上一次启动
-                    // 或网络抖动留下的缓存；自动重试等价于管理面板的“测试”。
+                else if (record.status !== 'ready' && !(allowTransientStatus && isPeerHostTransientStatus(record.status))) {
+                    // configured/version_mismatch 等状态仍需先完成握手；checking/unreachable/
+                    // reconnecting 只是旧连接尝试的结果，摘要数据面应直接重新验证目标。
                     record = await handshake.check(record.id);
                 }
-                if (record.status !== 'ready')
+                if (record.status !== 'ready' && !(allowTransientStatus && isPeerHostTransientStatus(record.status)))
                     return null;
                 // 即使 access token 尚未到期，也检查一次当前认证状态；临近过期时这里
                 // 会 refresh，refresh token 失效时会用保存的账号密码静默重登。
                 try {
-                    await sessions.getAccessToken(record.id);
+                    await sessions.getAccessToken(record.id, allowTransientStatus);
                 }
                 catch {
                     return null;
@@ -148,14 +143,19 @@ export function createPeerHostFeature(options = {}) {
                 // 助理只访问受管远端，不能为了本地索引唤醒全部 PeerHost 或重复扫描本地列表。
                 const selectedRecords = assistantWorkspaceIds === undefined ? records : records.filter((record) => record.status !== 'disabled' && record.status !== 'identity_changed'
                     && (record.visibleWorkspaceIds ?? []).some((workspaceId) => assistantWorkspaceIds.some((selected) => assistantWorkspaceMatches(selected, record.id, workspaceId))));
-                const preparedRecords = await Promise.all(selectedRecords.map((record) => preparePeerHost(record).catch(() => null)));
+                // 摘要是实际数据面探针：握手状态可能滞后，但消息和终端仍可正常访问时，
+                // 不能先用旧的 unreachable 状态把 Host 排除在 source 之外。
+                const preparedRecords = await Promise.all(selectedRecords.map((record) => preparePeerHost(record, { allowTransientStatus: true }).catch(() => null)));
                 signal?.throwIfAborted();
                 for (const [index, record] of preparedRecords.entries()) {
-                    if (record === null || record.status !== 'ready') {
+                    if (record === null) {
                         // 受管远端的握手/认证失败也必须交给助理退避，不能冒充没有远端工作区。
                         const original = selectedRecords[index];
-                        if (assistantWorkspaceIds !== undefined)
-                            sources.push({ hostId: localHostId, targetHostId: original.id, hostLabel: original.displayName, load: async () => { throw new Error('受管远端 Host 暂不可达'); } });
+                        if (original.status !== 'disabled' && original.status !== 'identity_changed')
+                            sources.push({
+                                hostId: localHostId, targetHostId: original.id, hostLabel: original.displayName, hostColor: original.color ?? null,
+                                load: async () => { throw new Error('远端 Host 暂不可达'); },
+                            });
                         continue;
                     }
                     const selectedWorkspaceIds = assistantWorkspaceIds === undefined
@@ -171,9 +171,9 @@ export function createPeerHostFeature(options = {}) {
                         source: createPeerHostRemoteSummarySource({
                             scope: { hostId: localHostId, targetHostId: record.id, workspaceId: '__aggregate__', sessionId: null, scopeGeneration: 0 },
                             transport: {
-                                rpc: (request) => callPeerNativeRpc(scopedProxy(signal ?? request.signal), record.id, { ...request, ...(signal === undefined ? {} : { signal }) }),
-                                stream: (request) => openPeerNativeStream(scopedProxy(signal ?? request.signal), record.id, { ...request, ...(signal === undefined ? {} : { signal }) }),
-                                cli: (request) => callPeerCliRpc(scopedProxy(signal ?? request.signal), record.id, { ...request, ...(signal === undefined ? {} : { signal }) }),
+                                rpc: (request) => callPeerNativeRpc(httpProxy, record.id, { ...request, ...(signal === undefined ? {} : { signal }) }),
+                                stream: (request) => openPeerNativeStream(httpProxy, record.id, { ...request, ...(signal === undefined ? {} : { signal }) }),
+                                cli: (request) => callPeerCliRpc(httpProxy, record.id, { ...request, ...(signal === undefined ? {} : { signal }) }),
                             },
                             // 默认只投影用户显式添加的远端工作区；未添加时不展示该 Host 的任何工作区。
                             visibleWorkspaceIds: selectedWorkspaceIds,
@@ -182,6 +182,20 @@ export function createPeerHostFeature(options = {}) {
                 }
                 return sources;
             };
+            /** 数据面摘要成功后清除过期的临时断线状态，让下一轮也从正常路径开始。 */
+            const markRecoveredPeerHosts = async (results) => {
+                if (options.aggregateSources !== undefined)
+                    return;
+                await Promise.all(results.flatMap((result) => {
+                    if (result.targetHostId === null || result.availability !== 'ready')
+                        return [];
+                    return [store.get(result.targetHostId).then((record) => {
+                            if (record !== null && isPeerHostTransientStatus(record.status))
+                                return store.updateStatus(record.id, 'ready', null).then(() => undefined);
+                            return undefined;
+                        })];
+                }));
+            };
             /** 远端工作区候选的唯一读取入口；不过滤可见性，供"添加工作区"选择器使用。 */
             const readRemoteWorkspaceCandidates = async (peerHostId) => {
                 const configured = await store.get(peerHostId);
@@ -236,12 +250,83 @@ export function createPeerHostFeature(options = {}) {
                 httpProxy,
                 wsProxy,
                 peer: {
-                    nativeRpc: (peerHostId, request) => callPeerNativeRpc(scopedProxy(request.signal), peerHostId, request),
-                    nativeStream: (peerHostId, request) => openPeerNativeStream(scopedProxy(request.signal), peerHostId, request),
+                    nativeRpc: (peerHostId, request) => callPeerNativeRpc(httpProxy, peerHostId, request),
+                    nativeStream: (peerHostId, request) => openPeerNativeStream(httpProxy, peerHostId, request),
                 },
             });
             context.resources.add(() => aggregatedTransport.close());
+            const readNotificationSource = async (peerHostId, payload, signal) => {
+                const response = await httpProxy.request(peerHostId, {
+                    scope: { hostId: localHostId, targetHostId: peerHostId, workspaceId: '__assistant_notifications__', sessionId: null, scopeGeneration: 0 },
+                    path: '/api/codingns/assistant/notifications/source', method: 'POST',
+                    body: JSON.stringify({ rpcId: `assistant-source-${randomUUID()}`, method: 'assistant/notifications/source', payload }), signal,
+                });
+                if ([404, 405, 501].includes(response.status))
+                    throw new CodingNsRpcError('UNSUPPORTED_CAPABILITY', '远端不支持会话通知来源协议');
+                return readNativeRpcEnvelope(response.body);
+            };
             const assistantGateway = {
+                async validateNotificationTarget(target) {
+                    if (target.hostId === localHostId)
+                        return false;
+                    const record = await store.get(target.hostId);
+                    if (record === null || record.status === 'disabled' || record.status === 'identity_changed')
+                        return false;
+                    const workspaceId = assistantPeerNotificationWorkspaceIds(target.hostId, record.visibleWorkspaceIds ?? [], [target.workspaceId])[0];
+                    if (workspaceId === undefined)
+                        return false;
+                    const signal = AbortSignal.timeout(5_000);
+                    try {
+                        const results = await aggregate.load(await buildSources([createVirtualWorkspaceId(target.hostId, workspaceId)], signal));
+                        signal.throwIfAborted();
+                        const present = results.some(result => result.targetHostId === target.hostId && result.availability === 'ready'
+                            && result.workspaces.some(item => item.workspaceId === workspaceId
+                                && item.sessions.some(session => session.scope.sessionId === target.sessionId && !session.blank)));
+                        if (!present)
+                            return false;
+                        if (target.requestId === undefined)
+                            return true;
+                        const feed = readAssistantNotificationFeed(await readNotificationSource(target.hostId, { workspaceIds: [workspaceId] }, signal));
+                        const actualSession = target.actualRequestTarget?.sessionId ?? target.sessionId;
+                        return feed.pending.some(fact => (fact.actualRequestSessionId ?? fact.sessionId) === actualSession && fact.requestId === target.requestId && fact.kind === target.requestKind);
+                    }
+                    catch {
+                        return false;
+                    }
+                },
+                subscribeNotifications(managedWorkspaceIds, observer, signal) {
+                    const subscription = new AssistantPeerNotifications({
+                        observer,
+                        nodes: async (signal) => {
+                            signal.throwIfAborted();
+                            const records = await store.list();
+                            signal.throwIfAborted();
+                            return records.filter(record => record.status !== 'disabled' && record.status !== 'identity_changed')
+                                .map(record => ({
+                                hostId: record.id, hostLabel: record.displayName,
+                                capabilityKey: assistantPeerNotificationCapabilityKey(record),
+                                workspaceIds: assistantPeerNotificationWorkspaceIds(record.id, record.visibleWorkspaceIds ?? [], managedWorkspaceIds),
+                            })).filter(node => node.workspaceIds.length > 0);
+                        },
+                        read: async (node, payload, signal) => {
+                            // 通知不依赖索引触发握手；只在缓存尚未 ready 时准备当前这台受管 Host。
+                            const configured = await store.get(node.hostId);
+                            if (configured === null)
+                                throw new CodingNsRpcError('PEER_HOST_NOT_FOUND', 'PeerHost 不存在');
+                            if (configured.status !== 'ready' && await preparePeerHost(configured) === null)
+                                throw new CodingNsRpcError('PEER_HOST_NOT_READY', '远端 Host 暂不可达');
+                            signal.throwIfAborted();
+                            return readNotificationSource(node.hostId, payload, signal);
+                        },
+                        stream: (node, signal) => aggregatedTransport.openStream({
+                            scope: { hostId: localHostId, targetHostId: node.hostId, workspaceId: '__assistant_notifications__', sessionId: null, scopeGeneration: 0 },
+                            method: 'codingnsAssistantNotifications/sourceStream',
+                            payload: { args: { request: { workspaceIds: node.workspaceIds } } },
+                            signal,
+                        }),
+                    }, signal);
+                    return subscription.start();
+                },
                 async workspaces(signal) {
                     signal?.throwIfAborted();
                     const records = await store.list();
@@ -485,12 +570,19 @@ export function createPeerHostFeature(options = {}) {
                             : [];
                         return toPeerHostClientRecord(await store.replaceVisibleWorkspaces(peerHostId, ids));
                     }
+                    case 'dismissDisconnectedWorkspace': {
+                        await workspaceCache.dismiss(requiredString(input.peerHostId, 'peerHostId'), requiredString(input.workspaceId, 'workspaceId'));
+                        return { removed: true };
+                    }
                     case 'wsEndpoint': return wsEndpoint;
                     case 'aggregate': {
                         // 顺序 Registry 必须认识本地工作区，即使本地 session 摘要在启动瞬间
                         // 还没有准备好。否则 order 只会留下远端 ID，客户端拖拽到本地项时
                         // 只能拒绝请求，表现为远端永远被固定在列表顶部。
-                        const results = ensureLocalWorkspaceSummaries(await aggregate.load(await buildSources()), context.services.dshContext);
+                        const loaded = ensureLocalWorkspaceSummaries(await aggregate.load(await buildSources()), context.services.dshContext);
+                        await markRecoveredPeerHosts(loaded);
+                        // 测试注入的独立来源不受配置列表约束；生产摘要按当前添加状态恢复缓存。
+                        const results = options.aggregateSources === undefined ? await workspaceCache.apply(loaded, await store.list()) : loaded;
                         workspaceRegistry.replace(results);
                         if (!workspaceOrderHydrated) {
                             await workspaceRegistry.hydrateOrder();
@@ -523,6 +615,7 @@ export function createPeerHostFeature(options = {}) {
                             scope,
                             path: requiredString(input.path, 'path'),
                             ...(input.method === undefined ? {} : { method: requiredString(input.method, 'method') }),
+                            ...(input.headers === undefined ? {} : { headers: parseProxyHeaders(input.headers) }),
                             ...(input.body === undefined ? {} : { body: requiredString(input.body, 'body') }),
                         });
                     }
@@ -546,13 +639,14 @@ export function createPeerHostFeature(options = {}) {
                         const payload = rewriteNativeRequestIds(method, input.payload, createScopedNativeIdResolver(workspaceRegistry, scope));
                         // 句柄由 nativeStreamNext/Close 轮询管理，不绑定本次 HTTP 请求的 signal：
                         // 该 signal 会在 nativeStream 响应返回后立即中止，导致第一次 next 直接结束。
-                        const stream = aggregatedTransport.openStream({ scope, method, payload });
-                        const targetHostId = scope.targetHostId;
-                        const iterator = targetHostId === null
-                            ? stream[Symbol.asyncIterator]()
-                            : mapAsyncIterator(stream[Symbol.asyncIterator](), (value) => rewriteNativeResponseIds(value, (id) => createVirtualWorkspaceId(targetHostId, id), (id) => createVirtualSessionId(targetHostId, id)));
-                        const streamId = randomUUID();
-                        nativeStreams.set(streamId, { iterator, scope, expiresAt: Date.now() + NATIVE_STREAM_TTL_MS });
+                        const streamId = await nativeStreams.open(scope, (signal) => {
+                            const stream = aggregatedTransport.openStream({ scope, method, payload, signal });
+                            const targetHostId = scope.targetHostId;
+                            if (targetHostId === null)
+                                return stream;
+                            const iterator = mapAsyncIterator(stream[Symbol.asyncIterator](), (value) => rewriteNativeResponseIds(value, (id) => createVirtualWorkspaceId(targetHostId, id), (id) => createVirtualSessionId(targetHostId, id), method));
+                            return { [Symbol.asyncIterator]: () => iterator };
+                        });
                         return { streamId };
                     }
                     case 'nativeStreamOpen': {
@@ -563,29 +657,18 @@ export function createPeerHostFeature(options = {}) {
                         // 句柄会在后续 nativeStreamNext/Close 中被轮询管理，不能绑定到本次 HTTP 请求的短生命周期 signal。
                         if (dshNativeDispatch === undefined)
                             throw new CodingNsRpcError('CODINGNS_RPC_UNSUPPORTED', '当前 Host 未提供 DSH Typert Gateway');
-                        const stream = await dshNativeDispatch.stream(method, input.payload);
-                        if (!isAsyncIterable(stream))
-                            throw new CodingNsRpcError('CODINGNS_RPC_UNSUPPORTED', `DSH 原生 Remote 方法不是流: ${method}`);
-                        const streamId = randomUUID();
-                        nativeStreams.set(streamId, { iterator: stream[Symbol.asyncIterator](), scope, expiresAt: Date.now() + NATIVE_STREAM_TTL_MS });
+                        const streamId = await nativeStreams.open(scope, async (signal) => {
+                            const stream = await dshNativeDispatch.stream(method, input.payload, signal);
+                            if (!isAsyncIterable(stream))
+                                throw new CodingNsRpcError('CODINGNS_RPC_UNSUPPORTED', `DSH 原生 Remote 方法不是流: ${method}`);
+                            return stream;
+                        });
                         return { streamId };
                     }
                     case 'nativeStreamNext': {
                         const streamId = requiredString(input.streamId, 'streamId');
-                        const stream = nativeStreams.get(streamId);
-                        if (stream === undefined || stream.expiresAt < Date.now()) {
-                            if (stream?.iterator.return !== undefined)
-                                await stream.iterator.return();
-                            nativeStreams.delete(streamId);
-                            throw new CodingNsRpcError('CODINGNS_RPC_NOT_FOUND', 'DSH 原生 Remote 流已失效');
-                        }
                         const scope = parseScope(input.scope);
-                        assertSameScope(stream.scope, scope);
-                        // 每次轮询都算一次心跳：空闲会话的 next 会长时间挂起，不能只在出帧时续期。
-                        nativeStreams.set(streamId, { ...stream, expiresAt: Date.now() + NATIVE_STREAM_TTL_MS });
-                        const next = await stream.iterator.next();
-                        if (next.done === true)
-                            nativeStreams.delete(streamId);
+                        const next = await nativeStreams.next(streamId, scope, rpcContext?.signal);
                         return {
                             done: next.done === true,
                             ...(next.done === true ? {} : { value: encodeNativeResponseBytes(next.value) }),
@@ -593,10 +676,7 @@ export function createPeerHostFeature(options = {}) {
                     }
                     case 'nativeStreamClose': {
                         const streamId = requiredString(input.streamId, 'streamId');
-                        const stream = nativeStreams.get(streamId);
-                        nativeStreams.delete(streamId);
-                        if (stream?.iterator.return !== undefined)
-                            await stream.iterator.return();
+                        await nativeStreams.close(streamId, parseScope(input.scope));
                         return { closed: true };
                     }
                     case 'native': {
@@ -605,18 +685,17 @@ export function createPeerHostFeature(options = {}) {
                             throw new CodingNsRpcError('CODINGNS_RPC_NOT_FOUND', `未知 DSH 原生 Remote 方法: ${method}`);
                         const scope = parseScope(input.scope);
                         const rewritten = rewriteNativeRequestIds(method, input.payload, createScopedNativeIdResolver(workspaceRegistry, scope));
-                        const value = await aggregatedTransport.rpc({ scope, method, payload: rewritten });
+                        const signal = rpcContext?.signal;
+                        const value = await aggregatedTransport.rpc({ scope, method, payload: rewritten, ...(signal === undefined ? {} : { signal }) });
                         const virtualHostId = scope.targetHostId ?? scope.hostId;
-                        return encodeNativeResponseBytes(rewriteNativeResponseIds(value, (id) => createVirtualWorkspaceId(virtualHostId, id), (id) => createVirtualSessionId(virtualHostId, id)));
+                        return encodeNativeResponseBytes(rewriteNativeResponseIds(value, (id) => createVirtualWorkspaceId(virtualHostId, id), (id) => createVirtualSessionId(virtualHostId, id), method));
                     }
                     default: throw new CodingNsRpcError('CODINGNS_RPC_NOT_FOUND', `未知 PeerHost RPC: peerHost/${action}`);
                 }
             });
             context.resources.add(unregister);
             context.resources.add(() => {
-                for (const stream of nativeStreams.values())
-                    void stream.iterator.return?.();
-                nativeStreams.clear();
+                nativeStreams.dispose();
             });
         },
     };
@@ -793,11 +872,6 @@ function finiteNumber(value) {
 function isAsyncIterable(value) {
     return typeof value === 'object' && value !== null && typeof value[Symbol.asyncIterator] === 'function';
 }
-function assertSameScope(expected, actual) {
-    if (expected.hostId !== actual.hostId || expected.targetHostId !== actual.targetHostId || expected.workspaceId !== actual.workspaceId || expected.sessionId !== actual.sessionId || expected.scopeGeneration !== actual.scopeGeneration) {
-        throw new CodingNsRpcError('CODINGNS_RPC_SCOPE_MISMATCH', 'DSH 原生 Remote 流作用域不匹配');
-    }
-}
 async function authorizePeerHostUpgrade(loginStore, request) {
     const origin = request.headers.origin;
     const host = request.headers.host;
@@ -908,6 +982,18 @@ function record(value) {
         throw new TypeError('PeerHost RPC 参数必须是对象');
     return value;
 }
+/** 解析页面侧转发的有限请求头，拒绝非字符串值与原型对象。 */
+function parseProxyHeaders(value) {
+    const input = record(value);
+    const headers = {};
+    for (const [name, raw] of Object.entries(input)) {
+        if (!/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/u.test(name) || typeof raw !== 'string') {
+            throw new TypeError('headers 必须是合法的字符串键值');
+        }
+        headers[name] = raw;
+    }
+    return headers;
+}
 /**
  * 解析工作区标签配色。
  *
@@ -936,7 +1022,10 @@ function requiredString(value, field) {
  * 当成可路由资源。
  */
 export function createScopedNativeIdResolver(registry, scope) {
+    const workspacePath = scope.targetHostId === null ? undefined
+        : registry.get(createVirtualWorkspaceId(scope.targetHostId, scope.workspaceId))?.path;
     return {
+        ...(workspacePath === undefined ? {} : { workspacePath }),
         resolveWorkspace(id) {
             const known = registry.resolveWorkspace(id);
             if (known !== null)