@jingyi0605/codingns4dsh 0.1.0

package/data/build/dist/client/terminal/model.d.ts

@@ -0,0 +1,116 @@
+import { Service, type Context } from '@deepseek-ai/cordis';
+import type { CodingNsTerminalCreateRequest, CodingNsTerminalEnvironment, CodingNsTerminalFrame, CodingNsTerminalShellOption, CodingNsWebTerminalInfo, TerminalAttachmentId, WebTerminalId } from '../../shared/contracts/terminal.js';
+import type { RemoteResult } from '@deepseek-ai/dsh-typert-protocol';
+export type { TerminalAttachmentId, WebTerminalId } from '../../shared/contracts/terminal.js';
+export type TerminalEnvironment = CodingNsTerminalEnvironment;
+export type TerminalFrame = CodingNsTerminalFrame;
+export type TerminalShell = CodingNsTerminalShellOption;
+export type WebTerminalInfo = CodingNsWebTerminalInfo;
+/** 只描述自有 Client 实际调用的公开 terminal wire 接口。 */
+export interface TerminalRemote {
+    close(sessionId: string, id: WebTerminalId): Promise<RemoteResult<void>>;
+    create(sessionId: string, request: CodingNsTerminalCreateRequest, signal?: AbortSignal): Promise<RemoteResult<WebTerminalInfo>>;
+    environment(sessionId: string, signal?: AbortSignal): Promise<RemoteResult<TerminalEnvironment>>;
+    follow(sessionId: string, id: WebTerminalId, attachmentId: TerminalAttachmentId, signal?: AbortSignal): AsyncIterable<TerminalFrame>;
+    list(sessionId: string): Promise<RemoteResult<WebTerminalInfo[]>>;
+    rename(sessionId: string, id: WebTerminalId, title: string): Promise<RemoteResult<void>>;
+    resize(sessionId: string, id: WebTerminalId, attachmentId: TerminalAttachmentId, cols: number, rows: number): Promise<RemoteResult<void>>;
+    shells(sessionId: string, signal?: AbortSignal): Promise<RemoteResult<TerminalShell[]>>;
+    write(sessionId: string, id: WebTerminalId, attachmentId: TerminalAttachmentId, data: string): Promise<RemoteResult<void>>;
+}
+export type TerminalRemoteSource = TerminalRemote | (() => TerminalRemote | undefined);
+export interface TerminalRenderFrame {
+    readonly revision: number;
+    readonly frame: Extract<TerminalFrame, {
+        readonly type: 'snapshot' | 'output';
+    }>;
+}
+export interface TerminalViewState {
+    readonly phase: 'idle' | 'loading' | 'creating' | 'connecting' | 'connected' | 'disconnected' | 'closing' | 'closed' | 'failed';
+    readonly environment?: TerminalEnvironment;
+    readonly info?: WebTerminalInfo;
+    readonly title: string;
+    readonly writable: boolean;
+    readonly render?: TerminalRenderFrame;
+    readonly error?: string;
+}
+export interface TerminalLaunchShells {
+    readonly shells: readonly TerminalShell[];
+    readonly selectedShell?: string;
+}
+export interface TerminalCloseFailure {
+    readonly sessionId: string;
+    readonly id: WebTerminalId;
+    readonly title: string;
+    readonly message: string;
+}
+export interface TerminalObservable<T> {
+    getSnapshot(): T;
+    subscribe(listener: () => void): () => void;
+}
+/** 一个 Sidebar 标签对应的终端模型；DOM 卸载只 detach，显式 close 才结束 Host 进程。 */
+export declare class CodingNsTerminalView {
+    readonly sessionId: string;
+    readonly id: WebTerminalId;
+    private readonly remote;
+    private readonly createWhenMissing;
+    private readonly shellPath?;
+    private readonly onWorkspaceResolved?;
+    readonly state: TerminalObservable<TerminalViewState>;
+    private readonly store;
+    private readonly lifetime;
+    private followController;
+    private pendingRender;
+    private mounted;
+    private revision;
+    private loading;
+    private writes;
+    private attachmentId;
+    /** 最近一次已排队的尺寸；ResizeObserver 可能在同一布局周期内重复触发。 */
+    private lastResize;
+    constructor(sessionId: string, id: WebTerminalId, remote: TerminalRemoteSource, createWhenMissing: boolean, shellPath?: string | undefined, onWorkspaceResolved?: ((workspaceId: string) => void) | undefined);
+    mount(): () => void;
+    refresh(): Promise<void>;
+    acknowledge(revision: number): void;
+    write(data: string): void;
+    resize(cols: number, rows: number): void;
+    rename(title: string): Promise<void>;
+    close(): Promise<void>;
+    dispose(): Promise<void>;
+    private load;
+    private connect;
+    private consume;
+    private deliver;
+    private detach;
+    private patch;
+    private fail;
+}
+/** Codingns4DSH 自有的浏览器终端服务，不依赖官方 terminal-controller Client 实现。 */
+export declare class CodingNsWebTerminals extends Service {
+    private readonly remote;
+    private readonly views;
+    private readonly workspaceIds;
+    private readonly recoveries;
+    private readonly closeFailureStore;
+    readonly closeFailures: TerminalObservable<readonly TerminalCloseFailure[]>;
+    private readonly closeRequests;
+    constructor(ctx: Context, remote: TerminalRemoteSource);
+    view(sessionId: string, key: string, contentId: string, terminalId?: WebTerminalId, shellPath?: string): CodingNsTerminalView;
+    /** 返回某个 Sidebar 内容已经保存的 Host 终端身份，用于恢复时去重。 */
+    boundTerminalId(sessionId: string, contentId: string): WebTerminalId | undefined;
+    launchShells(sessionId: string, signal: AbortSignal): Promise<TerminalLaunchShells>;
+    selectShell(path: string): void;
+    close(sessionId: string, key: string, contentId: string, terminalId?: WebTerminalId): void;
+    recover(sessionId: string): Promise<readonly WebTerminalInfo[]>;
+    retryClose(id: WebTerminalId): void;
+    dispose(): Promise<void>;
+    private rememberWorkspace;
+    private cleanup;
+}
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        /** Codingns4DSH 自有的浏览器终端模型服务。 */
+        webTerminals: CodingNsWebTerminals;
+    }
+}
+//# sourceMappingURL=model.d.ts.map

package/data/build/dist/client/terminal/model.js

@@ -0,0 +1,435 @@
+import { Service } from '@deepseek-ai/cordis';
+class ObservableValue {
+    value;
+    listeners = new Set();
+    constructor(value) {
+        this.value = value;
+    }
+    getSnapshot() { return this.value; }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    set(value) {
+        this.value = value;
+        for (const listener of [...this.listeners])
+            listener();
+    }
+}
+/** 一个 Sidebar 标签对应的终端模型；DOM 卸载只 detach，显式 close 才结束 Host 进程。 */
+export class CodingNsTerminalView {
+    sessionId;
+    id;
+    remote;
+    createWhenMissing;
+    shellPath;
+    onWorkspaceResolved;
+    state;
+    store = new ObservableValue({ phase: 'idle', title: '终端', writable: false });
+    lifetime = new AbortController();
+    followController;
+    pendingRender;
+    mounted = 0;
+    revision = 0;
+    loading;
+    writes = Promise.resolve();
+    attachmentId;
+    /** 最近一次已排队的尺寸；ResizeObserver 可能在同一布局周期内重复触发。 */
+    lastResize;
+    constructor(sessionId, id, remote, createWhenMissing, shellPath, onWorkspaceResolved) {
+        this.sessionId = sessionId;
+        this.id = id;
+        this.remote = remote;
+        this.createWhenMissing = createWhenMissing;
+        this.shellPath = shellPath;
+        this.onWorkspaceResolved = onWorkspaceResolved;
+        this.state = this.store;
+    }
+    mount() {
+        this.mounted += 1;
+        if (this.mounted === 1)
+            void this.refresh();
+        let active = true;
+        return () => {
+            if (!active)
+                return;
+            active = false;
+            this.mounted = Math.max(0, this.mounted - 1);
+            if (this.mounted === 0)
+                this.detach();
+        };
+    }
+    async refresh() {
+        if (this.loading !== undefined)
+            return this.loading;
+        if (this.lifetime.signal.aborted)
+            return;
+        this.loading = this.load().finally(() => { this.loading = undefined; });
+        return this.loading;
+    }
+    acknowledge(revision) {
+        if (this.pendingRender?.revision !== revision)
+            return;
+        this.pendingRender.resolve();
+        this.pendingRender = undefined;
+    }
+    write(data) {
+        const state = this.store.getSnapshot();
+        const attachmentId = this.attachmentId;
+        if (!state.writable || attachmentId === undefined || data === '')
+            return;
+        const max = state.environment?.maxInputBytes ?? 64 * 1024;
+        if (new TextEncoder().encode(data).byteLength > max) {
+            this.patch({ error: '终端输入超过允许上限' });
+            return;
+        }
+        this.writes = this.writes
+            .then(async () => { unwrap(await resolveRemote(this.remote).write(this.sessionId, this.id, attachmentId, data)); })
+            .catch((error) => this.fail(error));
+    }
+    resize(cols, rows) {
+        const state = this.store.getSnapshot();
+        const attachmentId = this.attachmentId;
+        if (!state.writable || attachmentId === undefined)
+            return;
+        const nextCols = Math.max(1, Math.min(Math.floor(cols), state.environment?.maxCols ?? 500));
+        const nextRows = Math.max(1, Math.min(Math.floor(rows), state.environment?.maxRows ?? 200));
+        const request = { attachmentId, cols: nextCols, rows: nextRows };
+        if (sameResize(this.lastResize, request))
+            return;
+        this.lastResize = request;
+        this.writes = this.writes
+            .then(async () => { unwrap(await resolveRemote(this.remote).resize(this.sessionId, this.id, attachmentId, nextCols, nextRows)); })
+            .catch((error) => {
+            if (sameResize(this.lastResize, request))
+                this.lastResize = undefined;
+            this.fail(error);
+        });
+    }
+    async rename(title) {
+        const normalized = title.trim();
+        if (normalized === '' || normalized === this.store.getSnapshot().title)
+            return;
+        try {
+            unwrap(await resolveRemote(this.remote).rename(this.sessionId, this.id, normalized));
+            const info = this.store.getSnapshot().info;
+            this.patch({ title: normalized, ...(info === undefined ? {} : { info: { ...info, title: normalized } }) });
+        }
+        catch (error) {
+            this.fail(error);
+        }
+    }
+    async close() {
+        if (this.store.getSnapshot().phase === 'closed')
+            return;
+        this.patch({ phase: 'closing', writable: false });
+        this.detach();
+        unwrap(await resolveRemote(this.remote).close(this.sessionId, this.id));
+        this.patch({ phase: 'closed', writable: false });
+    }
+    async dispose() {
+        this.lifetime.abort(new Error('终端 Client 已卸载'));
+        this.detach();
+        await this.writes.catch(() => undefined);
+    }
+    async load() {
+        this.patch({ phase: 'loading', writable: false });
+        try {
+            const remote = resolveRemote(this.remote);
+            const environment = unwrap(await remote.environment(this.sessionId, this.lifetime.signal));
+            if (environment.workspaceId !== undefined)
+                this.onWorkspaceResolved?.(environment.workspaceId);
+            const listed = unwrap(await remote.list(this.sessionId));
+            let info = listed.find((entry) => entry.id === this.id);
+            if (info === undefined && this.createWhenMissing) {
+                this.patch({ phase: 'creating', environment });
+                info = unwrap(await remote.create(this.sessionId, {
+                    id: this.id,
+                    ...(this.shellPath === undefined ? {} : { shellPath: this.shellPath }),
+                    cols: Math.min(80, environment.maxCols),
+                    rows: Math.min(24, environment.maxRows),
+                }, this.lifetime.signal));
+            }
+            if (info === undefined)
+                throw new Error('Host 中不存在该终端，且恢复流程禁止自动创建替代进程');
+            this.patch({ environment, info, title: info.title });
+            if (this.mounted > 0)
+                this.connect();
+        }
+        catch (error) {
+            if (!this.lifetime.signal.aborted)
+                this.fail(error);
+        }
+    }
+    connect() {
+        if (this.followController !== undefined || this.lifetime.signal.aborted || this.mounted === 0)
+            return;
+        const controller = new AbortController();
+        this.followController = controller;
+        this.attachmentId = crypto.randomUUID();
+        this.lastResize = undefined;
+        this.patch({ phase: 'connecting', writable: false });
+        void this.consume(controller.signal);
+    }
+    async consume(signal) {
+        try {
+            const attachmentId = this.attachmentId;
+            if (attachmentId === undefined)
+                return;
+            for await (const frame of resolveRemote(this.remote).follow(this.sessionId, this.id, attachmentId, signal)) {
+                if (signal.aborted)
+                    break;
+                if (frame.type === 'state') {
+                    this.patch({ info: frame.info, title: frame.info.title });
+                    continue;
+                }
+                await this.deliver(frame);
+            }
+            if (!signal.aborted)
+                this.patch({ phase: 'disconnected', writable: false });
+        }
+        catch (error) {
+            if (!signal.aborted)
+                this.fail(error);
+        }
+        finally {
+            if (this.followController?.signal === signal) {
+                this.followController = undefined;
+                this.attachmentId = undefined;
+            }
+        }
+    }
+    async deliver(frame) {
+        this.pendingRender?.resolve();
+        this.revision += 1;
+        let resolveWaiting = () => { };
+        const waiting = new Promise((resolve) => { resolveWaiting = resolve; });
+        this.pendingRender = { revision: this.revision, resolve: resolveWaiting };
+        this.patch({ phase: 'connected', writable: true, render: { revision: this.revision, frame } });
+        await waiting;
+    }
+    detach() {
+        this.pendingRender?.resolve();
+        this.pendingRender = undefined;
+        this.followController?.abort(new Error('终端视图已 detach'));
+        this.followController = undefined;
+        this.attachmentId = undefined;
+        this.lastResize = undefined;
+        if (!this.lifetime.signal.aborted && this.store.getSnapshot().phase !== 'closed') {
+            const { render: _render, ...state } = this.store.getSnapshot();
+            this.store.set({ ...state, phase: 'disconnected', writable: false });
+        }
+    }
+    patch(patch) {
+        this.store.set({ ...this.store.getSnapshot(), ...patch });
+    }
+    fail(error) {
+        this.patch({ phase: 'failed', writable: false, error: errorMessage(error) });
+    }
+}
+const BINDING_PREFIX = 'dsh.codingns.terminal.binding.v1.';
+const CLOSE_REQUEST_KEY = 'dsh.codingns.terminal.close.v1';
+const SHELL_KEY = 'dsh.codingns.terminal.shell.v1';
+/** Codingns4DSH 自有的浏览器终端服务，不依赖官方 terminal-controller Client 实现。 */
+export class CodingNsWebTerminals extends Service {
+    remote;
+    views = new Map();
+    workspaceIds = new Map();
+    recoveries = new Map();
+    closeFailureStore = new ObservableValue([]);
+    closeFailures = this.closeFailureStore;
+    closeRequests = new Map();
+    constructor(ctx, remote) {
+        super(ctx, 'webTerminals');
+        this.remote = remote;
+        for (const request of readCloseRequests())
+            this.closeRequests.set(String(request.id), request);
+        for (const request of this.closeRequests.values())
+            void this.cleanup(request);
+    }
+    view(sessionId, key, contentId, terminalId, shellPath) {
+        const mapKey = JSON.stringify([sessionId, key]);
+        const existing = this.views.get(mapKey);
+        if (existing !== undefined)
+            return existing.view;
+        const workspaceId = this.workspaceIds.get(sessionId);
+        const saved = terminalId
+            ?? (workspaceId === undefined ? undefined : readWorkspaceBinding(workspaceId, contentId))
+            ?? readBinding(sessionId, contentId);
+        const id = saved ?? crypto.randomUUID();
+        if (saved === undefined)
+            writeBinding(sessionId, contentId, id);
+        const view = new CodingNsTerminalView(sessionId, id, this.remote, saved === undefined, shellPath, (resolvedWorkspaceId) => this.rememberWorkspace(sessionId, contentId, id, resolvedWorkspaceId));
+        this.views.set(mapKey, { contentId, view });
+        return view;
+    }
+    /** 返回某个 Sidebar 内容已经保存的 Host 终端身份，用于恢复时去重。 */
+    boundTerminalId(sessionId, contentId) {
+        const workspaceId = this.workspaceIds.get(sessionId);
+        return (workspaceId === undefined ? undefined : readWorkspaceBinding(workspaceId, contentId))
+            ?? readBinding(sessionId, contentId);
+    }
+    async launchShells(sessionId, signal) {
+        const shells = unwrap(await resolveRemote(this.remote).shells(sessionId, signal));
+        const preferred = readString(SHELL_KEY);
+        return {
+            shells,
+            ...(preferred !== null && shells.some((shell) => shell.path === preferred) ? { selectedShell: preferred } : {}),
+        };
+    }
+    selectShell(path) { writeString(SHELL_KEY, path); }
+    close(sessionId, key, contentId, terminalId) {
+        const mapKey = JSON.stringify([sessionId, key]);
+        const record = this.views.get(mapKey);
+        const id = terminalId ?? record?.view.id ?? this.boundTerminalId(sessionId, contentId);
+        if (id === undefined)
+            return;
+        const request = { sessionId, id, title: record?.view.state.getSnapshot().title ?? '终端' };
+        this.closeRequests.set(String(id), request);
+        persistCloseRequests(this.closeRequests.values());
+        deleteBinding(sessionId, contentId);
+        const workspaceId = this.workspaceIds.get(sessionId);
+        if (workspaceId !== undefined)
+            deleteWorkspaceBinding(workspaceId, contentId);
+        this.views.delete(mapKey);
+        void this.cleanup(request, record?.view);
+    }
+    async recover(sessionId) {
+        const pending = this.recoveries.get(sessionId);
+        if (pending !== undefined)
+            return pending;
+        // 官方 list wire 只有 sessionId；先用 agent-scoped environment 让 Host 解析工作区。
+        const recovery = (async () => {
+            const environment = unwrap(await resolveRemote(this.remote).environment(sessionId));
+            if (environment.workspaceId !== undefined)
+                this.workspaceIds.set(sessionId, environment.workspaceId);
+            return unwrap(await resolveRemote(this.remote).list(sessionId));
+        })().finally(() => this.recoveries.delete(sessionId));
+        this.recoveries.set(sessionId, recovery);
+        return recovery;
+    }
+    retryClose(id) {
+        const request = this.closeRequests.get(String(id));
+        if (request !== undefined)
+            void this.cleanup(request);
+    }
+    async dispose() {
+        await Promise.all([...this.views.values()].map((record) => record.view.dispose()));
+        this.views.clear();
+        this.workspaceIds.clear();
+        this.recoveries.clear();
+    }
+    rememberWorkspace(sessionId, contentId, id, workspaceId) {
+        this.workspaceIds.set(sessionId, workspaceId);
+        writeWorkspaceBinding(workspaceId, contentId, id);
+    }
+    async cleanup(request, view) {
+        try {
+            if (view === undefined)
+                unwrap(await resolveRemote(this.remote).close(request.sessionId, request.id));
+            else
+                await view.close();
+            this.closeRequests.delete(String(request.id));
+            persistCloseRequests(this.closeRequests.values());
+            this.closeFailureStore.set(this.closeFailureStore.getSnapshot().filter((item) => item.id !== request.id));
+        }
+        catch (error) {
+            const failure = { ...request, message: errorMessage(error) };
+            this.closeFailureStore.set([...this.closeFailureStore.getSnapshot().filter((item) => item.id !== request.id), failure]);
+        }
+    }
+}
+function unwrap(result) {
+    if (typeof result !== 'object' || result === null || !('ok' in result)) {
+        throw new Error('终端服务返回了无效响应');
+    }
+    if (result.ok)
+        return result.value;
+    throw result.error;
+}
+function resolveRemote(source) {
+    const remote = typeof source === 'function' ? source() : source;
+    if (remote === undefined)
+        throw new Error('终端服务尚未就绪，请稍后重试');
+    return remote;
+}
+function sameResize(left, right) {
+    return left?.attachmentId === right.attachmentId && left.cols === right.cols && left.rows === right.rows;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function bindingKey(sessionId, contentId) {
+    return `${BINDING_PREFIX}${JSON.stringify([sessionId, contentId])}`;
+}
+function workspaceBindingKey(workspaceId, contentId) {
+    return `${BINDING_PREFIX}${JSON.stringify(['workspace', workspaceId, contentId])}`;
+}
+function readBinding(sessionId, contentId) {
+    const value = readString(bindingKey(sessionId, contentId));
+    return value !== null && /^[\w-]{1,128}$/u.test(value) ? value : undefined;
+}
+function writeBinding(sessionId, contentId, id) {
+    writeString(bindingKey(sessionId, contentId), String(id));
+}
+function readWorkspaceBinding(workspaceId, contentId) {
+    const value = readString(workspaceBindingKey(workspaceId, contentId));
+    return value !== null && /^[\w-]{1,128}$/u.test(value) ? value : undefined;
+}
+function writeWorkspaceBinding(workspaceId, contentId, id) {
+    writeString(workspaceBindingKey(workspaceId, contentId), String(id));
+}
+function deleteWorkspaceBinding(workspaceId, contentId) {
+    try {
+        localStorage.removeItem(workspaceBindingKey(workspaceId, contentId));
+    }
+    catch { /* 浏览器禁用存储时仅失去跨刷新绑定。 */ }
+}
+function deleteBinding(sessionId, contentId) {
+    try {
+        localStorage.removeItem(bindingKey(sessionId, contentId));
+    }
+    catch { /* 浏览器禁用存储时仅失去跨刷新绑定。 */ }
+}
+function readCloseRequests() {
+    const raw = readString(CLOSE_REQUEST_KEY);
+    if (raw === null)
+        return [];
+    try {
+        const values = JSON.parse(raw);
+        if (!Array.isArray(values))
+            return [];
+        return values.filter(isCloseRequest);
+    }
+    catch {
+        return [];
+    }
+}
+function isCloseRequest(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const record = value;
+    return typeof record.sessionId === 'string' && typeof record.id === 'string' && typeof record.title === 'string';
+}
+function persistCloseRequests(requests) {
+    writeString(CLOSE_REQUEST_KEY, JSON.stringify([...requests]));
+}
+function readString(key) {
+    if (typeof localStorage === 'undefined')
+        return null;
+    try {
+        return localStorage.getItem(key);
+    }
+    catch {
+        return null;
+    }
+}
+function writeString(key, value) {
+    if (typeof localStorage === 'undefined')
+        return;
+    try {
+        localStorage.setItem(key, value);
+    }
+    catch { /* 无痕或受限环境继续使用内存状态。 */ }
+}
+//# sourceMappingURL=model.js.map

package/data/build/dist/client/terminal/styles.d.ts

@@ -0,0 +1,21 @@
+export declare const terminalClass: {
+    readonly guideEntry: "codingns4dsh-terminal-guide-entry";
+    readonly guideMain: "codingns4dsh-terminal-guide-main";
+    readonly guideIcon: "codingns4dsh-terminal-guide-icon";
+    readonly guideText: "codingns4dsh-terminal-guide-text";
+    readonly guideTitle: "codingns4dsh-terminal-guide-title";
+    readonly guideDescription: "codingns4dsh-terminal-guide-description";
+    readonly guideTrigger: "codingns4dsh-terminal-guide-trigger";
+    readonly guideMenu: "codingns4dsh-terminal-guide-menu";
+    readonly title: "codingns4dsh-terminal-title";
+    readonly titleInput: "codingns4dsh-terminal-title-input";
+    readonly root: "codingns4dsh-terminal-root";
+    readonly screen: "codingns4dsh-terminal-screen";
+    readonly status: "codingns4dsh-terminal-status";
+    readonly error: "codingns4dsh-terminal-error";
+    readonly cleanupStack: "codingns4dsh-terminal-cleanup-stack";
+    readonly cleanupNotice: "codingns4dsh-terminal-cleanup-notice";
+};
+/** 安装与 DSH 0.1.6 内置终端相同的布局和主题令牌。 */
+export declare function installTerminalStyles(): () => void;
+//# sourceMappingURL=styles.d.ts.map

package/data/build/dist/client/terminal/styles.js

@@ -0,0 +1,51 @@
+const STYLE_ID = 'codingns4dsh-terminal-ui';
+export const terminalClass = {
+    guideEntry: 'codingns4dsh-terminal-guide-entry',
+    guideMain: 'codingns4dsh-terminal-guide-main',
+    guideIcon: 'codingns4dsh-terminal-guide-icon',
+    guideText: 'codingns4dsh-terminal-guide-text',
+    guideTitle: 'codingns4dsh-terminal-guide-title',
+    guideDescription: 'codingns4dsh-terminal-guide-description',
+    guideTrigger: 'codingns4dsh-terminal-guide-trigger',
+    guideMenu: 'codingns4dsh-terminal-guide-menu',
+    title: 'codingns4dsh-terminal-title',
+    titleInput: 'codingns4dsh-terminal-title-input',
+    root: 'codingns4dsh-terminal-root',
+    screen: 'codingns4dsh-terminal-screen',
+    status: 'codingns4dsh-terminal-status',
+    error: 'codingns4dsh-terminal-error',
+    cleanupStack: 'codingns4dsh-terminal-cleanup-stack',
+    cleanupNotice: 'codingns4dsh-terminal-cleanup-notice',
+};
+/** 安装与 DSH 0.1.6 内置终端相同的布局和主题令牌。 */
+export function installTerminalStyles() {
+    const existing = document.querySelector(`style[data-plugin-css="${STYLE_ID}"]`);
+    if (existing !== null)
+        return () => undefined;
+    const style = document.createElement('style');
+    style.dataset.plugin = 'codingns4dsh';
+    style.dataset.pluginCss = STYLE_ID;
+    style.textContent = terminalCss;
+    document.head.appendChild(style);
+    return () => style.remove();
+}
+const terminalCss = `
+.${terminalClass.guideEntry}{box-sizing:border-box;border:.5px solid var(--dsw-alias-border-l4);background:var(--dsw-alias-bg-layer-1);border-radius:24px;align-items:stretch;width:100%;display:flex;overflow:hidden}
+.${terminalClass.guideMain}{text-align:left;border-radius:24px 0 0 24px;flex:1;justify-content:flex-start;gap:14px;min-width:0;height:auto;min-height:56px;padding:14px 20px}
+.${terminalClass.guideIcon}{flex:none}
+.${terminalClass.guideText}{flex-direction:column;gap:3px;min-width:0;display:flex}
+.${terminalClass.guideTitle}{color:var(--dsw-alias-label-primary);white-space:nowrap;text-overflow:ellipsis;font-size:15px;line-height:1.4;overflow:hidden}
+.${terminalClass.guideDescription}{color:var(--dsw-alias-label-caption);white-space:nowrap;text-overflow:ellipsis;font-size:13px;line-height:1.4;overflow:hidden}
+.${terminalClass.guideTrigger}{border-radius:0 24px 24px 0;flex:none;align-self:stretch;width:44px;height:auto;padding:0}
+.${terminalClass.guideMenu}{flex:none;align-self:stretch;display:flex}
+.${terminalClass.title}{text-overflow:ellipsis;white-space:nowrap;min-width:0;overflow:hidden}
+.${terminalClass.titleInput}{width:120px;min-width:48px;max-width:100%;color:inherit;font:inherit;background:var(--dsw-alias-bg-l1);border:.5px solid var(--dsw-alias-border-l3);border-radius:4px;outline:none;padding:0 4px}
+.${terminalClass.root}{box-sizing:border-box;height:100%;min-height:0;color:var(--dsw-alias-label-primary);flex-direction:column;flex:1;padding-top:8px;font-size:13px;display:flex}
+.${terminalClass.screen}{min-width:0;min-height:0;color:var(--dsw-alias-label-primary);background:var(--dsw-alias-bg-base);flex:1;padding:8px;overflow:hidden}
+.${terminalClass.status}{background:var(--dsw-alias-bg-l2);flex-wrap:wrap;align-items:center;gap:8px;padding:5px 12px;display:flex}
+.${terminalClass.error}{overflow-wrap:anywhere;color:var(--dsw-alias-label-primary);background:var(--dsw-alias-bg-l2);margin:0;padding:10px 12px}
+.${terminalClass.cleanupStack}{pointer-events:auto;gap:8px;max-width:min(440px,calc(100vw - 40px));display:grid;position:fixed;bottom:20px;right:20px}
+.${terminalClass.cleanupNotice}{border:.5px solid var(--dsw-alias-border-l3);color:var(--dsw-alias-label-primary);background:var(--dsw-alias-bg-l1);overflow-wrap:anywhere;border-radius:8px;align-items:center;gap:12px;padding:12px 16px;font-size:13px;display:flex;box-shadow:0 4px 20px #0002}
+.${terminalClass.cleanupNotice} button{border:.5px solid var(--dsw-alias-border-l3);color:inherit;cursor:pointer;background:transparent;border-radius:4px;flex-shrink:0;padding:4px 8px}
+`;
+//# sourceMappingURL=styles.js.map

package/data/build/dist/client/terminal/ui.d.ts

@@ -0,0 +1,19 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { SettingsScope } from '@deepseek-ai/dsh-client-ui-settings/client';
+import type { CodingNsSettings } from '../../shared/contracts/config.js';
+import { CodingNsWebTerminals, type WebTerminalId } from './model.js';
+export declare const TERMINAL_PROVIDER_ID = "codingns4dsh/terminal";
+export declare const TERMINAL_KIND = "terminal";
+interface TerminalParams {
+    readonly terminalId?: WebTerminalId;
+    readonly shellPath?: string;
+}
+/** 注册终端类型及其所有公开 Sidebar Slot。 */
+export declare function registerCodingNsTerminalUi(ctx: Context, webTerminals: CodingNsWebTerminals, settings: SettingsScope<CodingNsSettings>): () => void;
+declare module '@deepseek-ai/dsh-client-ui-sidebar-right/client' {
+    interface SidebarRightTabParamsMap {
+        terminal: TerminalParams;
+    }
+}
+export {};
+//# sourceMappingURL=ui.d.ts.map