@heyputer/puter.js 2.0.15 → 2.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@heyputer/puter.js",
-    "version": "2.0.15",
+    "version": "2.1.1",
     "description": "Puter.js - A JavaScript library for interacting with Puter services.",
     "main": "src/index.js",
     "types": "index.d.ts",
@@ -40,6 +40,6 @@
     },
     "dependencies": {
         "@heyputer/kv.js": "^0.2.1",
-        "@heyputer/putility": "^1.0.3"
+        "@heyputer/putility": "^1.1.1"
     }
 }

package/src/index.js

@@ -506,7 +506,7 @@ const puterInit = (function() {
             this.request_rao_();
 
             // perform whoami and cache results
-            puter.getUser().then((user) => {
+            this.getUser().then((user) => {
                 this.whoami = user;
             });
         };
@@ -722,25 +722,50 @@ const puterInit = (function() {
             let documents_path = `/${username}/Documents`;
             let public_path = `/${username}/Public`;
 
-            // Home
+            // item:Home
+            if(!puter._cache.get('item:' + home_path)){
+                console.log(`/${username} item is not cached, refetching cache`);
+                // fetch home
+                puter.fs.stat(home_path);
+            }
+            // item:Desktop
+            if(!puter._cache.get('item:' + desktop_path)){
+                console.log(`/${username}/Desktop item is not cached, refetching cache`);
+                // fetch desktop
+                puter.fs.stat(desktop_path);
+            }
+            // item:Documents
+            if(!puter._cache.get('item:' + documents_path)){
+                console.log(`/${username}/Documents item is not cached, refetching cache`);
+                // fetch documents
+                puter.fs.stat(documents_path);
+            }
+            // item:Public
+            if(!puter._cache.get('item:' + public_path)){
+                console.log(`/${username}/Public item is not cached, refetching cache`);
+                // fetch public
+                puter.fs.stat(public_path);
+            }
+
+            // readdir:Home
             if(!puter._cache.get('readdir:' + home_path)){
                 console.log(`/${username} is not cached, refetching cache`);
                 // fetch home
                 puter.fs.readdir(home_path);
             }
-            // Desktop
+            // readdir:Desktop
             if(!puter._cache.get('readdir:' + desktop_path)){
                 console.log(`/${username}/Desktop is not cached, refetching cache`);
                 // fetch desktop
                 puter.fs.readdir(desktop_path);
             }
-            // Documents
+            // readdir:Documents
             if(!puter._cache.get('readdir:' + documents_path)){
                 console.log(`/${username}/Documents is not cached, refetching cache`);
                 // fetch documents
                 puter.fs.readdir(documents_path);
             }
-            // Public
+            // readdir:Public
             if(!puter._cache.get('readdir:' + public_path)){
                 console.log(`/${username}/Public is not cached, refetching cache`);
                 // fetch public

package/src/modules/Auth.js

@@ -1,11 +1,10 @@
-import * as utils from '../lib/utils.js'
+import * as utils from '../lib/utils.js';
 
 class Auth{
     // Used to generate a unique message id for each message sent to the host environment
     // we start from 1 because 0 is falsy and we want to avoid that for the message id
     #messageID = 1;
 
-
     /**
      * Creates a new instance with the given authentication token, API origin, and app ID,
      *
@@ -14,7 +13,7 @@ class Auth{
      * @param {string} APIOrigin - Origin of the API server. Used to build the API endpoint URLs.
      * @param {string} appID - ID of the app to use.
      */
-    constructor (context) {
+    constructor(context) {
         this.authToken = context.authToken;
         this.APIOrigin = context.APIOrigin;
         this.appID = context.appID;
@@ -27,22 +26,22 @@ class Auth{
      * @memberof [Auth]
      * @returns {void}
      */
-    setAuthToken (authToken) {
+    setAuthToken(authToken) {
         this.authToken = authToken;
     }
 
     /**
      * Sets the API origin.
-     * 
+     *
      * @param {string} APIOrigin - The new API origin.
      * @memberof [Auth]
      * @returns {void}
      */
-    setAPIOrigin (APIOrigin) {
+    setAPIOrigin(APIOrigin) {
         this.APIOrigin = APIOrigin;
     }
-    
-    signIn = (options) =>{
+
+    signIn = (options) => {
         options = options || {};
 
         return new Promise((resolve, reject) => {
@@ -50,17 +49,17 @@ class Auth{
             let w = 600;
             let h = 600;
             let title = 'Puter';
-            var left = (screen.width/2)-(w/2);
-            var top = (screen.height/2)-(h/2);
-            
+            var left = (screen.width / 2) - (w / 2);
+            var top = (screen.height / 2) - (h / 2);
+
             // Store reference to the popup window
-            const popup = window.open(puter.defaultGUIOrigin + '/action/sign-in?embedded_in_popup=true&msg_id=' + msg_id + (window.crossOriginIsolated ? '&cross_origin_isolated=true' : '') +(options.attempt_temp_user_creation ? '&attempt_temp_user_creation=true' : ''), 
-            title, 
-            'toolbar=no, location=no, directories=no, status=no, menubar=no, scrollbars=no, resizable=no, copyhistory=no, width='+w+', height='+h+', top='+top+', left='+left);
+            const popup = window.open(`${puter.defaultGUIOrigin}/action/sign-in?embedded_in_popup=true&msg_id=${msg_id}${window.crossOriginIsolated ? '&cross_origin_isolated=true' : ''}${options.attempt_temp_user_creation ? '&attempt_temp_user_creation=true' : ''}`,
+                            title,
+                            `toolbar=no, location=no, directories=no, status=no, menubar=no, scrollbars=no, resizable=no, copyhistory=no, width=${w}, height=${h}, top=${top}, left=${left}`);
 
             // Set up interval to check if popup was closed
             const checkClosed = setInterval(() => {
-                if (popup.closed) {
+                if ( popup.closed ) {
                     clearInterval(checkClosed);
                     // Remove the message listener
                     window.removeEventListener('message', messageHandler);
@@ -69,21 +68,23 @@ class Auth{
             }, 100);
 
             function messageHandler(e) {
-                if(e.data.msg_id == msg_id){
+                if ( e.data.msg_id == msg_id ){
                     // Clear the interval since we got a response
                     clearInterval(checkClosed);
-                    
+
                     // remove redundant attributes
                     delete e.data.msg_id;
                     delete e.data.msg;
 
-                    if(e.data.success){
+                    if ( e.data.success ){
                         // set the auth token
                         puter.setAuthToken(e.data.token);
 
                         resolve(e.data);
-                    }else
+                    } else
+                    {
                         reject(e.data);
+                    }
 
                     // delete the listener
                     window.removeEventListener('message', messageHandler);
@@ -92,20 +93,24 @@ class Auth{
 
             window.addEventListener('message', messageHandler);
         });
-    }
+    };
 
-    isSignedIn = () =>{
-        if(puter.authToken)
+    isSignedIn = () => {
+        if ( puter.authToken )
+        {
             return true;
+        }
         else
+        {
             return false;
-    }
+        }
+    };
 
     getUser = function(...args){
         let options;
 
         // If first argument is an object, it's the options
-        if (typeof args[0] === 'object' && args[0] !== null) {
+        if ( typeof args[0] === 'object' && args[0] !== null ) {
             options = args[0];
         } else {
             // Otherwise, we assume separate arguments are provided
@@ -122,45 +127,125 @@ class Auth{
             utils.setupXhrEventHandlers(xhr, options.success, options.error, resolve, reject);
 
             xhr.send();
-        })
-    }
+        });
+    };
 
-    signOut = () =>{
+    signOut = () => {
         puter.resetAuthToken();
-    }
+    };
 
-    async whoami () {
+    async whoami() {
         try {
-            const resp = await fetch(this.APIOrigin + '/whoami', {
+            const resp = await fetch(`${this.APIOrigin}/whoami`, {
                 headers: {
-                    Authorization: `Bearer ${this.authToken}`
-                }
+                    Authorization: `Bearer ${this.authToken}`,
+                },
             });
-            
+
             const result = await resp.json();
-            
+
             // Log the response
-            if (globalThis.puter?.apiCallLogger?.isEnabled()) {
+            if ( globalThis.puter?.apiCallLogger?.isEnabled() ) {
                 globalThis.puter.apiCallLogger.logRequest({
                     service: 'auth',
                     operation: 'whoami',
                     params: {},
-                    result: result
+                    result: result,
                 });
             }
-            
+
             return result;
-        } catch (error) {
+        } catch( error ) {
             // Log the error
-            if (globalThis.puter?.apiCallLogger?.isEnabled()) {
+            if ( globalThis.puter?.apiCallLogger?.isEnabled() ) {
                 globalThis.puter.apiCallLogger.logRequest({
                     service: 'auth',
                     operation: 'whoami',
                     params: {},
                     error: {
                         message: error.message || error.toString(),
-                        stack: error.stack
-                    }
+                        stack: error.stack,
+                    },
+                });
+            }
+            throw error;
+        }
+    }
+
+    async getMonthlyUsage() {
+        try {
+            const resp = await fetch(`${this.APIOrigin}/metering/usage`, {
+                headers: {
+                    Authorization: `Bearer ${this.authToken}`,
+                },
+            });
+
+            const result = await resp.json();
+
+            // Log the response
+            if ( globalThis.puter?.apiCallLogger?.isEnabled() ) {
+                globalThis.puter.apiCallLogger.logRequest({
+                    service: 'auth',
+                    operation: 'usage',
+                    params: {},
+                    result: result,
+                });
+            }
+
+            return result;
+        } catch( error ) {
+            // Log the error
+            if ( globalThis.puter?.apiCallLogger?.isEnabled() ) {
+                globalThis.puter.apiCallLogger.logRequest({
+                    service: 'auth',
+                    operation: 'usage',
+                    params: {},
+                    error: {
+                        message: error.message || error.toString(),
+                        stack: error.stack,
+                    },
+                });
+            }
+            throw error;
+        }
+    }
+
+    async getDetailedAppUsage(appId) {
+        if ( !appId ) {
+            throw new Error('appId is required');
+        }
+
+        try {
+            const resp = await fetch(`${this.APIOrigin}/metering/usage/${appId}`, {
+                headers: {
+                    Authorization: `Bearer ${this.authToken}`,
+                },
+            });
+
+            const result = await resp.json();
+
+            // Log the response
+            if ( globalThis.puter?.apiCallLogger?.isEnabled() ) {
+                globalThis.puter.apiCallLogger.logRequest({
+                    service: 'auth',
+                    operation: 'detailed_app_usage',
+                    params: { appId },
+                    result: result,
+                });
+            }
+
+            return result;
+        } catch( error ) {
+            // Log the error
+            if ( globalThis.puter?.apiCallLogger?.isEnabled() ) {
+                globalThis.puter.apiCallLogger.logRequest({
+                    service: 'auth',
+                    operation: 'detailed_app_usage',
+                    params: { appId },
+                    error: {
+                        message: error.message || error.toString(),
+                        stack: error.stack,
+                    },
                 });
             }
             throw error;
@@ -168,4 +253,4 @@ class Auth{
     }
 }
 
-export default Auth
+export default Auth;

package/src/modules/FileSystem/index.js

@@ -134,8 +134,12 @@ export class PuterJSFileSystemModule extends AdvancedBase {
         });
 
         this.socket.on('item.added', (item) => {
-            puter._cache.flushall();
-            console.log('Flushed cache for item.added');
+            // remove readdir cache for parent
+            puter._cache.del('readdir:' + path.dirname(item.path));
+            console.log('deleted cache for readdir:' + path.dirname(item.path));
+            // remove item cache for parent directory
+            puter._cache.del('item:' + path.dirname(item.path));
+            console.log('deleted cache for item:' + path.dirname(item.path));
         });
 
         this.socket.on('item.updated', (item) => {

package/src/modules/FileSystem/operations/stat.js

@@ -1,6 +1,14 @@
 import * as utils from '../../../lib/utils.js';
 import getAbsolutePathForApp from '../utils/getAbsolutePathForApp.js';
 
+// Track in-flight requests to avoid duplicate backend calls
+// Each entry stores: { promise, timestamp }
+const inflightRequests = new Map();
+
+// Time window (in ms) to group duplicate requests together
+// Requests made within this window will share the same backend call
+const DEDUPLICATION_WINDOW_MS = 2000; // 2 seconds
+
 const stat = async function (...args) {
     let options;
 
@@ -24,17 +32,6 @@ const stat = async function (...args) {
             options.consistency = 'strong';
         }
 
-        // If auth token is not provided and we are in the web environment, 
-        // try to authenticate with Puter
-        if(!puter.authToken && puter.env === 'web'){
-            try{
-                await puter.ui.authenticateWithPuter();
-            }catch(e){
-                // if authentication fails, throw an error
-                reject('Authentication failed.');
-            }
-        }
-
         // Generate cache key based on path or uid
         let cacheKey;
         if(options.path){
@@ -50,41 +47,106 @@ const stat = async function (...args) {
             }
         }
 
-        // create xhr object
-        const xhr = utils.initXhr('/stat', this.APIOrigin, undefined, "post", "text/plain;actually=json");
+        // Generate deduplication key based on all request parameters
+        const deduplicationKey = JSON.stringify({
+            path: options.path,
+            uid: options.uid,
+            returnSubdomains: options.returnSubdomains,
+            returnPermissions: options.returnPermissions,
+            returnVersions: options.returnVersions,
+            returnSize: options.returnSize,
+            consistency: options.consistency,
+        });
 
-        // set up event handlers for load and error events
-        utils.setupXhrEventHandlers(xhr, options.success, options.error, async (result) => {
-            // Calculate the size of the result for cache eligibility check
-            const resultSize = JSON.stringify(result).length;
+        // Check if there's already an in-flight request for the same parameters
+        const existingEntry = inflightRequests.get(deduplicationKey);
+        const now = Date.now();
+        
+        if (existingEntry) {
+            const timeSinceRequest = now - existingEntry.timestamp;
             
-            // Cache the result if it's not bigger than MAX_CACHE_SIZE
-            const MAX_CACHE_SIZE = 20 * 1024 * 1024;
+            // Only reuse the request if it's within the deduplication window
+            if (timeSinceRequest < DEDUPLICATION_WINDOW_MS) {
+                // Wait for the existing request and return its result
+                try {
+                    const result = await existingEntry.promise;
+                    resolve(result);
+                } catch (error) {
+                    reject(error);
+                }
+                return;
+            } else {
+                // Request is too old, remove it from the tracker
+                inflightRequests.delete(deduplicationKey);
+            }
+        }
 
-            if(resultSize <= MAX_CACHE_SIZE){
-                // UPSERT the cache
-                puter._cache.set(cacheKey, result);
+        // Create a promise for this request and store it to deduplicate concurrent calls
+        const requestPromise = new Promise(async (resolveRequest, rejectRequest) => {
+            // If auth token is not provided and we are in the web environment, 
+            // try to authenticate with Puter
+            if(!puter.authToken && puter.env === 'web'){
+                try{
+                    await puter.ui.authenticateWithPuter();
+                }catch(e){
+                    // if authentication fails, throw an error
+                    rejectRequest('Authentication failed.');
+                    return;
+                }
+            }
+
+            // create xhr object
+            const xhr = utils.initXhr('/stat', this.APIOrigin, undefined, "post", "text/plain;actually=json");
+
+            // set up event handlers for load and error events
+            utils.setupXhrEventHandlers(xhr, options.success, options.error, async (result) => {
+                // Calculate the size of the result for cache eligibility check
+                const resultSize = JSON.stringify(result).length;
+                
+                // Cache the result if it's not bigger than MAX_CACHE_SIZE
+                const MAX_CACHE_SIZE = 20 * 1024 * 1024;
+
+                if(resultSize <= MAX_CACHE_SIZE){
+                    // UPSERT the cache
+                    puter._cache.set(cacheKey, result);
+                }
+                
+                resolveRequest(result);
+            }, rejectRequest);
+
+            let dataToSend = {};
+            if (options.uid !== undefined) {
+                dataToSend.uid = options.uid;
+            } else if (options.path !== undefined) {
+                // If dirPath is not provided or it's not starting with a slash, it means it's a relative path
+                // in that case, we need to prepend the app's root directory to it
+                dataToSend.path = getAbsolutePathForApp(options.path);
             }
             
+            dataToSend.return_subdomains = options.returnSubdomains;
+            dataToSend.return_permissions = options.returnPermissions;
+            dataToSend.return_versions = options.returnVersions;
+            dataToSend.return_size = options.returnSize;
+            dataToSend.auth_token = this.authToken;
+
+            xhr.send(JSON.stringify(dataToSend));
+        });
+
+        // Store the promise and timestamp in the in-flight tracker
+        inflightRequests.set(deduplicationKey, {
+            promise: requestPromise,
+            timestamp: now,
+        });
+
+        // Wait for the request to complete and clean up
+        try {
+            const result = await requestPromise;
+            inflightRequests.delete(deduplicationKey);
             resolve(result);
-        }, reject);
-
-        let dataToSend = {};
-        if (options.uid !== undefined) {
-            dataToSend.uid = options.uid;
-        } else if (options.path !== undefined) {
-            // If dirPath is not provided or it's not starting with a slash, it means it's a relative path
-            // in that case, we need to prepend the app's root directory to it
-            dataToSend.path = getAbsolutePathForApp(options.path);
+        } catch (error) {
+            inflightRequests.delete(deduplicationKey);
+            reject(error);
         }
-        
-        dataToSend.return_subdomains = options.returnSubdomains;
-        dataToSend.return_permissions = options.returnPermissions;
-        dataToSend.return_versions = options.returnVersions;
-        dataToSend.return_size = options.returnSize;
-        dataToSend.auth_token = this.authToken;
-
-        xhr.send(JSON.stringify(dataToSend));
     })
 }
 

package/src/modules/UI.js

@@ -765,6 +765,12 @@ class UI extends EventListener {
         })
     }
 
+    requestUpgrade = function() {
+        return new Promise((resolve) => {
+            this.#postMessageWithCallback('requestUpgrade', resolve, {  });
+        })
+    }
+
     showSaveFilePicker = function(content, suggestedName, type){
         const undefinedOnCancel = new putility.libs.promise.TeePromise();
         const resolveOnlyPromise = new Promise((resolve, reject) => {

package/src/modules/Workers.js

@@ -97,7 +97,7 @@ 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) {
@@ -116,5 +116,55 @@ export class WorkersHandler {
             return true;
         }
     }
+    
+    async getLoggingHandle (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) => { };
+
+        // Coercibility to ReadableStream
+        Object.defineProperty(logStreamObject, 'start', {
+            enumerable: false,
+            value: async (controller) => {
+                socket.addEventListener("message", (event) => {
+                    controller.enqueue(JSON.parse(event.data));
+                });
+                socket.addEventListener("close", (event) => {
+                    try {
+                        controller.close();
+                    } 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) });
+
+            logStreamObject.dispatchEvent(logEvent)
+            logStreamObject.onLog(logEvent);
+        });
+        logStreamObject.close = socket.close;
+        return new Promise((res, rej) => {
+            let done = false;
+            socket.onopen = ()=>{
+                done = true;
+                res(logStreamObject);
+            }
+
+            socket.onerror = () => {
+                if (!done) {
+                    rej("Failed to open logging connection");
+                }
+            }
+        })
+    }
 
 }