@vida-global/apps-tools 1.0.1

package/index.js

@@ -0,0 +1,23 @@
+const { AppHooksHandler, AppFunctionHandler }    = require("./lib/actionHandlers");
+const { AppFunctionResponse, AppHookResponse }   = require('./lib/appResponses');
+const { BaseProviderConfigurator, BaseProvider } = require('./lib/providers/provider');
+const { AppServer }                              = require("./lib/server/server");
+const { VaderUserContext }                       = require("./lib/userContext");
+const { VidaApp }                                = require("./lib/apps/vidaApp");
+const { VidaLiveAppManager }                     = require("./lib/apps/appManager/vidaLiveAppManager");
+const { HttpClient, logger }                     = require("@vida-global/core");
+
+module.exports = {
+    AppFunctionHandler,
+    AppFunctionResponse,
+    AppHooksHandler,
+    AppHookResponse,
+    AppServer,
+    BaseProvider,
+    BaseProviderConfigurator,
+    HttpClient,
+    logger,
+    VaderUserContext,
+    VidaApp,
+    VidaLiveAppManager
+}

package/lib/actionHandlers/appFunctionHandler.js

@@ -0,0 +1,7 @@
+class AppFunctionHandler {
+    constructor(app) {
+        this.app = app
+    }
+}
+
+module.exports = { AppFunctionHandler };

package/lib/actionHandlers/appHooksHandler.js

@@ -0,0 +1,7 @@
+class AppHooksHandler {
+    constructor(app) {
+        this.app = app
+    }
+}
+
+module.exports = { AppHooksHandler };

package/lib/actionHandlers/index.js

@@ -0,0 +1,4 @@
+const { AppHooksHandler }    = require("./appHooksHandler");
+const { AppFunctionHandler } = require("./appFunctionHandler");
+
+module.exports = { AppHooksHandler, AppFunctionHandler };

package/lib/appResponses/appFunctionResponse.js

@@ -0,0 +1,23 @@
+class AppFunctionResponse {
+    status = null;
+    data = null;
+    error = null;
+    message = null;
+    functionName = null;
+    functionArgs = null;
+    responseTime = null;
+
+    constructor () {
+        this.logger = console
+    }
+
+    log () {
+        if (this.status === 'error') {
+            this.logger.error(`App response error: ${this.status} - ${this.message}`)
+        } else {
+            this.logger.log(`App response: ${this.status}`)
+        }
+    }
+}
+
+module.exports = { AppFunctionResponse };

package/lib/appResponses/appHookResponse.js

@@ -0,0 +1,21 @@
+class AppHookResponse {
+    status = null;
+    error = null;
+    data = null;
+    message = null;
+    responseTime = null;
+
+    constructor () {
+        this.logger = console
+    }
+
+    log () {
+        if (this.status === 'error') {
+            this.logger.error(`App response error: ${this.status} - ${this.message}`)
+        } else {
+            this.logger.log(`App response: ${this.status}`)
+        }
+    }
+}
+
+module.exports = { AppHookResponse };

package/lib/appResponses/calendarAppResponse.js

@@ -0,0 +1,6 @@
+const { AppFunctionResponse } = require('./appFunctionResponse');
+
+class CalendarAppResponse extends AppFunctionResponse {
+}
+
+module.exports = { CalendarAppResponse };

package/lib/appResponses/index.js

@@ -0,0 +1,9 @@
+const { AppFunctionResponse } = require('./appFunctionResponse');
+const { AppHookResponse }     = require('./appHookResponse');
+const { CalendarAppResponse } = require('./calendarAppResponse');
+
+module.exports = {
+    AppFunctionResponse,
+    AppHookResponse,
+    CalendarAppResponse
+}

package/lib/apps/appManager/abstractAppManager.js

@@ -0,0 +1,70 @@
+const { logger }                = require('@vida-global/core');
+const { ProviderManager }       = require('../../providers/providerManager');
+const { VaderUserContextProxy } = require('../../userContext')
+
+
+class AbstractAppManager {
+    #providerManager;
+
+
+    context(ctx) {
+        return new VaderUserContextProxy(this, ctx)
+    }
+
+
+    get logger() {
+        return logger;
+    }
+
+
+    get attachedToAppServer() {
+        return this.constructor.name == 'AppServerAppManager';
+    }
+
+
+    get providerManager() {
+        if (!this.#providerManager) {
+            this.#providerManager = new ProviderManager(this.redisClient, this.attachedToAppServer);
+        }
+        return this.#providerManager;
+    }
+
+
+    async _getApp(appClass, appId, appVersion, appManifest, userContext) {
+        const providerManager = this.providerManager;
+        const isServer        = this.attachedToAppServer;
+        return await appClass.get(appClass,
+                                { appId,
+                                  appVersion,
+                                  appManifest,
+                                  userContext,
+                                  providerManager },
+                                { isServer });
+    }
+
+
+    /***********************************************************************************************
+    * MISC
+    ***********************************************************************************************/
+    debugPrintCalls(appId, appVersion, functionName, callContext, manifest, functionArgs) {
+        this.logger.info(`Handling call ${appId} ${appVersion} ${functionName}`)
+
+        // User: ${JSON.stringify(callContext.user, null, 2)}
+        // Agent: ${JSON.stringify(callContext.agent, null, 2)}
+        // Caller: ${JSON.stringify(callContext.caller, null, 2)}
+
+        this.logger.info(
+            `Function call details:
+                Request Sent Dependencies: ${JSON.stringify(callContext?.manifest?.dependencies, null, 2)}
+                App ID: ${appId}
+                App Version: ${appVersion}
+                Function name: ${functionName}
+                Function args: ${JSON.stringify(functionArgs, null, 2)}`
+        );
+    }
+}
+
+
+module.exports = {
+    AbstractAppManager
+}

package/lib/apps/appManager/appServerAppManager.js

@@ -0,0 +1,237 @@
+const { AbstractAppManager }   = require('./abstractAppManager');
+const   fs                     = require('fs');
+const { generateOpenApiSpec }  = require('../../openApi');
+const   path                   = require('path');
+const   _                      = require("lodash")
+
+
+class AppServerAppManager extends AbstractAppManager {
+    #apps;
+    #useMocks;
+
+
+    constructor({ apps, useMocks }) {
+        super(...arguments);
+        this.#useMocks = useMocks;
+        this.#apps     = apps.map(app => {
+            const [id, version] = app.split('/')
+            return {id, version}
+        })
+        this.#validateApps();
+    }
+
+
+    get apps() {
+        return structuredClone(this.#apps);
+    }
+
+
+    get appsDirectory() {
+        return `${process.cwd()}/apps`;
+    }
+
+
+    /***********************************************************************************************
+    * APP MANAGEMENT
+    ***********************************************************************************************/
+    #mergeMocks(appId, appVersion, appManifest) {
+        if (!this.#useMocks) return;
+        try {
+            const mockData = require(`${process.cwd()}/apps/${appId}/${appVersion}/test/mocks.js`)
+            appManifest.dependencies = _.merge(_.cloneDeep(appManifest.dependencies), mockData)
+        } catch (error) {
+            this.logger.warn(`No mocks found for app ${appId} ${appVersion} ${error}`)
+        }
+    }
+
+
+    async getApp(appId, appVersion, appManifest, userContext) {
+        if (!appManifest) {
+            this.logger.info('no manifest provided, getting vanilla manifest')
+            appManifest = this.fetchVanillaAppManifest(appId, appVersion, userContext)
+        }
+
+        this.#mergeMocks(appId, appVersion, appManifest);
+
+        const appClass = require(`${process.cwd()}/apps/${appId}/${appVersion}/app.js`);
+        return await this._getApp(appClass, appId, appVersion, appManifest, userContext);
+    }
+
+
+    fetchVanillaAppManifest(appId, appVersion) {
+        const manifest = require(`${process.cwd()}/apps/${appId}/${appVersion}/manifest.js`)
+        // Return a deep clone to avoid mutating the cached module object
+        return _.cloneDeep(manifest)
+    }
+
+
+    async fetchAllVanillaManifests(userContext = null) {
+        const manifests = {}
+        for (const {id, version} of this.apps) {
+            const appIdVersion = `${id}:${version}`
+            const manifest     = require(`${process.cwd()}/apps/${id}/${version}/manifest.js`)
+            // Deep clone to avoid mutating the cached module export
+            manifests[appIdVersion] = _.cloneDeep(manifest)
+        }
+        return manifests
+    }
+
+
+    /***********************************************************************************************
+    * VALIDATION
+    ***********************************************************************************************/
+    #validateApps() {
+        for (const {id, version} of this.apps) {
+            this.#validateApp(id, version);
+        }
+    }
+
+
+    #validateApp(appId, version) {
+        const appPath = path.join(this.appsDirectory, appId, version);
+
+        // Check if directory exists
+        if (!fs.existsSync(appPath)) {
+            throw new Error(`Invalid app structure: Missing directory at ${appPath}`);
+        }
+
+        // Check for app.js file existence
+        const appJsPath = path.join(appPath, 'app.js');
+        if (!fs.existsSync(appJsPath)) {
+            throw new Error(`Invalid app structure: Missing app.js for ${appId}/${version} in ${appPath}`);
+        }
+
+        // Check for manifest.js file existence
+        const manifestJsPath = path.join(appPath, 'manifest.js');
+        if (!fs.existsSync(manifestJsPath)) {
+            throw new Error(`Invalid app structure: Missing manifest.js for ${appId}/${version} in ${appPath}`);
+        }
+    }
+
+
+    /***********************************************************************************************
+    * OPEN API
+    ***********************************************************************************************/
+    async generateOpenApiSpec () {
+        return await generateOpenApiSpec(this);
+    }
+
+
+    /***********************************************************************************************
+    * CALL HANDLERS
+    ***********************************************************************************************/
+    async handleFunctionCall(appId, appVersion, appManifest, functionName, functionArgs, userContext) {
+        const manifest = appManifest
+
+        this.debugPrintCalls(appId,
+                             appVersion,
+                             functionName,
+                             userContext.toDict(),
+                             manifest,
+                             functionArgs);
+
+        this.logger.info(`Handling function call ${appId} ${appVersion} ${functionName}`)
+        const app         = await this.getApp(appId, appVersion, manifest, userContext);
+        const hasFunction = await app.isFunctionInApp(functionName)
+
+        if (!hasFunction) throw new Error(`Function not found: ${functionName}`);
+
+        const result = await app.handleFunctionCall(functionName, functionArgs)
+        this.logger.info(`Function result: ${JSON.stringify(result, null, 2)}`)
+        return result
+    }
+
+
+    async handleHookCall(appId, appVersion, appManifest, hookName, hookArgs, userContext) {
+        let manifest = appManifest
+        this.debugPrintCalls(appId,
+                             appVersion,
+                             hookName,
+                             userContext.toDict(),
+                             manifest,
+                             hookArgs);
+
+        this.logger.info(`Handling hook call ${appId} ${appVersion} ${hookName}`)
+        const app     = await this.getApp(appId, appVersion, manifest, userContext);
+        const hasHook = await app.isHookInApp(hookName)
+
+        if (!hasHook) throw new Error(`Hook not found: ${hookName}`);
+
+        const result = await app.handleHookCall(hookName, hookArgs);
+        this.logger.info(`Hook result: ${JSON.stringify(result, null, 2)}`);
+        return result;
+    }
+
+
+    /***********************************************************************************************
+    * DATA FETCHERS
+    ***********************************************************************************************/
+    async getFunctions(onlyEnabled=false, userContext) {
+          let appFunctions  = []
+        const appVersionIds = await userContext.getAppVersionIds()
+        this.logger.info('VADER: getFunctions', appVersionIds)
+
+        for (const appVersionId of appVersionIds) {
+            const [appId, appVersion] = appVersionId.split(':')
+            const app                 = await this.getApp(appId, appVersion, null, userContext);
+            appFunctions              = await app.getFunctions(onlyEnabled)
+        }
+        return appFunctions
+    }
+
+
+    async getHooks(userContext) {
+        const responses     = []
+        const appVersionIds = await userContext.getAppVersionIds()
+        this.logger.info('VADER: getHooks', appVersionIds)
+
+        for (let appVersionId of appVersionIds) {
+            const [appId, appVersion] = appVersionId.split(':')
+            const vanillaManifest     = this.fetchVanillaAppManifest(appId, appVersion, userContext);
+            const app                 = await this.getApp(appId, appVersion, vanillaManifest, userContext);
+            const appHooks            = await app.getHooks()
+
+            for (const hook of appHooks) {
+                const hasHook = await app.isHookInApp(hook.name)
+                if (hasHook) {
+                    const result = await app.handleHookCall(hook.name, {})
+                    this.logger.info(`Hook result: ${JSON.stringify(result, null, 2)}`)
+                    responses.push(result)
+                } else {
+                    this.logger.warn('VADER: getHooks', hook.name, 'not found')
+                }
+            }
+
+            this.logger.info('VADER: getHooks', appVersionId)
+            const appInstructions = await app.getAgentInstructions()
+            if (appInstructions) {
+                const appFunctions       = await this.getFunctions(true, userContext)
+                const functionNameString = _.map(appFunctions, f => f.name).join(', ')
+                responses.push({
+                    status: 'success',
+                    message: `Instructions for using ${functionNameString} functions: ${appInstructions}`
+                })
+            }
+        }
+
+        return responses
+    }
+
+
+    async listApps(userContext) {
+        const apps         = []
+        const allManifests = await this.fetchAllVanillaManifests(userContext)
+
+        for (const appIdVersion of Object.keys(allManifests)) {
+            const [appId, appVersion] = appIdVersion.split(':')
+            const vanillaManifest     = this.fetchVanillaAppManifest(appId, appVersion, userContext)
+            const app                 = await this.getApp(appId, appVersion, vanillaManifest, userContext);
+            const compositeManifest   = await app.getCompositeManifest()
+            apps.push(compositeManifest)
+        }
+        return apps
+    }
+}
+
+
+module.exports = { AppServerAppManager };

package/lib/apps/appManager/vaderApiClient.js

@@ -0,0 +1,81 @@
+const { AppFunctionResponse } = require('../../appResponses/appFunctionResponse');
+const { AppHookResponse }     = require('../../appResponses/appHookResponse');
+const { HttpClient }          = require('@vida-global/core');
+
+
+class VaderApiClient extends HttpClient {
+    #vaderServerUrl;
+    #vaderServerToken;
+
+
+    constructor(vaderServerUrl, vaderServerToken) {
+        super();
+        this.#vaderServerUrl   = vaderServerUrl;
+        this.#vaderServerToken = vaderServerToken;
+    }
+
+
+    async invokeAppManager(functionName, functionArgs = [], userContext = null){
+        const endpoint = `/invoke/apps/manager/${functionName}`
+        const body     = {
+            userContext: userContext?.toDict() || null,
+            functionArgs,
+        };
+
+        const response = await this.post(endpoint, userContext, body);
+        return response.data;
+    }
+
+
+    async invokeFunction(app, functionName, functionArgs, userContext = null){
+        return await this.#invokeAction('function',
+                                        AppFunctionResponse,
+                                        app,
+                                        functionName,
+                                        functionArgs,
+                                        userContext);
+    }
+
+
+    async invokeHook(app, hookName, hookArgs, userContext = null) {
+        return await this.#invokeAction('hook',
+                                        AppHookResponse,
+                                        app,
+                                        hookName,
+                                        hookArgs,
+                                        userContext);
+    }
+
+
+    async #invokeAction(actionType, responseCls, app, actionName, actionArgs, userContext) {
+        const endpoint = `/invoke/app/${actionType}/${app.id()}/${app.version()}/${actionName}`
+        const body     = {
+            userContext: userContext?.toDict() || null,
+            appManifest: await app.getCompositeManifest(),
+            actionArgs,
+        };
+
+        try {
+            const response = await this.post(endpoint, userContext, body);
+            return response.data;
+        } catch(err) {
+            const appResponse   = new responseCls();
+            appResponse.status  = "error"
+            appResponse.message = await err.data();
+            return appResponse;
+        }
+    }
+
+
+    async post(endpoint, userContext, body) {
+        const vaderUrl   = userContext?.get('customVaderUrl')   || this.#vaderServerUrl;
+        const vaderToken = userContext?.get('customVaderToken') || this.#vaderServerToken;
+        const invokeUrl  = `${vaderUrl}${endpoint}`;
+        const headers    = {Authorization: `Bearer ${vaderToken}`};
+
+        return await super.post(invokeUrl, { body, headers });
+    }
+}
+
+
+module.exports = { VaderApiClient };

package/lib/apps/appManager/vidaLiveAppManager.js

@@ -0,0 +1,187 @@
+const { AbstractAppManager   } = require('./abstractAppManager');
+const { AppFunctionResponse }  = require('../../appResponses/appFunctionResponse');
+const { VaderApiClient }       = require('./vaderApiClient');
+const { VidaApp }              = require('../vidaApp');
+
+
+class VidaLiveAppManager extends AbstractAppManager {
+    #providersList;
+    #redisClient;
+    #vaderApiClient;
+
+    constructor({ redisClient, providersList, vaderServerUrl, vaderServerToken }) {
+        super(...arguments);
+        this.#vaderApiClient  = new VaderApiClient(vaderServerUrl, vaderServerToken);
+        this.#providersList   = providersList;
+        this.#redisClient     = redisClient;
+    }
+
+
+    async initialize(server) {
+        await this.providerManager.buildRoutes(server, this.#providersList)
+    }
+
+    
+    get redisClient() {
+        return this.#redisClient;
+    }
+
+
+    /***********************************************************************************************
+    * APP MANAGEMENT
+    ***********************************************************************************************/
+    async getApp(appId, appVersion, appManifest, userContext) {
+        const serverManifest = await this.#vaderApiClient.invokeAppManager('getApp',
+                                                                           [appId, appVersion, appManifest],
+                                                                           userContext);
+        return await this._getApp(VidaApp, appId, appVersion, serverManifest, userContext);
+    }
+
+
+
+    async fetchVanillaAppManifest(appId, appVersion) {
+        return await this.#vaderApiClient.invokeAppManager('fetchVanillaAppManifest',
+                                                           [appId, appVersion],
+                                                           userContext);
+
+    }
+
+
+    async fetchAllVanillaManifests(userContext = null) {
+        return await this.#vaderApiClient.invokeAppManager('fetchAllVanillaManifests',
+                                                           [],
+                                                           userContext);
+    }
+
+
+    async installApp(appId, appVersion, manifest = null, userContext) {
+        if (await this.isAppInstalled(appId, appVersion, userContext)) {
+            throw new Error(`App already installed: ${appId} ${appVersion}`);
+        }
+        if (!manifest) {
+            manifest = await this.fetchVanillaAppManifest(appId, appVersion, userContext);
+        }
+        const app = await this.getApp(appId, appVersion, manifest,userContext);
+        await app.install(manifest)
+        return app
+    }
+
+
+    async updateInstalledApp(appId, appVersion, manifest, userContext) {
+        if (!await this.isAppInstalled(appId, appVersion, userContext)) {
+            throw new Error(`App not installed: ${appId} ${appVersion}`)
+        }
+        const vanillaManifest = await this.fetchVanillaAppManifest(appId, appVersion, userContext);
+        const app             = await this.getApp(appId, appVersion, vanillaManifest,userContext);
+        await app.update(manifest);
+        return app
+    }
+
+
+    async reloadInstalledApp(appId, appVersion, userContext) {
+        if (!await this.isAppInstalled(appId, appVersion, userContext)) {
+            throw new Error(`App not installed: ${appId} ${appVersion}`)
+        }
+        const vanillaManifest = await this.fetchVanillaAppManifest(appId, appVersion, userContext);
+        const app             = await this.getApp(appId, appVersion, vanillaManifest,userContext);
+        await app.reload(vanillaManifest);
+        return app
+    }
+
+
+    async uninstallApp(appId, appVersion, userContext){
+        const vanillaManifest = await this.fetchVanillaAppManifest(appId, appVersion, userContext);
+        const app             = await this.getApp(appId, appVersion, vanillaManifest, userContext);
+
+        if (!(await app.isInstalled())) return null;
+
+        this.logger.info(`Uninstalling app ${appId} ${appVersion}`)
+        await app.uninstall()
+        return app
+    }
+
+
+    async isAppInstalled(appId, appVersion, userContext) {
+        return await userContext.isAppInstalled(appId, appVersion)
+    }
+
+
+    /***********************************************************************************************
+    * INVOKERS
+    ***********************************************************************************************/
+    async invokeFunction(functionName, functionArgs, userContext) {
+        const appVersionIds = await userContext.getAppVersionIds()
+        for (const appVersionId of appVersionIds) {
+            const [appId, appVersion] = appVersionId.split(':')
+            const app = await this.getApp(appId, appVersion, null, userContext);
+
+            if (!app.isInstalled()) continue;
+
+            const hasFunction = await app.isFunctionInApp(functionName)
+            if (hasFunction) {
+                return await this.#vaderApiClient.invokeFunction(app,
+                                                                 functionName,
+                                                                 functionArgs,
+                                                                 userContext);
+            }
+        }
+
+        const resp        = new AppFunctionResponse()
+        resp.status       = 'notfound'
+        resp.data         = null
+        resp.functionName = functionName
+        resp.functionArgs = functionArgs
+        resp.message      = `Function not found: ${functionName}`
+        return resp
+    }
+
+
+    async invokeHook(app, hookName, hookArgs, userContext = null) {
+        const appVersionIds = await userContext.getAppVersionIds()
+        for (const appVersionId of appVersionIds) {
+            const [appId, appVersion] = appVersionId.split(':')
+            const app                 = await this.getApp(appId, appVersion, null, userContext);
+            if (!app.isInstalled()) continue;
+
+            const hasHook = await app.isHookInApp(hookName)
+            if (hasHook) {
+                this.logger.info('VADER: invokeHook', hookName, 'found')
+                return await this.#vaderApiClient.invokeHook(app,
+                                                             hookName,
+                                                             hookArgs,
+                                                             userContext);
+            } else {
+                this.logger.info('VADER: invokeHook', hookName, 'not found')
+            }
+        }
+
+        return null
+    }
+
+
+    /***********************************************************************************************
+    * DATA FETCHERS
+    ***********************************************************************************************/
+    async getFunctions(onlyEnabled = false, userContext) {
+        return await this.#vaderApiClient.invokeAppManager('getFunctions',
+                                                           [onlyEnabled],
+                                                           userContext);
+    }
+
+
+    async getHooks(userContext) {
+        return await this.#vaderApiClient.invokeAppManager('getHooks',
+                                                           [],
+                                                           userContext);
+    }
+
+
+    async listApps(userContext) {
+        return await this.#vaderApiClient.invokeAppManager('listApps',
+                                                           [],
+                                                           userContext);
+    }
+}
+
+
+module.exports = { VidaLiveAppManager };