superuser.app 0.0.0

package/helpers/generate/endpoint/_index.js

@@ -0,0 +1,44 @@
+const fs = require('fs');
+const path = require('path');
+
+const colors = require('colors/safe');
+
+const fileWriter = require('../../file_writer.js');
+
+const generateTest = require('../test/_index.js');
+
+module.exports = async (InstantPackage, params) => {
+
+  let writePathname = params.args[0] || '';
+  writePathname = writePathname.split('/').filter(v => !!v).join('/');
+
+  let newFilename;
+
+  const pathname = path.join(__dirname, '..', '..', '..', 'src', 'endpoint');
+  if (!fs.existsSync(pathname)) {
+    throw new Error(`No endpoint template found.`);
+  }
+
+  console.log();
+  console.log(colors.bold.black(`Generating:`) + ` Endpoint file ...`);
+  console.log();
+
+  const files = fileWriter.readRecursive(pathname);
+  for (const filename in files) {
+    newFilename = filename;
+    newFilename = newFilename.replace(/^\/functions\//gi, $0 => $0 + (writePathname ? `${writePathname}/` : ``));
+    let fileData = files[filename];
+    fileWriter.writeFile(newFilename, fileData, false);
+  }
+
+  console.log();
+  console.log(colors.bold.green(`Success!`) + ` Created blank endpoint at "${newFilename}"!`);
+  console.log();
+
+  if (!params.vflags.hasOwnProperty('no-tests')) {
+    await generateTest(InstantPackage, {args: [], flags: {}, vflags: {endpoint: [newFilename]}});
+  }
+
+  return true;
+
+};

package/helpers/generate/test/_index.js

@@ -0,0 +1,112 @@
+const fs = require('fs');
+const path = require('path');
+
+const colors = require('colors/safe');
+
+const fileWriter = require('../../file_writer.js');
+
+module.exports = async (InstantPackage, params) => {
+
+  let testName = params.args[0] || '';
+  testName = testName.split('/').filter(v => !!v).join('/');
+  testName = testName.replace(/\.m?js$/gi, '');
+
+  let endpointFor = ((params.vflags.endpoint || [])[0] || '');
+
+  if (testName) {
+
+    const pathname = path.join(__dirname, '..', '..', '..', 'src', 'test', 'blank.js');
+    if (!fs.existsSync(pathname)) {
+      throw new Error(`No test template found for model.`);
+    }
+
+    let fileString = fs.readFileSync(pathname).toString();
+    fileString = fileString.replaceAll('Name', testName);
+
+    let newFilename = `test/tests/${testName}.js`;
+    const fileData = Buffer.from(fileString);
+    fileWriter.writeFile(newFilename, fileData, false);
+
+    console.log();
+    console.log(colors.bold.green(`Success!`) + ` Created tests for "${colors.bold.green(testName)}"!`);
+    console.log();
+
+  } else if (endpointFor) {
+
+    const pathname = path.join(__dirname, '..', '..', '..', 'src', 'test', 'endpoint.js');
+    if (!fs.existsSync(pathname)) {
+      throw new Error(`No test template found for endpoint.`);
+    }
+    if (!endpointFor.startsWith('/')) {
+      endpointFor = `/${endpointFor}`;
+    }
+    if (endpointFor.startsWith('/functions/')) {
+      endpointFor = endpointFor.slice('/functions'.length);
+    }
+    endpointFor = endpointFor.replace(/\.m?js$/, '');
+    let functionPathname = path.join(process.cwd(), `functions`, `${endpointFor}.js`);
+    if (!fs.existsSync(functionPathname)) {
+      functionPathname = path.join(process.cwd(), `functions`, `${endpointFor}.js`);
+      if (!fs.existsSync(functionPathname)) {
+        throw new Error(`Could not find matching endpoint "${endpointFor}" in "./functions" directory`);
+      }
+    }
+
+    let methods = [];
+    let endpointPath;
+    if (endpointFor.endsWith('/index')) {
+      endpointPath = endpointFor.slice(0, -('/index').length) + '/';
+    } else if (endpointFor.endsWith('/__main__')) {
+      endpointPath = endpointFor.slice(0, -('/__main__').length) + '/';
+    } else if (endpointFor.endsWith('/__notfound__')) {
+      endpointPath = endpointFor.slice(0, -('/__notfound__').length) + '/*/';
+    } else if (endpointFor.endsWith('/404')) {
+      endpointPath = endpointFor.slice(0, -('/404').length) + '/*/';
+    } else {
+      endpointPath = endpointFor + '/';
+    }
+
+    const file = fs.readFileSync(pathname);
+    let fileString = file.toString();
+    let template = '';
+    fileString = fileString.replaceAll('Pathname', endpointPath);
+    fileString = fileString.replace(/(\n)([ \t]*)\/\/ Method Begin\s*?\n([\s\S]*?)\/\/ Method End[ \t]*(\n)/gi, ($0, $1, $2, $3, $4) => {
+      template = $2 + $3.trim();
+      return `${$1}/* *** */${$4}`;
+    });
+
+    const dotenv = require(path.join(process.cwd(), `node_modules`, `dotenv`));
+    dotenv.config();
+    const endpoint = await import(functionPathname);
+
+    if ('default' in endpoint) {
+      methods.push('POST');
+    } else {
+      ('GET' in endpoint) && methods.push('GET');
+      ('POST' in endpoint) && methods.push('POST');
+      ('PUT' in endpoint) && methods.push('PUT');
+      ('DELETE' in endpoint) && methods.push('DELETE');
+    }
+
+    fileString = fileString.replace(
+      '/* *** */',
+      methods.map(method => {
+        return template
+          .replaceAll('Method', method)
+          .replaceAll('__method__', method === `DELETE` ? `del` : method.toLowerCase());
+      }).join('\n\n')
+    );
+
+    let newFilename = `test/tests/functions${endpointFor}.js`;
+    const fileData = Buffer.from(fileString);
+    fileWriter.writeFile(newFilename, fileData, false);
+
+    console.log();
+    console.log(colors.bold.green(`Success!`) + ` Created tests for "${colors.bold.green(endpointFor)}"!`);
+    console.log();
+
+  }
+
+  return true;
+
+};

package/helpers/load_package.js

@@ -0,0 +1,62 @@
+const https = require('https');
+const path = require('path');
+const fs = require('fs');
+
+const verifyPackages = require('./verify_packages.js');
+
+module.exports = async (params = null, validate = false) => {
+
+  if (validate) {
+    await verifyPackages(true);
+  }
+
+  let toolpkg;
+  const toolPathname = path.join(process.cwd(), 'superuser.json');
+  if (!fs.existsSync(toolPathname)) {
+    if (validate) {
+      throw new Error(
+        `No "superuser.json" in this directory. Are you sure you meant to do this?\n` +
+        `Run \`$ ibot init\` to initialize a project here if you are.`
+      );
+    }
+  } else {
+    toolpkg = JSON.parse(fs.readFileSync(toolPathname));
+  }
+
+  let dotenv;
+  const dotenvPathname = path.join(process.cwd(), 'node_modules', 'dotenv');
+  if (!fs.existsSync(dotenvPathname)) {
+    if (validate) {
+      throw new Error(
+        `dotenv should be installed in this directory to use Superuser Package locally.\n` +
+        `Run \`$ npm i dotenv --save-dev\` to install the latest version`
+      );
+    }
+  } else {
+    dotenv = require(dotenvPathname);
+  }
+
+  let InstantAPI;
+  const pathname = path.join(process.cwd(), 'node_modules', '@instant.dev/api');
+  if (!fs.existsSync(pathname)) {
+    if (validate) {
+      throw new Error(
+        `@instant.dev/api should be installed in this directory to use Superuser Package locally.\n` +
+        `Run \`$ npm i @instant.dev/api --save-dev\` to install the latest version`
+      );
+    }
+  } else {
+    InstantAPI = require(pathname);
+  }
+
+  if (
+    toolpkg &&
+    dotenv &&
+    InstantAPI
+  ) {
+    return { toolpkg, dotenv, InstantAPI };
+  } else {
+    return null;
+  }
+
+};

package/helpers/local_server.js

@@ -0,0 +1,72 @@
+const colors = require('colors/safe');
+const fs = require('fs');
+const childProcess = require('child_process');
+
+module.exports = {
+  run: ({port = null, isBackground = false} = {}) => {
+    const consoleLog = (...args) => !isBackground && console.log(...args);
+    consoleLog();
+    consoleLog(`Running ${colors.green.bold('Superuser Package')} development server ...`);
+    const pkgExists = fs.existsSync('package.json');
+    if (pkgExists) {
+      let pkg;
+      try {
+        pkg = JSON.parse(fs.readFileSync('package.json').toString());
+      } catch (e) {
+        throw new Error(`Could not read "package.json"`);
+      }
+      if (pkg?.scripts?.start) {
+        consoleLog(`Running script: ${colors.blue.bold(pkg.scripts.start)} ...`);
+        const envVars = {...process.env};
+        if (!fs.existsSync('.env')) {
+          consoleLog(
+            colors.bold.yellow(`Warn: `) +
+            `No envFile found in ".env", no environment variables loaded ...`
+          );
+        } else {
+          const lines = fs.readFileSync(`.env`)
+            .toString()
+            .split('\n')
+            .filter(line => !!line.trim() && !line.trim().startsWith('#'));
+          for (const line of lines) {
+            const key = line.split('=')[0];
+            const value = line.split('=').slice(1).join('=');
+            envVars[key] = value;
+            consoleLog(`Loading environment variable: ${colors.grey.bold(key)} ...`);
+          }
+        }
+        consoleLog();
+        if (isBackground) {
+          return childProcess.spawn(
+            pkg.scripts.start,
+            {
+              stdio: 'pipe',
+              shell: true,
+              env: {
+                ...envVars,
+                PORT: port || envVars.PORT || '',
+                DISABLE_HOT_RELOAD: 'true'
+              }
+            }
+          );
+        } else {
+          return childProcess.spawnSync(
+            pkg.scripts.start,
+            {
+              stdio: 'inherit',
+              shell: true,
+              env: {
+                ...envVars,
+                PORT: port || envVars.PORT || ''
+              }
+            }
+          );
+        }
+      } else {
+        throw new Error(`Could not find "package.json"["scripts"]["start"]`);
+      }
+    } else {
+      throw new Error(`No "package.json" in this directory`);
+    }
+  }
+};

package/helpers/settings_manager.js

@@ -0,0 +1,108 @@
+const os = require('os');
+const fs = require('fs');
+const path = require('path');
+
+const SETTINGS_FILENAME = '~/.ibotrc';
+
+const parsePathname = (pathname) => {
+  if (!pathname) {
+    pathname = './';
+  }
+  if (
+    !pathname.startsWith('~/') &&
+    !pathname.startsWith('./') &&
+    !pathname.startsWith('/')
+  ) {
+    pathname = './' + pathname;
+  }
+  if (pathname.startsWith('~/')) {
+    pathname = os.homedir().split(path.sep).join('/') + pathname.slice(1);
+  } else if (pathname.startsWith('./') || pathname.startsWith('../')) {
+    pathname = process.cwd().split(path.sep).join('/') + '/' + pathname;
+  }
+  return path.resolve(pathname);
+}
+
+function readSettings (validate = false) {
+  const pathname = parsePathname(SETTINGS_FILENAME);
+  if (!fs.existsSync(pathname)) {
+    fs.writeFileSync(pathname, '');
+  }
+  if (fs.statSync(pathname).isDirectory()) {
+    throw new Error(`Invalid settings file, is a directory: "${pathname}"`);
+  }
+  const file = fs.readFileSync(pathname);
+  const fileString = file.toString().replace(/\r/gi, '').trim();
+  const profileList = [];
+  if (fileString) {
+    const lines = fileString.split('\n');
+    for (const line of lines) {
+      if (line === '[profile]') {
+        profileList.push({});
+      } else if (!profileList.length) {
+        throw new Error(`Settings must start with [profile]`);
+      } else {
+        const values = line.split('=');
+        const key = values[0];
+        const value = values.slice(1).join('=');
+        profileList[profileList.length - 1][key] = value;
+      }
+    }
+  }
+  let curProfile;
+  let i = 0;
+  for (const profile of profileList) {
+    if (!profile.email) {
+      throw new Error(`Profile index ${i} missing "email"`);
+    }
+    if (!profile.key) {
+      throw new Error(`Profile index ${i} missing "key"`);
+    }
+    i++;
+  }
+  if (validate && !profileList[0]) {
+    throw new Error(`You are not logged in. Try \`ibot login\` to log in first.`);
+  }
+  return {
+    activeProfile: profileList[0],
+    profileList
+  }
+}
+
+function writeSettings (newProfile) {
+  if (!newProfile.email) {
+    throw new Error(`Must specify newProfile "email"`);
+  } else if (!newProfile.key) {
+    throw new Error(`Must specify newProfile "key"`);
+  }
+  const settings = readSettings();
+  const activeProfile = newProfile;
+  const profileList = [].concat(
+    activeProfile,
+    settings.profileList.filter(p => p.email !== newProfile.email)
+  );
+  const pathname = parsePathname(SETTINGS_FILENAME);
+  fs.writeFileSync(
+    pathname,
+    profileList.map(p => {
+      return [
+        `[profile]`,
+        `email=${p.email}`,
+        `key=${p.key}`,
+        p.host ? `host=${p.host}` : ''
+      ].filter(line => !!line.trim()).join('\n');
+    }).join('\n') + '\n'
+  );
+  console.log(`Settings: Set profile(email=${activeProfile.email}) as active in "${pathname}"`);
+  console.log(`Settings: Total of ${profileList.length} saved profiles`);
+  console.log();
+  return {
+    activeProfile,
+    profileList
+  };
+}
+
+module.exports = {
+  read: readSettings,
+  write: writeSettings
+};

package/helpers/verify_packages.js

@@ -0,0 +1,85 @@
+const colors = require('colors/safe');
+const semver = require('semver');
+
+const path = require('path');
+const https = require('https');
+
+const drawBox = require('./draw_box.js');
+
+module.exports = async (print = false) => {
+
+  const pkgs = {self: require('../package.json')};
+  try {
+    pkgs.api = require(path.join(process.cwd(), '/node_modules/@instant.dev/api/package.json'));
+  } catch (e) {
+    // do nothing:
+    // @instant.dev/api not installed locally
+  }
+  const packages = [
+    {
+      title: 'Superuser Package CLI',
+      name: pkgs.self.name,
+      version: pkgs.self.version,
+      global: true
+    },
+    {
+      title: 'Superuser Package Gateway (Instant API)',
+      name: pkgs.api ? pkgs.api.name : null,
+      version: pkgs.api ? pkgs.api.version : null,
+      dev: true
+    }
+  ];
+  const checkPackages = packages.filter(pkg => !!pkg.name);
+  const verifiedPackages = await Promise.all(
+    checkPackages.map(pkg => {
+      return (async () => {
+        try {
+          const response = await new Promise((resolve, reject) => {
+            const req = https.request(`https://registry.npmjs.org/${pkg.name}/latest`, res => {
+              const buffers = [];
+              res.on('data', data => buffers.push(data));
+              res.on('end', () => resolve(Buffer.concat(buffers)));
+            })
+            req.on('error', err => reject(err));
+            req.end();
+          });
+          const json = JSON.parse(response.toString());
+          pkg.latest = json.version;
+          return pkg;
+        } catch (e) {
+          // we want to be able to use CLI offline
+          // or if NPM is down / returning bad data
+          // so just set latest equal to version
+          pkg.latest = pkg.version;
+          return pkg;
+        }
+      })();
+    })
+  );
+  const updatePackages = verifiedPackages.filter(pkg => pkg.latest && semver.gt(pkg.latest, pkg.version));
+  if (updatePackages.length && print) {
+    console.log();
+    console.log(
+      drawBox.center(
+        `yellow`,
+        ``,
+        `Updates are available for ${colors.bold('ibot')}:`,
+        ``,
+        ...updatePackages.map(pkg => {
+          return [
+            pkg.title,
+            `${pkg.version} -> ${colors.bold.green(pkg.latest)}`,
+            `${colors.bold.grey(`npm i ${pkg.name}@latest${pkg.dev ? ' --save-dev' : ''}${pkg.global ? ' -g' : ''}`)}`,
+            ``
+          ].join('\n')
+        }),
+        `Install all with:`,
+        `${colors.bold.grey(`ibot update`)}`,
+        ``
+      )
+    );
+  }
+
+  return verifiedPackages;
+
+};

package/index.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+
+const { CommandLineInterface } = require('cmnd');
+const CLI = new CommandLineInterface('Superuser Package CLI');
+
+CLI.load(__dirname, './commands');
+CLI.run(process.argv.slice(2));

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "superuser.app",
+  "version": "0.0.0",
+  "description": "Superuser package manager: command line interface for building toolkits for your agents",
+  "main": "index.js",
+  "files": [
+    "/commands",
+    "/helpers",
+    "/src"
+  ],
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "bin": {
+    "sup": "index.js"
+  },
+  "author": "Keith Horwood",
+  "license": "MIT",
+  "dependencies": {
+    "cmnd": "^0.4.1",
+    "colors": "^1.4.0",
+    "i": "^0.3.7",
+    "inquirer": "^8.2.6",
+    "io": "^1.5.0",
+    "minimatch": "^9.0.4",
+    "semver": "^7.5.4",
+    "tar-stream": "^3.1.7",
+    "tree-kill": "^1.2.2"
+  },
+  "keywords": []
+}

package/src/endpoint/functions/index.js

@@ -0,0 +1,35 @@
+/**
+ * GET
+ */
+export async function GET (context) {
+
+  return `HTTP GET!`;
+
+};
+
+/**
+ * POST
+ */
+export async function POST (context) {
+
+  return `HTTP POST!`;
+
+}
+
+/**
+ * PUT
+ */
+export async function PUT (context) {
+
+  return `HTTP PUT!`;
+
+};
+
+/**
+ * DELETE
+ */
+export async function DELETE (context) {
+
+  return `HTTP DELETE!`;
+
+};

package/src/init/__.env

@@ -0,0 +1 @@
+MY_SECRET=development_secret

package/src/init/__.env.production

@@ -0,0 +1 @@
+MY_SECRET=production_secret

package/src/init/__.env.staging

@@ -0,0 +1 @@
+MY_SECRET=staging_secret

package/src/init/__.gitignore

@@ -0,0 +1,6 @@
+node_modules/
+.DS_Store
+.env
+.env.staging
+.env.production
+package-lock.json

package/src/init/functions/index.js

@@ -0,0 +1,15 @@
+/**
+ * Sample welcome API
+ * We can provide types to our APIs to enforce type-safety
+ *   at the HTTP request (@param) and response (@returns) layer
+ * @param {string} username 
+ * @returns {object}  welcomeMessage
+ * @returns {string}  welcomeMessage.message
+ */
+export async function GET (username = 'new user') {
+
+  return {
+    message: `Welcome to Superuser, ${username}!`
+  };
+
+};

package/src/init/instant.package.json

@@ -0,0 +1,3 @@
+{
+  "name": "@user/project"
+}

package/src/init/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@/not_npm_project",
+  "private": false,
+  "type": "module",
+  "scripts": {
+    "start": "node serve.instant.js",
+    "test": "mocha test/run.js"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@instant.dev/api": "latest",
+    "dotenv": "latest",
+    "mocha": "latest",
+    "chai": "latest"
+  }
+}

package/src/init/serve.instant.js

@@ -0,0 +1,52 @@
+/**
+ * This file is ** NOT ** used in production on the Superuser Package Registry
+ * Any code you change here ** WILL NOT ** run when hosted with Superuser Package
+ * 
+ * However, it used for local development and allows you to ship your Superuser Package
+ * service to any host which relies on `package.json["scripts"]["start"]`.
+ */
+
+// Third-party imports
+import InstantAPI from '@instant.dev/api';
+import dotenv from 'dotenv';
+
+// Native imports
+import cluster from 'cluster';
+import os from 'os';
+
+// Shorthand references
+const Daemon = InstantAPI.Daemon;
+const Gateway = InstantAPI.Daemon.Gateway;
+const EncryptionTools = InstantAPI.EncryptionTools;
+
+// Constants
+const ENVIRONMENT = process.env.NODE_ENV || 'development';
+const PORT = process.env.PORT || 8100;
+
+if (cluster.isPrimary) {
+
+  // Multi-process daemon
+  const daemon = new Daemon(
+    ENVIRONMENT !== 'development'
+      ? os.cpus().length
+      : 1,
+    'SuperuserDaemon'
+  );
+  daemon.start(PORT);
+
+} else {
+
+  // Individual webserver startup
+  const gateway = new Gateway({
+    name: 'SuperuserDaemon.Gateway',
+    debug: ENVIRONMENT !== 'production'
+  });
+  // Optional: Enable Sentry or another error reporting tool
+  // gateway.setErrorHandler(err => Sentry.captureException(err));
+  const et = new EncryptionTools();
+  dotenv.config();                   // load env vars
+  et.decryptProcessEnv(process.env); // decrypt env vars, if necessary
+  gateway.load(process.cwd());       // load routes from filesystem
+  gateway.listen(PORT);              // start server
+
+}