fix(desktop): profile-rail fresh chats keep one exact session owner from create through every later RPC
selectProfile(name) / newSessionInProfile(name) keep only $newChatProfile and clear $newChatRoute. #94147 taught the send path to capture the (registry source, profile) pair as the draft's exact owner, but three gaps still let a session created on the composite gateway conn:local::omar degrade to the bare string "omar" — and requestGatewayForProfile("omar") is a DIFFERENT socket than the one that minted the runtime, so the next session-scoped RPC 4001'd "session not found" while the runtime was ws-orphan-reaped: 1. Ownership persistence. The exact owner lived only in the bounded, in-memory owner-hint map. The primary aggregate serves a `local` registry source's rows WITHOUT connection_id (the unified-list splice tags non-local sources only), and mergeSessionPage replaced the optimistic row with that untagged row on the first sidebar refresh. After a hint eviction or a relaunch nothing exact was left. - One canonical SessionOwnerRoute type (store/session-request-router); AgentProfileRoute / SessionProfileRoute / SessionRpcOwnerRoute alias it. - Every owner ladder gains the connection-tagged ROW rung (knownSessionOwner / sessionOwnerRouteFromRow): the session-RPC dispatcher, knownOwnerForSession, the tile delegate, foregroundSessionScopes and the async probe (resolveSessionOwner) all yield the exact route when the row carries its connection. - mergeSessionPage carries connection_id onto a row that comes back untagged for the same profile (merge, don't clobber). - Owner hints are persisted (bounded LRU, hermes.desktop.sessionOwnerHints.v1) and rehydrated in LRU order; a removed registry connection drops its hints (use-gateway-boot onChanged) so fail-closed can't pin sessions to a dead source. 2. Fail closed. A request carrying session_id whose owner no rung could name silently fell to the ambient presentation gateway, turning missing metadata into a misleading backend "session not found". createSessionRpcDispatcher and requestForOwnedSession now reject with an explicit SessionOwnerResolutionError (store/session-owner-resolution). The ONE case where ambient is the owner by construction stays ambient: no registry source live AND at most one profile (legacy single-backend Desktop, whose older backends omit `profile` on rows). Main-pane runtime ids (native approval.respond, queued sends) now translate to their stored id through the per-runtime state mirror (storedSessionIdForRuntimeId), so they resolve an owner instead of tripping the gate. 3. Lifecycle. Between session.create returning and the foreground publication ($selectedStoredSessionId via navigate → route effect, or $sessionTiles), the owner entry had no active request and was not yet foreground-pinned: a prune recompute or a refcount-0 lease release could close the socket holding the just-minted runtime before the first prompt.submit. Both create paths now hold retainGatewayForAgent across the create RPC and hand off to holdSessionOwnerUntilForeground (session-states), which names the owner in foregroundSessionScopes — every registry dispose path honors it — until the session becomes selected/tiled, the caller releases it (failed create, mid-create drift close), or a 60s TTL expires. Nothing latches. Regressions: - profile-rail-fresh-chat-owner.test.tsx: new case evicts the hint AND merges an untagged refresh row after turn one; turn two still rides the same conn:local::omar socket, no probe, no session.close, no v1 socket; the existing case also asserts the owner is foreground-pinned from create. - session-rpc-dispatcher.test.ts (new): fail-closed error + ambient never called; legacy single-backend stays ambient; tagged-row rung routes by runtime id; hint outranks untagged row; probe result routes exactly. - session.test.ts: persisted hints survive a simulated relaunch in LRU order, malformed storage is ignored, per-connection forget; knownSessionOwner; mergeSessionPage carries / drops / preserves identity on connection_id. - session-states-foreground-scopes.test.ts: tagged-row scope for the selected thread; hold pins from create, retires on selection / tile mount, explicit release, TTL expiry. - session-states-runtime-map.test.ts: state-mirror rung; knownOwnerForSession through mirror + hint / tagged row; requestForOwnedSession fail-closed vs legacy ambient. - wiring-routing.test.ts: connection-tagged row rung; hint still outranks it. Stacked on #94145, #94147 and #94178 (merged as the integration base); review from this commit. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
This commit is contained in:
@@ -10,7 +10,7 @@ import type { SessionResumeResponse } from '@/types/hermes'
|
||||
import type { usePromptActions } from '../../session/hooks/use-prompt-actions'
|
||||
import { singleFlightSessionResume } from '../../session/hooks/use-prompt-actions/single-flight-resume'
|
||||
import { markSessionRecentlyInterrupted, withSessionNotFoundResume } from '../../session/hooks/use-prompt-actions/utils'
|
||||
import { resolveSessionProfile } from '../../session/hooks/use-session-actions/utils'
|
||||
import { resolveSessionOwner } from '../../session/hooks/use-session-actions/utils'
|
||||
import type { useSessionStateCache } from '../../session/hooks/use-session-state-cache'
|
||||
import type { GatewayRequester } from '../types'
|
||||
|
||||
@@ -74,11 +74,14 @@ export function useSessionTileDelegate({
|
||||
}
|
||||
}
|
||||
|
||||
// Same ladder as the window's session-RPC dispatcher: tile route → the
|
||||
// row's owner (exact when connection-tagged, else the hint / profile) →
|
||||
// the async cross-profile probe (exact when the resolved row is tagged).
|
||||
const ownerForStoredSession = async (storedSessionId: string): Promise<SessionOwnerScope> => {
|
||||
const owner =
|
||||
sessionTileOwnerRoute(storedSessionId) ??
|
||||
knownSessionOwner($sessions.get(), storedSessionId) ??
|
||||
(await resolveSessionProfile(storedSessionId))
|
||||
(await resolveSessionOwner(storedSessionId))
|
||||
|
||||
return owner
|
||||
}
|
||||
|
||||
@@ -0,0 +1,150 @@
|
||||
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
|
||||
|
||||
// Fail-closed owner resolution for the window's ONE session-scoped RPC
|
||||
// dispatcher. A request that names a session whose owner NO rung can name
|
||||
// (tile route → exact hint → connection-tagged / profiled row → REST probe)
|
||||
// must not ride the ambient presentation socket: "active" has no routing
|
||||
// authority, and the fallback turned missing ownership metadata into a
|
||||
// misleading backend "session not found". The single exception is the legacy
|
||||
// single-backend Desktop (no registry source, ≤1 profile), where the ambient
|
||||
// gateway IS the owner by construction.
|
||||
|
||||
const gatewayMocks = vi.hoisted(() => ({
|
||||
activeConnectionId: null as null | string,
|
||||
requestGatewayForAgent: vi.fn(async () => ({ routed: true })),
|
||||
requestGatewayForProfile: vi.fn(async () => ({ profiled: true }))
|
||||
}))
|
||||
|
||||
vi.mock('@/store/gateway', async importActual => ({
|
||||
...(await importActual<Record<string, unknown>>()),
|
||||
activeGatewayConnectionId: () => gatewayMocks.activeConnectionId,
|
||||
requestGatewayForAgent: gatewayMocks.requestGatewayForAgent,
|
||||
requestGatewayForProfile: gatewayMocks.requestGatewayForProfile
|
||||
}))
|
||||
|
||||
const probe = vi.hoisted(() => ({ resolveSessionOwner: vi.fn(async () => undefined as unknown) }))
|
||||
|
||||
vi.mock('@/app/session/hooks/use-session-actions/utils', async importActual => ({
|
||||
...(await importActual<Record<string, unknown>>()),
|
||||
resolveSessionOwner: probe.resolveSessionOwner
|
||||
}))
|
||||
|
||||
const { createSessionRpcDispatcher } = await import('./session-rpc-dispatcher')
|
||||
const { $profiles } = await import('@/store/profile')
|
||||
const { _resetSessionOwnerHintsForTests, setSessionOwnerHint, setSessions } = await import('@/store/session')
|
||||
const { isSessionOwnerResolutionError } = await import('@/store/session-owner-resolution')
|
||||
const { $sessionTiles } = await import('@/store/session-states')
|
||||
const { makeSessionInfo } = await import('@/test/session-info')
|
||||
|
||||
function dispatcher(ambientRequest = vi.fn(async () => ({ ambient: true }))) {
|
||||
return {
|
||||
ambientRequest,
|
||||
request: createSessionRpcDispatcher({
|
||||
ambientRequest: ambientRequest as never,
|
||||
runtimeIdByStoredSessionIdRef: { current: new Map([['stored-omar', 'rt-omar']]) },
|
||||
selectedStoredSessionIdRef: { current: null },
|
||||
sessionStateByRuntimeIdRef: { current: new Map() }
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
beforeEach(() => {
|
||||
gatewayMocks.activeConnectionId = 'local'
|
||||
$profiles.set([{ name: 'default' }, { name: 'omar' }] as never)
|
||||
probe.resolveSessionOwner.mockResolvedValue(undefined)
|
||||
})
|
||||
|
||||
afterEach(() => {
|
||||
setSessions([])
|
||||
$sessionTiles.set([])
|
||||
$profiles.set([])
|
||||
_resetSessionOwnerHintsForTests({ storage: true })
|
||||
vi.clearAllMocks()
|
||||
})
|
||||
|
||||
describe('createSessionRpcDispatcher: fail closed', () => {
|
||||
it('rejects with an explicit owner-resolution error instead of riding the ambient socket', async () => {
|
||||
const { ambientRequest, request } = dispatcher()
|
||||
|
||||
await expect(request('prompt.submit', { session_id: 'rt-orphan', text: 'hi' })).rejects.toSatisfy(
|
||||
isSessionOwnerResolutionError
|
||||
)
|
||||
await expect(request('prompt.submit', { session_id: 'rt-orphan', text: 'hi' })).rejects.toThrow(
|
||||
/owner could not be resolved for "rt-orphan" \(prompt.submit\)/
|
||||
)
|
||||
|
||||
expect(probe.resolveSessionOwner).toHaveBeenCalledWith('rt-orphan')
|
||||
expect(ambientRequest).not.toHaveBeenCalled()
|
||||
expect(gatewayMocks.requestGatewayForAgent).not.toHaveBeenCalled()
|
||||
expect(gatewayMocks.requestGatewayForProfile).not.toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('still lets a request with NO session (ambient chrome) reach the ambient socket', async () => {
|
||||
const { ambientRequest, request } = dispatcher()
|
||||
|
||||
await expect(request('config.get', {})).resolves.toEqual({ ambient: true })
|
||||
expect(ambientRequest).toHaveBeenCalledWith('config.get', {})
|
||||
})
|
||||
|
||||
it('keeps the legacy single-backend Desktop on the ambient socket: no registry source, one profile', async () => {
|
||||
gatewayMocks.activeConnectionId = null
|
||||
$profiles.set([{ name: 'default' }] as never)
|
||||
const { ambientRequest, request } = dispatcher()
|
||||
|
||||
await expect(request('session.resume', { session_id: 'stored-legacy' })).resolves.toEqual({ ambient: true })
|
||||
expect(ambientRequest).toHaveBeenCalledWith('session.resume', { session_id: 'stored-legacy' })
|
||||
})
|
||||
|
||||
it('fails closed as soon as there is somewhere to misroute to: a second profile, or a live registry source', async () => {
|
||||
gatewayMocks.activeConnectionId = null
|
||||
$profiles.set([{ name: 'default' }, { name: 'omar' }] as never)
|
||||
await expect(dispatcher().request('session.resume', { session_id: 'stored-x' })).rejects.toSatisfy(
|
||||
isSessionOwnerResolutionError
|
||||
)
|
||||
|
||||
gatewayMocks.activeConnectionId = 'local'
|
||||
$profiles.set([{ name: 'default' }] as never)
|
||||
await expect(dispatcher().request('session.resume', { session_id: 'stored-x' })).rejects.toSatisfy(
|
||||
isSessionOwnerResolutionError
|
||||
)
|
||||
})
|
||||
})
|
||||
|
||||
describe('createSessionRpcDispatcher: exact owner rungs', () => {
|
||||
it('routes by the connection-tagged row when the hint is gone (runtime id translated to the stored id)', async () => {
|
||||
setSessions([makeSessionInfo({ connection_id: 'local', id: 'stored-omar', profile: 'omar' })])
|
||||
const { ambientRequest, request } = dispatcher()
|
||||
|
||||
await expect(request('prompt.submit', { session_id: 'rt-omar', text: 'again' })).resolves.toEqual({ routed: true })
|
||||
|
||||
expect(gatewayMocks.requestGatewayForAgent).toHaveBeenCalledWith('local', 'omar', 'prompt.submit', {
|
||||
session_id: 'rt-omar',
|
||||
text: 'again'
|
||||
})
|
||||
expect(ambientRequest).not.toHaveBeenCalled()
|
||||
expect(probe.resolveSessionOwner).not.toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('prefers the exact hint over an untagged row profile, and the probe result over nothing', async () => {
|
||||
setSessions([makeSessionInfo({ id: 'stored-omar', profile: 'default' })])
|
||||
setSessionOwnerHint('stored-omar', { connectionId: 'local', profile: 'omar' })
|
||||
|
||||
await expect(dispatcher().request('session.interrupt', { session_id: 'rt-omar' })).resolves.toEqual({
|
||||
routed: true
|
||||
})
|
||||
expect(gatewayMocks.requestGatewayForAgent).toHaveBeenLastCalledWith('local', 'omar', 'session.interrupt', {
|
||||
session_id: 'rt-omar'
|
||||
})
|
||||
|
||||
_resetSessionOwnerHintsForTests()
|
||||
setSessions([])
|
||||
probe.resolveSessionOwner.mockResolvedValue({ connectionId: 'homelab', profile: 'worker' })
|
||||
|
||||
await expect(dispatcher().request('session.activate', { session_id: 'stored-hidden' })).resolves.toEqual({
|
||||
routed: true
|
||||
})
|
||||
expect(gatewayMocks.requestGatewayForAgent).toHaveBeenLastCalledWith('homelab', 'worker', 'session.activate', {
|
||||
session_id: 'stored-hidden'
|
||||
})
|
||||
})
|
||||
})
|
||||
@@ -23,15 +23,20 @@
|
||||
*
|
||||
* Session-scoped RPCs route to the backend that OWNS the session — never to
|
||||
* whatever is "active" (active is presentation only). The owner ladder is
|
||||
* resolveSessionRpcOwner (tile route → exact unique owner hint → row profile),
|
||||
* then a cross-profile REST probe for a hidden/unlisted session. Only a
|
||||
* request with NO session at all falls to the ambient socket.
|
||||
* resolveSessionRpcOwner (tile route → exact unique owner hint → the row's
|
||||
* owner: exact when connection-tagged, else its profile), then a
|
||||
* cross-profile REST probe for a hidden/unlisted session. A request with a
|
||||
* session whose owner STILL cannot be named fails closed with an explicit
|
||||
* SessionOwnerResolutionError rather than riding the ambient socket (the one
|
||||
* exception: the legacy single-backend Desktop, where ambient IS the owner).
|
||||
* Only a request with NO session at all falls to the ambient socket.
|
||||
*/
|
||||
import type { MutableRefObject } from 'react'
|
||||
|
||||
import { resolveSessionProfile } from '@/app/session/hooks/use-session-actions/utils'
|
||||
import { resolveSessionOwner } from '@/app/session/hooks/use-session-actions/utils'
|
||||
import type { ClientSessionState } from '@/app/types'
|
||||
import { $sessions, getSessionOwnerHint, knownSessionOwner } from '@/store/session'
|
||||
import { assertSessionOwnerResolved } from '@/store/session-owner-resolution'
|
||||
import { requestForSessionProfile, type SessionOwnerScope } from '@/store/session-request-router'
|
||||
import { $focusedStoredSessionId, sessionTileOwnerRoute, storedSessionIdForRuntimeId } from '@/store/session-states'
|
||||
|
||||
@@ -78,16 +83,20 @@ export function createSessionRpcDispatcher(deps: SessionRpcDispatcherDeps): Ambi
|
||||
if (!owner && routingSessionId) {
|
||||
// Unknown owner for a REAL session: probe across profiles (REST, not the
|
||||
// gateway socket, so no recursion) rather than defaulting to active. A
|
||||
// hit stamps ownership + caches a hint; a miss leaves owner undefined
|
||||
// and the request falls to ambient, exactly as an unroutable session did
|
||||
// before — but only after we tried, never as a silent active fallback.
|
||||
const probed = await resolveSessionProfile(routingSessionId)
|
||||
// hit stamps ownership on the row (exact when the row came back
|
||||
// connection-tagged); a miss leaves owner undefined.
|
||||
const probed = await resolveSessionOwner(routingSessionId)
|
||||
|
||||
if (probed) {
|
||||
owner = probed
|
||||
}
|
||||
}
|
||||
|
||||
// A request that names a session but whose owner nobody can name must not
|
||||
// ride the ambient socket: that turns missing metadata into a misleading
|
||||
// backend "session not found" on a backend that never held the runtime.
|
||||
assertSessionOwnerResolved(owner, { method, sessionId: paramSessionId ? routingSessionId : null })
|
||||
|
||||
return requestForSessionProfile<T>(owner, ambientRequest, method, params ?? {}, timeoutMs, signal)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -118,6 +118,31 @@ describe('resolveSessionRpcOwner', () => {
|
||||
expect(owner).toEqual(omar)
|
||||
})
|
||||
|
||||
it('reconstructs the EXACT owner from a connection-tagged row when the hint is gone (evicted / relaunch)', () => {
|
||||
// The bounded hint map is transient. A row tagged with its owning
|
||||
// connection (optimistic create row, unified-list splice, or a tag
|
||||
// mergeSessionPage carried across a refresh) names the same registry
|
||||
// entry, so the second turn still dials the socket that holds the runtime.
|
||||
expect(
|
||||
resolveSessionRpcOwner({
|
||||
routingSessionId: 'stored-omar',
|
||||
sessionOwnerHint: none,
|
||||
sessionRowOwner: () => ({ connectionId: 'local', profile: 'omar' }),
|
||||
tileOwnerRoute: none
|
||||
})
|
||||
).toEqual({ connectionId: 'local', profile: 'omar' })
|
||||
|
||||
// The hint still outranks the row when both exist.
|
||||
expect(
|
||||
resolveSessionRpcOwner({
|
||||
routingSessionId: 'stored-omar',
|
||||
sessionOwnerHint: () => omar,
|
||||
sessionRowOwner: () => ({ connectionId: 'homelab', profile: 'omar' }),
|
||||
tileOwnerRoute: none
|
||||
})
|
||||
).toEqual(omar)
|
||||
})
|
||||
|
||||
it('falls back to the session row profile, then to undefined for the probe', () => {
|
||||
expect(
|
||||
resolveSessionRpcOwner({
|
||||
@@ -136,5 +161,14 @@ describe('resolveSessionRpcOwner', () => {
|
||||
tileOwnerRoute: none
|
||||
})
|
||||
).toBeUndefined()
|
||||
|
||||
expect(
|
||||
resolveSessionRpcOwner({
|
||||
routingSessionId: 'stored-1',
|
||||
sessionOwnerHint: none,
|
||||
sessionRowOwner: () => null,
|
||||
tileOwnerRoute: none
|
||||
})
|
||||
).toBeUndefined()
|
||||
})
|
||||
})
|
||||
|
||||
@@ -5,6 +5,8 @@
|
||||
* React/Electron controller module.
|
||||
*/
|
||||
|
||||
import type { SessionOwnerRoute } from '@/store/session-request-router'
|
||||
|
||||
/**
|
||||
* Resolve a runtime session id back to its stored id by reverse-scanning the
|
||||
* stored->runtime binding map — the same ladder use-session-tile-delegate's
|
||||
@@ -51,14 +53,8 @@ export function resolveRoutingSessionId(args: {
|
||||
|
||||
/** The owner shapes the ladder below can return: an exact route (connection +
|
||||
* profile), a bare profile name, or undefined (unknown — probe, never
|
||||
* "active"). Structural twin of store/session-request-router's
|
||||
* SessionOwnerScope, kept local so this module stays import-free. */
|
||||
export interface SessionRpcOwnerRoute {
|
||||
connectionId: string
|
||||
mode?: 'local' | 'remote'
|
||||
profile: string
|
||||
targetProfile?: string
|
||||
}
|
||||
* "active"). The type-only import keeps this module runtime-import-free. */
|
||||
export type SessionRpcOwnerRoute = SessionOwnerRoute
|
||||
|
||||
/**
|
||||
* The SYNC owner a session-scoped RPC routes to, resolved in this order:
|
||||
@@ -66,21 +62,23 @@ export interface SessionRpcOwnerRoute {
|
||||
* 1. the persisted tile owner route (a bot chat / split tile records the
|
||||
* exact connectionId + profile it was opened with, survives relaunch);
|
||||
* 2. the exact, UNIQUE session owner hint (recorded the moment a routed
|
||||
* session.create returns, or at plugin open time) — the only durable
|
||||
* exact owner a fresh main-pane chat or a hidden session has;
|
||||
* session.create returns, or at plugin open time; persisted, bounded);
|
||||
* 3. the session row's owner — an EXACT route when the row is
|
||||
* connection-tagged (optimistic row from a routed create, or the
|
||||
* unified list splice), else its bare profile (the cross-profile
|
||||
* aggregator tags rows, but a bare profile loses the connection and
|
||||
* can lag the create);
|
||||
* 4. undefined → the caller runs the cross-profile probe.
|
||||
* connection-tagged (optimistic row from a routed create, the unified
|
||||
* list splice, or a tag carried across a refresh), else its bare
|
||||
* profile (the cross-profile aggregator tags rows, but a bare profile
|
||||
* loses the connection and can lag the create);
|
||||
* 4. undefined → the caller runs the cross-profile probe, and fails closed
|
||||
* if that misses too.
|
||||
*
|
||||
* The hint outranks the row because the row is presentation state that can
|
||||
* be stamped from the AMBIENT profile (an optimistic row minted while
|
||||
* All-profiles / Bot routing left `default` active), and because it carries
|
||||
* no connection: a fresh chat created on `local::omar` whose row read
|
||||
* `default` ran its first turn on omar and then 4001'd "session not found"
|
||||
* on the second, when the row's `default` owner won the route.
|
||||
* on the second, when the row's `default` owner won the route. The
|
||||
* connection-tagged row rung is what keeps two-turn continuity from resting
|
||||
* on the transient hint alone (bounded, evictable, gone after a relaunch).
|
||||
*/
|
||||
export function resolveSessionRpcOwner(args: {
|
||||
routingSessionId: null | string
|
||||
|
||||
@@ -54,8 +54,10 @@ import {
|
||||
$activeSessionId,
|
||||
$connection,
|
||||
$currentCwd,
|
||||
$selectedStoredSessionId,
|
||||
$sessions,
|
||||
ensureDefaultWorkspaceCwd,
|
||||
forgetSessionOwnerHintsForConnection,
|
||||
setConnection,
|
||||
setCurrentBranch,
|
||||
setCurrentCwd,
|
||||
@@ -672,6 +674,11 @@ export function useGatewayBoot({
|
||||
// (connectionId, profile) keep-set so two sources exposing the same
|
||||
// profile name (every source has a 'default') can't collide.
|
||||
configureGatewayRegistry({
|
||||
// Every dispose path in the registry (live-work pruner AND the
|
||||
// refcount-0 request leases) spares a socket a mounted tile, the
|
||||
// primary thread or a just-created session's owner hold is bound to
|
||||
// (#93892).
|
||||
foregroundScopes: foregroundSessionScopes,
|
||||
onActiveConnectionChanged: publish,
|
||||
// Keep $activeGatewayProfile in lockstep with the registry's OWN record
|
||||
// of which profile the active socket serves. The registry is the only
|
||||
@@ -770,6 +777,13 @@ export function useGatewayBoot({
|
||||
}
|
||||
|
||||
disposeSecondariesForConnection(payload.connectionId, { redial: payload.reason === 'updated' })
|
||||
|
||||
if (payload.reason !== 'updated') {
|
||||
// Nothing can dial the removed source again: drop the persisted exact
|
||||
// owner hints naming it so its sessions are not pinned (fail-closed)
|
||||
// to a route that no longer exists.
|
||||
forgetSessionOwnerHintsForConnection(payload.connectionId)
|
||||
}
|
||||
})
|
||||
|
||||
const onOnline = () => void forceReconnectNow()
|
||||
@@ -821,6 +835,11 @@ export function useGatewayBoot({
|
||||
keep.add(scope)
|
||||
}
|
||||
|
||||
// A just-created session's owner hold and every open pane's owner ride
|
||||
// in through foregroundSessionScopes above; the registry ALSO reads that
|
||||
// set itself (its `foregroundScopes` hook) so the refcount-0 lease
|
||||
// releases agree with this pruner. This recompute only has to RUN when
|
||||
// they change — see the tile / selected session / hold subscriptions.
|
||||
pruneSecondaryGateways(keep)
|
||||
}
|
||||
|
||||
@@ -830,6 +849,7 @@ export function useGatewayBoot({
|
||||
const offSessionTiles = $sessionTiles.subscribe(() => recomputeKeptGateways())
|
||||
const offActiveProfile = $activeGatewayProfile.subscribe(() => recomputeKeptGateways())
|
||||
const offTiles = $sessionTiles.subscribe(() => recomputeKeptGateways())
|
||||
const offSelectedSession = $selectedStoredSessionId.subscribe(() => recomputeKeptGateways())
|
||||
|
||||
const offWindowState = desktop.onWindowStateChanged?.(payload => {
|
||||
const current = $connection.get()
|
||||
@@ -1027,6 +1047,7 @@ export function useGatewayBoot({
|
||||
offSessionTiles()
|
||||
offActiveProfile()
|
||||
offTiles()
|
||||
offSelectedSession()
|
||||
window.removeEventListener('online', onOnline)
|
||||
document.removeEventListener('visibilitychange', onVisible)
|
||||
window.removeEventListener('focus', onFocus)
|
||||
|
||||
@@ -26,7 +26,9 @@ import {
|
||||
$activeSessionId,
|
||||
$selectedStoredSessionId,
|
||||
$sessions,
|
||||
_resetSessionOwnerHintsForTests,
|
||||
getSessionOwnerHint,
|
||||
mergeSessionPage,
|
||||
sessionMatchesStoredId,
|
||||
setActiveSessionId,
|
||||
setAwaitingResponse,
|
||||
@@ -35,6 +37,8 @@ import {
|
||||
setSelectedStoredSessionId,
|
||||
setSessions
|
||||
} from '@/store/session'
|
||||
import { foregroundSessionScopes } from '@/store/session-states'
|
||||
import type { SessionInfo } from '@/types/hermes'
|
||||
|
||||
import type { ClientSessionState } from '../../types'
|
||||
|
||||
@@ -64,7 +68,7 @@ import { useSessionStateCache } from './use-session-state-cache'
|
||||
// The explicit `local` source (This device) is different by design: a profile
|
||||
// pick made there takes the legacy profile-only door (ensureGatewayProfile,
|
||||
// so a per-profile remote override still resolves), and the draft's owner is
|
||||
// that v1 profile socket — the second case pins that the same one-socket
|
||||
// that v1 profile socket — the last case pins that the same one-socket
|
||||
// continuity holds there too.
|
||||
//
|
||||
// This suite drives the ACTUAL code path: the real registry store with mocked
|
||||
@@ -344,6 +348,7 @@ describe('profile rail: a fresh Omar chat keeps its exact registry owner across
|
||||
$newChatProfile.set(null)
|
||||
$newChatRoute.set(null)
|
||||
$newChatConnectionId.set(null)
|
||||
_resetSessionOwnerHintsForTests({ storage: true })
|
||||
})
|
||||
|
||||
afterEach(() => {
|
||||
@@ -360,7 +365,10 @@ describe('profile rail: a fresh Omar chat keeps its exact registry owner across
|
||||
delete (window as unknown as { hermesDesktop?: unknown }).hermesDesktop
|
||||
})
|
||||
|
||||
it('session.create and both prompt.submit calls ride the SAME conn:homelab::omar socket', async () => {
|
||||
/** Boot the exact field state: remote primary on `default`, `homelab` as
|
||||
* the active registry source, then selectProfile("omar") in the rail; mount
|
||||
* the window's real hook stack over the production dispatcher. */
|
||||
async function bootProfileRailOmar() {
|
||||
// Primary / ambient source: a remote gateway on `default`.
|
||||
const primary = makePrimary()
|
||||
setPrimaryGateway(primary as never, 'default')
|
||||
@@ -396,8 +404,32 @@ describe('profile rail: a fresh Omar chat keeps its exact registry owner across
|
||||
render(<Harness ambientRequest={ambientRequest as never} onReady={h => (handle = h)} />)
|
||||
await waitFor(() => expect(handle).not.toBeNull())
|
||||
|
||||
return { handle: handle!, omarSocket: omarSocket!, primary }
|
||||
}
|
||||
|
||||
/** What the gateway's stream end does: the turn settles. */
|
||||
async function settleTurn(handle: HarnessHandle) {
|
||||
await act(async () => {
|
||||
handle.updateSessionState(RUNTIME_ID, state => ({
|
||||
...state,
|
||||
awaitingResponse: false,
|
||||
busy: false,
|
||||
streamId: null,
|
||||
turnStartedAt: null
|
||||
}))
|
||||
handle.busyRef.current = false
|
||||
setBusy(false)
|
||||
setAwaitingResponse(false)
|
||||
})
|
||||
}
|
||||
|
||||
const calls = (socket: MockGateway) => socket.request.mock.calls.map(call => call[0] as string)
|
||||
|
||||
it('session.create and both prompt.submit calls ride the SAME conn:homelab::omar socket', async () => {
|
||||
const { handle, omarSocket, primary } = await bootProfileRailOmar()
|
||||
|
||||
// Turn one: no session yet → createBackendSessionForSend → prompt.submit.
|
||||
await expect(handle!.submitText('first prompt')).resolves.toBe(true)
|
||||
await expect(handle.submitText('first prompt')).resolves.toBe(true)
|
||||
await waitFor(() => expect($activeSessionId.get()).toBe(RUNTIME_ID))
|
||||
|
||||
// The stored↔runtime binding minted by the create must survive the first
|
||||
@@ -405,35 +437,28 @@ describe('profile rail: a fresh Omar chat keeps its exact registry owner across
|
||||
// (null) stored id, which the state cache read as a detach — after which
|
||||
// no session-scoped RPC could translate the runtime id back to the stored
|
||||
// id, so tile route / owner hint / row were all bypassed.
|
||||
expect(handle!.bindings()).toEqual({ runtimeForStored: RUNTIME_ID, storedForRuntime: STORED_ID })
|
||||
expect(handle.bindings()).toEqual({ runtimeForStored: RUNTIME_ID, storedForRuntime: STORED_ID })
|
||||
|
||||
// Answer one arrives: the turn settles (what the gateway's stream end does).
|
||||
await act(async () => {
|
||||
handle!.updateSessionState(RUNTIME_ID, state => ({
|
||||
...state,
|
||||
awaitingResponse: false,
|
||||
busy: false,
|
||||
streamId: null,
|
||||
turnStartedAt: null
|
||||
}))
|
||||
handle!.busyRef.current = false
|
||||
setBusy(false)
|
||||
setAwaitingResponse(false)
|
||||
})
|
||||
// From the moment the create returned, the owner socket is foreground-
|
||||
// pinned (owner hold → selected-thread rung) so no prune / lease release
|
||||
// can close it before the first prompt.submit lands.
|
||||
expect(foregroundSessionScopes()).toContain(omarScope)
|
||||
|
||||
// Answer one arrives: the turn settles.
|
||||
await settleTurn(handle)
|
||||
|
||||
// Turn two on the now-existing session.
|
||||
await expect(handle!.submitText('second prompt')).resolves.toBe(true)
|
||||
expect(handle!.bindings()).toEqual({ runtimeForStored: RUNTIME_ID, storedForRuntime: STORED_ID })
|
||||
await expect(handle.submitText('second prompt')).resolves.toBe(true)
|
||||
expect(handle.bindings()).toEqual({ runtimeForStored: RUNTIME_ID, storedForRuntime: STORED_ID })
|
||||
|
||||
// Every session-scoped RPC (create + both submits) hit ONE socket: the
|
||||
// registry entry conn:homelab::omar that minted the runtime.
|
||||
const calls = (socket: MockGateway) => socket.request.mock.calls.map(call => call[0] as string)
|
||||
const omarCalls = calls(omarSocket!)
|
||||
const omarCalls = calls(omarSocket)
|
||||
|
||||
expect(omarCalls).toContain('session.create')
|
||||
expect(omarCalls.filter(method => method === 'prompt.submit')).toHaveLength(2)
|
||||
expect(
|
||||
omarSocket!.request.mock.calls
|
||||
omarSocket.request.mock.calls
|
||||
.filter(call => call[0] === 'prompt.submit')
|
||||
.map(call => [(call[1] as { session_id: string }).session_id, (call[1] as { text: string }).text])
|
||||
).toEqual([
|
||||
@@ -476,6 +501,66 @@ describe('profile rail: a fresh Omar chat keeps its exact registry owner across
|
||||
expect($newChatConnectionId.get()).toBe(SOURCE_ID)
|
||||
})
|
||||
|
||||
it('turn two still rides conn:homelab::omar after the transient hint is evicted AND a refresh returned the row untagged', async () => {
|
||||
const { handle, omarSocket, primary } = await bootProfileRailOmar()
|
||||
|
||||
await expect(handle.submitText('first prompt')).resolves.toBe(true)
|
||||
await waitFor(() => expect($activeSessionId.get()).toBe(RUNTIME_ID))
|
||||
await settleTurn(handle)
|
||||
|
||||
// The two things that used to leave only a bare "omar" behind:
|
||||
// 1. the bounded owner-hint map evicts (or the app relaunched);
|
||||
// 2. the sidebar refresh comes back with the row untagged (the primary
|
||||
// aggregate serves a source's rows as plain profile rows whenever the
|
||||
// unified-list splice did not tag them).
|
||||
_resetSessionOwnerHintsForTests()
|
||||
expect(getSessionOwnerHint(STORED_ID)).toBeUndefined()
|
||||
|
||||
const untagged: SessionInfo = {
|
||||
...$sessions.get().find(session => sessionMatchesStoredId(session, STORED_ID))!,
|
||||
profile: 'omar'
|
||||
}
|
||||
|
||||
delete untagged.connection_id
|
||||
setSessions(prev => mergeSessionPage(prev, [untagged], []))
|
||||
|
||||
// The row still names the exact owner: the refresh carried the tag.
|
||||
expect($sessions.get().find(session => sessionMatchesStoredId(session, STORED_ID))).toMatchObject({
|
||||
connection_id: SOURCE_ID,
|
||||
profile: 'omar'
|
||||
})
|
||||
|
||||
await expect(handle.submitText('second prompt')).resolves.toBe(true)
|
||||
expect(handle.bindings()).toEqual({ runtimeForStored: RUNTIME_ID, storedForRuntime: STORED_ID })
|
||||
|
||||
expect(
|
||||
omarSocket.request.mock.calls
|
||||
.filter(call => call[0] === 'prompt.submit')
|
||||
.map(call => (call[1] as { session_id: string; text: string }).text)
|
||||
).toEqual(['first prompt', 'second prompt'])
|
||||
|
||||
// Nothing session-scoped reached the primary, a v1 "omar" socket, or any
|
||||
// other socket; no REST probe, no session.close, no second create.
|
||||
expect(calls(primary).filter(method => method === 'session.create' || method === 'prompt.submit')).toEqual([])
|
||||
expect(sockets.some(socket => socket.connectUrl?.includes(`:${V1_PORT}`))).toBe(false)
|
||||
|
||||
for (const socket of sockets) {
|
||||
if (socket !== omarSocket) {
|
||||
expect(
|
||||
socket.request.mock.calls.filter(call => sessionScoped(call[1]) || call[0] === 'session.create')
|
||||
).toEqual([])
|
||||
}
|
||||
}
|
||||
|
||||
expect(vi.mocked(getSession)).not.toHaveBeenCalled()
|
||||
|
||||
for (const socket of [primary, ...sockets]) {
|
||||
expect(calls(socket).filter(method => method === 'session.close')).toEqual([])
|
||||
}
|
||||
|
||||
expect(calls(omarSocket).filter(method => method === 'session.create')).toHaveLength(1)
|
||||
})
|
||||
|
||||
it('a pick on the explicit `local` source is a legacy profile pick: create and both turns ride the ONE v1 omar socket', async () => {
|
||||
const primary = makePrimary()
|
||||
setPrimaryGateway(primary as never, 'default')
|
||||
@@ -540,8 +625,6 @@ describe('profile rail: a fresh Omar chat keeps its exact registry owner across
|
||||
|
||||
// The legacy owner is the bare profile: no registry route, no hint — the
|
||||
// row's profile names the same v1 pool entry that minted the runtime.
|
||||
const calls = (socket: MockGateway) => socket.request.mock.calls.map(call => call[0] as string)
|
||||
|
||||
expect(calls(v1Socket!).filter(method => method === 'session.create')).toHaveLength(1)
|
||||
expect(
|
||||
v1Socket!.request.mock.calls
|
||||
|
||||
@@ -102,7 +102,8 @@ vi.mock('@/store/profile', async importOriginal => ({
|
||||
vi.mock('@/store/gateway', async importOriginal => ({
|
||||
...(await importOriginal<Record<string, unknown>>()),
|
||||
requestGatewayForAgent: vi.fn(),
|
||||
requestGatewayForProfile: vi.fn()
|
||||
requestGatewayForProfile: vi.fn(),
|
||||
retainGatewayForAgent: vi.fn(async () => () => undefined)
|
||||
}))
|
||||
|
||||
vi.mock('@/components/pane-shell/tree/store', async importOriginal => ({
|
||||
|
||||
@@ -22,7 +22,12 @@ import { setSessionYolo } from '@/lib/yolo-session'
|
||||
import { $clarifyRequests } from '@/store/clarify'
|
||||
import { migrateSessionDraft } from '@/store/composer'
|
||||
import { clearQueuedPrompts, migrateQueuedPrompts } from '@/store/composer-queue'
|
||||
import { openGatewayForAgent, openGatewayForProfile, requestGatewayForAgent } from '@/store/gateway'
|
||||
import {
|
||||
openGatewayForAgent,
|
||||
openGatewayForProfile,
|
||||
requestGatewayForAgent,
|
||||
retainGatewayForAgent
|
||||
} from '@/store/gateway'
|
||||
import { $gatewaySwitching } from '@/store/gateway-switch'
|
||||
import { $pinnedSessionIds } from '@/store/layout'
|
||||
import { clearNotifications, notify, notifyError } from '@/store/notifications'
|
||||
@@ -94,9 +99,11 @@ import {
|
||||
$sessionTiles,
|
||||
closeSessionTile,
|
||||
dropSessionState,
|
||||
holdSessionOwnerUntilForeground,
|
||||
openSessionTile,
|
||||
patchSessionTile,
|
||||
publishSessionState,
|
||||
releaseSessionOwnerHold,
|
||||
type SessionTileWorkspaceScope,
|
||||
type TileDock
|
||||
} from '@/store/session-states'
|
||||
@@ -484,28 +491,49 @@ export function useSessionActions({
|
||||
const capturedRoute = resolveNewChatOwnerRoute()
|
||||
const params = await desktopSessionCreateParams(cwd, capturedRoute)
|
||||
|
||||
const created = capturedRoute
|
||||
? await requestGatewayForAgent<SessionCreateResponse>(
|
||||
capturedRoute.connectionId,
|
||||
capturedRoute.profile,
|
||||
'session.create',
|
||||
params
|
||||
)
|
||||
: await requestGateway<SessionCreateResponse>('session.create', params)
|
||||
// Lease the owner socket for the whole create → owner-publication
|
||||
// sequence (#93602 primitive). The per-request lease inside
|
||||
// requestGatewayForAgent ends when session.create returns; the
|
||||
// foreground hold below takes over from that point until the created
|
||||
// chat is selected. Between the two, nothing may close the socket
|
||||
// that just minted the runtime.
|
||||
const releaseCreateLease = capturedRoute
|
||||
? await retainGatewayForAgent(capturedRoute.connectionId, capturedRoute.profile)
|
||||
: () => undefined
|
||||
|
||||
const stored = created.stored_session_id ?? null
|
||||
let created: SessionCreateResponse
|
||||
let stored: null | string
|
||||
|
||||
// Record the EXACT owner the moment a routed create returns a stored
|
||||
// id — before the drift check, the optimistic row, navigation, or any
|
||||
// session-scoped RPC can resolve this session's owner. The route is
|
||||
// the only authority: in All-profiles / Bot routing the ambient
|
||||
// $activeGatewayProfile stays on `default` while the session lives on
|
||||
// `capturedRoute` (e.g. local::omar). Without this hint the optimistic
|
||||
// row (stamped from ambient) was the only owner record, so the first
|
||||
// turn ran on omar and every later session-scoped RPC resolved the row
|
||||
// as `default` and 4001'd "session not found".
|
||||
if (stored && capturedRoute) {
|
||||
setSessionOwnerHint(stored, capturedRoute)
|
||||
try {
|
||||
created = capturedRoute
|
||||
? await requestGatewayForAgent<SessionCreateResponse>(
|
||||
capturedRoute.connectionId,
|
||||
capturedRoute.profile,
|
||||
'session.create',
|
||||
params
|
||||
)
|
||||
: await requestGateway<SessionCreateResponse>('session.create', params)
|
||||
|
||||
stored = created.stored_session_id ?? null
|
||||
|
||||
// Record the EXACT owner the moment a routed create returns a stored
|
||||
// id — before the drift check, the optimistic row, navigation, or any
|
||||
// session-scoped RPC can resolve this session's owner. The route is
|
||||
// the only authority: in All-profiles / Bot routing the ambient
|
||||
// $activeGatewayProfile stays on `default` while the session lives on
|
||||
// `capturedRoute` (e.g. local::omar). Without this hint the optimistic
|
||||
// row (stamped from ambient) was the only owner record, so the first
|
||||
// turn ran on omar and every later session-scoped RPC resolved the row
|
||||
// as `default` and 4001'd "session not found".
|
||||
if (stored && capturedRoute) {
|
||||
setSessionOwnerHint(stored, capturedRoute)
|
||||
// Pin the owner socket until the foreground publication (route →
|
||||
// $selectedStoredSessionId) covers it, so a prune or lease release
|
||||
// in that gap cannot close the runtime before the first prompt.
|
||||
holdSessionOwnerUntilForeground(stored, capturedRoute)
|
||||
}
|
||||
} finally {
|
||||
releaseCreateLease()
|
||||
}
|
||||
|
||||
// Only a genuine move to a DIFFERENT chat mid-create should orphan the
|
||||
@@ -538,6 +566,10 @@ export function useSessionActions({
|
||||
|
||||
await closeCreated.catch(() => undefined)
|
||||
|
||||
if (stored) {
|
||||
releaseSessionOwnerHold(stored)
|
||||
}
|
||||
|
||||
return null
|
||||
}
|
||||
|
||||
@@ -655,16 +687,38 @@ export function useSessionActions({
|
||||
...(workspaceScope.workspaceMode === 'bots' ? { hidden: true } : {})
|
||||
}
|
||||
|
||||
const created = capturedRoute
|
||||
? await requestGatewayForAgent<SessionCreateResponse>(
|
||||
capturedRoute.connectionId,
|
||||
capturedRoute.profile,
|
||||
'session.create',
|
||||
params
|
||||
)
|
||||
: await requestGateway<SessionCreateResponse>('session.create', params)
|
||||
// Same lease chain as createBackendSessionForSend: owner socket held
|
||||
// across the create, then the foreground hold carries it until the
|
||||
// tile is mounted ($sessionTiles names the owner from then on).
|
||||
const releaseCreateLease = capturedRoute
|
||||
? await retainGatewayForAgent(capturedRoute.connectionId, capturedRoute.profile)
|
||||
: () => undefined
|
||||
|
||||
const stored = created.stored_session_id
|
||||
let created: SessionCreateResponse
|
||||
let stored: string | undefined
|
||||
|
||||
try {
|
||||
created = capturedRoute
|
||||
? await requestGatewayForAgent<SessionCreateResponse>(
|
||||
capturedRoute.connectionId,
|
||||
capturedRoute.profile,
|
||||
'session.create',
|
||||
params
|
||||
)
|
||||
: await requestGateway<SessionCreateResponse>('session.create', params)
|
||||
|
||||
stored = created.stored_session_id
|
||||
|
||||
if (stored && capturedRoute) {
|
||||
// Same ownership transition as createBackendSessionForSend: the
|
||||
// route that minted the session is its exact owner from this
|
||||
// moment on, and its socket stays pinned until the tile mounts.
|
||||
setSessionOwnerHint(stored, capturedRoute)
|
||||
holdSessionOwnerUntilForeground(stored, capturedRoute)
|
||||
}
|
||||
} finally {
|
||||
releaseCreateLease()
|
||||
}
|
||||
|
||||
if (!stored) {
|
||||
const closeCreated = capturedRoute
|
||||
@@ -681,12 +735,6 @@ export function useSessionActions({
|
||||
|
||||
createdThisRun.add(stored)
|
||||
|
||||
// Same ownership transition as createBackendSessionForSend: the route
|
||||
// that minted the session is its exact owner from this moment on.
|
||||
if (capturedRoute) {
|
||||
setSessionOwnerHint(stored, capturedRoute)
|
||||
}
|
||||
|
||||
// Seed the per-runtime cache so the tile renders immediately without a
|
||||
// redundant resume. Only add the row to the SIDEBAR when `listed` — an
|
||||
// unlisted (draft) tab stays out of the session list until its first
|
||||
|
||||
@@ -37,6 +37,7 @@ import type { SessionProfileRoute } from '@/store/session-request-router'
|
||||
// Re-exported for the many session-actions/tile call sites that already import
|
||||
// it from here; the canonical definition lives in @/store/session.
|
||||
export { sessionMatchesStoredId }
|
||||
import { sessionOwnerRouteFromRow, type SessionOwnerScope } from '@/store/session-request-router'
|
||||
import { reportBackendContract, reportInstallMethodWarning } from '@/store/updates'
|
||||
import type { SessionCreateResponse, SessionInfo, SessionResumeResponse, SessionRuntimeInfo } from '@/types/hermes'
|
||||
|
||||
@@ -1506,6 +1507,25 @@ export async function resolveSessionProfile(storedSessionId: null | string): Pro
|
||||
return profile || undefined
|
||||
}
|
||||
|
||||
/**
|
||||
* The OWNER of a stored session through the same cache → active-backend →
|
||||
* cross-profile ladder, preferring the EXACT route when the resolved row is
|
||||
* connection-tagged (unified-list splice, optimistic create row, a carried
|
||||
* tag) over its bare profile. Session-scoped RPC dispatch uses this as the
|
||||
* async rung after the sync ladder (tile route → hint → row) misses, so a
|
||||
* registry-owned session never degrades to a profile-only route that dials a
|
||||
* different socket than the one holding its runtime.
|
||||
*/
|
||||
export async function resolveSessionOwner(storedSessionId: null | string): Promise<SessionOwnerScope> {
|
||||
if (!storedSessionId) {
|
||||
return undefined
|
||||
}
|
||||
|
||||
const row = await resolveStoredSession(storedSessionId)
|
||||
|
||||
return sessionOwnerRouteFromRow(row) ?? (row?.profile?.trim() || undefined)
|
||||
}
|
||||
|
||||
type SessionRuntimeStatePatch = Partial<
|
||||
Pick<
|
||||
ClientSessionState,
|
||||
|
||||
@@ -0,0 +1,177 @@
|
||||
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
|
||||
|
||||
// #93892 regression: the registry disposed the secondary socket an idle Bot
|
||||
// Chat tile was bound to — the live-work pruner for a pre-dialed (retained)
|
||||
// entry, and the refcount-0 request lease for one the tile's own resume
|
||||
// created. openGatewayForAgent marks the entry `retained`, but `retained` is
|
||||
// a one-way latch every hover pre-warm and profile switch also sets, so no
|
||||
// dispose path can honor it without leaking every socket ever warmed.
|
||||
// Instead the registry's `foregroundScopes` hook names the scopes FOREGROUND
|
||||
// surfaces are bound to (foregroundSessionScopes): a mounted tile pins its
|
||||
// owner socket for exactly as long as it is mounted, on every dispose path.
|
||||
|
||||
const gatewayMocks = vi.hoisted(() => ({
|
||||
closed: [] as string[]
|
||||
}))
|
||||
|
||||
vi.mock('@/hermes', async importActual => ({
|
||||
...(await importActual<Record<string, unknown>>()),
|
||||
setApiRequestConnection: vi.fn(),
|
||||
HermesGateway: class {
|
||||
connectionState = 'closed'
|
||||
wsUrl = ''
|
||||
connect = async (wsUrl: string): Promise<void> => {
|
||||
this.wsUrl = wsUrl
|
||||
this.connectionState = 'open'
|
||||
}
|
||||
close = (): void => {
|
||||
gatewayMocks.closed.push(this.wsUrl)
|
||||
this.connectionState = 'closed'
|
||||
}
|
||||
request = async (): Promise<unknown> => ({})
|
||||
onEvent = vi.fn(() => () => {})
|
||||
onState = vi.fn(() => () => {})
|
||||
}
|
||||
}))
|
||||
vi.mock('@/store/notify-baseline', () => ({ markNativeNotifyBaseline: vi.fn() }))
|
||||
|
||||
const {
|
||||
closeSecondaryGateways,
|
||||
configureGatewayRegistry,
|
||||
openGatewayForAgent,
|
||||
pruneSecondaryGateways,
|
||||
requestGatewayForAgent,
|
||||
setPrimaryGateway
|
||||
} = await import('./gateway')
|
||||
|
||||
const { $sessionTiles, foregroundSessionScopes, liveSessionScopes } = await import('./session-states')
|
||||
|
||||
function installDesktop(): void {
|
||||
;(window as unknown as { hermesDesktop: unknown }).hermesDesktop = {
|
||||
getConnection: vi.fn(async () => ({
|
||||
authMode: 'token',
|
||||
profile: 'default',
|
||||
token: 't',
|
||||
wsUrl: 'wss://local.invalid/api/ws?token=t'
|
||||
})),
|
||||
getConnectionFor: vi.fn(async ({ connectionId, profile }: { connectionId: string; profile: string }) => ({
|
||||
authMode: 'token',
|
||||
connectionId,
|
||||
profile,
|
||||
token: 't',
|
||||
wsUrl: `wss://${connectionId}.invalid/api/ws?profile=${profile}`
|
||||
})),
|
||||
getGatewayWsUrlFor: vi.fn(
|
||||
async ({ connectionId, profile }: { connectionId: string; profile: string }) =>
|
||||
`wss://${connectionId}.invalid/api/ws?profile=${profile}`
|
||||
),
|
||||
touchBackend: vi.fn(async () => undefined)
|
||||
}
|
||||
}
|
||||
|
||||
// What use-gateway-boot's recomputeKeptGateways feeds the pruner for a
|
||||
// window with NO busy / needs-input work anywhere — the idle bot chat case.
|
||||
// Foreground pins are NOT in here: the registry reads them itself.
|
||||
const idleKeepSet = () => liveSessionScopes()
|
||||
|
||||
const BOT_TILE = {
|
||||
ownerRoute: { connectionId: 'local', mode: 'local' as const, profile: 'bot' },
|
||||
runtimeId: 'rt-bot',
|
||||
storedSessionId: 'stored-bot'
|
||||
}
|
||||
|
||||
beforeEach(() => {
|
||||
installDesktop()
|
||||
// Wired exactly as use-gateway-boot wires it.
|
||||
configureGatewayRegistry({ foregroundScopes: foregroundSessionScopes, onEvent: vi.fn() })
|
||||
setPrimaryGateway({ connectionState: 'open' } as never, 'default')
|
||||
gatewayMocks.closed = []
|
||||
$sessionTiles.set([])
|
||||
})
|
||||
|
||||
afterEach(() => {
|
||||
closeSecondaryGateways()
|
||||
$sessionTiles.set([])
|
||||
vi.clearAllMocks()
|
||||
delete (window as unknown as { hermesDesktop?: unknown }).hermesDesktop
|
||||
})
|
||||
|
||||
describe('foreground tile retention vs. the live-work pruner (#93892)', () => {
|
||||
it('keeps an idle Bot Chat tile’s owner socket across prune recomputes', async () => {
|
||||
// The BOTS workspace dials the bot's own backend without activating it
|
||||
// (keepAllProfilesScope) and opens the canonical chat as a tile on that
|
||||
// route. The global active profile stays primary/default.
|
||||
await openGatewayForAgent('local', 'bot')
|
||||
$sessionTiles.set([BOT_TILE])
|
||||
|
||||
// Idle: no working / needs-input session anywhere. Before the fix this
|
||||
// recompute closed the socket → backend reaped the runtime → reclaim →
|
||||
// unbind → resume → … forever.
|
||||
pruneSecondaryGateways(idleKeepSet())
|
||||
pruneSecondaryGateways(idleKeepSet())
|
||||
|
||||
expect(gatewayMocks.closed).toEqual([])
|
||||
})
|
||||
|
||||
it('keeps the socket while the tile is still resuming (no runtime bound yet)', async () => {
|
||||
await openGatewayForAgent('local', 'bot')
|
||||
$sessionTiles.set([{ ...BOT_TILE, runtimeId: undefined }])
|
||||
|
||||
pruneSecondaryGateways(idleKeepSet())
|
||||
|
||||
expect(gatewayMocks.closed).toEqual([])
|
||||
})
|
||||
|
||||
it('releases the socket once the tile is closed — the pin never latches', async () => {
|
||||
await openGatewayForAgent('local', 'bot')
|
||||
$sessionTiles.set([BOT_TILE])
|
||||
pruneSecondaryGateways(idleKeepSet())
|
||||
expect(gatewayMocks.closed).toEqual([])
|
||||
|
||||
$sessionTiles.set([])
|
||||
pruneSecondaryGateways(idleKeepSet())
|
||||
|
||||
expect(gatewayMocks.closed).toEqual(['wss://local.invalid/api/ws?profile=bot'])
|
||||
})
|
||||
|
||||
it('keeps the socket a tile’s OWN resume dialed (no pre-dial, refcount-0 lease path)', async () => {
|
||||
// Relaunch with a persisted Bot Chat tab: nothing pre-dials the bot, so
|
||||
// the tile's session.resume goes out through requestGatewayForAgent's
|
||||
// per-request lease on a fresh, NON-retained entry. Before the fix the
|
||||
// lease's `finally` disposed that socket the instant the resume returned
|
||||
// — the runtime it had just minted was orphaned on the spot.
|
||||
$sessionTiles.set([{ ...BOT_TILE, runtimeId: undefined }])
|
||||
|
||||
await requestGatewayForAgent('local', 'bot', 'session.resume', { session_id: 'stored-bot' })
|
||||
|
||||
expect(gatewayMocks.closed).toEqual([])
|
||||
|
||||
// …and the pruner agrees with the lease.
|
||||
pruneSecondaryGateways(idleKeepSet())
|
||||
expect(gatewayMocks.closed).toEqual([])
|
||||
|
||||
// Tile gone: the next lease release disposes as it always did.
|
||||
$sessionTiles.set([])
|
||||
await requestGatewayForAgent('local', 'bot', 'session.usage', { session_id: 'stored-bot' })
|
||||
expect(gatewayMocks.closed).toEqual(['wss://local.invalid/api/ws?profile=bot'])
|
||||
})
|
||||
|
||||
it('still prunes a merely pre-warmed (retained, no surface) socket — `retained` is not a pin', async () => {
|
||||
// A roster hover warms the bot's socket through the same door and sets
|
||||
// the same `retained` flag; with no tile bound to it, it is idle garbage.
|
||||
await openGatewayForAgent('local', 'bot')
|
||||
|
||||
pruneSecondaryGateways(idleKeepSet())
|
||||
|
||||
expect(gatewayMocks.closed).toEqual(['wss://local.invalid/api/ws?profile=bot'])
|
||||
})
|
||||
|
||||
it('does not let a tile on one source pin another source’s same-named profile', async () => {
|
||||
await openGatewayForAgent('homelab', 'bot')
|
||||
$sessionTiles.set([BOT_TILE])
|
||||
|
||||
pruneSecondaryGateways(idleKeepSet())
|
||||
|
||||
expect(gatewayMocks.closed).toEqual(['wss://homelab.invalid/api/ws?profile=bot'])
|
||||
})
|
||||
})
|
||||
@@ -36,6 +36,19 @@ interface RegistryConfig {
|
||||
* (#89206: the stale-profile split-brain that stranded bot wake-ups).
|
||||
*/
|
||||
onActiveRouteChanged?: (profile: string) => void
|
||||
/**
|
||||
* Scopes a FOREGROUND surface is bound to right now — every mounted
|
||||
* session tile's owner and the primary thread's (foregroundSessionScopes in
|
||||
* store/session-states; a config hook because that store imports this
|
||||
* one). Consulted by EVERY dispose path — the live-work pruner and the
|
||||
* dispose-at-refcount-0 request/relay leases alike (#93892): a tile's
|
||||
* resume mints its runtime on its owner's socket, and any path that closes
|
||||
* that socket makes the backend orphan-reap the runtime, whose
|
||||
* `session.reclaimed` unbinds the tile and re-arms its resume — a spinner
|
||||
* loop with no terminal state. Read at decision time, never cached: it
|
||||
* follows the tile set, so closing the tile releases the socket.
|
||||
*/
|
||||
foregroundScopes?: () => ReadonlySet<string>
|
||||
}
|
||||
|
||||
// ── Secondary (pool) backends ──────────────────────────────────────────────
|
||||
@@ -56,7 +69,16 @@ interface Secondary {
|
||||
reconnectTimer: ReturnType<typeof setTimeout> | null
|
||||
reconnectAttempt: number
|
||||
reconnecting: boolean
|
||||
/** True when a foreground/prewarmed consumer owns this entry beyond one RPC. */
|
||||
/**
|
||||
* True when a foreground/prewarmed consumer owns this entry beyond one RPC.
|
||||
* Guards ONLY the dispose-at-refcount-0 paths (request/relay leases), never
|
||||
* the live-work pruner: it is a one-way latch that every hover pre-warm and
|
||||
* profile switch sets and nothing ever clears, so honoring it in
|
||||
* pruneSecondaryGateways would pin every socket ever warmed. A foreground
|
||||
* surface that must keep its owner socket (a mounted session tile, the
|
||||
* primary thread) is represented in the pruner's keep-set instead — see
|
||||
* foregroundSessionScopes in store/session-states (#93892).
|
||||
*/
|
||||
retained: boolean
|
||||
/**
|
||||
* Bot-relay retainers pinning this socket open across drain ticks (#93594).
|
||||
@@ -695,7 +717,13 @@ async function gatewayForProfile(
|
||||
released = true
|
||||
entry.activeRequests = Math.max(0, entry.activeRequests - 1)
|
||||
|
||||
if (entry.activeRequests === 0 && !entry.retained && !relayRetained(entry) && g.activeKey !== entry.scope) {
|
||||
if (
|
||||
entry.activeRequests === 0 &&
|
||||
!entry.retained &&
|
||||
!relayRetained(entry) &&
|
||||
!foregroundPinned(entry) &&
|
||||
g.activeKey !== entry.scope
|
||||
) {
|
||||
disposeSecondary(entry)
|
||||
|
||||
if (g.secondaries.get(entry.scope) === entry) {
|
||||
@@ -811,7 +839,13 @@ export async function requestGatewayForAgent<T>(
|
||||
} finally {
|
||||
entry.activeRequests = Math.max(0, entry.activeRequests - 1)
|
||||
|
||||
if (entry.activeRequests === 0 && !entry.retained && !relayRetained(entry) && g.activeKey !== entry.scope) {
|
||||
if (
|
||||
entry.activeRequests === 0 &&
|
||||
!entry.retained &&
|
||||
!relayRetained(entry) &&
|
||||
!foregroundPinned(entry) &&
|
||||
g.activeKey !== entry.scope
|
||||
) {
|
||||
disposeSecondary(entry)
|
||||
|
||||
if (g.secondaries.get(entry.scope) === entry) {
|
||||
@@ -831,6 +865,22 @@ export async function requestGatewayForAgent<T>(
|
||||
// scheduleReconnect/backoff machinery) alive across ticks; stopBotRelay (and
|
||||
// plugin dispose) releases it, restoring the dispose-at-refcount-0 behavior.
|
||||
|
||||
/**
|
||||
* True when a foreground surface (mounted tile / primary thread) is bound to
|
||||
* this entry's scope (#93892). Registry-scoped entries match on their
|
||||
* composite key only; local/legacy entries also match on the bare profile —
|
||||
* the same key language pruneSecondaryGateways' keep-set speaks.
|
||||
*/
|
||||
function foregroundPinned(entry: Secondary): boolean {
|
||||
const scopes = g.config?.foregroundScopes?.()
|
||||
|
||||
if (!scopes) {
|
||||
return false
|
||||
}
|
||||
|
||||
return scopes.has(entry.scope) || (!entry.connectionId && scopes.has(entry.profile))
|
||||
}
|
||||
|
||||
/** True when the bot relay currently pins this entry open. Number guard:
|
||||
* dev-HMR entries predate the field. */
|
||||
function relayRetained(entry: Secondary): boolean {
|
||||
@@ -879,6 +929,7 @@ export function retainGatewayForRelay(connectionId: null | string, profile: stri
|
||||
entry.relayRetainCount === 0 &&
|
||||
entry.activeRequests === 0 &&
|
||||
!entry.retained &&
|
||||
!foregroundPinned(entry) &&
|
||||
g.activeKey !== entry.scope &&
|
||||
g.secondaries.get(entry.scope) === entry
|
||||
) {
|
||||
@@ -941,7 +992,13 @@ export async function retainGatewayForAgent(connectionId: null | string, profile
|
||||
released = true
|
||||
entry.activeRequests = Math.max(0, entry.activeRequests - 1)
|
||||
|
||||
if (entry.activeRequests === 0 && !entry.retained && !relayRetained(entry) && g.activeKey !== entry.scope) {
|
||||
if (
|
||||
entry.activeRequests === 0 &&
|
||||
!entry.retained &&
|
||||
!relayRetained(entry) &&
|
||||
!foregroundPinned(entry) &&
|
||||
g.activeKey !== entry.scope
|
||||
) {
|
||||
disposeSecondary(entry)
|
||||
|
||||
if (g.secondaries.get(entry.scope) === entry) {
|
||||
@@ -1400,6 +1457,16 @@ function restoreActiveToPrimaryIfEvicted(): void {
|
||||
// source exposes a 'default' profile, so matching a non-local entry on the
|
||||
// bare profile name kept gateway B's 'default' socket alive off gateway A's
|
||||
// 'default' activity (and vice versa) — cross-connection attribution.
|
||||
//
|
||||
// Live work is not the only thing worth a socket: an idle tile still holds a
|
||||
// resumed runtime on its owner's socket, and closing that socket makes the
|
||||
// backend detach and orphan-reap the runtime, whose `session.reclaimed`
|
||||
// unbinds the tile and re-resumes it on a fresh socket that the next
|
||||
// recompute closes again — a spinner loop with no terminal state (#93892).
|
||||
// Foreground-bound scopes come from the registry's `foregroundScopes` hook
|
||||
// (foregroundPinned), not from `keep`, so every dispose path sees the same
|
||||
// pin. `entry.retained` is deliberately NOT consulted here (see the field's
|
||||
// doc).
|
||||
export function pruneSecondaryGateways(keep: Set<string>): void {
|
||||
const now = Date.now()
|
||||
|
||||
@@ -1412,6 +1479,9 @@ export function pruneSecondaryGateways(keep: Set<string>): void {
|
||||
// its whole active lifetime; the live-work pruner must not undo that
|
||||
// pin between drain ticks or the socket churn returns.
|
||||
relayRetained(entry) ||
|
||||
// A mounted tile / the primary thread is bound to a runtime on this
|
||||
// socket (#93892) — pinned for as long as that surface is mounted.
|
||||
foregroundPinned(entry) ||
|
||||
// Mid-dial activation target: the profile being switched TO is not yet
|
||||
// active and has no live work, so without this lease any recompute
|
||||
// during its cold spawn disposed the entry and the click died silently
|
||||
|
||||
@@ -26,6 +26,7 @@ import {
|
||||
import { notifyError } from '@/store/notifications'
|
||||
import { notifyRemoteOverrideAuthFailure } from '@/store/profile-remote-override'
|
||||
import { setConnection } from '@/store/session'
|
||||
import type { SessionOwnerRoute } from '@/store/session-request-router'
|
||||
import { resetStarmapGraph } from '@/store/starmap'
|
||||
import type { ProfileInfo } from '@/types/hermes'
|
||||
|
||||
@@ -250,12 +251,9 @@ export const $activeGatewayProfile = atom<string>('default')
|
||||
// Profile for the NEXT new chat (chosen via the new-chat picker). null = primary
|
||||
// / default, so single-profile users are unaffected.
|
||||
export const $newChatProfile = atom<string | null>(null)
|
||||
export interface AgentProfileRoute {
|
||||
connectionId: string
|
||||
mode?: 'local' | 'remote'
|
||||
profile: string
|
||||
targetProfile?: string
|
||||
}
|
||||
/** The draft's exact owner — the same shape every session-scoped surface
|
||||
* routes by (store/session-request-router SessionOwnerRoute). */
|
||||
export type AgentProfileRoute = SessionOwnerRoute
|
||||
|
||||
// A draft remembers the source it was created for. The active gateway may
|
||||
// change before the first Send; the draft's owner must not change with it.
|
||||
|
||||
@@ -0,0 +1,76 @@
|
||||
/**
|
||||
* Fail-closed owner resolution for session-scoped RPCs.
|
||||
*
|
||||
* A request that carries a `session_id` only means anything on the backend
|
||||
* that OWNS that session. When every rung of the owner ladder (tile route →
|
||||
* exact owner hint → connection-tagged / profiled row → cross-profile REST
|
||||
* probe) misses, the request must NOT quietly ride the ambient presentation
|
||||
* gateway: "active" is presentation state with no routing authority, and an
|
||||
* ambient fallback turns missing ownership metadata into a misleading backend
|
||||
* "session not found" (or, worse, an answer from a backend that merely happens
|
||||
* to know a same-named session). Surface an explicit owner-resolution error
|
||||
* instead — the caller's error UX shows it, and the runtime that minted the
|
||||
* session is left untouched for the next correctly-routed attempt.
|
||||
*
|
||||
* The ONE case where the ambient gateway is not a fallback but the owner by
|
||||
* construction: no registry source is live (legacy v1 primary) AND at most
|
||||
* one profile exists — a single backend serves every session, so there is
|
||||
* nothing to misroute to. Older single-profile backends omit `profile` on
|
||||
* their rows entirely; those users keep working unchanged.
|
||||
*/
|
||||
import { activeGatewayConnectionId } from './gateway'
|
||||
import { $profiles } from './profile'
|
||||
import { isSessionOwnerRoute, type SessionOwnerScope } from './session-request-router'
|
||||
|
||||
export class SessionOwnerResolutionError extends Error {
|
||||
constructor(
|
||||
readonly sessionId: string,
|
||||
readonly method: string
|
||||
) {
|
||||
super(
|
||||
`Session owner could not be resolved for "${sessionId}" (${method}): ` +
|
||||
'no owner route, hint, connection-tagged row or profile probe named the backend that holds this session, ' +
|
||||
'and routing it to the active gateway would be a guess.'
|
||||
)
|
||||
this.name = 'SessionOwnerResolutionError'
|
||||
}
|
||||
}
|
||||
|
||||
export function isSessionOwnerResolutionError(error: unknown): error is SessionOwnerResolutionError {
|
||||
return (
|
||||
error instanceof SessionOwnerResolutionError ||
|
||||
(error as { name?: unknown })?.name === 'SessionOwnerResolutionError'
|
||||
)
|
||||
}
|
||||
|
||||
/** True when the ambient gateway is provably the only backend any session
|
||||
* can live on (legacy single-backend Desktop): no registry source is active
|
||||
* and there is at most one profile. Everything else has somewhere to misroute. */
|
||||
export function ambientGatewayOwnsEverySession(): boolean {
|
||||
return activeGatewayConnectionId() === null && $profiles.get().length <= 1
|
||||
}
|
||||
|
||||
/** True when `owner` names a backend (an exact route or a profile). */
|
||||
export function sessionOwnerIsKnown(owner: SessionOwnerScope): boolean {
|
||||
if (isSessionOwnerRoute(owner)) {
|
||||
return Boolean(owner.connectionId.trim())
|
||||
}
|
||||
|
||||
return owner != null && Boolean(String(owner).trim())
|
||||
}
|
||||
|
||||
/**
|
||||
* Gate before a session-scoped RPC falls to the ambient dispatcher. Throws
|
||||
* SessionOwnerResolutionError when the session's owner is unknown and the
|
||||
* ambient gateway is not the sole backend; otherwise returns normally.
|
||||
*/
|
||||
export function assertSessionOwnerResolved(
|
||||
owner: SessionOwnerScope,
|
||||
context: { method: string; sessionId: null | string | undefined }
|
||||
): void {
|
||||
if (!context.sessionId || sessionOwnerIsKnown(owner) || ambientGatewayOwnsEverySession()) {
|
||||
return
|
||||
}
|
||||
|
||||
throw new SessionOwnerResolutionError(context.sessionId, context.method)
|
||||
}
|
||||
@@ -1,13 +1,47 @@
|
||||
import { requestGatewayForAgent, requestGatewayForProfile, retainGatewayForSessionTurn } from '@/store/gateway'
|
||||
|
||||
export interface SessionProfileRoute {
|
||||
/**
|
||||
* The ONE authoritative exact owner of a session: the registry connection whose
|
||||
* socket minted (or resumed) the runtime, plus the Desktop profile that selects
|
||||
* that route. `targetProfile` is the backend profile the route serves when it
|
||||
* differs from the Desktop-side name (remote overrides); `mode` is informative.
|
||||
*
|
||||
* Captured ONCE at the new-chat intent / send linearization point
|
||||
* (store/profile resolveNewChatOwnerRoute) and carried through session.create,
|
||||
* the owner hint, the optimistic row, the runtime binding, the foreground hold
|
||||
* and every later session-scoped RPC. Never re-derived from ambient state after
|
||||
* an asynchronous activation: connection/profile EQUALITY is not enough — the
|
||||
* runtime lives on one concrete WebSocket, and only this route names the
|
||||
* registry entry that holds it.
|
||||
*/
|
||||
export interface SessionOwnerRoute {
|
||||
connectionId: string
|
||||
mode?: 'local' | 'remote'
|
||||
profile: string
|
||||
targetProfile?: string
|
||||
}
|
||||
|
||||
export type SessionOwnerScope = undefined | null | string | SessionProfileRoute
|
||||
/** @deprecated Alias kept for existing imports; new code names SessionOwnerRoute. */
|
||||
export type SessionProfileRoute = SessionOwnerRoute
|
||||
|
||||
export type SessionOwnerScope = undefined | null | string | SessionOwnerRoute
|
||||
|
||||
/** Exact owner reconstructed from a CONNECTION-TAGGED session row (the
|
||||
* Electron unified-list splice tags foreign registry rows; an optimistic row
|
||||
* carries the create route's connection; mergeSessionPage carries the tag
|
||||
* across refreshes). A row without a connection tag yields undefined — a bare
|
||||
* profile is not an exact owner. */
|
||||
export function sessionOwnerRouteFromRow(
|
||||
row: { connection_id?: null | string; profile?: null | string } | null | undefined
|
||||
): SessionOwnerRoute | undefined {
|
||||
const connectionId = String(row?.connection_id ?? '').trim()
|
||||
|
||||
if (!connectionId) {
|
||||
return undefined
|
||||
}
|
||||
|
||||
return { connectionId, profile: String(row?.profile ?? '').trim() || 'default' }
|
||||
}
|
||||
|
||||
// ── Session-scoped RPC routing (the #89206 class) ───────────────────────────
|
||||
// A session-scoped RPC (session.resume / session.activate / session.usage /
|
||||
@@ -29,9 +63,11 @@ export type SessionOwnerScope = undefined | null | string | SessionProfileRoute
|
||||
|
||||
const normKey = (profile: null | string | undefined): string => (profile ?? '').trim() || 'default'
|
||||
|
||||
const isRoute = (owner: SessionOwnerScope): owner is SessionProfileRoute =>
|
||||
export const isSessionOwnerRoute = (owner: SessionOwnerScope): owner is SessionOwnerRoute =>
|
||||
Boolean(owner && typeof owner === 'object' && 'connectionId' in owner)
|
||||
|
||||
const isRoute = isSessionOwnerRoute
|
||||
|
||||
function routeParams(route: SessionProfileRoute, params: Record<string, unknown>): Record<string, unknown> {
|
||||
if (!route.targetProfile || !Object.prototype.hasOwnProperty.call(params, 'profile')) {
|
||||
return params
|
||||
|
||||
@@ -0,0 +1,95 @@
|
||||
import { afterEach, describe, expect, it, vi } from 'vitest'
|
||||
|
||||
import {
|
||||
$selectedStoredSessionId,
|
||||
_resetSessionOwnerHintsForTests,
|
||||
setActiveSessionId,
|
||||
setSessionOwnerHint
|
||||
} from '@/store/session'
|
||||
|
||||
import {
|
||||
$sessionTiles,
|
||||
_resetSessionOwnerHoldsForTests,
|
||||
foregroundSessionScopes,
|
||||
holdSessionOwnerUntilForeground,
|
||||
recordSessionEventScope,
|
||||
releaseSessionOwnerHold
|
||||
} from './session-states'
|
||||
|
||||
// A routed session.create returns a stored id on the owner's socket, but the
|
||||
// surface that will pin that socket (the selected primary thread, or a tile)
|
||||
// is published later and asynchronously. The hold names the owner in
|
||||
// foregroundSessionScopes — the gateway keep-set — from the moment the create
|
||||
// returns until the foreground publication takes over, the caller releases
|
||||
// it, or a bounded TTL expires. Nothing latches.
|
||||
|
||||
afterEach(() => {
|
||||
$sessionTiles.set([])
|
||||
setActiveSessionId(null)
|
||||
$selectedStoredSessionId.set(null)
|
||||
_resetSessionOwnerHoldsForTests()
|
||||
_resetSessionOwnerHintsForTests({ storage: true })
|
||||
vi.useRealTimers()
|
||||
})
|
||||
|
||||
describe('foregroundSessionScopes: owner hold across the create → foreground gap', () => {
|
||||
const omar = { connectionId: 'local', mode: 'local' as const, profile: 'omar' }
|
||||
|
||||
it('names the owner from the moment a routed create returns, before anything is selected or tiled', () => {
|
||||
holdSessionOwnerUntilForeground('stored-fresh', omar)
|
||||
|
||||
expect(foregroundSessionScopes()).toEqual(new Set(['conn:local::omar']))
|
||||
})
|
||||
|
||||
it('retires once the foreground publication covers it (selected primary thread / mounted tile)', () => {
|
||||
holdSessionOwnerUntilForeground('stored-fresh', omar)
|
||||
setSessionOwnerHint('stored-fresh', omar)
|
||||
|
||||
// Selected, but the runtime's event scope is not known yet: the hold is
|
||||
// still the only thing naming the owner socket, so it stays.
|
||||
$selectedStoredSessionId.set('stored-fresh')
|
||||
expect(foregroundSessionScopes()).toEqual(new Set(['conn:local::omar']))
|
||||
|
||||
// The first event from the owner socket records the runtime's scope; the
|
||||
// selected-thread rung now covers it and the hold retires for good.
|
||||
recordSessionEventScope({ connectionId: 'local', profile: 'omar', session_id: 'rt-fresh' })
|
||||
setActiveSessionId('rt-fresh')
|
||||
expect(foregroundSessionScopes()).toEqual(new Set(['conn:local::omar']))
|
||||
setActiveSessionId(null)
|
||||
$selectedStoredSessionId.set(null)
|
||||
_resetSessionOwnerHintsForTests()
|
||||
expect(foregroundSessionScopes()).toEqual(new Set())
|
||||
|
||||
holdSessionOwnerUntilForeground('stored-tile', { connectionId: 'homelab', profile: 'bot' })
|
||||
$sessionTiles.set([{ ownerRoute: { connectionId: 'homelab', profile: 'bot' }, storedSessionId: 'stored-tile' }])
|
||||
// Covered by the tile's own route rung now; the hold retired.
|
||||
expect(foregroundSessionScopes()).toEqual(new Set(['conn:homelab::bot']))
|
||||
$sessionTiles.set([])
|
||||
expect(foregroundSessionScopes()).toEqual(new Set())
|
||||
})
|
||||
|
||||
it('is released explicitly by the caller (failed create / drift close) and expires on its own', () => {
|
||||
vi.useFakeTimers()
|
||||
|
||||
const release = holdSessionOwnerUntilForeground('stored-a', omar)
|
||||
holdSessionOwnerUntilForeground('stored-b', { connectionId: 'homelab', profile: 'worker' })
|
||||
|
||||
release()
|
||||
expect(foregroundSessionScopes()).toEqual(new Set(['conn:homelab::worker']))
|
||||
|
||||
releaseSessionOwnerHold('stored-b')
|
||||
expect(foregroundSessionScopes()).toEqual(new Set())
|
||||
|
||||
holdSessionOwnerUntilForeground('stored-c', omar)
|
||||
vi.advanceTimersByTime(60_000 + 1)
|
||||
expect(foregroundSessionScopes()).toEqual(new Set())
|
||||
})
|
||||
|
||||
it('ignores blank ids, null owners and profile-only owners map to the legacy pool key', () => {
|
||||
holdSessionOwnerUntilForeground(' ', omar)
|
||||
holdSessionOwnerUntilForeground('stored-null', null)
|
||||
holdSessionOwnerUntilForeground('stored-legacy', 'research')
|
||||
|
||||
expect(foregroundSessionScopes()).toEqual(new Set(['research']))
|
||||
})
|
||||
})
|
||||
@@ -1,6 +1,18 @@
|
||||
import { afterEach, describe, expect, it } from 'vitest'
|
||||
import { afterEach, describe, expect, it, vi } from 'vitest'
|
||||
|
||||
import { $sessionTiles, storedSessionIdForRuntimeId } from '@/store/session-states'
|
||||
import { createClientSessionState } from '@/lib/chat-runtime'
|
||||
import { $profiles } from '@/store/profile'
|
||||
import { _resetSessionOwnerHintsForTests, setSessionOwnerHint, setSessions } from '@/store/session'
|
||||
import { isSessionOwnerResolutionError } from '@/store/session-owner-resolution'
|
||||
import {
|
||||
$sessionTiles,
|
||||
clearAllSessionStates,
|
||||
knownOwnerForSession,
|
||||
publishSessionState,
|
||||
requestForOwnedSession,
|
||||
storedSessionIdForRuntimeId
|
||||
} from '@/store/session-states'
|
||||
import { makeSessionInfo } from '@/test/session-info'
|
||||
|
||||
// #92687-adjacent Bot Mode misroute: a session RPC (prompt.submit et al.)
|
||||
// carries its target as a RUNTIME id, while tile owner routes key on the
|
||||
@@ -47,6 +59,20 @@ describe('storedSessionIdForRuntimeId', () => {
|
||||
expect(storedSessionIdForRuntimeId('undefined')).toBeNull()
|
||||
})
|
||||
|
||||
it('maps a MAIN-PANE runtime id through the per-runtime state mirror (no tile involved)', () => {
|
||||
// approval.respond from a native notification, a queued send: the caller
|
||||
// holds the runtime id of the primary thread, which no tile knows. The
|
||||
// state mirror carries the stored id the wiring cache bound.
|
||||
publishSessionState('rt-main', createClientSessionState('stored-main'))
|
||||
|
||||
expect(storedSessionIdForRuntimeId('rt-main')).toBe('stored-main')
|
||||
// A detached runtime (null stored id) is still unknown.
|
||||
publishSessionState('rt-detached', createClientSessionState(null))
|
||||
expect(storedSessionIdForRuntimeId('rt-detached')).toBeNull()
|
||||
|
||||
clearAllSessionStates()
|
||||
})
|
||||
|
||||
it('prefers the stored-id identity when one tile is stored-matched and another is runtime-matched', () => {
|
||||
// Pathological but possible after a stale rebind: some other tile's dead
|
||||
// runtimeId equals a live tile's storedSessionId. The stored-id claim is
|
||||
@@ -59,3 +85,45 @@ describe('storedSessionIdForRuntimeId', () => {
|
||||
expect(storedSessionIdForRuntimeId('collision')).toBe('collision')
|
||||
})
|
||||
})
|
||||
|
||||
describe('knownOwnerForSession / requestForOwnedSession', () => {
|
||||
afterEach(() => {
|
||||
$sessionTiles.set([])
|
||||
clearAllSessionStates()
|
||||
setSessions([])
|
||||
$profiles.set([])
|
||||
_resetSessionOwnerHintsForTests({ storage: true })
|
||||
})
|
||||
|
||||
it('resolves a main-pane runtime id to its EXACT owner via the mirror + the hint, then the tagged row', () => {
|
||||
publishSessionState('rt-main', createClientSessionState('stored-main'))
|
||||
setSessionOwnerHint('stored-main', { connectionId: 'local', profile: 'omar' })
|
||||
|
||||
expect(knownOwnerForSession('rt-main')).toEqual({ connectionId: 'local', profile: 'omar' })
|
||||
|
||||
_resetSessionOwnerHintsForTests()
|
||||
setSessions([makeSessionInfo({ connection_id: 'local', id: 'stored-main', profile: 'omar' })])
|
||||
expect(knownOwnerForSession('rt-main')).toEqual({ connectionId: 'local', profile: 'omar' })
|
||||
|
||||
setSessions([makeSessionInfo({ id: 'stored-main', profile: 'coder' })])
|
||||
expect(knownOwnerForSession('rt-main')).toBe('coder')
|
||||
})
|
||||
|
||||
it('fails closed with an explicit owner-resolution error instead of the ambient socket', async () => {
|
||||
// Somewhere to misroute to: two profiles exist.
|
||||
$profiles.set([{ name: 'default' }, { name: 'omar' }] as never)
|
||||
const ambient = vi.fn(async () => ({ ok: true }))
|
||||
|
||||
await expect(
|
||||
requestForOwnedSession('rt-orphan', ambient as never, 'approval.respond', { session_id: 'rt-orphan' })
|
||||
).rejects.toSatisfy(isSessionOwnerResolutionError)
|
||||
expect(ambient).not.toHaveBeenCalled()
|
||||
|
||||
// Legacy single backend: the ambient gateway IS the owner.
|
||||
$profiles.set([{ name: 'default' }] as never)
|
||||
await expect(
|
||||
requestForOwnedSession('rt-orphan', ambient as never, 'approval.respond', { session_id: 'rt-orphan' })
|
||||
).resolves.toEqual({ ok: true })
|
||||
expect(ambient).toHaveBeenCalledWith('approval.respond', { session_id: 'rt-orphan' })
|
||||
})
|
||||
})
|
||||
|
||||
@@ -53,7 +53,8 @@ import {
|
||||
setBusy,
|
||||
setSessions
|
||||
} from './session'
|
||||
import { requestForSessionProfile, type SessionOwnerScope, type SessionProfileRoute } from './session-request-router'
|
||||
import { assertSessionOwnerResolved } from './session-owner-resolution'
|
||||
import { requestForSessionProfile, type SessionOwnerRoute, type SessionOwnerScope } from './session-request-router'
|
||||
import { ackStoredSessionId, markSessionUnreadFinished } from './session-unread'
|
||||
import { isBrowserWindow, isSecondaryWindow } from './windows'
|
||||
|
||||
@@ -102,6 +103,43 @@ export function liveSessionScopes(): Set<string> {
|
||||
return scopes
|
||||
}
|
||||
|
||||
// ── Owner hold across the create → foreground gap ───────────────────────────
|
||||
// A routed session.create returns a stored id on the owner's socket, but the
|
||||
// surface that will PIN that socket (the selected primary thread, or a tile)
|
||||
// is published later and asynchronously: navigate → route effect →
|
||||
// $selectedStoredSessionId, or openSessionTile → $sessionTiles. In that gap
|
||||
// the entry has no active request, is not yet foreground-bound and, if the
|
||||
// user switched source meanwhile, is not the active key either — so the
|
||||
// live-work pruner or a refcount-0 lease release could close the socket that
|
||||
// holds the just-minted runtime before the first prompt.submit. The hold
|
||||
// names the owner in foregroundSessionScopes from the moment the create
|
||||
// returns until the foreground publication takes over (the stored id becomes
|
||||
// selected or tiled), the caller releases it (failed create / drift close),
|
||||
// or a bounded TTL expires — nothing latches.
|
||||
const SESSION_OWNER_HOLD_TTL_MS = 60_000
|
||||
const sessionOwnerHolds = new Map<string, { owner: SessionOwnerScope; until: number }>()
|
||||
|
||||
export function holdSessionOwnerUntilForeground(storedSessionId: string, owner: SessionOwnerScope): () => void {
|
||||
const id = storedSessionId.trim()
|
||||
|
||||
if (!id || !owner) {
|
||||
return () => undefined
|
||||
}
|
||||
|
||||
sessionOwnerHolds.set(id, { owner, until: Date.now() + SESSION_OWNER_HOLD_TTL_MS })
|
||||
|
||||
return () => releaseSessionOwnerHold(id)
|
||||
}
|
||||
|
||||
export function releaseSessionOwnerHold(storedSessionId: string): void {
|
||||
sessionOwnerHolds.delete(storedSessionId.trim())
|
||||
}
|
||||
|
||||
/** @internal Tests. */
|
||||
export function _resetSessionOwnerHoldsForTests(): void {
|
||||
sessionOwnerHolds.clear()
|
||||
}
|
||||
|
||||
/**
|
||||
* Registry scopes owned by an open foreground surface, when known.
|
||||
*
|
||||
@@ -111,6 +149,11 @@ export function liveSessionScopes(): Set<string> {
|
||||
* the same ownership contract: a non-focused idle tile is still user-visible
|
||||
* state and must not be evicted just because another pane has focus. Prefer the
|
||||
* live event scope, with the tile's persisted route as the pre-bind fallback.
|
||||
*
|
||||
* A just-created session's owner is named by its create → foreground hold
|
||||
* (holdSessionOwnerUntilForeground) until the selected/tiled publication or
|
||||
* a bounded TTL retires it, so nothing can close the socket that minted the
|
||||
* runtime before the first prompt lands.
|
||||
*/
|
||||
export function foregroundSessionScopes(): Set<string> {
|
||||
const scopes = new Set<string>()
|
||||
@@ -123,7 +166,7 @@ export function foregroundSessionScopes(): Set<string> {
|
||||
}
|
||||
}
|
||||
|
||||
const addRouteScope = (route: SessionProfileRoute | undefined) => {
|
||||
const addRouteScope = (route: SessionOwnerRoute | undefined) => {
|
||||
const connectionId = route?.connectionId?.trim()
|
||||
const profile = route?.profile?.trim()
|
||||
|
||||
@@ -139,6 +182,28 @@ export function foregroundSessionScopes(): Set<string> {
|
||||
addRouteScope(tile.ownerRoute)
|
||||
}
|
||||
|
||||
// Create → foreground holds. A hold whose scope the rungs above already
|
||||
// name (the runtime's event scope once selected, a mounted tile's route) is
|
||||
// covered and retires; an expired one retires too.
|
||||
const now = Date.now()
|
||||
|
||||
for (const [storedSessionId, hold] of [...sessionOwnerHolds]) {
|
||||
const scope =
|
||||
typeof hold.owner === 'string'
|
||||
? normalizeProfileKey(hold.owner)
|
||||
: hold.owner?.connectionId?.trim()
|
||||
? registryBackendScopeKey(hold.owner.connectionId.trim(), normalizeProfileKey(hold.owner.profile))
|
||||
: null
|
||||
|
||||
if (!scope || hold.until <= now || scopes.has(scope)) {
|
||||
sessionOwnerHolds.delete(storedSessionId)
|
||||
|
||||
continue
|
||||
}
|
||||
|
||||
scopes.add(scope)
|
||||
}
|
||||
|
||||
return scopes
|
||||
}
|
||||
|
||||
@@ -609,13 +674,13 @@ export interface SessionTile {
|
||||
/** Exact opaque owner key for Bot Mode tabs. */
|
||||
workspaceOwnerKey?: string
|
||||
/** Credential-free exact route used to resume this tab after relaunch. */
|
||||
ownerRoute?: SessionProfileRoute
|
||||
ownerRoute?: SessionOwnerRoute
|
||||
/** Stable title for hidden relationship chats absent from the Sessions list. */
|
||||
workspaceTabTitle?: string
|
||||
}
|
||||
|
||||
export interface SessionTileWorkspaceScope {
|
||||
ownerRoute?: SessionProfileRoute
|
||||
ownerRoute?: SessionOwnerRoute
|
||||
workspaceMode: WorkspaceMode
|
||||
workspaceOwnerKey?: string
|
||||
workspaceTabTitle?: string
|
||||
@@ -803,7 +868,7 @@ export function patchSessionTile(storedSessionId: string, patch: Partial<Session
|
||||
saveTiles($sessionTiles.get().map(t => (t.storedSessionId === storedSessionId ? { ...t, ...patch } : t)))
|
||||
}
|
||||
|
||||
export function sessionTileOwnerRoute(storedSessionId: string): SessionProfileRoute | undefined {
|
||||
export function sessionTileOwnerRoute(storedSessionId: string): SessionOwnerRoute | undefined {
|
||||
return $sessionTiles.get().find(tile => tile.storedSessionId === storedSessionId)?.ownerRoute
|
||||
}
|
||||
|
||||
@@ -846,11 +911,12 @@ export function openTileGatewayScopes(): Set<string> {
|
||||
* Sync owner resolution for a session id that may be a RUNTIME or a STORED id.
|
||||
* Tile route first (exact connectionId+profile, survives relaunch), then the
|
||||
* exact unique owner hint (stamped when a routed create returns / at open
|
||||
* time), then the known session owner (a connection-tagged row's exact route,
|
||||
* else its profile / the hint). The hint outranks the row for the same reason
|
||||
* as contrib/wiring's ladder: a row can be stamped from the ambient profile
|
||||
* and carries no connection. Returns undefined when no owner is known — the
|
||||
* caller falls back to ambient, never to "active".
|
||||
* time; persisted), then the session row's owner (an exact route when the row
|
||||
* is connection-tagged, else its bare profile, else the hint's profile). The
|
||||
* hint outranks the row for the same reason as contrib/wiring's ladder: a
|
||||
* row can be stamped from the ambient profile and carries no connection.
|
||||
* Returns undefined when no owner is known — the caller fails closed
|
||||
* (assertSessionOwnerResolved), never falls to "active".
|
||||
*/
|
||||
export function knownOwnerForSession(sessionId: null | string | undefined): SessionOwnerScope {
|
||||
if (!sessionId) {
|
||||
@@ -889,10 +955,12 @@ export function isSessionRemote(sessionId: null | string | undefined): boolean {
|
||||
|
||||
/**
|
||||
* Dispatch a session-scoped RPC through the OWNER of `sessionId` (tile route →
|
||||
* known profile), falling back to the ambient dispatcher only when no owner is
|
||||
* known. This is the client half of #91684: approval.respond (and siblings)
|
||||
* sent on the ambient socket land on whatever backend is active, which for a
|
||||
* cross-profile session is a backend that never held the approval.
|
||||
* hint → connection-tagged row / known profile). This is the client half of
|
||||
* #91684: approval.respond (and siblings) sent on the ambient socket land on
|
||||
* whatever backend is active, which for a cross-profile session is a backend
|
||||
* that never held the approval. An UNKNOWN owner fails closed with an
|
||||
* explicit SessionOwnerResolutionError unless the ambient gateway is provably
|
||||
* the only backend (legacy single-profile, no registry source).
|
||||
*/
|
||||
export function requestForOwnedSession<T>(
|
||||
sessionId: null | string | undefined,
|
||||
@@ -907,7 +975,15 @@ export function requestForOwnedSession<T>(
|
||||
timeoutMs?: number,
|
||||
signal?: AbortSignal
|
||||
): Promise<T> {
|
||||
return requestForSessionProfile<T>(knownOwnerForSession(sessionId), ambientRequest, method, params, timeoutMs, signal)
|
||||
const owner = knownOwnerForSession(sessionId)
|
||||
|
||||
try {
|
||||
assertSessionOwnerResolved(owner, { method, sessionId })
|
||||
} catch (error) {
|
||||
return Promise.reject(error)
|
||||
}
|
||||
|
||||
return requestForSessionProfile<T>(owner, ambientRequest, method, params, timeoutMs, signal)
|
||||
}
|
||||
|
||||
/** Resolve a session id THAT MAY BE A RUNTIME ID to the stored id its tile
|
||||
@@ -935,7 +1011,14 @@ export function storedSessionIdForRuntimeId(sessionId: string): null | string {
|
||||
}
|
||||
}
|
||||
|
||||
return null
|
||||
// The per-runtime state mirror carries the stored id the wiring cache bound
|
||||
// (ensureSessionState / a resume). This is how a MAIN-PANE runtime id — an
|
||||
// approval.respond from a native notification, a queued send — finds its
|
||||
// durable identity, and through it the exact owner (hint / tagged row).
|
||||
// Without this rung such ids fell straight to the ambient socket.
|
||||
const mirrored = $sessionStates.get()[sessionId]?.storedSessionId?.trim()
|
||||
|
||||
return mirrored || null
|
||||
}
|
||||
|
||||
export function setSessionTileWorkspaceScope(storedSessionId: string, scope: SessionTileWorkspaceScope): boolean {
|
||||
|
||||
@@ -26,13 +26,16 @@ import {
|
||||
$sessions,
|
||||
$unreadFinishedSessionIds,
|
||||
_resetLegacyDiscardForTests,
|
||||
_resetSessionOwnerHintsForTests,
|
||||
applyConfiguredDefaultProjectDir,
|
||||
commitWorkspaceCwdForSelectedSession,
|
||||
ensureDefaultWorkspaceCwd,
|
||||
forgetSessionOwnerHintsForConnection,
|
||||
getConfiguredDefaultProjectDir,
|
||||
getRememberedRoute,
|
||||
getRememberedSessionId,
|
||||
getSessionOwnerHint,
|
||||
hydrateSessionOwnerHints,
|
||||
knownSessionOwner,
|
||||
knownSessionProfile,
|
||||
mergeSessionPage,
|
||||
@@ -61,6 +64,10 @@ import {
|
||||
const session = (over: Partial<SessionInfo>): SessionInfo => makeSessionInfo({ id: 'live', ...over })
|
||||
|
||||
describe('session owner hints', () => {
|
||||
afterEach(() => {
|
||||
_resetSessionOwnerHintsForTests({ storage: true })
|
||||
})
|
||||
|
||||
it('preserves the registry owner recorded on a discovered session row', () => {
|
||||
expect(
|
||||
knownSessionOwner(
|
||||
@@ -109,6 +116,93 @@ describe('session owner hints', () => {
|
||||
expect(getSessionOwnerHint('bounded-0', scope)).toBeUndefined()
|
||||
expect(getSessionOwnerHint('bounded-256', scope)).toMatchObject({ connectionId: 'bounded-source' })
|
||||
})
|
||||
|
||||
it('survives a relaunch: hints are persisted and rehydrated in LRU order', () => {
|
||||
const omar = { connectionId: 'local', mode: 'local' as const, profile: 'omar' }
|
||||
const remote = { connectionId: 'homelab', mode: 'remote' as const, profile: 'worker', targetProfile: 'w' }
|
||||
|
||||
setSessionOwnerHint('stored-omar', omar)
|
||||
setSessionOwnerHint('stored-remote', remote)
|
||||
|
||||
// "Relaunch": the in-memory map is gone, storage is not.
|
||||
_resetSessionOwnerHintsForTests()
|
||||
expect(getSessionOwnerHint('stored-omar')).toBeUndefined()
|
||||
|
||||
hydrateSessionOwnerHints()
|
||||
|
||||
expect(getSessionOwnerHint('stored-omar')).toEqual(omar)
|
||||
expect(getSessionOwnerHint('stored-remote')).toEqual(remote)
|
||||
|
||||
// LRU order survives: the oldest persisted entry is the first evicted.
|
||||
for (let index = 0; index < 255; index += 1) {
|
||||
setSessionOwnerHint(`filler-${index}`, { connectionId: 'filler', profile: 'p' })
|
||||
}
|
||||
|
||||
expect(getSessionOwnerHint('stored-omar')).toBeUndefined()
|
||||
expect(getSessionOwnerHint('stored-remote')).toEqual(remote)
|
||||
})
|
||||
|
||||
it('ignores malformed persisted entries and never throws on hydrate', () => {
|
||||
window.localStorage.setItem(
|
||||
'hermes.desktop.sessionOwnerHints.v1',
|
||||
JSON.stringify([
|
||||
'junk',
|
||||
['no-route', null],
|
||||
['bad-shape', { connectionId: 7, profile: 'x' }],
|
||||
['good', { connectionId: 'local', profile: 'omar', mode: 'sideways' }]
|
||||
])
|
||||
)
|
||||
|
||||
_resetSessionOwnerHintsForTests()
|
||||
expect(() => hydrateSessionOwnerHints()).not.toThrow()
|
||||
expect(getSessionOwnerHint('good')).toEqual({ connectionId: 'local', profile: 'omar' })
|
||||
expect(getSessionOwnerHint('no-route')).toBeUndefined()
|
||||
expect(getSessionOwnerHint('bad-shape')).toBeUndefined()
|
||||
})
|
||||
|
||||
it('forgets every hint naming a removed connection, in memory and on disk', () => {
|
||||
setSessionOwnerHint('stored-a', { connectionId: 'gone', profile: 'omar' })
|
||||
setSessionOwnerHint('stored-b', { connectionId: 'gone', profile: 'default' })
|
||||
setSessionOwnerHint('stored-c', { connectionId: 'local', profile: 'omar' })
|
||||
|
||||
forgetSessionOwnerHintsForConnection('gone')
|
||||
|
||||
expect(getSessionOwnerHint('stored-a')).toBeUndefined()
|
||||
expect(getSessionOwnerHint('stored-b')).toBeUndefined()
|
||||
expect(getSessionOwnerHint('stored-c')).toEqual({ connectionId: 'local', profile: 'omar' })
|
||||
|
||||
_resetSessionOwnerHintsForTests()
|
||||
hydrateSessionOwnerHints()
|
||||
expect(getSessionOwnerHint('stored-a')).toBeUndefined()
|
||||
expect(getSessionOwnerHint('stored-c')).toEqual({ connectionId: 'local', profile: 'omar' })
|
||||
})
|
||||
})
|
||||
|
||||
describe('knownSessionOwner', () => {
|
||||
afterEach(() => {
|
||||
_resetSessionOwnerHintsForTests({ storage: true })
|
||||
})
|
||||
|
||||
it('returns the EXACT route for a connection-tagged row, the bare profile otherwise', () => {
|
||||
const rows = [
|
||||
session({ connection_id: 'local', id: 'tagged', profile: 'omar' }),
|
||||
session({ id: 'untagged', profile: 'coder' }),
|
||||
session({ connection_id: ' ', id: 'blank-tag', profile: 'coder' })
|
||||
]
|
||||
|
||||
expect(knownSessionOwner(rows, 'tagged')).toEqual({ connectionId: 'local', profile: 'omar' })
|
||||
expect(knownSessionOwner(rows, 'untagged')).toBe('coder')
|
||||
expect(knownSessionOwner(rows, 'blank-tag')).toBe('coder')
|
||||
expect(knownSessionOwner(rows, null)).toBeUndefined()
|
||||
})
|
||||
|
||||
it('falls through to the EXACT hint route for an unlisted session', () => {
|
||||
const route = { connectionId: 'homelab', profile: 'worker', targetProfile: 'w' }
|
||||
|
||||
setSessionOwnerHint('hidden', route)
|
||||
|
||||
expect(knownSessionOwner([], 'hidden')).toEqual(route)
|
||||
})
|
||||
})
|
||||
|
||||
describe('computed $attentionSessionIds', () => {
|
||||
@@ -201,6 +295,39 @@ describe('shouldMigrateComposerScope', () => {
|
||||
})
|
||||
|
||||
describe('mergeSessionPage', () => {
|
||||
it('carries the owning connection onto a row that comes back untagged (local registry source)', () => {
|
||||
// A `local` registry source's rows are served by the primary aggregate as
|
||||
// plain local rows: the unified-list splice tags only non-local sources.
|
||||
// The refresh must not strip the exact owner the routed create stamped.
|
||||
const previous = [session({ connection_id: 'local', id: 'omar-1', last_active: 5, profile: 'omar' })]
|
||||
const incoming = [session({ id: 'omar-1', last_active: 5, profile: 'omar' })]
|
||||
|
||||
expect(mergeSessionPage(previous, incoming, [])[0]).toMatchObject({ connection_id: 'local', profile: 'omar' })
|
||||
})
|
||||
|
||||
it('drops the carried tag when the refreshed row names a different profile, and never overrides an incoming tag', () => {
|
||||
const previous = [
|
||||
session({ connection_id: 'local', id: 'moved', profile: 'omar' }),
|
||||
session({ connection_id: 'local', id: 'foreign', profile: 'omar' })
|
||||
]
|
||||
|
||||
const incoming = [
|
||||
session({ id: 'moved', profile: 'default' }),
|
||||
session({ connection_id: 'homelab', id: 'foreign', profile: 'omar' })
|
||||
]
|
||||
|
||||
const merged = mergeSessionPage(previous, incoming, [])
|
||||
expect(merged.find(s => s.id === 'moved')?.connection_id).toBeUndefined()
|
||||
expect(merged.find(s => s.id === 'foreign')?.connection_id).toBe('homelab')
|
||||
})
|
||||
|
||||
it('keeps reference identity when the carried tag is already present', () => {
|
||||
const previous = [session({ connection_id: 'local', id: 'same', last_active: 1, profile: 'omar' })]
|
||||
const incoming = [session({ connection_id: 'local', id: 'same', last_active: 1, profile: 'omar' })]
|
||||
|
||||
expect(mergeSessionPage(previous, incoming, [])[0]).toBe(incoming[0])
|
||||
})
|
||||
|
||||
it('returns the server page untouched when there is nothing to keep', () => {
|
||||
const previous = [session({ id: 'a' }), session({ id: 'b' })]
|
||||
const incoming = [session({ id: 'a' })]
|
||||
|
||||
@@ -6,11 +6,11 @@ import type { ContextSuggestion } from '@/app/types'
|
||||
import type { HermesConnection } from '@/global'
|
||||
import type { ChatMessage } from '@/lib/chat-messages'
|
||||
import { activeConnectionScopeSuffix, rescopeConnectionScopedStores } from '@/lib/connection-scoped'
|
||||
import { persistBoolean, persistString, storedBoolean, storedString } from '@/lib/storage'
|
||||
import { persistBoolean, persistString, readJson, storedBoolean, storedString, writeJson } from '@/lib/storage'
|
||||
import { syncCronModelImpactConnection } from '@/store/cron-model-impact-scope'
|
||||
import type { SessionInfo, UsageStats } from '@/types/hermes'
|
||||
|
||||
import type { SessionProfileRoute } from './session-request-router'
|
||||
import type { SessionOwnerRoute, SessionOwnerScope } from './session-request-router'
|
||||
import { clearUnreadOnOpen } from './session-unread-remote'
|
||||
|
||||
type Updater<T> = T | ((current: T) => T)
|
||||
@@ -132,16 +132,18 @@ export function knownSessionProfile(sessions: readonly SessionInfo[], sessionId:
|
||||
}
|
||||
|
||||
/**
|
||||
* The complete known owner of a session, including its registry connection
|
||||
* when the row or an open-time hint carries one. Session-scoped RPC callers
|
||||
* must use this instead of `knownSessionProfile`: two sources can expose the
|
||||
* same profile name, so returning only that name silently collapses the route
|
||||
* back to the local/profile-only path.
|
||||
* The complete known owner of a session: the EXACT route when the row is
|
||||
* connection-tagged (an optimistic row from a routed create, a foreign
|
||||
* registry row from the unified-list splice, or a tag mergeSessionPage carried
|
||||
* across a refresh), else the open-time / create-time owner hint when it
|
||||
* agrees with the row, else the bare profile. Session-scoped RPC callers must
|
||||
* use this instead of `knownSessionProfile`: two sources can expose the same
|
||||
* profile name, so returning only that name silently collapses the route back
|
||||
* to the local/profile-only path. The exact rungs are what let a session's
|
||||
* owner be reconstructed after the bounded hint map has evicted it or the app
|
||||
* relaunched.
|
||||
*/
|
||||
export function knownSessionOwner(
|
||||
sessions: readonly SessionInfo[],
|
||||
sessionId: null | string
|
||||
): SessionProfileRoute | string | undefined {
|
||||
export function knownSessionOwner(sessions: readonly SessionInfo[], sessionId: null | string): SessionOwnerScope {
|
||||
if (!sessionId) {
|
||||
return undefined
|
||||
}
|
||||
@@ -457,6 +459,24 @@ export function resolveComposerSessionKey(
|
||||
* either its live `id` or its `_lineage_root_id`. Optimistic deletes/archives
|
||||
* drop the row from `previous` (and unpin it), so a removed session can't be
|
||||
* resurrected here. */
|
||||
const profileKeyOf = (profile: null | string | undefined): string => (profile ?? '').trim() || 'default'
|
||||
|
||||
function carriedConnectionId(prev: SessionInfo | undefined, incoming: SessionInfo): string | undefined {
|
||||
if (incoming.connection_id?.trim()) {
|
||||
return incoming.connection_id
|
||||
}
|
||||
|
||||
const carried = prev?.connection_id?.trim()
|
||||
|
||||
if (!carried) {
|
||||
return undefined
|
||||
}
|
||||
|
||||
return !incoming.profile?.trim() || profileKeyOf(incoming.profile) === profileKeyOf(prev?.profile)
|
||||
? carried
|
||||
: undefined
|
||||
}
|
||||
|
||||
export function mergeSessionPage(
|
||||
previous: SessionInfo[],
|
||||
incoming: SessionInfo[],
|
||||
@@ -480,8 +500,19 @@ export function mergeSessionPage(
|
||||
// (last_active = MAX(messages.timestamp)). Keep the fresher of the two.
|
||||
const last_active = Math.max(prev?.last_active ?? 0, session.last_active ?? 0)
|
||||
const title = session.title?.trim() ? session.title : prev?.title?.trim() ? prev.title : session.title
|
||||
// Carry the owning connection onto a row that arrives untagged. The
|
||||
// primary aggregate serves a `local` registry source's rows as plain
|
||||
// local rows (the unified-list splice tags only NON-local sources), so
|
||||
// the first refresh after a routed create used to replace the optimistic
|
||||
// row's exact owner (connection_id + profile) with a bare profile — after
|
||||
// which only the transient owner hint knew which socket held the runtime.
|
||||
// A refresh is new information layered over what we know, not a clobber;
|
||||
// the tag is kept only while the row still names the same profile.
|
||||
const connection_id = carriedConnectionId(prev, session)
|
||||
|
||||
return last_active === session.last_active && title === session.title ? session : { ...session, last_active, title }
|
||||
return last_active === session.last_active && title === session.title && connection_id === session.connection_id
|
||||
? session
|
||||
: { ...session, last_active, title, ...(connection_id ? { connection_id } : {}) }
|
||||
})
|
||||
|
||||
if (keep.size === 0) {
|
||||
@@ -657,31 +688,53 @@ export const $awaitingResponse = atom(false)
|
||||
// Null whenever the active route has a healthy (or in-flight) resume.
|
||||
export const $resumeFailedSessionId = atom<string | null>(null)
|
||||
export interface SessionResumeRequest {
|
||||
ownerRoute?: SessionProfileRoute
|
||||
ownerRoute?: SessionOwnerRoute
|
||||
sequence: number
|
||||
sessionId: string
|
||||
}
|
||||
let sessionResumeRequestSequence = 0
|
||||
export const $sessionResumeRequest = atom<SessionResumeRequest | null>(null)
|
||||
// ── Exact session owner hints ───────────────────────────────────────────────
|
||||
// The (connectionId, profile[, targetProfile, mode]) route a session was
|
||||
// created / resumed / opened on, keyed by stored id. Bounded LRU and
|
||||
// PERSISTED (best-effort, same origin storage as the tiles): the runtime a
|
||||
// routed create minted lives on one concrete socket, and after the sidebar
|
||||
// refresh replaced the optimistic row, or after a relaunch, this record is
|
||||
// how the exact owner is reconstructed for that session's next RPC instead of
|
||||
// degrading to a bare profile name that dials a different socket. Connection
|
||||
// ids are stable registry identities (`local`, registry uuids), so a hint
|
||||
// stays valid across restarts; forgetSessionOwnerHintsForConnection drops
|
||||
// them when a connection is removed from the registry.
|
||||
const SESSION_OWNER_HINT_LIMIT = 256
|
||||
const sessionOwnerHints = new Map<string, { id: string; route: SessionProfileRoute }>()
|
||||
const SESSION_OWNER_HINTS_KEY = 'hermes.desktop.sessionOwnerHints.v1'
|
||||
const sessionOwnerHints = new Map<string, { id: string; route: SessionOwnerRoute }>()
|
||||
|
||||
function sessionOwnerHintKey(sessionId: string, route: Pick<SessionProfileRoute, 'connectionId' | 'profile'>): string {
|
||||
function sessionOwnerHintKey(sessionId: string, route: Pick<SessionOwnerRoute, 'connectionId' | 'profile'>): string {
|
||||
return JSON.stringify([route.connectionId.trim(), route.profile.trim() || 'default', sessionId])
|
||||
}
|
||||
|
||||
export function setSessionOwnerHint(sessionId: string, route: SessionProfileRoute): void {
|
||||
const id = sessionId.trim()
|
||||
|
||||
const normalized = {
|
||||
function normalizeOwnerRoute(route: SessionOwnerRoute): SessionOwnerRoute {
|
||||
return {
|
||||
...route,
|
||||
connectionId: route.connectionId.trim(),
|
||||
profile: route.profile.trim() || 'default',
|
||||
...(route.targetProfile ? { targetProfile: route.targetProfile.trim() || 'default' } : {})
|
||||
}
|
||||
}
|
||||
|
||||
function persistSessionOwnerHints(): void {
|
||||
writeJson(
|
||||
SESSION_OWNER_HINTS_KEY,
|
||||
sessionOwnerHints.size === 0 ? null : [...sessionOwnerHints.values()].map(entry => [entry.id, entry.route])
|
||||
)
|
||||
}
|
||||
|
||||
function rememberSessionOwnerHint(sessionId: string, route: SessionOwnerRoute): boolean {
|
||||
const id = sessionId.trim()
|
||||
const normalized = normalizeOwnerRoute(route)
|
||||
|
||||
if (!id || !normalized.connectionId) {
|
||||
return
|
||||
return false
|
||||
}
|
||||
|
||||
const key = sessionOwnerHintKey(id, normalized)
|
||||
@@ -697,9 +750,89 @@ export function setSessionOwnerHint(sessionId: string, route: SessionProfileRout
|
||||
|
||||
sessionOwnerHints.delete(oldest)
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
export function getSessionOwnerHints(sessionId: string): SessionProfileRoute[] {
|
||||
/** Load persisted hints (oldest first, so LRU order survives). Malformed or
|
||||
* foreign-shaped entries are skipped; nothing here can throw. */
|
||||
export function hydrateSessionOwnerHints(): void {
|
||||
const raw = readJson<unknown>(SESSION_OWNER_HINTS_KEY)
|
||||
|
||||
if (!Array.isArray(raw)) {
|
||||
return
|
||||
}
|
||||
|
||||
for (const entry of raw) {
|
||||
if (!Array.isArray(entry) || entry.length !== 2) {
|
||||
continue
|
||||
}
|
||||
|
||||
const [id, route] = entry as [unknown, unknown]
|
||||
|
||||
if (
|
||||
typeof id !== 'string' ||
|
||||
!route ||
|
||||
typeof route !== 'object' ||
|
||||
typeof (route as SessionOwnerRoute).connectionId !== 'string' ||
|
||||
typeof (route as SessionOwnerRoute).profile !== 'string'
|
||||
) {
|
||||
continue
|
||||
}
|
||||
|
||||
const candidate = route as SessionOwnerRoute
|
||||
|
||||
rememberSessionOwnerHint(id, {
|
||||
connectionId: candidate.connectionId,
|
||||
profile: candidate.profile,
|
||||
...(typeof candidate.targetProfile === 'string' ? { targetProfile: candidate.targetProfile } : {}),
|
||||
...(candidate.mode === 'local' || candidate.mode === 'remote' ? { mode: candidate.mode } : {})
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
hydrateSessionOwnerHints()
|
||||
|
||||
export function setSessionOwnerHint(sessionId: string, route: SessionOwnerRoute): void {
|
||||
if (rememberSessionOwnerHint(sessionId, route)) {
|
||||
persistSessionOwnerHints()
|
||||
}
|
||||
}
|
||||
|
||||
/** Drop every hint naming `connectionId` — the registry no longer has it, so
|
||||
* nothing can dial that route again (fail-closed would otherwise pin those
|
||||
* sessions to a dead source forever). */
|
||||
export function forgetSessionOwnerHintsForConnection(connectionId: string): void {
|
||||
const id = connectionId.trim()
|
||||
|
||||
if (!id) {
|
||||
return
|
||||
}
|
||||
|
||||
let changed = false
|
||||
|
||||
for (const [key, entry] of [...sessionOwnerHints]) {
|
||||
if (entry.route.connectionId === id) {
|
||||
sessionOwnerHints.delete(key)
|
||||
changed = true
|
||||
}
|
||||
}
|
||||
|
||||
if (changed) {
|
||||
persistSessionOwnerHints()
|
||||
}
|
||||
}
|
||||
|
||||
/** @internal Tests: forget every in-memory hint (storage untouched unless asked). */
|
||||
export function _resetSessionOwnerHintsForTests({ storage = false }: { storage?: boolean } = {}): void {
|
||||
sessionOwnerHints.clear()
|
||||
|
||||
if (storage) {
|
||||
writeJson(SESSION_OWNER_HINTS_KEY, null)
|
||||
}
|
||||
}
|
||||
|
||||
export function getSessionOwnerHints(sessionId: string): SessionOwnerRoute[] {
|
||||
const id = sessionId.trim()
|
||||
|
||||
return [...sessionOwnerHints.values()].filter(entry => entry.id === id).map(entry => ({ ...entry.route }))
|
||||
@@ -707,8 +840,8 @@ export function getSessionOwnerHints(sessionId: string): SessionProfileRoute[] {
|
||||
|
||||
export function getSessionOwnerHint(
|
||||
sessionId: string,
|
||||
scope?: Pick<SessionProfileRoute, 'connectionId' | 'profile'>
|
||||
): SessionProfileRoute | undefined {
|
||||
scope?: Pick<SessionOwnerRoute, 'connectionId' | 'profile'>
|
||||
): SessionOwnerRoute | undefined {
|
||||
const id = sessionId.trim()
|
||||
|
||||
if (scope) {
|
||||
@@ -896,7 +1029,7 @@ export const setMessages = (next: Updater<ChatMessage[]>) => updateAtom($message
|
||||
export const setFreshDraftReady = (next: Updater<boolean>) => updateAtom($freshDraftReady, next)
|
||||
export const setResumeFailedSessionId = (next: Updater<string | null>) => updateAtom($resumeFailedSessionId, next)
|
||||
|
||||
export const requestSessionResume = (sessionId: string, ownerRoute?: SessionProfileRoute) => {
|
||||
export const requestSessionResume = (sessionId: string, ownerRoute?: SessionOwnerRoute) => {
|
||||
const id = sessionId.trim()
|
||||
|
||||
if (!id) {
|
||||
|
||||
@@ -15,6 +15,23 @@ vi.mock('@/lib/storage', () => ({
|
||||
storage.set(key, value)
|
||||
}
|
||||
},
|
||||
// store/session persists its exact owner hints through the JSON helpers.
|
||||
readJson: (key: string) => {
|
||||
const value = storage.get(key)
|
||||
|
||||
try {
|
||||
return value === undefined ? null : JSON.parse(value)
|
||||
} catch {
|
||||
return null
|
||||
}
|
||||
},
|
||||
writeJson: (key: string, value: unknown) => {
|
||||
if (value === null) {
|
||||
storage.delete(key)
|
||||
} else {
|
||||
storage.set(key, JSON.stringify(value))
|
||||
}
|
||||
},
|
||||
storedBoolean: (key: string, fallback: boolean) => {
|
||||
const value = storage.get(key)
|
||||
|
||||
|
||||
Reference in New Issue
Block a user