@rpcbase/cli 0.73.0 → 0.74.0

package/package.json

@@ -1,37 +1,24 @@
 {
   "name": "@rpcbase/cli",
-  "version": "0.73.0",
-  "license": "SSPL-1.0",
+  "version": "0.74.0",
+  "type": "module",
+  "main": "./index.js",
   "bin": {
-    "rb": "./bin.js"
+    "rb": "./src/index.js"
   },
-  "publishConfig": {
-    "registry": "https://registry.npmjs.org/"
-  },
-  "files": [
-    "src/",
-    "eslint/",
-    "stylelint/",
-    "!src/**/*.test.js"
-  ],
   "scripts": {
-    "test": "echo \"no test specified exiting with code 0\" && exit 0"
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "release": "wireit"
   },
   "wireit": {
-    "apply-version": {
-      "command": "node ../../scripts/prflow/apply-prerelease-versions.js $BRANCH_NAME"
-    },
     "release": {
-      "command": "npm publish --tag $NPM_RELEASE_CHANNEL | tee publish-output.txt",
-      "dependencies": [
-        "apply-version"
-      ],
+      "command": "../../scripts/publish.js",
+      "dependencies": [],
       "files": [
-        "package.json"
-      ],
-      "output": [
-        "publish-output.txt"
+        "package.json",
+        "index.js"
       ],
+      "output": [],
       "env": {
         "NPM_RELEASE_CHANNEL": {
           "external": true
@@ -40,28 +27,8 @@
     }
   },
   "dependencies": {
-    "@babel/core": "7.24.9",
-    "@babel/eslint-parser": "7.25.0",
-    "@babel/plugin-syntax-flow": "7.24.7",
-    "@babel/plugin-transform-react-jsx": "7.24.7",
-    "@rpcbase/agent": "0.42.0",
-    "bluebird": "3.7.2",
-    "concurrently": "8.2.2",
-    "debug": "4.3.6",
-    "dotenv": "16.4.5",
-    "eslint": "8.57.0",
-    "lint-staged": "15.2.7",
-    "octokit": "3.1.2",
-    "parse-dotenv": "2.1.0",
-    "picocolors": "1.0.1",
-    "semver": "7.6.0",
-    "stylelint": "16.7.0",
-    "stylelint-config-standard": "36.0.0",
-    "stylelint-config-standard-scss": "13.1.0",
-    "validator": "13.12.0",
+    "dotenv": "16.5.0",
+    "validator": "13.15.0",
     "yargs": "17.7.2"
-  },
-  "devDependencies": {
-    "jest": "29.7.0"
   }
 }

package/src/cmd-deploy.js

@@ -0,0 +1,137 @@
+import { execSync } from "child_process";
+import fs from "fs";
+import path from "path";
+import os from "os";
+import validator from "validator";
+
+export const deploy = async (argv) => {
+  const log = (message) => {
+    if (argv.verbose) console.log(message);
+  };
+
+  const {
+    RB_DEPLOY_HOST,
+    RB_DEPLOY_USER,
+    RB_DEPLOY_KEY,
+    RB_DEPLOY_DIR,
+  } = argv.env || {};
+
+  if (
+    !RB_DEPLOY_HOST ||
+    !validator.isURL(RB_DEPLOY_HOST, { require_tld: false })
+  ) {
+    throw new Error(
+      "Missing or invalid required environment variable: RB_DEPLOY_HOST",
+    );
+  }
+
+  if (!RB_DEPLOY_USER || !validator.isLength(RB_DEPLOY_USER, { min: 1 })) {
+    throw new Error(
+      "Missing or invalid required environment variable: RB_DEPLOY_USER",
+    );
+  }
+
+  if (!RB_DEPLOY_KEY || !validator.isLength(RB_DEPLOY_KEY, { min: 1 })) {
+    throw new Error(
+      "Missing or invalid required environment variable: RB_DEPLOY_KEY",
+    );
+  }
+
+  if (!RB_DEPLOY_DIR || !validator.isLength(RB_DEPLOY_DIR, { min: 1 })) {
+    throw new Error(
+      "Missing or invalid required environment variable: RB_DEPLOY_DIR",
+    );
+  }
+
+  const host = RB_DEPLOY_HOST;
+  const user = RB_DEPLOY_USER;
+  const deployDir = RB_DEPLOY_DIR;
+  let keyPath = RB_DEPLOY_KEY;
+
+  let tempKeyPath = null;
+
+  // Create an SSH function that can be reused
+  const ssh = async (command, stdioInherit = false) => {
+    const sshCommand = `ssh -i "${keyPath}" -o StrictHostKeyChecking=no ${user}@${host} "${command}"`;
+    log(`${command}`);
+    const out = execSync(sshCommand, {
+      stdio: (argv.verbose || stdioInherit) ? "inherit" : "pipe",
+    })
+    const res = out?.toString()?.trim() || ""
+    return res
+  };
+
+  try {
+    if (keyPath.startsWith("~")) keyPath = keyPath.replace("~", os.homedir());
+
+    if (!fs.existsSync(keyPath)) {
+      // try to treat RB_DEPLOY_KEY as base64-encoded key content
+      const keyContent = Buffer.from(RB_DEPLOY_KEY, "base64").toString("utf-8");
+      if (!keyContent.includes("-----BEGIN")) {
+        throw new Error(
+          "Decoded content does not appear to be a valid SSH key",
+        );
+      }
+      tempKeyPath = path.join(os.tmpdir(), `deploy-key-${Date.now()}`);
+      fs.writeFileSync(tempKeyPath, keyContent);
+      fs.chmodSync(tempKeyPath, "400");
+      keyPath = tempKeyPath;
+    }
+
+    log(`Connecting to ${host} as ${user} using key at ${keyPath}`);
+    const res = await ssh("echo connection-ok");
+    console.log(`${user}@${host}`, res)
+    await ssh(`mkdir -p ~/apps/${deployDir}`);
+
+    const excludeList = [
+      ".aider*",
+      ".husky/",
+      ".github/",
+      ".git/",
+      ".wireit/",
+      "coverage/",
+      "node_modules/",
+      ".gitignore",
+      "*.css.map",
+      "*.env*",
+      "*.js.map",
+      "*.md",
+    ];
+
+    const excludeArgs = excludeList.map((p) => `--exclude='${p}'`).join(" ");
+    const rsyncCmd = [
+      "rsync -avz -C",
+      excludeArgs,
+      "--delete",
+      `-e "ssh -i '${keyPath}' -o StrictHostKeyChecking=no"`,
+      ".",
+      `${user}@${host}:~/apps/${deployDir}/`,
+    ].join(" ");
+
+    log(`Running: ${rsyncCmd}`);
+    execSync(rsyncCmd, { stdio: argv.verbose ? "inherit" : "ignore" });
+
+    await ssh(`cd ~/apps/${deployDir}/infrastructure && [ -f package.json ] && yarn || true`);
+
+    log("Restarting application...");
+    await ssh(`cd ~/apps/${deployDir}/infrastructure && node ctrl.js down prod`, true);
+    log("Application stopped. Starting it up again...");
+    await ssh(`cd ~/apps/${deployDir}/infrastructure && node ctrl.js up prod`, true);
+
+    log("Deployment complete ✅");
+  } catch (error) {
+    console.error(
+      `Deployment failed: ${error instanceof Error ? error.message : error}`,
+    );
+    throw error;
+  } finally {
+    if (tempKeyPath) {
+      try {
+        fs.unlinkSync(tempKeyPath);
+        log(`Removed temporary key file: ${tempKeyPath}`);
+      } catch (cleanupError) {
+        console.warn(`Failed to remove temporary key file: ${cleanupError}`);
+      }
+    }
+  }
+};

package/src/{wait-for → cmd-wait-for}/index.js

@@ -1,13 +1,14 @@
-/* @flow */
-const path = require("path")
-const {execSync} = require("child_process");
+import path from "path";
+import { execSync } from "child_process";
+import { fileURLToPath } from "url"
 
-const wait_for = () => {
+
+export const waitFor = () => {
   process.title = "rb-wait-for"
 
   const args = process.argv.slice(3).join(" ")
 
-  const script_path = path.join(__dirname, "./wait-for.sh")
+  const script_path = path.join(path.dirname(fileURLToPath(import.meta.url)), "./wait-for.sh")
 
   const command = `${script_path} ${args}`
 
@@ -17,5 +18,3 @@ const wait_for = () => {
     console.error(`wait-for execution failed: ${error}`)
   }
 }
-
-module.exports = wait_for

package/src/{wait-for → cmd-wait-for}/wait-for.sh

@@ -1,4 +1,4 @@
-#!/bin/sh
+#!/usr/bin/env sh
 
 # original script: https://github.com/eficode/wait-for/blob/master/wait-for
 

package/src/index.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+
+import yargs from "yargs/yargs"
+import { hideBin } from 'yargs/helpers'
+import dotenv from 'dotenv'
+import fs from 'fs'
+import {deploy} from "./cmd-deploy.js"
+import {waitFor} from "./cmd-wait-for/index.js"
+
+yargs(hideBin(process.argv))
+  .option("env", {
+    describe: "Path to environment file",
+    type: "array",
+    global: true,
+    coerce: (envFiles) => {
+      if (!envFiles || envFiles.length === 0) return {};
+
+      const envVars = {};
+
+      envFiles.forEach(filePath => {
+        if (fs.existsSync(filePath)) {
+          const parsed = dotenv.parse(fs.readFileSync(filePath));
+          Object.assign(envVars, parsed);
+        } else {
+          console.warn(`Warning: Environment file ${filePath} not found.`);
+        }
+      });
+
+      // Then apply process.env variables to override file-based variables
+      Object.assign(envVars, process.env);
+
+      return envVars;
+    }
+  })
+  .command(
+    "test",
+    "test command",
+    (yargs) => {
+      return yargs
+        .option("verbose", {
+          alias: "v",
+          describe: "Run with verbose logging",
+          type: "boolean",
+        });
+    },
+    async(argv) => {
+      console.log("IT WORKS!")
+    },
+  )
+  .command(
+    "deploy",
+    "Deploy the application",
+    (yargs) => {
+      return yargs
+        .option("verbose", {
+          alias: "v",
+          describe: "Run with verbose logging",
+          type: "boolean",
+        });
+    },
+    async(argv) => {
+      await deploy(argv)
+    },
+  )
+  .command("wait-for", "Waits for the specified service to become available", () => {}, (argv) => {
+    waitFor()
+  })
+  .demandCommand(1, "You need to specify a command")
+  // .strict()
+  .help()
+  .parse();

package/bin.js

@@ -1,129 +0,0 @@
-#!/usr/bin/env node
-/* @flow */
-process.title = "rb-cli"
-// load .env
-const path = require("path")
-require("dotenv").config({path: path.join(process.cwd(), "./.env")})
-//
-const yargs = require("yargs/yargs")
-const {hideBin} = require("yargs/helpers")
-
-const increment_pkg = require("./src/versions/increment-pkg")
-const lint = require("./src/lint")
-const lint_staged = require("./src/lint-staged")
-const print_versions = require("./src/print_versions")
-const run_agent = require("./src/run_agent")
-const start_command = require("./src/start_command")
-const stylelint = require("./src/stylelint")
-const sync_dotenv = require("./src/sync-dotenv")
-const update = require("./src/update")
-const wait_for = require("./src/wait-for")
-
-
-yargs(hideBin(process.argv))
-  .command(["start", "*"], "Starts client, server, and infrastructure", (yargs) => {
-    yargs
-      .option("coverage", {
-        alias: "c",
-        type: "boolean",
-        default: false,
-        description: "Adds coverage instrumentation (always disabled in production)"
-      })
-      .option("verbose", {
-        type: "boolean",
-        default: false,
-        description: "Run with verbose logging"
-      })
-      .option("debug", {
-        type: "boolean",
-        default: false,
-        description: "Run with debug logging"
-      })
-  }, (argv) => {
-    if (argv.version) return print_versions()
-    start_command(argv)
-  })
-  .command(["lint"], "Run eslint", (yargs) => {}, (argv) => {
-    lint(argv)
-  })
-  .command(["stylelint"], "Run stylelint", (yargs) => {}, (argv) => {
-    stylelint(argv)
-  })
-  .command(["lint-staged"], "Run lint-staged", (yargs) => {}, (argv) => {
-    lint_staged(argv)
-  })
-  // TODO: rm this
-  .command(["agent"], "Run the agent", (yargs) => {
-    // yargs
-      // .option("option1", {
-      //   alias: "o",
-      //   type: "boolean",
-      //   default: false,
-      //   description: "Option description"
-      // })
-  }, (argv) => {
-    if (argv.version) return print_versions()
-    run_agent(argv)
-  })
-  // Update
-  .command(["update", "up"], "Update rb dependencies to latest version", (yargs) => {
-    yargs
-      .option("dry-run", {
-        type: "boolean",
-        default: false,
-        description: "Print output without writing any files"
-      })
-      .option("all", {
-        type: "boolean",
-        default: false,
-        description: "Doesn't filter @rpcbase/ dependencies, updates everything"
-      })
-  }, async(argv) => {
-    if (argv.version) return print_versions()
-    await update(argv)
-  })
-  // 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
-      .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(argv.source_env, argv.dest_env)
-  })
-  // wait-for
-  .command("wait-for", "", () => {}, (argv) => {
-    wait_for()
-  })
-  // Ping
-  .command("ping", "Ping", () => {}, (argv) => {
-    if (argv.version) return print_versions()
-    console.log("PING")
-  })
-  // Global options
-  .version(false)
-  .option("version", {
-    alias: "v",
-    type: "boolean",
-    description: "Displays the @rpcbase/cli version"
-  })
-  .help("h")
-  .alias("h", "help")
-  .parse()

package/src/helpers/docker_runtime_check.js

@@ -1,42 +0,0 @@
-/* @flow */
-const assert = require("assert")
-const {execSync} = require("child_process")
-const os = require("os")
-const colors = require("picocolors")
-
-
-const get_networks = () => {
-  const out = execSync("docker network ls --format=json")
-  const nets = out.toString().trim().split("\n")
-    .filter(l => !!l)
-    .map((l) => JSON.parse(l))
-
-  return nets
-}
-
-const docker_runtime_check = () => {
-  // check docker is running
-  try {
-    execSync("docker version --format=json")
-  } catch (err) {
-    console.log(colors.cyan("docker"), "exited with error")
-    process.exit(1)
-  }
-
-  // check network exists and create it if not
-  const {RB_APP_NAME} = process.env
-  assert(RB_APP_NAME, "missing RB_APP_NAME in env")
-
-  const net_name = `${RB_APP_NAME}-network`
-
-  const nets = get_networks()
-
-  const target_net = nets.find((n) => n.Name === net_name)
-
-  if (!target_net) {
-    execSync(`docker network create ${net_name}`)
-    console.log("created docker network:", net_name)
-  }
-}
-
-module.exports = docker_runtime_check

package/src/helpers/exit_with_message.js

@@ -1,12 +0,0 @@
-/* @flow */
-const colors = require("picocolors")
-
-const exit_with_message = (message = "", code = 1) => {
-  console.log(colors.red("error:"), message)
-
-  // TODO: sentry(?) report error
-
-  process.exit(code)
-}
-
-module.exports = exit_with_message

package/src/helpers/get_root_dir.js

@@ -1,19 +0,0 @@
-/* @flow */
-const path = require("path")
-
-const get_root_dir = (run_configs) => {
-  let project_root_dir
-  if (run_configs[0].type === "server") {
-    project_root_dir = path.join(run_configs[0].working_dir, "../../")
-  } else if (run_configs[0].type === "client") {
-    project_root_dir = path.join(run_configs[0].working_dir, "../")
-  }
-
-  if (!project_root_dir) {
-    throw new Error("unable to find project root dir")
-  }
-
-  return project_root_dir
-}
-
-module.exports = get_root_dir

package/src/helpers/tailscale_tunnel.js

@@ -1,78 +0,0 @@
-/* @flow */
-const path = require("path")
-const fs = require("fs")
-const dotenv = require("dotenv")
-const child_process = require("child_process")
-const util = require("util")
-
-const get_root_dir = require("./get_root_dir")
-
-
-const exec = util.promisify(child_process.exec)
-
-const TAILSCALE_PATH = "/Applications/Tailscale.app/Contents/MacOS/Tailscale"
-
-const has_tailscale = process.platform === "darwin" && fs.existsSync(TAILSCALE_PATH)
-
-
-const get_port = (run_configs) => {
-  const project_root_dir = get_root_dir(run_configs)
-
-  const server_env_path = path.join(project_root_dir, "./server/server/.env")
-
-  const server_env_buf = fs.readFileSync(server_env_path)
-  const parsed_env = dotenv.parse(server_env_buf)
-
-  const server_port = parsed_env.SERVER_PORT
-  const wss_port = parsed_env.WSS_PORT
-
-  return {server_port, wss_port}
-}
-
-
-const check_status = async() => {
-  try {
-    const {stdout, stderr} = await exec(`${TAILSCALE_PATH} funnel status --json`)
-    const out = JSON.parse(stdout)
-    return typeof out === "object"
-  } catch (err) {
-    //
-  }
-  return false
-}
-
-const start = async(run_configs) => {
-  if (!has_tailscale) return
-
-  const should_ts_start = await check_status()
-
-  if (!should_ts_start) return
-
-  const {server_port, wss_port} = get_port(run_configs)
-  try {
-    await exec(`${TAILSCALE_PATH} funnel --bg --set-path / --https=443 http://127.0.0.1:${server_port}`, {stdio: "inherit"})
-    if (wss_port) {
-      await exec(`${TAILSCALE_PATH} funnel --bg --set-path /wss --https=${wss_port} http://127.0.0.1:${wss_port}`, {stdio: "inherit"})
-    }
-  } catch (err) {
-    console.log("error starting tailscale, is the tailscale app running ?")
-  }
-}
-
-
-const stop = async(run_configs) => {
-  if (!has_tailscale) return
-
-  const {server_port, wss_port} = get_port(run_configs)
-  try {
-    await exec(`${TAILSCALE_PATH} funnel --https=443 off`, {stdio: "inherit"})
-    if (wss_port) {
-      await exec(`${TAILSCALE_PATH} funnel --https=${wss_port} off`)
-    }
-  } catch (err) {
-    // console.log("TAILSCALE ERR", err)
-    console.log("error stopping tailscale, it probably wasn't initally running. you can ignore it")
-  }
-}
-
-module.exports = {start, stop}

package/src/lint-staged.js

@@ -1,17 +0,0 @@
-const path = require("path")
-const {spawn} = require("child_process")
-
-const {hideBin} = require("yargs/helpers")
-
-module.exports = () => {
-  const args = hideBin(process.argv).slice(1) // remove first arg
-
-  const package_dir = path.dirname(require.resolve("lint-staged/package.json"))
-  const bin_path = path.join(package_dir, "./bin/lint-staged.js")
-
-  const ps = spawn(bin_path, args, { stdio: "inherit" })
-
-  ps.on("close", (code) => {
-    process.exit(code)
-  })
-}

package/src/lint.js

@@ -1,17 +0,0 @@
-const path = require("path")
-const {spawn} = require("child_process")
-
-const {hideBin} = require("yargs/helpers")
-
-module.exports = () => {
-  const args = hideBin(process.argv).slice(1) //remove first arg (our rb command 'lint')
-
-  const eslint_path = path.dirname(require.resolve("eslint/package.json"))
-  const bin_path = path.join(eslint_path, "./bin/eslint.js")
-
-  const ps = spawn(bin_path, args, { stdio: "inherit" })
-
-  ps.on("close", (code) => {
-    process.exit(code)
-  })
-}

package/src/print_versions.js

@@ -1,15 +0,0 @@
-/* @flow */
-const {execSync} = require("child_process")
-
-const colors = require("picocolors")
-
-const package = require("../package.json")
-
-const print_versions = () => {
-  console.log(`${colors.cyan("rb")} v${package.version}`)
-
-  const node_out = execSync("node -v")
-  console.log(`${colors.green("node")} ${node_out.toString().trim()}`)
-}
-
-module.exports = print_versions

package/src/run_agent.js

@@ -1,17 +0,0 @@
-/* @flow */
-const path = require("path")
-const fs = require("fs")
-
-const {run} = require("@rpcbase/agent")
-
-const run_agent = async() => {
-  process.title = "rb-agent"
-
-  const cwd = process.cwd()
-  const proj_parent_dir = cwd// path.join(cwd, "../../")
-  const proj_prefix = path.basename(proj_parent_dir)
-
-  run(proj_prefix)
-}
-
-module.exports = run_agent