@jingyi0605/codingns4dsh 0.1.0

package/data/build/dist/transport/webrtc-host.d.ts

@@ -0,0 +1,58 @@
+import type { RelayIceServer, RelaySignalingTicketRequest, RelaySignalingTicketResponse } from '../shared/contracts/signaling.js';
+import type { CodingNsControlApiClient } from '../host/control-api-client.js';
+import { type CodingNsCarrier, type DataChannelLike } from './carrier.js';
+import { type PeerConnectionLike, type SignalingSocketLike } from './webrtc-client.js';
+import { type DshTransportDebugLogger } from './debug.js';
+/** Host 侧每个客户端会话使用一个独立的 PeerConnection。真实 Node WebRTC 实现由调用方注入。 */
+export interface HostPeerConnectionLike extends Omit<PeerConnectionLike, 'createDataChannel' | 'createOffer'> {
+    readonly connectionState?: string;
+    readonly iceConnectionState?: string;
+    createAnswer(): Promise<{
+        type: 'answer';
+        sdp?: string;
+    }>;
+    ondatachannel: ((event: {
+        channel: DataChannelLike;
+    }) => void) | null;
+}
+export interface HostSignalingTicketRequest {
+    bindingId: string;
+    hostDtlsFingerprint: string;
+    credentialVersion?: number;
+}
+export interface WebRtcHostAcceptorOptions {
+    signalingTicket: RelaySignalingTicketResponse;
+    signalingSocketFactory(url: string): Promise<SignalingSocketLike> | SignalingSocketLike;
+    peerConnectionFactory(options: {
+        iceServers: RelayIceServer[];
+        iceTransportPolicy: 'all' | 'relay';
+    }): HostPeerConnectionLike;
+    channelLabel?: string;
+    onConnection?: (connection: WebRtcHostSession) => void | Promise<void>;
+    onSessionClosed?: (sessionId: string) => void | Promise<void>;
+    debug?: DshTransportDebugLogger;
+}
+export interface WebRtcHostSession {
+    readonly sessionId: string;
+    readonly peerConnection: HostPeerConnectionLike;
+    readonly carrier: CodingNsCarrier | null;
+    close(): Promise<void>;
+}
+export interface WebRtcHostAcceptor {
+    readonly signaling: SignalingSocketLike;
+    readonly sessions: ReadonlyMap<string, WebRtcHostSession>;
+    close(): Promise<void>;
+}
+/**
+ * 构造 Host 申请角色票据的请求 DTO，并在进入 Control API 前检查边界。
+ * 指纹只做非空和控制字符校验，具体格式由 Codingns4DSH 绑定记录比较逻辑决定。
+ */
+export declare function createHostSignalingTicketRequest(input: HostSignalingTicketRequest): RelaySignalingTicketRequest;
+/** 通过已认证 Host 控制面会话申请 Host 角色信令票据。 */
+export declare function requestHostSignalingTicket(controlClient: Pick<CodingNsControlApiClient, 'createSignalingTicket'>, accessToken: string, input: HostSignalingTicketRequest): Promise<RelaySignalingTicketResponse>;
+/**
+ * 接收客户端 offer 并回传 answer 的 Host 侧 WebRTC 骨架。
+ * 该函数只编排信令和可注入的 PeerConnection，不创建 Node WebRTC runtime 或网络服务。
+ */
+export declare function acceptWebRtcHost(options: WebRtcHostAcceptorOptions): Promise<WebRtcHostAcceptor>;
+//# sourceMappingURL=webrtc-host.d.ts.map

package/data/build/dist/transport/webrtc-host.js

@@ -0,0 +1,252 @@
+import { createDataChannelCarrier, createRelayTunnelHostCarrier, TUNNEL_DATA_CHANNEL_LABEL } from './carrier.js';
+import { createSignalingUrl, waitForSignalingRegistered, } from './webrtc-client.js';
+import { createDshTransportDebugLogger } from './debug.js';
+/**
+ * 构造 Host 申请角色票据的请求 DTO，并在进入 Control API 前检查边界。
+ * 指纹只做非空和控制字符校验，具体格式由 Codingns4DSH 绑定记录比较逻辑决定。
+ */
+export function createHostSignalingTicketRequest(input) {
+    if (/[\r\n]/u.test(input.hostDtlsFingerprint)) {
+        throw new TypeError('Host signaling ticket 的 DTLS fingerprint 无效');
+    }
+    const bindingId = input.bindingId.trim();
+    const hostDtlsFingerprint = input.hostDtlsFingerprint.trim();
+    if (!bindingId)
+        throw new TypeError('Host signaling ticket 的 bindingId 不能为空');
+    if (!hostDtlsFingerprint) {
+        throw new TypeError('Host signaling ticket 的 DTLS fingerprint 无效');
+    }
+    if (input.credentialVersion !== undefined
+        && (!Number.isInteger(input.credentialVersion) || input.credentialVersion < 1)) {
+        throw new TypeError('Host signaling ticket 的 credentialVersion 必须是正整数');
+    }
+    return {
+        bindingId,
+        hostDtlsFingerprint,
+        ...(input.credentialVersion === undefined ? {} : { credentialVersion: input.credentialVersion }),
+    };
+}
+/** 通过已认证 Host 控制面会话申请 Host 角色信令票据。 */
+export function requestHostSignalingTicket(controlClient, accessToken, input) {
+    if (!accessToken.trim())
+        throw new TypeError('Host signaling ticket 的 accessToken 不能为空');
+    return controlClient.createSignalingTicket(accessToken, createHostSignalingTicketRequest(input));
+}
+/**
+ * 接收客户端 offer 并回传 answer 的 Host 侧 WebRTC 骨架。
+ * 该函数只编排信令和可注入的 PeerConnection，不创建 Node WebRTC runtime 或网络服务。
+ */
+export async function acceptWebRtcHost(options) {
+    validateHostTicket(options.signalingTicket);
+    const debug = options.debug ?? createDshTransportDebugLogger({ side: 'host', component: 'webrtc-host' });
+    const signaling = await options.signalingSocketFactory(createSignalingUrl(options.signalingTicket.signalingBaseUrl, options.signalingTicket.ticket));
+    if ('readyState' in signaling) {
+        await waitForSignalingRegistered(signaling, 15_000);
+    }
+    const heartbeat = 'readyState' in signaling
+        ? setInterval(() => {
+            if (signaling.readyState === 1) {
+                try {
+                    signaling.send(JSON.stringify({ type: 'ping', at: new Date().toISOString() }));
+                }
+                catch { /* 断线由 close 处理 */ }
+            }
+        }, 20_000)
+        : undefined;
+    const sessions = new Map();
+    const queuedCandidates = new Map();
+    let closed = false;
+    const onMessage = (event) => {
+        const raw = event.data;
+        if (typeof raw !== 'string')
+            return;
+        let message;
+        try {
+            message = JSON.parse(raw);
+        }
+        catch {
+            return;
+        }
+        debug.log('signaling.message', { type: message.type, sessionId: 'sessionId' in message ? message.sessionId : null });
+        if (message.type === 'offer') {
+            if (message.senderRole !== 'client' || !message.sessionId || !message.sdp)
+                return;
+            void handleOffer(message.sessionId, message.sdp);
+            return;
+        }
+        if (message.type === 'candidate') {
+            if (message.senderRole !== 'client' || !message.sessionId || !message.candidate)
+                return;
+            const session = sessions.get(message.sessionId);
+            if (session)
+                void session.addCandidate({ candidate: message.candidate, sdpMid: message.mid });
+            else
+                queuedCandidates.set(message.sessionId, [
+                    ...(queuedCandidates.get(message.sessionId) ?? []),
+                    { candidate: message.candidate, sdpMid: message.mid },
+                ]);
+            return;
+        }
+        if (message.type === 'peer-left' && message.peerRole === 'client' && message.sessionId) {
+            void closeSession(message.sessionId);
+        }
+    };
+    const onClose = () => { void closeAllSessions(); };
+    signaling.addEventListener('message', onMessage);
+    signaling.addEventListener('close', onClose);
+    const closeSession = async (sessionId) => {
+        queuedCandidates.delete(sessionId);
+        const session = sessions.get(sessionId);
+        if (!session)
+            return;
+        sessions.delete(sessionId);
+        await session.close();
+        await options.onSessionClosed?.(sessionId);
+    };
+    const closeAllSessions = async () => {
+        const current = [...sessions.keys()];
+        await Promise.all(current.map((sessionId) => closeSession(sessionId)));
+    };
+    const handleOffer = async (sessionId, sdp) => {
+        if (closed)
+            return;
+        let session = sessions.get(sessionId);
+        if (!session) {
+            session = new HostSessionImpl(sessionId, options.peerConnectionFactory({
+                iceServers: options.signalingTicket.iceServers,
+                iceTransportPolicy: options.signalingTicket.iceTransportPolicy,
+            }), signaling, options.onConnection, () => { void closeSession(sessionId); }, TUNNEL_DATA_CHANNEL_LABEL, options.debug);
+            sessions.set(sessionId, session);
+        }
+        await session.answerOffer(sdp);
+        const candidates = queuedCandidates.get(sessionId) ?? [];
+        queuedCandidates.delete(sessionId);
+        for (const candidate of candidates)
+            await session.addCandidate(candidate);
+    };
+    return {
+        signaling,
+        get sessions() { return sessions; },
+        async close() {
+            if (closed)
+                return;
+            closed = true;
+            if (heartbeat !== undefined)
+                clearInterval(heartbeat);
+            signaling.removeEventListener('message', onMessage);
+            signaling.removeEventListener('close', onClose);
+            await closeAllSessions();
+            signaling.close(1000, 'host closed');
+        },
+    };
+}
+class HostSessionImpl {
+    sessionId;
+    peerConnection;
+    signaling;
+    onConnection;
+    onTransportClosed;
+    debug;
+    _carrier = null;
+    closed = false;
+    offerPromise = null;
+    remoteDescriptionReady = false;
+    pendingCandidates = [];
+    constructor(sessionId, peerConnection, signaling, onConnection, onTransportClosed, channelLabel, debug) {
+        this.sessionId = sessionId;
+        this.peerConnection = peerConnection;
+        this.signaling = signaling;
+        this.onConnection = onConnection;
+        this.onTransportClosed = onTransportClosed;
+        this.debug = debug;
+        this.peerConnection.addEventListener?.('connectionstatechange', this.onPeerState);
+        this.peerConnection.addEventListener?.('iceconnectionstatechange', this.onPeerState);
+        this.peerConnection.onicecandidate = (event) => {
+            if (this.closed || !event.candidate)
+                return;
+            this.signaling.send(JSON.stringify({
+                type: 'candidate',
+                candidate: event.candidate.candidate,
+                mid: event.candidate.sdpMid,
+                sessionId: this.sessionId,
+            }));
+        };
+        this.peerConnection.ondatachannel = (event) => {
+            if (this.closed)
+                return;
+            const channel = event.channel;
+            if (channelLabel && 'label' in channel && typeof channel.label === 'string'
+                && channel.label !== channelLabel) {
+                channel.close();
+                return;
+            }
+            if (this._carrier)
+                void this._carrier.close();
+            this.debug?.log('data-channel.accepted', { sessionId: this.sessionId, label: channel.label ?? null });
+            this._carrier = createRelayTunnelHostCarrier(createDataChannelCarrier(channel, { ...(this.debug ? { debug: this.debug } : {}) }), this.debug);
+            this._carrier.onClosed?.(() => { void this.onTransportClosed(); });
+            void this.onConnection?.(this);
+        };
+    }
+    get carrier() { return this._carrier; }
+    answerOffer(sdp) {
+        if (this.offerPromise)
+            return this.offerPromise;
+        this.offerPromise = this.answerOfferOnce(sdp).finally(() => { this.offerPromise = null; });
+        return this.offerPromise;
+    }
+    async addCandidate(candidate) {
+        if (this.closed)
+            return;
+        if (!this.remoteDescriptionReady) {
+            this.pendingCandidates.push(candidate);
+            return;
+        }
+        await this.peerConnection.addIceCandidate(candidate);
+    }
+    async answerOfferOnce(sdp) {
+        if (this.closed)
+            return;
+        await this.peerConnection.setRemoteDescription({ type: 'offer', sdp });
+        this.remoteDescriptionReady = true;
+        const pendingCandidates = this.pendingCandidates.splice(0);
+        for (const candidate of pendingCandidates)
+            await this.peerConnection.addIceCandidate(candidate);
+        const answer = await this.peerConnection.createAnswer();
+        await this.peerConnection.setLocalDescription(answer);
+        if (!this.closed) {
+            this.signaling.send(JSON.stringify({ type: 'answer', sdp: answer.sdp ?? '', sessionId: this.sessionId }));
+        }
+    }
+    async close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.peerConnection.onicecandidate = null;
+        this.peerConnection.ondatachannel = null;
+        this.peerConnection.removeEventListener?.('connectionstatechange', this.onPeerState);
+        this.peerConnection.removeEventListener?.('iceconnectionstatechange', this.onPeerState);
+        await this._carrier?.close();
+        this._carrier = null;
+        this.peerConnection.close();
+    }
+    onPeerState = () => {
+        const state = this.peerConnection;
+        const value = state.connectionState ?? state.iceConnectionState;
+        if (value === 'failed' || value === 'disconnected' || value === 'closed')
+            void this.onTransportClosed();
+    };
+}
+function validateHostTicket(ticket) {
+    if (!ticket.ticket.trim() || !ticket.bindingId.trim() || !ticket.signalingBaseUrl.trim()) {
+        throw new TypeError('Host signaling ticket 缺少必需字段');
+    }
+    if (!ticket.hostDtlsFingerprint.trim() || /[\r\n]/u.test(ticket.hostDtlsFingerprint)) {
+        throw new TypeError('Host signaling ticket 的 DTLS fingerprint 无效');
+    }
+    if (ticket.credentialVersion !== undefined
+        && (!Number.isInteger(ticket.credentialVersion) || ticket.credentialVersion < 1)) {
+        throw new TypeError('Host signaling ticket 的 credentialVersion 无效');
+    }
+}
+//# sourceMappingURL=webrtc-host.js.map

package/data/build/dist/typert.host.d.ts

@@ -0,0 +1,25 @@
+export declare const TYPERT: {
+    readonly package: "codingns4dsh";
+    readonly face: "host";
+    readonly schemas: readonly [];
+    readonly invocations: readonly [Record<string, unknown>, Record<string, unknown>, Record<string, unknown>, Record<string, unknown>, Record<string, unknown>, Record<string, unknown>, Record<string, unknown>, Record<string, unknown>, Record<string, unknown>, Record<string, unknown>];
+    readonly model: {
+        readonly services: readonly [{
+            readonly description: "codingns4dsh Sidebar 终端 UI 使用的兼容 controller。";
+            readonly summary: "Codingns4DSH 终端 controller";
+            readonly tags: readonly [];
+            readonly jsDoc: "/** codingns4dsh Sidebar 终端 UI 使用的兼容 controller。 */";
+            readonly key: "terminalController";
+            readonly exportName: "CodingNsTerminalController";
+            readonly members: {
+                name: string;
+                signature: string;
+                kind: string;
+            }[];
+            readonly types: readonly [];
+        }];
+        readonly events: readonly [];
+        readonly objects: readonly [];
+    };
+};
+//# sourceMappingURL=typert.host.d.ts.map

package/data/build/dist/typert.host.js

@@ -0,0 +1,150 @@
+/*
+ * codingns4dsh 自有的 Typert Host artifact。
+ *
+ * 这里不能重导出官方 terminal-controller 的 TYPERT：DSH loader 会校验
+ * manifest.package 必须属于实际导出它的 npm 包。下面的 endpoint、wire 字段和
+ * codec 与 DSH 0.1.6-alpha.2 对齐，但 package 与 invocation id 均归本包所有。
+ */
+import { z } from 'zod';
+const sessionIdSchema = z.string();
+const terminalIdSchema = z.string();
+const attachmentIdSchema = z.string();
+const shellSchema = z.object({
+    path: z.string().readonly(),
+    args: z.array(z.string()).readonly(),
+    name: z.string().readonly(),
+});
+const terminalInfoSchema = z.object({
+    id: terminalIdSchema.readonly(),
+    title: z.string().readonly(),
+    shell: shellSchema.readonly(),
+    cwd: z.string().readonly(),
+    cols: z.number().readonly(),
+    rows: z.number().readonly(),
+    state: z.union([z.literal('running'), z.literal('failed'), z.literal('exited')]).readonly(),
+    exitCode: z.union([z.literal(null), z.number()]).readonly(),
+    error: z.string().readonly().optional(),
+    controllerId: attachmentIdSchema.readonly().optional(),
+});
+const environmentSchema = z.object({
+    cwd: z.string().readonly(),
+    workspaceId: z.string().readonly().optional(),
+    maxInputBytes: z.number().readonly(),
+    maxCols: z.number().readonly(),
+    maxRows: z.number().readonly(),
+    scrollback: z.number().readonly(),
+});
+const createRequestSchema = z.object({
+    shellPath: z.string().readonly().optional(),
+    id: terminalIdSchema.readonly(),
+    cols: z.number().readonly(),
+    rows: z.number().readonly(),
+});
+const terminalFrameSchema = z.union([
+    z.object({
+        type: z.literal('snapshot').readonly(),
+        sequence: z.number().readonly(),
+        screen: z.string().readonly(),
+        info: terminalInfoSchema.readonly(),
+    }),
+    z.object({
+        type: z.literal('output').readonly(),
+        sequence: z.number().readonly(),
+        data: z.string().readonly(),
+    }),
+    z.object({
+        type: z.literal('state').readonly(),
+        info: terminalInfoSchema.readonly(),
+    }),
+]);
+function codec(typeSymbol, schema) {
+    return { mode: 'strict', typeSymbol, schema, create: () => schema };
+}
+function json(name, wire, typeSymbol, schema) {
+    return { name, wire, source: 'json', codec: codec(typeSymbol, schema) };
+}
+function agent() {
+    return {
+        name: 'agent',
+        wire: 'agentId',
+        source: 'lookup',
+        lookup: 'agent',
+        codec: codec('@deepseek-ai/dsh-session/types#SessionId', sessionIdSchema),
+    };
+}
+function invocation(method, parameters, result, options = {}) {
+    return {
+        id: `codingns4dsh#terminal/${method}`,
+        service: 'terminalController',
+        namespace: 'terminal',
+        method,
+        ...(options.stream === true ? { mode: 'stream' } : {}),
+        invocation: { kind: 'direct' },
+        ...(options.agentScoped === true ? { scope: { context: 'agent', wire: 'agentId' } } : {}),
+        parameters,
+        ...(options.cancellable === true ? { cancellation: { parameter: 'signal' } } : {}),
+        result,
+    };
+}
+const voidResult = (method) => codec(`codingns4dsh#terminal/${method}:result`, z.void());
+const idParameter = () => json('id', 'id', 'codingns4dsh/shared#WebTerminalId', terminalIdSchema);
+const attachmentParameter = () => json('attachmentId', 'attachmentId', 'codingns4dsh/shared#TerminalAttachmentId', attachmentIdSchema);
+export const TYPERT = {
+    package: 'codingns4dsh',
+    face: 'host',
+    schemas: [],
+    invocations: [
+        invocation('close', [agent(), idParameter()], voidResult('close'), { agentScoped: true }),
+        invocation('create', [
+            agent(),
+            json('request', 'request', 'codingns4dsh/shared#CodingNsTerminalCreateRequest', createRequestSchema),
+        ], codec('codingns4dsh/shared#CodingNsWebTerminalInfo', terminalInfoSchema), {
+            agentScoped: true,
+            cancellable: true,
+        }),
+        invocation('environment', [agent()], codec('codingns4dsh/shared#CodingNsTerminalEnvironment', environmentSchema), { agentScoped: true, cancellable: true }),
+        invocation('follow', [agent(), idParameter(), attachmentParameter()], codec('codingns4dsh/shared#CodingNsTerminalFrame', terminalFrameSchema), { agentScoped: true, cancellable: true, stream: true }),
+        invocation('list', [json('sessionId', 'sessionId', '@deepseek-ai/dsh-session/types#SessionId', sessionIdSchema)], codec('codingns4dsh#terminal/list:result', z.array(terminalInfoSchema))),
+        invocation('rename', [
+            agent(),
+            idParameter(),
+            json('title', 'title', 'codingns4dsh#terminal/rename:title', z.string()),
+        ], voidResult('rename'), { agentScoped: true }),
+        invocation('resize', [
+            agent(),
+            idParameter(),
+            attachmentParameter(),
+            json('cols', 'cols', 'codingns4dsh#terminal/resize:cols', z.number()),
+            json('rows', 'rows', 'codingns4dsh#terminal/resize:rows', z.number()),
+        ], voidResult('resize'), { agentScoped: true }),
+        invocation('retain', [
+            json('sessionId', 'sessionId', '@deepseek-ai/dsh-session/types#SessionId', sessionIdSchema),
+            idParameter(),
+        ], codec('codingns4dsh/shared#CodingNsTerminalRetentionFrame', z.object({ type: z.literal('retained').readonly() })), { cancellable: true, stream: true }),
+        invocation('shells', [agent()], codec('codingns4dsh#terminal/shells:result', z.array(shellSchema)), { agentScoped: true, cancellable: true }),
+        invocation('write', [
+            agent(),
+            idParameter(),
+            attachmentParameter(),
+            json('data', 'data', 'codingns4dsh#terminal/write:data', z.string()),
+        ], voidResult('write'), { agentScoped: true }),
+    ],
+    model: {
+        services: [{
+                description: 'codingns4dsh Sidebar 终端 UI 使用的兼容 controller。',
+                summary: 'Codingns4DSH 终端 controller',
+                tags: [],
+                jsDoc: '/** codingns4dsh Sidebar 终端 UI 使用的兼容 controller。 */',
+                key: 'terminalController',
+                exportName: 'CodingNsTerminalController',
+                members: [
+                    'environment', 'shells', 'list', 'create', 'retain',
+                    'follow', 'write', 'resize', 'rename', 'close',
+                ].map((name) => ({ name, signature: `${name}(...)`, kind: 'method' })),
+                types: [],
+            }],
+        events: [],
+        objects: [],
+    },
+};
+//# sourceMappingURL=typert.host.js.map

package/dsh.bundle.patch

@@ -0,0 +1,12 @@
+# 官方终端 Host 与 Client 行必须成对停用，避免重复 terminal namespace 和
+# webTerminals service；codingns4dsh 在同一个 Bundle generation 中提供两者。
+# rc3 没有这两个行，DSH 会按可选 patch 记录 warning 并继续启动；alpha2 则会正常命中。
+- id: terminal-controller
+  name: '@deepseek-ai/dsh-api-terminal-controller'
+  disabled: true
+- id: ui-sidebar-terminal
+  name: '@deepseek-ai/dsh-client-ui-sidebar-terminal'
+  disabled: true
+- insert:
+    - id: codingns4dsh
+      name: '@jingyi0605/codingns4dsh'

package/package.json

@@ -0,0 +1,135 @@
+{
+  "name": "@jingyi0605/codingns4dsh",
+  "version": "0.1.0",
+  "description": "Codingns4DSH 的 DeepSeek Harness 插件骨架与连接契约",
+  "type": "module",
+  "main": "./data/build/dist/index.js",
+  "types": "./data/build/dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./data/build/dist/index.d.ts",
+      "default": "./data/build/dist/index.js"
+    },
+    "./host": {
+      "types": "./data/build/dist/host/index.d.ts",
+      "default": "./data/build/dist/host/index.js"
+    },
+    "./typert": {
+      "types": "./data/build/dist/typert.host.d.ts",
+      "default": "./data/build/dist/typert.host.js"
+    },
+    "./client": {
+      "types": "./data/build/dist/client/index.d.ts",
+      "default": "./data/build/dist/client/bundle.js"
+    },
+    "./client/lan-access": {
+      "types": "./data/build/dist/client/lan-access.d.ts",
+      "default": "./data/build/dist/client/lan-access.js"
+    },
+    "./bootstrap": {
+      "types": "./data/build/dist/bootstrap/index.d.ts",
+      "default": "./data/build/dist/bootstrap/index.js"
+    },
+    "./shared": {
+      "types": "./data/build/dist/shared/index.d.ts",
+      "default": "./data/build/dist/shared/index.js"
+    },
+    "./features": {
+      "types": "./data/build/dist/features/index.d.ts",
+      "default": "./data/build/dist/features/index.js"
+    },
+    "./transport": {
+      "types": "./data/build/dist/transport/index.d.ts",
+      "default": "./data/build/dist/transport/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "engines": {
+    "dsh": ">=0.1.5-rc.3 <0.1.7-0",
+    "node": ">=22.19.0"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/dsh": ">=0.1.5-rc.3 <0.1.7-0"
+  },
+  "dsh": {
+    "manifestVersion": 1,
+    "bundle": {
+      "patch": "./dsh.bundle.patch"
+    },
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-api-remotes",
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-connection",
+        "@deepseek-ai/dsh-client-ui-conversation",
+        "@deepseek-ai/dsh-client-ui-layout",
+        "@deepseek-ai/dsh-client-ui-settings",
+        "@deepseek-ai/dsh-client-ui-renderer",
+        "@deepseek-ai/dsh-client-ui-session",
+        "@deepseek-ai/dsh-client-ui-sidebar-right",
+        "@deepseek-ai/dsh-client-ui-theme"
+      ],
+      "platform": "web",
+      "immediately": true
+    }
+  },
+  "scripts": {
+    "preinstall": "node scripts/check-dsh-install.mjs",
+    "version:check": "node scripts/check-version-sync.mjs",
+    "version:set-plugin": "node scripts/set-plugin-version.mjs",
+    "version:set-dsh": "node scripts/set-dsh-version.mjs",
+    "prebuild": "pnpm run version:check",
+    "build": "node scripts/clean-dist.mjs && tsc -p tsconfig.json && pnpm run bundle:client && pnpm run bundle:h5",
+    "prepack": "pnpm run build",
+    "publish:local": "bash scripts/publish-npm-package.sh",
+    "bundle:client": "tsdown",
+    "bundle:h5": "tsdown --config tsdown.h5.config.ts",
+    "dev:link": "node scripts/link-dsh-dev.mjs",
+    "dev:watch": "node scripts/dev-watch.mjs",
+    "watch:client": "tsdown --watch",
+    "test": "pnpm run build && node --test tests/*.spec.ts",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  },
+  "files": [
+    "data/build/dist/**/*.js",
+    "data/build/dist/**/*.d.ts",
+    "assets/provider-icons/**",
+    "dsh.bundle.patch",
+    "profile/**",
+    "version.json",
+    "README.md",
+    "package.json",
+    "scripts/check-dsh-install.mjs"
+  ],
+  "devDependencies": {
+    "@deepseek-ai/cordis": "^4.0.2",
+    "@deepseek-ai/dsh-client-connection": "0.1.6-alpha.2",
+    "@deepseek-ai/dsh-client-ui-renderer": "0.1.6-alpha.2",
+    "@deepseek-ai/dsh-client-ui-settings": "0.1.6-alpha.2",
+    "@deepseek-ai/dsh-client-ui-slots": "0.1.6-alpha.2",
+    "@deepseek-ai/dsh-settings": "0.1.6-alpha.2",
+    "@types/react": "~18.3.1",
+    "@types/ws": "^8.18.1",
+    "react": "^18.2.0",
+    "tsdown": "^0.22.2",
+    "typescript": "^5.9.2"
+  },
+  "dependencies": {
+    "@deepseek-ai/dsh-api-remotes": "0.1.6-alpha.2",
+    "@deepseek-ai/dsh-client-locale": "0.1.6-alpha.2",
+    "@deepseek-ai/dsh-client-ui-conversation": "0.1.6-alpha.2",
+    "@deepseek-ai/dsh-client-ui-layout": "0.1.6-alpha.2",
+    "@deepseek-ai/dsh-client-ui-primitives": "0.1.6-alpha.2",
+    "@deepseek-ai/dsh-client-ui-session": "0.1.6-alpha.2",
+    "@deepseek-ai/dsh-client-ui-sidebar-right": "0.1.6-alpha.2",
+    "@deepseek-ai/dsh-client-ui-theme": "0.1.6-alpha.2",
+    "@deepseek-ai/dsh-typert-protocol": "0.1.6-alpha.2",
+    "@deepseek-ai/schemastery": "^3.18.2",
+    "@lydell/node-pty": "1.1.0",
+    "@xterm/addon-fit": "^0.11.0",
+    "@xterm/xterm": "^6.0.0",
+    "werift": "^0.24.4",
+    "ws": "^8.21.0",
+    "zod": "^4.4.3"
+  }
+}

package/profile/README.md

@@ -0,0 +1,27 @@
+# Codingns4DSH DSH Profile
+
+这是独立的 Codingns4DSH Profile，插件版本为 `0.1.0`，兼容 DSH `>=0.1.5-rc.3 <0.1.7-0`，当前测试版本为 `0.1.6-alpha.2`。
+
+Profile 只选择 `@jingyi0605/codingns4dsh` Bundle。`cordis.patch.yml` 保持 `[]`，因为启动期
+Transport 必须由外部 pre-Cordis 启动胶水在 DSH Client/Cordis 创建前登记，不能由
+普通动态插件覆盖默认 `connection`。
+
+发布后，在 DSH 的 Profile 中安装精确版本的插件 Bundle：
+
+```bash
+dsh plugin --profile codingns4dsh add @jingyi0605/codingns4dsh@0.1.0
+```
+
+Profile 安装完成后，使用 DSH 官方启动器启动：
+
+```bash
+dsh --profile codingns4dsh --dump-config
+```
+
+Profile 和插件安装前都会读取当前 `dsh --version`；版本不在 Profile 的 `engines.dsh`
+范围内时，安装直接失败。启动时 Host、Client 和 Bootstrap 还会再次校验实际 DSH 版本，
+不兼容版本不会启用插件。
+
+真实 Transport 工厂完成后，桌面壳或页面应先调用 `codingns4dsh/bootstrap` 的
+`bootWithPreCordisTransport()`，再启动 DSH Client。DSH 升级后必须先发布匹配的新
+Profile 和启动胶水版本。

package/profile/cordis.patch.yml

@@ -0,0 +1,2 @@
+# 阶段 0 的示例 Profile 不覆盖任何 Host 行。
+[]