Import AITURK IDE 1.0.0-beta.1 from Hermes 63279301; preserve MIT license

apps/desktop/src/store/session-states-runtime-map.test.ts

@@ -0,0 +1,214 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+import { createClientSessionState } from '@/lib/chat-runtime'
+import { $connectionsRegistry } from '@/store/connection-registry-state'
+import { setPrimaryGateway, setPrimaryGatewayConnection } from '@/store/gateway'
+import { $profiles } from '@/store/profile'
+import { _resetSessionOwnerHintsForTests, setSessionOwnerHint, setSessions } from '@/store/session'
+import { isSessionOwnerResolutionError } from '@/store/session-owner-resolution'
+import {
+  $sessionTiles,
+  clearAllSessionStates,
+  dropSessionState,
+  knownOwnerForSession,
+  publishSessionState,
+  recordSessionEventScope,
+  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
+// STORED id. requestGateway (contrib/wiring) routes by the RPC's own target
+// session — which requires this translation. Before the fix it routed by the
+// WINDOW's focused tile, so a background bot chat's submit dispatched on
+// whatever backend the focused pane owned: the bot ran on the default
+// backend, or 4001'd when default didn't hold the session.
+
+describe('storedSessionIdForRuntimeId', () => {
+  afterEach(() => {
+    $sessionTiles.set([])
+  })
+
+  it('maps a runtime id to the stored id of the tile bound to it', () => {
+    $sessionTiles.set([
+      { runtimeId: 'rt-default', storedSessionId: 'stored-default' },
+      { runtimeId: 'rt-developer', storedSessionId: 'stored-developer' }
+    ])
+
+    expect(storedSessionIdForRuntimeId('rt-developer')).toBe('stored-developer')
+    expect(storedSessionIdForRuntimeId('rt-default')).toBe('stored-default')
+  })
+
+  it('passes a stored id through unchanged (callers may hold either identity)', () => {
+    $sessionTiles.set([{ runtimeId: 'rt-a', storedSessionId: 'stored-a' }])
+
+    expect(storedSessionIdForRuntimeId('stored-a')).toBe('stored-a')
+  })
+
+  it('returns null for an unknown id so the caller falls back to ambient routing', () => {
+    $sessionTiles.set([{ runtimeId: 'rt-a', storedSessionId: 'stored-a' }])
+
+    expect(storedSessionIdForRuntimeId('rt-unknown')).toBeNull()
+    expect(storedSessionIdForRuntimeId('')).toBeNull()
+  })
+
+  it('ignores tiles with no runtime binding instead of matching undefined ids', () => {
+    // A drafted/never-resumed tile has no runtimeId. Looking up an undefined-ish
+    // id must not accidentally claim that tile.
+    $sessionTiles.set([{ storedSessionId: 'stored-unbound' }, { runtimeId: 'rt-b', storedSessionId: 'stored-b' }])
+
+    expect(storedSessionIdForRuntimeId('rt-b')).toBe('stored-b')
+    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
+    // authoritative (durable identity wins).
+    $sessionTiles.set([
+      { runtimeId: 'collision', storedSessionId: 'stored-other' },
+      { runtimeId: 'rt-live', storedSessionId: 'collision' }
+    ])
+
+    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' })
+  })
+
+  it('routes a connection-tagged orphan runtime through the owner its inbound event recorded (#97511)', () => {
+    // Registry topology, multiple profiles, no tile/hint/row binding for the
+    // runtime — the approval.request event itself proved the exact owner.
+    $profiles.set([{ name: 'default' }, { name: 'omar' }] as never)
+    recordSessionEventScope({ connectionId: 'homelab', profile: 'omar', session_id: 'rt-unbound' })
+
+    expect(knownOwnerForSession('rt-unbound')).toEqual({ connectionId: 'homelab', profile: 'omar' })
+
+    // An event without a profile tag still records the 'default' convention
+    // every other owner source uses.
+    recordSessionEventScope({ connectionId: 'homelab', session_id: 'rt-unprofiled' })
+    expect(knownOwnerForSession('rt-unprofiled')).toEqual({ connectionId: 'homelab', profile: 'default' })
+  })
+
+  it('still prefers the durable stored owner when a stale runtime ledger entry collides with a stored id (#97511)', () => {
+    // Pathological collision: some dead runtime's id equals a live stored id.
+    // The persisted hint (durable identity) must outrank the ledger entry.
+    setSessionOwnerHint('stored-live', { connectionId: 'local', profile: 'omar' })
+    recordSessionEventScope({ connectionId: 'spark', profile: 'default', session_id: 'stored-live' })
+
+    expect(knownOwnerForSession('stored-live')).toEqual({ connectionId: 'local', profile: 'omar' })
+  })
+
+  it('keeps failing closed for untagged or unknown runtimes in multi-profile topology (#97511)', () => {
+    $profiles.set([{ name: 'default' }, { name: 'omar' }] as never)
+    // Untagged events carry no connectionId and record nothing.
+    recordSessionEventScope({ profile: 'omar', session_id: 'rt-untagged' })
+
+    expect(knownOwnerForSession('rt-untagged')).toBeUndefined()
+    expect(knownOwnerForSession('rt-never-seen')).toBeUndefined()
+  })
+
+  it('drops the recorded event owner together with the runtime state (#97511)', () => {
+    recordSessionEventScope({ connectionId: 'homelab', profile: 'omar', session_id: 'rt-dropped' })
+    expect(knownOwnerForSession('rt-dropped')).toEqual({ connectionId: 'homelab', profile: 'omar' })
+
+    dropSessionState('rt-dropped')
+    expect(knownOwnerForSession('rt-dropped')).toBeUndefined()
+  })
+
+  it('answers an approval on a sole-local registry install through the primary socket (#96394)', async () => {
+    // The reported topology: a modern Desktop (connections bridge present,
+    // registry loaded with exactly one `local` connection), one profile, and
+    // an approval.request whose runtime id has no tile / hint / row binding.
+    // hasRegistryTopology() is true here, so the ambient escape hatch is
+    // closed by design — the exact owner must come from the event itself.
+    ;(window as unknown as { hermesDesktop: unknown }).hermesDesktop = { connections: { list: async () => null } }
+    $connectionsRegistry.set({
+      activeConnectionId: 'local',
+      connections: [{ id: 'local', kind: 'local', label: 'Local' }]
+    } as never)
+    $profiles.set([{ name: 'default' }] as never)
+
+    const primaryRequest = vi.fn(async (method: string, params: unknown) => ({ method, params, via: 'primary' }))
+
+    setPrimaryGateway({ onEvent: () => () => undefined, request: primaryRequest, state: 'open' } as never, 'default')
+    setPrimaryGatewayConnection({ connectionId: 'local' })
+
+    const ambient = vi.fn(async () => ({ via: 'ambient' }))
+
+    try {
+      // Before the event lands the owner is unknown and routing still fails closed.
+      await expect(
+        requestForOwnedSession('rt-approval', ambient as never, 'approval.respond', { session_id: 'rt-approval' })
+      ).rejects.toSatisfy(isSessionOwnerResolutionError)
+
+      // use-gateway-boot stamps every primary event with the active connection
+      // id (Electron resolves the sole local connection to `local`).
+      recordSessionEventScope({ connectionId: 'local', profile: 'default', session_id: 'rt-approval' })
+
+      await expect(
+        requestForOwnedSession('rt-approval', ambient as never, 'approval.respond', { session_id: 'rt-approval' })
+      ).resolves.toEqual({ method: 'approval.respond', params: { session_id: 'rt-approval' }, via: 'primary' })
+      expect(ambient).not.toHaveBeenCalled()
+    } finally {
+      setPrimaryGateway(null)
+      $connectionsRegistry.set(null)
+      delete (window as unknown as { hermesDesktop?: unknown }).hermesDesktop
+    }
+  })
+})