@rpcbase/cli 0.38.0 → 0.40.0

package/bin.js

@@ -8,10 +8,11 @@ require("dotenv").config({path: path.join(process.cwd(), "./.env")})
 const yargs = require("yargs/yargs")
 const {hideBin} = require("yargs/helpers")
 
-const start_command = require("./src/start_command")
+const increment_pkg = require("./src/increment-pkg")
 const print_versions = require("./src/print_versions")
-const update = require("./src/update")
+const start_command = require("./src/start_command")
 const sync_dotenv = require("./src/sync-dotenv")
+const update = require("./src/update")
 
 
 yargs(hideBin(process.argv))
@@ -23,6 +24,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 +40,6 @@ yargs(hideBin(process.argv))
         description: "Run with debug logging"
       })
   }, (argv) => {
-    console.log("IS start")
     if (argv.version) return print_versions()
     start_command(argv)
   })
@@ -50,6 +55,12 @@ yargs(hideBin(process.argv))
     if (argv.version) return print_versions()
     await update()
   })
+  // Increment pkg
+  .command(["increment-pkg <files...>"], "Bump a package version if necessary by checking its source on github", (yargs) => {
+  }, async(argv) => {
+    if (argv.version) return print_versions()
+    await increment_pkg(argv)
+  })
   // sync-dotenv
   .command("sync-dotenv [source_env] [dest_env]", "Compare and sync dotenv files", (yargs) => {
     yargs

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rpcbase/cli",
-  "version": "0.38.0",
+  "version": "0.40.0",
   "license": "SSPL-1.0",
   "bin": {
     "rb": "./bin.js"
@@ -13,6 +13,7 @@
     "concurrently": "8.2.1",
     "debug": "4.3.4",
     "dotenv": "16.3.1",
+    "octokit": "2.1.0",
     "parse-dotenv": "2.1.0",
     "picocolors": "1.0.0",
     "semver": "7.5.4",

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/increment-pkg/get_gh_token.js

@@ -0,0 +1,30 @@
+/* @flow */
+const fs = require("fs")
+const path = require("path")
+
+const get_gh_token = () => {
+  let token
+
+  const npmrc_path = path.join(process.cwd(), "./.npmrc")
+  const gh_token_path = path.join(process.cwd(), "./.gh_token")
+
+  if (fs.existsSync(npmrc_path)) {
+    const content = fs.readFileSync(npmrc_path, "utf8")
+    const match = content.match(/^\/\/npm\.pkg\.github\.com\/:_authToken=(\S+)$/m)
+
+    if (match) {
+      token = match[1]
+    }
+  } else if (fs.existsSync(gh_token_path)) {
+    try {
+      token = JSON.parse(fs.readFileSync(gh_token_path))
+    } catch (err) {
+      console.log("unable to parse token from .gh_token")
+    }
+  }
+
+
+  return token
+}
+
+module.exports = get_gh_token

package/src/increment-pkg/index.js

@@ -0,0 +1,125 @@
+/* @flow */
+const fs = require("fs")
+const path = require("path")
+const {execSync} = require("child_process")
+
+const colors = require("picocolors")
+const Promise = require("bluebird")
+const semver = require("semver")
+const {Octokit} = require("octokit")
+
+const get_gh_token = require("./get_gh_token")
+
+
+const get_gh_client = () => {
+  const gh_token = get_gh_token()
+
+  if (!gh_token) return
+
+  const octokit = new Octokit({
+    auth: gh_token
+  })
+
+  return octokit
+}
+
+
+const get_latest_live_version = async(pack_dir) => {
+  const octokit = get_gh_client()
+
+  if (!octokit) {
+    console.log(colors.bold(colors.yellow("rb increment-pkg:")), "unable to get a github client, do you have a token in .npmrc or .github_token ?")
+    process.exit(0)
+    return
+  }
+
+  const origin_url = execSync("git remote get-url origin").toString().trim()
+  const owner = path.dirname(origin_url).split(":").pop()
+  const repo = path.basename(origin_url).replace(/\.git$/, "")
+
+  const remote_path = `pkg/${pack_dir}/package.json`
+
+  let res
+  try {
+    res = await octokit.request("GET /repos/{owner}/{repo}/contents/{path}", {
+      owner,
+      repo,
+      path: remote_path,
+    })
+  } catch (err) {
+    if (err.response.status === 404) {
+      console.log(`${owner}/${repo}/${remote_path} remote package not found, skipping version bump`)
+      return
+    } else {
+      console.log(err)
+    }
+  }
+
+  const file_contents = Buffer.from(res.data.content, "base64").toString()
+  const pack_obj = JSON.parse(file_contents)
+  const live_version = pack_obj.version
+
+  return live_version
+}
+
+
+// lint-staged script to increment package version when any package in the pkg/ folder is modified
+const increment_pkg = async(args) => {
+  const {files} = args
+
+  const touched_packages = {}
+
+  const packages_dir = path.join(process.cwd(), "./pkg")
+
+  files.forEach((f) => {
+    const rel_path = path.relative(packages_dir, f)
+    // get package dirname
+    const [pack_dir] = path.dirname(rel_path).split("/")
+    // check if it is actually a package
+    const pack_json_path = path.join(packages_dir, `./${pack_dir}/package.json`)
+    if (fs.existsSync(pack_json_path)) {
+      touched_packages[pack_dir] = true
+    }
+  })
+
+  const process_package = async(pack_dir) => {
+    const local_pack_path = path.join(packages_dir, `./${pack_dir}/package.json`)
+    const local_pack = JSON.parse(fs.readFileSync(local_pack_path))
+
+    const local_version = local_pack.version
+    if (!local_version) {
+      // skipping because package has no local version
+      return
+    }
+
+    const live_version = await get_latest_live_version(pack_dir)
+
+    if (!semver.valid(live_version)) {
+      console.log("warning:", "live version not valid, got:", JSON.stringify(live_version), "skipping")
+      return
+    }
+
+    if (!semver.valid(local_version)) {
+      console.log("error:", "local version not valid, got:", JSON.stringify(local_version), "skipping")
+      process.exit(1)
+      return
+    }
+
+    // if local_version == live_version -> bump
+    if (live_version && semver.eq(local_version, live_version)) {
+      const new_version = semver.inc(local_version, "minor")
+
+      console.log("bumped", local_pack.name, "to", new_version)
+
+      local_pack.version = new_version
+      fs.writeFileSync(local_pack_path, JSON.stringify(local_pack, null, 2) + "\n")
+
+      // add to git index, in case change was not triggered by package.json
+      execSync(`git add ${local_pack_path}`)
+    }
+  }
+
+  await Promise.map(Object.keys(touched_packages), process_package)
+}
+
+module.exports = increment_pkg

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()
   }