ssh-client-wrapper 2.14.0 → 2.16.0

package/README.md

@@ -60,6 +60,10 @@ Creates a new SSH client instance.
     *   `keyFile` (string, optional): The path to the private key file for key-based authentication.
     *   `passphrase` (string | Function, optional): The passphrase for the private key, or a function that returns it.
     *   `noStrictHostKeyChecking` (boolean, optional): If `true`, bypasses strict host key checking.
+    *   `maxRetry` (number, optional): Max number of retries for a retryable error. Defaults to `3`.
+    *   `retryDuration` (number, optional): Time (msec) to wait between each retry. Defaults to `1000`.
+    *   `retryableExitCodes` (number[], optional): Additional rsync exit codes to treat as retryable for `.send()`/`.recv()`. See [Retry behavior for `.send()` / `.recv()`](#retry-behavior-for-send--recv) below.
+    *   `replaceRetryableExitCodes` (boolean, optional): If `true`, `retryableExitCodes` replaces the built-in retryable exit code list instead of adding to it.
     *   And more... see `lib/index.js` for all available options.
 
 ### `.exec(cmd, [timeout], [outputCallback], [rcfile], [prependCmd])`
@@ -82,20 +86,91 @@ Executes a command and interacts with it, similar to the `expect` tool.
 
 *   Returns: `Promise<number>` - The return code of the command.
 
-### `.send(src, dst, [opt], [timeout])`
+### `.send(src, dst, [opt], [timeout], [retryableExitCodes], [replaceRetryableExitCodes])`
 Uploads files or directories to the remote host using `rsync`.
 
 *   `src` (string[]): An array of local paths to send.
 *   `dst` (string): The remote destination path.
+*   `retryableExitCodes` (number[], optional): Per-call override of retryable rsync exit codes for this call only (takes precedence over `hostInfo.retryableExitCodes`). See [Retry behavior for `.send()` / `.recv()`](#retry-behavior-for-send--recv).
+*   `replaceRetryableExitCodes` (boolean, optional): If `true`, `retryableExitCodes` replaces the built-in default instead of adding to it. Defaults to `false`.
 *   Returns: `Promise<void>`
 
-### `.recv(src, dst, [opt], [timeout])`
+### `.recv(src, dst, [opt], [timeout], [retryableExitCodes], [replaceRetryableExitCodes])`
 Downloads files or directories from the remote host using `rsync`.
 
 *   `src` (string[]): An array of remote paths to receive.
 *   `dst` (string): The local destination path.
+*   `retryableExitCodes` (number[], optional): Per-call override of retryable rsync exit codes for this call only (takes precedence over `hostInfo.retryableExitCodes`). See [Retry behavior for `.send()` / `.recv()`](#retry-behavior-for-send--recv).
+*   `replaceRetryableExitCodes` (boolean, optional): If `true`, `retryableExitCodes` replaces the built-in default instead of adding to it. Defaults to `false`.
 *   Returns: `Promise<void>`
 
+### Retry behavior for `.send()` / `.recv()`
+
+`.send()` and `.recv()` automatically retry (up to `hostInfo.maxRetry` times, default `3`, waiting `hostInfo.retryDuration` msec between attempts, default `1000`) when:
+
+*   the underlying `rsync` process exits with one of the built-in retryable exit codes: `10, 11, 12, 13, 14` (I/O and protocol errors that are commonly transient), or
+*   the SSH connection fails with a transient `kex_exchange_identification` error.
+
+If your environment sees other rsync exit codes that should also be retried (for example on a shared HPC filesystem where a "partial transfer" exit code can occur while output files are still being flushed), you can add to or replace the retryable list without changing the library's default, at two levels:
+
+*   **Per instance**, via `hostInfo.retryableExitCodes` / `hostInfo.replaceRetryableExitCodes` — applies to every `.send()`/`.recv()` call made through that `SshClientWrapper`.
+*   **Per call**, via the trailing `retryableExitCodes` / `replaceRetryableExitCodes` arguments on `.send()`/`.recv()` — applies only to that call, and fully overrides the instance-level setting if provided.
+
+By default (`replaceRetryableExitCodes: false`), `retryableExitCodes` is **added** to the built-in list — the common case, since it doesn't require knowing or repeating the built-in codes. Set `replaceRetryableExitCodes: true` to use `retryableExitCodes` verbatim instead (pass `[]` to disable exit-code-based retry entirely).
+
+```javascript
+// add exit codes 23 and 24 to the built-in retryable list, for every send/recv on this instance
+const ssh = new SshClientWrapper({
+  host: 'remote.server.com',
+  user: 'username',
+  password: 'password',
+  retryableExitCodes: [23, 24]
+});
+
+// or, just for a single call:
+await ssh.recv(['/remote/output/*'], './local-output', [], 0, [23, 24]);
+
+// full replace: only retry on 23 for this call
+await ssh.recv(['/remote/output/*'], './local-output', [], 0, [23], true);
+
+// disable exit-code-based retry entirely for this call
+await ssh.recv(['/remote/output/*'], './local-output', [], 0, [], true);
+```
+
+### `.remoteToRemoteCopy(src, dstHostInfo, dst, [opt], [timeout])`
+Copies files or directories directly from this remote host to another remote host using `rsync` with SSH agent forwarding.
+
+*   `src` (string[]): An array of file or directory paths on this (source) remote host.
+*   `dstHostInfo` (Object): Destination host information (requires `host` property; optionally `user`, `port`, `noStrictHostKeyChecking`).
+*   `dst` (string): Destination path on the destination remote host.
+*   `opt` (string[], optional): Additional options for rsync (e.g., `["--exclude=*.log"]`).
+*   `timeout` (number, optional): Timeout in seconds.
+*   Returns: `Promise<void>`
+
+**Note:** This method requires SSH agent forwarding to be enabled. Your SSH key must be loaded in the SSH agent on localhost, and the connection to the source host must forward the agent. No password or keyFile is needed for the source → destination connection as it uses the forwarded SSH agent.
+
+**Example:**
+```javascript
+const srcHost = new SshClientWrapper({
+  host: 'source.server.com',
+  user: 'user1',
+  keyFile: '/path/to/key'
+});
+
+const dstHostInfo = {
+  host: 'destination.server.com',
+  user: 'user2'
+};
+
+// Copy files directly from source to destination
+await srcHost.remoteToRemoteCopy(
+  ['/remote/path/file.txt', '/remote/path/dir/'],
+  dstHostInfo,
+  '/destination/path/',
+  ['--exclude=*.tmp']
+);
+```
+
 ### `.canConnect([timeout])`
 Checks if a connection to the remote host can be established.
 

package/lib/index.d.ts

@@ -11,6 +11,8 @@ declare module "ssh-client-wrapper" {
     ConnectTimeout?: number;
     maxRetry?: number;
     retryDuration?: number;
+    retryableExitCodes?: number[];
+    replaceRetryableExitCodes?: boolean;
     rcfile?: string;
     prependCmd?: string;
     sshOpt?: string[];
@@ -45,13 +47,17 @@ declare module "ssh-client-wrapper" {
       src: string[],
       dst: string,
       opt?: string[],
-      timeout?: number
+      timeout?: number,
+      retryableExitCodes?: number[],
+      replaceRetryableExitCodes?: boolean
     ): Promise<void>;
     recv(
       src: string[],
       dst: string,
       opt?: string[],
-      timeout?: number
+      timeout?: number,
+      retryableExitCodes?: number[],
+      replaceRetryableExitCodes?: boolean
     ): Promise<void>;
     canConnect(timeout?: number): Promise<boolean>;
     disconnect(): Promise<void>;

package/lib/index.js

@@ -3,7 +3,7 @@ import path from "path";
 import Debug from "debug";
 import * as sshExecModule from "./sshExec.js";
 import * as rsyncExecModule from "./rsyncExec.js";
-import { isArrayOfString, sanityCheck } from "./util.js";
+import { isArrayOfString, isArrayOfInteger, sanityCheck } from "./util.js";
 
 const debug = Debug("sshClientWrapper:debug:interface");
 const debugVerbose = Debug("sshClientWrapper:verbose:interface");
@@ -30,6 +30,8 @@ const debugVerbose = Debug("sshClientWrapper:verbose:interface");
  * @param {Integer} hostInfo.ConnectTimeout - timeout used when connectiong to ths SSH server
  * @param {Integer} hostInfo.maxRetry - max number of retry
  * @param {Integer} hostInfo.retryDuration - duration time (msec) between each retry
+ * @param {number[]} hostInfo.retryableExitCodes - rsync exit codes to treat as retryable for send/recv, in addition to the built-in default (unless hostInfo.replaceRetryableExitCodes is true)
+ * @param {boolean} hostInfo.replaceRetryableExitCodes - if true, hostInfo.retryableExitCodes replaces the built-in default set of retryable rsync exit codes instead of merging with it
  * @param {string} hostInfo.rcfile - rcfile path which will be sourced before executing actual command
  * @param {string} hostInfo.prependCmd - command string which will be executed before executing actual command
  * @param {string[]} hostInfo.sshOpt - additional options for ssh
@@ -149,9 +151,11 @@ class SshClientWrapper {
    * @param {string} dst - Destination path.
    * @param {string[]} opt - option for rsync
    * @param {Integer} timeout - timeout in secconds
+   * @param {number[]} retryableExitCodes - rsync exit codes to treat as retryable for this call (overrides hostInfo.retryableExitCodes)
+   * @param {boolean} replaceRetryableExitCodes - if true, retryableExitCodes replaces the default set instead of merging with it
    * @returns {Promise} - Resolved with undefined when file transfer is done.
    */
-  async send(src, dst, opt = [], timeout = 0) {
+  async send(src, dst, opt = [], timeout = 0, retryableExitCodes = null, replaceRetryableExitCodes = false) {
     debug("send called", src, dst, opt);
 
     if (!isArrayOfString(src)) {
@@ -171,7 +175,13 @@ class SshClientWrapper {
     if (typeof opt !== "undefined" && !isArrayOfString(opt)) {
       return logAndReject("opt must be array of string");
     }
-    return this.deps.send(this.hostInfo, src, dst, opt, timeout);
+    if (retryableExitCodes !== null && !isArrayOfInteger(retryableExitCodes)) {
+      return logAndReject("retryableExitCodes must be array of integer");
+    }
+    if (typeof replaceRetryableExitCodes !== "boolean") {
+      return logAndReject("replaceRetryableExitCodes must be boolean");
+    }
+    return this.deps.send(this.hostInfo, src, dst, opt, timeout, retryableExitCodes, replaceRetryableExitCodes);
   }
 
   /**
@@ -180,9 +190,11 @@ class SshClientWrapper {
    * @param {string} dst - Destination path.
    * @param {string[]} opt - option for rsync
    * @param {Integer} timeout - timeout in secconds
+   * @param {number[]} retryableExitCodes - rsync exit codes to treat as retryable for this call (overrides hostInfo.retryableExitCodes)
+   * @param {boolean} replaceRetryableExitCodes - if true, retryableExitCodes replaces the default set instead of merging with it
    * @returns {Promise} - Resolved with undefined when file transfer is done.
    */
-  async recv(src, dst, opt = [], timeout = 0) {
+  async recv(src, dst, opt = [], timeout = 0, retryableExitCodes = null, replaceRetryableExitCodes = false) {
     debug("recv called", src, dst, opt);
 
     if (!isArrayOfString(src)) {
@@ -202,7 +214,13 @@ class SshClientWrapper {
     if (typeof opt !== "undefined" && !isArrayOfString(opt)) {
       return logAndReject("opt must be array of string");
     }
-    return this.deps.recv(this.hostInfo, src, dst, opt, timeout);
+    if (retryableExitCodes !== null && !isArrayOfInteger(retryableExitCodes)) {
+      return logAndReject("retryableExitCodes must be array of integer");
+    }
+    if (typeof replaceRetryableExitCodes !== "boolean") {
+      return logAndReject("replaceRetryableExitCodes must be boolean");
+    }
+    return this.deps.recv(this.hostInfo, src, dst, opt, timeout, retryableExitCodes, replaceRetryableExitCodes);
   }
 
   /**
@@ -220,6 +238,42 @@ class SshClientWrapper {
     return this.deps.canConnect(this.hostInfo, timeout);
   }
 
+  /**
+   * Copy files directly from this remote host to another remote host using SSH agent forwarding.
+   * @param {string[]} src - File or directory paths on this (source) remote host.
+   * @param {object} dstHostInfo - Destination host information (needs host and user properties).
+   * @param {string} dst - Destination path on the destination remote host.
+   * @param {string[]} opt - options for rsync
+   * @param {Integer} timeout - timeout in seconds
+   * @returns {Promise} - Resolved when file transfer is done.
+   * 
+   * Note: This requires SSH agent forwarding to be available.
+   * The SSH agent on localhost must be forwarded to the source host,
+   * and then forwarded again to the destination host.
+   */
+  async remoteToRemoteCopy(src, dstHostInfo, dst, opt = [], timeout = 0) {
+    debug("remoteToRemoteCopy called", src, "to", dstHostInfo.host, dst);
+
+    if (!isArrayOfString(src)) {
+      return logAndReject("src must be array of string");
+    }
+    if (!src.some((e)=>{
+      return e !== "";
+    })) {
+      return logAndReject("src must contain non-empty string");
+    }
+    if (typeof dstHostInfo !== "object" || !dstHostInfo.host) {
+      return logAndReject("dstHostInfo must be object with host property");
+    }
+    if (typeof dst !== "string" || dst === "") {
+      return logAndReject("dst must be non-empty string");
+    }
+    if (typeof opt !== "undefined" && !isArrayOfString(opt)) {
+      return logAndReject("opt must be array of string");
+    }
+    return this.deps.remoteToRemoteCopy(this.hostInfo, src, dstHostInfo, dst, opt, timeout);
+  }
+
   /**
    * Disconnect master session
    */

package/lib/rsyncExec.js

@@ -6,7 +6,7 @@ import { glob, hasMagic } from "glob";
 import { connect, retryWrapper, sshExec } from "./sshExec.js";
 import { fork } from "./fork.js";
 
-import { sshCmd, rsyncCmd, acceptableRsyncRetrunCodes, getSshOption } from "./util.js";
+import { sshCmd, rsyncCmd, getSshOption, resolveRetryableExitCodes } from "./util.js";
 
 const debug = Debug("sshClientWrapper:debug:rsyncExec");
 const debugVerbose = Debug("sshClientWrapper:verbose:rsyncExec");
@@ -32,10 +32,12 @@ export async function checkRsyncVersion(timeout) {
  * @param {string} dst - Destination path.
  * @param {[string]} rsyncOpt - optional arguments for rsync
  * @param {Integer} timeout - timeout in secconds
+ * @param {number[]} retryableExitCodes - rsync exit codes to treat as retryable for this call (overrides hostInfo-level setting)
+ * @param {boolean} replaceRetryableExitCodes - if true, retryableExitCodes replaces the default instead of merging with it
  *
  * this function execute rsync -avv --copy-unsafe-links  src rsync://[user@]host[:port]/dst
  */
-export async function send(hostInfo, argSrc, dst, rsyncOpt, timeout) {
+export async function send(hostInfo, argSrc, dst, rsyncOpt, timeout, retryableExitCodes, replaceRetryableExitCodes) {
   await connect(hostInfo);
   const promises = await Promise.allSettled(argSrc.map((e)=>{
     return glob(e);
@@ -81,7 +83,8 @@ export async function send(hostInfo, argSrc, dst, rsyncOpt, timeout) {
   }
   debug(`send ${src} to ${hostInfo.host}:${dst}`);
   debugVerbose(`send: ${rsyncCmd} ${args.join(" ")}`);
-  return retryWrapper(fork.bind(null, hostInfo, rsyncCmd, args, timeout, null, acceptableRsyncRetrunCodes), hostInfo);
+  const exitCodes = resolveRetryableExitCodes(hostInfo, retryableExitCodes, replaceRetryableExitCodes);
+  return retryWrapper(fork.bind(null, hostInfo, rsyncCmd, args, timeout, null, exitCodes), hostInfo);
 }
 
 /**
@@ -106,10 +109,12 @@ async function isNewRsync(hostInfo) {
  * @param {string} dst - Destination path.
  * @param {[string]} rsyncOpt - optional arguments for rsync
  * @param {Integer} timeout - timeout in secconds
+ * @param {number[]} retryableExitCodes - rsync exit codes to treat as retryable for this call (overrides hostInfo-level setting)
+ * @param {boolean} replaceRetryableExitCodes - if true, retryableExitCodes replaces the default instead of merging with it
  *
  * this function execute rsync -av --copy-unsafe-links  rsync://[user@]host[:port]/src dst
  */
-export async function recv(hostInfo, argSrc, dst, rsyncOpt, timeout) {
+export async function recv(hostInfo, argSrc, dst, rsyncOpt, timeout, retryableExitCodes, replaceRetryableExitCodes) {
   await connect(hostInfo);
   const src = `${hostInfo.host}:${argSrc.join(" ")}`;
   const sshArgs = getSshOption(hostInfo, true);
@@ -125,5 +130,73 @@ export async function recv(hostInfo, argSrc, dst, rsyncOpt, timeout) {
 
   debug(`recv ${src} to ${dst}`);
   debugVerbose(`recv: ${rsyncCmd} ${args.join(" ")}`);
-  return retryWrapper(fork.bind(null, hostInfo, rsyncCmd, args, timeout, null, acceptableRsyncRetrunCodes), hostInfo);
+  const exitCodes = resolveRetryableExitCodes(hostInfo, retryableExitCodes, replaceRetryableExitCodes);
+  return retryWrapper(fork.bind(null, hostInfo, rsyncCmd, args, timeout, null, exitCodes), hostInfo);
+}
+
+/**
+ * Copy files directly between remote hosts using rsync over SSH with agent forwarding.
+ * This function executes rsync on the source remote host to transfer files directly
+ * to the destination remote host, avoiding the need to download and upload through localhost.
+ * @param {object} srcHostInfo - source host information object
+ * @param {string[]} argSrc - File or directory paths on the source remote host
+ * @param {object} dstHostInfo - destination host information object (needs host and user properties)
+ * @param {string} dst - Destination path on the destination remote host
+ * @param {string[]} rsyncOpt - optional arguments for rsync
+ * @param {Integer} timeout - timeout in seconds
+ * @returns {Promise} - Resolved when transfer is complete
+ *
+ * Authentication from source to destination uses SSH agent forwarding,
+ * so dstHostInfo does not need keyFile or password.
+ */
+export async function remoteToRemoteCopy(srcHostInfo, argSrc, dstHostInfo, dst, rsyncOpt, timeout) {
+  await connect(srcHostInfo);
+  
+  //Construct destination specification for rsync: user@host:path
+  let dstSpec = dstHostInfo.host;
+  if (dstHostInfo.user) {
+    dstSpec = `${dstHostInfo.user}@${dstHostInfo.host}`;
+  }
+  dstSpec = `${dstSpec}:${dst}`;
+  
+  //Build SSH options for the nested SSH connection (from src to dst)
+  const nestedSshArgs = ["-A"]; //Enable agent forwarding
+  
+  if (dstHostInfo.port) {
+    nestedSshArgs.push("-p", dstHostInfo.port.toString());
+  }
+  if (dstHostInfo.noStrictHostKeyChecking) {
+    nestedSshArgs.push("-oStrictHostKeyChecking=no");
+  }
+  
+  //Build rsync command to be executed on the source host
+  const rshOpt = `-e '${sshCmd} ${nestedSshArgs.join(" ")}'`;
+  const rsyncOptStr = rsyncOpt.length > 0 ? rsyncOpt.join(" ") : "";
+  const srcPaths = argSrc.join(" ");
+  
+  //Create destination directory on the destination host
+  let remoteMkdirCmd = "";
+  if (dst.endsWith("/")) {
+    remoteMkdirCmd = `mkdir -p ${dst}`;
+  } else {
+    const { dir } = path.parse(dst);
+    if (dir !== "" && dir !== "/") {
+      remoteMkdirCmd = `mkdir -p ${dir}`;
+    }
+  }
+  
+  if (remoteMkdirCmd) {
+    //Execute mkdir on destination host via source host with agent forwarding
+    const dstUser = dstHostInfo.user ? `${dstHostInfo.user}@` : "";
+    const mkdirSshCmd = `${sshCmd} -A ${nestedSshArgs.filter(arg=>{return arg !== "-A";}).join(" ")} ${dstUser}${dstHostInfo.host} '${remoteMkdirCmd}'`;
+    debug(`creating remote directory: ${mkdirSshCmd}`);
+    await sshExec(srcHostInfo, mkdirSshCmd, timeout, debugVerbose);
+  }
+  
+  //Execute rsync on source host
+  const rsyncRemoteCmd = `rsync -avv --copy-unsafe-links ${rshOpt} ${rsyncOptStr} ${srcPaths} ${dstSpec}`;
+  debug(`remote to remote copy: ${rsyncRemoteCmd}`);
+  debugVerbose(`executing on ${srcHostInfo.host}: ${rsyncRemoteCmd}`);
+  
+  return sshExec(srcHostInfo, rsyncRemoteCmd, timeout, debugVerbose);
 }

package/lib/util.js

@@ -42,6 +42,11 @@ const hostInfoSchema = {
     ControlPersistDir: { type: "string", pattern: "\\S+", transform: ["trim"] },
     maxRetry: { type: "number", minimum: 0, default: 3 },
     retryDuration: { type: "number", minimum: 0, default: 1000 },
+    retryableExitCodes: {
+      type: "array",
+      items: { type: "integer" }
+    },
+    replaceRetryableExitCodes: { type: "boolean" },
     rcfile: { type: "string", pattern: "\\S+", transform: ["trim"] },
     prependCmd: { type: "string", pattern: "\\S+", transform: ["trim"] },
     sshOpt: {
@@ -201,6 +206,12 @@ export const getSshOption = (hostInfo, withoutDestination)=>{
   if (hostInfo.noStrictHostKeyChecking) {
     args.push("-oStrictHostKeyChecking=no");
   }
+  
+  //Enable SSH agent forwarding if keyFile is set (indicates we're using key-based auth)
+  if (hostInfo.keyFile) {
+    args.push("-A");
+  }
+  
   const controlPersist = Number.isInteger(hostInfo.ControlPersist) && hostInfo.ControlPersist >= 0 ? hostInfo.ControlPersist : "180";
   const controlPersistDir = getControlPersistDir(hostInfo);
   args.push("-oControlMaster=auto");
@@ -229,6 +240,39 @@ export const isArrayOfString = (target)=>{
   });
 };
 
+export const isArrayOfInteger = (target)=>{
+  if (!Array.isArray(target)) {
+    return false;
+  }
+  return !target.some((e)=>{
+    //target has non integer member
+    return !Number.isInteger(e);
+  });
+};
+
+/**
+ * resolve which rsync exit codes should be treated as retryable for a single send/recv call
+ * @param {object} hostInfo - hostinfo object
+ * @param {number[]} methodCodes - retryableExitCodes argument passed directly to send/recv (highest priority)
+ * @param {boolean} methodReplace - replaceRetryableExitCodes argument passed directly to send/recv
+ * @returns {number[]} - exit codes which should be treated as retryable
+ *
+ * precedence: method-level argument (if given) fully supersedes hostInfo-level settings.
+ * at whichever level is used, replace=false (default) merges with acceptableRsyncRetrunCodes,
+ * replace=true uses the given codes verbatim (so [] disables exit-code-based retry entirely).
+ */
+export const resolveRetryableExitCodes = (hostInfo, methodCodes, methodReplace)=>{
+  if (methodCodes != null) {
+    return methodReplace ? methodCodes : [...acceptableRsyncRetrunCodes, ...methodCodes];
+  }
+  if (hostInfo.retryableExitCodes != null) {
+    return hostInfo.replaceRetryableExitCodes
+      ? hostInfo.retryableExitCodes
+      : [...acceptableRsyncRetrunCodes, ...hostInfo.retryableExitCodes];
+  }
+  return acceptableRsyncRetrunCodes;
+};
+
 /**
  * log and send message to pty
  * @param {object} pty - pty object which message will be send to

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ssh-client-wrapper",
-  "version": "2.14.0",
+  "version": "2.16.0",
   "description": "wrapper library for open ssh client and rsync",
   "keywords": [
     "ssh",
@@ -34,11 +34,14 @@
   "lint-staged": {
     "*.js": "eslint --fix"
   },
+  "overrides": {
+    "@semantic-release/npm": "^13.1.0"
+  },
   "dependencies": {
     "ajv": "^8.17.1",
     "ajv-keywords": "^5.1.0",
     "debug": "^4.4.3",
-    "glob": "^11.0.3",
+    "glob": "^12.0.0",
     "node-pty-prebuilt-multiarch": "^0.10.1-pre.5"
   },
   "devDependencies": {
@@ -46,11 +49,12 @@
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/git": "^10.0.1",
     "@semantic-release/github": "^11.0.4",
-    "@semantic-release/npm": "^12.0.2",
+    "@semantic-release/npm": "^13.1.0",
     "@stylistic/eslint-plugin": "^5.2.3",
     "c8": "^10.1.3",
     "chai": "^5.3.1",
     "chai-as-promised": "^8.0.1",
+    "eslint-plugin-chai-expect": "^3.1.0",
     "eslint-plugin-chai-friendly": "^1.1.0",
     "eslint-plugin-jsdoc": "^54.1.0",
     "eslint-plugin-node": "^11.1.0",