@heyputer/puter.js 2.1.6 → 2.1.8

package/src/modules/networking/parsers.js

@@ -15,16 +15,16 @@ export const UDP = 0x02;
 export const textde = new TextDecoder();
 const texten = new TextEncoder();
 export const errors = {
-     0x01: "Reason unspecified or unknown. Returning a more specific reason should be preferred."
-    ,0x03: "Unexpected stream closure due to a network error."
-    ,0x41: "Stream creation failed due to invalid information. This could be sent if the destination was a reserved address or the port is invalid."
-    ,0x42: "Stream creation failed due to an unreachable destination host. This could be sent if the destination is an domain which does not resolve to anything."
-    ,0x43: "Stream creation timed out due to the destination server not responding."
-    ,0x44: "Stream creation failed due to the destination server refusing the connection."
-    ,0x47: "TCP data transfer timed out."
-    ,0x48: "Stream destination address/domain is intentionally blocked by the proxy server."
-    ,0x49: "Connection throttled by the server."
-}
+    0x01: 'Reason unspecified or unknown. Returning a more specific reason should be preferred.'
+    , 0x03: 'Unexpected stream closure due to a network error.'
+    , 0x41: 'Stream creation failed due to invalid information. This could be sent if the destination was a reserved address or the port is invalid.'
+    , 0x42: 'Stream creation failed due to an unreachable destination host. This could be sent if the destination is an domain which does not resolve to anything.'
+    , 0x43: 'Stream creation timed out due to the destination server not responding.'
+    , 0x44: 'Stream creation failed due to the destination server refusing the connection.'
+    , 0x47: 'TCP data transfer timed out.'
+    , 0x48: 'Stream destination address/domain is intentionally blocked by the proxy server.'
+    , 0x49: 'Connection throttled by the server.',
+};
 
 /**
  * @typedef {{packetType: number, streamID: number, streamType?: number, port?: number, hostname?: string, payload?: Uint8Array, reason?: number, remainingBuffer?: number}} ParsedWispPacket
@@ -32,126 +32,128 @@ export const errors = {
 
 /**
  * Parses a wisp packet fully
- * 
- * @param {Uint8Array} data 
+ *
+ * @param {Uint8Array} data
  * @returns {ParsedWispPacket} Packet Info
  */
 
-export function parseIncomingPacket(data) {
+export function parseIncomingPacket (data) {
     const view = new DataView(data.buffer, data.byteOffset);
     const packetType = view.getUint8(0);
     const streamID = view.getUint32(1, true);
-    switch (packetType) { // Packet payload starts at Offset 5
-        case CONNECT:
-            const streamType = view.getUint8(5);
-            const port = view.getUint16(6, true);
-            const hostname = textde.decode(data.subarray(8, data.length));
-            return {packetType, streamID, streamType, port, hostname}
-            break;
-        case DATA:
-            const payload = data.subarray(5, data.length);
-            return {packetType, streamID, payload}
-            break;
-        case CONTINUE:
-            const remainingBuffer = view.getUint32(5, true);
-            return {packetType, streamID, remainingBuffer}
-            break;
-        case CLOSE:
-            const reason = view.getUint8(5)
-            return {packetType, streamID, reason}
-            break;
-        case INFO:
-            const infoObj = {};
-            infoObj["version_major"] = view.getUint8(5);
-            infoObj["version_minor"] = view.getUint8(6);
+    switch ( packetType ) { // Packet payload starts at Offset 5
+    case CONNECT:
+        const streamType = view.getUint8(5);
+        const port = view.getUint16(6, true);
+        const hostname = textde.decode(data.subarray(8, data.length));
+        return { packetType, streamID, streamType, port, hostname };
+        break;
+    case DATA:
+        const payload = data.subarray(5, data.length);
+        return { packetType, streamID, payload };
+        break;
+    case CONTINUE:
+        const remainingBuffer = view.getUint32(5, true);
+        return { packetType, streamID, remainingBuffer };
+        break;
+    case CLOSE:
+        const reason = view.getUint8(5);
+        return { packetType, streamID, reason };
+        break;
+    case INFO:
+        const infoObj = {};
+        infoObj['version_major'] = view.getUint8(5);
+        infoObj['version_minor'] = view.getUint8(6);
 
-            let ptr = 7;
-            while (ptr < data.length) {
-                const extType = view.getUint8(ptr);
-                const extLength = view.getUint32(ptr + 1, true);
-                const payload = data.subarray(ptr + 5, ptr + 5 + extLength);
-                infoObj[extType] = payload;
-                ptr += 5 + extLength;
-            }
-            return {packetType, streamID, infoObj}
-            break;
+        let ptr = 7;
+        while ( ptr < data.length ) {
+            const extType = view.getUint8(ptr);
+            const extLength = view.getUint32(ptr + 1, true);
+            const payload = data.subarray(ptr + 5, ptr + 5 + extLength);
+            infoObj[extType] = payload;
+            ptr += 5 + extLength;
+        }
+        return { packetType, streamID, infoObj };
+        break;
     }
 }
 /**
  * creates a wisp packet fully
- * 
- * @param {ParsedWispPacket} instructions 
+ *
+ * @param {ParsedWispPacket} instructions
  * @returns {Uint8Array} Constructed Packet
  */
 
-export function createWispPacket(instructions) {
+export function createWispPacket (instructions) {
     let size = 5;
-    switch (instructions.packetType) { // Pass 1: determine size of packet
-        case CONNECT:
-            instructions.hostEncoded = texten.encode(instructions.hostname)
-            size += 3 + instructions.hostEncoded.length;            
-            break;
-        case DATA:
-            size += instructions.payload.byteLength;
-            break;
-        case CONTINUE:
-            size += 4;
-            break;
-        case CLOSE:
-            size += 1;
-            break;
-        case INFO:
-            size += 2;
-            if (instructions.password) 
-                size += 6;
-            if (instructions.puterAuth) {
-                instructions.passwordEncoded = texten.encode(instructions.puterAuth);
-                size += 8 + instructions.passwordEncoded.length;
-            }
-            break;
-        default:
-            throw new Error("Not supported")
+    switch ( instructions.packetType ) { // Pass 1: determine size of packet
+    case CONNECT:
+        instructions.hostEncoded = texten.encode(instructions.hostname);
+        size += 3 + instructions.hostEncoded.length;
+        break;
+    case DATA:
+        size += instructions.payload.byteLength;
+        break;
+    case CONTINUE:
+        size += 4;
+        break;
+    case CLOSE:
+        size += 1;
+        break;
+    case INFO:
+        size += 2;
+        if ( instructions.password )
+        {
+            size += 6;
+        }
+        if ( instructions.puterAuth ) {
+            instructions.passwordEncoded = texten.encode(instructions.puterAuth);
+            size += 8 + instructions.passwordEncoded.length;
+        }
+        break;
+    default:
+        throw new Error('Not supported');
     }
 
     let data = new Uint8Array(size);
     const view = new DataView(data.buffer);
     view.setUint8(0, instructions.packetType);
     view.setUint32(1, instructions.streamID, true);
-    switch (instructions.packetType) { // Pass 2: fill out packet
-        case CONNECT:
-            view.setUint8(5, instructions.streamType);
-            view.setUint16(6, instructions.port, true);
-            data.set(instructions.hostEncoded, 8);
-            break;
-        case DATA:
-            data.set(instructions.payload, 5);
-            break;
-        case CONTINUE:
-            view.setUint32(5, instructions.remainingBuffer, true)
-            break;
-        case CLOSE:
-            view.setUint8(5, instructions.reason)
-            break;
-        case INFO:
-            // WISP 2.0
-            view.setUint8(5, 2);
-            view.setUint8(6, 0);
-            
-            if (instructions.password) {
-                // PASSWORD AUTH REQUIRED
-                view.setUint8(7, 0x02); // Protocol ID (Password)
-                view.setUint32(8, 1, true);
-                view.setUint8(12, 0); // Password required? true
-            }
+    switch ( instructions.packetType ) { // Pass 2: fill out packet
+    case CONNECT:
+        view.setUint8(5, instructions.streamType);
+        view.setUint16(6, instructions.port, true);
+        data.set(instructions.hostEncoded, 8);
+        break;
+    case DATA:
+        data.set(instructions.payload, 5);
+        break;
+    case CONTINUE:
+        view.setUint32(5, instructions.remainingBuffer, true);
+        break;
+    case CLOSE:
+        view.setUint8(5, instructions.reason);
+        break;
+    case INFO:
+        // WISP 2.0
+        view.setUint8(5, 2);
+        view.setUint8(6, 0);
+
+        if ( instructions.password ) {
+            // PASSWORD AUTH REQUIRED
+            view.setUint8(7, 0x02); // Protocol ID (Password)
+            view.setUint32(8, 1, true);
+            view.setUint8(12, 0); // Password required? true
+        }
 
-            if (instructions.puterAuth) {
-                // PASSWORD AUTH REQUIRED
-                view.setUint8(7, 0x02); // Protocol ID (Password)
-                view.setUint32(8, 5 + instructions.passwordEncoded.length, true);
-                view.setUint8(12, 0);
-                view.setUint16(13, instructions.passwordEncoded.length, true);
-                data.set(instructions.passwordEncoded, 15);
-            }
+        if ( instructions.puterAuth ) {
+            // PASSWORD AUTH REQUIRED
+            view.setUint8(7, 0x02); // Protocol ID (Password)
+            view.setUint32(8, 5 + instructions.passwordEncoded.length, true);
+            view.setUint8(12, 0);
+            view.setUint16(13, instructions.passwordEncoded.length, true);
+            data.set(instructions.passwordEncoded, 15);
+        }
     }
     return data;
 }

package/src/modules/networking/requests.js

@@ -1,5 +1,5 @@
 // SO: https://stackoverflow.com/a/76332760/ under CC BY-SA 4.0
-function mergeUint8Arrays(...arrays) {
+function mergeUint8Arrays (...arrays) {
     const totalSize = arrays.reduce((acc, e) => acc + e.length, 0);
     const merged = new Uint8Array(totalSize);
 
@@ -11,18 +11,18 @@ function mergeUint8Arrays(...arrays) {
     return merged;
 }
 
-function parseHTTPHead(head) {
-    const lines = head.split("\r\n");
+function parseHTTPHead (head) {
+    const lines = head.split('\r\n');
 
-    const firstLine = lines.shift().split(" ");
+    const firstLine = lines.shift().split(' ');
     const status = Number(firstLine[1]);
-    const statusText = firstLine.slice(2).join(" ") || "";
+    const statusText = firstLine.slice(2).join(' ') || '';
 
     const headersArray = [];
-    for (const header of lines) {
-        const splitHeaders = header.split(": ");
+    for ( const header of lines ) {
+        const splitHeaders = header.split(': ');
         const key = splitHeaders[0];
-        const value = splitHeaders.slice(1).join(": ");
+        const value = splitHeaders.slice(1).join(': ');
         headersArray.push([key, value]);
     }
     new Headers(headersArray);
@@ -32,7 +32,7 @@ function parseHTTPHead(head) {
 // Trivial stream based HTTP 1.1 client
 // TODO optional redirect handling
 
-export function pFetch(...args) {
+export function pFetch (...args) {
     return new Promise(async (res, rej) => {
         try {
             const reqObj = new Request(...args);
@@ -41,68 +41,62 @@ export function pFetch(...args) {
 
             // Socket creation: regular for HTTP, TLS for https
             let socket;
-            if (parsedURL.protocol === "http:") {
-                socket = new puter.net.Socket(
-                    parsedURL.hostname,
-                    parsedURL.port || 80,
-                );
-            } else if (parsedURL.protocol === "https:") {
-                socket = new puter.net.tls.TLSSocket(
-                    parsedURL.hostname,
-                    parsedURL.port || 443,
-                );
+            if ( parsedURL.protocol === 'http:' ) {
+                socket = new puter.net.Socket(parsedURL.hostname,
+                                parsedURL.port || 80);
+            } else if ( parsedURL.protocol === 'https:' ) {
+                socket = new puter.net.tls.TLSSocket(parsedURL.hostname,
+                                parsedURL.port || 443);
             } else {
                 const errorMsg = `Failed to fetch. URL scheme "${parsedURL.protocol}" is not supported.`;
-                
+
                 // Log the error
-                if (globalThis.puter?.apiCallLogger?.isEnabled()) {
+                if ( globalThis.puter?.apiCallLogger?.isEnabled() ) {
                     globalThis.puter.apiCallLogger.logRequest({
                         service: 'network',
                         operation: 'pFetch',
                         params: { url: reqObj.url, method: reqObj.method },
-                        error: { message: errorMsg }
+                        error: { message: errorMsg },
                     });
                 }
-                
+
                 rej(errorMsg);
                 return;
             }
 
             // Sending default UA
-            if (!headers.get("user-agent")) {
-                headers.set("user-agent", navigator.userAgent);
+            if ( ! headers.get('user-agent') ) {
+                headers.set('user-agent', navigator.userAgent);
             }
 
             let reqHead = `${reqObj.method} ${parsedURL.pathname}${parsedURL.search} HTTP/1.1\r\nHost: ${parsedURL.host}\r\nConnection: close\r\n`;
-            for (const [key, value] of headers) {
+            for ( const [key, value] of headers ) {
                 reqHead += `${key}: ${value}\r\n`;
             }
             let requestBody;
-            if (reqObj.body) {
+            if ( reqObj.body ) {
                 requestBody = new Uint8Array(await reqObj.arrayBuffer());
                 // If we have a body, we need to set the content length
-                if (!headers.has("content-length")) {
-                    headers.set("content-length", requestBody.length);
+                if ( ! headers.has('content-length') ) {
+                    headers.set('content-length', requestBody.length);
                 } else if (
-                    headers.get("content-length") !== String(requestBody.length)
+                    headers.get('content-length') !== String(requestBody.length)
                 ) {
-                    return rej(
-                        "Content-Length header does not match the body length. Please check your request.",
-                    );
+                    return rej('Content-Length header does not match the body length. Please check your request.');
                 }
                 reqHead += `Content-Length: ${requestBody.length}\r\n`;
             }
 
-            reqHead += "\r\n";
+            reqHead += '\r\n';
 
-            socket.on("open", async () => {
+            socket.on('open', async () => {
                 socket.write(reqHead); // Send headers
-                if (requestBody) {
+                if ( requestBody ) {
                     socket.write(requestBody); // Send body if present
                 }
             });
             const decoder = new TextDecoder();
-            let responseHead = "";
+            let responseHead = '';
             let dataOffset = -1;
             const fullDataParts = [];
             let responseReturned = false;
@@ -113,9 +107,9 @@ export function pFetch(...args) {
             let buffer = new Uint8Array(0);
 
             const outStream = new ReadableStream({
-                start(controller) {
+                start (controller) {
                     // This is annoyingly long
-                    function parseIncomingChunk(data) {
+                    function parseIncomingChunk (data) {
                         // append new data to our rolling buffer
                         const tmp = new Uint8Array(buffer.length + data.length);
                         tmp.set(buffer, 0);
@@ -123,11 +117,11 @@ export function pFetch(...args) {
                         buffer = tmp;
 
                         // pull out as many complete chunks (or headers) as we can
-                        while (true) {
-                            if (currentChunkLeft > 0) {
+                        while ( true ) {
+                            if ( currentChunkLeft > 0 ) {
                                 // we’re in the middle of reading a chunk body
                                 // need size + 2 bytes (for trailing \r\n)
-                                if (buffer.length >= currentChunkLeft + 2) {
+                                if ( buffer.length >= currentChunkLeft + 2 ) {
                                     // full body + CRLF available
                                     const chunk = buffer.slice(0, currentChunkLeft);
                                     controller.enqueue(chunk);
@@ -146,7 +140,7 @@ export function pFetch(...args) {
                                 // we need to parse the next size line
                                 // find the first "\r\n"
                                 let idx = -1;
-                                for (let i = 0; i + 1 < buffer.length; i++) {
+                                for ( let i = 0; i + 1 < buffer.length; i++ ) {
                                     if (
                                         buffer[i] === 0x0d &&
                                         buffer[i + 1] === 0x0a
@@ -155,7 +149,7 @@ export function pFetch(...args) {
                                         break;
                                     }
                                 }
-                                if (idx < 0) {
+                                if ( idx < 0 ) {
                                     // we don’t yet have a full size line
                                     break;
                                 }
@@ -165,16 +159,14 @@ export function pFetch(...args) {
                                     .decode(buffer.slice(0, idx))
                                     .trim();
                                 currentChunkLeft = parseInt(sizeText, 16);
-                                if (isNaN(currentChunkLeft)) {
-                                    controller.error(
-                                        "Invalid chunk length from server",
-                                    );
+                                if ( isNaN(currentChunkLeft) ) {
+                                    controller.error('Invalid chunk length from server');
                                 }
                                 // strip off the size line + CRLF
                                 buffer = buffer.slice(idx + 2);
 
                                 // zero-length => end of stream
-                                if (currentChunkLeft === 0) {
+                                if ( currentChunkLeft === 0 ) {
                                     responseReturned = true;
                                     controller.close();
                                     return;
@@ -182,51 +174,47 @@ export function pFetch(...args) {
                             }
                         }
                     }
-                    socket.on("data", (data) => {
+                    socket.on('data', (data) => {
                         // Dataoffset is set to another value once head is returned, its safe to assume all remaining data is body
-                        if (dataOffset !== -1 && !chunkedTransfer) {
+                        if ( dataOffset !== -1 && !chunkedTransfer ) {
                             controller.enqueue(data);
                             ingestedContent += data.length;
                         }
 
                         // We dont have the full responseHead yet
-                        if (dataOffset === -1) {
+                        if ( dataOffset === -1 ) {
                             fullDataParts.push(data);
                             responseHead += decoder.decode(data, { stream: true });
                         }
-                        if (chunkedTransfer) {
+                        if ( chunkedTransfer ) {
                             parseIncomingChunk(data);
                         }
 
                         // See if we have the HEAD of an HTTP/1.1 yet
-                        if (responseHead.indexOf("\r\n\r\n") !== -1) {
-                            dataOffset = responseHead.indexOf("\r\n\r\n");
+                        if ( responseHead.indexOf('\r\n\r\n') !== -1 ) {
+                            dataOffset = responseHead.indexOf('\r\n\r\n');
                             responseHead = responseHead.slice(0, dataOffset);
                             const parsedHead = parseHTTPHead(responseHead);
-                            contentLength = Number(
-                                parsedHead.headers.get("content-length"),
-                            );
+                            contentLength = Number(parsedHead.headers.get('content-length'));
                             chunkedTransfer =
-                                parsedHead.headers.get("transfer-encoding") ===
-                                "chunked";
-                            
+                                parsedHead.headers.get('transfer-encoding') ===
+                                'chunked';
+
                             // Log the response
-                            if (globalThis.puter?.apiCallLogger?.isEnabled()) {
+                            if ( globalThis.puter?.apiCallLogger?.isEnabled() ) {
                                 globalThis.puter.apiCallLogger.logRequest({
                                     service: 'network',
                                     operation: 'pFetch',
                                     params: { url: reqObj.url, method: reqObj.method },
-                                    result: { status: parsedHead.status, statusText: parsedHead.statusText }
+                                    result: { status: parsedHead.status, statusText: parsedHead.statusText },
                                 });
                             }
-                            
+
                             // Return initial response object
                             res(new Response(outStream, parsedHead));
 
-                            const residualBody = mergeUint8Arrays(
-                                ...fullDataParts,
-                            ).slice(dataOffset + 4);
-                            if (!chunkedTransfer) {
+                            const residualBody = mergeUint8Arrays(...fullDataParts).slice(dataOffset + 4);
+                            if ( ! chunkedTransfer ) {
                                 // Add any content we have but isn't part of the head into the body stream
                                 ingestedContent += residualBody.length;
                                 controller.enqueue(residualBody);
@@ -241,42 +229,43 @@ export function pFetch(...args) {
                             !chunkedTransfer
                         ) {
                             // Work around for the close bug for compliant HTTP/1.1 servers
-                            if (!responseReturned) {
+                            if ( ! responseReturned ) {
                                 responseReturned = true;
                                 controller.close();
                             }
                         }
                     });
-                    socket.on("close", () => {
-                        if (!responseReturned) {
+                    socket.on('close', () => {
+                        if ( ! responseReturned ) {
                             responseReturned = true;
                             controller.close();
                         }
                     });
-                    socket.on("error", (reason) => {
+                    socket.on('error', (reason) => {
                         // Log the error
-                        if (globalThis.puter?.apiCallLogger?.isEnabled()) {
+                        if ( globalThis.puter?.apiCallLogger?.isEnabled() ) {
                             globalThis.puter.apiCallLogger.logRequest({
                                 service: 'network',
                                 operation: 'pFetch',
                                 params: { url: reqObj.url, method: reqObj.method },
-                                error: { message: "Socket errored with the following reason: " + reason }
+                                error: { message: `Socket errored with the following reason: ${ reason}` },
                             });
                         }
-                        rej("Socket errored with the following reason: " + reason);
+                        rej(`Socket errored with the following reason: ${ reason}`);
                     });
                 },
             });
         } catch (e) {
             // Log unexpected errors
-            if (globalThis.puter?.apiCallLogger?.isEnabled()) {
+            if ( globalThis.puter?.apiCallLogger?.isEnabled() ) {
                 globalThis.puter.apiCallLogger.logRequest({
                     service: 'network',
                     operation: 'pFetch',
                     params: { url: reqObj.url, method: reqObj.method },
-                    error: { message: e.message || e.toString(), stack: e.stack }
+                    error: { message: e.message || e.toString(), stack: e.stack },
                 });
             }
             rej(e);
-        }});
+        }
+    });
 }

package/src/services/APIAccess.js

@@ -1,4 +1,4 @@
-import putility from "@heyputer/putility";
+import putility from '@heyputer/putility';
 
 const { TTopics } = putility.traits;
 
@@ -13,12 +13,12 @@ export class APIAccessService extends putility.concepts.Service {
         auth_token: {
             post_set (v) {
                 this.as(TTopics).pub('update');
-            }
+            },
         },
         api_origin: {
             post_set () {
                 this.as(TTopics).pub('update');
-            }
+            },
         },
     };
 
@@ -27,18 +27,18 @@ export class APIAccessService extends putility.concepts.Service {
         const self = this;
         const o = {};
         [
-            ['auth_token','auth_token'],
-            ['authToken','auth_token'],
-            ['APIOrigin','api_origin'],
-            ['api_origin','api_origin'],
-        ].forEach(([k1,k2]) => {
+            ['auth_token', 'auth_token'],
+            ['authToken', 'auth_token'],
+            ['APIOrigin', 'api_origin'],
+            ['api_origin', 'api_origin'],
+        ].forEach(([k1, k2]) => {
             Object.defineProperty(o, k1, {
                 get () {
                     return self[k2];
                 },
                 set (v) {
                     return self;
-                }
+                },
             });
         });
         return o;

package/src/services/FSRelay.js

@@ -1,12 +1,12 @@
 import putility from '@heyputer/putility';
 
 const example =     {
-        "id": "f485f1ba-de07-422c-8c4b-c2da057d4a44",
-        "uid": "f485f1ba-de07-422c-8c4b-c2da057d4a44",
-        "is_dir": true,
-        "immutable": true,
-        "name": "FromParentWindow",
-    };
+    'id': 'f485f1ba-de07-422c-8c4b-c2da057d4a44',
+    'uid': 'f485f1ba-de07-422c-8c4b-c2da057d4a44',
+    'is_dir': true,
+    'immutable': true,
+    'name': 'FromParentWindow',
+};
 
 export class FSRelayService extends putility.concepts.Service {
     async _init () {