@hera-al/browser-server 1.0.0

package/dist/playwright/pw-tools-core.storage.js

@@ -0,0 +1,76 @@
+import { ensurePageState, getPageForTargetId } from "./pw-session.js";
+export async function cookiesGetViaPlaywright(opts) {
+    const page = await getPageForTargetId(opts);
+    ensurePageState(page);
+    const cookies = await page.context().cookies();
+    return { cookies };
+}
+export async function cookiesSetViaPlaywright(opts) {
+    const page = await getPageForTargetId(opts);
+    ensurePageState(page);
+    const cookie = opts.cookie;
+    if (!cookie.name || cookie.value === undefined) {
+        throw new Error("cookie name and value are required");
+    }
+    const hasUrl = typeof cookie.url === "string" && cookie.url.trim();
+    const hasDomainPath = typeof cookie.domain === "string" &&
+        cookie.domain.trim() &&
+        typeof cookie.path === "string" &&
+        cookie.path.trim();
+    if (!hasUrl && !hasDomainPath) {
+        throw new Error("cookie requires url, or domain+path");
+    }
+    await page.context().addCookies([cookie]);
+}
+export async function cookiesClearViaPlaywright(opts) {
+    const page = await getPageForTargetId(opts);
+    ensurePageState(page);
+    await page.context().clearCookies();
+}
+export async function storageGetViaPlaywright(opts) {
+    const page = await getPageForTargetId(opts);
+    ensurePageState(page);
+    const kind = opts.kind;
+    const key = typeof opts.key === "string" ? opts.key : undefined;
+    const values = await page.evaluate(({ kind: kind2, key: key2 }) => {
+        const store = kind2 === "session" ? globalThis.sessionStorage : globalThis.localStorage;
+        if (key2) {
+            const value = store.getItem(key2);
+            return value === null ? {} : { [key2]: value };
+        }
+        const out = {};
+        for (let i = 0; i < store.length; i += 1) {
+            const k = store.key(i);
+            if (!k) {
+                continue;
+            }
+            const v = store.getItem(k);
+            if (v !== null) {
+                out[k] = v;
+            }
+        }
+        return out;
+    }, { kind, key });
+    return { values: values ?? {} };
+}
+export async function storageSetViaPlaywright(opts) {
+    const page = await getPageForTargetId(opts);
+    ensurePageState(page);
+    const key = String(opts.key ?? "");
+    if (!key) {
+        throw new Error("key is required");
+    }
+    await page.evaluate(({ kind, key: k, value }) => {
+        const store = kind === "session" ? globalThis.sessionStorage : globalThis.localStorage;
+        store.setItem(k, value);
+    }, { kind: opts.kind, key, value: String(opts.value ?? "") });
+}
+export async function storageClearViaPlaywright(opts) {
+    const page = await getPageForTargetId(opts);
+    ensurePageState(page);
+    await page.evaluate(({ kind }) => {
+        const store = kind === "session" ? globalThis.sessionStorage : globalThis.localStorage;
+        store.clear();
+    }, { kind: opts.kind });
+}
+//# sourceMappingURL=pw-tools-core.storage.js.map

package/dist/playwright/pw-tools-core.trace.d.ts

@@ -0,0 +1,13 @@
+export declare function traceStartViaPlaywright(opts: {
+    cdpUrl: string;
+    targetId?: string;
+    screenshots?: boolean;
+    snapshots?: boolean;
+    sources?: boolean;
+}): Promise<void>;
+export declare function traceStopViaPlaywright(opts: {
+    cdpUrl: string;
+    targetId?: string;
+    path: string;
+}): Promise<void>;
+//# sourceMappingURL=pw-tools-core.trace.d.ts.map

package/dist/playwright/pw-tools-core.trace.js

@@ -0,0 +1,26 @@
+import { ensureContextState, getPageForTargetId } from "./pw-session.js";
+export async function traceStartViaPlaywright(opts) {
+    const page = await getPageForTargetId(opts);
+    const context = page.context();
+    const ctxState = ensureContextState(context);
+    if (ctxState.traceActive) {
+        throw new Error("Trace already running. Stop the current trace before starting a new one.");
+    }
+    await context.tracing.start({
+        screenshots: opts.screenshots ?? true,
+        snapshots: opts.snapshots ?? true,
+        sources: opts.sources ?? false,
+    });
+    ctxState.traceActive = true;
+}
+export async function traceStopViaPlaywright(opts) {
+    const page = await getPageForTargetId(opts);
+    const context = page.context();
+    const ctxState = ensureContextState(context);
+    if (!ctxState.traceActive) {
+        throw new Error("No active trace. Start a trace before stopping it.");
+    }
+    await context.tracing.stop({ path: opts.path });
+    ctxState.traceActive = false;
+}
+//# sourceMappingURL=pw-tools-core.trace.js.map

package/dist/server/browser-context.d.ts

@@ -0,0 +1,29 @@
+import type { ResolvedBrowserConfig, ResolvedBrowserProfile } from "../config.js";
+export declare class BrowserContext {
+    private profiles;
+    private config;
+    constructor(config: ResolvedBrowserConfig);
+    updateConfig(config: ResolvedBrowserConfig): void;
+    getProfile(name?: string): ResolvedBrowserProfile;
+    private getRuntime;
+    ensureBrowserAvailable(profileName?: string): Promise<ResolvedBrowserProfile>;
+    stopBrowser(profileName?: string): Promise<void>;
+    isReachable(profileName?: string): Promise<boolean>;
+    listTabs(profileName?: string): Promise<Array<{
+        id: string;
+        title: string;
+        url: string;
+        type: string;
+    }>>;
+    openTab(url: string, profileName?: string): Promise<{
+        id: string;
+        title: string;
+        url: string;
+    }>;
+    closeTab(tabId: string, profileName?: string): Promise<void>;
+    focusTab(tabId: string, profileName?: string): Promise<void>;
+    setLastTargetId(profileName: string, targetId: string): void;
+    getLastTargetId(profileName?: string): string | undefined;
+    stopAll(): Promise<void>;
+}
+//# sourceMappingURL=browser-context.d.ts.map

package/dist/server/browser-context.js

@@ -0,0 +1,137 @@
+import { resolveProfile } from "../config.js";
+import { isChromeReachable, launchChrome, stopChrome } from "../core/chrome.js";
+import { fetchJson } from "../core/cdp.helpers.js";
+import { appendCdpPath } from "../core/cdp.js";
+import { createTargetViaCdp } from "../core/cdp.js";
+import { createLogger } from "../logger.js";
+import { closePlaywrightBrowserConnection, listPagesViaPlaywright, createPageViaPlaywright, closePageByTargetIdViaPlaywright, focusPageByTargetIdViaPlaywright, } from "../playwright/pw-session.js";
+const log = createLogger("Browser:Context");
+export class BrowserContext {
+    profiles = new Map();
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    updateConfig(config) {
+        this.config = config;
+    }
+    getProfile(name) {
+        const profileName = name || "default";
+        const resolved = resolveProfile(this.config, profileName);
+        if (!resolved) {
+            throw new Error(`Profile "${profileName}" not found`);
+        }
+        return resolved;
+    }
+    getRuntime(profile) {
+        let runtime = this.profiles.get(profile.name);
+        if (!runtime) {
+            runtime = { profile };
+            this.profiles.set(profile.name, runtime);
+        }
+        return runtime;
+    }
+    async ensureBrowserAvailable(profileName) {
+        const profile = this.getProfile(profileName);
+        const runtime = this.getRuntime(profile);
+        if (await isChromeReachable(profile.cdpUrl, 500)) {
+            return profile;
+        }
+        if (this.config.attachOnly) {
+            throw new Error(`Browser not reachable at ${profile.cdpUrl} (attachOnly mode)`);
+        }
+        if (!profile.cdpIsLoopback) {
+            throw new Error(`Remote browser at ${profile.cdpUrl} is not reachable`);
+        }
+        log.info(`Launching Chrome for profile "${profile.name}"...`);
+        runtime.chrome = await launchChrome(this.config, profile);
+        return profile;
+    }
+    async stopBrowser(profileName) {
+        const profile = this.getProfile(profileName);
+        const runtime = this.profiles.get(profile.name);
+        if (runtime?.chrome) {
+            await stopChrome(runtime.chrome);
+            runtime.chrome = undefined;
+        }
+        await closePlaywrightBrowserConnection();
+    }
+    async isReachable(profileName) {
+        const profile = this.getProfile(profileName);
+        return await isChromeReachable(profile.cdpUrl, 500);
+    }
+    async listTabs(profileName) {
+        const profile = this.getProfile(profileName);
+        try {
+            const listUrl = appendCdpPath(profile.cdpUrl, "/json/list");
+            const targets = await fetchJson(listUrl, 2000);
+            return targets.map(t => ({
+                id: t.id,
+                title: t.title || "",
+                url: t.url || "",
+                type: t.type || "page",
+            }));
+        }
+        catch {
+            // Fallback to Playwright
+            const pages = await listPagesViaPlaywright({ cdpUrl: profile.cdpUrl });
+            return pages.map(p => ({
+                id: p.targetId,
+                title: p.title,
+                url: p.url,
+                type: p.type,
+            }));
+        }
+    }
+    async openTab(url, profileName) {
+        const profile = this.getProfile(profileName);
+        try {
+            const result = await createTargetViaCdp({ cdpUrl: profile.cdpUrl, url });
+            return { id: result.targetId, title: "", url };
+        }
+        catch {
+            const result = await createPageViaPlaywright({ cdpUrl: profile.cdpUrl, url });
+            return { id: result.targetId, title: result.title, url: result.url };
+        }
+    }
+    async closeTab(tabId, profileName) {
+        const profile = this.getProfile(profileName);
+        try {
+            const closeUrl = appendCdpPath(profile.cdpUrl, `/json/close/${tabId}`);
+            await fetch(closeUrl, { method: "GET" });
+        }
+        catch {
+            await closePageByTargetIdViaPlaywright({ cdpUrl: profile.cdpUrl, targetId: tabId });
+        }
+    }
+    async focusTab(tabId, profileName) {
+        const profile = this.getProfile(profileName);
+        try {
+            const activateUrl = appendCdpPath(profile.cdpUrl, `/json/activate/${tabId}`);
+            await fetch(activateUrl, { method: "GET" });
+        }
+        catch {
+            await focusPageByTargetIdViaPlaywright({ cdpUrl: profile.cdpUrl, targetId: tabId });
+        }
+    }
+    setLastTargetId(profileName, targetId) {
+        const profile = this.getProfile(profileName);
+        const runtime = this.getRuntime(profile);
+        runtime.lastTargetId = targetId;
+    }
+    getLastTargetId(profileName) {
+        const name = profileName || "default";
+        return this.profiles.get(name)?.lastTargetId;
+    }
+    async stopAll() {
+        for (const [, runtime] of this.profiles) {
+            if (runtime.chrome) {
+                await stopChrome(runtime.chrome).catch(() => { });
+                runtime.chrome = undefined;
+            }
+        }
+        await closePlaywrightBrowserConnection().catch(() => { });
+        this.profiles.clear();
+    }
+}
+//# sourceMappingURL=browser-context.js.map

package/dist/server/browser-server.d.ts

@@ -0,0 +1,7 @@
+import type { ResolvedBrowserConfig } from "../config.js";
+import { BrowserContext } from "./browser-context.js";
+export declare function getBrowserContext(): BrowserContext | null;
+export declare function startBrowserServer(config: ResolvedBrowserConfig): Promise<void>;
+export declare function stopBrowserServer(): Promise<void>;
+export declare function reconfigureBrowserServer(config: ResolvedBrowserConfig): Promise<void>;
+//# sourceMappingURL=browser-server.d.ts.map

package/dist/server/browser-server.js

@@ -0,0 +1,49 @@
+import { serve } from "@hono/node-server";
+import { BrowserContext } from "./browser-context.js";
+import { registerRoutes } from "./routes/index.js";
+import { createLogger } from "../logger.js";
+const log = createLogger("Browser:Server");
+let serverHandle = null;
+let browserContext = null;
+export function getBrowserContext() {
+    return browserContext;
+}
+export async function startBrowserServer(config) {
+    if (serverHandle) {
+        log.warn("Browser server already running, stopping first");
+        await stopBrowserServer();
+    }
+    browserContext = new BrowserContext(config);
+    const app = registerRoutes(browserContext);
+    return new Promise((resolve, reject) => {
+        try {
+            serverHandle = serve({
+                fetch: app.fetch,
+                hostname: "127.0.0.1",
+                port: config.controlPort,
+            }, (info) => {
+                log.info(`Browser HTTP server listening on 127.0.0.1:${info.port}`);
+                resolve();
+            });
+        }
+        catch (err) {
+            reject(err);
+        }
+    });
+}
+export async function stopBrowserServer() {
+    if (browserContext) {
+        await browserContext.stopAll().catch(() => { });
+        browserContext = null;
+    }
+    if (serverHandle) {
+        serverHandle.close();
+        serverHandle = null;
+    }
+}
+export async function reconfigureBrowserServer(config) {
+    if (browserContext) {
+        browserContext.updateConfig(config);
+    }
+}
+//# sourceMappingURL=browser-server.js.map

package/dist/server/routes/act.d.ts

@@ -0,0 +1,4 @@
+import { Hono } from "hono";
+import type { BrowserContext } from "../browser-context.js";
+export declare function actRoutes(ctx: BrowserContext): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+//# sourceMappingURL=act.d.ts.map

package/dist/server/routes/act.js

@@ -0,0 +1,176 @@
+import { Hono } from "hono";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import crypto from "node:crypto";
+import { clickViaPlaywright, typeViaPlaywright, pressKeyViaPlaywright, hoverViaPlaywright, evaluateViaPlaywright, waitForViaPlaywright, takeScreenshotViaPlaywright, scrollIntoViewViaPlaywright, dragViaPlaywright, selectOptionViaPlaywright, fillFormViaPlaywright, } from "../../playwright/pw-tools-core.interactions.js";
+import { navigateViaPlaywright } from "../../playwright/pw-tools-core.snapshot.js";
+export function actRoutes(ctx) {
+    const app = new Hono();
+    app.post("/act", async (c) => {
+        const body = await c.req.json();
+        const { kind, profile: profileName, targetId, ...params } = body;
+        if (!kind) {
+            return c.json({ ok: false, error: "kind is required" }, 400);
+        }
+        try {
+            const profile = ctx.getProfile(profileName);
+            const cdpUrl = profile.cdpUrl;
+            const tid = targetId || ctx.getLastTargetId(profile.name);
+            let result;
+            switch (kind) {
+                case "navigate": {
+                    const nav = await navigateViaPlaywright({
+                        cdpUrl,
+                        targetId: tid,
+                        url: params.url,
+                        timeoutMs: params.timeoutMs,
+                    });
+                    result = nav;
+                    break;
+                }
+                case "click": {
+                    await clickViaPlaywright({
+                        cdpUrl,
+                        targetId: tid,
+                        ref: params.ref,
+                        doubleClick: params.doubleClick,
+                        button: params.button,
+                        modifiers: params.modifiers,
+                        timeoutMs: params.timeoutMs,
+                    });
+                    result = { clicked: true };
+                    break;
+                }
+                case "type": {
+                    await typeViaPlaywright({
+                        cdpUrl,
+                        targetId: tid,
+                        ref: params.ref,
+                        text: params.text,
+                        submit: params.submit,
+                        slowly: params.slowly,
+                        timeoutMs: params.timeoutMs,
+                    });
+                    result = { typed: true };
+                    break;
+                }
+                case "press": {
+                    await pressKeyViaPlaywright({
+                        cdpUrl,
+                        targetId: tid,
+                        key: params.key,
+                        delayMs: params.delayMs,
+                    });
+                    result = { pressed: true };
+                    break;
+                }
+                case "hover": {
+                    await hoverViaPlaywright({
+                        cdpUrl,
+                        targetId: tid,
+                        ref: params.ref,
+                        timeoutMs: params.timeoutMs,
+                    });
+                    result = { hovered: true };
+                    break;
+                }
+                case "scroll": {
+                    await scrollIntoViewViaPlaywright({
+                        cdpUrl,
+                        targetId: tid,
+                        ref: params.ref,
+                        timeoutMs: params.timeoutMs,
+                    });
+                    result = { scrolled: true };
+                    break;
+                }
+                case "drag": {
+                    await dragViaPlaywright({
+                        cdpUrl,
+                        targetId: tid,
+                        startRef: params.startRef,
+                        endRef: params.endRef,
+                        timeoutMs: params.timeoutMs,
+                    });
+                    result = { dragged: true };
+                    break;
+                }
+                case "select": {
+                    await selectOptionViaPlaywright({
+                        cdpUrl,
+                        targetId: tid,
+                        ref: params.ref,
+                        values: params.values,
+                        timeoutMs: params.timeoutMs,
+                    });
+                    result = { selected: true };
+                    break;
+                }
+                case "fill_form": {
+                    await fillFormViaPlaywright({
+                        cdpUrl,
+                        targetId: tid,
+                        fields: params.fields,
+                        timeoutMs: params.timeoutMs,
+                    });
+                    result = { filled: true };
+                    break;
+                }
+                case "screenshot": {
+                    const shot = await takeScreenshotViaPlaywright({
+                        cdpUrl,
+                        targetId: tid,
+                        ref: params.ref,
+                        element: params.element,
+                        fullPage: params.fullPage,
+                        type: params.type,
+                    });
+                    const ext = params.type === "jpeg" ? "jpg" : "png";
+                    const fileName = `screenshot-${crypto.randomUUID().slice(0, 8)}.${ext}`;
+                    const dir = path.join(os.tmpdir(), "grabmeabeer", "screenshots");
+                    await fs.mkdir(dir, { recursive: true });
+                    const filePath = path.join(dir, fileName);
+                    await fs.writeFile(filePath, shot.buffer);
+                    result = { path: filePath, size: shot.buffer.length };
+                    break;
+                }
+                case "evaluate": {
+                    const evalResult = await evaluateViaPlaywright({
+                        cdpUrl,
+                        targetId: tid,
+                        fn: params.fn,
+                        ref: params.ref,
+                        timeoutMs: params.timeoutMs,
+                    });
+                    result = { value: evalResult };
+                    break;
+                }
+                case "wait": {
+                    await waitForViaPlaywright({
+                        cdpUrl,
+                        targetId: tid,
+                        timeMs: params.timeMs,
+                        text: params.text,
+                        textGone: params.textGone,
+                        selector: params.selector,
+                        url: params.url,
+                        loadState: params.loadState,
+                        fn: params.fn,
+                        timeoutMs: params.timeoutMs,
+                    });
+                    result = { waited: true };
+                    break;
+                }
+                default:
+                    return c.json({ ok: false, error: `Unknown action kind: ${kind}` }, 400);
+            }
+            return c.json({ ok: true, result });
+        }
+        catch (err) {
+            return c.json({ ok: false, error: err instanceof Error ? err.message : String(err) }, 500);
+        }
+    });
+    return app;
+}
+//# sourceMappingURL=act.js.map

package/dist/server/routes/basic.d.ts

@@ -0,0 +1,4 @@
+import { Hono } from "hono";
+import type { BrowserContext } from "../browser-context.js";
+export declare function basicRoutes(ctx: BrowserContext): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+//# sourceMappingURL=basic.d.ts.map

package/dist/server/routes/basic.js

@@ -0,0 +1,36 @@
+import { Hono } from "hono";
+export function basicRoutes(ctx) {
+    const app = new Hono();
+    app.get("/", async (c) => {
+        const profile = c.req.query("profile");
+        try {
+            const reachable = await ctx.isReachable(profile);
+            return c.json({ ok: true, status: reachable ? "running" : "stopped" });
+        }
+        catch (err) {
+            return c.json({ ok: true, status: "stopped", error: String(err) });
+        }
+    });
+    app.post("/start", async (c) => {
+        const body = await c.req.json().catch(() => ({}));
+        try {
+            const profile = await ctx.ensureBrowserAvailable(body.profile);
+            return c.json({ ok: true, profile: profile.name, cdpUrl: profile.cdpUrl });
+        }
+        catch (err) {
+            return c.json({ ok: false, error: err instanceof Error ? err.message : String(err) }, 500);
+        }
+    });
+    app.post("/stop", async (c) => {
+        const body = await c.req.json().catch(() => ({}));
+        try {
+            await ctx.stopBrowser(body.profile);
+            return c.json({ ok: true });
+        }
+        catch (err) {
+            return c.json({ ok: false, error: err instanceof Error ? err.message : String(err) }, 500);
+        }
+    });
+    return app;
+}
+//# sourceMappingURL=basic.js.map

package/dist/server/routes/index.d.ts

@@ -0,0 +1,4 @@
+import { Hono } from "hono";
+import type { BrowserContext } from "../browser-context.js";
+export declare function registerRoutes(ctx: BrowserContext): Hono;
+//# sourceMappingURL=index.d.ts.map

package/dist/server/routes/index.js

@@ -0,0 +1,16 @@
+import { Hono } from "hono";
+import { basicRoutes } from "./basic.js";
+import { tabsRoutes } from "./tabs.js";
+import { actRoutes } from "./act.js";
+import { snapshotRoutes } from "./snapshot.js";
+import { storageRoutes } from "./storage.js";
+export function registerRoutes(ctx) {
+    const app = new Hono();
+    app.route("/", basicRoutes(ctx));
+    app.route("/", tabsRoutes(ctx));
+    app.route("/", actRoutes(ctx));
+    app.route("/", snapshotRoutes(ctx));
+    app.route("/", storageRoutes(ctx));
+    return app;
+}
+//# sourceMappingURL=index.js.map

package/dist/server/routes/snapshot.d.ts

@@ -0,0 +1,4 @@
+import { Hono } from "hono";
+import type { BrowserContext } from "../browser-context.js";
+export declare function snapshotRoutes(ctx: BrowserContext): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+//# sourceMappingURL=snapshot.d.ts.map