@jingyi0605/codingns4dsh 0.1.2 → 0.1.7-rc.3

package/data/build/dist/dsh-capabilities/routes.js

@@ -18,6 +18,7 @@ export function createDshCapabilityRegistry(dshVersion, runtime, context) {
         add({ id: 'connection-rpc-peer-aware', capability: 'connection.rpc', supportedDsh: rangeModern, runtime, priority: 20, status: 'supported', introducedIn: '0.1.7-rc.2', detect: (ctx) => ctx.connection !== undefined, create: (ctx) => ctx.connection });
         add({ id: 'connection-peer', capability: 'connection.peer', supportedDsh: rangeModern, runtime, priority: 20, status: 'supported', introducedIn: '0.1.7-rc.2', detect: (ctx) => ctx.connection?.peer !== undefined, create: (ctx) => ctx.connection.peer });
         add({ id: 'remote-result', capability: 'typert.remote', supportedDsh: '>=0.1.5-rc.3 <=0.1.7-rc.2', runtime, priority: 10, status: 'supported', introducedIn: '0.1.5-rc.3', detect: (ctx) => ctx.remote !== undefined, create: (ctx) => ctx.remote });
+        addPeerHostHostRoutes(add);
     }
     else {
         add({ id: 'settings-scope', capability: 'settings.store', supportedDsh: rangeLegacy, runtime, priority: 10, status: 'supported', introducedIn: '0.1.5-rc.3', detect: (ctx) => typeof ctx.settingsScope?.bind === 'function', create: (ctx) => ctx.settingsScope });
@@ -28,7 +29,41 @@ export function createDshCapabilityRegistry(dshVersion, runtime, context) {
         add({ id: 'conversation-events', capability: 'conversation.tool-call', supportedDsh: '>=0.1.5-rc.3 <=0.1.7-rc.2', runtime, priority: 10, status: 'supported', introducedIn: '0.1.5-rc.3', detect: (ctx) => ctx.uiConversation !== undefined, create: (ctx) => ctx.uiConversation });
         add({ id: 'sidebar-right', capability: 'sidebar.right', supportedDsh: '>=0.1.5-rc.3 <=0.1.7-rc.2', runtime, priority: 10, status: 'supported', introducedIn: '0.1.5-rc.3', detect: (ctx) => ctx.sidebarRight !== undefined, create: (ctx) => ctx.sidebarRight });
         add({ id: 'remote-result', capability: 'typert.remote', supportedDsh: '>=0.1.5-rc.3 <=0.1.7-rc.2', runtime, priority: 10, status: 'supported', introducedIn: '0.1.5-rc.3', detect: (ctx) => ctx.remote !== undefined, create: (ctx) => ctx.remote });
+        addPeerHostClientRoutes(add);
     }
     return registry;
 }
+/** PeerHost Host 能力只接受显式注入的适配器，避免把普通 DSH 服务误报为已实现。 */
+function addPeerHostHostRoutes(add) {
+    addPeerHostRoute(add, 'peer-host.store', 'peer-host-store', 'peerHostStore');
+    addPeerHostRoute(add, 'peer-host.handshake', 'peer-host-handshake', 'peerHostHandshake');
+    addPeerHostRoute(add, 'peer-host.http-proxy', 'peer-host-http-proxy', 'peerHostHttpProxy');
+    addPeerHostRoute(add, 'peer-host.ws-proxy', 'peer-host-ws-proxy', 'peerHostWsProxy');
+    addPeerHostRoute(add, 'peer-host.aggregate', 'peer-host-aggregate', 'peerHostAggregate');
+    addPeerHostRoute(add, 'peer-host.relay-route', 'peer-host-relay-route', 'peerHostRelayRoute');
+}
+/** PeerHost Client 导航能力由独立 adapter 注入；未注入时由 Feature 诊断降级。 */
+function addPeerHostClientRoutes(add) {
+    addPeerHostRoute(add, 'peer-host.native-navigation', 'peer-host-native-navigation-legacy', 'peerHostNativeNavigation', '>=0.1.5-rc.3 <=0.1.6', 'deprecated');
+    addPeerHostRoute(add, 'peer-host.native-navigation', 'peer-host-native-navigation-modern', 'peerHostNativeNavigation', '>=0.1.7-rc.2 <=0.1.7-rc.2', 'supported', 20);
+    addPeerHostRoute(add, 'peer-host.remote-web-context-fallback', 'peer-host-remote-web-context-fallback', 'peerHostRemoteWebContextFallback');
+}
+function addPeerHostRoute(add, capability, id, field, supportedDsh = '>=0.1.5-rc.3 <=0.1.7-rc.2', status = 'supported', priority = 10) {
+    add({
+        id,
+        capability,
+        supportedDsh,
+        runtime: capability === 'peer-host.native-navigation' || capability === 'peer-host.remote-web-context-fallback' ? 'client' : 'host',
+        priority,
+        status,
+        introducedIn: '0.1.5-rc.3',
+        detect: (context) => readPeerHostAdapter(context, field) !== undefined,
+        create: (context) => readPeerHostAdapter(context, field),
+    });
+}
+function readPeerHostAdapter(context, field) {
+    if (typeof context !== 'object' || context === null || Array.isArray(context))
+        return undefined;
+    return context[field];
+}
 //# sourceMappingURL=routes.js.map

package/data/build/dist/dsh-capabilities/settings-store.d.ts

@@ -26,4 +26,16 @@ export interface CodingNsSettingsStore<T> {
 }
 /** 将 DSH 两代写入结果统一成内部成功布尔值。 */
 export declare function accepted(write: Promise<void | boolean>): Promise<boolean>;
+/**
+ * 判断两份设置快照在内容上是否等价。
+ *
+ * DSH 的 ConfigForm、SettingsScope 和插件自己的 Host RPC 都会在每次读取时
+ * 构造新对象。`useSyncExternalStore` 要求 `getSnapshot()` 在内容未变化时返回
+ * 同一个引用，否则 React 会在每次渲染后重新比对快照并强制再次渲染，直到抛出
+ * “Maximum update depth exceeded”（React #185）。所有适配器都必须先比较内容、
+ * 再决定是否替换快照并唤醒订阅者。
+ */
+export declare function sameSettingsSnapshot<T>(left: CodingNsSettingsSnapshot<T>, right: CodingNsSettingsSnapshot<T>): boolean;
+/** 设置内容的结构比较：数组按顺序、对象按键，标量按 Object.is。 */
+export declare function sameSettingsValue(left: unknown, right: unknown): boolean;
 //# sourceMappingURL=settings-store.d.ts.map

package/data/build/dist/dsh-capabilities/settings-store.js

@@ -2,4 +2,38 @@
 export function accepted(write) {
     return write.then((result) => result !== false);
 }
+/**
+ * 判断两份设置快照在内容上是否等价。
+ *
+ * DSH 的 ConfigForm、SettingsScope 和插件自己的 Host RPC 都会在每次读取时
+ * 构造新对象。`useSyncExternalStore` 要求 `getSnapshot()` 在内容未变化时返回
+ * 同一个引用，否则 React 会在每次渲染后重新比对快照并强制再次渲染，直到抛出
+ * “Maximum update depth exceeded”（React #185）。所有适配器都必须先比较内容、
+ * 再决定是否替换快照并唤醒订阅者。
+ */
+export function sameSettingsSnapshot(left, right) {
+    return sameSettingsValue(left.value, right.value)
+        && left.revision === right.revision
+        && left.writable === right.writable
+        && left.status === right.status;
+}
+/** 设置内容的结构比较：数组按顺序、对象按键，标量按 Object.is。 */
+export function sameSettingsValue(left, right) {
+    if (Object.is(left, right))
+        return true;
+    if (left === null || right === null || typeof left !== 'object' || typeof right !== 'object')
+        return false;
+    if (Array.isArray(left) || Array.isArray(right)) {
+        if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length)
+            return false;
+        return left.every((value, index) => sameSettingsValue(value, right[index]));
+    }
+    const leftRecord = left;
+    const rightRecord = right;
+    const leftKeys = Object.keys(leftRecord);
+    const rightKeys = Object.keys(rightRecord);
+    if (leftKeys.length !== rightKeys.length)
+        return false;
+    return leftKeys.every((key) => Object.prototype.hasOwnProperty.call(rightRecord, key) && sameSettingsValue(leftRecord[key], rightRecord[key]));
+}
 //# sourceMappingURL=settings-store.js.map

package/data/build/dist/dsh-capabilities/types.d.ts

@@ -1,5 +1,5 @@
 /** DSH 宿主能力的稳定标识。业务模块只依赖这些标识，不直接依赖 DSH 版本。 */
-export type DshCapabilityId = 'settings.store' | 'connection.rpc' | 'connection.peer' | 'ui.icon.plus' | 'ui.icon.chevron' | 'locale.runtime' | 'theme.runtime' | 'conversation.tool-call' | 'sidebar.right' | 'typert.remote';
+export type DshCapabilityId = 'settings.store' | 'connection.rpc' | 'connection.peer' | 'ui.icon.plus' | 'ui.icon.chevron' | 'locale.runtime' | 'theme.runtime' | 'conversation.tool-call' | 'sidebar.right' | 'typert.remote' | 'peer-host.store' | 'peer-host.handshake' | 'peer-host.http-proxy' | 'peer-host.ws-proxy' | 'peer-host.aggregate' | 'peer-host.relay-route' | 'peer-host.native-navigation' | 'peer-host.remote-web-context-fallback';
 export type DshCapabilityRuntime = 'host' | 'client';
 export type DshCapabilityRouteStatus = 'supported' | 'deprecated';
 export type DshCapabilityResolutionStatus = 'ready' | 'degraded' | 'unavailable';

package/data/build/dist/features/host-router.d.ts

@@ -0,0 +1,26 @@
+import { type ResourceScopeDisposer } from '../shared/contracts/peer-host.js';
+import type { HostScope } from '../shared/contracts/peer-host.js';
+export type HostRouterInput = Omit<HostScope, 'scopeGeneration'>;
+/** 统一管理当前 Host/PeerHost 的完整作用域和 generation。 */
+export declare class HostRouter {
+    private current;
+    private generation;
+    private disposers;
+    private transition;
+    getCurrent(): HostScope | null;
+    switchTo(input: HostRouterInput, disposer?: ResourceScopeDisposer): Promise<HostScope>;
+    /**
+     * 重连成功后强制创建新的 generation，即使逻辑 HostScope 没有变化。
+     * 旧作用域的所有 disposer 会先执行，调用方必须用返回值重建订阅。
+     */
+    rebuild(input: HostRouterInput, disposer?: ResourceScopeDisposer): Promise<HostScope>;
+    private transitionTo;
+    addDisposer(disposer: ResourceScopeDisposer): () => void;
+    registerAbortController(scope: HostScope, controller: AbortController): () => void;
+    isCurrent(scope: HostScope | null | undefined): boolean;
+    assertCurrent(scope: HostScope): void;
+    commitIfCurrent<T>(scope: HostScope, write: () => T): T;
+    key(scope: HostScope, resource: string, resourceId?: string): string;
+    clear(): Promise<void>;
+}
+//# sourceMappingURL=host-router.d.ts.map

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

@@ -0,0 +1,110 @@
+import { ResourceScopeStaleError } from '../shared/contracts/peer-host.js';
+/** 统一管理当前 Host/PeerHost 的完整作用域和 generation。 */
+export class HostRouter {
+    current = null;
+    generation = 0;
+    disposers = [];
+    transition = Promise.resolve();
+    getCurrent() { return this.current; }
+    async switchTo(input, disposer) {
+        return this.transitionTo(input, disposer, false);
+    }
+    /**
+     * 重连成功后强制创建新的 generation，即使逻辑 HostScope 没有变化。
+     * 旧作用域的所有 disposer 会先执行，调用方必须用返回值重建订阅。
+     */
+    async rebuild(input, disposer) {
+        return this.transitionTo(input, disposer, true);
+    }
+    async transitionTo(input, disposer, force) {
+        validateInput(input);
+        let result;
+        const operation = this.transition.then(async () => {
+            if (!force && this.current !== null && sameInput(this.current, input)) {
+                if (disposer)
+                    this.addDisposer(disposer);
+                result = this.current;
+                return;
+            }
+            const previous = this.current;
+            this.current = null;
+            const errors = await disposeAll(this.disposers);
+            this.disposers = [];
+            const next = Object.freeze({ ...input, scopeGeneration: ++this.generation });
+            this.current = next;
+            if (disposer)
+                this.addDisposer(disposer);
+            result = next;
+            if (errors.length > 0)
+                throw new AggregateError(errors, 'HostScope 清理失败');
+            void previous;
+        });
+        this.transition = operation.then(() => undefined, () => undefined);
+        return operation.then(() => result);
+    }
+    addDisposer(disposer) {
+        if (this.current === null)
+            throw new ResourceScopeStaleError('No active HostScope');
+        const entry = { dispose: disposer, active: true };
+        this.disposers.push(entry);
+        return () => { entry.active = false; };
+    }
+    registerAbortController(scope, controller) {
+        this.assertCurrent(scope);
+        return this.addDisposer(() => { if (!controller.signal.aborted)
+            controller.abort(new ResourceScopeStaleError()); });
+    }
+    isCurrent(scope) {
+        return scope !== null && scope !== undefined && this.current !== null && sameScope(this.current, scope);
+    }
+    assertCurrent(scope) {
+        if (!this.isCurrent(scope))
+            throw new ResourceScopeStaleError('HostScope 已失效');
+    }
+    commitIfCurrent(scope, write) {
+        this.assertCurrent(scope);
+        return write();
+    }
+    key(scope, resource, resourceId = '') {
+        this.assertCurrent(scope);
+        return [scope.hostId, scope.targetHostId ?? 'current', scope.workspaceId, scope.sessionId ?? 'none', resource, resourceId].map(encodeURIComponent).join(':');
+    }
+    async clear() {
+        const operation = this.transition.then(async () => {
+            this.current = null;
+            const errors = await disposeAll(this.disposers);
+            this.disposers = [];
+            if (errors.length > 0)
+                throw new AggregateError(errors, 'HostScope 清理失败');
+        });
+        this.transition = operation.then(() => undefined, () => undefined);
+        await operation;
+    }
+}
+function validateInput(input) {
+    if (!input || !text(input.hostId) || !text(input.workspaceId) || (input.targetHostId !== null && !text(input.targetHostId)) || (input.sessionId !== null && !text(input.sessionId)))
+        throw new TypeError('HostScope 输入无效');
+}
+function text(value) { return typeof value === 'string' && value.trim() !== ''; }
+function sameInput(scope, input) {
+    return scope.hostId === input.hostId && scope.targetHostId === input.targetHostId && scope.workspaceId === input.workspaceId && scope.sessionId === input.sessionId;
+}
+function sameScope(left, right) {
+    return sameInput(left, right) && left.scopeGeneration === right.scopeGeneration;
+}
+async function disposeAll(entries) {
+    const errors = [];
+    for (const entry of [...entries].reverse()) {
+        if (!entry.active)
+            continue;
+        entry.active = false;
+        try {
+            await entry.dispose();
+        }
+        catch (error) {
+            errors.push(error);
+        }
+    }
+    return errors;
+}
+//# sourceMappingURL=host-router.js.map

package/data/build/dist/features/registry.js

@@ -404,6 +404,9 @@ function validateDescriptor(descriptor) {
     if (typeof descriptor.enabledByDefault !== 'boolean') {
         throw new FeatureRegistryError('FEATURE_INVALID_DESCRIPTOR', `Feature ${descriptor.name} has invalid enabledByDefault`, descriptor.name);
     }
+    if (descriptor.disabled !== undefined && typeof descriptor.disabled !== 'boolean') {
+        throw new FeatureRegistryError('FEATURE_INVALID_DESCRIPTOR', `Feature ${descriptor.name} has invalid disabled`, descriptor.name);
+    }
     if (descriptor.runtime !== 'host' && descriptor.runtime !== 'client' && descriptor.runtime !== 'both') {
         throw new FeatureRegistryError('FEATURE_INVALID_DESCRIPTOR', `Feature ${descriptor.name} has invalid runtime`, descriptor.name);
     }

package/data/build/dist/host/cli-adapters/codex-driver.d.ts

@@ -33,7 +33,7 @@ export declare class CodexAppServerDriver implements CodingNsCliDriver {
     probeSession(input: CodingNsCliSessionProbeInput): Promise<CodingNsCliSessionProbeResult>;
     executeTurn(input: CodingNsCliTurnInput): AsyncIterable<CodingNsAgentEvent>;
     /**
-     * 将一个 Codex turn 按工具完成点切成多个 DSH step。
+     * 将一个 Codex turn 按 assistant item 切成多个 DSH step。
      *
      * DSH 的 step 边界只能由 Agent Loop 提交；这里仅提前结束本次 llm/stream，
      * 保留同一个 Codex turn 的通知队列，下一次 llm/stream 再继续消费它。
@@ -42,10 +42,22 @@ export declare class CodexAppServerDriver implements CodingNsCliDriver {
     private startSegmentedTurn;
     private consumeSegment;
     private closeSegmentedTurn;
+    /** 在下一轮开始前主动压缩，避免把已满的线程直接交给 turn/start。 */
+    private ensureContextCapacity;
+    /** turn/start 遇到上下文超限时压缩一次并重试，兼容关闭自动压缩的 Codex 配置。 */
+    private startTurn;
+    /** thread/compact/start 立即返回，真正完成由 contextCompaction turn 的终态通知表示。 */
+    private compactThread;
+    private waitForCompaction;
     /** 将新输入 steer 到当前 Codex turn。 */
     steer(sessionId: string, prompt: string): Promise<void>;
     /** 中断当前 Codex turn，但保留 app-server 线程。 */
     interrupt(sessionId: string): Promise<void>;
+    /**
+     * 丢弃等待下一个 DSH step 的分段运行（取消、注入失败或切换适配器时）。
+     * 队列关闭后旧回合的通知不会再被投影进下一轮，续段标记同时解除。
+     */
+    discardSegmentedTurn(sessionId: string): void;
     /** 回传原生权限请求；审批值只在 Host 进程中流转。 */
     respondPermission(sessionId: string, response: CodingNsAgentPermissionResponse): void;
     /** 回传 requestUserInput 的结构化回答。 */