@jingyi0605/codingns4dsh 0.1.0

package/data/build/dist/host/terminal/terminal-controller.js

@@ -0,0 +1,324 @@
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+import { Remote, RemoteError, TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
+import { detectTerminalShells, resolveTerminalShell, } from './shell-detection.js';
+import { CodingNsTerminalService, TerminalServiceError } from './terminal-service.js';
+/** 与 DSH 0.1.6-alpha.2 `remote.terminal` 完全同名、同方法的 Host controller。 */
+let CodingNsTerminalController = (() => {
+    let _classSuper = TypertRemoteService;
+    let _instanceExtraInitializers = [];
+    let _environment_decorators;
+    let _shells_decorators;
+    let _list_decorators;
+    let _create_decorators;
+    let _retain_decorators;
+    let _follow_decorators;
+    let _write_decorators;
+    let _resize_decorators;
+    let _rename_decorators;
+    let _close_decorators;
+    return class CodingNsTerminalController extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _environment_decorators = [Remote];
+            _shells_decorators = [Remote];
+            _list_decorators = [Remote];
+            _create_decorators = [Remote];
+            _retain_decorators = [Remote({ mode: 'stream' })];
+            _follow_decorators = [Remote({ mode: 'stream' })];
+            _write_decorators = [Remote];
+            _resize_decorators = [Remote];
+            _rename_decorators = [Remote];
+            _close_decorators = [Remote];
+            __esDecorate(this, null, _environment_decorators, { kind: "method", name: "environment", static: false, private: false, access: { has: obj => "environment" in obj, get: obj => obj.environment }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _shells_decorators, { kind: "method", name: "shells", static: false, private: false, access: { has: obj => "shells" in obj, get: obj => obj.shells }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _list_decorators, { kind: "method", name: "list", static: false, private: false, access: { has: obj => "list" in obj, get: obj => obj.list }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _create_decorators, { kind: "method", name: "create", static: false, private: false, access: { has: obj => "create" in obj, get: obj => obj.create }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _retain_decorators, { kind: "method", name: "retain", static: false, private: false, access: { has: obj => "retain" in obj, get: obj => obj.retain }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _follow_decorators, { kind: "method", name: "follow", static: false, private: false, access: { has: obj => "follow" in obj, get: obj => obj.follow }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _write_decorators, { kind: "method", name: "write", static: false, private: false, access: { has: obj => "write" in obj, get: obj => obj.write }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _resize_decorators, { kind: "method", name: "resize", static: false, private: false, access: { has: obj => "resize" in obj, get: obj => obj.resize }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _rename_decorators, { kind: "method", name: "rename", static: false, private: false, access: { has: obj => "rename" in obj, get: obj => obj.rename }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _close_decorators, { kind: "method", name: "close", static: false, private: false, access: { has: obj => "close" in obj, get: obj => obj.close }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        options = __runInitializers(this, _instanceExtraInitializers);
+        static inject = ['typert'];
+        platform;
+        detectShells;
+        maxTerminals;
+        maxInputBytes;
+        maxCols;
+        maxRows;
+        /** 绑定范围与 controller 一样在 DSH 启动时锁定，避免运行中切换造成终端集合瞬间变化。 */
+        bindingScope;
+        /** list/retain 的官方 wire 只有 sessionId；这里把它解析到工作区后再查持久终端。 */
+        sessionWorkspaces = new Map();
+        constructor(ctx, options) {
+            super(ctx, 'terminalController', { namespace: 'terminal' });
+            this.options = options;
+            this.platform = options.platform ?? process.platform;
+            this.detectShells = options.detectShells ?? (() => detectTerminalShells({ platform: this.platform }));
+            this.maxTerminals = options.maxTerminals ?? 8;
+            this.maxInputBytes = options.maxInputBytes ?? 64 * 1024;
+            this.maxCols = options.maxCols ?? 500;
+            this.maxRows = options.maxRows ?? 200;
+            this.bindingScope = options.settings().bindingScope ?? 'workspace';
+        }
+        environment(agent, signal) {
+            signal.throwIfAborted();
+            const workspaceId = this.rememberWorkspace(agent);
+            return {
+                cwd: this.cwd(agent),
+                workspaceId,
+                maxInputBytes: this.maxInputBytes,
+                maxCols: this.maxCols,
+                maxRows: this.maxRows,
+                scrollback: this.options.settings().appearance.scrollback ?? 1000,
+            };
+        }
+        shells(agent, signal) {
+            signal.throwIfAborted();
+            const detected = this.detectShells();
+            const preferred = resolveTerminalShell(this.options.settings().defaultProfile, detected, this.platform);
+            const available = detected.filter((shell) => shell.available && shell.path !== null);
+            const ordered = [
+                ...available.filter((shell) => shell.path === preferred.path),
+                ...available.filter((shell) => shell.path !== preferred.path),
+            ];
+            if (ordered.length === 0)
+                throw new Error('当前平台没有可用的受支持终端 shell');
+            return ordered.map(shellOption);
+        }
+        list(sessionId) {
+            const workspaceId = this.sessionWorkspaces.get(sessionId);
+            return [...this.options.service.listSession(this.options.hostId, sessionId, workspaceId)];
+        }
+        async create(agent, request, signal) {
+            signal.throwIfAborted();
+            const scope = this.scope(agent);
+            this.rememberWorkspace(agent);
+            const existing = this.options.service.list(scope).find((terminal) => terminal.id === request.id);
+            if (existing !== undefined)
+                return existing;
+            if (this.options.service.list(scope).length >= this.maxTerminals) {
+                throw new RemoteError('terminal/limit-reached', '当前 DSH 会话的终端数量已达到上限', { limit: this.maxTerminals });
+            }
+            const selected = this.selectShell(request.shellPath);
+            try {
+                return await this.options.service.create({
+                    scope,
+                    terminalId: request.id,
+                    runtimeType: this.options.runtimeType?.(selected.profileId, this.platform)
+                        ?? runtimeType(this.platform, selected.profileId),
+                    shell: shellProfile(selected),
+                    cwd: this.cwd(agent),
+                    cols: request.cols,
+                    rows: request.rows,
+                });
+            }
+            catch (error) {
+                throw remoteTerminalError(error);
+            }
+        }
+        retain(sessionId, id, signal) {
+            try {
+                const identity = this.options.service.findIdentity(this.options.hostId, sessionId, id, this.sessionWorkspaces.get(sessionId));
+                return translateTerminalStream(this.options.service.retain(identity, signal));
+            }
+            catch (error) {
+                throw remoteTerminalError(error);
+            }
+        }
+        follow(agent, id, attachmentId, signal) {
+            if (!/^[\w-]{1,128}$/u.test(attachmentId))
+                throw new TypeError('终端 attach 标识无效');
+            try {
+                return translateTerminalStream(this.options.service.follow({
+                    identity: this.identity(agent, id),
+                    attachmentId,
+                    // attachmentId 由原生 Client 每次物理 attach 重新生成，正好作为短命
+                    // generation；它不会进入持久记录，也不会让旧 attach 的回调控制新流。
+                    generation: this.options.generation?.(agent, attachmentId) ?? `terminal-attach:${attachmentId}`,
+                    signal,
+                }));
+            }
+            catch (error) {
+                throw remoteTerminalError(error);
+            }
+        }
+        async write(agent, id, attachmentId, data) {
+            if (new TextEncoder().encode(data).byteLength > this.maxInputBytes)
+                throw new TypeError('终端输入超过允许上限');
+            try {
+                await this.options.service.write(this.identity(agent, id), attachmentId, data);
+            }
+            catch (error) {
+                throw remoteTerminalError(error);
+            }
+        }
+        async resize(agent, id, attachmentId, cols, rows) {
+            try {
+                await this.options.service.resize(this.identity(agent, id), attachmentId, cols, rows);
+            }
+            catch (error) {
+                throw remoteTerminalError(error);
+            }
+        }
+        async rename(agent, id, title) {
+            try {
+                await this.options.service.rename(this.identity(agent, id), title);
+            }
+            catch (error) {
+                throw remoteTerminalError(error);
+            }
+        }
+        async close(agent, id) {
+            try {
+                const identity = this.optionalIdentity(agent, id);
+                if (identity !== undefined)
+                    await this.options.service.close(identity);
+            }
+            catch (error) {
+                throw remoteTerminalError(error);
+            }
+        }
+        selectShell(shellPath) {
+            const detected = this.detectShells();
+            if (shellPath !== undefined) {
+                const selected = detected.find((shell) => shell.available && shell.path === shellPath);
+                if (selected?.path !== null && selected?.path !== undefined)
+                    return selected;
+                throw new TypeError('所选 shell 不在 Host 白名单或当前不可用');
+            }
+            const resolved = resolveTerminalShell(this.options.settings().defaultProfile, detected, this.platform);
+            const selected = detected.find((shell) => shell.available && shell.path === resolved.path);
+            if (selected?.path === null || selected?.path === undefined)
+                throw new Error('默认 shell 解析结果无效');
+            return selected;
+        }
+        cwd(agent) {
+            return agent.session.header?.cwd ?? process.cwd();
+        }
+        scope(agent) {
+            const cwd = this.cwd(agent);
+            return {
+                hostId: this.options.hostId,
+                workspaceId: this.workspaceId(agent, cwd),
+                dshSessionId: agent.id,
+            };
+        }
+        rememberWorkspace(agent) {
+            const workspaceId = this.workspaceId(agent, this.cwd(agent));
+            this.sessionWorkspaces.set(agent.id, workspaceId);
+            return workspaceId;
+        }
+        /**
+         * Workspace Registry 是跨会话的稳定身份。只有找不到正式工作区时才回退到
+         * 插件提供的 cwd 规则，避免把同一工作区的不同 Session 拆成多个终端集合。
+         */
+        workspaceId(agent, cwd) {
+            if (this.bindingScope === 'session')
+                return `session:${agent.id}`;
+            // Cordis 未注入可选服务时直接读 ctx.workspaceRegistry 会抛出 "without inject"；
+            // 通过 get 探测是官方允许的可选服务读取方式。
+            const registry = this.ctx.get('workspaceRegistry');
+            if (registry !== undefined) {
+                try {
+                    const workspace = registry.list().find((entry) => entry.sessionIds.includes(agent.id));
+                    if (workspace !== undefined)
+                        return workspace.id;
+                }
+                catch {
+                    // Workspace Registry 尚未完成启动时继续使用兼容回退，不能让终端功能阻塞 DSH。
+                }
+            }
+            return this.options.workspaceId?.(agent, cwd) ?? cwd;
+        }
+        identity(agent, terminalId) {
+            return { ...this.scope(agent), terminalId };
+        }
+        optionalIdentity(agent, terminalId) {
+            try {
+                return this.options.service.findIdentity(this.options.hostId, agent.id, terminalId, this.rememberWorkspace(agent));
+            }
+            catch (error) {
+                if (!(error instanceof TerminalServiceError) || error.code !== 'TERMINAL_UNAVAILABLE')
+                    throw error;
+                return undefined;
+            }
+        }
+    };
+})();
+export { CodingNsTerminalController };
+function shellOption(shell) {
+    return { path: shell.path, name: shell.displayName, args: shellArgs(shell.profileId) };
+}
+function shellProfile(shell) {
+    return { profileId: shell.profileId, path: shell.path, name: shell.displayName, args: shellArgs(shell.profileId) };
+}
+function shellArgs(profileId) {
+    if (profileId === 'cmd')
+        return [];
+    if (profileId === 'powershell')
+        return ['-NoLogo'];
+    return ['-i'];
+}
+function runtimeType(platform, profileId) {
+    if (platform !== 'win32')
+        return 'tmux';
+    if (profileId === 'cmd')
+        return 'conpty-cmd';
+    if (profileId === 'git-bash')
+        return 'conpty-git-bash';
+    return 'conpty-powershell';
+}
+function remoteTerminalError(error) {
+    if (!(error instanceof TerminalServiceError))
+        return error;
+    if (error.code === 'TERMINAL_CONTROL_UNAVAILABLE') {
+        return new RemoteError('terminal/control-unavailable', error.message, { reason: 'read-only' });
+    }
+    return new RemoteError('terminal/unavailable', error.message, {});
+}
+async function* translateTerminalStream(stream) {
+    try {
+        yield* stream;
+    }
+    catch (error) {
+        throw remoteTerminalError(error);
+    }
+}
+//# sourceMappingURL=terminal-controller.js.map

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

@@ -0,0 +1,30 @@
+import type { TerminalLaunchProfile, TerminalLaunchProfileInput, TerminalProcessInstance, TerminalProcessLaunchRequest, TerminalProcessLaunchResult } from '../../shared/contracts/terminal-process.js';
+import { CodingNsTerminalService } from './terminal-service.js';
+import { TerminalProcessStore } from './terminal-process-store.js';
+export interface TerminalProcessServiceOptions {
+    readonly hostId: string;
+    readonly terminalService: CodingNsTerminalService;
+    readonly resolveWorkspaceRoot: (workspaceId: string) => string | null;
+    readonly now?: () => Date;
+}
+/** 终端侧最小启动器：Host 先创建 PTY 命令，再让现有终端 controller attach。 */
+export declare class TerminalProcessService {
+    private readonly store;
+    private readonly options;
+    private readonly now;
+    constructor(store: TerminalProcessStore, options: TerminalProcessServiceOptions);
+    initialize(): Promise<void>;
+    listProfiles(workspaceId?: string): readonly TerminalLaunchProfile[];
+    createProfile(input: TerminalLaunchProfileInput): Promise<TerminalLaunchProfile>;
+    deleteProfile(workspaceId: string, profileId: string): Promise<boolean>;
+    getInstance(instanceId: string): TerminalProcessInstance | undefined;
+    listInstances(workspaceId?: string): readonly TerminalProcessInstance[];
+    launch(request: TerminalProcessLaunchRequest): Promise<TerminalProcessLaunchResult>;
+    stop(instanceId: string): Promise<TerminalProcessInstance>;
+    recover(): Promise<void>;
+    private handleExit;
+    private resolveCwd;
+}
+/** 与 Spec003 约定的名称；当前只承载 runtimeMode=pty 的终端进程。 */
+export { TerminalProcessService as ProcessRuntimeService };
+//# sourceMappingURL=terminal-process-service.d.ts.map

package/data/build/dist/host/terminal/terminal-process-service.js

@@ -0,0 +1,194 @@
+import { randomUUID } from 'node:crypto';
+import { isAbsolute, join, normalize, relative, sep } from 'node:path';
+import { CodingNsTerminalService } from './terminal-service.js';
+import { TerminalProcessStore, validateProfile } from './terminal-process-store.js';
+/** 终端侧最小启动器：Host 先创建 PTY 命令，再让现有终端 controller attach。 */
+export class TerminalProcessService {
+    store;
+    options;
+    now;
+    constructor(store, options) {
+        this.store = store;
+        this.options = options;
+        this.now = options.now ?? (() => new Date());
+    }
+    async initialize() { await this.store.load(); }
+    listProfiles(workspaceId) { return this.store.listProfiles(workspaceId); }
+    async createProfile(input) {
+        const current = this.store.getProfile(input.workspaceId, input.id);
+        const timestamp = this.now().toISOString();
+        const profile = {
+            id: input.id,
+            workspaceId: input.workspaceId,
+            name: input.name,
+            cwdRelative: input.cwdRelative,
+            command: input.command,
+            args: [...(input.args ?? [])],
+            env: { ...(input.env ?? {}) },
+            shell: { ...input.shell, args: [...input.shell.args] },
+            runtimeType: input.runtimeType,
+            runtimeMode: 'pty',
+            revision: (current?.revision ?? 0) + 1,
+            createdAt: current?.createdAt ?? timestamp,
+            updatedAt: timestamp,
+        };
+        validateProfile(profile);
+        await this.store.putProfile(profile);
+        return profile;
+    }
+    async deleteProfile(workspaceId, profileId) {
+        if (this.store.listInstances(workspaceId).some((instance) => instance.profileId === profileId && isActive(instance.state))) {
+            throw new Error('终端启动项仍有活动进程，不能删除');
+        }
+        return this.store.deleteProfile(workspaceId, profileId);
+    }
+    getInstance(instanceId) { return this.store.getInstance(instanceId); }
+    listInstances(workspaceId) { return this.store.listInstances(workspaceId); }
+    async launch(request) {
+        const profile = this.store.getProfile(request.workspaceId, request.profileId);
+        if (profile === undefined)
+            throw new Error('终端启动项不存在');
+        const cwd = this.resolveCwd(profile);
+        const terminalId = request.terminalId ?? `process-${randomUUID()}`;
+        const instanceId = `instance-${randomUUID()}`;
+        const startedAt = this.now().toISOString();
+        let instance = {
+            id: instanceId,
+            workspaceId: request.workspaceId,
+            profileId: profile.id,
+            terminalId,
+            runtimeSessionKey: null,
+            state: 'starting',
+            pid: null,
+            resolvedCommand: { command: profile.command, args: [...profile.args], cwd },
+            exitCode: null,
+            startedAt,
+            stoppedAt: null,
+        };
+        await this.store.putInstance(instance);
+        const scope = {
+            hostId: this.options.hostId,
+            workspaceId: request.workspaceId,
+            ...(request.dshSessionId === undefined ? {} : { dshSessionId: request.dshSessionId }),
+        };
+        const identity = { ...scope, terminalId };
+        try {
+            if (this.options.terminalService.getRecord(identity) !== undefined)
+                throw new Error('指定 terminalId 已经存在，不能覆盖已有终端');
+            const terminal = await this.options.terminalService.create({
+                scope,
+                terminalId,
+                runtimeType: profile.runtimeType,
+                shell: profile.shell,
+                ...(request.commandMode === 'shell-input' ? { title: `${profile.name}(${profile.shell.name})` } : {}),
+                ...(request.commandMode === 'shell-input' ? {} : { commandPath: profile.command, commandArgs: profile.args }),
+                commandEnv: profile.env,
+                launchProfileId: profile.id,
+                cwd,
+                cols: request.cols,
+                rows: request.rows,
+                onExit: (exitCode) => { void this.handleExit(instanceId, exitCode); },
+            });
+            if (request.commandMode === 'shell-input') {
+                await this.options.terminalService.writeInitialInput(identity, buildShellInput(profile));
+            }
+            const record = this.options.terminalService.getRecord(identity);
+            const runtime = await this.options.terminalService.inspect(identity);
+            if (record === undefined)
+                throw new Error('终端启动后记录丢失');
+            instance = {
+                ...instance,
+                runtimeSessionKey: record.runtimeSessionKey,
+                state: 'running',
+                // Shell-input 模式的 runtime PID 是交互 Shell，不是实际监听端口的业务进程。
+                // 业务进程身份由 DebugWorkspaceService 的端口快照单独确认。
+                pid: request.commandMode === 'shell-input' ? null : runtime.runtimePid,
+            };
+            await this.store.putInstance(instance);
+            return { instance, terminal };
+        }
+        catch (error) {
+            await this.store.putInstance({ ...instance, state: 'failed', error: errorMessage(error), stoppedAt: this.now().toISOString() });
+            try {
+                await this.options.terminalService.close(identity);
+            }
+            catch { /* 创建失败时可能尚未有终端记录 */ }
+            throw error;
+        }
+    }
+    async stop(instanceId) {
+        const instance = this.store.getInstance(instanceId);
+        if (instance === undefined)
+            throw new Error('终端进程实例不存在');
+        if (!isActive(instance.state))
+            return instance;
+        await this.store.putInstance({ ...instance, state: 'stopping' });
+        try {
+            await this.options.terminalService.close({
+                hostId: this.options.hostId,
+                workspaceId: instance.workspaceId,
+                terminalId: instance.terminalId,
+            });
+            const latest = this.store.getInstance(instanceId) ?? instance;
+            const stopped = { ...latest, state: 'exited', stoppedAt: this.now().toISOString() };
+            await this.store.putInstance(stopped);
+            return stopped;
+        }
+        catch (error) {
+            const failed = { ...instance, state: 'failed', error: errorMessage(error), stoppedAt: this.now().toISOString() };
+            await this.store.putInstance(failed);
+            throw error;
+        }
+    }
+    async recover() {
+        for (const instance of this.store.listInstances()) {
+            if (!isActive(instance.state))
+                continue;
+            const identity = { hostId: this.options.hostId, workspaceId: instance.workspaceId, terminalId: instance.terminalId };
+            try {
+                const runtime = await this.options.terminalService.inspect(identity);
+                await this.store.putInstance({ ...instance, state: runtime.alive ? 'running' : 'lost', pid: runtime.runtimePid, ...(runtime.alive ? {} : { error: runtime.detail ?? '终端运行时不存在' }) });
+            }
+            catch (error) {
+                await this.store.putInstance({ ...instance, state: 'lost', error: errorMessage(error) });
+            }
+        }
+    }
+    async handleExit(instanceId, exitCode) {
+        const current = this.store.getInstance(instanceId);
+        if (current === undefined || !isActive(current.state))
+            return;
+        await this.store.putInstance({ ...current, state: 'exited', exitCode, stoppedAt: this.now().toISOString() });
+    }
+    resolveCwd(profile) {
+        const root = this.options.resolveWorkspaceRoot(profile.workspaceId);
+        if (root === null || !isAbsolute(root))
+            throw new Error('Workspace 根目录不可用');
+        const cwd = normalize(join(root, profile.cwdRelative));
+        const escaped = relative(root, cwd);
+        if (escaped === '..' || escaped.startsWith(`..${sep}`) || isAbsolute(escaped))
+            throw new Error('终端启动项工作目录越出 Workspace');
+        return cwd;
+    }
+}
+/** 与 Spec003 约定的名称；当前只承载 runtimeMode=pty 的终端进程。 */
+export { TerminalProcessService as ProcessRuntimeService };
+function isActive(state) { return state === 'starting' || state === 'running' || state === 'stopping'; }
+function errorMessage(error) { return error instanceof Error ? error.message : String(error); }
+/** 按目标 Shell 的语法编码命令参数，避免把参数中的空格重新拆开。 */
+function buildShellInput(profile) {
+    const command = [profile.command, ...profile.args];
+    const shellType = profile.shell.profileId === 'cmd'
+        ? 'cmd'
+        : profile.shell.profileId === 'powershell'
+            ? 'powershell'
+            : 'posix';
+    const line = shellType === 'powershell'
+        ? `& ${command.map(powerShellQuote).join(' ')}`
+        : command.map(shellType === 'cmd' ? cmdQuote : posixQuote).join(' ');
+    return `${line}${shellType === 'posix' ? '\n' : '\r'}`;
+}
+function posixQuote(value) { return `'${value.replaceAll("'", "'\\''")}'`; }
+function powerShellQuote(value) { return `'${value.replaceAll("'", "''")}'`; }
+function cmdQuote(value) { return `"${value.replaceAll('"', '""')}"`; }
+//# sourceMappingURL=terminal-process-service.js.map

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

@@ -0,0 +1,45 @@
+import type { TerminalLaunchProfile, TerminalProcessInstance } from '../../shared/contracts/terminal-process.js';
+declare const STORE_VERSION = 1;
+interface TerminalProcessDocument {
+    readonly version: typeof STORE_VERSION;
+    readonly profiles: readonly TerminalLaunchProfile[];
+    readonly instances: readonly TerminalProcessInstance[];
+}
+export interface TerminalProcessStorePersistence {
+    load(): Promise<unknown>;
+    save(document: TerminalProcessDocument): Promise<void>;
+}
+export declare class JsonFileTerminalProcessStorePersistence implements TerminalProcessStorePersistence {
+    private readonly filename;
+    constructor(filename: string);
+    load(): Promise<unknown>;
+    save(document: TerminalProcessDocument): Promise<void>;
+}
+export declare class InMemoryTerminalProcessStorePersistence implements TerminalProcessStorePersistence {
+    private document;
+    constructor(initial?: unknown);
+    load(): Promise<unknown>;
+    save(document: TerminalProcessDocument): Promise<void>;
+}
+export declare class TerminalProcessStore {
+    private readonly persistence;
+    private profiles;
+    private instances;
+    private writeTail;
+    private loaded;
+    constructor(persistence: TerminalProcessStorePersistence);
+    load(): Promise<void>;
+    getProfile(workspaceId: string, profileId: string): TerminalLaunchProfile | undefined;
+    listProfiles(workspaceId?: string): readonly TerminalLaunchProfile[];
+    putProfile(profile: TerminalLaunchProfile): Promise<void>;
+    deleteProfile(workspaceId: string, profileId: string): Promise<boolean>;
+    getInstance(instanceId: string): TerminalProcessInstance | undefined;
+    listInstances(workspaceId?: string): readonly TerminalProcessInstance[];
+    putInstance(instance: TerminalProcessInstance): Promise<void>;
+    private enqueue;
+    private persist;
+    private requireLoaded;
+}
+export declare function validateProfile(profile: TerminalLaunchProfile): void;
+export {};
+//# sourceMappingURL=terminal-process-store.d.ts.map