hermes-agent/apps/desktop/electron/renderer-heap-flags.ts
Austin Pickett a35f600b8a fix(desktop): resolve the Windows ssh client instead of hard-coding System32 OpenSSH
All ssh spawns (the -G config probe, the ssh-config:resolve IPC, SSH
terminals, and SshConnection) now go through one pure resolver:
desktop.ssh_path in config.yaml, then System32 OpenSSH, then Git for
Windows' usr\bin\ssh.exe, then bare ssh. Non-Windows keeps bare ssh.

A failed local ssh -G probe is now tagged terminal: boot latches on the
failure overlay (naming the client and the ssh_path setting) instead of
re-driving the same probe every ~2s.

Fixes #103288
2026-09-29 22:56:15 -04:00

210 lines
7.4 KiB
TypeScript

// Renderer heap ceiling + `desktop.electron_flags` for packaged launches (#77311).
//
// Chromium only forwards `--js-flags` to renderer processes when the BROWSER
// process has the switch on its own command line before `ready`. The
// `hermes desktop` launcher appends `desktop.electron_flags` to argv, but a
// packaged app started from its Start-menu / .desktop entry never runs that
// launcher, so the config key was dead there and the renderer had no heap
// ceiling at all. This module is pure (no Electron import) so the switch
// planning is vitest-able; main.ts applies the result via app.commandLine.
export interface DesktopLaunchConfig {
electronFlags: string[]
rendererMaxOldSpaceMb: number
/** `desktop.renderer_accessibility`; unset when the key is absent or unreadable. */
rendererAccessibility?: boolean
/** `desktop.ssh_path`: explicit Windows ssh client (#103288); unset when absent. */
sshPath?: string
}
export interface PlannedSwitch {
name: string
value?: string
}
/**
* Read the two launch keys out of `config.yaml` text without a YAML parser
* (the main bundle ships none). Deliberately narrow: a top-level `desktop:`
* mapping with two-space-indented `electron_flags` (flow list, block list with
* four-space `- ` items, or one string) and `renderer_max_old_space_mb`
* (integer). Anything else keeps the defaults — a malformed config must never
* block the launch — but a `desktop:` block that clearly MEANT to set one of
* them and produced nothing warns once, because the failure is otherwise
* invisible (the app just launches with no heap ceiling). The supported shape
* is documented in `website/docs/user-guide/desktop.md`.
*/
export function readDesktopLaunchConfig(yamlText: string): DesktopLaunchConfig {
const out: DesktopLaunchConfig = { electronFlags: [], rendererMaxOldSpaceMb: 0 }
const lines = String(yamlText ?? '').split(/\r?\n/)
const start = lines.findIndex(line => /^desktop:\s*(#.*)?$/.test(line))
if (start < 0) {
return out
}
const unquote = (raw: string) => raw.trim().replace(/^(['"])(.*)\1$/, '$2')
const blockLines: string[] = []
const splitFlow = (raw: string) => raw.slice(1, -1).split(',').map(unquote).filter(Boolean)
for (let i = start + 1; i < lines.length; i += 1) {
const line = lines[i]
if (/^\S/.test(line)) {
break // next top-level key
}
blockLines.push(line)
const keyed = /^ {2}([a-z_]+):\s*(.*?)\s*$/.exec(line)
if (!keyed) {
continue
}
const [, key, rawValue] = keyed
const value = rawValue.replace(/\s+#.*$/, '')
if (key === 'ssh_path') {
// YAML double quotes escape backslashes ("C:\\Git\\usr\\bin\\ssh.exe");
// plain and single-quoted scalars keep them literally.
const doubleQuoted = /^"(.*)"$/.exec(value)
const sshPath = doubleQuoted ? doubleQuoted[1].replace(/\\\\/g, '\\') : unquote(value)
if (sshPath) {
out.sshPath = sshPath
}
} else if (key === 'renderer_accessibility') {
const word = unquote(value).toLowerCase()
if (['0', 'false', 'no', 'off', 'disabled'].includes(word)) {
out.rendererAccessibility = false
} else if (['1', 'true', 'yes', 'on', 'enabled'].includes(word)) {
out.rendererAccessibility = true
}
} else if (key === 'renderer_max_old_space_mb') {
const mb = Number.parseInt(unquote(value), 10)
out.rendererMaxOldSpaceMb = Number.isFinite(mb) && mb > 0 ? mb : 0
} else if (key === 'electron_flags') {
if (value.startsWith('[') && value.endsWith(']')) {
out.electronFlags = splitFlow(value)
} else if (value) {
out.electronFlags = unquote(value).split(/\s+/).filter(Boolean)
} else {
const items: string[] = []
for (let j = i + 1; j < lines.length; j += 1) {
const item = /^ {4}- (.*)$/.exec(lines[j])
if (!item) {
break
}
items.push(unquote(item[1]))
}
out.electronFlags = items.filter(Boolean)
}
}
}
if (out.electronFlags.length === 0 && out.rendererMaxOldSpaceMb === 0) {
// The parser is a deliberate subset, so a valid-YAML-but-unsupported shape
// (any indentation other than two-space keys / four-space `- ` items)
// yields nothing at all. Silence there reads as "the knob does not work";
// one line naming the supported shape is the difference between a five
// minute fix and a bug report.
const meantToSet = blockLines.some(line => /(electron_flags|renderer_max_old_space_mb)\s*:/.test(line))
if (meantToSet) {
console.warn(
'[hermes] config.yaml: desktop.electron_flags / desktop.renderer_max_old_space_mb were ignored — ' +
'the launch reader supports only two-space-indented keys under a top-level `desktop:` with ' +
'four-space `- ` list items (see the Desktop docs). Launching with Chromium defaults.'
)
}
}
return out
}
/**
* Plan the `app.commandLine.appendSwitch` calls for a launch.
*
* Every `--js-flags` source (an existing switch on `argv`, entries in
* `electron_flags`, and the typed `renderer_max_old_space_mb`) is MERGED into a
* single `js-flags` switch — appendSwitch replaces, so applying them one by
* one would silently drop all but the last. Other `--name[=value]` entries
* pass through as their own switches. Flags already present on `argv` are not
* re-applied (the `hermes desktop` launcher put them there).
*/
export function planLaunchSwitches(cfg: DesktopLaunchConfig, argv: readonly string[] = []): PlannedSwitch[] {
const jsFlagParts: string[] = []
const others: PlannedSwitch[] = []
const argvSwitches = new Set<string>()
const consider = (flag: string, fromArgv: boolean) => {
const match = /^--([^=\s]+)(?:=(.*))?$/.exec(flag.trim())
if (!match) {
return
}
const [, name, value] = match
if (name === 'js-flags') {
jsFlagParts.push(
...String(value ?? '')
.split(/\s+/)
.filter(Boolean)
)
return
}
if (fromArgv) {
argvSwitches.add(name)
} else if (!argvSwitches.has(name)) {
others.push(value === undefined ? { name } : { name, value })
}
}
for (let i = 0; i < argv.length; i += 1) {
const arg = String(argv[i] ?? '').trim()
const next = i + 1 < argv.length ? String(argv[i + 1] ?? '').trim() : ''
// `--name value` is as valid on a command line as `--name=value`. Scanning
// the two tokens independently dropped the value: `--js-flags
// --max-old-space-size=4096` registered a bare `js-flags` with no parts
// and a bogus `max-old-space-size` switch, so the config's ceiling
// replaced the launcher's instead of merging with it. `--js-flags` always
// takes a value (its own value is dash-prefixed), any other switch pairs
// only with a non-flag token.
const bareName = /^--([^=\s]+)$/.exec(arg)?.[1]
if (bareName && next && (bareName === 'js-flags' || !next.startsWith('-'))) {
consider(`${arg}=${next}`, true)
i += 1
continue
}
consider(arg, true)
}
for (const flag of cfg.electronFlags) {
consider(flag, false)
}
if (cfg.rendererMaxOldSpaceMb > 0 && !jsFlagParts.some(part => part.startsWith('--max-old-space-size='))) {
jsFlagParts.push(`--max-old-space-size=${Math.floor(cfg.rendererMaxOldSpaceMb)}`)
}
const planned = [...others]
if (jsFlagParts.length > 0) {
planned.push({ name: 'js-flags', value: Array.from(new Set(jsFlagParts)).join(' ') })
}
return planned
}