mirror of
https://github.com/anomalyco/opencode.git
synced 2026-11-20 10:18:46 +03:00
fix(app): restore selected review pane tab per session (#48079)
This commit is contained in:
committed by
GitHub
Unverified
parent
2dea1f3d0e
commit
d55d941f3c
@@ -39,6 +39,51 @@ test("restores review mode and selected file per session", async ({ page }) => {
|
||||
await expectSelectedFile(page, "gamma.ts")
|
||||
})
|
||||
|
||||
for (const tab of ["Context", "Open file", "README.md"]) {
|
||||
test(`restores the selected ${tab} pane tab after switching sessions and reloading`, async ({ page }) => {
|
||||
await setup(page)
|
||||
await page.goto(sessionHref(sessionA))
|
||||
await expectSessionTitle(page, titleA)
|
||||
await page.getByRole("button", { name: "Toggle review" }).click()
|
||||
|
||||
const panel = page.locator("#review-panel")
|
||||
if (tab === "Context") await page.getByRole("button", { name: "View context usage" }).click()
|
||||
if (tab !== "Context") await panel.getByRole("button", { name: "Open file" }).click()
|
||||
if (tab === "README.md") await panel.getByRole("button", { name: "README.md" }).click()
|
||||
await expect(panel.getByRole("tab", { name: tab, selected: true })).toBeVisible()
|
||||
|
||||
await switchSession(page, titleB)
|
||||
await page.getByRole("button", { name: "Toggle review" }).click()
|
||||
await expect(panel.locator("#session-side-panel-review-tab")).toHaveAttribute("aria-selected", "true")
|
||||
|
||||
await switchSession(page, titleA)
|
||||
await expect(panel.getByRole("tab", { name: tab, selected: true })).toBeVisible()
|
||||
|
||||
await page.reload()
|
||||
await expectSessionTitle(page, titleA)
|
||||
await expect(panel.getByRole("tab", { name: tab, selected: true })).toBeVisible()
|
||||
|
||||
const selected = panel.getByRole("tab", { name: tab })
|
||||
const review = panel.locator("#session-side-panel-review-tab")
|
||||
await selected.press("Home")
|
||||
await expect(review).toHaveAttribute("aria-selected", "true")
|
||||
await review.press("End")
|
||||
await expect(selected).toHaveAttribute("aria-selected", "true")
|
||||
await review.click()
|
||||
await expect(review).toHaveAttribute("aria-selected", "true")
|
||||
await selected.click()
|
||||
await expect(selected).toHaveAttribute("aria-selected", "true")
|
||||
|
||||
await switchSession(page, titleB)
|
||||
await expect(review).toHaveAttribute("aria-selected", "true")
|
||||
await switchSession(page, titleA)
|
||||
await expect(selected).toHaveAttribute("aria-selected", "true")
|
||||
await selected.press("Control+w")
|
||||
await expect(selected).toHaveCount(0)
|
||||
await expect(review).toHaveAttribute("aria-selected", "true")
|
||||
})
|
||||
}
|
||||
|
||||
async function selectFile(page: Page, file: string) {
|
||||
await page.getByRole("button", { name: file }).click()
|
||||
await expectSelectedFile(page, file)
|
||||
@@ -76,6 +121,10 @@ async function setup(page: Page) {
|
||||
default: { providerID: "opencode", modelID: "test" },
|
||||
},
|
||||
sessions: [session(sessionA, titleA, 1700000000000), session(sessionB, titleB, 1700000001000)],
|
||||
fileList: () => [
|
||||
{ name: "README.md", path: "README.md", absolute: `${directory}/README.md`, type: "file", ignored: false },
|
||||
],
|
||||
fileContent: (path) => ({ type: "text", content: `contents:${path}` }),
|
||||
pageMessages: () => ({ items: [] }),
|
||||
})
|
||||
await page.route(/\/api\/vcs(?:\?.*)?$/, (route) =>
|
||||
|
||||
@@ -1,7 +1,12 @@
|
||||
import type { Browser } from "@opencode/plugin-browser/rpc"
|
||||
|
||||
export type BrowserPaneEndpoint = Readonly<{ url: string; username?: string; password?: string }>
|
||||
export type BrowserPaneTarget = Readonly<{ sessionID: string; endpoint: BrowserPaneEndpoint; restore?: Browser.State }>
|
||||
export type BrowserPaneTarget = Readonly<{
|
||||
serverKey: string
|
||||
sessionID: string
|
||||
endpoint: BrowserPaneEndpoint
|
||||
restore?: Browser.State
|
||||
}>
|
||||
export type BrowserPaneLayout = {
|
||||
tabID: Browser.TabID
|
||||
visible: boolean
|
||||
|
||||
@@ -95,7 +95,11 @@ export const { use: useBrowserAttachments, provider: BrowserAttachmentsProvider
|
||||
const connection = createBrowserConnection({
|
||||
pane,
|
||||
// Resolve the current port at every wake, including after sidecar replacement.
|
||||
target: () => ({ sessionID, endpoint: { ...server.conn.http, url: server.ctx.sdk.url } }),
|
||||
target: () => ({
|
||||
serverKey: server.key,
|
||||
sessionID,
|
||||
endpoint: { ...server.conn.http, url: server.ctx.sdk.url },
|
||||
}),
|
||||
focus: (tabID) => focus.get(id)?.forEach((listener) => listener(tabID)),
|
||||
change: (state) => {
|
||||
if (state.error === "browser.pane.unsupported") {
|
||||
|
||||
@@ -29,7 +29,7 @@ function fixture() {
|
||||
}[] = []
|
||||
const endpoint = { url: "http://localhost:4096" }
|
||||
const connection = createBrowserConnection({
|
||||
target: () => ({ sessionID: "ses_browser", endpoint: { ...endpoint } }),
|
||||
target: () => ({ serverKey: "browser-test", sessionID: "ses_browser", endpoint: { ...endpoint } }),
|
||||
change: (state) => states.push(state),
|
||||
focus: () => {},
|
||||
pane: {
|
||||
@@ -66,7 +66,12 @@ test("suspension retains tabs and reconnects once on demand using the current en
|
||||
app.connection.wake()
|
||||
app.connection.wake()
|
||||
expect(app.calls).toHaveLength(2)
|
||||
expect(app.calls[1].target).toEqual({ sessionID: "ses_browser", endpoint: app.endpoint, restore: browser })
|
||||
expect(app.calls[1].target).toEqual({
|
||||
serverKey: "browser-test",
|
||||
sessionID: "ses_browser",
|
||||
endpoint: app.endpoint,
|
||||
restore: browser,
|
||||
})
|
||||
expect(app.states.at(-1)?.suspended).toBe(false)
|
||||
app.calls[0].emit({ type: "state", state: null, error: "browser.pane.registration.closed" })
|
||||
expect(app.states.at(-1)?.registration).toBeDefined()
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
import { For, Match, Show, Switch, createEffect, createMemo, onCleanup, type JSX } from "solid-js"
|
||||
import { createMediaQuery } from "@solid-primitives/media"
|
||||
import { createEventListener } from "@solid-primitives/event-listener"
|
||||
import { DragDropProvider, PointerSensor } from "@dnd-kit/solid"
|
||||
import { isSortable } from "@dnd-kit/solid/sortable"
|
||||
import { Accessibility, AutoScroller, Feedback, PointerActivationConstraints } from "@dnd-kit/dom"
|
||||
@@ -191,6 +192,7 @@ export function SessionSidePanel(props: {
|
||||
|
||||
let fileFilter: HTMLInputElement | undefined
|
||||
let tabList: HTMLDivElement | undefined
|
||||
let selectionEvent: Event | undefined
|
||||
const temporaryTab = tabs().preview
|
||||
const previewTab = (value: string) => {
|
||||
const next = normalizeTab(value)
|
||||
@@ -299,11 +301,24 @@ export function SessionSidePanel(props: {
|
||||
tabs().move(source.id.toString(), source.index)
|
||||
}}
|
||||
>
|
||||
<Tabs value={activeTab()} onChange={activateTab}>
|
||||
<Tabs
|
||||
value={activeTab()}
|
||||
onChange={(value) => {
|
||||
// Kobalte selects the first tab while session triggers register.
|
||||
// Persist input events only; createSessionTabs owns fallback selection.
|
||||
if (selectionEvent && selectionEvent.eventPhase !== Event.NONE) activateTab(value)
|
||||
}}
|
||||
>
|
||||
<div class="session-review-v2-tabs-bar sticky top-0 shrink-0 flex items-center">
|
||||
<Tabs.List
|
||||
ref={(el: HTMLDivElement) => {
|
||||
tabList = el
|
||||
createEventListener(
|
||||
el,
|
||||
["pointerdown", "click", "keydown"],
|
||||
(event) => (selectionEvent = event),
|
||||
{ capture: true },
|
||||
)
|
||||
const stop = createFileTabListSync({ el, contextOpen })
|
||||
onCleanup(stop)
|
||||
}}
|
||||
|
||||
@@ -13,6 +13,8 @@ import { createBrowserNetwork, type BrowserNetwork } from "./browser/network"
|
||||
import { destinationOrigin } from "./browser/policy"
|
||||
import { emitIpcEvent } from "./ipc-events"
|
||||
import { SidecarCredentials } from "./service/sidecar-credentials"
|
||||
import { createBrowserRestoreStore } from "./browser/restore"
|
||||
import type { StateStore } from "./storage/state"
|
||||
|
||||
type Entry = {
|
||||
bindingID: string
|
||||
@@ -28,10 +30,12 @@ type Entry = {
|
||||
partition: string
|
||||
lastState?: string
|
||||
network?: BrowserNetwork
|
||||
storageKey: string
|
||||
}
|
||||
|
||||
export function createBrowserPane() {
|
||||
export function createBrowserPane(storage: StateStore) {
|
||||
const entries = new Map<string, Entry>()
|
||||
const restore = createBrowserRestoreStore(storage)
|
||||
// Keep long-lived RPC requests off Chromium's shared HTTP connection pool.
|
||||
const runtime = ManagedRuntime.make(NodeHttpClient.layerNodeHttp)
|
||||
let disposed = false
|
||||
@@ -42,6 +46,16 @@ export function createBrowserPane() {
|
||||
if (entries.has(bindingID)) throw new Error("browser.pane.owner.invalid")
|
||||
if (win.isDestroyed() || win.webContents.isDestroyed()) throw new Error("browser.pane.owner.unavailable")
|
||||
const sessionID = SessionID.make(target.sessionID)
|
||||
const storageKey = `${target.serverKey}\n${sessionID}`
|
||||
const saved = restore.load(storageKey)
|
||||
const previous = target.restore ?? {
|
||||
tabs: saved.tabs.map((tab) => ({
|
||||
...tab,
|
||||
title: "",
|
||||
generation: 0,
|
||||
})),
|
||||
focusedTabID: saved.focusedTabID,
|
||||
}
|
||||
const entry: Entry = {
|
||||
bindingID,
|
||||
win,
|
||||
@@ -50,7 +64,7 @@ export function createBrowserPane() {
|
||||
requests: new Map(),
|
||||
pages: new Map(),
|
||||
tabs: new Map(
|
||||
target.restore?.tabs.map((tab) => [
|
||||
previous.tabs.map((tab) => [
|
||||
tab.id,
|
||||
{
|
||||
...tab,
|
||||
@@ -61,8 +75,9 @@ export function createBrowserPane() {
|
||||
},
|
||||
]),
|
||||
),
|
||||
focusedTabID: target.restore?.focusedTabID ?? null,
|
||||
focusedTabID: previous.focusedTabID,
|
||||
partition: `opencode-browser-${crypto.randomUUID()}`,
|
||||
storageKey,
|
||||
}
|
||||
// "unsupported" means the server has no browser plugin; the renderer stops retrying.
|
||||
let reason: "browser.pane.unsupported" | "browser.pane.replaced" | "browser.pane.suspended" | undefined
|
||||
@@ -260,7 +275,9 @@ export function createBrowserPane() {
|
||||
await execute(entry, { action: command, files: [] }, new AbortController().signal)
|
||||
},
|
||||
async close(win: BrowserWindow, bindingID: string) {
|
||||
close(owned(win, bindingID))
|
||||
const entry = owned(win, bindingID)
|
||||
restore.remove(entry.storageKey)
|
||||
close(entry)
|
||||
},
|
||||
async dispose() {
|
||||
disposed = true
|
||||
@@ -323,6 +340,16 @@ export function createBrowserPane() {
|
||||
state: inventory(entry),
|
||||
...(error === undefined ? {} : { error }),
|
||||
}
|
||||
// Teardown publishes an empty inventory to the renderer, but the saved URLs survive app exit.
|
||||
if (entry.report)
|
||||
restore.save(entry.storageKey, {
|
||||
tabs: event.state.tabs.map((tab) => ({
|
||||
id: tab.id,
|
||||
// A restored page can publish before Chromium assigns its URL.
|
||||
url: tab.url || entry.tabs.get(tab.id)?.url || "about:blank",
|
||||
})),
|
||||
focusedTabID: entry.focusedTabID,
|
||||
})
|
||||
const next = JSON.stringify(event)
|
||||
if (entry.lastState === next) return
|
||||
entry.lastState = next
|
||||
|
||||
@@ -0,0 +1,58 @@
|
||||
import { expect, test } from "bun:test"
|
||||
import { Browser } from "@opencode/plugin-browser/rpc"
|
||||
import { mkdtemp, rm } from "node:fs/promises"
|
||||
import path from "node:path"
|
||||
import { tmpdir } from "node:os"
|
||||
import { openDatabase } from "../storage/database"
|
||||
import { createStateStore } from "../storage/state"
|
||||
import { createBrowserRestoreStore } from "./restore"
|
||||
|
||||
test("persists browser tab URLs and focus across a database reopen", async () => {
|
||||
const directory = await mkdtemp(path.join(tmpdir(), "opencode-browser-restore-"))
|
||||
const filename = path.join(directory, "state.sqlite")
|
||||
const first = openDatabase(filename)
|
||||
const storage = createStateStore(first.db)
|
||||
const restore = createBrowserRestoreStore(storage)
|
||||
const key = "local\nses_restore"
|
||||
const tab = {
|
||||
id: Browser.TabID.make("tab_00000000-0000-0000-0000-000000000001"),
|
||||
url: "https://example.com/docs",
|
||||
title: "Transient title",
|
||||
loading: false,
|
||||
canGoBack: true,
|
||||
canGoForward: false,
|
||||
generation: 5,
|
||||
}
|
||||
restore.save(key, { tabs: [tab], focusedTabID: tab.id })
|
||||
storage.close()
|
||||
first.close()
|
||||
|
||||
const second = openDatabase(filename)
|
||||
const reopenedStorage = createStateStore(second.db)
|
||||
const reopened = createBrowserRestoreStore(reopenedStorage)
|
||||
try {
|
||||
expect(reopened.load(key)).toEqual({ tabs: [{ id: tab.id, url: tab.url }], focusedTabID: tab.id })
|
||||
expect(reopened.load("remote\nses_restore")).toEqual({ tabs: [], focusedTabID: null })
|
||||
reopened.save(key, { tabs: [], focusedTabID: null })
|
||||
expect(reopened.load(key)).toEqual({ tabs: [], focusedTabID: null })
|
||||
reopened.remove(key)
|
||||
expect(reopenedStorage.get("opencode.browser.dat", key)).toBeNull()
|
||||
} finally {
|
||||
reopenedStorage.close()
|
||||
second.close()
|
||||
// Bun's SQLite shim can retain WAL handles on Windows after close.
|
||||
await rm(directory, { recursive: true, force: true }).catch(() => undefined)
|
||||
}
|
||||
})
|
||||
|
||||
test("ignores malformed browser restoration metadata", () => {
|
||||
const database = openDatabase(":memory:")
|
||||
const storage = createStateStore(database.db)
|
||||
try {
|
||||
storage.set("opencode.browser.dat", "local\nses_restore", '{"tabs":[{"id":"invalid","url":12}]}')
|
||||
expect(createBrowserRestoreStore(storage).load("local\nses_restore")).toEqual({ tabs: [], focusedTabID: null })
|
||||
} finally {
|
||||
storage.close()
|
||||
database.close()
|
||||
}
|
||||
})
|
||||
@@ -0,0 +1,31 @@
|
||||
import { Browser } from "@opencode/plugin-browser/rpc"
|
||||
import { Option, Schema } from "effect"
|
||||
import type { StateStore } from "../storage/state"
|
||||
|
||||
const Stored = Schema.fromJsonString(
|
||||
Schema.Struct({
|
||||
tabs: Schema.Array(Schema.Struct({ id: Browser.TabID, url: Browser.Tab.fields.url })),
|
||||
focusedTabID: Schema.NullOr(Browser.TabID),
|
||||
}),
|
||||
)
|
||||
const decode = Schema.decodeUnknownOption(Stored)
|
||||
const encode = Schema.encodeSync(Stored)
|
||||
const namespace = "opencode.browser.dat"
|
||||
|
||||
export function createBrowserRestoreStore(storage: StateStore) {
|
||||
return {
|
||||
load(key: string) {
|
||||
return Option.getOrElse(decode(storage.get(namespace, key)), () => ({ tabs: [], focusedTabID: null }))
|
||||
},
|
||||
save(key: string, state: typeof Stored.Type) {
|
||||
const value = encode({
|
||||
tabs: state.tabs.map((tab) => ({ id: tab.id, url: tab.url })),
|
||||
focusedTabID: state.focusedTabID,
|
||||
})
|
||||
if (storage.get(namespace, key) !== value) storage.set(namespace, key, value)
|
||||
},
|
||||
remove(key: string) {
|
||||
storage.delete(namespace, key)
|
||||
},
|
||||
}
|
||||
}
|
||||
@@ -6,13 +6,15 @@ import { ipcEventStream } from "../ipc-events"
|
||||
import { IpcPortHandoff } from "../ipc-transport"
|
||||
import { Shutdown } from "../lifecycle/shutdown"
|
||||
import { isRendererUrl } from "../windows/protocol"
|
||||
import { DesktopStorage } from "../storage"
|
||||
import { sender } from "./context"
|
||||
|
||||
export const eventHandlers = EventRpcs.toLayer(
|
||||
Effect.gen(function* () {
|
||||
const handoff = yield* IpcPortHandoff
|
||||
const shutdown = yield* Shutdown.Service
|
||||
const browser = createBrowserPane()
|
||||
const storage = yield* DesktopStorage.Service
|
||||
const browser = createBrowserPane(storage.state)
|
||||
const stop = Effect.promise(() => browser.dispose())
|
||||
const remove = yield* shutdown.add(stop)
|
||||
yield* Effect.addFinalizer(() => Effect.sync(remove).pipe(Effect.andThen(stop)))
|
||||
|
||||
@@ -10,6 +10,7 @@ const endpoint = Schema.Struct({
|
||||
password: Schema.optionalKey(text(4_096)),
|
||||
})
|
||||
const target = Schema.Struct({
|
||||
serverKey: text(16_384),
|
||||
sessionID: text(256).check(Schema.isStartsWith("ses")),
|
||||
endpoint,
|
||||
restore: Schema.optionalKey(Browser.State),
|
||||
|
||||
@@ -12,6 +12,8 @@ import { bindIpcEvents, ipcEventStream } from "../../src/main/ipc-events"
|
||||
import { createBrowserConnection, type BrowserConnectionState } from "../../../app/src/session/browser/connection"
|
||||
import type { BrowserPaneEvent } from "../../../app/src/runtime/platform/browser-pane"
|
||||
import { Smoke } from "./contract"
|
||||
import { openDatabase } from "../../src/main/storage/database"
|
||||
import { createStateStore } from "../../src/main/storage/state"
|
||||
|
||||
async function main() {
|
||||
app.setPath("userData", path.join(process.env.SMOKE_ROOT!, "electron-data"))
|
||||
@@ -36,7 +38,9 @@ async function main() {
|
||||
const client = OpenCode.make({ baseUrl: endpoint.url, headers })
|
||||
const location = { directory: process.env.SMOKE_SERVER_FILES! }
|
||||
const session = await client.session.create({ title: "Idle browser", location })
|
||||
const pane = createBrowserPane()
|
||||
const database = openDatabase(":memory:")
|
||||
const storage = createStateStore(database.db)
|
||||
const pane = createBrowserPane(storage)
|
||||
const win = new BrowserWindow({ show: false, width: 1100, height: 800, webPreferences: { sandbox: true } })
|
||||
await win.loadURL("about:blank")
|
||||
win.showInactive()
|
||||
@@ -53,7 +57,7 @@ async function main() {
|
||||
)
|
||||
const states: BrowserConnectionState[] = []
|
||||
const connection = createBrowserConnection({
|
||||
target: () => ({ sessionID: session.id, endpoint }),
|
||||
target: () => ({ serverKey: "browser-idle", sessionID: session.id, endpoint }),
|
||||
change: (state) => states.push(state),
|
||||
focus: () => {},
|
||||
pane: {
|
||||
@@ -117,15 +121,13 @@ async function main() {
|
||||
)
|
||||
assert(!result.error, result.output)
|
||||
assert(result.output.includes("Browser connection restored"))
|
||||
const background = await client
|
||||
.rpc(Smoke)
|
||||
.execute(
|
||||
{
|
||||
sessionID: session.id,
|
||||
code: `return await tools.browser.snapshot({tabID: ${JSON.stringify(saved.tabs[1].id)}})`,
|
||||
},
|
||||
{ location },
|
||||
)
|
||||
const background = await client.rpc(Smoke).execute(
|
||||
{
|
||||
sessionID: session.id,
|
||||
code: `return await tools.browser.snapshot({tabID: ${JSON.stringify(saved.tabs[1].id)}})`,
|
||||
},
|
||||
{ location },
|
||||
)
|
||||
assert(!background.error, background.output)
|
||||
assert.equal(loads.get("/second"), 2, "an agent can load an inactive restored tab without user focus")
|
||||
if (process.env.SMOKE_EVIDENCE) {
|
||||
@@ -139,6 +141,8 @@ async function main() {
|
||||
} finally {
|
||||
connection.dispose()
|
||||
await pane.dispose()
|
||||
storage.close()
|
||||
database.close()
|
||||
await Effect.runPromise(Fiber.interrupt(events))
|
||||
await Effect.runPromise(unbind)
|
||||
win.destroy()
|
||||
|
||||
@@ -11,6 +11,8 @@ import { createBrowserPane } from "../../src/main/browser-pane"
|
||||
import { bindIpcEvents, ipcEventStream } from "../../src/main/ipc-events"
|
||||
import { Smoke } from "./contract"
|
||||
import { verifyTargets } from "./targets"
|
||||
import { openDatabase } from "../../src/main/storage/database"
|
||||
import { createStateStore } from "../../src/main/storage/state"
|
||||
|
||||
type Output<Name extends Browser.Method> = Schema.Schema.Type<Extract<Browser.Operation, { name: Name }>["output"]>
|
||||
|
||||
@@ -126,7 +128,10 @@ async function main() {
|
||||
const location = { directory: process.env.SMOKE_SERVER_FILES! }
|
||||
const rpc = client.rpc(Smoke)
|
||||
const session = await client.session.create({ title: "Browser suite", location })
|
||||
const pane = createBrowserPane()
|
||||
const database = openDatabase(path.join(root, "browser.sqlite"))
|
||||
const storage = createStateStore(database.db)
|
||||
const pane = createBrowserPane(storage)
|
||||
let restored: ReturnType<typeof createBrowserPane> | undefined
|
||||
const win = new BrowserWindow({ show: false, width: 1100, height: 800, webPreferences: { sandbox: true } })
|
||||
const readyToShow = once(win, "ready-to-show")
|
||||
await win.loadURL("about:blank")
|
||||
@@ -138,6 +143,7 @@ async function main() {
|
||||
)
|
||||
const ipcErrors: string[] = []
|
||||
const replaced: string[] = []
|
||||
const focusEvents: string[] = []
|
||||
const inventories = new Map<string, Browser.State | null>()
|
||||
const unbind = await Effect.runPromise(bindIpcEvents(win.webContents.id))
|
||||
const events = Effect.runFork(
|
||||
@@ -150,6 +156,7 @@ async function main() {
|
||||
inventories.set(event.bindingID, event.event.state)
|
||||
return
|
||||
}
|
||||
focusEvents.push(event.event.tabID)
|
||||
if (!inventories.get(event.bindingID)?.tabs.some((tab) => tab.id === event.event.tabID))
|
||||
ipcErrors.push("Focus arrived before its tab inventory")
|
||||
pane.layout(win, event.bindingID, {
|
||||
@@ -188,6 +195,7 @@ async function main() {
|
||||
try {
|
||||
await verifyTargets(win, fixture)
|
||||
await pane.register(win, "suite", {
|
||||
serverKey: "browser-suite",
|
||||
sessionID: session.id,
|
||||
endpoint: { url: process.env.SMOKE_URL!, password: process.env.SMOKE_PASSWORD },
|
||||
})
|
||||
@@ -547,15 +555,54 @@ async function main() {
|
||||
)
|
||||
assert.deepEqual(ipcErrors, [])
|
||||
await pane.register(win, "replacement", {
|
||||
serverKey: "browser-suite",
|
||||
sessionID: session.id,
|
||||
endpoint: { url: process.env.SMOKE_URL!, password: process.env.SMOKE_PASSWORD },
|
||||
})
|
||||
await until(async () => replaced.includes("suite"))
|
||||
await until(async () => {
|
||||
const state = await call("tabs.list", {})
|
||||
return state.tabs.length === 2 && state.tabs.every((tab) => !tab.loading && tab.url !== "about:blank")
|
||||
})
|
||||
const saved = await call("tabs.list", {})
|
||||
assert.equal(saved.tabs.length, 2)
|
||||
await call("evaluate", { tabID, script: "window.restoreOnlyInMemory = true; null" })
|
||||
await pane.dispose()
|
||||
storage.flush()
|
||||
restored = createBrowserPane(storage)
|
||||
const focusCount = focusEvents.length
|
||||
await restored.register(win, "restored", {
|
||||
serverKey: "browser-suite",
|
||||
sessionID: session.id,
|
||||
endpoint: { url: process.env.SMOKE_URL!, password: process.env.SMOKE_PASSWORD },
|
||||
})
|
||||
await until(async () => {
|
||||
const state = await call("tabs.list", {})
|
||||
return (
|
||||
state.tabs.length === saved.tabs.length && state.tabs.every((tab) => !tab.loading && tab.url !== "about:blank")
|
||||
)
|
||||
})
|
||||
const reopened = await call("tabs.list", {})
|
||||
assert.deepEqual(
|
||||
reopened.tabs.map((tab) => ({ id: tab.id, url: tab.url })),
|
||||
saved.tabs.map((tab) => ({ id: tab.id, url: tab.url })),
|
||||
)
|
||||
assert.equal(reopened.focusedTabID, saved.focusedTabID)
|
||||
await Promise.all(
|
||||
saved.tabs.map(async (tab) => {
|
||||
assert.equal((await call("evaluate", { tabID: tab.id, script: "location.href" })).value, tab.url)
|
||||
}),
|
||||
)
|
||||
assert.equal((await call("evaluate", { tabID, script: "typeof window.restoreOnlyInMemory" })).value, "undefined")
|
||||
assert.equal(focusEvents.length, focusCount, "Restoring URLs must not select Browser over the saved pane tab")
|
||||
console.log(
|
||||
`PASS ${visited.size} browser operations over physical authenticated HTTP, including file bytes in both directions`,
|
||||
)
|
||||
} finally {
|
||||
await restored?.dispose()
|
||||
await pane.dispose()
|
||||
storage.close()
|
||||
database.close()
|
||||
await Effect.runPromise(Fiber.interrupt(events))
|
||||
await Effect.runPromise(unbind)
|
||||
win.destroy()
|
||||
|
||||
Reference in New Issue
Block a user