@elizaos/agent 2.0.0-alpha.441 → 2.0.0-alpha.501

package/plugins/plugin-browser-bridge/src/routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../../../../../../plugins/plugin-browser-bridge/src/routes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAClC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AAM3E,OAAO,EAAE,KAAK,YAAY,EAAU,KAAK,IAAI,EAAE,MAAM,eAAe,CAAC;AA0BrE,MAAM,WAAW,yBAAyB;IACxC,GAAG,EAAE,IAAI,CAAC,eAAe,CAAC;IAC1B,GAAG,EAAE,IAAI,CAAC,cAAc,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,GAAG,CAAC;IACT,KAAK,EAAE;QACL,OAAO,EAAE,YAAY,GAAG,IAAI,CAAC;QAC7B,aAAa,EAAE,IAAI,GAAG,IAAI,CAAC;KAC5B,CAAC;IACF,IAAI,EAAE,CAAC,GAAG,EAAE,IAAI,CAAC,cAAc,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IACzE,KAAK,EAAE,CAAC,GAAG,EAAE,IAAI,CAAC,cAAc,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5E,YAAY,EAAE,CAAC,CAAC,SAAS,MAAM,EAC7B,GAAG,EAAE,IAAI,CAAC,eAAe,EACzB,GAAG,EAAE,IAAI,CAAC,cAAc,EACxB,OAAO,CAAC,EAAE,mBAAmB,KAC1B,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IACvB,mBAAmB,EAAE,CACnB,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,IAAI,CAAC,cAAc,EACxB,KAAK,EAAE,MAAM,KACV,MAAM,GAAG,IAAI,CAAC;CACpB;AA6ED,iBAAS,gBAAgB,CACvB,GAAG,EAAE,yBAAyB,EAC9B,SAAS,EAAE,MAAM,GAChB,OAAO,CAkBT;AA0JD,wBAAsB,yBAAyB,CAC7C,GAAG,EAAE,yBAAyB,GAC7B,OAAO,CAAC,OAAO,CAAC,CA8dlB;AAED,OAAO,EAAE,gBAAgB,EAAE,CAAC"}

package/plugins/plugin-browser-bridge/src/routes.js

@@ -0,0 +1,496 @@
+/**
+ * Agent Browser Bridge HTTP routes.
+ *
+ * Mounted under `/api/browser-bridge/*` by the plugin-collector. Pair +
+ * settings + companion-sync + tabs + current-page + packaging endpoints
+ * are fully generic. Session endpoints (confirm/progress/complete) still
+ * operate on the LifeOps-owned `life_browser_sessions` table and therefore
+ * call into the LifeOps route service because that app owns workflow-scoped
+ * browser sessions.
+ *
+ * Companion/auto-pair/sync authentication uses the
+ * `X-Browser-Bridge-Companion-Id` header paired with a bearer pairing
+ * token. The old `X-LifeOps-Browser-Companion-Id` and legacy
+ * `x-eliza-browser-companion-id` aliases were deliberately removed.
+ */
+import fs from "node:fs";
+import { checkRateLimit, } from "@elizaos/agent/api/rate-limiter";
+import { createIntegrationTelemetrySpan } from "@elizaos/agent/diagnostics/integration-observability";
+import { logger } from "@elizaos/core";
+import { BROWSER_BRIDGE_PACKAGE_PATH_TARGETS, } from "./contracts.js";
+import { buildBrowserBridgeCompanionPackage, getBrowserBridgeCompanionDownloadFile, getBrowserBridgeCompanionPackageStatus, openBrowserBridgeCompanionManager, openBrowserBridgeCompanionPackagePath, } from "./packaging.js";
+import { BROWSER_BRIDGE_ROUTE_SERVICE_TYPE, } from "./service.js";
+function getService(ctx) {
+    if (!ctx.state.runtime) {
+        ctx.error(ctx.res, "Agent runtime is not available", 503);
+        return null;
+    }
+    const service = ctx.state.runtime.getService(BROWSER_BRIDGE_ROUTE_SERVICE_TYPE);
+    if (!service) {
+        ctx.error(ctx.res, "Browser Bridge service is not available", 503);
+        return null;
+    }
+    return service;
+}
+function getBrowserCompanionAuth(ctx) {
+    const companionHeader = ctx.req.headers["x-browser-bridge-companion-id"];
+    const companionId = typeof companionHeader === "string" ? companionHeader.trim() : "";
+    if (!companionId) {
+        ctx.error(ctx.res, "Missing X-Browser-Bridge-Companion-Id header", 401);
+        return null;
+    }
+    const authHeader = typeof ctx.req.headers.authorization === "string"
+        ? ctx.req.headers.authorization.trim()
+        : "";
+    const match = /^Bearer\s+(.+)$/i.exec(authHeader);
+    const pairingToken = match?.[1]?.trim() ?? "";
+    if (!pairingToken) {
+        ctx.error(ctx.res, "Missing browser companion bearer token", 401);
+        return null;
+    }
+    return {
+        companionId,
+        pairingToken,
+    };
+}
+function browserAutoPairOriginAllowed(ctx) {
+    const originHeader = typeof ctx.req.headers.origin === "string"
+        ? ctx.req.headers.origin.trim()
+        : "";
+    if (!originHeader) {
+        return requestIsLoopback(ctx);
+    }
+    if (originHeader === ctx.url.origin) {
+        return true;
+    }
+    return (originHeader.startsWith("chrome-extension://") ||
+        originHeader.startsWith("safari-web-extension://"));
+}
+function requestIsLoopback(ctx) {
+    const remoteAddress = ctx.req.socket.remoteAddress?.trim().toLowerCase();
+    return (remoteAddress === "127.0.0.1" ||
+        remoteAddress === "::1" ||
+        remoteAddress === "0:0:0:0:0:0:0:1" ||
+        remoteAddress === "::ffff:127.0.0.1" ||
+        remoteAddress === "::ffff:0:127.0.0.1");
+}
+const BROWSER_BRIDGE_RATE_LIMITS = {
+    default: { maxRequests: 60, windowMs: 60_000 },
+};
+function rateLimitRequest(ctx, operation) {
+    const agentId = String(ctx.state.runtime?.agentId ?? "unknown");
+    const companionHeader = ctx.req.headers["x-browser-bridge-companion-id"];
+    const companionId = typeof companionHeader === "string" ? companionHeader.trim() : "anonymous";
+    const remoteAddress = ctx.req.socket.remoteAddress?.trim() ?? "unknown";
+    const limitKey = `${agentId}:${operation}:${remoteAddress}:${companionId}`;
+    const config = BROWSER_BRIDGE_RATE_LIMITS.default;
+    const { allowed, retryAfterMs } = checkRateLimit(limitKey, config);
+    if (!allowed) {
+        ctx.res.writeHead(429, {
+            "Content-Type": "application/json",
+            "Retry-After": String(Math.ceil(retryAfterMs / 1_000)),
+        });
+        ctx.res.end(JSON.stringify({ error: "Rate limit exceeded", retryAfterMs }));
+        return true;
+    }
+    return false;
+}
+function routeOperation(ctx) {
+    return `${ctx.method.toUpperCase()} ${ctx.pathname}`;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function isStatusError(error) {
+    return (error instanceof Error &&
+        "status" in error &&
+        typeof error.status === "number");
+}
+function decodeMatchedPathComponent(ctx, match, index, res, label) {
+    const raw = match?.[index];
+    return raw ? ctx.decodePathComponent(raw, res, label) : null;
+}
+async function runRoute(ctx, fn) {
+    const operation = routeOperation(ctx);
+    const span = createIntegrationTelemetrySpan({
+        boundary: "browser-bridge",
+        operation,
+    });
+    const service = getService(ctx);
+    if (!service) {
+        logger.info({
+            boundary: "browser-bridge",
+            operation,
+            statusCode: 503,
+        }, "[browser-bridge] Route rejected because agent runtime is unavailable");
+        span.failure({
+            statusCode: 503,
+            errorKind: "runtime_unavailable",
+        });
+        return true;
+    }
+    try {
+        await fn(service);
+        span.success({
+            statusCode: ctx.res.statusCode >= 400 ? ctx.res.statusCode : 200,
+        });
+        return true;
+    }
+    catch (error) {
+        if (isStatusError(error)) {
+            const logFn = error.status === 401
+                ? logger.debug.bind(logger)
+                : logger.warn.bind(logger);
+            logFn({
+                boundary: "browser-bridge",
+                operation,
+                statusCode: error.status,
+            }, `[browser-bridge] Route failed: ${error.message}`);
+            span.failure({
+                statusCode: error.status,
+                error,
+                errorKind: error.status === 401
+                    ? "browser_bridge_auth_invalid"
+                    : "browser_bridge_service_error",
+            });
+            ctx.error(ctx.res, error.message, error.status);
+            return true;
+        }
+        logger.error({
+            boundary: "browser-bridge",
+            operation,
+        }, `[browser-bridge] Route crashed: ${errorMessage(error)}`);
+        span.failure({
+            error,
+            errorKind: "unhandled_error",
+        });
+        throw error;
+    }
+}
+async function runStatelessRoute(ctx, fn) {
+    const operation = routeOperation(ctx);
+    const span = createIntegrationTelemetrySpan({
+        boundary: "browser-bridge",
+        operation,
+    });
+    try {
+        await fn();
+        span.success({
+            statusCode: ctx.res.statusCode >= 400 ? ctx.res.statusCode : 200,
+        });
+        return true;
+    }
+    catch (error) {
+        if (isStatusError(error)) {
+            logger.warn({
+                boundary: "browser-bridge",
+                operation,
+                statusCode: error.status,
+            }, `[browser-bridge] Route failed: ${error.message}`);
+            span.failure({
+                statusCode: error.status,
+                error,
+                errorKind: "browser_bridge_service_error",
+            });
+            ctx.error(ctx.res, error.message, error.status);
+            return true;
+        }
+        logger.error({
+            boundary: "browser-bridge",
+            operation,
+        }, `[browser-bridge] Route crashed: ${errorMessage(error)}`);
+        span.failure({
+            error,
+            errorKind: "unhandled_error",
+        });
+        throw error;
+    }
+}
+// ---------------------------------------------------------------------------
+// Dispatcher
+// ---------------------------------------------------------------------------
+export async function handleBrowserBridgeRoutes(ctx) {
+    const { req, res, method, pathname, json, readJsonBody } = ctx;
+    if (method === "GET" && pathname === "/api/browser-bridge/sessions") {
+        return runRoute(ctx, async (service) => {
+            json(res, {
+                sessions: await service.listBrowserSessions(ctx.state.adminEntityId),
+            });
+        });
+    }
+    if (method === "GET" && pathname === "/api/browser-bridge/settings") {
+        return runRoute(ctx, async (service) => {
+            json(res, {
+                settings: await service.getBrowserSettings(ctx.state.adminEntityId),
+            });
+        });
+    }
+    if (method === "POST" && pathname === "/api/browser-bridge/settings") {
+        const body = await readJsonBody(req, res);
+        if (!body)
+            return true;
+        return runRoute(ctx, async (service) => {
+            json(res, {
+                settings: await service.updateBrowserSettings(body, ctx.state.adminEntityId),
+            });
+        });
+    }
+    if (method === "POST" && pathname === "/api/browser-bridge/companions/pair") {
+        const body = await readJsonBody(req, res);
+        if (!body)
+            return true;
+        return runRoute(ctx, async (service) => {
+            json(res, await service.createBrowserCompanionPairing(body, ctx.state.adminEntityId), 201);
+        });
+    }
+    if (method === "POST" &&
+        pathname === "/api/browser-bridge/companions/auto-pair") {
+        if (rateLimitRequest(ctx, "companions:auto-pair")) {
+            return true;
+        }
+        if (!browserAutoPairOriginAllowed(ctx)) {
+            ctx.error(res, "browser auto-pair must come from the agent app or a browser extension", 403);
+            return true;
+        }
+        const body = await readJsonBody(req, res);
+        if (!body)
+            return true;
+        return runRoute(ctx, async (service) => {
+            json(res, await service.autoPairBrowserCompanion(body, ctx.url.origin, ctx.state.adminEntityId), 201);
+        });
+    }
+    if (method === "GET" && pathname === "/api/browser-bridge/companions") {
+        return runRoute(ctx, async (service) => {
+            json(res, {
+                companions: await service.listBrowserCompanions(ctx.state.adminEntityId),
+            });
+        });
+    }
+    if (method === "GET" && pathname === "/api/browser-bridge/packages") {
+        return runStatelessRoute(ctx, async () => {
+            json(res, { status: getBrowserBridgeCompanionPackageStatus() });
+        });
+    }
+    if (method === "POST" &&
+        pathname === "/api/browser-bridge/packages/open-path") {
+        if (!requestIsLoopback(ctx)) {
+            ctx.error(res, "Local extension install helpers can only run on the same machine as the agent", 403);
+            return true;
+        }
+        const body = await readJsonBody(req, res);
+        if (!body)
+            return true;
+        if (typeof body.target !== "string" ||
+            !BROWSER_BRIDGE_PACKAGE_PATH_TARGETS.includes(body.target)) {
+            ctx.error(res, `target must be one of: ${BROWSER_BRIDGE_PACKAGE_PATH_TARGETS.join(", ")}`, 400);
+            return true;
+        }
+        const validatedTarget = body.target;
+        return runStatelessRoute(ctx, async () => {
+            json(res, await openBrowserBridgeCompanionPackagePath(validatedTarget, {
+                revealOnly: body.revealOnly === true,
+            }));
+        });
+    }
+    if (method === "POST" && pathname === "/api/browser-bridge/companions/sync") {
+        if (rateLimitRequest(ctx, "companions:sync")) {
+            return true;
+        }
+        const body = await readJsonBody(req, res);
+        if (!body)
+            return true;
+        return runRoute(ctx, async (service) => {
+            const auth = getBrowserCompanionAuth(ctx);
+            if (!auth) {
+                return;
+            }
+            json(res, await service.syncBrowserCompanion(auth.companionId, auth.pairingToken, body, ctx.state.adminEntityId));
+        });
+    }
+    if (method === "GET" && pathname === "/api/browser-bridge/tabs") {
+        return runRoute(ctx, async (service) => {
+            json(res, {
+                tabs: await service.listBrowserTabs(ctx.state.adminEntityId),
+            });
+        });
+    }
+    const browserPackageBuildMatch = pathname.match(/^\/api\/browser-bridge\/packages\/([^/]+)\/build$/);
+    if (method === "POST" && browserPackageBuildMatch) {
+        const browser = decodeMatchedPathComponent(ctx, browserPackageBuildMatch, 1, res, "browser package target");
+        if (!browser)
+            return true;
+        if (browser !== "chrome" && browser !== "safari") {
+            ctx.error(res, "browser must be chrome or safari", 400);
+            return true;
+        }
+        return runStatelessRoute(ctx, async () => {
+            json(res, {
+                status: await buildBrowserBridgeCompanionPackage(browser),
+            });
+        });
+    }
+    const browserPackageOpenManagerMatch = pathname.match(/^\/api\/browser-bridge\/packages\/([^/]+)\/open-manager$/);
+    if (method === "POST" && browserPackageOpenManagerMatch) {
+        if (!requestIsLoopback(ctx)) {
+            ctx.error(res, "Local extension install helpers can only run on the same machine as the agent", 403);
+            return true;
+        }
+        const browser = decodeMatchedPathComponent(ctx, browserPackageOpenManagerMatch, 1, res, "browser package target");
+        if (!browser)
+            return true;
+        if (browser !== "chrome" && browser !== "safari") {
+            ctx.error(res, "browser must be chrome or safari", 400);
+            return true;
+        }
+        return runStatelessRoute(ctx, async () => {
+            json(res, await openBrowserBridgeCompanionManager(browser));
+        });
+    }
+    const browserPackageDownloadMatch = pathname.match(/^\/api\/browser-bridge\/packages\/([^/]+)\/download$/);
+    if (method === "GET" && browserPackageDownloadMatch) {
+        const browser = decodeMatchedPathComponent(ctx, browserPackageDownloadMatch, 1, res, "browser package target");
+        if (!browser)
+            return true;
+        if (browser !== "chrome" && browser !== "safari") {
+            ctx.error(res, "browser must be chrome or safari", 400);
+            return true;
+        }
+        return runStatelessRoute(ctx, async () => {
+            const artifact = getBrowserBridgeCompanionDownloadFile(browser);
+            res.statusCode = 200;
+            res.setHeader("Content-Type", artifact.contentType);
+            res.setHeader("Content-Disposition", `attachment; filename="${artifact.filename}"`);
+            await new Promise((resolve, reject) => {
+                const stream = fs.createReadStream(artifact.path);
+                stream.on("error", reject);
+                res.on("error", reject);
+                stream.on("end", resolve);
+                stream.pipe(res);
+            });
+        });
+    }
+    if (method === "GET" && pathname === "/api/browser-bridge/current-page") {
+        return runRoute(ctx, async (service) => {
+            json(res, {
+                page: await service.getCurrentBrowserPage(ctx.state.adminEntityId),
+            });
+        });
+    }
+    if (method === "POST" && pathname === "/api/browser-bridge/sync") {
+        const body = await readJsonBody(req, res);
+        if (!body)
+            return true;
+        return runRoute(ctx, async (service) => {
+            json(res, await service.syncBrowserState(body, ctx.state.adminEntityId));
+        });
+    }
+    if (method === "POST" && pathname === "/api/browser-bridge/sessions") {
+        const body = await readJsonBody(req, res);
+        if (!body)
+            return true;
+        return runRoute(ctx, async (service) => {
+            json(res, {
+                session: await service.createBrowserSession(body, ctx.state.adminEntityId),
+            }, 201);
+        });
+    }
+    const browserSessionMatch = pathname.match(/^\/api\/browser-bridge\/sessions\/([^/]+)$/);
+    if (browserSessionMatch) {
+        const sessionId = decodeMatchedPathComponent(ctx, browserSessionMatch, 1, res, "browser session id");
+        if (!sessionId)
+            return true;
+        if (method === "GET") {
+            return runRoute(ctx, async (service) => {
+                json(res, {
+                    session: await service.getBrowserSession(sessionId, ctx.state.adminEntityId),
+                });
+            });
+        }
+    }
+    const browserConfirmMatch = pathname.match(/^\/api\/browser-bridge\/sessions\/([^/]+)\/confirm$/);
+    if (method === "POST" && browserConfirmMatch) {
+        const sessionId = decodeMatchedPathComponent(ctx, browserConfirmMatch, 1, res, "browser session id");
+        if (!sessionId)
+            return true;
+        const body = await readJsonBody(req, res);
+        if (!body)
+            return true;
+        return runRoute(ctx, async (service) => {
+            json(res, {
+                session: await service.confirmBrowserSession(sessionId, body, ctx.state.adminEntityId),
+            });
+        });
+    }
+    const browserProgressMatch = pathname.match(/^\/api\/browser-bridge\/sessions\/([^/]+)\/progress$/);
+    if (method === "POST" && browserProgressMatch) {
+        const sessionId = decodeMatchedPathComponent(ctx, browserProgressMatch, 1, res, "browser session id");
+        if (!sessionId)
+            return true;
+        const body = await readJsonBody(req, res);
+        if (!body)
+            return true;
+        return runRoute(ctx, async (service) => {
+            json(res, {
+                session: await service.updateBrowserSessionProgress(sessionId, body, ctx.state.adminEntityId),
+            });
+        });
+    }
+    const browserCompleteMatch = pathname.match(/^\/api\/browser-bridge\/sessions\/([^/]+)\/complete$/);
+    if (method === "POST" && browserCompleteMatch) {
+        const sessionId = decodeMatchedPathComponent(ctx, browserCompleteMatch, 1, res, "browser session id");
+        if (!sessionId)
+            return true;
+        const body = await readJsonBody(req, res);
+        if (!body)
+            return true;
+        return runRoute(ctx, async (service) => {
+            json(res, {
+                session: await service.completeBrowserSession(sessionId, body, ctx.state.adminEntityId),
+            });
+        });
+    }
+    const browserCompanionProgressMatch = pathname.match(/^\/api\/browser-bridge\/companions\/sessions\/([^/]+)\/progress$/);
+    if (method === "POST" && browserCompanionProgressMatch) {
+        if (rateLimitRequest(ctx, "companions:session-progress")) {
+            return true;
+        }
+        const sessionId = decodeMatchedPathComponent(ctx, browserCompanionProgressMatch, 1, res, "browser session id");
+        if (!sessionId)
+            return true;
+        const body = await readJsonBody(req, res);
+        if (!body)
+            return true;
+        return runRoute(ctx, async (service) => {
+            const auth = getBrowserCompanionAuth(ctx);
+            if (!auth) {
+                return;
+            }
+            json(res, {
+                session: await service.updateBrowserSessionProgressFromCompanion(auth.companionId, auth.pairingToken, sessionId, body, ctx.state.adminEntityId),
+            });
+        });
+    }
+    const browserCompanionCompleteMatch = pathname.match(/^\/api\/browser-bridge\/companions\/sessions\/([^/]+)\/complete$/);
+    if (method === "POST" && browserCompanionCompleteMatch) {
+        if (rateLimitRequest(ctx, "companions:session-complete")) {
+            return true;
+        }
+        const sessionId = decodeMatchedPathComponent(ctx, browserCompanionCompleteMatch, 1, res, "browser session id");
+        if (!sessionId)
+            return true;
+        const body = await readJsonBody(req, res);
+        if (!body)
+            return true;
+        return runRoute(ctx, async (service) => {
+            const auth = getBrowserCompanionAuth(ctx);
+            if (!auth) {
+                return;
+            }
+            json(res, {
+                session: await service.completeBrowserSessionFromCompanion(auth.companionId, auth.pairingToken, sessionId, body, ctx.state.adminEntityId),
+            });
+        });
+    }
+    return false;
+}
+export { rateLimitRequest };