@heyputer/puter.js 1.0.0

package/src/modules/Util.js

@@ -0,0 +1,38 @@
+import { $SCOPE, CallbackManager, Dehydrator, Hydrator } from "../lib/xdrpc.js";
+
+/**
+ * The Util module exposes utilities within puter.js itself.
+ * These utilities may be used internally by other modules.
+ */
+export default class Util {
+    constructor () {
+        // This is in `puter.util.rpc` instead of `puter.rpc` because
+        // `puter.rpc` is reserved for an app-to-app RPC interface.
+        // This is a lower-level RPC interface used to communicate
+        // with iframes.
+        this.rpc = new UtilRPC();
+    }
+}
+
+class UtilRPC {
+    constructor () {
+        this.callbackManager = new CallbackManager();
+        this.callbackManager.attach_to_source(globalThis);
+    }
+
+    getDehydrator () {
+        return new Dehydrator({ callbackManager: this.callbackManager });
+    }
+
+    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

@@ -0,0 +1,120 @@
+import getAbsolutePathForApp from "./FileSystem/utils/getAbsolutePathForApp.js";
+import * as utils from '../lib/utils.js';
+
+export class WorkersHandler {
+
+    constructor(authToken) {
+        this.authToken = authToken;
+    }
+
+    async create(workerName, filePath, appName) {
+        if (!puter.authToken && puter.env === 'web') {
+            try {
+                await puter.ui.authenticateWithPuter();
+            } catch (e) {
+                // if authentication fails, throw an error
+                throw 'Authentication failed.';
+            }
+        }
+
+        let appId;
+        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) {
+            currentWorkers = {};
+        }
+        filePath = getAbsolutePathForApp(filePath);
+
+        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?");
+        }
+        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') {
+            try {
+                await puter.ui.authenticateWithPuter();
+            } catch (e) {
+                // if authentication fails, throw an error
+                throw 'Authentication failed.';
+            }
+        }
+
+        const req = new Request(...args);
+        if (!req.headers.get("puter-auth")) {
+            req.headers.set("puter-auth", puter.authToken);
+        }
+        return fetch(req);
+    }
+
+    async list() {
+        if (!puter.authToken && puter.env === 'web') {
+            try {
+                await puter.ui.authenticateWithPuter();
+            } catch (e) {
+                // if authentication fails, throw an error
+                throw 'Authentication failed.';
+            }
+        }
+        const driverCall = await utils.make_driver_method([], 'workers', "worker-service", 'getFilePaths')();
+        return driverCall;
+    }
+
+    async get(workerName) {
+        if (!puter.authToken && puter.env === 'web') {
+            try {
+                await puter.ui.authenticateWithPuter();
+            } catch (e) {
+                // if authentication fails, throw an error
+                throw 'Authentication failed.';
+            }
+        }
+
+        workerName = workerName.toLocaleLowerCase(); // just incase
+        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') {
+            try {
+                await puter.ui.authenticateWithPuter();
+            } catch (e) {
+                // if authentication fails, throw an error
+                throw 'Authentication failed.';
+            }
+        }
+
+        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);;
+
+        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?");
+        } else {
+            let currentWorkers = await puter.kv.get("user-workers");
+
+            if (!currentWorkers) {
+                currentWorkers = {};
+            }
+            delete currentWorkers[workerName];
+
+            await puter.kv.set("user-workers", currentWorkers);
+            return true;
+        }
+    }
+
+}

package/src/modules/networking/PSocket.js

@@ -0,0 +1,87 @@
+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
+};
+
+export class PSocket extends EventListener {
+    _events = new Map();
+    _streamID;
+    constructor(host, port) {
+        super(["data", "drain", "open", "error", "close", "tlsdata", "tlsopen", "tlsclose"]);
+
+        (async () => {
+            if(!puter.authToken && puter.env === 'web' && requireAuth){
+                try{
+                    await puter.ui.authenticateWithPuter();
+                    
+                }catch(e){
+                    // if authentication fails, throw an error
+                    throw (e);
+                }
+            }
+            if (!wispInfo.handler) {
+                // first launch -- lets init the socket
+                const { token: wispToken, server: wispServer } = (await (await fetch(puter.APIOrigin + '/wisp/relay-token/create', {
+                    method: 'POST',
+                    headers: {
+                        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) => {
+                    wispInfo.handler.onReady = res;
+                });
+            }
+
+
+
+            const callbacks = {
+                dataCallBack: (data) => {
+                    this.emit("data", data);
+                },
+                closeCallBack: (reason) => {
+                    if (reason !== 0x02) {
+                        this.emit("error", new Error(errors[reason]));
+                        this.emit("close", true);
+                        return;    
+                    }
+                    this.emit("close", false);
+                }
+            }
+    
+            this._streamID = wispInfo.handler.register(host, port, callbacks);
+            setTimeout(() => {this.emit("open", undefined)}, 0);
+
+        })();
+    }
+    addListener(...args) {
+        this.on(...args);
+    }
+    write(data, callback) {
+        if (data.buffer) { // TypedArray
+            wispInfo.handler.write(this._streamID, data);
+            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();
+        } else {
+            throw new Error("Invalid data type (not TypedArray, ArrayBuffer or String!!)");
+        }
+    }
+    close() {
+        wispInfo.handler.close(this._streamID);
+    }
+}

package/src/modules/networking/PTLS.js

@@ -0,0 +1,100 @@
+/**
+ * This file uses https://github.com/MercuryWorkshop/rustls-wasm authored by GitHub:@r58Playz under the MIT License
+ */
+
+import { PSocket } from "./PSocket.js";
+
+let rustls = undefined;
+
+export class PTLSSocket extends PSocket {
+    constructor(...args) {
+        super(...args);
+        super.on("open", (async() => {
+            if (!rustls) {
+                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 
+                 */
+                start: (controller) => {
+                    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(); },
+            })
+
+            let read, write;
+            try {
+                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));
+                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();
+                    done = readerDone;
+                    if (!done) {
+                        this.emit("tlsdata", value);
+                    }
+                }
+                this.emit("tlsclose", false);
+            } catch (e) {
+                this.emit("error", e)
+                this.emit("tlsclose", true);
+            }
+            
+        }));
+    }
+    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
+            this.writer.write(data.slice(0).buffer).then(callback);
+        } else if (data.resize) { // ArrayBuffer
+            this.writer.write(data).then(callback);
+        } else if (typeof(data) === "string"){
+            this.writer.write(data).then(callback);
+        } else {
+            throw new Error("Invalid data type (not TypedArray, ArrayBuffer or String!!)");
+        }
+    }
+
+}

package/src/modules/networking/PWispHandler.js

@@ -0,0 +1,89 @@
+import {CLOSE, CONNECT, DATA, CONTINUE, INFO, TCP, UDP, createWispPacket, parseIncomingPacket, textde} from "./parsers.js"
+
+export class PWispHandler {
+    _ws;
+    _nextStreamID = 1;
+    _bufferMax;
+    onReady = undefined;
+    streamMap = new Map();
+    constructor(wispURL, puterAuth) {
+        const setup = () => {
+            this._ws = new WebSocket(wispURL);
+            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;
+                        }
+                        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) {
+        const queue = this.streamMap.get(streamID).queue;
+        for (let i = 0; i < queue.length; i++) {
+            this.write(streamID, queue.shift());
+        }
+    }
+    register(host, port, callbacks) {
+        const streamID = this._nextStreamID++;
+        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
+        }))
+        return streamID;
+    }
+
+    write(streamID, data) {
+        const streamData = this.streamMap.get(streamID);
+        if (streamData.buffer > 0) {
+            streamData.buffer--;
+
+            this._ws.send(createWispPacket({
+                packetType: DATA,
+                streamID: streamID,
+                payload: data
+            }))
+        } else {
+            streamData.queue.push(data)
+        }
+    }
+    close(streamID) {
+        this._ws.send(createWispPacket({
+            packetType: CLOSE,
+            streamID: streamID,
+            reason: 0x02
+        }))
+    }
+}

package/src/modules/networking/parsers.js

@@ -0,0 +1,157 @@
+/* eslint-disable no-unreachable */
+/* eslint-disable no-case-declarations */
+// PACKET TYPES
+export const CONNECT  = 0x01;
+export const DATA     = 0x02;
+export const CONTINUE = 0x03;
+export const CLOSE    = 0x04;
+export const INFO     = 0x05;
+
+// STREAM TYPES
+export const TCP = 0x01;
+export const UDP = 0x02;
+
+// Frequently used objects
+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."
+}
+
+/**
+ * @typedef {{packetType: number, streamID: number, streamType?: number, port?: number, hostname?: string, payload?: Uint8Array, reason?: number, remainingBuffer?: number}} ParsedWispPacket
+ */
+
+/**
+ * Parses a wisp packet fully
+ * 
+ * @param {Uint8Array} data 
+ * @returns {ParsedWispPacket} Packet Info
+ */
+
+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);
+
+            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 
+ * @returns {Uint8Array} Constructed Packet
+ */
+
+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")
+    }
+
+    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
+            }
+
+            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;
+}