sourcemonkey 0.0.0-stage → 0.5.0

package/lib/harness/extension-launch.js

@@ -0,0 +1,285 @@
+// A throwaway Chromium with the package's built SourceMonkey (dist/)
+// loaded: sm-dev's temp browser, the `sourcemonkey/harness`
+// fixture's, and the repo's own e2e suites'. With `--manager`, a
+// fetched Tampermonkey or Violentmonkey instead (manager-fetch.ts).
+//
+// - Playwright's Chromium, since Google Chrome (137+) ignores
+//   `--load-extension`. Hidden runs use Chrome's new headless mode
+//   (`--headless=new`), the only headless mode that loads extensions,
+//   with a windowed Chrome's user agent (see `windowedUserAgent`).
+// - A fresh profile in a temp directory, deleted when the browser is
+//   closed. Its Preferences grant "Allow User Scripts" before launch,
+//   which Chrome otherwise leaves to a click (chrome.userScripts is
+//   undefined without it), and pin the extension to the toolbar.
+// - Launched as a persistent context (a profile directory needs one),
+//   which has no Playwright `Browser`. A caller that needs one (sm-dev's
+//   run, the fixture's `browser`) connects over CDP to the launched
+//   browser's port; the e2e suites use the context as it is.
+import { execFile } from 'node:child_process';
+import { existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import net from 'node:net';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { leaveDialogsOpen } from './console-commands.js';
+import { ExtensionMissingError, extensionIdFromKey, findExtensionWorker, sourceMonkeyExtensionId } from './extension-backend.js';
+import { fetchedDir } from './manager-fetch.js';
+import { MANAGERS, managerFlag } from './managers.js';
+import { loadPlaywright, missingChromium } from './playwright-chromium.js';
+import { rebuildAdvice } from './rebuild-advice.js';
+import { quoted } from './output-style.js';
+// dist/, beside lib/: in the checkout, and in an installed package,
+// which ships both.
+export const EXTENSION_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..', 'dist');
+/**
+ * Launches Chromium with SourceMonkey loaded, or `options.manager`.
+ * Throws an error saying why when it can't. It has one blank tab,
+ * opened after the warm-up (see `warmUp`), for a run's first tab.
+ */
+export async function launchExtensionBrowser(options = {}) {
+    const manager = options.manager ?? 'sourcemonkey';
+    const dir = manager === 'sourcemonkey' ? EXTENSION_DIR : fetchedDir(manager);
+    if (!existsSync(path.join(dir, 'manifest.json'))) {
+        throw new Error(manager === 'sourcemonkey' ? `The built extension is missing from ${EXTENSION_DIR}. ${rebuildAdvice()}`
+            : `${MANAGERS[manager].label} isn't fetched. Fetch it with ${quoted(`sm-dev ${managerFlag(manager)} manager fetch`)}`);
+    }
+    const headed = options.headed === true;
+    const profile = mkdtempSync(path.join(os.tmpdir(), 'sm-dev-extension-'));
+    let context;
+    const close = async () => {
+        await context?.close().catch(() => undefined);
+        try {
+            rmSync(profile, { recursive: true, force: true });
+        }
+        catch { /* Chrome may hold a file briefly */ }
+    };
+    try {
+        if (manager === 'sourcemonkey')
+            await prepareProfile(profile, options.downloadsDir);
+        else
+            writePreferences(profile, fetchedId(dir, manager), options.downloadsDir);
+        // Port 0 has Chrome pick a free port and write it to the profile.
+        // A port picked here could be taken before Chrome binds it, and the
+        // run would connect to whatever took it. A port given is checked
+        // first, since Chrome starts without its port when it's taken.
+        if (options.port !== undefined && !await portFree(options.port)) {
+            throw new Error(`Port ${options.port} is already in use. Use ${quoted('--existing-browser')} to connect to a browser there, or pick another port.`);
+        }
+        context = await launch(profile, headed, [`--remote-debugging-port=${options.port ?? 0}`, ...(options.muted === false ? [] : ['--mute-audio']), ...(options.args ?? [])], dir, options.backForwardCache === true);
+        // Chrome writes the port it picked; one given, it doesn't.
+        const port = options.port ?? readFileSync(path.join(profile, 'DevToolsActivePort'), 'utf8').split('\n')[0].trim();
+        if (options.connectedElsewhere)
+            leaveDialogsOpen(context);
+        if (options.downloadsDir)
+            await chromeDownloads(context);
+        if (manager === 'sourcemonkey')
+            await warmUp(context);
+        else if (manager === 'tampermonkey')
+            await quietTampermonkey(context, fetchedId(dir, manager));
+        // The launch's first tab predates the warm-up, so scripts fail in
+        // it. A new one replaces it (opened first: a headed browser with
+        // no tab left would quit).
+        const stale = context.pages();
+        await context.newPage();
+        for (const page of stale)
+            await page.close();
+        return { endpoint: `http://127.0.0.1:${port}`, context, profile, close };
+    }
+    catch (err) {
+        await close();
+        if (err instanceof ExtensionMissingError)
+            throw new Error(`Chromium did not load the extension from ${EXTENSION_DIR}`);
+        throw err;
+    }
+}
+// Whether nothing listens on `port` on this machine.
+function portFree(port) {
+    return new Promise((resolve) => {
+        const server = net.createServer();
+        server.once('error', () => resolve(false));
+        server.listen(port, '127.0.0.1', () => server.close(() => resolve(true)));
+    });
+}
+// The user agent a windowed Chrome of this version sends, in Chrome's
+// reduced form (`Chrome/153.0.0.0`). A hidden one says HeadlessChrome,
+// which some servers refuse, and the extension fetches a script's
+// `@require`s and `GM_xmlhttpRequest`s with it. Only the user agent
+// string changes: the client hints (`Sec-CH-UA`,
+// `navigator.userAgentData`) still name HeadlessChrome. Null when the
+// version can't be read; the browser's own is kept then.
+async function windowedUserAgent(executable) {
+    const version = process.platform === 'win32'
+        // There `chrome.exe --version` opens a window instead of printing;
+        // the version is the name of a folder beside it.
+        ? readdirSync(path.dirname(executable)).find((name) => /^\d+\.\d+\.\d+\.\d+$/.test(name)) ?? ''
+        : await new Promise((resolve) => {
+            execFile(executable, ['--version'], { timeout: 5000 }, (err, stdout) => resolve(err ? '' : stdout));
+        });
+    const major = /(\d+)\.\d+\.\d+\.\d+/.exec(version)?.[1];
+    if (!major)
+        return null;
+    const platform = process.platform === 'darwin' ? 'Macintosh; Intel Mac OS X 10_15_7'
+        : process.platform === 'win32' ? 'Windows NT 10.0; Win64; x64'
+            : 'X11; Linux x86_64';
+    return `Mozilla/5.0 (${platform}) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${major}.0.0.0 Safari/537.36`;
+}
+/**
+ * Turns off Tampermonkey's "installed" page, which it opens in a new
+ * tab a second or so after each start of a copy loaded with
+ * `--load-extension` (Chrome installs it anew each time): its
+ * `notification_showUpdate` setting, set before it gets that far.
+ */
+async function quietTampermonkey(context, id) {
+    const ours = (w) => w.url().startsWith(`chrome-extension://${id}/`);
+    const worker = context.serviceWorkers().find(ours) ?? await context.waitForEvent('serviceworker', { predicate: ours, timeout: 10_000 });
+    await worker.evaluate(async () => {
+        const key = '!extdb.#config';
+        const config = (await chrome.storage.local.get(key))[key] ?? { origin: 'normal', value: {} };
+        config.value.notification_showUpdate = 'off';
+        await chrome.storage.local.set({ [key]: config });
+    });
+}
+// The id of a fetched manager, from the key its manifest was given.
+function fetchedId(dir, manager) {
+    const { key } = JSON.parse(readFileSync(path.join(dir, 'manifest.json'), 'utf8'));
+    if (typeof key !== 'string')
+        throw new Error(`The extension in ${dir} has no key in its manifest. Fetch it again with ${quoted(`sm-dev --manager ${MANAGERS[manager].short} manager fetch`)}`);
+    return extensionIdFromKey(key);
+}
+async function launch(profile, headed, args = [], dir = EXTENSION_DIR, backForwardCache = false) {
+    const { chromium, install } = await loadPlaywright();
+    // Playwright's own message names only the missing path.
+    const missing = missingChromium(chromium.executablePath(), install);
+    if (missing)
+        throw new Error(missing);
+    const userAgent = headed ? null : await windowedUserAgent(chromium.executablePath()).catch(() => null);
+    try {
+        return await chromium.launchPersistentContext(profile, {
+            // `headless: false` keeps Playwright from adding its own headless
+            // flag (the old mode, which doesn't load extensions); a hidden
+            // browser gets `--headless=new` instead.
+            headless: false,
+            // The run closes it as it stops, on the signals it handles itself.
+            // Playwright's own handlers would close it first, and the run would
+            // report the browser gone. It still closes it if sm-dev exits.
+            handleSIGINT: false,
+            handleSIGTERM: false,
+            handleSIGHUP: false,
+            // A visible browser gets no emulated viewport, so its windows are
+            // sized as in a browser a person runs. Playwright's default (a
+            // fixed 1280x720) resizes every window it sees in a visible browser
+            // to fit, popups such as SourceMonkey's connection prompt included.
+            // A hidden one keeps the default: nobody sees its windows, and its
+            // pages keep the size they always had.
+            ...(headed ? { viewport: null } : {}),
+            ...(backForwardCache ? { ignoreDefaultArgs: ['--disable-back-forward-cache'] } : {}),
+            args: [
+                ...(headed ? [] : ['--headless=new']),
+                ...(userAgent ? [`--user-agent=${userAgent}`] : []),
+                ...extensionArgs(dir),
+                ...args,
+            ],
+        });
+    }
+    catch (err) {
+        // Playwright's message starts with the call's name, and may go on
+        // for lines (a boxed install hint); the first line says what failed.
+        const first = err.message.split('\n')[0].replace(/^browserType\.\w+: /, '');
+        throw new Error(`Chromium could not start: ${first}`);
+    }
+}
+/**
+ * Installs a script and removes it again, before the run opens its tab.
+ *
+ * - In a fresh profile, a tab opened before the extension's first script
+ *   install can't message the extension, even after a reload: a script
+ *   that runs there reports that it couldn't read its stored GM values.
+ *   Only a tab in a new renderer process (another site) recovers.
+ * - The run pushes its scripts after its tab is open, so it needs a tab
+ *   opened after this. See TODO.md.
+ */
+export async function warmUp(context) {
+    const worker = await findExtensionWorker(context);
+    await worker.evaluate(async (text) => {
+        const api = self.SourceMonkey;
+        const run = 'sm-dev-warm-up';
+        await api.writeRunScript({ run, text });
+        await api.releaseRun(run);
+    }, '// ==UserScript==\n// @name sm-dev warm-up\n// @match https://sm-dev.invalid/*\n// ==/UserScript==\n');
+}
+/**
+ * Readies a new profile for SourceMonkey (Preferences, first run done),
+ * for a browser started with `extensionArgs`. Also for a test's own
+ * browser, launched outside Playwright.
+ */
+export async function prepareProfile(profile, downloadsDir) {
+    writePreferences(profile, await sourceMonkeyExtensionId(), downloadsDir);
+    await primeFirstRun(profile);
+}
+/** The Chrome flags that load the package's SourceMonkey (or the extension in `dir`), and only it. */
+export function extensionArgs(dir = EXTENSION_DIR) {
+    return [`--disable-extensions-except=${dir}`, `--load-extension=${dir}`];
+}
+// Grants the extension "Allow User Scripts" and pins it to the toolbar,
+// with the keys Chrome writes when those are clicked. With
+// `downloadsDir`, also the keys Chrome writes when the download
+// location is changed in its settings: `directory_upgrade` marks it
+// user-chosen, so Chrome doesn't fall back to its platform default.
+function writePreferences(profile, extensionId, downloadsDir) {
+    const dir = path.join(profile, 'Default');
+    mkdirSync(dir, { recursive: true });
+    const prefs = {
+        extensions: { settings: { [extensionId]: { user_scripts_enabled: true } }, pinned_extensions: [extensionId] },
+        ...(downloadsDir ? { download: { default_directory: downloadsDir, directory_upgrade: true, prompt_for_download: false } } : {}),
+    };
+    writeFileSync(path.join(dir, 'Preferences'), JSON.stringify(prefs));
+}
+// Hands downloads back to Chrome. Playwright has told it to save every
+// download under a GUID name in its own temp dir (CDP
+// `Browser.setDownloadBehavior: allowAndName`), with no option to opt
+// out. `default` undoes that, so the Preferences above apply.
+async function chromeDownloads(context) {
+    const page = await context.newPage();
+    try {
+        const cdp = await context.newCDPSession(page);
+        await cdp.send('Browser.setDownloadBehavior', { behavior: 'default' });
+        await cdp.detach();
+    }
+    finally {
+        await page.close();
+    }
+}
+/**
+ * Marks the extension's first run done, in a launch of its own before
+ * the run's.
+ *
+ * - On a first run, the extension opens its collections page, which adds
+ *   the default collections from GitHub. Their scripts would then run
+ *   alongside the one being tried.
+ * - That starts while the browser is still starting, so the flag can't
+ *   be set in time in the run's own launch. Set here, it's in storage
+ *   for the next launch, whose first-run check then does nothing.
+ * - This launch may still have started the page's adds, so it closes the
+ *   page and removes what they added.
+ */
+async function primeFirstRun(profile) {
+    const context = await launch(profile, false);
+    try {
+        const worker = await findExtensionWorker(context);
+        // Key mirrors FIRST_RUN_DONE_KEY in src/extension/script-store.ts.
+        await worker.evaluate(() => chrome.storage.local.set({ firstRunComplete: true }));
+        for (const page of context.pages()) {
+            if (page.url().includes('/collections.html'))
+                await page.close().catch(() => undefined);
+        }
+        await worker.evaluate(async () => {
+            const sm = self.SourceMonkey;
+            for (const c of await sm.getCollections())
+                await sm.removeCollection(c.id);
+        });
+    }
+    finally {
+        // A clean close is what writes the storage to disk.
+        await context.close();
+    }
+}

package/lib/harness/extension-link.d.ts

@@ -0,0 +1,315 @@
+import type { BrowserContext, Page } from '@playwright/test';
+import { type ProtocolVersion } from '../sm-dev-protocol.js';
+import type { StackLayout } from '../composed-source.js';
+import type { PushedFile } from '../external-files.js';
+import { type LogEntry, type PushResult } from './extension-backend.js';
+import type { ManagerControl } from './manager-commands.js';
+import type { ExtensionFrame } from './frames.js';
+/**
+ * How the extension's protocol version compares with sm-dev's
+ * (`SM_DEV_PROTOCOL`): an error for a major that differs, a note for a
+ * minor that does, or null when they match.
+ */
+export declare function compareProtocol(extension: ProtocolVersion | undefined, ours?: ProtocolVersion): {
+    error?: string;
+    note?: string;
+} | null;
+/** An event from the extension, as sm-dev-link.ts and background.ts send them. */
+export type ExtensionEvent = {
+    kind: 'report';
+    type: string;
+    tabId: number;
+    documentId: string;
+    topFrame?: boolean;
+    scriptId: string;
+    name: string;
+    url: string;
+    message?: string;
+    stack?: string;
+    reason?: string;
+    detail?: string;
+    at: number;
+} | {
+    kind: 'log';
+    scriptId: string;
+    entry: LogEntry;
+    fromReport?: boolean;
+    at: number;
+} | {
+    kind: 'menu';
+    op: 'add' | 'remove';
+    tabId: number;
+    documentId: string;
+    topFrame?: boolean;
+    scriptId: string;
+    commandId: string;
+    name?: string;
+    at: number;
+} | {
+    kind: 'values';
+    scriptId: string;
+    tabId?: number;
+    documentId?: string;
+    writes: {
+        key: string;
+        value?: unknown;
+        deleted?: boolean;
+    }[];
+    at: number;
+} | {
+    kind: 'tab-opened';
+    sourceTabId: number;
+    tabId: number;
+    url: string;
+    scriptId?: string;
+    requestId?: string;
+    active?: boolean;
+    at: number;
+} | {
+    kind: 'tab-closed';
+    scriptId: string;
+    requestId: string;
+    at: number;
+} | {
+    kind: 'request';
+    scriptId: string;
+    tabId: number;
+    documentId?: string;
+    id: string;
+    url: string;
+    method: string;
+    outcome?: 'load' | 'error' | 'timeout' | 'abort';
+    status?: number;
+    error?: string;
+    at: number;
+} | {
+    kind: 'download';
+    scriptId: string;
+    tabId: number;
+    documentId?: string;
+    requestId: string;
+    url: string;
+    name: string;
+    outcome?: 'load' | 'error' | 'timeout' | 'abort';
+    filename?: string;
+    error?: string;
+    at: number;
+} | {
+    kind: 'connect-prompt';
+    op: 'shown' | 'answered' | 'closed';
+    promptId: string;
+    scriptId: string;
+    tabId: number;
+    host: string;
+    url?: string;
+    method?: string;
+    answer?: 'once' | 'cancel' | 'allow' | 'allow-all' | 'deny';
+    at: number;
+} | {
+    kind: 'notification';
+    op: 'shown' | 'clicked' | 'closed';
+    scriptId: string;
+    tabId: number;
+    documentId?: string;
+    requestId: string;
+    notificationId?: string;
+    text?: string;
+    title?: string;
+    at: number;
+};
+/**
+ * A run's id in the extension: sm-dev's run id (`D2`, or a named one)
+ * with a random tail, since run ids are reused once a run ends. Kept to
+ * the characters a URL path segment allows, since its scripts' URLs
+ * carry it.
+ */
+export declare function linkRunId(runId: string | undefined): string;
+export declare class ExtensionLink {
+    private readonly context;
+    /**
+     * The run's unique id (`linkRunId`), which its claims and its test
+     * collection carry.
+     */
+    readonly runId: string;
+    /** The extension's service worker, whose console carries the events. */
+    readonly workerUrl: string;
+    /** The origin of the extension's pages and its scripts' world. */
+    readonly origin: string;
+    private worker;
+    private readonly heard;
+    private readonly stopped;
+    private readonly listeners;
+    private readonly restartListeners;
+    private renewTimer;
+    private readonly tabs;
+    private readonly vouches;
+    private closed;
+    private closing;
+    private readonly renewing;
+    private adopted;
+    /** The extension's protocol version, as `open` read it. */
+    private extensionProtocol;
+    /** For the run to print: how the extension's protocol minor differs from sm-dev's, if it does. */
+    versionNote: string | null;
+    private absent;
+    private madeUpTabId;
+    private readonly onWorker;
+    /**
+     * Throws, naming `feature`, when the extension's protocol minor is
+     * older than `minor`: for a call or event added in that minor, before
+     * using it.
+     */
+    requireMinor(minor: number, feature: string): void;
+    /**
+     * Whether this run has a SourceMonkey link: for output that depends
+     * on what the extension does. False for a run with another manager.
+     */
+    get linked(): boolean;
+    private constructor();
+    /**
+     * Connects to the extension in `context`'s browser, for a run. Its
+     * tabs run its own scripts, and it hears the extension's events.
+     * Throws when the extension's protocol major differs from sm-dev's
+     * (`compareProtocol`), or `userScriptsOff` when Chrome won't let it
+     * run scripts. A minor that differs leaves `versionNote` set.
+     */
+    static open(context: BrowserContext, runId: string): Promise<ExtensionLink>;
+    /**
+     * A link for a run whose manager isn't SourceMonkey: no extension to
+     * call, no tabs claimed, no events heard. Its tabs are plain browser
+     * tabs, and every call into the extension throws `reason`.
+     */
+    static without(context: BrowserContext, runId: string, reason: string): ExtensionLink;
+    private adopt;
+    /** Hears each event the extension sends. */
+    onEvent(listener: (event: ExtensionEvent) => void): void;
+    /**
+     * Told when a new worker replaced the one before, whose events in
+     * between are lost, with how many of the run's tab claims had to be
+     * made again.
+     */
+    onRestart(listener: (restoredClaims: number) => void): void;
+    private current;
+    /**
+     * Runs `fn` in the worker. Tried again once in a new worker when the
+     * one known stopped meanwhile; an error of the call's own is thrown,
+     * not repeated, since a call may not be safe to make twice.
+     */
+    call<A, R>(fn: (arg: A) => R | Promise<R>, arg: A): Promise<R>;
+    /**
+     * Claims `page`'s tab for the run before it loads the run's page. The
+     * tab is named to the extension by a navigation it watches for, to
+     * `about:blank#<fragment>`, and the claim is recorded before this
+     * returns. Leaves the tab on `about:blank`, for the run to load its
+     * page in. Returns the tab's id. Throws an error naming the step that
+     * failed. A link `without` SourceMonkey claims nothing, and makes up
+     * an id.
+     */
+    claimPage(page: Page, scriptsOff?: boolean): Promise<number>;
+    private nameTab;
+    /**
+     * A tab the extension claimed for the run itself (one a run tab
+     * opened), for renewals to keep.
+     */
+    holdTab(tabId: number, scriptsOff?: boolean): void;
+    /** The run no longer holds the tab (it closed). */
+    forgetTab(tabId: number): void;
+    /**
+     * Marks a tab the run claimed, for every document it loads from now
+     * on, as one whose scripts on the run's own get `run`, or takes the
+     * marker away. Through a CDP script, which runs ahead of every
+     * extension script in a new document. It only reaches the tab: the
+     * tabs it opens, and its subframes, ask the extension. The marker is
+     * gone with the session, as the run closes or its connection drops.
+     */
+    private setVouch;
+    /** Turns a claimed tab's scripts off or back on, for `--noscript` tabs. */
+    setTabScriptsOff(tabId: number, off: boolean): Promise<void>;
+    private forgetVouch;
+    private renew;
+    private renewIn;
+    /**
+     * Installs or replaces one of the run's scripts in its test collection,
+     * with the dependency bodies read from disk (`pushedFiles`).
+     */
+    /**
+     * `source`: the file's `file://` URL, which `script list` shows. An
+     * extension before protocol 1.2 ignores it.
+     */
+    push(text: string, name: string, files?: Record<string, PushedFile>, source?: string): Promise<PushResult>;
+    /** Which document `tabId` shows (see the worker's `tabDocument`), or null if it can't be read. */
+    tabDocument(tabId: number): Promise<{
+        url: string;
+        timeOrigin: number;
+    } | null>;
+    /** How the script's injected entry maps back to its files; see `remapStackText`. */
+    stackLayout(scriptId: string): Promise<StackLayout | null>;
+    /**
+     * A tab's frames, live documents only, as Chrome lists them to the
+     * extension: straight from `chrome.webNavigation`, which every
+     * extension sm-dev works with has, so no protocol version gates it.
+     * Null when Chrome can't list them (the tab is gone).
+     */
+    allFrames(tabId: number): Promise<ExtensionFrame[] | null>;
+    /** A script's stored values, in the wire form the extension keeps. */
+    values(scriptId: string): Promise<Record<string, unknown>>;
+    /** A script's Log entries, oldest first, as its Log tab shows them. */
+    scriptLog(scriptId: string): Promise<LogEntry[]>;
+    /** Writes values (wire form) as another tab of the script would. */
+    writeValues(scriptId: string, writes: {
+        key: string;
+        value?: unknown;
+        deleted?: boolean;
+    }[]): Promise<void>;
+    /** The scripts the toolbar badge lists for a tab, with their status and collection. */
+    scriptsOnTab(tabId: number): Promise<{
+        id: string;
+        name: string;
+        status: string;
+        collection: string;
+        number?: number;
+    }[]>;
+    /**
+     * Fires a menu command in a tab, as clicking it in the toolbar menu
+     * does: in `documentId`, the document that registered it, when given.
+     * An extension before protocol 2.1 ignores it, firing the first match.
+     */
+    fireMenu(tabId: number, scriptId: string, commandId: string, documentId?: string): Promise<boolean>;
+    /**
+     * Runs a manual script (`@run-at context-menu`) in a tab, as its popup
+     * "Run this script" does. Throws with the extension's reason when it
+     * can't.
+     */
+    runManualScript(tabId: number, scriptId: string): Promise<void>;
+    /** The collections and installed scripts, for the `collection` and `script` commands. */
+    readonly manager: ManagerControl;
+    /** Clicks a shown notification, as the person would. False when it isn't showing. */
+    clickNotification(notificationId: string): Promise<boolean>;
+    /**
+     * Answers a connection prompt, as the person would in its window.
+     * False when it isn't waiting.
+     */
+    answerConnectPrompt(promptId: string, choice: 'once' | 'cancel' | 'allow' | 'allow-all' | 'deny'): Promise<boolean>;
+    /** Closes a shown notification, as the person would. */
+    closeNotification(notificationId: string): Promise<boolean>;
+    /**
+     * Releases the run's claims and subscription, which removes its test
+     * collection, and stops renewing.
+     */
+    close(): Promise<void>;
+    private release;
+}
+/** An error's first line, without the call Playwright names at its start. */
+export declare function firstLine(err: unknown): string;
+/**
+ * The collection and script commands' connection to SourceMonkey, with
+ * no run: no tabs claimed, no events heard. For one command, made just
+ * after the worker is found, so it doesn't look for a new one.
+ * - Throws as `ExtensionLink.open` does for a protocol major that
+ *   differs.
+ * - Doesn't need "Allow User Scripts", since nothing here runs a script.
+ */
+export declare function openManagerLink(context: BrowserContext): Promise<{
+    manager: ManagerControl;
+    versionNote: string | null;
+}>;