jeopi-cli 16.2.14 → 16.2.15

package/dist/types/tools/bash-skill-urls.d.ts

@@ -0,0 +1,31 @@
+import type { Skill } from "../extensibility/skills";
+import { type LocalProtocolOptions } from "../internal-urls";
+import type { InternalResource } from "../internal-urls/types";
+interface InternalUrlResolver {
+    canHandle(input: string): boolean;
+    resolve(input: string): Promise<InternalResource>;
+}
+export interface InternalUrlExpansionOptions {
+    skills: readonly Skill[];
+    noEscape?: boolean;
+    internalRouter?: InternalUrlResolver;
+    localOptions?: LocalProtocolOptions;
+    ensureLocalParentDirs?: boolean;
+}
+/**
+ * Resolve a single skill:// URL to its absolute filesystem path.
+ * Does NOT read file content or verify existence.
+ */
+export declare function resolveSkillUrlToPath(url: string, skills: readonly Skill[]): string;
+/**
+ * Expand all skill:// URIs in a bash command string.
+ * Returns the command with URIs replaced by shell-escaped absolute paths.
+ * Throws ToolError if any URI cannot be resolved.
+ */
+export declare function expandSkillUrls(command: string, skills: readonly Skill[]): string;
+/**
+ * Expand supported internal URLs in a bash command string to shell-escaped absolute paths.
+ * Supported schemes: skill://, agent://, artifact://, memory://, rule://, local://
+ */
+export declare function expandInternalUrls(command: string, options: InternalUrlExpansionOptions): Promise<string>;
+export {};

package/dist/types/tools/bash.d.ts

@@ -0,0 +1,148 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback, ToolApprovalDecision } from "jeopi-agent-core";
+import type { Component } from "jeopi-tui";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import { type Theme } from "../modes/theme/theme";
+import type { ToolSession } from ".";
+import { type OutputMeta } from "./output-meta";
+export declare const BASH_DEFAULT_PREVIEW_LINES = 10;
+/**
+ * Bash patterns flagged as safety critical for approval policy.
+ *
+ * Kept intentionally tight — the cost of a false negative is data loss or a compromised host,
+ * while false positives remain actionable through user policy control.
+ * New patterns should target shapes that are virtually never legitimate in automation.
+ */
+export declare const CRITICAL_BASH_PATTERNS: readonly [RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp];
+declare const bashSchemaBase: import("arktype/internal/variants/object.ts").ObjectType<{
+    command: string;
+    env?: {
+        [x: string]: string;
+    } | undefined;
+    timeout?: number | undefined;
+    cwd?: string | undefined;
+    pty?: boolean | undefined;
+}, {}>;
+declare const bashSchemaWithAsync: import("arktype/internal/variants/object.ts").ObjectType<{
+    command: string;
+    env?: {
+        [x: string]: string;
+    } | undefined;
+    timeout?: number | undefined;
+    cwd?: string | undefined;
+    pty?: boolean | undefined;
+    async?: boolean | undefined;
+}, {}>;
+type BashToolSchema = typeof bashSchemaBase | typeof bashSchemaWithAsync;
+export interface BashToolInput {
+    command: string;
+    env?: Record<string, string>;
+    timeout?: number;
+    cwd?: string;
+    async?: boolean;
+    pty?: boolean;
+}
+export interface BashToolDetails {
+    meta?: OutputMeta;
+    timeoutSeconds?: number;
+    requestedTimeoutSeconds?: number;
+    wallTimeMs?: number;
+    /** Exit code of a command that ran to completion but failed (non-zero). */
+    exitCode?: number;
+    terminalId?: string;
+    async?: {
+        state: "running" | "completed" | "failed";
+        jobId: string;
+        type: "bash";
+    };
+}
+export interface BashToolOptions {
+}
+/**
+ * Bash tool implementation.
+ *
+ * Executes bash commands with optional timeout and working directory.
+ */
+export declare class BashTool implements AgentTool<typeof bashSchemaBase | typeof bashSchemaWithAsync, BashToolDetails> {
+    #private;
+    private readonly session;
+    readonly name = "bash";
+    readonly approval: (args: unknown) => ToolApprovalDecision;
+    readonly formatApprovalDetails: (args: unknown) => string[];
+    readonly label = "Bash";
+    readonly loadMode = "essential";
+    readonly description: string;
+    readonly parameters: BashToolSchema;
+    readonly concurrency: (args: Partial<BashToolInput>) => "shared" | "exclusive";
+    readonly strict = true;
+    constructor(session: ToolSession);
+    execute(_toolCallId: string, { command: rawCommand, env: rawEnv, timeout: rawTimeout, cwd, async: asyncRequested, pty, }: BashToolInput, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<BashToolDetails>, ctx?: AgentToolContext): Promise<AgentToolResult<BashToolDetails>>;
+}
+export interface BashRenderArgs {
+    command?: string;
+    env?: Record<string, string>;
+    timeout?: number;
+    cwd?: string;
+    __partialJson?: string;
+    [key: string]: unknown;
+}
+export interface BashRenderContext {
+    /** Raw output text */
+    output?: string;
+    /** Whether output came from artifact storage */
+    isFullOutput?: boolean;
+    /** Whether output is expanded */
+    expanded?: boolean;
+    /** Number of preview lines when collapsed */
+    previewLines?: number;
+    /** Timeout in seconds */
+    timeout?: number;
+}
+export interface ShellRendererConfig<TArgs> {
+    resolveTitle: (args: TArgs | undefined, options: RenderResultOptions) => string;
+    resolveCommand?: (args: TArgs | undefined) => string | undefined;
+    resolveCwd?: (args: TArgs | undefined) => string | undefined;
+    resolveEnv?: (args: TArgs | undefined) => Record<string, string> | undefined;
+    showHeader?: boolean;
+}
+export declare function getBashEnvForDisplay(args: BashRenderArgs): Record<string, string> | undefined;
+/**
+ * Returns the bash command formatted for the result body: the dim `$ cd … &&`
+ * prefix joined with syntax-highlighted command lines. The prefix is applied
+ * only to the first line so multi-line commands display cleanly — terminals
+ * reset SGR state at line boundaries, which made the previous single-string
+ * `theme.fg("dim", ...)` form render only the first line as dim.
+ */
+export declare function formatBashCommandLines(args: BashRenderArgs, uiTheme: Theme): string[];
+export declare function createShellRenderer<TArgs>(config: ShellRendererConfig<TArgs>): {
+    renderCall(args: TArgs, options: RenderResultOptions, uiTheme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: BashToolDetails;
+        isError?: boolean;
+    }, options: RenderResultOptions & {
+        renderContext?: BashRenderContext;
+    }, uiTheme: Theme, args?: TArgs): Component;
+    mergeCallAndResult: boolean;
+    inline: boolean;
+    provisionalPendingPreview: string;
+};
+export declare const bashToolRenderer: {
+    renderCall(args: BashRenderArgs, options: RenderResultOptions, uiTheme: Theme): Component;
+    renderResult(result: {
+        content: {
+            type: string;
+            text?: string;
+        }[];
+        details?: BashToolDetails;
+        isError?: boolean;
+    }, options: RenderResultOptions & {
+        renderContext?: BashRenderContext;
+    }, uiTheme: Theme, args?: BashRenderArgs | undefined): Component;
+    mergeCallAndResult: boolean;
+    inline: boolean;
+    provisionalPendingPreview: string;
+};
+export {};

package/dist/types/tools/browser/aria/aria-snapshot.d.ts

@@ -0,0 +1,39 @@
+import type { ElementHandle, Page } from "puppeteer-core";
+export interface AriaSnapshotOptions {
+    /** Maximum tree depth to render. */
+    depth?: number;
+    /** Append `[box=x,y,w,h]` bounding boxes to each node. */
+    boxes?: boolean;
+}
+/**
+ * Capture a Playwright-format ARIA snapshot of `root` (or the whole document when
+ * null). Always runs in `ai` mode so every node carries a `[ref=eN]` id; resolve
+ * those to elements with {@link resolveAriaRefHandle}. Ids are renumbered from e1
+ * on each call and remain valid until the next snapshot.
+ */
+export declare function captureAriaSnapshot(page: Page, root: ElementHandle | null, options?: AriaSnapshotOptions): Promise<string>;
+/**
+ * Resolve a `[ref=eN]` id from the latest snapshot to a live `ElementHandle`, or
+ * null when the ref no longer matches any element. Runs in the main world so it
+ * sees the `_ariaRef` expandos the snapshot wrote.
+ */
+export declare function resolveAriaRefHandle(page: Page, ref: string): Promise<ElementHandle | null>;
+/**
+ * Recognize the explicit `[ref=eN]` selector forms and return the bare ref id,
+ * else null. Accepts `aria-ref=e5` (Playwright-MCP style), `aria-ref/e5`, and
+ * `ariaref/e5` — lets `tab.click("aria-ref=e5")` etc. act on snapshot refs. A
+ * bare `e5` is intentionally NOT a ref selector: the cmux backend already uses
+ * bare `eN`/`@eN` for its own observe ids, so requiring the prefix keeps action
+ * selectors meaning the same thing on both backends. (`tab.ref("e5")` still
+ * accepts a bare id directly.)
+ */
+export declare function parseAriaRefSelector(selector: string): string | null;
+/**
+ * Build a self-contained expression script that runs the vendored bundle in the
+ * page and returns the ARIA snapshot YAML. Used by the cmux backend, whose
+ * `browser.eval` RPC takes a script string and returns the completion value (it
+ * has no ElementHandle to pass in). The script resolves `selector` via
+ * `document.querySelector` in-page (CSS selectors only) or falls back to the
+ * whole document. Like the puppeteer path it installs nothing on `window`.
+ */
+export declare function buildAriaSnapshotScript(selector: string | undefined, options?: AriaSnapshotOptions): string;

package/dist/types/tools/browser/attach.d.ts

@@ -0,0 +1,34 @@
+import type { Browser, Page } from "puppeteer-core";
+/**
+ * Allocate an unused TCP port on 127.0.0.1 by binding to port 0 and reading
+ * back the kernel-assigned port. There's a small race between close and the
+ * subsequent bind in the launched app, but Chromium's listener will retry.
+ */
+export declare function findFreeCdpPort(): Promise<number>;
+/** Poll `${cdpUrl}/json/version` until it responds with 200, with abort + timeout support. */
+export declare function waitForCdp(cdpUrl: string, timeoutMs: number, signal?: AbortSignal): Promise<void>;
+/**
+ * If any running instance of `exe` was launched with `--remote-debugging-port`
+ * and that endpoint actually answers, return it so attach can reuse it instead
+ * of killing and respawning. Idempotent re-attaches are the common case.
+ */
+export declare function findReusableCdp(exe: string, signal?: AbortSignal): Promise<{
+    cdpUrl: string;
+    pid: number;
+} | null>;
+/**
+ * Pick the best page target on an attached browser. Prefer discoverable page
+ * targets first so Chromium/Edge attach flows that hide pages from
+ * `browser.pages()` can still return a usable tab.
+ */
+export declare function pickElectronTarget(browser: Browser, matcher?: string): Promise<Page>;
+/**
+ * SIGTERM the process tree, wait briefly, then SIGKILL anything still alive.
+ * Single-process variant for our own spawned children.
+ */
+export declare function gracefulKillTreeOnce(pid: number, gracePeriodMs?: number): Promise<void>;
+/**
+ * Multi-process variant for attach: find every PID running `executablePath`
+ * (single-instance apps may keep an orphan around) and tear them all down.
+ */
+export declare function killExistingByPath(executablePath: string, signal?: AbortSignal): Promise<number>;

package/dist/types/tools/browser/cmux/cmux-tab.d.ts

@@ -0,0 +1,212 @@
+import { JsRuntime } from "../../../eval/js/shared/runtime";
+import type { ToolSession } from "../../index";
+import { type AriaSnapshotOptions } from "../aria/aria-snapshot";
+import { type ReadableFormat } from "../readable";
+import type { Observation, ReadyInfo, RunResultOk, ScreenshotResult, SessionSnapshot } from "../tab-protocol";
+import type { CmuxSocketClient } from "./socket-client";
+interface ScreenshotOptions {
+    selector?: string;
+    fullPage?: boolean;
+    save?: string;
+    silent?: boolean;
+    encoding?: "base64" | "binary";
+}
+interface ObserveOptions {
+    includeAll?: boolean;
+    viewportOnly?: boolean;
+}
+interface RunContext {
+    session: SessionSnapshot;
+    displays: RunResultOk["displays"];
+    screenshots: ScreenshotResult[];
+    signal: AbortSignal;
+    timeoutMs: number;
+}
+type WaitUntil = "load" | "domcontentloaded" | "networkidle0" | "networkidle2";
+type DragTarget = string | {
+    readonly x: number;
+    readonly y: number;
+};
+interface BoundingBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface CmuxResponseRecord {
+    id: number;
+    url: string;
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    body: string;
+}
+interface ViewportOptions {
+    width: number;
+    height: number;
+    deviceScaleFactor?: number;
+}
+export interface RunCmuxCodeOptions {
+    code: string;
+    timeoutMs: number;
+    signal?: AbortSignal;
+    session: ToolSession;
+    snapshot: SessionSnapshot;
+}
+export declare class CmuxTab {
+    #private;
+    constructor(opts: {
+        client: CmuxSocketClient;
+        surfaceId: string;
+        url?: string;
+        title?: string;
+    });
+    get surfaceId(): string;
+    get page(): CmuxPageFacade;
+    get browser(): CmuxBrowserFacade;
+    viewport(): ReadyInfo["viewport"];
+    setViewport(viewport: ViewportOptions): Promise<void>;
+    url(): string;
+    title(): Promise<string>;
+    readyInfo(viewport?: ReadyInfo["viewport"]): Promise<ReadyInfo>;
+    setRunContext(context: RunContext): void;
+    clearRunContext(): void;
+    goto(url: string, opts?: {
+        waitUntil?: WaitUntil;
+        timeoutMs?: number;
+    }): Promise<void>;
+    observe(opts?: ObserveOptions): Promise<Observation>;
+    ariaSnapshot(selector?: string, opts?: AriaSnapshotOptions): Promise<string>;
+    ref(id: string): Promise<CmuxElementHandle>;
+    click(selector: string): Promise<void>;
+    dblclick(selector: string): Promise<void>;
+    hover(selector: string): Promise<void>;
+    focus(selector: string): Promise<void>;
+    check(selector: string): Promise<void>;
+    uncheck(selector: string): Promise<void>;
+    type(selector: string, text: string): Promise<void>;
+    fill(selector: string, value: string): Promise<void>;
+    press(key: string, opts?: {
+        selector?: string;
+    }): Promise<void>;
+    scroll(dx: number, dy: number): Promise<void>;
+    waitFor(selector: string, opts?: {
+        timeout?: number;
+    }): Promise<CmuxElementHandle>;
+    waitForSelector(selector: string, opts?: {
+        timeout?: number;
+    }): Promise<CmuxElementHandle>;
+    evaluate<TResult, TArgs extends unknown[]>(fn: string | ((...args: TArgs) => TResult | Promise<TResult>), ...args: TArgs): Promise<TResult>;
+    scrollIntoView(selector: string): Promise<void>;
+    select(selector: string, ...values: string[]): Promise<string[]>;
+    extract(format?: ReadableFormat): Promise<string>;
+    screenshot(opts?: ScreenshotOptions): Promise<ScreenshotResult>;
+    waitForUrl(pattern: string | RegExp, opts?: {
+        timeout?: number;
+    }): Promise<string>;
+    waitForNavigation(opts?: {
+        waitUntil?: WaitUntil;
+        timeout?: number;
+    }): Promise<null>;
+    drag(from: DragTarget, to: DragTarget): Promise<void>;
+    uploadFile(selector: string, ...filePaths: string[]): Promise<void>;
+    waitForResponse(pattern: string | RegExp | ((response: CmuxResponse) => boolean | Promise<boolean>), opts?: {
+        timeout?: number;
+    }): Promise<CmuxResponse>;
+    id(id: number): Promise<CmuxElementHandle>;
+    ensureRuntime(session: SessionSnapshot): JsRuntime;
+    elementHandle(selector: string): CmuxElementHandle;
+    elementExists(selector: string): Promise<boolean>;
+    elementBox(selector: string): Promise<BoundingBox | null>;
+    evaluateOnSelector<TResult>(selector: string, source: string, args: unknown[]): Promise<TResult>;
+    pageContent(): Promise<string>;
+    pageScreenshot(opts?: ScreenshotOptions): Promise<Buffer | string>;
+    waitForFunction(fn: string | ((...args: unknown[]) => unknown | Promise<unknown>), opts: {
+        timeout?: number;
+        polling?: number;
+    } | undefined, ...args: unknown[]): Promise<unknown>;
+}
+declare class CmuxResponse {
+    #private;
+    constructor(record: CmuxResponseRecord);
+    url(): string;
+    status(): number;
+    statusText(): string;
+    headers(): Record<string, string>;
+    text(): Promise<string>;
+    json(): Promise<unknown>;
+}
+declare class CmuxElementHandle {
+    #private;
+    constructor(tab: CmuxTab, selector: string);
+    click(): Promise<void>;
+    type(text: string): Promise<void>;
+    fill(value: string): Promise<void>;
+    focus(): Promise<void>;
+    hover(): Promise<void>;
+    evaluate<TResult, TArgs extends unknown[]>(fn: (element: unknown, ...args: TArgs) => TResult | Promise<TResult>, ...args: TArgs): Promise<TResult>;
+    boundingBox(): Promise<BoundingBox | null>;
+    uploadFile(...paths: string[]): Promise<void>;
+    dispose(): Promise<void>;
+}
+declare class CmuxLocator {
+    #private;
+    constructor(tab: CmuxTab, selector: string);
+    setTimeout(timeoutMs: number): this;
+    click(): Promise<void>;
+    fill(value: string): Promise<void>;
+    waitHandle(): Promise<CmuxElementHandle>;
+}
+declare class CmuxPageFacade {
+    #private;
+    readonly keyboard: {
+        press: (key: string) => Promise<void>;
+    };
+    readonly mouse: {
+        wheel: (delta: {
+            deltaX?: number;
+            deltaY?: number;
+        }) => Promise<void>;
+        move: (x: number, y: number) => Promise<void>;
+        down: () => Promise<void>;
+        up: () => Promise<void>;
+    };
+    constructor(tab: CmuxTab);
+    url(): string;
+    title(): Promise<string>;
+    viewport(): ReadyInfo["viewport"];
+    setViewport(viewport: ViewportOptions): Promise<void>;
+    goto(url: string, opts?: {
+        waitUntil?: WaitUntil;
+        timeout?: number;
+    }): Promise<{
+        url: string;
+    }>;
+    evaluate<TResult, TArgs extends unknown[]>(fn: string | ((...args: TArgs) => TResult | Promise<TResult>), ...args: TArgs): Promise<TResult>;
+    content(): Promise<string>;
+    locator(selector: string): CmuxLocator;
+    $(selector: string): Promise<CmuxElementHandle | null>;
+    waitForSelector(selector: string, opts?: {
+        timeout?: number;
+    }): Promise<CmuxElementHandle>;
+    waitForFunction(fn: string | ((...args: unknown[]) => unknown | Promise<unknown>), opts?: {
+        timeout?: number;
+        polling?: number;
+    }, ...args: unknown[]): Promise<unknown>;
+    waitForResponse(pattern: string | RegExp | ((response: CmuxResponse) => boolean | Promise<boolean>), opts?: {
+        timeout?: number;
+    }): Promise<CmuxResponse>;
+    screenshot(opts?: ScreenshotOptions): Promise<Buffer | string>;
+}
+declare class CmuxBrowserFacade {
+    #private;
+    connected: boolean;
+    constructor(tab: CmuxTab);
+    pages(): Promise<CmuxPageFacade[]>;
+    version(): Promise<string>;
+    wsEndpoint(): string;
+    disconnect(): void;
+    close(): Promise<void>;
+}
+export declare function runCmuxCode(tab: CmuxTab, opts: RunCmuxCodeOptions): Promise<RunResultOk>;
+export {};

package/dist/types/tools/browser/cmux/rpc.d.ts

@@ -0,0 +1,70 @@
+import type { Observation } from "../tab-protocol";
+export interface CmuxKind {
+    kind: "cmux";
+    socketPath: string;
+    password?: string;
+    surface?: string;
+}
+export interface CmuxOpenSplitResult {
+    surface_id?: unknown;
+    url?: unknown;
+    workspace_id?: unknown;
+    created_split?: unknown;
+    placement_strategy?: unknown;
+}
+export interface CmuxSnapshotRef {
+    role?: unknown;
+    name?: unknown;
+}
+export interface CmuxSnapshotPage {
+    title?: unknown;
+    url?: unknown;
+    ready_state?: unknown;
+    text?: unknown;
+    html?: unknown;
+}
+export interface CmuxSnapshotResult {
+    snapshot?: unknown;
+    refs?: Record<string, CmuxSnapshotRef>;
+    page?: CmuxSnapshotPage;
+    url?: unknown;
+    title?: unknown;
+    ready_state?: unknown;
+    surface_id?: unknown;
+}
+export interface CmuxEvalResult {
+    value?: unknown;
+    surface_id?: unknown;
+    content_world?: unknown;
+}
+export interface CmuxUrlGetResult {
+    url?: unknown;
+    surface_id?: unknown;
+    workspace_id?: unknown;
+}
+export interface CmuxScreenshotResult {
+    png_base64?: unknown;
+    path?: unknown;
+    url?: unknown;
+    surface_id?: unknown;
+    width?: unknown;
+    height?: unknown;
+}
+export interface CmuxGeometry {
+    innerWidth: number;
+    innerHeight: number;
+    dpr: number;
+    scrollX: number;
+    scrollY: number;
+    scrollWidth: number;
+    scrollHeight: number;
+}
+export declare const GEOMETRY_SCRIPT = "(() => ({ innerWidth: window.innerWidth, innerHeight: window.innerHeight, dpr: window.devicePixelRatio||1, scrollX: window.scrollX, scrollY: window.scrollY, scrollWidth: document.documentElement.scrollWidth, scrollHeight: document.documentElement.scrollHeight }))()";
+export declare function cmuxSnapshotToObservation(result: CmuxSnapshotResult, viewport: Observation["viewport"], geometry: CmuxGeometry): Observation;
+export declare function serializeEval(fn: string | ((...args: unknown[]) => unknown), args: unknown[]): string;
+export declare function mapWaitUntil(waitUntil: string | undefined): "interactive" | "complete";
+export interface ResolveCmuxKindOptions {
+    surface?: string;
+    settingEnabled?: boolean;
+}
+export declare function resolveCmuxKind(options?: ResolveCmuxKindOptions | null, env?: Record<string, string | undefined>): CmuxKind | null;

package/dist/types/tools/browser/cmux/socket-client.d.ts

@@ -0,0 +1,19 @@
+type CmuxErrorPayload = {
+    code?: unknown;
+    message?: unknown;
+    details?: unknown;
+};
+export declare function formatCmuxError(error: CmuxErrorPayload | undefined): string;
+export declare class CmuxSocketClient {
+    #private;
+    constructor(opts: {
+        socketPath: string;
+        password?: string;
+    });
+    connect(): Promise<void>;
+    request(method: string, params: Record<string, unknown>, opts?: {
+        timeoutMs?: number;
+    }): Promise<Record<string, unknown>>;
+    close(): void;
+}
+export {};

package/dist/types/tools/browser/launch.d.ts

@@ -0,0 +1,67 @@
+import type { Browser, CDPSession, Page, default as Puppeteer, Target } from "puppeteer-core";
+export declare const DEFAULT_VIEWPORT: {
+    width: number;
+    height: number;
+    deviceScaleFactor: number;
+};
+/**
+ * Per-CDP-message timeout applied to every puppeteer launch/connect. Set above
+ * `TOOL_TIMEOUTS.browser.max` (30s) so the agent-side wall-clock is the canonical
+ * limit; this constant only catches genuinely stuck CDP sockets (renderer wedged,
+ * connection dropped, etc.).
+ */
+export declare const BROWSER_PROTOCOL_TIMEOUT_MS = 60000;
+export declare function loadPuppeteer(): Promise<typeof Puppeteer>;
+export declare function loadPuppeteerInWorker(safeDir: string): Promise<typeof Puppeteer>;
+export interface LaunchHeadlessOptions {
+    headless: boolean;
+    viewport?: {
+        width: number;
+        height: number;
+        deviceScaleFactor?: number;
+    };
+}
+export declare function launchHeadlessBrowser(opts: LaunchHeadlessOptions): Promise<Browser>;
+export declare function applyViewport(page: Page, viewport?: {
+    width: number;
+    height: number;
+    deviceScaleFactor?: number;
+}): Promise<void>;
+export interface UserAgentOverride {
+    userAgent: string;
+    platform: string;
+    acceptLanguage: string;
+    userAgentMetadata: {
+        brands: Array<{
+            brand: string;
+            version: string;
+        }>;
+        fullVersion: string;
+        fullVersionList: Array<{
+            brand: string;
+            version: string;
+        }>;
+        platform: string;
+        platformVersion: string;
+        architecture: string;
+        bitness: string;
+        model: string;
+        mobile: boolean;
+    };
+}
+export interface UserAgentSession {
+    override: UserAgentOverride;
+    browserSession: CDPSession | null;
+}
+/** Builds the browser-page stealth bootstrap source for regression tests. */
+export declare function buildStealthInjectionScriptForTest(scripts?: readonly string[]): string;
+/** Apply stealth patches + UA override to a headless page. Idempotent within a tab. */
+export declare function applyStealthPatches(browser: Browser, page: Page, state: {
+    browserSession: CDPSession | null;
+    override: UserAgentOverride | null;
+}): Promise<void>;
+export declare function targetSupportsUserAgentOverrideForTest(target: Target): boolean;
+export declare function configureUserAgentTargetsForTest(browser: Browser, state: {
+    browserSession: CDPSession | null;
+    override: UserAgentOverride;
+}, targetTimeoutMs?: number): Promise<void>;

package/dist/types/tools/browser/readable.d.ts

@@ -0,0 +1,17 @@
+export type ReadableFormat = "text" | "markdown";
+export interface ReadableResult {
+    url: string;
+    title?: string;
+    byline?: string;
+    excerpt?: string;
+    contentLength: number;
+    text?: string;
+    markdown?: string;
+}
+/**
+ * Extract readable content from raw HTML.
+ * Tries Readability (article-isolation scoring) first, then falls back to a
+ * CSS selector chain over the same pre-parsed DOM. Returns null if neither
+ * path yields usable content.
+ */
+export declare function extractReadableFromHtml(html: string, url: string, format: ReadableFormat): Promise<ReadableResult | null>;