@jingyi0605/codingns4dsh 0.1.1 → 0.1.7-rc.2

package/data/build/dist/host/cli-adapters/registry.js

@@ -1,6 +1,7 @@
 import { CodingNsRpcError } from '../rpc-table.js';
 import { CodingNsCliSessionStore } from './session-store.js';
 import { readLegacyImportedAdapterPreferences } from './legacy-session-settings.js';
+import { knownCodexContextWindow } from './model-catalog.js';
 const DEFAULT_INSTALLED_CACHE_TTL_MS = 5 * 60_000;
 const DEFAULT_UNINSTALLED_CACHE_TTL_MS = 30_000;
 const DEFAULT_MODEL_CACHE_TTL_MS = 10 * 60_000;
@@ -29,7 +30,12 @@ export class CodingNsCliAdapterRegistry {
     modelTimers = new Map();
     modelGenerations = new Map();
     requestedModelCatalogs = new Set();
-    /** 已切到下一个 DSH step、但仍在继续产出 Provider 流的驱动迭代器。 */
+    /**
+     * 已切到下一个 DSH step、但仍在继续产出 Provider 流的运行。
+     *
+     * 通用切分由 Registry 持有活迭代器；驱动自行分段的适配器（Codex、Command Code）
+     * 把进程和段状态留在驱动内，这里只登记续段意图，用 null 迭代器区分两者。
+     */
     segmentedTurns = new Map();
     cacheGeneration = 0;
     disposed = false;
@@ -264,6 +270,11 @@ export class CodingNsCliAdapterRegistry {
             }
             const suspended = this.segmentedTurns.get(input.sessionId);
             const resumingSegmentedTurn = suspended?.adapterId === input.adapterId;
+            // 驱动自行分段时，续段必须由 Host 显式声明；驱动不能靠猜输入形状决定是否
+            // 复用旧进程，否则注入失败后的新用户消息会被拼进上一次运行。
+            const resumingDriverTurn = resumingSegmentedTurn && suspended !== undefined && suspended.iterator === null;
+            if (resumingDriverTurn)
+                this.segmentedTurns.delete(input.sessionId);
             this.sessions.set(input.sessionId, current);
             this.sessionStore?.upsert(input.sessionId, {
                 ...current,
@@ -281,19 +292,32 @@ export class CodingNsCliAdapterRegistry {
             // 每轮都写入稳定的适配器身份。旧日志只有通用 codingns-external 标记，
             // 这条 request/context 是升级后自动迁移时唯一可靠的回填依据。
             try {
+                const contextWindow = input.adapterId === 'codex' ? knownCodexContextWindow(input.modelId) : undefined;
                 this.nativeSessions?.appendRequestContext?.(input.sessionId, {
                     provider: input.adapterId,
                     model: input.modelId ?? input.adapterId,
+                    ...(contextWindow === undefined ? {} : { contextWindow, confirmed: true, source: 'catalog' }),
                 });
             }
             catch { /* 原生历史写入失败不应阻断外部 Agent */ }
             if (suspended !== undefined && suspended.adapterId !== input.adapterId) {
                 this.segmentedTurns.delete(input.sessionId);
-                await closeAgentIterator(suspended.iterator);
+                if (suspended.iterator !== null)
+                    await closeAgentIterator(suspended.iterator);
+                try {
+                    this.drivers.get(suspended.adapterId)?.discardSegmentedTurn?.(input.sessionId);
+                }
+                catch { /* 切换适配器不能被旧驱动清理失败阻断 */ }
+            }
+            // 通用切分要在复用时立刻撤销登记，否则耗尽后的旧迭代器会被下一条用户消息再次消费。
+            let iterator;
+            if (resumingSegmentedTurn && suspended !== undefined && suspended.iterator !== null) {
+                this.segmentedTurns.delete(input.sessionId);
+                iterator = suspended.iterator;
+            }
+            else {
+                iterator = driver.executeTurn({ ...input, ...(resumingDriverTurn ? { resumeSegmentedTurn: true } : {}) })[Symbol.asyncIterator]();
             }
-            const iterator = suspended?.adapterId === input.adapterId
-                ? (this.segmentedTurns.delete(input.sessionId), suspended.iterator)
-                : driver.executeTurn(input)[Symbol.asyncIterator]();
             while (true) {
                 const next = await iterator.next();
                 if (next.done)
@@ -328,6 +352,10 @@ export class CodingNsCliAdapterRegistry {
                 // 直接交给 Feature，不能再次按工具完成事件切一遍。
                 if (event.type === 'step-boundary') {
                     await closeAgentIterator(iterator);
+                    // 驱动自己持有 Provider 进程与段状态：这里只登记续段意图，下一次
+                    // llm/stream 再显式要求驱动恢复；注入失败时 discardSegmentedTurn
+                    // 会同时丢弃 Registry 意图和驱动内的进程。
+                    this.segmentedTurns.set(input.sessionId, { adapterId: input.adapterId, iterator: null });
                     yield event;
                     return;
                 }
@@ -433,7 +461,13 @@ export class CodingNsCliAdapterRegistry {
         if (suspended === undefined)
             return;
         this.segmentedTurns.delete(sessionId);
-        void closeAgentIterator(suspended.iterator);
+        if (suspended.iterator !== null)
+            void closeAgentIterator(suspended.iterator);
+        // 驱动自行分段时进程留在驱动内，必须显式通知它结束悬挂的 Provider 运行。
+        try {
+            this.drivers.get(suspended.adapterId)?.discardSegmentedTurn?.(sessionId);
+        }
+        catch { /* 取消流程不能被清理失败阻断 */ }
     }
     async dispose() {
         if (this.disposed)
@@ -447,7 +481,7 @@ export class CodingNsCliAdapterRegistry {
         this.modelFailures.clear();
         this.modelGenerations.clear();
         this.requestedModelCatalogs.clear();
-        await Promise.all([...this.segmentedTurns.values()].map(({ iterator }) => closeAgentIterator(iterator)));
+        await Promise.all([...this.segmentedTurns.values()].map(({ iterator }) => iterator === null ? Promise.resolve() : closeAgentIterator(iterator)));
         this.segmentedTurns.clear();
         await Promise.all([...this.drivers.values()].map((driver) => driver.dispose?.()));
     }

package/data/build/dist/host/cli-adapters/rpc-driver-utils.js

@@ -1,19 +1,38 @@
 import { spawnSync } from 'node:child_process';
 import { JsonRpcProcess } from './json-rpc-process.js';
-import { WINDOWS } from './process-utils.js';
+import { commandEnvironment, resolveCommandPath, WINDOWS } from './process-utils.js';
 export async function detectBinary(options) {
     const run = options.spawnSync ?? spawnSync;
+    let lookupAfterDetectionFailure = false;
     for (const command of options.binaries) {
+        const direct = detectCommand(command);
+        if (direct !== null)
+            return direct;
+        if (!lookupAfterDetectionFailure)
+            continue;
+        const resolved = resolveCommandPath(command, run);
+        if (resolved === null)
+            continue;
+        const fallback = detectCommand(resolved);
+        if (fallback !== null)
+            return fallback;
+    }
+    return { installed: false, version: null, command: null };
+    function detectCommand(command) {
+        lookupAfterDetectionFailure = false;
         try {
-            const result = run(command, ['--version'], { encoding: 'utf8', timeout: 3_000, windowsHide: true, shell: WINDOWS });
+            const result = run(command, ['--version'], { encoding: 'utf8', timeout: 3_000, windowsHide: true, shell: WINDOWS, env: commandEnvironment(command) });
             const output = `${result.stdout ?? ''}${result.stderr ?? ''}`;
             const version = output.match(/\d+\.\d+(?:\.\d+)?/u)?.[0] ?? null;
             if (result.status === 0 && version !== null)
                 return { installed: true, version, command };
+            lookupAfterDetectionFailure = result.status === null;
+        }
+        catch {
+            lookupAfterDetectionFailure = true; /* PATH 中没有该命令 */
         }
-        catch { /* PATH 中没有该命令 */ }
+        return null;
     }
-    return { installed: false, version: null, command: null };
 }
 /** 把一个 JSON-RPC 请求期间收到的通知排成异步流，同时等待最终响应。 */
 export async function* streamRpcRequest(process, method, params, signal, options = {}) {

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

@@ -25,6 +25,7 @@ export declare abstract class StandardStreamDriver implements CodingNsCliDriver
     private readonly versionArgs;
     private readonly modelArgs;
     private cachedBinary;
+    private cachedEnvironment;
     private readonly processes;
     protected constructor(descriptor: Omit<CodingNsCliAdapterDescriptor, 'installed' | 'enabled' | 'version' | 'command'>, defaults: {
         binaries: readonly string[];
@@ -36,6 +37,8 @@ export declare abstract class StandardStreamDriver implements CodingNsCliDriver
         version: string | null;
         command: string | null;
     }>;
+    private lookupAfterDetectionFailure;
+    private detectCommand;
     listModels(): Promise<CodingNsCliModelCatalog>;
     executeTurn(input: CodingNsCliTurnInput): AsyncIterable<CodingNsAgentEvent>;
     dispose(): void;

package/data/build/dist/host/cli-adapters/standard-stream-driver.js

@@ -2,7 +2,7 @@ import { spawn, spawnSync } from 'node:child_process';
 import readline from 'node:readline';
 import { firstToolText, isToolRecord, normalizeToolStatus, serializeToolValue } from './tool-observation.js';
 import { usageChunk } from './rpc-driver-utils.js';
-import { terminateChildProcess } from './process-utils.js';
+import { commandEnvironment, resolveCommandPath, terminateChildProcess } from './process-utils.js';
 const WINDOWS = process.platform === 'win32';
 /**
  * 把采用 JSONL/stream-json 的 CLI 统一成 Codingns4DSH 的最小驱动契约。
@@ -16,6 +16,7 @@ export class StandardStreamDriver {
     versionArgs;
     modelArgs;
     cachedBinary = null;
+    cachedEnvironment;
     processes = new Set();
     constructor(descriptor, defaults, options = {}) {
         this.descriptor = descriptor;
@@ -27,27 +28,46 @@ export class StandardStreamDriver {
     }
     async detect() {
         for (const command of this.binaries) {
-            try {
-                const result = this.runSpawnSync(command, this.versionArgs, { encoding: 'utf8', timeout: 5_000, windowsHide: true, shell: WINDOWS });
-                const output = `${result.stdout ?? ''}\n${result.stderr ?? ''}`;
-                const version = this.parseVersion(output);
-                if (result.status === 0 && version !== null) {
-                    this.cachedBinary = command;
-                    return { installed: true, version, command };
-                }
-            }
-            catch {
-                // 候选命令不存在时继续尝试下一个名称。
-            }
+            const direct = await this.detectCommand(command);
+            if (direct !== null)
+                return direct;
+            if (!this.lookupAfterDetectionFailure)
+                continue;
+            const resolved = resolveCommandPath(command, this.runSpawnSync);
+            if (resolved === null)
+                continue;
+            const fallback = await this.detectCommand(resolved, commandEnvironment(resolved));
+            if (fallback !== null)
+                return fallback;
         }
         return { installed: false, version: null, command: null };
     }
+    lookupAfterDetectionFailure = false;
+    async detectCommand(command, env) {
+        this.lookupAfterDetectionFailure = false;
+        try {
+            const result = this.runSpawnSync(command, this.versionArgs, { encoding: 'utf8', timeout: 5_000, windowsHide: true, shell: WINDOWS, ...(env === undefined ? {} : { env }) });
+            const output = `${result.stdout ?? ''}\n${result.stderr ?? ''}`;
+            const version = this.parseVersion(output);
+            if (result.status === 0 && version !== null) {
+                this.cachedBinary = command;
+                this.cachedEnvironment = env ?? commandEnvironment(command);
+                return { installed: true, version, command };
+            }
+            this.lookupAfterDetectionFailure = result.status === null;
+        }
+        catch {
+            // 候选命令不存在时继续尝试下一个名称。
+            this.lookupAfterDetectionFailure = true;
+        }
+        return null;
+    }
     async listModels() {
         const command = this.cachedBinary ?? (await this.detect()).command;
         if (command === null)
             return emptyCatalog();
         try {
-            const result = this.runSpawnSync(command, this.modelArgs, { encoding: 'utf8', timeout: 12_000, windowsHide: true, shell: WINDOWS });
+            const result = this.runSpawnSync(command, this.modelArgs, { encoding: 'utf8', timeout: 12_000, windowsHide: true, shell: WINDOWS, ...(this.cachedEnvironment === undefined ? {} : { env: this.cachedEnvironment }) });
             if (result.status !== 0)
                 return emptyCatalog();
             return this.parseModels(`${result.stdout ?? ''}\n${result.stderr ?? ''}`);
@@ -61,7 +81,7 @@ export class StandardStreamDriver {
         if (command === null)
             throw new Error(`${this.descriptor.name} 未安装`);
         const child = this.runSpawn(command, this.buildArgs(input), {
-            cwd: input.cwd ?? process.cwd(), env: { ...process.env }, stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true, shell: WINDOWS,
+            cwd: input.cwd ?? process.cwd(), env: this.cachedEnvironment ?? { ...process.env }, stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true, shell: WINDOWS,
         });
         this.processes.add(child);
         let emittedFinish = false;
@@ -119,6 +139,7 @@ export class StandardStreamDriver {
             terminateChildProcess(child);
         this.processes.clear();
         this.cachedBinary = null;
+        this.cachedEnvironment = undefined;
     }
     parseVersion(output) { return output.match(/\b\d+\.\d+(?:\.\d+)?(?:[-+][0-9A-Za-z.-]+)?\b/u)?.[0] ?? null; }
     parseEvent(value, input) {

package/data/build/dist/host/dsh-device-runtime.d.ts

@@ -20,6 +20,8 @@ export interface DshHostDeviceRuntimeOptions {
     readonly dshVersion?: string;
     /** 覆盖自动获取的计算机名，主要用于测试和受控运行环境。 */
     readonly computerName?: string;
+    /** 当前 DSH 配置文件名称，用于在远端 Host 列表中区分同机实例。 */
+    readonly profileName?: string;
     readonly capabilities?: readonly string[];
     readonly resources?: Pick<FeatureResourceScope, 'add'>;
     readonly signalingSocketFactory?: Parameters<typeof startHostRelayRuntime>[0]['signalingSocketFactory'];

package/data/build/dist/host/dsh-device-runtime.js

@@ -21,14 +21,13 @@ export async function startDshHostDeviceRuntime(options) {
     const dtlsStore = options.dtlsStore ?? new FileHostDtlsIdentityStore(defaultDtlsPath());
     const identity = await ensureHostDtlsIdentity(dtlsStore);
     const dshVersion = options.dshVersion?.trim() || DSH_VERSION;
+    const reportedDshVersion = formatDshVersion(dshVersion, options.profileName ?? process.env.CODINGNS4DSH_PROFILE_NAME);
     const computerName = options.computerName?.trim() || hostname().trim() || 'unknown';
-    const heartbeatDetails = { dshVersion, computerName };
-    let credential = await credentialStore.read();
-    let device;
-    if (credential === null || credential.dtlsFingerprint !== identity.fingerprint) {
+    const heartbeatDetails = { dshVersion: reportedDshVersion, computerName, dtlsFingerprint: identity.fingerprint };
+    const registerDevice = async (previous) => {
         const request = {
-            displayName: options.displayName?.trim() || 'DSH Host',
-            dshVersion,
+            displayName: options.displayName?.trim() || previous?.displayName || 'DSH Host',
+            dshVersion: reportedDshVersion,
             computerName,
             devicePublicKey: identity.certPem,
             dtlsFingerprint: identity.fingerprint,
@@ -36,43 +35,56 @@ export async function startDshHostDeviceRuntime(options) {
             capabilities: [...(options.capabilities ?? ['rpc', 'pty', 'file', 'web'])],
         };
         const registered = await withAccessToken((accessToken) => options.controlClient.registerDshDevice(accessToken, request));
-        credential = {
+        const nextCredential = {
             deviceId: registered.device.dshDeviceId ?? registered.device.deviceId ?? (() => { throw new Error('DSH 注册响应缺少设备标识'); })(),
             deviceCredential: registered.deviceCredential,
             credentialVersion: registered.credentialVersion,
             dtlsFingerprint: identity.fingerprint,
             tunnelDomain: registered.device.tunnelDomain ?? null,
             displayName: registered.device.displayName,
-            dshVersion: registered.device.dshVersion ?? dshVersion,
+            dshVersion: registered.device.dshVersion ?? reportedDshVersion,
             computerName: registered.device.computerName ?? computerName,
             savedAt: new Date().toISOString(),
         };
-        await credentialStore.write(credential);
+        await credentialStore.write(nextCredential);
+        return { credential: nextCredential, device: registered.device };
+    };
+    let credential = await credentialStore.read();
+    let device;
+    if (credential === null || credential.dtlsFingerprint !== identity.fingerprint) {
+        const registered = await registerDevice(credential);
+        credential = registered.credential;
         device = registered.device;
     }
     else {
         const listed = await withAccessToken((accessToken) => options.controlClient.listDshDevices(accessToken));
-        device = listed.devices.find((candidate) => (candidate.dshDeviceId ?? candidate.deviceId) === credential.deviceId) ?? {
-            dshDeviceId: credential.deviceId,
-            deviceId: credential.deviceId,
-            displayName: credential.displayName,
-            dshVersion: credential.dshVersion ?? dshVersion,
-            computerName: credential.computerName ?? computerName,
-            protocolVersion: options.protocolVersion ?? 'dsh-envelope-v1',
-            capabilities: [...(options.capabilities ?? [])],
-            dtlsFingerprint: credential.dtlsFingerprint,
-            ...(credential.tunnelDomain === null ? {} : { tunnelDomain: credential.tunnelDomain }),
-            status: 'active',
-            online: false,
-            lastHeartbeatAt: null,
-            createdAt: credential.savedAt,
-            updatedAt: credential.savedAt,
-        };
+        const listedDevice = listed.devices.find((candidate) => (candidate.dshDeviceId ?? candidate.deviceId) === credential.deviceId);
+        if (listedDevice) {
+            device = listedDevice;
+        }
+        else {
+            // 控制台删除了服务端记录时，旧凭据已经失去归属，必须重新注册当前 DTLS 身份。
+            const registered = await registerDevice(credential);
+            credential = registered.credential;
+            device = registered.device;
+        }
     }
     if (credential === null)
         throw new Error('DSH 设备凭据初始化失败');
-    const savedCredential = credential;
-    await withAccessToken((accessToken) => options.controlClient.heartbeatDshDevice(accessToken, savedCredential.deviceId, savedCredential.deviceCredential, heartbeatDetails));
+    let savedCredential = credential;
+    try {
+        await withAccessToken((accessToken) => options.controlClient.heartbeatDshDevice(accessToken, savedCredential.deviceId, savedCredential.deviceCredential, heartbeatDetails));
+    }
+    catch (error) {
+        if (!isRecoverableDshDeviceCredentialError(error))
+            throw error;
+        // 设备记录可能在列表检查后、心跳前被删除，此时换发当前 Host 的新凭据。
+        await credentialStore.clear();
+        const registered = await registerDevice(savedCredential);
+        savedCredential = registered.credential;
+        device = registered.device;
+        await withAccessToken((accessToken) => options.controlClient.heartbeatDshDevice(accessToken, savedCredential.deviceId, savedCredential.deviceCredential, heartbeatDetails));
+    }
     const runtimeOptions = {
         controlClient: { createSignalingTicket: async () => { throw new Error('DSH runtime 必须使用 DSH ticket'); } },
         createTicket: ({ identity: material, credentialVersion }) => requestDshTicket(withAccessToken, options.controlClient, savedCredential, material.fingerprint, credentialVersion),
@@ -124,6 +136,20 @@ async function requestDshTicket(withAccessToken, client, credential, fingerprint
         credentialVersion: response.credentialVersion,
     };
 }
-function defaultDshCredentialPath() { return join(homedir(), '.config', 'codingns4dsh', 'device-credential.json'); }
-function defaultDtlsPath() { return join(homedir(), '.config', 'codingns4dsh', 'dtls-identity.json'); }
+function defaultDshCredentialPath() { return join(defaultStateDirectory(), 'device-credential.json'); }
+function defaultDtlsPath() { return join(defaultStateDirectory(), 'dtls-identity.json'); }
+function defaultStateDirectory() {
+    return process.env.CODINGNS4DSH_STATE_DIR?.trim() || join(homedir(), '.config', 'codingns4dsh');
+}
+/** 只装饰远端列表展示值；Transport 握手仍使用原始 DSH 版本。 */
+function formatDshVersion(version, profileName) {
+    const profile = profileName?.trim();
+    return profile ? `${version} (配置: ${profile})` : version;
+}
+function isRecoverableDshDeviceCredentialError(error) {
+    return isRecord(error) && error.status === 404 && error.errorCode === 'DSH_DEVICE_NOT_FOUND';
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
 //# sourceMappingURL=dsh-device-runtime.js.map

package/data/build/dist/host/features/auth.js

@@ -4,6 +4,7 @@ import { CodingNsAuthSession } from '../auth-session.js';
 import { HttpCodingNsControlApiClient } from '../control-api-client.js';
 import { FileCodingNsCredentialStore, FileDshDeviceCredentialStore } from '../credential-store.js';
 import { startDshHostDeviceRuntime } from '../dsh-device-runtime.js';
+import { FileHostDtlsIdentityStore } from '../relay-tunnel-runtime.js';
 import { CodingNsRpcError } from '../rpc-table.js';
 import { createDshRpcGatewayFeature } from '../dsh-gateway-feature.js';
 import { createLocalDshWebRuntimeProvider, createRemoteWebRuntimeFeature } from '../remote-web-runtime.js';
@@ -38,6 +39,7 @@ export function createAuthFeature() {
             const stateDirectory = process.env.CODINGNS4DSH_STATE_DIR?.trim() || join(homedir(), '.config', 'codingns4dsh');
             const credentials = new FileCodingNsCredentialStore(join(stateDirectory, 'codingns-credentials.json'));
             const dshCredentials = new FileDshDeviceCredentialStore(join(stateDirectory, 'device-credential.json'));
+            const dtlsIdentity = new FileHostDtlsIdentityStore(join(stateDirectory, 'dtls-identity.json'));
             const loginProtectionStore = new FileLanAccessDshLoginStore(join(stateDirectory, 'lan-access-login.json'));
             let session = null;
             let sessionBaseUrl = null;
@@ -88,6 +90,7 @@ export function createAuthFeature() {
                             controlClient: target.getControlClient(),
                             accessToken,
                             credentialStore: dshCredentials,
+                            dtlsStore: dtlsIdentity,
                             accessTokenProvider: () => target.getAccessToken(),
                             withAccessToken: (operation) => target.withAccessToken(operation),
                             ...(context.services.dshVersion === undefined ? {} : { dshVersion: context.services.dshVersion }),
@@ -132,9 +135,14 @@ export function createAuthFeature() {
                 bind: (payload) => requireSession().bindHost(parseHostBind(payload)),
                 unbind: (payload) => requireSession().unbindHost(parseStringField(payload, 'bindingId')),
                 signalingTicket: (payload) => requireSession().createClientSignalingTicket(parseOptionalStringField(payload, 'tunnelDomain')),
-                'dsh/device/list': () => {
+                'dsh/device/list': async () => {
                     const target = requireSession();
-                    return target.withAccessToken((accessToken) => target.getControlClient().listDshDevices(accessToken));
+                    return target.withAccessToken(async (accessToken) => {
+                        const listed = await target.getControlClient().listDshDevices(accessToken);
+                        // 即使 Host 当前未启动，也用本地凭据标识当前设备，避免列表回退到账号下另一台 Host。
+                        const currentDeviceId = dshRuntime?.credential.deviceId ?? (await dshCredentials.read())?.deviceId;
+                        return currentDeviceId === undefined ? listed : { ...listed, currentDeviceId };
+                    });
                 },
                 'dsh/device/start': async () => { await startDsh(requireSession()); return dshRuntime?.device ?? null; },
                 'dsh/device/stop': async () => { await dshRuntime?.stop(); dshRuntime = null; return { stopped: true }; },

package/data/build/dist/host/features/file-management.d.ts

@@ -0,0 +1,5 @@
+import type { FeatureModule } from '../../shared/contracts/feature.js';
+import type { CodingNsHostServices } from './types.js';
+/** 文件管理增强的 Host 边界；所有路径先解析到已知工作区，再执行文件操作。 */
+export declare function createFileManagementFeature(): FeatureModule<CodingNsHostServices>;
+//# sourceMappingURL=file-management.d.ts.map