Skip to content

Open-source AI coworkers that each get a computer of their own: a browser, files and tools, with every action decided before it happens and recorded after. Bring any AG-UI agent.

7.8 KB
Raw Blame
// The ONLY listeners of runtime.onMessage, onMessageExternal and onConnect in the whole extension (MV3 needs them
// registered synchronously at top level, and one place keeps the trust checks in one place).
import {
  type ExternalAnswer,
  type ExternalResponse,
  type ExternalToBackground,
  type PageResponse,
  type PageToBackground,
  PORT_CONTENT,
  PORT_OFFSCREEN,
  parseContentMessage,
  parseExternalMessage,
  parsePageConnectDecide,
} from "../protocol/messages";
import {
  type ConnectionLoss,
  handleConnectionMessage,
  handleExternalConnect,
} from "./connection";
import {
  answerOpenBotPage,
  isOpenBotPageMessage,
  type OpenBotPageControls,
} from "./openbot-page";

export type RouterHandlers = {
  page(
    message: PageToBackground,
    sender: chrome.runtime.MessageSender,
  ): Promise<PageResponse>;
  external(
    message: ExternalToBackground,
    sender: chrome.runtime.MessageSender,
  ): Promise<ExternalResponse>;
  contentPort(port: chrome.runtime.Port): void;
  offscreenPort(port: chrome.runtime.Port): void;
};

type RouterDeps = RouterHandlers &
  OpenBotPageControls & {
    connected(): Promise<void>;
    disconnected(): Promise<void>;
    /** The recording controller's, for a connection an approved Connect (or OpenBot Desktop's connect) replaces. */
    connectionLost(loss: ConnectionLoss): Promise<void>;
  };

const CONNECTION_TYPES = new Set<string>([
  "page.connect.pending",
  "page.connect.decide",
  "page.disconnect",
  "page.desktop.available",
  "page.connect.desktop",
]);
const RECORDING_TYPES = new Set<string>([
  "page.state",
  "page.learning",
  "page.record",
  "page.stop",
  "page.restart",
  "page.notice",
  "page.notice.dismiss",
  "page.kept.discard",
  "page.voice",
  "page.narration",
  "page.site",
]);

const UNKNOWN: PageResponse = { ok: false, error: "Unknown request." };
const FAILED: PageResponse = {
  ok: false,
  error: "The Recorder could not do that. Try again.",
};

function isOwnPage(sender: chrome.runtime.MessageSender): boolean {
  return (
    sender.id === chrome.runtime.id &&
    typeof sender.url === "string" &&
    sender.url.startsWith(chrome.runtime.getURL(""))
  );
}

function messageType(raw: unknown): string | null {
  const type = (raw as { type?: unknown } | null)?.type;
  return typeof type === "string" ? type : null;
}

async function routePage(
  raw: unknown,
  sender: chrome.runtime.MessageSender,
  deps: RouterDeps,
): Promise<PageResponse> {
  if (!isOwnPage(sender)) return { ok: false, error: "Not allowed." };
  const type = messageType(raw);
  if (type === null) return UNKNOWN;
  const message =
    type === "page.connect.decide"
      ? parsePageConnectDecide(raw)
      : (raw as PageToBackground);
  if (message === null) return UNKNOWN;
  if (CONNECTION_TYPES.has(type)) {
    // A connection a Connect approves in place of another person's, or another OpenBot's, ends the old one in the
    // recording controller first: what still runs with its token stops, kept for its person.
    const answer = await handleConnectionMessage(message, {
      connectionLost: deps.connectionLost,
    });
    if (answer === undefined) return UNKNOWN;
    // The follow-up runs after the connection changed: never fail the page on it. OpenBot Desktop's connect, with no
    // Connect page, is an approved Connect too.
    const connected =
      (message.type === "page.connect.decide" && message.approve) ||
      (message.type === "page.connect.desktop" &&
        "connected" in answer &&
        answer.connected);
    if (answer.ok && connected)
      await deps
        .connected()
        .catch((error) =>
          console.error("Recorder: reconnect follow-up failed", error),
        );
    if (answer.ok && message.type === "page.disconnect")
      await deps
        .disconnected()
        .catch((error) =>
          console.error("Recorder: disconnect follow-up failed", error),
        );
    return answer;
  }
  if (
    RECORDING_TYPES.has(type) ||
    (import.meta.env.RECORDER_VARIANT === "e2e" &&
      type === "RECORDER_E2E_FLOOD")
  )
    return deps.page(message, sender);
  return UNKNOWN;
}

/** openbot.ping and openbot.connect from a web page. A trusted OpenBot's connect, made with no Connect page, is an
 * approved Connect, and followed up as one; its answer says so (`connected`). */
async function routeConnect(
  message: ExternalToBackground,
  sender: chrome.runtime.MessageSender,
  deps: RouterDeps,
): Promise<ExternalResponse> {
  const answer = await handleExternalConnect(message, sender);
  if (answer.ok && "connected" in answer && answer.connected)
    await deps
      .connected()
      .catch((error) =>
        console.error("Recorder: reconnect follow-up failed", error),
      );
  return answer;
}

/** A port whose onMessage listeners only ever see messages that passed parseContentMessage. */
function filteredContentPort(port: chrome.runtime.Port): chrome.runtime.Port {
  const wrapped = new Map<unknown, (message: unknown) => void>();
  const onMessage = {
    addListener(
      listener: (message: unknown, port: chrome.runtime.Port) => void,
    ) {
      const guarded = (raw: unknown) => {
        const message = parseContentMessage(raw);
        if (message === null) return;
        listener(message, filtered);
      };
      wrapped.set(listener, guarded);
      port.onMessage.addListener(guarded);
    },
    removeListener(listener: unknown) {
      const guarded = wrapped.get(listener);
      if (!guarded) return;
      wrapped.delete(listener);
      port.onMessage.removeListener(guarded);
    },
    hasListener: (listener: unknown) => wrapped.has(listener),
  };
  const disconnectWrapped = new Map<unknown, () => void>();
  const onDisconnect = {
    addListener(listener: (port: chrome.runtime.Port) => void) {
      const guarded = () => listener(filtered);
      disconnectWrapped.set(listener, guarded);
      port.onDisconnect.addListener(guarded);
    },
    removeListener(listener: unknown) {
      const guarded = disconnectWrapped.get(listener);
      if (!guarded) return;
      disconnectWrapped.delete(listener);
      port.onDisconnect.removeListener(guarded);
    },
    hasListener: (listener: unknown) => disconnectWrapped.has(listener),
  };
  const filtered = {
    name: port.name,
    sender: port.sender,
    onMessage,
    onDisconnect,
    postMessage: (message: unknown) => port.postMessage(message),
    disconnect: () => port.disconnect(),
  } as unknown as chrome.runtime.Port;
  return filtered;
}

export function installRouter(deps: RouterDeps): void {
  chrome.runtime.onMessage.addListener((raw, sender, sendResponse) => {
    routePage(raw, sender, deps).then(
      (answer) => sendResponse(answer),
      () => sendResponse(FAILED),
    );
    return true;
  });

  chrome.runtime.onMessageExternal.addListener((raw, sender, sendResponse) => {
    const message = parseExternalMessage(raw);
    if (message === null) {
      sendResponse({ ok: false, error: "invalid" } satisfies ExternalResponse);
      return false;
    }
    const answer: Promise<ExternalAnswer> =
      message.type === "recorder.page-network" ||
      message.type === "recorder.page-agent"
        ? deps.external(message, sender)
        : isOpenBotPageMessage(message)
          ? answerOpenBotPage(message, sender, deps)
          : routeConnect(message, sender, deps);
    answer.then(
      (response) => sendResponse(response),
      () => sendResponse({ ok: false, error: "invalid" }),
    );
    return true;
  });

  chrome.runtime.onConnect.addListener((port) => {
    if (port.name === PORT_CONTENT) {
      deps.contentPort(filteredContentPort(port));
      return;
    }
    if (
      port.name === PORT_OFFSCREEN &&
      port.sender?.id === chrome.runtime.id &&
      port.sender.url === chrome.runtime.getURL("offscreen.html")
    ) {
      deps.offscreenPort(port);
      return;
    }
    port.disconnect();
  });
}