From 61fcab146cc9c8f4b17676b814038dc4c8858844 Mon Sep 17 00:00:00 2001 From: Lucas Coutinho Date: Mon, 9 Nov 2026 23:34:03 -0300 Subject: [PATCH 1/4] fix(web): refuse commands on closed browser sessions --- ...gent-browser-provider-fleet-record.test.ts | 80 +++++++++++++++++++ .../platform-web/src/agent-browser-fleet.ts | 16 +++- .../src/agent-browser-provider.ts | 18 ++++- website/docs/docs/sessions.md | 4 + 4 files changed, 113 insertions(+), 5 deletions(-) diff --git a/packages/platform-web/src/__tests__/agent-browser-provider-fleet-record.test.ts b/packages/platform-web/src/__tests__/agent-browser-provider-fleet-record.test.ts index 56c350cbc4..e2a6391b1d 100644 --- a/packages/platform-web/src/__tests__/agent-browser-provider-fleet-record.test.ts +++ b/packages/platform-web/src/__tests__/agent-browser-provider-fleet-record.test.ts @@ -9,6 +9,7 @@ import { type CommandExecutorOverride, } from '@agent-device/host-kit/command'; import { createAgentBrowserWebProvider } from '../agent-browser-provider.ts'; +import { AppError } from '@agent-device/kernel/errors'; import { agentBrowserJsonResult, installFakeManagedAgentBrowser, @@ -63,6 +64,7 @@ function createTwoSessionDaemon() { }); return { store, + providerOf, a: providerOf('session-a'), b: providerOf('session-b'), setPublished: (names: string[]) => { @@ -71,6 +73,84 @@ function createTwoSessionDaemon() { }; } +test('a closed browser refuses later requests from new providers until an explicit reopen', async () => { + const daemon = createTwoSessionDaemon(); + const commands: string[] = []; + await withCommandExecutorOverride( + async (_command, args) => { + commands.push(managedAgentBrowserCliArgs(args)[0]!); + return agentBrowserJsonResult({ success: true, data: {} }); + }, + async () => { + await daemon.a.open('about:blank'); + await daemon.a.close(); + daemon.setPublished([]); + const closed = daemon.providerOf('session-a'); + for (const command of [ + () => closed.snapshot(), + () => closed.screenshot('/tmp/closed.png'), + () => closed.clickRef!('@e1'), + ]) { + await assert.rejects(command, (error: unknown) => { + assert.ok(error instanceof AppError); + assert.equal(error.code, 'SESSION_NOT_FOUND'); + assert.equal(error.details?.reason, 'web_session_closed'); + assert.equal(error.details?.dispatched, 'no'); + return true; + }); + } + assert.deepEqual(commands, ['open', 'close']); + await daemon.b.snapshot(); + await closed.open('about:blank'); + await daemon.providerOf('session-a').snapshot(); + assert.deepEqual(commands, ['open', 'close', 'snapshot', 'open', 'snapshot']); + }, + ); +}); + +test('a failed reopen does not authorize calls on a closed browser', async () => { + const daemon = createTwoSessionDaemon(); + await withCommandExecutorOverride(succeedingBackend, async () => { + await daemon.a.open('about:blank'); + await daemon.a.close(); + }); + daemon.setPublished([]); + await withCommandExecutorOverride( + async () => agentBrowserJsonResult({ success: false, error: 'open failed' }, 1), + async () => { + await assert.rejects(() => daemon.a.open('about:blank')); + }, + ); + let calls = 0; + await withCommandExecutorOverride( + async () => { + calls += 1; + return agentBrowserJsonResult({ success: true, data: {} }); + }, + async () => { + await assert.rejects(() => daemon.providerOf('session-a').snapshot(), { + code: 'SESSION_NOT_FOUND', + }); + }, + ); + assert.equal(calls, 0); +}); + +test('a failed close leaves browser requests available for cleanup and retry', async () => { + const daemon = createTwoSessionDaemon(); + await withCommandExecutorOverride( + async (_command, args) => + managedAgentBrowserCliArgs(args)[0] === 'close' + ? agentBrowserJsonResult({ success: false, error: 'close failed' }, 1) + : agentBrowserJsonResult({ success: true, data: {} }), + async () => { + await daemon.a.open('about:blank'); + await assert.rejects(() => daemon.a.close()); + await daemon.providerOf('session-a').snapshot(); + }, + ); +}); + test('a close that ends while another session is opening keeps the fleet record', async () => { const daemon = createTwoSessionDaemon(); const openStarted = createGate(); diff --git a/packages/platform-web/src/agent-browser-fleet.ts b/packages/platform-web/src/agent-browser-fleet.ts index 2eac61aac0..8dbb9b75fe 100644 --- a/packages/platform-web/src/agent-browser-fleet.ts +++ b/packages/platform-web/src/agent-browser-fleet.ts @@ -21,8 +21,10 @@ export type AgentBrowserFleet = Readonly<{ openStarted(session: string): void; /** The `open` for `session` ended; `launched` is whether the browser is up. */ openSettled(session: string, launched: boolean): void; - /** The browser of `session` was closed. */ - closed(session: string): void; + /** A close for `session` completed, with or without a successful backend result. */ + closed(session: string, succeeded: boolean): void; + /** A successful close revoked this browser until its next successful open. */ + wasClosed(session: string): boolean; /** Every launched browser exited without a close: drop them. Launching ones stay. */ evictLaunched(): void; /** The sessions whose browser is launching or up, whether or not the daemon published them. */ @@ -43,6 +45,7 @@ function createAgentBrowserFleet(): AgentBrowserFleet { const recordLocks = new Map>(); const opening = new Map(); const launched = new Set(); + const closed = new Set(); return Object.freeze({ updateRecord: async (task) => await withKeyedLock(recordLocks, RECORD_LOCK_KEY, task), openStarted(session) { @@ -52,11 +55,16 @@ function createAgentBrowserFleet(): AgentBrowserFleet { const remaining = (opening.get(session) ?? 1) - 1; if (remaining > 0) opening.set(session, remaining); else opening.delete(session); - if (browserUp) launched.add(session); + if (browserUp) { + launched.add(session); + closed.delete(session); + } }, - closed(session) { + closed(session, succeeded) { launched.delete(session); + if (succeeded) closed.add(session); }, + wasClosed: (session) => closed.has(session), evictLaunched() { launched.clear(); }, diff --git a/packages/platform-web/src/agent-browser-provider.ts b/packages/platform-web/src/agent-browser-provider.ts index 5a75d4e7ce..0bdfe84137 100644 --- a/packages/platform-web/src/agent-browser-provider.ts +++ b/packages/platform-web/src/agent-browser-provider.ts @@ -504,6 +504,21 @@ async function runAgentBrowserCommand( interpret: (result: { stdout: string; stderr: string; exitCode: number }) => unknown, run: AgentBrowserRunOptions, ): Promise { + if ( + cliArgs[0] !== 'open' && + options.ownedProcessRecords && + agentBrowserFleetOf(options.ownedProcessRecords).wasClosed(fleetSessionOf(options)) + ) { + throw new AppError( + 'SESSION_NOT_FOUND', + 'Browser session is closed. Run open before retrying.', + { + reason: 'web_session_closed', + dispatched: 'no', + hint: 'Run agent-device open --platform web with the same --session to reopen it.', + }, + ); + } let stdout = ''; let stderr = ''; let exitCode = 0; @@ -609,7 +624,8 @@ function settleFleetMembership( ): void { const succeeded = params.commandCompleted && params.semanticSuccess && params.exitCode === 0; if (params.cliArgs[0] === 'open') fleet.openSettled(session, succeeded); - else if (params.cliArgs[0] === 'close' && params.commandCompleted) fleet.closed(session); + else if (params.cliArgs[0] === 'close' && params.commandCompleted) + fleet.closed(session, succeeded); } /** diff --git a/website/docs/docs/sessions.md b/website/docs/docs/sessions.md index 9f3acd2eef..42a1379985 100644 --- a/website/docs/docs/sessions.md +++ b/website/docs/docs/sessions.md @@ -57,6 +57,10 @@ agent-device close --session my-session Don't run commands that change state in parallel on the same session. Run actions such as `open`, `press`, `fill`, `type`, `scroll`, `back`, `alert`, `replay`, `batch`, and `close` one at a time. +After you close a web session, later browser commands refuse with `SESSION_NOT_FOUND`, even when +you pass `--platform web`. The closed session stays out of `session list`. Use `open` to start it +again. A failed reopen keeps the closed session unavailable. + ## Lock a named session to a device A lock keeps a named session's commands on its device: per-call selectors that conflict with the From 82dd2307efa8a7a3b2122991d12d62d05eed4e8d Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Tue, 10 Nov 2026 20:19:10 +0000 Subject: [PATCH 2/4] fix(web): refuse closed browser sessions at the daemon seam A successful web close records the session on the daemon session store. Later non-open commands answer named_session_not_found before dispatch. Closing again succeeds and does not close the browser a second time. A session that was never opened still follows the device-selector path. Co-authored-by: Lucas Coutinho --- packages/daemon/src/core/session-store.ts | 20 ++ .../request-router-closed-web-session.test.ts | 225 ++++++++++++++++++ .../src/sessions/request-handler-chain.ts | 23 +- .../internal/session-close.ts | 61 ++++- .../internal/session-open-execution.ts | 1 + .../daemon/src/sessions/session-teardown.ts | 7 +- ...gent-browser-provider-fleet-record.test.ts | 80 ------- .../platform-web/src/agent-browser-fleet.ts | 16 +- .../src/agent-browser-provider.ts | 18 +- website/docs/docs/sessions.md | 7 +- 10 files changed, 339 insertions(+), 119 deletions(-) create mode 100644 packages/daemon/src/server/__tests__/request-router-closed-web-session.test.ts diff --git a/packages/daemon/src/core/session-store.ts b/packages/daemon/src/core/session-store.ts index cb1125a227..92d938d049 100644 --- a/packages/daemon/src/core/session-store.ts +++ b/packages/daemon/src/core/session-store.ts @@ -57,6 +57,12 @@ export type RetainedExecutionHost = Readonly<{ export class SessionStore { private readonly sessions = new Map(); + /** + * Addresses whose web browser close succeeded. The set lives on this store, so it ends when the + * daemon's store does: a restart starts without it. A failed close never enters it, and a + * successful open leaves it. + */ + private readonly closedWebSessions = new Set(); private readonly retainedExecutionHosts = new Map(); private acceptingSessions = true; private readonly runtimeHints = new Map(); @@ -166,6 +172,20 @@ export class SessionStore { return this.sessions.delete(ref.address); } + /** The web browser for `address` closed successfully. Later non-open commands refuse it. */ + markWebSessionClosed(address: string): void { + this.closedWebSessions.add(address); + } + + /** A successful open of `address` may use the browser again. */ + clearClosedWebSession(address: string): void { + this.closedWebSessions.delete(address); + } + + isWebSessionClosed(address: string): boolean { + return this.closedWebSessions.has(address); + } + listRetainedExecutionHosts(leaseId: string): RetainedExecutionHost[] { return Array.from(this.retainedExecutionHosts.values()).filter( (host) => host.lease.leaseId === leaseId, diff --git a/packages/daemon/src/server/__tests__/request-router-closed-web-session.test.ts b/packages/daemon/src/server/__tests__/request-router-closed-web-session.test.ts new file mode 100644 index 0000000000..e3a152f748 --- /dev/null +++ b/packages/daemon/src/server/__tests__/request-router-closed-web-session.test.ts @@ -0,0 +1,225 @@ +import fs from 'node:fs'; +import path from 'node:path'; +import { afterEach, beforeEach, expect, test, vi } from 'vitest'; +import { createTestDeviceInventoryGateways } from '@agent-device/device-selection/inventory-gateways-fixtures'; +import { + webSessionDevice, + type DeviceInfo, + type WebSessionIdentity, +} from '@agent-device/kernel/device'; +import { PRE_DISPATCH_REFUSAL_REASONS } from '@agent-device/kernel/errors'; +import { + WEB_DESKTOP_DEVICE, + createTestHostEnvironment, + mkdtempForTestSync, +} from '@agent-device/test-kit'; +import { getResolveTargetDeviceMock } from '../../__tests__/support/request-router-dispatch-mocks.ts'; +import { dispatchApplicationLifecycleEffect } from '../../__tests__/support/application-lifecycle-runtime-fixture.ts'; +import { fakeCreateCommandSurface } from '../../__tests__/support/command-surface-fake.ts'; +import { platformResourceCleanupFixture } from '../../__tests__/support/platform-resource-cleanup-fixture.ts'; +import { makeSessionStore } from '../../__tests__/support/store-factory.ts'; +import { + createLifecycleDeviceRuntimeGatewaySpies, + createRequestHandler, +} from '../../__tests__/support/test-device-runtime-gateway.ts'; +import type { DaemonRequest } from '../../core/daemon-request.ts'; +import { LeaseRegistry } from '../../resources/lease-registry.ts'; +import { teardownSessionResources } from '../../sessions/session-teardown.ts'; + +const mockResolveTargetDevice = vi.mocked(getResolveTargetDeviceMock()); + +const webSessionResolution = async ( + _flags: unknown, + options?: { webSession?: WebSessionIdentity }, +): Promise => + options?.webSession + ? webSessionDevice(WEB_DESKTOP_DEVICE, options.webSession) + : WEB_DESKTOP_DEVICE; + +beforeEach(() => { + mockResolveTargetDevice.mockReset(); + mockResolveTargetDevice.mockImplementation(webSessionResolution); + dispatchApplicationLifecycleEffect.mockReset(); + dispatchApplicationLifecycleEffect.mockImplementation(async () => undefined); +}); + +afterEach(() => { + dispatchApplicationLifecycleEffect.mockReset(); + dispatchApplicationLifecycleEffect.mockImplementation(async () => undefined); + vi.unstubAllEnvs(); +}); + +function closeEffectCount(): number { + return dispatchApplicationLifecycleEffect.mock.calls.filter((call) => call[1] === 'close').length; +} + +function webDaemon() { + const claimsDir = mkdtempForTestSync('agent-device-router-closed-web-claims-'); + vi.stubEnv('AGENT_DEVICE_CLAIMS_DIR', claimsDir); + const sessionStore = makeSessionStore('agent-device-router-closed-web-'); + const platformResourceCleanup = platformResourceCleanupFixture(); + const runtime = createLifecycleDeviceRuntimeGatewaySpies(); + const handler = createRequestHandler({ + host: createTestHostEnvironment(), + createCommandSurface: fakeCreateCommandSurface, + logPath: path.join(mkdtempForTestSync('daemon'), 'daemon.log'), + token: 'test-token', + sessionStore, + leaseRegistry: new LeaseRegistry(), + deviceRuntimeGateway: runtime.gateway, + deviceInventoryGateways: createTestDeviceInventoryGateways(), + platformResourceCleanup, + trackDownloadableArtifact: () => 'artifact-id', + }); + return { + claimsDir, + sessionStore, + platformResourceCleanup, + bind: runtime.bind, + handler, + }; +} + +function request( + session: string, + command: string, + positionals: string[] = [], + requestId = command, +): DaemonRequest { + return { + token: 'test-token', + session, + command, + positionals, + flags: { platform: 'web' }, + meta: { requestId: `req-${requestId}`, sessionExplicit: true }, + }; +} + +function closedSessionRefusal(session: string) { + return { + ok: false, + error: { + code: 'SESSION_NOT_FOUND', + details: { + reason: PRE_DISPATCH_REFUSAL_REASONS.namedSessionNotFound, + dispatched: 'no', + session, + }, + }, + }; +} + +test('a closed named web session refuses later browser commands and a second close does not close again', async () => { + const daemon = webDaemon(); + const session = 'closed-web'; + try { + expect(await daemon.handler(request(session, 'open', ['about:blank']))).toMatchObject({ + ok: true, + }); + const ref = daemon.sessionStore.lookup(session); + if (!ref) throw new Error('opened web session is missing'); + expect(await daemon.handler(request(session, 'close'))).toMatchObject({ ok: true }); + expect(daemon.sessionStore.get(session)).toBeUndefined(); + expect(daemon.sessionStore.isWebSessionClosed(session)).toBe(true); + await teardownSessionResources({ + appLog: 'already-settled', + ref, + sessionStore: daemon.sessionStore, + platformCleanup: daemon.platformResourceCleanup, + }); + expect(daemon.platformResourceCleanup.closeManagedBrowser).not.toHaveBeenCalled(); + const closesAfterFirst = closeEffectCount(); + const managedClosesAfterFirst = + daemon.platformResourceCleanup.closeManagedBrowser.mock.calls.length; + expect(closesAfterFirst).toBeGreaterThan(0); + const bindsAfterClose = daemon.bind.mock.calls.length; + + for (const command of [ + request(session, 'snapshot', [], 'snapshot'), + request(session, 'screenshot', ['/tmp/closed-web.png'], 'screenshot'), + request(session, 'click', ['@e1'], 'click'), + ]) { + expect(await daemon.handler(command)).toMatchObject(closedSessionRefusal(session)); + } + expect(daemon.bind.mock.calls.length).toBe(bindsAfterClose); + expect(closeEffectCount()).toBe(closesAfterFirst); + + expect(await daemon.handler(request(session, 'close', [], 'close-again'))).toMatchObject({ + ok: true, + }); + expect(closeEffectCount()).toBe(closesAfterFirst); + expect(daemon.platformResourceCleanup.closeManagedBrowser.mock.calls.length).toBe( + managedClosesAfterFirst, + ); + + const listed = await daemon.handler(request(session, 'session_list', [], 'list')); + expect(listed).toMatchObject({ ok: true, data: { sessions: [] } }); + } finally { + fs.rmSync(daemon.claimsDir, { recursive: true, force: true }); + } +}); + +test('a failed web close does not stick, and a failed reopen stays closed', async () => { + const daemon = webDaemon(); + const session = 'reopen-web'; + try { + expect(await daemon.handler(request(session, 'open', ['about:blank'], 'open-1'))).toMatchObject( + { ok: true }, + ); + dispatchApplicationLifecycleEffect.mockImplementation(async (_device, command) => { + if (command === 'close') throw new Error('close failed'); + }); + const failedClose = await daemon.handler(request(session, 'close', [], 'close-fail')); + expect(failedClose.ok).toBe(false); + expect(daemon.sessionStore.get(session)).toBeDefined(); + expect(daemon.sessionStore.isWebSessionClosed(session)).toBe(false); + + dispatchApplicationLifecycleEffect.mockImplementation(async () => undefined); + expect(await daemon.handler(request(session, 'close', [], 'close-retry'))).toMatchObject({ + ok: true, + }); + expect(daemon.sessionStore.isWebSessionClosed(session)).toBe(true); + + dispatchApplicationLifecycleEffect.mockImplementation(async (_device, command) => { + if (command === 'open') throw new Error('open failed'); + }); + const failedOpen = await daemon.handler(request(session, 'open', ['about:blank'], 'open-fail')); + expect(failedOpen.ok).toBe(false); + expect(daemon.sessionStore.isWebSessionClosed(session)).toBe(true); + expect(await daemon.handler(request(session, 'snapshot', [], 'snapshot-still'))).toMatchObject( + closedSessionRefusal(session), + ); + + dispatchApplicationLifecycleEffect.mockImplementation(async () => undefined); + expect(await daemon.handler(request(session, 'open', ['about:blank'], 'open-2'))).toMatchObject( + { ok: true }, + ); + expect(daemon.sessionStore.isWebSessionClosed(session)).toBe(false); + expect(daemon.sessionStore.get(session)?.device.platform).toBe('web'); + const reopened = await daemon.handler(request(session, 'snapshot', [], 'snapshot-open')); + if (!reopened.ok) { + expect(reopened.error.details?.reason).not.toBe( + PRE_DISPATCH_REFUSAL_REASONS.namedSessionNotFound, + ); + } + } finally { + fs.rmSync(daemon.claimsDir, { recursive: true, force: true }); + } +}); + +test('a named web session that was never opened is not answered as closed', async () => { + const daemon = webDaemon(); + const session = 'never-opened'; + try { + const response = await daemon.handler(request(session, 'snapshot')); + expect(daemon.sessionStore.isWebSessionClosed(session)).toBe(false); + if (!response.ok) { + expect(response.error.details?.reason).not.toBe( + PRE_DISPATCH_REFUSAL_REASONS.namedSessionNotFound, + ); + } + } finally { + fs.rmSync(daemon.claimsDir, { recursive: true, force: true }); + } +}); diff --git a/packages/daemon/src/sessions/request-handler-chain.ts b/packages/daemon/src/sessions/request-handler-chain.ts index 97b6236e15..1756c0a9be 100644 --- a/packages/daemon/src/sessions/request-handler-chain.ts +++ b/packages/daemon/src/sessions/request-handler-chain.ts @@ -6,7 +6,7 @@ import type { CommandFlags } from '@agent-device/contracts/command'; import type { CloudArtifactProvider } from '@agent-device/contracts/observability'; import { AppError } from '@agent-device/kernel/errors'; import type { DaemonCommandRoute } from '@agent-device/command-registry/daemon-command-descriptor'; -import { getDaemonCommandRoute } from '../core/daemon-command-registry.ts'; +import { getDaemonCommandRoute, getSessionCommandKind } from '../core/daemon-command-registry.ts'; import * as genericRequestHandlerModule from '../execution/request-generic-dispatch.ts'; import type { DaemonCommandContext } from '../core/context.ts'; import type { LeaseLifecycleProvider, ProviderAppCatalog } from '@agent-device/contracts/device'; @@ -126,9 +126,30 @@ const DAEMON_ROUTE_HANDLERS = { export type { DaemonCommandRoute }; +/** + * `batch` and `replay` re-enter this chain per step, so an `open` step can clear a closed web + * session. Inventory commands do not drive the browser. + */ +function closedWebSessionAllows(command: string): boolean { + return ( + command === 'open' || + command === 'close' || + command === 'batch' || + command === 'replay' || + getSessionCommandKind(command) === 'inventory' + ); +} + export async function runRequestHandlerChain( params: RequestHandlerChainParams, ): Promise { + if ( + !closedWebSessionAllows(params.req.command) && + params.sessionStore.isWebSessionClosed(params.sessionName) + ) { + const { namedSessionNotFoundError } = await import('../core/explicit-session-resolution.ts'); + throw namedSessionNotFoundError(params.sessionName); + } const route = getDaemonCommandRoute(params.req.command); return await DAEMON_ROUTE_HANDLERS[route].run(params); } diff --git a/packages/daemon/src/sessions/session-lifecycle/internal/session-close.ts b/packages/daemon/src/sessions/session-lifecycle/internal/session-close.ts index ba8459ee6e..8ffbcad0d6 100644 --- a/packages/daemon/src/sessions/session-lifecycle/internal/session-close.ts +++ b/packages/daemon/src/sessions/session-lifecycle/internal/session-close.ts @@ -87,9 +87,11 @@ async function prepareRepairClose(params: { const repairArmed = isRepairArmedSession(session); const closeReceipt = JSON.stringify(req.positionals ?? []); if (repairArmed && !hasRepairPlatformCloseReceipt(session, closeReceipt)) { - const platformCloseError = await dispatchTargetedPlatformClose({ + const platformCloseError = await closePlatformObservingWebSession({ req, session, + sessionName: ref.address, + sessionStore, logPath, lifecycle, }); @@ -183,6 +185,24 @@ async function releaseProviderLeaseForClose(params: { } } +async function closePlatformObservingWebSession(params: { + req: DaemonRequest; + session: SessionState; + sessionName: string; + sessionStore: SessionStore; + logPath: string; + lifecycle: CloseRuntime | CloseRuntimeWithRuntimeHintClear; +}): Promise { + if (isWebSession(params.session) && params.sessionStore.isWebSessionClosed(params.sessionName)) { + return undefined; + } + const error = await dispatchTargetedPlatformClose(params); + if (!error && isWebSession(params.session)) { + params.sessionStore.markWebSessionClosed(params.sessionName); + } + return error; +} + async function dispatchTargetedPlatformClose(params: { req: DaemonRequest; session: SessionState; @@ -278,6 +298,7 @@ export async function handleSessionCloseCommands( return await closeWithoutSession({ req, sessionName, + sessionStore, logPath, env: params.host.env, inspectFacts: params.inspectFacts, @@ -325,6 +346,8 @@ export async function handleSessionCloseCommands( return await closeAppWithoutEndingSession({ req, session, + sessionName, + sessionStore, logPath, lifecycle: admission.runtime, app, @@ -435,7 +458,12 @@ async function runCloseTeardownAndRelease(params: { clearRuntimeHints, cleanupFailures, repairArmed: params.repairArmed, - dispatchTargetedPlatformClose, + dispatchTargetedPlatformClose: (closeParams) => + closePlatformObservingWebSession({ + ...closeParams, + sessionName: ref.address, + sessionStore, + }), finalizeOrdinaryCloseScript, platformResourceCleanup: params.platformResourceCleanup, }); @@ -529,14 +557,18 @@ function buildCloseSuccessResponse(params: { async function closeAppWithoutEndingSession(params: { req: DaemonRequest; session: SessionState; + sessionName: string; + sessionStore: SessionStore; logPath: string; lifecycle: CloseRuntime | CloseRuntimeWithRuntimeHintClear; app: string; }): Promise { - const { req, session, logPath, lifecycle, app } = params; - const platformCloseError = await dispatchTargetedPlatformClose({ + const { req, session, sessionName, sessionStore, logPath, lifecycle, app } = params; + const platformCloseError = await closePlatformObservingWebSession({ req, session, + sessionName, + sessionStore, logPath, lifecycle, }); @@ -553,13 +585,32 @@ async function closeAppWithoutEndingSession(params: { async function closeWithoutSession(params: { req: DaemonRequest; sessionName: string; + sessionStore: SessionStore; logPath: string; env: EnvMap; inspectFacts?: InspectDeviceRuntimeFacts; platformServices: DaemonPlatformServices; bindDevice?: BindDeviceRuntime; }): Promise { - const { req, sessionName, logPath, env, inspectFacts, bindDevice, platformServices } = params; + const { + req, + sessionName, + sessionStore, + logPath, + env, + inspectFacts, + bindDevice, + platformServices, + } = params; + if (sessionStore.isWebSessionClosed(sessionName)) { + return { + ok: true, + data: { + session: sessionName, + ...successText(`Closed: ${sessionName}`), + }, + }; + } const { requireNamedSessionHoldsDevice } = await import('../../../core/explicit-session-resolution.ts'); requireNamedSessionHoldsDevice({ req, sessionAddress: sessionName, session: undefined }); diff --git a/packages/daemon/src/sessions/session-lifecycle/internal/session-open-execution.ts b/packages/daemon/src/sessions/session-lifecycle/internal/session-open-execution.ts index 20cc3599ef..8bc8355cc4 100644 --- a/packages/daemon/src/sessions/session-lifecycle/internal/session-open-execution.ts +++ b/packages/daemon/src/sessions/session-lifecycle/internal/session-open-execution.ts @@ -300,6 +300,7 @@ export async function completeOpenCommand(params: { openDispatchSession?.trace?.outPath, ), }); + if (device.platform === 'web') sessionStore.clearClosedWebSession(sessionName); sessionAppBundleId = outcome.appBundleId ?? sessionAppBundleId; const timing: OpenTiming = { ...outcome.timing }; const preparedSelection = markSelectionBootOccurred(selection); diff --git a/packages/daemon/src/sessions/session-teardown.ts b/packages/daemon/src/sessions/session-teardown.ts index 912cd24e91..67ea0317da 100644 --- a/packages/daemon/src/sessions/session-teardown.ts +++ b/packages/daemon/src/sessions/session-teardown.ts @@ -12,7 +12,8 @@ import type { SessionStore } from '../core/session-store.ts'; import { finishLiveAudioProbe } from '@agent-device/capture-kit/audio-probe-session-resource'; import { finishLivePerfCapture } from '@agent-device/capture-kit/perf-capture-session-resource'; import { finishLiveScreenRecording } from '@agent-device/capture-kit/screen-recording-session-resource'; -import { openWebSessionNames } from './web-session-names.ts'; +import { webBackendKeyOf } from '@agent-device/kernel/device'; +import { isWebSession, openWebSessionNames } from './web-session-names.ts'; import type { PlatformResourceCleanup } from '../core/platform-resource-cleanup.ts'; export async function stopSessionAppLog(params: { @@ -49,11 +50,15 @@ async function stopSessionWebBrowser(params: { }): Promise { const { ref, sessionStore, platformCleanup } = params; const session = sessionStore.resolveCurrent(ref) ?? ref.session; + if (isWebSession(session) && sessionStore.isWebSessionClosed(ref.address)) return; await platformCleanup.closeManagedBrowser({ device: session.device, stateDir: sessionStore.resolveDaemonStateDir(), openSessionNames: () => openWebSessionNames(sessionStore), }); + if (isWebSession(session) && webBackendKeyOf(session.device.id) !== undefined) { + sessionStore.markWebSessionClosed(ref.address); + } } export type SessionCleanupStep = { step: string; run: () => Promise }; diff --git a/packages/platform-web/src/__tests__/agent-browser-provider-fleet-record.test.ts b/packages/platform-web/src/__tests__/agent-browser-provider-fleet-record.test.ts index e2a6391b1d..56c350cbc4 100644 --- a/packages/platform-web/src/__tests__/agent-browser-provider-fleet-record.test.ts +++ b/packages/platform-web/src/__tests__/agent-browser-provider-fleet-record.test.ts @@ -9,7 +9,6 @@ import { type CommandExecutorOverride, } from '@agent-device/host-kit/command'; import { createAgentBrowserWebProvider } from '../agent-browser-provider.ts'; -import { AppError } from '@agent-device/kernel/errors'; import { agentBrowserJsonResult, installFakeManagedAgentBrowser, @@ -64,7 +63,6 @@ function createTwoSessionDaemon() { }); return { store, - providerOf, a: providerOf('session-a'), b: providerOf('session-b'), setPublished: (names: string[]) => { @@ -73,84 +71,6 @@ function createTwoSessionDaemon() { }; } -test('a closed browser refuses later requests from new providers until an explicit reopen', async () => { - const daemon = createTwoSessionDaemon(); - const commands: string[] = []; - await withCommandExecutorOverride( - async (_command, args) => { - commands.push(managedAgentBrowserCliArgs(args)[0]!); - return agentBrowserJsonResult({ success: true, data: {} }); - }, - async () => { - await daemon.a.open('about:blank'); - await daemon.a.close(); - daemon.setPublished([]); - const closed = daemon.providerOf('session-a'); - for (const command of [ - () => closed.snapshot(), - () => closed.screenshot('/tmp/closed.png'), - () => closed.clickRef!('@e1'), - ]) { - await assert.rejects(command, (error: unknown) => { - assert.ok(error instanceof AppError); - assert.equal(error.code, 'SESSION_NOT_FOUND'); - assert.equal(error.details?.reason, 'web_session_closed'); - assert.equal(error.details?.dispatched, 'no'); - return true; - }); - } - assert.deepEqual(commands, ['open', 'close']); - await daemon.b.snapshot(); - await closed.open('about:blank'); - await daemon.providerOf('session-a').snapshot(); - assert.deepEqual(commands, ['open', 'close', 'snapshot', 'open', 'snapshot']); - }, - ); -}); - -test('a failed reopen does not authorize calls on a closed browser', async () => { - const daemon = createTwoSessionDaemon(); - await withCommandExecutorOverride(succeedingBackend, async () => { - await daemon.a.open('about:blank'); - await daemon.a.close(); - }); - daemon.setPublished([]); - await withCommandExecutorOverride( - async () => agentBrowserJsonResult({ success: false, error: 'open failed' }, 1), - async () => { - await assert.rejects(() => daemon.a.open('about:blank')); - }, - ); - let calls = 0; - await withCommandExecutorOverride( - async () => { - calls += 1; - return agentBrowserJsonResult({ success: true, data: {} }); - }, - async () => { - await assert.rejects(() => daemon.providerOf('session-a').snapshot(), { - code: 'SESSION_NOT_FOUND', - }); - }, - ); - assert.equal(calls, 0); -}); - -test('a failed close leaves browser requests available for cleanup and retry', async () => { - const daemon = createTwoSessionDaemon(); - await withCommandExecutorOverride( - async (_command, args) => - managedAgentBrowserCliArgs(args)[0] === 'close' - ? agentBrowserJsonResult({ success: false, error: 'close failed' }, 1) - : agentBrowserJsonResult({ success: true, data: {} }), - async () => { - await daemon.a.open('about:blank'); - await assert.rejects(() => daemon.a.close()); - await daemon.providerOf('session-a').snapshot(); - }, - ); -}); - test('a close that ends while another session is opening keeps the fleet record', async () => { const daemon = createTwoSessionDaemon(); const openStarted = createGate(); diff --git a/packages/platform-web/src/agent-browser-fleet.ts b/packages/platform-web/src/agent-browser-fleet.ts index 8dbb9b75fe..2eac61aac0 100644 --- a/packages/platform-web/src/agent-browser-fleet.ts +++ b/packages/platform-web/src/agent-browser-fleet.ts @@ -21,10 +21,8 @@ export type AgentBrowserFleet = Readonly<{ openStarted(session: string): void; /** The `open` for `session` ended; `launched` is whether the browser is up. */ openSettled(session: string, launched: boolean): void; - /** A close for `session` completed, with or without a successful backend result. */ - closed(session: string, succeeded: boolean): void; - /** A successful close revoked this browser until its next successful open. */ - wasClosed(session: string): boolean; + /** The browser of `session` was closed. */ + closed(session: string): void; /** Every launched browser exited without a close: drop them. Launching ones stay. */ evictLaunched(): void; /** The sessions whose browser is launching or up, whether or not the daemon published them. */ @@ -45,7 +43,6 @@ function createAgentBrowserFleet(): AgentBrowserFleet { const recordLocks = new Map>(); const opening = new Map(); const launched = new Set(); - const closed = new Set(); return Object.freeze({ updateRecord: async (task) => await withKeyedLock(recordLocks, RECORD_LOCK_KEY, task), openStarted(session) { @@ -55,16 +52,11 @@ function createAgentBrowserFleet(): AgentBrowserFleet { const remaining = (opening.get(session) ?? 1) - 1; if (remaining > 0) opening.set(session, remaining); else opening.delete(session); - if (browserUp) { - launched.add(session); - closed.delete(session); - } + if (browserUp) launched.add(session); }, - closed(session, succeeded) { + closed(session) { launched.delete(session); - if (succeeded) closed.add(session); }, - wasClosed: (session) => closed.has(session), evictLaunched() { launched.clear(); }, diff --git a/packages/platform-web/src/agent-browser-provider.ts b/packages/platform-web/src/agent-browser-provider.ts index 0bdfe84137..5a75d4e7ce 100644 --- a/packages/platform-web/src/agent-browser-provider.ts +++ b/packages/platform-web/src/agent-browser-provider.ts @@ -504,21 +504,6 @@ async function runAgentBrowserCommand( interpret: (result: { stdout: string; stderr: string; exitCode: number }) => unknown, run: AgentBrowserRunOptions, ): Promise { - if ( - cliArgs[0] !== 'open' && - options.ownedProcessRecords && - agentBrowserFleetOf(options.ownedProcessRecords).wasClosed(fleetSessionOf(options)) - ) { - throw new AppError( - 'SESSION_NOT_FOUND', - 'Browser session is closed. Run open before retrying.', - { - reason: 'web_session_closed', - dispatched: 'no', - hint: 'Run agent-device open --platform web with the same --session to reopen it.', - }, - ); - } let stdout = ''; let stderr = ''; let exitCode = 0; @@ -624,8 +609,7 @@ function settleFleetMembership( ): void { const succeeded = params.commandCompleted && params.semanticSuccess && params.exitCode === 0; if (params.cliArgs[0] === 'open') fleet.openSettled(session, succeeded); - else if (params.cliArgs[0] === 'close' && params.commandCompleted) - fleet.closed(session, succeeded); + else if (params.cliArgs[0] === 'close' && params.commandCompleted) fleet.closed(session); } /** diff --git a/website/docs/docs/sessions.md b/website/docs/docs/sessions.md index 42a1379985..7faf5d1bc3 100644 --- a/website/docs/docs/sessions.md +++ b/website/docs/docs/sessions.md @@ -57,9 +57,10 @@ agent-device close --session my-session Don't run commands that change state in parallel on the same session. Run actions such as `open`, `press`, `fill`, `type`, `scroll`, `back`, `alert`, `replay`, `batch`, and `close` one at a time. -After you close a web session, later browser commands refuse with `SESSION_NOT_FOUND`, even when -you pass `--platform web`. The closed session stays out of `session list`. Use `open` to start it -again. A failed reopen keeps the closed session unavailable. +After you close a web session, later browser commands refuse with `SESSION_NOT_FOUND` +(`named_session_not_found`), even when you pass `--platform web`. The closed session stays out of +`session list`. That closed state lasts until the daemon restarts. Use `open` to start it again. A +failed reopen keeps the closed session unavailable. ## Lock a named session to a device From 4d891037fe9f19e3bd2eb2b9f3f8a2b6715c45ed Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Tue, 10 Nov 2026 20:23:32 +0000 Subject: [PATCH 3/4] fix(web): record a closed browser without a platform check in teardown Session teardown asks the cleanup capability whether a browser closed and stores that answer. The capability stays the only place that selects web. Co-authored-by: Lucas Coutinho --- .../platform-resource-cleanup-fixture.ts | 2 +- .../src/core/platform-resource-cleanup.ts | 6 +++++- packages/daemon/src/core/session-store.ts | 20 +++++++++---------- ...quest-execution-scope-lease-expiry.test.ts | 2 +- .../request-router-closed-web-session.test.ts | 12 +++++------ .../daemon-runtime-web-close-teardown.test.ts | 5 ++++- .../src/sessions/request-handler-chain.ts | 2 +- .../internal/session-close.ts | 9 ++++++--- .../internal/session-open-execution.ts | 2 +- .../daemon/src/sessions/session-teardown.ts | 11 ++++------ src/platform-runtime-resource-cleanup.ts | 5 +++-- 11 files changed, 42 insertions(+), 34 deletions(-) diff --git a/packages/daemon/src/__tests__/support/platform-resource-cleanup-fixture.ts b/packages/daemon/src/__tests__/support/platform-resource-cleanup-fixture.ts index 1a8b0c7edd..0a1b523dec 100644 --- a/packages/daemon/src/__tests__/support/platform-resource-cleanup-fixture.ts +++ b/packages/daemon/src/__tests__/support/platform-resource-cleanup-fixture.ts @@ -22,7 +22,7 @@ export function platformResourceCleanupFixture( ): PlatformResourceCleanupFixture { return Object.freeze({ stopSnapshotHelper: vi.fn(overrides.stopSnapshotHelper ?? (async () => {})), - closeManagedBrowser: vi.fn(overrides.closeManagedBrowser ?? (async () => {})), + closeManagedBrowser: vi.fn(overrides.closeManagedBrowser ?? (async () => false)), cleanupSessionlessExecutionHost: vi.fn( overrides.cleanupSessionlessExecutionHost ?? (async () => {}), ), diff --git a/packages/daemon/src/core/platform-resource-cleanup.ts b/packages/daemon/src/core/platform-resource-cleanup.ts index 54cf659043..326e403d6f 100644 --- a/packages/daemon/src/core/platform-resource-cleanup.ts +++ b/packages/daemon/src/core/platform-resource-cleanup.ts @@ -3,6 +3,10 @@ import type { DeviceInfo } from '@agent-device/kernel/device'; /** Platform-owned resource finalization invoked by neutral daemon orchestration. */ export type PlatformResourceCleanup = Readonly<{ stopSnapshotHelper(device: DeviceInfo): Promise; + /** + * Closes the managed browser of a web session device. Returns true when this call closed one, + * and false when the device has no managed browser to close. + */ closeManagedBrowser( params: Readonly<{ /** The web session device whose browser closes; its id carries the backend key. */ @@ -11,7 +15,7 @@ export type PlatformResourceCleanup = Readonly<{ /** The backend keys of the published web sessions. */ openSessionNames: () => readonly string[]; }>, - ): Promise; + ): Promise; cleanupSessionlessExecutionHost(device: DeviceInfo): Promise; retainExecutionHostAfterClose(params: { device: DeviceInfo; diff --git a/packages/daemon/src/core/session-store.ts b/packages/daemon/src/core/session-store.ts index 92d938d049..b39f3874ae 100644 --- a/packages/daemon/src/core/session-store.ts +++ b/packages/daemon/src/core/session-store.ts @@ -58,11 +58,11 @@ export type RetainedExecutionHost = Readonly<{ export class SessionStore { private readonly sessions = new Map(); /** - * Addresses whose web browser close succeeded. The set lives on this store, so it ends when the - * daemon's store does: a restart starts without it. A failed close never enters it, and a + * Addresses whose managed browser close succeeded. The set lives on this store, so it ends when + * the daemon's store does: a restart starts without it. A failed close never enters it, and a * successful open leaves it. */ - private readonly closedWebSessions = new Set(); + private readonly closedBrowserSessions = new Set(); private readonly retainedExecutionHosts = new Map(); private acceptingSessions = true; private readonly runtimeHints = new Map(); @@ -172,18 +172,18 @@ export class SessionStore { return this.sessions.delete(ref.address); } - /** The web browser for `address` closed successfully. Later non-open commands refuse it. */ - markWebSessionClosed(address: string): void { - this.closedWebSessions.add(address); + /** The managed browser for `address` closed successfully. Later non-open commands refuse it. */ + markClosedBrowserSession(address: string): void { + this.closedBrowserSessions.add(address); } /** A successful open of `address` may use the browser again. */ - clearClosedWebSession(address: string): void { - this.closedWebSessions.delete(address); + clearClosedBrowserSession(address: string): void { + this.closedBrowserSessions.delete(address); } - isWebSessionClosed(address: string): boolean { - return this.closedWebSessions.has(address); + hasClosedBrowserSession(address: string): boolean { + return this.closedBrowserSessions.has(address); } listRetainedExecutionHosts(leaseId: string): RetainedExecutionHost[] { diff --git a/packages/daemon/src/server/__tests__/request-execution-scope-lease-expiry.test.ts b/packages/daemon/src/server/__tests__/request-execution-scope-lease-expiry.test.ts index 44f4829590..8b36b0b0e4 100644 --- a/packages/daemon/src/server/__tests__/request-execution-scope-lease-expiry.test.ts +++ b/packages/daemon/src/server/__tests__/request-execution-scope-lease-expiry.test.ts @@ -127,7 +127,7 @@ test.each(['rebuild', 'retire'] as const)( leaseRegistry: leases, platformResourceCleanup: { stopSnapshotHelper, - closeManagedBrowser: async () => {}, + closeManagedBrowser: async () => false, cleanupSessionlessExecutionHost: async () => {}, retainExecutionHostAfterClose: () => false, }, diff --git a/packages/daemon/src/server/__tests__/request-router-closed-web-session.test.ts b/packages/daemon/src/server/__tests__/request-router-closed-web-session.test.ts index e3a152f748..cd13115bbc 100644 --- a/packages/daemon/src/server/__tests__/request-router-closed-web-session.test.ts +++ b/packages/daemon/src/server/__tests__/request-router-closed-web-session.test.ts @@ -121,7 +121,7 @@ test('a closed named web session refuses later browser commands and a second clo if (!ref) throw new Error('opened web session is missing'); expect(await daemon.handler(request(session, 'close'))).toMatchObject({ ok: true }); expect(daemon.sessionStore.get(session)).toBeUndefined(); - expect(daemon.sessionStore.isWebSessionClosed(session)).toBe(true); + expect(daemon.sessionStore.hasClosedBrowserSession(session)).toBe(true); await teardownSessionResources({ appLog: 'already-settled', ref, @@ -173,20 +173,20 @@ test('a failed web close does not stick, and a failed reopen stays closed', asyn const failedClose = await daemon.handler(request(session, 'close', [], 'close-fail')); expect(failedClose.ok).toBe(false); expect(daemon.sessionStore.get(session)).toBeDefined(); - expect(daemon.sessionStore.isWebSessionClosed(session)).toBe(false); + expect(daemon.sessionStore.hasClosedBrowserSession(session)).toBe(false); dispatchApplicationLifecycleEffect.mockImplementation(async () => undefined); expect(await daemon.handler(request(session, 'close', [], 'close-retry'))).toMatchObject({ ok: true, }); - expect(daemon.sessionStore.isWebSessionClosed(session)).toBe(true); + expect(daemon.sessionStore.hasClosedBrowserSession(session)).toBe(true); dispatchApplicationLifecycleEffect.mockImplementation(async (_device, command) => { if (command === 'open') throw new Error('open failed'); }); const failedOpen = await daemon.handler(request(session, 'open', ['about:blank'], 'open-fail')); expect(failedOpen.ok).toBe(false); - expect(daemon.sessionStore.isWebSessionClosed(session)).toBe(true); + expect(daemon.sessionStore.hasClosedBrowserSession(session)).toBe(true); expect(await daemon.handler(request(session, 'snapshot', [], 'snapshot-still'))).toMatchObject( closedSessionRefusal(session), ); @@ -195,7 +195,7 @@ test('a failed web close does not stick, and a failed reopen stays closed', asyn expect(await daemon.handler(request(session, 'open', ['about:blank'], 'open-2'))).toMatchObject( { ok: true }, ); - expect(daemon.sessionStore.isWebSessionClosed(session)).toBe(false); + expect(daemon.sessionStore.hasClosedBrowserSession(session)).toBe(false); expect(daemon.sessionStore.get(session)?.device.platform).toBe('web'); const reopened = await daemon.handler(request(session, 'snapshot', [], 'snapshot-open')); if (!reopened.ok) { @@ -213,7 +213,7 @@ test('a named web session that was never opened is not answered as closed', asyn const session = 'never-opened'; try { const response = await daemon.handler(request(session, 'snapshot')); - expect(daemon.sessionStore.isWebSessionClosed(session)).toBe(false); + expect(daemon.sessionStore.hasClosedBrowserSession(session)).toBe(false); if (!response.ok) { expect(response.error.details?.reason).not.toBe( PRE_DISPATCH_REFUSAL_REASONS.namedSessionNotFound, diff --git a/packages/daemon/src/server/http/daemon-runtime-web-close-teardown.test.ts b/packages/daemon/src/server/http/daemon-runtime-web-close-teardown.test.ts index dad358acba..c6ad25df4c 100644 --- a/packages/daemon/src/server/http/daemon-runtime-web-close-teardown.test.ts +++ b/packages/daemon/src/server/http/daemon-runtime-web-close-teardown.test.ts @@ -32,7 +32,10 @@ test('daemon shutdown awaits a slow web close inside its extended budget', async const session = makeWebSession('shutdown-slow-web-session'); sessionStore.publish(session.name, session); const platformCleanup = platformResourceCleanupFixture({ - closeManagedBrowser: async () => await new Promise((resolve) => setTimeout(resolve, 20_000)), + closeManagedBrowser: async () => { + await new Promise((resolve) => setTimeout(resolve, 20_000)); + return false; + }, }); const stderrChunks: string[] = []; diff --git a/packages/daemon/src/sessions/request-handler-chain.ts b/packages/daemon/src/sessions/request-handler-chain.ts index 1756c0a9be..7f5df83839 100644 --- a/packages/daemon/src/sessions/request-handler-chain.ts +++ b/packages/daemon/src/sessions/request-handler-chain.ts @@ -145,7 +145,7 @@ export async function runRequestHandlerChain( ): Promise { if ( !closedWebSessionAllows(params.req.command) && - params.sessionStore.isWebSessionClosed(params.sessionName) + params.sessionStore.hasClosedBrowserSession(params.sessionName) ) { const { namedSessionNotFoundError } = await import('../core/explicit-session-resolution.ts'); throw namedSessionNotFoundError(params.sessionName); diff --git a/packages/daemon/src/sessions/session-lifecycle/internal/session-close.ts b/packages/daemon/src/sessions/session-lifecycle/internal/session-close.ts index 8ffbcad0d6..76c9085618 100644 --- a/packages/daemon/src/sessions/session-lifecycle/internal/session-close.ts +++ b/packages/daemon/src/sessions/session-lifecycle/internal/session-close.ts @@ -193,12 +193,15 @@ async function closePlatformObservingWebSession(params: { logPath: string; lifecycle: CloseRuntime | CloseRuntimeWithRuntimeHintClear; }): Promise { - if (isWebSession(params.session) && params.sessionStore.isWebSessionClosed(params.sessionName)) { + if ( + isWebSession(params.session) && + params.sessionStore.hasClosedBrowserSession(params.sessionName) + ) { return undefined; } const error = await dispatchTargetedPlatformClose(params); if (!error && isWebSession(params.session)) { - params.sessionStore.markWebSessionClosed(params.sessionName); + params.sessionStore.markClosedBrowserSession(params.sessionName); } return error; } @@ -602,7 +605,7 @@ async function closeWithoutSession(params: { bindDevice, platformServices, } = params; - if (sessionStore.isWebSessionClosed(sessionName)) { + if (sessionStore.hasClosedBrowserSession(sessionName)) { return { ok: true, data: { diff --git a/packages/daemon/src/sessions/session-lifecycle/internal/session-open-execution.ts b/packages/daemon/src/sessions/session-lifecycle/internal/session-open-execution.ts index 8bc8355cc4..c71971417e 100644 --- a/packages/daemon/src/sessions/session-lifecycle/internal/session-open-execution.ts +++ b/packages/daemon/src/sessions/session-lifecycle/internal/session-open-execution.ts @@ -300,7 +300,7 @@ export async function completeOpenCommand(params: { openDispatchSession?.trace?.outPath, ), }); - if (device.platform === 'web') sessionStore.clearClosedWebSession(sessionName); + if (device.platform === 'web') sessionStore.clearClosedBrowserSession(sessionName); sessionAppBundleId = outcome.appBundleId ?? sessionAppBundleId; const timing: OpenTiming = { ...outcome.timing }; const preparedSelection = markSelectionBootOccurred(selection); diff --git a/packages/daemon/src/sessions/session-teardown.ts b/packages/daemon/src/sessions/session-teardown.ts index 67ea0317da..df78c15f3a 100644 --- a/packages/daemon/src/sessions/session-teardown.ts +++ b/packages/daemon/src/sessions/session-teardown.ts @@ -12,8 +12,7 @@ import type { SessionStore } from '../core/session-store.ts'; import { finishLiveAudioProbe } from '@agent-device/capture-kit/audio-probe-session-resource'; import { finishLivePerfCapture } from '@agent-device/capture-kit/perf-capture-session-resource'; import { finishLiveScreenRecording } from '@agent-device/capture-kit/screen-recording-session-resource'; -import { webBackendKeyOf } from '@agent-device/kernel/device'; -import { isWebSession, openWebSessionNames } from './web-session-names.ts'; +import { openWebSessionNames } from './web-session-names.ts'; import type { PlatformResourceCleanup } from '../core/platform-resource-cleanup.ts'; export async function stopSessionAppLog(params: { @@ -50,15 +49,13 @@ async function stopSessionWebBrowser(params: { }): Promise { const { ref, sessionStore, platformCleanup } = params; const session = sessionStore.resolveCurrent(ref) ?? ref.session; - if (isWebSession(session) && sessionStore.isWebSessionClosed(ref.address)) return; - await platformCleanup.closeManagedBrowser({ + if (sessionStore.hasClosedBrowserSession(ref.address)) return; + const closed = await platformCleanup.closeManagedBrowser({ device: session.device, stateDir: sessionStore.resolveDaemonStateDir(), openSessionNames: () => openWebSessionNames(sessionStore), }); - if (isWebSession(session) && webBackendKeyOf(session.device.id) !== undefined) { - sessionStore.markWebSessionClosed(ref.address); - } + if (closed) sessionStore.markClosedBrowserSession(ref.address); } export type SessionCleanupStep = { step: string; run: () => Promise }; diff --git a/src/platform-runtime-resource-cleanup.ts b/src/platform-runtime-resource-cleanup.ts index d5138c8fde..2f1129aec8 100644 --- a/src/platform-runtime-resource-cleanup.ts +++ b/src/platform-runtime-resource-cleanup.ts @@ -78,9 +78,9 @@ export function createPlatformResourceCleanup( await stopAndroidSnapshotHelperRuntimeForDevice(device); }, async closeManagedBrowser(params) { - if (params.device.platform !== 'web') return; + if (params.device.platform !== 'web') return false; const backendKey = webBackendKeyOf(params.device.id); - if (backendKey === undefined) return; + if (backendKey === undefined) return false; await closeManagedWebRuntimeSession( { backendKey, @@ -90,6 +90,7 @@ export function createPlatformResourceCleanup( }, host, ); + return true; }, async cleanupSessionlessExecutionHost(device) { if (!isIosFamily(device)) return; From d97c0db94643a2132c39f8eccd28f8dd8ebbc2d2 Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Wed, 11 Nov 2026 00:00:55 +0000 Subject: [PATCH 4/4] fix(web): clear a closed browser marker on every successful open A non-web open of a marked address left the marker in place, so the next snapshot was refused as named_session_not_found. Every successful open now leaves the set, and the chain refuses a marked address only while no session is held there. Co-authored-by: Lucas Coutinho --- .../src/core/platform-resource-cleanup.ts | 5 ++- packages/daemon/src/core/session-store.ts | 7 +-- .../request-router-closed-web-session.test.ts | 45 ++++++++++++++++++- .../src/sessions/request-handler-chain.ts | 8 ++-- .../session-teardown-resources.test.ts | 39 ++++++++++++++++ .../internal/session-open-execution.ts | 2 +- 6 files changed, 96 insertions(+), 10 deletions(-) diff --git a/packages/daemon/src/core/platform-resource-cleanup.ts b/packages/daemon/src/core/platform-resource-cleanup.ts index 326e403d6f..3ff1dc2d5e 100644 --- a/packages/daemon/src/core/platform-resource-cleanup.ts +++ b/packages/daemon/src/core/platform-resource-cleanup.ts @@ -4,8 +4,9 @@ import type { DeviceInfo } from '@agent-device/kernel/device'; export type PlatformResourceCleanup = Readonly<{ stopSnapshotHelper(device: DeviceInfo): Promise; /** - * Closes the managed browser of a web session device. Returns true when this call closed one, - * and false when the device has no managed browser to close. + * Closes the managed browser when `device` is a web session device. Returns true after that + * close. Returns false when the platform is not web, or when the device id carries no backend + * key. A close the backend refuses rejects instead of returning false. */ closeManagedBrowser( params: Readonly<{ diff --git a/packages/daemon/src/core/session-store.ts b/packages/daemon/src/core/session-store.ts index b39f3874ae..bc98d161ae 100644 --- a/packages/daemon/src/core/session-store.ts +++ b/packages/daemon/src/core/session-store.ts @@ -60,7 +60,8 @@ export class SessionStore { /** * Addresses whose managed browser close succeeded. The set lives on this store, so it ends when * the daemon's store does: a restart starts without it. A failed close never enters it, and a - * successful open leaves it. + * successful open of any platform leaves it. A marked address is refused only while no session + * is held there. */ private readonly closedBrowserSessions = new Set(); private readonly retainedExecutionHosts = new Map(); @@ -172,12 +173,12 @@ export class SessionStore { return this.sessions.delete(ref.address); } - /** The managed browser for `address` closed successfully. Later non-open commands refuse it. */ + /** The managed browser for `address` closed successfully. Commands refuse it while no session is held there. */ markClosedBrowserSession(address: string): void { this.closedBrowserSessions.add(address); } - /** A successful open of `address` may use the browser again. */ + /** A successful open of `address` leaves the set, whichever platform opened. */ clearClosedBrowserSession(address: string): void { this.closedBrowserSessions.delete(address); } diff --git a/packages/daemon/src/server/__tests__/request-router-closed-web-session.test.ts b/packages/daemon/src/server/__tests__/request-router-closed-web-session.test.ts index cd13115bbc..f940495827 100644 --- a/packages/daemon/src/server/__tests__/request-router-closed-web-session.test.ts +++ b/packages/daemon/src/server/__tests__/request-router-closed-web-session.test.ts @@ -9,6 +9,7 @@ import { } from '@agent-device/kernel/device'; import { PRE_DISPATCH_REFUSAL_REASONS } from '@agent-device/kernel/errors'; import { + ANDROID_EMULATOR, WEB_DESKTOP_DEVICE, createTestHostEnvironment, mkdtempForTestSync, @@ -85,13 +86,14 @@ function request( command: string, positionals: string[] = [], requestId = command, + flags: DaemonRequest['flags'] = { platform: 'web' }, ): DaemonRequest { return { token: 'test-token', session, command, positionals, - flags: { platform: 'web' }, + flags, meta: { requestId: `req-${requestId}`, sessionExplicit: true }, }; } @@ -223,3 +225,44 @@ test('a named web session that was never opened is not answered as closed', asyn fs.rmSync(daemon.claimsDir, { recursive: true, force: true }); } }); + +test.each([ + ['named session', 'mixed-platform'], + ['default session', 'default'], +] as const)( + 'a successful non-web open of a %s supersedes a closed web marker', + async (_label, session) => { + const daemon = webDaemon(); + try { + expect( + await daemon.handler(request(session, 'open', ['about:blank'], 'open-web')), + ).toMatchObject({ ok: true }); + expect(await daemon.handler(request(session, 'close', [], 'close-web'))).toMatchObject({ + ok: true, + }); + expect(daemon.sessionStore.get(session)).toBeUndefined(); + expect(daemon.sessionStore.hasClosedBrowserSession(session)).toBe(true); + + mockResolveTargetDevice.mockResolvedValue(ANDROID_EMULATOR); + const opened = await daemon.handler( + request(session, 'open', ['com.android.settings'], 'open-android', { + platform: 'android', + }), + ); + expect(opened).toMatchObject({ ok: true }); + expect(daemon.sessionStore.get(session)?.device.platform).toBe('android'); + + const snapshot = await daemon.handler( + request(session, 'snapshot', [], 'snapshot-android', { platform: 'android' }), + ); + if (!snapshot.ok) { + expect(snapshot.error.details?.reason).not.toBe( + PRE_DISPATCH_REFUSAL_REASONS.namedSessionNotFound, + ); + } + expect(daemon.sessionStore.hasClosedBrowserSession(session)).toBe(false); + } finally { + fs.rmSync(daemon.claimsDir, { recursive: true, force: true }); + } + }, +); diff --git a/packages/daemon/src/sessions/request-handler-chain.ts b/packages/daemon/src/sessions/request-handler-chain.ts index 7f5df83839..0f0c6da811 100644 --- a/packages/daemon/src/sessions/request-handler-chain.ts +++ b/packages/daemon/src/sessions/request-handler-chain.ts @@ -127,8 +127,9 @@ const DAEMON_ROUTE_HANDLERS = { export type { DaemonCommandRoute }; /** - * `batch` and `replay` re-enter this chain per step, so an `open` step can clear a closed web - * session. Inventory commands do not drive the browser. + * A marked address is refused only while the daemon holds no session there. `batch` and `replay` + * re-enter this chain per step, so an `open` step can clear the marker. Inventory commands do not + * drive the browser. */ function closedWebSessionAllows(command: string): boolean { return ( @@ -145,7 +146,8 @@ export async function runRequestHandlerChain( ): Promise { if ( !closedWebSessionAllows(params.req.command) && - params.sessionStore.hasClosedBrowserSession(params.sessionName) + params.sessionStore.hasClosedBrowserSession(params.sessionName) && + params.sessionStore.get(params.sessionName) === undefined ) { const { namedSessionNotFoundError } = await import('../core/explicit-session-resolution.ts'); throw namedSessionNotFoundError(params.sessionName); diff --git a/packages/daemon/src/sessions/session-lifecycle/internal/__tests__/session-teardown-resources.test.ts b/packages/daemon/src/sessions/session-lifecycle/internal/__tests__/session-teardown-resources.test.ts index 0896561e41..f8a00f8c7d 100644 --- a/packages/daemon/src/sessions/session-lifecycle/internal/__tests__/session-teardown-resources.test.ts +++ b/packages/daemon/src/sessions/session-lifecycle/internal/__tests__/session-teardown-resources.test.ts @@ -277,6 +277,45 @@ function attachPerfCapture( return finish; } +test('daemon session teardown records a closed browser when the platform close succeeds', async () => { + const sessionName = 'web-closed-marker-teardown'; + const sessionStore = makeSessionStore(); + const device = webSessionDevice(WEB_DESKTOP_DEVICE, { name: sessionName }); + sessionStore.publish(sessionName, makeSession(sessionName, device)); + const platformCleanup = platformResourceCleanupFixture({ + closeManagedBrowser: async () => true, + }); + + await teardownSessionResources({ + appLog: 'already-settled', + ref: sessionStore.lookup(sessionName)!, + sessionStore, + platformCleanup, + }); + + // Shutdown and lease expiry both reach this mark through teardownSessionResources. + expect(sessionStore.hasClosedBrowserSession(sessionName)).toBe(true); +}); + +test('daemon session teardown does not record a closed browser when the platform close reports none', async () => { + const sessionName = 'web-unmarked-teardown'; + const sessionStore = makeSessionStore(); + const device = webSessionDevice(WEB_DESKTOP_DEVICE, { name: sessionName }); + sessionStore.publish(sessionName, makeSession(sessionName, device)); + const platformCleanup = platformResourceCleanupFixture({ + closeManagedBrowser: async () => false, + }); + + await teardownSessionResources({ + appLog: 'already-settled', + ref: sessionStore.lookup(sessionName)!, + sessionStore, + platformCleanup, + }); + + expect(sessionStore.hasClosedBrowserSession(sessionName)).toBe(false); +}); + test('daemon session teardown closes an open web session immediately, not on agent-browser idle timeout', async () => { const sessionName = 'web-active-teardown'; const sessionStore = makeSessionStore(); diff --git a/packages/daemon/src/sessions/session-lifecycle/internal/session-open-execution.ts b/packages/daemon/src/sessions/session-lifecycle/internal/session-open-execution.ts index c71971417e..3ab1cad00f 100644 --- a/packages/daemon/src/sessions/session-lifecycle/internal/session-open-execution.ts +++ b/packages/daemon/src/sessions/session-lifecycle/internal/session-open-execution.ts @@ -300,7 +300,7 @@ export async function completeOpenCommand(params: { openDispatchSession?.trace?.outPath, ), }); - if (device.platform === 'web') sessionStore.clearClosedBrowserSession(sessionName); + sessionStore.clearClosedBrowserSession(sessionName); sessionAppBundleId = outcome.appBundleId ?? sessionAppBundleId; const timing: OpenTiming = { ...outcome.timing }; const preparedSelection = markSelectionBootOccurred(selection);