ssh-client-wrapper 2.10.2 → 2.12.4

package/lib/sshExec.js

@@ -3,22 +3,40 @@ const crypto = require("crypto");
 const { setTimeout: setTimeoutPromise } = require("timers/promises");
 const debug = require("debug")("sshClientWrapper:debug:sshExec");
 const debugVerbose = require("debug")("sshClientWrapper:verbose:sshExec");
-const debugSendMasterPty = require("debug")("sshClientWrapperInsecure:sshExec_masterPty");
+const debugSendMasterPty = require("debug")("sshClientWrapper:insecure:sshExec:masterPty");
 const { sendPty, sshCmd, getSshOption, sanityCheck, watchDogTimer } = require("./util.js");
 const { fork, createMasterPty, sshLoginCallback } = require("./fork.js");
 
+/**
+ * @typedef Integer {number} - integer number
+ */
+
 /**
  * Execute command on remote host.
- * @param {Object} hostInfo - hostinfo object
+ * @param {object} hostInfo - hostinfo object
  * @param {string} cmd - Cmdline which will be executed on remote host.
  * @param {number} timeout - timeout (in sec.)
  * @param {Function} outputCallback - Callback routine for stdout and stderr.
+ * @param {string} rcfile - rcfile path which will be sourced before executing actual command
+ * @param {string} prependCmd - command string which will be executed before executing actual command
+ * @returns {Integer} - return value of cmd
  */
-async function sshExec (hostInfo, cmd, timeout, outputCallback) {
+async function sshExec(hostInfo, cmd, timeout, outputCallback, rcfile, prependCmd) {
   debug("sshExec called");
   await connect(hostInfo);
   debug("exec", cmd, "on remote server");
   const args = getSshOption(hostInfo, false);
+  if (rcfile) {
+    args.push(`. ${rcfile};`);
+  } else if (hostInfo.rcfile) {
+    args.push(`. ${hostInfo.rcfile};`);
+  }
+  if (prependCmd) {
+    args.push(`${prependCmd};`);
+  } else if (hostInfo.prependCmd) {
+    args.push(`${hostInfo.prependCmd};`);
+  }
+
   args.push(cmd);
   debugVerbose(`exec: ${sshCmd} ${args.join(" ")}`);
 
@@ -31,11 +49,42 @@ async function sshExec (hostInfo, cmd, timeout, outputCallback) {
     }
     if (e.rt === 126) {
       debug(`${cmd} got Permission deny error but ignored`);
-      return e.rt;
     }
     if (e.rt === 127) {
       debug(`${cmd} not found but ignored`);
-      return e.rt;
+    }
+    return e.rt;
+  }
+}
+
+async function expect(hostInfo, cmd, expects, timeout) {
+  debug("expect called");
+  await connect(hostInfo);
+  debugVerbose("exec", cmd, "on remote server with", expects);
+  const args = getSshOption(hostInfo, false);
+  const compiledExpects = expects.map((e)=>{
+    return {
+      reExpect: new RegExp(e.expect),
+      send: e.send,
+      keep: e.keep
+    };
+  });
+  const reExpect = hostInfo.prompt ? new RegExp(hostInfo.prompt) : /[$#>] /;
+  compiledExpects.unshift({ reExpect, send: cmd });
+  compiledExpects.push({ reExpect, send: "exit" });
+
+  try {
+    const rt = await fork(hostInfo, sshCmd, args, timeout, null, [], compiledExpects);
+    return rt;
+  } catch (e) {
+    if (typeof e.rt === "undefined") {
+      throw e;
+    }
+    if (e.rt === 126) {
+      debug(`${cmd} got Permission deny error but ignored`);
+    }
+    if (e.rt === 127) {
+      debug(`${cmd} not found but ignored`);
     }
     return e.rt;
   }
@@ -43,32 +92,32 @@ async function sshExec (hostInfo, cmd, timeout, outputCallback) {
 
 /**
  * Check if you can connect to sepecified server
- * @param {Object} hostInfo - hostinfo object
+ * @param {object} hostInfo - hostinfo object
  * @param {Integer} timeout - timeout in secconds
  */
-async function canConnect (hostInfo, timeout = 60) {
+async function canConnect(hostInfo, timeout) {
   debug("canConnect called");
   sanityCheck(hostInfo);
 
   await connect(hostInfo, timeout);
   await disconnect(hostInfo);
-  // if connection fail, Error is throwed.
-  // so, if we reach here, connection must be succeeded
+  //if connection fail, Error is throwed.
+  //so, if we reach here, connection must be succeeded
   return true;
 }
 
 /**
  * check if master session exists or not
- * @param {Object} hostInfo - hostinfo object
+ * @param {object} hostInfo - hostinfo object
  * @returns {boolean} - true if master session exists
  */
-async function existsMaster (hostInfo, argTimeout) {
+async function existsMaster(hostInfo, argTimeout) {
   debugVerbose("existsMaster called");
   const args = getSshOption(hostInfo);
   args.push("-Ocheck");
 
   let output = "";
-  const cb = (e) => {
+  const cb = (e)=>{
     output += e;
   };
 
@@ -92,9 +141,9 @@ async function existsMaster (hostInfo, argTimeout) {
 
 /**
  * create master ssh connection
- * @param {Object} hostInfo - hostinfo object
+ * @param {object} hostInfo - hostinfo object
  */
-async function connect (hostInfo, timeout = 60) {
+async function connect(hostInfo, timeout = 60) {
   debug("connect called");
 
   if (await existsMaster(hostInfo, timeout)) {
@@ -110,8 +159,9 @@ async function connect (hostInfo, timeout = 60) {
   const re = new RegExp(`^${words}`);
 
   let ac = null;
-  const p = new Promise((resolve, reject) => {
-    ac = watchDogTimer(timeout, "make connection", () => {
+  let output = null;
+  const p = new Promise((resolve, reject)=>{
+    ac = watchDogTimer(timeout, "make connection", ()=>{
       sendPty(hostInfo.masterPty, "\n", debugSendMasterPty, 137);
       sendPty(hostInfo.masterPty, "exit\n", debugSendMasterPty, 138);
 
@@ -119,16 +169,17 @@ async function connect (hostInfo, timeout = 60) {
       err.host = hostInfo.host;
       err.user = hostInfo.user;
       err.port = hostInfo.port;
+      err.output = output;
       reject(err);
     });
 
     let done = false;
-    hostInfo.masterPty.onData((data) => {
+    hostInfo.masterPty.onData((data)=>{
       if (done) {
-        // safeguard
+        //safeguard
         return;
       }
-      const output = data.toString();
+      output = data.toString();
       debugVerbose(output);
 
       if (re.test(output)) {
@@ -147,12 +198,12 @@ async function connect (hostInfo, timeout = 60) {
         reject(new Error("Control socket creation failed"));
       }
     });
-    hostInfo.masterPty.onData((data) => {
+    hostInfo.masterPty.onData((data)=>{
       const output = data.toString();
       sshLoginCallback(output, hostInfo.masterPty, hostInfo.password, hostInfo.passphrase, debugSendMasterPty)
         .catch(reject);
     });
-    hostInfo.masterPty.onExit((e) => {
+    hostInfo.masterPty.onExit((e)=>{
       debug("master pty exit", e);
       resolve(e);
     });
@@ -175,9 +226,9 @@ async function connect (hostInfo, timeout = 60) {
 
 /**
  * remove master session
- * @param {Object} hostInfo - hostinfo object
+ * @param {object} hostInfo - hostinfo object
  */
-async function disconnect (hostInfo) {
+async function disconnect(hostInfo) {
   debug("disconnect called");
 
   if (await existsMaster(hostInfo)) {
@@ -185,7 +236,7 @@ async function disconnect (hostInfo) {
     args.push("-Oexit");
 
     let output = "";
-    const cb = (e) => {
+    const cb = (e)=>{
       output += e;
     };
     try {
@@ -212,50 +263,22 @@ async function disconnect (hostInfo) {
   }
 }
 
-/**
- * execute ls command and return output
- * @param {Object} hostInfo - hostinfo object
- * @param {string} target - file or directory path to watch
- * @param {string[]} lsOpt - optional arguments for ls
- * @param {number} timeout - timeout (in sec.)
- * @returns {string[]} - output from ls
- */
-async function ls (hostInfo, target, lsOpt, timeout) {
-  debug("ls called");
-  const outputArray = [];
-  try {
-    await sshExec(hostInfo, `ls ${lsOpt.join(" ")} ${target}`, timeout, (data) => {
-      outputArray.push(data);
-    });
-  } catch (e) {
-    // non-zero retrun should be allowed
-    if (typeof e.rt === "undefined" || e.rt < 0) {
-      throw e;
-    }
-  }
-  return outputArray.length === 0
-    ? []
-    : outputArray
-      .join("\n")
-      .replace(/\n+/g, "\n")
-      .replace(/\n$/, "")
-      .split("\n");
-}
-
 /**
  * retry fork() if it throw retryable error
  * @param {Function} func - function to be wrapped
- * @param {Object} hostInfo - hostinfo object
+ * @param {object} hostInfo - hostinfo object
  * @param {Integer} argMaxRetry - max retry number
+ * @param {Integer} argDuration - time to wait before retring
+ * @returns {Integer} - return value of func
  */
-async function retryWrapper (func, hostInfo, argMaxRetry, argDuration) {
+async function retryWrapper(func, hostInfo, argMaxRetry, argDuration) {
   const maxRetry = argMaxRetry || hostInfo.maxRetry || 3;
   const duration = argDuration || hostInfo.retryDuration || 1000;
   if (maxRetry === 1) {
     return func();
   }
   let retryCount = 0;
-  while (true) {
+  for (;;) {
     let rt;
     try {
       rt = await func();
@@ -284,6 +307,6 @@ module.exports = {
   canConnect,
   connect,
   disconnect,
-  ls,
+  expect,
   retryWrapper
 };

package/lib/util.js

@@ -26,7 +26,7 @@ const ajv = new Ajv({
 });
 require("ajv-keywords")(ajv, "transform");
 
-// never validate password and passphrase value to avoid security insident
+//never validate password and passphrase value to avoid security insident
 const hostInfoSchema = {
   type: "object",
   properties: {
@@ -40,7 +40,13 @@ const hostInfoSchema = {
     ControlPersistDir: { type: "string", pattern: "\\S+", transform: ["trim"] },
     maxRetry: { type: "number", minimum: 0, default: 3 },
     retryDuration: { type: "number", minimum: 0, default: 1000 },
-    sshOpt: { type: "array", minItems: 1, items: { type: "string", pattern: "\\S+", transform: ["trim"] } }
+    rcfile: { type: "string", pattern: "\\S+", transform: ["trim"] },
+    prependCmd: { type: "string", pattern: "\\S+", transform: ["trim"] },
+    sshOpt: {
+      type: "array",
+      minItems: 1,
+      items: { type: "string", pattern: "\\S+", transform: ["trim"] }
+    }
   },
   required: ["host"]
 };
@@ -64,20 +70,20 @@ const validate = ajv.compile(hostInfoSchema);
  * @param {Function} func - function
  * @param {data} data - binary data which can be converted to string
  */
-const buff2String = (func, data) => {
+const buff2String = (func, data)=>{
   func(data.toString().replace(/\r\n/g, EOL));
 };
 
 /**
  * check if given hostInfo object is OK
- * @param { Object } hostInfo - host information object defined in index.js
+ * @param {object} hostInfo - host information object defined in index.js
  */
-const sanityCheck = (hostInfo) => {
+const sanityCheck = (hostInfo)=>{
   debug("sanityCheck called", hostInfo);
 
-  // keep password, passphrase, and masterPty before validate.
-  // these properties can have a iellegal value as JSON data
-  // so we keep them before ajv validation and put them back
+  //keep password, passphrase, and masterPty before validate.
+  //these properties can have a iellegal value as JSON data
+  //so we keep them before ajv validation and put them back
 
   const { password, passphrase, masterPty } = hostInfo;
   validate(hostInfo);
@@ -100,7 +106,7 @@ const sanityCheck = (hostInfo) => {
       }
       if (prop.startsWith("sshOpt")) {
         debug("remove empty member of sshOpt");
-        hostInfo.sshOpt = hostInfo.sshOpt.filter((opt) => {
+        hostInfo.sshOpt = hostInfo.sshOpt.filter((opt)=>{
           return opt !== "";
         });
         continue;
@@ -132,7 +138,7 @@ const sanityCheck = (hostInfo) => {
   return hostInfo;
 };
 
-function getControlPersistDir (hostInfo) {
+function getControlPersistDir(hostInfo) {
   for (const candidate of [hostInfo.ControlPersistDir, process.env.SSH_CONTROL_PERSIST_DIR]) {
     if (typeof candidate === "string") {
       const stat = fs.statSync(candidate, { throwIfNoEntry: false });
@@ -146,10 +152,10 @@ function getControlPersistDir (hostInfo) {
 
 /**
  * return ssh option with some hard corded options
- * @param { Object} hostInfo - host information object defined in index.js
+ * @param {object} hostInfo - host information object defined in index.js
  * @param {boolean} withoutDestination - return except for hostname
  */
-const getSshOption = (hostInfo, withoutDestination) => {
+const getSshOption = (hostInfo, withoutDestination)=>{
   debug("getSshOption called");
   const args = [];
 
@@ -203,31 +209,32 @@ const getSshOption = (hostInfo, withoutDestination) => {
     args.push(`-oConnectTimeout=${hostInfo.ConnectTimeout}`);
   }
   if (Array.isArray(hostInfo.sshOpt)) {
-    args.push(...hostInfo.sshOpt.filter((e) => {
+    args.push(...hostInfo.sshOpt.filter((e)=>{
       return typeof e === "string";
     }));
   }
+
   return args;
 };
 
-const isArrayOfString = (target) => {
+const isArrayOfString = (target)=>{
   if (!Array.isArray(target)) {
     return false;
   }
-  return !target.some((e) => {
-    // target has non string member
+  return !target.some((e)=>{
+    //target has non string member
     return typeof e !== "string";
   });
 };
 
 /**
  * log and send message to pty
- * @param {Object} pty - pty object which message will be send to
+ * @param {object} pty - pty object which message will be send to
  * @param {string} message - message
  * @param {Function} logger - logging function
  * @param {string} label - where this function is called
  */
-const sendPty = async (pty, message, logger, label) => {
+const sendPty = async (pty, message, logger, label)=>{
   logger(`${label}: ${message}`);
   pty.write(message);
 };
@@ -239,15 +246,15 @@ const sendPty = async (pty, message, logger, label) => {
  * @param {Function} cb - call back function which will be called after timeout
  * @returns {AbortController} - ac to stop watch dog timer
  */
-const watchDogTimer = (timeout, label, cb) => {
+const watchDogTimer = (timeout, label, cb)=>{
   const ac = new AbortController();
   const signal = ac.signal;
   setTimeoutPromise(timeout * 1000, "neverUsedValue", { signal })
-    .then(() => {
+    .then(()=>{
       debug(`can not finish ${label} within ${timeout} sec`);
       return typeof cb === "function" ? cb() : true;
     })
-    .catch((err) => {
+    .catch((err)=>{
       if (err.name === "AbortError") {
         debug(`timeout was aborted because ${label} has finished or canceled`);
       } else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ssh-client-wrapper",
-  "version": "2.10.2",
+  "version": "2.12.4",
   "description": "wrapper library for open ssh client and rsync",
   "keywords": [
     "ssh",
@@ -14,7 +14,7 @@
   "main": "lib/index.js",
   "scripts": {
     "mocha": "mocha --recursive test",
-    "lint": "eslint --fix lib test",
+    "lint": "eslint --fix ./",
     "test": "nyc --reporter=html --reporter=text mocha",
     "coverage": "nyc report --reporter=text-lcov > coverage-report.lcov",
     "postversion": "git push && git push origin $(git describe --abbrev=0 --tags)",
@@ -34,24 +34,22 @@
     "*.js": "eslint --fix"
   },
   "dependencies": {
-    "ajv": "^8.13.0",
+    "ajv": "^8.17.1",
     "ajv-keywords": "^5.1.0",
-    "debug": "^4.3.4",
-    "glob": "^10.3.12",
+    "debug": "^4.4.0",
+    "eslint-plugin-chai-friendly": "^1.0.1",
+    "glob": "^10.4.5",
     "node-pty": "^0.10.1",
     "promise-retry": "^2.0.1"
   },
   "devDependencies": {
+    "@eslint/js": "^9.19.0",
+    "@stylistic/eslint-plugin": "^3.0.1",
     "chai": "^4.3.7",
     "chai-as-promised": "^7.1.1",
     "chai-fs": "^2.0.0",
-    "eslint": "^8.38.0",
-    "eslint-config-standard": "^17.1.0",
-    "eslint-plugin-chai-expect": "^3.0.0",
-    "eslint-plugin-chai-friendly": "^0.7.4",
-    "eslint-plugin-import": "^2.29.1",
-    "eslint-plugin-n": "^16.6.2",
-    "eslint-plugin-promise": "^6.1.1",
+    "eslint-plugin-jsdoc": "^50.6.3",
+    "eslint-plugin-node": "^11.1.0",
     "fs-extra": "^11.1.1",
     "husky": "^8.0.0",
     "lint-staged": "^13.2.1",

package/run_test_all.sh

@@ -1,21 +1,11 @@
 #!/bin/bash
-
 function cleanup(){
-  docker compose rm --stop --force testbed
+  docker compose down
 }
-
 trap cleanup EXIT
 set -e -o pipefail
 
-docker compose up testbed -d
-export TEST_HOST=localhost
-export TEST_USER=testuser
-export TEST_PW=passw0rd
-export TEST_PORT=4100
-ssh-keygen -R '[localhost]:4100'
-
-npm run test
-echo local test success
+./run_test_local.sh keep
 
 docker compose run --build --rm tester
 echo test on latest ubuntu success
@@ -25,3 +15,4 @@ echo test on bullseye success
 
 docker compose run --build --rm tester-buster
 echo test on buster success
+docker compose down

package/run_test_local.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+docker compose up testbed -d
+export TEST_HOST=localhost
+export TEST_USER=testuser
+export TEST_PW=passw0rd
+export TEST_PORT=4100
+ssh-keygen -R '[localhost]:4100'
+
+npm run test
+echo local test success
+if [ x${1} != xkeep ];then
+  docker compose down
+fi

package/test/getSshOption.js

@@ -1,22 +1,22 @@
 "use strict";
-process.on("unhandledRejection", console.dir); // eslint-disable-line no-console
+process.on("unhandledRejection", console.dir); //eslint-disable-line no-console
 
-// setup test framework
+//setup test framework
 const chai = require("chai");
 const { expect } = require("chai");
 chai.use(require("chai-as-promised"));
 
-// testee
+//testee
 const { getSshOption } = require("../lib/util.js");
 
-describe("test for getSshOption", () => {
+describe("test for getSshOption", ()=>{
   const defaultValues = {
     host: "testHostName",
     ControlPersist: 180,
     maxRetry: 3,
     retryDuration: 1000
   };
-  it("should return minimum ssh option array", () => {
+  it("should return minimum ssh option array", ()=>{
     const sshOpts = getSshOption(defaultValues);
     expect(sshOpts).to.be.an("array");
     expect(sshOpts).to.have.lengthOf(4);
@@ -25,7 +25,7 @@ describe("test for getSshOption", () => {
     expect(sshOpts[2]).to.equal("-oControlPath=~/.ssh/ssh-client-wrapper-%r@%h:%p");
     expect(sshOpts[3]).to.equal("-oControlPersist=180");
   });
-  it("should change ControlPath by ControlPersistDir", () => {
+  it("should change ControlPath by ControlPersistDir", ()=>{
     const hostInfo = { ...defaultValues };
     hostInfo.ControlPersistDir = "/tmp";
     const sshOpts = getSshOption(hostInfo);
@@ -36,7 +36,7 @@ describe("test for getSshOption", () => {
     expect(sshOpts[2]).to.equal("-oControlPath=/tmp/ssh-client-wrapper-%r@%h:%p");
     expect(sshOpts[3]).to.equal("-oControlPersist=180");
   });
-  it("should change ControlPath by Environment variable", () => {
+  it("should change ControlPath by Environment variable", ()=>{
     process.env.SSH_CONTROL_PERSIST_DIR = "/tmp";
     const sshOpts = getSshOption(defaultValues);
     expect(sshOpts).to.be.an("array");