@rpcbase/cli 0.37.0 → 0.39.0

package/bin.js

@@ -23,6 +23,11 @@ yargs(hideBin(process.argv))
         default: false,
         description: "Adds coverage instrumentation (always disabled in production)"
       })
+      .option("docker", {
+        type: "boolean",
+        default: false,
+        description: "Run in docker"
+      })
       .option("verbose", {
         type: "boolean",
         default: false,
@@ -34,7 +39,6 @@ yargs(hideBin(process.argv))
         description: "Run with debug logging"
       })
   }, (argv) => {
-    console.log("IS start")
     if (argv.version) return print_versions()
     start_command(argv)
   })
@@ -51,16 +55,24 @@ yargs(hideBin(process.argv))
     await update()
   })
   // sync-dotenv
-  .command(["sync-dotenv"], "Compare and sync dotenv files", (yargs) => {
+  .command("sync-dotenv [source_env] [dest_env]", "Compare and sync dotenv files", (yargs) => {
     yargs
       .option("write", {
         type: "boolean",
         default: false,
         description: "Write the ouput to dest env file"
       })
+      .positional("source_env", {
+        describe: "source .env file",
+        type: "string"
+      })
+      .positional("dest_env", {
+        describe: "destination env file",
+        type: "string"
+      })
   }, async(argv) => {
     if (argv.version) return print_versions()
-    await sync_dotenv()
+    await sync_dotenv(argv.source_env, argv.dest_env)
   })
   // Ping
   .command("ping", "Ping", () => {}, (argv) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rpcbase/cli",
-  "version": "0.37.0",
+  "version": "0.39.0",
   "license": "SSPL-1.0",
   "bin": {
     "rb": "./bin.js"

package/src/helpers/docker_runtime_check.js

@@ -3,14 +3,8 @@ const {execSync} = require("child_process")
 const os = require("os")
 const colors = require("picocolors")
 
-const {CONTAINER_MODE} = process.env
 
 const docker_runtime_check = () => {
-  // skip check on osx except when forcing docker
-  if (os.platform() === "darwin" && CONTAINER_MODE !== "docker") {
-    return
-  }
-
   try {
     execSync("docker version -f json")
   } catch (err) {

package/src/helpers/get_run_configs.js

@@ -5,13 +5,8 @@ const fs = require("fs")
 const ERRORS = require("../errors")
 const exit_with_message = require("./exit_with_message")
 
-const {CONTAINER_MODE} = process.env
-
 // run type is client | server | both
-const get_run_configs = () => {
-  if (!["docker", "native"].includes(CONTAINER_MODE.trim()))
-    throw new Error("expected CONTAINER_MODE to be native|docker")
-
+const get_run_configs = (args) => {
   const cwd = process.cwd()
 
   // check if running parent of rb project
@@ -62,8 +57,9 @@ const get_run_configs = () => {
 
   if (run_configs) {
     // check if there is server we add agent but in native mode only
+    // in docker mode, the agent is a container
     const server = run_configs.find((rc) => rc.type === "server")
-    if (server && CONTAINER_MODE === "native") {
+    if (server && !args.docker) {
       run_configs.push({
         type: "agent",
         working_dir: server.working_dir,

package/src/helpers/tailscale_tunnel.js

@@ -35,7 +35,7 @@ const start = (run_configs) => {
     execSync(`${TAILSCALE_PATH} serve https:443 / http://127.0.0.1:${server_port}`, {stdio: "inherit"})
     execSync(`${TAILSCALE_PATH} funnel 443 on`, {stdio: "inherit"})
   } catch (err) {
-    console.log("TAILSCALE ERR", err)
+    console.log("error starting tailscale, is the tailscale app running ?")
   }
 }
 
@@ -49,7 +49,8 @@ const stop = (run_configs) => {
     execSync(`${TAILSCALE_PATH} serve https:443 / http://127.0.0.1:${server_port} off`, {stdio: "inherit"})
     execSync(`${TAILSCALE_PATH} funnel 443 off`, {stdio: "inherit"})
   } catch (err) {
-    console.log("TAILSCALE ERR", err)
+    // console.log("TAILSCALE ERR", err)
+    console.log("error stopping tailscale, it probably wasn't initally running. you can probably ignore it")
   }
 }
 

package/src/start_command.js

@@ -18,7 +18,7 @@ const verify_project = require("./verify_project")
 // server native + docker + docker-native is way too complex
 // either everything is native, or everything is in docker
 const start_command = async(args) => {
-  const run_configs = get_run_configs()
+  const run_configs = get_run_configs(args)
 
   const run_commands = []
 
@@ -49,7 +49,6 @@ const start_command = async(args) => {
       command = `${command} ${hideBin(process.argv).join(" ")}`
     }
 
-
     // add command
     run_commands.push({
       name,
@@ -62,9 +61,8 @@ const start_command = async(args) => {
 
   const has_server = run_configs.findIndex((c) => c.type === "server") > -1
 
-  // TODO: we shouldnt check in native mode
   // check if docker is running
-  if (has_server) {
+  if (args.docker) {
     docker_runtime_check()
   }
 

package/src/sync-dotenv/index.js

@@ -1,137 +1,125 @@
+/* @flow */
 const path = require("path")
 const fs = require("fs")
 const os = require('os')
-const parseEnv = require("parse-dotenv")
-const dotenv = require("dotenv")
+const parse_env = require("parse-dotenv")
+
 
 const DEFAULT_ENV_PATH = path.resolve(process.cwd(), ".env")
-const DEFAULT_SAMPLE_ENV = path.resolve(process.cwd(), ".env.sample")
+const SAMPLE_ENV_SUFFIX = ".sample"
+const COMMENT_PREFIX = "__COMMENT_"
 
-const envToString = (parsed) =>
+const env_to_string = (parsed) =>
   Object.keys(parsed)
     .map(key => `${key}=${parsed[key] || ""}`)
     .join(os.EOL)
     .replace(/(__\w+_\d+__=)/g, "")
 
-const writeToSampleEnv = (path, parsedEnv) => {
+
+const write_to_dest_env = (path, parsed_env) => {
   try {
-    fs.writeFileSync(path, envToString(parsedEnv))
+    fs.writeFileSync(path, env_to_string(parsed_env))
   } catch (e) {
     throw new Error(`Sync failed. ${e.message}`)
   }
 }
 
-const emptyObjProps = (obj) => {
-  const objCopy = { ...obj }
-  Object.keys(objCopy).forEach(key => {
-    if (objCopy[key].includes("#")) {
-      if (objCopy[key].match(/(".*"|'.*')/g)) {
-        const objArr = objCopy[key].split(/(".*"|'.*')/)
-        objCopy[key] = objArr.slice(-1)[0].trim()
+
+const get_empty_obj_props = (obj) => {
+
+  const obj_copy = { ...obj }
+
+  Object.keys(obj_copy).forEach(key => {
+    if (obj_copy[key].includes("#")) {
+      if (obj_copy[key].match(/(".*"|'.*')/g)) {
+        const objArr = obj_copy[key].split(/(".*"|'.*')/)
+        obj_copy[key] = objArr.slice(-1)[0].trim()
       } else {
-        const objArr = objCopy[key].split("#")
-        objCopy[key] = `#${objArr.slice(-1)[0]}`
+        const objArr = obj_copy[key].split("#")
+        obj_copy[key] = `#${objArr.slice(-1)[0]}`
       }
 
       return
     }
 
-    if (!key.startsWith("__COMMENT_")) {
-      objCopy[key] = ""
+    if (!key.startsWith(COMMENT_PREFIX)) {
+      obj_copy[key] = ""
     }
   })
 
-  return objCopy
+  return obj_copy
 }
 
-const getUniqueVarsFromEnvs = (
+const get_unique_vars_from_envs = (
   env,
-  envExample,
+  env_example,
   config = {}
 ) => {
-  const ignoreKeys = config.preserve || []
-
-  const uniqueKeys = new Set(Object.keys(env))
-  const uniqueKeysArray = Array.from(uniqueKeys)
+  const unique_keys = new Set(Object.keys(env))
+  const unique_keys_list = Array.from(unique_keys)
 
-  const uniqueFromSource = uniqueKeysArray.map((key) => {
-    if (key.startsWith("__COMMENT_")) return { [key]: env[key] }
-    return { [key]: envExample[key] || "" }
+  const unique_from_source = unique_keys_list.map((key) => {
+    if (key.startsWith(COMMENT_PREFIX)) return { [key]: env[key] }
+    return { [key]: env_example[key] || "" }
   })
 
-  const presevedVars = Object.keys(envExample)
-    .map(key => ({ [key]: envExample[key] }))
+  const preseved_vars = Object.keys(env_example)
+    .map(key => ({ [key]: env_example[key] }))
     // .filter(env => {
     //   console.log("ICICIC", env)
     //   return ignoreKeys.length && ignoreKeys.includes(Object.keys(env)[0])
     // })
 
-  return [...uniqueFromSource, ...presevedVars]
+  return [...unique_from_source, ...preseved_vars]
 }
 
 
-const syncWithSampleEnv = (
-  envPath,
-  envExamplePath
+const sync_with_dest_env = (
+  env_path,
+  env_example_path
 ) => {
   const config = { emptyLines: true, comments: true }
 
-  const sourceEnv = emptyObjProps(
-    parseEnv(envPath, config)
+  const source_env = get_empty_obj_props(
+    parse_env(env_path, config)
   )
-  const targetEnv = parseEnv(envExamplePath)
 
-  const uniqueVars = getUniqueVarsFromEnvs(sourceEnv, targetEnv, config)
-  const envCopy = {}
-  uniqueVars.forEach(env => {
+  const target_env = parse_env(env_example_path)
+
+  const unique_vars = get_unique_vars_from_envs(source_env, target_env, config)
+  const env_copy = {}
+
+  unique_vars.forEach(env => {
     const [key] = Object.keys(env)
-    envCopy[key] = env[key]
+    env_copy[key] = env[key]
   })
 
-  writeToSampleEnv(envExamplePath, envCopy)
+  write_to_dest_env(env_example_path, env_copy)
 }
 
 
 const sync_dotenv = (
-  source,
-  sample_env,
-  samples
+  env_path,
+  _dest_env,
 ) => {
-  if (sample_env && (sample_env === ".env" || path.basename(sample_env) === ".env")) {
-    throw new Error("Cannot sync .env with .env")
+  if (env_path && !fs.existsSync(env_path)) {
+    throw new Error(`env_path: ${env_path} doesn't exist`)
   }
 
-  const sample_env_paths = !samples
-    ? [path.resolve(process.cwd(), sample_env || DEFAULT_SAMPLE_ENV)]
-    : globby
-      .sync(samples)
-      .map((sample) => path.resolve(process.cwd(), sample))
-
-  const envPath = source
-    ? fs.existsSync(source)
-      ? source
-      : null
-    : DEFAULT_ENV_PATH
-
-  if (envPath === null) throw new Error(`${source} not found`)
-
-  if (!source && !fs.existsSync(envPath)) throw new Error(".env doesn't exists")
-
-  if (!sample_env_paths.length)
-    throw new Error(`${samples} did not match any file`)
+  const source_path = env_path || DEFAULT_ENV_PATH
 
-  if (!fs.existsSync(sample_env_paths[0])) {
-    fs.writeFileSync(sample_env_paths[0], "")
-    // throw new Error(`${sample_env || path.basename(DEFAULT_SAMPLE_ENV)} not found`)
+  if (!fs.existsSync(source_path)) {
+    throw new Error(`${env_path || ".env"} file not found`)
   }
 
-  const sourcePath = envPath
+  const dest_env_path = _dest_env || `${source_path}${SAMPLE_ENV_SUFFIX}`
 
-  for (const samplePath of sample_env_paths) {
-    syncWithSampleEnv(sourcePath, samplePath)
+  // creates the sample env file if it doesn't exist
+  if (!fs.existsSync(dest_env_path)) {
+    fs.writeFileSync(dest_env_path, "")
   }
 
-  return sample_env_paths.join(" ")
+  sync_with_dest_env(source_path, dest_env_path)
 }
 
 

package/src/sync-dotenv/LICENSE

@@ -1,22 +0,0 @@
-MIT License
-
-Copyright (c) 2019 Luqman Olushi O.
-Copyright (c) 2023 rpcbase
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.