uzdu 1.0.17 → 1.1.0

package/README.md

@@ -29,19 +29,19 @@ bunx uzdu -h
 
 ### uploading
 
-- [Amazon S3](https://docs.aws.amazon.com/s3/) `npx uzdu upload aws -h`
-- [Azure Blob Storage](https://azure.microsoft.com/en-us/products/storage/blobs) `npx uzdu upload az -h`
-- [Nexus](https://support.sonatype.com/hc/en-us/articles/115006744008-Repository-How-can-I-programmatically-upload-files-into-Nexus-3#DirectUploadusingHTTPPUTtotheRepositoryPath) `npx uzdu upload http -h`
-- SSH/SCP `npx uzdu upload ssh -h`
+- [Amazon S3](https://docs.aws.amazon.com/s3/) `npx uzdu upload aws --dotenv /projects/environments/test.env -- build/index.html -- uzdu:ru-central1-d:http://storage.yandexcloud.net`
+- [Azure Blob Storage](https://azure.microsoft.com/en-us/products/storage/blobs) `AZURE_STORAGE_CONNECTION_STRING=...; npx uzdu upload azure build/ $web`
+- [Nexus](https://support.sonatype.com/hc/en-us/articles/115006744008-Repository-How-can-I-programmatically-upload-files-into-Nexus-3#DirectUploadusingHTTPPUTtotheRepositoryPath) `npx upload http --header "Authorization: Basic TOKEN=" -- website.zip https://nexus/repository/private-raw/dist/test-uzdu/website.zip",`
+- SSH/SFTP `npx uzdu upload ssh /projects/website/build/ sftp://root:password@example.localtest.me/var/www/html/`
 
 ### downloading
 
-- http `npx uzdu download http -h`
+- http `npx uzdu download http --dotenv --header \"Authorization: Basic TOKEN=\" https://nexus/repository/private-raw/dist/test-uzdu/website.zip website.zip`
 
 ### working with zip-archives
 
-- zip `npx uzdu zip -h`
-- unzip `npx uzdu unzip -h`
+- zip `npx uzdu zip build/ ./build.zip`
+- unzip `npx uzdu unzip /tmp/repo.zip ./src`
 
 
 ## For developers

package/lib/{chunk-VO6FBXH2.js → chunk-463DKYHI.js}

@@ -3,8 +3,9 @@ import {
   getEnvironment,
   initEnvironment,
   listFiles,
-  resolvePath
-} from "./chunk-OIXJ4D3Z.js";
+  resolvePath,
+  runSequentially
+} from "./chunk-WWXWWCCX.js";
 
 // src/azure.ts
 var azure_exports = {};
@@ -95,7 +96,12 @@ async function upload2(dir, s3config, metadataFile = ".metadata.json") {
   }
   await Promise.all(Object.entries(files).map(async ([file, absFile]) => {
     const filePath = absFile;
-    const fileContent = fs2.readFileSync(filePath);
+    const fileContent = await new Promise((resolve, reject) => {
+      fs2.readFile(filePath, (err, data) => {
+        if (err) reject(err);
+        else resolve(data);
+      });
+    });
     const params = {
       Bucket: s3config.bucket,
       Key: file,
@@ -126,6 +132,7 @@ async function upload2(dir, s3config, metadataFile = ".metadata.json") {
 // src/ssh.ts
 var ssh_exports = {};
 __export(ssh_exports, {
+  execute: () => execute,
   getConnectConfig: () => getConnectConfig,
   getCredentials: () => getCredentials,
   getDirMap: () => getDirMap,
@@ -137,26 +144,29 @@ import { Client } from "ssh2";
 import fs3 from "fs";
 import path3 from "path";
 import deepmerge from "deepmerge";
-async function upload3(source, sftpUrl, sshCredentials) {
+async function upload3(source, sftpUrl, options) {
   await new Promise((resolve, reject) => {
     fs3.stat(source, async (err, stats) => {
+      if (err) {
+        reject(err);
+        return;
+      }
       if (stats.isSymbolicLink()) {
         reject(new Error(`${source} is symlink`));
       } else {
         let sshConnection;
         try {
           const _connectConfig = getConnectConfig(sftpUrl);
-          const _sshCredentials = sshCredentials || getCredentials();
+          const _sshCredentials = _connectConfig.password ? void 0 : getCredentials(options);
           const connectConfig = { ..._connectConfig, ..._sshCredentials };
           sshConnection = await connect(connectConfig);
           const files = await listFiles(source);
-          const destination = getRemoteDestination(sftpUrl);
+          const destination = normilizeSftpPath(_connectConfig.path) || "";
           const _source = source.replace(/\/+$/, "");
           await mkdirs(sshConnection, destination, files);
           await uploadFiles(files, _source, destination, sshConnection);
           resolve();
         } catch (e) {
-          console.error("SFTP error", e);
           reject(e);
         } finally {
           sshConnection?.destroy();
@@ -165,22 +175,69 @@ async function upload3(source, sftpUrl, sshCredentials) {
     });
   });
 }
+async function execute(sshAddress, commands, options) {
+  await new Promise(async (resolve, reject) => {
+    let sshConnection;
+    try {
+      const _connectConfig = getConnectConfig(sshAddress);
+      const _sshCredentials = _connectConfig.password ? void 0 : getCredentials(options);
+      const connectConfig = { ..._connectConfig, ..._sshCredentials };
+      sshConnection = await connect(connectConfig);
+      const shellOptions = {
+        ...options,
+        cwd: normilizeSftpPath(_connectConfig.path)
+      };
+      await shellExec(sshConnection, commands, shellOptions);
+      resolve();
+    } catch (e) {
+      reject(e);
+    } finally {
+      sshConnection?.destroy();
+    }
+  });
+}
 async function mkdirs(sshConnection, destination, sources) {
   const fileMap = getDirMap(sources);
   const makeDirs = getMakeDirs(fileMap, destination);
   const commands = makeDirs ? makeDirs.map((dir) => `mkdir -p "${dir}"`) : [`mkdir -p "${destination}"`];
-  const commandLine = commands.length > 1 ? commands.join(";") : commands[0];
-  await new Promise((res, rej) => {
-    sshConnection.exec(commandLine, {}, (err, channel) => {
-      if (err) {
-        console.error("mkdir error", err);
-        rej(new Error(`failed: mkdir -p ... : ${err}`));
-      } else {
-        channel.on("exit", (code, signal) => {
-          if (code != 0) rej(new Error(`Exit code: ${code} for "mkdir -p ..."`));
-          else res();
-        });
-      }
+  await shellExec(sshConnection, commands);
+}
+async function shellExec(sshConnection, commands, options) {
+  if (!commands) {
+    return Promise.reject("shellExec did not get any command");
+  }
+  if (options?.cwd) {
+    const command = `set -e; cd ${options.cwd}; set +e; ${commands.join(";")}`;
+    await shellCommand(sshConnection, command, options);
+  } else {
+    const shellCommands = commands.map((command) => () => shellCommand(sshConnection, command, options));
+    await runSequentially(shellCommands);
+  }
+}
+async function shellCommand(sshClient, command, options) {
+  return new Promise((res, rej) => {
+    const decoder = new TextDecoder();
+    sshClient.exec(command, (err, stream) => {
+      if (err) rej(err);
+      stream.on("close", (code, signal) => {
+        if (code != 0) {
+          options?.callback?.({ error: `closing SSH by signal=${signal} and exit code=${code}`, code, signal });
+          rej(new Error(`Close code ${code}`));
+        } else {
+          res(code);
+        }
+      }).on("exit", (code, signal) => {
+        if (code != 0) {
+          options?.callback?.({ error: `Exit command signal=${signal} and exit code=${code}`, code, signal });
+          rej(new Error(`Exit code ${code}`));
+        } else {
+          res(code);
+        }
+      }).on("data", (message) => {
+        options?.callback?.({ message: decoder.decode(message).replace(/\n$/, "") });
+      }).stderr.on("data", (error) => {
+        options?.callback?.({ error: decoder.decode(error) });
+      });
     });
   });
 }
@@ -210,16 +267,14 @@ function uploadFiles(sourceFiles, source, destination, sshConnection) {
   return new Promise((resolve, reject) => {
     sshConnection.sftp(async (err, sftp) => {
       if (err) {
-        console.error("uploadFiles error");
         reject(err);
       } else {
         if (Object.keys(sourceFiles).length == 1) {
           const lstat2 = fs3.lstatSync(source);
           if (lstat2.isFile()) {
-            const dest = path3.join(destination, sourceFiles[0]).replace(/\\/g, "/");
+            const dest = path3.join(destination, Object.keys(sourceFiles)[0]).replace(/\\/g, "/");
             const src = source;
             await _uploadFile(src, dest, sftp).then(() => resolve()).catch((e) => {
-              console.error(src);
               reject(e);
             });
             return;
@@ -235,8 +290,6 @@ function uploadFiles(sourceFiles, source, destination, sshConnection) {
           const dest = path3.join(destination, baseName).replace(/\\/g, "/");
           const promise = new Promise((res, rej) => {
             _uploadFile(absPath, dest, sftp).then(() => res()).catch((e) => {
-              console.error(absPath);
-              console.error(e);
               rej(e);
             });
           });
@@ -253,7 +306,7 @@ async function connect(sshConfig) {
   try {
     return await new Promise((resolve, reject) => {
       conn.on("error", (e) => {
-        reject(new Error(`Target host error: ${e}`));
+        reject(e);
       }).on("ready", () => {
         resolve(conn);
       }).connect({
@@ -273,7 +326,6 @@ async function connect(sshConfig) {
       });
     });
   } catch (e) {
-    console.error("Connection failed", e);
     conn.destroy();
     throw e;
   }
@@ -333,7 +385,7 @@ function getCredentials(options) {
       }
     } else {
       const uzduPassword = process.env.UZDU_SSH_PASSWORD;
-      if (!uzduPassword) throw new Error("Specify either --privateKeyPath or password in SFTP URL. Otherwise consider using --dotenv and one of environment variables: UZDU_SSH_KEY_PATH, UZDU_SSH_KEY, UZDU_SSH_PASSWORD");
+      if (!uzduPassword) throw new Error("Specify password in SFTP URL. Otherwise consider using one of environment variables: UZDU_SSH_KEY_PATH, UZDU_SSH_KEY, UZDU_SSH_PASSWORD");
       password = uzduPassword;
     }
   }
@@ -345,17 +397,34 @@ function getCredentials(options) {
   return authConfig;
 }
 var sftpUrlRegex = /^sftp:\/\/(?:(?<username>[\w\.\-]{1,32})(?::(?<password>.+))?@)?(?:(?<host>[\w\.\-]+)|\[(?<ipv6>[\d:]+)\])(?::(?<port>\d{1,5}))?\/(?<path>.*)$/g;
-function getConnectConfig(sftpUrl) {
+var sshUrlRegex = /^(?:(?<username>[\w\.\-]{1,32})(?::(?<password>.+))?@)?(?:(?<host>[\w\.\-]+)|\[(?<ipv6>[\d:]+)\])(?::(?<port>\d{1,5}))?$/g;
+var suspectSftpRegex = /^sftp:\/\/.+/g;
+function getConnectConfig(url) {
+  let execArray;
+  sshUrlRegex.lastIndex = 0;
   sftpUrlRegex.lastIndex = 0;
-  const execArray = sftpUrlRegex.exec(sftpUrl);
+  if (sftpUrlRegex.test(url)) {
+    sftpUrlRegex.lastIndex = 0;
+    execArray = sftpUrlRegex.exec(url);
+  } else if (sshUrlRegex.test(url)) {
+    sshUrlRegex.lastIndex = 0;
+    suspectSftpRegex.lastIndex = 0;
+    if (suspectSftpRegex.test(url)) {
+      throw new Error(`SSH URL starts with "sftp://". If it is sftp URL, then add trailing slash after hostname[:port] - ${url}/, if it is SSH URL, consider password that does not start with 2 slashes.`);
+    }
+    execArray = sshUrlRegex.exec(url);
+  } else {
+    throw new Error(`Not an SFTP or SSH address: ${url}`);
+  }
   const { groups } = execArray ?? {};
   const host = groups?.host || groups?.ipv6;
-  if (!host) throw new Error(`Wrong URL "${sftpUrl}": host or ivp6 is not specified`);
+  if (!host) throw new Error(`Wrong URL "${url}": host or ivp6 is not specified`);
   const username = groups?.username;
   const password = groups?.password;
+  const path4 = groups?.path;
   const _port = parseInt(groups.port);
   const port = isNaN(_port) ? void 0 : _port;
-  const connectConfig = { username, password, host, port };
+  const connectConfig = { username, password, host, port, path: path4 };
   return connectConfig;
 }
 function getRemoteDestination(sftpUrl) {
@@ -364,21 +433,27 @@ function getRemoteDestination(sftpUrl) {
   if (!execArray) throw new Error("Wrong sftp URL");
   if (!execArray.groups) throw new Error("Wrong URL: path is not specified");
   const path4 = execArray.groups.path;
-  const re = /^(?<first>[^\/]+)(?:\/)?(?<second>.*)?/g;
+  return normilizeSftpPath(execArray.groups?.path) || "";
+}
+function normilizeSftpPath(path4) {
+  if (path4 == void 0) return void 0;
+  const re = /^(?<first>[^\/]*)(?<root>\/)?(?<second>.*)?/g;
   re.lastIndex = 0;
   const execPathArray = re.exec(path4);
   const { groups } = execPathArray ?? {};
   const first = groups?.first;
   const second = groups?.second;
+  const root = groups?.root;
   let dest;
   if (first) {
     const execTild = /^(?<tild>~)/.exec(first);
     const { groups: groups2 } = execTild ?? {};
-    dest = groups2?.tild ? `./${second}` : `/${first}${second ? `/${second}` : ""}`;
+    dest = groups2?.tild ? `${second ? second : ""}` : `/${first}${second ? `/${second}` : ""}`;
   } else {
-    dest = path4;
+    if (!root && !second) dest = "/";
+    else dest = path4;
   }
-  const destination = dest.replace(/\/+$/, "");
+  const destination = dest != "/" ? dest.replace(/\/+$/, "") : dest;
   return destination;
 }
 
@@ -388,6 +463,5 @@ export {
   upload2,
   s3_exports,
   upload3,
-  getCredentials,
   ssh_exports
 };

package/lib/{chunk-7B56UNA6.js → chunk-LFEIDM4S.js}

@@ -1,7 +1,7 @@
 import {
   __export,
   listFiles
-} from "./chunk-OIXJ4D3Z.js";
+} from "./chunk-WWXWWCCX.js";
 
 // src/http.ts
 var http_exports = {};

package/lib/{chunk-OIXJ4D3Z.js → chunk-WWXWWCCX.js}

@@ -7,6 +7,7 @@ var __export = (target, all) => {
 // src/utils.ts
 var utils_exports = {};
 __export(utils_exports, {
+  SequentilRunError: () => SequentilRunError,
   addMetadata: () => addMetadata,
   checkIsFile: () => checkIsFile,
   doUnzip: () => doUnzip,
@@ -17,6 +18,7 @@ __export(utils_exports, {
   makeZip: () => makeZip,
   outputConfiguration: () => outputConfiguration,
   resolvePath: () => resolvePath,
+  runSequentially: () => runSequentially,
   safeIndex: () => safeIndex,
   shouldBeDirectory: () => shouldBeDirectory,
   shouldBeFile: () => shouldBeFile
@@ -230,6 +232,35 @@ function parseEnvironment(src) {
   }
   return obj;
 }
+async function runSequentially(tasks, breaksOnError = true) {
+  const results = [];
+  for (let i = 0; i < tasks.length; i++) {
+    try {
+      const result = await tasks[i]();
+      results.push(result);
+    } catch (err) {
+      if (breaksOnError) throw new SequentilRunError(i, `${err.message || err}`);
+      else {
+        console.error(`Error in #${i}: ${err.message || err}`);
+        results.push(null);
+      }
+    }
+  }
+  ;
+  return results;
+}
+var SequentilRunError = class extends Error {
+  /**
+   * 
+   * @param message Text of the error
+   * @param index where in the sequense the error happened
+   */
+  constructor(index, message = "Sequential Error") {
+    super(message);
+    this.index = index;
+    this.message = message;
+  }
+};
 
 export {
   __export,
@@ -243,5 +274,6 @@ export {
   shouldBeDirectory,
   outputConfiguration,
   resolvePath,
+  runSequentially,
   utils_exports
 };

package/lib/uzdu-copy.js

@@ -2,7 +2,7 @@
 import {
   checkIsFile,
   outputConfiguration
-} from "./chunk-OIXJ4D3Z.js";
+} from "./chunk-WWXWWCCX.js";
 
 // src/uzdu-copy.ts
 import { Command } from "commander";

package/lib/uzdu-download.js

@@ -1,11 +1,11 @@
 import {
   download
-} from "./chunk-7B56UNA6.js";
+} from "./chunk-LFEIDM4S.js";
 import {
   getEnvironment,
   initEnvironment,
   outputConfiguration
-} from "./chunk-OIXJ4D3Z.js";
+} from "./chunk-WWXWWCCX.js";
 
 // src/uzdu-download.ts
 import { Command, Option } from "commander";

package/lib/uzdu-metadata.js

@@ -2,7 +2,7 @@ import {
   addMetadata,
   outputConfiguration,
   shouldBeDirectory
-} from "./chunk-OIXJ4D3Z.js";
+} from "./chunk-WWXWWCCX.js";
 
 // src/uzdu-metadata.ts
 import { Argument, Command } from "commander";

package/lib/uzdu-unzip.js

@@ -2,7 +2,7 @@
 import {
   doUnzip,
   outputConfiguration
-} from "./chunk-OIXJ4D3Z.js";
+} from "./chunk-WWXWWCCX.js";
 
 // src/uzdu-unzip.ts
 import { Command } from "commander";

package/lib/uzdu-upload.js

@@ -1,19 +1,18 @@
 import {
-  getCredentials,
   upload as upload2,
   upload2 as upload3,
   upload3 as upload4
-} from "./chunk-VO6FBXH2.js";
+} from "./chunk-463DKYHI.js";
 import {
   upload
-} from "./chunk-7B56UNA6.js";
+} from "./chunk-LFEIDM4S.js";
 import {
   getEnvironment,
   initEnvironment,
   outputConfiguration,
   resolvePath,
   shouldBeDirectory
-} from "./chunk-OIXJ4D3Z.js";
+} from "./chunk-WWXWWCCX.js";
 
 // src/uzdu-upload.ts
 import { Argument, Command, Option } from "commander";
@@ -38,8 +37,8 @@ command.command("aws").description("upload to AWS S3").argument("<from>", "the d
     const optConfig = { bucket: bucketName, endpoint };
     if (region) optConfig.region = region;
     const config = Object.assign(env, optConfig);
-    if (!config.accessKeyId) throw new Error("AWS Access Key ID is not specified. Provide an environement variable S3_ACCESS_KEY_ID.");
-    if (!config.secretAccessKey) throw new Error("AWS Secret Key is not specified. Provide an environment variable S3_SECRET_ACCESS_KEY.");
+    if (!config.accessKeyId) throw new Error("AWS Access Key ID is not specified. Provide an environement variable AWS_ACCESS_KEY_ID.");
+    if (!config.secretAccessKey) throw new Error("AWS Secret Key is not specified. Provide an environment variable AWS_SECRET_ACCESS_KEY.");
     if (!config.region) throw new Error("AWS region is not specified. Provide it in a bucket address or as an envronment variable S3_REGION.");
     await upload3(from, config);
   } catch (e) {
@@ -72,7 +71,7 @@ command.command("azure").alias("az").description("upload to Azure Blob Storage")
     }
     const connectionString = process.env.AZURE_STORAGE_CONNECTION_STRING;
     if (!connectionString) {
-      throw new Error("AZURE_STORAGE_CONNECTION_STRING is absent in environment variables. Consider option --dotenv to laod it.");
+      throw new Error("AZURE_STORAGE_CONNECTION_STRING is absent in environment variables. Consider the command option --dotenv to load it from a file.");
     }
     shouldBeDirectory(from);
     const azOpt = {
@@ -88,10 +87,8 @@ command.command("ssh").description("upload via SFTP. In addition to sftpURL cons
   new Option("-d|--dotenv [file]", 'load environment variables from a property file, i.e. a file with "key=value" lines.').preset(".env")
 ).addOption(new Option("--privateKeyPath [path to file]", "Path to SSH private key, fallback is UZDU_SSH_KEY_PATH environment variable. Also consider using UZDU_SSH_KEY to provide SSH private key content or UZDU_SSH_PASSWORD.")).action(async (source, sftpUrl, options, thisCommand) => {
   try {
-    const sshCredentials = getCredentials(options);
-    await upload4(resolvePath(source), sftpUrl, sshCredentials);
+    await upload4(resolvePath(source), sftpUrl, options);
   } catch (e) {
-    console.error(e);
     thisCommand.error(e.message || e, { exitCode: 127, code: "ssh.upload.error" });
   }
 });

package/lib/uzdu-zip.js

@@ -2,7 +2,7 @@
 import {
   makeZip,
   outputConfiguration
-} from "./chunk-OIXJ4D3Z.js";
+} from "./chunk-WWXWWCCX.js";
 
 // src/uzdu-zip.ts
 import { Command } from "commander";

package/lib/uzdu.d.ts

@@ -73,8 +73,28 @@ declare function safeIndex<T>(arr: T[], index: number): T | undefined;
  * @return '/home/bob/GitHub/Repo/file.png'
  */
 declare function resolvePath(filePath: string): string;
+/**
+ * Sequential runner
+ * @param tasks array of functions to be executed sequentially
+ * @param breaksOnError breaks all if any function fails.
+ * @returns array of results
+ * @throws SequentialRunError
+ */
+declare function runSequentially(tasks: Function[], breaksOnError?: boolean): Promise<any[]>;
+declare class SequentilRunError extends Error {
+    readonly index: number;
+    readonly message: string;
+    /**
+     *
+     * @param message Text of the error
+     * @param index where in the sequense the error happened
+     */
+    constructor(index: number, message?: string);
+}
 
 type utils_BlobObject = BlobObject;
+type utils_SequentilRunError = SequentilRunError;
+declare const utils_SequentilRunError: typeof SequentilRunError;
 declare const utils_addMetadata: typeof addMetadata;
 declare const utils_checkIsFile: typeof checkIsFile;
 declare const utils_doUnzip: typeof doUnzip;
@@ -85,11 +105,12 @@ declare const utils_listFiles: typeof listFiles;
 declare const utils_makeZip: typeof makeZip;
 declare const utils_outputConfiguration: typeof outputConfiguration;
 declare const utils_resolvePath: typeof resolvePath;
+declare const utils_runSequentially: typeof runSequentially;
 declare const utils_safeIndex: typeof safeIndex;
 declare const utils_shouldBeDirectory: typeof shouldBeDirectory;
 declare const utils_shouldBeFile: typeof shouldBeFile;
 declare namespace utils {
-  export { type utils_BlobObject as BlobObject, utils_addMetadata as addMetadata, utils_checkIsFile as checkIsFile, utils_doUnzip as doUnzip, utils_getEnvironment as getEnvironment, utils_initEnvironment as initEnvironment, utils_listBlobs as listBlobs, utils_listFiles as listFiles, utils_makeZip as makeZip, utils_outputConfiguration as outputConfiguration, utils_resolvePath as resolvePath, utils_safeIndex as safeIndex, utils_shouldBeDirectory as shouldBeDirectory, utils_shouldBeFile as shouldBeFile };
+  export { type utils_BlobObject as BlobObject, utils_SequentilRunError as SequentilRunError, utils_addMetadata as addMetadata, utils_checkIsFile as checkIsFile, utils_doUnzip as doUnzip, utils_getEnvironment as getEnvironment, utils_initEnvironment as initEnvironment, utils_listBlobs as listBlobs, utils_listFiles as listFiles, utils_makeZip as makeZip, utils_outputConfiguration as outputConfiguration, utils_resolvePath as resolvePath, utils_runSequentially as runSequentially, utils_safeIndex as safeIndex, utils_shouldBeDirectory as shouldBeDirectory, utils_shouldBeFile as shouldBeFile };
 }
 
 declare function upload$3(dirOrFile: string, url: URL, headers?: string[]): Promise<void>;
@@ -132,7 +153,25 @@ type SshCredentials = {
     password?: undefined;
     privateKey: Buffer | string;
 };
-declare function upload(source: string, sftpUrl: string, sshCredentials?: SshCredentials): Promise<void>;
+type ShellCallbackParams = {
+    message?: string;
+    error?: string;
+    signal?: number;
+    code?: number;
+};
+type ShellCommandCallback = (value: ShellCallbackParams) => void;
+type SftpConnectConfig = ConnectConfig & {
+    path?: string;
+};
+declare function upload(source: string, sftpUrl: string, options?: {
+    privateKeyPath?: string;
+    dotenv?: string;
+}): Promise<void>;
+declare function execute(sshAddress: string, commands: string[], options?: {
+    privateKeyPath?: string;
+    dotenv?: string;
+    callback?: ShellCommandCallback;
+}): Promise<void>;
 type FileMapEntry = {
     [key: string]: false | FileMapEntry;
 };
@@ -163,12 +202,13 @@ declare function getCredentials(options?: {
  * sftp://ubuntu:pa55w0rd@example.com/opt/file
  * sftp://root@[2001:db8::5]:222/opt/file
  * sftp://203.0.113.5/opt/file
+ * root:pa55w0rd@example.com
  * ```
- * @param sftpUrl
+ * @param url
  *
  * @throws Wrong URL: host or ivp6 is not specified
  */
-declare function getConnectConfig(sftpUrl: string): ConnectConfig;
+declare function getConnectConfig(url: string): SftpConnectConfig;
 /**
  *
  * @param sftpUrl
@@ -178,7 +218,11 @@ declare function getConnectConfig(sftpUrl: string): ConnectConfig;
  */
 declare function getRemoteDestination(sftpUrl: string): string;
 
+type ssh_SftpConnectConfig = SftpConnectConfig;
+type ssh_ShellCallbackParams = ShellCallbackParams;
+type ssh_ShellCommandCallback = ShellCommandCallback;
 type ssh_SshCredentials = SshCredentials;
+declare const ssh_execute: typeof execute;
 declare const ssh_getConnectConfig: typeof getConnectConfig;
 declare const ssh_getCredentials: typeof getCredentials;
 declare const ssh_getDirMap: typeof getDirMap;
@@ -186,7 +230,7 @@ declare const ssh_getMakeDirs: typeof getMakeDirs;
 declare const ssh_getRemoteDestination: typeof getRemoteDestination;
 declare const ssh_upload: typeof upload;
 declare namespace ssh {
-  export { type ssh_SshCredentials as SshCredentials, ssh_getConnectConfig as getConnectConfig, ssh_getCredentials as getCredentials, ssh_getDirMap as getDirMap, ssh_getMakeDirs as getMakeDirs, ssh_getRemoteDestination as getRemoteDestination, ssh_upload as upload };
+  export { type ssh_SftpConnectConfig as SftpConnectConfig, type ssh_ShellCallbackParams as ShellCallbackParams, type ssh_ShellCommandCallback as ShellCommandCallback, type ssh_SshCredentials as SshCredentials, ssh_execute as execute, ssh_getConnectConfig as getConnectConfig, ssh_getCredentials as getCredentials, ssh_getDirMap as getDirMap, ssh_getMakeDirs as getMakeDirs, ssh_getRemoteDestination as getRemoteDestination, ssh_upload as upload };
 }
 
 export { azure, http, s3, ssh, utils };

package/lib/uzdu.js

@@ -3,21 +3,21 @@ import {
   azure_exports,
   s3_exports,
   ssh_exports
-} from "./chunk-VO6FBXH2.js";
+} from "./chunk-463DKYHI.js";
 import {
   http_exports
-} from "./chunk-7B56UNA6.js";
+} from "./chunk-LFEIDM4S.js";
 import {
   outputConfiguration,
   utils_exports
-} from "./chunk-OIXJ4D3Z.js";
+} from "./chunk-WWXWWCCX.js";
 
 // src/uzdu.ts
 import { Command } from "commander";
 var version;
 var description;
 try {
-  version = "1.0.17";
+  version = "1.1.0";
   description = "UZDU - universal zipper, downloader and uploader. Move files to/from zip, clouds (AWS, Azure), to HTTP PUT (e.g. Nexus) and to SSH";
 } catch (e) {
   if (e instanceof ReferenceError) {
@@ -33,6 +33,7 @@ program.command("zip", "create zip-archive from a directory or a file");
 program.command("unzip", "unzip archive to a directory");
 program.command("copy", "copy files and directories");
 program.command("metadata", "create Amazon S3 metadata file. See https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingMetadata.html.").alias("meta");
+program.command("exec", "execute shell command");
 program.configureOutput(outputConfiguration);
 async function main() {
   await program.parseAsync();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uzdu",
-  "version": "1.0.17",
+  "version": "1.1.0",
   "description": "UZDU - universal zipper, downloader and uploader. Move files to/from zip, clouds (AWS, Azure), to HTTP PUT (e.g. Nexus) and to SSH",
   "bin": {
     "uzdu": "lib/uzdu.js"