@heyputer/puter.js 2.0.0 → 2.0.1

package/src/modules/Util.js

@@ -1,38 +0,0 @@
-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

@@ -1,120 +0,0 @@
-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

@@ -1,87 +0,0 @@
-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

@@ -1,100 +0,0 @@
-/**
- * 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

@@ -1,89 +0,0 @@
-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

@@ -1,157 +0,0 @@
-/* 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;
-}