superuser.app 0.0.0

package/commands/up.js

@@ -0,0 +1,257 @@
+const zlib = require('zlib');
+const fs = require('fs');
+const path = require('path');
+
+const io = require('io');
+const tar = require('tar-stream');
+const { minimatch } = require('minimatch');
+
+const { Command } = require('cmnd');
+const colors = require('colors/safe');
+
+const constants = require('../helpers/constants.js');
+const SettingsManager = require('../helpers/settings_manager.js');
+const loadPackage = require('../helpers/load_package.js');
+const SUPPORTED_ENVS = ['development', 'staging', 'production'];
+const DEFAULT_IGNORE = [
+  'node_modules/',      // modules installed on deploy
+  'test/',              // tests not relevent for deploy
+  '.git',               // do not deploy git history
+  '.DS_Store',          // do not deploy macOS files
+  'package-lock.json',  // deps installed from package.json
+  'serve.instant.js'     // not used by Superuser Package Registry; irrelevant
+];
+
+function formatSize (size) {
+  const units = ['B', 'kB', 'MB', 'GB', 'TB', 'PB'];
+  let curUnit = 0;
+  while (size > 1024) {
+    size = size / 1024;
+    curUnit++;
+  }
+  let strSize = size.toFixed(2);
+  const intSize = strSize.split('.')[0];
+  let decSize = strSize.split('.')[1];
+  while (decSize.endsWith('0')) {
+    decSize = decSize.slice(0, -1);
+  }
+  return intSize + (decSize ? `.${decSize}` : '') + (units[curUnit] || 'overflowB');
+}
+
+function readFiles (base, properties, dir, data) {
+
+  dir = dir || '/';
+  data = data || [];
+  properties = properties || {};
+
+  let ignore = properties.ignore || [];
+
+  return fs.readdirSync(path.join(base, dir)).reduce((data, f) => {
+
+    let pathname = path.join(dir, f);
+    let fullpath = path.join(base, pathname);
+
+    for (let i = 0; i < ignore.length; i++) {
+      let filename = pathname.split(path.sep).join('/').slice(1);
+      let pattern = ignore[i];
+      if (minimatch(filename, pattern, {matchBase: true, dot: true})) {
+        return data;
+      }
+    }
+
+    if (fs.statSync(fullpath).isDirectory()) {
+      return readFiles(base, properties, pathname, data);
+    } else {
+      let filename = pathname[0] === path.sep ? pathname.substr(1) : pathname;
+      let buffer = fs.readFileSync(fullpath);
+      filename = filename.split(path.sep).join('/'); // Windows
+      data.push({filename: filename, buffer: buffer});
+      return data;
+    }
+
+  }, data);
+
+};
+
+class UpCommand extends Command {
+
+  constructor() {
+    super('up');
+  }
+
+  help () {
+    return {
+      description: 'Deploys your project to the Superuser Package Registry',
+      args: [],
+      flags: {
+        v: 'Verbose mode; print full details of packaging'
+      },
+      vflags: {
+        env: `Deployment environment; defaults to "development"`
+      }
+    };
+  }
+
+  async run (params) {
+
+    const settings = SettingsManager.read(true);
+    const InstantPackage = await loadPackage(params, true);
+
+    const isVerbose = params.flags.hasOwnProperty('v');
+    const env = (params.vflags.env || [])[0] || 'development';
+    if (!SUPPORTED_ENVS.includes(env)) {
+      throw new Error(`env must be one of: "${SUPPORTED_ENVS.join('", "')}"`);
+    }
+
+    let functJSON;
+    let packageJSON;
+
+    try {
+      functJSON = require(path.join(process.cwd(), 'superuser.json'));
+    } catch (e) {
+      console.error(e);
+      console.error(new Error('Invalid "superuser.json" in this directory'));
+      process.exit(1);
+    }
+
+    // override name from CLI
+    const name = (params.flags.n || [''])[0].trim() || functJSON.name;
+
+    try {
+      packageJSON = require(path.join(process.cwd(), 'package.json'));
+    } catch (e) {
+      console.error(e);
+      console.error(new Error('Invalid "package.json" in this directory'));
+      process.exit(1);
+    }
+
+    console.log();
+    console.log(`Packaging "${colors.bold(name)}" (${colors.bold.grey(env)})...`);
+    console.log();
+
+    !fs.existsSync('/tmp') && fs.mkdirSync('/tmp');
+    !fs.existsSync('/tmp/ibot') && fs.mkdirSync('/tmp/ibot', 0o777);
+    const tmpName = name.replace(/\//g, '.');
+    const tmpPath = `/tmp/ibot/${tmpName}.${new Date().valueOf()}.tar.gz`;
+
+    const t0 = new Date().valueOf();
+
+    const tarball = fs.createWriteStream(tmpPath, {mode: 0o777});
+    const pack = tar.pack();
+
+    let ignore = DEFAULT_IGNORE.slice();
+    if (fs.existsSync(path.join(process.cwd(), '.ibotignore'))) {
+      ignore = ignore.concat(
+        fs.readFileSync(path.join(process.cwd(), '.ibotignore')).toString()
+          .split('\n')
+          .map(line => line.trim())
+          .filter(line => !!line && !line.trim().startsWith('#'))
+      );
+    }
+    ignore = ignore.map(v => v.endsWith('/') ? `${v}*` : v);
+    const data = readFiles(process.cwd(), {ignore: ignore});
+
+    // pipe the pack stream to your file
+    pack.pipe(tarball);
+
+    // Run everything in parallel...
+    let fileCount = 0;
+    let fileSize = 0;
+    await Promise.all(data.map(file => {
+      return new Promise((resolve, reject) => {
+        isVerbose && console.log(`Packaging: "${file.filename}" (${formatSize(file.buffer.byteLength)}) ...`);
+        fileSize += file.buffer.byteLength;
+        fileCount++;
+        pack.entry(
+          {name: file.filename},
+          file.buffer,
+          (err, result) => {
+            if (err) {
+              reject(err);
+            } else {
+              resolve(result);
+            }
+          }
+        )
+      });
+    }));
+    isVerbose && console.log();
+
+    pack.finalize();
+    const result = await new Promise(resolve => {
+      tarball.on('close', () => {
+        const buffer = fs.readFileSync(tmpPath);
+        fs.unlinkSync(tmpPath);
+        const result = zlib.gzipSync(buffer);
+        resolve(result);
+      });
+    });
+
+    const packageSize = result.byteLength;
+    const t = new Date().valueOf() - t0;
+    console.log(`Packaged ${fileCount} files (${formatSize(fileSize)}) in ${t} ms!`);
+    console.log(`Final tarball: ${formatSize(packageSize)} (${((packageSize / fileSize) * 100).toFixed(2)}% compression ratio, lower is better)`);
+    console.log();
+
+    const host = settings.activeProfile.host || constants.BASE_URL;
+    console.log(`Deploying to ${colors.bold(host)} ...`);
+    console.log();
+    const upResult = await new Promise(async (resolve) => {
+      await io.post(
+        `${host}/v1/packages`,
+        settings.activeProfile.key,
+        null,
+        {
+          name: name,
+          environment: env,
+          timeout: Math.max(1, Math.min(parseInt(functJSON.timeout) || 0), 900),
+          tarball: {_base64: result.toString('base64')},
+          _stream: true
+        },
+        ({event, data, id}) => {
+          if (event === '@response') {
+            let json;
+            try {
+              json = JSON.parse(data.body);
+              data.data = json;
+            } catch (e) {
+              // do nothing;
+            }
+            resolve(data);
+          } else if (event === 'log') {
+            console.log(`${colors.bold.grey(`Deploy:`)} ${data}`);
+          }
+        }
+      );
+    });
+
+    if (upResult.statusCode !== 200) {
+      if (upResult.data && upResult.data.error && upResult.data.error.message) {
+        throw new Error(upResult.data.error.message);
+      } else {
+        throw new Error(`Invalid response from server: statusCode ${upResult.statusCode}`);
+      }
+    } else if (upResult.data?.packageVersions?.[0]?.packageDeployments?.[0]?.error_json) {
+      const errorJSON = upResult.data?.packageVersions[0].packageDeployments[0].error_json;
+      const error = new Error(errorJSON.message);
+      if (errorJSON.details) {
+        error.details = errorJSON.details;
+      }
+      throw error;
+    }
+
+    const url = upResult.data.version_urls[env];
+    const time = new Date().valueOf() - t0;
+
+    console.log();
+    console.log(`${colors.bold.green('Success:')} ${colors.bold(name)} deployed to ${colors.bold.grey(env)} in ${time} ms!`);
+    console.log(` => ${colors.bold.blue(url)}`);
+    console.log();
+
+    return void 0;
+
+  }
+
+}
+
+module.exports = UpCommand;

package/commands/update.js

@@ -0,0 +1,84 @@
+const { Command } = require('cmnd');
+
+const childProcess = require('child_process');
+const colors = require('colors/safe');
+const semver = require('semver');
+
+const loadPackage = require('../helpers/load_package.js');
+const verifyPackages = require('../helpers/verify_packages.js');
+
+class UpdateCommand extends Command {
+
+  constructor() {
+    super('update');
+  }
+
+  help () {
+    return {
+      description: 'Updates all installed dependencies to latest version',
+      args: [],
+      flags: {},
+      vflags: {
+        'force-local': 'Forces a re-installation of all local dependencies',
+        'force': 'Forces a re-installation of all dependencies (includes the CLI)'
+      }
+    };
+  }
+
+  async run (params) {
+
+    console.log();
+    console.log(colors.black.bold(`Info:`) + ` Retrieving current package details...`);
+    console.log();
+
+    const verifiedPackages = await verifyPackages();
+
+    console.log(verifiedPackages);
+
+    const updatePackages = verifiedPackages.filter(pkg => pkg.latest && semver.gt(pkg.latest, pkg.version));
+    const globalPackages = (params.vflags['force'])
+      ? verifiedPackages.filter(pkg => pkg.global)
+      : updatePackages.filter(pkg => pkg.global);
+    const localDevPackages = (params.vflags['force'] || params.vflags['force-local'])
+      ? verifiedPackages.filter(pkg => pkg.dev)
+      : updatePackages.filter(pkg => pkg.dev);
+    const localPackages = (params.vflags['force'] || params.vflags['force-local'])
+      ? verifiedPackages.filter(pkg => !pkg.global && !pkg.dev)
+      : updatePackages.filter(pkg => !pkg.global && !pkg.dev);
+
+    if (globalPackages.length) {
+      const result = childProcess.spawnSync(`npm i ${globalPackages.map(pkg => `${pkg.name}@latest`).join(' ')} -g`, {stdio: 'inherit', shell: true});
+      if (result.status !== 0) {
+        throw new Error(`Error installing global dependencies`);
+      }
+      console.log();
+      console.log(colors.bold.green(`Installed:`) + ` ${globalPackages.length} global packages\n${globalPackages.map(pkg => ` - ${pkg.name}@${pkg.latest}`).join('\n')}`);
+    }
+    if (localDevPackages.length) {
+      const result = childProcess.spawnSync(`npm i ${localDevPackages.map(pkg => `${pkg.name}@latest`).join(' ')} --save-dev`, {stdio: 'inherit', shell: true});
+      if (result.status !== 0) {
+        throw new Error(`Error installing local devDependencies`);
+      }
+      console.log();
+      console.log(colors.bold.green(`Installed:`) + ` ${localPackages.length} local devDependencies\n${localPackages.map(pkg => ` - ${pkg.name}@${pkg.latest}`).join('\n')}`);
+    }
+    if (localPackages.length) {
+      const result = childProcess.spawnSync(`npm i ${localPackages.map(pkg => `${pkg.name}@latest`).join(' ')}`, {stdio: 'inherit', shell: true});
+      if (result.status !== 0) {
+        throw new Error(`Error installing local dependencies`);
+      }
+      console.log();
+      console.log(colors.bold.green(`Installed:`) + ` ${localPackages.length} local dependencies\n${localPackages.map(pkg => ` - ${pkg.name}@${pkg.latest}`).join('\n')}`);
+    }
+
+    console.log();
+    console.log(colors.bold.green(`Up to date!`) + ` All of your ${colors.bold.green('Superuser Package')} dependencies are up to date.`);
+    console.log();
+
+    return void 0;
+
+  }
+
+}
+
+module.exports = UpdateCommand;

package/commands/version.js

@@ -0,0 +1,31 @@
+const { Command } = require('cmnd');
+
+const verifyPackages = require('../helpers/verify_packages.js');
+
+class VersionCommand extends Command {
+
+  constructor() {
+    super('version');
+  }
+
+  help () {
+    return {
+      description: 'Retrieves the current version of installed dependencies',
+      args: [],
+      flags: {},
+      vflags: {}
+    };
+  }
+
+  async run (params) {
+
+    const verifiedPackages = await verifyPackages();
+    console.log(verifiedPackages);
+
+    return void 0;
+
+  }
+
+}
+
+module.exports = VersionCommand;

package/helpers/constants.js

@@ -0,0 +1,3 @@
+module.exports = {
+  BASE_URL: 'https://api.instant.chat'
+};

package/helpers/draw_box.js

@@ -0,0 +1,38 @@
+const colors = require('colors/safe');
+
+const stripColors = str => str.replace(/[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, '');
+
+module.exports = {
+  center: (color, ...text) => {
+    colorize = colors[color] || (v => v);
+    let lines = text.join('\n').split('\n')
+      .map(line => stripColors(line).length % 2 === 0 ? line : line + ' ');
+    let maxLength = Math.max.apply(Math, lines.map(line => stripColors(line).length));
+    let minPad = 2;
+    let length = maxLength + minPad * 2;
+    return [].concat(
+      colorize(`╔` + `═`.repeat(length) + `╗`),
+      lines.map(line => {
+        let count = (length - stripColors(line).length) / 2;
+        return colorize(`║`) + ` `.repeat(count) + line + ` `.repeat(count) + colorize(`║`);
+      }),
+      colorize(`╚` + `═`.repeat(length) + `╝`)
+    ).join('\n');
+  },
+  left: (color, ...text) => {
+    colorize = colors[color] || (v => v);
+    let lines = text.join('\n').split('\n')
+      .map(line => stripColors(line).length % 2 === 0 ? line : line + ' ');
+    let maxLength = Math.max.apply(Math, lines.map(line => stripColors(line).length));
+    let minPad = 2;
+    let length = maxLength + minPad * 2;
+    return [].concat(
+      colorize(`╔` + `═`.repeat(length) + `╗`),
+      lines.map(line => {
+        let count = length - stripColors(line).length - minPad;
+        return colorize(`║`) + ` `.repeat(minPad) + line + ` `.repeat(count) + colorize(`║`);
+      }),
+      colorize(`╚` + `═`.repeat(length) + `╝`),
+    ).join('\n');
+  }
+};

package/helpers/draw_table.js

@@ -0,0 +1,144 @@
+const inquirer = require('inquirer');
+const colors = require('colors/safe');
+
+const stripColors = str => str.replace(/[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, '');
+
+const renderLine = (columns, rows, index, color) => {
+  const columnData = columns.map(columnName => {
+    const colLength = stripColors(columnName + '').length;
+    const maxLength = rows.reduce((max, row) => {
+      return Math.max(stripColors(row[columnName] + '').length, max);
+    }, colLength);
+    return {
+      name: columnName,
+      maxLength
+    };
+  });
+  const outlineColorize = colors.reset[color] || colors.reset;
+  const colorize = colors[color] || (v => v);
+  const minPad = 1;
+  if (index === 'top') {
+    return (
+      outlineColorize(`╒`) +
+      columnData.map(c => {
+        return outlineColorize(`═`.repeat(c.maxLength + minPad * 2))
+      }).join(outlineColorize('╤')) +
+      outlineColorize(`╕`) + '\n' +
+      outlineColorize(`  │`) +
+      columnData.map(c => {
+        const item = c.name + '';
+        return Array(minPad).fill(' ').join('') +
+          item +
+          Array(c.maxLength - item.length + 1).fill(' ').join('');
+      }).join(outlineColorize('│')) +
+      outlineColorize(`│`) + '\n' +
+      outlineColorize(`  ╞`) +
+      columnData.map(c => {
+        return outlineColorize(`═`.repeat(c.maxLength + minPad * 2));
+      }).join(outlineColorize('╪')) +
+      outlineColorize(`╡`)
+    );
+  } else if (index === 'bottom') {
+    return (
+      outlineColorize(`└`) +
+      columnData.map(c => {
+        return outlineColorize(`─`.repeat(c.maxLength + minPad * 2));
+      }).join(outlineColorize('┴')) +
+      outlineColorize(`┘`)
+    );
+  } else if (index === 'middle') {
+    return (
+      outlineColorize(`├`) +
+      columnData.map(c => {
+        return outlineColorize(`─`.repeat(c.maxLength + minPad * 2));
+      }).join(outlineColorize('┼')) +
+      outlineColorize(`┤`)
+    );
+  } else if (index === 'bottom-cancel') {
+    return (
+      outlineColorize(`└`) +
+      columnData.map(c => {
+        return outlineColorize(`─`.repeat(c.maxLength + minPad * 2));
+      }).join(outlineColorize('─')) +
+      outlineColorize(`┘`)
+    );
+  } else if (index === 'middle-cancel') {
+    return (
+      outlineColorize(`├`) +
+      columnData.map(c => {
+        return outlineColorize(`─`.repeat(c.maxLength + minPad * 2));
+      }).join(outlineColorize('┴')) +
+      outlineColorize(`┤`)
+    );
+  } else if (index === -1) {
+    const length = Math.max(0, columnData.reduce((sum, c) => {
+      return sum + (c.maxLength + minPad * 2 + 1); // outline
+    }, -(1 + minPad * 2))); // -2 for left / right minPad
+    const item = `${colors.bold.red('x')} cancel`;
+    return (
+      colorize(`│`) +
+      Array(minPad).fill(' ').join('') +
+      item + 
+      Array(length - stripColors(item).length).fill(' ').join('') +
+      Array(minPad).fill(' ').join('') +
+      colorize(`│`)
+    );
+  } else {
+    return (
+      colorize(`│`) +
+      columnData.map(c => {
+        const item = rows[index][c.name] + '';
+        return Array(minPad).fill(' ').join('') +
+          item +
+          Array(c.maxLength - stripColors(item).length + 1).fill(' ').join('');
+      }).join(colorize('│')) +
+      colorize(`│`)
+    );
+  }
+};
+
+module.exports = {
+  render: (columns, rows, color = 'grey') => {
+    console.log([].concat(
+      '  ' + renderLine(columns, rows, 'top', color),
+      rows.map((row, i) => {
+        return '  ' + renderLine(columns, rows, i, color);
+      }),
+      '  ' + renderLine(columns, rows, 'bottom', color)
+    ).join('\n'));
+    return true;
+  },
+  selectIndexFromTable: async (title, columns, rows, color = 'grey') => {
+    const result = await inquirer.prompt([
+      {
+        name: 'index',
+        type: 'list',
+        message: title,
+        loop: false,
+        pageSize: 100,
+        choices: [].concat(
+          new inquirer.Separator(
+            renderLine(columns, rows, 'top', color)
+          ),
+          rows.map((_, i) => {
+            return {
+              name: renderLine(columns, rows, i, color),
+              value: i
+            }
+          }),
+          new inquirer.Separator(
+            renderLine(columns, rows, 'middle-cancel', color)
+          ),
+          {
+            name: renderLine(columns, rows, -1, color),
+            value: -1
+          },
+          new inquirer.Separator(
+            renderLine(columns, rows, 'bottom-cancel', color)
+          )
+        )
+      }
+    ]);
+    return result.index;
+  }
+};

package/helpers/file_writer.js

@@ -0,0 +1,101 @@
+const fs = require('fs');
+const path = require('path');
+const colors = require('colors/safe');
+
+module.exports = {
+
+  readRecursive (root, files = {}, prefix = '', pathname = '') {
+    files = files || {};
+    let filenames = fs.readdirSync(path.join(root, pathname));
+    filenames.forEach(filename => {
+      let filepath = [pathname, filename].join('/');
+      let fullpath = path.join(root, filepath);
+      let stat = fs.statSync(fullpath);
+      if (stat.isDirectory()) {
+        this.readRecursive(root, files, prefix, filepath);
+      } else {
+        files[`${prefix}${filepath}`] = fs.readFileSync(fullpath);
+      }
+    });
+    return files;
+  },
+
+  writeFile (filename, buffer, overwrite = true, validate = false) {
+    if (filename.startsWith('/')) {
+      filename = `.${filename}`;
+    }
+    if (!filename.startsWith('.')) {
+      filename = `./${filename}`;
+    }
+    // e.g. __.gitignore becomes .gitignore
+    // this prevents unintended behavior in this repo from .env, .gitignore files and more
+    filename = filename.replaceAll('/__.', '/.');
+    console.log(colors.bold.black(`FileWriter:`) +  ` Writing file "${filename}" ...`);
+    let paths = filename.split('/').slice(1, -1);
+    for (let i = 1; i <= paths.length; i++) {
+      let pathname = paths.slice(0, i).join('/');
+      if (!fs.existsSync(pathname)) {
+        fs.mkdirSync(pathname);
+      }
+    }
+    if (!overwrite) {
+      if (fs.existsSync(path.join('.', filename))) {
+        if (validate) {
+          throw new Error(`Could not write, file already exists: "${filename}"`);
+        } else {
+          console.log(colors.bold.black(`FileWriter:`) + colors.yellow(` Warn: Skipped "${filename}" (already exists)`));
+          return false;
+        }
+      }
+    }
+    fs.writeFileSync(path.join('.', filename), buffer);
+    return true;
+  },
+
+  writeLine (filename = '', line) {
+    console.log(colors.bold.black(`FileWriter:`) + ` Writing line "${line}" to "${filename}"`);
+    const exists = fs.existsSync(filename);
+    let fileString = '';
+    if (exists) {
+      fileString = fs.readFileSync(filename).toString();
+    }
+    let lines = fileString.split('\n')
+      .map(l => l.trim())
+      .filter(l => !!l);
+    if (!lines.find(l => l === line)) {
+      lines.push(line);
+    }
+    fs.writeFileSync(filename, lines.join('\n'));
+  },
+
+  writeJSON (filename, key, value, keepValueIfExists = false) {
+    console.log(colors.bold.black(`FileWriter:`) + ` Writing [${key}=${JSON.stringify(value)}] to JSON file "${filename}"`);
+    const exists = fs.existsSync(filename);
+    let json = {};
+    if (exists) {
+      let fileString = fs.readFileSync(filename).toString();
+      try {
+        json = JSON.parse(fileString);
+      } catch (e) {
+        throw new Error(`Could not write, invalid JSON: "${filename}"`);
+      }
+      if (!json || typeof json !== 'object' || Array.isArray(json)) {
+        throw new Error(`Could not write, JSON not an object: "${filename}"`);
+      }
+    }
+    let keys = key.split('.');
+    let writeKey = keys.pop();
+    let obj = json;
+    while (keys.length) {
+      let curKey = keys.shift();
+      obj[curKey] = obj[curKey] || {};
+      obj = obj[curKey];
+    }
+    if (!(writeKey in obj) || !keepValueIfExists) {
+      obj[writeKey] = value;
+    }
+    fs.writeFileSync(filename, JSON.stringify(json, null, 2));
+    return true;
+  }
+
+};