@heyputer/puter.js 2.0.1 → 2.0.3

package/src/modules/Apps.js

@@ -0,0 +1,215 @@
+import * as utils from '../lib/utils.js'
+
+class Apps{
+    /**
+     * Creates a new instance with the given authentication token, API origin, and app ID,
+     *
+     * @class
+     * @param {string} authToken - Token used to authenticate the user.
+     * @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) {
+        this.authToken = context.authToken;
+        this.APIOrigin = context.APIOrigin;
+        this.appID = context.appID;
+    }
+
+    /**
+     * Sets a new authentication token.
+     *
+     * @param {string} authToken - The new authentication token.
+     * @memberof [Apps]
+     * @returns {void}
+     */
+    setAuthToken (authToken) {
+        this.authToken = authToken;
+    }
+
+    /**
+     * Sets the API origin.
+     * 
+     * @param {string} APIOrigin - The new API origin.
+     * @memberof [Apps]
+     * @returns {void}
+     */
+    setAPIOrigin (APIOrigin) {
+        this.APIOrigin = APIOrigin;
+    }
+
+    list = async (...args) => {
+        let options = {};
+
+        // if args is a single object, assume it is the options object
+        if (typeof args[0] === 'object' && args[0] !== null) {
+            options.params = args[0];
+        }
+
+        options.predicate =  ['user-can-edit'];
+
+        return utils.make_driver_method(['uid'], 'puter-apps', undefined, 'select').call(this, options);
+    }
+
+    create = async (...args) => {
+        let options = {};
+        // * allows for: puter.apps.new('example-app') *
+        if (typeof args[0] === 'string') {
+            let indexURL = args[1];
+            let title = args[2] ?? args[0];
+
+            options = { 
+                object: { 
+                    name: args[0], 
+                    index_url: indexURL, 
+                    title: title
+                }
+            };
+        }
+
+        // * allows for: puter.apps.new({name: 'example-app', indexURL: 'https://example.com'}) *
+        else if (typeof args[0] === 'object' && args[0] !== null) {
+            let options_raw = args[0];
+
+            options = { 
+                object: { 
+                    name: options_raw.name, 
+                    index_url: options_raw.indexURL, 
+                    // title is optional only if name is provided. 
+                    // If title is provided, use it. If not, use name.
+                    title: options_raw.title ?? options_raw.name,
+                    description: options_raw.description,
+                    icon: options_raw.icon,
+                    maximize_on_start: options_raw.maximizeOnStart,
+                    background: options_raw.background,
+                    filetype_associations: options_raw.filetypeAssociations,
+                    metadata: options_raw.metadata,
+                },
+                options: {
+                    dedupe_name: options_raw.dedupeName ?? false,
+                }
+            };
+        }
+
+        // name and indexURL are required
+        if(!options.object.name){
+            throw {
+                success: false, 
+                error: {
+                    code: 'invalid_request', 
+                    message: 'Name is required'
+                }
+            };
+        }
+        if(!options.object.index_url){
+            throw {
+                success: false, 
+                error: {
+                    code: 'invalid_request', 
+                    message: 'Index URL is required'
+                }
+            };
+        }
+
+        // Call the original chat.complete method
+        return await utils.make_driver_method(['object'], 'puter-apps', undefined, 'create').call(this, options);
+    }
+
+    update = async(...args) => {
+        let options = {};
+
+        // if there is one string argument, assume it is the app name
+        // * allows for: puter.apps.update('example-app') *
+        if (Array.isArray(args) && typeof args[0] === 'string') {
+            let object_raw = args[1];
+            let object = { 
+                name: object_raw.name, 
+                index_url: object_raw.indexURL, 
+                title: object_raw.title,
+                description: object_raw.description,
+                icon: object_raw.icon,
+                maximize_on_start: object_raw.maximizeOnStart,
+                background: object_raw.background,
+                filetype_associations: object_raw.filetypeAssociations,
+                metadata: object_raw.metadata,
+            };
+
+            options = { id: { name: args[0]}, object: object};
+        }
+
+        // Call the original chat.complete method
+        return await utils.make_driver_method(['object'], 'puter-apps', undefined, 'update').call(this, options);
+    }
+
+    get = async(...args) => {
+        let options = {};
+
+        // if there is one string argument, assume it is the app name
+        // * allows for: puter.apps.get('example-app') *
+        if (Array.isArray(args) && typeof args[0] === 'string') {
+            // if second argument is an object, assume it is the options object
+            if (typeof args[1] === 'object' && args[1] !== null) {
+                options.params = args[1];
+            }
+            // name
+            options.id =  {name: args[0]};
+        }
+
+        // if first argument is an object, assume it is the options object
+        if (typeof args[0] === 'object' && args[0] !== null) {
+            options.params = args[0];
+        }
+
+        return utils.make_driver_method(['uid'], 'puter-apps', undefined, 'read').call(this, options);
+    }
+
+    delete = async(...args) => {
+        let options = {};
+        // if there is one string argument, assume it is the app name
+        // * allows for: puter.apps.get('example-app') *
+        if (Array.isArray(args) && typeof args[0] === 'string') {
+            options = { id: {name: args[0]}};
+        }
+        return utils.make_driver_method(['uid'], 'puter-apps', undefined, 'delete').call(this, options);
+    }
+
+    getDeveloperProfile = function(...args){
+        let options;
+
+        // If first argument is an object, it's the options
+        if (typeof args[0] === 'object' && args[0] !== null) {
+            options = args[0];
+        } else {
+            // Otherwise, we assume separate arguments are provided
+            options = {
+                success: args[0],
+                error: args[1],
+            };
+        }
+
+        return new Promise((resolve, reject) => {
+            let options;
+
+            // If first argument is an object, it's the options
+            if (typeof args[0] === 'object' && args[0] !== null) {
+                options = args[0];
+            } else {
+                // Otherwise, we assume separate arguments are provided
+                options = {
+                    success: args[0],
+                    error: args[1],
+                };
+            }
+    
+            return new Promise((resolve, reject) => {
+                const xhr = utils.initXhr('/get-dev-profile', puter.APIOrigin, puter.authToken, 'get');
+    
+                // set up event handlers for load and error events
+                utils.setupXhrEventHandlers(xhr, options.success, options.error, resolve, reject);
+    
+                xhr.send();
+            })
+        });
+    }
+}
+
+export default Apps;

package/src/modules/Auth.js

@@ -0,0 +1,171 @@
+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,
+     *
+     * @class
+     * @param {string} authToken - Token used to authenticate the user.
+     * @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) {
+        this.authToken = context.authToken;
+        this.APIOrigin = context.APIOrigin;
+        this.appID = context.appID;
+    }
+
+    /**
+     * Sets a new authentication token.
+     *
+     * @param {string} authToken - The new authentication token.
+     * @memberof [Auth]
+     * @returns {void}
+     */
+    setAuthToken (authToken) {
+        this.authToken = authToken;
+    }
+
+    /**
+     * Sets the API origin.
+     * 
+     * @param {string} APIOrigin - The new API origin.
+     * @memberof [Auth]
+     * @returns {void}
+     */
+    setAPIOrigin (APIOrigin) {
+        this.APIOrigin = APIOrigin;
+    }
+    
+    signIn = (options) =>{
+        options = options || {};
+
+        return new Promise((resolve, reject) => {
+            let msg_id = this.#messageID++;
+            let w = 600;
+            let h = 600;
+            let title = 'Puter';
+            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);
+
+            // Set up interval to check if popup was closed
+            const checkClosed = setInterval(() => {
+                if (popup.closed) {
+                    clearInterval(checkClosed);
+                    // Remove the message listener
+                    window.removeEventListener('message', messageHandler);
+                    reject({ error: 'auth_window_closed', msg: 'Authentication window was closed by the user without completing the process.' });
+                }
+            }, 100);
+
+            function messageHandler(e) {
+                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){
+                        // set the auth token
+                        puter.setAuthToken(e.data.token);
+
+                        resolve(e.data);
+                    }else
+                        reject(e.data);
+
+                    // delete the listener
+                    window.removeEventListener('message', messageHandler);
+                }
+            }
+
+            window.addEventListener('message', messageHandler);
+        });
+    }
+
+    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) {
+            options = args[0];
+        } else {
+            // Otherwise, we assume separate arguments are provided
+            options = {
+                success: args[0],
+                error: args[1],
+            };
+        }
+
+        return new Promise((resolve, reject) => {
+            const xhr = utils.initXhr('/whoami', puter.APIOrigin, puter.authToken, 'get');
+
+            // set up event handlers for load and error events
+            utils.setupXhrEventHandlers(xhr, options.success, options.error, resolve, reject);
+
+            xhr.send();
+        })
+    }
+
+    signOut = () =>{
+        puter.resetAuthToken();
+    }
+
+    async whoami () {
+        try {
+            const resp = await fetch(this.APIOrigin + '/whoami', {
+                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: 'whoami',
+                    params: {},
+                    result: result
+                });
+            }
+            
+            return result;
+        } catch (error) {
+            // Log the error
+            if (globalThis.puter?.apiCallLogger?.isEnabled()) {
+                globalThis.puter.apiCallLogger.logRequest({
+                    service: 'auth',
+                    operation: 'whoami',
+                    params: {},
+                    error: {
+                        message: error.message || error.toString(),
+                        stack: error.stack
+                    }
+                });
+            }
+            throw error;
+        }
+    }
+}
+
+export default Auth

package/src/modules/Debug.js

@@ -0,0 +1,39 @@
+export class Debug {
+    constructor (context, parameters) {
+        this.context = context;
+        this.parameters = parameters;
+
+        this._init();
+    }
+
+    _init () {
+        // Check query parameter 'enabled_logs'
+        const url = new URL(location.href);
+        let enabled_logs = url.searchParams.get('enabled_logs');
+        if ( ! enabled_logs ) enabled_logs = '';
+        enabled_logs = enabled_logs.split(';');
+        for ( const category of enabled_logs ) {
+            if ( category === '' ) continue;
+            this.context.puter.logger.on(category);
+        }
+
+        globalThis.addEventListener('message', async e => {
+            // Ensure message is from parent window
+            if ( e.source !== globalThis.parent ) return;
+            // (parent window is allowed to be anything)
+
+            // Check if it's a debug message
+            if ( ! e.data.$ ) return;
+            if ( e.data.$ !== 'puterjs-debug' ) return;
+
+            // It's okay to log this; it will only show if a
+            // developer does something in the console.
+            console.log('Got a puter.js debug event!', e.data);
+
+            if ( e.data.cmd === 'log.on' ) {
+                console.log('Got instruction to turn logs on!');
+                this.context.puter.logger.on(e.data.category);
+            }
+        })
+    }
+}

package/src/modules/Drivers.js

@@ -0,0 +1,278 @@
+class FetchDriverCallBackend {
+    constructor ({ context }) {
+        this.context = context;
+        this.response_handlers = this.constructor.response_handlers;
+    }
+    
+    static response_handlers = {
+        'application/x-ndjson': async resp => {
+            const Stream = async function* Stream (readableStream) {
+                const reader = readableStream.getReader();
+                let value, done;
+                while ( ! done ) {
+                    ({ value, done } = await reader.read());
+                    if ( done ) break;
+                    const parts = (new TextDecoder().decode(value).split('\n'));
+                    for ( const part of parts ) {
+                        if ( part.trim() === '' ) continue;
+                        yield JSON.parse(part);
+                    }
+                }
+            }
+            
+            return Stream(resp.body);
+        },
+        'application/json': async resp => {
+            return await resp.json();
+        },
+        'application/octet-stream': async resp => {
+            return await resp.blob();
+        },
+    }
+    
+    async call ({ driver, method_name, parameters }) {
+        try {
+            const resp = await fetch(`${this.context.APIOrigin}/drivers/call`, {
+                headers: {
+                    'Content-Type': 'text/plain;actually=json',
+                },
+                method: 'POST',
+                body: JSON.stringify({
+                    'interface': driver.iface_name,
+                    ...(driver.service_name
+                        ? { service: driver.service_name }
+                        : {}),
+                    method: method_name,
+                    args: parameters,
+                    auth_token: this.context.authToken
+                }),
+            });
+            
+            const content_type = resp.headers.get('content-type')
+                .split(';')[0].trim(); // TODO: parser for Content-Type
+            const handler = this.response_handlers[content_type];
+            if ( ! handler ) {
+                const msg = `unrecognized content type: ${content_type}`;
+                console.error(msg);
+                console.error('creating blob so dev tools shows response...');
+                await resp.blob();
+                
+                // Log the error
+                if (globalThis.puter?.apiCallLogger?.isEnabled()) {
+                    globalThis.puter.apiCallLogger.logRequest({
+                        service: 'drivers',
+                        operation: `${driver.iface_name}::${method_name}`,
+                        params: { interface: driver.iface_name, driver: driver.service_name || driver.iface_name, method: method_name, args: parameters },
+                        error: { message: msg }
+                    });
+                }
+                
+                throw new Error(msg);
+            }
+            
+            const result = await handler(resp);
+            
+            // Log the successful response
+            if (globalThis.puter?.apiCallLogger?.isEnabled()) {
+                globalThis.puter.apiCallLogger.logRequest({
+                    service: 'drivers',
+                    operation: `${driver.iface_name}::${method_name}`,
+                    params: { interface: driver.iface_name, driver: driver.service_name || driver.iface_name, method: method_name, args: parameters },
+                    result: result
+                });
+            }
+            
+            return result;
+        } catch (error) {
+            // Log unexpected errors
+            if (globalThis.puter?.apiCallLogger?.isEnabled()) {
+                globalThis.puter.apiCallLogger.logRequest({
+                    service: 'drivers',
+                    operation: `${driver.iface_name}::${method_name}`,
+                    params: { interface: driver.iface_name, driver: driver.service_name || driver.iface_name, method: method_name, args: parameters },
+                    error: {
+                        message: error.message || error.toString(),
+                        stack: error.stack
+                    }
+                });
+            }
+            throw error;
+        }
+    }
+}
+
+class Driver {
+    constructor ({
+        iface,
+        iface_name,
+        service_name,
+        call_backend,
+    }) {
+        this.iface = iface;
+        this.iface_name = iface_name;
+        this.service_name = service_name;
+        this.call_backend = call_backend;
+    }
+    async call (method_name, parameters) {
+        return await this.call_backend.call({
+            driver: this,
+            method_name,
+            parameters,
+        });
+    }
+}
+
+class Drivers {
+    /**
+     * Creates a new instance with the given authentication token, API origin, and app ID,
+     *
+     * @class
+     * @param {string} authToken - Token used to authenticate the user.
+     * @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) {
+        this.authToken = context.authToken;
+        this.APIOrigin = context.APIOrigin;
+        this.appID = context.appID;
+        
+        // Driver-specific
+        this.drivers_ = {};
+
+        // TODO: replace with `context` from constructor and test site login
+        this.context = {};
+        Object.defineProperty(this.context, 'authToken', {
+            get: () => this.authToken,
+        });
+        Object.defineProperty(this.context, 'APIOrigin', {
+            get: () => this.APIOrigin,
+        });
+    }
+    
+    _init ({ puter }) {
+        puter.call = this.call.bind(this);
+    }
+
+    /**
+     * Sets a new authentication token and resets the socket connection with the updated token, if applicable.
+     *
+     * @param {string} authToken - The new authentication token.
+     * @memberof [AI]
+     * @returns {void}
+     */
+    setAuthToken (authToken) {
+        this.authToken = authToken;
+    }
+
+    /**
+     * Sets the API origin.
+     * 
+     * @param {string} APIOrigin - The new API origin.
+     * @memberof [AI]
+     * @returns {void}
+     */
+    setAPIOrigin (APIOrigin) {
+        this.APIOrigin = APIOrigin;
+    }
+    
+    async list () {
+        try {
+            const resp = await fetch(`${this.APIOrigin}/lsmod`, {
+                headers: {
+                    Authorization: 'Bearer ' + this.authToken,
+                },
+                method: 'POST'
+            });
+            
+            const list = await resp.json();
+            
+            // Log the response
+            if (globalThis.puter?.apiCallLogger?.isEnabled()) {
+                globalThis.puter.apiCallLogger.logRequest({
+                    service: 'drivers',
+                    operation: 'list',
+                    params: {},
+                    result: list.interfaces
+                });
+            }
+            
+            return list.interfaces;
+        } catch (error) {
+            // Log the error
+            if (globalThis.puter?.apiCallLogger?.isEnabled()) {
+                globalThis.puter.apiCallLogger.logRequest({
+                    service: 'drivers',
+                    operation: 'list',
+                    params: {},
+                    error: {
+                        message: error.message || error.toString(),
+                        stack: error.stack
+                    }
+                });
+            }
+            throw error;
+        }
+    }
+    
+    async get (iface_name, service_name) {
+        if ( ! service_name ) service_name = iface_name;
+        const key = `${iface_name}:${service_name}`;
+        if ( this.drivers_[key] ) return this.drivers_[key];
+
+        // const interfaces = await this.list();
+        // if ( ! interfaces[iface_name] ) {
+        //     throw new Error(`Interface ${iface_name} not found`);
+        // }
+
+        return this.drivers_[key] = new Driver ({
+            call_backend: new FetchDriverCallBackend({
+                context: this.context,
+            }),
+            // iface: interfaces[iface_name],
+            iface_name,
+            service_name,
+        });
+    }
+    
+    async call (...a) {
+        let iface_name, service_name, method_name, parameters;
+        
+        // Services with the same name as an interface they implement
+        // are considered the default implementation for that interface.
+        //
+        // A method with the same name as the interface and service it is
+        // called on can be left unspecified in a driver call through puter.js.
+        //
+        // For example:
+        // puter.drivers.call('ipgeo', { ip: '1.2.3.4' });
+        //
+        // Is the same as:
+        // puter.drivers.call('ipgeo', 'ipgeo', 'ipgeo', { ip: '1.2.3.4' })
+        //
+        // This is commonly the case when an interface only exists to
+        // connect a particular service to the drivers API. In this case,
+        // the interface might not specify the structure of the response
+        // because it is only intended for that specific integration
+        // (and that integration alone is responsible for avoiding regressions)
+        
+        // interface name, service name, method name, parameters
+        if ( a.length === 4 ) {
+            ([iface_name, service_name, method_name, parameters] = a);
+        }
+        // interface name, method name, parameters
+        else if ( a.length === 3 ) {
+            ([iface_name, method_name, parameters] = a);
+        }
+        // interface name, parameters
+        else if ( a.length === 2 ) {
+            ([iface_name, parameters] = a);
+            method_name = iface_name;
+        }
+
+        const driver = await this.get(iface_name, service_name);
+        return await driver.call(method_name, parameters);
+    }
+    
+}
+
+export default Drivers;