@elizaos/plugin-browser 2.0.0-alpha.9 → 2.0.3-beta.2

package/dist/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAWH,eAAO,MAAM,eAAe,mDAAsB,CAAC;AAEnD,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgCnC,CAAC;AAEF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0BjC,CAAC;AAEF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgC7B,CAAC;AAEF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuBrC,CAAC;AAEF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKtB,CAAC"}

package/dist/schema.js

@@ -0,0 +1,133 @@
+import {
+  boolean,
+  index,
+  integer,
+  pgSchema,
+  text,
+  unique
+} from "drizzle-orm/pg-core";
+const browserPgSchema = pgSchema("browser");
+const browserBridgeCompanions = browserPgSchema.table(
+  "browser_bridge_companions",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    browser: text("browser").notNull(),
+    profileId: text("profile_id").notNull(),
+    profileLabel: text("profile_label").notNull().default(""),
+    label: text("label").notNull().default(""),
+    extensionVersion: text("extension_version"),
+    connectionState: text("connection_state").notNull().default("disconnected"),
+    permissionsJson: text("permissions_json").notNull().default("{}"),
+    pairingTokenHash: text("pairing_token_hash"),
+    pairingTokenExpiresAt: text("pairing_token_expires_at"),
+    pairingTokenRevokedAt: text("pairing_token_revoked_at"),
+    pendingPairingTokenHashesJson: text("pending_pairing_token_hashes_json").notNull().default("[]"),
+    lastSeenAt: text("last_seen_at"),
+    pairedAt: text("paired_at"),
+    metadataJson: text("metadata_json").notNull().default("{}"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => [
+    unique().on(t.agentId, t.browser, t.profileId),
+    index("idx_browser_bridge_companions_agent").on(
+      t.agentId,
+      t.browser,
+      t.updatedAt
+    )
+  ]
+);
+const browserBridgeSettings = browserPgSchema.table(
+  "browser_bridge_settings",
+  {
+    agentId: text("agent_id").primaryKey(),
+    enabled: boolean("enabled").notNull().default(false),
+    trackingMode: text("tracking_mode").notNull().default("current_tab"),
+    allowBrowserControl: boolean("allow_browser_control").notNull().default(false),
+    requireConfirmationForAccountAffecting: boolean(
+      "require_confirmation_for_account_affecting"
+    ).notNull().default(true),
+    incognitoEnabled: boolean("incognito_enabled").notNull().default(false),
+    siteAccessMode: text("site_access_mode").notNull().default("current_site_only"),
+    grantedOriginsJson: text("granted_origins_json").notNull().default("[]"),
+    blockedOriginsJson: text("blocked_origins_json").notNull().default("[]"),
+    maxRememberedTabs: integer("max_remembered_tabs").notNull().default(10),
+    pauseUntil: text("pause_until"),
+    metadataJson: text("metadata_json").notNull().default("{}"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  }
+);
+const browserBridgeTabs = browserPgSchema.table(
+  "browser_bridge_tabs",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    companionId: text("companion_id"),
+    browser: text("browser").notNull(),
+    profileId: text("profile_id").notNull(),
+    windowId: text("window_id").notNull(),
+    tabId: text("tab_id").notNull(),
+    url: text("url").notNull().default(""),
+    title: text("title").notNull().default(""),
+    activeInWindow: boolean("active_in_window").notNull().default(false),
+    focusedWindow: boolean("focused_window").notNull().default(false),
+    focusedActive: boolean("focused_active").notNull().default(false),
+    incognito: boolean("incognito").notNull().default(false),
+    faviconUrl: text("favicon_url"),
+    lastSeenAt: text("last_seen_at").notNull(),
+    lastFocusedAt: text("last_focused_at"),
+    metadataJson: text("metadata_json").notNull().default("{}"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => [
+    unique().on(t.agentId, t.browser, t.profileId, t.windowId, t.tabId),
+    index("idx_browser_bridge_tabs_agent").on(
+      t.agentId,
+      t.focusedActive,
+      t.activeInWindow,
+      t.lastSeenAt
+    )
+  ]
+);
+const browserBridgePageContexts = browserPgSchema.table(
+  "browser_bridge_page_contexts",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    browser: text("browser").notNull(),
+    profileId: text("profile_id").notNull(),
+    windowId: text("window_id").notNull(),
+    tabId: text("tab_id").notNull(),
+    url: text("url").notNull().default(""),
+    title: text("title").notNull().default(""),
+    selectionText: text("selection_text"),
+    mainText: text("main_text"),
+    headingsJson: text("headings_json").notNull().default("[]"),
+    linksJson: text("links_json").notNull().default("[]"),
+    formsJson: text("forms_json").notNull().default("[]"),
+    capturedAt: text("captured_at").notNull(),
+    metadataJson: text("metadata_json").notNull().default("{}")
+  },
+  (t) => [
+    unique().on(t.agentId, t.browser, t.profileId, t.windowId, t.tabId),
+    index("idx_browser_bridge_page_contexts_agent").on(t.agentId, t.capturedAt)
+  ]
+);
+const browserBridgeSchema = {
+  browserBridgeCompanions,
+  browserBridgeSettings,
+  browserBridgeTabs,
+  browserBridgePageContexts
+};
+export {
+  browserBridgeCompanions,
+  browserBridgePageContexts,
+  browserBridgeSchema,
+  browserBridgeSettings,
+  browserBridgeTabs,
+  browserPgSchema
+};
+//# sourceMappingURL=schema.js.map

package/dist/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/schema.ts"],"sourcesContent":["/**\n * Agent Browser Bridge Drizzle schema.\n *\n * The four generic browser tables (`browser_bridge_companions`,\n * `browser_bridge_settings`, `browser_bridge_tabs`,\n * `browser_bridge_page_contexts`) are owned by this plugin. The\n * workflow-bound `life_browser_sessions` table remains in LifeOps because\n * it carries `workflowId` plus LifeOps-only scoping columns.\n *\n * Tables are placed in the `browser` PostgreSQL schema (matches the\n * `deriveSchemaName(\"@elizaos/plugin-browser\")` result used by\n * plugin-sql's runtime migrator) so they no longer trip the\n * \"Plugin table is using public schema\" warning. The runtime migrator\n * issues `CREATE SCHEMA IF NOT EXISTS` automatically before applying\n * migrations.\n *\n * Migrations are applied via elizaOS plugin-sql's `runPluginMigrations`\n * when the plugin's `schema` field is populated and an appropriate\n * migration strategy is selected. Renaming the old `life_browser_*`\n * tables to `browser_bridge_*` is a destructive migration controlled by\n * plugin-sql's destructive-migration override.\n */\n\nimport {\n  boolean,\n  index,\n  integer,\n  pgSchema,\n  text,\n  unique,\n} from \"drizzle-orm/pg-core\";\n\nexport const browserPgSchema = pgSchema(\"browser\");\n\nexport const browserBridgeCompanions = browserPgSchema.table(\n  \"browser_bridge_companions\",\n  {\n    id: text(\"id\").primaryKey(),\n    agentId: text(\"agent_id\").notNull(),\n    browser: text(\"browser\").notNull(),\n    profileId: text(\"profile_id\").notNull(),\n    profileLabel: text(\"profile_label\").notNull().default(\"\"),\n    label: text(\"label\").notNull().default(\"\"),\n    extensionVersion: text(\"extension_version\"),\n    connectionState: text(\"connection_state\").notNull().default(\"disconnected\"),\n    permissionsJson: text(\"permissions_json\").notNull().default(\"{}\"),\n    pairingTokenHash: text(\"pairing_token_hash\"),\n    pairingTokenExpiresAt: text(\"pairing_token_expires_at\"),\n    pairingTokenRevokedAt: text(\"pairing_token_revoked_at\"),\n    pendingPairingTokenHashesJson: text(\"pending_pairing_token_hashes_json\")\n      .notNull()\n      .default(\"[]\"),\n    lastSeenAt: text(\"last_seen_at\"),\n    pairedAt: text(\"paired_at\"),\n    metadataJson: text(\"metadata_json\").notNull().default(\"{}\"),\n    createdAt: text(\"created_at\").notNull(),\n    updatedAt: text(\"updated_at\").notNull(),\n  },\n  (t) => [\n    unique().on(t.agentId, t.browser, t.profileId),\n    index(\"idx_browser_bridge_companions_agent\").on(\n      t.agentId,\n      t.browser,\n      t.updatedAt,\n    ),\n  ],\n);\n\nexport const browserBridgeSettings = browserPgSchema.table(\n  \"browser_bridge_settings\",\n  {\n    agentId: text(\"agent_id\").primaryKey(),\n    enabled: boolean(\"enabled\").notNull().default(false),\n    trackingMode: text(\"tracking_mode\").notNull().default(\"current_tab\"),\n    allowBrowserControl: boolean(\"allow_browser_control\")\n      .notNull()\n      .default(false),\n    requireConfirmationForAccountAffecting: boolean(\n      \"require_confirmation_for_account_affecting\",\n    )\n      .notNull()\n      .default(true),\n    incognitoEnabled: boolean(\"incognito_enabled\").notNull().default(false),\n    siteAccessMode: text(\"site_access_mode\")\n      .notNull()\n      .default(\"current_site_only\"),\n    grantedOriginsJson: text(\"granted_origins_json\").notNull().default(\"[]\"),\n    blockedOriginsJson: text(\"blocked_origins_json\").notNull().default(\"[]\"),\n    maxRememberedTabs: integer(\"max_remembered_tabs\").notNull().default(10),\n    pauseUntil: text(\"pause_until\"),\n    metadataJson: text(\"metadata_json\").notNull().default(\"{}\"),\n    createdAt: text(\"created_at\").notNull(),\n    updatedAt: text(\"updated_at\").notNull(),\n  },\n);\n\nexport const browserBridgeTabs = browserPgSchema.table(\n  \"browser_bridge_tabs\",\n  {\n    id: text(\"id\").primaryKey(),\n    agentId: text(\"agent_id\").notNull(),\n    companionId: text(\"companion_id\"),\n    browser: text(\"browser\").notNull(),\n    profileId: text(\"profile_id\").notNull(),\n    windowId: text(\"window_id\").notNull(),\n    tabId: text(\"tab_id\").notNull(),\n    url: text(\"url\").notNull().default(\"\"),\n    title: text(\"title\").notNull().default(\"\"),\n    activeInWindow: boolean(\"active_in_window\").notNull().default(false),\n    focusedWindow: boolean(\"focused_window\").notNull().default(false),\n    focusedActive: boolean(\"focused_active\").notNull().default(false),\n    incognito: boolean(\"incognito\").notNull().default(false),\n    faviconUrl: text(\"favicon_url\"),\n    lastSeenAt: text(\"last_seen_at\").notNull(),\n    lastFocusedAt: text(\"last_focused_at\"),\n    metadataJson: text(\"metadata_json\").notNull().default(\"{}\"),\n    createdAt: text(\"created_at\").notNull(),\n    updatedAt: text(\"updated_at\").notNull(),\n  },\n  (t) => [\n    unique().on(t.agentId, t.browser, t.profileId, t.windowId, t.tabId),\n    index(\"idx_browser_bridge_tabs_agent\").on(\n      t.agentId,\n      t.focusedActive,\n      t.activeInWindow,\n      t.lastSeenAt,\n    ),\n  ],\n);\n\nexport const browserBridgePageContexts = browserPgSchema.table(\n  \"browser_bridge_page_contexts\",\n  {\n    id: text(\"id\").primaryKey(),\n    agentId: text(\"agent_id\").notNull(),\n    browser: text(\"browser\").notNull(),\n    profileId: text(\"profile_id\").notNull(),\n    windowId: text(\"window_id\").notNull(),\n    tabId: text(\"tab_id\").notNull(),\n    url: text(\"url\").notNull().default(\"\"),\n    title: text(\"title\").notNull().default(\"\"),\n    selectionText: text(\"selection_text\"),\n    mainText: text(\"main_text\"),\n    headingsJson: text(\"headings_json\").notNull().default(\"[]\"),\n    linksJson: text(\"links_json\").notNull().default(\"[]\"),\n    formsJson: text(\"forms_json\").notNull().default(\"[]\"),\n    capturedAt: text(\"captured_at\").notNull(),\n    metadataJson: text(\"metadata_json\").notNull().default(\"{}\"),\n  },\n  (t) => [\n    unique().on(t.agentId, t.browser, t.profileId, t.windowId, t.tabId),\n    index(\"idx_browser_bridge_page_contexts_agent\").on(t.agentId, t.capturedAt),\n  ],\n);\n\nexport const browserBridgeSchema = {\n  browserBridgeCompanions,\n  browserBridgeSettings,\n  browserBridgeTabs,\n  browserBridgePageContexts,\n} as const;\n"],"mappings":"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","names":[]}

package/dist/service.d.ts

@@ -0,0 +1,30 @@
+import type { Service, UUID } from "@elizaos/core";
+import type { BrowserBridgeCompanionAutoPairResponse, BrowserBridgeCompanionPairingResponse, BrowserBridgeCompanionRevokeResponse, BrowserBridgeCompanionStatus, BrowserBridgeCompanionSyncResponse, BrowserBridgePageContext, BrowserBridgeSettings, BrowserBridgeTabSummary, CreateBrowserBridgeCompanionAutoPairRequest, CreateBrowserBridgeCompanionPairingRequest, SyncBrowserBridgeStateRequest, UpdateBrowserBridgeSessionProgressRequest, UpdateBrowserBridgeSettingsRequest } from "./contracts.js";
+import type { CompleteLifeOpsBrowserSessionRequest, ConfirmLifeOpsBrowserSessionRequest, CreateLifeOpsBrowserSessionRequest, LifeOpsBrowserSession } from "./lifeops-session-contracts.js";
+export declare const BROWSER_BRIDGE_ROUTE_SERVICE_TYPE = "lifeops_browser_plugin";
+export interface BrowserBridgeRouteService extends Service {
+    getBrowserSettings(ownerEntityId?: UUID | null): Promise<BrowserBridgeSettings>;
+    updateBrowserSettings(request: UpdateBrowserBridgeSettingsRequest, ownerEntityId?: UUID | null): Promise<BrowserBridgeSettings>;
+    listBrowserCompanions(ownerEntityId?: UUID | null): Promise<BrowserBridgeCompanionStatus[]>;
+    listBrowserTabs(ownerEntityId?: UUID | null): Promise<BrowserBridgeTabSummary[]>;
+    getCurrentBrowserPage(ownerEntityId?: UUID | null): Promise<BrowserBridgePageContext | null>;
+    syncBrowserState(request: SyncBrowserBridgeStateRequest, ownerEntityId?: UUID | null): Promise<{
+        companion: BrowserBridgeCompanionStatus;
+        tabs: BrowserBridgeTabSummary[];
+        currentPage: BrowserBridgePageContext | null;
+    }>;
+    createBrowserCompanionPairing(request: CreateBrowserBridgeCompanionPairingRequest, ownerEntityId?: UUID | null): Promise<BrowserBridgeCompanionPairingResponse>;
+    autoPairBrowserCompanion(request: CreateBrowserBridgeCompanionAutoPairRequest, apiBaseUrl: string, ownerEntityId?: UUID | null): Promise<BrowserBridgeCompanionAutoPairResponse>;
+    revokeBrowserCompanion(companionId: string, ownerEntityId?: UUID | null): Promise<BrowserBridgeCompanionRevokeResponse>;
+    revokeBrowserCompanionFromCompanion(companionId: string, pairingToken: string, ownerEntityId?: UUID | null): Promise<BrowserBridgeCompanionRevokeResponse>;
+    syncBrowserCompanion(companionId: string, pairingToken: string, request: SyncBrowserBridgeStateRequest, ownerEntityId?: UUID | null): Promise<BrowserBridgeCompanionSyncResponse>;
+    listBrowserSessions(ownerEntityId?: UUID | null): Promise<LifeOpsBrowserSession[]>;
+    getBrowserSession(sessionId: string, ownerEntityId?: UUID | null): Promise<LifeOpsBrowserSession>;
+    createBrowserSession(request: CreateLifeOpsBrowserSessionRequest, ownerEntityId?: UUID | null): Promise<LifeOpsBrowserSession>;
+    confirmBrowserSession(sessionId: string, request: ConfirmLifeOpsBrowserSessionRequest, ownerEntityId?: UUID | null): Promise<LifeOpsBrowserSession>;
+    updateBrowserSessionProgress(sessionId: string, request: UpdateBrowserBridgeSessionProgressRequest, ownerEntityId?: UUID | null): Promise<LifeOpsBrowserSession>;
+    completeBrowserSession(sessionId: string, request: CompleteLifeOpsBrowserSessionRequest, ownerEntityId?: UUID | null): Promise<LifeOpsBrowserSession>;
+    updateBrowserSessionProgressFromCompanion(companionId: string, pairingToken: string, sessionId: string, request: UpdateBrowserBridgeSessionProgressRequest, ownerEntityId?: UUID | null): Promise<LifeOpsBrowserSession>;
+    completeBrowserSessionFromCompanion(companionId: string, pairingToken: string, sessionId: string, request: CompleteLifeOpsBrowserSessionRequest, ownerEntityId?: UUID | null): Promise<LifeOpsBrowserSession>;
+}
+//# sourceMappingURL=service.d.ts.map

package/dist/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"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"}

package/dist/service.js

@@ -0,0 +1,5 @@
+const BROWSER_BRIDGE_ROUTE_SERVICE_TYPE = "lifeops_browser_plugin";
+export {
+  BROWSER_BRIDGE_ROUTE_SERVICE_TYPE
+};
+//# sourceMappingURL=service.js.map

package/dist/service.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/service.ts"],"sourcesContent":["import type { Service, UUID } from \"@elizaos/core\";\nimport type {\n  BrowserBridgeCompanionAutoPairResponse,\n  BrowserBridgeCompanionPairingResponse,\n  BrowserBridgeCompanionRevokeResponse,\n  BrowserBridgeCompanionStatus,\n  BrowserBridgeCompanionSyncResponse,\n  BrowserBridgePageContext,\n  BrowserBridgeSettings,\n  BrowserBridgeTabSummary,\n  CreateBrowserBridgeCompanionAutoPairRequest,\n  CreateBrowserBridgeCompanionPairingRequest,\n  SyncBrowserBridgeStateRequest,\n  UpdateBrowserBridgeSessionProgressRequest,\n  UpdateBrowserBridgeSettingsRequest,\n} from \"./contracts.js\";\nimport type {\n  CompleteLifeOpsBrowserSessionRequest,\n  ConfirmLifeOpsBrowserSessionRequest,\n  CreateLifeOpsBrowserSessionRequest,\n  LifeOpsBrowserSession,\n} from \"./lifeops-session-contracts.js\";\n\nexport const BROWSER_BRIDGE_ROUTE_SERVICE_TYPE = \"lifeops_browser_plugin\";\n\nexport interface BrowserBridgeRouteService extends Service {\n  getBrowserSettings(\n    ownerEntityId?: UUID | null,\n  ): Promise<BrowserBridgeSettings>;\n  updateBrowserSettings(\n    request: UpdateBrowserBridgeSettingsRequest,\n    ownerEntityId?: UUID | null,\n  ): Promise<BrowserBridgeSettings>;\n  listBrowserCompanions(\n    ownerEntityId?: UUID | null,\n  ): Promise<BrowserBridgeCompanionStatus[]>;\n  listBrowserTabs(\n    ownerEntityId?: UUID | null,\n  ): Promise<BrowserBridgeTabSummary[]>;\n  getCurrentBrowserPage(\n    ownerEntityId?: UUID | null,\n  ): Promise<BrowserBridgePageContext | null>;\n  syncBrowserState(\n    request: SyncBrowserBridgeStateRequest,\n    ownerEntityId?: UUID | null,\n  ): Promise<{\n    companion: BrowserBridgeCompanionStatus;\n    tabs: BrowserBridgeTabSummary[];\n    currentPage: BrowserBridgePageContext | null;\n  }>;\n  createBrowserCompanionPairing(\n    request: CreateBrowserBridgeCompanionPairingRequest,\n    ownerEntityId?: UUID | null,\n  ): Promise<BrowserBridgeCompanionPairingResponse>;\n  autoPairBrowserCompanion(\n    request: CreateBrowserBridgeCompanionAutoPairRequest,\n    apiBaseUrl: string,\n    ownerEntityId?: UUID | null,\n  ): Promise<BrowserBridgeCompanionAutoPairResponse>;\n  revokeBrowserCompanion(\n    companionId: string,\n    ownerEntityId?: UUID | null,\n  ): Promise<BrowserBridgeCompanionRevokeResponse>;\n  revokeBrowserCompanionFromCompanion(\n    companionId: string,\n    pairingToken: string,\n    ownerEntityId?: UUID | null,\n  ): Promise<BrowserBridgeCompanionRevokeResponse>;\n  syncBrowserCompanion(\n    companionId: string,\n    pairingToken: string,\n    request: SyncBrowserBridgeStateRequest,\n    ownerEntityId?: UUID | null,\n  ): Promise<BrowserBridgeCompanionSyncResponse>;\n  listBrowserSessions(\n    ownerEntityId?: UUID | null,\n  ): Promise<LifeOpsBrowserSession[]>;\n  getBrowserSession(\n    sessionId: string,\n    ownerEntityId?: UUID | null,\n  ): Promise<LifeOpsBrowserSession>;\n  createBrowserSession(\n    request: CreateLifeOpsBrowserSessionRequest,\n    ownerEntityId?: UUID | null,\n  ): Promise<LifeOpsBrowserSession>;\n  confirmBrowserSession(\n    sessionId: string,\n    request: ConfirmLifeOpsBrowserSessionRequest,\n    ownerEntityId?: UUID | null,\n  ): Promise<LifeOpsBrowserSession>;\n  updateBrowserSessionProgress(\n    sessionId: string,\n    request: UpdateBrowserBridgeSessionProgressRequest,\n    ownerEntityId?: UUID | null,\n  ): Promise<LifeOpsBrowserSession>;\n  completeBrowserSession(\n    sessionId: string,\n    request: CompleteLifeOpsBrowserSessionRequest,\n    ownerEntityId?: UUID | null,\n  ): Promise<LifeOpsBrowserSession>;\n  updateBrowserSessionProgressFromCompanion(\n    companionId: string,\n    pairingToken: string,\n    sessionId: string,\n    request: UpdateBrowserBridgeSessionProgressRequest,\n    ownerEntityId?: UUID | null,\n  ): Promise<LifeOpsBrowserSession>;\n  completeBrowserSessionFromCompanion(\n    companionId: string,\n    pairingToken: string,\n    sessionId: string,\n    request: CompleteLifeOpsBrowserSessionRequest,\n    ownerEntityId?: UUID | null,\n  ): Promise<LifeOpsBrowserSession>;\n}\n"],"mappings":"AAuBO,MAAM,oCAAoC;","names":[]}

package/dist/targets/bridge-target.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Bridge target — routes a `BrowserWorkspaceCommand` to the Agent Browser
+ * Bridge companion (Chrome / Safari) via `BrowserBridgeRouteService`.
+ *
+ * The bridge surface is intentionally narrower than the workspace surface.
+ * It speaks at the level of paired browser tabs, not of an embedded
+ * BrowserView, so subactions like `eval` / `pdf` / `trace` / `profiler`
+ * have no clean translation. We translate the read-mostly subset that DOES
+ * map cleanly:
+ *
+ *   list            → list companion-tracked tabs
+ *   state           → snapshot of current page context
+ *   open            → ask the companion to open a URL in a new tab
+ *   navigate        → ask the companion to navigate the current/named tab
+ *   close           → ask the companion to close a tab
+ *   show / hide     → focus / unfocus a tab in the companion window
+ *   get             → return the current page text/title/url
+ *   back / forward / reload → companion navigation history nav
+ *
+ * Anything outside that subset throws a clear error so the caller
+ * (typically the BROWSER action) can surface a "this isn't supported on
+ * the bridge target — try the workspace target" message back to the user.
+ *
+ * The bridge protocol's session-tracking semantics (`createBrowserSession`,
+ * `confirmBrowserSession`, etc.) are LifeOps workflow concerns and live
+ * in a dedicated lifeops session action, not here.
+ */
+import type { BrowserBridgeRouteService } from "../service.js";
+import type { BrowserWorkspaceCommand, BrowserWorkspaceCommandResult } from "../workspace/browser-workspace-types.js";
+export declare function dispatchBridgeCommand(service: BrowserBridgeRouteService, command: BrowserWorkspaceCommand): Promise<BrowserWorkspaceCommandResult>;
+//# sourceMappingURL=bridge-target.d.ts.map

package/dist/targets/bridge-target.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridge-target.d.ts","sourceRoot":"","sources":["../../src/targets/bridge-target.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAGH,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,eAAe,CAAC;AAC/D,OAAO,KAAK,EACV,uBAAuB,EACvB,6BAA6B,EAE9B,MAAM,yCAAyC,CAAC;AAyCjD,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,yBAAyB,EAClC,OAAO,EAAE,uBAAuB,GAC/B,OAAO,CAAC,6BAA6B,CAAC,CAsExC"}

package/dist/targets/bridge-target.js

@@ -0,0 +1,98 @@
+const SUPPORTED_SUBACTIONS = /* @__PURE__ */ new Set([
+  "list",
+  "state",
+  "open",
+  "navigate",
+  "close",
+  "show",
+  "hide",
+  "tab",
+  "get",
+  "back",
+  "forward",
+  "reload"
+]);
+function bridgeTabToWorkspaceTab(tab) {
+  return {
+    id: tab.id,
+    title: tab.title,
+    url: tab.url,
+    partition: `bridge:${tab.profileId}`,
+    kind: "standard",
+    visible: tab.activeInWindow,
+    createdAt: tab.createdAt,
+    updatedAt: tab.updatedAt,
+    lastFocusedAt: tab.lastFocusedAt
+  };
+}
+function unsupported(subaction) {
+  return new Error(
+    `Browser bridge target does not support subaction "${subaction}". Use the workspace target for embedded-browser features (eval, pdf, snapshot, trace, profiler, etc.).`
+  );
+}
+async function dispatchBridgeCommand(service, command) {
+  if (!SUPPORTED_SUBACTIONS.has(command.subaction)) {
+    throw unsupported(command.subaction);
+  }
+  switch (command.subaction) {
+    case "list":
+    case "tab":
+      return {
+        mode: "desktop",
+        subaction: command.subaction,
+        tabs: (await service.listBrowserTabs()).map(bridgeTabToWorkspaceTab)
+      };
+    case "state": {
+      const page = await service.getCurrentBrowserPage();
+      return {
+        mode: "desktop",
+        subaction: command.subaction,
+        value: page ? {
+          url: page.url,
+          title: page.title,
+          browser: page.browser,
+          profileId: page.profileId,
+          windowId: page.windowId,
+          tabId: page.tabId,
+          capturedAt: page.capturedAt
+        } : null
+      };
+    }
+    case "get": {
+      const page = await service.getCurrentBrowserPage();
+      if (!page) {
+        return {
+          mode: "desktop",
+          subaction: command.subaction,
+          value: null
+        };
+      }
+      const mode = command.getMode ?? "text";
+      const value = mode === "url" ? page.url : mode === "title" ? page.title : page.mainText ?? "";
+      return { mode: "desktop", subaction: command.subaction, value };
+    }
+    // open / navigate / close / show / hide / back / forward / reload are
+    // session-creating operations on the bridge — they require a
+    // LifeOpsBrowserSession to record the action and gate confirmation.
+    // The bridge's session APIs aren't appropriate to call from a generic
+    // BROWSER target, so we throw a clear error directing the caller to
+    // the dedicated lifeops session action.
+    case "open":
+    case "navigate":
+    case "close":
+    case "show":
+    case "hide":
+    case "back":
+    case "forward":
+    case "reload":
+      throw new Error(
+        `Bridge target subaction "${command.subaction}" requires a recorded LifeOpsBrowserSession (the bridge gates account-affecting ops behind owner confirmation). Use the lifeops browser-session action to start a session, or pin target=workspace for embedded-browser tabs.`
+      );
+    default:
+      throw unsupported(command.subaction);
+  }
+}
+export {
+  dispatchBridgeCommand
+};
+//# sourceMappingURL=bridge-target.js.map

package/dist/targets/bridge-target.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/targets/bridge-target.ts"],"sourcesContent":["/**\n * Bridge target — routes a `BrowserWorkspaceCommand` to the Agent Browser\n * Bridge companion (Chrome / Safari) via `BrowserBridgeRouteService`.\n *\n * The bridge surface is intentionally narrower than the workspace surface.\n * It speaks at the level of paired browser tabs, not of an embedded\n * BrowserView, so subactions like `eval` / `pdf` / `trace` / `profiler`\n * have no clean translation. We translate the read-mostly subset that DOES\n * map cleanly:\n *\n *   list            → list companion-tracked tabs\n *   state           → snapshot of current page context\n *   open            → ask the companion to open a URL in a new tab\n *   navigate        → ask the companion to navigate the current/named tab\n *   close           → ask the companion to close a tab\n *   show / hide     → focus / unfocus a tab in the companion window\n *   get             → return the current page text/title/url\n *   back / forward / reload → companion navigation history nav\n *\n * Anything outside that subset throws a clear error so the caller\n * (typically the BROWSER action) can surface a \"this isn't supported on\n * the bridge target — try the workspace target\" message back to the user.\n *\n * The bridge protocol's session-tracking semantics (`createBrowserSession`,\n * `confirmBrowserSession`, etc.) are LifeOps workflow concerns and live\n * in a dedicated lifeops session action, not here.\n */\n\nimport type { BrowserBridgeTabSummary } from \"../contracts.js\";\nimport type { BrowserBridgeRouteService } from \"../service.js\";\nimport type {\n  BrowserWorkspaceCommand,\n  BrowserWorkspaceCommandResult,\n  BrowserWorkspaceTab,\n} from \"../workspace/browser-workspace-types.js\";\n\nconst SUPPORTED_SUBACTIONS = new Set<BrowserWorkspaceCommand[\"subaction\"]>([\n  \"list\",\n  \"state\",\n  \"open\",\n  \"navigate\",\n  \"close\",\n  \"show\",\n  \"hide\",\n  \"tab\",\n  \"get\",\n  \"back\",\n  \"forward\",\n  \"reload\",\n]);\n\nfunction bridgeTabToWorkspaceTab(\n  tab: BrowserBridgeTabSummary,\n): BrowserWorkspaceTab {\n  // The bridge speaks BrowserBridgeTabSummary; the BROWSER action expects\n  // BrowserWorkspaceTab. Map the overlapping fields and use defaults for the rest.\n  return {\n    id: tab.id,\n    title: tab.title,\n    url: tab.url,\n    partition: `bridge:${tab.profileId}`,\n    kind: \"standard\",\n    visible: tab.activeInWindow,\n    createdAt: tab.createdAt,\n    updatedAt: tab.updatedAt,\n    lastFocusedAt: tab.lastFocusedAt,\n  };\n}\n\nfunction unsupported(subaction: BrowserWorkspaceCommand[\"subaction\"]): Error {\n  return new Error(\n    `Browser bridge target does not support subaction \"${subaction}\". Use the workspace target for embedded-browser features (eval, pdf, snapshot, trace, profiler, etc.).`,\n  );\n}\n\nexport async function dispatchBridgeCommand(\n  service: BrowserBridgeRouteService,\n  command: BrowserWorkspaceCommand,\n): Promise<BrowserWorkspaceCommandResult> {\n  if (!SUPPORTED_SUBACTIONS.has(command.subaction)) {\n    throw unsupported(command.subaction);\n  }\n  switch (command.subaction) {\n    case \"list\":\n    case \"tab\":\n      // Bridge `tab` always behaves like list; the bridge has no concept of\n      // creating an internal tab via the agent — the user owns the tabs.\n      return {\n        mode: \"desktop\",\n        subaction: command.subaction,\n        tabs: (await service.listBrowserTabs()).map(bridgeTabToWorkspaceTab),\n      };\n    case \"state\": {\n      const page = await service.getCurrentBrowserPage();\n      return {\n        mode: \"desktop\",\n        subaction: command.subaction,\n        value: page\n          ? {\n              url: page.url,\n              title: page.title,\n              browser: page.browser,\n              profileId: page.profileId,\n              windowId: page.windowId,\n              tabId: page.tabId,\n              capturedAt: page.capturedAt,\n            }\n          : null,\n      };\n    }\n    case \"get\": {\n      const page = await service.getCurrentBrowserPage();\n      if (!page) {\n        return {\n          mode: \"desktop\",\n          subaction: command.subaction,\n          value: null,\n        };\n      }\n      const mode = command.getMode ?? \"text\";\n      const value =\n        mode === \"url\"\n          ? page.url\n          : mode === \"title\"\n            ? page.title\n            : (page.mainText ?? \"\");\n      return { mode: \"desktop\", subaction: command.subaction, value };\n    }\n    // open / navigate / close / show / hide / back / forward / reload are\n    // session-creating operations on the bridge — they require a\n    // LifeOpsBrowserSession to record the action and gate confirmation.\n    // The bridge's session APIs aren't appropriate to call from a generic\n    // BROWSER target, so we throw a clear error directing the caller to\n    // the dedicated lifeops session action.\n    case \"open\":\n    case \"navigate\":\n    case \"close\":\n    case \"show\":\n    case \"hide\":\n    case \"back\":\n    case \"forward\":\n    case \"reload\":\n      throw new Error(\n        `Bridge target subaction \"${command.subaction}\" requires a recorded LifeOpsBrowserSession (the bridge gates account-affecting ops behind owner confirmation). Use the lifeops browser-session action to start a session, or pin target=workspace for embedded-browser tabs.`,\n      );\n    default:\n      throw unsupported(command.subaction);\n  }\n}\n"],"mappings":"AAoCA,MAAM,uBAAuB,oBAAI,IAA0C;AAAA,EACzE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAAC;AAED,SAAS,wBACP,KACqB;AAGrB,SAAO;AAAA,IACL,IAAI,IAAI;AAAA,IACR,OAAO,IAAI;AAAA,IACX,KAAK,IAAI;AAAA,IACT,WAAW,UAAU,IAAI,SAAS;AAAA,IAClC,MAAM;AAAA,IACN,SAAS,IAAI;AAAA,IACb,WAAW,IAAI;AAAA,IACf,WAAW,IAAI;AAAA,IACf,eAAe,IAAI;AAAA,EACrB;AACF;AAEA,SAAS,YAAY,WAAwD;AAC3E,SAAO,IAAI;AAAA,IACT,qDAAqD,SAAS;AAAA,EAChE;AACF;AAEA,eAAsB,sBACpB,SACA,SACwC;AACxC,MAAI,CAAC,qBAAqB,IAAI,QAAQ,SAAS,GAAG;AAChD,UAAM,YAAY,QAAQ,SAAS;AAAA,EACrC;AACA,UAAQ,QAAQ,WAAW;AAAA,IACzB,KAAK;AAAA,IACL,KAAK;AAGH,aAAO;AAAA,QACL,MAAM;AAAA,QACN,WAAW,QAAQ;AAAA,QACnB,OAAO,MAAM,QAAQ,gBAAgB,GAAG,IAAI,uBAAuB;AAAA,MACrE;AAAA,IACF,KAAK,SAAS;AACZ,YAAM,OAAO,MAAM,QAAQ,sBAAsB;AACjD,aAAO;AAAA,QACL,MAAM;AAAA,QACN,WAAW,QAAQ;AAAA,QACnB,OAAO,OACH;AAAA,UACE,KAAK,KAAK;AAAA,UACV,OAAO,KAAK;AAAA,UACZ,SAAS,KAAK;AAAA,UACd,WAAW,KAAK;AAAA,UAChB,UAAU,KAAK;AAAA,UACf,OAAO,KAAK;AAAA,UACZ,YAAY,KAAK;AAAA,QACnB,IACA;AAAA,MACN;AAAA,IACF;AAAA,IACA,KAAK,OAAO;AACV,YAAM,OAAO,MAAM,QAAQ,sBAAsB;AACjD,UAAI,CAAC,MAAM;AACT,eAAO;AAAA,UACL,MAAM;AAAA,UACN,WAAW,QAAQ;AAAA,UACnB,OAAO;AAAA,QACT;AAAA,MACF;AACA,YAAM,OAAO,QAAQ,WAAW;AAChC,YAAM,QACJ,SAAS,QACL,KAAK,MACL,SAAS,UACP,KAAK,QACJ,KAAK,YAAY;AAC1B,aAAO,EAAE,MAAM,WAAW,WAAW,QAAQ,WAAW,MAAM;AAAA,IAChE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAOA,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AACH,YAAM,IAAI;AAAA,QACR,4BAA4B,QAAQ,SAAS;AAAA,MAC/C;AAAA,IACF;AACE,YAAM,YAAY,QAAQ,SAAS;AAAA,EACvC;AACF;","names":[]}

package/dist/targets/stagehand-target.d.ts

@@ -0,0 +1,3 @@
+import type { BrowserTarget } from "../browser-service.js";
+export declare function maybeCreateStagehandTarget(env?: NodeJS.ProcessEnv): Promise<BrowserTarget | null>;
+//# sourceMappingURL=stagehand-target.d.ts.map

package/dist/targets/stagehand-target.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stagehand-target.d.ts","sourceRoot":"","sources":["../../src/targets/stagehand-target.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAuB3D,wBAAsB,0BAA0B,CAC9C,GAAG,GAAE,MAAM,CAAC,UAAwB,GACnC,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC,CAkC/B"}

package/dist/targets/stagehand-target.js

@@ -0,0 +1,187 @@
+import { execFileSync, execSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { logger } from "@elizaos/core";
+const pluginSrcDir = path.dirname(fileURLToPath(import.meta.url));
+const STAGEHAND_COMMAND_URL_ENV = [
+  "ELIZA_BROWSER_STAGEHAND_COMMAND_URL",
+  "STAGEHAND_BROWSER_COMMAND_URL",
+  "ELIZA_STAGEHAND_COMMAND_URL"
+];
+const STAGEHAND_BASE_URL_ENV = [
+  "ELIZA_BROWSER_STAGEHAND_URL",
+  "STAGEHAND_SERVER_URL",
+  "ELIZA_STAGEHAND_SERVER_URL"
+];
+const STAGEHAND_AUTO_SETUP_ENV = "ELIZA_BROWSER_STAGEHAND_AUTO_SETUP";
+const STAGEHAND_ALLOW_MOBILE_ENV = "ELIZA_BROWSER_ALLOW_STAGEHAND_ON_MOBILE";
+async function maybeCreateStagehandTarget(env = process.env) {
+  if (isDisabled(env.ELIZA_BROWSER_STAGEHAND_ENABLED)) return null;
+  const mobile = isMobileRuntime(env);
+  if (mobile && !isEnabled(env[STAGEHAND_ALLOW_MOBILE_ENV])) {
+    logger.debug(
+      "[BrowserService] stagehand target not registered on mobile; using the app browser surface instead"
+    );
+    return null;
+  }
+  if (!isDisabled(env[STAGEHAND_AUTO_SETUP_ENV])) {
+    ensureLocalStagehandServer(env);
+  }
+  const commandUrl = resolveStagehandCommandUrl(env);
+  if (!commandUrl) {
+    logger.debug(
+      "[BrowserService] stagehand target not registered; set ELIZA_BROWSER_STAGEHAND_COMMAND_URL or STAGEHAND_SERVER_URL to enable it"
+    );
+    return null;
+  }
+  return {
+    id: "stagehand",
+    name: "Stagehand Browser",
+    description: "Fallback Stagehand/Playwright browser backend reached through a local or remote stagehand command endpoint.",
+    kind: "stagehand",
+    priority: 10,
+    score: ({ mobile: mobileContext }) => mobileContext ? null : 10,
+    available: async () => probeStagehand(commandUrl, env),
+    execute: async (command) => executeStagehandCommand(commandUrl, command)
+  };
+}
+function resolveStagehandCommandUrl(env) {
+  for (const key of STAGEHAND_COMMAND_URL_ENV) {
+    const value = normalizeUrl(env[key]);
+    if (value) return value;
+  }
+  for (const key of STAGEHAND_BASE_URL_ENV) {
+    const value = normalizeUrl(env[key]);
+    if (value) return new URL("/api/browser-command", value).toString();
+  }
+  return null;
+}
+async function probeStagehand(_commandUrl, env) {
+  const healthUrl = normalizeUrl(env.ELIZA_BROWSER_STAGEHAND_HEALTH_URL);
+  if (!healthUrl) return true;
+  try {
+    const response = await fetch(healthUrl, { method: "GET" });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+async function executeStagehandCommand(commandUrl, command) {
+  const response = await fetch(commandUrl, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ command })
+  });
+  const body = await response.json().catch(() => null);
+  if (!response.ok) {
+    const message = body && typeof body === "object" && "error" in body ? String(body.error) : `Stagehand command endpoint returned HTTP ${response.status}`;
+    throw new Error(message);
+  }
+  return normalizeStagehandResult(command, body);
+}
+function normalizeStagehandResult(command, body) {
+  if (body && typeof body === "object") {
+    const record = body;
+    const result = record.result && typeof record.result === "object" ? record.result : record;
+    return {
+      ...result,
+      mode: "cloud",
+      subaction: command.subaction
+    };
+  }
+  return {
+    mode: "cloud",
+    subaction: command.subaction,
+    value: body
+  };
+}
+function ensureLocalStagehandServer(env) {
+  const stagehandDir = findStagehandDir(env);
+  if (!stagehandDir) return false;
+  const stagehandIndex = path.join(stagehandDir, "dist", "index.js");
+  if (fs.existsSync(stagehandIndex)) return true;
+  const stagehandSrc = path.join(stagehandDir, "src", "index.ts");
+  if (!fs.existsSync(stagehandSrc)) return false;
+  try {
+    if (!fs.existsSync(path.join(stagehandDir, "node_modules"))) {
+      execSync("bun install --ignore-scripts", {
+        cwd: stagehandDir,
+        stdio: "ignore",
+        timeout: 6e4
+      });
+    }
+    const localTsc = path.join(stagehandDir, "node_modules", ".bin", "tsc");
+    if (fs.existsSync(localTsc)) {
+      execFileSync(localTsc, [], {
+        cwd: stagehandDir,
+        stdio: "ignore",
+        timeout: 6e4
+      });
+    } else {
+      execFileSync("bunx", ["tsc"], {
+        cwd: stagehandDir,
+        stdio: "ignore",
+        timeout: 6e4
+      });
+    }
+    logger.info("[BrowserService] stagehand-server built successfully");
+    return fs.existsSync(stagehandIndex);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    logger.debug(
+      `[BrowserService] stagehand-server auto-setup failed: ${message}`
+    );
+    return false;
+  }
+}
+function findStagehandDir(env) {
+  const configured = env.ELIZA_BROWSER_STAGEHAND_DIR?.trim();
+  const candidates = [
+    configured,
+    ...ancestorPaths(pluginSrcDir).flatMap((root) => [
+      path.join(root, "stagehand-server"),
+      path.join(root, "plugins", "plugin-browser", "stagehand-server"),
+      path.join(root, "eliza", "plugins", "plugin-browser", "stagehand-server")
+    ])
+  ].filter((candidate) => Boolean(candidate));
+  for (const candidate of candidates) {
+    const dir = path.resolve(candidate);
+    if (fs.existsSync(path.join(dir, "dist", "index.js")) || fs.existsSync(path.join(dir, "src", "index.ts"))) {
+      return dir;
+    }
+  }
+  return null;
+}
+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;
+  }
+}
+function normalizeUrl(value) {
+  if (!value?.trim()) return null;
+  try {
+    return new URL(value.trim()).toString();
+  } catch {
+    return null;
+  }
+}
+function isEnabled(value) {
+  return value === "1" || value?.toLowerCase() === "true";
+}
+function isDisabled(value) {
+  return value === "0" || value?.toLowerCase() === "false";
+}
+function isMobileRuntime(env) {
+  const platform = (env.ELIZA_MOBILE_PLATFORM ?? env.ELIZA_PLATFORM ?? env.CAPACITOR_PLATFORM ?? "").toLowerCase();
+  return platform === "ios" || platform === "android" || platform === "mobile";
+}
+export {
+  maybeCreateStagehandTarget
+};
+//# sourceMappingURL=stagehand-target.js.map

package/dist/targets/stagehand-target.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/targets/stagehand-target.ts"],"sourcesContent":["import { execFileSync, execSync } from \"node:child_process\";\nimport fs from \"node:fs\";\nimport path from \"node:path\";\nimport { fileURLToPath } from \"node:url\";\nimport { logger } from \"@elizaos/core\";\nimport type { BrowserTarget } from \"../browser-service.js\";\nimport type {\n  BrowserWorkspaceCommand,\n  BrowserWorkspaceCommandResult,\n} from \"../workspace/browser-workspace-types.js\";\n\nconst pluginSrcDir = path.dirname(fileURLToPath(import.meta.url));\n\nconst STAGEHAND_COMMAND_URL_ENV = [\n  \"ELIZA_BROWSER_STAGEHAND_COMMAND_URL\",\n  \"STAGEHAND_BROWSER_COMMAND_URL\",\n  \"ELIZA_STAGEHAND_COMMAND_URL\",\n] as const;\n\nconst STAGEHAND_BASE_URL_ENV = [\n  \"ELIZA_BROWSER_STAGEHAND_URL\",\n  \"STAGEHAND_SERVER_URL\",\n  \"ELIZA_STAGEHAND_SERVER_URL\",\n] as const;\n\nconst STAGEHAND_AUTO_SETUP_ENV = \"ELIZA_BROWSER_STAGEHAND_AUTO_SETUP\";\nconst STAGEHAND_ALLOW_MOBILE_ENV = \"ELIZA_BROWSER_ALLOW_STAGEHAND_ON_MOBILE\";\n\nexport async function maybeCreateStagehandTarget(\n  env: NodeJS.ProcessEnv = process.env,\n): Promise<BrowserTarget | null> {\n  if (isDisabled(env.ELIZA_BROWSER_STAGEHAND_ENABLED)) return null;\n\n  const mobile = isMobileRuntime(env);\n  if (mobile && !isEnabled(env[STAGEHAND_ALLOW_MOBILE_ENV])) {\n    logger.debug(\n      \"[BrowserService] stagehand target not registered on mobile; using the app browser surface instead\",\n    );\n    return null;\n  }\n\n  if (!isDisabled(env[STAGEHAND_AUTO_SETUP_ENV])) {\n    ensureLocalStagehandServer(env);\n  }\n\n  const commandUrl = resolveStagehandCommandUrl(env);\n  if (!commandUrl) {\n    logger.debug(\n      \"[BrowserService] stagehand target not registered; set ELIZA_BROWSER_STAGEHAND_COMMAND_URL or STAGEHAND_SERVER_URL to enable it\",\n    );\n    return null;\n  }\n\n  return {\n    id: \"stagehand\",\n    name: \"Stagehand Browser\",\n    description:\n      \"Fallback Stagehand/Playwright browser backend reached through a local or remote stagehand command endpoint.\",\n    kind: \"stagehand\",\n    priority: 10,\n    score: ({ mobile: mobileContext }) => (mobileContext ? null : 10),\n    available: async () => probeStagehand(commandUrl, env),\n    execute: async (command) => executeStagehandCommand(commandUrl, command),\n  };\n}\n\nfunction resolveStagehandCommandUrl(env: NodeJS.ProcessEnv): string | null {\n  for (const key of STAGEHAND_COMMAND_URL_ENV) {\n    const value = normalizeUrl(env[key]);\n    if (value) return value;\n  }\n  for (const key of STAGEHAND_BASE_URL_ENV) {\n    const value = normalizeUrl(env[key]);\n    if (value) return new URL(\"/api/browser-command\", value).toString();\n  }\n  return null;\n}\n\nasync function probeStagehand(\n  _commandUrl: string,\n  env: NodeJS.ProcessEnv,\n): Promise<boolean> {\n  const healthUrl = normalizeUrl(env.ELIZA_BROWSER_STAGEHAND_HEALTH_URL);\n  if (!healthUrl) return true;\n  try {\n    const response = await fetch(healthUrl, { method: \"GET\" });\n    return response.ok;\n  } catch {\n    return false;\n  }\n}\n\nasync function executeStagehandCommand(\n  commandUrl: string,\n  command: BrowserWorkspaceCommand,\n): Promise<BrowserWorkspaceCommandResult> {\n  const response = await fetch(commandUrl, {\n    method: \"POST\",\n    headers: { \"content-type\": \"application/json\" },\n    body: JSON.stringify({ command }),\n  });\n  const body = await response.json().catch(() => null);\n  if (!response.ok) {\n    const message =\n      body && typeof body === \"object\" && \"error\" in body\n        ? String((body as { error?: unknown }).error)\n        : `Stagehand command endpoint returned HTTP ${response.status}`;\n    throw new Error(message);\n  }\n  return normalizeStagehandResult(command, body);\n}\n\nfunction normalizeStagehandResult(\n  command: BrowserWorkspaceCommand,\n  body: unknown,\n): BrowserWorkspaceCommandResult {\n  if (body && typeof body === \"object\") {\n    const record = body as {\n      result?: unknown;\n      mode?: unknown;\n      subaction?: unknown;\n      value?: unknown;\n    };\n    const result =\n      record.result && typeof record.result === \"object\"\n        ? (record.result as BrowserWorkspaceCommandResult)\n        : (record as BrowserWorkspaceCommandResult);\n    return {\n      ...result,\n      mode: \"cloud\",\n      subaction: command.subaction,\n    };\n  }\n  return {\n    mode: \"cloud\",\n    subaction: command.subaction,\n    value: body,\n  };\n}\n\nfunction ensureLocalStagehandServer(env: NodeJS.ProcessEnv): boolean {\n  const stagehandDir = findStagehandDir(env);\n  if (!stagehandDir) return false;\n\n  const stagehandIndex = path.join(stagehandDir, \"dist\", \"index.js\");\n  if (fs.existsSync(stagehandIndex)) return true;\n\n  const stagehandSrc = path.join(stagehandDir, \"src\", \"index.ts\");\n  if (!fs.existsSync(stagehandSrc)) return false;\n\n  try {\n    if (!fs.existsSync(path.join(stagehandDir, \"node_modules\"))) {\n      execSync(\"bun install --ignore-scripts\", {\n        cwd: stagehandDir,\n        stdio: \"ignore\",\n        timeout: 60_000,\n      });\n    }\n    const localTsc = path.join(stagehandDir, \"node_modules\", \".bin\", \"tsc\");\n    if (fs.existsSync(localTsc)) {\n      execFileSync(localTsc, [], {\n        cwd: stagehandDir,\n        stdio: \"ignore\",\n        timeout: 60_000,\n      });\n    } else {\n      execFileSync(\"bunx\", [\"tsc\"], {\n        cwd: stagehandDir,\n        stdio: \"ignore\",\n        timeout: 60_000,\n      });\n    }\n    logger.info(\"[BrowserService] stagehand-server built successfully\");\n    return fs.existsSync(stagehandIndex);\n  } catch (err) {\n    const message = err instanceof Error ? err.message : String(err);\n    logger.debug(\n      `[BrowserService] stagehand-server auto-setup failed: ${message}`,\n    );\n    return false;\n  }\n}\n\nfunction findStagehandDir(env: NodeJS.ProcessEnv): string | null {\n  const configured = env.ELIZA_BROWSER_STAGEHAND_DIR?.trim();\n  const candidates = [\n    configured,\n    ...ancestorPaths(pluginSrcDir).flatMap((root) => [\n      path.join(root, \"stagehand-server\"),\n      path.join(root, \"plugins\", \"plugin-browser\", \"stagehand-server\"),\n      path.join(root, \"eliza\", \"plugins\", \"plugin-browser\", \"stagehand-server\"),\n    ]),\n  ].filter((candidate): candidate is string => Boolean(candidate));\n\n  for (const candidate of candidates) {\n    const dir = path.resolve(candidate);\n    if (\n      fs.existsSync(path.join(dir, \"dist\", \"index.js\")) ||\n      fs.existsSync(path.join(dir, \"src\", \"index.ts\"))\n    ) {\n      return dir;\n    }\n  }\n  return null;\n}\n\nfunction ancestorPaths(start: string): string[] {\n  const ancestors: string[] = [];\n  let current = path.resolve(start);\n  while (true) {\n    ancestors.push(current);\n    const parent = path.dirname(current);\n    if (parent === current) return ancestors;\n    current = parent;\n  }\n}\n\nfunction normalizeUrl(value: string | undefined): string | null {\n  if (!value?.trim()) return null;\n  try {\n    return new URL(value.trim()).toString();\n  } catch {\n    return null;\n  }\n}\n\nfunction isEnabled(value: string | undefined): boolean {\n  return value === \"1\" || value?.toLowerCase() === \"true\";\n}\n\nfunction isDisabled(value: string | undefined): boolean {\n  return value === \"0\" || value?.toLowerCase() === \"false\";\n}\n\nfunction isMobileRuntime(env: NodeJS.ProcessEnv): boolean {\n  const platform = (\n    env.ELIZA_MOBILE_PLATFORM ??\n    env.ELIZA_PLATFORM ??\n    env.CAPACITOR_PLATFORM ??\n    \"\"\n  ).toLowerCase();\n  return platform === \"ios\" || platform === \"android\" || platform === \"mobile\";\n}\n"],"mappings":"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","names":[]}

package/dist/workspace/browser-capture.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Headless browser capture — opens the StreamView in headless Chrome and
+ * saves screenshots to a temp file. FFmpeg reads the temp file using
+ * -loop 1 to continuously re-read the latest frame.
+ *
+ * This approach avoids the pipe bottleneck — FFmpeg reads at its own
+ * pace while the browser updates the file independently.
+ *
+ * Visual parity with the desktop shell:
+ * - Appends `?popout` to the URL so the app renders StreamView directly
+ *   (without onboarding, auth gates, or navigation chrome).
+ * - Enables SwiftShader for WebGL so VRM avatar renders identically.
+ * - Seeds localStorage with overlay layout, theme, and avatar index so
+ *   the first rendered frame matches the configured appearance.
+ * - Uses `waitUntil: "networkidle0"` to ensure all assets load before capture.
+ * - Keeps CSS animations/transitions enabled for visual parity.
+ */
+/** Path to the temp frame file that FFmpeg reads */
+export declare const FRAME_FILE: string;
+export interface BrowserCaptureConfig {
+    url: string;
+    width?: number;
+    height?: number;
+    fps?: number;
+    quality?: number;
+    /** Optional overlay layout JSON to seed into localStorage before page load. */
+    overlayLayout?: string;
+    /** Theme name to apply (e.g. "eliza", "haxor", "psycho"). */
+    theme?: string;
+    /** Avatar VRM index (1–8). */
+    avatarIndex?: number;
+    /** Destination ID — seeds the destination-specific localStorage key. */
+    destinationId?: string;
+}
+export declare function getBrowserCaptureExecutablePath(): string;
+export declare function isBrowserCaptureSupported(): boolean;
+export declare function startBrowserCapture(config: BrowserCaptureConfig): Promise<void>;
+export declare function stopBrowserCapture(): Promise<void>;
+export declare function isBrowserCaptureRunning(): boolean;
+export declare function hasFrameFile(): boolean;
+//# sourceMappingURL=browser-capture.d.ts.map