@jingyi0605/codingns4dsh 0.1.0

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

@@ -0,0 +1,248 @@
+import { CODINGNS_SETTINGS_NAMESPACE } from '../shared/contracts/config.js';
+import { CodingNsRpcError } from './rpc-table.js';
+/**
+ * 创建 Codingns4DSH Host RPC 主处理器。
+ *
+ * 它只做一次 `namespace/action` 前缀解析，具体动作由各功能模块在启动时登记的
+ * 命名空间处理器实现；新增模块不需要修改这个文件。这是浏览器表单与 Host 能力
+ * 之间的唯一边界：密码只在一次 RPC 请求中经过 Host，refresh token 只进入 Host
+ * 凭据存储。
+ */
+export function createCodingNsRpcHandler(table) {
+    return async (endpoint, payload) => {
+        const target = table.resolve(endpoint);
+        if (target === null) {
+            return failure('CODINGNS_RPC_NOT_FOUND', `未知 Codingns4DSH RPC: ${endpoint}`);
+        }
+        try {
+            return success(await target.handler(target.action, payload));
+        }
+        catch (error) {
+            return failure(errorCode(error), error instanceof Error ? error.message : String(error));
+        }
+    };
+}
+/** 在当前 Connection 上挂载 Codingns4DSH RPC 主处理器；注销由调用方的 effect 负责。 */
+export function registerCodingNsRpc(ctx, table, settingsProvider) {
+    // 连接服务的 rpc.handle 内部会把路由注册延迟到另一个 effect；该 effect 的 owner
+    // 不携带本插件的 webServer 注入，在部分 DSH 版本中会直接失败。因此这里捕获已经
+    // 注入的服务实例，挂载同协议的前缀路由，避免把 RPC 请求落到 SPA fallback。
+    const webServer = ctx.webServer;
+    const connection = ctx.connection;
+    ctx.effect(() => {
+        const unregisterSettings = settingsProvider === undefined
+            ? undefined
+            : table.register('settings', createCodingNsSettingsRpcHandler(settingsProvider));
+        const handler = createCodingNsRpcHandler(table);
+        const unregisterChannel = webServer.register({
+            kind: 'prefix',
+            path: '/codingns',
+            handler: (request, response) => handleChannelRequest(request, response, connection, handler),
+        });
+        // 保留旧的精确 Fetch 路由，兼容早期 H5/桌面载体直接访问 `/api/codingns/*`
+        // 的调用方。两条入口共享同一个 handler，不复制任何业务逻辑。
+        const disposeFetch = CODINGNS_RPC_ENDPOINTS.map((endpoint) => ctx.connection.fetch.register({
+            path: `/api/codingns/${endpoint}`,
+            methods: ['POST'],
+            requestBody: 'buffered',
+            fetch: async (request) => handleFetchRpc(request, endpoint, handler),
+        }));
+        return async () => {
+            for (const dispose of disposeFetch.reverse())
+                await dispose();
+            unregisterChannel();
+            unregisterSettings?.();
+        };
+    }, 'codingns4dsh: Host RPC');
+}
+async function handleChannelRequest(request, response, connection, handler) {
+    const abortController = new AbortController();
+    request.once('close', () => abortController.abort());
+    const rejection = connection.requestRejection({ headers: request.headers });
+    if (rejection !== undefined) {
+        response.statusCode = rejection;
+        response.end(rejection === 401 ? 'unauthorized' : 'forbidden');
+        return;
+    }
+    const endpoint = endpointFromChannelUrl(request.url);
+    if (request.method !== 'POST' || endpoint === undefined) {
+        response.statusCode = 404;
+        response.end('not found');
+        return;
+    }
+    const contentType = request.headers['content-type']?.split(';', 1)[0]?.trim().toLowerCase();
+    if (contentType !== 'application/json') {
+        response.statusCode = 415;
+        response.end('content type must be application/json');
+        return;
+    }
+    let body;
+    try {
+        body = JSON.parse(await readRequestBody(request));
+    }
+    catch {
+        response.statusCode = 400;
+        response.end('body is not JSON');
+        return;
+    }
+    if (!isRecord(body) || body.type !== 'client-request' || typeof body.rpcId !== 'string' || typeof body.method !== 'string') {
+        writeRpcResponse(response, typeof body?.rpcId === 'string' ? body.rpcId : 'invalid-request', {
+            ok: false,
+            error: { code: 'gateway/bad-request', message: 'invalid client-request message', details: {} },
+        });
+        return;
+    }
+    if (body.method !== endpoint) {
+        writeRpcResponse(response, body.rpcId, {
+            ok: false,
+            error: { code: 'gateway/bad-request', message: `method ${JSON.stringify(body.method)} does not match endpoint ${JSON.stringify(endpoint)}`, details: {} },
+        });
+        return;
+    }
+    try {
+        writeRpcResponse(response, body.rpcId, await handler(endpoint, body.payload, abortController.signal));
+    }
+    catch (error) {
+        response.statusCode = 500;
+        response.end(`handler failure: ${String(error)}`);
+    }
+}
+function endpointFromChannelUrl(rawUrl) {
+    if (rawUrl === undefined)
+        return undefined;
+    const pathname = new URL(rawUrl, 'http://127.0.0.1').pathname;
+    if (!pathname.startsWith('/codingns/'))
+        return undefined;
+    const endpoint = pathname.slice('/codingns/'.length);
+    if (endpoint === '' || endpoint.split('/').some((segment) => segment === '' || segment === '.' || segment === '..' || !/^[A-Za-z0-9_$.-]+$/u.test(segment)))
+        return undefined;
+    return endpoint;
+}
+async function readRequestBody(request) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of request) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        size += buffer.byteLength;
+        if (size > 4 * 1024 * 1024)
+            throw new Error('request body too large');
+        chunks.push(buffer);
+    }
+    return Buffer.concat(chunks).toString('utf8');
+}
+function writeRpcResponse(response, rpcId, result) {
+    const body = JSON.stringify({ type: 'server-response', rpcId, result });
+    response.statusCode = 200;
+    response.setHeader('content-type', 'application/json; charset=utf-8');
+    response.end(body);
+}
+const CODINGNS_RPC_ENDPOINTS = [
+    'auth/snapshot', 'auth/login', 'auth/logout', 'auth/devices', 'auth/bind', 'auth/unbind', 'auth/signalingTicket', 'auth/dsh/device/list', 'auth/dsh/device/start', 'auth/dsh/device/stop', 'auth/dsh/device/status', 'auth/dsh/relayTicket',
+    'host/status',
+    'settings/get', 'settings/set',
+    'terminal/status',
+    'terminalProcess/profile/list', 'terminalProcess/profile/create', 'terminalProcess/profile/delete',
+    'terminalProcess/launch', 'terminalProcess/runtime/list', 'terminalProcess/runtime/get', 'terminalProcess/runtime/stop',
+    'debug/config/get', 'debug/config/save', 'debug/config/update', 'debug/config/delete', 'debug/profile/list', 'debug/profile/launch',
+    'debug/runtime/get', 'debug/runtime/list', 'debug/runtime/stop',
+    'debug/port/check', 'debug/port/terminate', 'debug/port/kill', 'debug/proxy/get', 'debug/proxy/enable', 'debug/proxy/disable',
+    'lanAccessDsh/addresses', 'lanAccessDsh/detect', 'lanAccessDsh/get', 'lanAccessDsh/settings/get', 'lanAccessDsh/settings/set', 'lanAccessDsh/login/get', 'lanAccessDsh/login/set', 'lanAccessDsh/login/session/open', 'lanAccessDsh/start', 'lanAccessDsh/stop',
+    'cli/catalog', 'cli/models', 'cli/adapter/set', 'cli/session/get', 'cli/session/set', 'cli/session/list', 'cli/session/adapter-map', 'cli/session/archive', 'cli/session/steer', 'cli/session/follow-up', 'cli/session/interrupt', 'cli/subscription',
+];
+/** 创建远程设置处理器；只允许 Codingns4DSH 自己的 namespace 和路径编辑。 */
+export function createCodingNsSettingsRpcHandler(provider) {
+    return async (action, payload) => {
+        if (action === 'get')
+            return readCodingNsSettings(provider);
+        if (action === 'set') {
+            if (!provider.writable)
+                throw new CodingNsRpcError('CODINGNS_SETTINGS_READ_ONLY', 'Host 设置提供器当前只读');
+            const input = parseSettingsMutation(payload);
+            await provider.mutate(CODINGNS_SETTINGS_NAMESPACE, input.ops, input.expectedRevision);
+            return readCodingNsSettings(provider);
+        }
+        throw new CodingNsRpcError('CODINGNS_RPC_NOT_FOUND', `未知 Codingns4DSH RPC: settings/${action}`);
+    };
+}
+function readCodingNsSettings(provider) {
+    const descriptor = provider.describe({ redactSecrets: true }).find((item) => item.ns === CODINGNS_SETTINGS_NAMESPACE);
+    if (descriptor === undefined)
+        throw new CodingNsRpcError('CODINGNS_SETTINGS_UNAVAILABLE', 'Codingns4DSH 设置尚未注册');
+    const value = provider.get(CODINGNS_SETTINGS_NAMESPACE);
+    // cliSessions 是 Host-only 索引，包含 providerSessionId/rawStoreRef，不能通过设置 RPC
+    // 暴露给浏览器。外部会话列表必须走 cli/session/list，由 Host 按需返回摘要。
+    const { cliSessions: _cliSessions, ...clientValue } = value;
+    return { value: clientValue, revision: descriptor.revision };
+}
+function parseSettingsMutation(value) {
+    if (!isRecord(value) || !Array.isArray(value.ops) || value.ops.length === 0 || value.ops.length > 8) {
+        throw new TypeError('settings/set 参数必须包含 1 到 8 个 ops');
+    }
+    const expectedRevisionValue = value.expectedRevision;
+    if (expectedRevisionValue !== undefined && (typeof expectedRevisionValue !== 'number' || !Number.isInteger(expectedRevisionValue) || expectedRevisionValue < 0)) {
+        throw new TypeError('expectedRevision 必须是非负整数');
+    }
+    const ops = value.ops.map(parseSettingsOp);
+    return expectedRevisionValue === undefined ? { ops } : { ops, expectedRevision: expectedRevisionValue };
+}
+function parseSettingsOp(value) {
+    if (!isRecord(value) || (value.op !== 'set' && value.op !== 'unset') || !Array.isArray(value.path)) {
+        throw new TypeError('设置操作必须是 { op, path, value? }');
+    }
+    const path = value.path;
+    if (path.length === 0 || path.length > 3 || path.some((part) => typeof part !== 'string' || !/^[A-Za-z][A-Za-z0-9_-]*$/u.test(part))) {
+        throw new TypeError('设置路径非法');
+    }
+    if (!isAllowedSettingsPath(path))
+        throw new CodingNsRpcError('CODINGNS_SETTINGS_FIELD_FORBIDDEN', `禁止修改设置字段: ${path.join('.')}`);
+    if (value.op === 'unset')
+        return { op: 'unset', path };
+    if (!('value' in value))
+        throw new TypeError('set 操作缺少 value');
+    return { op: 'set', path, value: value.value };
+}
+function isAllowedSettingsPath(path) {
+    if (path.length === 1)
+        return ['controlBaseUrl', 'controlBaseUrls', 'terminalEnhancement', 'workspaceSessionEnhancement'].includes(path[0] ?? '');
+    if (path[0] === 'modules')
+        return path.length === 2 && ['lanAccess', 'reverseProxy', 'cliAdapters', 'terminalEnhancement', 'workspaceSessionEnhancement', 'debug'].includes(path[1] ?? '');
+    if (path[0] === 'workspaceSessionEnhancement') {
+        return path.length === 2 && ['showAdapterLogo', 'showArchivedSessions', 'showSubscriptionUsage'].includes(path[1] ?? '');
+    }
+    return path[0] === 'lanAccessDsh' && path.length === 2 && ['autoStart', 'listenHost', 'listenPort', 'dshPort'].includes(path[1] ?? '');
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+async function handleFetchRpc(request, endpoint, handler) {
+    let body;
+    try {
+        body = await request.json();
+    }
+    catch {
+        return new Response('body is not JSON', { status: 400 });
+    }
+    if (!body || typeof body !== 'object')
+        return new Response('invalid RPC envelope', { status: 400 });
+    const envelope = body;
+    const method = envelope.method;
+    if (typeof envelope.rpcId !== 'string' || (method !== endpoint && method !== `codingns/${endpoint}`)) {
+        return new Response('invalid RPC envelope', { status: 400 });
+    }
+    const result = await handler(endpoint, envelope.payload, request.signal);
+    return Response.json({ type: 'server-response', rpcId: envelope.rpcId, result });
+}
+function success(value) {
+    return { ok: true, value };
+}
+function failure(code, message) {
+    return { ok: false, error: { code, message, details: {} } };
+}
+function errorCode(error) {
+    if (error && typeof error === 'object' && 'errorCode' in error && typeof error.errorCode === 'string')
+        return error.errorCode;
+    if (error instanceof Error && error.name)
+        return error.name;
+    return 'CODINGNS_RPC_FAILED';
+}
+//# sourceMappingURL=rpc.js.map

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

@@ -0,0 +1,19 @@
+import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+import type { SettingsScope } from '@deepseek-ai/dsh-settings';
+import { type CodingNsSettings } from '../shared/contracts/config.js';
+/**
+ * DSH 设置服务使用的 Codingns4DSH namespace schema。
+ *
+ * 模块开关用字典表达：新增模块只是字典里多一个键，既不需要改这个 schema，
+ * 也不需要改 CodingNsSettings 接口。
+ */
+export declare const CodingNsSettingsSchema: z<CodingNsSettings>;
+/**
+ * 在 Host 设置文档中注册 Codingns4DSH 的持久化选项。
+ *
+ * 必须在已经注入 `settings` 的上下文里调用。返回的 scope 既用于读取当前值，
+ * 也通过 watch 驱动功能模块启停。
+ */
+export declare function registerCodingNsSettings(ctx: Context): SettingsScope<CodingNsSettings>;
+//# sourceMappingURL=settings.d.ts.map

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

@@ -0,0 +1,80 @@
+import z from '@deepseek-ai/schemastery';
+import { CODINGNS_SETTINGS_NAMESPACE, DEFAULT_CODINGNS_SETTINGS, } from '../shared/contracts/config.js';
+/**
+ * DSH 设置服务使用的 Codingns4DSH namespace schema。
+ *
+ * 模块开关用字典表达：新增模块只是字典里多一个键，既不需要改这个 schema，
+ * 也不需要改 CodingNsSettings 接口。
+ */
+export const CodingNsSettingsSchema = z.object({
+    controlBaseUrl: z.string().default(DEFAULT_CODINGNS_SETTINGS.controlBaseUrl),
+    controlBaseUrls: z.array(z.string()).default(DEFAULT_CODINGNS_SETTINGS.controlBaseUrls),
+    modules: z.dict(z.boolean()).default(DEFAULT_CODINGNS_SETTINGS.modules),
+    agentAdapters: z.dict(z.boolean()).default(DEFAULT_CODINGNS_SETTINGS.agentAdapters ?? {}),
+    agentAdapterPreferences: z.dict(z.object({
+        modelId: z.union([z.string(), z.const(undefined)]),
+        effortId: z.union([z.string(), z.const(undefined)]),
+    })).default({}),
+    // 会话索引是 Host 摘要数据，不能让它进入浏览器状态或模型上下文。
+    cliSessions: z.array(z.any()).default(DEFAULT_CODINGNS_SETTINGS.cliSessions ?? []),
+    lanAccessDsh: z.object({
+        autoStart: z.boolean().default(DEFAULT_CODINGNS_SETTINGS.lanAccessDsh.autoStart),
+        listenHost: z.string().default(DEFAULT_CODINGNS_SETTINGS.lanAccessDsh.listenHost),
+        listenPort: z.number().default(DEFAULT_CODINGNS_SETTINGS.lanAccessDsh.listenPort),
+        dshPort: z.number().default(DEFAULT_CODINGNS_SETTINGS.lanAccessDsh.dshPort),
+    }).default(DEFAULT_CODINGNS_SETTINGS.lanAccessDsh),
+    terminalEnhancement: z.object({
+        bindingScope: z.union([z.const('workspace'), z.const('session')])
+            .default(DEFAULT_CODINGNS_SETTINGS.terminalEnhancement.bindingScope ?? 'workspace'),
+        defaultProfile: z.union([
+            z.const('system'), z.const('zsh'), z.const('bash'),
+            z.const('powershell'), z.const('cmd'), z.const('git-bash'),
+        ]).default(DEFAULT_CODINGNS_SETTINGS.terminalEnhancement.defaultProfile),
+        appearance: z.object({
+            theme: z.union([z.const('inherit'), z.const('custom')])
+                .default(DEFAULT_CODINGNS_SETTINGS.terminalEnhancement.appearance.theme),
+            background: nullableColorSchema(),
+            foreground: nullableColorSchema(),
+            cursorColor: nullableColorSchema(),
+            fontFamily: z.union([
+                z.string().min(1).max(128).pattern(/^[^\u0000-\u001F\u007F]+$/u),
+                z.const(null),
+            ]).default(null),
+            fontSize: nullableNumberSchema(10, 32),
+            lineHeight: nullableNumberSchema(1, 2),
+            cursorStyle: z.union([
+                z.const('block'), z.const('bar'), z.const('underline'), z.const(null),
+            ]).default(null),
+            cursorBlink: z.union([z.boolean(), z.const(null)]).default(null),
+            scrollback: z.union([z.number().step(1).min(1000).max(100000), z.const(null)]).default(null),
+        }).default(DEFAULT_CODINGNS_SETTINGS.terminalEnhancement.appearance),
+    }).default({
+        ...DEFAULT_CODINGNS_SETTINGS.terminalEnhancement,
+        bindingScope: DEFAULT_CODINGNS_SETTINGS.terminalEnhancement.bindingScope ?? 'workspace',
+    }),
+    workspaceSessionEnhancement: z.object({
+        showAdapterLogo: z.boolean().default(DEFAULT_CODINGNS_SETTINGS.workspaceSessionEnhancement.showAdapterLogo),
+        showArchivedSessions: z.boolean().default(DEFAULT_CODINGNS_SETTINGS.workspaceSessionEnhancement.showArchivedSessions),
+        showSubscriptionUsage: z.boolean().default(DEFAULT_CODINGNS_SETTINGS.workspaceSessionEnhancement.showSubscriptionUsage),
+    }).default(DEFAULT_CODINGNS_SETTINGS.workspaceSessionEnhancement),
+});
+/** 颜色字段只接受完整十六进制颜色，`null` 表示继承 DSH 原生值。 */
+function nullableColorSchema() {
+    return z.union([z.string().pattern(/^#[0-9A-Fa-f]{6}$/u), z.const(null)]).default(null);
+}
+function nullableNumberSchema(min, max) {
+    return z.union([z.number().min(min).max(max), z.const(null)]).default(null);
+}
+/**
+ * 在 Host 设置文档中注册 Codingns4DSH 的持久化选项。
+ *
+ * 必须在已经注入 `settings` 的上下文里调用。返回的 scope 既用于读取当前值，
+ * 也通过 watch 驱动功能模块启停。
+ */
+export function registerCodingNsSettings(ctx) {
+    const settings = ctx.settings;
+    return settings.register(CODINGNS_SETTINGS_NAMESPACE, CodingNsSettingsSchema, {
+        applies: 'live',
+    });
+}
+//# sourceMappingURL=settings.js.map

package/data/build/dist/host/terminal/attachment-registry.d.ts

@@ -0,0 +1,17 @@
+import type { CodingNsTerminalRuntimeType, TerminalAttachmentRecord, TerminalRecordIdentity } from '../../shared/contracts/terminal.js';
+export interface ManagedTerminalAttachment extends TerminalAttachmentRecord {
+    readonly identity: TerminalRecordIdentity;
+    readonly runtimeType: CodingNsTerminalRuntimeType;
+}
+/** generation 级 attach 注册表；这里只持有短命连接，绝不写入持久存储。 */
+export declare class TerminalAttachmentRegistry {
+    private readonly attachments;
+    add(attachment: ManagedTerminalAttachment): void;
+    get(subscriptionId: string): ManagedTerminalAttachment | undefined;
+    isCurrent(subscriptionId: string, generation: string, runtimeAttachmentId: string): boolean;
+    remove(subscriptionId: string): ManagedTerminalAttachment | undefined;
+    listByGeneration(generation: string): readonly ManagedTerminalAttachment[];
+    listByTerminal(identity: TerminalRecordIdentity): readonly ManagedTerminalAttachment[];
+    list(): readonly ManagedTerminalAttachment[];
+}
+//# sourceMappingURL=attachment-registry.d.ts.map

package/data/build/dist/host/terminal/attachment-registry.js

@@ -0,0 +1,49 @@
+/** generation 级 attach 注册表；这里只持有短命连接，绝不写入持久存储。 */
+export class TerminalAttachmentRegistry {
+    attachments = new Map();
+    add(attachment) {
+        if (this.attachments.has(attachment.subscriptionId)) {
+            throw new Error(`终端订阅已经存在: ${attachment.subscriptionId}`);
+        }
+        this.attachments.set(attachment.subscriptionId, cloneAttachment(attachment));
+    }
+    get(subscriptionId) {
+        const attachment = this.attachments.get(subscriptionId);
+        return attachment === undefined ? undefined : cloneAttachment(attachment);
+    }
+    isCurrent(subscriptionId, generation, runtimeAttachmentId) {
+        const attachment = this.attachments.get(subscriptionId);
+        return attachment?.generation === generation
+            && attachment.runtimeAttachmentId === runtimeAttachmentId;
+    }
+    remove(subscriptionId) {
+        const attachment = this.attachments.get(subscriptionId);
+        if (attachment === undefined)
+            return undefined;
+        this.attachments.delete(subscriptionId);
+        return cloneAttachment(attachment);
+    }
+    listByGeneration(generation) {
+        return [...this.attachments.values()]
+            .filter((attachment) => attachment.generation === generation)
+            .map(cloneAttachment);
+    }
+    listByTerminal(identity) {
+        return [...this.attachments.values()]
+            .filter((attachment) => sameIdentity(attachment.identity, identity))
+            .map(cloneAttachment);
+    }
+    list() {
+        return [...this.attachments.values()].map(cloneAttachment);
+    }
+}
+function sameIdentity(left, right) {
+    return left.hostId === right.hostId
+        && left.workspaceId === right.workspaceId
+        && left.dshSessionId === right.dshSessionId
+        && left.terminalId === right.terminalId;
+}
+function cloneAttachment(attachment) {
+    return { ...attachment, identity: { ...attachment.identity } };
+}
+//# sourceMappingURL=attachment-registry.js.map

package/data/build/dist/host/terminal/backends/conpty-backend.d.ts

@@ -0,0 +1,39 @@
+import { type ConptyBrokerClientLike } from '../broker/conpty-broker-client.js';
+import { type TerminalRuntimeAdapter, type TerminalRuntimeAttachInput, type TerminalRuntimeAttachment, type TerminalRuntimeCreateInput, type TerminalRuntimeIdentity, type TerminalRuntimeResizeInput, type TerminalRuntimeSession, type TerminalRuntimeWriteInput } from '../runtime-adapter.js';
+export interface ConptyBackendOptions {
+    readonly platform?: string;
+    readonly brokerClient?: ConptyBrokerClientLike;
+    readonly launchBroker?: (input: {
+        readonly pipeName: string;
+        readonly auth: string;
+        readonly shellPath: string;
+        readonly shellArgs: readonly string[];
+        readonly cwd: string;
+        readonly env: Readonly<Record<string, string | undefined>>;
+    }) => void;
+    readonly startupAttempts?: number;
+    readonly startupDelayMs?: number;
+}
+/** DSH 进程只启动和连接 broker；真正的 ConPTY 始终由 detached broker 持有。 */
+export declare class ConptyTerminalBackend implements TerminalRuntimeAdapter {
+    readonly runtimeTypes: readonly ["conpty-powershell", "conpty-cmd", "conpty-git-bash"];
+    private readonly platform;
+    private readonly brokerClient;
+    private readonly launchBroker;
+    private readonly startupAttempts;
+    private readonly startupDelayMs;
+    private readonly attachments;
+    constructor(options?: ConptyBackendOptions);
+    create(input: TerminalRuntimeCreateInput): Promise<TerminalRuntimeIdentity>;
+    inspect(session: TerminalRuntimeSession): Promise<TerminalRuntimeIdentity>;
+    attach(input: TerminalRuntimeAttachInput): Promise<TerminalRuntimeAttachment>;
+    write(input: TerminalRuntimeWriteInput): Promise<void>;
+    resize(input: TerminalRuntimeResizeInput): Promise<void>;
+    detach(attachmentId: string): Promise<void>;
+    terminate(session: TerminalRuntimeSession): Promise<void>;
+    private tryInspect;
+    private getAttachment;
+    private assertSupported;
+}
+export declare function conptyPipeName(runtimeSessionKey: string): string;
+//# sourceMappingURL=conpty-backend.d.ts.map

package/data/build/dist/host/terminal/backends/conpty-backend.js

@@ -0,0 +1,160 @@
+import { spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+import { ConptyBrokerClient, } from '../broker/conpty-broker-client.js';
+import { TerminalRuntimeError, } from '../runtime-adapter.js';
+/** DSH 进程只启动和连接 broker；真正的 ConPTY 始终由 detached broker 持有。 */
+export class ConptyTerminalBackend {
+    runtimeTypes = ['conpty-powershell', 'conpty-cmd', 'conpty-git-bash'];
+    platform;
+    brokerClient;
+    launchBroker;
+    startupAttempts;
+    startupDelayMs;
+    attachments = new Map();
+    constructor(options = {}) {
+        this.platform = options.platform ?? process.platform;
+        this.brokerClient = options.brokerClient ?? new ConptyBrokerClient();
+        this.launchBroker = options.launchBroker ?? launchDetachedBroker;
+        this.startupAttempts = options.startupAttempts ?? 40;
+        this.startupDelayMs = options.startupDelayMs ?? 50;
+    }
+    async create(input) {
+        this.assertSupported(input.session);
+        const existing = await this.tryInspect(input.session);
+        if (existing?.alive)
+            return existing;
+        const pipeName = conptyPipeName(input.session.runtimeSessionKey);
+        this.launchBroker({
+            pipeName,
+            auth: input.session.runtimeSessionKey,
+            shellPath: input.session.commandPath ?? input.session.shellPath,
+            shellArgs: input.session.commandArgs ?? input.session.shellArgs,
+            cwd: input.session.cwd,
+            env: { ...process.env, ...(input.session.commandEnv ?? {}), ...(input.env ?? {}) },
+        });
+        for (let attempt = 0; attempt < this.startupAttempts; attempt += 1) {
+            const identity = await this.tryInspect(input.session);
+            if (identity?.alive)
+                return identity;
+            await delay(this.startupDelayMs);
+        }
+        throw new TerminalRuntimeError('TERMINAL_RUNTIME_CREATE_FAILED', 'ConPTY broker 启动超时');
+    }
+    async inspect(session) {
+        this.assertSupported(session);
+        return (await this.tryInspect(session)) ?? {
+            alive: false,
+            runtimeSessionKey: session.runtimeSessionKey,
+            runtimePid: null,
+            shellPid: null,
+            detail: 'ConPTY broker 不存在或无法连接',
+        };
+    }
+    async attach(input) {
+        this.assertSupported(input.session);
+        let attachmentId = null;
+        const attachment = await this.brokerClient.attach({
+            pipeName: conptyPipeName(input.session.runtimeSessionKey),
+            auth: input.session.runtimeSessionKey,
+            runtimeSessionKey: input.session.runtimeSessionKey,
+            cols: input.cols,
+            rows: input.rows,
+            onData: input.onData,
+            onExit: (exitCode) => {
+                if (attachmentId !== null)
+                    this.attachments.delete(attachmentId);
+                input.onExit?.(exitCode);
+            },
+        });
+        attachmentId = attachment.attachmentId;
+        this.attachments.set(attachment.attachmentId, attachment);
+        return { attachmentId: attachment.attachmentId, identity: attachment.identity };
+    }
+    async write(input) {
+        this.getAttachment(input.attachmentId).write(input.data);
+    }
+    async resize(input) {
+        this.getAttachment(input.attachmentId).resize(input.cols, input.rows);
+    }
+    async detach(attachmentId) {
+        const attachment = this.attachments.get(attachmentId);
+        if (attachment === undefined)
+            return;
+        this.attachments.delete(attachmentId);
+        await attachment.detach();
+    }
+    async terminate(session) {
+        this.assertSupported(session);
+        for (const [attachmentId, attachment] of this.attachments) {
+            if (attachment.identity.runtimeSessionKey === session.runtimeSessionKey)
+                await this.detach(attachmentId);
+        }
+        try {
+            await this.brokerClient.terminate(conptyPipeName(session.runtimeSessionKey), session.runtimeSessionKey);
+        }
+        catch (error) {
+            // 已经消失的 broker 等价于关闭完成，保证显式 close 幂等。
+            if (!isUnavailable(error))
+                throw error;
+        }
+    }
+    async tryInspect(session) {
+        try {
+            return await this.brokerClient.inspect(conptyPipeName(session.runtimeSessionKey), session.runtimeSessionKey, session.runtimeSessionKey);
+        }
+        catch (error) {
+            if (isUnavailable(error))
+                return null;
+            throw error;
+        }
+    }
+    getAttachment(attachmentId) {
+        const attachment = this.attachments.get(attachmentId);
+        if (attachment === undefined)
+            throw new TerminalRuntimeError('TERMINAL_ATTACHMENT_NOT_FOUND', '终端 attach 不存在或已经释放');
+        return attachment;
+    }
+    assertSupported(session) {
+        if (this.platform !== 'win32') {
+            throw new TerminalRuntimeError('TERMINAL_PLATFORM_UNSUPPORTED', 'ConPTY backend 只支持 Windows');
+        }
+        if (!this.runtimeTypes.includes(session.runtimeType)) {
+            throw new TerminalRuntimeError('TERMINAL_PLATFORM_UNSUPPORTED', `ConPTY backend 不支持 ${session.runtimeType}`);
+        }
+    }
+}
+export function conptyPipeName(runtimeSessionKey) {
+    const digest = createHash('sha256').update(runtimeSessionKey).digest('hex').slice(0, 40);
+    return `\\\\.\\pipe\\codingns4dsh-${digest}`;
+}
+function launchDetachedBroker(input) {
+    const scriptPath = fileURLToPath(new URL('../broker/conpty-broker-process.js', import.meta.url));
+    const child = spawn(process.execPath, [
+        scriptPath,
+        '--pipe', input.pipeName,
+        '--shell', input.shellPath,
+        '--cwd', input.cwd,
+    ], {
+        env: {
+            ...input.env,
+            CODINGNS4DSH_TERMINAL_AUTH: input.auth,
+            CODINGNS4DSH_TERMINAL_ARGS: JSON.stringify(input.shellArgs),
+        },
+        detached: true,
+        stdio: 'ignore',
+        windowsHide: true,
+        shell: false,
+    });
+    child.unref();
+}
+function isUnavailable(error) {
+    if (!(error instanceof Error))
+        return false;
+    const code = error.code;
+    return code === 'ENOENT' || code === 'ECONNREFUSED' || code === 'EPIPE';
+}
+function delay(milliseconds) {
+    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+//# sourceMappingURL=conpty-backend.js.map

package/data/build/dist/host/terminal/backends/local-pty-backend.d.ts

@@ -0,0 +1,36 @@
+import { spawn as spawnPty } from '@lydell/node-pty';
+import { type TerminalRuntimeAdapter, type TerminalRuntimeAttachInput, type TerminalRuntimeAttachment, type TerminalRuntimeCreateInput, type TerminalRuntimeIdentity, type TerminalRuntimeResizeInput, type TerminalRuntimeSession, type TerminalRuntimeWriteInput } from '../runtime-adapter.js';
+export interface LocalPtyBackendOptions {
+    readonly platform?: string;
+    readonly ptySpawner?: typeof spawnPty;
+    readonly createAttachmentId?: () => string;
+}
+/**
+ * 非强化模式使用的进程内 PTY。
+ *
+ * shell 由当前 DSH 进程直接持有，不承诺跨 DSH 重启恢复。浏览器 detach 只
+ * 释放订阅；显式关闭或 controller 销毁才结束 shell。
+ */
+export declare class LocalPtyTerminalBackend implements TerminalRuntimeAdapter {
+    readonly runtimeTypes: readonly ["local-pty"];
+    private readonly platform;
+    private readonly ptySpawner;
+    private readonly createAttachmentId;
+    private readonly processes;
+    private readonly attachments;
+    constructor(options?: LocalPtyBackendOptions);
+    create(input: TerminalRuntimeCreateInput): Promise<TerminalRuntimeIdentity>;
+    inspect(session: TerminalRuntimeSession): Promise<TerminalRuntimeIdentity>;
+    attach(input: TerminalRuntimeAttachInput): Promise<TerminalRuntimeAttachment>;
+    write(input: TerminalRuntimeWriteInput): Promise<void>;
+    resize(input: TerminalRuntimeResizeInput): Promise<void>;
+    detach(attachmentId: string): Promise<void>;
+    terminate(session: TerminalRuntimeSession): Promise<void>;
+    dispose(): Promise<void>;
+    private requireAttachment;
+    private handleExit;
+    private removeAttachments;
+    private releaseProcess;
+    private assertSupported;
+}
+//# sourceMappingURL=local-pty-backend.d.ts.map