Orca is the place for working with a fleet of agents (e.g. Grok Bot, Claude Code). Run any coding agent with your own subscription. Available on desktop, mobile and remote runtime.
TypeScript adeagent-ideai-agentsautomationbotclaude-codecodexghosttygrok-bothermes-agentmobile-appmuseopenclawopencodeorchestrationpiruntimeterminalworktreesyc-backed
import { runInNewContext } from 'node:vm'
import { describe, expect, it, vi } from 'vitest'
import {
CONTENT_SCRIPT_RELAY_KEY,
createContentScriptRelayBridge,
createContentScriptSyncForward,
installContentScriptRelayFilter
} from './browser-extension-content-script-relay'
import type { BrowserExtensionStorageSyncRelay } from './browser-extension-storage-sync'
type Listener = (
message: unknown,
sender: unknown,
sendResponse: (reply: unknown) => void
) => unknown
/** Runs the filter from its source text, as contextBridge.executeInMainWorld does for pages. */
function install(answer?: BrowserExtensionStorageSyncRelay) {
const listeners = new Set<Listener>()
const onMessage = {
addListener: (listener: Listener) => listeners.add(listener),
removeListener: (listener: Listener) => listeners.delete(listener)
}
const sendMessage = vi.fn(async (_message: unknown) => true)
const chrome = { runtime: { id: 'ext', onMessage, sendMessage } }
const browser = { runtime: { id: 'ext', onMessage } }
const realm = { chrome, browser }
runInNewContext(`(${installContentScriptRelayFilter.toString()})(answer)`, {
...realm,
globalThis: realm,
answer
})
// Delivers like Chromium: every native listener, first sendResponse wins.
const dispatch = (message: unknown, sender: unknown): Promise<unknown> =>
new Promise((resolve) => {
let kept = false
for (const listener of listeners) {
kept = listener(message, sender, resolve) === true || kept
}
if (!kept) {
setTimeout(() => resolve('no reply'), 0)
}
})
return { chrome, browser, listeners, dispatch, sendMessage }
}
const fromContentScript = { id: 'ext', tab: { id: 7 } }
const relayed = { [CONTENT_SCRIPT_RELAY_KEY]: { method: 'get', args: ['theme'] } }
describe('content script relay', () => {
it('probes native document identity without exposing packets or adding receiving-end listeners', async () => {
const receiver = install()
const seen = vi.fn()
const second = vi.fn()
expect(receiver.listeners.size).toBe(0)
receiver.chrome.runtime.onMessage.addListener(seen)
receiver.chrome.runtime.onMessage.addListener(second)
await expect(
receiver.dispatch({ orcaDocumentTargetProbe: { token: 'private-probe' } }, { id: 'ext' })
).resolves.toBe(true)
expect(receiver.sendMessage).toHaveBeenCalledExactlyOnceWith({
orcaDocumentTargetProbe: { token: 'private-probe', response: true }
})
expect(seen).not.toHaveBeenCalled()
expect(second).not.toHaveBeenCalled()
expect(receiver.listeners.size).toBe(2)
await receiver.dispatch(
{ orcaDocumentTargetProbe: { token: 'private-probe', response: true } },
fromContentScript
)
expect(seen).not.toHaveBeenCalled()
receiver.chrome.runtime.onMessage.removeListener(seen)
receiver.chrome.runtime.onMessage.removeListener(second)
expect(receiver.listeners.size).toBe(0)
})
it('answers a content script’s relayed call in the worker and hides it from the extension', async () => {
const answer = vi.fn(async () => ({ ok: true as const, value: { theme: 'dark' } }))
const worker = install(answer)
const seen: unknown[] = []
const extensionListener = (message: unknown) => {
seen.push(message)
}
worker.chrome.runtime.onMessage.addListener(extensionListener)
await expect(worker.dispatch(relayed, fromContentScript)).resolves.toEqual({
ok: true,
value: { theme: 'dark' }
})
expect(answer).toHaveBeenCalledWith('get', ['theme'], undefined)
await worker.dispatch({ hello: 1 }, fromContentScript)
expect(seen).toEqual([{ hello: 1 }])
expect(worker.browser.runtime.onMessage).toBe(worker.chrome.runtime.onMessage)
worker.chrome.runtime.onMessage.removeListener(extensionListener)
await worker.dispatch({ hello: 2 }, fromContentScript)
expect(seen).toEqual([{ hello: 1 }])
})
it('answers only the extension’s own content scripts', async () => {
const answer = vi.fn(async () => ({ ok: true as const, value: null }))
const worker = install(answer)
await expect(worker.dispatch(relayed, { id: 'ext' })).resolves.toBe('no reply')
await expect(worker.dispatch(relayed, { id: 'other', tab: { id: 1 } })).resolves.toBe(
'no reply'
)
expect(answer).not.toHaveBeenCalled()
})
it('only hides relayed calls in extension pages, leaving the answer to the worker', async () => {
const page = install()
const seen: unknown[] = []
page.chrome.runtime.onMessage.addListener((message: unknown) => {
seen.push(message)
return true
})
await expect(page.dispatch(relayed, fromContentScript)).resolves.toBe('no reply')
expect(seen).toEqual([])
})
it('passes the calling content script’s id to the worker’s answer', async () => {
const answer = vi.fn(async () => ({ ok: true as const, value: {} }))
const worker = install(answer)
const call = { [CONTENT_SCRIPT_RELAY_KEY]: { method: 'set', args: [{ a: 1 }], from: 'cs-1' } }
await worker.dispatch(call, fromContentScript)
expect(answer).toHaveBeenCalledWith('set', [{ a: 1 }], 'cs-1')
})
it('sends a content script’s call to the worker and reports a missing worker as an error', async () => {
const sendMessage = vi.fn(async () => ({ ok: true, value: 3 }))
const bridge = createContentScriptRelayBridge(sendMessage, { id: 'ext' })
await expect(bridge.call('orcaStorageSync', 'getBytesInUse', [null])).resolves.toEqual({
ok: true,
value: 3
})
expect(sendMessage).toHaveBeenCalledWith({
[CONTENT_SCRIPT_RELAY_KEY]: {
method: 'getBytesInUse',
args: [null],
from: expect.any(String)
}
})
const unanswered = createContentScriptRelayBridge(
async () => {
throw new Error('Could not establish connection. Receiving end does not exist.')
},
{ id: 'ext' }
)
await expect(unanswered.call('orcaStorageSync', 'get', [])).resolves.toEqual({
ok: false,
error: 'Could not establish connection. Receiving end does not exist.'
})
})
it('gives a listening content script the worker’s sync changes, except its own writes', async () => {
const native = new Set<Listener>()
const onMessage = {
addListener: (listener: Listener) => native.add(listener),
removeListener: (listener: Listener) => native.delete(listener)
}
const sendMessage = vi.fn(async (_message: unknown) => ({ ok: true, value: {} }))
const bridge = createContentScriptRelayBridge(sendMessage, { id: 'ext', onMessage })
const events: unknown[][] = []
bridge.onEvent((...event) => events.push(event))
const deliver = (message: unknown, sender: unknown) => {
for (const listener of native) {
listener(message, sender, () => {})
}
}
const change = (from?: string) => ({
[CONTENT_SCRIPT_RELAY_KEY]: { changes: { theme: { newValue: 'dark' } }, from }
})
expect(native.size).toBe(0)
bridge.listen('orcaStorageSync', 'onChanged', true)
await bridge.call('orcaStorageSync', 'set', [{ theme: 'light' }])
const [sent] = sendMessage.mock.calls[0]
const ownId =
isRecord(sent) && isRecord(sent[CONTENT_SCRIPT_RELAY_KEY])
? sent[CONTENT_SCRIPT_RELAY_KEY].from
: null
expect(typeof ownId).toBe('string')
deliver(change(String(ownId)), { id: 'ext' })
deliver(change(), { id: 'other-extension' })
deliver(change('another-frame'), { id: 'ext' })
expect(events).toEqual([['orcaStorageSync', 'onChanged', [{ theme: { newValue: 'dark' } }]]])
bridge.listen('orcaStorageSync', 'onChanged', false)
expect(native.size).toBe(0)
})
it('sends the worker’s sync changes to every live tab, naming the writer', async () => {
const sendMessage = vi.fn(async () => undefined)
const tabs = {
query: vi.fn(async () => [{ id: 1 }, { id: 2, discarded: true }, { id: 3 }]),
sendMessage
}
const manifest = (contentScripts: unknown[]) => ({
content_scripts: contentScripts
})
const withManifest = (contentScripts: unknown[]) =>
vi.stubGlobal('chrome', { tabs, runtime: { getManifest: () => manifest(contentScripts) } })
try {
withManifest([])
expect(createContentScriptSyncForward()).toBeNull()
withManifest([{ matches: ['<all_urls>'], js: ['content.js'] }])
createContentScriptSyncForward()?.({ a: { newValue: 1 } }, 'cs-1')
await vi.waitFor(() => expect(sendMessage).toHaveBeenCalledTimes(2))
const message = {
[CONTENT_SCRIPT_RELAY_KEY]: { changes: { a: { newValue: 1 } }, from: 'cs-1' }
}
expect(sendMessage.mock.calls).toEqual([
[1, message],
[3, message]
])
} finally {
vi.unstubAllGlobals()
}
})
})
function isRecord(value: unknown): value is Record<string, unknown> {
return value !== null && typeof value === 'object'
}