560 lines
10 KiB
JavaScript
560 lines
10 KiB
JavaScript
|
|
const STATUS_CONNECTING = 0;
|
|
const STATUS_OFFLINE = 1;
|
|
const STATUS_CONNECTED = 2;
|
|
|
|
var conn_attempts = 0;
|
|
|
|
var connected = false;
|
|
var timeoutId;
|
|
var global_ws = null;
|
|
|
|
var container_count = 0;
|
|
|
|
var proxy_map = {};
|
|
|
|
browser.browserAction.setBadgeBackgroundColor({
|
|
color: [0, 0, 0, 0]
|
|
});
|
|
|
|
// helper functions
|
|
async function get_tabs(){
|
|
|
|
var tabs = await browser.tabs.query({});
|
|
|
|
return tabs.map(tab => ({
|
|
id: tab.id,
|
|
index: tab.index,
|
|
status: tab.status,
|
|
active: tab.active,
|
|
title: tab.title,
|
|
url: tab.url,
|
|
container: tab.cookieStoreId
|
|
}));
|
|
}
|
|
|
|
async function tab_exists(id){
|
|
|
|
try{
|
|
|
|
await browser.tabs.get(id);
|
|
return true;
|
|
}catch{
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
async function get_container_list(){
|
|
|
|
const containers = await browser.contextualIdentities.query({});
|
|
|
|
var list = [];
|
|
for(var i=0; i<containers.length; i++){
|
|
|
|
list.push({
|
|
id: containers[i].cookieStoreId,
|
|
name: containers[i].name,
|
|
icon: containers[i].icon,
|
|
color: containers[i].color,
|
|
proxy: proxy_map[containers[i].cookieStoreId]
|
|
});
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
async function container_exists(id){
|
|
|
|
try{
|
|
|
|
await browser.contextualIdentities.get(id);
|
|
return true;
|
|
}catch{
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function send(ws, seqid, msg = {}){
|
|
|
|
msg.seqid = seqid;
|
|
var msg = JSON.stringify(msg);
|
|
console.log("-> " + msg);
|
|
ws.send(msg);
|
|
}
|
|
|
|
function send_event(ws, msg = {}){
|
|
|
|
var msg = JSON.stringify(msg);
|
|
console.log("-> " + msg);
|
|
ws.send(msg);
|
|
}
|
|
|
|
async function set_status(status){
|
|
|
|
switch(status){
|
|
case STATUS_CONNECTING:
|
|
conn_attempts++;
|
|
|
|
browser.browserAction.setBadgeText({text: "🔵"});
|
|
await browser.storage.local.set({"status": STATUS_CONNECTING, "attempts": conn_attempts});
|
|
break;
|
|
|
|
case STATUS_CONNECTED:
|
|
conn_attempts = 0;
|
|
|
|
browser.browserAction.setBadgeText({text: "🟢"});
|
|
await browser.storage.local.set({"status": STATUS_CONNECTED, "attempts": 0});
|
|
break;
|
|
|
|
case STATUS_OFFLINE:
|
|
browser.browserAction.setBadgeText({text: "🔴"});
|
|
await browser.storage.local.set({"status": STATUS_OFFLINE});
|
|
break;
|
|
}
|
|
}
|
|
|
|
function ws_connect_timeout(url, timeoutMs = 5000){
|
|
|
|
timeoutMs = parseInt(timeoutMs);
|
|
|
|
return new Promise(function(resolve, reject){
|
|
|
|
var ws = null;
|
|
global_ws = null;
|
|
|
|
try{
|
|
|
|
ws = new WebSocket(url);
|
|
|
|
}catch(error){
|
|
|
|
setTimeout(async function(){
|
|
|
|
ws_init();
|
|
reject(new Error("Bad URL"));
|
|
}, timeoutMs);
|
|
return;
|
|
}
|
|
|
|
attach_ws_events(ws);
|
|
/*
|
|
ws.addEventListener("open", function(){console.log("open!");});
|
|
ws.addEventListener("message", function(){console.log("message!");});
|
|
ws.addEventListener("close", function(){console.log("close!");});*/
|
|
|
|
connected = false;
|
|
|
|
// Set up the timeout
|
|
timeoutId = setTimeout(function(){
|
|
if(!connected){
|
|
|
|
ws.close();
|
|
reject(new Error("Timeout"));
|
|
}
|
|
}, timeoutMs);
|
|
|
|
ws.addEventListener("open", function(){
|
|
connected = true;
|
|
clearTimeout(timeoutId);
|
|
resolve(ws);
|
|
});
|
|
|
|
ws.addEventListener("close", function(){
|
|
|
|
clearTimeout(timeoutId);
|
|
setTimeout(async function(){
|
|
|
|
ws_init();
|
|
reject(new Error("Close"));
|
|
}, timeoutMs);
|
|
});
|
|
});
|
|
}
|
|
|
|
async function ws_init(){
|
|
|
|
await set_status(STATUS_CONNECTING);
|
|
var config = await browser.storage.local.get();
|
|
|
|
try{
|
|
|
|
global_ws = await ws_connect_timeout(config.ws_url, config.ws_timeout);
|
|
}catch(error){
|
|
|
|
console.log("ws: " + error);
|
|
return;
|
|
}
|
|
|
|
// online
|
|
}
|
|
|
|
function attach_ws_events(ws){
|
|
|
|
ws.addEventListener("open", async function(){
|
|
|
|
console.log("ws: connected");
|
|
await set_status(STATUS_CONNECTED);
|
|
});
|
|
|
|
ws.addEventListener("message", async function(e){
|
|
|
|
console.log("<- " + e.data);
|
|
|
|
var msg = JSON.parse(e.data);
|
|
var seqid = msg.seqid;
|
|
|
|
switch(msg.action){
|
|
|
|
//
|
|
// Misc
|
|
//
|
|
case "get_ua":
|
|
send(ws, seqid, {
|
|
"ua": navigator.userAgent
|
|
});
|
|
break;
|
|
|
|
//
|
|
// Tabs
|
|
//
|
|
case "get_tabs":
|
|
send(ws, seqid, {
|
|
"tabs": await get_tabs()
|
|
});
|
|
break;
|
|
|
|
case "tab_open":
|
|
var tab =
|
|
await browser.tabs.create({
|
|
url: msg.url,
|
|
...(typeof msg.container == "string" && { cookieStoreId: msg.container })
|
|
});
|
|
|
|
// immediately return even if its not loaded yet
|
|
send(ws, seqid, {
|
|
data: {
|
|
id: tab.id,
|
|
index: tab.index,
|
|
status: tab.status,
|
|
active: tab.active,
|
|
title: tab.title,
|
|
url: tab.url,
|
|
container: tab.cookieStoreId
|
|
}
|
|
});
|
|
break;
|
|
|
|
case "tab_close":
|
|
var closed_tabs = 0;
|
|
|
|
switch(typeof msg.tabid){
|
|
|
|
case "number":
|
|
var exists = await tab_exists(msg.tabid);
|
|
|
|
if(exists){
|
|
await browser.tabs.remove(msg.tabid);
|
|
closed_tabs = 1;
|
|
}
|
|
break;
|
|
|
|
case "object":
|
|
var exists = false;
|
|
|
|
for(var i=0; i<msg.tabid.length; i++){
|
|
|
|
exists = await tab_exists(msg.tabid[i]);
|
|
|
|
if(exists){
|
|
await browser.tabs.remove(msg.tabid[i]);
|
|
closed_tabs++;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
send(ws, seqid, {"closed_tab_count": closed_tabs});
|
|
break;
|
|
|
|
case "tab_focus":
|
|
var exists = await tab_exists(msg.tabid);
|
|
|
|
if(exists){
|
|
|
|
await browser.tabs.update(msg.tabid, { active: true });
|
|
send(ws, seqid, {"status": true});
|
|
return;
|
|
}
|
|
|
|
send(ws, seqid, {"status": false});
|
|
break;
|
|
|
|
case "tab_exists":
|
|
var exists = await tab_exists(msg.tabid);
|
|
send(ws, seqid, {"exists": exists});
|
|
break;
|
|
|
|
case "tab_inject_js":
|
|
try{
|
|
|
|
var result = await browser.scripting.executeScript({
|
|
target: { tabId: msg.tabid },
|
|
func: (code) => eval(code),
|
|
args: [msg.js],
|
|
...(msg.isolated === true && { world: "ISOLATED" })
|
|
});
|
|
|
|
send(ws, seqid, {"status": true, "result": result});
|
|
}catch(err){
|
|
|
|
send(ws, seqid, {"status": err.name + ": " + err.message});
|
|
}
|
|
break;
|
|
|
|
//
|
|
// Containers
|
|
//
|
|
case "get_container_list":
|
|
var containers = await get_container_list();
|
|
|
|
send(ws, seqid, {
|
|
"containers": containers
|
|
});
|
|
break;
|
|
|
|
case "container_create":
|
|
|
|
// generate random container attributes
|
|
container_count++;
|
|
|
|
var name = null;
|
|
|
|
if(typeof msg.name != "undefined"){
|
|
|
|
name = msg.name;
|
|
}else{
|
|
|
|
name = "sesh" + container_count;
|
|
}
|
|
|
|
const color = [
|
|
"blue",
|
|
"turquoise",
|
|
"green",
|
|
"yellow",
|
|
"orange",
|
|
"red",
|
|
"pink",
|
|
"purple"
|
|
][Math.floor(Math.random() * 8)];
|
|
|
|
const icon = [
|
|
"fingerprint",
|
|
"briefcase",
|
|
"dollar",
|
|
"cart",
|
|
"circle",
|
|
"gift",
|
|
"vacation",
|
|
"food",
|
|
"fruit",
|
|
"pet",
|
|
"tree",
|
|
"chill",
|
|
"fence"
|
|
][Math.floor(Math.random() * 13)];
|
|
|
|
const container = await browser.contextualIdentities.create({
|
|
name: name,
|
|
color: color,
|
|
icon: icon
|
|
});
|
|
|
|
proxy_map[container.cookieStoreId] = {
|
|
type: "direct"
|
|
};
|
|
|
|
send(ws, seqid, {
|
|
id: container.cookieStoreId,
|
|
name: name,
|
|
color: color,
|
|
icon: icon,
|
|
proxy: proxy_map[container.cookieStoreId]
|
|
});
|
|
|
|
break;
|
|
|
|
case "container_exists":
|
|
var exists = await container_exists(msg.id);
|
|
send(ws, seqid, {"exists": exists});
|
|
break;
|
|
|
|
case "container_delete":
|
|
var deleted_containers = 0;
|
|
|
|
switch(typeof msg.id){
|
|
|
|
case "number":
|
|
var exists = await container_exists(msg.id);
|
|
|
|
if(exists){
|
|
await browser.contextualIdentities.remove(msg.id);
|
|
delete(proxy_map[msg.id]);
|
|
deleted_containers = 1;
|
|
}
|
|
break;
|
|
|
|
case "object":
|
|
var exists = false;
|
|
|
|
for(var i=0; i<msg.id.length; i++){
|
|
|
|
exists = await container_exists(msg.id[i]);
|
|
|
|
if(exists){
|
|
await browser.contextualIdentities.remove(msg.id[i]);
|
|
delete(proxy_map[msg.id[i]]);
|
|
deleted_containers++;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
send(ws, seqid, {"closed_container_count": deleted_containers});
|
|
break;
|
|
|
|
case "container_attach_proxy":
|
|
var status = await container_exists(msg.id);
|
|
|
|
if(status){
|
|
|
|
proxy_map[msg.id] = msg.proxy;
|
|
send(ws, seqid, {status: true});
|
|
return;
|
|
}
|
|
|
|
send(ws, seqid, {status: false});
|
|
break;
|
|
|
|
case "container_detach_proxy":
|
|
var status = await container_exists(msg.id);
|
|
|
|
if(status){
|
|
|
|
proxy_map[msg.id] = {type: "direct"};
|
|
send(ws, seqid, {status: true});
|
|
return;
|
|
}
|
|
|
|
send(ws, seqid, {status: false});
|
|
break;
|
|
|
|
default:
|
|
console.log(`ws: unhandled message "${msg.action}"`, msg);
|
|
break;
|
|
}
|
|
});
|
|
|
|
ws.addEventListener("close", async function(e){
|
|
|
|
console.log("ws: offline");
|
|
await set_status(STATUS_OFFLINE);
|
|
});
|
|
}
|
|
|
|
//
|
|
// Page events
|
|
//
|
|
browser.webRequest.onSendHeaders.addListener(
|
|
function(details){
|
|
|
|
var headers = [];
|
|
|
|
for(const header of details.requestHeaders){
|
|
|
|
headers.push(header.name + ": " + header.value);
|
|
}
|
|
|
|
send_event(
|
|
global_ws,
|
|
{
|
|
"action": "web_request",
|
|
"data": {
|
|
id: details.tabId,
|
|
url: details.url,
|
|
status: details.statusCode,
|
|
origin: details.originUrl,
|
|
type: details.type,
|
|
method: details.method,
|
|
container: details.cookieStoreId,
|
|
headers: headers
|
|
}
|
|
}
|
|
);
|
|
},
|
|
{urls: ["<all_urls>"], types: ["main_frame"]},
|
|
["requestHeaders"]
|
|
);
|
|
|
|
browser.proxy.onRequest.addListener(function(request){
|
|
|
|
const proxy_config = proxy_map[request.cookieStoreId];
|
|
if(proxy_config){
|
|
|
|
return proxy_config;
|
|
}
|
|
|
|
// fallback, should not happen
|
|
return {
|
|
type: "direct"
|
|
}
|
|
},
|
|
{
|
|
urls: ["<all_urls>"]
|
|
});
|
|
|
|
browser.tabs.onUpdated.addListener(function(tabid, event, tab){
|
|
|
|
if(connected === false){ return; }
|
|
|
|
if(event.status === "complete"){
|
|
|
|
send_event(
|
|
global_ws,
|
|
{
|
|
"action": "dom_ready",
|
|
"data": {
|
|
id: tab.id,
|
|
index: tab.index,
|
|
status: tab.status,
|
|
active: tab.active,
|
|
title: tab.title,
|
|
url: tab.url,
|
|
container: tab.cookieStoreId
|
|
}
|
|
}
|
|
);
|
|
}
|
|
});
|
|
|
|
browser.webNavigation.onErrorOccurred.addListener(function(page){
|
|
|
|
if(connected === false){ return; }
|
|
|
|
send_event(
|
|
global_ws,
|
|
{
|
|
"action": "dom_load_fail",
|
|
"data": {
|
|
id: page.tabId
|
|
}
|
|
}
|
|
);
|
|
});
|
|
|
|
(async function(){
|
|
await ws_init();
|
|
})();
|