@elizaos/agent 2.0.0-alpha.173 → 2.0.0-alpha.192

package/packages/agent/src/services/browser-workspace-forms.js

@@ -0,0 +1,244 @@
+import { buildBrowserWorkspaceElementSelector, findClosestBrowserWorkspaceForm, } from "./browser-workspace-elements.js";
+import { assertBrowserWorkspaceUrl, inferBrowserWorkspaceTitle, normalizeBrowserWorkspaceText, } from "./browser-workspace-helpers.js";
+import { ensureBrowserWorkspaceDom, getJSDOMClass, installBrowserWorkspaceWebRuntime, } from "./browser-workspace-jsdom.js";
+import { fetchBrowserWorkspaceTrackedResponse } from "./browser-workspace-network.js";
+import { getBrowserWorkspaceRuntimeState, getBrowserWorkspaceTimestamp, resetBrowserWorkspaceRuntimeNavigationState, } from "./browser-workspace-state.js";
+export function ensureBrowserWorkspaceFormControlElement(element, subaction) {
+    if (element.tagName === "INPUT" ||
+        element.tagName === "TEXTAREA" ||
+        element.tagName === "SELECT") {
+        return element;
+    }
+    throw new Error(`Eliza browser workspace ${subaction} requires an input, textarea, or select target.`);
+}
+export function ensureBrowserWorkspaceCheckboxElement(element, subaction) {
+    if (element.tagName === "INPUT") {
+        const input = element;
+        const type = input.type.trim().toLowerCase();
+        if (type === "checkbox" || type === "radio") {
+            return input;
+        }
+    }
+    throw new Error(`Eliza browser workspace ${subaction} requires a checkbox or radio input target.`);
+}
+export function setBrowserWorkspaceControlValue(control, nextValue) {
+    control.value = nextValue;
+    if (control.tagName === "TEXTAREA") {
+        control.textContent = nextValue;
+    }
+    control.setAttribute("value", nextValue);
+}
+export async function activateWebBrowserWorkspaceElement(tab, element, subaction) {
+    const tag = element.tagName.toLowerCase();
+    if (tag === "a") {
+        const href = element.getAttribute("href")?.trim();
+        if (!href) {
+            throw new Error("Target link does not have an href.");
+        }
+        const nextUrl = new URL(href, tab.url).toString();
+        clearWebBrowserWorkspaceTabElementRefs(tab.id);
+        tab.url = assertBrowserWorkspaceUrl(nextUrl);
+        tab.title = inferBrowserWorkspaceTitle(tab.url);
+        tab.dom = null;
+        tab.loadedUrl = null;
+        pushWebBrowserWorkspaceHistory(tab, tab.url);
+        await loadWebBrowserWorkspaceTabDocument(tab);
+        return {
+            mode: "web",
+            subaction,
+            tab: cloneWebBrowserWorkspaceTabState(tab),
+            value: {
+                clickCount: subaction === "dblclick" ? 2 : 1,
+                selector: buildBrowserWorkspaceElementSelector(element),
+                url: tab.url,
+            },
+        };
+    }
+    const inputElement = tag === "input" ? element : null;
+    const inputType = inputElement?.type?.toLowerCase() ?? "";
+    if (inputElement && (inputType === "checkbox" || inputType === "radio")) {
+        inputElement.checked = inputType === "radio" ? true : !inputElement.checked;
+        return {
+            mode: "web",
+            subaction,
+            value: {
+                checked: inputElement.checked,
+                clickCount: subaction === "dblclick" ? 2 : 1,
+                selector: buildBrowserWorkspaceElementSelector(element),
+            },
+        };
+    }
+    const submitForm = findClosestBrowserWorkspaceForm(element);
+    if (submitForm &&
+        (tag === "form" ||
+            tag === "button" ||
+            (tag === "input" &&
+                ["button", "image", "submit"].includes(inputType || "submit")))) {
+        await submitWebBrowserWorkspaceForm(tab, submitForm);
+        return {
+            mode: "web",
+            subaction,
+            tab: cloneWebBrowserWorkspaceTabState(tab),
+            value: {
+                clickCount: subaction === "dblclick" ? 2 : 1,
+                selector: buildBrowserWorkspaceElementSelector(element),
+                url: tab.url,
+            },
+        };
+    }
+    return {
+        mode: "web",
+        subaction,
+        value: {
+            clickCount: subaction === "dblclick" ? 2 : 1,
+            selector: buildBrowserWorkspaceElementSelector(element),
+            text: normalizeBrowserWorkspaceText(element.textContent),
+        },
+    };
+}
+export function scrollWebBrowserWorkspaceTarget(dom, element, direction, pixels) {
+    const resolvedPixels = Number.isFinite(pixels)
+        ? Math.max(1, Math.abs(pixels))
+        : 240;
+    const axis = direction === "left" || direction === "right" ? "x" : "y";
+    const delta = direction === "up" || direction === "left"
+        ? -resolvedPixels
+        : resolvedPixels;
+    if (element && element instanceof dom.window.HTMLElement) {
+        if (axis === "y") {
+            element.scrollTop = (element.scrollTop || 0) + delta;
+            return {
+                axis,
+                selector: buildBrowserWorkspaceElementSelector(element),
+                value: element.scrollTop,
+            };
+        }
+        element.scrollLeft = (element.scrollLeft || 0) + delta;
+        return {
+            axis,
+            selector: buildBrowserWorkspaceElementSelector(element),
+            value: element.scrollLeft,
+        };
+    }
+    const key = axis === "y" ? "__elizaScrollY" : "__elizaScrollX";
+    const current = Number(dom.window[key] ?? 0);
+    const next = current + delta;
+    dom.window[key] = next;
+    return {
+        axis,
+        selector: null,
+        value: next,
+    };
+}
+export async function submitWebBrowserWorkspaceForm(tab, form) {
+    const state = getBrowserWorkspaceRuntimeState("web", tab.id);
+    const dom = ensureBrowserWorkspaceDom(tab);
+    const action = form.getAttribute("action")?.trim() || tab.url;
+    const method = (form.getAttribute("method")?.trim() || "get").toLowerCase();
+    const submitUrl = new URL(action, tab.url).toString();
+    const formData = new dom.window.FormData(form);
+    const searchParams = new URLSearchParams();
+    for (const [key, value] of formData.entries()) {
+        searchParams.append(key, String(value));
+    }
+    if (method === "get") {
+        const nextUrl = new URL(submitUrl);
+        nextUrl.search = searchParams.toString();
+        clearWebBrowserWorkspaceTabElementRefs(tab.id);
+        tab.url = nextUrl.toString();
+        tab.title = inferBrowserWorkspaceTitle(tab.url);
+        tab.dom = null;
+        tab.loadedUrl = null;
+        pushWebBrowserWorkspaceHistory(tab, tab.url);
+        await loadWebBrowserWorkspaceTabDocument(tab);
+        return;
+    }
+    const response = await fetchBrowserWorkspaceTrackedResponse(state, submitUrl, {
+        body: searchParams.toString(),
+        headers: {
+            "Content-Type": "application/x-www-form-urlencoded; charset=utf-8",
+        },
+        method: method.toUpperCase(),
+    }, "document");
+    if (!response.ok) {
+        throw new Error(`Browser workspace form submit failed (${response.status}): ${submitUrl}`);
+    }
+    const html = await response.text();
+    const finalUrl = assertBrowserWorkspaceUrl(response.url?.trim() || submitUrl);
+    const nextDom = new (getJSDOMClass())(html, {
+        pretendToBeVisual: true,
+        url: finalUrl,
+    });
+    installBrowserWorkspaceWebRuntime(tab, nextDom);
+    resetBrowserWorkspaceRuntimeNavigationState(state);
+    clearWebBrowserWorkspaceTabElementRefs(tab.id);
+    tab.url = finalUrl;
+    tab.dom = nextDom;
+    tab.loadedUrl = finalUrl;
+    tab.title =
+        normalizeBrowserWorkspaceText(nextDom.window.document.title) ||
+            inferBrowserWorkspaceTitle(finalUrl);
+    tab.updatedAt = getBrowserWorkspaceTimestamp();
+    pushWebBrowserWorkspaceHistory(tab, finalUrl);
+}
+// --- Web tab helpers that forms/activation need ---
+import { clearBrowserWorkspaceElementRefs } from "./browser-workspace-state.js";
+export function clearWebBrowserWorkspaceTabElementRefs(tabId) {
+    clearBrowserWorkspaceElementRefs("web", tabId);
+}
+export function cloneWebBrowserWorkspaceTabState(tab) {
+    return {
+        id: tab.id,
+        title: tab.title,
+        url: tab.url,
+        partition: tab.partition,
+        visible: tab.visible,
+        createdAt: tab.createdAt,
+        updatedAt: tab.updatedAt,
+        lastFocusedAt: tab.lastFocusedAt,
+    };
+}
+export function pushWebBrowserWorkspaceHistory(tab, nextUrl) {
+    const nextHistory = tab.history.slice(0, tab.historyIndex + 1);
+    nextHistory.push(nextUrl);
+    tab.history = nextHistory;
+    tab.historyIndex = nextHistory.length - 1;
+}
+export async function loadWebBrowserWorkspaceTabDocument(tab) {
+    const state = getBrowserWorkspaceRuntimeState("web", tab.id);
+    const { createEmptyWebBrowserWorkspaceDom } = await import("./browser-workspace-jsdom.js");
+    if (tab.url === "about:blank") {
+        tab.dom = createEmptyWebBrowserWorkspaceDom(tab.url);
+        installBrowserWorkspaceWebRuntime(tab, tab.dom);
+        tab.loadedUrl = tab.url;
+        tab.title = "New Tab";
+        tab.updatedAt = getBrowserWorkspaceTimestamp();
+        return;
+    }
+    const response = await fetchBrowserWorkspaceTrackedResponse(state, tab.url, {}, "document");
+    if (!response.ok) {
+        throw new Error(`Browser workspace web load failed (${response.status}): ${tab.url}`);
+    }
+    const html = await response.text();
+    const finalUrl = assertBrowserWorkspaceUrl(response.url?.trim() || tab.url);
+    const dom = new (getJSDOMClass())(html, {
+        pretendToBeVisual: true,
+        url: finalUrl,
+    });
+    installBrowserWorkspaceWebRuntime(tab, dom);
+    resetBrowserWorkspaceRuntimeNavigationState(state);
+    tab.dom = dom;
+    tab.loadedUrl = finalUrl;
+    tab.url = finalUrl;
+    tab.title =
+        normalizeBrowserWorkspaceText(dom.window.document.title) ||
+            inferBrowserWorkspaceTitle(finalUrl);
+    tab.updatedAt = getBrowserWorkspaceTimestamp();
+    tab.history[tab.historyIndex] = finalUrl;
+}
+export async function ensureLoadedWebBrowserWorkspaceTabDocument(tab) {
+    if (!tab.dom || tab.loadedUrl !== tab.url) {
+        await loadWebBrowserWorkspaceTabDocument(tab);
+    }
+    return ensureBrowserWorkspaceDom(tab);
+}

package/packages/agent/src/services/browser-workspace-helpers.d.ts

@@ -0,0 +1,20 @@
+import type { BrowserWorkspaceCommand, BrowserWorkspaceMode, BrowserWorkspaceSubaction } from "./browser-workspace-types.js";
+export declare const DEFAULT_TIMEOUT_MS = 12000;
+export declare const DEFAULT_WAIT_INTERVAL_MS = 120;
+export declare const DEFAULT_WEB_PARTITION = "persist:eliza-browser";
+export declare const DESKTOP_BRIDGE_UNAVAILABLE_MESSAGE = "Eliza browser workspace desktop bridge is unavailable.";
+export declare const browserWorkspacePageFetch: any;
+export declare function normalizeEnvValue(value: string | undefined): string | null;
+export declare function normalizeBrowserWorkspaceText(value: unknown): string;
+export declare function parseBrowserWorkspaceNumberLike(value: unknown): number | undefined;
+export declare function assertBrowserWorkspaceUrl(rawUrl: string): string;
+export declare function inferBrowserWorkspaceTitle(url: string): string;
+export declare function createBrowserWorkspaceDesktopOnlyMessage(subaction: BrowserWorkspaceSubaction): string;
+export declare function createBrowserWorkspaceNotFoundError(tabId: string): Error;
+export declare function createBrowserWorkspaceCommandTargetError(subaction: BrowserWorkspaceSubaction): Error;
+export declare function sleep(ms: number): Promise<void>;
+export declare function writeBrowserWorkspaceFile(filePath: string, contents: string | Uint8Array): Promise<string>;
+export declare function normalizeBrowserWorkspaceCommand(command: BrowserWorkspaceCommand): BrowserWorkspaceCommand;
+export declare function resolveBrowserWorkspaceCommandElementRefs(command: BrowserWorkspaceCommand, mode: BrowserWorkspaceMode, tabId: string): BrowserWorkspaceCommand;
+export declare function buildBrowserWorkspaceCssStringLiteral(value: string): string;
+//# sourceMappingURL=browser-workspace-helpers.d.ts.map

package/packages/agent/src/services/browser-workspace-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-workspace-helpers.d.ts","sourceRoot":"","sources":["../../../../../src/services/browser-workspace-helpers.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,uBAAuB,EACvB,oBAAoB,EACpB,yBAAyB,EAC1B,MAAM,8BAA8B,CAAC;AAEtC,eAAO,MAAM,kBAAkB,QAAS,CAAC;AACzC,eAAO,MAAM,wBAAwB,MAAM,CAAC;AAC5C,eAAO,MAAM,qBAAqB,0BAA0B,CAAC;AAC7D,eAAO,MAAM,kCAAkC,2DACW,CAAC;AAC3D,eAAO,MAAM,yBAAyB,KAAoC,CAAC;AAE3E,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAM1E;AAED,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAIpE;AAED,wBAAgB,+BAA+B,CAC7C,KAAK,EAAE,OAAO,GACb,MAAM,GAAG,SAAS,CASpB;AAED,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAoBhE;AAED,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAU9D;AAED,wBAAgB,wCAAwC,CACtD,SAAS,EAAE,yBAAyB,GACnC,MAAM,CAER;AAED,wBAAgB,mCAAmC,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,CAIxE;AAED,wBAAgB,wCAAwC,CACtD,SAAS,EAAE,yBAAyB,GACnC,KAAK,CAIP;AAED,wBAAsB,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAErD;AAED,wBAAsB,yBAAyB,CAC7C,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,GAAG,UAAU,GAC5B,OAAO,CAAC,MAAM,CAAC,CAKjB;AAED,wBAAgB,gCAAgC,CAC9C,OAAO,EAAE,uBAAuB,GAC/B,uBAAuB,CA2BzB;AAED,wBAAgB,yCAAyC,CACvD,OAAO,EAAE,uBAAuB,EAChC,IAAI,EAAE,oBAAoB,EAC1B,KAAK,EAAE,MAAM,GACZ,uBAAuB,CA0BzB;AAED,wBAAgB,qCAAqC,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE3E"}

package/packages/agent/src/services/browser-workspace-helpers.js

@@ -0,0 +1,121 @@
+import * as fsp from "node:fs/promises";
+import * as path from "node:path";
+import { resolveBrowserWorkspaceElementRef } from "./browser-workspace-state.js";
+export const DEFAULT_TIMEOUT_MS = 12_000;
+export const DEFAULT_WAIT_INTERVAL_MS = 120;
+export const DEFAULT_WEB_PARTITION = "persist:eliza-browser";
+export const DESKTOP_BRIDGE_UNAVAILABLE_MESSAGE = "Eliza browser workspace desktop bridge is unavailable.";
+export const browserWorkspacePageFetch = globalThis.fetch.bind(globalThis);
+export function normalizeEnvValue(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+export function normalizeBrowserWorkspaceText(value) {
+    return String(value ?? "")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+export function parseBrowserWorkspaceNumberLike(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const parsed = Number.parseFloat(value.trim());
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+export function assertBrowserWorkspaceUrl(rawUrl) {
+    const trimmed = rawUrl.trim();
+    if (trimmed === "about:blank") {
+        return trimmed;
+    }
+    let parsed;
+    try {
+        parsed = new URL(trimmed);
+    }
+    catch {
+        throw new Error(`browser workspace rejected invalid URL: ${rawUrl}`);
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        throw new Error(`browser workspace only supports http/https URLs, got ${parsed.protocol}`);
+    }
+    return parsed.toString();
+}
+export function inferBrowserWorkspaceTitle(url) {
+    if (url === "about:blank") {
+        return "New Tab";
+    }
+    try {
+        return new URL(url).hostname.replace(/^www\./, "") || "Eliza Browser";
+    }
+    catch {
+        return "Eliza Browser";
+    }
+}
+export function createBrowserWorkspaceDesktopOnlyMessage(subaction) {
+    return `Eliza browser workspace ${subaction} is only available in the desktop app.`;
+}
+export function createBrowserWorkspaceNotFoundError(tabId) {
+    return new Error(`Browser workspace request failed (404): Tab ${tabId} was not found.`);
+}
+export function createBrowserWorkspaceCommandTargetError(subaction) {
+    return new Error(`Eliza browser workspace ${subaction} requires a current tab. Open or show a tab first, or pass an explicit id.`);
+}
+export async function sleep(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}
+export async function writeBrowserWorkspaceFile(filePath, contents) {
+    const resolved = path.resolve(filePath);
+    await fsp.mkdir(path.dirname(resolved), { recursive: true });
+    await fsp.writeFile(resolved, contents);
+    return resolved;
+}
+export function normalizeBrowserWorkspaceCommand(command) {
+    const raw = command;
+    const normalizedSubaction = typeof raw.subaction === "string"
+        ? raw.subaction.trim().toLowerCase()
+        : typeof raw.operation === "string"
+            ? raw.operation.trim().toLowerCase()
+            : "";
+    const subaction = normalizedSubaction === "goto"
+        ? "navigate"
+        : normalizedSubaction === "read"
+            ? "get"
+            : command.subaction;
+    const timeoutMs = parseBrowserWorkspaceNumberLike(command.timeoutMs) ??
+        parseBrowserWorkspaceNumberLike(raw.ms) ??
+        parseBrowserWorkspaceNumberLike(raw.milliseconds);
+    return {
+        ...command,
+        subaction,
+        timeoutMs,
+        steps: Array.isArray(command.steps)
+            ? command.steps.map((step) => normalizeBrowserWorkspaceCommand(step))
+            : command.steps,
+    };
+}
+export function resolveBrowserWorkspaceCommandElementRefs(command, mode, tabId) {
+    const selector = command.selector?.trim();
+    if (!selector) {
+        return command;
+    }
+    const match = selector.match(/^(@e\d+)([\s\S]*)$/i);
+    if (!match?.[1]) {
+        return command;
+    }
+    const resolvedSelector = resolveBrowserWorkspaceElementRef(mode, tabId, match[1]);
+    if (!resolvedSelector) {
+        throw new Error(`Unknown browser snapshot element ref ${match[1]}. Run snapshot or inspect again before reusing element refs.`);
+    }
+    return {
+        ...command,
+        selector: `${resolvedSelector}${match[2] ?? ""}`,
+    };
+}
+export function buildBrowserWorkspaceCssStringLiteral(value) {
+    return JSON.stringify(value);
+}

package/packages/agent/src/services/browser-workspace-jsdom.d.ts

@@ -0,0 +1,16 @@
+import type { JSDOM } from "jsdom";
+import type { BrowserWorkspaceRuntimeState, WebBrowserWorkspaceTabState } from "./browser-workspace-types.js";
+/**
+ * Locate jsdom's package.json on disk, then resolve its declared entry file from there.
+ * Vitest workers run on Node; Node cannot resolve `jsdom` from workspace roots when
+ * Bun hoists deps under node_modules/.bun, but requiring jsdom from its own package
+ * directory still works.
+ */
+export declare function findJsdomPackageJsonPath(): string;
+/** Lazy-load jsdom so importing this module does not require jsdom at parse time (Vitest / server tests). */
+export declare function getJSDOMClass(): typeof import("jsdom").JSDOM;
+export declare function createEmptyWebBrowserWorkspaceDom(url: string): JSDOM;
+export declare function applyBrowserWorkspaceDomSettings(dom: JSDOM, state: BrowserWorkspaceRuntimeState): void;
+export declare function installBrowserWorkspaceWebRuntime(tab: WebBrowserWorkspaceTabState, dom: JSDOM): void;
+export declare function ensureBrowserWorkspaceDom(tab: WebBrowserWorkspaceTabState): JSDOM;
+//# sourceMappingURL=browser-workspace-jsdom.d.ts.map

package/packages/agent/src/services/browser-workspace-jsdom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-workspace-jsdom.d.ts","sourceRoot":"","sources":["../../../../../src/services/browser-workspace-jsdom.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AASnC,OAAO,KAAK,EACV,4BAA4B,EAC5B,2BAA2B,EAC5B,MAAM,8BAA8B,CAAC;AAItC;;;;;GAKG;AACH,wBAAgB,wBAAwB,IAAI,MAAM,CA2CjD;AAED,6GAA6G;AAC7G,wBAAgB,aAAa,IAAI,cAAc,OAAO,EAAE,KAAK,CAc5D;AAED,wBAAgB,iCAAiC,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,CAQpE;AAED,wBAAgB,gCAAgC,CAC9C,GAAG,EAAE,KAAK,EACV,KAAK,EAAE,4BAA4B,GAClC,IAAI,CA8EN;AAED,wBAAgB,iCAAiC,CAC/C,GAAG,EAAE,2BAA2B,EAChC,GAAG,EAAE,KAAK,GACT,IAAI,CAkFN;AAED,wBAAgB,yBAAyB,CACvC,GAAG,EAAE,2BAA2B,GAC/B,KAAK,CAQP"}

package/packages/agent/src/services/browser-workspace-jsdom.js

@@ -0,0 +1,223 @@
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { normalizeBrowserWorkspaceText } from "./browser-workspace-helpers.js";
+import { fetchBrowserWorkspaceTrackedResponse } from "./browser-workspace-network.js";
+import { browserWorkspaceClipboardText, getBrowserWorkspaceRuntimeState, getBrowserWorkspaceTimestamp, setBrowserWorkspaceClipboardText, } from "./browser-workspace-state.js";
+let jsdomCtor;
+/**
+ * Locate jsdom's package.json on disk, then resolve its declared entry file from there.
+ * Vitest workers run on Node; Node cannot resolve `jsdom` from workspace roots when
+ * Bun hoists deps under node_modules/.bun, but requiring jsdom from its own package
+ * directory still works.
+ */
+export function findJsdomPackageJsonPath() {
+    const candidatesUnderBase = (base) => {
+        const rels = [
+            path.join("node_modules", "jsdom", "package.json"),
+            path.join("apps", "app", "node_modules", "jsdom", "package.json"),
+        ];
+        for (const rel of rels) {
+            const full = path.join(base, rel);
+            if (existsSync(full)) {
+                return full;
+            }
+        }
+        return undefined;
+    };
+    const walk = (start, maxDepth) => {
+        let dir = start;
+        for (let depth = 0; depth < maxDepth; depth += 1) {
+            const hit = candidatesUnderBase(dir);
+            if (hit) {
+                return hit;
+            }
+            const parent = path.dirname(dir);
+            if (parent === dir) {
+                break;
+            }
+            dir = parent;
+        }
+        return undefined;
+    };
+    const fromSource = walk(path.dirname(fileURLToPath(import.meta.url)), 24);
+    if (fromSource) {
+        return fromSource;
+    }
+    const fromCwd = walk(process.cwd(), 16);
+    if (fromCwd) {
+        return fromCwd;
+    }
+    throw new Error("Could not find jsdom on disk (install dependencies: jsdom is listed on @elizaos/agent and apps/app).");
+}
+/** Lazy-load jsdom so importing this module does not require jsdom at parse time (Vitest / server tests). */
+export function getJSDOMClass() {
+    if (!jsdomCtor) {
+        const jsdomPkg = findJsdomPackageJsonPath();
+        const jsdomDir = path.dirname(jsdomPkg);
+        const meta = JSON.parse(readFileSync(jsdomPkg, "utf8"));
+        const mainRel = (meta.main ?? "./lib/api.js").replace(/^\.\//, "");
+        const entry = path.join(jsdomDir, mainRel);
+        const req = createRequire(jsdomPkg);
+        const mod = req(entry);
+        jsdomCtor = mod.JSDOM;
+    }
+    return jsdomCtor;
+}
+export function createEmptyWebBrowserWorkspaceDom(url) {
+    return new (getJSDOMClass())('<!doctype html><html lang="en"><head><title>New Tab</title></head><body></body></html>', {
+        pretendToBeVisual: true,
+        url,
+    });
+}
+export function applyBrowserWorkspaceDomSettings(dom, state) {
+    const viewport = state.settings.viewport;
+    if (viewport) {
+        Object.defineProperty(dom.window, "innerWidth", {
+            configurable: true,
+            value: viewport.width,
+        });
+        Object.defineProperty(dom.window, "innerHeight", {
+            configurable: true,
+            value: viewport.height,
+        });
+        Object.defineProperty(dom.window, "devicePixelRatio", {
+            configurable: true,
+            value: viewport.scale,
+        });
+    }
+    Object.defineProperty(dom.window.navigator, "onLine", {
+        configurable: true,
+        get: () => !state.settings.offline,
+    });
+    if (state.settings.device) {
+        Object.defineProperty(dom.window.navigator, "userAgent", {
+            configurable: true,
+            value: `ElizaBrowserWorkspace/${state.settings.device}`,
+        });
+    }
+    const matchMedia = (query) => {
+        const matches = query.includes("prefers-color-scheme") &&
+            ((state.settings.media === "dark" && query.includes("dark")) ||
+                (state.settings.media === "light" && query.includes("light")));
+        return {
+            addEventListener() { },
+            addListener() { },
+            dispatchEvent() {
+                return true;
+            },
+            matches,
+            media: query,
+            onchange: null,
+            removeEventListener() { },
+            removeListener() { },
+        };
+    };
+    Object.defineProperty(dom.window, "matchMedia", {
+        configurable: true,
+        value: matchMedia,
+    });
+    Object.defineProperty(dom.window.navigator, "clipboard", {
+        configurable: true,
+        value: {
+            readText: async () => browserWorkspaceClipboardText,
+            writeText: async (value) => {
+                setBrowserWorkspaceClipboardText(String(value ?? ""));
+            },
+        },
+    });
+    Object.defineProperty(dom.window.navigator, "geolocation", {
+        configurable: true,
+        value: {
+            getCurrentPosition: (success) => {
+                const coords = state.settings.geo ?? { latitude: 0, longitude: 0 };
+                success({
+                    coords: {
+                        accuracy: 1,
+                        latitude: coords.latitude,
+                        longitude: coords.longitude,
+                    },
+                    timestamp: Date.now(),
+                });
+            },
+        },
+    });
+}
+export function installBrowserWorkspaceWebRuntime(tab, dom) {
+    const state = getBrowserWorkspaceRuntimeState("web", tab.id);
+    applyBrowserWorkspaceDomSettings(dom, state);
+    const windowRecord = dom.window;
+    windowRecord.__elizaBrowserWorkspaceState = state;
+    const consoleTarget = dom.window.console;
+    if (!consoleTarget.__elizaWrapped) {
+        for (const level of ["log", "info", "warn", "error"]) {
+            consoleTarget[level] = (...args) => {
+                state.consoleEntries.push({
+                    level,
+                    message: args
+                        .map((value) => normalizeBrowserWorkspaceText(value))
+                        .join(" "),
+                    timestamp: getBrowserWorkspaceTimestamp(),
+                });
+                return undefined;
+            };
+        }
+        consoleTarget.__elizaWrapped = true;
+    }
+    dom.window.alert = (message) => {
+        state.dialog = {
+            defaultValue: null,
+            message: String(message ?? ""),
+            open: true,
+            type: "alert",
+        };
+    };
+    dom.window.confirm = (message) => {
+        state.dialog = {
+            defaultValue: null,
+            message: String(message ?? ""),
+            open: true,
+            type: "confirm",
+        };
+        return false;
+    };
+    dom.window.prompt = (message, defaultValue) => {
+        state.dialog = {
+            defaultValue: defaultValue ?? null,
+            message: String(message ?? ""),
+            open: true,
+            type: "prompt",
+        };
+        return null;
+    };
+    Object.defineProperty(dom.window, "fetch", {
+        configurable: true,
+        value: async (input, init) => {
+            const inputUrl = typeof input === "string"
+                ? input
+                : input instanceof URL
+                    ? input.toString()
+                    : typeof input.url === "string"
+                        ? input.url
+                        : String(input);
+            return fetchBrowserWorkspaceTrackedResponse(state, new URL(inputUrl, tab.url).toString(), {
+                ...init,
+                headers: init?.headers ??
+                    (input.headers
+                        ? input.headers
+                        : undefined),
+                method: init?.method ??
+                    (typeof input.method === "string"
+                        ? input.method
+                        : undefined),
+            }, "fetch");
+        },
+    });
+}
+export function ensureBrowserWorkspaceDom(tab) {
+    if (tab.dom && tab.loadedUrl === tab.url) {
+        return tab.dom;
+    }
+    throw new Error(`Browser workspace tab ${tab.id} is not loaded yet. Reload or inspect the page first.`);
+}

package/packages/agent/src/services/browser-workspace-network.d.ts

@@ -0,0 +1,7 @@
+import type { BrowserWorkspaceNetworkRequestRecord, BrowserWorkspaceNetworkRoute, BrowserWorkspaceRuntimeState } from "./browser-workspace-types.js";
+export declare function browserWorkspacePatternMatches(pattern: string, value: string): boolean;
+export declare function normalizeBrowserWorkspaceHeaders(headers: Record<string, string> | undefined): Record<string, string>;
+export declare function findBrowserWorkspaceNetworkRoute(state: BrowserWorkspaceRuntimeState, url: string): BrowserWorkspaceNetworkRoute | null;
+export declare function recordBrowserWorkspaceNetworkRequest(state: BrowserWorkspaceRuntimeState, request: Omit<BrowserWorkspaceNetworkRequestRecord, "id" | "timestamp">): BrowserWorkspaceNetworkRequestRecord;
+export declare function fetchBrowserWorkspaceTrackedResponse(state: BrowserWorkspaceRuntimeState, url: string, init: RequestInit, resourceType: string): Promise<Response>;
+//# sourceMappingURL=browser-workspace-network.d.ts.map

package/packages/agent/src/services/browser-workspace-network.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-workspace-network.d.ts","sourceRoot":"","sources":["../../../../../src/services/browser-workspace-network.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,oCAAoC,EACpC,4BAA4B,EAC5B,4BAA4B,EAC7B,MAAM,8BAA8B,CAAC;AAEtC,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,GACZ,OAAO,CAwBT;AAED,wBAAgB,gCAAgC,CAC9C,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,GAC1C,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAYxB;AAED,wBAAgB,gCAAgC,CAC9C,KAAK,EAAE,4BAA4B,EACnC,GAAG,EAAE,MAAM,GACV,4BAA4B,GAAG,IAAI,CAOrC;AAED,wBAAgB,oCAAoC,CAClD,KAAK,EAAE,4BAA4B,EACnC,OAAO,EAAE,IAAI,CAAC,oCAAoC,EAAE,IAAI,GAAG,WAAW,CAAC,GACtE,oCAAoC,CAWtC;AAED,wBAAsB,oCAAoC,CACxD,KAAK,EAAE,4BAA4B,EACnC,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,WAAgB,EACtB,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,QAAQ,CAAC,CA8FnB"}