local-browser-bridge 0.1.0

package/dist/src/browser-attach-ux-helper.d.ts

@@ -0,0 +1,39 @@
+import { type ChromeRelayFailureInterpretation } from "./chrome-relay-error-helper";
+/**
+ * Stable consumer utility for mapping diagnostics, sessions, and structured
+ * relay failures into a small attach/resume UX interpretation surface.
+ */
+import type { AttachmentSession, BrowserAttachMode, BrowserAttachReadinessState, BrowserDiagnostics, ChromeRelayErrorDetails, ChromeRelayFailureOperation, SupportedBrowser } from "./types";
+export type BrowserAttachUxState = "ready" | "blocked" | "attached" | "resumed" | "user-action-required" | "retryable-failure" | "non-retryable-failure";
+export interface BrowserAttachUxInterpretation {
+    state: BrowserAttachUxState;
+    browser: SupportedBrowser;
+    attachMode: BrowserAttachMode;
+    operation: ChromeRelayFailureOperation;
+    label: string;
+    readOnly: boolean;
+    sharedTabScoped: boolean;
+    readiness: BrowserAttachReadinessState | "ready" | undefined;
+    prompt: string | undefined;
+    scopeNote: string | undefined;
+    retryGuidance: string | undefined;
+    retryable: boolean | undefined;
+    userActionRequired: boolean | undefined;
+    relayFailureCategory: ChromeRelayFailureInterpretation["category"] | undefined;
+}
+export declare function interpretBrowserAttachUxFromDiagnostics(args: {
+    browser: SupportedBrowser;
+    attachMode: BrowserAttachMode;
+    diagnostics: BrowserDiagnostics;
+    operation?: ChromeRelayFailureOperation;
+}): BrowserAttachUxInterpretation;
+export declare function interpretBrowserAttachUxFromSession(args: {
+    session: Pick<AttachmentSession, "browser" | "attach" | "status" | "kind" | "semantics">;
+    operation?: ChromeRelayFailureOperation;
+}): BrowserAttachUxInterpretation;
+export declare function interpretBrowserAttachUxFromError(args: {
+    details: ChromeRelayErrorDetails | Pick<ChromeRelayErrorDetails, "relay"> | null | undefined;
+    browser?: SupportedBrowser;
+    attachMode?: BrowserAttachMode;
+    operation?: ChromeRelayFailureOperation;
+}): BrowserAttachUxInterpretation | undefined;

package/dist/src/browser-attach-ux-helper.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interpretBrowserAttachUxFromDiagnostics = interpretBrowserAttachUxFromDiagnostics;
+exports.interpretBrowserAttachUxFromSession = interpretBrowserAttachUxFromSession;
+exports.interpretBrowserAttachUxFromError = interpretBrowserAttachUxFromError;
+const chrome_relay_error_helper_1 = require("./chrome-relay-error-helper");
+function labelFor(browser, attachMode) {
+    if (browser === "safari") {
+        return "Safari (actionable)";
+    }
+    if (attachMode === "relay") {
+        return "Chrome (shared tab, read-only)";
+    }
+    return "Chrome (direct, read-only)";
+}
+function isReadOnly(browser, attachMode) {
+    return browser === "chrome" || attachMode === "relay";
+}
+function isSharedTabScoped(browser, attachMode) {
+    return browser === "chrome" && attachMode === "relay";
+}
+function firstBlockerPrompt(blockers) {
+    const first = blockers[0]?.code;
+    if (!first) {
+        return undefined;
+    }
+    switch (first) {
+        case "automation_permission_denied":
+            return "Safari needs macOS Automation permission before I can control tabs. Grant access, then try again.";
+        case "screen_recording_permission_denied":
+            return "Safari screenshots also require Screen Recording permission on this Mac.";
+        case "browser_not_running":
+            return "Safari is not open yet. Open Safari with a normal tab, then retry.";
+        case "browser_no_windows":
+            return "Safari has no open browser windows yet. Open a normal Safari window, then retry.";
+        case "browser_no_tabs":
+            return "Safari has open windows, but there is no normal inspectable tab yet. Focus or open a regular Safari tab, then retry.";
+        case "direct_unavailable_attach_endpoint_missing":
+            return "Chrome direct attach needs a local DevTools endpoint that is already available on this machine. Once Chrome is running in that mode, I can inspect tabs in read-only mode.";
+        case "relay_toolbar_not_clicked":
+            return "To connect this Chrome tab, click the relay extension button on the tab you want to share.";
+        case "relay_share_required":
+            return "Chrome relay only works for a tab you explicitly share. Share the tab first, then retry.";
+        case "relay_no_shared_tab":
+            return "Chrome relay is connected, but there is no shared tab right now. Share the target tab, then retry.";
+        case "relay_attach_scope_expired":
+            return "That shared-tab grant is no longer active. Click the relay extension again on the original tab, then retry resume.";
+        default:
+            return blockers[0]?.message;
+    }
+}
+function interpretBrowserAttachUxFromDiagnostics(args) {
+    const operation = args.operation ?? "attach";
+    const label = labelFor(args.browser, args.attachMode);
+    const readOnly = isReadOnly(args.browser, args.attachMode);
+    const sharedTabScoped = isSharedTabScoped(args.browser, args.attachMode);
+    if (args.browser === "safari") {
+        const blockers = [
+            ...(args.diagnostics.preflight?.inspect.blockers ?? []),
+            ...(args.diagnostics.preflight?.automation.blockers ?? [])
+        ];
+        const ready = Boolean(args.diagnostics.preflight?.inspect.ready && args.diagnostics.preflight?.automation.ready);
+        return {
+            state: ready ? "ready" : "blocked",
+            browser: args.browser,
+            attachMode: args.attachMode,
+            operation,
+            label,
+            readOnly,
+            sharedTabScoped,
+            readiness: ready ? "ready" : "unavailable",
+            prompt: firstBlockerPrompt([
+                ...blockers,
+                ...(args.diagnostics.preflight?.screenshot.blockers ?? [])
+            ]),
+            scopeNote: undefined,
+            retryGuidance: undefined,
+            retryable: undefined,
+            userActionRequired: undefined,
+            relayFailureCategory: undefined
+        };
+    }
+    const modeDiagnostics = args.attachMode === "relay" ? args.diagnostics.attach?.relay : args.diagnostics.attach?.direct;
+    return {
+        state: modeDiagnostics?.ready ? "ready" : "blocked",
+        browser: args.browser,
+        attachMode: args.attachMode,
+        operation,
+        label,
+        readOnly,
+        sharedTabScoped,
+        readiness: modeDiagnostics?.state ?? "unavailable",
+        prompt: firstBlockerPrompt(modeDiagnostics?.blockers ?? []),
+        scopeNote: sharedTabScoped ? "Scope note: Chrome relay is still limited to the currently shared tab and remains read-only." : undefined,
+        retryGuidance: undefined,
+        retryable: undefined,
+        userActionRequired: undefined,
+        relayFailureCategory: undefined
+    };
+}
+function interpretBrowserAttachUxFromSession(args) {
+    const operation = args.operation ?? "attach";
+    const { session } = args;
+    const label = labelFor(session.browser, session.attach.mode);
+    const sharedTabScoped = session.browser === "chrome" && session.attach.mode === "relay";
+    return {
+        state: operation === "resumeSession" ? "resumed" : "attached",
+        browser: session.browser,
+        attachMode: session.attach.mode,
+        operation,
+        label,
+        readOnly: session.status.state === "read-only",
+        sharedTabScoped,
+        readiness: undefined,
+        prompt: sharedTabScoped && session.attach.resumeRequiresUserGesture
+            ? "That shared-tab grant is no longer active. Click the relay extension again on the original tab, then retry resume."
+            : undefined,
+        scopeNote: sharedTabScoped || session.semantics.inspect === "shared-tab-only"
+            ? "Scope note: Chrome relay is still limited to the currently shared tab and remains read-only."
+            : undefined,
+        retryGuidance: undefined,
+        retryable: session.attach.resumable,
+        userActionRequired: session.attach.resumeRequiresUserGesture,
+        relayFailureCategory: undefined
+    };
+}
+function interpretBrowserAttachUxFromError(args) {
+    const interpretation = (0, chrome_relay_error_helper_1.interpretChromeRelayFailure)(args.details);
+    if (!interpretation) {
+        return undefined;
+    }
+    const browser = args.browser ?? "chrome";
+    const attachMode = args.attachMode ?? "relay";
+    const operation = args.operation ??
+        (args.details && "context" in args.details ? args.details.context.operation : undefined) ??
+        "attach";
+    return {
+        state: interpretation.userActionRequired
+            ? "user-action-required"
+            : interpretation.retryable === false
+                ? "non-retryable-failure"
+                : "retryable-failure",
+        browser,
+        attachMode,
+        operation,
+        label: labelFor(browser, attachMode),
+        readOnly: interpretation.readOnly,
+        sharedTabScoped: interpretation.scopeLimitedToCurrentSharedTab,
+        readiness: undefined,
+        prompt: (0, chrome_relay_error_helper_1.chromeRelayBranchPrompt)(interpretation.branch),
+        scopeNote: (0, chrome_relay_error_helper_1.chromeRelayScopeNote)(interpretation),
+        retryGuidance: (0, chrome_relay_error_helper_1.chromeRelayRetryGuidance)(interpretation),
+        retryable: interpretation.retryable,
+        userActionRequired: interpretation.userActionRequired,
+        relayFailureCategory: interpretation.category,
+    };
+}

package/dist/src/capabilities.d.ts

@@ -0,0 +1,3 @@
+import type { BridgeCapabilitiesContract, BrowserCapabilityDescriptor, SupportedBrowser } from "./types";
+export declare function getBrowserCapabilityDescriptor(browser: SupportedBrowser): BrowserCapabilityDescriptor;
+export declare function getBridgeCapabilities(browser?: SupportedBrowser): BridgeCapabilitiesContract;

package/dist/src/capabilities.js

@@ -0,0 +1,182 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBrowserCapabilityDescriptor = getBrowserCapabilityDescriptor;
+exports.getBridgeCapabilities = getBridgeCapabilities;
+const package_json_1 = __importDefault(require("../package.json"));
+const CONTRACT_SCHEMA_PATH = "schema/capabilities.schema.json";
+const PRODUCT_MANIFESTO_PATH = "docs/product-direction.md";
+function buildBrowserCapabilities(browser) {
+    if (browser === "safari") {
+        return {
+            kind: "safari-actionable",
+            browser: "safari",
+            adapter: "SafariAdapter",
+            available: true,
+            maturity: "primary",
+            platforms: ["macos"],
+            bridge: {
+                browserNative: false,
+                implementation: "macos Apple Events via osascript/JXA plus screencapture"
+            },
+            targeting: {
+                modes: ["front", "indexed", "signature"],
+                sessionResumeStrategies: ["front", "indexed", "signature", "url_title", "url", "last_known_index"]
+            },
+            operations: {
+                capabilities: true,
+                diagnostics: true,
+                inspectFrontTab: true,
+                inspectTab: true,
+                listTabs: true,
+                attach: true,
+                resumeSession: true,
+                activate: true,
+                navigate: true,
+                screenshot: true
+            },
+            attachModes: [
+                {
+                    mode: "direct",
+                    source: "user-browser",
+                    scope: "browser",
+                    supported: true,
+                    readiness: "ready"
+                }
+            ],
+            transports: {
+                cli: true,
+                http: true
+            },
+            constraints: [
+                "Safari automation depends on macOS Apple Events permissions.",
+                "Screenshots depend on macOS screen recording permissions.",
+                "Activation, navigation, and screenshot capture visibly focus Safari."
+            ]
+        };
+    }
+    if (browser === "chrome") {
+        return {
+            kind: "chrome-readonly",
+            browser: "chrome",
+            adapter: "ChromeAdapter",
+            available: true,
+            maturity: "experimental-readonly",
+            platforms: ["macos"],
+            bridge: {
+                browserNative: true,
+                implementation: "Chrome/Chromium inspection over an existing local DevTools endpoint; read-only in v1"
+            },
+            targeting: {
+                modes: ["front", "indexed", "signature"],
+                sessionResumeStrategies: [
+                    "front",
+                    "indexed",
+                    "native_identity",
+                    "signature",
+                    "url_title",
+                    "url",
+                    "last_known_index"
+                ]
+            },
+            operations: {
+                capabilities: true,
+                diagnostics: true,
+                inspectFrontTab: true,
+                inspectTab: true,
+                listTabs: true,
+                attach: true,
+                resumeSession: true,
+                activate: false,
+                navigate: false,
+                screenshot: false
+            },
+            attachModes: [
+                {
+                    mode: "direct",
+                    source: "user-browser",
+                    scope: "browser",
+                    supported: true,
+                    readiness: "degraded"
+                },
+                {
+                    mode: "relay",
+                    source: "extension-relay",
+                    scope: "tab",
+                    supported: true,
+                    readiness: "unavailable"
+                }
+            ],
+            transports: {
+                cli: true,
+                http: true
+            },
+            constraints: [
+                "Chrome/Chromium inspection currently requires an already-running local DevTools HTTP endpoint.",
+                "This adapter is read-only in this phase: attach and saved-session resume work for inspectable targets, but activate/navigate/screenshot do not.",
+                "If no debugging endpoint is discoverable, inspection returns a clear unavailable error and diagnostics enumerate the attempted sources.",
+                "Chrome attach-mode metadata distinguishes direct user-browser attach from future extension relay attach without changing the current read-only behavior model."
+            ]
+        };
+    }
+    throw new Error(`Unsupported browser capability descriptor: ${browser}`);
+}
+function getBrowserCapabilityDescriptor(browser) {
+    return buildBrowserCapabilities(browser);
+}
+function getBridgeCapabilities(browser) {
+    const browsers = browser
+        ? [getBrowserCapabilityDescriptor(browser)]
+        : [getBrowserCapabilityDescriptor("safari"), getBrowserCapabilityDescriptor("chrome")];
+    return {
+        schemaVersion: 1,
+        schema: {
+            path: CONTRACT_SCHEMA_PATH,
+            version: "1.0.0"
+        },
+        generatedAt: new Date().toISOString(),
+        product: {
+            name: package_json_1.default.name,
+            displayName: "local-browser-bridge",
+            version: package_json_1.default.version,
+            summary: "Reusable, agent-agnostic local browser bridge with honest capability signaling. Safari is actionable; Chrome/Chromium is read-only in v1.",
+            direction: {
+                localOnly: true,
+                agentAgnostic: true,
+                browserStrategy: "safari-first",
+                architectureStrategy: "bridge-first"
+            },
+            manifestoPath: PRODUCT_MANIFESTO_PATH
+        },
+        transports: {
+            cli: {
+                available: true,
+                format: "json",
+                binary: "local-browser-bridge",
+                aliasBinaries: ["safari-attach-tool"],
+                command: "local-browser-bridge capabilities [--browser safari|chrome]"
+            },
+            http: {
+                available: true,
+                format: "json",
+                baseUrl: "http://127.0.0.1:3000",
+                capabilitiesPath: "/v1/capabilities"
+            }
+        },
+        targeting: {
+            modes: ["front", "indexed", "signature"],
+            sessionResumeStrategies: [
+                "front",
+                "indexed",
+                "native_identity",
+                "signature",
+                "url_title",
+                "url",
+                "last_known_index"
+            ]
+        },
+        browsers
+    };
+}

package/dist/src/chrome-relay-error-helper.d.ts

@@ -0,0 +1,19 @@
+import type { ChromeRelayErrorDetails, ChromeRelayFailureBranch, ChromeRelaySharedTabScope } from "./types";
+/**
+ * Stable consumer utility for interpreting additive Chrome relay failure details
+ * into a transport-neutral branching shape.
+ */
+export type ChromeRelayFailureCategory = "share-required" | "user-action-required" | "retryable-relay-failure" | "non-retryable-relay-failure" | "shared-tab-read-only-scope-limitation";
+export interface ChromeRelayFailureInterpretation {
+    category: ChromeRelayFailureCategory;
+    retryable: boolean | undefined;
+    userActionRequired: boolean | undefined;
+    branch: ChromeRelayFailureBranch | undefined;
+    sharedTabScope: ChromeRelaySharedTabScope | undefined;
+    scopeLimitedToCurrentSharedTab: boolean;
+    readOnly: true;
+}
+export declare function interpretChromeRelayFailure(details: Pick<ChromeRelayErrorDetails, "relay"> | ChromeRelayErrorDetails | null | undefined): ChromeRelayFailureInterpretation | undefined;
+export declare function chromeRelayBranchPrompt(branch: ChromeRelayFailureBranch | undefined): string | undefined;
+export declare function chromeRelayRetryGuidance(interpretation: Pick<ChromeRelayFailureInterpretation, "retryable" | "userActionRequired"> | null | undefined): string | undefined;
+export declare function chromeRelayScopeNote(interpretation: Pick<ChromeRelayFailureInterpretation, "scopeLimitedToCurrentSharedTab"> | null | undefined): string | undefined;

package/dist/src/chrome-relay-error-helper.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interpretChromeRelayFailure = interpretChromeRelayFailure;
+exports.chromeRelayBranchPrompt = chromeRelayBranchPrompt;
+exports.chromeRelayRetryGuidance = chromeRelayRetryGuidance;
+exports.chromeRelayScopeNote = chromeRelayScopeNote;
+function categoryFromRelay(relay) {
+    if (relay.branch === "share-tab" || relay.branch === "share-original-tab-again") {
+        return "share-required";
+    }
+    if (relay.branch === "use-current-shared-tab") {
+        return "shared-tab-read-only-scope-limitation";
+    }
+    if (relay.userActionRequired) {
+        return "user-action-required";
+    }
+    if (relay.retryable === false) {
+        return "non-retryable-relay-failure";
+    }
+    return "retryable-relay-failure";
+}
+function interpretChromeRelayFailure(details) {
+    const relay = details?.relay;
+    if (!relay) {
+        return undefined;
+    }
+    return {
+        category: categoryFromRelay(relay),
+        retryable: relay.retryable,
+        userActionRequired: relay.userActionRequired,
+        branch: relay.branch,
+        sharedTabScope: relay.sharedTabScope,
+        scopeLimitedToCurrentSharedTab: relay.sharedTabScope === "current-shared-tab",
+        readOnly: true
+    };
+}
+function chromeRelayBranchPrompt(branch) {
+    switch (branch) {
+        case "click-toolbar-button":
+            return "To connect this Chrome tab, click the relay extension button on the tab you want to share.";
+        case "share-tab":
+            return "Chrome relay only works for a tab you explicitly share. Share the tab first, then retry.";
+        case "share-original-tab-again":
+            return "That shared-tab grant is no longer active. Click the relay extension again on the original tab, then retry resume.";
+        case "use-current-shared-tab":
+            return "Chrome relay attach only works for the tab that is currently shared. Use the shared tab or share a different tab first.";
+        case "install-extension":
+            return "Install the Chrome relay extension on this machine, then retry.";
+        case "reconnect-extension":
+            return "Reconnect or re-enable the Chrome relay extension, then retry.";
+        case "configure-relay-probe":
+            return "Configure a local Chrome relay state probe for this bridge instance before using relay attach.";
+        case "repair-relay-probe":
+            return "Fix the local Chrome relay state file so it is valid JSON again, then retry.";
+        default:
+            return undefined;
+    }
+}
+function chromeRelayRetryGuidance(interpretation) {
+    if (!interpretation) {
+        return undefined;
+    }
+    if (interpretation.retryable === false) {
+        return "Retry guidance: Stop automatic retries and surface the relay failure directly.";
+    }
+    if (interpretation.retryable === true) {
+        return interpretation.userActionRequired
+            ? "Retry guidance: Wait for the user action to complete, then retry the same relay path."
+            : "Retry guidance: A targeted retry on the same relay path is reasonable.";
+    }
+    return undefined;
+}
+function chromeRelayScopeNote(interpretation) {
+    if (!interpretation?.scopeLimitedToCurrentSharedTab) {
+        return undefined;
+    }
+    return "Scope note: Chrome relay is still limited to the currently shared tab and remains read-only.";
+}

package/dist/src/chrome-relay-helper-cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function runChromeRelayHelperCli(args: string[]): Promise<void>;

package/dist/src/chrome-relay-helper-cli.js

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runChromeRelayHelperCli = runChromeRelayHelperCli;
+const errors_1 = require("./errors");
+const chrome_relay_helper_1 = require("./chrome-relay-helper");
+const SUPPORTED_FLOWS = [
+    "extension-missing",
+    "disconnected",
+    "click-required",
+    "share-required",
+    "shared-tab",
+    "expired-share",
+    "clear-shared-tab"
+];
+function printUsage() {
+    process.stdout.write([
+        "Usage:",
+        "  local-browser-bridge-chrome-relay <flow> [--output <path>] [--tab-id <id>] [--url <url>] [--title <title>]",
+        "      [--updated-at <iso>] [--expires-at <iso>] [--version <version>]",
+        "      [--resumable true|false] [--resume-requires-user-gesture true|false]",
+        "",
+        `Flows: ${SUPPORTED_FLOWS.join(", ")}`,
+        "",
+        `Default output path order: --output, ${chrome_relay_helper_1.CHROME_RELAY_STATE_PATH_ENV}, ${(0, chrome_relay_helper_1.getDefaultChromeRelayStateOutputPath)()}`,
+        `Bridge also reads: ${(0, chrome_relay_helper_1.getHomeChromeRelayStateOutputPath)()}`,
+        "",
+        "Examples:",
+        "  local-browser-bridge-chrome-relay extension-missing",
+        "  local-browser-bridge-chrome-relay click-required --output ./.local-browser-bridge/chrome-relay-state.json",
+        "  local-browser-bridge-chrome-relay shared-tab --tab-id relay-42 --title \"Shared Docs\" --url https://example.com/docs",
+        "  local-browser-bridge-chrome-relay expired-share --tab-id relay-42 --url https://example.com/docs",
+        "  local-browser-bridge-chrome-relay clear-shared-tab"
+    ].join("\n") + "\n");
+}
+function readFlag(args, name) {
+    const index = args.indexOf(name);
+    if (index === -1) {
+        return undefined;
+    }
+    return args[index + 1];
+}
+function readBooleanFlag(args, name) {
+    const raw = readFlag(args, name)?.trim();
+    if (raw === undefined) {
+        return undefined;
+    }
+    if (raw === "true") {
+        return true;
+    }
+    if (raw === "false") {
+        return false;
+    }
+    throw new errors_1.AppError(`${name} must be true or false.`, 400, "invalid_boolean_flag");
+}
+function readFlow(raw) {
+    if (raw && SUPPORTED_FLOWS.includes(raw)) {
+        return raw;
+    }
+    throw new errors_1.AppError(`Flow must be one of: ${SUPPORTED_FLOWS.join(", ")}.`, 400, "invalid_relay_flow");
+}
+async function runChromeRelayHelperCli(args) {
+    const command = args[0];
+    if (!command || command === "--help" || command === "-h") {
+        printUsage();
+        return;
+    }
+    const result = await (0, chrome_relay_helper_1.writeChromeRelayFixtureState)({
+        flow: readFlow(command),
+        outputPath: readFlag(args, "--output"),
+        version: readFlag(args, "--version"),
+        updatedAt: readFlag(args, "--updated-at"),
+        expiresAt: readFlag(args, "--expires-at"),
+        tabId: readFlag(args, "--tab-id"),
+        url: readFlag(args, "--url"),
+        title: readFlag(args, "--title"),
+        resumable: readBooleanFlag(args, "--resumable"),
+        resumeRequiresUserGesture: readBooleanFlag(args, "--resume-requires-user-gesture")
+    });
+    (0, errors_1.writeJsonLine)(process.stdout, {
+        ok: true,
+        helper: "local-browser-bridge-chrome-relay",
+        flow: result.flow,
+        path: result.path,
+        state: result.state
+    });
+}
+async function main() {
+    await runChromeRelayHelperCli(process.argv.slice(2));
+}
+if (require.main === module) {
+    main().catch((error) => {
+        const { payload } = (0, errors_1.toErrorPayload)(error);
+        (0, errors_1.writeJsonLine)(process.stderr, payload);
+        process.exitCode = 1;
+    });
+}

package/dist/src/chrome-relay-helper.d.ts

@@ -0,0 +1,29 @@
+import { type ChromeRelayStateProbe } from "./chrome-relay-state";
+export declare const CHROME_RELAY_STATE_PATH_ENV = "LOCAL_BROWSER_BRIDGE_CHROME_RELAY_STATE_PATH";
+export type ChromeRelayFixtureFlow = "extension-missing" | "disconnected" | "click-required" | "share-required" | "shared-tab" | "expired-share" | "clear-shared-tab";
+export interface BuildChromeRelayFixtureOptions {
+    flow: ChromeRelayFixtureFlow;
+    version?: string;
+    updatedAt?: string;
+    tabId?: string;
+    url?: string;
+    title?: string;
+    expiresAt?: string;
+    resumable?: boolean;
+    resumeRequiresUserGesture?: boolean;
+}
+export interface ChromeRelayWriteResult {
+    flow: ChromeRelayFixtureFlow;
+    path: string;
+    state: ChromeRelayStateProbe;
+}
+export declare function getDefaultChromeRelayStateOutputPath(): string;
+export declare function getHomeChromeRelayStateOutputPath(): string;
+export declare function resolveChromeRelayStateOutputPath(explicitPath?: string): string;
+export declare function buildChromeRelayFixtureState(options: BuildChromeRelayFixtureOptions): ChromeRelayStateProbe;
+export declare function writeChromeRelayStateSnapshot(state: ChromeRelayStateProbe, options?: {
+    outputPath?: string;
+}): Promise<string>;
+export declare function writeChromeRelayFixtureState(options: BuildChromeRelayFixtureOptions & {
+    outputPath?: string;
+}): Promise<ChromeRelayWriteResult>;