Skip to content
Draft
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Original file line number Diff line number Diff line change
Expand Up @@ -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 () => {}),
),
Expand Down
7 changes: 6 additions & 1 deletion packages/daemon/src/core/platform-resource-cleanup.ts
Original file line number Diff line number Diff line change
Expand Up @@ -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<void>;
/**
* 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. */
Expand All @@ -11,7 +16,7 @@ export type PlatformResourceCleanup = Readonly<{
/** The backend keys of the published web sessions. */
openSessionNames: () => readonly string[];
}>,
): Promise<void>;
): Promise<boolean>;
cleanupSessionlessExecutionHost(device: DeviceInfo): Promise<void>;
retainExecutionHostAfterClose(params: {
device: DeviceInfo;
Expand Down
21 changes: 21 additions & 0 deletions packages/daemon/src/core/session-store.ts
Original file line number Diff line number Diff line change
Expand Up @@ -57,6 +57,13 @@ export type RetainedExecutionHost = Readonly<{

export class SessionStore {
private readonly sessions = new Map<string, SessionEntry>();
/**
* 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<string>();
private readonly retainedExecutionHosts = new Map<string, RetainedExecutionHost>();
private acceptingSessions = true;
private readonly runtimeHints = new Map<string, SessionRuntimeHints>();
Expand Down Expand Up @@ -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,
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -127,7 +127,7 @@ test.each(['rebuild', 'retire'] as const)(
leaseRegistry: leases,
platformResourceCleanup: {
stopSnapshotHelper,
closeManagedBrowser: async () => {},
closeManagedBrowser: async () => false,
cleanupSessionlessExecutionHost: async () => {},
retainExecutionHostAfterClose: () => false,
},
Expand Down
Original file line number Diff line number Diff line change
@@ -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<DeviceInfo> =>
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 });
}
},
);
Original file line number Diff line number Diff line change
Expand Up @@ -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[] = [];

Expand Down
25 changes: 24 additions & 1 deletion packages/daemon/src/sessions/request-handler-chain.ts
Original file line number Diff line number Diff line change
Expand Up @@ -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';
Expand Down Expand Up @@ -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<DaemonResponse | null> {
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);
}
Expand Down
Loading