@jingyi0605/codingns4dsh 0.1.0

package/data/build/dist/host/terminal/runtime-manager.js

@@ -0,0 +1,179 @@
+import { randomUUID } from 'node:crypto';
+import { TerminalAttachmentRegistry } from './attachment-registry.js';
+/** 统一选择 backend，并确保停用插件时只清理 attach，不结束持久进程。 */
+export class TerminalRuntimeManager {
+    adapters = new Map();
+    registry = new TerminalAttachmentRegistry();
+    monitors = new Map();
+    constructor(adapters) {
+        for (const adapter of adapters) {
+            for (const runtimeType of adapter.runtimeTypes) {
+                if (this.adapters.has(runtimeType))
+                    throw new Error(`终端 backend 重复注册: ${runtimeType}`);
+                this.adapters.set(runtimeType, adapter);
+            }
+        }
+    }
+    create(record) {
+        return this.adapter(record.runtimeType).create({ session: runtimeSession(record), cols: record.cols, rows: record.rows });
+    }
+    inspect(record) {
+        return this.adapter(record.runtimeType).inspect(runtimeSession(record));
+    }
+    async attach(record, input) {
+        const backend = this.adapter(record.runtimeType);
+        const subscriptionId = randomUUID();
+        let runtimeAttachmentId;
+        const earlyData = [];
+        let earlyExit;
+        const attachment = await backend.attach({
+            session: runtimeSession(record),
+            cols: input.cols,
+            rows: input.rows,
+            onData: (data) => {
+                if (runtimeAttachmentId === undefined) {
+                    earlyData.push(data);
+                    return;
+                }
+                if (this.registry.isCurrent(subscriptionId, input.generation, runtimeAttachmentId))
+                    input.onData(data);
+            },
+            onExit: (exitCode) => {
+                if (runtimeAttachmentId === undefined) {
+                    earlyExit = exitCode;
+                    return;
+                }
+                if (this.registry.isCurrent(subscriptionId, input.generation, runtimeAttachmentId))
+                    input.onExit(exitCode);
+            },
+        });
+        runtimeAttachmentId = attachment.attachmentId;
+        const managed = {
+            identity: { ...input.identity },
+            runtimeType: record.runtimeType,
+            terminalId: record.terminalId,
+            generation: input.generation,
+            streamId: input.streamId,
+            subscriptionId,
+            runtimeAttachmentId,
+        };
+        this.registry.add(managed);
+        for (const data of earlyData) {
+            if (this.registry.isCurrent(subscriptionId, input.generation, runtimeAttachmentId))
+                input.onData(data);
+        }
+        if (earlyExit !== undefined && this.registry.isCurrent(subscriptionId, input.generation, runtimeAttachmentId)) {
+            input.onExit(earlyExit);
+        }
+        return managed;
+    }
+    async write(subscriptionId, data) {
+        const attachment = this.requireAttachment(subscriptionId);
+        await this.adapter(attachment.runtimeType).write({ attachmentId: attachment.runtimeAttachmentId, data });
+    }
+    /**
+     * 在不抢占浏览器 attach 控制权的前提下，向持久终端写入一次启动命令。
+     * 这是调试快捷启动所需的“先开 Shell、再发送命令”路径。
+     */
+    async writeSession(record, data) {
+        const monitor = this.monitors.get(monitorKey(record));
+        const backend = this.adapter(record.runtimeType);
+        if (monitor !== undefined) {
+            // monitor attach 与持久 Shell 同寿命，不能像临时 attach 一样写完立即销毁。
+            await backend.write({ attachmentId: monitor.attachmentId, data });
+            return;
+        }
+        const attachment = await backend.attach({
+            session: runtimeSession(record),
+            cols: record.cols,
+            rows: record.rows,
+            onData: () => undefined,
+        });
+        try {
+            await backend.write({ attachmentId: attachment.attachmentId, data });
+        }
+        finally {
+            await backend.detach(attachment.attachmentId);
+        }
+    }
+    async resize(subscriptionId, cols, rows) {
+        const attachment = this.requireAttachment(subscriptionId);
+        await this.adapter(attachment.runtimeType).resize({ attachmentId: attachment.runtimeAttachmentId, cols, rows });
+    }
+    async detach(subscriptionId) {
+        const attachment = this.registry.remove(subscriptionId);
+        if (attachment === undefined)
+            return;
+        await this.adapter(attachment.runtimeType).detach(attachment.runtimeAttachmentId);
+    }
+    async detachGeneration(generation) {
+        await Promise.all(this.registry.listByGeneration(generation).map((attachment) => this.detach(attachment.subscriptionId)));
+    }
+    async detachTerminal(identity) {
+        await Promise.all(this.registry.listByTerminal(identity).map((attachment) => this.detach(attachment.subscriptionId)));
+    }
+    /** 为 Host 进程状态提供退出监听，不获取终端输入控制权。 */
+    async monitor(record, onExit) {
+        const key = monitorKey(record);
+        if (this.monitors.has(key))
+            return;
+        const backend = this.adapter(record.runtimeType);
+        const attachment = await backend.attach({
+            session: runtimeSession(record),
+            cols: record.cols,
+            rows: record.rows,
+            onData: () => undefined,
+            onExit: (exitCode) => {
+                this.monitors.delete(key);
+                onExit(exitCode);
+            },
+        });
+        this.monitors.set(key, { runtimeType: record.runtimeType, attachmentId: attachment.attachmentId });
+    }
+    async detachMonitor(record) {
+        const key = monitorKey(record);
+        const monitor = this.monitors.get(key);
+        if (monitor === undefined)
+            return;
+        this.monitors.delete(key);
+        await this.adapter(monitor.runtimeType).detach(monitor.attachmentId);
+    }
+    async dispose() {
+        await Promise.all(this.registry.list().map((attachment) => this.detach(attachment.subscriptionId)));
+        await Promise.all([...this.monitors].map(async ([, monitor]) => this.adapter(monitor.runtimeType).detach(monitor.attachmentId)));
+        this.monitors.clear();
+        await Promise.all([...new Set(this.adapters.values())].map((adapter) => adapter.dispose?.()));
+    }
+    async terminate(record) {
+        await this.detachMonitor(record);
+        await this.adapter(record.runtimeType).terminate(runtimeSession(record));
+    }
+    adapter(runtimeType) {
+        const adapter = this.adapters.get(runtimeType);
+        if (adapter === undefined)
+            throw new Error(`当前 Host 没有终端 backend: ${runtimeType}`);
+        return adapter;
+    }
+    requireAttachment(subscriptionId) {
+        const attachment = this.registry.get(subscriptionId);
+        if (attachment === undefined)
+            throw new Error('终端 attach 不存在或已经释放');
+        return attachment;
+    }
+}
+function monitorKey(record) {
+    return JSON.stringify([record.hostId, record.workspaceId, record.terminalId]);
+}
+function runtimeSession(record) {
+    return {
+        runtimeSessionKey: record.runtimeSessionKey,
+        runtimeType: record.runtimeType,
+        shellPath: record.shellPath,
+        shellArgs: record.shellArgs ?? [],
+        ...(record.commandPath === undefined ? {} : { commandPath: record.commandPath }),
+        ...(record.commandArgs === undefined ? {} : { commandArgs: record.commandArgs }),
+        ...(record.commandEnv === undefined ? {} : { commandEnv: record.commandEnv }),
+        cwd: record.cwd,
+    };
+}
+//# sourceMappingURL=runtime-manager.js.map

package/data/build/dist/host/terminal/shell-detection.d.ts

@@ -0,0 +1,23 @@
+export type TerminalShellProfileId = 'system' | 'zsh' | 'bash' | 'powershell' | 'cmd' | 'git-bash';
+export interface DetectedTerminalShell {
+    readonly profileId: Exclude<TerminalShellProfileId, 'system'>;
+    readonly displayName: string;
+    readonly path: string | null;
+    readonly available: boolean;
+    readonly unavailableReason?: string;
+}
+export interface ShellDetectionOptions {
+    readonly platform?: string;
+    readonly env?: Readonly<Record<string, string | undefined>>;
+    readonly isExecutable?: (path: string) => boolean;
+}
+export interface ResolvedTerminalShell {
+    readonly requestedProfileId: TerminalShellProfileId;
+    readonly resolvedProfileId: Exclude<TerminalShellProfileId, 'system'>;
+    readonly path: string;
+    readonly fallbackReason?: string;
+}
+/** 平台探测只返回白名单 profile，浏览器不能借此提交任意可执行文件。 */
+export declare function detectTerminalShells(options?: ShellDetectionOptions): readonly DetectedTerminalShell[];
+export declare function resolveTerminalShell(requestedProfileId: TerminalShellProfileId, detected: readonly DetectedTerminalShell[], platform?: string): ResolvedTerminalShell;
+//# sourceMappingURL=shell-detection.d.ts.map

package/data/build/dist/host/terminal/shell-detection.js

@@ -0,0 +1,105 @@
+import { accessSync, constants } from 'node:fs';
+/** 平台探测只返回白名单 profile，浏览器不能借此提交任意可执行文件。 */
+export function detectTerminalShells(options = {}) {
+    const platform = options.platform ?? process.platform;
+    const env = options.env ?? process.env;
+    const executable = options.isExecutable ?? defaultIsExecutable;
+    if (platform === 'win32')
+        return detectWindowsShells(env, executable);
+    if (platform === 'darwin' || platform === 'linux')
+        return detectPosixShells(platform, env, executable);
+    return [];
+}
+export function resolveTerminalShell(requestedProfileId, detected, platform = process.platform) {
+    const requested = requestedProfileId === 'system'
+        ? undefined
+        : detected.find((shell) => shell.profileId === requestedProfileId);
+    if (requested?.available && requested.path !== null) {
+        return { requestedProfileId, resolvedProfileId: requested.profileId, path: requested.path };
+    }
+    const order = platform === 'win32'
+        ? ['powershell', 'cmd']
+        : ['zsh', 'bash'];
+    const fallback = order
+        .map((profileId) => detected.find((shell) => shell.profileId === profileId))
+        .find((shell) => shell?.available === true && shell.path !== null);
+    if (fallback === undefined)
+        throw new Error('当前平台没有可用的受支持终端 shell');
+    return {
+        requestedProfileId,
+        resolvedProfileId: fallback.profileId,
+        path: fallback.path,
+        ...(requestedProfileId === 'system'
+            ? {}
+            : { fallbackReason: `${requestedProfileId} 当前不可用，已回退到${fallback.displayName}` }),
+    };
+}
+function detectPosixShells(platform, env, executable) {
+    const envShell = env.SHELL;
+    const zsh = firstExecutable([
+        ...(envShell?.endsWith('/zsh') ? [envShell] : []),
+        '/bin/zsh',
+        '/usr/bin/zsh',
+        ...(platform === 'darwin' ? ['/opt/homebrew/bin/zsh', '/usr/local/bin/zsh'] : []),
+    ], executable, platform);
+    const bash = firstExecutable([
+        ...(envShell?.endsWith('/bash') ? [envShell] : []),
+        '/bin/bash',
+        '/usr/bin/bash',
+        '/usr/local/bin/bash',
+    ], executable, platform);
+    return [shellResult('zsh', 'zsh', zsh), shellResult('bash', 'bash', bash)];
+}
+function detectWindowsShells(env, executable) {
+    const systemRoot = env.SystemRoot ?? env.WINDIR ?? 'C:\\Windows';
+    const programFiles = env.ProgramFiles ?? 'C:\\Program Files';
+    const programFilesX86 = env['ProgramFiles(x86)'];
+    const localAppData = env.LOCALAPPDATA;
+    const pathEntries = (env.Path ?? env.PATH ?? '').split(';').map((value) => value.trim()).filter(Boolean);
+    const powershell = firstExecutable(uniqueWindowsPaths([
+        `${systemRoot}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`,
+        `${programFiles}\\PowerShell\\7\\pwsh.exe`,
+        ...(programFilesX86 ? [`${programFilesX86}\\PowerShell\\7\\pwsh.exe`] : []),
+        ...(localAppData ? [`${localAppData}\\Programs\\PowerShell\\7\\pwsh.exe`] : []),
+        ...pathCandidates(pathEntries, ['pwsh.exe', 'powershell.exe']),
+    ]), executable, 'win32');
+    const cmd = firstExecutable([env.ComSpec ?? '', `${systemRoot}\\System32\\cmd.exe`], executable, 'win32');
+    const gitBash = firstExecutable(uniqueWindowsPaths([
+        `${programFiles}\\Git\\bin\\bash.exe`,
+        ...(programFilesX86 ? [`${programFilesX86}\\Git\\bin\\bash.exe`] : []),
+        ...(localAppData ? [`${localAppData}\\Programs\\Git\\bin\\bash.exe`] : []),
+        ...pathCandidates(pathEntries, ['bash.exe']),
+    ]), executable, 'win32');
+    return [
+        shellResult('powershell', 'PowerShell', powershell),
+        shellResult('cmd', '命令提示符', cmd),
+        shellResult('git-bash', 'Git Bash', gitBash),
+    ];
+}
+function pathCandidates(entries, names) {
+    return entries.flatMap((entry) => names.map((name) => `${entry.replace(/[\\/]+$/u, '')}\\${name}`));
+}
+function uniqueWindowsPaths(paths) {
+    return [...new Set(paths)];
+}
+function firstExecutable(paths, executable, platform) {
+    return paths.find((path) => path !== '' && isAbsoluteForPlatform(path, platform) && executable(path)) ?? null;
+}
+function isAbsoluteForPlatform(path, platform) {
+    return platform === 'win32' ? /^[a-zA-Z]:[\\/]/.test(path) || path.startsWith('\\\\') : path.startsWith('/');
+}
+function shellResult(profileId, displayName, path) {
+    return path === null
+        ? { profileId, displayName, path: null, available: false, unavailableReason: '未找到可执行文件' }
+        : { profileId, displayName, path, available: true };
+}
+function defaultIsExecutable(path) {
+    try {
+        accessSync(path, constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=shell-detection.js.map

package/data/build/dist/host/terminal/startup.d.ts

@@ -0,0 +1,33 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { SettingsProvider, SettingsScope } from '@deepseek-ai/dsh-settings';
+import type { CodingNsSettings } from '../../shared/contracts/config.js';
+import { createTerminalController, type TerminalControllerFactoryResult } from './controller-factory.js';
+export interface TerminalStartupIdentity {
+    readonly hostId: string;
+    readonly storeFilename: string;
+    readonly hostIdFilename: string;
+}
+export interface InstallTerminalControllerOptions {
+    readonly platform?: string;
+    readonly createController?: typeof createTerminalController;
+    readonly resolveIdentity?: (settingsDocumentPath: string) => Promise<TerminalStartupIdentity>;
+    /** 由 Host 解析稳定 Workspace ID 到受信任根目录；不能接收浏览器传来的绝对路径。 */
+    readonly resolveWorkspaceRoot?: (workspaceId: string) => string | null;
+}
+/**
+ * 从 DSH 设置文档旁边的持久目录读取本机终端身份。
+ *
+ * hostId 首次生成后独占写入，不依赖 PID、端口或 Bundle 安装路径；同一 Profile
+ * 重启后会继续使用同一身份和同一终端映射文件。
+ */
+export declare function resolveTerminalStartupIdentity(settingsDocumentPath: string, createId?: () => string): Promise<TerminalStartupIdentity>;
+/** 每个浏览器 attachment 都是一个短命 generation，不能写入持久记录。 */
+export declare function terminalAttachmentGeneration(hostId: string, attachmentId: string): string;
+/** 工作区身份使用规范化绝对路径，避免同一路径的相对写法生成两份映射。 */
+export declare function terminalWorkspaceId(cwd: string): string;
+/**
+ * 在 Host 启动时读取一次启用快照并安装唯一 controller。
+ * 设置后续变化不会热切同名 Cordis service，必须重启 DSH 才会重新选择模式。
+ */
+export declare function installTerminalController(ctx: Context, settings: SettingsScope<CodingNsSettings>, provider: Pick<SettingsProvider, 'documentPath'>, options?: InstallTerminalControllerOptions): Promise<TerminalControllerFactoryResult>;
+//# sourceMappingURL=startup.d.ts.map

package/data/build/dist/host/terminal/startup.js

@@ -0,0 +1,100 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, isAbsolute, join } from 'node:path';
+import { createTerminalController, } from './controller-factory.js';
+import { terminalStorePath } from './terminal-store.js';
+const HOST_ID_FILENAME = 'host-id';
+const HOST_ID_PATTERN = /^local-[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u;
+/**
+ * 从 DSH 设置文档旁边的持久目录读取本机终端身份。
+ *
+ * hostId 首次生成后独占写入，不依赖 PID、端口或 Bundle 安装路径；同一 Profile
+ * 重启后会继续使用同一身份和同一终端映射文件。
+ */
+export async function resolveTerminalStartupIdentity(settingsDocumentPath, createId = () => `local-${randomUUID()}`) {
+    if (settingsDocumentPath.trim() === '')
+        throw new Error('DSH 设置文档路径为空，无法定位终端持久目录');
+    const absoluteSettingsPath = absolutePath(settingsDocumentPath);
+    const hostIdFilename = join(dirname(absoluteSettingsPath), 'codingns4dsh', HOST_ID_FILENAME);
+    await mkdir(dirname(hostIdFilename), { recursive: true, mode: 0o700 });
+    let hostId;
+    try {
+        hostId = parseHostId(await readFile(hostIdFilename, 'utf8'), hostIdFilename);
+    }
+    catch (error) {
+        if (!isMissingFile(error))
+            throw error;
+        const candidate = parseHostId(createId(), '新生成的 Host ID');
+        try {
+            await writeFile(hostIdFilename, `${candidate}\n`, { encoding: 'utf8', mode: 0o600, flag: 'wx' });
+            hostId = candidate;
+        }
+        catch (writeError) {
+            if (!isExistingFile(writeError))
+                throw writeError;
+            hostId = parseHostId(await readFile(hostIdFilename, 'utf8'), hostIdFilename);
+        }
+    }
+    return {
+        hostId,
+        storeFilename: terminalStorePath(absoluteSettingsPath),
+        hostIdFilename,
+    };
+}
+/** 每个浏览器 attachment 都是一个短命 generation，不能写入持久记录。 */
+export function terminalAttachmentGeneration(hostId, attachmentId) {
+    return `${hostId}:terminal-attach:${attachmentId}`;
+}
+/** 工作区身份使用规范化绝对路径，避免同一路径的相对写法生成两份映射。 */
+export function terminalWorkspaceId(cwd) {
+    return absolutePath(cwd);
+}
+/**
+ * 在 Host 启动时读取一次启用快照并安装唯一 controller。
+ * 设置后续变化不会热切同名 Cordis service，必须重启 DSH 才会重新选择模式。
+ */
+export async function installTerminalController(ctx, settings, provider, options = {}) {
+    const createController = options.createController ?? createTerminalController;
+    const current = settings.get();
+    const enhancedEnabled = current.modules.terminalEnhancement ?? false;
+    const common = {
+        settings: () => settings.get().terminalEnhancement,
+        ...(options.platform === undefined ? {} : { platform: options.platform }),
+        ...(options.resolveWorkspaceRoot === undefined ? {} : { resolveWorkspaceRoot: options.resolveWorkspaceRoot }),
+    };
+    if (!enhancedEnabled) {
+        return createController(ctx, { enhancedEnabled: false, ...common });
+    }
+    const documentPath = provider.documentPath;
+    if (documentPath === undefined) {
+        throw new Error('终端强化需要文件型 DSH 设置 Provider，以便持久保存 Host ID 和终端映射');
+    }
+    const identity = await (options.resolveIdentity ?? resolveTerminalStartupIdentity)(documentPath);
+    return createController(ctx, {
+        enhancedEnabled: true,
+        hostId: identity.hostId,
+        storeFilename: identity.storeFilename,
+        generation: (_agent, attachmentId) => terminalAttachmentGeneration(identity.hostId, attachmentId),
+        workspaceId: (_agent, cwd) => terminalWorkspaceId(cwd),
+        ...common,
+    });
+}
+function parseHostId(value, source) {
+    const normalized = value.trim().toLowerCase();
+    if (!HOST_ID_PATTERN.test(normalized))
+        throw new Error(`${source} 包含无效的终端 Host ID`);
+    return normalized;
+}
+function isMissingFile(error) {
+    return isNodeError(error) && error.code === 'ENOENT';
+}
+function isExistingFile(error) {
+    return isNodeError(error) && error.code === 'EEXIST';
+}
+function isNodeError(error) {
+    return error instanceof Error;
+}
+function absolutePath(path) {
+    return isAbsolute(path) ? path : join(process.cwd(), path);
+}
+//# sourceMappingURL=startup.js.map

package/data/build/dist/host/terminal/terminal-controller.d.ts

@@ -0,0 +1,78 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
+import type { TerminalEnhancementSettings } from '../../shared/contracts/config.js';
+import type { CodingNsTerminalCreateRequest, CodingNsTerminalEnvironment, CodingNsTerminalFrame, CodingNsTerminalRetentionFrame, CodingNsTerminalRuntimeType, CodingNsTerminalShellOption, CodingNsWebTerminalInfo } from '../../shared/contracts/terminal.js';
+import { type DetectedTerminalShell, type TerminalShellProfileId } from './shell-detection.js';
+import { CodingNsTerminalService } from './terminal-service.js';
+declare module '@deepseek-ai/dsh-typert-protocol' {
+    interface RemoteErrorDetailsMap {
+        'terminal/unavailable': Record<string, never>;
+        'terminal/control-unavailable': {
+            readonly reason: 'read-only' | 'not-running';
+        };
+        'terminal/limit-reached': {
+            readonly limit: number;
+        };
+    }
+}
+export interface DshTerminalAgent {
+    readonly id: string;
+    readonly session: {
+        readonly header?: {
+            readonly cwd?: string;
+        };
+    };
+}
+export interface CodingNsTerminalControllerOptions {
+    readonly hostId: string;
+    readonly service: CodingNsTerminalService;
+    readonly settings: () => TerminalEnhancementSettings;
+    readonly platform?: string;
+    readonly generation?: (agent: DshTerminalAgent, attachmentId: string) => string;
+    readonly workspaceId?: (agent: DshTerminalAgent, cwd: string) => string;
+    /** 基线模式固定使用进程内 PTY；强化模式再按平台选择持久 backend。 */
+    readonly runtimeType?: (profileId: Exclude<TerminalShellProfileId, 'system'>, platform: string) => CodingNsTerminalRuntimeType;
+    readonly detectShells?: () => readonly DetectedTerminalShell[];
+    readonly maxTerminals?: number;
+    readonly maxInputBytes?: number;
+    readonly maxCols?: number;
+    readonly maxRows?: number;
+}
+/** 与 DSH 0.1.6-alpha.2 `remote.terminal` 完全同名、同方法的 Host controller。 */
+export declare class CodingNsTerminalController extends TypertRemoteService {
+    private readonly options;
+    static inject: string[];
+    private readonly platform;
+    private readonly detectShells;
+    private readonly maxTerminals;
+    private readonly maxInputBytes;
+    private readonly maxCols;
+    private readonly maxRows;
+    /** 绑定范围与 controller 一样在 DSH 启动时锁定，避免运行中切换造成终端集合瞬间变化。 */
+    private readonly bindingScope;
+    /** list/retain 的官方 wire 只有 sessionId；这里把它解析到工作区后再查持久终端。 */
+    private readonly sessionWorkspaces;
+    constructor(ctx: Context, options: CodingNsTerminalControllerOptions);
+    environment(agent: DshTerminalAgent, signal: AbortSignal): CodingNsTerminalEnvironment;
+    shells(agent: DshTerminalAgent, signal: AbortSignal): CodingNsTerminalShellOption[];
+    list(sessionId: string): CodingNsWebTerminalInfo[];
+    create(agent: DshTerminalAgent, request: CodingNsTerminalCreateRequest, signal: AbortSignal): Promise<CodingNsWebTerminalInfo>;
+    retain(sessionId: string, id: string, signal: AbortSignal): AsyncIterable<CodingNsTerminalRetentionFrame>;
+    follow(agent: DshTerminalAgent, id: string, attachmentId: string, signal: AbortSignal): AsyncIterable<CodingNsTerminalFrame>;
+    write(agent: DshTerminalAgent, id: string, attachmentId: string, data: string): Promise<void>;
+    resize(agent: DshTerminalAgent, id: string, attachmentId: string, cols: number, rows: number): Promise<void>;
+    rename(agent: DshTerminalAgent, id: string, title: string): Promise<void>;
+    close(agent: DshTerminalAgent, id: string): Promise<void>;
+    private selectShell;
+    private cwd;
+    private scope;
+    private rememberWorkspace;
+    /**
+     * Workspace Registry 是跨会话的稳定身份。只有找不到正式工作区时才回退到
+     * 插件提供的 cwd 规则，避免把同一工作区的不同 Session 拆成多个终端集合。
+     */
+    private workspaceId;
+    private identity;
+    private optionalIdentity;
+}
+//# sourceMappingURL=terminal-controller.d.ts.map