mirror of
https://github.com/stablyai/orca.git
synced 2026-11-16 02:47:34 +00:00
* [comment audit] Align legacy failure-read counts with cached display * [comment audit] Condense shared provider lifecycle and browser recovery comments [skip ci] * [comment audit] Condense shared generation, path and preview comments [skip ci] * [comment audit] Condense host, file and Git contract rationale [skip ci] * [comment audit] Tighten Git lifecycle and provider contract comments [skip ci] * [comment audit] Clarify shared host authority and launch isolation [skip ci] * [comment audit] simplify local access mobile and native chat contracts [skip ci] * [comment audit] simplify native chat presentation and state contracts [skip ci] * [comment audit] simplify native runtime and provider contracts [skip ci] * [comment audit] simplify migration and orchestration contracts [skip ci] * [comment audit] simplify plugin trust and process capture rationale [skip ci] * [comment audit] simplify terminal delivery and remote compatibility rationale [skip ci] * [comment audit] clarify remote recovery and launch wire rationale [skip ci] * [comment audit] shorten shared RPC compatibility and runtime evidence comments [skip ci] * [comment audit] simplify secure storage shell startup and sidebar rationale [skip ci] * [comment audit] clarify sidebar, skill and SSH invariants [skip ci] * [comment audit] condense structured chat delivery and timing rationale [skip ci] * [comment audit] condense terminal replay and telemetry invariants [skip ci] * [comment audit] clarify launch permission and terminal delivery rationale [skip ci] * [comment audit] clarify workspace ownership and layout contracts [skip ci] * [comment audit] wait for fitted and painted SSH terminal links * [comment audit] clarify layout persistence and session ownership [skip ci] * [comment audit] clarify host routing and workspace lifecycle contracts [skip ci] * [comment audit] clarify startup persistence and app lifetime comments [skip ci] * [comment audit] clarify recovery and activity boundaries [skip ci] * [comment audit] condense activity and artifact invariants [skip ci] * [comment audit] condense automation authority contracts [skip ci] * [comment audit] simplify automation scheduling and history contracts [skip ci] * [comment audit] clarify browser chrome and annotation lifecycles [skip ci] * [comment audit] clarify browser routing and retained guest ownership [skip ci] * [comment audit] clarify browser recovery and document ownership comments [skip ci] * [comment audit] restore hosted runners required by native IME fixtures * [comment audit] shorten preview, palette and dashboard invariants [skip ci] * [comment audit] clarify terminal preview, dashboard and retention comments [skip ci] * [comment audit] clarify diff-note recovery and editor lifecycle comments [skip ci] * [comment audit] shorten rich-text and combined-diff ownership comments [skip ci] * [comment audit] shorten autosave, draft recovery and model ownership comments [skip ci] * [comment audit] shorten save-queue, notebook and Markdown constraints [skip ci] * [comment audit] shorten Monaco, PDF and rich Markdown safeguards [skip ci] * [comment audit] clarify rich Markdown source and selection safeguards [skip ci] * [comment audit] clarify editor loading and emulator stream lifetimes [skip ci] * [comment audit] trim emulator and feature tour narration [skip ci] * [comment audit] clarify floating workspace and GitHub cache ownership [skip ci] * [comment audit] trim provider controls and Linear filter explanations [skip ci] * [comment audit] clarify pairing and chat resume lifetimes [skip ci] * [comment audit] clarify chat delivery and transcript lifetimes [skip ci] * [comment audit] clarify session options and host-owned status [skip ci] * [comment audit] clarify draft durability and live-status precedence [skip ci] * [comment audit] Trim chat send and model ownership explanations [skip ci] * [comment audit] Shorten transcript ownership and send recovery comments [skip ci] * [comment audit] Simplify native chat composer and transcript hook comments [skip ci] * [comment audit] Shorten native chat scroll and structured session explanations [skip ci] * [comment audit] Trim workspace picker and onboarding commentary [skip ci] * [comment audit] Simplify pet rendering, review cache and quick open comments [skip ci] * [comment audit] Trim sidebar and session history explanations [skip ci] * [comment audit] Condense session resume and review checks comments [skip ci] * [comment audit] Shorten checks state and file explorer refresh comments [skip ci] * [comment audit] Trim plugin bridge and source-control action rationale [skip ci] * [comment audit] Trim source-control listing and review rationale [skip ci] * [comment audit] Shorten sidebar lifecycle and explorer safeguards [skip ci] * [comment audit] Condense Settings account and appearance rationale [skip ci] * [comment audit] Trim pairing and repository Settings explanations [skip ci] * [comment audit] Condense Settings search SSH and terminal safeguards [skip ci] * [comment audit] Shorten Settings voice and provider ownership comments [skip ci] * [comment audit] Condense Settings draft persistence and host-state rationale [skip ci] * [comment audit] Trim Settings hooks and sidebar setup rationale [skip ci] * [comment audit] Condense sidebar deletion and board-filter safeguards [skip ci] * [comment audit] Condense worktree cards, host ownership and Markdown contracts [skip ci] * [comment audit] Condense sidebar drag, folder and filtering contracts [skip ci] * [comment audit] Condense sidebar parity, sleep and host ownership contracts [skip ci] * [comment audit] Prune focus-read baseline after comment cleanup * [comment audit] Clarify sidebar visibility, board drops and agent evidence [skip ci] * [comment audit] Tighten sidebar listing, drag and reveal contracts [skip ci] * [comment audit] Clarify viewport geometry and skill update safeguards [skip ci] * [comment audit] Tighten skill inventory, usage and host status comments [skip ci] * [comment audit] Clarify usage ownership and resource kill safeguards [skip ci] * [comment audit] Tighten tab selection, rename and search contracts [skip ci] * [comment audit] Tighten tab-strip geometry and drag ownership comments [skip ci] * [comment audit] Tighten Tasks recovery, pagination and mutation comments [skip ci] * [comment audit] Tighten provider loading and terminal recovery comments [skip ci] * [comment audit] Tighten completion, cadence and PTY ownership comments [skip ci] * [comment audit] Clarify terminal restore and parked-pane boundaries [skip ci] * [comment audit] Tighten PTY startup and replay explanations [skip ci] * [comment audit] Clarify PTY identity and delivery ownership [skip ci] * [comment audit] Shorten remote reconnect and input replay rationale [skip ci] * [comment audit] Condense terminal parking clipboard and file link comments [skip ci] * [comment audit] Clarify IME ownership and trim trace history [skip ci] * [comment audit] Shorten pane recovery and parked watcher explanations [skip ci] * [comment audit] Condense snapshot replay and visibility recovery rationale [skip ci] * [comment audit] Shorten terminal parking and keyboard ownership rationale [skip ci] * [comment audit] Trim renderer lifecycle and menu rationale [skip ci] * [comment audit] Condense workspace cleanup ownership and settlement notes [skip ci] * [comment audit] Clarify renderer hook evidence and source ownership [skip ci] * [comment audit] Tighten IPC ownership and reconnect explanations [skip ci] * [comment audit] Trim renderer focus, paste and attention comments [skip ci] * [comment audit] Shorten scroll, locale and agent lifecycle comments [skip ci] * [comment audit] Trim agent launch, resume and ownership commentary [skip ci] * [comment audit] Shorten account, browser and editor comments [skip ci] * [comment audit] Clarify host-mirror waits, previews and input ownership [skip ci] * [comment audit] Condense launch recovery and editor tokenization comments [skip ci] * [comment audit] Condense workspace selection and terminal pane rationale [skip ci] * [comment audit] Condense terminal fitting and rendering recovery comments [skip ci] * [comment audit] Condense terminal input and host routing explanations [skip ci] * [comment audit] Condense ownership and sleeping-session recovery rationale [skip ci] * [comment audit] Condense structured launch and terminal link explanations [skip ci] * [comment audit] Condense terminal ownership and workspace file routing rationale [skip ci] * [comment audit] Condense session persistence and workspace activation rationale [skip ci] * [comment audit] Condense workspace routing and browser ownership rationale [skip ci] * [comment audit] Condense mirror recovery and layout authority rationale [skip ci] * [comment audit] Condense runtime transport and file safety rationale [skip ci] * [comment audit] Condense runtime graph and structured session rationale [skip ci] * [comment audit] Condense browser creation and remote tab recovery rationale [skip ci] * [comment audit] Condense snapshot authority and publisher recovery rationale [skip ci] * [comment audit] Condense frame, startup and provider cache rationale [skip ci] * [comment audit] Condense host twin and agent lifecycle rationale [skip ci] * [comment audit] Condense browser authority and editor cleanup rationale [skip ci] * [comment audit] Condense editor buffer identity and review cache rationale [skip ci] * [comment audit] Condense provider lifetime and repository ownership rationale [skip ci] * [comment audit] Condense reconnect, hydration and terminal retirement rationale [skip ci] * [comment audit] Condense recovery, reconciliation and persistence rationale [skip ci] * [comment audit] Condense cleanup ownership and listing admission rationale [skip ci] * [comment audit] Condense teardown ordering and terminal ownership rationale [skip ci] * [comment audit] Condense recovery ledger and web host-boundary rationale [skip ci] * [comment audit] Condense web reconnect and credential lifecycle rationale [skip ci] * [comment audit] Condense cloud rollout and assignment safety rationale [skip ci] * [comment audit] Condense relay session and database recovery rationale [skip ci] * [comment audit] Condense relay placement and protocol compatibility rationale [skip ci] * [comment audit] Condense build and packaging constraints [skip ci] * [comment audit] Condense CI gates and validation isolation rationale [skip ci] * [comment audit] Condense catalog identity and browser validation rationale [skip ci] * [comment audit] Condense mobile browser and frame-budget rationale [skip ci] * [comment audit] Shorten mobile route and browser test explanations [skip ci] * [comment audit] Condense editor and session seam test rationale [skip ci] * [comment audit] Trim session and terminal closure history [skip ci] * [comment audit] Shorten terminal browser and census explanations [skip ci] * [comment audit] Preserve root-only E2E diagnostic baseline * [comment audit] Condense mobile seam and HTML preview test rationale [skip ci] * [comment audit] Condense preview instrumentation and render harness rationale [skip ci] * [comment audit] Condense bundle contracts and native-build constraints [skip ci] * [comment audit] Shorten native packaging and CI routing rationale [skip ci] * [comment audit] Condense release tooling and benchmark constraints [skip ci] * [comment audit] Condense packaging and platform gate rationale [skip ci] * [comment audit] Shorten mobile route and history rationale [skip ci] * [comment audit] Condense mobile browser and component rationale [skip ci] * [comment audit] Shorten drawer and workspace-form rationale [skip ci] * [comment audit] Trim mobile review and editor-document explanations [skip ci] * [comment audit] Condense editor lifecycle and Markdown explanations [skip ci] * [comment audit] Trim mobile file, diagnostics and dictation commentary [skip ci] * [comment audit] Simplify mobile host-list and workspace-view explanations [skip ci] * [comment audit] Clarify mobile shell lifetime and bridge delivery constraints [skip ci] * [comment audit] Condense bridge stream, native request and audio rationale [skip ci] * [comment audit] Reduce bridge schema and page-client commentary [skip ci] * [comment audit] Tighten mobile page bridge contracts [skip ci] * [comment audit] Clarify mobile cache and session constraints [skip ci] * [comment audit] Condense mobile route and lifecycle rationale [skip ci] * [comment audit] Tighten mobile shell hook timing rationale [skip ci] * [comment audit] Clarify route handoff and notification compatibility [skip ci] * [comment audit] Clarify push registration and dictation cleanup constraints [skip ci] * [comment audit] Condense keyboard geometry and native media ownership rationale [skip ci] * [comment audit] Tighten mobile chat scroll and composer concurrency rationale [skip ci] * [comment audit] Condense mobile reply compatibility and upload ownership rationale [skip ci] * [comment audit] Condense optimistic echo and scroll ownership rationale [skip ci] * [comment audit] Tighten stream replay and queued session ownership rationale [skip ci] * [comment audit] Condense mobile composer and reply-schema constraints [skip ci] * [comment audit] Clarify mobile transcript recovery and session ownership [skip ci] * [comment audit] Clarify mobile queue and source-control compatibility [skip ci] * [comment audit] Condense storage and task launch constraints [skip ci] * [comment audit] Clarify task schemas and terminal document ownership [skip ci] * [comment audit] Tighten terminal input and viewport rationale [skip ci] * [comment audit] Shorten terminal and RPC recorder contracts [skip ci] * [comment audit] Condense recorder engine and connection contracts [skip ci] * [comment audit] Shorten host credential and relay recovery comments [skip ci] * [comment audit] Tighten pairing recovery and bundle transport rationale [skip ci] * [comment audit] Clarify RPC delivery and workspace catalog boundaries [skip ci] * [comment audit] Condense catalog and relay entry contracts [skip ci] * [comment audit] Shorten shutdown and SSH relay delivery contracts [skip ci] * [comment audit] Condense WSL relay and E2E regression rationale [skip ci] * [comment audit] Shorten cross-version harness and renderer fixture explanations [skip ci] * [comment audit] Condense paired-host and E2E lifecycle rationale [skip ci] * [comment audit] Shorten layout oracle and regression explanations [skip ci] * [comment audit] Condense paired recovery and ownership regression contracts [skip ci] * [comment audit] Shorten restart, sidebar and SSH lifecycle contracts [skip ci] * [comment audit] Condense terminal rendering and IME regression rationale [skip ci] * [comment audit] Shorten terminal recovery and benchmark contracts [skip ci] * [comment audit] Condense tooling and Windows lifecycle proof rationale [skip ci] * [comment audit] Condense workflow routing and release rationale [skip ci] * [comment audit] Condense mobile security and installer contracts [skip ci] * [comment audit] Shorten native rationale and stylesheet workarounds [skip ci] * [comment audit] Shorten Windows visibility probe rationale [skip ci] * [comment audit] Condense embedded release and signing rationale [skip ci] * [comment audit] Retain current main test behavior in final reconciliation [skip ci] * [comment audit] Complete final comment review across current source inventory * [comment audit] Handle consolidated audit reports before final CI * [comment audit] Preserve credential storage census detail [skip ci] * [comment audit] Scale broad changed E2E selections with verified timing shards * [comment audit] Align E2E assertions with browser close and settled session metadata * [comment audit] Match existing E2Es to current resource and windowing contracts * [comment audit] Observe the shared server outage notice in reconnect coverage * [comment audit] Make existing renderer probes measure settled tab and PTY work * [comment audit] Align palette E2E selector with task search * [comment audit] Refresh remaining palette search selectors * [comment audit] Keep selector correction within selected audit specs * [comment audit] Await emoji fixture settings inside renderer evaluation * [comment audit] Cancel fixture fit retries between terminal tests --------- Co-authored-by: OrcaWin <293788423+OrcaWin@users.noreply.github.com>
468 lines
18 KiB
JavaScript
468 lines
18 KiB
JavaScript
#!/usr/bin/env node
|
||
// Compare parking OFF→ON in one app session at many-worktree scale: JS heap, WebGL contexts and mounted managers.
|
||
// Prime each terminal’s scrollback, leave one active, then measure the delta after shortened hysteresis parks hidden views.
|
||
// Companion reveal benchmark measures the return cost.
|
||
|
||
import { mkdirSync, mkdtempSync, writeFileSync } from 'node:fs'
|
||
import os from 'node:os'
|
||
import path from 'node:path'
|
||
import process from 'node:process'
|
||
import { execFileSync } from 'node:child_process'
|
||
import { fileURLToPath } from 'node:url'
|
||
import {
|
||
collectRendererDiagnostics,
|
||
connectToApp,
|
||
installRendererProbe,
|
||
launchDevApp,
|
||
pickFreePort,
|
||
stopDevApp,
|
||
waitForStoreReady
|
||
} from '../../../config/scripts/windows-apphang-repro/electron-dev-session.mjs'
|
||
import {
|
||
createCompletedOnboardingProfile,
|
||
safeRemoveLocalDirectory
|
||
} from '../../../config/scripts/windows-apphang-repro/wsl-workspace-fixture.mjs'
|
||
import {
|
||
pollUntil,
|
||
rendererActionTimeoutMs,
|
||
runWithTimeout,
|
||
setupTimeoutMs
|
||
} from '../../../config/scripts/windows-apphang-repro/repro-timing.mjs'
|
||
|
||
const rootDir = path.resolve(fileURLToPath(new URL('../../..', import.meta.url)))
|
||
const PARK_DELAY_MS = 1_500
|
||
const SETTLE_AFTER_PARK_MS = 4_000
|
||
// Keep root short for macOS’s ~104-char Unix socket limit; longer temp paths break daemon startup and snapshot-backed parking.
|
||
const shortRoot = path.join(os.homedir(), '.ocpr')
|
||
|
||
function parseArgs() {
|
||
const args = {
|
||
label: 'run',
|
||
worktrees: 8,
|
||
scrollbackLines: 5000,
|
||
reportPath: null,
|
||
keep: false
|
||
}
|
||
for (const arg of process.argv.slice(2)) {
|
||
if (arg === '--help' || arg === '-h') {
|
||
console.log(
|
||
'Usage: node tests/tools/benchmarks/terminal-cold-park-resource-bench.mjs [--label=name] [--worktrees=N] [--scrollback-lines=N] [--report=path] [--keep]'
|
||
)
|
||
process.exit(0)
|
||
}
|
||
if (arg === '--keep') {
|
||
args.keep = true
|
||
continue
|
||
}
|
||
const [name, value] = arg.split('=', 2)
|
||
if (name === '--label') {
|
||
args.label = value?.trim() || 'run'
|
||
} else if (name === '--worktrees') {
|
||
args.worktrees = Math.max(2, Number(value) || 8)
|
||
} else if (name === '--scrollback-lines') {
|
||
args.scrollbackLines = Math.max(0, Number(value) || 0)
|
||
} else if (name === '--report') {
|
||
args.reportPath = value
|
||
}
|
||
}
|
||
return args
|
||
}
|
||
|
||
function git(cwd, ...cmd) {
|
||
execFileSync('git', cmd, { cwd, stdio: 'pipe' })
|
||
}
|
||
|
||
function createShortUserDataDirectory() {
|
||
mkdirSync(shortRoot, { recursive: true })
|
||
const userDataDir = mkdtempSync(path.join(shortRoot, 'ud-'))
|
||
createCompletedOnboardingProfile(userDataDir)
|
||
return userDataDir
|
||
}
|
||
|
||
function createLocalRepoFixture(worktreeCount) {
|
||
mkdirSync(shortRoot, { recursive: true })
|
||
const baseDir = mkdtempSync(path.join(shortRoot, 'fx-'))
|
||
const repoPath = path.join(baseDir, 'repo')
|
||
mkdirSync(repoPath, { recursive: true })
|
||
git(repoPath, 'init', '--initial-branch=main')
|
||
git(repoPath, 'config', 'user.email', 'bench@orca.local')
|
||
git(repoPath, 'config', 'user.name', 'Orca Bench')
|
||
writeFileSync(path.join(repoPath, 'README.md'), '# cold-park resource fixture\n')
|
||
git(repoPath, 'add', '.')
|
||
git(repoPath, 'commit', '-m', 'init', '--no-gpg-sign')
|
||
const worktreePaths = []
|
||
for (let i = 0; i < worktreeCount; i++) {
|
||
const worktreePath = path.join(baseDir, `wt-${i}`)
|
||
git(repoPath, 'worktree', 'add', worktreePath, '-b', `wt-${i}`)
|
||
worktreePaths.push(worktreePath)
|
||
}
|
||
return { baseDir, repoPath, worktreePaths }
|
||
}
|
||
|
||
async function setupWorkspaces(page, fixture) {
|
||
return await runWithTimeout(
|
||
'fixture registration in Orca',
|
||
() =>
|
||
page.evaluate(
|
||
async ({ repoPath, importedWorktreePaths }) => {
|
||
const store = window.__store
|
||
if (!store) {
|
||
throw new Error('window.__store is unavailable.')
|
||
}
|
||
await store.getState().fetchSettings?.()
|
||
const addResult = await window.api.repos.add({ path: repoPath, kind: 'git' })
|
||
if ('error' in addResult) {
|
||
throw new Error(addResult.error)
|
||
}
|
||
const owner = store.getState().settings?.activeRuntimeEnvironmentId ?? null
|
||
await store.getState().fetchRepos({ runtimeEnvironmentId: owner })
|
||
const state = store.getState()
|
||
const repo = state.repos.find((c) => c.path === repoPath) ?? addResult.repo
|
||
await state.updateRepo(repo.id, {
|
||
externalWorktreeVisibility: 'show',
|
||
externalWorktreeVisibilityPromptDismissedAt: Date.now(),
|
||
importedExternalWorktreePaths: importedWorktreePaths,
|
||
externalWorktreeInboxBaselinePaths: importedWorktreePaths
|
||
})
|
||
await store.getState().fetchWorktrees(repo.id, { requireAuthoritative: true })
|
||
const nextState = store.getState()
|
||
nextState.setSidebarOpen(true)
|
||
nextState.setGroupBy('none')
|
||
nextState.setSortBy('recent')
|
||
nextState.setShowActiveOnly(false)
|
||
nextState.setActiveView('terminal')
|
||
return { repoId: repo.id }
|
||
},
|
||
{ repoPath: fixture.repoPath, importedWorktreePaths: fixture.worktreePaths }
|
||
),
|
||
setupTimeoutMs
|
||
)
|
||
}
|
||
|
||
async function listWorktrees(page, repoId) {
|
||
return page.evaluate(async (id) => {
|
||
await window.__store
|
||
?.getState?.()
|
||
?.fetchWorktrees?.(id, { requireAuthoritative: true })
|
||
.catch(() => undefined)
|
||
const state = window.__store?.getState?.()
|
||
const list = state?.worktreesByRepo?.[id] ?? []
|
||
return list.map((w) => ({
|
||
id: w.id,
|
||
path: w.path,
|
||
isMainWorktree: w.isMainWorktree
|
||
}))
|
||
}, repoId)
|
||
}
|
||
|
||
async function clickWorktreeCard(page, worktreeId) {
|
||
const rect = await runWithTimeout(
|
||
`locate worktree card ${worktreeId}`,
|
||
() =>
|
||
page.evaluate((id) => {
|
||
const rows = Array.from(document.querySelectorAll('[data-worktree-id]'))
|
||
const row = rows.find((c) => c.getAttribute('data-worktree-id') === id)
|
||
if (!row) {
|
||
return null
|
||
}
|
||
row.scrollIntoView({ block: 'center', inline: 'nearest' })
|
||
const surface = row.querySelector('[data-worktree-card-surface="true"]') ?? row
|
||
const bounds = surface.getBoundingClientRect()
|
||
if (bounds.width <= 0 || bounds.height <= 0) {
|
||
return null
|
||
}
|
||
return { x: bounds.left + bounds.width / 2, y: bounds.top + bounds.height / 2 }
|
||
}, worktreeId),
|
||
rendererActionTimeoutMs
|
||
)
|
||
if (!rect) {
|
||
throw new Error(`Could not find rendered worktree card for ${worktreeId}`)
|
||
}
|
||
await runWithTimeout(
|
||
`click worktree card ${worktreeId}`,
|
||
() => page.mouse.click(rect.x, rect.y),
|
||
rendererActionTimeoutMs
|
||
)
|
||
}
|
||
|
||
async function activateWorktreeTerminal(page, worktreeId) {
|
||
await clickWorktreeCard(page, worktreeId)
|
||
await pollUntil(
|
||
`active worktree ${worktreeId}`,
|
||
() =>
|
||
page.evaluate((id) => {
|
||
const state = window.__store?.getState?.()
|
||
return state?.activeWorktreeId === id && state.activeTabType === 'terminal'
|
||
}, worktreeId),
|
||
Boolean,
|
||
30_000
|
||
)
|
||
}
|
||
|
||
async function waitForBoundTerminal(page, worktreeId) {
|
||
return await pollUntil(
|
||
`pty bound ${worktreeId}`,
|
||
() =>
|
||
page.evaluate((id) => {
|
||
const state = window.__store?.getState?.()
|
||
const tabId =
|
||
state?.activeWorktreeId === id && state.activeTabType === 'terminal'
|
||
? state.activeTabId
|
||
: (state?.activeTabIdByWorktree?.[id] ?? null)
|
||
const manager = tabId ? window.__paneManagers?.get(tabId) : null
|
||
const pane = manager?.getActivePane?.() ?? manager?.getPanes?.()?.[0] ?? null
|
||
return pane?.container?.dataset?.ptyId ?? null
|
||
}, worktreeId),
|
||
Boolean,
|
||
30_000,
|
||
10
|
||
)
|
||
}
|
||
|
||
async function primeScrollback(page, worktreeId, lineCount) {
|
||
if (lineCount <= 0) {
|
||
return 0
|
||
}
|
||
const ptyId = await page.evaluate((id) => {
|
||
const state = window.__store?.getState?.()
|
||
const tabId =
|
||
state?.activeWorktreeId === id && state.activeTabType === 'terminal'
|
||
? state.activeTabId
|
||
: (state?.activeTabIdByWorktree?.[id] ?? null)
|
||
const manager = tabId ? window.__paneManagers?.get(tabId) : null
|
||
const pane = manager?.getActivePane?.() ?? manager?.getPanes?.()?.[0] ?? null
|
||
return pane?.container?.dataset?.ptyId ?? null
|
||
}, worktreeId)
|
||
if (!ptyId) {
|
||
return 0
|
||
}
|
||
const cmd = `awk 'BEGIN{for(i=0;i<${lineCount};i++)printf "%04d %s\\n", i, "cold-park-resource-scrollback-priming-line-padding-to-eighty-cols"}'\n`
|
||
await page.evaluate(({ id, c }) => window.api.pty.write(id, c), { id: ptyId, c: cmd })
|
||
return await pollUntil(
|
||
`scrollback primed ${worktreeId}`,
|
||
() =>
|
||
page.evaluate((id) => {
|
||
const state = window.__store?.getState?.()
|
||
const tabId =
|
||
state?.activeWorktreeId === id && state.activeTabType === 'terminal'
|
||
? state.activeTabId
|
||
: (state?.activeTabIdByWorktree?.[id] ?? null)
|
||
const manager = tabId ? window.__paneManagers?.get(tabId) : null
|
||
const pane = manager?.getActivePane?.() ?? manager?.getPanes?.()?.[0] ?? null
|
||
return (pane?.serializeAddon?.serialize?.() ?? '').length
|
||
}, worktreeId),
|
||
(len) => Number.isFinite(len) && len > lineCount * 30,
|
||
20_000,
|
||
100
|
||
).catch(() => 0)
|
||
}
|
||
|
||
const sleep = (ms) => new Promise((r) => setTimeout(r, ms))
|
||
|
||
async function setParkingEnabled(page, enabled) {
|
||
await page.evaluate(async (value) => {
|
||
const store = window.__store
|
||
await store.getState().updateSettings?.({ terminalHiddenViewParking: value })
|
||
}, enabled)
|
||
}
|
||
|
||
const toMB = (bytes) => (bytes == null ? null : Math.round((bytes / 1048576) * 10) / 10)
|
||
|
||
// Force repeated GC for lazily reclaimed xterm typed arrays, then read app process memory, renderer heap and pane/WebGL counts.
|
||
async function measureResources(page, cdp) {
|
||
// Repeat GC with settling gaps so delayed collection cannot hide released typed-array storage.
|
||
for (let i = 0; i < 4; i++) {
|
||
await cdp.send('HeapProfiler.collectGarbage').catch(() => undefined)
|
||
await sleep(400)
|
||
}
|
||
const metrics = await cdp.send('Performance.getMetrics').catch(() => ({ metrics: [] }))
|
||
const metricMap = Object.fromEntries((metrics.metrics ?? []).map((m) => [m.name, m.value]))
|
||
const renderer = await page.evaluate(async () => {
|
||
const managers = window.__paneManagers
|
||
let attachedWebgl = 0
|
||
let paneCount = 0
|
||
for (const [, manager] of managers?.entries?.() ?? []) {
|
||
const diags = manager?.getRenderingDiagnostics?.() ?? []
|
||
paneCount += diags.length
|
||
for (const d of diags) {
|
||
if (d.hasWebgl) {
|
||
attachedWebgl += 1
|
||
}
|
||
}
|
||
}
|
||
const mem = performance?.memory ?? null
|
||
// Use getAppMetrics process memory to include main’s daemon-snapshot cost, absent from renderer heap.
|
||
const snapshot = await window.api?.memory?.getSnapshot?.().catch(() => null)
|
||
return {
|
||
paneManagerCount: managers?.size ?? 0,
|
||
terminalPaneCount: paneCount,
|
||
attachedWebglContexts: attachedWebgl,
|
||
rendererJsHeapUsedMB: mem ? Math.round((mem.usedJSHeapSize / 1048576) * 10) / 10 : null,
|
||
appMemory: snapshot?.app
|
||
? {
|
||
totalMB: Math.round(((snapshot.app.memory ?? 0) / 1048576) * 10) / 10,
|
||
mainMB: Math.round(((snapshot.app.main?.memory ?? 0) / 1048576) * 10) / 10,
|
||
rendererMB: Math.round(((snapshot.app.renderer?.memory ?? 0) / 1048576) * 10) / 10,
|
||
otherMB: Math.round(((snapshot.app.other?.memory ?? 0) / 1048576) * 10) / 10
|
||
}
|
||
: null
|
||
}
|
||
})
|
||
return {
|
||
...renderer,
|
||
cdpJsHeapUsedMB: toMB(metricMap.JSHeapUsedSize),
|
||
cdpNodes: metricMap.Nodes ?? null,
|
||
cdpLayoutCount: metricMap.LayoutCount ?? null
|
||
}
|
||
}
|
||
|
||
async function main() {
|
||
const args = parseArgs()
|
||
const startedAt = Date.now()
|
||
const report = {
|
||
label: args.label,
|
||
startedAt: new Date(startedAt).toISOString(),
|
||
platform: `${process.platform} ${os.release()}`,
|
||
parkDelayMs: PARK_DELAY_MS,
|
||
args: { worktrees: args.worktrees, scrollbackLines: args.scrollbackLines },
|
||
states: {},
|
||
cleanupErrors: []
|
||
}
|
||
let fixture = null
|
||
let userDataDir = null
|
||
let launched = null
|
||
let browser = null
|
||
let page = null
|
||
try {
|
||
fixture = createLocalRepoFixture(args.worktrees)
|
||
const cdpPort = await pickFreePort()
|
||
userDataDir = createShortUserDataDirectory()
|
||
process.env.ORCA_E2E_TERMINAL_PARKING_DELAY_MS = String(PARK_DELAY_MS)
|
||
console.log(
|
||
`[cold-park-res] fixture=${fixture.baseDir} userData=${userDataDir} cdp=${cdpPort} worktrees=${args.worktrees}`
|
||
)
|
||
launched = launchDevApp({ cdpPort, userDataDir })
|
||
const connected = await connectToApp(cdpPort)
|
||
browser = connected.browser
|
||
page = connected.page
|
||
const cdp = await page.context().newCDPSession(page)
|
||
await cdp.send('Performance.enable').catch(() => undefined)
|
||
await cdp.send('HeapProfiler.enable').catch(() => undefined)
|
||
await waitForStoreReady(page)
|
||
await installRendererProbe(page)
|
||
const setup = await setupWorkspaces(page, fixture)
|
||
const worktrees = await pollUntil(
|
||
'worktrees registered',
|
||
() => listWorktrees(page, setup.repoId),
|
||
(list) => Array.isArray(list) && list.length >= args.worktrees,
|
||
45_000,
|
||
500
|
||
)
|
||
console.log(`[cold-park-res] ${worktrees.length} worktrees registered`)
|
||
const primary = worktrees.find((w) => w.isMainWorktree) ?? worktrees[0]
|
||
const anotherWorktree = worktrees.find((w) => w.id !== primary.id)
|
||
|
||
// Keep parking off while mounting/filling every terminal for baseline.
|
||
await setParkingEnabled(page, false)
|
||
for (const wt of worktrees) {
|
||
await activateWorktreeTerminal(page, wt.id)
|
||
await waitForBoundTerminal(page, wt.id)
|
||
await primeScrollback(page, wt.id, args.scrollbackLines)
|
||
}
|
||
// Activate primary while all other views remain mounted under disabled parking.
|
||
await activateWorktreeTerminal(page, primary.id)
|
||
await sleep(SETTLE_AFTER_PARK_MS)
|
||
report.states.parkingOff = await measureResources(page, cdp)
|
||
console.log(`[cold-park-res] parkingOff: ${JSON.stringify(report.states.parkingOff)}`)
|
||
|
||
// Enable parking and toggle focus to reevaluate shortened hysteresis.
|
||
await setParkingEnabled(page, true)
|
||
await sleep(PARK_DELAY_MS + 500)
|
||
// Re-focus primary to trigger the park policy effect re-run for the others.
|
||
await activateWorktreeTerminal(page, anotherWorktree.id)
|
||
await activateWorktreeTerminal(page, primary.id)
|
||
await sleep(SETTLE_AFTER_PARK_MS)
|
||
report.states.parkingOn = await measureResources(page, cdp)
|
||
console.log(`[cold-park-res] parkingOn: ${JSON.stringify(report.states.parkingOn)}`)
|
||
|
||
const off = report.states.parkingOff
|
||
const on = report.states.parkingOn
|
||
const subMB = (a, b) => (a != null && b != null ? Math.round((a - b) * 10) / 10 : null)
|
||
report.delta = {
|
||
paneManagersReleased: off.paneManagerCount - on.paneManagerCount,
|
||
webglContextsReleased: off.attachedWebglContexts - on.attachedWebglContexts,
|
||
cdpJsHeapSavedMB: subMB(off.cdpJsHeapUsedMB, on.cdpJsHeapUsedMB),
|
||
rendererJsHeapSavedMB: subMB(off.rendererJsHeapUsedMB, on.rendererJsHeapUsedMB),
|
||
appTotalSavedMB: subMB(off.appMemory?.totalMB, on.appMemory?.totalMB),
|
||
appRendererSavedMB: subMB(off.appMemory?.rendererMB, on.appMemory?.rendererMB),
|
||
appMainSavedMB: subMB(off.appMemory?.mainMB, on.appMemory?.mainMB),
|
||
domNodesReleased:
|
||
off.cdpNodes != null && on.cdpNodes != null ? off.cdpNodes - on.cdpNodes : null
|
||
}
|
||
report.finalDiagnostics = await collectRendererDiagnostics(page)
|
||
} finally {
|
||
report.elapsedMs = Date.now() - startedAt
|
||
if (browser) {
|
||
await browser.close().catch(() => undefined)
|
||
}
|
||
if (launched) {
|
||
try {
|
||
await stopDevApp(launched.child)
|
||
// stopDevApp kills only top-level Vite on macOS/Linux; reap surviving Electron descendants so repeated benches cannot saturate the machine.
|
||
if (launched.child?.pid && process.platform !== 'win32') {
|
||
try {
|
||
execFileSync('pkill', ['-9', '-P', String(launched.child.pid)], { stdio: 'ignore' })
|
||
} catch {
|
||
/* no descendants left — fine */
|
||
}
|
||
}
|
||
} catch (error) {
|
||
report.cleanupErrors.push(error instanceof Error ? error.message : String(error))
|
||
}
|
||
report.appLogsTail = launched.logs.slice(-40)
|
||
}
|
||
if (!args.keep) {
|
||
if (fixture) {
|
||
safeRemoveLocalDirectory(fixture.baseDir, report.cleanupErrors)
|
||
}
|
||
if (userDataDir) {
|
||
safeRemoveLocalDirectory(userDataDir, report.cleanupErrors)
|
||
}
|
||
}
|
||
const stamp = new Date(startedAt).toISOString().replace(/[:.]/g, '-')
|
||
const reportPath = path.resolve(
|
||
args.reportPath ??
|
||
path.join(
|
||
rootDir,
|
||
'tests',
|
||
'tools',
|
||
'benchmarks',
|
||
'results',
|
||
`cold-park-res-${args.label}-${stamp}.json`
|
||
)
|
||
)
|
||
mkdirSync(path.dirname(reportPath), { recursive: true })
|
||
writeFileSync(reportPath, `${JSON.stringify(report, null, 2)}\n`)
|
||
console.log(`[cold-park-res] report=${reportPath}`)
|
||
if (report.delta) {
|
||
const d = report.delta
|
||
console.log(
|
||
`[cold-park-res] DELTA (off−on): paneManagers=${d.paneManagersReleased} webglContexts=${d.webglContextsReleased} domNodes=${d.domNodesReleased}`
|
||
)
|
||
console.log(
|
||
`[cold-park-res] memory saved: appTotal=${d.appTotalSavedMB}MB (renderer=${d.appRendererSavedMB}MB main=${d.appMainSavedMB}MB) rendererJsHeap=${d.rendererJsHeapSavedMB}MB cdpJsHeap=${d.cdpJsHeapSavedMB}MB`
|
||
)
|
||
if (report.states.parkingOff?.appMemory && report.states.parkingOn?.appMemory) {
|
||
console.log(
|
||
`[cold-park-res] appTotal off=${report.states.parkingOff.appMemory.totalMB}MB on=${report.states.parkingOn.appMemory.totalMB}MB`
|
||
)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
main().catch((error) => {
|
||
console.error(error instanceof Error ? error.stack || error.message : String(error))
|
||
process.exit(1)
|
||
})
|