From 1dbf55e4df68df591ebfe2742e7d5e0b1dbfe93e Mon Sep 17 00:00:00 2001 From: Neil <4138956+nwparker@users.noreply.github.com> Date: Mon, 3 Aug 2026 00:50:20 -0700 Subject: [PATCH] Stop reporting supported Linux hosts as an unsupported remote platform (#12209) Co-authored-by: Orca --- .../ssh/ssh-remote-platform-detection.test.ts | 129 +++++++++++++++- src/main/ssh/ssh-remote-platform-detection.ts | 138 ++++++++++++++++-- 2 files changed, 252 insertions(+), 15 deletions(-) diff --git a/src/main/ssh/ssh-remote-platform-detection.test.ts b/src/main/ssh/ssh-remote-platform-detection.test.ts index 71fc4e7c0..aa3fb3a09 100644 --- a/src/main/ssh/ssh-remote-platform-detection.test.ts +++ b/src/main/ssh/ssh-remote-platform-detection.test.ts @@ -1,4 +1,4 @@ -import { beforeEach, describe, expect, it, vi } from 'vitest' +import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest' import type { SshConnection } from './ssh-connection' const execCommandMock = vi.hoisted(() => vi.fn()) @@ -16,9 +16,19 @@ function decodePowerShellCommand(command: string): string { return match ? Buffer.from(match[1], 'base64').toString('utf16le') : '' } +/** OpenSSH refuses session channels past MaxSessions with reason 2 + "open failed". */ +function maxSessionsError(): Error { + return Object.assign(new Error('(SSH) Channel open failure: open failed'), { reason: 2 }) +} + describe('detectRemoteHostPlatform', () => { beforeEach(() => { execCommandMock.mockReset() + vi.spyOn(console, 'warn').mockImplementation(() => {}) + }) + + afterEach(() => { + vi.restoreAllMocks() }) it('detects POSIX hosts from uname output', async () => { @@ -109,3 +119,120 @@ describe('detectRemoteHostPlatform', () => { expect(usedWhitespaceFieldSplit).toBe(false) }) }) + +describe('detectRemoteHostPlatform failure reporting', () => { + beforeEach(() => { + execCommandMock.mockReset() + vi.spyOn(console, 'warn').mockImplementation(() => {}) + }) + + afterEach(() => { + vi.restoreAllMocks() + }) + + it('does not misreport a refused exec channel as an unsupported platform', async () => { + execCommandMock.mockRejectedValue(maxSessionsError()) + + // The host is linux-x64 and fully supported; the probe never ran. + await expect(detectRemoteHostPlatform(conn)).rejects.toThrow(/open failed/iu) + await expect(detectRemoteHostPlatform(conn)).rejects.toMatchObject({ + cause: expect.objectContaining({ reason: 2 }) + }) + // Both probes run: the second gets a fresh session-channel retry budget. + expect(execCommandMock).toHaveBeenCalledTimes(4) + }) + + it('still detects Windows when the uname probe hits the session limit', async () => { + execCommandMock + .mockRejectedValueOnce(maxSessionsError()) + .mockResolvedValueOnce('__ORCA_REMOTE_PLATFORM__ Windows AMD64\r\n') + + await expect(detectRemoteHostPlatform(conn)).resolves.toMatchObject({ + relayPlatform: 'win32-x64' + }) + }) + + it('skips the second probe when the first channel never confirmed close', async () => { + const error = Object.assign(new Error('boom'), { sshChannelCloseConfirmed: false }) + execCommandMock.mockRejectedValueOnce(error) + + await expect(detectRemoteHostPlatform(conn)).rejects.toBe(error) + expect(execCommandMock).toHaveBeenCalledTimes(1) + }) + + it('skips the second probe when the first was cancelled', async () => { + const error = Object.assign(new Error('SSH operation was cancelled'), { name: 'AbortError' }) + execCommandMock.mockRejectedValueOnce(error) + + await expect(detectRemoteHostPlatform(conn)).rejects.toBe(error) + expect(execCommandMock).toHaveBeenCalledTimes(1) + }) + + it('prefers a refused channel over the other probe non-zero exit', async () => { + execCommandMock + .mockRejectedValueOnce(new Error('Command "sh -c ..." failed (exit 127): sh: not found')) + .mockRejectedValueOnce(maxSessionsError()) + + await expect(detectRemoteHostPlatform(conn)).rejects.toThrow(/open failed/u) + await expect(detectRemoteHostPlatform(conn)).rejects.not.toThrow(/exit 127/u) + }) + + it('prefers unrecognized uname output over a failed PowerShell probe', async () => { + execCommandMock + .mockResolvedValueOnce('__ORCA_REMOTE_PLATFORM__ Linux') + .mockRejectedValueOnce(new Error('powershell.exe: not found')) + + await expect(detectRemoteHostPlatform(conn)).rejects.toThrow(/__ORCA_REMOTE_PLATFORM__ Linux/u) + }) + + it('reports the raw probe output when a POSIX host yields no marker line', async () => { + // Restricted shell / ForceCommand: the probe command is swallowed, banner only. + execCommandMock.mockResolvedValue('Welcome to pc-server05\n') + + await expect(detectRemoteHostPlatform(conn)).rejects.toThrow(/pc-server05/u) + }) + + it('truncates a long banner in the thrown message but logs a longer tail', async () => { + execCommandMock.mockResolvedValue(`${'banner line\n'.repeat(500)}goodbye\n`) + const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {}) + + const error = await detectRemoteHostPlatform(conn).catch((err: Error) => err) + + expect(error).toBeInstanceOf(Error) + expect((error as Error).message).not.toContain('\n') + expect((error as Error).message.length).toBeLessThanOrEqual(300) + expect(String(warnSpy.mock.calls[0]?.[0]).length).toBeGreaterThan(600) + }) + + it('returns null when a parsed uname is genuinely unsupported', async () => { + execCommandMock + .mockResolvedValueOnce('__ORCA_REMOTE_PLATFORM__ FreeBSD x86_64\n') + .mockRejectedValueOnce(new Error('powershell.exe: not found')) + + await expect(detectRemoteHostPlatform(conn)).resolves.toBeNull() + }) + + it('does not call an unmappable uname unsupported when PowerShell was refused', async () => { + // Cygwin sh on a win32-x64 host: only PowerShell can settle it, and it never ran. + execCommandMock + .mockResolvedValueOnce('__ORCA_REMOTE_PLATFORM__ CYGWIN_NT-10.0 x86_64\n') + .mockRejectedValueOnce(maxSessionsError()) + + const error = await detectRemoteHostPlatform(conn).catch((err: unknown) => err) + + expect(error).toBeInstanceOf(Error) + expect((error as Error).message).toMatch(/open failed/iu) + expect((error as Error).message).not.toMatch(/unsupported/iu) + expect((error as Error).cause).toMatchObject({ reason: 2 }) + }) + + it('falls through to PowerShell for a Cygwin uname it cannot map', async () => { + execCommandMock + .mockResolvedValueOnce('__ORCA_REMOTE_PLATFORM__ CYGWIN_NT-10.0 x86_64\n') + .mockResolvedValueOnce('__ORCA_REMOTE_PLATFORM__ Windows AMD64\r\n') + + await expect(detectRemoteHostPlatform(conn)).resolves.toMatchObject({ + relayPlatform: 'win32-x64' + }) + }) +}) diff --git a/src/main/ssh/ssh-remote-platform-detection.ts b/src/main/ssh/ssh-remote-platform-detection.ts index 44c31e617..5f830fb74 100644 --- a/src/main/ssh/ssh-remote-platform-detection.ts +++ b/src/main/ssh/ssh-remote-platform-detection.ts @@ -5,27 +5,128 @@ import { } from '../../shared/process-output-field-scanner' import { parseUnameToRelayPlatform, type RelayPlatform } from './relay-protocol' import { execCommand } from './ssh-relay-deploy-helpers' +import { isUnconfirmedSshCommandTermination } from './ssh-relay-exec-command' +import { isSshSessionLimitError } from './ssh-session-limit-error' import { getRemoteHostPlatform, type RemoteHostPlatform } from './ssh-remote-platform' import { powerShellCommand } from './ssh-remote-powershell' const PLATFORM_PROBE_MARKER = '__ORCA_REMOTE_PLATFORM__' +const MAX_UNAME_FIELD_CHARS = 64 +const MAX_THROWN_OUTPUT_CHARS = 200 +const MAX_LOGGED_OUTPUT_CHARS = 1000 +const EXEC_TIMEOUT_MESSAGE = /timed out after \d+s$/u + +type PlatformProbeOutcome = + | { kind: 'detected'; platform: RelayPlatform } + | { kind: 'unsupported'; uname: string } + | { kind: 'unparsed'; output: string } + | { kind: 'failed'; error: unknown } export async function detectRemoteHostPlatform( conn: SshConnection, options?: { signal?: AbortSignal } ): Promise { - const unamePlatform = await detectUnamePlatform(conn, options?.signal) - if (unamePlatform) { - return getRemoteHostPlatform(unamePlatform) + const uname = await detectUnamePlatform(conn, options?.signal) + if (uname.kind === 'detected') { + return getRemoteHostPlatform(uname.platform) } - const windowsPlatform = await detectWindowsPlatform(conn, options?.signal) - return windowsPlatform ? getRemoteHostPlatform(windowsPlatform) : null + if (uname.kind === 'failed' && shouldAbandonAfterUnameProbe(uname.error)) { + throw uname.error + } + const windows = await detectWindowsPlatform(conn, options?.signal) + if (windows.kind === 'detected') { + return getRemoteHostPlatform(windows.platform) + } + // Why: only the PowerShell probe can settle a uname the parser cannot map + // (Cygwin, say), so a refused or timed-out channel leaves it unsettled. + const windowsProbeNeverRan = windows.kind === 'failed' && isTransportShapedError(windows.error) + if ((uname.kind === 'unsupported' && !windowsProbeNeverRan) || windows.kind === 'unsupported') { + const reported = uname.kind === 'unsupported' ? uname.uname : probeUname(windows) + console.warn(`[ssh-relay] Remote reported an unsupported platform: ${reported}`) + return null + } + console.warn( + `[ssh-relay] Remote platform detection failed (uname probe: ${uname.kind}, PowerShell probe: ${windows.kind}). ` + + `Remote output: "${summarizeProbeOutput(probeEvidence(uname) || probeEvidence(windows), MAX_LOGGED_OUTPUT_CHARS)}"` + ) + throw undetectedPlatformError(uname, windows) +} + +// Why: an unconfirmed close still holds the sshd session slot, so a second +// probe only burns another exec timeout before being refused too. +function shouldAbandonAfterUnameProbe(error: unknown): boolean { + return ( + (error instanceof Error && error.name === 'AbortError') || + isUnconfirmedSshCommandTermination(error) + ) +} + +/** Precedence: transport failure from either probe, then uname, then PowerShell. */ +function undetectedPlatformError( + uname: PlatformProbeOutcome, + windows: PlatformProbeOutcome +): Error { + for (const outcome of [uname, windows]) { + if (outcome.kind === 'failed' && isTransportShapedError(outcome.error)) { + return wrapProbeError(outcome.error) + } + } + if (uname.kind === 'failed') { + return wrapProbeError(uname.error) + } + if (uname.kind === 'unparsed') { + return unrecognizedOutputError(uname.output) + } + if (windows.kind === 'failed') { + return wrapProbeError(windows.error) + } + return unrecognizedOutputError(probeOutput(windows)) +} + +// Why: a refused or timed-out channel explains the failure better than the +// other probe's mundane non-zero exit (e.g. "sh: not found" on Windows). +function isTransportShapedError(error: unknown): boolean { + return ( + isSshSessionLimitError(error) || + isUnconfirmedSshCommandTermination(error) || + (error instanceof Error && EXEC_TIMEOUT_MESSAGE.test(error.message)) + ) +} + +function wrapProbeError(error: unknown): Error { + const message = error instanceof Error ? error.message : String(error) + return new Error(`Could not detect the remote platform: ${message}`, { cause: error }) +} + +function unrecognizedOutputError(output: string): Error { + return new Error( + `Remote platform probe returned no recognizable output. Remote output: "${summarizeProbeOutput(output, MAX_THROWN_OUTPUT_CHARS)}"` + ) +} + +function probeOutput(outcome: PlatformProbeOutcome): string { + return outcome.kind === 'unparsed' ? outcome.output : '' +} + +function probeUname(outcome: PlatformProbeOutcome): string { + return outcome.kind === 'unsupported' ? outcome.uname : '' +} + +function probeEvidence(outcome: PlatformProbeOutcome): string { + return probeOutput(outcome) || probeUname(outcome) +} + +// Why: the marker is printed last, so the tail holds the evidence; collapsing +// CR/LF keeps a Windows banner from becoming a multi-line renderer message. +function summarizeProbeOutput(output: string, maxChars: number): string { + const collapsed = output.replace(/\s+/gu, ' ').trim() + return collapsed.length > maxChars ? `…${collapsed.slice(-maxChars)}` : collapsed } async function detectUnamePlatform( conn: SshConnection, signal?: AbortSignal -): Promise { +): Promise { try { // Why: Remote startup output may omit its trailing newline and must not absorb the marker. const command = `printf '\\n%s ' '${PLATFORM_PROBE_MARKER}'; uname -sm` @@ -33,16 +134,16 @@ async function detectUnamePlatform( ? await execCommand(conn, command, { signal }) : await execCommand(conn, command) return parseRemotePlatformOutput(output) - } catch { + } catch (error) { signal?.throwIfAborted() - return null + return { kind: 'failed', error } } } async function detectWindowsPlatform( conn: SshConnection, signal?: AbortSignal -): Promise { +): Promise { try { const script = [ '$arch = $env:PROCESSOR_ARCHITECTURE', @@ -56,13 +157,14 @@ async function detectWindowsPlatform( ...(signal ? { signal } : {}) }) return parseRemotePlatformOutput(output) - } catch { + } catch (error) { signal?.throwIfAborted() - return null + return { kind: 'failed', error } } } -function parseRemotePlatformOutput(output: string): RelayPlatform | null { +function parseRemotePlatformOutput(output: string): PlatformProbeOutcome { + let unsupportedUname = '' // Why: SSH startup noise can resemble valid probe output and select the wrong relay. for (const line of iterateProcessOutputLines(output)) { const parts = getProcessOutputFields(line, 3) @@ -71,8 +173,16 @@ function parseRemotePlatformOutput(output: string): RelayPlatform | null { } const platform = parseUnameToRelayPlatform(parts[1], parts[2]) if (platform) { - return platform + return { kind: 'detected', platform } } + unsupportedUname = `${clampUnameField(parts[1])} ${clampUnameField(parts[2])}` } - return null + return unsupportedUname + ? { kind: 'unsupported', uname: unsupportedUname } + : { kind: 'unparsed', output } +} + +// Why: a single field can be kilobytes — the scanner reads up to 4096 chars. +function clampUnameField(field: string): string { + return field.length > MAX_UNAME_FIELD_CHARS ? `${field.slice(0, MAX_UNAME_FIELD_CHARS)}…` : field }