@linxin666/dsh-ssh 0.4.2 → 0.4.4

package/src/mount-once.ts

@@ -5,44 +5,138 @@
  * the loader accepts a standalone install of the same package side by side;
  * without this guard the second instance would still re-register the same
  * webserver routes, tools, settings namespaces, and system-prompt sections
- * and fail the boot. mountOnce makes the second host apply a no-op for the
- * lifetime of the first instance (the browser half is already deduped by
- * package name in the client module host).
+ * and fail the boot. mountOnce makes a mount of an already-mounted package a
+ * no-op for as long as the first instance lives (the browser half is already
+ * deduped by package name in the client module host).
+ *
+ * A no-op is only safe while the holder is ALIVE. The holder can be disposed
+ * long after the refused mount ran its course: the Host reloads a profile by
+ * creating the new loader entries before the old ones are torn down (a
+ * plugin-manager enable/disable/install write, a settings-driven row reload,
+ * HMR), so the new aggregate shell entry mounts its family plugin while the
+ * previous entry still owns the name. Dropping that refused mount lost the
+ * plugin for good - the previous entry then disposed its own mount, releasing
+ * the name with nobody left to take it, and the family row stayed listed as
+ * active while its host routes 404ed (the task-board panel showed
+ * "board.hostError.notMounted", no degraded record appeared, and only a Host
+ * restart recovered it).
+ *
+ * The refused mount is therefore QUEUED, not dropped, and replayed the moment
+ * the holder releases the name - if the waiting fiber is still alive then. The
+ * single-instance guarantee is unchanged: exactly one mount is live per
+ * package name, and the replay re-enters the guard so a later mount still
+ * dedupes against it.
  *
  * The registry rides a global symbol so two module instances of the same
- * package (npm copy vs repository link) still share one verdict. cordis
- * `ctx.effect` runs its callback immediately and treats the callback's
+ * package (npm copy vs repository link) still share one verdict. That symbol
+ * is a CROSS-REPOSITORY contract, not this file's private state: the four
+ * satellite packages (dsh-skins / dsh-pet / dsh-presets /
+ * dsh-community-plugins) are separate repositories carrying their own copy of
+ * this guard, rebuilt on their own schedule, so the value under `MOUNTED`
+ * must keep the shape every published copy reads (a `Set` of package names
+ * with `has`/`add`/`delete`). The wait queues this guard added therefore live
+ * under their own additive key, and the registry reads back a `Set` even when
+ * some other build left a different value there. Changing `MOUNTED`'s shape
+ * in place broke that contract once: a satellite's legacy copy created a
+ * `Set`, the family's new copy read it as a `Map`, and every family row
+ * mounted after it failed with "claims.get is not a function".
+ *
+ * cordis `ctx.effect` runs its callback immediately and treats the callback's
  * return value as the fiber disposer, so the unmarker is returned, not run.
  */
 
+/** Published cross-repository contract: package names currently mounted. */
 const MOUNTED = Symbol.for('dsh-web.mounted-plugins')
 
+/** Additive key this guard owns: refused mounts waiting for the name. */
+const WAITERS = Symbol.for('dsh-web.mounted-plugins.waiters')
+
+/** The slice of a cordis context this guard touches. */
+interface MountContext {
+  effect?: (effect: () => unknown) => unknown
+}
+
+/** One mount that was refused while another fiber owned the package name. */
+interface PendingMount {
+  /** Replay the refused mount; a no-op once its own fiber has been disposed. */
+  run(): void
+}
+
 interface MountRegistry {
-  [MOUNTED]?: Set<string>
+  [MOUNTED]?: unknown
+  [WAITERS]?: Map<string, PendingMount[]>
 }
 
+/**
+ * The shared name registry, always a `Set` whatever another build stored here:
+ * a foreign value (an interim shape, a hand-written global) must not take every
+ * family plugin down with it.
+ * @returns the process-wide set of mounted package names.
+ */
 function mountedSet(): Set<string> {
   const registry = globalThis as MountRegistry
-  return (registry[MOUNTED] ??= new Set())
+  const existing = registry[MOUNTED]
+  if (existing instanceof Set) return existing as Set<string>
+  const created = new Set<string>()
+  registry[MOUNTED] = created
+  return created
+}
+
+/** Queue per package name for mounts refused while a holder was alive. */
+function mountWaiters(): Map<string, PendingMount[]> {
+  const registry = globalThis as MountRegistry
+  return (registry[WAITERS] ??= new Map())
 }
 
 /**
  * Wrap a cordis plugin apply so the package runs at most once per process.
- * The first mount registers normally and unmarks when its fiber disposes;
- * any later mount of the same package name is a no-op.
+ * The first mount registers normally and releases the name when its fiber
+ * disposes; a mount refused while that name is held waits for the release and
+ * then runs, unless its own fiber disposes first.
  * @param packageName - npm package identity shared by every install source.
  * @param fn - the original plugin apply.
  * @returns an apply of the same shape.
  */
 export function mountOnce<T extends (...args: any[]) => unknown>(packageName: string, fn: T): T {
-  return ((...args: unknown[]) => {
+  const mount = (...args: unknown[]): unknown => {
     const mounted = mountedSet()
-    if (mounted.has(packageName)) return
+    const ctx = args[0] as MountContext | undefined
+    if (mounted.has(packageName)) {
+      // Another fiber (the aggregate row, a standalone install, or a copy built
+      // from an older revision of this guard) owns the name. Queue instead of
+      // dropping: dropping lost the plugin for the rest of the process when the
+      // holder was disposed by a reload.
+      const waiters = mountWaiters()
+      const queue = waiters.get(packageName) ?? []
+      let alive = true
+      const pending: PendingMount = {
+        run: () => {
+          if (alive) mount(...args)
+        },
+      }
+      // A fiber that dies while it waits must not be replayed afterwards: its
+      // context is disposed and registering effects on it would throw.
+      ctx?.effect?.(() => () => {
+        alive = false
+        const index = queue.indexOf(pending)
+        if (index >= 0) queue.splice(index, 1)
+      })
+      queue.push(pending)
+      waiters.set(packageName, queue)
+      return
+    }
     mounted.add(packageName)
-    const ctx = args[0] as { effect?: (effect: () => unknown) => unknown } | undefined
     ctx?.effect?.(() => () => {
       mounted.delete(packageName)
+      const waiters = mountWaiters()
+      const queue = waiters.get(packageName)
+      if (queue === undefined) return
+      waiters.delete(packageName)
+      // Defer the handover one microtask so the disposing mount's own effects
+      // (routes, ledger, timers) are torn down before the next one registers.
+      for (const waiter of queue.splice(0)) queueMicrotask(() => { waiter.run() })
     })
     return fn(...args)
-  }) as T
+  }
+  return mount as T
 }

package/src/protocol.ts

@@ -188,7 +188,8 @@ export interface ApiErrorBody {
 
 /** WebSocket terminal protocol frames (host -> client and client -> host). */
 export type TerminalServerFrame =
-  | { type: 'ready'; alias: string }
+  /** The shell is up; `sessionId` reattaches to it after a view detach. */
+  | { type: 'ready'; alias: string; sessionId: string }
   | { type: 'output'; data: string }
   | { type: 'exit'; code: number | null; error?: string }
   | {
@@ -202,6 +203,10 @@ export type TerminalClientFrame =
   | { type: 'input'; data: string }
   | { type: 'resize'; cols: number; rows: number }
   | { type: 'auth_response'; responses: string[] }
+  /** Leave the socket while the host keeps the shell alive for a reattach. */
+  | { type: 'detach' }
+  /** End the session outright (the view's disconnect control). */
+  | { type: 'close' }
 
 /** Route paths the client calls (shared literals). */
 export const SSH_API_BASE = '/api/dsh-ssh' as const

package/src/routes.ts

@@ -15,10 +15,11 @@ import { tmpdir } from 'node:os'
 import { randomBytes } from 'node:crypto'
 import { WebSocket, WebSocketServer } from 'ws'
 import type { WebRoute, WebUpgradeRoute } from '@deepseek-ai/dsh-host-webserver'
-import type { SshEngine, ShellSession, KeyboardInteractiveHandler } from './engine.ts'
+import type { SshEngine } from './engine.ts'
+import { TerminalSessionRegistry } from './engine/terminal-sessions.ts'
 import { readJsonBody, writeJson } from './http.ts'
 import { isLoopbackRequest } from './loopback.ts'
-import { SSH_API, type HostPayload, type TerminalClientFrame, type TerminalServerFrame } from './protocol.ts'
+import { SSH_API, type HostPayload, type TerminalServerFrame } from './protocol.ts'
 import type { HostStore } from './store.ts'
 
 /** Cap on declared upload bodies (staged to disk before SFTP). */
@@ -31,12 +32,6 @@ const MAX_UPLOAD_BYTES = 4 * 1024 * 1024 * 1024
  */
 const terminalWss = new WebSocketServer({ noServer: true })
 
-/** Pause the shell when the socket's send buffer exceeds this… */
-const BACKPRESSURE_HIGH_WATER = 1024 * 1024
-
-/** …and resume once it drains below this. */
-const BACKPRESSURE_LOW_WATER = 512 * 1024
-
 /** URL query helper (first value, decoded). */
 function queryParam(url: URL, name: string): string | undefined {
   const value = url.searchParams.get(name)
@@ -60,7 +55,7 @@ maxUploadBytes?: number
  * @param deps - store, engine, staging dir.
  * @returns routes and the upgrade route.
  */
-export function makeRoutes(deps: SshRoutesDeps): { routes: WebRoute[]; upgrade: WebUpgradeRoute } {
+export function makeRoutes(deps: SshRoutesDeps): { routes: WebRoute[]; upgrade: WebUpgradeRoute; terminalSessions: TerminalSessionRegistry } {
   const { store, engine } = deps
   const staging = deps.stagingDir ?? join(tmpdir(), 'dsh-ssh-uploads')
 const maxUploadBytes = deps.maxUploadBytes ?? MAX_UPLOAD_BYTES
@@ -452,6 +447,12 @@ const maxUploadBytes = deps.maxUploadBytes ?? MAX_UPLOAD_BYTES
   ]
 
   // ---------------------------------------------- terminal (upgrade)
+  // The shell outlives the view that opened it: a session is created once and
+  // any later socket attaches by id, so a panel switch or a dropped socket
+  // does not tear the remote shell down (engine/terminal-sessions.ts).
+  const terminalSessions = new TerminalSessionRegistry({
+    openShell: (alias, size, onKeyboardInteractive) => engine.openShell(alias, size, onKeyboardInteractive),
+  })
   const upgrade: WebUpgradeRoute = {
     path: SSH_API.terminal,
     handler: (req, socket, head) => {
@@ -462,114 +463,32 @@ const maxUploadBytes = deps.maxUploadBytes ?? MAX_UPLOAD_BYTES
       }
       const url = new URL(req.url ?? '/', 'http://localhost')
       const alias = queryParam(url, 'alias')
-      if (alias === undefined) {
+      const sessionId = queryParam(url, 'session')
+      if (alias === undefined && sessionId === undefined) {
         socket.write('HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n')
         socket.destroy()
         return
       }
       const cols = Number.parseInt(queryParam(url, 'cols') ?? '80', 10)
       const rows = Number.parseInt(queryParam(url, 'rows') ?? '24', 10)
+      const size = {
+        cols: Number.isFinite(cols) ? cols : 80,
+        rows: Number.isFinite(rows) ? rows : 24,
+      }
       terminalWss.handleUpgrade(req, socket, head, (ws) => {
-        let session: ShellSession | undefined
-        let closed = false
-        let paused = false
-        let pendingAuthFinish: ((responses: string[]) => void) | undefined
-        // Resume the shell once the socket's send buffer drains below the
-        // low-water mark (transport backpressure).
-        const resume = (): void => {
-          if (paused && ws.bufferedAmount < BACKPRESSURE_LOW_WATER) {
-            paused = false
-            session?.resume()
-          }
-        }
-        const sendFrame = (frame: TerminalServerFrame): void => {
-          if (closed || ws.readyState !== WebSocket.OPEN) return
-          ws.send(JSON.stringify(frame), resume)
-          if (!paused && ws.bufferedAmount > BACKPRESSURE_HIGH_WATER) {
-            paused = true
-            session?.pause()
-          }
-        }
-        const closeSession = (): void => {
-          if (pendingAuthFinish !== undefined) {
-            const fn = pendingAuthFinish
-            pendingAuthFinish = undefined
-            try { fn([]) } catch { /* ignore */ }
-          }
-          const opened = session
-          session = undefined
-          if (opened !== undefined) opened.close()
-        }
-
-        const onKeyboardInteractive: KeyboardInteractiveHandler = (name, instructions, _lang, prompts, finish) => {
-          const entry = store.find(alias)
-          // Auto-answer password if configured and prompt is a password request
-          if (entry?.auth.kind === 'password' && entry.auth.password !== undefined && prompts.length > 0 && prompts.every(p => /password/i.test(p.prompt))) {
-            const password = entry.auth.password
-            finish(prompts.map(() => password))
-            return
-          }
-          // Interactive 2FA prompt sent to the client terminal
-          pendingAuthFinish = finish
-          sendFrame({
-            type: 'auth_prompt',
-            name,
-            instructions,
-            prompts: prompts.map(p => ({ prompt: p.prompt, echo: p.echo })),
-          })
-        }
-
-        engine.openShell(alias, {
-          cols: Number.isFinite(cols) ? cols : 80,
-          rows: Number.isFinite(rows) ? rows : 24,
-        }, onKeyboardInteractive).then((opened) => {
-          if (ws.readyState !== WebSocket.OPEN) {
-            opened.close()
-            return
-          }
-          session = opened
-          sendFrame({ type: 'ready', alias })
-          opened.onData = (data) => sendFrame({ type: 'output', data: data.toString('utf8') })
-          opened.onExit = (code, error) => {
-            sendFrame({ type: 'exit', code, error })
-            closed = true
-            try { ws.close(1000) } catch { /* already closed */ }
-          }
-        }).catch((error) => {
-          sendFrame({ type: 'exit', code: null, error: error instanceof Error ? error.message : String(error) })
-          closed = true
+        if (sessionId !== undefined) {
+          if (terminalSessions.attach(ws, sessionId, size)) return
+          // The session was reaped or the host restarted: tell the view so it
+          // can fall back to a fresh connect instead of sitting blank.
+          const expired: TerminalServerFrame = { type: 'exit', code: null, error: 'terminal session expired' }
+          try { ws.send(JSON.stringify(expired)) } catch { /* socket raced away */ }
           try { ws.close(1000) } catch { /* already closed */ }
-        })
-        ws.on('message', (data) => {
-          let frame: TerminalClientFrame
-          try {
-            frame = JSON.parse(String(data)) as TerminalClientFrame
-          } catch {
-            return
-          }
-          if (frame.type === 'input') {
-            session?.send(frame.data)
-          } else if (frame.type === 'resize') {
-            session?.resize(Math.max(2, frame.cols), Math.max(1, frame.rows))
-          } else if (frame.type === 'auth_response') {
-            if (pendingAuthFinish !== undefined) {
-              const fn = pendingAuthFinish
-              pendingAuthFinish = undefined
-              fn(frame.responses)
-            }
-          }
-        })
-        ws.on('close', () => {
-          closed = true
-          closeSession()
-        })
-        ws.on('error', () => {
-          closed = true
-          closeSession()
-        })
+          return
+        }
+        void terminalSessions.open(ws, alias as string, size)
       })
     },
   }
 
-  return { routes, upgrade }
+  return { routes, upgrade, terminalSessions }
 }

package/lib/types/client/body-mutations.d.ts

@@ -1,45 +0,0 @@
-/**
- * One `document.body` MutationObserver per page, shared by every family
- * plugin bundle.
- *
- * Family plugins that inject at the DOM level must notice when the shell
- * re-renders around their injected node: the sidebar entry rows
- * (sidebar-entry-core), the center-column panel containers
- * (panel-mount-core), and the aggregate shell's column shims. Each consumer
- * used to install its OWN `MutationObserver` on `document.body` with
- * `{ childList: true, subtree: true }`, so a page carrying N family plugins
- * paid N native observers and N callback invocations for EVERY mutation batch
- * the app produced — chat token streaming alone produces many per second, and
- * the count grows with the number of installed plugins.
- *
- * This module keeps exactly ONE body observer per page. The registry lives on
- * `globalThis` under a `Symbol.for` key, so the per-package generated copies
- * of this file (scripts/sync-shared.mjs) and separately bundled plugins all
- * reach the same hub at runtime instead of one hub per module instance.
- * Record subscribers receive the mutations accumulated since the last flush.
- * Consumers that only re-check their DOM use subscribeBodyInvalidations:
- * when all subscribers use that path, the hub retains no mutation records
- * (or detached subtrees) while a background page's animation frames pause.
- * Both paths run at most once per frame. The last subscriber disconnects the
- * observer, cancels the pending frame and releases its records.
- *
- * Failure policy: without a DOM or `MutationObserver` the subscription is a
- * no-op disposer (the same silence the per-consumer observers had), and when
- * `requestAnimationFrame` is unavailable the flush runs synchronously so a
- * subscriber is never silently dropped. A throwing subscriber cannot stop the
- * others.
- */
-/**
- * Subscribe to a coalesced DOM re-check without retaining mutation records.
- * The marked wrapper also works with an older hub, which delivers records
- * that it simply ignores until a page reload picks up the updated hub.
- */
-export declare function subscribeBodyInvalidations(subscriber: () => void): () => void;
-/**
- * Subscribe to body-level childList mutations.
- * @param subscriber - called at most once per animation frame with the records
- *   collected since the previous flush; must be safe to run repeatedly.
- * @returns the disposer removing this subscriber (and the observer when it was
- *   the last one).
- */
-export declare function subscribeBodyMutations(subscriber: (records: MutationRecord[]) => void): () => void;

package/lib/types/client/mount.d.ts

@@ -1,27 +0,0 @@
-/**
- * Panel view mounting (dsh-ssh wrapper).
- *
- * The single-occupant takeover lifecycle — container injection into the
- * center column, sibling eviction, remount resilience, sidebar click-out —
- * lives exactly once in shared/client/panel-mount-core.ts (synced copy); this
- * wrapper supplies the SSH panel tree, view dataset key, CSS module, and the
- * html attribute names. Those names are pinned by panel.module.css, skins,
- * and the semantic attributes contract.
- */
-import type { SshApi } from './api.ts';
-import type { PanelController } from './panel/controller.ts';
-import type { TerminalFontSource } from './panel/helpers.ts';
-import type { LocaleRefreshSource } from './sidebar-entry.ts';
-/** The injected panel container (kept in the DOM, hidden when inactive). */
-export declare const PANEL_VIEW_SELECTOR = "[data-dsh-ssh-view]";
-/**
- * Mount the panel React tree into the center column and bind its visibility
- * to the controller's panelOpen state.
- * @param controller - the panel controller driving the view.
- * @param api - the SSH API client the tabs operate through.
- * @param terminalFont - live terminal-font setting source (issue #577).
- * @param locale - locale-change source; when given, re-renders an open panel
- *   on a Language switch.
- * @returns disposer unmounting the tree and restoring the column.
- */
-export declare function mountPanel(controller: PanelController, api: SshApi, terminalFont?: TerminalFontSource, locale?: LocaleRefreshSource): () => void;

package/lib/types/client/panel-mount-core.d.ts

@@ -1,56 +0,0 @@
-/**
- * Center-column panel takeover lifecycle.
- *
- * The `conversation` slot is single-occupant (ui-conversation) and external
- * plugins cannot declare slots, so a family panel takes over the center
- * column at the DOM level: a container is appended inside the center column
- * (`[class*="centerCol"]`, the 0.1.0-rc.6+ AppFrame layout; previously
- * `[data-pane="conversation"]` on older shells — the mount selector keeps
- * both, ssh #243 / task-board #107) as an extra trailing child React never
- * manages, and a stylesheet rule hides the conversation content while the
- * panel is active. Toggling is a data attribute on <html> — no React
- * involvement, so the conversation subtree underneath stays mounted and
- * stateful.
- *
- * Consuming plugins keep a thin wrapper that supplies the panel tree,
- * container attribute names, and stylesheet class; those names are pinned by
- * each package's CSS, skins, and the semantic-attributes contract. The
- * sidebar row toggling the panel shares its core the same way
- * (shared/client/sidebar-entry-core.ts, synced copy).
- */
-import { type Root } from 'react-dom/client';
-/** Options for mountCenterPanel; dsh-ssh mount.tsx and dsh-task-board board-mount.tsx are the canonical consumers. */
-export interface CenterPanelMountOptions {
-    /** Render the panel tree (first open, remount while open, locale refresh). */
-    render: (root: Root) => void;
-    /** dataset key of the injected container's view attribute, e.g. `dshSshView` for `data-dsh-ssh-view`. */
-    viewDatasetKey: string;
-    /** value of the container's L2 `data-dsh-plugin` semantic attribute. */
-    pluginName: string;
-    /** stylesheet class applied to the injected container. */
-    viewClassName: string;
-    /** <html> attribute set while this panel is active. */
-    activeAttribute: string;
-    /** the sibling panel's active attribute, removed from <html> when this panel opens. */
-    siblingActiveAttribute: string;
-    /** detail value this panel broadcasts on the cross-plugin activation event. */
-    panelName: string;
-    /** sibling detail value whose activation closes this panel. */
-    siblingPanelName: string;
-    /** open flag of the owning controller. */
-    isOpen: () => boolean;
-    /** close the panel, handing the center column back to the conversation. */
-    close: () => void;
-    /** subscribe to the owning controller's open-state changes; returns an unsubscriber. */
-    subscribe: (listener: () => void) => () => void;
-    /** locale-change source; when given, re-renders an open panel on a Language switch. */
-    locale?: {
-        subscribe(listener: () => void): () => void;
-    };
-}
-/**
- * Mount a family panel into the center column and bind its visibility to the
- * owning controller's open state.
- * @returns disposer unmounting the tree and restoring the column.
- */
-export declare function mountCenterPanel(options: CenterPanelMountOptions): () => void;

package/lib/types/client/sidebar-entry-core.d.ts

@@ -1,55 +0,0 @@
-/** Per-package configuration for one sidebar entry row. */
-export interface SidebarEntryOptions {
-    /** Full attribute name identifying the injected row (idempotency key), e.g. 'data-dsh-ssh-entry'. */
-    rowAttribute: string;
-    /** CSS selector matching the injected row, e.g. '[data-dsh-ssh-entry]'. */
-    rowSelector: string;
-    /**
-     * L2 semantic-attribute plugin id (issue #506, enum table:
-     * skins/skin-center/contracts/semantic-attrs-v1.md). When set, the row also
-     * outputs data-dsh-plugin="<id>" and data-dsh-part="sidebar-entry"; unset
-     * leaves the row without semantic attributes.
-     */
-    plugin?: string;
-    /** Inline icon markup (matches the shell's 16px nav-icon look). */
-    icon: string;
-    /** CSS module class names for the row and its two spans (entry / entryIcon / entryLabel). */
-    css: Record<string, string>;
-    /** Localized row label (aria-label + visible text). */
-    label(): string;
-    /** Optional localized tooltip (title attribute). */
-    tooltip?(): string;
-    /**
-     * Optional locale-change subscription: re-applies label / aria-label /
-     * tooltip whenever the active locale changes. Plain-DOM rows would
-     * otherwise keep the label captured at mount; pass the SDK locale runtime
-     * subscription (ctx.locale.subscribe) so the row follows the language
-     * switch without a reload.
-     */
-    refresh?: {
-        subscribe(listener: () => void): () => void;
-    };
-    /** Click action (open/toggle the owning panel). */
-    onToggle(): void;
-    /** Family-block position: 'before' inserts ahead of sibling plugin rows, 'after' behind them. */
-    position: 'before' | 'after';
-    /**
-     * Selectors of the sibling plugin entry rows this package orders against
-     * (its own row included — the placement guard excludes a row that is
-     * already inside the root). Each package passes the same list it used
-     * before the consolidation so the rendered order stays stable.
-     */
-    familySelectors: readonly string[];
-    /** Optional active-state bridge; highlights the row while the panel is open. */
-    active?: {
-        subscribe(listener: () => void): () => void;
-        isOpen(): boolean;
-    };
-}
-/**
- * Mount the sidebar entry, waiting for the shell to render and self-healing
- * on later React re-renders.
- * @param options - the row's attribute/icon/copy/action/ordering configuration.
- * @returns disposer removing the entry and its observers.
- */
-export declare function mountSidebarEntry(options: SidebarEntryOptions): () => void;

package/lib/types/client/sidebar-entry.d.ts

@@ -1,26 +0,0 @@
-/**
- * Sidebar entry injection — package-specific wiring over the shared core.
- *
- * The DOM injection / self-healing / idempotency logic lives exactly once in
- * shared/client/sidebar-entry-core.ts (synced copy); this wrapper supplies the
- * ssh icon, copy, CSS module, and the panel toggle. The row is plain DOM (no
- * React tree) so it can never disturb the shell's reconciliation; the panel
- * view it toggles is a separate React root mounted in the center column
- * (see mount.tsx).
- */
-import type { PanelController } from './panel/controller.ts';
-/** Stable data attribute identifying the injected entry row. */
-export declare const ENTRY_SELECTOR = "[data-dsh-ssh-entry]";
-/** Locale-change subscription the shared core asks for (ctx.locale.subscribe shape). */
-export interface LocaleRefreshSource {
-    subscribe(listener: () => void): () => void;
-}
-/**
- * Mount the sidebar entry, waiting for the shell to render and self-healing
- * on later React re-renders.
- * @param controller - the panel controller the entry toggles.
- * @param locale - locale-change source; when given, re-applies the label on
- *   a Language switch (the plain-DOM row otherwise keeps the mount-time copy).
- * @returns disposer removing the entry and its observers.
- */
-export declare function mountSidebarEntry(controller: PanelController, locale?: LocaleRefreshSource): () => void;