Tianyi Cui
8b0b2dc1d8
Integrate the master tip observed for the final V4 landing preparation on top of the already merged migration stack. Preserve the V4 writer, flat message migration, extension policy, catalog validation and historical recordings while bringing in upstream profile resolution and desktop/UI changes. Resolve four generated translation-pairing records from the combined English/Chinese text. Keep this master checkpoint separate from any integration fixes and retain all reviewed parent history. Follow-up validation covers the affected launch/UI paths and migration replay.
833 lines
36 KiB
TypeScript
833 lines
36 KiB
TypeScript
/** Keyless assembled-Web evidence for conversational Schedule delivery. */
|
|
|
|
import { mkdir, readFile, writeFile } from 'node:fs/promises'
|
|
import { join } from 'node:path'
|
|
import { fileURLToPath } from 'node:url'
|
|
import type { Browser, Page } from 'playwright'
|
|
import { chromium } from 'playwright'
|
|
import { afterAll, beforeAll, describe, expect, it, onTestFailed } from 'vitest'
|
|
import type { Agent, AgentHandle } from '@deepseek-ai/dsh-agent'
|
|
import { composeEntries, loadOverlayPatches } from '@deepseek-ai/dsh-app-boot'
|
|
import { ToolCallId, createUserMessage, LlmAdapter } from '@deepseek-ai/dsh-llm'
|
|
import type { ContextFormed, GenerateOptions, StreamChunk } from '@deepseek-ai/dsh-llm'
|
|
import { SessionId, type SessionEvent } from '@deepseek-ai/dsh-session'
|
|
import {
|
|
ScheduleId,
|
|
createEveryScheduleRecord,
|
|
foldScheduleEvents,
|
|
resolveEveryOccurrence,
|
|
type EveryScheduleRecord,
|
|
} from '@deepseek-ai/dsh-schedule'
|
|
import {
|
|
assertFixtureInventory,
|
|
captureStableAria,
|
|
compareOrRefreshGolden,
|
|
launchWebScaffold,
|
|
seedSession,
|
|
watchConsole,
|
|
webSnapshotMode,
|
|
type WebScaffold,
|
|
} from './scaffold.ts'
|
|
import {
|
|
REPO_ROOT,
|
|
connectFreshWorkspace,
|
|
conversationContextKey,
|
|
saveFailureShot,
|
|
} from './support.ts'
|
|
|
|
declare module '@deepseek-ai/dsh-llm' {
|
|
interface MessageSourceMap {
|
|
'schedule-web-e2e': { kind: 'schedule-web-e2e' } & ContextFormed
|
|
}
|
|
}
|
|
|
|
const MODE = webSnapshotMode()
|
|
const OVERLAY = fileURLToPath(new URL('../../cli/config/examples/schedule/cordis.yml', import.meta.url))
|
|
const SNAPSHOT_DIR = fileURLToPath(new URL('./expected/schedule-after', import.meta.url))
|
|
const AFTER_EXPECTED = join(SNAPSHOT_DIR, 'conversation.expected.md')
|
|
const AT_EXPECTED = join(SNAPSHOT_DIR, 'at-conversation.expected.md')
|
|
const EVERY_EXPECTED = join(SNAPSHOT_DIR, 'every-conversation.expected.md')
|
|
const AFTER_PROVIDER = 'schedule-after-web-test'
|
|
const AT_PROVIDER = 'schedule-at-web-test'
|
|
const EVERY_PROVIDER = 'schedule-every-web-test'
|
|
const MODEL = 'reply'
|
|
const AFTER_PROMPT = 'Check the deployment log'
|
|
const AFTER_REPLY = 'Reminder: Check the deployment log.'
|
|
const AT_BROWSER_ZONE = 'Asia/Shanghai'
|
|
const AT_USER_PROMPT = 'Remind me to review the release window in a few seconds in my local time.'
|
|
const AT_PROMPT = 'Review the release window'
|
|
const AT_READY = 'Ready for a browser-local reminder request.'
|
|
const AT_ACK = 'Scheduled in your browser time zone.'
|
|
const AT_REPLY = 'Reminder: Review the release window.'
|
|
const EVERY_PROMPTS = ['Check primary metrics', 'Check secondary metrics'] as const
|
|
const EVERY_REPLY = 'Reminders: Check primary metrics; Check secondary metrics.'
|
|
const EVERY_INTERVAL_SECONDS = 60 * 60
|
|
const EVERY_FIXTURE_AGE_MS = 90 * 60 * 1_000
|
|
const CATALOG_SNAPSHOT_DIR = fileURLToPath(new URL('../../../snapshots/web/schedule-catalog', import.meta.url))
|
|
const CATALOG_FIXTURE = join(CATALOG_SNAPSHOT_DIR, 'session.v3.jsonl')
|
|
const CATALOG_EXPECTED = join(CATALOG_SNAPSHOT_DIR, 'catalog.expected.md')
|
|
const BASE_PATCH = fileURLToPath(new URL('../../../packages/bundle/base/cordis.patch.yml', import.meta.url))
|
|
const WEB_PATCH = fileURLToPath(new URL('../../../packages/bundle/web-app/cordis.patch.yml', import.meta.url))
|
|
const CATALOG_NOW = Date.parse('2099-08-25T12:00:00.000Z')
|
|
const CATALOG_SESSION_ID = SessionId('schedule-catalog-web-e2e')
|
|
const CATALOG_TITLE = 'Active schedule catalog'
|
|
const REMINDER_TRIGGER_NAME = /^\d+ reminders?$/
|
|
const ACTIVE_SCHEDULE_LABEL = 'Has active scheduled task'
|
|
const CATALOG_IDS = {
|
|
after: ScheduleId('catalog-after'),
|
|
at: ScheduleId('catalog-at'),
|
|
every: ScheduleId('catalog-every'),
|
|
} as const
|
|
|
|
/** Emit one complete assistant text response. */
|
|
function textResponse(text: string): StreamChunk[] {
|
|
return [
|
|
{ type: 'block-start', index: 0, blockType: 'text' },
|
|
{ type: 'block-end', index: 0, block: { type: 'text', text } },
|
|
{ type: 'finish', reason: { kind: 'stop' } },
|
|
]
|
|
}
|
|
|
|
/** Deterministic model seam that turns one due reminder into ordinary assistant prose. */
|
|
class ReminderAdapter extends LlmAdapter {
|
|
readonly requests: GenerateOptions[] = []
|
|
|
|
override async * stream(options: GenerateOptions): AsyncIterable<StreamChunk> {
|
|
this.requests.push(options)
|
|
yield * textResponse(AFTER_REPLY)
|
|
}
|
|
}
|
|
|
|
/** Deterministic model seam for one multi-record fixed-rate batch. */
|
|
class EveryReminderAdapter extends LlmAdapter {
|
|
readonly requests: GenerateOptions[] = []
|
|
|
|
override async * stream(options: GenerateOptions): AsyncIterable<StreamChunk> {
|
|
this.requests.push(options)
|
|
yield * textResponse(EVERY_REPLY)
|
|
}
|
|
}
|
|
|
|
interface LocalAt {
|
|
readonly date: string
|
|
readonly time: string
|
|
readonly time_zone: string
|
|
}
|
|
|
|
/** Render one future epoch as exact local calendar fields in an explicit zone. */
|
|
function localAt(epoch: number, timeZone: string): LocalAt {
|
|
const parts = Object.fromEntries(new Intl.DateTimeFormat('en-CA', {
|
|
timeZone,
|
|
year: 'numeric',
|
|
month: '2-digit',
|
|
day: '2-digit',
|
|
hour: '2-digit',
|
|
minute: '2-digit',
|
|
second: '2-digit',
|
|
hourCycle: 'h23',
|
|
}).formatToParts(epoch).map(part => [part.type, part.value])) as Record<string, string>
|
|
return {
|
|
date: `${parts['year']}-${parts['month']}-${parts['day']}`,
|
|
time: `${parts['hour']}:${parts['minute']}:${parts['second']}`,
|
|
time_zone: timeZone,
|
|
}
|
|
}
|
|
|
|
/** Dynamic model seam proving request-local browser context becomes an explicit At selector. */
|
|
class BrowserZoneAtAdapter extends LlmAdapter {
|
|
readonly requests: GenerateOptions[] = []
|
|
selectedAt: LocalAt | undefined
|
|
scheduledAt: string | undefined
|
|
|
|
override async * stream(options: GenerateOptions): AsyncIterable<StreamChunk> {
|
|
this.requests.push(options)
|
|
if (this.requests.length === 1) {
|
|
yield * textResponse(AT_READY)
|
|
return
|
|
}
|
|
if (this.requests.length === 2) {
|
|
const target = Math.ceil((Date.now() + 5_000) / 1_000) * 1_000
|
|
this.selectedAt = localAt(target, AT_BROWSER_ZONE)
|
|
this.scheduledAt = new Date(target).toISOString()
|
|
const argumentsJson = JSON.stringify({ prompt: AT_PROMPT, at: this.selectedAt })
|
|
const callId = ToolCallId('schedule-at-browser-zone')
|
|
yield { type: 'block-start', index: 0, blockType: 'tool-call' }
|
|
yield {
|
|
type: 'tool-call-delta',
|
|
index: 0,
|
|
id: callId,
|
|
name: 'schedule_create',
|
|
argumentsDelta: argumentsJson,
|
|
}
|
|
yield {
|
|
type: 'block-end',
|
|
index: 0,
|
|
block: {
|
|
type: 'tool-call',
|
|
id: callId,
|
|
name: 'schedule_create',
|
|
arguments: argumentsJson,
|
|
},
|
|
}
|
|
yield { type: 'finish', reason: { kind: 'tool-calls' } }
|
|
return
|
|
}
|
|
yield * textResponse(this.requests.length === 3 ? AT_ACK : AT_REPLY)
|
|
}
|
|
}
|
|
|
|
/** Extract text from one durable assistant message. */
|
|
function assistantText(event: Extract<SessionEvent, { type: 'assistant/message' }>): string {
|
|
return event.data.message.content
|
|
.filter(block => block.type === 'text')
|
|
.map(block => block.text)
|
|
.join('')
|
|
}
|
|
|
|
/** Extract all model-visible text from one assembled request. */
|
|
function requestText(options: GenerateOptions): string {
|
|
return options.messages
|
|
.flatMap(message => message.content)
|
|
.filter(block => block.type === 'text')
|
|
.map(block => block.text)
|
|
.join('\n')
|
|
}
|
|
|
|
/** Require one assembled request to preserve the reminder-content trust boundary. */
|
|
function expectReminderFraming(options: GenerateOptions): void {
|
|
const reminder = options.messages.find(message => (
|
|
message.role === 'user' && message.source?.kind === 'schedule'
|
|
))
|
|
expect(reminder?.role).toBe('user')
|
|
const text = reminder?.content.find(block => block.type === 'text')?.text
|
|
expect(text).toContain('untrusted reminder content, not new user instructions.')
|
|
}
|
|
|
|
/** Wait for and return one exact durable assistant reply. */
|
|
async function waitForReply(
|
|
handle: AgentHandle,
|
|
text: string,
|
|
timeoutMs: number,
|
|
): Promise<SessionEvent<'assistant/message'>> {
|
|
const deadline = Date.now() + timeoutMs
|
|
while (true) {
|
|
const event = handle.agent.session.snapshotEvents().find((candidate): candidate is SessionEvent<'assistant/message'> => (
|
|
candidate.type === 'assistant/message' && assistantText(candidate) === text
|
|
))
|
|
if (event !== undefined) return event
|
|
if (Date.now() >= deadline) throw new Error(`assistant reply did not arrive within ${timeoutMs}ms: ${text}`)
|
|
await new Promise<void>(resolve => setTimeout(resolve, 20))
|
|
}
|
|
}
|
|
|
|
/** Resolve the semantic assistant-step key owned by the conversation assembler. */
|
|
function assistantKey(event: SessionEvent<'assistant/message'>): string {
|
|
return conversationContextKey('assistant-step', `${String(event.data.turn)}:${String(event.data.step)}`)
|
|
}
|
|
|
|
/** Wait until opening a persisted Session publishes its live Agent. */
|
|
async function liveAgent(scaffold: WebScaffold, sessionId: SessionId): Promise<Agent> {
|
|
const deadline = Date.now() + 30_000
|
|
for (;;) {
|
|
const found = scaffold.ctx.agents.get(sessionId)
|
|
if (found !== undefined) return found
|
|
if (Date.now() >= deadline) throw new Error(`opening session "${sessionId}" published no live Agent`)
|
|
await new Promise<void>(resolve => setTimeout(resolve, 100))
|
|
}
|
|
}
|
|
|
|
/** Expand the first Workspace row and open the named Session. */
|
|
async function openSession(page: Page, title: string): Promise<void> {
|
|
const workspace = page.locator('[role="treeitem"]').first()
|
|
await workspace.waitFor({ timeout: 15_000 })
|
|
const deadline = Date.now() + 5_000
|
|
while (await workspace.getAttribute('aria-expanded') !== 'true') {
|
|
if (Date.now() >= deadline) throw new Error('workspace item did not expand')
|
|
await workspace.click()
|
|
await new Promise<void>(resolve => setTimeout(resolve, 50))
|
|
}
|
|
const row = page.getByRole('treeitem', { name: new RegExp(title) })
|
|
await row.waitFor({ timeout: 15_000 })
|
|
await row.click()
|
|
// The current crumb renders as plain text, not a button.
|
|
await page.getByRole('navigation', { name: 'Session hierarchy' })
|
|
.getByText(title, { exact: true })
|
|
.waitFor({ timeout: 15_000 })
|
|
}
|
|
|
|
describe.skipIf(MODE === 'record')('web e2e: conversational reminders', () => {
|
|
let scaffold: WebScaffold
|
|
let afterHandle: AgentHandle
|
|
let atHandle: AgentHandle
|
|
let everyHandle: AgentHandle
|
|
let browser: Browser
|
|
let page: Page
|
|
let afterAssistantReply: SessionEvent<'assistant/message'> | undefined
|
|
let atAssistantReply: SessionEvent<'assistant/message'> | undefined
|
|
let everyAssistantReply: SessionEvent<'assistant/message'> | undefined
|
|
let everyRecords: readonly [EveryScheduleRecord, EveryScheduleRecord]
|
|
let tripwire: ReturnType<typeof watchConsole>
|
|
const afterAdapter = new ReminderAdapter()
|
|
const atAdapter = new BrowserZoneAtAdapter()
|
|
const everyAdapter = new EveryReminderAdapter()
|
|
|
|
beforeAll(async () => {
|
|
scaffold = await launchWebScaffold({ extraOverlayPath: OVERLAY })
|
|
scaffold.ctx.effect(
|
|
() => scaffold.ctx.llm.registerAdapter([AFTER_PROVIDER], afterAdapter),
|
|
'Schedule Web After adapter',
|
|
)
|
|
scaffold.ctx.effect(
|
|
() => scaffold.ctx.llm.registerAdapter([AT_PROVIDER], atAdapter),
|
|
'Schedule Web At adapter',
|
|
)
|
|
scaffold.ctx.effect(
|
|
() => scaffold.ctx.llm.registerAdapter([EVERY_PROVIDER], everyAdapter),
|
|
'Schedule Web Every adapter',
|
|
)
|
|
|
|
browser = await chromium.launch()
|
|
page = await browser.newPage({
|
|
viewport: { width: 1680, height: 1000 },
|
|
locale: 'en-US',
|
|
timezoneId: AT_BROWSER_ZONE,
|
|
})
|
|
await page.addInitScript(() => { localStorage.setItem('dsh.locale', 'en') })
|
|
tripwire = watchConsole(page)
|
|
await page.goto(scaffold.authenticatedUrl, { waitUntil: 'load' })
|
|
await page.waitForSelector('[class*="frame"]', { timeout: 30_000 })
|
|
await connectFreshWorkspace(page, scaffold.workspaceCwd)
|
|
expect(await page.evaluate(() => Intl.DateTimeFormat().resolvedOptions().timeZone))
|
|
.toBe(AT_BROWSER_ZONE)
|
|
|
|
const cwd = join(scaffold.workspaceCwd, 'workspace')
|
|
const workspace = await scaffold.ctx.workspaceRegistry.resolveByPath(cwd)
|
|
if (workspace === undefined) throw new Error('connected Web workspace was not registered')
|
|
|
|
afterHandle = await scaffold.ctx.agents.create({
|
|
sessionId: SessionId('schedule-after-web-e2e'),
|
|
meta: { cwd },
|
|
agentOptions: { provider: AFTER_PROVIDER, model: MODEL },
|
|
})
|
|
afterHandle.agent.session.append('session/title', {
|
|
title: 'Scheduled After follow-up',
|
|
messageSeqs: [],
|
|
source: { kind: 'user' },
|
|
})
|
|
await workspace.attachSession(afterHandle.agent.id)
|
|
const afterCreated = await scaffold.ctx.tools.execute({
|
|
signal: AbortSignal.timeout(10_000),
|
|
callId: ToolCallId('schedule-after-create'),
|
|
name: 'schedule_create',
|
|
arguments: { prompt: AFTER_PROMPT, after_seconds: 1 },
|
|
agent: afterHandle.agent,
|
|
})
|
|
if (afterCreated.isError) {
|
|
throw new Error(`Schedule After create failed: ${JSON.stringify(afterCreated.value)}`)
|
|
}
|
|
expect(afterCreated.value).toMatchObject({
|
|
id: 'schedule-1',
|
|
kind: 'after',
|
|
prompt: AFTER_PROMPT,
|
|
afterSeconds: 1,
|
|
state: 'scheduled',
|
|
deliveryMode: 'session-local',
|
|
})
|
|
afterAssistantReply = await waitForReply(afterHandle, AFTER_REPLY, 15_000)
|
|
await afterHandle.agent.whenIdle()
|
|
await expect(scaffold.ctx.sessions.flush(afterHandle.agent.session)).resolves.toBe(true)
|
|
|
|
everyHandle = await scaffold.ctx.agents.create({
|
|
sessionId: SessionId('schedule-every-web-e2e'),
|
|
meta: { cwd },
|
|
agentOptions: { provider: EVERY_PROVIDER, model: MODEL },
|
|
})
|
|
everyHandle.agent.session.append('session/title', {
|
|
title: 'Fixed-rate reminder batch',
|
|
messageSeqs: [],
|
|
source: { kind: 'user' },
|
|
})
|
|
const seededAt = Date.now()
|
|
everyRecords = [
|
|
createEveryScheduleRecord(
|
|
ScheduleId('schedule-every-primary'),
|
|
EVERY_PROMPTS[0],
|
|
EVERY_INTERVAL_SECONDS,
|
|
seededAt - EVERY_FIXTURE_AGE_MS,
|
|
),
|
|
createEveryScheduleRecord(
|
|
ScheduleId('schedule-every-secondary'),
|
|
EVERY_PROMPTS[1],
|
|
EVERY_INTERVAL_SECONDS,
|
|
seededAt - EVERY_FIXTURE_AGE_MS,
|
|
),
|
|
]
|
|
for (const record of everyRecords) {
|
|
everyHandle.agent.session.append('schedule/change', {
|
|
version: 1,
|
|
operation: 'create',
|
|
schedule: record,
|
|
})
|
|
}
|
|
await expect(scaffold.ctx.sessions.flush(everyHandle.agent.session)).resolves.toBe(true)
|
|
await workspace.attachSession(everyHandle.agent.id)
|
|
const everyListed = await scaffold.ctx.tools.execute({
|
|
signal: AbortSignal.timeout(10_000),
|
|
callId: ToolCallId('schedule-every-list'),
|
|
name: 'schedule_list',
|
|
arguments: {},
|
|
agent: everyHandle.agent,
|
|
})
|
|
expect(everyListed.isError).toBe(false)
|
|
everyAssistantReply = await waitForReply(everyHandle, EVERY_REPLY, 15_000)
|
|
await everyHandle.agent.whenIdle()
|
|
await expect(scaffold.ctx.sessions.flush(everyHandle.agent.session)).resolves.toBe(true)
|
|
|
|
atHandle = await scaffold.ctx.agents.create({
|
|
sessionId: SessionId('schedule-at-web-e2e'),
|
|
meta: { cwd },
|
|
agentOptions: { provider: AT_PROVIDER, model: MODEL },
|
|
})
|
|
atHandle.agent.session.append('session/title', {
|
|
title: 'Explicit local-time reminder',
|
|
messageSeqs: [],
|
|
source: { kind: 'user' },
|
|
})
|
|
atHandle.agent.followup(createUserMessage({
|
|
content: [{ type: 'text', text: 'Prepare the reminder test session.' }],
|
|
source: { kind: 'schedule-web-e2e' },
|
|
}))
|
|
await atHandle.agent.whenIdle()
|
|
expect(atAdapter.requests).toHaveLength(1)
|
|
await expect(scaffold.ctx.sessions.flush(atHandle.agent.session)).resolves.toBe(true)
|
|
await workspace.attachSession(atHandle.agent.id)
|
|
await page.reload({ waitUntil: 'load' })
|
|
await page.waitForSelector('[class*="frame"]', { timeout: 30_000 })
|
|
const workspaceItem = page.locator('[role="treeitem"]').first()
|
|
await workspaceItem.waitFor({ timeout: 15_000 })
|
|
const expansionDeadline = Date.now() + 5_000
|
|
while (await workspaceItem.getAttribute('aria-expanded') !== 'true') {
|
|
if (Date.now() >= expansionDeadline) throw new Error('workspace item did not expand')
|
|
if (await workspaceItem.getAttribute('aria-expanded') !== 'true') {
|
|
await workspaceItem.click()
|
|
}
|
|
await new Promise<void>(resolve => setTimeout(resolve, 50))
|
|
}
|
|
const atSession = page.getByRole('treeitem', { name: /Explicit local-time reminder/ })
|
|
await atSession.waitFor({ timeout: 15_000 })
|
|
await atSession.click()
|
|
const composer = page.locator('[data-composer-input][contenteditable="true"]').last()
|
|
await composer.fill(AT_USER_PROMPT)
|
|
const settled = scaffold.whenTurnSettled(60_000)
|
|
await page.getByRole('button', { name: 'Send message', exact: true }).click()
|
|
expect(await settled).toBe(atHandle.agent.id)
|
|
await page.getByText(AT_ACK, { exact: true }).waitFor({ timeout: 15_000 })
|
|
atAssistantReply = await waitForReply(atHandle, AT_REPLY, 20_000)
|
|
await atHandle.agent.whenIdle()
|
|
await expect(scaffold.ctx.sessions.flush(atHandle.agent.session)).resolves.toBe(true)
|
|
}, 120_000)
|
|
|
|
afterAll(async () => {
|
|
const failures: unknown[] = []
|
|
await browser?.close().catch((error: unknown) => failures.push(error))
|
|
await atHandle?.dispose().catch((error: unknown) => failures.push(error))
|
|
await everyHandle?.dispose().catch((error: unknown) => failures.push(error))
|
|
await afterHandle?.dispose().catch((error: unknown) => failures.push(error))
|
|
await scaffold?.close().catch((error: unknown) => failures.push(error))
|
|
if (failures.length === 1) throw failures[0]
|
|
if (failures.length > 1) throw new AggregateError(failures, 'Schedule Web evidence teardown failed')
|
|
})
|
|
|
|
it('renders After as an ordinary assistant follow-up', async () => {
|
|
onTestFailed(() => saveFailureShot(page, 'web-e2e-schedule-after'))
|
|
const reminderRequest = afterAdapter.requests[0]
|
|
if (reminderRequest === undefined) throw new Error('model did not receive the After reminder')
|
|
expectReminderFraming(reminderRequest)
|
|
const session = page.getByRole('treeitem', { name: /Scheduled After follow-up/ })
|
|
await session.click()
|
|
if (afterAssistantReply === undefined) throw new Error('After assistant reply was not captured')
|
|
const selector = `[data-chat-anchor-key="${assistantKey(afterAssistantReply)}"]`
|
|
const row = page.locator(selector)
|
|
await row.waitFor({ timeout: 15_000 })
|
|
expect(await row.getAttribute('data-chat-flow-kind')).toBe('assistant-step')
|
|
expect(await row.textContent()).toContain(AFTER_REPLY)
|
|
await compareOrRefreshGolden(
|
|
AFTER_EXPECTED,
|
|
await captureStableAria(page, selector, scaffold.workspaceCwd),
|
|
MODE,
|
|
)
|
|
expect(await page.getByRole('button', { name: REMINDER_TRIGGER_NAME }).count()).toBe(0)
|
|
}, 60_000)
|
|
|
|
it('batches one latest occurrence per overdue Every record into an ordinary follow-up', async () => {
|
|
onTestFailed(() => saveFailureShot(page, 'web-e2e-schedule-every'))
|
|
const ids = new Set(everyRecords.map(record => record.id))
|
|
const dispatches = everyHandle.agent.session.snapshotEvents().filter(event => (
|
|
event.type === 'schedule/change'
|
|
&& event.data.operation === 'dispatch'
|
|
&& ids.has(event.data.id)
|
|
))
|
|
expect(dispatches).toHaveLength(2)
|
|
const acceptedAt = dispatches.map((event) => {
|
|
if (event.type !== 'schedule/change' || event.data.operation !== 'dispatch'
|
|
|| !('acceptedAt' in event.data)) throw new Error('expected Every dispatch')
|
|
return event.data.acceptedAt
|
|
})
|
|
expect(new Set(acceptedAt).size).toBe(1)
|
|
const decision = acceptedAt[0]
|
|
if (decision === undefined) throw new Error('missing Every decision time')
|
|
|
|
const batch = everyHandle.agent.session.snapshotEvents().find(event => (
|
|
event.type === 'user/message'
|
|
&& event.data.source.kind === 'schedule'
|
|
&& event.data.content.some(block => block.type === 'text'
|
|
&& block.text.startsWith('[SCHEDULE REMINDER BATCH]'))
|
|
))
|
|
if (batch?.type !== 'user/message') throw new Error('missing Every batch message')
|
|
const batchBlock = batch.data.content.find(block => block.type === 'text')
|
|
if (batchBlock?.type !== 'text') throw new Error('missing Every batch text')
|
|
for (const record of everyRecords) {
|
|
const occurrenceAt = resolveEveryOccurrence(record, Date.parse(decision)).occurrenceAt
|
|
expect(batchBlock.text).toContain(JSON.stringify({
|
|
schedule_id: record.id,
|
|
occurrence_at: occurrenceAt,
|
|
reminder_prompt: record.prompt,
|
|
}).slice(1, -1))
|
|
}
|
|
expect(everyAdapter.requests).toHaveLength(1)
|
|
const reminderRequest = everyAdapter.requests[0]
|
|
if (reminderRequest === undefined) throw new Error('model did not receive the Every batch')
|
|
expect(requestText(reminderRequest)).toContain(batchBlock.text)
|
|
expectReminderFraming(reminderRequest)
|
|
const active = foldScheduleEvents(everyHandle.agent.session.snapshotEvents()).active
|
|
expect(active).toHaveLength(2)
|
|
expect(active.every(record => Date.parse(record.scheduledAt) > Date.parse(decision))).toBe(true)
|
|
|
|
const session = page.getByRole('treeitem', { name: /Fixed-rate reminder batch/ })
|
|
await session.click()
|
|
if (everyAssistantReply === undefined) throw new Error('Every assistant reply was not captured')
|
|
const selector = `[data-chat-anchor-key="${assistantKey(everyAssistantReply)}"]`
|
|
const row = page.locator(selector)
|
|
await row.waitFor({ timeout: 15_000 })
|
|
expect(await row.getAttribute('data-chat-flow-kind')).toBe('assistant-step')
|
|
expect(await row.textContent()).toContain(EVERY_REPLY)
|
|
await compareOrRefreshGolden(
|
|
EVERY_EXPECTED,
|
|
await captureStableAria(page, selector, scaffold.workspaceCwd),
|
|
MODE,
|
|
)
|
|
await page.getByRole('button', { name: '2 reminders', exact: true }).waitFor({ timeout: 15_000 })
|
|
expect(await page.getByRole('list', { name: 'Active reminders' }).count()).toBe(0)
|
|
}, 60_000)
|
|
|
|
it('uses request-local browser context to create an explicit local At reminder', async () => {
|
|
onTestFailed(() => saveFailureShot(page, 'web-e2e-schedule-at'))
|
|
const user = atHandle.agent.session.snapshotEvents().find(event => (
|
|
event.type === 'user/message'
|
|
&& event.data.source.kind === 'user'
|
|
&& event.data.content.some(block => block.type === 'text' && block.text === AT_USER_PROMPT)
|
|
))
|
|
if (user?.type !== 'user/message' || user.data.source.kind !== 'user') {
|
|
throw new Error('missing browser user-rpc message')
|
|
}
|
|
expect(user.data.source).toMatchObject({ kind: 'user', clientTimeZone: AT_BROWSER_ZONE })
|
|
expect(typeof (user.data.source as { rpcId?: unknown }).rpcId).toBe('string')
|
|
|
|
const firstRequest = atAdapter.requests[1]
|
|
if (firstRequest === undefined) throw new Error('model did not receive the browser prompt')
|
|
expect(requestText(firstRequest)).toContain(
|
|
`Browser time zone for this request: ${AT_BROWSER_ZONE}. `
|
|
+ 'Interpret otherwise-unqualified dates and times in this zone.',
|
|
)
|
|
expect(firstRequest.tools?.some(tool => tool.name === 'schedule_create')).toBe(true)
|
|
const selectedAt = atAdapter.selectedAt
|
|
const scheduledAt = atAdapter.scheduledAt
|
|
if (selectedAt === undefined || scheduledAt === undefined) {
|
|
throw new Error('model did not choose an explicit local At target')
|
|
}
|
|
expect(selectedAt.time_zone).toBe(AT_BROWSER_ZONE)
|
|
|
|
const toolCall = atHandle.agent.session.snapshotEvents().find(event => (
|
|
event.type === 'tool/call' && event.data.name === 'schedule_create'
|
|
))
|
|
if (toolCall?.type !== 'tool/call') throw new Error('missing schedule_create tool call')
|
|
expect(JSON.parse(toolCall.data.arguments)).toEqual({ prompt: AT_PROMPT, at: selectedAt })
|
|
const created = atHandle.agent.session.snapshotEvents().find(event => (
|
|
event.type === 'schedule/change'
|
|
&& event.data.operation === 'create'
|
|
&& event.data.schedule.kind === 'at'
|
|
))
|
|
if (created?.type !== 'schedule/change' || created.data.operation !== 'create') {
|
|
throw new Error('explicit local At call did not create a durable record')
|
|
}
|
|
const schedule = created.data.schedule
|
|
expect(schedule).toMatchObject({
|
|
kind: 'at',
|
|
prompt: AT_PROMPT,
|
|
scheduledAt,
|
|
})
|
|
expect(atHandle.agent.session.snapshotEvents().filter(event => (
|
|
event.type === 'schedule/change'
|
|
&& event.data.operation === 'dispatch'
|
|
&& event.data.id === schedule.id
|
|
))).toHaveLength(1)
|
|
expect(atAdapter.requests).toHaveLength(4)
|
|
const reminderRequest = atAdapter.requests[3]
|
|
if (reminderRequest === undefined) throw new Error('model did not receive the At reminder')
|
|
expectReminderFraming(reminderRequest)
|
|
|
|
const session = page.getByRole('treeitem', { name: /Explicit local-time reminder/ })
|
|
await session.click()
|
|
if (atAssistantReply === undefined) throw new Error('At assistant reply was not captured')
|
|
const selector = `[data-chat-anchor-key="${assistantKey(atAssistantReply)}"]`
|
|
const row = page.locator(selector)
|
|
await row.waitFor({ timeout: 15_000 })
|
|
expect(await row.getAttribute('data-chat-flow-kind')).toBe('assistant-step')
|
|
expect(await row.textContent()).toContain(AT_REPLY)
|
|
await compareOrRefreshGolden(
|
|
AT_EXPECTED,
|
|
await captureStableAria(page, selector, scaffold.workspaceCwd),
|
|
MODE,
|
|
)
|
|
expect(await page.getByRole('button', { name: REMINDER_TRIGGER_NAME }).count()).toBe(0)
|
|
expect(tripwire.pageErrors).toEqual([])
|
|
expect(tripwire.warnings).toEqual([])
|
|
}, 60_000)
|
|
|
|
it('keeps the fixture inventory closed', async () => {
|
|
await assertFixtureInventory(SNAPSHOT_DIR, [
|
|
'at-conversation.expected.md',
|
|
'conversation.expected.md',
|
|
'every-conversation.expected.md',
|
|
])
|
|
})
|
|
})
|
|
|
|
describe.skipIf(MODE === 'record')('web e2e: active Schedule catalog', () => {
|
|
let scaffold: WebScaffold
|
|
let browser: Browser
|
|
let page: Page
|
|
let tripwire: ReturnType<typeof watchConsole>
|
|
|
|
beforeAll(async () => {
|
|
const fixture = await readFile(CATALOG_FIXTURE, 'utf8')
|
|
scaffold = await launchWebScaffold({
|
|
extraOverlayPath: OVERLAY,
|
|
})
|
|
await seedSession(scaffold, fixture, CATALOG_SESSION_ID, 'standard')
|
|
const workspace = await scaffold.ctx.workspaceRegistry.create(scaffold.workspaceCwd)
|
|
await workspace.attachSession(CATALOG_SESSION_ID)
|
|
|
|
// Seed the zero-I/O list view before the Session is opened.
|
|
const catalogReader = await scaffold.ctx.sessionPersistence.open(CATALOG_SESSION_ID, 'read')
|
|
try {
|
|
const catalogEvents = [...(await catalogReader.read()).events]
|
|
scaffold.ctx.sessionProjectionCache.coldSnapshot(catalogReader.header, catalogReader.inheritedEventCount, catalogEvents)
|
|
} finally {
|
|
await catalogReader.close()
|
|
}
|
|
|
|
browser = await chromium.launch()
|
|
page = await browser.newPage({
|
|
viewport: { width: 900, height: 900 },
|
|
locale: 'en-US',
|
|
timezoneId: AT_BROWSER_ZONE,
|
|
})
|
|
await page.clock.setFixedTime(new Date(CATALOG_NOW))
|
|
await page.addInitScript(() => { localStorage.setItem('dsh.locale', 'en') })
|
|
tripwire = watchConsole(page)
|
|
await page.goto(scaffold.authenticatedUrl, { waitUntil: 'load' })
|
|
await page.waitForSelector('[class*="frame"]', { timeout: 30_000 })
|
|
await page.evaluate(() => { document.body.removeAttribute('data-ds-dark-theme') })
|
|
const openSidebar = page.getByRole('button', { name: 'Open sidebar' })
|
|
if (await openSidebar.isVisible()) {
|
|
await openSidebar.click()
|
|
await page.getByRole('button', { name: 'Collapse sidebar' }).waitFor({ timeout: 10_000 })
|
|
}
|
|
const workspaceRow = page.locator('[role="treeitem"]').first()
|
|
await workspaceRow.waitFor({ timeout: 15_000 })
|
|
const expansionDeadline = Date.now() + 5_000
|
|
while (await workspaceRow.getAttribute('aria-expanded') !== 'true') {
|
|
if (Date.now() >= expansionDeadline) throw new Error('workspace item did not expand')
|
|
await workspaceRow.click()
|
|
await new Promise<void>(resolve => setTimeout(resolve, 50))
|
|
}
|
|
await page.getByRole('treeitem', { name: new RegExp(CATALOG_TITLE) }).waitFor({ timeout: 15_000 })
|
|
}, 120_000)
|
|
|
|
afterAll(async () => {
|
|
const failures: unknown[] = []
|
|
await browser?.close().catch((error: unknown) => failures.push(error))
|
|
await scaffold?.close().catch((error: unknown) => failures.push(error))
|
|
if (failures.length === 1) throw failures[0]
|
|
if (failures.length > 1) throw new AggregateError(failures, 'Schedule catalog teardown failed')
|
|
})
|
|
|
|
it('replays the overlay-only catalog and sidebar marker, then removes both live', async () => {
|
|
onTestFailed(() => saveFailureShot(page, 'web-e2e-schedule-catalog'))
|
|
const base = composeEntries([
|
|
loadOverlayPatches('Schedule catalog base roster', BASE_PATCH),
|
|
loadOverlayPatches('Schedule catalog base roster', WEB_PATCH),
|
|
])
|
|
const scheduled = composeEntries([
|
|
loadOverlayPatches('Schedule catalog overlay roster', BASE_PATCH),
|
|
loadOverlayPatches('Schedule catalog overlay roster', WEB_PATCH),
|
|
loadOverlayPatches('Schedule catalog overlay roster', OVERLAY),
|
|
])
|
|
expect(base.find(entry => entry.id === 'ui-schedule')).toMatchObject({
|
|
name: '@deepseek-ai/dsh-client-ui-schedule',
|
|
disabled: true,
|
|
})
|
|
expect(scheduled.find(entry => entry.id === 'ui-schedule')).toMatchObject({
|
|
name: '@deepseek-ai/dsh-client-ui-schedule',
|
|
disabled: false,
|
|
})
|
|
|
|
const catalogRow = page.getByRole('treeitem', { name: new RegExp(CATALOG_TITLE) })
|
|
expect(await catalogRow.getByRole('img', { name: ACTIVE_SCHEDULE_LABEL }).count()).toBe(1)
|
|
|
|
await page.getByRole('button', { name: 'Search sessions' }).click()
|
|
const search = page.getByPlaceholder('Search session names', { exact: false })
|
|
await search.fill(CATALOG_TITLE)
|
|
const result = page.getByRole('tree', { name: 'Search results' })
|
|
.getByRole('treeitem', { name: new RegExp(CATALOG_TITLE) })
|
|
await result.waitFor({ timeout: 15_000 })
|
|
expect(await result.getByRole('img', { name: ACTIVE_SCHEDULE_LABEL }).count()).toBe(1)
|
|
expect(await result.getByRole('button').count()).toBe(0)
|
|
|
|
await page.getByRole('button', { name: 'Clear search' }).click()
|
|
await catalogRow.waitFor({ timeout: 15_000 })
|
|
|
|
await page.getByRole('button', { name: 'View options' }).click()
|
|
await page.getByRole('menuitem', { name: 'In one list' }).click()
|
|
const flatRow = page.getByRole('treeitem', { name: new RegExp(CATALOG_TITLE) })
|
|
await flatRow.waitFor({ timeout: 15_000 })
|
|
expect(await flatRow.getByRole('img', { name: ACTIVE_SCHEDULE_LABEL }).count()).toBe(1)
|
|
|
|
await page.getByRole('button', { name: 'View options' }).click()
|
|
await page.getByRole('menuitem', { name: 'WorkSpace', exact: true }).click()
|
|
await catalogRow.waitFor({ timeout: 15_000 })
|
|
expect(await catalogRow.getByRole('img', { name: ACTIVE_SCHEDULE_LABEL }).count()).toBe(1)
|
|
|
|
await openSession(page, CATALOG_TITLE)
|
|
const parentAgent = await liveAgent(scaffold, CATALOG_SESSION_ID)
|
|
|
|
const trigger = page.getByRole('button', { name: '3 reminders' })
|
|
await trigger.waitFor({ timeout: 15_000 })
|
|
await trigger.click()
|
|
const catalog = page.getByRole('list', { name: 'Active reminders' })
|
|
await catalog.waitFor({ timeout: 10_000 })
|
|
expect(await catalog.getByRole('listitem').count()).toBe(3)
|
|
const lightLayout = await page.evaluate(() => {
|
|
const triggerElement = document.querySelector('button[aria-label="3 reminders"]')
|
|
const catalogElement = document.querySelector('[aria-label="Active reminders"]')
|
|
if (!(triggerElement instanceof HTMLElement) || !(catalogElement instanceof HTMLElement)) {
|
|
throw new Error('active reminder trigger or catalog is not mounted')
|
|
}
|
|
const triggerBox = triggerElement.getBoundingClientRect()
|
|
const catalogBox = catalogElement.getBoundingClientRect()
|
|
const viewport = window.innerWidth
|
|
return {
|
|
bodyPortal: catalogElement.parentElement === document.body,
|
|
position: getComputedStyle(catalogElement).position,
|
|
triggerLeft: triggerBox.left,
|
|
catalogLeft: catalogBox.left,
|
|
catalogRight: catalogBox.right,
|
|
width: catalogBox.width,
|
|
viewport,
|
|
expectedLeft: Math.min(Math.max(16, triggerBox.left), viewport - catalogBox.width - 16),
|
|
scrollWidth: document.documentElement.scrollWidth,
|
|
background: getComputedStyle(catalogElement).backgroundColor,
|
|
}
|
|
})
|
|
expect(lightLayout.bodyPortal).toBe(true)
|
|
expect(lightLayout.position).toBe('fixed')
|
|
expect(lightLayout.width).toBe(336)
|
|
expect(lightLayout.catalogLeft).toBe(lightLayout.expectedLeft)
|
|
expect(lightLayout.catalogLeft).toBeLessThan(lightLayout.triggerLeft)
|
|
expect(lightLayout.catalogRight).toBeLessThanOrEqual(lightLayout.viewport - 16)
|
|
expect(lightLayout.scrollWidth).toBeLessThanOrEqual(lightLayout.viewport)
|
|
expect(lightLayout.background).not.toBe('rgba(0, 0, 0, 0)')
|
|
const longRow = catalog.getByRole('listitem').filter({ hasText: 'Join release review' })
|
|
const cadenceRow = catalog.getByRole('listitem').filter({ hasText: 'Check exact cadence' })
|
|
const longPrompt = longRow.locator(':scope > span').nth(1)
|
|
const promptLayout = await longPrompt.evaluate(element => ({
|
|
height: element.getBoundingClientRect().height,
|
|
clientWidth: element.clientWidth,
|
|
scrollWidth: element.scrollWidth,
|
|
}))
|
|
expect(promptLayout.height).toBeGreaterThan(18)
|
|
expect(promptLayout.scrollWidth).toBeLessThanOrEqual(promptLayout.clientWidth)
|
|
const [longRowLayout, cadenceRowLayout] = await Promise.all([
|
|
longRow.evaluate((element) => {
|
|
const box = element.getBoundingClientRect()
|
|
return {
|
|
bottom: box.bottom,
|
|
clientHeight: element.clientHeight,
|
|
scrollHeight: element.scrollHeight,
|
|
childBottoms: [...element.children].map(child => child.getBoundingClientRect().bottom),
|
|
}
|
|
}),
|
|
cadenceRow.evaluate((element) => {
|
|
const box = element.getBoundingClientRect()
|
|
return { top: box.top, bottom: box.bottom }
|
|
}),
|
|
])
|
|
expect(longRowLayout.scrollHeight).toBeLessThanOrEqual(longRowLayout.clientHeight)
|
|
expect(longRowLayout.childBottoms).not.toHaveLength(0)
|
|
for (const childBottom of longRowLayout.childBottoms) {
|
|
expect(childBottom).toBeLessThanOrEqual(longRowLayout.bottom)
|
|
}
|
|
expect(longRowLayout.bottom).toBeLessThanOrEqual(cadenceRowLayout.top)
|
|
expect(cadenceRowLayout.bottom).toBeGreaterThan(cadenceRowLayout.top)
|
|
const scrollLayout = await catalog.evaluate(element => ({
|
|
clientHeight: element.clientHeight,
|
|
scrollHeight: element.scrollHeight,
|
|
}))
|
|
expect(scrollLayout.scrollHeight).toBeGreaterThan(scrollLayout.clientHeight)
|
|
|
|
const evidenceDir = join(REPO_ROOT, '.artifacts')
|
|
await mkdir(evidenceDir, { recursive: true })
|
|
await writeFile(
|
|
join(evidenceDir, 'web-e2e-schedule-catalog-left-alignment.json'),
|
|
`${JSON.stringify(lightLayout, null, 2)}\n`,
|
|
)
|
|
await page.screenshot({
|
|
path: join(evidenceDir, 'web-e2e-schedule-catalog-left-alignment.png'),
|
|
fullPage: true,
|
|
})
|
|
|
|
await page.evaluate(() => { document.body.setAttribute('data-ds-dark-theme', '') })
|
|
const darkBackground = await catalog.evaluate(element => getComputedStyle(element).backgroundColor)
|
|
expect(darkBackground).not.toBe('rgba(0, 0, 0, 0)')
|
|
expect(darkBackground).not.toBe(lightLayout.background)
|
|
await compareOrRefreshGolden(
|
|
CATALOG_EXPECTED,
|
|
await captureStableAria(page, '[aria-label="Active reminders"]', scaffold.workspaceCwd),
|
|
MODE,
|
|
)
|
|
|
|
const sessionRow = page.getByRole('treeitem', { name: new RegExp(CATALOG_TITLE) })
|
|
expect(await sessionRow.getByRole('img', { name: ACTIVE_SCHEDULE_LABEL }).count()).toBe(1)
|
|
for (const id of Object.values(CATALOG_IDS)) {
|
|
parentAgent.session.append('schedule/change', { version: 1, operation: 'delete', id })
|
|
}
|
|
await expect(scaffold.ctx.sessions.flush(parentAgent.session)).resolves.toBe(true)
|
|
await expect.poll(() => page.getByRole('button', { name: REMINDER_TRIGGER_NAME }).count(), {
|
|
timeout: 15_000,
|
|
}).toBe(0)
|
|
expect(await page.getByRole('list', { name: 'Active reminders' }).count()).toBe(0)
|
|
await expect.poll(() => sessionRow.getByRole('img', { name: ACTIVE_SCHEDULE_LABEL }).count(), {
|
|
timeout: 15_000,
|
|
}).toBe(0)
|
|
await assertFixtureInventory(CATALOG_SNAPSHOT_DIR, [
|
|
'catalog.expected.md',
|
|
'session.v3.jsonl',
|
|
'system-prompt.expected.md',
|
|
'tool-schemas.expected.json',
|
|
])
|
|
expect(tripwire.pageErrors).toEqual([])
|
|
expect(tripwire.warnings).toEqual([])
|
|
}, 60_000)
|
|
})
|