@vida-global/apps-tools 1.0.1

package/lib/providers/providers/auth/mcp/index.js

@@ -0,0 +1,99 @@
+const {BaseProvider, BaseProviderConfigurator } = require('../../../provider');
+const {logger} = require('@vida-global/core');
+
+class MCPAuthConfigurator extends BaseProviderConfigurator {
+    async initialize() {
+        logger.info('MCP Auth Configurator initialized');
+    }
+}
+
+class MCPAuthProvider extends BaseProvider {
+    type = 'auth'
+    name = 'mcp'
+    configurator = MCPAuthConfigurator
+
+    async initialize() {
+        logger.info('MCP Auth Provider initialized');
+        this._client = null;
+    }
+
+    async uninstall() {
+        logger.info('MCP Auth Provider Uninstalled');
+        await this.userContext.deleteProviderConfig(
+            this.type, this.name, this.appId, this.appVersion
+        )
+        this._client = null;
+    }
+
+    async update(config) {
+        logger.info('MCP Auth Provider Updated')
+        await this.userContext.setProviderConfig(
+            this.type, this.name, config,
+            this.appId, this.appVersion
+        )
+        this.config = config;
+        this._client = null;
+    }
+
+    async getManifest() {
+        return this.config
+    }
+
+    async isConfigured() {
+        if (this.config && this.config.parameters) {
+            const { properties, required } = this.config.parameters;
+            if (required && Array.isArray(required)) {
+                for (const field of required) {
+                    const property = properties[field];
+                    if (!property || !property.value ||
+                        (property.type === 'string' && property.value.trim() === '')) {
+                        return false;
+                    }
+                }
+            }
+        }
+        return true;
+    }
+
+    async getClient() {
+        // Lazy import to avoid hard dependency unless used
+        let MCPClient;
+        try {
+            MCPClient = await import('mcp-client').then(m => m.MCPClient || m.default);
+        } catch (e) {
+            console.error(e)
+            throw new Error('mcp-client dependency is not installed. Please install mcp-client to use MCP app.');
+        }
+
+        const mcpUrl = this.config?.parameters?.properties?.mcpUrl?.value;
+        const authHeader = this.config?.parameters?.properties?.authHeader?.value;
+        if (!mcpUrl) {
+            throw new Error('MCP URL is not configured in provider auth:mcp');
+        }
+
+        if (this._client && this._client.__connected) {
+            return this._client;
+        }
+
+        const client = new MCPClient({ name: 'VADER-MCP', version: '1.0.0' });
+        const useSSE = this.config?.parameters?.properties?.useSSE?.value;
+        let connectOptions = {};
+        if (useSSE) {
+            connectOptions = { url: mcpUrl, type: 'sse' };
+        } else {
+            connectOptions = { url: mcpUrl };
+        }
+        if (authHeader) {
+            connectOptions.headers = { Authorization: authHeader };
+        }
+        console.log(`Connecting to MCP using ${useSSE ? 'SSE' : 'HTTP'}.`)
+        await client.connect(connectOptions);
+        console.log('Connected to MCP')
+        // mark connected
+        client.__connected = true;
+        this._client = client;
+        return client;
+    }
+}
+
+module.exports = MCPAuthProvider;

package/lib/providers/providers/auth/outlook/index.js

@@ -0,0 +1,257 @@
+const {logger} = require('@vida-global/core');
+const {BaseProvider, BaseProviderConfigurator} = require('../../../provider');
+const axios = require('axios');
+const { URL } = require('url');
+const _ = require('lodash');
+
+
+const oAuthConfig = {
+    scopes: [
+        'Calendars.ReadWrite',
+        'Calendars.Read',
+        'User.Read'
+    ],
+    initiateOAuthUrl: '/vader/oauth/outlook/initiate',
+    callbackPath: '/vader/oauth/outlook/callback',
+    authorizationEndpoint: 'https://login.microsoftonline.com/common/oauth2/v2.0/authorize',
+    tokenEndpoint: 'https://login.microsoftonline.com/common/oauth2/v2.0/token'
+}
+
+
+class OutlookOAuthConfigurator extends BaseProviderConfigurator {
+    async storeToken(user, tokenResponse) {
+        let tokenInfo = {
+            accessToken: tokenResponse.access_token,
+            refreshToken: tokenResponse.refresh_token,
+            expiresAt: Date.now() + (tokenResponse.expires_in * 1000)
+        };
+
+        await this.redis.set(this.TOKEN_KEY(user), JSON.stringify(tokenInfo));
+    }
+
+    getAuthorizationUrl(redirectUri, state) {
+        const params = new URLSearchParams({
+            client_id: this.config.clientId,
+            response_type: 'code',
+            redirect_uri: redirectUri,
+            scope: oAuthConfig.scopes.join(' '),
+            response_mode: 'query',
+            state: state
+        });
+
+        return `${oAuthConfig.authorizationEndpoint}?${params.toString()}`;
+    }
+
+    buildRoutes(app) {
+        app.get(oAuthConfig.initiateOAuthUrl, async (req, res) => {
+            const {redirectUri, userId} = req.query;
+
+            if (!redirectUri || !userId) {
+                return res.status(400).send('Missing required parameters: redirectUri and userId');
+            }
+
+            // State data
+            const stateData = {
+                redirectUri,
+                userId,
+                // timestamp: Date.now()
+            };
+
+            // Configure redirect URI and generate authorization URL
+            const authUrl = this.getAuthorizationUrl(redirectUri, Buffer.from(JSON.stringify(stateData)).toString('base64'));
+
+            res.redirect(authUrl);
+        })
+
+        app.get(oAuthConfig.callbackPath, async (req, res) => {
+            let redirectUri = null;
+            try {
+                redirectUri = await this.handleOAuthCallback(req);
+                res.redirect(redirectUri);
+            } catch (error) {
+                console.error('OAuth callback error:', error);
+                res.status(500).send('Authentication failed. Please try again.');
+            }
+        });
+    }
+
+    async handleOAuthCallback(req) {
+        if (req.query.error) {
+            throw new Error(`OAuth error: ${req.query.error}`);
+        }
+
+        const {code, state} = req.query;
+        if (!code) {
+            throw new Error('No authorization code received');
+        }
+        if (!state) {
+            throw new Error('No state parameter received');
+        }
+
+        const sessionData = JSON.parse(Buffer.from(state, 'base64').toString());
+        let {redirectUri, userId} = sessionData;
+        if (!redirectUri || !userId) {
+            throw new Error('Invalid state parameter');
+        }
+        redirectUri = decodeURIComponent(redirectUri);
+        let user = {id: userId};
+        let success = true
+        try {
+            const response = await axios.post(
+              oAuthConfig.tokenEndpoint, {
+                  client_id: this.config.clientId,
+                  client_secret: this.config.clientSecret,
+                  code: code,
+                  redirect_uri: redirectUri,
+                  grant_type: 'authorization_code'
+              }, {
+                  headers: {
+                      'Content-Type': 'application/x-www-form-urlencoded'
+                  }
+              });
+            await this.storeToken(user, response.data);
+        } catch (error) {
+            console.error('Error exchanging code for token:', error);
+            success = false;
+        }
+        const finalUrl = new URL(redirectUri);
+        finalUrl.searchParams.append(
+          'success', success ? 'true' : 'false'
+        );
+        finalUrl.searchParams.append(
+          'userId', user.id
+        )
+        return finalUrl.toString();
+    }
+}
+
+
+class OutlookAuthProvider extends BaseProvider {
+    type = 'auth';
+    name = 'oauth2';
+    configurator = OutlookOAuthConfigurator;
+
+    TOKEN_KEY (user) {
+        return `vader:oauth:outlook:${user.id}:token`;
+    }
+
+    OAUTH_SESSION_KEY (user) {
+        return `vader:oauth:outlook:${user.id}:session`;
+    }
+
+    async initialize() {
+        if (!this.isServer && this.user) {
+            // Load token from Redis if available
+            const tokenData = await this.redis.get(this.TOKEN_KEY(this.user));
+            if (tokenData) {
+                this.tokenInfo = JSON.parse(tokenData);
+            }
+            if (this.isTokenExpired()) {
+                await this.refreshToken();
+            }
+        }
+        this.config = {
+            ...this.config,
+            ...oAuthConfig
+        }
+        logger.info('Outlook Oauth Provider Initialized')
+    }
+
+    async uninstall () {
+        await this.redis.del(this.TOKEN_KEY(this.user));
+        await this.redis.del(this.OAUTH_SESSION_KEY(this.user));
+    }
+
+    async isConfigured() {
+        if (!this.config.clientId || !this.config.clientSecret) {
+            return false;
+        }
+
+        if (!this.tokenInfo) {
+            return false;
+        }
+
+        // Check if the token is expired and try to refresh
+        if (this.isTokenExpired() && !(await this.refreshToken())) {
+            logger.warn('Outlook Oauth Provider: Token expired and failed to refresh');
+            return false;
+        }
+
+        return true;
+    }
+
+    async getManifest() {
+        if (this.isServer) {
+            return {
+                ...oAuthConfig
+            }
+        } else {
+            return {
+                ...oAuthConfig,
+                parameters: {
+                    type: "object",
+                    properties: {
+                        accessToken: {
+                            type: "string",
+                            description: "Access Token for outlook API.",
+                            value: await this.getAccessToken(),
+                        }
+                    },
+                    required: ["accessToken"],
+                }
+            }
+        }
+    }
+
+    isTokenExpired() {
+        if (!this.tokenInfo || !this.tokenInfo.expiresAt) {
+            return true;
+        }
+        // Add a 5-minute buffer before expiration
+        return Date.now() >= (this.tokenInfo.expiresAt - 300000);
+    }
+
+    async getAccessToken() {
+        if (this.isTokenExpired()) {
+            await this.refreshToken();
+        }
+        return this.tokenInfo?.accessToken;
+    }
+
+    async refreshToken() {
+        if (!this.tokenInfo?.refreshToken) {
+            return false;
+        }
+
+        try {
+            const response = await axios.post(oAuthConfig.tokenEndpoint, {
+                client_id: this.config.clientId,
+                client_secret: this.config.clientSecret,
+                refresh_token: this.tokenInfo.refreshToken,
+                grant_type: 'refresh_token'
+            }, {
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded'
+                }
+            });
+
+            await this.storeToken(response.data);
+            return true;
+        } catch (error) {
+            logger.error('Error refreshing token:', error);
+            return false;
+        }
+    }
+
+    async storeToken(user, tokenResponse) {
+        let tokenInfo = {
+            accessToken: tokenResponse.access_token,
+            refreshToken: tokenResponse.refresh_token,
+            expiresAt: Date.now() + (tokenResponse.expires_in * 1000)
+        };
+
+        await this.redis.set(this.TOKEN_KEY(this.user), JSON.stringify(tokenInfo));
+    }
+}
+
+module.exports = OutlookAuthProvider;

package/lib/providers/providers/auth/squareUp/index.js

@@ -0,0 +1,111 @@
+const axios = require('axios');
+const {BaseProvider} = require('../../../provider');
+
+
+class SquareUpProvider extends BaseProvider {
+    type = 'auth';
+    name = 'square';
+
+    async getField (fieldName) {
+        return await this.readData(fieldName);
+    }
+
+    async isConfigured() {
+        const {refreshToken, accessToken} = await this.getCredentials();
+        return !!(refreshToken && accessToken);
+    }
+
+    async getClientConfig() {
+        const siteUrl = await this.readConfig('siteUrl');
+        const clientId = await this.readConfig('clientId');
+        const clientSecret = await this.readConfig('clientSecret');
+        const redirectUrl = `${siteUrl}/api/v2/providers/${this.type}/${this.name}/receive`;
+        return {redirectUrl, clientId, clientSecret};
+    }
+
+    async getAuthUrl(redirectUrl) {
+        const {clientId, redirectUrl: defaultRedirectUrl} = await this.getClientConfig();
+        const finalRedirectUrl = redirectUrl || defaultRedirectUrl;
+        const state = `${this.user.id}|${this.agent.id}|${redirectUrl ? `|${redirectUrl}` : ''}`;
+        const scope = (this.appParams.scope || ['APPOINTMENTS_READ', 'CUSTOMERS_READ']).join(' ');
+
+        // Generate the SquareUp authorization URL
+        return `https://connect.squareup.com/oauth2/authorize?client_id=${clientId}&response_type=code&scope=${scope}&redirect_uri=${encodeURIComponent(finalRedirectUrl)}&state=${state}`;
+    }
+
+    async exchangeCodeForToken(code) {
+        const {clientId, clientSecret, redirectUrl} = await this.getClientConfig();
+
+        try {
+            const response = await axios.post('https://connect.squareup.com/oauth2/token', {
+                client_id: clientId,
+                client_secret: clientSecret,
+                code: code,
+                grant_type: 'authorization_code',
+                redirect_uri: redirectUrl,
+            });
+
+            return response.data;
+        } catch (error) {
+            console.error('SQUAREUP PROVIDER ERROR: Failed to exchange code for token:', error);
+            throw error;
+        }
+    }
+
+    async setCredentials(code) {
+        const tokenData = await this.exchangeCodeForToken(code);
+        await this.writeData('squareUpOauthAccessToken', tokenData.access_token);
+        await this.writeData('squareUpOauthRefreshToken', tokenData.refresh_token);
+        await this.writeData('squareUpOauthExpires', Date.now() + tokenData.expires_in * 1000); // in milliseconds
+        return 'success';
+    }
+
+    async getCredentials() {
+        const refreshToken = await this.readData('squareUpOauthRefreshToken');
+        const accessToken = await this.readData('squareUpOauthAccessToken');
+        return {refreshToken, accessToken};
+    }
+
+    async refreshAccessToken() {
+        const {clientId, clientSecret} = await this.getClientConfig();
+        const refreshToken = await this.readData('squareUpOauthRefreshToken');
+
+        try {
+            const response = await axios.post('https://connect.squareup.com/oauth2/token', {
+                client_id: clientId,
+                client_secret: clientSecret,
+                refresh_token: refreshToken,
+                grant_type: 'refresh_token',
+            });
+
+            const tokenData = response.data;
+            await this.writeData('squareUpOauthAccessToken', tokenData.access_token);
+            await this.writeData('squareUpOauthExpires', Date.now() + tokenData.expires_in * 1000); // in milliseconds
+        } catch (error) {
+            console.error('SQUAREUP PROVIDER ERROR: Failed to refresh access token:', error);
+            throw error;
+        }
+    }
+
+    async revokeCredentials() {
+        const accessToken = await this.readData('squareUpOauthAccessToken');
+
+        try {
+            if (accessToken) {
+                await axios.post('https://connect.squareup.com/oauth2/revoke', {
+                    client_id: await this.readConfig('clientId'),
+                    access_token: accessToken,
+                });
+                await this.deleteData('squareUpOauthAccessToken');
+                await this.deleteData('squareUpOauthRefreshToken');
+                await this.deleteData('squareUpOauthExpires');
+            }
+            return 'success';
+        } catch (error) {
+            console.error('SQUAREUP PROVIDER ERROR: Failed to revoke credentials:', error);
+            return 'squareup-error';
+        }
+    }
+}
+
+module.exports = SquareUpProvider;

package/lib/providers/providers/mock.js

@@ -0,0 +1,51 @@
+const { logger } = require('@vida-global/core');
+
+
+class MockProvider {
+    constructor(providerType, providerName, {user, agent, caller, appParams}, mockData) {
+        this.providerType = providerType
+        this.providerName = providerName
+        this.user = user
+        this.agent = agent
+        this.caller = caller
+        this.appParams = appParams
+        this.mockData = mockData
+    }
+
+    static getObjectProxy(instance)
+    {
+        return new Proxy(instance, {
+            get(target, prop, receiver) {
+                if (prop in target) {
+                    if (typeof target[prop] === 'function') {
+                        return target[prop].bind(target)
+                    } else {
+                        return target[prop]
+                    }
+                } else {
+                    const method = target.mockData.methods?.find((m) => m.method === prop)
+                    if (method) {
+                        return method.value.bind(target)
+                    }
+                    return Reflect.get(target, prop, receiver);
+                }
+            }
+        });
+    }
+
+    async isConfigured() {
+        return true
+    }
+    
+    async getField(name) {
+        const field = this.mockData.fields?.find((f) => f.field === name)
+        if (!field) {
+            // logger.error(`Could not find field ${name} on provider type ${this.providerType} with name ${this.providerName}`)
+            throw Error(`MockData: Could not find field ${name} on provider type ${this.providerType} with name ${this.providerName}`)
+        }
+        return field.value
+    }
+}
+
+module.exports = MockProvider;
+

package/lib/server/appController.js

@@ -0,0 +1,112 @@
+const { VidaServerController } = require('@vida-global/core');
+
+
+class AppController extends VidaServerController {
+
+    /***********************************************************************************************
+    * FUNCTIONS
+    ***********************************************************************************************/
+    async postInvokeFunction() {
+        try {
+            await this.invokeFunction();
+        } catch (err) {
+            this.logger.error({message: err.message, stack: err.stack}, 'Unhandled Exception')
+            this.statusCode = err.status || 500;
+            await this.render({
+                error: {message: err.message, status: err.status || 500}
+            })
+        }
+    }
+
+
+    async invokeFunction() {
+        await this.#invokeAppAction('Function');
+    }
+
+
+    /***********************************************************************************************
+    * HOOKS
+    ***********************************************************************************************/
+    async postInvokeHook() {
+        try {
+            await this.invokeHook();
+        } catch (error) {
+            logger.info(error)
+            return res.status(500).json({error})
+        }
+    }
+
+
+    async invokeHook() {
+        await this.#invokeAppAction('Hook');
+    }
+
+
+    /***********************************************************************************************
+    * CALL HELPER
+    ***********************************************************************************************/
+    async postInvokeAppManager() {
+        try {
+            await this.invokeAppManager();
+        } catch (error) {
+            logger.info(error)
+            return res.status(500).json({error})
+        }
+    }
+
+
+    async invokeAppManager() {
+        const { functionArgs,
+                functionName,
+                userContext } = this.params
+        const context         = this.appManager.context(userContext);
+        let resp = await context[functionName](...functionArgs)
+        if (resp.serialize && typeof resp.serialize === 'function') {
+            resp = await resp.serialize()
+        }
+        await this.render(resp);
+    }
+
+
+    /***********************************************************************************************
+    * CALL HELPER
+    ***********************************************************************************************/
+    async getOpenApi() {
+        const specs = await this.appManager.generateOpenApiSpec();
+        await this.render(specs);
+    }
+
+
+    /***********************************************************************************************
+    * MISC
+    ***********************************************************************************************/
+    static get routes() {
+        return {
+            postInvokeAppManager: '/invoke/apps/manager/:functionName',
+            postInvokeFunction:   '/invoke/app/function/:appId/:appVersion/:functionName',
+            postInvokeHook:       '/invoke/app/hook/:appId/:appVersion/:hookName',
+            getOpenApi:           '/openapi.json'
+        }
+    }
+
+
+    async #invokeAppAction(actionType) {
+        const { appId,
+                appVersion,
+                userContext,
+                appManifest } = this.params;
+        const actionName      = this.params[`${actionType.toLowerCase()}Name`];
+        const actionArgs      = this.params[`${actionType.toLowerCase()}Args`];
+        const context         = this.appManager.context(userContext);
+        const actionHandler   = `handle${actionType}Call`;
+        const resp            = await context[actionHandler](appId,
+                                                             appVersion,
+                                                             appManifest,
+                                                             actionName,
+                                                             actionArgs);
+        await this.render(resp);
+    }
+}
+
+
+module.exports = { AppController };

package/lib/server/server.js

@@ -0,0 +1,73 @@
+const { AppServerAppManager } = require('../apps/appManager/appServerAppManager');
+const   swaggerUi             = require("swagger-ui-express");
+const { VidaServer, logger }  = require('@vida-global/core');
+
+
+class AppServer extends VidaServer{
+    #appManager;
+    #apps;
+
+    constructor({ apps, useMocks=true }) {
+        super(...arguments);
+        this.#appManager = new AppServerAppManager({ apps, useMocks });
+    }
+
+
+    buildController(controllerCls, request, response) {
+        const controller      = super.buildController(...arguments);
+        controller.appManager = this.#appManager;
+        return controller;
+    }
+
+
+    setupMiddleware() {
+        super.setupMiddleware();
+        this.initializeSwaggerDocs();
+        this.use(this.contentLengthMiddleware);
+    }
+
+
+    initializeSwaggerDocs() {
+        const swaggerSpecUrl = "/openapi.json"
+        const options = {
+            swaggerOptions: {
+                url: swaggerSpecUrl
+            }
+        }
+        this.use("/api-docs", swaggerUi.serve, swaggerUi.setup(null, options))
+        this.logger.info(`API Docs available at: http://${this.host}:${this.port}/api-docs`)
+    }
+
+
+    contentLengthMiddleware(err, req, res, next) {
+        if (err.status === 413) {
+            logger.error({
+                error: err,
+                route: req.originalUrl,
+                method: req.method,
+                contentLength: req.headers['content-length'],
+                payload: req.body
+            }, 'Request entity too large');
+
+            return res.status(413).json({
+                status: 'error',
+                message: 'Request entity too large',
+                details: {
+                    maxSize: '50mb',
+                    receivedSize: req.headers['content-length']
+                }
+            });
+        }
+        next();
+    }
+
+
+    get controllerDirectories() {
+        return [__dirname];
+    }
+}
+
+
+module.exports = {
+    AppServer
+}