@jingyi0605/codingns4dsh 0.1.0

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

@@ -0,0 +1,178 @@
+import { randomUUID } from 'node:crypto';
+import { spawn as spawnPty } from '@lydell/node-pty';
+import { TerminalRuntimeError, normalizeTerminalSize, } from '../runtime-adapter.js';
+const MAX_REPLAY_CHARACTERS = 1024 * 1024;
+/**
+ * 非强化模式使用的进程内 PTY。
+ *
+ * shell 由当前 DSH 进程直接持有，不承诺跨 DSH 重启恢复。浏览器 detach 只
+ * 释放订阅；显式关闭或 controller 销毁才结束 shell。
+ */
+export class LocalPtyTerminalBackend {
+    runtimeTypes = ['local-pty'];
+    platform;
+    ptySpawner;
+    createAttachmentId;
+    processes = new Map();
+    attachments = new Map();
+    constructor(options = {}) {
+        this.platform = options.platform ?? process.platform;
+        this.ptySpawner = options.ptySpawner ?? spawnPty;
+        this.createAttachmentId = options.createAttachmentId ?? randomUUID;
+    }
+    async create(input) {
+        this.assertSupported(input.session);
+        const existing = this.processes.get(input.session.runtimeSessionKey);
+        if (existing?.alive)
+            return identityOf(input.session, existing.pty.pid, true);
+        const size = normalizeTerminalSize(input.cols ?? 120, input.rows ?? 30);
+        let pty;
+        try {
+            pty = this.ptySpawner(input.session.commandPath ?? input.session.shellPath, [...(input.session.commandArgs ?? input.session.shellArgs)], {
+                cwd: input.session.cwd,
+                env: { ...process.env, ...(input.session.commandEnv ?? {}), ...(input.env ?? {}) },
+                cols: size.cols,
+                rows: size.rows,
+                name: 'xterm-256color',
+            });
+        }
+        catch (error) {
+            throw new TerminalRuntimeError('TERMINAL_RUNTIME_CREATE_FAILED', '本机 PTY 创建失败', { cause: error });
+        }
+        let state;
+        const dataSubscription = pty.onData((data) => {
+            if (state === undefined || !state.alive)
+                return;
+            state.replay = boundedAppend(state.replay, data);
+            for (const attachment of this.attachments.values()) {
+                if (attachment.runtimeSessionKey === input.session.runtimeSessionKey)
+                    attachment.onData(data);
+            }
+        });
+        const exitSubscription = pty.onExit(({ exitCode }) => {
+            if (state !== undefined)
+                this.handleExit(input.session.runtimeSessionKey, state, exitCode);
+        });
+        state = { pty, dataSubscription, exitSubscription, alive: true, replay: '' };
+        this.processes.set(input.session.runtimeSessionKey, state);
+        return identityOf(input.session, pty.pid, true);
+    }
+    async inspect(session) {
+        this.assertSupported(session);
+        const state = this.processes.get(session.runtimeSessionKey);
+        if (state?.alive)
+            return identityOf(session, state.pty.pid, true);
+        return {
+            ...identityOf(session, null, false),
+            detail: '本机 PTY 不存在或已退出',
+        };
+    }
+    async attach(input) {
+        this.assertSupported(input.session);
+        const state = this.processes.get(input.session.runtimeSessionKey);
+        if (state === undefined || !state.alive) {
+            throw new TerminalRuntimeError('TERMINAL_RUNTIME_LOST', '本机 PTY 已经丢失');
+        }
+        const size = normalizeTerminalSize(input.cols, input.rows);
+        state.pty.resize(size.cols, size.rows);
+        const attachmentId = this.createAttachmentId();
+        if (state.replay !== '')
+            input.onData(state.replay);
+        this.attachments.set(attachmentId, {
+            runtimeSessionKey: input.session.runtimeSessionKey,
+            onData: input.onData,
+            ...(input.onExit === undefined ? {} : { onExit: input.onExit }),
+        });
+        return { attachmentId, identity: identityOf(input.session, state.pty.pid, true) };
+    }
+    async write(input) {
+        const { process } = this.requireAttachment(input.attachmentId);
+        process.pty.write(input.data);
+    }
+    async resize(input) {
+        const { process } = this.requireAttachment(input.attachmentId);
+        const size = normalizeTerminalSize(input.cols, input.rows);
+        process.pty.resize(size.cols, size.rows);
+    }
+    async detach(attachmentId) {
+        this.attachments.delete(attachmentId);
+    }
+    async terminate(session) {
+        this.assertSupported(session);
+        const state = this.processes.get(session.runtimeSessionKey);
+        if (state === undefined)
+            return;
+        this.removeAttachments(session.runtimeSessionKey);
+        this.releaseProcess(session.runtimeSessionKey, state);
+        try {
+            state.pty.kill();
+        }
+        catch { /* PTY 可能已经自然退出 */ }
+    }
+    async dispose() {
+        this.attachments.clear();
+        for (const [runtimeSessionKey, state] of [...this.processes]) {
+            this.releaseProcess(runtimeSessionKey, state);
+            try {
+                state.pty.kill();
+            }
+            catch { /* PTY 可能已经自然退出 */ }
+        }
+    }
+    requireAttachment(attachmentId) {
+        const attachment = this.attachments.get(attachmentId);
+        if (attachment === undefined) {
+            throw new TerminalRuntimeError('TERMINAL_ATTACHMENT_NOT_FOUND', '终端 attach 不存在或已经释放');
+        }
+        const process = this.processes.get(attachment.runtimeSessionKey);
+        if (process === undefined || !process.alive) {
+            throw new TerminalRuntimeError('TERMINAL_RUNTIME_LOST', '本机 PTY 已经丢失');
+        }
+        return { process };
+    }
+    handleExit(runtimeSessionKey, state, exitCode) {
+        if (this.processes.get(runtimeSessionKey) !== state || !state.alive)
+            return;
+        const callbacks = [...this.attachments]
+            .filter(([, attachment]) => attachment.runtimeSessionKey === runtimeSessionKey)
+            .map(([, attachment]) => attachment.onExit);
+        this.removeAttachments(runtimeSessionKey);
+        this.releaseProcess(runtimeSessionKey, state);
+        for (const callback of callbacks)
+            callback?.(exitCode);
+    }
+    removeAttachments(runtimeSessionKey) {
+        for (const [attachmentId, attachment] of this.attachments) {
+            if (attachment.runtimeSessionKey === runtimeSessionKey)
+                this.attachments.delete(attachmentId);
+        }
+    }
+    releaseProcess(runtimeSessionKey, state) {
+        state.alive = false;
+        if (this.processes.get(runtimeSessionKey) === state)
+            this.processes.delete(runtimeSessionKey);
+        state.dataSubscription.dispose();
+        state.exitSubscription.dispose();
+    }
+    assertSupported(session) {
+        if (!['darwin', 'linux', 'win32'].includes(this.platform)) {
+            throw new TerminalRuntimeError('TERMINAL_PLATFORM_UNSUPPORTED', `本机 PTY 不支持 ${this.platform}`);
+        }
+        if (session.runtimeType !== 'local-pty') {
+            throw new TerminalRuntimeError('TERMINAL_PLATFORM_UNSUPPORTED', `本机 PTY 不支持 ${session.runtimeType}`);
+        }
+    }
+}
+function identityOf(session, pid, alive) {
+    return {
+        alive,
+        runtimeSessionKey: session.runtimeSessionKey,
+        runtimePid: pid,
+        shellPid: pid,
+    };
+}
+function boundedAppend(current, data) {
+    const combined = current + data;
+    return combined.length <= MAX_REPLAY_CHARACTERS ? combined : combined.slice(-MAX_REPLAY_CHARACTERS);
+}
+//# sourceMappingURL=local-pty-backend.js.map

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

@@ -0,0 +1,40 @@
+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 TmuxCommandResult {
+    readonly status: number | null;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+export interface TmuxCommandRunner {
+    run(command: string, args: readonly string[]): TmuxCommandResult;
+}
+export interface TmuxBackendOptions {
+    readonly tmuxPath?: string;
+    readonly platform?: string;
+    readonly commandRunner?: TmuxCommandRunner;
+    readonly ptySpawner?: typeof spawnPty;
+    readonly createAttachmentId?: () => string;
+}
+/** tmux 拥有持久 shell，node-pty 这里只承载可随 generation 销毁的 tmux client。 */
+export declare class TmuxTerminalBackend implements TerminalRuntimeAdapter {
+    readonly runtimeTypes: readonly ["tmux"];
+    private readonly tmuxPath;
+    private readonly platform;
+    private readonly runner;
+    private readonly ptySpawner;
+    private readonly createAttachmentId;
+    private readonly attachments;
+    constructor(options?: TmuxBackendOptions);
+    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 getAttachment;
+    private assertSupported;
+    private requireTmuxPath;
+}
+export declare function tmuxSessionName(runtimeSessionKey: string): string;
+//# sourceMappingURL=tmux-backend.d.ts.map

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

@@ -0,0 +1,191 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { spawnSync } from 'node:child_process';
+import { accessSync, constants } from 'node:fs';
+import { spawn as spawnPty } from '@lydell/node-pty';
+import { TerminalRuntimeError, normalizeTerminalSize, } from '../runtime-adapter.js';
+/** tmux 拥有持久 shell，node-pty 这里只承载可随 generation 销毁的 tmux client。 */
+export class TmuxTerminalBackend {
+    runtimeTypes = ['tmux'];
+    tmuxPath;
+    platform;
+    runner;
+    ptySpawner;
+    createAttachmentId;
+    attachments = new Map();
+    constructor(options = {}) {
+        this.platform = options.platform ?? process.platform;
+        this.tmuxPath = options.tmuxPath ?? detectTmuxPath(this.platform);
+        this.runner = options.commandRunner ?? { run: runCommand };
+        this.ptySpawner = options.ptySpawner ?? spawnPty;
+        this.createAttachmentId = options.createAttachmentId ?? randomUUID;
+    }
+    async create(input) {
+        this.assertSupported(input.session);
+        const tmuxPath = this.requireTmuxPath();
+        const current = await this.inspect(input.session);
+        if (current.alive)
+            return current;
+        const name = tmuxSessionName(input.session.runtimeSessionKey);
+        const result = this.runner.run(tmuxPath, [
+            'new-session', '-d', '-s', name,
+            ...Object.entries(input.session.commandEnv ?? {}).flatMap(([key, value]) => ['-e', `${key}=${value}`]),
+            '-c', input.session.cwd,
+            ...tmuxLaunchCommand(input.session),
+        ]);
+        if (result.status !== 0) {
+            throw new TerminalRuntimeError(result.status === null ? 'TERMINAL_RUNTIME_UNAVAILABLE' : 'TERMINAL_RUNTIME_CREATE_FAILED', sanitizeCommandError('tmux 会话创建失败', result.stderr));
+        }
+        return this.inspect(input.session);
+    }
+    async inspect(session) {
+        this.assertSupported(session);
+        if (this.tmuxPath === null)
+            return {
+                alive: false,
+                runtimeSessionKey: session.runtimeSessionKey,
+                runtimePid: null,
+                shellPid: null,
+                detail: '未找到可执行的 tmux',
+            };
+        const result = this.runner.run(this.tmuxPath, ['has-session', '-t', tmuxSessionName(session.runtimeSessionKey)]);
+        if (result.status === null) {
+            throw new TerminalRuntimeError('TERMINAL_RUNTIME_UNAVAILABLE', sanitizeCommandError('tmux 不可执行', result.stderr));
+        }
+        if (result.status !== 0 && !isMissingSession(result.stderr)) {
+            throw new TerminalRuntimeError('TERMINAL_RUNTIME_UNAVAILABLE', sanitizeCommandError('tmux 会话检查失败', result.stderr));
+        }
+        return {
+            alive: result.status === 0,
+            runtimeSessionKey: session.runtimeSessionKey,
+            runtimePid: null,
+            shellPid: null,
+            ...(result.status === 0 ? {} : { detail: sanitizeCommandError('tmux 会话不存在', result.stderr) }),
+        };
+    }
+    async attach(input) {
+        const identity = await this.inspect(input.session);
+        if (!identity.alive) {
+            throw new TerminalRuntimeError('TERMINAL_RUNTIME_LOST', 'tmux 会话已经丢失');
+        }
+        const size = normalizeTerminalSize(input.cols, input.rows);
+        const tmuxPath = this.requireTmuxPath();
+        const attachmentId = this.createAttachmentId();
+        const name = tmuxSessionName(input.session.runtimeSessionKey);
+        const pty = this.ptySpawner(tmuxPath, ['attach-session', '-t', name], {
+            cwd: input.session.cwd,
+            env: { ...process.env, ...(input.env ?? {}) },
+            cols: size.cols,
+            rows: size.rows,
+            name: 'xterm-256color',
+        });
+        const state = { sessionName: name, pty, detached: false };
+        this.attachments.set(attachmentId, state);
+        pty.onData((data) => {
+            if (!state.detached)
+                input.onData(data);
+        });
+        pty.onExit(({ exitCode }) => {
+            if (this.attachments.get(attachmentId) === state)
+                this.attachments.delete(attachmentId);
+            if (!state.detached)
+                input.onExit?.(exitCode);
+        });
+        return { attachmentId, identity };
+    }
+    async write(input) {
+        this.getAttachment(input.attachmentId).pty.write(input.data);
+    }
+    async resize(input) {
+        const size = normalizeTerminalSize(input.cols, input.rows);
+        this.getAttachment(input.attachmentId).pty.resize(size.cols, size.rows);
+    }
+    async detach(attachmentId) {
+        const state = this.attachments.get(attachmentId);
+        if (state === undefined)
+            return;
+        state.detached = true;
+        this.attachments.delete(attachmentId);
+        // 杀掉的只是 tmux client；tmux server 和其中的 shell 继续运行。
+        try {
+            state.pty.kill();
+        }
+        catch { /* attach 可能已经自然退出 */ }
+    }
+    async terminate(session) {
+        this.assertSupported(session);
+        const tmuxPath = this.requireTmuxPath();
+        const name = tmuxSessionName(session.runtimeSessionKey);
+        for (const [attachmentId, state] of this.attachments) {
+            if (state.sessionName === name)
+                await this.detach(attachmentId);
+        }
+        const result = this.runner.run(tmuxPath, ['kill-session', '-t', name]);
+        // tmux 的“目标不存在”视为幂等成功。
+        if (result.status !== 0 && !isMissingSession(result.stderr)) {
+            throw new TerminalRuntimeError('TERMINAL_RUNTIME_CREATE_FAILED', sanitizeCommandError('tmux 会话关闭失败', result.stderr));
+        }
+    }
+    getAttachment(attachmentId) {
+        const state = this.attachments.get(attachmentId);
+        if (state === undefined)
+            throw new TerminalRuntimeError('TERMINAL_ATTACHMENT_NOT_FOUND', '终端 attach 不存在或已经释放');
+        return state;
+    }
+    assertSupported(session) {
+        if (this.platform !== 'darwin' && this.platform !== 'linux') {
+            throw new TerminalRuntimeError('TERMINAL_PLATFORM_UNSUPPORTED', 'tmux backend 只支持 macOS 和 Linux');
+        }
+        if (session.runtimeType !== 'tmux') {
+            throw new TerminalRuntimeError('TERMINAL_PLATFORM_UNSUPPORTED', `tmux backend 不支持 ${session.runtimeType}`);
+        }
+    }
+    requireTmuxPath() {
+        if (this.tmuxPath === null)
+            throw new TerminalRuntimeError('TERMINAL_RUNTIME_UNAVAILABLE', '未找到可执行的 tmux');
+        return this.tmuxPath;
+    }
+}
+/**
+ * 调试命令必须是 Shell 的子进程：杀掉端口对应的业务进程后，tmux pane
+ * 仍然回到交互 Shell；只有显式停止才会调用 terminate 销毁整个会话。
+ */
+function tmuxLaunchCommand(session) {
+    if (session.commandPath === undefined)
+        return [session.shellPath, ...session.shellArgs];
+    const command = [session.commandPath, ...(session.commandArgs ?? [])].map(shellQuote).join(' ');
+    const shell = [session.shellPath, ...session.shellArgs].map(shellQuote).join(' ');
+    return [session.shellPath, ...session.shellArgs, '-c', `${command}; exec ${shell}`];
+}
+function shellQuote(value) {
+    return `'${value.replaceAll("'", "'\\''")}'`;
+}
+export function tmuxSessionName(runtimeSessionKey) {
+    const digest = createHash('sha256').update(runtimeSessionKey).digest('hex').slice(0, 32);
+    return `codingns4dsh-${digest}`;
+}
+function runCommand(command, args) {
+    return spawnSync(command, args, { encoding: 'utf8', windowsHide: true, shell: false });
+}
+function detectTmuxPath(platform) {
+    const candidates = platform === 'darwin'
+        ? ['/opt/homebrew/bin/tmux', '/usr/local/bin/tmux', '/usr/bin/tmux']
+        : ['/usr/bin/tmux', '/usr/local/bin/tmux', '/bin/tmux'];
+    return candidates.find(isExecutable) ?? null;
+}
+function isExecutable(path) {
+    try {
+        accessSync(path, constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isMissingSession(stderr) {
+    return /no (server running|sessions|session)|can't find session|error connecting to .*no such file or directory/i.test(stderr);
+}
+function sanitizeCommandError(prefix, stderr) {
+    const detail = stderr.trim().replace(/[\r\n]+/g, ' ').slice(0, 300);
+    return detail ? `${prefix}：${detail}` : prefix;
+}
+//# sourceMappingURL=tmux-backend.js.map

package/data/build/dist/host/terminal/broker/conpty-broker-client.d.ts

@@ -0,0 +1,27 @@
+import { type TerminalRuntimeIdentity } from '../runtime-adapter.js';
+export interface ConptyBrokerAttachment {
+    readonly attachmentId: string;
+    readonly identity: TerminalRuntimeIdentity;
+    write(data: string): void;
+    resize(cols: number, rows: number): void;
+    detach(): Promise<void>;
+}
+export interface ConptyBrokerClientLike {
+    inspect(pipeName: string, auth: string, runtimeSessionKey: string): Promise<TerminalRuntimeIdentity>;
+    attach(input: {
+        readonly pipeName: string;
+        readonly auth: string;
+        readonly runtimeSessionKey: string;
+        readonly cols: number;
+        readonly rows: number;
+        readonly onData: (data: string) => void;
+        readonly onExit?: (exitCode: number | null) => void;
+    }): Promise<ConptyBrokerAttachment>;
+    terminate(pipeName: string, auth: string): Promise<void>;
+}
+export declare class ConptyBrokerClient implements ConptyBrokerClientLike {
+    inspect(pipeName: string, auth: string, runtimeSessionKey: string): Promise<TerminalRuntimeIdentity>;
+    attach(input: Parameters<ConptyBrokerClientLike['attach']>[0]): Promise<ConptyBrokerAttachment>;
+    terminate(pipeName: string, auth: string): Promise<void>;
+}
+//# sourceMappingURL=conpty-broker-client.d.ts.map

package/data/build/dist/host/terminal/broker/conpty-broker-client.js

@@ -0,0 +1,154 @@
+import { connect } from 'node:net';
+import { randomUUID } from 'node:crypto';
+import { createJsonLineParser, parseBrokerMessage, writeBrokerMessage, } from './conpty-broker-protocol.js';
+import { TerminalRuntimeError, normalizeTerminalSize } from '../runtime-adapter.js';
+const BROKER_REQUEST_TIMEOUT_MS = 5_000;
+export class ConptyBrokerClient {
+    async inspect(pipeName, auth, runtimeSessionKey) {
+        const message = await requestOnce(pipeName, { version: 1, auth, type: 'inspect' });
+        if (message.type !== 'inspect-result')
+            throw protocolError(message);
+        return {
+            alive: message.alive,
+            runtimeSessionKey,
+            runtimePid: message.brokerPid,
+            shellPid: message.shellPid,
+        };
+    }
+    async attach(input) {
+        const socket = connect(input.pipeName);
+        const size = normalizeTerminalSize(input.cols, input.rows);
+        const attachmentId = randomUUID();
+        let settled = false;
+        let detached = false;
+        let finished = false;
+        return new Promise((resolve, reject) => {
+            const fail = (error) => {
+                if (finished)
+                    return;
+                finished = true;
+                socket.destroy();
+                if (!settled)
+                    reject(new TerminalRuntimeError('TERMINAL_RUNTIME_LOST', '无法连接 ConPTY broker', { cause: error }));
+                else if (!detached)
+                    input.onExit?.(null);
+                settled = true;
+            };
+            const parser = createJsonLineParser((value) => {
+                const message = parseBrokerMessage(value);
+                if (message === null)
+                    return fail(new Error('broker 返回了无效协议消息'));
+                if (message.type === 'error')
+                    return fail(protocolError(message));
+                if (message.type === 'output') {
+                    if (!finished)
+                        input.onData(message.data);
+                    return;
+                }
+                if (message.type === 'exit') {
+                    if (!finished) {
+                        finished = true;
+                        input.onExit?.(message.exitCode);
+                        socket.end();
+                    }
+                    return;
+                }
+                if (message.type !== 'attached' || settled)
+                    return;
+                settled = true;
+                const identity = {
+                    alive: true,
+                    runtimeSessionKey: input.runtimeSessionKey,
+                    runtimePid: message.brokerPid,
+                    shellPid: message.shellPid,
+                };
+                resolve({
+                    attachmentId,
+                    identity,
+                    write(data) {
+                        if (!detached)
+                            writeBrokerMessage(socket, { version: 1, auth: input.auth, type: 'input', data });
+                    },
+                    resize(cols, rows) {
+                        if (detached)
+                            return;
+                        const next = normalizeTerminalSize(cols, rows);
+                        writeBrokerMessage(socket, { version: 1, auth: input.auth, type: 'resize', ...next });
+                    },
+                    async detach() {
+                        if (detached)
+                            return;
+                        detached = true;
+                        finished = true;
+                        writeBrokerMessage(socket, { version: 1, auth: input.auth, type: 'detach' });
+                        socket.end();
+                    },
+                });
+            });
+            socket.once('connect', () => writeBrokerMessage(socket, { version: 1, auth: input.auth, type: 'attach', ...size }));
+            socket.setTimeout(BROKER_REQUEST_TIMEOUT_MS, () => fail(new Error('ConPTY broker attach 响应超时')));
+            socket.on('data', (chunk) => {
+                try {
+                    parser.push(chunk);
+                }
+                catch (error) {
+                    fail(error);
+                }
+            });
+            socket.once('error', fail);
+            socket.once('close', () => {
+                if (!detached)
+                    fail(new Error('broker 连接已经关闭'));
+            });
+        });
+    }
+    async terminate(pipeName, auth) {
+        const message = await requestOnce(pipeName, { version: 1, auth, type: 'terminate' });
+        if (message.type !== 'terminated')
+            throw protocolError(message);
+    }
+}
+async function requestOnce(pipeName, request) {
+    const socket = connect(pipeName);
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const finish = (action) => {
+            if (settled)
+                return;
+            settled = true;
+            socket.end();
+            action();
+        };
+        socket.setTimeout(BROKER_REQUEST_TIMEOUT_MS, () => {
+            socket.destroy();
+            finish(() => reject(new TerminalRuntimeError('TERMINAL_RUNTIME_LOST', 'ConPTY broker 响应超时')));
+        });
+        const parser = createJsonLineParser((value) => {
+            const message = parseBrokerMessage(value);
+            if (message === null)
+                finish(() => reject(new TerminalRuntimeError('TERMINAL_BROKER_PROTOCOL_INVALID', 'broker 返回了无效协议消息')));
+            else if (message.type === 'error')
+                finish(() => reject(protocolError(message)));
+            else
+                finish(() => resolve(message));
+        });
+        socket.once('connect', () => writeBrokerMessage(socket, request));
+        socket.on('data', (chunk) => {
+            try {
+                parser.push(chunk);
+            }
+            catch (error) {
+                finish(() => reject(error));
+            }
+        });
+        socket.once('error', (error) => finish(() => reject(error)));
+        socket.once('close', () => finish(() => reject(new Error('broker 未返回响应'))));
+    });
+}
+function protocolError(message) {
+    if (message.type === 'error' && message.code === 'UNAUTHORIZED') {
+        return new TerminalRuntimeError('TERMINAL_BROKER_UNAUTHORIZED', message.message);
+    }
+    return new TerminalRuntimeError('TERMINAL_BROKER_PROTOCOL_INVALID', message.type === 'error' ? message.message : `broker 返回了意外消息：${message.type}`);
+}
+//# sourceMappingURL=conpty-broker-client.js.map

package/data/build/dist/host/terminal/broker/conpty-broker-process.d.ts

@@ -0,0 +1,10 @@
+interface BrokerArguments {
+    readonly pipeName: string;
+    readonly auth: string;
+    readonly shellPath: string;
+    readonly shellArgs: readonly string[];
+    readonly cwd: string;
+}
+export declare function runConptyBroker(args: BrokerArguments): void;
+export {};
+//# sourceMappingURL=conpty-broker-process.d.ts.map