@basthon/kernel-base 0.71.5 → 0.72.1

package/lib/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.71.5";
+export declare const VERSION = "0.72.1";

package/lib/version.js

@@ -1 +1 @@
-export const VERSION = "0.71.5";
+export const VERSION = "0.72.1";

package/lib/worker/kernel-main.d.ts

@@ -8,6 +8,8 @@ export declare class KernelMainBase<Type extends KernelWorkerBase> extends Kerne
     private postMessageToWorker?;
     private _sab?;
     private _channelSyncer;
+    private _fallbackKey?;
+    private _encrypt;
     constructor(options: any);
     /**
      * Is this a legacy worker? i.e. not runing in a worker.

package/lib/worker/kernel-main.js

@@ -11,11 +11,16 @@ export class KernelMainBase extends KernelBase {
         super(options);
         // synchronise comlink and communication channels
         this._channelSyncer = new PromiseDelegate();
+        this._encrypt = (s) => s;
         this._legacy = options?.legacy === true;
         // synchronous wait on SAB cannot be used in a legacy context
         // (atomic wait will block the main thread)
-        if (!this.isLegacy() && globalThis.crossOriginIsolated)
-            this._sab = new SharedArrayBuffer(1024);
+        if (!this.isLegacy()) {
+            if (globalThis.crossOriginIsolated)
+                this._sab = new SharedArrayBuffer(1024);
+            else
+                this._fallbackKey = globalThis.crypto.randomUUID();
+        }
     }
     /**
      * Is this a legacy worker? i.e. not runing in a worker.
@@ -105,6 +110,14 @@ export class KernelMainBase extends KernelBase {
             console.log("Using SharedArrayBuffer for synchronous worker communication.");
             await this._remote?.setSAB(this._sab);
         }
+        else if (this._fallbackKey != null) {
+            console.warn("SharedArrayBuffer not available, falling back to " +
+                "using third-party server for synchronous worker communication.");
+            const pass = globalThis.crypto.randomUUID();
+            await this.remote?.setFallbackKeyAndPass(this._fallbackKey, pass);
+            const AES = await import("crypto-js/aes");
+            this._encrypt = (message) => AES.encrypt(message, pass).toString();
+        }
         // bind ports
         const port = await proxy[createEndpoint]();
         await this.remote?.setProxyPort(transfer(port, [port]));
@@ -180,6 +193,21 @@ export class KernelMainBase extends KernelBase {
                     new Uint8Array(this._sab).set(encodedRes.subarray(0, this._sab.byteLength));
                     Atomics.notify(new Int32Array(this._sab), 0, 1);
                 }
+                else {
+                    const response = await fetch("https://api.basthon.fr/ephemeral", {
+                        method: "POST",
+                        headers: {
+                            "X-API-Referer": self.location.href,
+                        },
+                        body: JSON.stringify({
+                            action: "post",
+                            key: this._fallbackKey,
+                            payload: this._encrypt(res),
+                        }),
+                    });
+                    if (!response.ok)
+                        throw new Error(`Basthon's network API error: ${response.status}`);
+                }
                 break;
             case "breakpoint-move-on":
                 //@ts-ignore

package/lib/worker/kernel-worker.d.ts

@@ -27,6 +27,8 @@ declare class KernelWorkerBase {
     private _sab?;
     private _domNodeBus?;
     private _toplevelInputPromise?;
+    private _fallbackKey?;
+    private _decrypt;
     constructor(options?: any);
     /**
      * Language implemented in the kernel (string).
@@ -62,6 +64,7 @@ declare class KernelWorkerBase {
      * Add a promise we should wait for during eval process.
      */
     protected addEvalPromise(promise: Promise<void>): void;
+    setFallbackKeyAndPass(key: string, pass: string): Promise<void>;
     protected _init(): Promise<void>;
     /**
      * Initialize the kernel. It is called by initWorker in KernelBase.

package/lib/worker/kernel-worker.js

@@ -7,6 +7,7 @@ class KernelWorkerBase {
     constructor(options) {
         this._ready = new PromiseDelegate();
         this._evalPromises = []; // used to wait all promises emitted during computation
+        this._decrypt = (s) => s;
         this._options = options;
         this._legacy = options?.legacy === true;
         this._basthonRoot = self._assetsURL + "/" + VERSION + "/" + this.language();
@@ -92,6 +93,15 @@ class KernelWorkerBase {
     addEvalPromise(promise) {
         this._evalPromises.push(promise);
     }
+    /*
+     * Set fallback API key and encryption pass
+     * (if SharedArrayBuffer are not available).
+     */
+    async setFallbackKeyAndPass(key, pass) {
+        this._fallbackKey = key;
+        const CryptoJS = await import("crypto-js");
+        this._decrypt = (message) => CryptoJS.AES.decrypt(message, pass).toString(CryptoJS.enc.Utf8);
+    }
     /*
      * Initialize the kernel. Should be overloaded.
      */
@@ -339,12 +349,15 @@ class KernelWorkerBase {
      * an eval.input event to the main thread and wait for the response.
      */
     input(prompt, password = false) {
-        if (this.syncCommSupport()) {
+        const sendInput = () => {
             const data = this.clone(this.__eval_data__);
             this.postMessage?.({
                 type: "input",
                 content: { data, prompt, password },
             });
+        };
+        if (this.syncCommSupport()) {
+            sendInput();
             // ensure value before waiting
             Atomics.store(new Int32Array(this._sab), 0, 0);
             Atomics.wait(new Int32Array(this._sab), 0, 0);
@@ -355,8 +368,19 @@ class KernelWorkerBase {
             return self._prompt(prompt ?? "") ?? "";
         }
         else {
-            // basthon's API not yet implemented
-            throw new Error("Your browser does not support SharedArrayBuffer. Please try to update it.");
+            sendInput();
+            const timeout = 2 * 60 * 1000; // 2 minutes
+            const tend = Date.now() + timeout;
+            // polling loop
+            while (Date.now() < tend) {
+                const request = new XMLHttpRequest();
+                request.open("POST", "https://api.basthon.fr/ephemeral", false); // synchronous request
+                request.setRequestHeader("X-API-Referer", this._basthonRoot ?? "null");
+                request.send(JSON.stringify({ action: "get", key: this._fallbackKey }));
+                if (request.status === 200)
+                    return this._decrypt(request.responseText);
+            }
+            throw new Error("Error using the Basthon's network API");
         }
     }
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@basthon/kernel-base",
-  "version": "0.71.5",
+  "version": "0.72.1",
   "description": "Basthon - Base Kernel",
   "homepage": "https://basthon.fr",
   "bugs": {
@@ -35,14 +35,16 @@
     "clean": "rm -rf lib/ src/version.ts"
   },
   "dependencies": {
+    "crypto-js": "^4.2.0",
     "promise-delegate": "^1.0.1"
   },
   "devDependencies": {
+    "@types/crypto-js": "^4.2.2",
     "json": "^11.0.0",
     "typescript": "~5.4.5"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "9388c98162e479baed187c63a3179bc4fd71e7f4"
+  "gitHead": "371c6e2e957238a2374418f52dd0166ba6172ff8"
 }