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

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

@@ -0,0 +1,503 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { VERSION } from "@elizaos/agent/runtime/version";
+const pluginSrcDir = path.dirname(fileURLToPath(import.meta.url));
+const elizaRoot = path.resolve(pluginSrcDir, "../../../");
+const outerRepoRoot = path.resolve(elizaRoot, "../");
+function uniquePaths(paths) {
+    return [...new Set(paths.map((candidate) => path.resolve(candidate)))];
+}
+function ancestorPaths(start) {
+    const ancestors = [];
+    let current = path.resolve(start);
+    while (true) {
+        ancestors.push(current);
+        const parent = path.dirname(current);
+        if (parent === current) {
+            return ancestors;
+        }
+        current = parent;
+    }
+}
+const workspaceRootCandidates = uniquePaths([
+    process.cwd(),
+    outerRepoRoot,
+    elizaRoot,
+    ...ancestorPaths(pluginSrcDir),
+    ...ancestorPaths(process.cwd()),
+]);
+const extensionRootCandidates = workspaceRootCandidates.flatMap((root) => [
+    path.join(root, "eliza", "apps", "browser-bridge"),
+    path.join(root, "apps", "browser-bridge"),
+    path.join(root, "apps", "app-lifeops", "extensions", "lifeops-browser"),
+    path.join(root, "eliza", "apps", "app-lifeops", "extensions", "lifeops-browser"),
+    path.join(root, "apps", "extensions", "lifeops-browser"),
+    path.join(root, "eliza", "apps", "extensions", "lifeops-browser"),
+]);
+const packageJsonCandidates = workspaceRootCandidates.flatMap((root) => [
+    path.join(root, "package.json"),
+    path.join(root, "eliza", "package.json"),
+]);
+const extensionPackageJsonCandidates = uniquePaths(extensionRootCandidates.map((candidate) => path.join(candidate, "package.json")));
+const buildInfoCandidates = workspaceRootCandidates.flatMap((root) => [
+    path.join(root, "dist", "build-info.json"),
+    path.join(root, "eliza", "dist", "build-info.json"),
+]);
+const NIGHTLY_EPOCH_UTC_MS = Date.UTC(2020, 0, 1);
+const DEFAULT_REPOSITORY = "elizaos/eliza";
+function existingPath(candidate) {
+    return fs.existsSync(candidate) ? candidate : null;
+}
+function firstExisting(candidates) {
+    for (const candidate of candidates) {
+        const resolved = existingPath(candidate);
+        if (resolved) {
+            return resolved;
+        }
+    }
+    return null;
+}
+function readVersionField(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return null;
+    }
+    const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+    return typeof parsed.version === "string" && parsed.version.trim()
+        ? parsed.version.trim()
+        : null;
+}
+function normalizeRepositoryIdentifier(value) {
+    if (typeof value === "string") {
+        const trimmed = value.trim().replace(/^git\+/, "");
+        if (!trimmed) {
+            return null;
+        }
+        const shorthandMatch = trimmed.match(/^([^/\s]+)\/([^/\s]+)$/);
+        if (shorthandMatch) {
+            return `${shorthandMatch[1]}/${shorthandMatch[2]}`;
+        }
+        const githubMatch = trimmed.match(/github\.com[/:]([^/]+)\/([^/]+?)(?:\.git)?$/i);
+        if (githubMatch) {
+            return `${githubMatch[1]}/${githubMatch[2]}`;
+        }
+        return null;
+    }
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+        const repositoryRecord = value;
+        return normalizeRepositoryIdentifier(repositoryRecord.url);
+    }
+    return null;
+}
+function readRepositoryField(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return null;
+    }
+    const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+    return normalizeRepositoryIdentifier(parsed.repository);
+}
+function resolveBrowserBridgeReleaseVersion() {
+    for (const candidate of extensionPackageJsonCandidates) {
+        const value = readVersionField(candidate);
+        if (value) {
+            return value;
+        }
+    }
+    for (const candidate of packageJsonCandidates) {
+        const value = readVersionField(candidate);
+        if (value) {
+            return value;
+        }
+    }
+    for (const candidate of buildInfoCandidates) {
+        const value = readVersionField(candidate);
+        if (value) {
+            return value;
+        }
+    }
+    return VERSION;
+}
+function resolveBrowserBridgeReleaseRepository(env = process.env) {
+    const configuredRepository = typeof env.GITHUB_REPOSITORY === "string" && env.GITHUB_REPOSITORY.trim()
+        ? env.GITHUB_REPOSITORY.trim()
+        : null;
+    if (configuredRepository) {
+        return configuredRepository;
+    }
+    for (const candidate of extensionPackageJsonCandidates) {
+        const repository = readRepositoryField(candidate);
+        if (repository) {
+            return repository;
+        }
+    }
+    for (const candidate of packageJsonCandidates) {
+        const repository = readRepositoryField(candidate);
+        if (repository) {
+            return repository;
+        }
+    }
+    return DEFAULT_REPOSITORY;
+}
+function normalizeReleaseVersionCandidate(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        return null;
+    }
+    return trimmed.startsWith("v") ? trimmed.slice(1) : trimmed;
+}
+function parseReleaseVersion(raw) {
+    const normalized = normalizeReleaseVersionCandidate(raw);
+    if (!normalized) {
+        return null;
+    }
+    const match = normalized.match(/^(\d+)\.(\d+)\.(\d+)(?:-(alpha|beta|rc|nightly)\.([0-9A-Za-z.-]+))?$/);
+    if (!match) {
+        return null;
+    }
+    const majorRaw = match[1];
+    const minorRaw = match[2];
+    const patchRaw = match[3];
+    if (!majorRaw || !minorRaw || !patchRaw) {
+        return null;
+    }
+    const major = Number.parseInt(majorRaw, 10);
+    const minor = Number.parseInt(minorRaw, 10);
+    const patch = Number.parseInt(patchRaw, 10);
+    const prereleaseLabel = match[4] ?? null;
+    const prereleaseValue = match[5] ?? null;
+    return {
+        raw: normalized,
+        tag: `v${normalized}`,
+        major,
+        minor,
+        patch,
+        prereleaseLabel,
+        prereleaseValue,
+        baseVersion: `${major}.${minor}.${patch}`,
+        hasPrerelease: prereleaseLabel !== null,
+    };
+}
+function clamp(value, minimum, maximum) {
+    return Math.min(maximum, Math.max(minimum, value));
+}
+function parseNumericPrereleaseValue(value) {
+    if (!value) {
+        return 0;
+    }
+    const parsed = Number.parseInt(value, 10);
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+function deriveNightlyOrdinal(value) {
+    if (typeof value === "string" && /^\d{8}$/.test(value)) {
+        const year = Number.parseInt(value.slice(0, 4), 10);
+        const month = Number.parseInt(value.slice(4, 6), 10);
+        const day = Number.parseInt(value.slice(6, 8), 10);
+        const utcMs = Date.UTC(year, month - 1, day);
+        if (Number.isFinite(utcMs)) {
+            return clamp(Math.floor((utcMs - NIGHTLY_EPOCH_UTC_MS) / 86_400_000) + 1, 1, 9999);
+        }
+    }
+    const parsed = parseNumericPrereleaseValue(value);
+    if (parsed > 0) {
+        return clamp(parsed, 1, 9999);
+    }
+    let hash = 0;
+    for (const character of String(value ?? "")) {
+        hash = (hash * 33 + character.charCodeAt(0)) % 9999;
+    }
+    return clamp(hash, 1, 9999);
+}
+function derivePrereleaseOrdinal(release) {
+    if (!release.hasPrerelease || !release.prereleaseLabel) {
+        return 0;
+    }
+    if (release.prereleaseLabel === "nightly") {
+        return deriveNightlyOrdinal(release.prereleaseValue);
+    }
+    return clamp(parseNumericPrereleaseValue(release.prereleaseValue), 0, 9999);
+}
+function buildChromeExtensionVersion(release) {
+    let buildSegment = 60000;
+    if (release.hasPrerelease && release.prereleaseLabel) {
+        const ordinal = derivePrereleaseOrdinal(release);
+        buildSegment =
+            release.prereleaseLabel === "rc"
+                ? 50000 + ordinal
+                : release.prereleaseLabel === "beta"
+                    ? 40000 + ordinal
+                    : release.prereleaseLabel === "alpha"
+                        ? 30000 + ordinal
+                        : 10000 + ordinal;
+    }
+    return [release.major, release.minor, release.patch, buildSegment].join(".");
+}
+function buildSafariExtensionVersions(release) {
+    const ordinal = derivePrereleaseOrdinal(release);
+    const suffix = !release.hasPrerelease || !release.prereleaseLabel
+        ? 9000
+        : release.prereleaseLabel === "rc"
+            ? 8000 + ordinal
+            : release.prereleaseLabel === "beta"
+                ? 7000 + ordinal
+                : release.prereleaseLabel === "alpha"
+                    ? 6000 + ordinal
+                    : 5000 + ordinal;
+    return {
+        marketingVersion: release.baseVersion,
+        buildVersion: String(release.major * 100_000_000 +
+            release.minor * 1_000_000 +
+            release.patch * 10_000 +
+            suffix),
+    };
+}
+function versionedArtifactName(prefix, extension, release) {
+    return `${prefix}-${release.tag}.${extension.replace(/^\./, "")}`;
+}
+function buildGitHubReleasePageUrl(repository, release) {
+    return `https://github.com/${repository}/releases/tag/${release.tag}`;
+}
+function buildGitHubReleaseAssetDownloadUrl(repository, release, assetName) {
+    return `https://github.com/${repository}/releases/download/${release.tag}/${assetName}`;
+}
+function resolveBrowserBridgeStoreUrls(env = process.env) {
+    const chromeWebStoreUrl = typeof env.ELIZA_BROWSER_BRIDGE_CHROME_STORE_URL === "string" &&
+        env.ELIZA_BROWSER_BRIDGE_CHROME_STORE_URL.trim()
+        ? env.ELIZA_BROWSER_BRIDGE_CHROME_STORE_URL.trim()
+        : null;
+    const safariAppStoreUrl = typeof env.ELIZA_BROWSER_BRIDGE_SAFARI_STORE_URL === "string" &&
+        env.ELIZA_BROWSER_BRIDGE_SAFARI_STORE_URL.trim()
+        ? env.ELIZA_BROWSER_BRIDGE_SAFARI_STORE_URL.trim()
+        : null;
+    return {
+        chromeWebStoreUrl,
+        safariAppStoreUrl,
+    };
+}
+export function buildBrowserBridgeReleaseManifestForVersion(rawVersion, env = process.env) {
+    const release = parseReleaseVersion(rawVersion);
+    if (!release) {
+        return null;
+    }
+    const repository = resolveBrowserBridgeReleaseRepository(env);
+    const storeUrls = resolveBrowserBridgeStoreUrls(env);
+    const chromeAssetName = versionedArtifactName("browser-bridge-chrome", "zip", release);
+    const safariAssetName = versionedArtifactName("browser-bridge-safari", "zip", release);
+    const safariVersions = buildSafariExtensionVersions(release);
+    return {
+        schema: "browser_bridge_release_v2",
+        releaseTag: release.tag,
+        releaseVersion: release.raw,
+        repository,
+        releasePageUrl: buildGitHubReleasePageUrl(repository, release),
+        chromeVersion: buildChromeExtensionVersion(release),
+        chromeVersionName: release.raw,
+        safariMarketingVersion: safariVersions.marketingVersion,
+        safariBuildVersion: safariVersions.buildVersion,
+        chrome: {
+            installKind: storeUrls.chromeWebStoreUrl
+                ? "chrome_web_store"
+                : "github_release",
+            installUrl: storeUrls.chromeWebStoreUrl ??
+                buildGitHubReleaseAssetDownloadUrl(repository, release, chromeAssetName),
+            storeListingUrl: storeUrls.chromeWebStoreUrl,
+            asset: {
+                fileName: chromeAssetName,
+                downloadUrl: buildGitHubReleaseAssetDownloadUrl(repository, release, chromeAssetName),
+            },
+        },
+        safari: {
+            installKind: storeUrls.safariAppStoreUrl
+                ? "apple_app_store"
+                : "github_release",
+            installUrl: storeUrls.safariAppStoreUrl ??
+                buildGitHubReleaseAssetDownloadUrl(repository, release, safariAssetName),
+            storeListingUrl: storeUrls.safariAppStoreUrl,
+            asset: {
+                fileName: safariAssetName,
+                downloadUrl: buildGitHubReleaseAssetDownloadUrl(repository, release, safariAssetName),
+            },
+        },
+        generatedAt: new Date().toISOString(),
+    };
+}
+function readReleaseManifest(artifactsDir) {
+    const manifestPath = path.join(artifactsDir, "browser-bridge-release-manifest.json");
+    if (!fs.existsSync(manifestPath)) {
+        return null;
+    }
+    try {
+        return JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function resolveBrowserBridgeReleaseManifest(artifactsDir, options) {
+    if (artifactsDir) {
+        const releaseManifest = readReleaseManifest(artifactsDir);
+        if (releaseManifest) {
+            return releaseManifest;
+        }
+    }
+    if (!options?.allowSynthesis) {
+        return null;
+    }
+    return buildBrowserBridgeReleaseManifestForVersion(options.version ?? resolveBrowserBridgeReleaseVersion(), options.env);
+}
+function resolveBrowserBridgeExtensionRoot() {
+    return firstExisting(extensionRootCandidates);
+}
+function packageScriptName(browser) {
+    return browser === "safari" ? "package-safari.mjs" : "package-chrome.mjs";
+}
+function runCommand(command, args, cwd) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            cwd,
+            stdio: ["ignore", "pipe", "pipe"],
+            env: process.env,
+        });
+        let stderr = "";
+        child.stderr.on("data", (chunk) => {
+            stderr += String(chunk);
+        });
+        child.on("error", reject);
+        child.on("exit", (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject(new Error(stderr.trim() ||
+                `${command} ${args.join(" ")} exited with code ${code ?? "unknown"}`));
+        });
+    });
+}
+export function resolveBrowserBridgeExtensionPath() {
+    return resolveBrowserBridgeExtensionRoot();
+}
+export function resolveBrowserBridgeCompanionPackagePath(status, target) {
+    switch (target) {
+        case "extension_root":
+            return status.extensionPath;
+        case "chrome_build":
+            return status.chromeBuildPath;
+        case "chrome_package":
+            return status.chromePackagePath;
+        case "safari_web_extension":
+            return status.safariWebExtensionPath;
+        case "safari_app":
+            return status.safariAppPath;
+        case "safari_package":
+            return status.safariPackagePath;
+        default:
+            return null;
+    }
+}
+async function openPathInHost(pathValue, revealOnly) {
+    const revealDirectory = revealOnly &&
+        fs.existsSync(pathValue) &&
+        fs.statSync(pathValue).isDirectory()
+        ? pathValue
+        : path.dirname(pathValue);
+    const cwd = outerRepoRoot;
+    switch (process.platform) {
+        case "darwin":
+            await runCommand("open", revealOnly ? ["-R", pathValue] : [pathValue], cwd);
+            return;
+        case "win32":
+            await runCommand(revealOnly ? "explorer.exe" : "cmd", revealOnly ? [`/select,${pathValue}`] : ["/c", "start", "", pathValue], cwd);
+            return;
+        case "linux":
+            await runCommand("xdg-open", [revealOnly ? revealDirectory : pathValue], cwd);
+            return;
+        default:
+            throw new Error(`Opening local paths is not supported on ${process.platform}`);
+    }
+}
+async function openChromeExtensionsManager() {
+    const cwd = outerRepoRoot;
+    switch (process.platform) {
+        case "darwin":
+            await runCommand("open", ["-a", "Google Chrome", "chrome://extensions/"], cwd);
+            return;
+        case "win32":
+            await runCommand("cmd", ["/c", "start", "", "chrome", "chrome://extensions/"], cwd);
+            return;
+        case "linux":
+            await runCommand("xdg-open", ["chrome://extensions/"], cwd);
+            return;
+        default:
+            throw new Error(`Opening the Chrome extensions manager is not supported on ${process.platform}`);
+    }
+}
+export function getBrowserBridgeCompanionPackageStatus() {
+    const resolvedExtensionPath = resolveBrowserBridgeExtensionPath();
+    if (!resolvedExtensionPath) {
+        return {
+            extensionPath: null,
+            chromeBuildPath: null,
+            chromePackagePath: null,
+            safariWebExtensionPath: null,
+            safariAppPath: null,
+            safariPackagePath: null,
+            releaseManifest: resolveBrowserBridgeReleaseManifest(null, {
+                allowSynthesis: true,
+            }),
+        };
+    }
+    const distDir = path.join(resolvedExtensionPath, "dist");
+    const artifactsDir = path.join(distDir, "artifacts");
+    return {
+        extensionPath: resolvedExtensionPath,
+        chromeBuildPath: existingPath(path.join(distDir, "chrome")),
+        chromePackagePath: existingPath(path.join(artifactsDir, "browser-bridge-chrome.zip")),
+        safariWebExtensionPath: existingPath(path.join(distDir, "safari")),
+        safariAppPath: existingPath(path.join(artifactsDir, "Agent Browser Bridge.app")),
+        safariPackagePath: existingPath(path.join(artifactsDir, "browser-bridge-safari.zip")),
+        releaseManifest: resolveBrowserBridgeReleaseManifest(artifactsDir, {
+            allowSynthesis: true,
+        }),
+    };
+}
+export function getBrowserBridgeCompanionDownloadFile(browser) {
+    const status = getBrowserBridgeCompanionPackageStatus();
+    const filePath = browser === "safari" ? status.safariPackagePath : status.chromePackagePath;
+    if (!filePath) {
+        throw new Error(`${browser === "safari" ? "Safari" : "Chrome"} package has not been built yet`);
+    }
+    return {
+        path: filePath,
+        filename: path.basename(filePath),
+        contentType: "application/zip",
+    };
+}
+export async function openBrowserBridgeCompanionPackagePath(target, options) {
+    const revealOnly = options?.revealOnly ?? false;
+    const status = getBrowserBridgeCompanionPackageStatus();
+    const resolvedPath = resolveBrowserBridgeCompanionPackagePath(status, target);
+    if (!resolvedPath) {
+        throw new Error(`Browser Bridge path is not available for ${target}`);
+    }
+    await openPathInHost(resolvedPath, revealOnly);
+    return {
+        target,
+        path: resolvedPath,
+        revealOnly,
+    };
+}
+export async function openBrowserBridgeCompanionManager(browser) {
+    if (browser !== "chrome") {
+        throw new Error("Only Chrome exposes a local extensions manager for unpacked install");
+    }
+    await openChromeExtensionsManager();
+    return { browser };
+}
+export async function buildBrowserBridgeCompanionPackage(browser) {
+    const resolvedExtensionPath = resolveBrowserBridgeExtensionPath();
+    if (!resolvedExtensionPath) {
+        throw new Error("Browser Bridge extension workspace is not available");
+    }
+    await runCommand("bun", [path.join(resolvedExtensionPath, "scripts", packageScriptName(browser))], resolvedExtensionPath);
+    return getBrowserBridgeCompanionPackageStatus();
+}

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

@@ -0,0 +1,10 @@
+/**
+ * Agent Browser Bridge plugin export.
+ *
+ * plugin-collector discovers `routes` and `schema` at runtime. Milady loads
+ * this as a core plugin so the Browser Workspace UI and browser companion
+ * extension share one route surface.
+ */
+import type { Plugin } from "@elizaos/core";
+export declare const browserBridgePlugin: Plugin;
+//# sourceMappingURL=plugin.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../../../../../plugins/plugin-browser-bridge/src/plugin.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AASH,OAAO,KAAK,EAAgB,MAAM,EAAe,MAAM,eAAe,CAAC;AAsKvE,eAAO,MAAM,mBAAmB,EAAE,MAOjC,CAAC"}

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

@@ -0,0 +1,140 @@
+/**
+ * Agent Browser Bridge plugin export.
+ *
+ * plugin-collector discovers `routes` and `schema` at runtime. Milady loads
+ * this as a core plugin so the Browser Workspace UI and browser companion
+ * extension share one route surface.
+ */
+import { TLSSocket } from "node:tls";
+import { readJsonBody as httpReadJsonBody, sendJson as httpSendJson, sendJsonError as httpSendJsonError, } from "@elizaos/agent/api/http-helpers";
+import { resolveCanonicalOwnerId } from "@elizaos/core";
+import { browserBridgeActions } from "./actions.js";
+import { handleBrowserBridgeRoutes, } from "./routes.js";
+import { browserBridgeSchema } from "./schema.js";
+function json(res, data, status = 200) {
+    httpSendJson(res, data, status);
+}
+function error(res, message, status = 400) {
+    httpSendJsonError(res, message, status);
+}
+function httpDecodePathComponent(raw, res, fieldName) {
+    try {
+        return decodeURIComponent(raw);
+    }
+    catch {
+        httpSendJsonError(res, `Invalid ${fieldName}: malformed URL encoding`, 400);
+        return null;
+    }
+}
+function firstHeaderValue(value) {
+    if (Array.isArray(value)) {
+        return firstHeaderValue(value[0]);
+    }
+    if (typeof value !== "string") {
+        return null;
+    }
+    const normalized = value.split(",")[0]?.trim();
+    return normalized ? normalized : null;
+}
+function requestBaseUrl(req) {
+    const headers = req.headers ?? {};
+    const protocol = firstHeaderValue(headers["x-forwarded-proto"]) ??
+        (req.socket instanceof TLSSocket && req.socket.encrypted
+            ? "https"
+            : "http");
+    const host = firstHeaderValue(headers["x-forwarded-host"]) ??
+        firstHeaderValue(headers.host) ??
+        "localhost";
+    return `${protocol}://${host}`;
+}
+function routeOwnerEntityId(runtime) {
+    const ownerId = runtime ? resolveCanonicalOwnerId(runtime) : null;
+    return typeof ownerId === "string" ? ownerId : null;
+}
+function buildRouteContext(req, res, runtime) {
+    const method = (req.method ?? "GET").toUpperCase();
+    const url = new URL(req.url ?? "/", requestBaseUrl(req));
+    return {
+        req,
+        res,
+        method,
+        pathname: url.pathname,
+        url,
+        state: {
+            runtime,
+            adminEntityId: routeOwnerEntityId(runtime),
+        },
+        json,
+        error,
+        readJsonBody: httpReadJsonBody,
+        decodePathComponent: httpDecodePathComponent,
+    };
+}
+const STATIC_ROUTES = [
+    { type: "GET", path: "/api/browser-bridge/sessions" },
+    { type: "GET", path: "/api/browser-bridge/settings" },
+    { type: "POST", path: "/api/browser-bridge/settings" },
+    { type: "POST", path: "/api/browser-bridge/companions/pair" },
+    { type: "POST", path: "/api/browser-bridge/companions/auto-pair" },
+    { type: "GET", path: "/api/browser-bridge/companions" },
+    { type: "GET", path: "/api/browser-bridge/packages" },
+    { type: "POST", path: "/api/browser-bridge/packages/open-path" },
+    { type: "POST", path: "/api/browser-bridge/companions/sync", public: true },
+    { type: "GET", path: "/api/browser-bridge/tabs" },
+    { type: "GET", path: "/api/browser-bridge/current-page" },
+    { type: "POST", path: "/api/browser-bridge/sync" },
+    { type: "POST", path: "/api/browser-bridge/sessions" },
+];
+const DYNAMIC_ROUTES = [
+    { type: "GET", path: "/api/browser-bridge/sessions/:id" },
+    { type: "POST", path: "/api/browser-bridge/sessions/:id/confirm" },
+    { type: "POST", path: "/api/browser-bridge/sessions/:id/progress" },
+    { type: "POST", path: "/api/browser-bridge/sessions/:id/complete" },
+    {
+        type: "POST",
+        path: "/api/browser-bridge/companions/sessions/:id/progress",
+        public: true,
+    },
+    {
+        type: "POST",
+        path: "/api/browser-bridge/companions/sessions/:id/complete",
+        public: true,
+    },
+    { type: "POST", path: "/api/browser-bridge/packages/:browser/build" },
+    {
+        type: "POST",
+        path: "/api/browser-bridge/packages/:browser/open-manager",
+    },
+    { type: "GET", path: "/api/browser-bridge/packages/:browser/download" },
+];
+function routeHandler() {
+    return async (req, res, runtime) => {
+        const httpReq = req;
+        const httpRes = res;
+        const ctx = buildRouteContext(httpReq, httpRes, runtime ?? null);
+        await handleBrowserBridgeRoutes(ctx);
+    };
+}
+const browserBridgePluginRoutes = [
+    ...STATIC_ROUTES.map((r) => ({
+        type: r.type,
+        path: r.path,
+        rawPath: true,
+        ...(r.public ? { public: true } : {}),
+        handler: routeHandler(),
+    })),
+    ...DYNAMIC_ROUTES.map((r) => ({
+        type: r.type,
+        path: r.path,
+        rawPath: true,
+        ...(r.public ? { public: true } : {}),
+        handler: routeHandler(),
+    })),
+];
+export const browserBridgePlugin = {
+    name: "@elizaos/plugin-browser-bridge",
+    description: "Agent Browser Bridge: Chrome/Safari companion pairing, settings, tab + page context sync, packaging artifacts, and workflow-linked browser session endpoints.",
+    schema: browserBridgeSchema,
+    routes: browserBridgePluginRoutes,
+    actions: browserBridgeActions,
+};

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

@@ -0,0 +1,37 @@
+/**
+ * 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 type http from "node:http";
+import type { ReadJsonBodyOptions } from "@elizaos/agent/api/http-helpers";
+import { type AgentRuntime, type UUID } from "@elizaos/core";
+export interface BrowserBridgeRouteContext {
+    req: http.IncomingMessage;
+    res: http.ServerResponse;
+    method: string;
+    pathname: string;
+    url: URL;
+    state: {
+        runtime: AgentRuntime | null;
+        adminEntityId: UUID | null;
+    };
+    json: (res: http.ServerResponse, data: unknown, status?: number) => void;
+    error: (res: http.ServerResponse, message: string, status?: number) => void;
+    readJsonBody: <T extends object>(req: http.IncomingMessage, res: http.ServerResponse, options?: ReadJsonBodyOptions) => Promise<T | null>;
+    decodePathComponent: (raw: string, res: http.ServerResponse, label: string) => string | null;
+}
+declare function rateLimitRequest(ctx: BrowserBridgeRouteContext, operation: string): boolean;
+export declare function handleBrowserBridgeRoutes(ctx: BrowserBridgeRouteContext): Promise<boolean>;
+export { rateLimitRequest };
+//# sourceMappingURL=routes.d.ts.map