@mytmpvpn/mytmpvpn-cli 1.1.0

package/src/mytmpvpn.ts

@@ -0,0 +1,349 @@
+#!/usr/bin/env -S NODE_NO_WARNINGS=1 node
+// Use NODE_NO_WARNINGS=1 to get rid of the fetch node deprecated API
+//  https://github.com/netlify/cli/issues/4608 -- but it hangs the process: https://github.com/nodejs/node/issues/21960
+import * as fs from 'fs'
+import * as path from 'path'
+import { Argument, Command, Option } from 'commander'
+import * as log from 'loglevel'
+log.setDefaultLevel("info")
+
+import * as vpnlib from '@mytmpvpn/mytmpvpn-common/models/vpn'
+import * as peanuts from '@mytmpvpn/mytmpvpn-common/models/peanuts'
+import { getDefaultAppConfigFile, loadAppConfig } from '@mytmpvpn/mytmpvpn-client/appconfig'
+import { getDefaultUserConfigFile, getDefaultUserProfile, getDefaultUserConfigDir, loadUserConfig, UserConfig } from '@mytmpvpn/mytmpvpn-client/userconfig'
+import * as auth from '@mytmpvpn/mytmpvpn-client/auth'
+import { MyTmpVpnClient } from '@mytmpvpn/mytmpvpn-client/mytmpvpn-client'
+
+const program = new Command()
+
+function handleError(error: any, verbose: boolean = false) {
+  if (error.response) {
+    // The request was made and the server responded with a status code
+    // that falls out of the range of 2xx
+    try {
+      log.error(`[${error.response.status}] - ${JSON.stringify(error.response.data)}`)
+    } catch (Error) {
+      log.error(`[${error.response.status}] - ${JSON.stringify(error.message)}`)
+    }
+
+    log.debug(error.response.headers)
+  } else if (error.request) {
+    // The request was made but no response was received
+    // `error.request` is an instance of XMLHttpRequest in the browser and an instance of
+    // http.ClientRequest in node.js
+    log.error(`No reponse received. Check your profile and your appConfig`)
+  } else {
+    // Something happened in setting up the request that triggered an Error
+    log.error(`Error while setting up the request ${JSON.stringify(error)}`)
+  }
+  log.trace(`Stack trace: ${error}`)
+}
+
+program
+  .name('mytmpvpn-cli')
+  .description('MyTmpVpn CLI')
+  .version('0.0.1')
+  .option('--verbose', 'Produce more logs')
+  .option('--appConfig <file>', 'Path to the application config file', getDefaultAppConfigFile())
+  .option('--userConfig <file>', 'Path to the user config file', getDefaultUserConfigFile())
+  .option('--profile <name>', 'Name of the profile in the user config file to use', getDefaultUserProfile())
+program.on('option:verbose', function () {
+  log.setDefaultLevel("trace")
+})
+
+program.command('list-peanuts-packs')
+  .description(`Returns the list of peanuts packs you can purchase. A peanuts pack contains a given number of peanuts. You need a minimum of ${peanuts.PEANUTS_CONFIG.min} peanuts to create a vpn`)
+  .action((_, command) => {
+    const options = command.optsWithGlobals()
+    const appConfig = loadAppConfig(options.appConfig)
+    // We don't need authenticated user to call this API
+    const client = new MyTmpVpnClient(appConfig.apiUrl)
+    client.listPeanutsPacks()
+      .then(((packs: peanuts.PeanutsPack[]) => {
+        log.info(JSON.stringify(packs, null, 2))
+      }))
+      .catch((err) => handleError(err))
+  })
+
+program.command('get-peanuts-balance')
+  .description('Get the current peanuts balance')
+  .action((_, command) => {
+    const options = command.optsWithGlobals()
+    log.debug(`Get peanuts balance`)
+    auth.getLoggedInClientFromFiles({ appConfigFile: options.appConfig, userConfigFile: options.userConfig, profileName: options.profile }, (err, client) => {
+      if (err) {
+        handleError(err, options.verbose)
+        return
+      }
+      client.getPeanutsBalance().then(balance => {
+        log.info(balance)
+      }).catch(err => {
+        handleError(err)
+      })
+    })
+  })
+
+  program.command('list-regions')
+  .description('Returns the list of all regions where vpn can be created')
+  .action((_, command) => {
+    const options = command.optsWithGlobals()
+    const appConfig = loadAppConfig(options.appConfig)
+    // We don't need authenticated user to call this API
+    const client = new MyTmpVpnClient(appConfig.apiUrl)
+    client.listRegions()
+      .then(((regions: any) => {
+        log.info(JSON.stringify(regions, null, 2))
+      }))
+      .catch((err) => handleError(err))
+  })
+
+
+program.command('create')
+  .description('Create a new vpn')
+  .argument('<region>', 'region where the vpn should be created, as returned by list-regions')
+  .option('--sync', 'wait for vpn creation completion')
+  .addOption(new Option('--type <type>', 'Type of VPN')
+    .choices(vpnlib.getVpnConfigTypes())
+    .default(vpnlib.VpnType.WireGuard))
+  .option('--peanuts <nb>', 'Max number of peanuts to use (specify -1 for maximum)', '-1')
+  .action((region: string, _, command) => {
+    const options = command.optsWithGlobals()
+    const syncStr = options.sync ? "synchronously" : "asynchronously"
+    log.debug(`Creating new ${options.type} vpn into ${region} ${syncStr}`)
+    auth.getLoggedInClientFromFiles({ appConfigFile: options.appConfig, userConfigFile: options.userConfig, profileName: options.profile }, (err, client) => {
+      if (err) {
+        handleError(err, options.verbose)
+        return
+      }
+      client.createVpn(region, { type: options.type, maxPeanuts: options.peanuts }).then(vpn => {
+        if (!options.sync) {
+          log.info(vpn)
+          return
+        }
+        client.waitUntilVpnStateIs(vpn.vpnId, vpnlib.VpnState.Running).then(updatedVpn => {
+          log.info(updatedVpn)
+        }).catch(err => {
+          handleError(err)
+        })
+      }).catch(err => {
+        handleError(err)
+      })
+    })
+  })
+
+
+program.command('delete')
+  .description('Delete a vpn')
+  .argument('<vpnId>', 'vpnId to delete')
+  .option('--sync', 'wait for vpn deletion completion')
+  .action((vpnId, _, command) => {
+    const options = command.optsWithGlobals()
+    const syncStr = options.sync ? "synchronously" : "asynchronously"
+    log.debug(`Deleting vpn ${vpnId} ${syncStr}`)
+    auth.getLoggedInClientFromFiles({ appConfigFile: options.appConfig, userConfigFile: options.userConfig, profileName: options.profile }, (err, client) => {
+      if (err) {
+        handleError(err.message || JSON.stringify(err))
+        return
+      }
+      client.deleteVpn(vpnId).then(vpn => {
+        if (!options.sync) {
+          log.info(JSON.stringify(vpn))
+          return
+        }
+        client.waitUntilVpnStateIs(vpnId, vpnlib.VpnState.Deleted).then(updatedVpn => {
+          log.info(updatedVpn)
+          return
+        }).catch(err => {
+          handleError(err.response?.data || JSON.stringify(err))
+        })
+      }).catch(err => {
+        handleError(err.response?.data || JSON.stringify(err))
+      })
+    })
+  })
+
+program.command('get')
+  .description('Get information on a vpn')
+  .argument('<vpnId>', 'vpnId to get information from')
+  .action((vpnId, _, command) => {
+    const options = command.optsWithGlobals()
+    auth.getLoggedInClientFromFiles({ appConfigFile: options.appConfig, userConfigFile: options.userConfig, profileName: options.profile }, (err, client) => {
+      if (err) {
+        handleError(err)
+        return
+      }
+      client.getVpn(vpnId)
+        .then(result => log.info(result))
+        .catch(err => handleError(err))
+    })
+  })
+
+program.command('download-config')
+  .description('Download configuration of the given vpn to the given file')
+  .argument('<vpnId>', 'vpnId to get config file from')
+  .option('--file <file>', 'file where the config should be downloaded to. Default is <vpnId>.tar.gz')
+  .option('--path <path>', 'path where the config file should be written to', getDefaultUserConfigDir())
+  .action((vpnId, _, command) => {
+    const options = command.optsWithGlobals()
+    const file = options.file ? options.file : `${vpnId}.tar.gz`
+    const fullpath = path.join(options.path, file)
+    auth.getLoggedInClientFromFiles({ appConfigFile: options.appConfig, userConfigFile: options.userConfig, profileName: options.profile }, (err, client) => {
+      if (err) {
+        handleError(err)
+        return
+      }
+      client.getVpnConfig(vpnId, fs.createWriteStream(fullpath))
+        .then(() => log.info(fullpath))
+        .catch(err => handleError(err))
+    })
+  })
+
+program.command('list')
+  .description('List all vpns')
+  .option('--region <region>', 'region to list vpns from')
+  .option('--exclude-state <state>', 'state to exclude from the list', 'DELETED')
+  .action((_, command) => {
+    const options = command.optsWithGlobals()
+    auth.getLoggedInClientFromFiles({ appConfigFile: options.appConfig, userConfigFile: options.userConfig, profileName: options.profile }, (err, client) => {
+      if (err) {
+        handleError(err)
+        return
+      }
+      client.listVpns(options.state)
+        .then(vpns => {
+          log.info(JSON.stringify(vpns, null, 2))
+        })
+        .catch(err => handleError(err))
+    })
+  })
+
+program.command('wait')
+  .description('Wait for vpn operation completion')
+  .argument('<vpnId>', 'the vpnId to wait a status change for')
+  .argument('<state>', 'the state to wait for')
+  .action((vpnId, state: keyof typeof vpnlib.VpnState, _, command) => {
+    const options = command.optsWithGlobals()
+    const actualState = vpnlib.VpnState[state]
+    if (!actualState) {
+      handleError(`Unknown state: ${state}. Valid states: ${Object.values(vpnlib.VpnState)}`)
+      return
+    }
+    log.debug(`Waiting for ${vpnId} state to be (at least) ${state}`)
+    auth.getLoggedInClientFromFiles({ appConfigFile: options.appConfig, userConfigFile: options.userConfig, profileName: options.profile }, (err, client) => {
+      if (err) {
+        handleError(err)
+        return
+      }
+      client.waitUntilVpnStateIs(vpnId, actualState)
+        .then(vpn => {
+          log.info(vpn)
+        })
+        .catch(err => handleError(err))
+    })
+  })
+
+program.command('register')
+  .description('Register a new user to the MyTmpVpn application')
+  .argument('<username>', 'the email/phone that will identify your account')
+  .argument('<password>', 'a password')
+  .action((username, password, _, command) => {
+    const options = command.optsWithGlobals()
+    var userConfig: UserConfig
+    if (fs.existsSync(options.userConfig)) {
+      userConfig = loadUserConfig(options.userConfig)
+      if (userConfig.profiles[options.profile]) {
+        handleError(`Profile ${options.profile}  already exists in ${options.userConfig}, specify another profile name using --profile`)
+        return
+      }
+      userConfig.profiles[options.profile] = {
+        username: username,
+        password: password
+      }
+    } else {
+      userConfig = {
+        version: 1,
+        profiles: {
+          default: {
+            username: username,
+            password: password
+          }
+        }
+      }
+    }
+    auth.registerUserFromFiles(options.appConfig, username, password, (err, result) => {
+      if (err) {
+        handleError(err)
+        return
+      }
+      log.info(`Please confirm your identity with the code sent to ${username}`)
+      fs.mkdir(path.dirname(options.userConfig), { recursive: true }, (err, path?) => {
+        if (err) {
+          handleError(err)
+          return
+        }
+        log.debug(`Directory: ${path} created`)
+        fs.writeFile(options.userConfig, JSON.stringify(userConfig, null, 2), (err) => {
+          if (err) {
+            handleError(err)
+            return
+          }
+        })
+        log.info(`A new profile has been created for ${options.profile} in ${options.userConfig}`)
+      })
+    })
+  })
+
+program.command('confirm-registration')
+  .description('Confirm registration to the MyTmpVpn application using the code that was sent to email/phone')
+  .argument('<username>', 'the email/phone that identify your account')
+  .argument('<code>', 'the code received')
+  .action((username, code, _, command) => {
+    const options = command.optsWithGlobals()
+    auth.confirmUserFromFiles(options.appConfig, username, code, (err, result) => {
+      if (err) {
+        handleError(err)
+        return
+      }
+      log.debug(result)
+      log.info(`User ${username} confirmed!`)
+    })
+  })
+
+program.addHelpText('after', `
+
+Examples:
+
+  # Before doing anything, you need to register to the MyTmpVpn service:
+
+  $ mytmpvpn register 'your@email.com' 'StrongPassword'  # Min: 8 characters with digit, lower, upper and symbols
+  $ mytmpvpn confirm-registration 'code'  # The code you've received by email
+
+  # You then need to buy some peanuts, the list of peanuts packs can be fetched using:
+
+  $ mytmpvpn list-peanuts-packs
+
+  # Visit one of those URLs returned, and complete the purchase.
+  # There is no CLI for purchasing peanuts-packs.
+  # Once you have purchased some peanuts, your peanuts balance should show it:
+
+  $ mytmpvpn get-peanuts-balance
+
+  # Then you can use the following command at will:
+  
+  # List available regions:
+  $ mytmpvpn list-regions                 
+
+  # Create a new vpn in Paris:
+  $ mytmpvpn --sync create 'paris'         # This takes several minutes, please be patient or remove --sync
+
+  # List all my vpns:
+  $ mytmpvpn list
+
+  # Fetch the configuration of a given vpn
+  $ mytmpvpn download-config 'vpn-id'      # The vpn-id is provided by the list command
+
+  # Delete a given vpn 
+  $ mytmpvpn delete 'vpn-id'   # The vpn-id is provided by the list command
+`)
+
+program.parse()

package/tsconfig.json

@@ -0,0 +1,115 @@
+{
+  // this project builds all of the following:
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig to read more about this file */
+    "outDir": "dist",                                   /* Specify an output folder for all emitted files. */
+
+    // we want subprojects to inherit these options:
+    "baseUrl": ".",                                     /* Specify the base directory to resolve non-relative module names. */
+    "paths": {                                          /* Specify a set of entries that re-map imports to additional lookup locations. */
+      "mytmpvpn-cli/*": [
+        "dist/*"
+      ]
+    },
+   
+    /* Projects */
+    // "incremental": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
+    "composite": false,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
+    // "tsBuildInfoFile": "./.tsbuildinfo",              /* Specify the path to .tsbuildinfo incremental compilation file. */
+    // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */
+    // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
+    // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
+
+    /* Language and Environment */
+    "target": "ES2020",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    "lib": ["ES2020"],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+    // "jsx": "preserve",                                /* Specify what JSX code is generated. */
+    // "experimentalDecorators": true,                   /* Enable experimental support for TC39 stage 2 draft decorators. */
+    // "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
+    // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */
+    // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
+    // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */
+    // "reactNamespace": "",                             /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */
+    // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
+    // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
+    // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
+
+    /* Modules */
+    "module": "commonjs",                                /* Specify what module code is generated. */
+    // "rootDir": "./src",                                  /* Specify the root folder within your source files. */
+    // "moduleResolution": "node",                       /* Specify how TypeScript looks up a file from a given module specifier. */
+    // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
+    //"typeRoots": ["./node_modules/@types"],              /* Specify multiple folders that act like './node_modules/@types'. */
+    // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
+    // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
+    // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
+    // "resolveJsonModule": true,                        /* Enable importing .json files. */
+    // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */
+
+    /* JavaScript Support */
+    // "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
+    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
+    // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
+
+    /* Emit */
+    "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
+    // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
+    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
+    // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
+    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
+    
+    // "removeComments": true,                           /* Disable emitting comments. */
+    // "noEmit": true,                                   /* Disable emitting files from a compilation. */
+    // "importHelpers": false,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
+    // "importsNotUsedAsValues": "remove",               /* Specify emit/checking behavior for imports that are only used for types. */
+    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
+    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
+    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
+    // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
+    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
+    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
+    // "stripInternal": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
+    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */
+    // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
+    // "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
+    // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
+    // "preserveValueImports": true,                     /* Preserve unused imported values in the JavaScript output that would otherwise be removed. */
+
+    /* Interop Constraints */
+    // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
+    // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
+    // "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
+    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
+    "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
+
+    /* Type Checking */
+    "strict": true,                                      /* Enable all strict type-checking options. */
+    "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
+    "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
+    "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
+    "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
+    "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
+    "noImplicitThis": true,                           /* Enable error reporting when 'this' is given the type 'any'. */
+    "useUnknownInCatchVariables": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */
+    "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
+    "noUnusedLocals": false,                           /* Enable error reporting when local variables aren't read. */
+    "noUnusedParameters": false,                       /* Raise an error when a function parameter isn't read. */
+    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
+    "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
+    "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
+    "noUncheckedIndexedAccess": true,                 /* Add 'undefined' to a type when accessed using an index. */
+    "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
+    "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */
+    "allowUnusedLabels": false,                        /* Disable error reporting for unused labels. */
+    "allowUnreachableCode": false,                     /* Disable error reporting for unreachable code. */
+
+    /* Completeness */
+    // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
+    "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
+  },
+  "include": [
+    "src/**/*",
+    "test/**/*",
+  ],
+}