@rpcbase/cli 0.79.0 → 0.80.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rpcbase/cli",
-  "version": "0.79.0",
+  "version": "0.80.0",
   "type": "module",
   "main": "./index.js",
   "bin": {

package/src/cmd-deploy.js

@@ -1,4 +1,4 @@
-import { execFileSync, execSync } from "child_process";
+import { execSync } from "child_process";
 import fs from "fs";
 import path from "path";
 import os from "os";

package/src/cmd-ssh.js

@@ -0,0 +1,91 @@
+import { execSync } from "child_process";
+import fs from "fs";
+import path from "path";
+import os from "os";
+import validator from "validator";
+
+export const ssh = async (argv) => {
+  const log = (message) => {
+    if (argv.verbose) console.log(message);
+  }
+
+  const {
+    RB_DEPLOY_HOST,
+    RB_DEPLOY_USER,
+    RB_DEPLOY_KEY,
+  } = 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",
+    );
+  }
+
+  const host = RB_DEPLOY_HOST;
+  const user = RB_DEPLOY_USER;
+  let keyPath = RB_DEPLOY_KEY;
+
+  let tempKeyPath = null;
+
+  const execSsh = async (command, stdioInherit = true) => {
+    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;
+    }
+
+    await execSsh("echo connection-ok", false);
+
+    await execSsh(argv.command, true)
+
+  } catch (error) {
+    console.error(
+      `Command 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/index.js

@@ -5,12 +5,14 @@ import { hideBin } from 'yargs/helpers'
 import dotenv from 'dotenv'
 import fs from 'fs'
 import {deploy} from "./cmd-deploy.js"
+import {ssh} from "./cmd-ssh.js"
 import {waitFor} from "./cmd-wait-for/index.js"
 
 yargs(hideBin(process.argv))
   .option("env", {
     describe: "Path to environment file",
     type: "array",
+    nargs: 1,
     global: true,
     default: ["process.env"],
     coerce: (envFiles) => {
@@ -69,6 +71,25 @@ yargs(hideBin(process.argv))
       await deploy(argv)
     },
   )
+  .command(
+    "ssh <command>",
+    "Run ssh command",
+    (yargs) => {
+      return yargs
+        .positional("command", {
+          describe: "Command to run on the remote server",
+          type: "string",
+        })
+        .option("verbose", {
+          alias: "v",
+          describe: "Run with verbose logging",
+          type: "boolean",
+        })
+    },
+    async(argv) => {
+      await ssh(argv)
+    },
+  )
   .command("wait-for", "Waits for the specified service to become available", () => {}, (argv) => {
     waitFor()
   })