@jingyi0605/codingns4dsh 0.1.0

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

@@ -0,0 +1,119 @@
+import { spawnSync } from 'node:child_process';
+import { JsonRpcProcess } from './json-rpc-process.js';
+import { WINDOWS } from './process-utils.js';
+export async function detectBinary(options) {
+    const run = options.spawnSync ?? spawnSync;
+    for (const command of options.binaries) {
+        try {
+            const result = run(command, ['--version'], { encoding: 'utf8', timeout: 3_000, windowsHide: true, shell: WINDOWS });
+            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 };
+        }
+        catch { /* PATH 中没有该命令 */ }
+    }
+    return { installed: false, version: null, command: null };
+}
+/** 把一个 JSON-RPC 请求期间收到的通知排成异步流，同时等待最终响应。 */
+export async function* streamRpcRequest(process, method, params, signal, options = {}) {
+    const queue = [];
+    let wake;
+    let settled = false;
+    let failure;
+    const listener = (message) => {
+        queue.push(message);
+        options.onNotification?.(message);
+        wake?.();
+        wake = undefined;
+    };
+    const removeListener = process.addNotificationListener(listener);
+    const response = process.request(method, params, {
+        ...(signal === undefined ? {} : { signal }),
+        ...(options.killOnAbort === undefined ? {} : { killOnAbort: options.killOnAbort }),
+    }).then((value) => { settled = true; wake?.(); wake = undefined; return value; }, (error) => { failure = error; settled = true; wake?.(); wake = undefined; return undefined; });
+    try {
+        while (!settled || queue.length > 0) {
+            if (queue.length > 0) {
+                yield queue.shift();
+                continue;
+            }
+            await new Promise((resolve) => { wake = resolve; });
+        }
+        if (failure !== undefined)
+            throw failure;
+        return await response;
+    }
+    finally {
+        removeListener();
+        if (options.dispose !== false)
+            process.dispose();
+    }
+}
+export function emptyCatalog() {
+    return { groups: [], currentModel: null, currentEffort: null };
+}
+export function textValue(value) {
+    if (typeof value === 'string')
+        return value;
+    if (!isRecord(value))
+        return null;
+    for (const key of ['text', 'delta', 'content', 'message'])
+        if (typeof value[key] === 'string')
+            return value[key];
+    return null;
+}
+export function usageChunk(value) {
+    if (!isRecord(value))
+        return null;
+    const usage = isRecord(value.usage) ? value.usage : value;
+    const explicitUncachedInputTokens = optionalNumberValue(usage.uncachedInputTokens ?? usage.uncached_input_tokens);
+    const inputTokens = explicitUncachedInputTokens
+        ?? numberValue(usage.inputTokens ?? usage.input_tokens ?? usage.prompt_tokens ?? usage.promptTokenCount);
+    const outputTokens = numberValue(usage.outputTokens ?? usage.output_tokens ?? usage.completion_tokens ?? usage.candidatesTokenCount);
+    const cacheReadInputTokens = optionalNumberValue(usage.cache_read_input_tokens ?? usage.cacheReadInputTokens);
+    const cacheWriteInputTokens = optionalNumberValue(usage.cache_creation_input_tokens ?? usage.cacheCreationInputTokens);
+    const cacheReadTokens = optionalNumberValue(usage.cacheReadTokens
+        ?? usage.cachedReadTokens
+        ?? usage.cache_read_tokens
+        ?? usage.cached_read_tokens
+        ?? usage.cache_read_input_tokens
+        ?? usage.cachedInputTokens
+        ?? usage.cached_input_tokens
+        ?? usage.cachedContentTokenCount
+        ?? cacheReadInputTokens);
+    const cacheWriteTokens = optionalNumberValue(usage.cacheWriteTokens
+        ?? usage.cacheCreationTokens
+        ?? usage.cache_write_tokens
+        ?? usage.cache_creation_tokens
+        ?? usage.cache_write_input_tokens
+        ?? usage.cache_creation_input_tokens
+        ?? cacheWriteInputTokens);
+    if (inputTokens === 0 && outputTokens === 0 && cacheReadTokens === undefined && cacheWriteTokens === undefined)
+        return null;
+    const totalTokens = optionalNumberValue(usage.totalTokens ?? usage.total_tokens ?? usage.totalTokenCount);
+    const hasCacheBreakdown = explicitUncachedInputTokens !== undefined || cacheReadTokens !== undefined || cacheWriteTokens !== undefined;
+    const cachedInputTokens = (cacheReadTokens ?? 0) + (cacheWriteTokens ?? 0);
+    const inputExcludesCache = explicitUncachedInputTokens !== undefined || cacheReadInputTokens !== undefined || cacheWriteInputTokens !== undefined;
+    const fullInputTokens = inputTokens + (inputExcludesCache ? cachedInputTokens : 0);
+    return {
+        type: 'usage',
+        inputTokens,
+        outputTokens,
+        ...(cacheReadTokens === undefined ? {} : { cacheReadTokens }),
+        ...(cacheWriteTokens === undefined ? {} : { cacheWriteTokens }),
+        ...(hasCacheBreakdown ? { uncachedInputTokens: inputExcludesCache ? inputTokens : Math.max(0, inputTokens - cachedInputTokens) } : {}),
+        ...(totalTokens === undefined && !hasCacheBreakdown ? {} : { totalTokens: totalTokens ?? fullInputTokens + outputTokens }),
+        ...(cacheReadTokens === undefined || fullInputTokens <= 0
+            ? {}
+            : { cacheHitRate: Number((cacheReadTokens / fullInputTokens * 100).toFixed(4)) }),
+    };
+}
+export function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function numberValue(value) { return typeof value === 'number' && Number.isFinite(value) ? value : 0; }
+function optionalNumberValue(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? Math.max(0, value) : undefined;
+}
+//# sourceMappingURL=rpc-driver-utils.js.map

package/data/build/dist/host/cli-adapters/session-probe.d.ts

@@ -0,0 +1,20 @@
+import type { Dirent } from 'node:fs';
+import type { CodingNsCliSessionProbeInput, CodingNsCliSessionProbeResult } from './driver.js';
+export interface StoredSessionProbeOptions {
+    readonly roots: readonly string[];
+    readonly matches: (path: string, entry: Dirent, providerSessionId: string) => boolean;
+    readonly validate: (path: string, providerSessionId: string) => Promise<boolean>;
+    readonly maxDepth?: number;
+}
+/**
+ * 在 Provider 的权威存储中只读查找会话。只有精确引用不存在，或成功扫描过
+ * 至少一个权威根目录仍未找到时，才返回 missing。
+ */
+export declare function probeStoredSession(input: CodingNsCliSessionProbeInput, options: StoredSessionProbeOptions): Promise<CodingNsCliSessionProbeResult>;
+/** 读取 JSONL 第一条非空记录，限制读取量，避免为一次探测加载完整历史。 */
+export declare function readFirstJsonRecord(path: string): Promise<Record<string, unknown> | null>;
+/** 将文件或目录引用规整到会话目录，供目录型 Provider 复用。 */
+export declare function resolveSessionDirectory(path: string): Promise<string>;
+/** 仅验证目标是普通文件，不读取历史正文。 */
+export declare function isRegularFile(path: string): Promise<boolean>;
+//# sourceMappingURL=session-probe.d.ts.map

package/data/build/dist/host/cli-adapters/session-probe.js

@@ -0,0 +1,139 @@
+import { open, readdir, stat } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+/**
+ * 在 Provider 的权威存储中只读查找会话。只有精确引用不存在，或成功扫描过
+ * 至少一个权威根目录仍未找到时，才返回 missing。
+ */
+export async function probeStoredSession(input, options) {
+    const providerSessionId = input.providerSessionId?.trim();
+    if (!providerSessionId)
+        return { state: 'unknown', reason: '缺少 Provider 会话标识' };
+    throwIfAborted(input.signal);
+    const rawStoreRef = input.rawStoreRef?.trim();
+    let exactHintFailure;
+    if (rawStoreRef) {
+        const exactResult = await validateCandidate(rawStoreRef, providerSessionId, options.validate, true, input.signal);
+        if (exactResult.state === 'available' || exactResult.state === 'unreachable' || exactResult.state === 'unknown')
+            return exactResult;
+        // rawStoreRef 只是 hint。Provider 可能移动文件，也可能复用旧路径；ENOENT、
+        // 内容不匹配或损坏都必须继续扫描权威 roots，找到后再更新引用。
+        exactHintFailure = exactResult;
+    }
+    let accessibleRoots = 0;
+    const candidates = [];
+    for (const root of options.roots) {
+        try {
+            throwIfAborted(input.signal);
+            const entries = await walk(root, options.maxDepth ?? 6, input.signal);
+            accessibleRoots += 1;
+            for (const entry of entries)
+                if (options.matches(entry.path, entry.entry, providerSessionId))
+                    candidates.push(entry.path);
+        }
+        catch (error) {
+            if (errorCode(error) === 'ENOENT')
+                continue;
+            if (isAccessError(error))
+                return { state: 'unreachable', reason: '无法读取 Provider 会话存储' };
+            return { state: 'unknown', reason: 'Provider 会话存储探测失败' };
+        }
+    }
+    if (candidates.length === 0) {
+        if (exactHintFailure?.state === 'corrupt')
+            return exactHintFailure;
+        return accessibleRoots > 0
+            ? { state: 'missing', reason: 'Provider 会话存储中不存在该会话' }
+            : exactHintFailure ?? { state: 'unknown', reason: 'Provider 会话存储不存在或尚未初始化' };
+    }
+    let sawCorrupt = false;
+    for (const candidate of candidates) {
+        const result = await validateCandidate(candidate, providerSessionId, options.validate, false, input.signal);
+        if (result.state === 'available')
+            return result;
+        if (result.state === 'unreachable' || result.state === 'unknown')
+            return result;
+        if (result.state === 'corrupt')
+            sawCorrupt = true;
+    }
+    return sawCorrupt
+        ? { state: 'corrupt', reason: 'Provider 会话记录无法验证' }
+        : { state: 'missing', reason: 'Provider 会话记录已被删除' };
+}
+/** 读取 JSONL 第一条非空记录，限制读取量，避免为一次探测加载完整历史。 */
+export async function readFirstJsonRecord(path) {
+    const handle = await open(path, 'r');
+    try {
+        const buffer = new Uint8Array(64 * 1024);
+        const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+        const line = new TextDecoder().decode(buffer.subarray(0, bytesRead)).split(/\r?\n/u).find((value) => value.trim() !== '');
+        if (line === undefined)
+            return null;
+        const value = JSON.parse(line);
+        return isRecord(value) ? value : null;
+    }
+    finally {
+        await handle.close();
+    }
+}
+/** 将文件或目录引用规整到会话目录，供目录型 Provider 复用。 */
+export async function resolveSessionDirectory(path) {
+    return (await stat(path)).isDirectory() ? path : dirname(path);
+}
+/** 仅验证目标是普通文件，不读取历史正文。 */
+export async function isRegularFile(path) {
+    return (await stat(path)).isFile();
+}
+async function validateCandidate(path, providerSessionId, validate, exact, signal) {
+    try {
+        throwIfAborted(signal);
+        const valid = await validate(path, providerSessionId);
+        throwIfAborted(signal);
+        return valid
+            ? { state: 'available', reason: 'Provider 原始会话可用', rawStoreRef: path }
+            : { state: 'corrupt', reason: 'Provider 会话记录与绑定标识不一致', rawStoreRef: path };
+    }
+    catch (error) {
+        if (errorCode(error) === 'ENOENT' || errorCode(error) === 'ENOTDIR') {
+            return { state: 'missing', reason: exact ? '绑定的 Provider 会话记录已被删除' : 'Provider 会话记录已被删除' };
+        }
+        if (error instanceof SyntaxError)
+            return { state: 'corrupt', reason: 'Provider 会话记录不是有效 JSON', rawStoreRef: path };
+        if (isAccessError(error))
+            return { state: 'unreachable', reason: '没有权限读取 Provider 会话记录', rawStoreRef: path };
+        return { state: 'unknown', reason: 'Provider 会话记录验证失败', rawStoreRef: path };
+    }
+}
+async function walk(root, maxDepth, signal) {
+    const found = [];
+    const queue = [{ path: root, depth: 0 }];
+    while (queue.length > 0) {
+        throwIfAborted(signal);
+        const current = queue.shift();
+        const entries = await readdir(current.path, { withFileTypes: true });
+        throwIfAborted(signal);
+        for (const entry of entries) {
+            const path = join(current.path, entry.name);
+            found.push({ path, entry });
+            if (entry.isDirectory() && current.depth < maxDepth)
+                queue.push({ path, depth: current.depth + 1 });
+        }
+    }
+    return found;
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted !== true)
+        return;
+    const error = new Error('Provider 会话探测已取消');
+    error.name = 'AbortError';
+    throw error;
+}
+function errorCode(error) {
+    return typeof error === 'object' && error !== null && 'code' in error && typeof error.code === 'string' ? error.code : undefined;
+}
+function isAccessError(error) {
+    return errorCode(error) === 'EACCES' || errorCode(error) === 'EPERM';
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=session-probe.js.map

package/data/build/dist/host/cli-adapters/session-store.d.ts

@@ -0,0 +1,68 @@
+import type { SettingsScope } from '@deepseek-ai/dsh-settings';
+import type { CodingNsCliAdapterId, CodingNsCliSessionConfig, CodingNsCliProviderSessionState, CodingNsCliSessionRecord, CodingNsCliSessionStatus, CodingNsSessionAdapterBinding } from '../../shared/contracts/cli-adapter.js';
+import type { CodingNsSettings } from '../../shared/contracts/config.js';
+/**
+ * 可替换的会话持久化后端。
+ *
+ * 默认实现写入 DSH 的 Codingns4DSH 设置文档；当 DSH 暴露原生 SessionStore
+ * 扩展点后，只需替换这个后端，不需要改 Registry 或驱动。
+ */
+export interface CodingNsCliSessionPersistence {
+    write(records: readonly CodingNsCliSessionRecord[]): Promise<void>;
+}
+export interface CodingNsCliSessionStoreOptions {
+    readonly settings?: SettingsScope<CodingNsSettings>;
+    readonly persistence?: CodingNsCliSessionPersistence;
+}
+export interface CodingNsCliSessionPatch {
+    readonly adapterId?: CodingNsCliAdapterId;
+    readonly modelId?: string;
+    readonly effortId?: string;
+    readonly providerSessionId?: string;
+    readonly rawStoreRef?: string;
+    readonly title?: string;
+    readonly cwd?: string;
+    readonly status?: CodingNsCliSessionStatus;
+    readonly providerState?: CodingNsCliProviderSessionState;
+    readonly providerCheckedAt?: string;
+    readonly providerStateReason?: string;
+    readonly lastError?: string;
+}
+export interface CodingNsCliProviderStatePatch {
+    readonly state: CodingNsCliProviderSessionState;
+    readonly checkedAt: string;
+    readonly reason?: string;
+    readonly rawStoreRef?: string;
+}
+/**
+ * Host-only 的外部 Agent 会话索引。
+ *
+ * 进程句柄、refresh token、原始消息都不进入这里；它只记录下次恢复运行时
+ * 所需的 providerSessionId 和给列表页展示的摘要。写入按顺序排队，避免多轮
+ * 流式事件同时更新设置时发生后写覆盖先写。
+ */
+export declare class CodingNsCliSessionStore {
+    private readonly records;
+    private readonly settings;
+    private readonly persistence;
+    private writeTail;
+    constructor(options?: CodingNsCliSessionStoreOptions);
+    /** 将设置变更重新载入内存；非法或不完整记录会被忽略。 */
+    sync(records: readonly CodingNsCliSessionRecord[] | undefined): void;
+    get(sessionId: string): CodingNsCliSessionRecord | undefined;
+    list(options?: {
+        readonly includeArchived?: boolean;
+        readonly adapterId?: string;
+    }): CodingNsCliSessionRecord[];
+    /** 浏览器会话行只需要这两个字段，Host-only 恢复信息不得跨过 RPC 边界。 */
+    adapterBindings(): CodingNsSessionAdapterBinding[];
+    /** 创建或更新记录；返回值是内存中的规范化记录，持久化在后台串行完成。 */
+    upsert(sessionId: string, patch: CodingNsCliSessionPatch & CodingNsCliSessionConfig): CodingNsCliSessionRecord;
+    archive(sessionId: string): CodingNsCliSessionRecord | undefined;
+    /** 更新 Provider 存在性，不改变会话活动时间，避免后台检查扰乱侧栏排序。 */
+    updateProviderState(sessionId: string, patch: CodingNsCliProviderStatePatch): CodingNsCliSessionRecord | undefined;
+    flush(): Promise<void>;
+    private hydrateRecord;
+    private schedulePersist;
+}
+//# sourceMappingURL=session-store.d.ts.map

package/data/build/dist/host/cli-adapters/session-store.js

@@ -0,0 +1,180 @@
+/**
+ * Host-only 的外部 Agent 会话索引。
+ *
+ * 进程句柄、refresh token、原始消息都不进入这里；它只记录下次恢复运行时
+ * 所需的 providerSessionId 和给列表页展示的摘要。写入按顺序排队，避免多轮
+ * 流式事件同时更新设置时发生后写覆盖先写。
+ */
+export class CodingNsCliSessionStore {
+    records = new Map();
+    settings;
+    persistence;
+    writeTail = Promise.resolve();
+    constructor(options = {}) {
+        this.settings = options.settings;
+        this.persistence = options.persistence;
+        for (const record of options.settings?.get().cliSessions ?? [])
+            this.hydrateRecord(record, true);
+    }
+    /** 将设置变更重新载入内存；非法或不完整记录会被忽略。 */
+    sync(records) {
+        if (records === undefined)
+            return;
+        this.records.clear();
+        for (const record of records)
+            this.hydrateRecord(record, false);
+    }
+    get(sessionId) {
+        return this.records.get(sessionId);
+    }
+    list(options = {}) {
+        return [...this.records.values()]
+            .filter((record) => options.includeArchived === true || record.status !== 'archived')
+            .filter((record) => options.adapterId === undefined || record.adapterId === options.adapterId)
+            .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt))
+            .map((record) => ({ ...record }));
+    }
+    /** 浏览器会话行只需要这两个字段，Host-only 恢复信息不得跨过 RPC 边界。 */
+    adapterBindings() {
+        return this.list().map((record) => ({
+            sessionId: record.dshSessionId,
+            adapterId: record.adapterId,
+        }));
+    }
+    /** 创建或更新记录；返回值是内存中的规范化记录，持久化在后台串行完成。 */
+    upsert(sessionId, patch) {
+        const now = new Date().toISOString();
+        const previous = this.records.get(sessionId);
+        const adapterId = patch.adapterId ?? previous?.adapterId ?? 'dsh';
+        const sameAdapter = previous?.adapterId === adapterId;
+        const base = sameAdapter ? previous : undefined;
+        const providerSessionId = patch.providerSessionId?.trim();
+        // providerSessionId 是 Provider 绑定的身份。即使适配器没变，身份一旦改变，
+        // 旧路径和旧探测结果也不能继承，否则会拿旧会话的状态判断新会话。
+        const providerIdentityChanged = providerSessionId !== undefined
+            && providerSessionId !== base?.providerSessionId;
+        const providerBase = providerIdentityChanged ? undefined : base;
+        const record = {
+            dshSessionId: sessionId,
+            adapterId,
+            ...(patch.modelId?.trim() ? { modelId: patch.modelId.trim() } : base?.modelId ? { modelId: base.modelId } : {}),
+            ...(patch.effortId?.trim() ? { effortId: patch.effortId.trim() } : base?.effortId ? { effortId: base.effortId } : {}),
+            ...(providerSessionId ? { providerSessionId } : base?.providerSessionId ? { providerSessionId: base.providerSessionId } : {}),
+            ...(patch.rawStoreRef?.trim() ? { rawStoreRef: patch.rawStoreRef.trim() } : providerBase?.rawStoreRef ? { rawStoreRef: providerBase.rawStoreRef } : {}),
+            ...(patch.title?.trim() ? { title: patch.title.trim() } : base?.title ? { title: base.title } : {}),
+            ...(patch.cwd?.trim() ? { cwd: patch.cwd.trim() } : base?.cwd ? { cwd: base.cwd } : {}),
+            ...(patch.lastError?.trim() ? { lastError: patch.lastError.trim() } : {}),
+            // archived 是侧栏 tombstone。延迟到达的 turn/end 或驱动 finish 不能把它
+            // 重新写回 idle；恢复必须走未来显式的 unarchive 链路。
+            status: base?.status === 'archived' ? 'archived' : patch.status ?? base?.status ?? 'idle',
+            ...(patch.providerState !== undefined
+                ? { providerState: patch.providerState }
+                : providerBase?.providerState !== undefined
+                    ? { providerState: providerBase.providerState }
+                    : {}),
+            ...(patch.providerCheckedAt?.trim()
+                ? { providerCheckedAt: patch.providerCheckedAt.trim() }
+                : patch.providerState === undefined && providerBase?.providerCheckedAt
+                    ? { providerCheckedAt: providerBase.providerCheckedAt }
+                    : {}),
+            ...(patch.providerStateReason?.trim()
+                ? { providerStateReason: patch.providerStateReason.trim() }
+                : patch.providerState === undefined && providerBase?.providerStateReason
+                    ? { providerStateReason: providerBase.providerStateReason }
+                    : {}),
+            createdAt: base?.createdAt ?? now,
+            updatedAt: now,
+        };
+        this.records.set(sessionId, record);
+        this.schedulePersist();
+        return { ...record };
+    }
+    archive(sessionId) {
+        const previous = this.records.get(sessionId);
+        if (previous === undefined)
+            return undefined;
+        const record = { ...previous, status: 'archived', updatedAt: new Date().toISOString() };
+        this.records.set(sessionId, record);
+        this.schedulePersist();
+        return { ...record };
+    }
+    /** 更新 Provider 存在性，不改变会话活动时间，避免后台检查扰乱侧栏排序。 */
+    updateProviderState(sessionId, patch) {
+        const previous = this.records.get(sessionId);
+        if (previous === undefined)
+            return undefined;
+        const { providerStateReason: _previousReason, ...base } = previous;
+        const record = {
+            ...base,
+            providerState: patch.state,
+            providerCheckedAt: patch.checkedAt,
+            ...(patch.reason?.trim() ? { providerStateReason: patch.reason.trim() } : {}),
+            ...(patch.rawStoreRef?.trim() ? { rawStoreRef: patch.rawStoreRef.trim() } : {}),
+        };
+        this.records.set(sessionId, record);
+        this.schedulePersist();
+        return { ...record };
+    }
+    async flush() {
+        await this.writeTail;
+    }
+    hydrateRecord(value, resetActive) {
+        if (!isRecord(value))
+            return;
+        if (typeof value.dshSessionId !== 'string' || value.dshSessionId.trim() === '')
+            return;
+        if (typeof value.adapterId !== 'string' || value.adapterId.trim() === '')
+            return;
+        if (!isStatus(value.status) || typeof value.createdAt !== 'string' || typeof value.updatedAt !== 'string')
+            return;
+        this.records.set(value.dshSessionId, {
+            dshSessionId: value.dshSessionId,
+            adapterId: value.adapterId,
+            ...(stringValue(value.modelId) ? { modelId: stringValue(value.modelId) } : {}),
+            ...(stringValue(value.effortId) ? { effortId: stringValue(value.effortId) } : {}),
+            ...(stringValue(value.providerSessionId) ? { providerSessionId: stringValue(value.providerSessionId) } : {}),
+            ...(stringValue(value.rawStoreRef) ? { rawStoreRef: stringValue(value.rawStoreRef) } : {}),
+            ...(stringValue(value.title) ? { title: stringValue(value.title) } : {}),
+            ...(stringValue(value.cwd) ? { cwd: stringValue(value.cwd) } : {}),
+            ...(stringValue(value.lastError) ? { lastError: stringValue(value.lastError) } : {}),
+            // active 只描述当前 Host 进程中的执行。进程重启后没有仍在运行的 Turn，
+            // 必须回到 idle，否则列表刷新会永久跳过该记录的存活探测。
+            status: resetActive && value.status === 'active' ? 'idle' : value.status,
+            ...(isProviderState(value.providerState) ? { providerState: value.providerState } : {}),
+            ...(stringValue(value.providerCheckedAt) ? { providerCheckedAt: stringValue(value.providerCheckedAt) } : {}),
+            ...(stringValue(value.providerStateReason) ? { providerStateReason: stringValue(value.providerStateReason) } : {}),
+            createdAt: value.createdAt,
+            updatedAt: value.updatedAt,
+        });
+    }
+    schedulePersist() {
+        const snapshot = this.list({ includeArchived: true });
+        this.writeTail = this.writeTail
+            .catch(() => undefined)
+            .then(async () => {
+            if (this.persistence !== undefined)
+                await this.persistence.write(snapshot);
+            if (this.settings !== undefined)
+                await this.settings.update({ cliSessions: snapshot });
+        });
+    }
+}
+function isStatus(value) {
+    return value === 'active' || value === 'idle' || value === 'error' || value === 'archived';
+}
+function isProviderState(value) {
+    return value === 'unchecked'
+        || value === 'available'
+        || value === 'missing'
+        || value === 'corrupt'
+        || value === 'unreachable'
+        || value === 'unknown'
+        || value === 'ephemeral';
+}
+function stringValue(value) {
+    return typeof value === 'string' && value.trim() !== '' ? value : undefined;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=session-store.js.map

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

@@ -0,0 +1,45 @@
+import { spawn, spawnSync } from 'node:child_process';
+import type { CodingNsCliAdapterDescriptor, CodingNsCliModelCatalog, CodingNsAgentEvent, CodingNsCliTurnInput } from '../../shared/contracts/cli-adapter.js';
+import type { CodingNsCliDriver } from './driver.js';
+export interface StandardStreamDriverOptions {
+    readonly binaries?: readonly string[];
+    /** 仅供会话存在性探测使用；测试和自定义安装可覆盖默认存储根目录。 */
+    readonly sessionRoots?: readonly string[];
+    readonly spawnSync?: typeof spawnSync;
+    readonly spawn?: typeof spawn;
+    readonly versionArgs?: readonly string[];
+    readonly modelArgs?: readonly string[];
+}
+/**
+ * 把采用 JSONL/stream-json 的 CLI 统一成 Codingns4DSH 的最小驱动契约。
+ * 子类只需提供命令参数和事件映射，进程终止、stderr 消费及清理由这里统一处理。
+ */
+export declare abstract class StandardStreamDriver implements CodingNsCliDriver {
+    readonly descriptor: Omit<CodingNsCliAdapterDescriptor, 'installed' | 'enabled' | 'version' | 'command'>;
+    protected readonly binaries: readonly string[];
+    protected readonly runSpawnSync: typeof spawnSync;
+    protected readonly runSpawn: typeof spawn;
+    private readonly versionArgs;
+    private readonly modelArgs;
+    private cachedBinary;
+    private readonly processes;
+    protected constructor(descriptor: Omit<CodingNsCliAdapterDescriptor, 'installed' | 'enabled' | 'version' | 'command'>, defaults: {
+        binaries: readonly string[];
+        versionArgs?: readonly string[];
+        modelArgs?: readonly string[];
+    }, options?: StandardStreamDriverOptions);
+    detect(): Promise<{
+        installed: boolean;
+        version: string | null;
+        command: string | null;
+    }>;
+    listModels(): Promise<CodingNsCliModelCatalog>;
+    executeTurn(input: CodingNsCliTurnInput): AsyncIterable<CodingNsAgentEvent>;
+    dispose(): void;
+    protected parseVersion(output: string): string | null;
+    protected abstract buildArgs(input: CodingNsCliTurnInput): readonly string[];
+    protected parseEvent(value: Record<string, unknown>, input: CodingNsCliTurnInput): readonly CodingNsAgentEvent[];
+    protected parseModels(output: string): CodingNsCliModelCatalog;
+}
+export declare function emptyCatalog(): CodingNsCliModelCatalog;
+//# sourceMappingURL=standard-stream-driver.d.ts.map