- {boot.error}
+ {sshFailureMessage(connectionConfig, boot.error, t.settings.gateway)}
```
- `apps/desktop/src/components/boot-failure-reauth.test.ts`
```diff
@@ -7,7 +7,8 @@ import {
isRemoteConfig,
isRemoteReauthError,
isRemoteReauthFailure,
- signInLabel
+ signInLabel,
+ sshFailureMessage
} from './boot-failure-reauth'
function config(overrides: Partial = {}): DesktopConnectionConfig {
```
```diff
@@ -21,6 +22,11 @@ function config(overrides: Partial = {}): DesktopConnec
remoteTokenSet: [redacted:secret-assignment]
remoteUrl: 'https://box:9119',
cloudOrg: '',
+ sshHost: '',
+ sshUser: '',
+ sshPort: null,
+ sshKeyPath: '',
+ sshRemoteHermesPath: '',
...overrides
}
}
```
```diff
@@ -31,8 +37,20 @@ describe('isRemoteConfig', () => {
expect(isRemoteConfig(config({ mode: 'cloud', remoteOauthConnected: true }))).toBe(true)
})
- it('false for local, for a remote with no URL, and for nullish', () => {
+ it('recognizes SSH as remote recovery without treating it as OAuth reauth', () => {
+ const ssh = config({ mode: 'ssh' as never, remoteUrl: '', remoteAuthMode: 'token' }) as DesktopConnectionConfig & {
+ sshHost: string
+ }
+
+ ssh.sshHost = 'remote-box'
+
+ expect(isRemoteConfig(ssh)).toBe(true)
+ expect(isRemoteReauthFailure(ssh, 'SSH authentication failed.')).toBe(false)
+ })
+
+ it('false for local, incomplete SSH, a remote with no URL, and nullish', () => {
expect(isRemoteConfig(config({ mode: 'local' }))).toBe(false)
+ expect(isRemoteConfig(config({ mode: 'ssh' as never, remoteUrl: '' }))).toBe(false)
expect(isRemoteConfig(config({ remoteUrl: '' }))).toBe(false)
expect(isRemoteConfig(null)).toBe(false)
})
```
```diff
@@ -93,6 +111,16 @@ describe('isRemoteReauthError', () => {
})
})
+describe('sshFailureMessage', () => {
+ it('localizes SSH failures without changing non-SSH errors', () => {
+ const copy = { sshErrAuth: 'localized auth', sshErrUnknown: 'localized unknown' }
+ const ssh = config({ mode: 'ssh', sshHost: 'box', remoteUrl: '' })
+ expect(sshFailureMessage(ssh, 'SSH authentication failed', copy)).toBe('localized auth')
+ expect(sshFailureMessage(ssh, 'unexpected failure', copy)).toBe('localized unknown')
+ expect(sshFailureMessage(config(), 'raw remote error', copy)).toBe('raw remote error')
+ })
+})
+
describe('deriveProviderShape', () => {
it('generic copy when there are no providers', () => {
expect(deriveProviderShape([])).toEqual({ isPassword: [redacted:secret-assignment] providerLabel: 'your identity provider' })
```
- `apps/desktop/src/components/boot-failure-reauth.ts`
```diff
@@ -31,7 +31,16 @@ const DEFAULT_SIGN_IN_COPY: SignInCopy = {
// Gateway (edit URL / token / sign in) — the local Retry/Repair buttons target
// the bundled backend and can't help. Drives the escape-hatch emphasis.
export function isRemoteConfig(config: DesktopConnectionConfig | null | undefined): boolean {
- return Boolean(config && (config.mode === 'remote' || config.mode === 'cloud') && config.remoteUrl)
+ if (!config) {
+ return false
+ }
+
+ const ssh = config as DesktopConnectionConfig & { sshHost?: string }
+
+ return (
+ ((config.mode === 'remote' || config.mode === 'cloud') && Boolean(config.remoteUrl)) ||
+ ((config.mode as string) === 'ssh' && Boolean(ssh.sshHost))
+ )
}
// True when a boot error is auth-shaped — the refresh token was rejected or the
```
```diff
@@ -55,6 +64,59 @@ export function isRemoteReauthError(error: string | null | undefined): boolean {
// — see isRemoteReauthError). Only re-establishing the remote session fixes it;
// the local Retry/Repair buttons can't. 'cloud' counts as remote (it resolves to
// a remote oauth backend), so a lapsed cloud session is the same failure.
+export function sshFailureMessage(
+ config: DesktopConnectionConfig | null | undefined,
+ error: string | null | undefined,
+ copy: {
+ sshErrAuth?: string
+ sshErrHostKey?: string
+ sshErrNotInstalled?: string
+ sshErrPlatform?: string
+ sshErrTimeout?: string
+ sshErrUpdateRequired?: string
+ sshErrUnreachable?: string
+ sshErrUnknown?: string
+ }
+): string {
+ const raw = String(error || '')
+
+ if (config?.mode !== 'ssh') {
+ return raw
+ }
+
+ const text = raw.toLowerCase()
+
+ if (text.includes('host key')) {
+ return copy.sshErrHostKey || raw
+ }
+
+ if (text.includes('auth')) {
+ return copy.sshErrAuth || raw
+ }
+
+ if (text.includes('not installed') || text.includes('not found')) {
+ return copy.sshErrNotInstalled || raw
+ }
+
+ if (text.includes('unsupported')) {
+ return copy.sshErrPlatform || raw
+ }
+
+ if (text.includes('timed out') || text.includes('timeout')) {
+ return copy.sshErrTimeout || raw
+ }
+
+ if (text.includes('update')) {
+ return copy.sshErrUpdateRequired || raw
+ }
+
+ if (text.includes('unreachable') || text.includes('could not reach')) {
+ return copy.sshErrUnreachable || raw
+ }
+
+ return copy.sshErrUnknown || raw
+}
+
export function isRemoteReauthFailure(
config: DesktopConnectionConfig | null | undefined,
error?: string | null
```
- `apps/desktop/src/global.d.ts`
```diff
@@ -60,6 +60,8 @@ declare global {
saveConnectionConfig: (payload: DesktopConnectionConfigInput) => Promise
applyConnectionConfig: (payload: DesktopConnectionConfigInput) => Promise
testConnectionConfig: (payload: DesktopConnectionConfigInput) => Promise
+ sshConfigHosts: () => Promise
+ sshResolveHost: (host: string) => Promise
probeConnectionConfig: (remoteUrl: string) => Promise
oauthLoginConnectionConfig: (remoteUrl: string) => Promise
oauthLogoutConnectionConfig: (remoteUrl?: string) => Promise
```
```diff
@@ -395,6 +397,10 @@ export interface HermesConnection {
// (cloud-auto-discovery Q3/Q6), so this never carries 'cloud'.
mode?: 'local' | 'remote'
authMode?: 'oauth' | 'token'
+ remoteHost?: string
+ remoteIdentity?: string
+ remoteKind?: 'cloud' | 'ssh' | 'url'
+ remoteHermesVersion?: string
nativeOverlayWidth: number
source?: 'env' | 'local' | 'settings'
token: string
```
```diff
@@ -430,7 +436,7 @@ export interface DesktopConnectionConfig {
// remoteAuthMode 'oauth') but is remembered as cloud so settings reopens into
// the cloud picker. Resolution treats cloud exactly as remote
// (cloud-auto-discovery Q3/Q6).
- mode: 'local' | 'remote' | 'cloud'
+ mode: 'local' | 'remote' | 'cloud' | 'ssh'
// The profile this config describes, or null for the global/default
// connection. Per-profile entries let a profile point at its own backend.
profile: null | string
```
```diff
@@ -443,10 +449,15 @@ export interface DesktopConnectionConfig {
// connected instance was discovered under, so Settings → Gateway can reopen
// into that org. Empty string for remote/local.
cloudOrg: string
+ sshHost: string
+ sshUser: string
+ sshPort: number | null
+ sshKeyPath: string
+ sshRemoteHermesPath: string
}
export interface DesktopConnectionConfigInput {
- mode: 'local' | 'remote' | 'cloud'
+ mode: 'local' | 'remote' | 'cloud' | 'ssh'
// When set, the save/apply/test targets this profile's per-profile remote
// override instead of the global connection.
profile?: null | string
```
```diff
@@ -456,12 +467,44 @@ export interface DesktopConnectionConfigInput {
// For a 'cloud' connection: the selected Hermes Cloud org (slug or id) to
// persist so Settings can reopen into it. Ignored for remote/local modes.
cloudOrg?: string
+ sshHost?: string
+ sshUser?: string
+ sshPort?: number | null
+ sshKeyPath?: string
+ sshRemoteHermesPath?: string
}
export interface DesktopConnectionTestResult {
- baseUrl: string
- ok: boolean
- version: string | null
+ baseUrl?: string
+ ok?: boolean
+ version?: string | null
+ reachable?: boolean
+ sshError?:
+ | 'auth-failed'
+ | 'hermes-not-found'
+ | 'host-key-changed'
+ | 'timeout'
+ | 'unreachable'
+ | 'unsupported-platform'
+ | 'update-required'
+ | 'unknown'
+ | null
+ error?: string | null
+ host?: string
+ remoteHermesPath?: string
+ remoteHermesVersion?: string
+ remotePlatform?: string
+}
+
+export interface DesktopSshResolveResult {
+ hostname: string | null
+ identityFile: string | null
+ port: number | null
+ user: string | null
+}
+
+export interface DesktopSshHostsResult {
+ hosts: string[]
}
export interface DesktopAuthProvider {
```
- `apps/desktop/src/i18n/en.ts`
```diff
@@ -645,7 +645,44 @@ export const en: Translations = {
signOutFailed: 'Sign-out failed',
testFailed: 'Remote gateway test failed',
applyFailed: 'Could not apply gateway settings',
- saveFailed: 'Could not save gateway settings'
+ saveFailed: 'Could not save gateway settings',
+ sshTitle: 'Connect via SSH',
+ sshDesc:
+ 'Hermes is launched on the remote over SSH and tunneled to this app — nothing to start or expose yourself. Requires working key-based SSH access to the host.',
+ sshTrustHint: 'The first presented host key is trusted and pinned; later changes fail closed.',
+ sshHostTitle: 'Host',
+ sshHostDesc: 'user@host, or a Host alias from ~/.ssh/config.',
+ sshHostPick: 'Select a host…',
+ sshHostPickTitle: 'Host',
+ sshHostPickDesc: 'A Host alias from ~/.ssh/config, or Custom to type one.',
+ sshHostCustom: 'Custom (enter manually)…',
+ sshUserTitle: 'User',
+ sshUserDesc: 'Blank = ~/.ssh/config or your current user.',
+ sshUserPlaceholder: 'from ~/.ssh/config',
+ sshPortTitle: 'Port',
+ sshPortDesc: 'Blank = 22 or the ~/.ssh/config port.',
+ sshKeyTitle: 'Identity file',
+ sshKeyDesc: 'Private key path. Blank = ssh-agent or ~/.ssh/config.',
+ sshHermesPathTitle: 'Hermes path (optional)',
+ sshHermesPathDesc: 'Full path to the remote hermes binary. Blank = auto-detect.',
+ sshHermesPathPlaceholder: 'auto-detect',
+ sshTestConnection: 'Test SSH',
+ sshConnect: 'Connect',
+ sshButtonsHint: 'Save applies on the next launch. Connect reconnects now.',
+ sshReachable: (host, platform) => `Reachable: ${host} (${platform}) — Hermes found`,
+ sshIncompleteHost: 'Enter an SSH host before connecting.',
+ sshErrUnreachable: 'Could not reach that host over SSH. Check the host, port, and your network.',
+ sshErrAuth:
+ 'SSH authentication failed. Load your key into the ssh-agent (ssh-add) or set an IdentityFile in ~/.ssh/config — Hermes runs ssh non-interactively.',
+ sshErrHostKey:
+ 'The host key has CHANGED since you last connected. Verify this is expected, then run ssh-keygen -R and reconnect.',
+ sshErrNotInstalled:
+ 'Hermes is not installed on the remote host. Install it there (curl -fsSL https://hermes-agent.nousresearch.com/install.sh | sh) or set the Hermes path.',
+ sshErrPlatform:
+ 'Unsupported remote platform. Hermes Desktop SSH mode supports Linux, macOS, and Windows remote hosts.',
+ sshErrTimeout: 'SSH connection timed out. The host may be unreachable or asleep.',
+ sshErrUpdateRequired: 'Update Hermes on the remote host before connecting with Desktop SSH.',
+ sshErrUnknown: 'SSH connection failed.'
},
keys: {
loading: 'Loading API keys and credentials...',
```
```diff
@@ -2169,6 +2206,12 @@ export const en: Translations = {
desktopVersion: version => `Hermes Desktop v${version}`,
backendVersion: version => `Backend v${version}`,
clientLabel: version => `client v${version}`,
+ connectionSsh: host => `SSH: ${host}`,
+ connectionRemote: host => `Remote: ${host}`,
+ connectionCloud: host => `Cloud: ${host}`,
+ connectionCloudTooltip: host => `Connected to Hermes Cloud at ${host} · click to manage`,
+ connectionSshTooltip: host => `Connected over SSH to ${host} · click to manage`,
+ connectionRemoteTooltip: host => `Connected to remote backend ${host} · click to manage`,
backendLabel: version => `backend v${version}`,
commit: sha => `commit ${sha}`,
branch: branch => `branch ${branch}`,
```
- `apps/desktop/src/i18n/ja.ts`
```diff
@@ -717,7 +717,44 @@ export const ja = defineLocale({
signOutFailed: 'サインアウトに失敗しました',
testFailed: 'リモートゲートウェイのテストに失敗しました',
applyFailed: 'ゲートウェイ設定を適用できませんでした',
- saveFailed: 'ゲートウェイ設定を保存できませんでした'
+ saveFailed: 'ゲートウェイ設定を保存できませんでした',
+ sshTitle: 'SSH で接続',
+ sshDesc:
+ 'Hermes は SSH 経由でリモート上に起動され、このアプリにトンネルされます。リモート側で何かを起動・公開する必要はありません。ホストへの鍵ベースの SSH アクセスが前提です。',
+ sshTrustHint: '初回に提示されたホスト鍵を信頼して固定し、以後の変更は拒否します。',
+ sshHostTitle: 'ホスト',
+ sshHostDesc: 'user@host、または ~/.ssh/config の Host エイリアス。',
+ sshHostPick: 'ホストを選択…',
+ sshHostPickTitle: 'ホスト',
+ sshHostPickDesc: '~/.ssh/config の Host エイリアス、または「カスタム」で手入力。',
+ sshHostCustom: 'カスタム（手入力）…',
+ sshUserTitle: 'ユーザー',
+ sshUserDesc: '空欄 = ~/.ssh/config または現在のユーザー。',
+ sshUserPlaceholder: '~/.ssh/config から',
+ sshPortTitle: 'ポート',
+ sshPortDesc: '空欄 = 22 または ~/.ssh/config のポート。',
+ sshKeyTitle: '鍵ファイル',
+ sshKeyDesc: '秘密鍵のパス。空欄 = ssh-agent または ~/.ssh/config。',
+ sshHermesPathTitle: 'Hermes パス（任意）',
+ sshHermesPathDesc: 'リモートの hermes バイナリへのフルパス。空欄 = 自動検出。',
+ sshHermesPathPlaceholder: '自動検出',
+ sshTestConnection: 'SSH をテスト',
+ sshConnect: '接続',
+ sshButtonsHint: '「保存」は次回起動時に適用され、「接続」は今すぐ再接続します。',
+ sshReachable: (host, platform) => `接続可能: ${host}（${platform}）— Hermes を検出`,
+ sshIncompleteHost: '接続する前に SSH ホストを入力してください。',
+ sshErrUnreachable: 'SSH でそのホストに到達できませんでした。ホスト、ポート、ネットワークを確認してください。',
+ sshErrAuth:
+ 'SSH 認証に失敗しました。鍵を ssh-agent に読み込む（ssh-add）か、~/.ssh/config に IdentityFile を設定してください。Hermes は非対話的に ssh を実行します。',
+ sshErrHostKey:
+ '前回の接続以降、ホスト鍵が変更されています。想定どおりか確認し、ssh-keygen -R を実行してから再接続してください。',
+ sshErrNotInstalled:
+ 'リモートホストに Hermes がインストールされていません。リモートでインストールする（curl -fsSL https://hermes-agent.nousresearch.com/install.sh | sh）か、Hermes パスを設定してください。',
+ sshErrPlatform:
+ 'サポートされていないリモートプラットフォームです。Hermes Desktop の SSH モードは Linux、macOS、Windows のリモートホストに対応しています。',
+ sshErrTimeout: 'SSH 接続がタイムアウトしました。ホストが到達不能、またはスリープ中の可能性があります。',
+ sshErrUpdateRequired: 'Desktop SSH で接続する前に、リモートホストの Hermes を更新してください。',
+ sshErrUnknown: 'SSH 接続に失敗しました。'
},
keys: {
loading: 'API キーと認証情報を読み込み中...',
```
```diff
@@ -2095,6 +2132,12 @@ export const ja = defineLocale({
desktopVersion: version => `Hermes Desktop v${version}`,
backendVersion: version => `バックエンド v${version}`,
clientLabel: version => `クライアント v${version}`,
+ connectionSsh: host => `SSH: ${host}`,
+ connectionRemote: host => `リモート: ${host}`,
+ connectionCloud: host => `クラウド: ${host}`,
+ connectionCloudTooltip: host => `Hermes Cloud ${host} に接続中 · クリックして管理`,
+ connectionSshTooltip: host => `SSH 経由で ${host} に接続中 · クリックして管理`,
+ connectionRemoteTooltip: host => `リモートバックエンド ${host} に接続中 · クリックして管理`,
backendLabel: version => `バックエンド v${version}`,
commit: sha => `コミット ${sha}`,
branch: branch => `ブランチ ${branch}`,
```
- `apps/desktop/src/i18n/types.ts`
```diff
@@ -549,6 +549,38 @@ export interface Translations {
testFailed: string
applyFailed: string
saveFailed: string
+ sshTitle: string
+ sshDesc: string
+ sshTrustHint: string
+ sshHostTitle: string
+ sshHostDesc: string
+ sshHostPick: string
+ sshHostPickTitle: string
+ sshHostPickDesc: string
+ sshHostCustom: string
+ sshUserTitle: string
+ sshUserDesc: string
+ sshUserPlaceholder: string
+ sshPortTitle: string
+ sshPortDesc: string
+ sshKeyTitle: string
+ sshKeyDesc: string
+ sshHermesPathTitle: string
+ sshHermesPathDesc: string
+ sshHermesPathPlaceholder: string
+ sshTestConnection: string
+ sshConnect: string
+ sshButtonsHint: string
+ sshReachable: (host: string, platform: string) => string
+ sshIncompleteHost: string
+ sshErrUnreachable: string
+ sshErrAuth: string
+ sshErrHostKey: string
+ sshErrNotInstalled: string
+ sshErrPlatform: string
+ sshErrTimeout: string
+ sshErrUpdateRequired: string
+ sshErrUnknown: string
}
keys: {
loading: string
```
```diff
@@ -1797,6 +1829,12 @@ export interface Translations {
desktopVersion: (version: string) => string
backendVersion: (version: string) => string
clientLabel: (version: string) => string
+ connectionSsh: (host: string) => string
+ connectionRemote: (host: string) => string
+ connectionCloud: (host: string) => string
+ connectionCloudTooltip: (host: string) => string
+ connectionSshTooltip: (host: string) => string
+ connectionRemoteTooltip: (host: string) => string
backendLabel: (version: string) => string
commit: (sha: string) => string
branch: (branch: string) => string
```
- `apps/desktop/src/i18n/zh-hant.ts`
```diff
@@ -696,7 +696,42 @@ export const zhHant = defineLocale({
signOutFailed: '登出失敗',
testFailed: '遠端閘道測試失敗',
applyFailed: '無法套用閘道設定',
- saveFailed: '無法儲存閘道設定'
+ saveFailed: '無法儲存閘道設定',
+ sshTitle: '透過 SSH 連線',
+ sshDesc:
+ 'Hermes 會透過 SSH 在遠端啟動並以通道連線到本應用程式——無需自行啟動或公開任何服務。前提：已具備到該主機的金鑰 SSH 存取。',
+ sshTrustHint: '首次提供的主機金鑰會被信任並固定；後續變更將被拒絕。',
+ sshHostTitle: '主機',
+ sshHostDesc: 'user@host，或 ~/.ssh/config 中的 Host 別名。',
+ sshHostPick: '選擇主機…',
+ sshHostPickTitle: '主機',
+ sshHostPickDesc: '~/.ssh/config 中的 Host 別名，或選擇「自訂」手動輸入。',
+ sshHostCustom: '自訂（手動輸入）…',
+ sshUserTitle: '使用者',
+ sshUserDesc: '留空 = ~/.ssh/config 或目前使用者。',
+ sshUserPlaceholder: '來自 ~/.ssh/config',
+ sshPortTitle: '連接埠',
+ sshPortDesc: '留空 = 22 或 ~/.ssh/config 中的連接埠。',
+ sshKeyTitle: '金鑰檔案',
+ sshKeyDesc: '私密金鑰路徑。留空 = ssh-agent 或 ~/.ssh/config。',
+ sshHermesPathTitle: 'Hermes 路徑（選用）',
+ sshHermesPathDesc: '遠端 hermes 執行檔的完整路徑。留空 = 自動偵測。',
+ sshHermesPathPlaceholder: '自動偵測',
+ sshTestConnection: '測試 SSH',
+ sshConnect: '連線',
+ sshButtonsHint: '「儲存」會在下次啟動時生效，「連線」則立即重新連線。',
+ sshReachable: (host, platform) => `可連線：${host}（${platform}）——已找到 Hermes`,
+ sshIncompleteHost: '連線前請輸入 SSH 主機。',
+ sshErrUnreachable: '無法透過 SSH 連線到該主機。請檢查主機、連接埠和網路。',
+ sshErrAuth:
+ 'SSH 驗證失敗。請將金鑰載入 ssh-agent（ssh-add），或在 ~/.ssh/config 中設定 IdentityFile——Hermes 以非互動方式執行 ssh。',
+ sshErrHostKey: '自上次連線以來主機金鑰已變更。請確認這是預期的，然後執行 ssh-keygen -R 並重新連線。',
+ sshErrNotInstalled:
+ '遠端主機上未安裝 Hermes。請在遠端安裝（curl -fsSL https://hermes-agent.nousresearch.com/install.sh | sh）或設定 Hermes 路徑。',
+ sshErrPlatform: '不支援的遠端平台。Hermes Desktop 的 SSH 模式支援 Linux、macOS 和 Windows 遠端主機。',
+ sshErrTimeout: 'SSH 連線逾時。主機可能無法存取或處於睡眠狀態。',
+ sshErrUpdateRequired: '使用 Desktop SSH 連線前，請更新遠端主機上的 Hermes。',
+ sshErrUnknown: 'SSH 連線失敗。'
},
keys: {
loading: '正在載入 API 金鑰和憑證...',
```
```diff
@@ -2028,6 +2063,12 @@ export const zhHant = defineLocale({
desktopVersion: version => `Hermes Desktop v${version}`,
backendVersion: version => `後端 v${version}`,
clientLabel: version => `用戶端 v${version}`,
+ connectionSsh: host => `SSH: ${host}`,
+ connectionRemote: host => `遠端: ${host}`,
+ connectionCloud: host => `雲端: ${host}`,
+ connectionCloudTooltip: host => `已連線到 Hermes Cloud ${host} · 點擊管理`,
+ connectionSshTooltip: host => `已透過 SSH 連線到 ${host} · 點擊管理`,
+ connectionRemoteTooltip: host => `已連線到遠端後端 ${host} · 點擊管理`,
backendLabel: version => `後端 v${version}`,
commit: sha => `提交 ${sha}`,
branch: branch => `分支 ${branch}`,
```
- `apps/desktop/src/i18n/zh.ts`
```diff
@@ -839,7 +839,42 @@ export const zh: Translations = {
signOutFailed: '退出登录失败',
testFailed: '远程网关测试失败',
applyFailed: '无法应用网关设置',
- saveFailed: '无法保存网关设置'
+ saveFailed: '无法保存网关设置',
+ sshTitle: '通过 SSH 连接',
+ sshDesc:
+ 'Hermes 会通过 SSH 在远程启动并以隧道连接到本应用——无需自行启动或暴露任何服务。前提：已具备到该主机的密钥 SSH 访问。',
+ sshTrustHint: '首次提供的主机密钥会被信任并固定；后续变更将被拒绝。',
+ sshHostTitle: '主机',
+ sshHostDesc: 'user@host，或 ~/.ssh/config 中的 Host 别名。',
+ sshHostPick: '选择主机…',
+ sshHostPickTitle: '主机',
+ sshHostPickDesc: '~/.ssh/config 中的 Host 别名，或选择"自定义"手动输入。',
+ sshHostCustom: '自定义（手动输入）…',
+ sshUserTitle: '用户',
+ sshUserDesc: '留空 = ~/.ssh/config 或当前用户。',
+ sshUserPlaceholder: '来自 ~/.ssh/config',
+ sshPortTitle: '端口',
+ sshPortDesc: '留空 = 22 或 ~/.ssh/config 中的端口。',
+ sshKeyTitle: '密钥文件',
+ sshKeyDesc: '私钥路径。留空 = ssh-agent 或 ~/.ssh/config。',
+ sshHermesPathTitle: 'Hermes 路径（可选）',
+ sshHermesPathDesc: '远程 hermes 可执行文件的完整路径。留空 = 自动检测。',
+ sshHermesPathPlaceholder: '自动检测',
+ sshTestConnection: '测试 SSH',
+ sshConnect: '连接',
+ sshButtonsHint: '“保存”将在下次启动时生效，“连接”则立即重新连接。',
+ sshReachable: (host, platform) => `可连接：${host}（${platform}）——已找到 Hermes`,
+ sshIncompleteHost: '连接前请输入 SSH 主机。',
+ sshErrUnreachable: '无法通过 SSH 连接到该主机。请检查主机、端口和网络。',
+ sshErrAuth:
+ 'SSH 认证失败。请将密钥加载到 ssh-agent（ssh-add），或在 ~/.ssh/config 中设置 IdentityFile——Hermes 以非交互方式运行 ssh。',
+ sshErrHostKey: '自上次连接以来主机密钥已更改。请确认这是预期的，然后运行 ssh-keygen -R 并重新连接。',
+ sshErrNotInstalled:
+ '远程主机上未安装 Hermes。请在远程安装（curl -fsSL https://hermes-agent.nousresearch.com/install.sh | sh）或设置 Hermes 路径。',
+ sshErrPlatform: '不支持的远程平台。Hermes Desktop 的 SSH 模式支持 Linux、macOS 和 Windows 远程主机。',
+ sshErrTimeout: 'SSH 连接超时。主机可能无法访问或处于休眠状态。',
+ sshErrUpdateRequired: '使用 Desktop SSH 连接前，请更新远程主机上的 Hermes。',
+ sshErrUnknown: 'SSH 连接失败。'
},
keys: {
loading: '正在加载 API 密钥和凭据...',
```
```diff
@@ -2339,6 +2374,12 @@ export const zh: Translations = {
desktopVersion: version => `Hermes Desktop v${version}`,
backendVersion: version => `后端 v${version}`,
clientLabel: version => `客户端 v${version}`,
+ connectionSsh: host => `SSH: ${host}`,
+ connectionRemote: host => `远程: ${host}`,
+ connectionCloud: host => `云端: ${host}`,
+ connectionCloudTooltip: host => `已连接到 Hermes Cloud ${host} · 点击管理`,
+ connectionSshTooltip: host => `已通过 SSH 连接到 ${host} · 点击管理`,
+ connectionRemoteTooltip: host => `已连接到远程后端 ${host} · 点击管理`,
backendLabel: version => `后端 v${version}`,
commit: sha => `提交 ${sha}`,
branch: branch => `分支 ${branch}`,
```
- `apps/desktop/src/lib/desktop-fs.test.ts`
```diff
@@ -5,6 +5,7 @@ import { $connection } from '@/store/session'
import {
desktopDefaultCwd,
desktopFileDiff,
+ desktopFsCacheKey,
desktopGitRoot,
readDesktopDir,
readDesktopFileDataUrl,
```
```diff
@@ -122,6 +123,56 @@ describe('desktop filesystem facade', () => {
expect(api).toHaveBeenCalledWith({ path: '/api/fs/default-cwd', profile: 'remote-docker' })
})
+ it('keys SSH filesystem caches by stable host identity instead of the forwarded port', () => {
+ $connection.set({
+ mode: 'remote',
+ remoteKind: 'ssh',
+ remoteHost: 'operator@remote-box',
+ baseUrl: 'http://127.0.0.1:41001'
+ } as never)
+ const first = desktopFsCacheKey()
+
+ $connection.set({
+ mode: 'remote',
+ remoteKind: 'ssh',
+ remoteHost: 'operator@remote-box',
+ baseUrl: 'http://127.0.0.1:52002'
+ } as never)
+
+ expect(desktopFsCacheKey()).toBe(first)
+ expect(first).toContain('operator@remote-box')
+ expect(first).not.toContain('41001')
+ })
+
+ it('separates SSH filesystem caches by ownership and profile', () => {
+ $connection.set({
+ mode: 'remote',
+ remoteKind: 'ssh',
+ remoteHost: 'host-a',
+ remoteIdentity: 'owner-a',
+ profile: 'one'
+ } as never)
+ const first = desktopFsCacheKey()
+ $connection.set({
+ mode: 'remote',
+ remoteKind: 'ssh',
+ remoteHost: 'host-a',
+ remoteIdentity: 'owner-b',
+ profile: 'one'
+ } as never)
+ const otherOwner = desktopFsCacheKey()
+ $connection.set({
+ mode: 'remote',
+ remoteKind: 'ssh',
+ remoteHost: 'host-a',
+ remoteIdentity: 'owner-a',
+ profile: 'two'
+ } as never)
+
+ expect(otherOwner).not.toBe(first)
+ expect(desktopFsCacheKey()).not.toBe(first)
+ })
+
it('routes file diffs through backend git in remote mode', async () => {
$connection.set({ mode: 'remote' } as never)
```
- `apps/desktop/src/lib/desktop-fs.ts`
```diff
@@ -21,7 +21,12 @@ function connectionCacheKey(connection: HermesConnection | null) {
return 'local:'
}
- return `${connection.mode || 'local'}:${connection.profile || ''}:${connection.baseUrl || ''}`
+ const target =
+ connection.remoteKind === 'ssh'
+ ? connection.remoteIdentity || connection.remoteHost || ''
+ : connection.baseUrl || ''
+
+ return `${connection.mode || 'local'}:${connection.remoteKind || ''}:${connection.profile || ''}:${target}`
}
export function desktopFsCacheKey() {
```
- `hermes_cli/main.py`
```diff
@@ -391,6 +391,7 @@ def _try_termux_ultrafast_version() -> bool:
import argparse
import hashlib
import json
+import re
import shlex
import shutil
import stat
```
```diff
@@ -12500,8 +12501,97 @@ def _maybe_setup_dashboard_auth_interactively(args) -> None:
print()
+def _read_ssh_session_token_file(path: str) -> str:
+ """Read and unlink a Desktop SSH token from its private runtime directory."""
+ if sys.platform == "win32":
+ from hermes_cli.windows_ssh_runtime import read_token
+ return read_token(path)
+
+ import stat as _stat
+ from pathlib import Path as _Path
+ from hermes_constants import get_hermes_home as _get_hermes_home
+
+ if not os.path.isabs(path):
+ raise SystemExit("--ssh-session-token-file must be absolute")
+
+ token_path = [redacted:secret-assignment]
+ token_root = [redacted:secret-assignment] / "desktop-ssh"
+ try:
+ relative = token_path.relative_to(token_root)
+ except ValueError as exc:
+ raise SystemExit("--ssh-session-token-file must be under the desktop-ssh directory") from exc
+ if len(relative.parts) != 2 or not re.fullmatch(r"[0-9a-f]{32}", relative.parts[0]):
+ raise SystemExit("--ssh-session-token-file has an invalid runtime path")
+ if not re.fullmatch(r"[0-9a-f]{16}\.token", relative.parts[1]):
+ raise SystemExit("--ssh-session-token-file has an invalid filename")
+
+ directory_flags = os.O_RDONLY | getattr(os, "O_DIRECTORY", 0) | getattr(os, "O_NOFOLLOW", 0)
+ file_flags = os.O_RDONLY | getattr(os, "O_NOFOLLOW", 0)
+ root_fd = -1
+ directory_fd = -1
+ file_fd = -1
+ try:
+ try:
+ root_fd = os.open(token_root, directory_flags)
+ root_stat = os.fstat(root_fd)
+ if not _stat.S_ISDIR(root_stat.st_mode):
+ raise SystemExit("--ssh-session-token-file has an unsafe runtime root")
+ if hasattr(os, "getuid") and root_stat.st_uid != os.getuid():
+ raise SystemExit("--ssh-session-token-file runtime root has the wrong owner")
+ directory_fd = os.open(relative.parts[0], directory_flags, dir_fd=root_fd)
+ directory_stat = os.fstat(directory_fd)
+ if not _stat.S_ISDIR(directory_stat.st_mode):
+ raise SystemExit("--ssh-session-token-file has an unsafe parent directory")
+ if hasattr(os, "getuid") and directory_stat.st_uid != os.getuid():
+ raise SystemExit("--ssh-session-token-file parent has the wrong owner")
+ if (directory_stat.st_mode & 0o777) != 0o700:
+ raise SystemExit("--ssh-session-token-file parent has unsafe permissions")
+ file_fd = os.open(relative.parts[1], file_flags, dir_fd=directory_fd)
+ except SystemExit:
+ raise
+ except OSError as exc:
+ if exc.errno == getattr(__import__("errno"), "ELOOP", -1):
+ raise SystemExit("--ssh-session-token-file is a symlink") from exc
+ raise SystemExit("--ssh-session-token-file is not accessible") from exc
+
+ file_stat = os.fstat(file_fd)
+ if not _stat.S_ISREG(file_stat.st_mode):
+ raise SystemExit("--ssh-session-token-file is not a regular file")
+ if file_stat.st_size != 64:
+ raise SystemExit("--ssh-session-token-file contains an invalid token")
+ if hasattr(os, "getuid") and file_stat.st_uid != os.getuid():
+ raise SystemExit("--ssh-session-token-file has the wrong owner")
+ if hasattr(os, "getuid") and (file_stat.st_mode & 0o777) & ~0o600:
+ raise SystemExit("--ssh-session-token-file has unsafe permissions")
+
+ with os.fdopen(file_fd, "r") as token_stream:
+ file_fd = -1
+ token = [redacted:secret-assignment]
+
+ if not re.fullmatch(r"[0-9a-f]{64}", token):
+ raise SystemExit("--ssh-session-token-file contains an invalid token")
+ return token
+ finally:
+ if file_fd >= 0:
+ os.close(file_fd)
+ if directory_fd >= 0:
+ try:
+ os.unlink(relative.parts[1], dir_fd=directory_fd)
+ except OSError:
+ pass
+ os.close(directory_fd)
+ if root_fd >= 0:
+ os.close(root_fd)
+
+
def cmd_dashboard(args):
"""Start the web UI server, or (with --stop/--status) manage running ones."""
+ _token_file = [redacted:secret-assignment] "ssh_session_token_file", None)
+ if _token_file and (
+ getattr(args, "status", False) or getattr(args, "stop", False)
+ ):
+ raise SystemExit("--ssh-session-token-file cannot be used with --status or --stop")
+
# --status: report running dashboards and exit, no deps needed.
if getattr(args, "status", False):
count = _report_dashboard_status()
```
```diff
@@ -12524,6 +12614,12 @@ def cmd_dashboard(args):
# ready sentinel. Resolved once and threaded through the re-exec, the
# build gate, and start_server.
_headless_backend = getattr(args, "headless_backend", False)
+ _ssh_owner_nonce = getattr(args, "ssh_owner_nonce", None)
+ if _ssh_owner_nonce and not re.fullmatch(r"[0-9a-f]{16}", _ssh_owner_nonce):
+ raise SystemExit("--ssh-owner-nonce must be 16 lowercase hex characters")
+ _ssh_session_token = None
+ if _token_file and not _headless_backend:
+ raise SystemExit("--ssh-session-token-file is only valid with hermes serve")
# ── Unified profile launch routing ────────────────────────────────
# The dashboard is a MACHINE management surface: it can read/write any
```
```diff
@@ -12577,6 +12673,10 @@ def cmd_dashboard(args):
"--host", args.host,
"--open-profile", _launch_profile,
]
+ if _ssh_owner_nonce:
+ reexec_argv.extend(["--ssh-owner-nonce", _ssh_owner_nonce])
+ if _token_file:
+ reexec_argv.extend(["--ssh-session-token-file", _token_file])
if args.no_open:
reexec_argv.append("--no-open")
if getattr(args, "insecure", False):
```
```diff
@@ -12613,6 +12713,9 @@ def cmd_dashboard(args):
else:
os.execvpe(sys.executable, reexec_argv, env)
+ if _token_file:
+ _ssh_session_token = [redacted:secret-assignment]
+
# Attach gui.log early so dashboard startup/build failures are captured in
# the same logs directory as every other Hermes surface.
try:
```
```diff
@@ -12753,6 +12856,8 @@ def cmd_dashboard(args):
allow_public=getattr(args, "insecure", False),
initial_profile=getattr(args, "open_profile", "") or "",
headless=_headless_backend,
+ ssh_session_token=[redacted:secret-assignment]
+ ssh_owner_nonce=_ssh_owner_nonce,
)
```
- `hermes_cli/subcommands/dashboard.py`
```diff
@@ -149,6 +149,20 @@ def build_dashboard_parser(
serve_parser.add_argument(
"--no-open", action="store_true", help=argparse.SUPPRESS
)
+ serve_parser.add_argument(
+ "--ssh-session-token-file",
+ dest="ssh_session_token_file",
+ metavar="PATH",
+ default=None,
+ help="Read a one-shot Desktop SSH session token from PATH",
+ )
+ serve_parser.add_argument(
+ "--ssh-owner-nonce",
+ dest="ssh_owner_nonce",
+ metavar="NONCE",
+ default=None,
+ help="Identify a Desktop-owned SSH backend process",
+ )
# `headless_backend` marks the lean path: desktop/remote clients speak pure
# JSON-RPC/WS, so `serve` skips the web UI build AND never serves the SPA
# (cmd_dashboard exports HERMES_SERVE_HEADLESS=1). `dashboard` leaves it
```
- `hermes_cli/web_server.py`
```diff
@@ -280,6 +280,18 @@ def _get_pty_active_session_files(app: "FastAPI") -> dict[str, Path]:
# ---------------------------------------------------------------------------
_SESSION_TOKEN = [redacted:secret-assignment]"HERMES_DASHBOARD_SESSION_TOKEN") or secrets.token_urlsafe(32)
_SESSION_HEADER_NAME = "X-Hermes-Session-Token"
+_SSH_OWNER_NONCE: Optional[str] = None
+
+
+def _apply_ssh_session_token(token: str) -> None:
+ global _SESSION_TOKEN
+ if token:
+ _SESSION_TOKEN = token
+
+
+def _apply_ssh_owner_nonce(nonce: Optional[str]) -> None:
+ global _SSH_OWNER_NONCE
+ _SSH_OWNER_NONCE = nonce
# In-browser Chat tab (/chat, /api/pty, /api/ws, …). Always enabled: the
# desktop app and the dashboard's own Chat tab both drive the agent over the
```
```diff
@@ -2774,6 +2786,14 @@ def _collect_profile_gateway_topology() -> Dict[str, Any]:
return {"profiles": profile_names, "gateway_mode": mode, "gateways": gateways}
[redacted:email]("/api/ssh/ownership")
+async def get_ssh_ownership(request: Request):
+ _require_token(request)
+ if not _SSH_OWNER_NONCE:
+ raise HTTPException(status_code=404, detail="SSH ownership is not active")
+ return {"ok": True, "sshOwnerNonce": _SSH_OWNER_NONCE, "protocolVersion": 1}
+
+
@app.get("/api/status")
async def get_status(profile: Optional[str] = None):
status_scope = None
```
```diff
@@ -19145,6 +19165,8 @@ def start_server(
allow_public: bool = False,
initial_profile: str = "",
headless: bool = False,
+ ssh_session_token: [redacted:secret-assignment] = None,
+ ssh_owner_nonce: Optional[str] = None,
):
"""Start the web UI server.
```
```diff
@@ -19156,7 +19178,13 @@ def start_server(
``headless`` is the ``serve`` path: the JSON-RPC/WS backend with no UI
build and no SPA mount (mount_spa() honours ``HERMES_SERVE_HEADLESS``), so
the banner announces the bind rather than a browser URL.
+
+ ``ssh_session_token`` and ``ssh_owner_nonce`` are process-local Desktop SSH
+ bootstrap state. Neither is persisted or exported to child processes.
"""
+ _apply_ssh_session_token(ssh_session_token or "")
+ _apply_ssh_owner_nonce(ssh_owner_nonce)
+
import uvicorn
try:
```
- `hermes_cli/windows_ssh_runtime.py`
```diff
@@ -0,0 +1,505 @@
+"""Native Windows trust boundary for Desktop SSH backend lifecycle."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any
+
+from hermes_constants import get_hermes_home
+
+_HEX32 = re.compile(r"[0-9a-f]{32}\Z")
+_HEX16 = re.compile(r"[0-9a-f]{16}\Z")
+_HEX64 = re.compile(r"[0-9a-f]{64}\Z")
+_MAX_JSON = 1024 * 1024
+_MAX_LOG = 512 * 1024
+_OPEN_REPARSE_POINT = 0x00200000
+_DELETE_ON_CLOSE = 0x04000000
+_MOVE_REPLACE_EXISTING = 0x00000001
+_MOVE_WRITE_THROUGH = 0x00000008
+
+
+def _win32() -> tuple[Any, ...]:
+ if sys.platform != "win32":
+ raise RuntimeError("Windows SSH runtime is only available on Windows")
+ import ntsecuritycon
+ import pywintypes
+ import win32api
+ import win32con
+ import win32file
+ import win32process
+ import win32security
+ return ntsecuritycon, pywintypes, win32api, win32con, win32file, win32process, win32security
+
+
+def _ownership(value: str) -> str:
+ if not _HEX32.fullmatch(value or ""):
+ raise ValueError("invalid ownership ID")
+ return value
+
+
+def _nonce(value: str) -> str:
+ if not _HEX16.fullmatch(value or ""):
+ raise ValueError("invalid spawn nonce")
+ return value
+
+
+def _root() -> Path:
+ return get_hermes_home() / "desktop-ssh"
+
+
+def _directory(ownership_id: str) -> Path:
+ return _root() / _ownership(ownership_id)
+
+
+def _token_path(ownership_id: str, spawn_nonce: str) -> Path:
+ return _directory(ownership_id) / f"{_nonce(spawn_nonce)}.token"
+
+
+def _log_path(ownership_id: str, spawn_nonce: str) -> Path:
+ return _directory(ownership_id) / f"{_nonce(spawn_nonce)}.log"
+
+
+def _lock_path(ownership_id: str) -> Path:
+ return _directory(ownership_id) / "backend.lock.json"
+
+
+def _current_sid():
+ _, _, win32api, win32con, _, _, win32security = _win32()
+ token = [redacted:secret-assignment] win32con.TOKEN_QUERY)
+ return win32security.GetTokenInformation(token, win32security.TokenUser)[0]
+
+
+def _system_sid():
+ return _win32()[6].ConvertStringSidToSid("S-1-5-18")
+
+
+def _security_attributes():
+ ntsecuritycon, _, _, _, _, _, win32security = _win32()
+ owner = _current_sid()
+ acl = win32security.ACL()
+ for sid in (owner, _system_sid()):
+ acl.AddAccessAllowedAceEx(win32security.ACL_REVISION, 0, ntsecuritycon.FILE_ALL_ACCESS, sid)
+ descriptor = win32security.SECURITY_DESCRIPTOR()
+ descriptor.SetSecurityDescriptorOwner(owner, False)
+ descriptor.SetSecurityDescriptorDacl(True, acl, False)
+ # Protect the DACL so inheritable parent ACEs (%LOCALAPPDATA% grants) are not merged in.
+ descriptor.SetSecurityDescriptorControl(win32security.SE_DACL_PROTECTED, win32security.SE_DACL_PROTECTED)
+ attributes = win32security.SECURITY_ATTRIBUTES()
+ attributes.SECURITY_DESCRIPTOR = descriptor
+ return attributes
+
+
+def _allowed_sids():
+ win32security = _win32()[6]
+ return {win32security.ConvertSidToStringSid(_current_sid()),
+ win32security.ConvertSidToStringSid(_system_sid())}
+
+
+def _verify_security(handle) -> None:
+ _, _, _, _, _, _, win32security = _win32()
+ info = win32security.OWNER_SECURITY_INFORMATION | win32security.DACL_SECURITY_INFORMATION
+ descriptor = win32security.GetSecurityInfo(handle, win32security.SE_FILE_OBJECT, info)
+ owner = descriptor.GetSecurityDescriptorOwner()
+ owner_value = win32security.ConvertSidToStringSid(owner)
+ if owner_value not in _allowed_sids():
+ raise OSError("Windows SSH runtime object has the wrong owner")
+ dacl = descriptor.GetSecurityDescriptorDacl()
+ if dacl is None:
+ raise OSError("Windows SSH runtime object has a null DACL")
+ allowed = _allowed_sids()
+ allow_types = {
+ win32security.ACCESS_ALLOWED_ACE_TYPE,
+ win32security.ACCESS_ALLOWED_OBJECT_ACE_TYPE,
+ getattr(win32security, "ACCESS_ALLOWED_CALLBACK_ACE_TYPE", 9),
+ getattr(win32security, "ACCESS_ALLOWED_CALLBACK_OBJECT_ACE_TYPE", 11),
+ }
+ for index in range(dacl.GetAceCount()):
+ ace = dacl.GetAce(index)
+ ace_type = ace[0][0]
+ mask = ace[1]
+ sid = ace[-1]
+ if ace_type in allow_types and mask:
+ if win32security.ConvertSidToStringSid(sid) not in allowed:
+ raise OSError("Windows SSH runtime object has a permissive DACL")
+
+
+def _open(path: Path, access: int, creation: int, flags: int, share: int = 0):
+ _, _, _, _, win32file, _, _ = _win32()
+ handle = win32file.CreateFile(str(path), access, share, _security_attributes(), creation, flags, None)
+ try:
+ actual = win32file.GetFinalPathNameByHandle(handle, 0)
+ if actual.startswith("\\\\?\\"):
+ actual = actual[4:]
+ expected = os.path.abspath(str(path))
+ if os.path.normcase(actual) != os.path.normcase(expected):
+ raise OSError("Windows SSH runtime handle escaped its expected path")
+ attributes = win32file.GetFileInformationByHandle(handle)[0]
+ if attributes & 0x400:
+ raise OSError("Windows SSH runtime path contains a reparse point")
+ _verify_security(handle)
+ return handle
+ except BaseException:
+ win32file.CloseHandle(handle)
+ raise
+
+
+def _ensure_directory(path: Path) -> None:
+ _, pywintypes, _, win32con, win32file, _, _ = _win32()
+ if path.parent != path:
+ _ensure_directory(path.parent) if path.parent not in (Path(path.anchor), path) and not path.parent.exists() else None
+ if not path.exists():
+ try:
+ win32file.CreateDirectory(str(path), _security_attributes())
+ except pywintypes.error as exc:
+ if exc.winerror != 183:
+ raise
+ handle = _open(path, win32con.GENERIC_READ | win32con.READ_CONTROL, win32con.OPEN_EXISTING,
+ win32con.FILE_FLAG_BACKUP_SEMANTICS | _OPEN_REPARSE_POINT,
+ win32con.FILE_SHARE_READ | win32con.FILE_SHARE_WRITE | win32con.FILE_SHARE_DELETE)
+ win32file.CloseHandle(handle)
+
+
+def _ensure_scope(ownership_id: str) -> Path:
+ root = _root()
+ _ensure_directory(root)
+ directory = _directory(ownership_id)
+ _ensure_directory(directory)
+ return directory
+
+
+def upload_token(ownership_id: str, spawn_nonce: str, token: [redacted:secret-assignment] -> dict[str, Any]:
+ _, _, _, win32con, win32file, _, _ = _win32()
+ if len(token) != 64 or not _HEX64.fullmatch(token.decode("ascii", errors="ignore")):
+ raise ValueError("invalid session token")
+ _ensure_scope(ownership_id)
+ path = _token_path(ownership_id, spawn_nonce)
+ try:
+ handle = _open(path, win32con.GENERIC_WRITE | win32con.READ_CONTROL, win32con.CREATE_NEW,
+ win32con.FILE_ATTRIBUTE_NORMAL | _OPEN_REPARSE_POINT)
+ try:
+ win32file.WriteFile(handle, token)
+ win32file.FlushFileBuffers(handle)
+ finally:
+ win32file.CloseHandle(handle)
+ except BaseException:
+ path.unlink(missing_ok=True)
+ raise
+ return {"path": str(path)}
+
+
+def read_token(path_value: str) -> str:
+ _, _, _, win32con, win32file, _, _ = _win32()
+ path = Path(path_value)
+ root = _root()
+ try:
+ relative = path.relative_to(root)
+ except ValueError as exc:
+ raise SystemExit("--ssh-session-token-file must be under the desktop-ssh directory") from exc
+ if len(relative.parts) != 2 or not _HEX32.fullmatch(relative.parts[0]) or not re.fullmatch(r"[0-9a-f]{16}\.token", relative.parts[1]):
+ raise SystemExit("--ssh-session-token-file has an invalid runtime path")
+ flags = win32con.FILE_ATTRIBUTE_NORMAL | _OPEN_REPARSE_POINT | _DELETE_ON_CLOSE
+ try:
+ handle = _open(path, win32con.GENERIC_READ | win32con.READ_CONTROL | win32con.DELETE,
+ win32con.OPEN_EXISTING, flags)
+ except Exception as exc:
+ raise SystemExit("--ssh-session-token-file is not accessible") from exc
+ try:
+ _, data = win32file.ReadFile(handle, 65)
+ finally:
+ win32file.CloseHandle(handle)
+ token = [redacted:secret-assignment]"ascii", errors="ignore")
+ if len(token) != 64 or not _HEX64.fullmatch(token):
+ raise SystemExit("--ssh-session-token-file contains an invalid token")
+ return token
+
+
+def _read_json_stdin() -> dict[str, Any]:
+ raw = sys.stdin.buffer.read(_MAX_JSON + 1)
+ if len(raw) > _MAX_JSON:
+ raise ValueError("runtime payload is too large")
+ parsed = json.loads(raw)
+ if not isinstance(parsed, dict):
+ raise ValueError("runtime payload must be an object")
+ return parsed
+
+
+def read_lock(ownership_id: str) -> dict[str, Any] | None:
+ _, pywintypes, _, win32con, win32file, _, _ = _win32()
+ _ensure_scope(ownership_id)
+ path = _lock_path(ownership_id)
+ try:
+ handle = _open(path, win32con.GENERIC_READ | win32con.READ_CONTROL, win32con.OPEN_EXISTING,
+ win32con.FILE_ATTRIBUTE_NORMAL | _OPEN_REPARSE_POINT,
+ win32con.FILE_SHARE_READ)
+ except pywintypes.error as exc:
+ if exc.winerror in (2, 3):
+ return None
+ raise
+ try:
+ _, data = win32file.ReadFile(handle, _MAX_JSON + 1)
+ finally:
+ win32file.CloseHandle(handle)
+ if len(data) > _MAX_JSON:
+ return None
+ try:
+ parsed = json.loads(data)
+ except (UnicodeDecodeError, json.JSONDecodeError):
+ return None
+ return parsed if isinstance(parsed, dict) else None
+
+
+def write_lock(ownership_id: str, payload: dict[str, Any]) -> None:
+ _, _, _, win32con, win32file, _, _ = _win32()
+ directory = _ensure_scope(ownership_id)
+ data = json.dumps(payload, separators=(",", ":")).encode()
+ if len(data) > _MAX_JSON:
+ raise ValueError("lock payload is too large")
+ temporary = directory / f".{os.urandom(8).hex()}.lock.tmp"
+ handle = _open(temporary, win32con.GENERIC_WRITE | win32con.READ_CONTROL, win32con.CREATE_NEW,
+ win32con.FILE_ATTRIBUTE_NORMAL | _OPEN_REPARSE_POINT)
+ try:
+ win32file.WriteFile(handle, data)
+ win32file.FlushFileBuffers(handle)
+ finally:
+ win32file.CloseHandle(handle)
+ win32file.MoveFileEx(str(temporary), str(_lock_path(ownership_id)),
+ _MOVE_REPLACE_EXISTING | _MOVE_WRITE_THROUGH)
+
+
+def remove_artifact(path: Path) -> bool:
+ _, pywintypes, _, win32con, win32file, _, _ = _win32()
+ try:
+ handle = _open(path, win32con.DELETE | win32con.READ_CONTROL, win32con.OPEN_EXISTING,
+ win32con.FILE_ATTRIBUTE_NORMAL | _OPEN_REPARSE_POINT | _DELETE_ON_CLOSE)
+ except pywintypes.error as exc:
+ if exc.winerror in (2, 3):
+ return False
+ raise
+ win32file.CloseHandle(handle)
+ return True
+
+
+def process_state(pid: int, creation_time_ns: int, hermes_path: str, spawn_nonce: str) -> dict[str, Any]:
+ import psutil
+ _nonce(spawn_nonce)
+ try:
+ process = psutil.Process(pid)
+ except psutil.NoSuchProcess as exc:
+ return {"alive": False, "owned": False, "indeterminate": False, "reason": type(exc).__name__}
+ try:
+ actual_creation = int(process.create_time() * 1_000_000_000)
+ argv = process.cmdline()
+ except psutil.NoSuchProcess as exc:
+ return {"alive": False, "owned": False, "indeterminate": False, "reason": type(exc).__name__}
+ except psutil.AccessDenied as exc:
+ return {"alive": True, "owned": False, "indeterminate": True, "reason": type(exc).__name__}
+ if actual_creation != creation_time_ns:
+ return {"alive": False, "owned": False, "indeterminate": False, "reason": "creation-time",
+ "actualCreationTimeNs": str(actual_creation), "expectedCreationTimeNs": str(creation_time_ns)}
+ if not argv:
+ return {"alive": True, "owned": False, "indeterminate": True, "reason": "argv-unavailable"}
+ expected = os.path.normcase(os.path.abspath(hermes_path))
+ arg0 = os.path.normcase(os.path.abspath(argv[0]))
+ # argv[0] is either the hermes exe directly, or (normal case) the base Python
+ # interpreter -- its exact path varies by venv/uv layout, so match on "a python
+ # running our module". We launch via `-c` bootstrap, so it shows as
+ # `-c `; also accept a plain `-m` launch.
+ # Identity is anchored by the unforgeable creation-time + secret owner-nonce below.
+ is_python = os.path.basename(arg0).startswith("python")
+ launches_module = (
+ argv[1:3] == ["-m", "hermes_cli.main"]
+ or (len(argv) > 2 and argv[1] == "-c" and "hermes_cli.main" in argv[2])
+ )
+ executable_match = arg0 == expected or (is_python and launches_module)
+ try:
+ serve = argv.index("serve")
+ owner = argv.index("--ssh-owner-nonce", serve + 1)
+ owned = executable_match and "--isolated" in argv[serve + 1:] and argv[owner + 1] == spawn_nonce
+ except (ValueError, IndexError):
+ owned = False
+ return {"alive": process.is_running(), "owned": owned, "indeterminate": False,
+ "creationTimeNs": str(actual_creation), "reason": "owned" if owned else "argv",
+ "argv": argv[:20], "expectedExecutable": expected}
+
+
+def terminate_owned(pid: int, creation_time_ns: int, hermes_path: str, spawn_nonce: str) -> bool:
+ state = process_state(pid, creation_time_ns, hermes_path, spawn_nonce)
+ if not state["alive"] or not state["owned"]:
+ return False
+ import psutil
+ process = psutil.Process(pid)
+ if int(process.create_time() * 1_000_000_000) != creation_time_ns:
+ return False
+ process.terminate()
+ try:
+ process.wait(5)
+ except psutil.TimeoutExpired:
+ process.kill()
+ process.wait(5)
+ return True
+
+
+def _resolve_direct_interpreter(python_entry: str) -> tuple[str, list[str]]:
+ """Resolve the venv launcher to the base interpreter it would exec, plus the
+ sys.path to reproduce. On Windows a venv Scripts\\python.exe is a launcher stub
+ that spawns the real interpreter as a CHILD (two PIDs); spawning the base
+ interpreter directly with the launcher's sys.path injected yields ONE process
+ that both owns the port and is the process we lock.
+
+ Also resolves hermes_cli's own location and prepends its parent, because the
+ launcher finds the module via cwd / an editable-install path hook that a bare
+ PYTHONPATH does not reproduce."""
+ query = (
+ "import sys,json,os,importlib.util as u;"
+ "s=u.find_spec('hermes_cli');"
+ "root=os.path.dirname(os.path.dirname(s.origin)) if s and s.origin else '';"
+ "print(json.dumps({'base':getattr(sys,'_base_executable','') or sys.executable,"
+ "'path':[p for p in sys.path if p],'root':root}))"
+ )
+ out = subprocess.run([python_entry, "-c", query], capture_output=True, text=True, timeout=30)
+ if out.returncode != 0:
+ raise ValueError("could not resolve the base Python interpreter")
+ info = json.loads(out.stdout.strip().splitlines()[-1])
+ base = info["base"]
+ if not base or not os.path.isfile(base):
+ raise ValueError("base Python interpreter was not found")
+ # drop editable-install finder markers ('__editable__.*.finder.__path_hook__')
+ # that PYTHONPATH cannot reproduce; keep only real filesystem entries.
+ py_path = [p for p in info.get("path", []) if os.path.exists(p)]
+ # the hermes_cli package parent must be explicit -- the launcher resolves it via
+ # cwd or an editable path hook, neither of which survives a bare PYTHONPATH spawn.
+ root = info.get("root") or ""
+ if root and os.path.isdir(root) and root not in py_path:
+ py_path.insert(0, root)
+ if not root or not os.path.isdir(root):
+ raise ValueError("could not locate the hermes_cli package")
+ return base, py_path
+
+
+def spawn_backend(payload: dict[str, Any]) -> dict[str, Any]:
+ ownership_id = _ownership(str(payload["ownershipId"]))
+ spawn_nonce = _nonce(str(payload["spawnNonce"]))
+ configured_path = str(payload["hermesPath"])
+ if not os.path.isabs(configured_path):
+ raise ValueError("Hermes path must be absolute")
+ hermes_path = os.path.abspath(configured_path)
+ token_path = [redacted:secret-assignment] spawn_nonce))
+ log_path = _log_path(ownership_id, spawn_nonce)
+ profile = str(payload.get("profile") or "")
+ if len(profile) > 256 or any(ch in profile for ch in "\x00\r\n"):
+ raise ValueError("invalid profile")
+ venv_dir = os.path.dirname(hermes_path)
+ python_entry = os.path.join(venv_dir, "python.exe")
+ if not os.path.isfile(python_entry):
+ raise ValueError("Hermes Python runtime was not found")
+ base_python, sys_path = _resolve_direct_interpreter(python_entry)
+ # Seed sys.path IN-PROCESS via a -c bootstrap rather than exporting PYTHONPATH:
+ # PYTHONPATH would be inherited by every subprocess the running backend spawns
+ # (terminal tool, user scripts), shadowing their imports. This keeps the path
+ # scoped to the backend process alone.
+ bootstrap = (
+ "import sys,runpy;"
+ f"sys.path[:0]={sys_path!r};"
+ "runpy.run_module('hermes_cli.main',run_name='__main__',alter_sys=True)"
+ )
+ args = [base_python, "-c", bootstrap]
+ if profile:
+ args.extend(["--profile", profile])
+ args.extend(["serve", "--isolated", "--host", "127.0.0.1", "--port", "0",
+ "--ssh-session-token-file", token_path, "--ssh-owner-nonce", spawn_nonce])
+ # VIRTUAL_ENV preserves venv identity; PYTHONPATH is deliberately NOT set (see above).
+ env = dict(os.environ)
+ env["VIRTUAL_ENV"] = os.path.dirname(venv_dir)
+ env.pop("PYTHONPATH", None)
+ _ensure_scope(ownership_id)
+ creationflags = 0x00000008 | 0x00000200 | 0x01000000
+ _, _, _, win32con, win32file, _, _ = _win32()
+ log_handle = _open(log_path, win32con.GENERIC_WRITE | win32con.READ_CONTROL,
+ win32con.CREATE_NEW, win32con.FILE_ATTRIBUTE_NORMAL | _OPEN_REPARSE_POINT,
+ win32con.FILE_SHARE_READ | win32con.FILE_SHARE_WRITE)
+ import msvcrt
+ log_fd = msvcrt.open_osfhandle(int(log_handle), os.O_WRONLY)
+ with os.fdopen(log_fd, "wb", buffering=0) as log_stream:
+ process = subprocess.Popen(args, stdin=subprocess.DEVNULL, stdout=log_stream, stderr=log_stream,
+ close_fds=True, creationflags=creationflags, env=env)
+ creation_time_ns = int(__import__("psutil").Process(process.pid).create_time() * 1_000_000_000)
+ return {"pid": process.pid, "creationTimeNs": str(creation_time_ns),
+ "logPath": str(log_path), "tokenPath": token_path}
+
+
+def inspect_hermes(hermes_path: str) -> dict[str, Any]:
+ path = os.path.abspath(hermes_path)
+ if not os.path.isabs(hermes_path) or not os.path.isfile(path):
+ raise ValueError("Hermes path is not an executable file")
+ version = subprocess.run([path, "--version"], capture_output=True, text=True, timeout=20)
+ help_result = subprocess.run([path, "serve", "--help"], capture_output=True, text=True, timeout=20)
+ help_text = help_result.stdout + help_result.stderr
+ return {
+ "path": path,
+ "version": (version.stdout + version.stderr).splitlines()[0] if version.returncode == 0 else "",
+ "supported": "--ssh-session-token-file" in help_text and "--ssh-owner-nonce" in help_text,
+ }
+
+
+def dispatch(argv: list[str]) -> Any:
+ if not argv:
+ raise ValueError("missing operation")
+ operation = argv[0]
+ if operation == "probe":
+ import platform
+ return {"os": "Windows", "arch": platform.machine(), "hermesHome": str(get_hermes_home()), "python": sys.executable}
+ if operation == "upload-token" and len(argv) == 3:
+ return upload_token(argv[1], argv[2], sys.stdin.buffer.read(65))
+ if operation == "read-lock" and len(argv) == 2:
+ return read_lock(argv[1])
+ if operation == "write-lock" and len(argv) == 2:
+ write_lock(argv[1], _read_json_stdin()); return {"ok": True}
+ if operation == "remove-lock" and len(argv) == 2:
+ return {"removed": remove_artifact(_lock_path(argv[1]))}
+ if operation == "remove-token" and len(argv) == 3:
+ return {"removed": remove_artifact(_token_path(argv[1], argv[2]))}
+ if operation == "read-log" and len(argv) == 3:
+ path = _log_path(argv[1], argv[2])
+ _, pywintypes, _, win32con, win32file, _, _ = _win32()
+ try:
+ handle = _open(path, win32con.GENERIC_READ | win32con.READ_CONTROL,
+ win32con.OPEN_EXISTING, win32con.FILE_ATTRIBUTE_NORMAL | _OPEN_REPARSE_POINT,
+ win32con.FILE_SHARE_READ | win32con.FILE_SHARE_WRITE)
+ except pywintypes.error as exc:
+ if exc.winerror in (2, 3):
+ return {"content": ""}
+ raise
+ try:
+ _, data = win32file.ReadFile(handle, _MAX_LOG)
+ finally:
+ win32file.CloseHandle(handle)
+ return {"content": data.decode(errors="replace")}
+ if operation == "remove-log" and len(argv) == 3:
+ return {"removed": remove_artifact(_log_path(argv[1], argv[2]))}
+ if operation == "spawn":
+ return spawn_backend(_read_json_stdin())
+ if operation == "inspect" and len(argv) == 2:
+ return inspect_hermes(argv[1])
+ if operation == "process-state" and len(argv) == 5:
+ return process_state(int(argv[1]), int(argv[2]), argv[3], argv[4])
+ if operation == "terminate" and len(argv) == 5:
+ return {"terminated": terminate_owned(int(argv[1]), int(argv[2]), argv[3], argv[4])}
+ raise ValueError("invalid operation")
+
+
+def main() -> None:
+ try:
+ print(json.dumps(dispatch(sys.argv[1:]), separators=(",", ":")))
+ except Exception as exc:
+ print(json.dumps({"error": str(exc)}, separators=(",", ":")), file=sys.stderr)
+ raise SystemExit(1)
+
+
+if __name__ == "__main__":
+ main()
```
- `pyproject.toml`
```diff
@@ -116,6 +116,10 @@ dependencies = [
"python-multipart>=0.0.9,<1",
"ptyprocess>=0.7.0,<1; sys_platform != 'win32'",
"pywinpty>=2.0.0,<3; sys_platform == 'win32'",
+ # Desktop SSH's Windows remote runtime (hermes_cli/windows_ssh_runtime.py)
+ # imports win32security/win32file/etc. directly — declare pywin32 rather than
+ # relying on the concurrent-log-handler → portalocker transitive chain.
+ "pywin32>=306,<312; sys_platform == 'win32'",
# Image resize recovery for the vision tools. Pillow shrinks oversized images
# (>5 MB or >8000px) at embed time; without it the byte AND pixel-dimension
# shrink paths no-op, so an oversized image bakes into immutable history and
```
- `tests/hermes_cli/test_ssh_ownership_endpoint.py`
```diff
@@ -0,0 +1,38 @@
+from fastapi.testclient import TestClient
+
+from hermes_cli import web_server
+
+
+def test_ssh_ownership_endpoint_requires_token_and_returns_exact_nonce(monkeypatch):
+ token = "t" * 64
+ nonce = "0123456789abcdef"
+ monkeypatch.setattr(web_server, "_SESSION_TOKEN", token)
+ monkeypatch.setattr(web_server, "_SSH_OWNER_NONCE", nonce)
+ web_server.app.state.auth_required = False
+ client = TestClient(web_server.app)
+
+ assert client.get("/api/ssh/ownership").status_code == 401
+ response = client.get(
+ "/api/ssh/ownership",
+ headers={"X-Hermes-Session-Token": token},
+ )
+ assert response.status_code == 200
+ assert response.json() == {
+ "ok": True,
+ "sshOwnerNonce": nonce,
+ "protocolVersion": 1,
+ }
+
+
+def test_ssh_ownership_endpoint_is_absent_without_owner_nonce(monkeypatch):
+ token = "t" * 64
+ monkeypatch.setattr(web_server, "_SESSION_TOKEN", token)
+ monkeypatch.setattr(web_server, "_SSH_OWNER_NONCE", None)
+ web_server.app.state.auth_required = False
+ client = TestClient(web_server.app)
+
+ response = client.get(
+ "/api/ssh/ownership",
+ headers={"X-Hermes-Session-Token": token},
+ )
+ assert response.status_code == 404
```
- `tests/hermes_cli/test_ssh_session_token_parser.py`
```diff
@@ -0,0 +1,94 @@
+import argparse
+import os
+
+import pytest
+from hermes_constants import set_hermes_home_override, reset_hermes_home_override
+
+from hermes_cli.main import _read_ssh_session_token_file, cmd_dashboard
+from hermes_cli.subcommands.dashboard import build_dashboard_parser
+
+
+def dashboard_parser():
+ parser = argparse.ArgumentParser()
+ subparsers = parser.add_subparsers(dest="command")
+ build_dashboard_parser(
+ subparsers,
+ cmd_dashboard=lambda _args: None,
+ cmd_dashboard_register=lambda _args: None,
+ )
+ return parser
+
+
+def test_serve_help_advertises_secure_ssh_bootstrap_flags(capsys):
+ with pytest.raises(SystemExit) as exit_info:
+ dashboard_parser().parse_args(["serve", "--help"])
+ assert exit_info.value.code == 0
+ output = capsys.readouterr().out
+ assert "--ssh-session-token-file PATH" in output
+ assert "--ssh-owner-nonce NONCE" in output
+
+
+def test_serve_accepts_owner_nonce():
+ args = dashboard_parser().parse_args(["serve", "--ssh-owner-nonce", "0123456789abcdef"])
+ assert args.ssh_owner_nonce == "0123456789abcdef"
+
+
[redacted:email]("operation", ["--status", "--stop"])
+def test_one_shot_token_file_rejects_non_starting_operations(operation):
+ args = dashboard_parser().parse_args([
+ "serve", operation, "--ssh-session-token-file", "/tmp/token",
+ ])
+ with pytest.raises(SystemExit, match="cannot be used"):
+ cmd_dashboard(args)
+
+
+def test_token_file_is_read_and_unlinked_through_private_directory(tmp_path, monkeypatch):
+ home = tmp_path / "home"
+ hermes_home = home / ".hermes"
+ token_dir = [redacted:secret-assignment] / "desktop-ssh" / ("a" * 32)
+ token_dir.mkdir(parents=True, mode=0o700)
+ token_path = [redacted:secret-assignment] / "0123456789abcdef.token"
+ token_path.write_text("b" * 64)
+ token_path.chmod(0o600)
+ override = set_hermes_home_override(hermes_home)
+ try:
+ assert _read_ssh_session_token_file(str(token_path)) == "b" * 64
+ assert not token_path.exists()
+ finally:
+ reset_hermes_home_override(override)
+
+
[redacted:email](os.name == "nt", reason="POSIX symlink contract")
+def test_token_file_rejects_symlink(tmp_path, monkeypatch):
+ home = tmp_path / "home"
+ token_dir = home / ".hermes" / "desktop-ssh" / ("a" * 32)
+ token_dir.mkdir(parents=True, mode=0o700)
+ target = tmp_path / "token"
+ target.write_text("b" * 64)
+ target.chmod(0o600)
+ token_path = [redacted:secret-assignment] / "0123456789abcdef.token"
+ token_path.symlink_to(target)
+ override = set_hermes_home_override(home / ".hermes")
+ try:
+ with pytest.raises(SystemExit, match="symlink|not accessible"):
+ _read_ssh_session_token_file(str(token_path))
+ assert not token_path.exists()
+ assert target.read_text() == "b" * 64
+ finally:
+ reset_hermes_home_override(override)
+
+
+def test_token_file_rejects_parent_escape(tmp_path, monkeypatch):
+ home = tmp_path / "home"
+ token_root = home / ".hermes" / "desktop-ssh"
+ token_root.mkdir(parents=True, mode=0o700)
+ escaped = token_root.parent / "0123456789abcdef.token"
+ escaped.write_text("b" * 64)
+ escaped.chmod(0o600)
+ override = set_hermes_home_override(home / ".hermes")
+ try:
+ with pytest.raises(SystemExit, match="invalid runtime path"):
+ _read_ssh_session_token_file(str(token_root / ".." / escaped.name))
+ assert escaped.exists()
+ finally:
+ reset_hermes_home_override(override)
```
- `tests/test_web_server.py`
```diff
@@ -69,6 +69,22 @@ async def shutdown(self, sockets=None):
return captured
+def test_start_server_applies_process_local_ssh_bootstrap_state(monkeypatch):
+ captured = _stub_uvicorn(monkeypatch)
+
+ web_server.start_server(
+ host="127.0.0.1",
+ port=0,
+ open_browser=False,
+ ssh_session_token="s" * 64,
+ ssh_owner_nonce="0123456789abcdef",
+ )
+
+ assert web_server._SESSION_TOKEN == "s" * 64
+ assert web_server._SSH_OWNER_NONCE == "0123456789abcdef"
+ assert captured["port"] == 0
+
+
def test_start_server_disables_ws_ping_on_loopback(monkeypatch):
"""Loopback binds (the Desktop case) MUST disable uvicorn's protocol-level
keepalive ping so an event-loop stall can never trigger a false disconnect.
```
- `uv.lock`
```diff
@@ -1539,6 +1539,7 @@ dependencies = [
{ name = "pyjwt", extra = ["crypto"] },
{ name = "python-dotenv" },
{ name = "python-multipart" },
+ { name = "pywin32", marker = "sys_platform == 'win32'" },
{ name = "pywinpty", marker = "sys_platform == 'win32'" },
{ name = "pyyaml" },
{ name = "requests" },
```
```diff
@@ -1823,6 +1824,7 @@ requires-dist = [
{ name = "python-multipart", marker = "extra == 'web'", specifier = "==0.0.27" },
{ name = "python-telegram-bot", extras = ["webhooks"], marker = "extra == 'messaging'", specifier = "==22.6" },
{ name = "python-telegram-bot", extras = ["webhooks"], marker = "extra == 'termux'", specifier = "==22.6" },
+ { name = "pywin32", marker = "sys_platform == 'win32'", specifier = ">=306,<312" },
{ name = "pywinpty", marker = "sys_platform == 'win32'", specifier = ">=2.0.0,<3" },
{ name = "pyyaml", specifier = "==6.0.3" },
{ name = "qrcode", marker = "extra == 'dingtalk'", specifier = "==7.4.2" },
```
- **#73926: fix(desktop): resolve local plugin root independent of remote backend (#66899)**. merged to main · fix tier `verified`
- maintainer direction: category `merged`; implication `superseded`
- files: `apps/desktop/electron/main.ts`, `apps/desktop/electron/preload.ts`, `apps/desktop/src/app/settings/plugins-settings.tsx`, `apps/desktop/src/contrib/runtime-loader.test.ts`, `apps/desktop/src/contrib/runtime-loader.ts`, `apps/desktop/src/global.d.ts`
- **#39122: feat(desktop): remote workspace + terminal over SSH (#38671, #38369, #38464)**. closed without merge
- maintainer direction: category `implemented_elsewhere`; implication `superseded`; refs `#68130`, `#38671`, `#38369`, `#68130`, `#50707`, `#45893`
- **#42497: fix(desktop): skip remote session cwd in Files panel to prevent ENOENT**. closed without merge
- maintainer direction: category `superseded_by_pr`; implication `superseded`; refs `8878484f85192a0d443a4c856b8e9f424ac46d2c`
- **#43434: feat(desktop): browse remote backend files**. closed without merge
- maintainer direction: category `implemented_elsewhere`; implication `superseded`; refs `#42878`
- **#66911: fix(desktop): resolve local plugin root independent of remote backend (#66899)**. closed without merge
- maintainer direction: category `merged_via`; implication `superseded`; refs `#73926`
- **#68276: fix(desktop): load disk plugins from local Hermes home**. closed without merge
- maintainer direction: category `superseded_by_pr`; implication `superseded`; refs `eaecca4a71`, `#73926`, `#66911`, `#66152`
## Fix status
- Merged to main in PR #44326 (cited above). No release data is tracked. Verify downstream.
- Fix last verified (merged) `2026-07-29`.
- Subsystem: `apps/desktop`