@heyputer/puter.js 2.1.4 → 2.1.7

package/src/modules/Util.js

@@ -1,4 +1,4 @@
-import { $SCOPE, CallbackManager, Dehydrator, Hydrator } from "../lib/xdrpc.js";
+import { $SCOPE, CallbackManager, Dehydrator, Hydrator } from '../lib/xdrpc.js';
 
 /**
  * The Util module exposes utilities within puter.js itself.
@@ -27,11 +27,11 @@ class UtilRPC {
     getHydrator ({ target }) {
         return new Hydrator({ target });
     }
-    
+
     registerCallback (resolve) {
         return this.callbackManager.register_callback(resolve);
     }
-    
+
     send (target, id, ...args) {
         target.postMessage({ $SCOPE, id, args }, '*');
     }

package/src/modules/Workers.js

@@ -1,14 +1,14 @@
-import getAbsolutePathForApp from "./FileSystem/utils/getAbsolutePathForApp.js";
+import getAbsolutePathForApp from './FileSystem/utils/getAbsolutePathForApp.js';
 import * as utils from '../lib/utils.js';
 
 export class WorkersHandler {
 
-    constructor(authToken) {
+    constructor (authToken) {
         this.authToken = authToken;
     }
 
-    async create(workerName, filePath, appName) {
-        if (!puter.authToken && puter.env === 'web') {
+    async create (workerName, filePath, appName) {
+        if ( !puter.authToken && puter.env === 'web' ) {
             try {
                 await puter.ui.authenticateWithPuter();
             } catch (e) {
@@ -18,30 +18,30 @@ export class WorkersHandler {
         }
 
         let appId;
-        if (typeof (appName)=== "string") {
+        if ( typeof (appName) === 'string' ) {
             appId = ((await puter.apps.list()).find(el => el.name === appName)).uid;
         }
 
         workerName = workerName.toLocaleLowerCase(); // just incase
-        let currentWorkers = await puter.kv.get("user-workers");
-        if (!currentWorkers) {
+        let currentWorkers = await puter.kv.get('user-workers');
+        if ( ! currentWorkers ) {
             currentWorkers = {};
         }
         filePath = getAbsolutePathForApp(filePath);
 
-        const driverResult = await utils.make_driver_method(['authorization', 'filePath', 'workerName', 'appId'], 'workers', "worker-service", 'create')(puter.authToken, filePath, workerName, appId);;
+        const driverResult = await utils.make_driver_method(['authorization', 'filePath', 'workerName', 'appId'], 'workers', 'worker-service', 'create')(puter.authToken, filePath, workerName, appId);;
 
-        if (!driverResult.success) {
-            throw new Error(driverResult?.errors || "Driver failed to execute, do you have the necessary permissions?");
+        if ( ! driverResult.success ) {
+            throw new Error(driverResult?.errors || 'Driver failed to execute, do you have the necessary permissions?');
         }
-        currentWorkers[workerName] = { filePath, url: driverResult["url"], deployTime: Date.now(), createTime: Date.now() };
-        await puter.kv.set("user-workers", currentWorkers);
+        currentWorkers[workerName] = { filePath, url: driverResult['url'], deployTime: Date.now(), createTime: Date.now() };
+        await puter.kv.set('user-workers', currentWorkers);
 
         return driverResult;
     }
 
-    async exec(...args) {
-        if (!puter.authToken && puter.env === 'web') {
+    async exec (...args) {
+        if ( !puter.authToken && puter.env === 'web' ) {
             try {
                 await puter.ui.authenticateWithPuter();
             } catch (e) {
@@ -51,14 +51,14 @@ export class WorkersHandler {
         }
 
         const req = new Request(...args);
-        if (!req.headers.get("puter-auth")) {
-            req.headers.set("puter-auth", puter.authToken);
+        if ( ! req.headers.get('puter-auth') ) {
+            req.headers.set('puter-auth', puter.authToken);
         }
         return fetch(req);
     }
 
-    async list() {
-        if (!puter.authToken && puter.env === 'web') {
+    async list () {
+        if ( !puter.authToken && puter.env === 'web' ) {
             try {
                 await puter.ui.authenticateWithPuter();
             } catch (e) {
@@ -66,12 +66,12 @@ export class WorkersHandler {
                 throw 'Authentication failed.';
             }
         }
-        const driverCall = await utils.make_driver_method([], 'workers', "worker-service", 'getFilePaths')();
+        const driverCall = await utils.make_driver_method([], 'workers', 'worker-service', 'getFilePaths')();
         return driverCall;
     }
 
-    async get(workerName) {
-        if (!puter.authToken && puter.env === 'web') {
+    async get (workerName) {
+        if ( !puter.authToken && puter.env === 'web' ) {
             try {
                 await puter.ui.authenticateWithPuter();
             } catch (e) {
@@ -81,12 +81,12 @@ export class WorkersHandler {
         }
 
         workerName = workerName.toLocaleLowerCase(); // just incase
-        const driverCall = await utils.make_driver_method(['workerName'], 'workers', "worker-service", 'getFilePaths')(workerName);
+        const driverCall = await utils.make_driver_method(['workerName'], 'workers', 'worker-service', 'getFilePaths')(workerName);
         return driverCall[0];
     }
 
-    async delete(workerName) {
-        if (!puter.authToken && puter.env === 'web') {
+    async delete (workerName) {
+        if ( !puter.authToken && puter.env === 'web' ) {
             try {
                 await puter.ui.authenticateWithPuter();
             } catch (e) {
@@ -97,74 +97,77 @@ export class WorkersHandler {
 
         workerName = workerName.toLocaleLowerCase(); // just incase
         // const driverCall = await puter.drivers.call("workers", "worker-service", "destroy", { authorization: puter.authToken, workerName });
-        const driverResult = await utils.make_driver_method(['authorization', 'workerName'], 'workers', "worker-service", 'destroy')(puter.authToken, workerName);
+        const driverResult = await utils.make_driver_method(['authorization', 'workerName'], 'workers', 'worker-service', 'destroy')(puter.authToken, workerName);
 
-        if (!driverResult.result) {
-            if (!driverResult.result) {
+        if ( ! driverResult.result ) {
+            if ( ! driverResult.result ) {
                 new Error("Worker doesn't exist");
             }
-            throw new Error(driverResult?.errors || "Driver failed to execute, do you have the necessary permissions?");
+            throw new Error(driverResult?.errors || 'Driver failed to execute, do you have the necessary permissions?');
         } else {
-            let currentWorkers = await puter.kv.get("user-workers");
+            let currentWorkers = await puter.kv.get('user-workers');
 
-            if (!currentWorkers) {
+            if ( ! currentWorkers ) {
                 currentWorkers = {};
             }
             delete currentWorkers[workerName];
 
-            await puter.kv.set("user-workers", currentWorkers);
+            await puter.kv.set('user-workers', currentWorkers);
             return true;
         }
     }
-    
+
     async getLoggingHandle (workerName) {
-        const loggingEndpoint = await utils.make_driver_method([], 'workers', "worker-service", 'getLoggingUrl')(puter.authToken, workerName);
+        const loggingEndpoint = await utils.make_driver_method([], 'workers', 'worker-service', 'getLoggingUrl')(puter.authToken, workerName);
         const socket = new WebSocket(`${loggingEndpoint}/${puter.authToken}/${workerName}`);
         const logStreamObject = new EventTarget();
-        logStreamObject.onLog = (data) => { };
+        logStreamObject.onLog = (data) => {
+
+        };
 
         // Coercibility to ReadableStream
         Object.defineProperty(logStreamObject, 'start', {
             enumerable: false,
             value: async (controller) => {
-                socket.addEventListener("message", (event) => {
+                socket.addEventListener('message', (event) => {
                     controller.enqueue(JSON.parse(event.data));
                 });
-                socket.addEventListener("close", (event) => {
+                socket.addEventListener('close', (event) => {
                     try {
                         controller.close();
-                    } catch (e) { }
+                    } catch (e) {
+
+                    }
                 });
-            }
+            },
         });
         Object.defineProperty(logStreamObject, 'cancel', {
             enumerable: false,
             value: async () => {
                 socket.close();
-            }
+            },
         });
 
+        socket.addEventListener('message', (event) => {
+            const logEvent = new MessageEvent('log', { data: JSON.parse(event.data) });
 
-        socket.addEventListener("message", (event) => {
-            const logEvent = new MessageEvent("log", { data: JSON.parse(event.data) });
-
-            logStreamObject.dispatchEvent(logEvent)
+            logStreamObject.dispatchEvent(logEvent);
             logStreamObject.onLog(logEvent);
         });
         logStreamObject.close = socket.close;
         return new Promise((res, rej) => {
             let done = false;
-            socket.onopen = ()=>{
+            socket.onopen = () => {
                 done = true;
                 res(logStreamObject);
-            }
+            };
 
             socket.onerror = () => {
-                if (!done) {
-                    rej("Failed to open logging connection");
+                if ( ! done ) {
+                    rej('Failed to open logging connection');
                 }
-            }
-        })
+            };
+        });
     }
 
 }

package/src/modules/networking/PSocket.js

@@ -1,41 +1,41 @@
-import EventListener from "../../lib/EventListener.js";
-import { errors } from "./parsers.js";
-import { PWispHandler } from "./PWispHandler.js";
+import EventListener from '../../lib/EventListener.js';
+import { errors } from './parsers.js';
+import { PWispHandler } from './PWispHandler.js';
 const texten = new TextEncoder();
 const requireAuth = false; // for initial launch
 
 export let wispInfo = {
-    server: "wss://puter.cafe/", // Unused currently
-    handler: undefined
+    server: 'wss://puter.cafe/', // Unused currently
+    handler: undefined,
 };
 
 export class PSocket extends EventListener {
     _events = new Map();
     _streamID;
-    constructor(host, port) {
-        super(["data", "drain", "open", "error", "close", "tlsdata", "tlsopen", "tlsclose"]);
+    constructor (host, port) {
+        super(['data', 'drain', 'open', 'error', 'close', 'tlsdata', 'tlsopen', 'tlsclose']);
 
         (async () => {
-            if(!puter.authToken && puter.env === 'web' && requireAuth){
-                try{
+            if ( !puter.authToken && puter.env === 'web' && requireAuth ) {
+                try {
                     await puter.ui.authenticateWithPuter();
-                    
-                }catch(e){
+
+                } catch (e) {
                     // if authentication fails, throw an error
                     throw (e);
                 }
             }
-            if (!wispInfo.handler) {
+            if ( ! wispInfo.handler ) {
                 // first launch -- lets init the socket
-                const { token: wispToken, server: wispServer } = (await (await fetch(puter.APIOrigin + '/wisp/relay-token/create', {
+                const { token: wispToken, server: wispServer } = (await (await fetch(`${puter.APIOrigin }/wisp/relay-token/create`, {
                     method: 'POST',
                     headers: {
-                        Authorization: puter.authToken ? `Bearer ${puter.authToken}`:'',
+                        Authorization: puter.authToken ? `Bearer ${puter.authToken}` : '',
                         'Content-Type': 'application/json',
                     },
                     body: JSON.stringify({}),
                 })).json());
-    
+
                 wispInfo.handler = new PWispHandler(wispServer, wispToken);
                 // Wait for websocket to fully open
                 await new Promise((res, req) => {
@@ -43,45 +43,45 @@ export class PSocket extends EventListener {
                 });
             }
 
-
-
             const callbacks = {
                 dataCallBack: (data) => {
-                    this.emit("data", data);
+                    this.emit('data', data);
                 },
                 closeCallBack: (reason) => {
-                    if (reason !== 0x02) {
-                        this.emit("error", new Error(errors[reason]));
-                        this.emit("close", true);
-                        return;    
+                    if ( reason !== 0x02 ) {
+                        this.emit('error', new Error(errors[reason]));
+                        this.emit('close', true);
+                        return;
                     }
-                    this.emit("close", false);
-                }
-            }
-    
+                    this.emit('close', false);
+                },
+            };
+
             this._streamID = wispInfo.handler.register(host, port, callbacks);
-            setTimeout(() => {this.emit("open", undefined)}, 0);
+            setTimeout(() => {
+                this.emit('open', undefined);
+            }, 0);
 
         })();
     }
-    addListener(...args) {
+    addListener (...args) {
         this.on(...args);
     }
-    write(data, callback) {
-        if (data.buffer) { // TypedArray
+    write (data, callback) {
+        if ( data.buffer ) { // TypedArray
             wispInfo.handler.write(this._streamID, data);
-            if (callback) callback();
-        } else if (data.resize) { // ArrayBuffer
+            if ( callback ) callback();
+        } else if ( data.resize ) { // ArrayBuffer
             data.write(this._streamID, new Uint8Array(data));
-            if (callback) callback();
-        } else if (typeof(data) === "string") {
-            wispInfo.handler.write(this._streamID, texten.encode(data))
-            if (callback) callback();
+            if ( callback ) callback();
+        } else if ( typeof (data) === 'string' ) {
+            wispInfo.handler.write(this._streamID, texten.encode(data));
+            if ( callback ) callback();
         } else {
-            throw new Error("Invalid data type (not TypedArray, ArrayBuffer or String!!)");
+            throw new Error('Invalid data type (not TypedArray, ArrayBuffer or String!!)');
         }
     }
-    close() {
+    close () {
         wispInfo.handler.close(this._streamID);
     }
 }

package/src/modules/networking/PTLS.js

@@ -2,102 +2,109 @@
  * This file uses https://github.com/MercuryWorkshop/rustls-wasm authored by GitHub:@r58Playz under the MIT License
  */
 
-import { PSocket } from "./PSocket.js";
+import { PSocket } from './PSocket.js';
 
 let rustls = undefined;
 
 export class PTLSSocket extends PSocket {
-    constructor(...args) {
+    constructor (...args) {
         super(...args);
-        super.on("open", (async() => {
-            if (!rustls) {
+        super.on('open', (async () => {
+            if ( ! rustls ) {
                 // Safari exists unfortunately without good ReadableStream support. Until that is fixed we need this.
-                if (!globalThis.ReadableByteStreamController) {
-                    await import( /* webpackIgnore: true */ "https://unpkg.com/web-streams-polyfill@3.0.2/dist/polyfill.js");
+                if ( ! globalThis.ReadableByteStreamController ) {
+                    await import( /* webpackIgnore: true */ 'https://unpkg.com/web-streams-polyfill@3.0.2/dist/polyfill.js');
                 }
-                rustls = (await import( /* webpackIgnore: true */ "https://puter-net.b-cdn.net/rustls.js"))
-                await rustls.default("https://puter-net.b-cdn.net/rustls.wasm")
+                rustls = (await import( /* webpackIgnore: true */ 'https://puter-net.b-cdn.net/rustls.js'));
+                await rustls.default('https://puter-net.b-cdn.net/rustls.wasm');
             }
 
             let cancelled = false;
             const readable = new ReadableStream({
                 /**
-                 * 
-                 * @param {ReadableStreamDefaultController} controller 
+                 *
+                 * @param {ReadableStreamDefaultController} controller
                  */
                 start: (controller) => {
-                    super.on("data", (data) => {
-                        controller.enqueue(data.buffer)
-                    })
-                    super.on("close", () => {
-                        if (!cancelled)
-                            controller.close()
-                    })
-                    
+                    super.on('data', (data) => {
+                        controller.enqueue(data.buffer);
+                    });
+                    super.on('close', () => {
+                        if ( ! cancelled )
+                        {
+                            controller.close();
+                        }
+                    });
+
                 },
                 pull: (controller) => {
 
                 },
                 cancel: () => {
                     cancelled = true;
-                }
+                },
+
+            });
 
-            })
-    
             const writable = new WritableStream({
-                write: (chunk) => { super.write(chunk); },
-                abort: () => { super.close(); },
-                close: () => { super.close(); },
-            })
+                write: (chunk) => {
+                    super.write(chunk);
+                },
+                abort: () => {
+                    super.close();
+                },
+                close: () => {
+                    super.close();
+                },
+            });
 
             let read, write;
             try {
-                const TLSConnnection = await rustls.connect_tls(readable, writable, args[0])
+                const TLSConnnection = await rustls.connect_tls(readable, writable, args[0]);
                 read = TLSConnnection.read;
                 write = TLSConnnection.write;
             } catch (e) {
-                this.emit("error", new Error("TLS Handshake failed: " + e));
+                this.emit('error', new Error(`TLS Handshake failed: ${ e}`));
                 return;
             }
-            
-            
+
             this.writer = write.getWriter();
             // writer.write("GET / HTTP/1.1\r\nHost: google.com\r\n\r\n");
             let reader = read.getReader();
             let done = false;
-            this.emit("tlsopen", undefined);
-            try {   
-                while (!done) {    
-                    const {done: readerDone, value} = await reader.read();
+            this.emit('tlsopen', undefined);
+            try {
+                while ( !done ) {
+                    const { done: readerDone, value } = await reader.read();
                     done = readerDone;
-                    if (!done) {
-                        this.emit("tlsdata", value);
+                    if ( ! done ) {
+                        this.emit('tlsdata', value);
                     }
                 }
-                this.emit("tlsclose", false);
+                this.emit('tlsclose', false);
             } catch (e) {
-                this.emit("error", e)
-                this.emit("tlsclose", true);
+                this.emit('error', e);
+                this.emit('tlsclose', true);
             }
-            
+
         }));
     }
-    on(event, callback) {
-        if (event === "data" || event === "open" || event === "close") {
-            return super.on("tls" + event, callback)
+    on (event, callback) {
+        if ( event === 'data' || event === 'open' || event === 'close' ) {
+            return super.on(`tls${ event}`, callback);
         } else {
             return super.on(event, callback);
         }
     }
-    write(data, callback) {
-        if (data.buffer) { // TypedArray
+    write (data, callback) {
+        if ( data.buffer ) { // TypedArray
             this.writer.write(data.slice(0).buffer).then(callback);
-        } else if (data.resize) { // ArrayBuffer
+        } else if ( data.resize ) { // ArrayBuffer
             this.writer.write(data).then(callback);
-        } else if (typeof(data) === "string"){
+        } else if ( typeof (data) === 'string' ) {
             this.writer.write(data).then(callback);
         } else {
-            throw new Error("Invalid data type (not TypedArray, ArrayBuffer or String!!)");
+            throw new Error('Invalid data type (not TypedArray, ArrayBuffer or String!!)');
         }
     }
 

package/src/modules/networking/PWispHandler.js

@@ -1,4 +1,4 @@
-import {CLOSE, CONNECT, DATA, CONTINUE, INFO, TCP, UDP, createWispPacket, parseIncomingPacket, textde} from "./parsers.js"
+import { CLOSE, CONNECT, DATA, CONTINUE, INFO, TCP, UDP, createWispPacket, parseIncomingPacket, textde } from './parsers.js';
 
 export class PWispHandler {
     _ws;
@@ -6,84 +6,86 @@ export class PWispHandler {
     _bufferMax;
     onReady = undefined;
     streamMap = new Map();
-    constructor(wispURL, puterAuth) {
+    constructor (wispURL, puterAuth) {
         const setup = () => {
             this._ws = new WebSocket(wispURL);
-            this._ws.binaryType = "arraybuffer"
+            this._ws.binaryType = 'arraybuffer';
             this._ws.onmessage = (event) => {
                 const parsed = parseIncomingPacket(new Uint8Array(event.data));
-                switch (parsed.packetType) {
-                    case DATA:
-                        this.streamMap.get(parsed.streamID).dataCallBack(parsed.payload.slice(0)) // return a copy for the user to do as they please
-                        break;
-                    case CONTINUE:
-                        if (parsed.streamID === 0) {
-                            this._bufferMax = parsed.remainingBuffer;
-                            this._ws.onclose = () => {
-                                setTimeout(setup(), 1000);
-                            }
-                            if (this.onReady) {
-                                this.onReady();
-                            }
-                            return;
+                switch ( parsed.packetType ) {
+                case DATA:
+                    this.streamMap.get(parsed.streamID).dataCallBack(parsed.payload.slice(0)); // return a copy for the user to do as they please
+                    break;
+                case CONTINUE:
+                    if ( parsed.streamID === 0 ) {
+                        this._bufferMax = parsed.remainingBuffer;
+                        this._ws.onclose = () => {
+                            setTimeout(setup(), 1000);
+                        };
+                        if ( this.onReady ) {
+                            this.onReady();
                         }
-                        this.streamMap.get(parsed.streamID).buffer = parsed.remainingBuffer;
-                        this._continue()
-                        break;
-                    case CLOSE:
-                        if (parsed.streamID !== 0)
-                            this.streamMap.get(parsed.streamID).closeCallBack(parsed.reason);
-                        break;
-                    case INFO:
-                        puterAuth && this._ws.send(createWispPacket({
-                            packetType: INFO,
-                            streamID: 0,
-                            puterAuth
-                        }))
-                        break;
+                        return;
+                    }
+                    this.streamMap.get(parsed.streamID).buffer = parsed.remainingBuffer;
+                    this._continue();
+                    break;
+                case CLOSE:
+                    if ( parsed.streamID !== 0 )
+                    {
+                        this.streamMap.get(parsed.streamID).closeCallBack(parsed.reason);
+                    }
+                    break;
+                case INFO:
+                    puterAuth && this._ws.send(createWispPacket({
+                        packetType: INFO,
+                        streamID: 0,
+                        puterAuth,
+                    }));
+                    break;
                 }
-            }
-        }
+            };
+        };
         setup();
     }
-    _continue(streamID) {
+    _continue (streamID) {
         const queue = this.streamMap.get(streamID).queue;
-        for (let i = 0; i < queue.length; i++) {
+        for ( let i = 0; i < queue.length; i++ ) {
             this.write(streamID, queue.shift());
         }
     }
-    register(host, port, callbacks) {
+    register (host, port, callbacks) {
         const streamID = this._nextStreamID++;
-        this.streamMap.set(streamID, {queue: [], streamID, buffer: this._bufferMax, dataCallBack: callbacks.dataCallBack, closeCallBack: callbacks.closeCallBack});
+        this.streamMap.set(streamID, { queue: [], streamID, buffer: this._bufferMax, dataCallBack: callbacks.dataCallBack, closeCallBack: callbacks.closeCallBack });
         this._ws.send(createWispPacket({
             packetType: CONNECT,
             streamType: TCP,
             streamID: streamID,
             hostname: host,
-            port: port
-        }))
+            port: port,
+        }));
         return streamID;
     }
 
-    write(streamID, data) {
+    write (streamID, data) {
         const streamData = this.streamMap.get(streamID);
-        if (streamData.buffer > 0) {
+        if ( streamData.buffer > 0 ) {
             streamData.buffer--;
 
             this._ws.send(createWispPacket({
                 packetType: DATA,
                 streamID: streamID,
-                payload: data
-            }))
+                payload: data,
+            }));
         } else {
-            streamData.queue.push(data)
+            streamData.queue.push(data);
         }
     }
-    close(streamID) {
+    close (streamID) {
         this._ws.send(createWispPacket({
             packetType: CLOSE,
             streamID: streamID,
-            reason: 0x02
-        }))
+            reason: 0x02,
+        }));
     }
 }