backend-manager 3.2.170 → 3.2.172

package/dist/manager/libraries/openai.js

@@ -0,0 +1,460 @@
+const fetch = require('wonderful-fetch');
+const jetpack = require('fs-jetpack');
+const powertools = require('node-powertools');
+const _ = require('lodash');
+const JSON5 = require('json5');
+
+const TOKEN_COST_TABLE = {
+  // May 13th, 2024
+  'gpt-4o': {
+    input: 0.0050,
+    output: 0.0150,
+  },
+  'gpt-4-turbo': {
+    input: 0.0100,
+    output: 0.0300,
+  },
+  'gpt-4-turbo-preview': {
+    input: 0.0100,
+    output: 0.0300,
+  },
+  'gpt-4-vision-preview': {
+    input: 0.0100,
+    output: 0.0300,
+  },
+  'gpt-4-1106-preview': {
+    input: 0.0100,
+    output: 0.0300,
+  },
+  'gpt-4': {
+    input: 0.0300,
+    output: 0.0600,
+  },
+  'gpt-3.5-turbo': {
+    input: 0.0005,
+    output: 0.0015,
+  },
+
+  // // Apr 9th, 2024
+  // 'gpt-4-turbo': {
+  //   input: 0.0100,
+  //   output: 0.0300,
+  // },
+  // 'gpt-4-turbo-preview': {
+  //   input: 0.0100,
+  //   output: 0.0300,
+  // },
+  // 'gpt-4-vision-preview': {
+  //   input: 0.0100,
+  //   output: 0.0300,
+  // },
+  // 'gpt-4-1106-preview': {
+  //   input: 0.0100,
+  //   output: 0.0300,
+  // },
+  // 'gpt-4': {
+  //   input: 0.0300,
+  //   output: 0.0600,
+  // },
+  // 'gpt-3.5-turbo': {
+  //   input: 0.0005,
+  //   output: 0.0015,
+  // },
+
+  // Mar 6th, 2024
+  // 'gpt-4-turbo-preview': {
+  //   input: 0.0100,
+  //   output: 0.0300,
+  // },
+  // 'gpt-4-vision-preview': {
+  //   input: 0.0100,
+  //   output: 0.0300,
+  // },
+  // 'gpt-4-1106-preview': {
+  //   input: 0.0100,
+  //   output: 0.0300,
+  // },
+  // 'gpt-4': {
+  //   input: 0.0300,
+  //   output: 0.0600,
+  // },
+  // 'gpt-3.5-turbo': {
+  //   input: 0.0005,
+  //   output: 0.0015,
+  // },
+
+  // Nov 6th, 2023
+  // 'gpt-4-turbo-preview': {
+  //   input: 0.0100,
+  //   output: 0.0300,
+  // },
+  // 'gpt-4-1106-preview': {
+  //   input: 0.0100,
+  //   output: 0.0300,
+  // },
+  // 'gpt-4': {
+  //   input: 0.0300,
+  //   output: 0.0600,
+  // },
+  // 'gpt-3.5-turbo': {
+  //   input: 0.0010,
+  //   output: 0.0020,
+  // },
+}
+
+const UNSUPPORTED_JSON = [
+  /gpt-3.5/,
+  /gpt-4-vision/,
+];
+
+
+function OpenAI(assistant, key) {
+  const self = this;
+
+  self.assistant = assistant;
+  self.Manager = assistant.Manager;
+  self.user = assistant.user;
+  self.key = key || self.Manager.config?.openai?.key;
+
+  self.tokens = {
+    total: {
+      count: 0,
+      price: 0,
+    },
+    input: {
+      count: 0,
+      price: 0,
+    },
+    output: {
+      count: 0,
+      price: 0,
+    },
+  }
+
+  return self;
+}
+
+OpenAI.prototype.request = function (options) {
+  const self = this;
+  const Manager = self.Manager;
+  const assistant = self.assistant;
+
+  return new Promise(async function(resolve, reject) {
+    options = _.merge({}, options);
+
+    options.model = typeof options.model === 'undefined' ? 'gpt-3.5-turbo' : options.model;
+    options.timeout = typeof options.timeout === 'undefined' ? 120000 : options.timeout;
+    options.moderate = typeof options.moderate === 'undefined' ? true : options.moderate;
+    options.log = typeof options.log === 'undefined' ? false : options.log;
+    options.user = options.user || assistant.getUser();
+
+    options.retries = typeof options.retries === 'undefined' ? 0 : options.retries;
+    options.retryTriggers = typeof options.retryTriggers === 'undefined' ? ['network', 'parse'] : options.retryTriggers;
+
+    options.prompt = options.prompt || {};
+    options.prompt.path = options.prompt.path || '';
+    options.prompt.text = options.prompt.text || options.prompt.content || '';
+    options.prompt.settings = options.prompt.settings || {};
+
+    options.message = options.message || {};
+    options.message.path = options.message.path || '';
+    options.message.text = options.message.text || options.message.content || '';
+    options.message.settings = options.message.settings || {};
+    options.message.images = options.message.images || [];
+
+    options.history = options.history || {};
+    options.history.messages = options.history.messages || [];
+    options.history.limit = typeof options.history.limit === 'undefined' ? 5 : options.history.limit;
+
+    options.response = typeof options.response === 'undefined' ? undefined : options.response;
+    options.temperature = typeof options.temperature === 'undefined' ? 0.7 : options.temperature;
+    options.maxTokens = typeof options.maxTokens === 'undefined' ? 512 : options.maxTokens;
+
+    let attempt = 0;
+
+    function _log() {
+      if (!options.log)  {
+        return;
+      }
+
+      assistant.log('callOpenAI():', ...arguments);
+    }
+
+    function _load(input) {
+      // console.log('*** input!!!', input.content.slice(0, 50), input.path);
+      // console.log('*** input.content', input.content.slice(0, 50));
+      // console.log('*** input.path', input.path);
+
+      let text = '';
+
+      // Load text
+      if (input.path) {
+        const exists = jetpack.exists(input.path);
+
+        _log('Reading prompt from path:', input.path);
+
+        if (!exists) {
+          return new Error(`Path ${input.path} not found`);
+        } else if (exists === 'dir') {
+          return new Error(`Path ${input.path} is a directory`);
+        }
+
+        try {
+          text = jetpack.read(input.path);
+        } catch (e) {
+          return new Error(`Error reading file ${input.path}: ${e}`);
+        }
+      } else {
+        text = input.text;
+      }
+
+      return powertools.template(text, input.settings).trim();
+    }
+
+    // Log
+    _log('Starting', options);
+
+    // Determine response format
+    let responseFormat = options.response === 'json' ? { type: 'json_object' } : undefined;
+    if (UNSUPPORTED_JSON.some((model) => options.model.match(model))) {
+      responseFormat = undefined;
+      assistant.warn(`Model ${options.model} does not support JSON response format`);
+    }
+
+    _log('responseFormat', responseFormat);
+
+    // Load prompt
+    const prompt = _load(options.prompt);
+    const message = _load(options.message);
+    const user = options.user?.auth?.uid || assistant.request.geolocation.ip;
+
+    // Log
+    _log('Prompt', prompt);
+    _log('Message', message);
+    _log('User', user);
+
+    // Check for errors
+    if (prompt instanceof Error) {
+      return reject(assistant.errorify(`Error loading prompt: ${prompt}`, {code: 400}));
+    }
+
+    if (message instanceof Error) {
+      return reject(assistant.errorify(`Error loading message: ${message}`, {code: 400}));
+    }
+
+    // Request
+    function _request(mode, options) {
+      return new Promise(async function(resolve, reject) {
+        let resultPath = '';
+        const request = {
+          url: '',
+          method: 'post',
+          response: 'json',
+          // response: 'raw',
+          // log: true,
+          attachResponseHeaders: true,
+          tries: 1,
+          timeout: options.timeout,
+          headers: {
+            'Authorization': `Bearer ${self.key}`,
+          },
+          body: {},
+        }
+
+        if (mode === 'chatgpt') {
+          request.url = 'https://api.openai.com/v1/chat/completions';
+
+          // Get history
+          const history = options.history.messages.slice(-options.history.limit);
+
+          // Add prompt to history
+          history.unshift({
+            role: 'system',
+            text: prompt,
+            images: [],
+          });
+
+          // Set last history item
+          const lastHistory = history[history.length - 1];
+
+          // If message is different than last message in history, add it
+          if (lastHistory?.text !== message) {
+            history.push({
+              role: 'user',
+              text: message,
+              images: options.message.images,
+            });
+          }
+
+          // Format history
+          history.map((m) => {
+            m.role = m.role || 'system';
+
+            m.content = [];
+
+            // Set content
+            if (m.text) {
+              m.content.push({
+                type: 'text',
+                text: m.text,
+              })
+            }
+
+            // Set images
+            m.images = m.images || [];
+
+            // Loop through and add
+            m.images.forEach((i) => {
+              if (i.url) {
+                m.content.push({
+                  type: 'image_url',
+                  image_url: {
+                    url: i.url,
+                    detail: i.detail || 'low',
+                  }
+                });
+              }
+            }),
+
+            // Delete text and images
+            delete m.text;
+            delete m.images;
+          })
+
+          // Log message
+          history.forEach((m) => {
+            _log('Message', m.role, m.content);
+          });
+
+          request.body = {
+            model: options.model,
+            response_format: responseFormat,
+            messages: history,
+            temperature: options.temperature,
+            max_tokens: options.maxTokens,
+            user: user,
+          }
+          resultPath = 'choices[0].message.content';
+        } else if (mode === 'moderation') {
+          request.url = 'https://api.openai.com/v1/moderations';
+          request.body = {
+            input: message,
+            user: user,
+          }
+          resultPath = 'results[0]';
+        }
+
+        // Request
+        await fetch(request.url, request)
+        .then(async (r) => {
+          // Set token counts
+          self.tokens.input.count += r?.usage?.prompt_tokens || 0;
+          self.tokens.output.count += r?.usage?.completion_tokens || 0;
+          self.tokens.total.count = self.tokens.input.count + self.tokens.output.count;
+
+          // Set token prices
+          self.tokens.input.price = (self.tokens.input.count / 1000) * TOKEN_COST_TABLE[options.model].input;
+          self.tokens.output.price = (self.tokens.output.count / 1000) * TOKEN_COST_TABLE[options.model].output;
+          self.tokens.total.price = self.tokens.input.price + self.tokens.output.price;
+
+          // Return
+          return resolve(_.get(r, resultPath));
+        })
+        .catch((e) => {
+          return reject(e);
+        })
+      });
+    }
+
+    // Moderate if needed
+    let moderation = null;
+    if (options.moderate) {
+      moderation = await _request('moderation', options)
+      .then(async (r) => {
+        _log('Moderated', r);
+
+        return r;
+      })
+      .catch((e) => e);
+
+      // Check for moderation flag
+      if (moderation.flagged) {
+        return reject(assistant.errorify(`This request is inappropriate`, {code: 451}));
+      }
+    }
+
+    function _attempt() {
+      const retries = options.retries;
+      const triggers = options.retryTriggers;
+
+      // Increment attempt
+      attempt++;
+
+      // Log
+      _log(`Request ${attempt}/${retries}`);
+
+      // Request
+      _request('chatgpt', options)
+      .then((r) => {
+        _log('Response', r);
+        _log('Tokens', self.tokens);
+
+        // Try to parse JSON response if needed
+        try {
+          const content = options.response === 'json' ? JSON5.parse(r) : r;
+
+          // Return
+          return resolve({
+            content: content,
+            tokens: self.tokens,
+            moderation: moderation,
+          })
+        } catch (e) {
+          assistant.error('Error parsing response', r, e);
+
+          // Retry
+          if (attempt < retries && triggers.includes('parse')) {
+            return _attempt();
+          }
+
+          // Return
+          return reject(e);
+        }
+      })
+      .catch((e) => {
+        const parsed = tryParse(e.message)?.error || {};
+        const type = parsed?.type || '';
+        const message = parsed?.message || e.message;
+
+        // Log
+        assistant.error(`Error requesting (type=${type}, message=${message})`, e);
+
+        // Check for invalid request error
+        if (type === 'invalid_request_error') {
+          return reject(assistant.errorify(message, {code: 400}));
+        }
+
+        // Retry
+        if (attempt < retries && triggers.includes('network')) {
+          return _attempt();
+        }
+
+        // Return
+        return reject(e);
+      });
+    }
+
+    // Make attempt
+    _attempt();
+  });
+}
+
+function tryParse(content) {
+  try {
+    return JSON5.parse(content);
+  } catch (e) {
+    return content;
+  }
+}
+
+module.exports = OpenAI;

package/dist/manager/routes/restart/index.js

@@ -0,0 +1,52 @@
+function Route() {
+  const self = this;
+
+  return self;
+}
+
+Route.prototype.main = async function (assistant) {
+  const self = this;
+
+  // Set shortcuts
+  const Manager = assistant.Manager;
+  const usage = assistant.usage;
+  const user = assistant.usage.user;
+  const analytics = assistant.analytics;
+  const settings = assistant.settings;
+
+  // Load preloaded libraries
+  const jetpack = require('fs-jetpack');
+
+  // Send analytics event
+  analytics.event({
+    name: 'restart',
+    params: {},
+  });
+
+  // Check for user authentication
+  // if (!user.roles.admin) {
+  //   return assistant.respond(`Admin required`, {code: 401});;
+  // }
+
+  // Log
+  assistant.log('Restarting...');
+
+  // Remove node_modules
+  jetpack.remove('node_modules');
+
+  // Perform delayed refresh to allow a successful response
+  setTimeout(function () {
+    require('child_process').exec('refresh', (error, stdout, stderr) => {
+      // Quit the process if there is an error
+      if (error || stderr) {
+        console.log(`error: ${error ? error.message : stderr}`);
+        return process.exit(1);
+      }
+    });
+  }, 1000);
+
+  // Return success
+  assistant.respond({success: true});
+};
+
+module.exports = Route;

package/dist/manager/routes/test/index.js

@@ -0,0 +1,43 @@
+function Route() {
+  const self = this;
+
+  return self;
+}
+
+Route.prototype.main = async function (assistant) {
+  const self = this;
+
+  // Set shortcuts
+  const Manager = assistant.Manager;
+  const usage = assistant.usage;
+  const user = assistant.usage.user;
+  const analytics = assistant.analytics;
+  const settings = assistant.settings;
+
+  // Load preloaded libraries
+  // ..
+
+  // Send analytics event
+  analytics.event({
+    name: 'test',
+    params: {},
+  });
+
+  // Check for user authentication
+  // if (!user.roles.admin) {
+  //   return assistant.respond(`Admin required`, {code: 401});;
+  // }
+
+  // Log
+  assistant.log('Running test');
+  assistant.log('assistant.request.body', assistant.request.body);
+  assistant.log('assistant.request.query', assistant.request.query);
+  assistant.log('assistant.request.headers', assistant.request.headers);
+  assistant.log('assistant.request.data', assistant.request.data);
+  assistant.log('assistant.settings', assistant.settings);
+
+  // Return success
+  assistant.respond({timestamp: new Date().toISOString(), id: assistant.id});
+};
+
+module.exports = Route;

package/dist/manager/schemas/restart.js

@@ -0,0 +1,13 @@
+module.exports = function (assistant) {
+  return {
+    // DEFAULTS
+    ['defaults']: {
+      // Common
+      delay: {
+        types: ['number'],
+        default: 1000,
+        value: undefined,
+      },
+    },
+  };
+}

package/dist/manager/schemas/test.js

@@ -0,0 +1,13 @@
+module.exports = function (assistant) {
+  return {
+    // DEFAULTS
+    ['defaults']: {
+      // Common
+      delay: {
+        types: ['number'],
+        default: 1000,
+        value: undefined,
+      },
+    },
+  };
+}

package/dist/require.js

@@ -0,0 +1,3 @@
+module.exports = function (lib) {
+  return require(lib)
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backend-manager",
-  "version": "3.2.170",
+  "version": "3.2.172",
   "description": "Quick tools for developing Firebase functions",
   "main": "src/manager/index.js",
   "bin": {
@@ -13,7 +13,9 @@
     "test:usage": "./node_modules/mocha/bin/mocha test/usage.js --timeout=10000",
     "test:payment-resolver": "./node_modules/mocha/bin/mocha test/payment-resolver.js --timeout=10000",
     "test:user": "./node_modules/mocha/bin/mocha test/user.js --timeout=10000",
-    "start": "node src/index.js"
+    "start": "node src/index.js",
+    "prepare": "node -e \"require('prepare-package')()\"",
+    "prepare:watch": "nodemon -w ./src -e '*' --exec 'npm run prepare'"
   },
   "engines": {
     "node": "16"
@@ -33,6 +35,11 @@
     "url": "https://github.com/itw-creative-works/backend-manager/issues"
   },
   "homepage": "https://itwcreativeworks.com",
+  "preparePackage": {
+    "input": "./src",
+    "output": "./dist",
+    "replace": {}
+  },
   "dependencies": {
     "@firebase/rules-unit-testing": "^2.0.7",
     "@google-cloud/storage": "^7.11.2",
@@ -51,7 +58,7 @@
     "glob": "^10.4.2",
     "hcaptcha": "^0.1.1",
     "inquirer": "^8.2.5",
-    "itwcw-package-analytics": "^1.0.3",
+    "itwcw-package-analytics": "^1.0.4",
     "json5": "^2.2.3",
     "jwt-decode": "^3.1.2",
     "lodash": "^4.17.21",
@@ -62,19 +69,22 @@
     "moment": "^2.30.1",
     "nanoid": "^3.3.7",
     "node-fetch": "^2.7.0",
-    "node-powertools": "^1.4.3",
+    "node-powertools": "^1.4.4",
     "npm-api": "^1.0.1",
-    "paypal-server-api": "^2.0.12",
+    "paypal-server-api": "^2.0.14",
     "pushid": "^1.0.0",
-    "resolve-account": "^1.0.24",
+    "resolve-account": "^1.0.25",
     "semver": "^7.6.2",
     "shortid": "^2.2.16",
-    "sizeitup": "^1.0.8",
+    "sizeitup": "^1.0.9",
     "uid-generator": "^2.0.0",
     "ultimate-jekyll-poster": "^1.0.2",
     "uuid": "^9.0.1",
-    "wonderful-fetch": "^1.1.11",
-    "wonderful-log": "^1.0.6",
+    "wonderful-fetch": "^1.1.12",
+    "wonderful-log": "^1.0.7",
     "yargs": "^17.7.2"
+  },
+  "devDependencies": {
+    "prepare-package": "^1.1.12"
   }
 }