@tiphareth/dsh-hardssh 0.1.2-alpha → 0.2.2

package/src/client/manager-button.tsx

@@ -1,269 +0,0 @@
-/**
- * The SSH workspace manager: a session-header button opening a dropdown that
- * lists SSH-bound workspaces grouped by server (two-level: server → its
- * workspaces) and lets the operator:
- * - delete a workspace (existing),
- * - edit / delete a SERVER (gear / minus on each server row; deleting a
- *   server is allowed only when it backs no workspace — the API also enforces
- *   this with a 409 HOST_IN_USE),
- * - create a new server (bottom action), reusing the host form dialog.
- * Rendering is a portal dropdown with its own React root (the shell exposes
- * no modal slot for external plugins).
- */
-import { createRoot } from 'react-dom/client'
-import { useEffect, useRef, useState, type ReactElement } from 'react'
-import { createPortal } from 'react-dom'
-import type { WorkspaceManager } from './state.ts'
-import type { SshWorkspaceRecord } from '../protocol.ts'
-import { tt } from './text.ts'
-import css from './workspace.module.css'
-import { CloudIcon, ComputerIcon } from './icons.tsx'
-import type { SshHostSummary } from '../ssh/protocol.ts'
-import { HostFormDialog } from './ssh/panel/HostFormDialog.tsx'
-import type { SshApi } from './ssh/api.ts'
-
-/** The session-header button. Slot-injected props: manager + sshApi. */
-export function WorkspaceManagerButton(props: {
-  manager: WorkspaceManager
-  /** Full SSH host API (list/create/update/delete) for server management. */
-  sshApi?: SshApi
-  sessionId?: unknown
-  useSession?: unknown
-  useSessions?: unknown
-  useWorkspaces?: unknown
-  useProjection?: unknown
-  useInput?: unknown
-  inputActions?: unknown
-  renderSlot?: unknown
-  renderSlotChain?: unknown
-  t?: unknown
-}): ReactElement {
-  return (
-    <button
-      type="button"
-      className={css.managerButton}
-      data-ssh-workspace-manager=""
-      title={tt('manager.tooltip')}
-      onClick={(event) => openManager(props.manager, props.sshApi, event.currentTarget)}
-    >
-      <svg viewBox="0 0 16 16" width="12" height="12" fill="none" stroke="currentColor" strokeWidth="1.4" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">
-        <rect x="2" y="3" width="12" height="10" rx="2" />
-        <path d="M6 6.5l2.2 1.6L6 9.7" />
-        <path d="M9.5 9.5h2" />
-      </svg>
-      <span>{tt('manager.label')}</span>
-    </button>
-  )
-}
-
-/** Open the manager dropdown, anchored under the trigger button. */
-export function openManager(manager: WorkspaceManager, sshApi?: SshApi, trigger?: HTMLElement): void {
-  const element = document.createElement('div')
-  element.dataset.sshWorkspaceManagerOverlay = ''
-  document.body.appendChild(element)
-  const root = createRoot(element)
-  const close = (): void => {
-    root.unmount()
-    element.remove()
-  }
-  let anchor: { bottom: number; left: number } | undefined
-  if (trigger !== undefined) {
-    const rect = trigger.getBoundingClientRect()
-    anchor = { bottom: rect.bottom, left: rect.left }
-  }
-  root.render(<ManagerOverlay manager={manager} sshApi={sshApi} onClose={close} anchor={anchor} />)
-}
-
-/** Group workspaces by server alias for the two-level listing. */
-function groupByServer(workspaces: SshWorkspaceRecord[]): Array<{ alias: string; workspaces: SshWorkspaceRecord[] }> {
-  const map = new Map<string, SshWorkspaceRecord[]>()
-  for (const workspace of workspaces) {
-    const list = map.get(workspace.alias)
-    if (list === undefined) map.set(workspace.alias, [workspace])
-    else list.push(workspace)
-  }
-  return [...map.entries()].map(([alias, workspaces]) => ({ alias, workspaces }))
-}
-
-/** The host-form dialog invocation state. */
-type HostDialogState = { mode: 'create' } | { mode: 'edit'; host: SshHostSummary }
-
-/** The manager dropdown: server + workspace rows, with server CRUD. */
-export function ManagerOverlay(props: {
-  manager: WorkspaceManager
-  sshApi?: SshApi
-  onClose: () => void
-  anchor?: { bottom: number; left: number }
-}): ReactElement {
-  const [workspaces, setWorkspaces] = useState<SshWorkspaceRecord[] | null>(null)
-  const [hosts, setHosts] = useState<SshHostSummary[] | null>(null)
-  const [error, setError] = useState<string | null>(null)
-  const [deleting, setDeleting] = useState<string | null>(null)
-  const [deletingAlias, setDeletingAlias] = useState<string | null>(null)
-  const [hostDialog, setHostDialog] = useState<HostDialogState | null>(null)
-  const menuRef = useRef<HTMLDivElement | null>(null)
-
-  // Close when a click lands OUTSIDE the dropdown.
-  useEffect(() => {
-    const onMouseDown = (event: MouseEvent): void => {
-      if (menuRef.current !== null && menuRef.current.contains(event.target as Node)) return
-      props.onClose()
-    }
-    document.addEventListener('mousedown', onMouseDown)
-    return () => document.removeEventListener('mousedown', onMouseDown)
-  }, [props])
-
-  const load = (): void => {
-    setWorkspaces(props.manager.getSnapshot().workspaces)
-  }
-
-  const loadHosts = (): void => {
-    if (props.sshApi === undefined) return
-    void props.sshApi.listHosts().then(
-      (list) => { setHosts(list) },
-      (cause: unknown) => {
-        setError(cause instanceof Error ? cause.message : String(cause))
-        setHosts([])
-      },
-    )
-  }
-
-  useEffect(() => {
-    load()
-    void props.manager.refresh()
-    const unsubscribe = props.manager.subscribe(() => { load() })
-    loadHosts()
-    return () => { unsubscribe() }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [])
-
-  const remove = (id: string): void => {
-    setDeleting(id)
-    void props.manager.remove(id)
-      .catch((e: unknown) => setError(e instanceof Error ? e.message : String(e)))
-      .finally(() => setDeleting(null))
-  }
-
-  const deleteHost = (alias: string): void => {
-    if (props.sshApi === undefined) return
-    setDeletingAlias(alias)
-    void props.sshApi.deleteHost(alias)
-      .then(() => { loadHosts() })
-      .catch((e: unknown) => setError(e instanceof Error ? e.message : String(e)))
-      .finally(() => setDeletingAlias(null))
-  }
-
-  const savedHost = (): void => {
-    setHostDialog(null)
-    loadHosts()
-    void props.manager.refresh()
-  }
-
-  const anchorTop = props.anchor !== undefined ? props.anchor.bottom + 4 : 56
-  const anchorLeft = props.anchor !== undefined ? props.anchor.left : Math.max(8, window.innerWidth - 380)
-  const top = Math.max(8, Math.min(anchorTop, window.innerHeight - 340))
-  const left = Math.max(8, Math.min(anchorLeft, window.innerWidth - 380))
-
-
-  return createPortal(
-    <div
-      ref={menuRef}
-      className={css.menuDropdown}
-      data-ssh-workspace-manager-menu=""
-      style={{ top, left, width: 380 }}
-      onClick={(event) => event.stopPropagation()}
-    >
-      <p className={css.managerMenuHeader}>
-        {tt('manager.title')}
-        <button type="button" className={css.managerMenuClose} onClick={props.onClose} aria-label={tt('create.cancel')}>&times;</button>
-      </p>
-
-      {error !== null && <div className={css.dialogFail}>{error}</div>}
-
-      {workspaces === null && hosts === null && <div className={css.dialogInfo}>{tt('panel.loading')}</div>}
-
-      {workspaces !== null && workspaces.length === 0 && (
-        <div className={css.dialogHint}>{tt('manager.empty')}</div>
-      )}
-
-      {/* Server rows (edit + delete) with their workspaces underneath */}
-      {hosts !== null && hosts.map((host) => {
-        const hostWorkspaces = workspaces === null ? [] : workspaces.filter(w => w.alias === host.alias)
-        const inUse = hostWorkspaces.length > 0
-        return (
-          <div key={host.alias} style={{ marginBottom: 10 }}>
-            <div className={css.managerGroupHeader} style={{ display: 'flex', alignItems: 'center', gap: 6, padding: '4px 8px' }}>
-              <ComputerIcon size={13} />
-              <span style={{ fontWeight: 500, fontSize: 13, flex: 1, minWidth: 0, overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' }}>
-                {host.alias}
-              </span>
-              <span className={css.hostMeta} style={{ fontSize: 11 }}>{host.user}@{host.host}:{host.port}</span>
-              {/* Gear: edit server */}
-              <button
-                type="button"
-                className={css.menuItemIconButton}
-                title={tt('manager.editServer')}
-                aria-label={tt('manager.editServer')}
-                onClick={() => { setHostDialog({ mode: 'edit', host }) }}
-              >
-                ⚙
-              </button>
-              {/* Minus: delete server (disabled while it backs workspaces) */}
-              <button
-                type="button"
-                className={css.menuItemIconButton}
-                title={inUse ? tt('manager.hostInUse', hostWorkspaces.length) : tt('manager.deleteServer')}
-                aria-label={tt('manager.deleteServer')}
-                disabled={inUse || deletingAlias === host.alias}
-                onClick={() => { if (!inUse) deleteHost(host.alias) }}
-              >
-                −
-              </button>
-            </div>
-            {hostWorkspaces.map((workspace) => (
-              <div key={workspace.id} className={css.hostRow} style={{ display: 'flex', alignItems: 'center', gap: 6, padding: '3px 8px' }}>
-                <CloudIcon size={12} />
-                <span className={css.hostAlias} style={{ fontSize: 12.5, overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap', flex: 1, minWidth: 0 }}>
-                  {workspace.title}
-                </span>
-                <span className={css.hostMeta} style={{ fontSize: 11, overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap', maxWidth: 150 }}>
-                  {workspace.remoteRoot}
-                </span>
-                <button
-                  type="button"
-                  className={`${css.button} ${css.danger}`}
-                  style={{ flex: 'none', padding: '2px 8px', fontSize: 12 }}
-                  disabled={deleting === workspace.id}
-                  onClick={() => { if (!deleting) remove(workspace.id) }}
-                >
-                  {deleting === workspace.id ? '…' : tt('manager.delete')}
-                </button>
-              </div>
-            ))}
-          </div>
-        )
-      })}
-
-      {/* Bottom: create a new server */}
-      {props.sshApi !== undefined && (
-        <div style={{ marginTop: 4, borderTop: `1px solid var(--dsw-alias-border-l2, rgba(0,0,0,0.1))`, paddingTop: 6 }}>
-          <button type="button" className={css.menuItem} onClick={() => { setHostDialog({ mode: 'create' }) }}>
-            <span className={css.menuItemIcon}>＋</span>
-            <span>{tt('manager.newHost')}</span>
-          </button>
-        </div>
-      )}
-
-      {hostDialog !== null && props.sshApi !== undefined && (
-        <HostFormDialog
-          api={props.sshApi}
-          editing={hostDialog.mode === 'edit' ? hostDialog.host : null}
-          onClose={() => { setHostDialog(null) }}
-          onSaved={savedHost}
-        />
-      )}
-    </div>,
-    document.body,
-  )
-}
-

package/src/client/ssh/mount.tsx

@@ -1,83 +0,0 @@
-/**
- * Panel view mounting.
- *
- * The `conversation` slot is single-occupant (ui-conversation) and external
- * plugins cannot declare slots, so the panel takes over the center column at
- * the DOM level: a container is appended inside the `[data-pane="conversation"]`
- * grid item (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.
- */
-import { createRoot, type Root } from 'react-dom/client'
-import type { SshApi } from './api.ts'
-import type { PanelController } from './panel/controller.ts'
-import { SshPanel } from './panel/SshPanel.tsx'
-import css from './panel/panel.module.css'
-
-/** The injected panel container (kept in the DOM, hidden when inactive). */
-export const PANEL_VIEW_SELECTOR = '[data-dsh-ssh-view]'
-
-const CONVERSATION_COLUMN_SELECTOR = '[data-pane="conversation"]'
-const ACTIVE_ATTR = 'data-dsh-ssh-active'
-
-/** Find the center column, or undefined while the frame is not mounted. */
-function conversationColumn(): HTMLElement | undefined {
-  return document.querySelector<HTMLElement>(CONVERSATION_COLUMN_SELECTOR) ?? undefined
-}
-
-/**
- * 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.
- * @returns disposer unmounting the tree and restoring the column.
- */
-export function mountPanel(controller: PanelController, api: SshApi): () => void {
-  let root: Root | undefined
-  let container: HTMLDivElement | undefined
-
-  const ensure = (): void => {
-    if (container !== undefined) {
-      if (container.isConnected) return
-      // The conversation pane was replaced; drop the stale tree and remount.
-      root?.unmount()
-      root = undefined
-      container.remove()
-      container = undefined
-    }
-    const column = conversationColumn()
-    if (column === undefined) return
-    container = document.createElement('div')
-    container.dataset.dshSshView = ''
-    container.className = css.view
-    column.appendChild(container)
-    root = createRoot(container)
-    root.render(<SshPanel controller={controller} api={api} />)
-  }
-
-  // The frame mounts after boot settlement; watch for the column's arrival.
-  const waitObserver = new MutationObserver(() => { ensure() })
-  waitObserver.observe(document.body, { childList: true, subtree: true })
-
-  const applyActive = (): void => {
-    if (controller.getSnapshot().panelOpen) {
-      document.documentElement.setAttribute(ACTIVE_ATTR, '')
-    } else {
-      document.documentElement.removeAttribute(ACTIVE_ATTR)
-    }
-  }
-  const unsubscribe = controller.subscribe(applyActive)
-  applyActive()
-  ensure()
-
-  return () => {
-    waitObserver.disconnect()
-    unsubscribe()
-    document.documentElement.removeAttribute(ACTIVE_ATTR)
-    root?.unmount()
-    root = undefined
-    container?.remove()
-    container = undefined
-  }
-}

package/src/client/ssh/panel/HostsTab.tsx

@@ -1,236 +0,0 @@
-/**
- * Hosts tab: the host table with search (debounced through listHosts),
- * add/edit/delete/test actions, ~/.ssh/config import, and a connect action
- * that hands the alias to the terminal tab via onConnect.
- */
-import { useCallback, useEffect, useRef, useState } from 'react'
-import type { SshApi } from '../api.ts'
-import type { SshHostSummary, TestResult } from '../../../ssh/protocol.ts'
-import { errorMessage, tt } from './helpers.ts'
-import { HostFormDialog } from './HostFormDialog.tsx'
-import { HostFingerprintDialog } from './HostFingerprintDialog.tsx'
-import { SessionSecretDialog } from './SessionSecretDialog.tsx'
-import { SshApiError } from '../api.ts'
-import css from './panel.module.css'
-
-/** Hosts tab props. */
-export interface HostsTabProps {
-  api: SshApi
-  /** Connect the given alias in the terminal tab. */
-  onConnect: (alias: string) => void
-}
-
-/** The host-form dialog invocation. */
-type DialogState = { mode: 'create' } | { mode: 'edit'; host: SshHostSummary }
-
-/** A pending host-key confirmation. */
-interface HostKeyConfirmState {
-  alias: string
-  fingerprintSha256: string
-  mismatch: boolean
-}
-
-/** A pending session-secret prompt (VSCode Remote-SSH style). */
-interface SessionSecretState {
-  alias: string
-  secret: 'password' | 'passphrase'
-  user?: string
-}
-
-/** The hosts table plus its toolbar and dialogs. */
-export function HostsTab({ api, onConnect }: HostsTabProps) {
-  const [hosts, setHosts] = useState<SshHostSummary[] | null>(null)
-  const [error, setError] = useState<string | null>(null)
-  const [search, setSearch] = useState('')
-  const [testingAlias, setTestingAlias] = useState<string | null>(null)
-  const [testResults, setTestResults] = useState<Record<string, TestResult>>({})
-  const [importing, setImporting] = useState(false)
-  const [notice, setNotice] = useState<string | null>(null)
-  const [dialog, setDialog] = useState<DialogState | null>(null)
-  const [hostKeyConfirm, setHostKeyConfirm] = useState<HostKeyConfirmState | null>(null)
-  const [secretConfirm, setSecretConfirm] = useState<SessionSecretState | null>(null)
-  const seqRef = useRef(0)
-
-  const load = useCallback(async (query?: string): Promise<void> => {
-    const seq = ++seqRef.current
-    try {
-      const list = await api.listHosts(query)
-      if (seq !== seqRef.current) return
-      setHosts(list)
-      setError(null)
-    } catch (cause) {
-      if (seq !== seqRef.current) return
-      setError(errorMessage(cause))
-    }
-  }, [api])
-
-  useEffect(() => { void load() }, [load])
-
-  // Debounced search: every keystroke re-filters through the API.
-  useEffect(() => {
-    const timer = setTimeout(() => {
-      const query = search.trim()
-      void load(query === '' ? undefined : query)
-    }, 300)
-    return () => { clearTimeout(timer) }
-  }, [search, load])
-
-  const runTest = async (alias: string): Promise<void> => {
-    setTestingAlias(alias)
-    try {
-      const result = await api.testHost(alias)
-      if (result.code === 'NEEDS_PASSWORD' && (result.secret === 'password' || result.secret === 'passphrase')) {
-        // VSCode Remote-SSH style: prompt once per session, then retry.
-        setSecretConfirm({
-          alias,
-          secret: result.secret,
-          user: hosts?.find(host => host.alias === alias)?.user,
-        })
-        setTestingAlias(null)
-        return
-      }
-      setTestResults(prev => ({ ...prev, [alias]: result }))
-    } catch (cause) {
-      if (cause instanceof SshApiError && (cause.code === 'HOST_KEY_UNKNOWN' || cause.code === 'HOST_KEY_MISMATCH')) {
-        setHostKeyConfirm({
-          alias,
-          fingerprintSha256: cause.hostKeyFingerprint ?? '',
-          mismatch: cause.code === 'HOST_KEY_MISMATCH',
-        })
-        setTestingAlias(null)
-        return
-      }
-      setTestResults(prev => ({ ...prev, [alias]: { ok: false, error: errorMessage(cause) } }))
-    } finally {
-      setTestingAlias(null)
-    }
-  }
-
-  /** After the fingerprint is confirmed (or reset), retry the test. */
-  const retryAfterFingerprint = async (alias: string): Promise<void> => {
-    setHostKeyConfirm(null)
-    await runTest(alias)
-  }
-
-  /** After the session secret is provided, retry the test. */
-  const retryAfterSecret = async (alias: string): Promise<void> => {
-    setSecretConfirm(null)
-    await runTest(alias)
-  }
-
-  const deleteHost = async (alias: string): Promise<void> => {
-    if (!window.confirm(tt('hosts.deleteConfirm', { alias }))) return
-    try {
-      await api.deleteHost(alias)
-      void load()
-    } catch (cause) {
-      setError(errorMessage(cause))
-    }
-  }
-
-  const importConfig = async (): Promise<void> => {
-    setImporting(true)
-    try {
-      const result = await api.importSshConfig()
-      setNotice(tt('hosts.imported', { parsed: result.parsed, added: result.added, skipped: result.skipped }))
-      void load()
-    } catch (cause) {
-      setError(errorMessage(cause))
-    } finally {
-      setImporting(false)
-    }
-  }
-
-  return (
-    <div className={css.fillBody}>
-      <div className={css.toolbar}>
-        <input className={css.search} type="search" placeholder={tt('hosts.search')} value={search} onChange={event => { setSearch(event.target.value) }} />
-        <div className={css.toolbarSpacer} />
-        <button type="button" className={css.primaryButton} onClick={() => { setDialog({ mode: 'create' }) }}>{tt('hosts.add')}</button>
-        <button type="button" className={css.ghostButton} disabled={importing} onClick={() => { void importConfig() }}>{importing ? tt('common.loading') : tt('hosts.import')}</button>
-      </div>
-      {notice !== null && <div className={css.banner} data-kind="ok">{notice}</div>}
-      {error !== null && <div className={css.banner} data-kind="error">{tt('common.error', { error })}</div>}
-      {hosts === null && error === null && <div className={css.loading}>{tt('common.loading')}</div>}
-      {hosts !== null && hosts.length === 0 && <div className={css.empty}>{tt('hosts.empty')}</div>}
-      {hosts !== null && hosts.length > 0 && (
-        <div className={css.tableWrap}>
-          <table className={css.table}>
-            <thead>
-              <tr>
-                <th>{tt('hosts.col.alias')}</th>
-                <th>{tt('hosts.col.host')}</th>
-                <th>{tt('hosts.col.user')}</th>
-                <th>{tt('hosts.col.auth')}</th>
-                <th>{tt('hosts.col.environment')}</th>
-                <th>{tt('hosts.col.tags')}</th>
-                <th>{tt('hosts.col.description')}</th>
-                <th>{tt('hosts.col.actions')}</th>
-              </tr>
-            </thead>
-            <tbody>
-              {hosts.map(host => {
-                const test = testResults[host.alias]
-                return (
-                  <tr key={host.alias}>
-                    <td className={css.mono}>{host.alias}</td>
-                    <td className={css.mono}>{host.host}:{host.port}</td>
-                    <td>{host.user}</td>
-                    <td><span className={css.badge} data-kind={host.auth}>{host.auth === 'key' ? tt('form.auth.key') : tt('form.auth.password')}</span></td>
-                    <td className={css.cellMuted}>{host.environment ?? ''}</td>
-                    <td className={css.cellMuted}>{host.tags.join(', ')}</td>
-                    <td className={css.cellMuted}>{host.description ?? ''}</td>
-                    <td>
-                      <div className={css.actions}>
-                        <button type="button" className={css.linkButton} disabled={testingAlias === host.alias} onClick={() => { void runTest(host.alias) }}>
-                          {testingAlias === host.alias ? tt('hosts.testing') : tt('hosts.test')}
-                        </button>
-                        {testingAlias === host.alias && <span className={css.spinner} aria-hidden="true" />}
-                        {test !== undefined && (
-                          <span className={css.inlineTest} data-status={test.ok ? 'ok' : 'fail'}>
-                            {test.ok ? tt('hosts.testOk', { latency: test.latencyMs ?? 0 }) : tt('hosts.testFail', { error: test.error ?? '' })}
-                          </span>
-                        )}
-                        <button type="button" className={css.linkButton} onClick={() => { setDialog({ mode: 'edit', host }) }}>{tt('hosts.edit')}</button>
-                        <button type="button" className={css.linkButton} data-danger onClick={() => { void deleteHost(host.alias) }}>{tt('hosts.delete')}</button>
-                        <button type="button" className={css.ghostButton} onClick={() => { onConnect(host.alias) }}>{tt('hosts.connected')}</button>
-                      </div>
-                    </td>
-                  </tr>
-                )
-              })}
-            </tbody>
-          </table>
-        </div>
-      )}
-      {dialog !== null && (
-        <HostFormDialog
-          api={api}
-          editing={dialog.mode === 'edit' ? dialog.host : null}
-          onClose={() => { setDialog(null) }}
-          onSaved={() => { setDialog(null); void load() }}
-        />
-      )}
-      {hostKeyConfirm !== null && (
-        <HostFingerprintDialog
-          api={api}
-          alias={hostKeyConfirm.alias}
-          fingerprintSha256={hostKeyConfirm.fingerprintSha256}
-          mismatch={hostKeyConfirm.mismatch}
-          onClose={() => { setHostKeyConfirm(null) }}
-          onTrusted={() => { void retryAfterFingerprint(hostKeyConfirm.alias) }}
-        />
-      )}
-      {secretConfirm !== null && (
-        <SessionSecretDialog
-          api={api}
-          alias={secretConfirm.alias}
-          user={secretConfirm.user}
-          secret={secretConfirm.secret}
-          onClose={() => { setSecretConfirm(null) }}
-          onProvided={() => { void retryAfterSecret(secretConfirm.alias) }}
-        />
-      )}
-    </div>
-  )
-}

package/src/client/ssh/panel/controller.ts

@@ -1,48 +0,0 @@
-/**
- * SSH panel controller: the single owner of the panel's open/closed state.
- *
- * Framework-free (structural runtime faces, task-board core/controller.ts
- * style) so the DOM mounts and the React panel share one tiny subscription
- * surface. The state lives only for the browser session (no persistence).
- */
-
-/** Immutable controller snapshot for UI subscriptions. */
-export interface PanelControllerSnapshot {
-  panelOpen: boolean
-}
-
-/** The panel state owner the sidebar entry toggles and the view renders from. */
-export class PanelController {
-  private panelOpen = false
-  private listeners = new Set<() => void>()
-
-  getSnapshot(): PanelControllerSnapshot {
-    return { panelOpen: this.panelOpen }
-  }
-
-  subscribe(fn: () => void): () => void {
-    this.listeners.add(fn)
-    return () => { this.listeners.delete(fn) }
-  }
-
-  open(): void {
-    if (this.panelOpen) return
-    this.panelOpen = true
-    this.notify()
-  }
-
-  close(): void {
-    if (!this.panelOpen) return
-    this.panelOpen = false
-    this.notify()
-  }
-
-  toggle(): void {
-    if (this.panelOpen) this.close()
-    else this.open()
-  }
-
-  private notify(): void {
-    for (const fn of [...this.listeners]) fn()
-  }
-}