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..3ff1dc2d5e 100644 --- a/packages/daemon/src/core/platform-resource-cleanup.ts +++ b/packages/daemon/src/core/platform-resource-cleanup.ts @@ -3,6 +3,11 @@ 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 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<{ /** The web session device whose browser closes; its id carries the backend key. */ @@ -11,7 +16,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 cb1125a227..bc98d161ae 100644 --- a/packages/daemon/src/core/session-store.ts +++ b/packages/daemon/src/core/session-store.ts @@ -57,6 +57,13 @@ export type RetainedExecutionHost = Readonly<{ export class SessionStore { private readonly sessions = new Map(); + /** + * 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 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(); private acceptingSessions = true; private readonly runtimeHints = new Map(); @@ -166,6 +173,20 @@ export class SessionStore { return this.sessions.delete(ref.address); } + /** 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` leaves the set, whichever platform opened. */ + clearClosedBrowserSession(address: string): void { + this.closedBrowserSessions.delete(address); + } + + hasClosedBrowserSession(address: string): boolean { + return this.closedBrowserSessions.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-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 new file mode 100644 index 0000000000..f940495827 --- /dev/null +++ b/packages/daemon/src/server/__tests__/request-router-closed-web-session.test.ts @@ -0,0 +1,268 @@ +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 { + ANDROID_EMULATOR, + 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, + flags: DaemonRequest['flags'] = { platform: 'web' }, +): DaemonRequest { + return { + token: 'test-token', + session, + command, + positionals, + flags, + 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.hasClosedBrowserSession(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.hasClosedBrowserSession(session)).toBe(false); + + dispatchApplicationLifecycleEffect.mockImplementation(async () => undefined); + expect(await daemon.handler(request(session, 'close', [], 'close-retry'))).toMatchObject({ + ok: 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.hasClosedBrowserSession(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.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) { + 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.hasClosedBrowserSession(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 }); + } +}); + +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/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 97b6236e15..0f0c6da811 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,32 @@ const DAEMON_ROUTE_HANDLERS = { export type { DaemonCommandRoute }; +/** + * 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 ( + 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.hasClosedBrowserSession(params.sessionName) && + params.sessionStore.get(params.sessionName) === undefined + ) { + 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/__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-close.ts b/packages/daemon/src/sessions/session-lifecycle/internal/session-close.ts index ba8459ee6e..76c9085618 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,27 @@ 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.hasClosedBrowserSession(params.sessionName) + ) { + return undefined; + } + const error = await dispatchTargetedPlatformClose(params); + if (!error && isWebSession(params.session)) { + params.sessionStore.markClosedBrowserSession(params.sessionName); + } + return error; +} + async function dispatchTargetedPlatformClose(params: { req: DaemonRequest; session: SessionState; @@ -278,6 +301,7 @@ export async function handleSessionCloseCommands( return await closeWithoutSession({ req, sessionName, + sessionStore, logPath, env: params.host.env, inspectFacts: params.inspectFacts, @@ -325,6 +349,8 @@ export async function handleSessionCloseCommands( return await closeAppWithoutEndingSession({ req, session, + sessionName, + sessionStore, logPath, lifecycle: admission.runtime, app, @@ -435,7 +461,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 +560,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 +588,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.hasClosedBrowserSession(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..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,6 +300,7 @@ export async function completeOpenCommand(params: { openDispatchSession?.trace?.outPath, ), }); + 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 912cd24e91..df78c15f3a 100644 --- a/packages/daemon/src/sessions/session-teardown.ts +++ b/packages/daemon/src/sessions/session-teardown.ts @@ -49,11 +49,13 @@ async function stopSessionWebBrowser(params: { }): Promise { const { ref, sessionStore, platformCleanup } = params; const session = sessionStore.resolveCurrent(ref) ?? ref.session; - await platformCleanup.closeManagedBrowser({ + if (sessionStore.hasClosedBrowserSession(ref.address)) return; + const closed = await platformCleanup.closeManagedBrowser({ device: session.device, stateDir: sessionStore.resolveDaemonStateDir(), openSessionNames: () => openWebSessionNames(sessionStore), }); + 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; diff --git a/website/docs/docs/sessions.md b/website/docs/docs/sessions.md index 9f3acd2eef..7faf5d1bc3 100644 --- a/website/docs/docs/sessions.md +++ b/website/docs/docs/sessions.md @@ -57,6 +57,11 @@ 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` +(`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 A lock keeps a named session's commands on its device: per-call selectors that conflict with the