AnyEvent-MCP
view release on metacpan or search on metacpan
webbrowser/mcp-webbrowser.user.js view on Meta::CPAN
}
if (tab.mcp_webbrowser?.enabled)
start (tab, undefined, allow);
else
allow ();
});
function start (tab, allow_menu, allow) {
/////////////////////////////////////////////////////////////////////////////
// Tab permission and identity are userscript-manager state, not origin state.
function random_id () {
return Array.from (crypto.getRandomValues (new Uint8Array (16)),
byte => byte.toString (16).padStart (2, "0")).join ("");
}
let instance_id;
let broker_url = "";
let ws;
let reconnect_timer;
let active;
let toggle_menu;
let mark_menu;
let marked = false;
let indicator_menus = [];
let indicators;
let status = "connecting";
let connection_error = "";
let offline_timer, grace_timer, title_observer, toast, toast_timer;
const symbols = { connecting: "ð¡", connected: "ð¢", disconnected: "ð´" };
const title_symbols = { connecting: "â", connected: "â", disconnected: "â" };
const title_prefix = /^(?:\[(?:â|â|â)MCP\]\s*)+/;
function plain_title (title) {
return title.replace (title_prefix, "");
}
function update_title () {
if (!document.head)
return;
const enabled = tab?.mcp_webbrowser?.enabled && indicators.title;
if (enabled && !title_observer) {
title_observer = new MutationObserver (update_title);
title_observer.observe (document.head, { childList: true, subtree: true, characterData: true });
} else if (!enabled && title_observer) {
title_observer.disconnect ();
title_observer = undefined;
}
const base = plain_title (document.title);
const title = enabled ? `[${title_symbols[status]}MCP]${base ? " " + base : ""}` : base;
if (document.title !== title)
document.title = title;
}
function hide_toast () {
clearTimeout (toast_timer);
toast?.remove ();
toast = undefined;
}
function show_toast () {
if (!tab?.mcp_webbrowser?.enabled || !indicators.toast ||
document.visibilityState !== "visible" || !document.documentElement)
return;
if (!toast) {
try {
toast = GM_addElement (document.documentElement, "div", {});
if (!toast)
throw new Error ("GM_addElement returned no element");
toast.style.cssText = "position:fixed!important;right:12px!important;bottom:12px!important;"
+ "z-index:2147483647!important;background:#202020!important;color:white!important;"
+ "border:1px solid #888!important;border-radius:8px!important;padding:9px 13px!important;"
+ "font:13px sans-serif!important;pointer-events:none!important";
} catch (err) {
toast = undefined;
console.warn ("mcp-webbrowser: cannot show indicator", err);
return;
}
}
toast.textContent = `${symbols[status]} MCP ${status}${connection_error ? ": " + connection_error : ""}`;
clearTimeout (toast_timer);
if (status === "connected")
toast_timer = setTimeout (hide_toast, 3000);
}
function set_status (next) {
if (status === next)
return;
status = next;
update_title ();
register_menu ();
if (toast)
show_toast ();
}
function clear_status_timers () {
clearTimeout (offline_timer);
clearTimeout (grace_timer);
offline_timer = grace_timer = undefined;
}
function awaiting_connection () {
if (!tab?.mcp_webbrowser?.enabled)
return;
if (!offline_timer && status !== "disconnected")
offline_timer = setTimeout (() => {
offline_timer = undefined;
set_status ("disconnected");
}, 30000);
if (status === "connected" && !grace_timer)
grace_timer = setTimeout (() => {
grace_timer = undefined;
set_status ("connecting");
}, 1500);
}
function connected () {
connection_error = "";
clear_status_timers ();
set_status ("connected");
}
function webbrowser_url (url, target) {
const u = new URL (url);
if (u.protocol === "http:")
u.protocol = "ws:";
else if (u.protocol === "https:")
u.protocol = "wss:";
else if (u.protocol !== "ws:" && u.protocol !== "wss:")
throw new Error ("expected an HTTP or WebSocket URL");
if (u.search || u.hash)
throw new Error ("broker URL must not contain a query or fragment");
u.pathname = u.pathname.replace (/\/+$/, "") + "/" + encodeURIComponent (target);
return u.href;
}
function disconnect (revoke = false) {
clearTimeout (reconnect_timer);
reconnect_timer = undefined;
const socket = ws;
ws = undefined;
for (const id in pending) {
pending[id].cancel?.();
delete pending[id];
}
if (socket) {
if (revoke && socket.readyState === WebSocket.OPEN)
socket.send (JSON.stringify (["quit"]));
socket.close ();
}
}
function inject_script (script, inserted, failed) {
function inject () {
try {
GM_addElement (
document.documentElement, "script", { textContent: script }
).remove ();
inserted ();
} catch (err) {
failed (err);
}
}
if (!document.documentElement) {
document.addEventListener ("DOMContentLoaded", inject, { once: true });
return () => document.removeEventListener ("DOMContentLoaded", inject);
}
inject ();
}
const pending = Object.create (null);
let eval_id = 0;
let compile_queue;
// Cross the isolated-world boundary only for evaluation. Never pass the broker
// URL or socket into page JavaScript. Results are data, not authentication.
function execute_in_page (code, navigate, max_bytes) {
const channel = "mcp-eval-" + instance_id + "-" + ++eval_id;
const stop_channel = channel + "-stop";
const { promise, resolve } = Promise.withResolvers ();
const ready = compile_queue;
const done = Promise.withResolvers ();
compile_queue = done.promise;
let compiled = false;
let finished = false;
let released = false;
let startup_timer;
let cancel_injection;
function release () {
if (!released) {
released = true;
// A cancelled waiter must not let its successor overtake its predecessor.
ready.then (() => done.resolve ());
}
}
function cleanup () {
window.removeEventListener (channel, receive);
clearTimeout (startup_timer);
cancel_injection?.();
window.dispatchEvent (new CustomEvent (stop_channel));
}
function finish (success, value) {
if (finished)
return;
finished = true;
cleanup ();
release ();
resolve ([success, value]);
}
function receive (ev) {
let reply;
try {
reply = JSON.parse (ev.detail);
} catch (err) {
finish (false, "Invalid page evaluation result: " + err);
return;
}
if (reply[0] === "compiled") {
compiled = true;
clearTimeout (startup_timer);
release ();
} else
finish (reply[0] === "syntax-error" ? false : reply[0], reply[1]);
}
function start () {
if (finished)
return;
window.addEventListener (channel, receive);
// A separate, known-good page-world script can report parsing failures
// even when the following source never executes.
try {
cancel_injection = inject_script (`
{
const channel = ${JSON.stringify (channel)};
const stop_channel = ${JSON.stringify (stop_channel)};
const cleanup = () => {
window.removeEventListener ("error", on_error, true);
window.removeEventListener (channel, on_compiled);
window.removeEventListener (stop_channel, cleanup);
};
const on_compiled = ev => {
if (ev.detail === '["compiled"]')
cleanup ();
};
const on_error = ev => {
if (ev.error?.name !== "SyntaxError" && !/SyntaxError/.test (ev.message || ""))
return;
const message = ev.message +
(ev.filename ? " (" + ev.filename + ":" + ev.lineno + ":" + ev.colno + ")" : "");
cleanup ();
window.dispatchEvent (new CustomEvent (channel, {
detail: JSON.stringify (["syntax-error", message]),
}));
};
window.addEventListener ("error", on_error, true);
window.addEventListener (channel, on_compiled);
window.addEventListener (stop_channel, cleanup);
}
`, () => {
// Inject only after the error listener is installed.
Promise.resolve ().then (() => {
if (finished)
return;
try {
cancel_injection = inject_script (`
{
let navigate_cb;
const report = (success, value) => {
window.navigation?.removeEventListener ("navigatesuccess", navigate_cb);
let detail;
try {
detail = JSON.stringify ([success, value]);
const bytes = new TextEncoder ().encode (detail).length;
if (bytes > ${max_bytes})
detail = JSON.stringify ([false,
"Browser result too large (" + bytes + " bytes; max " + ${max_bytes} + ")"]);
} catch (err) {
detail = JSON.stringify ([false, "Cannot serialize result: " + err]);
}
window.dispatchEvent (new CustomEvent (${JSON.stringify (channel)}, { detail }));
};
const fn = async () =>
${code}
;
if (${navigate} && window.navigation) {
navigate_cb = () => report (true, { url: location.href, title: document.title });
navigation.addEventListener ("navigatesuccess", navigate_cb);
window.addEventListener (${JSON.stringify (stop_channel)},
() => navigation.removeEventListener ("navigatesuccess", navigate_cb),
{ once: true });
}
window.dispatchEvent (new CustomEvent (${JSON.stringify (channel)}, {
detail: '["compiled"]',
}));
Promise.resolve ().then (fn).then (
value => {
if (!${navigate}) {
if (typeof value === "function")
report (false, "Cannot return function; pass CODE, not async () => CODE");
else if (typeof value === "symbol")
report (false, "Cannot return symbol; expected JSON value");
else
report (true, value === undefined ? null : value);
}
},
err => report (false, String (err))
);
}
//# sourceURL=mcp-webbrowser-eval-${eval_id}
`, () => {
if (!compiled && !finished)
startup_timer = setTimeout (() => finish (false,
"Page code did not start (syntax error or blocked injection)"), 200);
}, err => finish (false, "Cannot inject page code: " + err));
} catch (err) {
finish (false, "Cannot inject page code: " + err);
}
});
}, err => finish (false, "Cannot install page error listener: " + err));
} catch (err) {
finish (false, "Cannot install page error listener: " + err);
}
}
ready.then (start);
return {
promise,
cancel: () => finish (false, "Browser execution cancelled"),
};
}
function start_execution (socket, id, code, navigate, max_bytes = 16 * 1024) {
console.log ("mcp-webbrowser " + (navigate ? "navigate" : "execute") + " #" + id + ":", code);
const call = execute_in_page (code, navigate, max_bytes);
pending[id] = call;
call.promise.then (([success, value]) => {
if (pending[id] !== call || ws !== socket)
return;
delete pending[id];
if (success && navigate)
value.title = plain_title (value.title);
const reply = success && navigate
? ["navigated", id, value] : ["reply", id, success, value];
let message = JSON.stringify (reply);
const bytes = new TextEncoder ().encode (message).length;
if (bytes > max_bytes)
message = JSON.stringify (["reply", id, false,
"Browser result too large (" + bytes + " bytes; max " + max_bytes + ")"]);
socket.send (message);
});
}
function add_element (socket, id, args) {
try {
const parent = args.parent
? document.querySelector (args.parent) : document.documentElement;
if (!parent)
throw new Error ("Element parent not found: " + (args.parent || "document root"));
// GM_addElement applies initial properties before insertion, important
// for CSP-sensitive style/script elements.
const element = GM_addElement (parent, args.tag, {
...args.attributes, ...args.properties,
});
if (!element)
throw new Error ("GM_addElement returned no element");
for (const [name, value] of Object.entries (args.attributes || {}))
element.setAttribute (name, value);
socket.send (JSON.stringify (["reply", id, true,
{ tag: element.localName, id: element.getAttribute ("id") }]));
} catch (err) {
socket.send (JSON.stringify (["reply", id, false, String (err)]));
}
}
function connect () {
if (ws || !tab?.mcp_webbrowser?.enabled || !broker_url)
return;
awaiting_connection ();
clearTimeout (reconnect_timer);
reconnect_timer = undefined;
let url;
try {
url = webbrowser_url (broker_url, tab.mcp_webbrowser.id);
} catch (err) {
console.warn ("mcp-webbrowser: invalid broker URL", err);
return;
}
let socket;
try {
socket = new WebSocket (url);
} catch (err) {
console.warn ("mcp-webbrowser: cannot open WebSocket", err);
reconnect_timer = setTimeout (connect, 5000);
return;
}
ws = socket;
socket.onopen = () => {
if (socket !== ws)
return;
socket.send (JSON.stringify ([
"mcp-webbrowser", 1, 2, instance_id,
{ url: location.href, title: plain_title (document.title) },
]));
};
socket.onmessage = ev => {
if (socket !== ws)
return;
let msg;
try {
msg = JSON.parse (ev.data);
} catch {
socket.close (4002, "Invalid browser protocol");
return;
}
if (!Array.isArray (msg)) {
socket.close (4002, "Invalid browser protocol");
} else if (msg[0] === "welcome") {
if (msg[2] !== instance_id)
socket.close (4002, "Wrong document instance");
else {
connected ();
if (tab.mcp_webbrowser.allow_pending) {
socket.send (JSON.stringify (["allowed"]));
delete tab.mcp_webbrowser.allow_pending;
GM_saveTab (tab);
}
}
} else if (msg[0] === "marked" && typeof msg[1] === "boolean") {
marked = msg[1];
register_menu ();
} else if (msg[0] === "call" && (msg[2] === "execute" || msg[2] === "navigate")
&& typeof msg[3]?.code === "string") {
if (msg[2] === "navigate") {
pending[msg[1]] = { code: msg[3].code, max_bytes: msg[3].max_bytes, phase: "ready" };
socket.send (JSON.stringify (["ready", msg[1]]));
} else {
start_execution (socket, msg[1], msg[3].code, false, msg[3].max_bytes);
}
} else if (msg[0] === "call" && msg[2] === "add_element") {
add_element (socket, msg[1], msg[3]);
} else if (msg[0] === "call" && msg[2] === "list_tab_operations") {
socket.send (JSON.stringify (["reply", msg[1], true, []]));
} else if (msg[0] === "call" && msg[2] === "call_tab_operation") {
socket.send (JSON.stringify (["reply", msg[1], false, "No additional operations"]));
} else if (msg[0] === "proceed") {
const call = pending[msg[1]];
if (!call || call.phase !== "ready") {
socket.close (4002, "Unexpected navigation proceed");
} else {
delete pending[msg[1]];
start_execution (socket, msg[1], call.code, true, call.max_bytes);
}
} else if (msg[0] === "cancel") {
pending[msg[1]]?.cancel?.();
delete pending[msg[1]];
} else {
socket.close (4002, "Unknown browser message");
}
};
socket.onclose = ev => {
if (socket !== ws)
return;
for (const id in pending) {
pending[id].cancel?.();
delete pending[id];
}
if (ev.code !== 1000 && ev.code !== 1001) {
connection_error = `WebSocket ${ev.code}${ev.reason ? ": " + ev.reason : ""}`;
console.warn ("mcp-webbrowser:", connection_error);
set_status ("disconnected");
show_toast ();
}
ws = undefined;
if (tab?.mcp_webbrowser?.enabled) {
awaiting_connection ();
reconnect_timer = setTimeout (connect, 5000);
}
};
}
function configure_broker () {
const value = prompt ("mcp-webbrowser --print-url (empty to disable):", broker_url);
if (value === null)
return false;
const url = value.trim ();
try {
if (url)
webbrowser_url (url, "test");
} catch (err) {
alert (err.message);
return false;
}
broker_url = url;
GM_setValue ("mcp-webbrowser-url", broker_url);
disconnect ();
if (tab?.mcp_webbrowser?.enabled) {
clear_status_timers ();
set_status (broker_url ? "connecting" : "disconnected");
}
connect ();
return !!broker_url;
}
function register_menu () {
if (toggle_menu !== undefined)
GM_unregisterMenuCommand (toggle_menu);
if (mark_menu !== undefined)
GM_unregisterMenuCommand (mark_menu);
for (const id of indicator_menus)
GM_unregisterMenuCommand (id);
indicator_menus = [];
toggle_menu = GM_registerMenuCommand (
`Disconnect MCP access to this tab (${status})`,
() => {
tab.mcp_webbrowser.enabled = false;
GM_saveTab (tab);
deactivate (true);
GM_unregisterMenuCommand (toggle_menu);
for (const id of indicator_menus)
GM_unregisterMenuCommand (id);
GM_unregisterMenuCommand (mark_menu);
GM_unregisterMenuCommand (configure_menu);
allow ();
}
);
mark_menu = GM_registerMenuCommand (marked ? "Unmark this MCP tab" : "Mark this tab for MCP", () => {
if (ws?.readyState === WebSocket.OPEN)
ws.send (JSON.stringify (["mark", !marked]));
});
( run in 0.978 second using v1.01-cache-2.11-cpan-234fa220139 )