@melra/browser-runtime 0.3.0-alpha.14 → 0.3.0-alpha.16

package/README.md

@@ -37,7 +37,12 @@ leaves the browser, so treat them as sensitive artifacts.
 
 `unhinged: true` disables every check above except URL syntax. That includes the
 cloud-metadata block, which is the check most likely to matter on a hosted
-machine.
+machine. A `reserved` callback, which the MELRA server always passes, still
+refuses uploading a path it names or loading one through a `file:` URL, in
+every mode. The server's callback names MELRA's data directory, the policy
+file, the profile, the HAR files and credential files, but leaves its
+artifacts (screenshots and downloads) readable, so the browser can use them
+again.
 
 Requires Node.js 22 or newer, and a Chromium that Playwright can launch. Full
 documentation: [github.com/XAGI-Lab/melra](https://github.com/XAGI-Lab/melra)

package/dist/index.d.ts

@@ -34,6 +34,12 @@ export interface BrowserRuntimeOptions extends NetworkPolicy {
      * caller looks at next. `"allow"` keeps it as an addressable tab.
      */
     popups?: "allow" | "block";
+    /**
+     * Whether a path is one the browser may not upload or load, in any mode:
+     * the data MELRA itself holds. The runtime passes the file runtime's
+     * reading check, so its artifacts may be uploaded and loaded again.
+     */
+    reserved?: (path: string) => Promise<boolean>;
 }
 /**
  * Name any human-verification widget embedded in the page.
@@ -67,9 +73,13 @@ export declare function inputSent(error: unknown): boolean;
  * a message. Exported for unit testing.
  */
 export declare function pageAddress(url: string): string;
+/**
+ * The `<meta>` name of a page only an operator may act on: `melra console`
+ * serves its approval page with it, and its CSP lets no script take it off.
+ */
+export declare const APPROVAL_SURFACE = "melra-approval-surface";
 export declare class BrowserRuntime {
     private readonly options;
-    private browser;
     private context;
     private activePage;
     private connection;
@@ -97,8 +107,66 @@ export declare class BrowserRuntime {
     private popups;
     /** Pending closes of blocked popups, awaited before the action reports. */
     private closing;
-    /** True only while `tab_new` is opening the tab the caller asked for. */
-    private openingTab;
+    /**
+     * The `newPage` call in flight while `openPage` opens a tab MELRA asked for:
+     * the page it resolves to is that tab, not a window a site opened.
+     */
+    private opening;
+    /** In a launched browser, pages handed over while `openPage`'s `newPage` is in flight, held until it settles. */
+    private openingPagesQueue;
+    /**
+     * The windows this runtime owns, by CDP target id: tabs it opened, and every
+     * window one it owns or the tab it is driving opened. Decided when Chromium
+     * creates the window, from the opener it names then: Playwright's `opener()`
+     * comes later, and is null by then if the opener has closed. In a browser
+     * this runtime is attached to, the rest belong to someone else, the
+     * operator above all.
+     *
+     * ponytail: a tab a link opens with a modifier or middle click has no
+     * opener at all, so between actions it counts as the operator's whichever
+     * page clicked it, and while an action runs as the action's. A page's request for one (`Page.frameRequestedNavigation`)
+     * cannot be tied to the tab that follows: a refused request leaves nothing
+     * to match, and claiming the next opener-less tab would let a page have the
+     * operator's tabs, a console's among them, closed. Closing that gap needs a
+     * signal Chromium does not give.
+     */
+    private ownTargets;
+    /**
+     * The active page's target id once this runtime has driven it, navigated it
+     * or sent it input, since it became active. Until then it may be a tab of
+     * the operator's the runtime only picked up, and what it opens is theirs.
+     */
+    private drivenTarget;
+    /** Target ids already looked up; a page keeps its id across navigations. */
+    private targetIds;
+    /**
+     * Windows Chromium created while an action was running, with that action's
+     * number: its popups, whenever Playwright gets round to handing them over.
+     */
+    private createdActing;
+    /**
+     * The page targets of this context Chromium has announced and not yet
+     * destroyed, the operator's among them, so an opener can be known for a tab
+     * rather than, say, a frame of one.
+     */
+    private pageTargets;
+    /** The running action: what its page opens is the action's if it navigates the page or sends it input. */
+    private action;
+    /**
+     * The target id of the page an action that navigates it or sends it input
+     * acts on, in a browser this runtime is attached to, once looked up: what
+     * it opens while the action runs is the action's, even if the runtime has
+     * not driven it yet. A read leaves it out: like between actions, what a tab
+     * the runtime only landed on opens while the runtime reads it is the
+     * operator's, though the read's own calls into the page give it activation.
+     */
+    private actingTarget;
+    /** Counts actions, so a popup reported by a later one says so. */
+    private actions;
+    /** The page the running action acts on, once it has one. */
+    private actingOn;
+    /** Whether the running action has sent its step back or forward. */
+    private stepped;
     /**
      * Browser-level session that hears about a new window the moment Chromium
      * creates it, which is what lets an action wait for a popup it knows exists
@@ -106,10 +174,30 @@ export declare class BrowserRuntime {
      * not grant one; popups are then reported on Playwright's timing alone.
      */
     private targets;
-    /** Windows Chromium has created since tracking began, by browser context. */
-    private windowsCreated;
-    /** Windows Playwright has handed to the `page` handler, popup or not. */
-    private windowsAdopted;
+    /**
+     * The windows an action's wait is owed, by CDP target id, with their browser
+     * context: every page Chromium creates once tracking began, bar one that is
+     * the operator's in a browser this runtime is attached to. A window leaves
+     * when Playwright has handed it over and its id is looked up (`targetOf`),
+     * or when it is destroyed, which for a blocked popup is the runtime's own
+     * close. Those still owed when an action's wait ends, however it ends, or
+     * when the action fails before it waits, are given up on: kept, one whose
+     * first response never comes would hold every later action to its whole
+     * timeout (#226). One handed over later stands in for no other window
+     * (#234), and is reported by the action running then (`giveUpOwed`).
+     * `popup`: whether it has an opener, as a page's window does and the
+     * runtime's own tab does not.
+     *
+     * ponytail: a window a page opens between actions is owed to the next
+     * action, so one that never loads still holds that action up once.
+     */
+    private owed;
+    /** Popups given up on in block mode, by target id, with the timer that closes them (`giveUpOwed`). */
+    private lapsing;
+    /** Popups those timers closed, until their targets are destroyed. */
+    private lapsedIds;
+    /** Pages handed over closed and blank while one of those was closing: those popups. */
+    private lapsedPages;
     /** This context's id in CDP, resolved on first use and then fixed. */
     private contextId;
     /**
@@ -118,12 +206,23 @@ export declare class BrowserRuntime {
      */
     private signal;
     private callMs;
+    /** A wait's absolute deadline, applied to every bounded call it makes. */
+    private waitDeadline;
     /**
      * Set once the running action's effect call has returned. From then on the
      * page may have acted on it, so a failure is no longer evidence that nothing
      * happened — see `execute`.
      */
     private dispatched;
+    /** Set when the route refused reserved data during the running action. */
+    private refusedReserved;
+    /**
+     * The workspace root with its links resolved, once, as the file runtime
+     * resolves it: a root link re-pointed later does not move uploads to a
+     * different directory than file operations. An upload awaits it and fails
+     * if it did.
+     */
+    private readonly root;
     constructor(options: BrowserRuntimeOptions);
     /**
      * Bound a Playwright call that takes no timeout of its own by the running
@@ -137,26 +236,100 @@ export declare class BrowserRuntime {
      */
     private call;
     private uploadPaths;
+    /**
+     * `assertSafeUrl`, and a file: URL naming reserved data is refused too. Only
+     * unhinged mode lets a file: URL through the first, and the reserved data
+     * stays out of reach there as it does for the file and terminal adapters.
+     */
+    private assertAllowed;
     private ensureContext;
     /**
-     * Hold the action's result until Playwright has handed over every window
-     * Chromium created, so the action that opened a window is the one that
-     * reports it.
+     * Hold the action's result while this context's windows are still owed
+     * (`owed`), so the action that opened a window is the one that reports it.
+     * A window stops being owed once it is handed over and looked up, or once it
+     * is destroyed: in a launched browser a blocked popup when the runtime's
+     * close lands and an allowed one when its lookup returns; in one this
+     * runtime is attached to, every window once it is looked up to be judged;
+     * and one destroyed before it is handed over, at once.
      *
      * Costs one round trip when nothing was opened. Waits only while a window is
-     * known to exist and is still unreported, bounded by the action's own
-     * timeout: the window is part of what the action did. A window still pending
-     * after that is reported by the action running when Playwright delivers it.
+     * owed, bounded by the action's own timeout: the window is part of what the
+     * action did. One still owed after that is given up on, so no later action
+     * waits for it, and is reported by the action running when Playwright
+     * delivers it, if it ever does.
      */
     private awaitOpenedWindows;
+    /**
+     * Gives up on the windows still owed (`owed`). In block mode a popup among
+     * them, which Playwright has not handed over to be closed, is closed by its
+     * id once it has had as long again to load (#240). One that loads in that
+     * time is handed over, reported with its address, and closed as any popup
+     * is; one that never does is handed over closed, with no address, and
+     * reported between actions (`adopt`). In a launched browser every window is
+     * this runtime's; in one it is attached to, only a window of this context is
+     * closed, checked when the timer fires. The context is known by then even
+     * when the action giving up failed before its wait: any page looked up
+     * tells it (`targetOf`), and an action that drives a page looks it up first.
+     *
+     * ponytail: "as long again" is the giving-up action's own `grace`
+     * (its `timeoutMs`), not a setting; a window that loads later is closed
+     * before it can be seen.
+     */
+    private giveUpOwed;
+    private forgetLapsing;
+    /**
+     * This context's id in CDP, looked up once: what owed windows are kept
+     * under. False when there is no page yet to ask.
+     */
+    private learnContextId;
+    /** A window handed over is owed by no wait once its id is known (`owed`). */
+    private release;
+    /**
+     * Reports a window a page opened and, in block mode, closes it. `during`:
+     * whether it came while an action ran.
+     */
+    private adopt;
     /**
      * Opens a page MELRA asked for, not one the site opened by itself.
      *
      * The popup handler cannot tell the two apart — both arrive as a `page`
-     * event — so this flag is the difference, and it is held across exactly the
-     * await that emits the event.
+     * event — so `opening` holds the `newPage` call that emits the event, and a
+     * browser this runtime is attached to compares the page with what it
+     * resolves to. A launched browser looks no window up as it is handed over,
+     * so the handler queues every page it is handed then (#233), and they are
+     * sorted here once `newPage` has said which one is the tab.
      */
     private openPage;
+    /**
+     * A page's CDP target id. Bounded on its own, not by the action's budget or
+     * cancel: between actions those belong to an action that has finished.
+     */
+    private targetOf;
+    /**
+     * Whether to treat a new window as this runtime's, in a browser it is
+     * attached to: one created while an action ran, which then counts as the
+     * runtime's for the windows it opens, or one of `ownTargets`. `during`
+     * says whether the action reporting it is the one it came in; any other
+     * reports it as between actions. Asked twice before giving up. One that
+     * closed before it could be asked is reported, as everywhere else; that
+     * one, and one still open that cannot be asked, count by when Playwright
+     * handed it over.
+     */
+    private adoptable;
+    /**
+     * Makes `page` the one actions land on. It is not driven yet: it may be a
+     * tab of the operator's the runtime only picked up, and what it opens stays
+     * theirs until the runtime navigates it or sends it input (`drive`). The
+     * page already active stays driven if it was.
+     */
+    private activate;
+    /**
+     * The runtime is navigating the active page or has sent it input, so from
+     * here what that page opens is the runtime's, until another page is made
+     * active. Not before: an action refused, or one whose target was never
+     * found, leaves an operator's tab theirs.
+     */
+    private drive;
     private page;
     /**
      * The tab list, with the index each entry can be addressed by.
@@ -164,8 +337,37 @@ export declare class BrowserRuntime {
      * Returned by every tab action rather than only by `tabs`, because opening,
      * switching, and closing all renumber the list — a caller that had to issue a
      * separate `tabs` call after each one would be acting on a stale index.
+     *
+     * Never throws: it follows the effect of every tab action but `tabs`, and a
+     * listing that failed made a tab opened or closed read as nothing done. A
+     * tab that does not answer within a second, or the action's timeout if
+     * shorter, or before a cancel, is listed with `title: null`;
+     * one closed meanwhile is left out, and the indices are the ones after it.
+     * `pages` is the list they index, for an action to report its own tab's.
      */
     private describeTabs;
+    /**
+     * Whether any frame of the page holds a filled secret field, and the frames
+     * it read: a targeted read searches only those, so it never looks in a frame
+     * this did not vouch for. Every frame, not the bounded set a snapshot reads:
+     * a selector can enter any of them, including one that attached while the
+     * others were being asked, so the list is read again until it stops growing.
+     * "unknown" when some frame could not answer, which a read must not take for
+     * "clear". The whole check takes at most `ms`.
+     */
+    private secretFieldFilled;
+    /** The frames a targeted read may search, or its refusal while a secret field is filled. */
+    private clearOfSecrets;
+    /**
+     * A frame mid-navigation is asked again once its next document has loaded;
+     * a detached one holds nothing. A frame with no document yet (a lazy or
+     * still-loading iframe) that does not answer is "unread": it does not make
+     * the page unknown, and a targeted read does not search it. A cancelled task
+     * is not "unknown": it stops. Each frame is given at most `ms` in all, and
+     * one that gets its document while being asked is asked again with what is
+     * left, which is not one of its retries.
+     */
+    private frameHoldsSecret;
     /**
      * The frames a target may live in, main frame first.
      *
@@ -183,6 +385,9 @@ export declare class BrowserRuntime {
      * Every way the caller gave us to find the element, in the order we trust
      * them. Split out from `locator` because waiting and acting need the same
      * list but disagree about what to do when nothing matches yet.
+     *
+     * `within` starts a checked read only in the frames its check read; where a
+     * match may end up is `readFirst`'s to judge.
      */
     private candidates;
     /**
@@ -200,8 +405,18 @@ export declare class BrowserRuntime {
      * Resolution only reads the page and always runs before an action's effect,
      * so a `count` that times out here fails a click or a fill cleanly: nothing
      * was sent, and `execute` does not report it as an unknown outcome.
+     *
      */
     private locator;
+    /**
+     * A candidate's first match, if its own document is one a secret check
+     * read. A selector or role can lead from the frame it starts in to another,
+     * so a checked read judges the element it would use, not the route to it:
+     * a match anywhere else counts as none, and what it is makes no difference.
+     */
+    private readFirst;
+    /** `locator` for a checked read: the element itself, from the read frames. */
+    private readTarget;
     /**
      * Wait for a target to reach a state, re-resolving it on every poll.
      *
@@ -230,6 +445,51 @@ export declare class BrowserRuntime {
      * reliably no matter what is in it.
      */
     private typeInto;
+    /**
+     * An input action on its target's element, held to the documents it was
+     * checked on: the page's, and the one the target was first found in, which
+     * for a target inside a frame is that frame's. The input goes through the
+     * element, which a navigation takes away, so a page or frame that navigates
+     * itself while the action waits (for the element to show, say) fails the
+     * action rather than having the target found, and acted on, in the new
+     * document. The target is found again only in the document it was found
+     * in, and only before any input reached it.
+     *
+     * The element is first waited for as the action would wait (`ready`: the
+     * states named, which sends the page nothing), so the check after that is
+     * the last thing before the input, the address it named included. Once the
+     * action has sent input (an earlier field of a form, say), only its
+     * document is held: a page may rewrite its own path in answer, as it may
+     * while it is typed into. A target found again after a re-render is not
+     * waited for twice, so one re-rendered faster than that can still be hit.
+     * Whatever runs out is reported as the action's `timeout` running out
+     * (`ranOut`).
+     *
+     * ponytail: Playwright's own hit-target check and dispatch come after this,
+     * so a navigation that commits in that instant can still receive the one
+     * click or key; closing it needs input that names its document, which CDP
+     * lacks.
+     */
+    private actOn;
+    /**
+     * The target found again after it went away, searched for in slices that
+     * each end by asking whether the page, or the document it was first found
+     * in (a frame's), has left: a page that takes the target away and then
+     * navigates to a document without it would otherwise be waited on until
+     * the timeout. A slice cut short, by a frame detaching as the page around
+     * it leaves, is asked about the same way.
+     */
+    private refind;
+    /** `call` for a handle: one that arrives after the bound or a cancel is released, not left in the page. */
+    private handle;
+    /**
+     * Whether the page has left the document an input action was checked on,
+     * or, with `address`, the address it named. A navigation destroys the old
+     * document's context, so asking its handle fails. A call that timed out or
+     * was cancelled is no answer either way and is passed on, and a closed page
+     * has not moved anywhere: the action's own error says what happened.
+     */
+    private moved;
     /**
      * An attached CDP browser has no pinning proxy, and Chromium follows a
      * redirect without showing the hop to the route guard, so an allowed page
@@ -260,6 +520,7 @@ export declare class BrowserRuntime {
     execute(operation: BrowserOperation, signal?: AbortSignal): Promise<Record<string, unknown>>;
     private executeOne;
     private run;
+    private act;
     close(): Promise<void>;
 }
 export { assertSafeDestination, assertSafeUrl, isPrivateAddress, type NetworkPolicy, type SafeDestination, } from "@melra/policy-core";

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}