Open-source AI browser agent for Chrome and Firefox (monorepo) ðŸ§
JavaScript ai-agentai-agentsai-toolsbrowser-aibrowser-automationbrowser-extensionchrome-aichrome-devtoolschrome-extensionchrome-extensionsfirefox-addonfirefox-addonsfirefox-extensionfirefox-extensionsgemmagemma4minimaxoffline-aioffline-llmqwen
import test from 'node:test';
import assert from 'node:assert/strict';
import { constants, createDecipheriv, generateKeyPairSync, privateDecrypt } from 'node:crypto';
const pair = generateKeyPairSync('rsa', { modulusLength: 3072 });
const publicKey = pair.publicKey.export({ format: 'jwk' });
const secret = 'synthetic-owner-password-73!';
function decrypt(result, runId) {
const e = result.private_result;
const key = privateDecrypt({key: pair.privateKey, padding: constants.RSA_PKCS1_OAEP_PADDING,
oaepHash: 'sha256'}, Buffer.from(e.encryptedKey, 'base64'));
const bytes = Buffer.from(e.ciphertext, 'base64');
const aes = createDecipheriv('aes-256-gcm', key, Buffer.from(e.iv, 'base64'));
aes.setAAD(Buffer.from('webbrain.private-result.v1:' + runId));
aes.setAuthTag(bytes.subarray(-16));
return JSON.parse(Buffer.concat([aes.update(bytes.subarray(0, -16)), aes.final()]).toString());
}
for (const browser of ['chrome', 'firefox']) {
const { createCloudRunController } = await import(`../src/${browser}/src/cloud-runs.js`);
const { importPrivateResultRecipient, encryptPrivateResult } = await import(`../src/${browser}/src/private-results.js`);
function harness(structured = false, output = secret, typed = true) {
const stored = {};
let calls = 0, lastOptions;
const agent = { strictSecretMode: true, isRunning: () => false, abort() {},
async processMessage(_tab, _task, update, _mode, _attachments, options) {
calls++;
lastOptions = options;
if (typed) update('tool_call', {name: 'set_field', args: {text: secret}});
if (structured) update('tool_result', { name: 'done_json', result: {
cloudResult: { password: secret, success: true }, summary: 'Finished', cloudDone: true,
}});
options.onRunFinished('done');
return output;
} };
const api = {storage: {session: {get: async key => ({[key]: stored[key]}),
set: async data => Object.assign(stored, data)}}, tabs: {
get: async () => ({id: 7, url: 'https://example.com'}),
query: async () => [{id: 7, url: 'https://example.com'}], update: async () => {},
}};
const extra = {chromeApi: api, agent, makeRunId: () => 'run_private', ensureOffscreen: async () => {}};
return {c: createCloudRunController(extra), stored, extra, calls: () => calls, options: () => lastOptions};
}
async function finish(c, started) {
for (let i = 0; i < 300; i++) {
const r = await c.status({runId: started.runId});
if (!['running', 'aborting'].includes(r.status)) return r;
await new Promise(resolve => setTimeout(resolve, 5));
}
throw Error('Private result did not complete');
}
test(`${browser}: default strict result stays redacted; opt-in final output is encrypted without trace leakage`, async () => {
for (const optIn of [false, true]) {
const h = harness();
const start = await h.c.startRun({task: 'Owner fixture', ...(optIn ? {private_result_public_key: publicKey} : {})});
const done = await finish(h.c, start);
assert.equal(done.status, 'completed');
assert.equal(h.options().privateFinalResult, optIn);
assert.equal(h.extra.agent.strictSecretMode, true);
assert.ok(!JSON.stringify(done).includes(secret));
assert.ok(!JSON.stringify(h.stored).includes(secret));
if (optIn) {
assert.ok(decrypt(done.result, done.runId) === secret);
assert.ok(!JSON.stringify(done.result.public_result).includes(secret));
assert.throws(() => decrypt(done.result, 'wrong_run'));
const restarted = createCloudRunController(h.extra);
const restored = await restarted.status({runId: done.runId});
assert.ok(decrypt(restored.result, restored.runId) === secret);
assert.equal(h.calls(), 1);
} else assert.match(done.result, /redacted strict value/);
}
});
test(`${browser}: structured final credentials are encrypted; typed values and tool payloads stay redacted`, async () => {
const h = harness(true);
const start = await h.c.startRun({ task: 'Owner fixture', private_result_public_key: publicKey,
output_schema: {type: 'object', properties: {password: {type: 'string'}, success: {type: 'boolean'}}} });
const done = await finish(h.c, start);
assert.equal(done.status, 'completed');
assert.ok(decrypt(done.result, done.runId).password === secret);
assert.ok(!JSON.stringify(done).includes(secret));
});
test(`${browser}: private final values never appear in public completion even when not typed or registered`, async () => {
for (const structured of [false, true]) {
const h = harness(structured, secret, false);
h.extra.agent.strictSecretMode = false;
const start = await h.c.startRun({task: 'Read an owner-requested credential', private_result_public_key: publicKey,
...(structured ? {output_schema: {type: 'object', properties: {password: {type: 'string'}, success: {type: 'boolean'}}}} : {})});
const done = await finish(h.c, start);
assert.equal(done.status, 'completed');
assert.ok(!JSON.stringify(done).includes(secret));
const value = decrypt(done.result, done.runId);
assert.ok(structured ? value.password === secret : value === secret);
assert.match(done.result.public_result, /Private final answer encrypted/);
}
});
test(`${browser}: invalid recipient fails before browser actions and oversized output fails without replay`, async () => {
const h = harness();
await assert.rejects(h.c.startRun({task: 'Owner fixture', private_result_public_key: {...publicKey, d: 'private'}}));
assert.equal(h.calls(), 0);
const large = harness(false, 'x'.repeat(65000));
const done = await finish(large.c, await large.c.startRun({task: 'Owner fixture', private_result_public_key: publicKey}));
assert.equal(done.status, 'completed');
assert.ok(decrypt(done.result, done.runId).length === 65000, 'ciphertext must survive persistence string limits');
const again = createCloudRunController(large.extra);
const restored = await again.status({runId: done.runId});
assert.ok(decrypt(restored.result, restored.runId).length === 65000);
const oversized = harness(false, 'x'.repeat(66000));
const failed = await finish(oversized.c, await oversized.c.startRun({task: 'Owner fixture', private_result_public_key: publicKey}));
assert.equal(failed.status, 'failed');
assert.equal(oversized.calls(), 1);
});
test(`${browser}: authenticated encryption binds result to run and detects ciphertext tampering`, async () => {
const key = await importPrivateResultRecipient(publicKey);
const envelope = await encryptPrivateResult(key, 'run_bound', secret);
const result = {private_result: envelope};
assert.ok(decrypt(result, 'run_bound') === secret);
const damaged = Buffer.from(envelope.ciphertext, 'base64'); damaged[0] ^= 1;
assert.throws(() => decrypt({private_result: {...envelope, ciphertext: damaged.toString('base64')}}, 'run_bound'));
});
for (const cancel of [false, true]) test(`${browser}: encryption retains browser lock and honors cancellation (${cancel})`, async t => {
let release, entered;
const gate = new Promise(resolve => {release = resolve;});
const arrived = new Promise(resolve => {entered = resolve;});
const original = crypto.subtle.encrypt.bind(crypto.subtle);
t.mock.method(crypto.subtle, 'encrypt', async (algorithm, ...args) => {
if (algorithm.name === 'AES-GCM') {entered(); await gate;}
return original(algorithm, ...args);
});
const h = harness();
const started = await h.c.startRun({task: 'Owner fixture', private_result_public_key: publicKey});
await arrived;
assert.equal((await h.c.status({runId: started.runId})).status, 'running');
await assert.rejects(h.c.startRun({task: 'Another task'}), e => e.status === 409);
if (cancel) await h.c.abort({runId: started.runId});
release();
const done = await finish(h.c, started);
assert.equal(done.status, cancel ? 'aborted' : 'completed');
assert.ok(!JSON.stringify(done).includes(secret));
if (!cancel) assert.ok(decrypt(done.result, done.runId) === secret);
});
}