@jingyi0605/codingns4dsh 0.1.0

package/data/build/dist/host/native-session-bridge.d.ts

@@ -0,0 +1,130 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { CodingNsAgentQuestion, CodingNsAgentQuestionResponse } from '../shared/contracts/cli-adapter.js';
+/**
+ * DSH Host 原生会话服务的最小运行时面。
+ *
+ * 这里故意不直接依赖 dsh-session 或 dsh-api-session-controller：插件的
+ * package.json 只锁定 DSH 兼容版本，某些精简 Host 可能没有装载完整会话服务。
+ * 运行时探测可以让这类 Host 继续使用 Codingns4DSH，而完整 DSH 则优先走原生 API。
+ */
+export interface CodingNsNativeSessionStore {
+    get(sessionId: string): unknown;
+    list(): readonly unknown[];
+    flush?(session: unknown): Promise<boolean> | Promise<void> | boolean | void;
+}
+/** 公共 CLI 投影层写入 DSH 的工具调用，不包含任何 Provider 私有字段。 */
+export interface CodingNsNativeToolCall {
+    readonly callId: string;
+    readonly name: string;
+    readonly arguments: string;
+}
+/** 一次工具调用在 DSH Session 中的稳定位置。 */
+export interface CodingNsNativeToolCallHandle {
+    readonly sessionId: string;
+    readonly turn: number;
+    readonly step: number;
+    readonly callId: string;
+    readonly callSeq: number;
+}
+/** 公共 CLI 投影层写入 DSH 的工具结果。 */
+export interface CodingNsNativeToolResult {
+    readonly output: string;
+    readonly isError: boolean;
+    readonly error?: string;
+    readonly meta?: unknown;
+}
+/** 外部 Agent 工具在 DSH Session 中的只读时间线标记。 */
+export interface CodingNsNativeExternalToolEvent {
+    readonly phase: 'start' | 'update';
+    readonly callId: string;
+    readonly name: string;
+    readonly arguments: string;
+    readonly status: 'running' | 'completed' | 'failed';
+    readonly output?: string;
+    readonly error?: string;
+}
+export type CodingNsNativeApprovalOutcome = 'allowed-once' | 'rejected' | 'cancelled' | 'unavailable';
+/** 公共消息投影层交给 DSH 原生权限服务的请求。 */
+export interface CodingNsNativeApprovalRequest {
+    readonly requestId: string;
+    readonly toolName: string;
+    readonly callId?: string;
+    readonly reason?: string;
+    readonly signal?: AbortSignal;
+}
+/** 公共消息投影层交给 DSH 原生问题服务的请求。 */
+export interface CodingNsNativeQuestionRequest {
+    readonly requestId: string;
+    readonly questions: readonly CodingNsAgentQuestion[];
+    readonly signal?: AbortSignal;
+}
+/** 外部 Agent 已确认的模型路由上下文容量，用于 DSH token-meter 的上下文占用投影。 */
+export interface CodingNsNativeRequestContext {
+    readonly provider: string;
+    readonly model: string;
+    readonly contextWindow?: number;
+}
+export interface CodingNsNativeSessionController {
+    create?(request: {
+        readonly sessionId?: string;
+        readonly cwd?: string;
+    }): Promise<{
+        readonly sessionId: string;
+    }>;
+    list?(request?: unknown, signal?: AbortSignal): Promise<{
+        readonly items: readonly unknown[];
+    }>;
+}
+/** DSH 工作区控制器负责改变原生侧栏中的会话可见性。 */
+export interface CodingNsNativeWorkspaceController {
+    archiveSession?(request: {
+        readonly sessionId: string;
+    }): Promise<unknown> | unknown;
+    unarchiveSession?(request: {
+        readonly sessionId: string;
+    }): Promise<unknown> | unknown;
+}
+export interface CodingNsNativeSessionBridge {
+    readonly available: boolean;
+    /** 当前 Host 是否提供可接收 Session 事件的事件总线。 */
+    readonly supportsEvents: boolean;
+    readonly store: CodingNsNativeSessionStore | undefined;
+    readonly controller: CodingNsNativeSessionController | undefined;
+    readonly workspaceController?: CodingNsNativeWorkspaceController;
+    /** 获取已经进入 DSH 原生 SessionStore 的会话。 */
+    get(sessionId: string): unknown | undefined;
+    /** 获取当前 Host 已装载的原生会话；失败时返回空数组。 */
+    list(): readonly unknown[];
+    /** 调用 DSH 原生 session/list；无 Controller 时回退到本地 SessionStore。 */
+    listRemote(signal?: AbortSignal): Promise<readonly unknown[]>;
+    /** 创建或采用一个 DSH 原生会话。 */
+    ensure(sessionId: string, cwd?: string): Promise<string | null>;
+    /** 等待 DSH 原生持久化监听器完成当前会话的检查点。 */
+    flush(sessionId: string): Promise<void>;
+    /**
+     * 只追加已由外部 Agent 执行的工具历史，不经过 DSH Agent Loop。
+     * 返回 null 表示会话或活动 step 不可用，调用方应安静降级。
+     */
+    appendToolCall?(sessionId: string, call: CodingNsNativeToolCall): CodingNsNativeToolCallHandle | null;
+    /** 追加与 appendToolCall 配对的只读结果；不会再次执行工具。 */
+    appendToolResult?(handle: CodingNsNativeToolCallHandle, result: CodingNsNativeToolResult): boolean;
+    /** 兼容旧调用方；内部仍转换为 DSH 原生 tool/call 与 tool/result。 */
+    appendExternalToolEvent?(sessionId: string, event: CodingNsNativeExternalToolEvent): boolean;
+    /** 写入当前原生步骤的路由上下文元数据，不携带凭据或消息正文。 */
+    appendRequestContext?(sessionId: string, context: CodingNsNativeRequestContext): boolean;
+    /** 使用 DSH 原生 approval 组件请求一次权限决定；服务不可用时拒绝。 */
+    requestApproval?(sessionId: string, request: CodingNsNativeApprovalRequest): Promise<CodingNsNativeApprovalOutcome>;
+    /** 使用 DSH 原生 userQuestions 组件提问；服务不可用或取消时返回 null。 */
+    askQuestions?(sessionId: string, request: CodingNsNativeQuestionRequest): Promise<CodingNsAgentQuestionResponse | null>;
+    /** 从 DSH 原生侧栏归档会话；控制器不可用时返回 false。 */
+    archive?(sessionId: string): Promise<boolean>;
+    /** 恢复 DSH 原生侧栏中的归档会话；控制器不可用时返回 false。 */
+    unarchive?(sessionId: string): Promise<boolean>;
+    /** 订阅 DSH 的原生事件流；返回值用于在功能停用时移除监听器。 */
+    subscribe(handlers: {
+        readonly onEvent?: (session: unknown, event: unknown) => void;
+        readonly onFlush?: (session: unknown) => void | Promise<void>;
+    }): () => void;
+}
+export declare function createCodingNsNativeSessionBridge(ctx: Context): CodingNsNativeSessionBridge;
+//# sourceMappingURL=native-session-bridge.d.ts.map

package/data/build/dist/host/native-session-bridge.js

@@ -0,0 +1,317 @@
+export function createCodingNsNativeSessionBridge(ctx) {
+    // Cordis Context 是运行时代理，直接读取未在 inject 中声明的可选服务会抛错。
+    // get() 专门用于无强制依赖的服务探测，精简 Host 缺少服务时会返回 undefined。
+    const storeValue = ctx.get('sessions');
+    const controllerValue = ctx.get('sessionController');
+    const workspaceControllerValue = ctx.get('workspaceController');
+    const store = isSessionStore(storeValue) ? storeValue : undefined;
+    const controller = isSessionController(controllerValue) ? controllerValue : undefined;
+    const workspaceController = isWorkspaceController(workspaceControllerValue) ? workspaceControllerValue : undefined;
+    const currentWorkspaceController = () => {
+        const value = ctx.get('workspaceController');
+        return isWorkspaceController(value) ? value : undefined;
+    };
+    const on = typeof ctx.on === 'function'
+        ? ctx.on.bind(ctx)
+        : undefined;
+    const externalHandles = new Map();
+    const appendNativeToolCall = (sessionId, call) => {
+        const session = appendableSession(store?.get(sessionId));
+        const position = session === null ? null : activeStep(session);
+        if (session === null || position === null)
+            return null;
+        const event = session.append('tool/call', {
+            turn: position.turn,
+            step: position.step,
+            callId: call.callId,
+            name: call.name,
+            arguments: call.arguments,
+        });
+        const callSeq = eventSeq(event);
+        return callSeq === null ? null : { sessionId, ...position, callId: call.callId, callSeq };
+    };
+    const appendNativeToolResult = (handle, result) => {
+        const session = appendableSession(store?.get(handle.sessionId));
+        if (session === null)
+            return false;
+        const error = result.error?.trim();
+        session.append('tool/result', {
+            turn: handle.turn,
+            step: handle.step,
+            message: {
+                id: `${handle.callId}-result-${handle.turn}-${handle.step}`,
+                role: 'user',
+                content: [{
+                        type: 'tool-result',
+                        toolCallId: handle.callId,
+                        content: [{ type: 'text', text: result.output }],
+                        ...(result.isError ? { isError: true } : {}),
+                    }],
+                source: { kind: 'tool', callId: handle.callId },
+            },
+            ...(result.isError
+                ? { error: { name: 'ExternalToolError', code: 'EXTERNAL_TOOL_FAILED', ...(error ? { reason: error } : {}) } }
+                : {}),
+            ...(result.meta === undefined ? {} : { meta: result.meta }),
+        }, {
+            surfaceOp: 'append',
+            sourceEventSeqs: [handle.callSeq],
+        });
+        return true;
+    };
+    const appendNativeRequestContext = (sessionId, context) => {
+        const session = appendableSession(store?.get(sessionId));
+        if (session === null || context.provider.trim() === '' || context.model.trim() === '')
+            return false;
+        try {
+            session.append('request/context', {
+                provider: context.provider,
+                model: context.model,
+                ...(context.contextWindow === undefined ? {} : { contextWindow: context.contextWindow }),
+            });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    return {
+        get available() {
+            return store !== undefined || controller !== undefined || currentWorkspaceController() !== undefined;
+        },
+        supportsEvents: on !== undefined,
+        store,
+        controller,
+        ...(workspaceController === undefined ? {} : { workspaceController }),
+        get(sessionId) {
+            return store?.get(sessionId);
+        },
+        list() {
+            try {
+                return store?.list() ?? [];
+            }
+            catch {
+                return [];
+            }
+        },
+        async listRemote(signal) {
+            if (controller?.list !== undefined) {
+                try {
+                    return (await controller.list({}, signal)).items;
+                }
+                catch {
+                    return [];
+                }
+            }
+            return this.list();
+        },
+        async ensure(sessionId, cwd) {
+            if (sessionId.trim() === '')
+                return null;
+            if (store?.get(sessionId) !== undefined)
+                return sessionId;
+            if (controller?.create !== undefined) {
+                const created = await controller.create({ sessionId, ...(cwd ? { cwd } : {}) });
+                return typeof created.sessionId === 'string' && created.sessionId.trim() ? created.sessionId : sessionId;
+            }
+            // 不调用裸 SessionStore.create()：它把会话绑定到插件 Fiber，停用插件
+            // 时会被移除，无法满足长期会话和原生侧栏持久化要求。
+            return null;
+        },
+        async flush(sessionId) {
+            const session = store?.get(sessionId);
+            if (session === undefined || store?.flush === undefined)
+                return;
+            await store.flush(session);
+        },
+        appendToolCall(sessionId, call) {
+            return appendNativeToolCall(sessionId, call);
+        },
+        appendToolResult(handle, result) {
+            return appendNativeToolResult(handle, result);
+        },
+        appendRequestContext(sessionId, context) {
+            return appendNativeRequestContext(sessionId, context);
+        },
+        appendExternalToolEvent(sessionId, externalTool) {
+            try {
+                // 兼容旧调用方，但仍然写入 DSH 原生工具事件，绝不能伪造 assistant/attempt。
+                const key = `${sessionId}:${externalTool.callId}`;
+                if (externalTool.phase === 'start') {
+                    if (externalHandles.has(key))
+                        return true;
+                    const handle = appendNativeToolCall(sessionId, {
+                        callId: externalTool.callId,
+                        name: externalTool.name,
+                        arguments: externalTool.arguments,
+                    });
+                    if (handle === null)
+                        return false;
+                    externalHandles.set(key, handle);
+                    return true;
+                }
+                const handle = externalHandles.get(key);
+                if (handle === undefined)
+                    return false;
+                if (externalTool.status === 'running')
+                    return true;
+                const result = appendNativeToolResult(handle, {
+                    output: externalTool.output ?? externalTool.error ?? '',
+                    isError: externalTool.status === 'failed',
+                    ...(externalTool.error ? { error: externalTool.error } : {}),
+                });
+                if (result)
+                    externalHandles.delete(key);
+                return result;
+            }
+            catch {
+                return false;
+            }
+        },
+        async requestApproval(sessionId, request) {
+            const agent = nativeAgent(ctx, sessionId);
+            const approval = nativeApproval(ctx);
+            if (agent === null || approval === null)
+                return 'unavailable';
+            try {
+                const outcome = await approval.request({
+                    agent,
+                    toolName: request.toolName,
+                    ...(request.callId ? { callId: request.callId } : {}),
+                    ...(request.reason ? { reason: request.reason } : {}),
+                    ...(request.signal === undefined ? {} : { signal: request.signal }),
+                });
+                return isApprovalOutcome(outcome) ? outcome : 'unavailable';
+            }
+            catch {
+                return request.signal?.aborted ? 'cancelled' : 'unavailable';
+            }
+        },
+        async askQuestions(sessionId, request) {
+            const agent = nativeAgent(ctx, sessionId);
+            const userQuestions = nativeUserQuestions(ctx);
+            if (agent === null || userQuestions === null)
+                return null;
+            try {
+                const answer = await userQuestions.ask({
+                    agent,
+                    questions: request.questions,
+                    ...(request.signal === undefined ? {} : { signal: request.signal }),
+                });
+                if (!isQuestionAnswer(answer))
+                    return null;
+                return { requestId: request.requestId, answers: answer.answers };
+            }
+            catch {
+                return null;
+            }
+        },
+        async archive(sessionId) {
+            const current = currentWorkspaceController();
+            if (sessionId.trim() === '' || current?.archiveSession === undefined)
+                return false;
+            await current.archiveSession({ sessionId });
+            return true;
+        },
+        async unarchive(sessionId) {
+            const current = currentWorkspaceController();
+            if (sessionId.trim() === '' || current?.unarchiveSession === undefined)
+                return false;
+            await current.unarchiveSession({ sessionId });
+            return true;
+        },
+        subscribe(handlers) {
+            const disposers = [];
+            if (on !== undefined && handlers.onEvent !== undefined) {
+                disposers.push(on('session/event', (session, event) => handlers.onEvent?.(session, event)));
+            }
+            if (on !== undefined && handlers.onFlush !== undefined) {
+                disposers.push(on('session/flush', (session) => handlers.onFlush?.(session)));
+            }
+            return () => { for (const dispose of disposers)
+                dispose(); };
+        },
+    };
+}
+function appendableSession(value) {
+    if (!isRecord(value))
+        return null;
+    if (typeof value.snapshotEvents !== 'function' || typeof value.append !== 'function')
+        return null;
+    return value;
+}
+function activeStep(session) {
+    let events;
+    try {
+        events = session.snapshotEvents();
+    }
+    catch {
+        return null;
+    }
+    const closed = new Set();
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        const candidate = events[index];
+        const event = isRecord(candidate) ? candidate : null;
+        const data = isRecord(event?.data) ? event.data : null;
+        const turn = finiteInteger(data?.turn);
+        const step = finiteInteger(data?.step);
+        if (turn === null || step === null)
+            continue;
+        const key = `${turn}:${step}`;
+        if (event?.type === 'step/end')
+            closed.add(key);
+        if (event?.type === 'step/start' && !closed.has(key))
+            return { turn, step };
+    }
+    return null;
+}
+function eventSeq(value) {
+    return isRecord(value) ? finiteInteger(value.seq) : null;
+}
+function finiteInteger(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 ? value : null;
+}
+function isSessionStore(value) {
+    return isRecord(value) && typeof value.get === 'function' && typeof value.list === 'function';
+}
+function isSessionController(value) {
+    return isRecord(value) && (typeof value.create === 'function' || typeof value.list === 'function');
+}
+function isWorkspaceController(value) {
+    return isRecord(value) && (typeof value.archiveSession === 'function' || typeof value.unarchiveSession === 'function');
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function nativeAgent(ctx, sessionId) {
+    const value = ctx.get('agents');
+    if (!isRecord(value) || typeof value.get !== 'function')
+        return null;
+    try {
+        return value.get(sessionId) ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function nativeApproval(ctx) {
+    const value = ctx.get('approval');
+    return isRecord(value) && typeof value.request === 'function' ? value : null;
+}
+function nativeUserQuestions(ctx) {
+    const value = ctx.get('userQuestions');
+    return isRecord(value) && typeof value.ask === 'function' ? value : null;
+}
+function isApprovalOutcome(value) {
+    return value === 'allowed-once' || value === 'rejected' || value === 'cancelled' || value === 'unavailable';
+}
+function isQuestionAnswer(value) {
+    if (!isRecord(value) || !Array.isArray(value.answers))
+        return false;
+    return value.answers.every((answer) => isRecord(answer)
+        && typeof answer.id === 'string'
+        && Array.isArray(answer.selected)
+        && answer.selected.every((item) => typeof item === 'string')
+        && (answer.custom === undefined || typeof answer.custom === 'string'));
+}
+//# sourceMappingURL=native-session-bridge.js.map

package/data/build/dist/host/relay-tunnel-runtime.d.ts

@@ -0,0 +1,97 @@
+import { RTCCertificate } from 'werift';
+import type { FeatureResourceScope } from '../shared/contracts/feature.js';
+import type { FeatureModule } from '../shared/contracts/feature.js';
+import type { FeatureRegistry } from '../features/registry.js';
+import type { RelayIceServer, RelaySignalingTicketResponse } from '../shared/contracts/signaling.js';
+import type { CodingNsControlApiClient } from './control-api-client.js';
+import { type HostPeerConnectionLike, type WebRtcHostAcceptor, type WebRtcHostSession } from '../transport/webrtc-host.js';
+import { DshGateway, type DshGatewayFeature } from '../transport/dsh-gateway.js';
+import { type DshTransportDebugLogger } from '../transport/debug.js';
+/** Relay Tunnel 规定的 DataChannel label，不允许使用插件自定义值。 */
+export declare const CODINGNS_TUNNEL_DATA_CHANNEL_LABEL = "codingns-tunnel";
+export interface HostDtlsIdentityMaterial {
+    privateKeyPem: string;
+    certPem: string;
+    signatureHash: {
+        signature: number;
+        hash: number;
+    };
+    fingerprint: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface HostDtlsIdentityStore {
+    read(): Promise<HostDtlsIdentityMaterial | null>;
+    write(identity: HostDtlsIdentityMaterial): Promise<void>;
+}
+/** 文件存储适用于 Host 桌面进程；先写临时文件再 rename，避免半截证书。 */
+export declare class FileHostDtlsIdentityStore implements HostDtlsIdentityStore {
+    private readonly filePath;
+    constructor(filePath: string);
+    read(): Promise<HostDtlsIdentityMaterial | null>;
+    write(identity: HostDtlsIdentityMaterial): Promise<void>;
+}
+/** 生成一张新的 werift DTLS 证书，并返回控制面约定的 sha-256 指纹。 */
+export declare function generateHostDtlsIdentity(): Promise<HostDtlsIdentityMaterial>;
+/** 读取已有身份，否则生成并持久化；指纹因此跨进程重启保持不变。 */
+export declare function ensureHostDtlsIdentity(store: HostDtlsIdentityStore): Promise<HostDtlsIdentityMaterial>;
+export declare function formatHostDtlsFingerprint(certificate: Pick<RTCCertificate, 'getFingerprints'>): string;
+export interface HostRelaySession extends WebRtcHostSession {
+    readonly tunnelDomain: string;
+    readonly gateway: DshGateway;
+}
+export interface HostRelayRuntimeOptions {
+    readonly controlClient: Pick<CodingNsControlApiClient, 'createSignalingTicket'>;
+    /** DSH 独立设备可注入自己的票据申请器，避免复用 Codingns4DSH binding。 */
+    readonly createTicket?: (input: {
+        accessToken: string;
+        identity: HostDtlsIdentityMaterial;
+        credentialVersion?: number;
+    }) => Promise<RelaySignalingTicketResponse>;
+    readonly accessToken: string;
+    readonly bindingId?: string;
+    readonly credentialVersion?: number;
+    readonly dtlsStore: HostDtlsIdentityStore;
+    readonly signalingSocketFactory?: (url: string) => Promise<HostSignalingSocket> | HostSignalingSocket;
+    readonly peerConnectionFactory?: (options: {
+        iceServers: RelayIceServer[];
+        iceTransportPolicy: 'all' | 'relay';
+    }) => HostPeerConnectionLike;
+    readonly resources?: Pick<FeatureResourceScope, 'add'>;
+    readonly onSession?: (session: HostRelaySession) => void | Promise<void>;
+    readonly gatewayFeatures?: readonly DshGatewayFeature[];
+    /** 传给 DSH Gateway 的运行时版本；缺省时仅保留独立模块测试兼容性。 */
+    readonly dshVersion?: string;
+    readonly gatewayRegistry?: FeatureRegistry<unknown, FeatureModule<unknown>>;
+    readonly debug?: DshTransportDebugLogger;
+    readonly generation?: string;
+    readonly hostId?: string;
+    readonly ticketRenewSkewMs?: number;
+}
+export interface HostRelayRuntime {
+    readonly identity: HostDtlsIdentityMaterial;
+    readonly ticket: RelaySignalingTicketResponse;
+    readonly acceptor: WebRtcHostAcceptor;
+    readonly sessions: ReadonlyMap<string, WebRtcHostSession>;
+    close(): Promise<void>;
+}
+/**
+ * 启动一个可接收多个 Client 的 Host Relay runtime。
+ * `resources` 若提供，所有 WebSocket、PeerConnection、心跳和换票计时器都会登记。
+ */
+export declare function startHostRelayRuntime(options: HostRelayRuntimeOptions): Promise<HostRelayRuntime>;
+/** 为 Host answerer 创建 werift PeerConnection，并适配到 transport 的注入接口。 */
+export declare function createWeriftPeerConnectionFactory(identity?: HostDtlsIdentityMaterial): NonNullable<HostRelayRuntimeOptions['peerConnectionFactory']>;
+export interface HostSignalingSocket {
+    readonly readyState: number;
+    send(data: string): void;
+    close(code?: number, reason?: string): void;
+    addEventListener(type: 'message' | 'close' | 'error', listener: (event: Event) => void): void;
+    removeEventListener(type: 'message' | 'close' | 'error', listener: (event: Event) => void): void;
+}
+/** 建立 Host 信令并等待服务端 registered；registered 后每 20 秒发 ping。 */
+export declare function createRegisteredHostSignalingSocket(url: string, options?: {
+    registrationTimeoutMs?: number;
+    heartbeatIntervalMs?: number;
+}): Promise<HostSignalingSocket>;
+//# sourceMappingURL=relay-tunnel-runtime.d.ts.map