@tiphareth/dsh-hardssh 0.1.2 → 0.2.2

package/src/client/index.ts

@@ -22,12 +22,14 @@ import { SshApi } from './ssh/api.ts'
 import { NS, dictionaries, type WorkspaceKey } from './locales.ts'
 import { WorkspaceManager } from './state.ts'
 import { setLanguage } from './text.ts'
-import { WorkspaceManagerButton } from './manager-button.tsx'
+import { registerWorkspacePanel } from './workspace-panel-entry.tsx'
 import { migrateLegacySessionMemory } from './migrate.ts'
 import { DirectoryFlow } from './directory-flow.tsx'
+import { connectHost } from './connect-host.ts'
 import { mountWorkspaceBadges } from './workspace-badges.ts'
-import { connectHost, mountWorkspaceGates } from './workspace-gate.ts'
+import { makeAnchorAliasResolver, mountSessionConnectGate, type SessionGateList } from './session-connect-gate.ts'
 import { mountSshOperations } from './ssh/apply.ts'
+import { createSessionSshTargetSource } from './ssh/session-target.ts'
 
 declare module '@deepseek-ai/dsh-client-ui-slots' {
   interface LocaleNamespaceMap {
@@ -37,9 +39,7 @@ declare module '@deepseek-ai/dsh-client-ui-slots' {
 }
 
 // Type-only re-exports of the SSH operations surfaces (merge phase 2).
-export type { PanelControllerSnapshot } from './ssh/panel/controller.ts'
 export type { SshPanelProps } from './ssh/panel/SshPanel.tsx'
-export type { HostsTabProps } from './ssh/panel/HostsTab.tsx'
 export type { HostFormDialogProps } from './ssh/panel/HostFormDialog.tsx'
 export type { TerminalTabProps } from './ssh/panel/TerminalTab.tsx'
 export type { TransferTabProps } from './ssh/panel/TransferTab.tsx'
@@ -47,32 +47,47 @@ export type { TunnelsTabProps } from './ssh/panel/TunnelsTab.tsx'
 export type { ClusterTabProps } from './ssh/panel/ClusterTab.tsx'
 export type { SshKey } from './ssh/locales.ts'
 
-/** Required services: slots for the header buttons + directory-flow holes,
- *  locale for the copy, workspaces for the native local-directory chooser. */
-export const inject = ['slots', 'locale', 'workspaces']
+/** Required services: slots for the extension seats, locale for copy,
+ *  workspaces for the native local-directory chooser, sessions for the
+ *  open/new-session connection gate, and sidebarRightTabs for the SSH
+ *  operations console type. Keep the registry explicit: without it Cordis may
+ *  activate this client before ui-sidebar-right provides the service; the
+ *  guarded registration then degrades silently and no HardSSH tab exists. */
+export const inject = ['slots', 'locale', 'workspaces', 'sessions', 'sidebarRightTabs']
 
 /** Apply the browser half. */
 export function apply(ctx: ClientContext): void {
-  // SSH operations surfaces (sidebar entry + operations panel), merged from
-  // the legacy dsh-ssh client. Mounted first; its failures degrade the SSH
-  // panel only, never the GUI.
-  mountSshOperations(ctx)
-
-  ctx.effect(() => ctx.locale.register(NS, dictionaries), 'dsh-hardssh: dictionaries')
-
   const api = new WorkspaceApi()
   const hostsApi = new SshHostsApi()
   const sshApi = new SshApi()
   const manager = new WorkspaceManager(api)
+  const sessionList = ctx.sessions.list
+  const sessions: SessionGateList = {
+    subscribe: (listener) => sessionList.subscribe(listener),
+    phase: () => sessionList.getSnapshot().phase,
+    currentSessionId: () => sessionList.getSnapshot().current,
+    sessionIds: () => sessionList.getSnapshot().ids,
+    sessionCwd: (id) => {
+      const byId = sessionList.getSnapshot().byId as unknown as
+        Record<string, { cwd?: string } | undefined>
+      return byId[id]?.cwd
+    },
+  }
+
+  // The operations console inherits its ONLY target from the selected Session's
+  // workspace. A local Session resolves to null and the panel renders disabled;
+  // individual operation tabs never own a host picker.
+  mountSshOperations(ctx, sshApi, createSessionSshTargetSource(sessions, manager))
+
+  ctx.effect(() => ctx.locale.register(NS, dictionaries), 'dsh-hardssh: dictionaries')
 
   const disposers: Array<() => void> = []
   try {
-    ctx.slots.inject('conversation.session.header.utilities', () => {
-      return ctx.slots.register(
-        { name: 'conversation.session.header.utilities', id: 'ssh-workspace-manager', order: -10, inject: () => ({ manager, sshApi }) },
-        WorkspaceManagerButton,
-      )
-    })
+    // The SSH workspace manager is a GLOBAL surface: a left-sidebar entry row
+    // (sidebar.panellist) opening a center panel (main). The shell owns the
+    // row, its label and its active highlight; selecting it switches the
+    // center column, and selecting the Conversation row switches back.
+    registerWorkspacePanel(ctx, { manager, sshApi })
 
     // Replace the native-only directory-flow occupant (both holes) with the
     // SSH/local chooser. `pickDirectory` restores the original native local
@@ -119,14 +134,13 @@ export function apply(ctx: ClientContext): void {
 
     manager.start()
 
-    // Decorate the sidebar workspace rows: append a remote badge to every
-    // host workspace whose title belongs to an SSH-bound workspace. The
-    // badge set is driven by the manager (the single owner of the workspace
-    // list): every successful poll / mutation emits, and the snapshot is the
-    // only data source. Best-effort: a DOM miss only logs.
+    // Sidebar row decoration: label every host workspace whose title belongs to
+    // an SSH-bound workspace with a compact `alias` badge, tinted by whether the
+    // server currently holds a pooled connection. The shell still exposes no
+    // row-decoration slot, so this stays the documented DOM extension it always
+    // was (MutationObserver self-heal), unlike the session list below.
     let badgesDispose: (() => void) | undefined
-    // Live connection state (aliases with a pooled transport) → blue badge.
-    let connectedAliases = new Set<string>()
+    let connectedAliases: ReadonlySet<string> = new Set<string>()
     const refreshBadges = (): void => {
       try {
         const workspaces = manager.getSnapshot().workspaces
@@ -142,20 +156,18 @@ export function apply(ctx: ClientContext): void {
       }
     }
     disposers.push(() => { badgesDispose?.() })
-    // Same-source sync: no independent fetch or timer — the manager emits on
-    // its 3s poll and on create/remove/rename; the first pass lands when the
-    // manager's initial refresh resolves (start() runs before this subscribe
-    // is registered, and its first emit happens after the synchronous body).
+    // Same-source sync: no independent workspace fetch — the manager emits on
+    // its 3s poll and on create/remove/rename.
     disposers.push(manager.subscribe(() => { refreshBadges() }))
 
-    // Connection-state poll: keep badge colors current (same cadence as the
-    // manager's workspace poll). Failure keeps everything gray (safe).
+    // Connection-state poll: badge colors AND the gate's pass cache both key off
+    // "which servers have a live pooled transport right now".
     const refreshConnections = async (): Promise<void> => {
       try {
         connectedAliases = new Set(await sshApi.connectedAliases())
       } catch (error) {
         console.warn('[dsh-hardssh] connection-state poll failed:', error)
-        connectedAliases = new Set()
+        connectedAliases = new Set<string>()
       }
       refreshBadges()
     }
@@ -163,25 +175,16 @@ export function apply(ctx: ClientContext): void {
     disposers.push(() => { window.clearInterval(connTimer) })
     void refreshConnections()
 
-    // Click gate: probing a workspace row must first establish the SSH
-    // connection (host-key TOFU confirm + session password dialogs), so the
-    // shell never opens a workspace that silently fails underneath.
-    let gateDispose: (() => void) | undefined
-    const refreshGates = (): void => {
-      try {
-        const workspaces = manager.getSnapshot().workspaces
-        gateDispose?.()
-        gateDispose = mountWorkspaceGates(workspaces.map((workspace) => ({
-          id: workspace.id,
-          title: workspace.title,
-          alias: workspace.alias,
-        })), sshApi)
-      } catch (error) {
-        console.warn('[dsh-hardssh] gate refresh failed:', error)
-      }
-    }
-    disposers.push(() => { gateDispose?.() })
-    disposers.push(manager.subscribe(() => { refreshGates() }))
+    // Session-open connection gate: opening a session (or creating a New
+    // Session) inside an SSH workspace probes the owning server first, so the
+    // fingerprint / session-password dialogs appear before any remote operation
+    // fails. Driven by the public session list — not by DOM rows — so it
+    // survives any sidebar restyle.
+    disposers.push(mountSessionConnectGate({
+      sessions,
+      aliasForCwd: makeAnchorAliasResolver(() => manager.getSnapshot().workspaces),
+      ensureConnected: (alias) => connectHost(sshApi, alias),
+    }))
   } catch (error) {
     console.warn('[dsh-hardssh] mount failed:', error)
   }

package/src/client/locales.ts

@@ -13,7 +13,14 @@ export const zh = {
   'manager.label': 'SSH 工作区',
   'manager.tooltip': '管理 SSH 工作区：绑定服务器目录，绑定后的会话在远程操作，其余会话在本机',
   'manager.title': 'SSH 工作区管理',
+  'panel.workspaces': 'SSH 工作区',
+  'ops.tab': 'SSH',
+  'ops.guide': '打开 SSH 运维面板：终端、传输、隧道、集群',
     'manager.empty': '还没有 SSH 工作区',
+  'manager.connected': '已连接',
+  'manager.disconnected': '未连接',
+  'manager.connectionUnknown': '状态未知',
+  'manager.connectionError': '无法读取服务器连接状态：%s',
   'manager.delete': '删除',
   'manager.editServer': '编辑服务器',
   'manager.deleteServer': '删除服务器',
@@ -61,7 +68,14 @@ export const en: Record<WorkspaceKey, string> = {
   'manager.label': 'SSH workspaces',
   'manager.tooltip': 'Manage SSH workspaces: bind a server directory — sessions in a bound workspace operate remotely, all others stay local',
   'manager.title': 'SSH Workspaces',
+  'panel.workspaces': 'SSH workspaces',
+  'ops.tab': 'SSH',
+  'ops.guide': 'Open the SSH operations panel: terminal, transfer, tunnels, cluster',
     'manager.empty': 'No SSH workspaces yet',
+  'manager.connected': 'Connected',
+  'manager.disconnected': 'Disconnected',
+  'manager.connectionUnknown': 'Status unknown',
+  'manager.connectionError': 'Could not read server connection state: %s',
       'manager.delete': 'Delete',
   'manager.editServer': 'Edit server',
   'manager.deleteServer': 'Delete server',

package/src/client/session-connect-gate.ts

@@ -0,0 +1,163 @@
+/**
+ * Session-open connection gate: whenever the shell opens a session whose cwd
+ * belongs to an SSH-bound workspace, probe the owning server FIRST so the
+ * interactive connection dialogs appear (host-key TOFU confirm / VSCode-style
+ * session password) instead of the workspace silently failing underneath.
+ *
+ * This replaces the old sidebar row-click gate. The shell exposes no row slot
+ * for workspace rows, and the previous `[class*="projectRow"]` DOM listener was
+ * never a contract — the session list, by contrast, IS a public client surface
+ * (`ctx.sessions.list`), so the trigger is now "a session became current" (open)
+ * plus "a session appeared while we were watching" (New Session in an SSH
+ * workspace) rather than a click on a DOM node we do not own.
+ *
+ * Probing is delegated to `connectHost`, which owns the TTL pass cache and the
+ * in-flight coalescing: re-selecting the same workspace inside the TTL, or
+ * creating several sessions in it, prompts at most once.
+ *
+ * @module dsh-hardssh/client/session-connect-gate
+ */
+
+/** The narrow slice of `ctx.sessions.list` this gate reads. Structural on
+ *  purpose: the shell's `SessionId`/`SessionSummary` types stay out of the
+ *  plugin's public surface, and the adapter at the call site does the one
+ *  unavoidable cast. */
+export interface SessionGateList {
+  subscribe(listener: () => void): () => void
+  /** Initial host list arrival; pending means an empty list is not authoritative. */
+  phase(): 'pending' | 'ready'
+  /** Currently selected session, undefined on the empty state. */
+  currentSessionId(): string | undefined
+  /** Listed session ids, in host order. */
+  sessionIds(): readonly string[]
+  /** The session's workspace cwd (the anchor path for SSH workspaces). */
+  sessionCwd(sessionId: string): string | undefined
+}
+
+/** Gate dependencies. */
+export interface SessionConnectGateDeps {
+  sessions: SessionGateList
+  /** Alias owning the SSH workspace that CONTAINS this cwd, when bound. */
+  aliasForCwd(cwd: string | undefined): string | undefined
+  /** Probe + prompt; resolves true once the server may be used. */
+  ensureConnected(alias: string): Promise<boolean>
+}
+
+/** Normalize one path for anchor comparison: unified separators, no trailing
+ *  separator, and case-folded for Windows-shaped paths (Windows anchors are
+ *  case-insensitive; POSIX anchors are not).
+ *
+ *  Deliberately a SECOND implementation of `base/ledger.ts`'s
+ *  `normalizeAnchorPath`: the base module imports `node:fs` for its own
+ *  persistence and therefore cannot be pulled into the browser bundle. Keep the
+ *  two in step — the host-side duplicates were consolidated for exactly this
+ *  reason, and this one is the documented exception. */
+function normalizeAnchor(path: string): string {
+  const unified = path.replace(/\\/gu, '/').replace(/\/+$/u, '')
+  if (/^[a-zA-Z]:\//u.test(unified) || unified.startsWith('//')) return unified.toLowerCase()
+  return unified
+}
+
+/** True when `cwd` is the anchor itself or sits inside it. */
+function isUnderAnchor(anchor: string, cwd: string): boolean {
+  return cwd === anchor || cwd.startsWith(`${anchor}/`)
+}
+
+/**
+ * Build the cwd → workspace resolver over a live workspace list. The LONGEST
+ * matching anchor wins, so a workspace nested under another one still routes to
+ * its own server.
+ * @param workspaces - live records carrying an anchor path.
+ * @returns resolver returning the owning record, or undefined when unbound.
+ */
+export function makeAnchorWorkspaceResolver<T extends { anchorPath: string }>(
+  workspaces: () => ReadonlyArray<T>,
+): (cwd: string | undefined) => T | undefined {
+  return (cwd) => {
+    if (cwd === undefined || cwd === '') return undefined
+    const target = normalizeAnchor(cwd)
+    let best: T | undefined
+    let bestLength = -1
+    for (const workspace of workspaces()) {
+      const anchor = normalizeAnchor(workspace.anchorPath)
+      if (anchor === '' || !isUnderAnchor(anchor, target)) continue
+      if (anchor.length > bestLength) {
+        bestLength = anchor.length
+        best = workspace
+      }
+    }
+    return best
+  }
+}
+
+/** Alias-only compatibility face used by the connection gate. */
+export function makeAnchorAliasResolver(
+  workspaces: () => ReadonlyArray<{ alias: string; anchorPath: string }>,
+): (cwd: string | undefined) => string | undefined {
+  const resolve = makeAnchorWorkspaceResolver(workspaces)
+  return (cwd) => resolve(cwd)?.alias
+}
+
+/**
+ * Watch the session list and probe the server behind every SSH-bound session
+ * the operator opens or creates.
+ *
+ * The first pass ADOPTS the existing list without probing: a GUI restore must
+ * not fire one connection dialog per remembered session. Only the session the
+ * shell actually selects (including the restored current one) and sessions
+ * created after that pass trigger a probe.
+ *
+ * @param deps - session list view, anchor resolver and probe.
+ * @returns disposer removing the subscription.
+ */
+export function mountSessionConnectGate(deps: SessionConnectGateDeps): () => void {
+  const adopted = new Set<string>()
+  let primed = false
+  let lastCurrent: string | undefined
+
+  /** Probe the server owning one session's workspace (best-effort). */
+  const probe = (sessionId: string | undefined): void => {
+    if (sessionId === undefined) return
+    const alias = deps.aliasForCwd(deps.sessions.sessionCwd(sessionId))
+    if (alias === undefined) return
+    void deps.ensureConnected(alias).catch((error: unknown) => {
+      console.warn('[dsh-hardssh] session connect gate failed:', error)
+    })
+  }
+
+  const pass = (): void => {
+    // The session store starts `pending` with an empty list. Do not prime from
+    // that placeholder: the first successful host pull would otherwise make
+    // every restored historical Session look newly-created and probe every
+    // configured server at GUI startup.
+    if (!primed && deps.sessions.phase() !== 'ready') return
+
+    const ids = deps.sessions.sessionIds()
+    // One probe per session per pass: a New Session both appears and becomes
+    // current in the same snapshot, and probing it twice would open a second
+    // dialog path for a single operator action.
+    const probed = new Set<string>()
+    if (!primed) {
+      for (const id of ids) adopted.add(id)
+      primed = true
+    } else {
+      for (const id of ids) {
+        if (adopted.has(id)) continue
+        adopted.add(id)
+        // A session created while we watch: the New Session flow in an SSH
+        // workspace lands here before its first operation runs.
+        probed.add(id)
+        probe(id)
+      }
+    }
+    const current = deps.sessions.currentSessionId()
+    if (current !== lastCurrent) {
+      lastCurrent = current
+      if (current !== undefined && !probed.has(current)) probe(current)
+    }
+  }
+
+  const dispose = deps.sessions.subscribe(pass)
+  pass()
+  return dispose
+}