@jingyi0605/codingns4dsh 0.1.2 → 0.1.7-rc.2

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

@@ -0,0 +1,316 @@
+import { CODINGNS_RPC_CHANNEL } from '../shared/contracts/transport.js';
+/** 根据当前 Host 自有端点生成作用域 WebSocket 工厂；不接受目标 Host URL。 */
+export function createPeerHostWebSocketFactory(endpoint, options = {}) {
+    if (!Number.isSafeInteger(endpoint.port) || endpoint.port < 0 || endpoint.port > 65_535)
+        throw new TypeError('PeerHost WebSocket 端口无效');
+    const path = endpoint.path.startsWith('/api/') && !endpoint.path.includes('..') ? endpoint.path : (() => { throw new TypeError('PeerHost WebSocket 路径无效'); })();
+    return async (scope) => {
+        assertPeerScope(scope);
+        const host = options.host?.trim() || wildcardHost(endpoint.host) || currentLocationHost();
+        if (host === '')
+            throw new Error('无法解析当前 Host WebSocket 地址');
+        const protocol = options.protocol ?? currentLocationProtocol();
+        const url = new URL(`${protocol}://${host}:${String(endpoint.port)}${path}`);
+        url.searchParams.set('hostId', scope.hostId);
+        url.searchParams.set('targetHostId', scope.targetHostId);
+        url.searchParams.set('workspaceId', scope.workspaceId);
+        if (scope.sessionId !== null)
+            url.searchParams.set('sessionId', scope.sessionId);
+        url.searchParams.set('scopeGeneration', String(scope.scopeGeneration));
+        const WebSocketCtor = globalThis.WebSocket;
+        if (typeof WebSocketCtor !== 'function')
+            throw new Error('当前运行时没有 WebSocket');
+        return adaptBrowserWebSocket(new WebSocketCtor(url));
+    };
+}
+/** 将浏览器标准 WebSocket 事件适配为 Client 事件流使用的轻量接口。 */
+function adaptBrowserWebSocket(socket) {
+    return {
+        get readyState() { return socket.readyState; },
+        send(data) { socket.send(data); },
+        close(code, reason) { socket.close(code, reason); },
+        on(event, listener) {
+            if (event === 'message') {
+                socket.addEventListener('message', (message) => listener(message.data, typeof message.data !== 'string'));
+                return;
+            }
+            socket.addEventListener(event, (...args) => listener(...args));
+        },
+    };
+}
+/** Client 侧远端资源适配器；每一次请求都从 HostScope 生成，不保存目标凭据。 */
+export function createPeerHostScopedClient(rpc) {
+    const request = async (scope, path, options = {}) => {
+        assertPeerScope(scope);
+        if (!path.startsWith('/api/') || path.includes('://'))
+            throw new TypeError('PeerHost 代理路径必须是固定 API 路径');
+        const payload = {
+            peerHostId: scope.targetHostId,
+            scope,
+            path,
+            ...(options.method === undefined ? {} : { method: options.method }),
+            ...(options.body === undefined ? {} : { body: options.body }),
+        };
+        let result;
+        try {
+            result = await rpc.call(CODINGNS_RPC_CHANNEL, 'peerHost/request', payload);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (!/HTTP (?:404|405)\b/u.test(message))
+                throw error;
+            result = await rpc.call('/api', 'codingns/peerHost/request', payload);
+        }
+        if (!result.ok)
+            throw new Error(result.error.message);
+        return result.value;
+    };
+    return {
+        request,
+        loadSessionHistory: (scope, cursor) => request(requireSession(scope), `/api/sessions/${encodeURIComponent(scope.sessionId)}/history${cursor === undefined ? '' : `?cursor=${encodeURIComponent(cursor)}`}`),
+        sendMessage: (scope, body) => request(requireSession(scope), `/api/sessions/${encodeURIComponent(scope.sessionId)}/messages`, { method: 'POST', body }),
+        stopSession: (scope) => request(requireSession(scope), `/api/sessions/${encodeURIComponent(scope.sessionId)}/stop`, { method: 'POST', body: '{}' }),
+        replyPermission: (scope, body) => request(requireSession(scope), `/api/sessions/${encodeURIComponent(scope.sessionId)}/permission`, { method: 'POST', body }),
+        answerQuestion: (scope, body) => request(requireSession(scope), `/api/sessions/${encodeURIComponent(scope.sessionId)}/answer`, { method: 'POST', body }),
+        readFile: (scope, path) => request(scope, `/api/files?path=${encodeURIComponent(path)}`),
+        writeFile: (scope, body) => request(scope, '/api/files', { method: 'PUT', body }),
+        gitStatus: (scope) => request(scope, '/api/git/status'),
+        terminal: (scope, action, body) => request(scope, `/api/terminal/${action}`, { method: 'POST', ...(body === undefined ? {} : { body }) }),
+        rightTool: (scope, action, body) => request(scope, `/api/right-tools/${action}`, { method: 'POST', ...(body === undefined ? {} : { body }) }),
+        openEventStream: (scope, socketFactory, listener, options) => openEventStream(scope, socketFactory, listener, options),
+    };
+}
+const OPEN = 1;
+const CLOSED = 3;
+const SOCKET_OPEN_TIMEOUT_MS = 15_000;
+const PEER_HOST_EVENT_TYPES = new Set([
+    'peerHost.error',
+    'system.connected', 'workbench.snapshot', 'workbench.delta', 'fileTree.snapshot',
+    'git.snapshot', 'session.subscribed', 'session.backfill', 'session.delta',
+    'session.runtime_message', 'session.runtime_status', 'session.activity',
+    'session.permission_request', 'session.error', 'terminal.output', 'terminal.status',
+    'terminal.exit', 'terminal.error', 'rightTool.snapshot', 'rightTool.delta',
+]);
+async function openEventStream(scope, socketFactory, listener, options = {}) {
+    assertPeerScope(scope);
+    const maxReconnectAttempts = normalizeReconnectAttempts(options.maxReconnectAttempts);
+    const reconnectDelaysMs = normalizeReconnectDelays(options.reconnectDelaysMs);
+    const initialSocket = await socketFactory(scope);
+    try {
+        await waitForSocketOpen(initialSocket);
+    }
+    catch (error) {
+        closeSocket(initialSocket, 1011, 'PeerHost WebSocket 打开失败');
+        throw error;
+    }
+    let socket = initialSocket;
+    let closed = false;
+    let reconnectTimer;
+    let reconnectAttempt = 0;
+    let connecting = false;
+    let pendingSocket;
+    const replayableSubscriptions = new Map();
+    const close = () => {
+        if (closed)
+            return;
+        closed = true;
+        if (reconnectTimer !== undefined)
+            clearTimeout(reconnectTimer);
+        reconnectTimer = undefined;
+        closeSocket(socket, 1000, 'PeerHost 作用域已清理');
+        if (pendingSocket !== undefined && pendingSocket !== socket)
+            closeSocket(pendingSocket, 1000, 'PeerHost 作用域已清理');
+    };
+    const send = (type, payload = {}) => {
+        if (!PEER_HOST_CLIENT_MESSAGE_TYPES.has(type))
+            throw new Error('PeerHost WebSocket 消息未加入白名单');
+        assertMessagePayload(payload);
+        if (closed || socket.readyState !== OPEN)
+            throw new Error('PeerHost WebSocket 尚未连接');
+        socket.send(JSON.stringify({ type, ...scope, ...payload }));
+        if (PEER_HOST_REPLAYABLE_MESSAGE_TYPES.has(type))
+            replayableSubscriptions.set(type, { ...payload });
+    };
+    const terminalInput = (payload) => { send('terminal.input', payload); };
+    const terminalResize = (payload) => { send('terminal.resize', payload); };
+    const terminalClose = (payload = {}) => { send('terminal.close', payload); };
+    const rightToolSubscribe = (payload) => { send('rightTool.subscribe', payload); };
+    const rightToolRefresh = (payload = {}) => { send('rightTool.refresh', payload); };
+    const rightToolClose = (payload = {}) => { send('rightTool.close', payload); };
+    const scheduleReconnect = () => {
+        if (closed || reconnectTimer !== undefined || reconnectAttempt >= maxReconnectAttempts)
+            return;
+        const delay = reconnectDelaysMs[Math.min(reconnectAttempt, reconnectDelaysMs.length - 1)];
+        reconnectAttempt += 1;
+        reconnectTimer = setTimeout(() => {
+            reconnectTimer = undefined;
+            void reconnect();
+        }, delay);
+    };
+    const attach = (next) => {
+        socket = next;
+        const current = next;
+        current.on('message', (data, isBinary) => {
+            if (closed || isBinary === true || typeof data !== 'string')
+                return;
+            const event = parseScopedEvent(data, scope);
+            if (event !== null)
+                listener(event);
+        });
+        current.on('close', () => {
+            if (!closed && socket === current)
+                scheduleReconnect();
+        });
+        current.on('error', () => {
+            if (closed || socket !== current)
+                return;
+            if (current.readyState === OPEN)
+                current.close(1011, 'PeerHost WebSocket 连接错误');
+            else
+                scheduleReconnect();
+        });
+        replaySubscriptions(current);
+    };
+    const reconnect = async () => {
+        if (closed || connecting)
+            return;
+        connecting = true;
+        try {
+            const next = await socketFactory(scope);
+            pendingSocket = next;
+            await waitForSocketOpen(next);
+            pendingSocket = undefined;
+            if (closed) {
+                closeSocket(next, 1000, 'PeerHost 作用域已清理');
+                return;
+            }
+            reconnectAttempt = 0;
+            attach(next);
+        }
+        catch {
+            pendingSocket = undefined;
+            scheduleReconnect();
+        }
+        finally {
+            connecting = false;
+        }
+    };
+    attach(socket);
+    return { close, send, terminalInput, terminalResize, terminalClose, rightToolSubscribe, rightToolRefresh, rightToolClose };
+    function replaySubscriptions(current) {
+        if (current.readyState !== OPEN)
+            return;
+        for (const [type, payload] of replayableSubscriptions) {
+            current.send(JSON.stringify({ type, ...scope, ...payload }));
+        }
+    }
+}
+async function waitForSocketOpen(socket) {
+    if (socket.readyState === OPEN)
+        return;
+    if (socket.readyState === CLOSED)
+        throw new Error('PeerHost WebSocket 在打开前关闭');
+    await new Promise((resolve, reject) => {
+        let settled = false;
+        const finish = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            if (error === undefined)
+                resolve();
+            else
+                reject(error);
+        };
+        const timer = setTimeout(() => finish(new Error('PeerHost WebSocket 打开超时')), SOCKET_OPEN_TIMEOUT_MS);
+        socket.on('open', () => finish());
+        socket.on('close', () => finish(new Error('PeerHost WebSocket 在打开前关闭')));
+        socket.on('error', () => finish(new Error('PeerHost WebSocket 打开失败')));
+    });
+}
+function closeSocket(socket, code, reason) {
+    if (socket.readyState !== CLOSED)
+        socket.close(code, reason);
+}
+const PEER_HOST_CLIENT_MESSAGE_TYPES = new Set([
+    'workbench.subscribe', 'workbench.refresh', 'fileTree.subscribe', 'fileTree.refresh',
+    'git.subscribe', 'git.refresh', 'session.subscribe', 'session.load_older',
+    'session.send', 'session.stop', 'session.permission_reply', 'session.answer',
+    'terminal.subscribe', 'terminal.input', 'terminal.resize', 'terminal.close',
+    'rightTool.subscribe', 'rightTool.refresh', 'rightTool.close',
+]);
+/** 这些消息描述可重建的订阅，重连后可以安全重放；命令和输入绝不能重放。 */
+const PEER_HOST_REPLAYABLE_MESSAGE_TYPES = new Set([
+    'workbench.subscribe', 'fileTree.subscribe', 'git.subscribe', 'session.subscribe', 'terminal.subscribe', 'rightTool.subscribe',
+]);
+function parseScopedEvent(raw, expected) {
+    let value;
+    try {
+        value = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return null;
+    const event = value;
+    if (typeof event.type !== 'string' || !PEER_HOST_EVENT_TYPES.has(event.type))
+        return null;
+    if (requiresSession(event.type) && (typeof event.sessionId !== 'string' || event.sessionId.trim() === ''))
+        return null;
+    if (event.hostId !== expected.hostId || event.targetHostId !== expected.targetHostId || event.workspaceId !== expected.workspaceId || event.scopeGeneration !== expected.scopeGeneration)
+        return null;
+    const eventSessionId = typeof event.sessionId === 'string' && event.sessionId.trim() !== '' ? event.sessionId : null;
+    if (eventSessionId !== expected.sessionId)
+        return null;
+    return event;
+}
+function requiresSession(type) {
+    return type.startsWith('session.');
+}
+function assertMessagePayload(payload) {
+    if (typeof payload !== 'object' || payload === null || Array.isArray(payload))
+        throw new TypeError('PeerHost WebSocket 消息参数必须是对象');
+    for (const key of ['type', 'hostId', 'targetHostId', 'workspaceId', 'sessionId', 'scopeGeneration']) {
+        if (Object.prototype.hasOwnProperty.call(payload, key))
+            throw new TypeError('PeerHost WebSocket 消息不得覆盖作用域字段');
+    }
+}
+function normalizeReconnectAttempts(value) {
+    if (value === undefined)
+        return 4;
+    if (!Number.isSafeInteger(value) || value < 0 || value > 8)
+        throw new TypeError('PeerHost WebSocket 重连次数无效');
+    return value;
+}
+function normalizeReconnectDelays(value) {
+    const delays = value === undefined ? [100, 250, 500, 1000] : [...value];
+    if (delays.length === 0 || delays.some((item) => !Number.isSafeInteger(item) || item < 0 || item > 30_000))
+        throw new TypeError('PeerHost WebSocket 重连等待时间无效');
+    return delays;
+}
+function requireSession(scope) {
+    assertPeerScope(scope);
+    if (scope.sessionId === null || scope.sessionId.trim() === '')
+        throw new TypeError('会话操作必须包含 sessionId');
+    return scope;
+}
+function assertPeerScope(scope) {
+    if (scope.targetHostId === null || scope.targetHostId.trim() === '')
+        throw new TypeError('PeerHost 作用域必须包含 targetHostId');
+    if (scope.hostId.trim() === '' || scope.workspaceId.trim() === '' || !Number.isSafeInteger(scope.scopeGeneration) || scope.scopeGeneration < 0)
+        throw new TypeError('PeerHost 作用域无效');
+}
+function wildcardHost(value) {
+    const host = value.trim();
+    return host === '0.0.0.0' || host === '::' || host === '[::]' ? '' : host;
+}
+function currentLocationHost() {
+    const location = globalThis.location;
+    return location?.hostname?.trim() ?? '';
+}
+function currentLocationProtocol() {
+    const location = globalThis.location;
+    return location?.protocol === 'https:' ? 'wss' : 'ws';
+}
+//# sourceMappingURL=peer-host-scoped-client.js.map

package/data/build/dist/client/peer-host-session-controller.d.ts

@@ -0,0 +1,30 @@
+import type { HostScope } from '../shared/contracts/peer-host.js';
+import { HostRouter, type HostRouterInput } from './host-router.js';
+import type { PeerHostEventListener, PeerHostEventSocketFactory, PeerHostEventSubscription, PeerHostEventStreamOptions, PeerHostProxyResponse, PeerHostScopedClient } from './peer-host-scoped-client.js';
+/**
+ * 远端会话的唯一 Client 入口。
+ *
+ * 控制器不保存目标凭据，只保存当前 HostScope；所有异步结果在提交前再次
+ * 校验 generation，避免切换工作区或会话后旧请求回写新页面。
+ */
+export declare class PeerHostSessionController {
+    private readonly router;
+    private readonly client;
+    constructor(router: HostRouter, client: PeerHostScopedClient);
+    select(input: HostRouterInput): Promise<HostScope>;
+    current(): HostScope | null;
+    /**
+     * Host 侧重连成功后重建同一逻辑作用域。
+     * `HostRouter.rebuild` 会先清理旧订阅，再递增 generation；摘要刷新回调只能使用新作用域。
+     */
+    rebuildAfterReconnect(scope: HostScope, refreshSummary?: (nextScope: HostScope) => Promise<void> | void): Promise<HostScope>;
+    loadHistory(scope: HostScope, cursor?: string): Promise<PeerHostProxyResponse>;
+    sendMessage(scope: HostScope, body: string): Promise<PeerHostProxyResponse>;
+    stop(scope: HostScope): Promise<PeerHostProxyResponse>;
+    replyPermission(scope: HostScope, body: string): Promise<PeerHostProxyResponse>;
+    answerQuestion(scope: HostScope, body: string): Promise<PeerHostProxyResponse>;
+    subscribe(scope: HostScope, socketFactory: PeerHostEventSocketFactory, listener: PeerHostEventListener, options?: PeerHostEventStreamOptions): Promise<PeerHostEventSubscription>;
+    private run;
+    private assertCurrent;
+}
+//# sourceMappingURL=peer-host-session-controller.d.ts.map

package/data/build/dist/client/peer-host-session-controller.js

@@ -0,0 +1,95 @@
+import { HostRouter } from './host-router.js';
+/**
+ * 远端会话的唯一 Client 入口。
+ *
+ * 控制器不保存目标凭据，只保存当前 HostScope；所有异步结果在提交前再次
+ * 校验 generation，避免切换工作区或会话后旧请求回写新页面。
+ */
+export class PeerHostSessionController {
+    router;
+    client;
+    constructor(router, client) {
+        this.router = router;
+        this.client = client;
+    }
+    async select(input) {
+        return this.router.switchTo(input);
+    }
+    current() {
+        return this.router.getCurrent();
+    }
+    /**
+     * Host 侧重连成功后重建同一逻辑作用域。
+     * `HostRouter.rebuild` 会先清理旧订阅，再递增 generation；摘要刷新回调只能使用新作用域。
+     */
+    async rebuildAfterReconnect(scope, refreshSummary) {
+        this.assertCurrent(scope);
+        const nextScope = await this.router.rebuild({
+            hostId: scope.hostId,
+            targetHostId: scope.targetHostId,
+            workspaceId: scope.workspaceId,
+            sessionId: scope.sessionId,
+        });
+        if (refreshSummary !== undefined) {
+            this.assertCurrent(nextScope);
+            await refreshSummary(nextScope);
+            this.assertCurrent(nextScope);
+        }
+        return nextScope;
+    }
+    async loadHistory(scope, cursor) {
+        this.assertCurrent(scope);
+        const response = await this.client.loadSessionHistory(scope, cursor);
+        this.assertCurrent(scope);
+        return response;
+    }
+    async sendMessage(scope, body) {
+        return this.run(scope, () => this.client.sendMessage(scope, body));
+    }
+    async stop(scope) {
+        return this.run(scope, () => this.client.stopSession(scope));
+    }
+    async replyPermission(scope, body) {
+        return this.run(scope, () => this.client.replyPermission(scope, body));
+    }
+    async answerQuestion(scope, body) {
+        return this.run(scope, () => this.client.answerQuestion(scope, body));
+    }
+    async subscribe(scope, socketFactory, listener, options) {
+        this.assertCurrent(scope);
+        const subscription = await this.client.openEventStream(scope, socketFactory, listener, options);
+        if (!this.router.isCurrent(scope)) {
+            subscription.close();
+            throw new Error('PeerHost 作用域已失效');
+        }
+        const remove = this.router.addDisposer(subscription.close);
+        let disposed = false;
+        const close = () => {
+            if (disposed)
+                return;
+            disposed = true;
+            subscription.close();
+            remove();
+        };
+        return {
+            close,
+            send: subscription.send,
+            terminalInput: subscription.terminalInput,
+            terminalResize: subscription.terminalResize,
+            terminalClose: subscription.terminalClose,
+            rightToolSubscribe: subscription.rightToolSubscribe,
+            rightToolRefresh: subscription.rightToolRefresh,
+            rightToolClose: subscription.rightToolClose,
+        };
+    }
+    async run(scope, operation) {
+        this.assertCurrent(scope);
+        const response = await operation();
+        this.assertCurrent(scope);
+        return response;
+    }
+    assertCurrent(scope) {
+        this.router.assertCurrent(scope);
+    }
+}
+//# sourceMappingURL=peer-host-session-controller.js.map

package/data/build/dist/client/quick-phrase-slot.js

@@ -5,8 +5,20 @@ import { applyQuickPhraseOrder, QUICK_PHRASE_FALLBACK_MARGIN, QUICK_PHRASE_TRIGG
 import { dshPopupSurfaceStyle, dshThemeColor } from './theme.js';
 const QUICK_PHRASE_FALLBACK_SIZE = 28;
 const QUICK_PHRASE_FALLBACK_ICON_SIZE = 14;
+const QUICK_PHRASE_STYLE_ID = 'codingns4dsh-quick-phrase-responsive-style';
+/** 移动端弹层脱离对话窗口边界，使用整个视口宽度。 */
+function installQuickPhraseStyles() {
+    if (typeof document === 'undefined' || document.querySelector(`style[data-plugin-css="${QUICK_PHRASE_STYLE_ID}"]`) !== null)
+        return;
+    const style = document.createElement('style');
+    style.dataset.plugin = 'codingns4dsh';
+    style.dataset.pluginCss = QUICK_PHRASE_STYLE_ID;
+    style.textContent = '@media (max-width: 768px){.codingns4dsh-quick-phrase-overlay{left:0!important;right:0!important;width:100vw!important}}';
+    document.head.appendChild(style);
+}
 /** 在添加文件按钮右侧的输入工具区挂载插件自己的快捷会话入口。 */
 export function registerQuickPhraseSlot(slots, settings, locale) {
+    installQuickPhraseStyles();
     const t = locale.bind('codingns');
     return slots.inject('conversation.input.left', () => slots.register({
         name: 'conversation.input.left',
@@ -172,6 +184,7 @@ function QuickPhraseSlot(props) {
         strokeWidth: 2,
         'aria-hidden': true,
     }, createElement('path', { d: 'M7 8h10' }), createElement('path', { d: 'M7 12h8' }), createElement('path', { d: 'M7 16h5' }), createElement('path', { d: 'M5 5h14v14H9l-4 4V5z' }))), open && createElement('div', {
+        className: 'codingns4dsh-quick-phrase-overlay',
         role: 'dialog',
         'aria-label': t('workspace.quickPhrasesDialogLabel'),
         'aria-modal': true,
@@ -224,6 +237,7 @@ function QuickPhraseSlot(props) {
             onClick: () => removePhrase(phrase.id),
             style: quickPhraseDeleteStyle,
         }, '×')))))), addOpen && createElement('div', {
+        className: 'codingns4dsh-quick-phrase-overlay',
         role: 'dialog',
         'aria-label': t('workspace.quickPhrasesAddDialogLabel'),
         'aria-modal': true,

package/data/build/dist/client/remote-web-context.js

@@ -802,18 +802,40 @@ function createBridgeScript() {
     const parentTransport = (() => {
       try { return parent.__CODINGNS4DSH_REMOTE_TRANSPORT__; } catch { return undefined; }
     })();
-    globalThis.__DSH_TRANSPORT__ = {
+    const bridgedTransport = {
       fetch: window.fetch.bind(window),
       openStream: openRemoteStream,
-      // 该 iframe 的所有 DSH 请求都经由已认证的 Codingns4DSH 隧道回到选定 Host。
-      // 必须声明 Host 所有权，否则 ui-settings 会把远程页面降级为 memory
-      // 模式，原生“模型”页无法读取 settings provider。
+      // 仅作为 iframe 内 RemoteWebSocket 的虚拟基址，实际请求仍回到父窗口。
+      streamBaseUrl: resourceBase(),
+      // 声明 Host 所有权，保持原生设置存储可用。
       ownsHost: true,
       generation: parentTransport?.getGeneration?.bind(parentTransport),
       onGenerationChange: parentTransport?.onGenerationChange?.bind(parentTransport),
       reconnect: parentTransport?.reconnect?.bind(parentTransport),
       close: parentTransport?.close?.bind(parentTransport),
     };
+    // 远程 DSH Web 的启动页自带 Host 注入的 __DSH_TRANSPORT__ 行，它在本脚本之后
+    // 执行：直接赋值会覆盖桥接 Transport，丢掉 openStream 和 streamBaseUrl，让
+    // /api/remote.mux 退回 iframe 自己的 WebSocket（CSP connect-src 为 none），
+    // 会话列表和原生设置页面会一起加载失败。这里改为合并写入，后到的赋值只能补充
+    // 字段，桥接能力始终保留。
+    const mergeTransport = (next) => Object.assign(
+      {},
+      next !== null && typeof next === 'object' ? next : {},
+      bridgedTransport,
+    );
+    let transportValue = mergeTransport(globalThis.__DSH_TRANSPORT__);
+    try {
+      Object.defineProperty(globalThis, '__DSH_TRANSPORT__', {
+        configurable: true,
+        enumerable: true,
+        get: () => transportValue,
+        set: (next) => { transportValue = mergeTransport(next); },
+      });
+    } catch {
+      // 同名属性不可配置时退化为一次合并赋值，同样保留桥接字段。
+      globalThis.__DSH_TRANSPORT__ = mergeTransport(globalThis.__DSH_TRANSPORT__);
+    }
     globalThis.__CODINGNS4DSH_DEBUG__ = (event, fields = {}) => {
       bridgeLog('client.' + String(event), fields);
     };

package/data/build/dist/client/session-changed-files-view.d.ts

@@ -0,0 +1,15 @@
+import type { ReactElement } from 'react';
+import type { CodingNsRpcClient } from './features/types.js';
+export declare const SESSION_CHANGED_FILES_VIEW_ID = "codingns4dsh/session-changed-files";
+interface SessionChangedFilesViewProps {
+    readonly sessionId: string;
+    readonly rpc: CodingNsRpcClient;
+    readonly remote?: unknown;
+    readonly reportCount?: (sessionId: string, count: number) => void;
+}
+/** 会话“修改文件”视图；数据只通过插件 RPC 和现有 Git RPC 读取。 */
+export declare function SessionChangedFilesView(props: SessionChangedFilesViewProps): ReactElement;
+/** 注册 DSH 原生 conversation.view Slot；标签由 DSH 根据 Slot 的 id/label 自动投影。 */
+export declare function registerSessionChangedFilesView(ctx: unknown, rpc: CodingNsRpcClient, remote?: unknown): (() => void) | undefined;
+export {};
+//# sourceMappingURL=session-changed-files-view.d.ts.map