2023-07-20 19:43:41 +00:00
|
|
|
import {
|
2023-08-10 07:14:54 +00:00
|
|
|
downloadSmallObject,
|
2023-07-20 19:43:41 +00:00
|
|
|
maybeInitDefaultPortals,
|
2023-09-11 09:56:40 +00:00
|
|
|
savePortals,
|
2023-10-19 21:12:24 +00:00
|
|
|
savePortalSessions,
|
2023-07-20 19:43:41 +00:00
|
|
|
setActivePortalMasterKey,
|
|
|
|
} from "@lumeweb/libweb";
|
|
|
|
import { log, logErr, sendAuthUpdate } from "./util.js";
|
|
|
|
import {
|
|
|
|
defaultKernelLink,
|
|
|
|
setKernelLoaded,
|
|
|
|
setLoginComplete,
|
|
|
|
} from "./vars.js";
|
|
|
|
import { getStoredUserKey } from "./storage.js";
|
|
|
|
import { readableStreamToBlob } from "binconv";
|
2023-09-08 17:56:42 +00:00
|
|
|
import { addContextToErr } from "@lumeweb/libkernel";
|
2023-07-20 19:43:41 +00:00
|
|
|
|
2023-09-11 09:56:03 +00:00
|
|
|
let kernelLoadAttempt = false;
|
|
|
|
|
2023-11-04 07:04:34 +00:00
|
|
|
function testIndexedDBSupport() {
|
|
|
|
return new Promise((resolve, reject) => {
|
|
|
|
// Check for IndexedDB support
|
|
|
|
if (!("indexedDB" in window)) {
|
|
|
|
reject(new Error("IndexedDB is not supported by this browser."));
|
|
|
|
} else {
|
|
|
|
// Attempt to open an IndexedDB database
|
|
|
|
const request = indexedDB.open("test_db", 1);
|
|
|
|
|
|
|
|
request.onerror = function (event) {
|
|
|
|
// Error occurred, reject the promise
|
2023-11-04 07:34:21 +00:00
|
|
|
|
|
|
|
reject(
|
|
|
|
// @ts-ignore
|
|
|
|
new Error("IndexedDB test error: " + event?.target?.error?.code),
|
|
|
|
);
|
2023-11-04 07:04:34 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
request.onsuccess = function (event) {
|
|
|
|
// Success, resolve the promise
|
|
|
|
// @ts-ignore
|
|
|
|
event?.target?.result.close(); // Close the DB when done
|
|
|
|
resolve(true);
|
|
|
|
};
|
|
|
|
|
|
|
|
request.onupgradeneeded = function (event: IDBVersionChangeEvent) {
|
|
|
|
// Database needs to be created or upgraded
|
|
|
|
// @ts-ignore
|
|
|
|
const db = event?.target?.result;
|
|
|
|
if (!db.objectStoreNames.contains("test_store")) {
|
|
|
|
// Create an object store
|
|
|
|
db.createObjectStore("test_store", { keyPath: "id" });
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
export async function boot() {
|
2023-07-20 19:43:41 +00:00
|
|
|
let userKey;
|
|
|
|
|
2023-11-04 07:34:37 +00:00
|
|
|
try {
|
|
|
|
await testIndexedDBSupport();
|
|
|
|
} catch {
|
2023-11-04 07:04:34 +00:00
|
|
|
setKernelLoaded("indexeddb_error");
|
|
|
|
logErr("indexed db is not supported or is blocked");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2023-07-20 19:43:41 +00:00
|
|
|
try {
|
|
|
|
userKey = getStoredUserKey();
|
|
|
|
} catch (e) {
|
|
|
|
logErr(addContextToErr(e, "user key could not be fetched"));
|
|
|
|
sendAuthUpdate();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!userKey) {
|
|
|
|
sendAuthUpdate();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
log("user is already logged in, attempting to load kernel");
|
|
|
|
setActivePortalMasterKey(userKey);
|
|
|
|
setLoginComplete(true);
|
|
|
|
sendAuthUpdate();
|
|
|
|
loadKernel();
|
|
|
|
}
|
|
|
|
|
|
|
|
export async function loadKernel() {
|
2023-09-11 09:56:03 +00:00
|
|
|
if (kernelLoadAttempt) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
kernelLoadAttempt = true;
|
|
|
|
|
2023-09-08 17:56:42 +00:00
|
|
|
try {
|
|
|
|
maybeInitDefaultPortals();
|
|
|
|
} catch (e) {
|
|
|
|
let err = addContextToErr(e, "unable to init portals");
|
2023-07-20 19:43:41 +00:00
|
|
|
setKernelLoaded(err);
|
|
|
|
logErr(err);
|
|
|
|
sendAuthUpdate();
|
|
|
|
return;
|
|
|
|
}
|
2023-09-08 17:56:42 +00:00
|
|
|
let kernelCode;
|
|
|
|
try {
|
|
|
|
kernelCode = await downloadDefaultKernel();
|
|
|
|
} catch (e) {
|
|
|
|
let extErr = addContextToErr(e, "unable to download kernel");
|
2023-07-20 19:43:41 +00:00
|
|
|
setKernelLoaded(extErr);
|
|
|
|
logErr(extErr);
|
|
|
|
sendAuthUpdate();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2023-09-11 09:56:40 +00:00
|
|
|
savePortals();
|
2023-10-19 21:12:24 +00:00
|
|
|
savePortalSessions();
|
2023-09-11 09:56:40 +00:00
|
|
|
|
2023-07-20 19:43:41 +00:00
|
|
|
try {
|
|
|
|
await new Promise(async (resolve, reject) => {
|
|
|
|
const url = URL.createObjectURL(await readableStreamToBlob(kernelCode));
|
|
|
|
|
|
|
|
const el = document.createElement("script");
|
|
|
|
el.src = url;
|
|
|
|
el.onload = () => {
|
|
|
|
URL.revokeObjectURL(url);
|
|
|
|
resolve(null);
|
|
|
|
};
|
|
|
|
el.onerror = (
|
|
|
|
event: Event | string,
|
|
|
|
source?: string,
|
|
|
|
lineno?: number,
|
|
|
|
colno?: number,
|
|
|
|
error?: Error,
|
|
|
|
) => {
|
|
|
|
URL.revokeObjectURL(url);
|
|
|
|
reject(error);
|
|
|
|
};
|
|
|
|
|
|
|
|
document.head.appendChild(el);
|
|
|
|
});
|
|
|
|
|
|
|
|
setKernelLoaded("success");
|
|
|
|
sendAuthUpdate();
|
|
|
|
log("kernel successfully loaded");
|
|
|
|
return;
|
|
|
|
} catch (err: any) {
|
|
|
|
let extErr = addContextToErr(err, "unable to eval kernel");
|
|
|
|
setKernelLoaded(extErr);
|
|
|
|
logErr(extErr);
|
|
|
|
logErr(err.toString());
|
|
|
|
console.error(extErr);
|
|
|
|
console.error(err);
|
|
|
|
sendAuthUpdate();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-09-08 17:56:42 +00:00
|
|
|
async function downloadKernel(kernelCid: string): Promise<ReadableStream> {
|
|
|
|
return await downloadSmallObject(kernelCid);
|
2023-07-20 19:43:41 +00:00
|
|
|
}
|
|
|
|
|
2023-09-08 17:56:42 +00:00
|
|
|
function downloadDefaultKernel(): Promise<ReadableStream> {
|
2023-07-20 19:43:41 +00:00
|
|
|
return downloadKernel(defaultKernelLink);
|
|
|
|
}
|