@jaychang1989/dsh-webchat 0.3.0 → 0.4.1

package/lib/types/protocol.d.ts

@@ -1,107 +0,0 @@
-/**
- * Shared wire surface of the dsh-webchat plugin: API paths, transcript data
- * model, and engine status views. Imported by both the host routes and the
- * browser panel (the client bundle inlines it — no shared runtime identity).
- */
-/** One transcript message (markdown text). */
-export interface WebChatMessage {
-    /** Local stable id. */
-    readonly id: string;
-    readonly role: 'user' | 'assistant';
-    /** Markdown body. */
-    readonly content: string;
-    /** Unix epoch ms. */
-    readonly ts: number;
-    /** True while the engine is still streaming this message. */
-    readonly streaming?: boolean;
-    /** Set when the exchange failed (content may be partial). */
-    readonly error?: string;
-    /** Local absolute paths of images attached to a user message. */
-    readonly attachments?: string[];
-}
-/** One web chat session transcript (persisted locally). */
-export interface WebChatTranscript {
-    readonly id: string;
-    title: string;
-    readonly createdAt: number;
-    updatedAt: number;
-    /** Model the chat currently runs on the web (deepseek-chat / deepseek-reasoner). */
-    model: string;
-    readonly messages: WebChatMessage[];
-    /** True while an assistant reply is streaming. */
-    streaming: boolean;
-}
-/**
- * Structured engine error codes so callers (panel / agent tools) can act on a
- * failure instead of only printing it: NEED_LOGIN → prompt the login window;
- * PAGE_CHANGED → the DeepSeek page/stream protocol moved and the plugin likely
- * needs an upgrade; TIMEOUT → generation exceeded the reply window; NETWORK →
- * browser launch / HTTP / connectivity failure.
- */
-export type WebChatErrorCode = 'NEED_LOGIN' | 'PAGE_CHANGED' | 'TIMEOUT' | 'NETWORK';
-/** Coarse engine state for the panel. */
-export type EngineState = 'stopped' | 'launching' | 'ready' | 'error';
-/** Snapshot the panel polls. */
-export interface WebChatState {
-    readonly engine: EngineState;
-    readonly engineError?: string;
-    /** null = unknown yet; false = browser up but not logged in; true = chat page ready. */
-    readonly loggedIn: boolean | null;
-    readonly pageUrl?: string;
-    /** Deep-think (R1) toggle state read from the page. */
-    readonly deepThink: boolean;
-    /** Internet-search toggle state read from the page. */
-    readonly search: boolean;
-    readonly activeChatId?: string;
-    readonly chats: WebChatTranscript[];
-    /** True while a message is being sent / replied (serialized engine busy). */
-    readonly busy: boolean;
-    /** Last send error, transient for the panel to display. */
-    readonly lastError?: string;
-    /** Structured code for the last error (so the panel can show a targeted action). */
-    readonly lastErrorCode?: WebChatErrorCode;
-}
-/** Engine-level operation results surfaced to agent tools. */
-export interface SendResult {
-    readonly ok: boolean;
-    readonly chatId?: string;
-    readonly reply?: string;
-    readonly error?: string;
-    /** Structured error code (when ok is false) for actionable handling. */
-    readonly code?: WebChatErrorCode;
-}
-/** Result of transferring a transcript into harness mode. */
-export interface TransferResult {
-    readonly ok: boolean;
-    readonly sessionId?: string;
-    readonly filePath?: string;
-    /** True when the session was attached to a workspace (grouped); false = ungrouped. */
-    readonly attached?: boolean;
-    /** Workspace id the session landed in, when attached. */
-    readonly workspaceId?: string;
-    readonly error?: string;
-}
-/**
- * How a transfer seeds the new harness session: 'distill' condenses the web
- * conversation into an executable task brief via the harness LLM; 'raw'
- * replays the full transcript verbatim. The web panel lets the user choose.
- */
-export type TransferMode = 'distill' | 'raw';
-/** API path constants shared by host routes and the browser panel. */
-export declare const WEBChat_API: {
-    readonly state: "/api/dsh-webchat/state";
-    readonly openLogin: "/api/dsh-webchat/open-login";
-    readonly closeBrowser: "/api/dsh-webchat/close-browser";
-    readonly newChat: "/api/dsh-webchat/new-chat";
-    readonly send: "/api/dsh-webchat/send";
-    readonly stop: "/api/dsh-webchat/stop";
-    readonly deepThink: "/api/dsh-webchat/deep-think";
-    readonly search: "/api/dsh-webchat/search";
-    readonly transfer: "/api/dsh-webchat/transfer";
-    readonly exportFile: "/api/dsh-webchat/export";
-    readonly renameChat: "/api/dsh-webchat/rename";
-    readonly deleteChat: "/api/dsh-webchat/delete";
-    readonly clearChats: "/api/dsh-webchat/clear";
-    readonly webChats: "/api/dsh-webchat/web-chats";
-    readonly recover: "/api/dsh-webchat/recover";
-};

package/lib/types/routes.d.ts

@@ -1,22 +0,0 @@
-/**
- * The /api/dsh-webchat route family: engine state, browser login control,
- * chat operations (new chat / send / stop / switch model), transcript
- * export, and the harness transfer that seeds a new session with a web
- * transcript. Every route carries the same loopback-only trust fence the
- * dsh-ssh plugin uses — these endpoints drive a browser and create sessions,
- * so LAN-exposed deployments must not serve them.
- */
-import type { Context } from '@deepseek-ai/cordis';
-import type { WebRoute } from '@deepseek-ai/dsh-host-webserver';
-import type { DeepSeekWebEngine } from './engine/engine.ts';
-import type { TranscriptStore } from './store.ts';
-import type { DistillConfig } from './transfer.ts';
-/** Route family dependencies. */
-export interface WebChatRoutesDeps {
-    ctx: Context;
-    engine: DeepSeekWebEngine;
-    store: TranscriptStore;
-    distill: DistillConfig;
-}
-/** Build every /api/dsh-webchat route. */
-export declare function makeRoutes(deps: WebChatRoutesDeps): WebRoute[];

package/lib/types/store.d.ts

@@ -1,69 +0,0 @@
-/**
- * Local transcript store. Chats are persisted as one JSON file under the
- * plugin data dir (~/.dsh/dsh-webchat/transcripts.json by default) so web
- * conversations survive restarts and can be transferred into harness mode
- * at any time. Atomic writes (tmp + rename) keep a crash from corrupting
- * history.
- */
-import type { WebChatMessage, WebChatTranscript } from './protocol.ts';
-/** Default plugin data directory (tests inject a sandbox root). */
-export declare function defaultDataDir(): string;
-export interface TranscriptStoreOptions {
-    /** Root data dir; the transcripts file lives directly under it. */
-    dataDir?: string;
-}
-/**
- * JSON-file transcript store. All mutations are synchronous and persisted
- * immediately (chats are small); the engine and routes use this single
- * instance so GUI and agent tools always see the same history.
- */
-export declare class TranscriptStore {
-    readonly dataDir: string;
-    private readonly file;
-    private chats;
-    private activeChatId;
-    constructor(options?: TranscriptStoreOptions);
-    private read;
-    private persist;
-    /** Create a fresh chat and make it active. */
-    createChat(model: string): WebChatTranscript;
-    /** All chats, newest first. */
-    list(): WebChatTranscript[];
-    /** Local transcript titles (for matching against the web sidebar). */
-    titles(): string[];
-    /**
-     * Import a recovered web conversation as a local transcript. Dedups by exact
-     * title (web conversations with the same title map to the existing chat), so
-     * re-syncing is idempotent. Returns the chat plus whether it was newly created.
-     */
-    importTranscript(input: {
-        title: string;
-        model: string;
-        messages: WebChatMessage[];
-    }): {
-        chat: WebChatTranscript;
-        created: boolean;
-    };
-    /** The active chat, or undefined when none exists yet. */
-    activeChat(): WebChatTranscript | undefined;
-    /** Read one chat by id. */
-    getChat(id: string): WebChatTranscript | undefined;
-    /** Pick the active chat, creating one if none exists. */
-    ensureActiveChat(model: string): WebChatTranscript;
-    /** Set which chat is active. */
-    setActiveChat(id: string): boolean;
-    /** Mutate the active (or named) chat and persist. */
-    private update;
-    /** Append a message to a chat. */
-    appendMessage(id: string, message: WebChatMessage): WebChatTranscript | undefined;
-    /** Replace (or insert) one message by id — used for streaming updates. */
-    upsertMessage(id: string, message: WebChatMessage): WebChatTranscript | undefined;
-    /** Mark the chat's streaming flag (assistant reply started/stopped). */
-    setStreaming(id: string, streaming: boolean, model?: string): WebChatTranscript | undefined;
-    /** Rename a chat (used to pin a meaningful title after the first exchange). */
-    renameChat(id: string, title: string): WebChatTranscript | undefined;
-    /** Delete one chat; a deleted active chat falls back to the newest remaining. */
-    deleteChat(id: string): boolean;
-    /** Delete every chat; returns the number removed. */
-    clearAllChats(): number;
-}

package/lib/types/tools.d.ts

@@ -1,27 +0,0 @@
-/**
- * Agent tools: the DSH-native counterpart of the web-chat panel. The harness
- * agent can chat through the DeepSeek web session (webchat_send), inspect
- * stored transcripts (webchat_status / webchat_import), and hand a web
- * conversation into a new harness session (webchat_transfer) — mirroring how
- * Codex's chatgpt mode lets the agent itself use the web subscription.
- */
-import type { Context } from '@deepseek-ai/cordis';
-import type { DeepSeekWebEngine } from './engine/engine.ts';
-import type { TranscriptStore } from './store.ts';
-import type { DistillConfig } from './transfer.ts';
-/** Minimal workspace projection surfaced to the agent (id/path/title only). */
-export interface WorkspaceRef {
-    id: string;
-    path: string;
-    title: string;
-}
-/** The engine-status tool. */
-export declare function webChatStatusTool(engine: DeepSeekWebEngine, store: TranscriptStore, listWorkspaces?: () => WorkspaceRef[] | undefined): import("@deepseek-ai/dsh-tools").ToolDefinition;
-/** The send-via-web tool. */
-export declare function webChatSendTool(engine: DeepSeekWebEngine): import("@deepseek-ai/dsh-tools").ToolDefinition;
-/** The web-conversation recover tool (sync web sidebar → local store). */
-export declare function webChatRecoverTool(engine: DeepSeekWebEngine): import("@deepseek-ai/dsh-tools").ToolDefinition;
-/** The transcript import tool. */
-export declare function webChatImportTool(store: TranscriptStore): import("@deepseek-ai/dsh-tools").ToolDefinition;
-/** The transfer tool (closes over the host context so it can create sessions). */
-export declare function webChatTransferTool(hostCtx: Context, store: TranscriptStore, distill: DistillConfig): import("@deepseek-ai/dsh-tools").ToolDefinition;

package/lib/types/transfer.d.ts

@@ -1,138 +0,0 @@
-/**
- * Harness-mode transfer: turn a web-chat transcript into development context.
- *
- * This is the "Continue in Codex" / ChatGPT-mode analog, and like Codex it is
- * a CONTEXT HANDOFF rather than a raw replay: the exploration-phase web
- * conversation is distilled (via the harness LLM) into an executable task
- * brief — the execution-phase state representation the agent actually needs —
- * and that brief seeds a fresh harness session. The raw transcript is kept as
- * the fallback when distillation is unavailable.
- *
- * Two targets:
- *  - new harness session — a COLD persisted session seeded with the distilled
- *    brief (or raw transcript), so it shows up in the GUI list and resumes;
- *  - workspace file — the raw transcript rendered to markdown in the target
- *    project directory, so any agent can read it with file tools.
- *
- * Session creation writes directly through the session-persistence backend
- * (`sessionPersistence.create` + `append`), NOT `ctx.sessions.create()`:
- * the store's `create` produces a LIVE session owned by the calling fiber,
- * which the GUI then refuses to resume ("cannot prepare … while it is live").
- * A cold persisted session is exactly what the GUI's resume path expects.
- */
-import type { Context } from '@deepseek-ai/cordis';
-import type { SessionEvent } from '@deepseek-ai/dsh-session';
-import type { Workspace } from '@deepseek-ai/dsh-workspace';
-import type { TransferMode, WebChatMessage, WebChatTranscript } from './protocol.ts';
-/** Render the message list of a transcript (no header) to markdown. */
-export declare function renderMessagesMarkdown(messages: WebChatMessage[], options?: {
-    excludeThinking?: boolean;
-}): string;
-/** Render one transcript to markdown for harness consumption. */
-export declare function renderTranscriptMarkdown(transcript: WebChatTranscript, options?: {
-    excludeThinking?: boolean;
-}): string;
-/**
- * Framing that turns the distilled brief into established context for the
- * agent — the analog of Codex's "another model started to solve this problem
- * and produced a summary; use it to build on the work already done".
- */
-export declare const HANDOFF_PREAMBLE = "\u8FD9\u662F\u4E00\u6B21\u4ECE DeepSeek \u7F51\u9875\u7AEF\u4F1A\u8BDD\uFF08chat.deepseek.com\uFF09\u8F6C\u6765\u7684\u4E0A\u4E0B\u6587\u4EA4\u63A5\u3002\u4E0B\u9762\u7684\u4EFB\u52A1\u7B80\u62A5\u5DF2\u628A\u8BE5\u5BF9\u8BDD\u63D0\u70BC\u4E3A\u53EF\u6267\u884C\u7684\u4EFB\u52A1\u4E0A\u4E0B\u6587\u2014\u2014\u628A\u5B83\u5F53\u4F5C\u65E2\u5B9A\u76EE\u6807\u4E0E\u80CC\u666F\uFF0C\u76F4\u63A5\u5728\u5176\u57FA\u7840\u4E0A\u7EE7\u7EED\uFF0C\u4E0D\u8981\u590D\u8FF0\u3002";
-/** Transfer distillation settings (resolved from the plugin config surface). */
-export interface DistillConfig {
-    /** When true (default), distill the transcript into a task brief via ctx.llm. */
-    distill: boolean;
-    /** Provider route for the distillation call; empty = auto-detect. */
-    provider: string;
-    /** Model id for the distillation call; empty = auto-detect. */
-    model: string;
-    /** Output-token cap for the final brief (single-shot / reduce). Default 4096. */
-    maxTokens?: number;
-    /** Output-token cap for each per-chunk map summary. Default 1024. */
-    chunkTokens?: number;
-}
-/** Default output-token cap for the final distillation brief. */
-export declare const DEFAULT_TRANSFER_MAX_TOKENS = 4096;
-/** Default output-token cap for one chunk summary in the map phase. */
-export declare const DEFAULT_TRANSFER_CHUNK_TOKENS = 1024;
-/** Character budget per chunk when splitting a long transcript for map-reduce. */
-export declare const CHUNK_CHAR_BUDGET = 12000;
-/** A successful distillation result. */
-export interface DistillResult {
-    brief: string;
-    provider: string;
-    model: string;
-}
-/**
- * Split a transcript's messages into chunks of at most `budget` characters
- * (sum of `message.content.length`), never splitting a single message: a
- * message larger than the budget becomes its own (oversized) chunk. Streaming
- * assistant messages are skipped (they were never completed).
- */
-export declare function chunkTranscript(transcript: WebChatTranscript, budget?: number): WebChatMessage[][];
-/**
- * Distill a web transcript into an executable task brief via the harness LLM.
- * Long transcripts are distilled with map-reduce: each chunk is summarized
- * (map, capped at `chunkTokens`), then the summaries are merged into the final
- * brief (reduce, capped at `maxTokens`). Short transcripts take a single shot.
- * Returns undefined (so callers fall back to the raw transcript) when the LLM
- * service, a provider/model, or a clean completion is unavailable.
- */
-export declare function distillTranscriptToBrief(ctx: Context, transcript: WebChatTranscript, config: DistillConfig): Promise<DistillResult | undefined>;
-/** Build a user-message surface event carrying the handoff text at a given seq. */
-export declare function transcriptUserMessageEvent(markdown: string, seq: number): SessionEvent<'user/message'>;
-/** Build the seed user-message event carrying the handoff text (seq 0). */
-export declare function transcriptSeedEvent(markdown: string): SessionEvent<'user/message'>;
-export interface TransferWorkspaceTarget {
-    /** Stable workspace id (from the registry / GUI picker); wins over `path`. */
-    workspaceId?: string;
-    /** Directory path to use as the session cwd (optionally resolves to a workspace). */
-    path?: string;
-}
-export interface TransferToSessionInput {
-    transcript: WebChatTranscript;
-    cwd?: string;
-    /** Target workspace; when set, the session is grouped under it (attached). */
-    workspace?: TransferWorkspaceTarget;
-    /**
-     * Existing harness session to CONTINUE instead of creating a new one. When
-     * set, the distilled brief (or raw transcript) is appended as a fresh user
-     * message to that session rather than seeding a new session.
-     */
-    targetSessionId?: string;
-}
-/** Resolved transfer destination: the session cwd plus an optional owning workspace. */
-export interface ResolvedTransferTarget {
-    cwd: string;
-    workspace?: Workspace;
-}
-/** The result of creating a transferred harness session. */
-export interface TransferToSessionResult {
-    sessionId: string;
-    distilled: boolean;
-    /** True when the session was attached to a workspace; false = ungrouped. */
-    attached: boolean;
-    /** Workspace id the session landed in, when attached. */
-    workspaceId?: string;
-}
-/**
- * Create a new COLD harness session seeded with a distilled task brief (or the
- * raw transcript when the user chooses 'raw' / distillation is unavailable),
- * written straight through the session-persistence backend so the GUI lists it
- * and can resume it later (no live-store ownership). When `input.workspace`
- * names a registered workspace, the session's cwd is set to that workspace's
- * canonical path and the session is attached to the workspace's account, so
- * the GUI groups it under that workspace instead of "ungrouped".
- *
- * `mode` is the user's explicit choice; when undefined the plugin config
- * default (`transferDistill`) applies.
- */
-export declare function transferToHarnessSession(ctx: Context, input: TransferToSessionInput, config: DistillConfig, mode?: TransferMode): Promise<TransferToSessionResult>;
-export interface ExportTranscriptInput {
-    transcript: WebChatTranscript;
-    cwd?: string;
-}
-/** Write the transcript markdown into the target directory; returns the path. */
-export declare function exportTranscriptFile(input: ExportTranscriptInput): {
-    filePath: string;
-};

package/src/client/api.ts

@@ -1,90 +0,0 @@
-/**
- * Browser-side API client for the /api/dsh-webchat route family. The only
- * data access path the panel components use — plain fetch, same origin.
- */
-
-import { WEBChat_API, type TransferMode, type WebChatState } from '../protocol.ts'
-
-/** Shape every /api/dsh-webchat response carries: ok plus optional error. */
-interface ApiResult {
-  ok: boolean
-  error?: string
-}
-
-/** Endpoint payloads always extend ApiResult. */
-type EndpointResult<T> = T & ApiResult
-
-async function request<T>(path: string, body?: unknown): Promise<EndpointResult<T>> {
-  const response = await fetch(path, {
-    method: body === undefined ? 'GET' : 'POST',
-    headers: body === undefined ? undefined : { 'content-type': 'application/json' },
-    body: body === undefined ? undefined : JSON.stringify(body),
-  })
-  const payload = (await response.json().catch(() => ({}))) as EndpointResult<T>
-  if (!response.ok && payload.ok !== true) {
-    return { ...payload, ok: false, error: payload.error ?? `HTTP ${response.status}` }
-  }
-  return payload
-}
-
-export class WebChatApi {
-  state(): Promise<EndpointResult<WebChatState>> {
-    return request<WebChatState>(WEBChat_API.state)
-  }
-
-  openLogin(): Promise<EndpointResult<{ ok: boolean }>> {
-    return request<{ ok: boolean }>(WEBChat_API.openLogin)
-  }
-
-  closeBrowser(): Promise<EndpointResult<{ ok: boolean }>> {
-    return request<{ ok: boolean }>(WEBChat_API.closeBrowser)
-  }
-
-  newChat(): Promise<EndpointResult<{ ok: boolean; chatId?: string }>> {
-    return request<{ ok: boolean; chatId?: string }>(WEBChat_API.newChat)
-  }
-
-  send(text: string, images?: string[]): Promise<EndpointResult<{ ok: boolean; chatId?: string }>> {
-    return request<{ ok: boolean; chatId?: string }>(WEBChat_API.send, { text, images })
-  }
-
-  stop(): Promise<EndpointResult<{ ok: boolean }>> {
-    return request<{ ok: boolean }>(WEBChat_API.stop)
-  }
-
-  setDeepThink(enabled: boolean): Promise<EndpointResult<{ ok: boolean }>> {
-    return request<{ ok: boolean }>(WEBChat_API.deepThink, { enabled })
-  }
-
-  setSearch(enabled: boolean): Promise<EndpointResult<{ ok: boolean }>> {
-    return request<{ ok: boolean }>(WEBChat_API.search, { enabled })
-  }
-
-  transfer(chatId: string, cwd?: string, mode?: TransferMode, workspaceId?: string, targetSessionId?: string): Promise<EndpointResult<{ ok: boolean; sessionId?: string; distilled?: boolean; attached?: boolean; continued?: boolean; workspaceId?: string }>> {
-    return request<{ ok: boolean; sessionId?: string; distilled?: boolean; attached?: boolean; continued?: boolean; workspaceId?: string }>(WEBChat_API.transfer, { chatId, cwd, mode, workspaceId, targetSessionId })
-  }
-
-  exportFile(chatId: string, cwd?: string): Promise<EndpointResult<{ ok: boolean; filePath?: string }>> {
-    return request<{ ok: boolean; filePath?: string }>(WEBChat_API.exportFile, { chatId, cwd })
-  }
-
-  renameChat(chatId: string, title: string): Promise<EndpointResult<{ ok: boolean }>> {
-    return request<{ ok: boolean }>(WEBChat_API.renameChat, { chatId, title })
-  }
-
-  deleteChat(chatId: string): Promise<EndpointResult<{ ok: boolean }>> {
-    return request<{ ok: boolean }>(WEBChat_API.deleteChat, { chatId })
-  }
-
-  clearChats(): Promise<EndpointResult<{ ok: boolean; count?: number }>> {
-    return request<{ ok: boolean; count?: number }>(WEBChat_API.clearChats)
-  }
-
-  webChats(): Promise<EndpointResult<{ ok: boolean; web: Array<{ title: string }>; missing: string[] }>> {
-    return request<{ ok: boolean; web: Array<{ title: string }>; missing: string[] }>(WEBChat_API.webChats)
-  }
-
-  recover(title: string): Promise<EndpointResult<{ ok: boolean; chatId?: string; title?: string; created?: boolean }>> {
-    return request<{ ok: boolean; chatId?: string; title?: string; created?: boolean }>(WEBChat_API.recover, { title })
-  }
-}

package/src/client/controller.ts

@@ -1,43 +0,0 @@
-/**
- * Panel controller: minimal external state the sidebar entry and the panel
- * share (open/closed), plus a tiny pub/sub. The chat data itself lives in the
- * panel component's polling loop.
- */
-
-export interface PanelSnapshot {
-  readonly panelOpen: boolean
-}
-
-const INITIAL: PanelSnapshot = { panelOpen: false }
-
-/** Plain pub/sub store (no React dependency — used by the DOM sidebar entry). */
-export class PanelController {
-  private snapshot: PanelSnapshot = INITIAL
-  private readonly listeners = new Set<() => void>()
-
-  getSnapshot(): PanelSnapshot {
-    return this.snapshot
-  }
-
-  subscribe(listener: () => void): () => void {
-    this.listeners.add(listener)
-    return () => { this.listeners.delete(listener) }
-  }
-
-  private set(patch: Partial<PanelSnapshot>): void {
-    this.snapshot = { ...this.snapshot, ...patch }
-    for (const listener of [...this.listeners]) listener()
-  }
-
-  open(): void {
-    if (!this.snapshot.panelOpen) this.set({ panelOpen: true })
-  }
-
-  close(): void {
-    if (this.snapshot.panelOpen) this.set({ panelOpen: false })
-  }
-
-  toggle(): void {
-    this.set({ panelOpen: !this.snapshot.panelOpen })
-  }
-}

package/src/client/css-modules.d.ts

@@ -1,5 +0,0 @@
-/** CSS Modules ambient declaration for the tsdown virtual loader. */
-declare module '*.module.css' {
-  const classes: Record<string, string>
-  export default classes
-}

package/src/client/index.ts

@@ -1,75 +0,0 @@
-/**
- * Browser-half entry for the dsh-webchat plugin — runs inside the dsh web GUI.
- *
- * Registers the locale dictionaries and mounts the two DOM surfaces: the
- * sidebar entry row (toggles the panel) and the web-chat panel in the center
- * column. Failure policy: DOM mounting problems are logged, never thrown —
- * the web shell fails the whole boot when a plugin apply throws, and an
- * external plugin must not take the GUI down.
- *
- * Export discipline (packages/client rule): the /client surface carries what
- * cordis loading needs plus types only — all value exports stay internal.
- */
-import type { ClientContext, ISessions, IWorkspaces } from '@deepseek-ai/dsh-client-runtime/client'
-// Type-only: pulls the locale plugin's Context merge (ctx.locale).
-import type {} from '@deepseek-ai/dsh-client-locale/client'
-// Type-only: pulls the LocaleNamespaceMap merge table.
-import type {} from '@deepseek-ai/dsh-client-ui-slots'
-import { WebChatApi } from './api.ts'
-import { PanelController } from './controller.ts'
-import { en, zh, type WebChatKey } from './locales.ts'
-import { mountPanel } from './mount.tsx'
-import { mountSidebarEntry } from './sidebar-entry.ts'
-
-/** Locale namespace this plugin owns. */
-const NS = 'dsh-webchat'
-
-declare module '@deepseek-ai/dsh-client-ui-slots' {
-  interface LocaleNamespaceMap {
-    /** dsh-webchat surface copy. */
-    'dsh-webchat': WebChatKey
-  }
-}
-
-/** Required services (fiber inject waiting — the runtime must be up first). */
-export const inject = ['slots', 'locale', 'sessions', 'workspaces']
-
-/** Type-only surface (export discipline: no value exports beyond the plugin contract). */
-export type { WebChatPanelProps } from './panel/WebChatPanel.tsx'
-export type { WebChatKey } from './locales.ts'
-
-/**
- * Mount the web-chat panel.
- * @param ctx - client root context (locale + sessions services).
- */
-export function apply(ctx: ClientContext): void {
-  ctx.effect(() => ctx.locale.register(NS, { zh, en }), 'dsh-webchat: dictionaries')
-
-  const controller = new PanelController()
-  const api = new WebChatApi()
-  // The host-side dsh-session package also merges `Context.sessions` into
-  // cordis types; the client runtime's ISessions is the authoritative shape
-  // here, so read it through a narrow cast rather than trusting the merged
-  // type (which the host package wins during a shared typecheck).
-  const sessions = (ctx as unknown as { sessions: ISessions }).sessions
-  const workspaces = (ctx as unknown as { workspaces: IWorkspaces }).workspaces
-  const tt = ctx.locale.bind(NS)
-  const currentCwd = (): string | undefined => {
-    const snapshot = sessions.list.getSnapshot()
-    const current = snapshot.current
-    if (current === undefined) return undefined
-    return snapshot.byId[current]?.cwd
-  }
-
-  const disposers: Array<() => void> = []
-  try {
-    disposers.push(mountSidebarEntry({ controller, tt }))
-    disposers.push(mountPanel({ sessions, workspaces, api, controller, tt, currentCwd }))
-  } catch (error) {
-    // DOM failures degrade the panel, never the GUI.
-    console.warn('[dsh-webchat] mount failed:', error)
-  }
-  ctx.effect(() => () => {
-    for (const dispose of disposers.splice(0)) dispose()
-  }, 'dsh-webchat: ui mounts')
-}