mirror of
https://github.com/NousResearch/hermes-agent.git
synced 2026-07-18 14:52:04 +00:00
9ff0ba0827
Two fixes to the Electron desktop launch path, with the port-reservation logic extracted into a unit-tested module:
1. hermes:bootstrap:reset ("Reload and retry") only cleared connectionPromise, leaving the live backend alive; the orphan kept binding PORT_FLOOR (9120) so the next startHermes() hit EADDRINUSE / "Object has been destroyed" and the window looped. Await teardownPrimaryBackendAndWait() so the reset stops the old backend before restarting.
2. pickPort() probes-then-closes a socket before the real bind happens in a separate Python child, so two concurrent spawns (primary + pool backend) could both be handed PORT_FLOOR and one died with EADDRINUSE. The reservation bookkeeping is extracted into electron/port-pool.cjs (PortPool): pickPort() reserves the chosen port until the child exits and releases it on every exit/error/throw-before-spawn path, closing the TOCTOU window.
PortPool is dependency-injected (probe passed in) and socket-free, unit-tested in electron/port-pool.test.cjs (8 cases) and wired into the test:desktop:platforms script.
(cherry picked from commit d4133945b9)
73 lines
2.4 KiB
JavaScript
73 lines
2.4 KiB
JavaScript
'use strict'
|
|
|
|
/**
|
|
* In-process port reservation pool for the desktop backend launcher.
|
|
*
|
|
* pickPort() probes a localhost port with a throwaway server and closes it
|
|
* before the real bind happens in a separate Python child. Between that probe
|
|
* and the child's bind there is a TOCTOU window: a second concurrent spawn
|
|
* (the primary backend racing a pool backend) can be handed the SAME port, and
|
|
* one then dies with EADDRINUSE ("address already in use" -> "Object has been
|
|
* destroyed" boot loop). Reserving the chosen port in THIS process until the
|
|
* child exits closes that window.
|
|
*
|
|
* The OS bind remains the source of truth; this only deconflicts racers inside
|
|
* this process — it can't stop a foreign squatter, which the probe + the
|
|
* EADDRINUSE self-heal still cover.
|
|
*
|
|
* The pool is dependency-injected (the availability probe is passed in) and
|
|
* free of Electron/Node socket I/O, so it is unit-tested without real sockets
|
|
* (see port-pool.test.cjs).
|
|
*/
|
|
class PortPool {
|
|
/**
|
|
* @param {number} floor inclusive lowest port to hand out
|
|
* @param {number} ceiling inclusive highest port to hand out
|
|
*/
|
|
constructor(floor, ceiling) {
|
|
this.floor = floor
|
|
this.ceiling = ceiling
|
|
this._reserved = new Set()
|
|
}
|
|
|
|
/** @returns {boolean} whether `port` is currently reserved in-process. */
|
|
has(port) {
|
|
return this._reserved.has(port)
|
|
}
|
|
|
|
/** Release a previously reserved port. No-op if it was not reserved. */
|
|
release(port) {
|
|
this._reserved.delete(port)
|
|
}
|
|
|
|
/** Drop all reservations. */
|
|
clear() {
|
|
this._reserved.clear()
|
|
}
|
|
|
|
/** @returns {number} count of currently reserved ports. */
|
|
get size() {
|
|
return this._reserved.size
|
|
}
|
|
|
|
/**
|
|
* Reserve and return the lowest port in [floor, ceiling] that is neither
|
|
* already reserved in-process nor rejected by `isAvailable(port)`, or null
|
|
* if every port is taken. `isAvailable` may be sync (boolean) or async
|
|
* (Promise<boolean>); it is awaited either way.
|
|
*
|
|
* @param {(port: number) => boolean | Promise<boolean>} isAvailable
|
|
* @returns {Promise<number|null>}
|
|
*/
|
|
async reserve(isAvailable) {
|
|
for (let port = this.floor; port <= this.ceiling; port += 1) {
|
|
if (this._reserved.has(port)) continue
|
|
if (!(await isAvailable(port))) continue
|
|
this._reserved.add(port)
|
|
return port
|
|
}
|
|
return null
|
|
}
|
|
}
|
|
|
|
module.exports = { PortPool }
|