uzdu 1.0.18 → 1.1.1

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-ACV2CMWZ.js → chunk-2E5O5JIN.js}

@@ -3,160 +3,48 @@ import {
   getEnvironment,
   initEnvironment,
   listFiles,
-  resolvePath
-} from "./chunk-OIXJ4D3Z.js";
-
-// src/azure.ts
-var azure_exports = {};
-__export(azure_exports, {
-  default: () => upload
-});
-import { BlobServiceClient } from "@azure/storage-blob";
-import path from "path";
-import fs from "fs";
-async function upload(dir, options, metadataFile = ".metadata.json") {
-  if (!options.connectionString) throw Error("Uploader needs connection string for Azure Blob Storage. Provide AZURE_STORAGE_CONNECTION_STRING environment variable!");
-  const opts = Object.assign({}, { container: "$web" }, options);
-  const blobServiceClient = BlobServiceClient.fromConnectionString(options.connectionString);
-  const isDebug = process.env.DEBUG && process.env.DEBUG.toLowerCase() === "true";
-  const containerClient = blobServiceClient.getContainerClient(opts.container);
-  let dist = path.resolve(process.cwd(), dir);
-  const files = await listFiles(dir);
-  let metadata;
-  try {
-    const metadataJson = fs.readFileSync(path.join(dir, metadataFile), { encoding: "utf-8" });
-    metadata = JSON.parse(metadataJson);
-  } catch (e) {
-  }
-  if (Object.keys(files).length == 1) {
-    const lstat = fs.lstatSync(dist);
-    if (lstat.isFile()) {
-      dist = path.dirname(dist);
-    }
-  }
-  await Promise.all(Object.entries(files).map(async ([file, absFile]) => {
-    let blobObj;
-    if (metadata) {
-      blobObj = metadata[file];
-    }
-    const blockBlobClient = containerClient.getBlockBlobClient(file);
-    const blobHTTPHeaders = {};
-    if (blobObj?.headers) {
-      const { CacheControl, ContentType } = blobObj.headers;
-      blobHTTPHeaders.blobCacheControl = CacheControl;
-      blobHTTPHeaders.blobContentType = ContentType;
-    }
-    const localFilePath = absFile;
-    await blockBlobClient.uploadFile(localFilePath, { blobHTTPHeaders });
-  }));
-}
-
-// src/s3.ts
-var s3_exports = {};
-__export(s3_exports, {
-  default: () => upload2
-});
-import { S3Client } from "@aws-sdk/client-s3";
-import { Upload } from "@aws-sdk/lib-storage";
-import fs2 from "fs";
-import path2 from "path";
-async function upload2(dir, s3config, metadataFile = ".metadata.json") {
-  if (!s3config.accessKeyId || !s3config.secretAccessKey) {
-    throw new Error("AWS credentials not found in environment variables AWS_KEY_ID and AWS_SECRET_KEY.");
-  }
-  if (!s3config.region) {
-    throw new Error('Neither "region" in the bucket address nor AWS_REGION environment variable was found.');
-  }
-  if (!s3config.bucket) {
-    throw new Error("Amazon S3 bucket name is required");
-  }
-  const { accessKeyId, secretAccessKey, region, endpoint } = s3config;
-  const client = new S3Client({
-    credentials: {
-      accessKeyId,
-      secretAccessKey
-    },
-    region,
-    endpoint
-  });
-  let dist = path2.resolve(process.cwd(), dir);
-  const files = await listFiles(dist);
-  let metadata;
-  try {
-    const metadataJson = fs2.readFileSync(path2.join(dir, metadataFile), { encoding: "utf-8" });
-    metadata = JSON.parse(metadataJson);
-  } catch (e) {
-  }
-  if (Object.keys(files).length == 1) {
-    const lstat = fs2.lstatSync(dist);
-    if (lstat.isFile()) {
-      dist = path2.dirname(dist);
-    }
-  }
-  await Promise.all(Object.entries(files).map(async ([file, absFile]) => {
-    const filePath = absFile;
-    const fileContent = fs2.readFileSync(filePath);
-    const params = {
-      Bucket: s3config.bucket,
-      Key: file,
-      Body: fileContent
-    };
-    if (metadata) {
-      const blobObj = metadata[file];
-      if (blobObj && blobObj.headers) {
-        const { CacheControl, ContentType } = blobObj.headers;
-        if (CacheControl) params.CacheControl = CacheControl;
-        if (ContentType) params.ContentType = ContentType;
-      }
-    }
-    return new Upload({
-      client,
-      params,
-      tags: [],
-      queueSize: 4,
-      // optional concurrency configuration
-      partSize: 1024 * 1024 * 5,
-      // optional size of each part, in bytes, at least 5MB
-      leavePartsOnError: false
-      // optional manually handle dropped parts
-    }).done();
-  }));
-}
+  resolvePath,
+  runSequentially
+} from "./chunk-WWXWWCCX.js";
 
 // src/ssh.ts
 var ssh_exports = {};
 __export(ssh_exports, {
+  execute: () => execute,
   getConnectConfig: () => getConnectConfig,
   getCredentials: () => getCredentials,
   getDirMap: () => getDirMap,
   getMakeDirs: () => getMakeDirs,
   getRemoteDestination: () => getRemoteDestination,
-  upload: () => upload3
+  upload: () => upload
 });
 import { Client } from "ssh2";
-import fs3 from "fs";
-import path3 from "path";
+import fs from "fs";
+import path from "path";
 import deepmerge from "deepmerge";
-async function upload3(source, sftpUrl, sshCredentials) {
+async function upload(source, sftpUrl, options) {
   await new Promise((resolve, reject) => {
-    fs3.stat(source, async (err, stats) => {
+    fs.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 +53,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) });
+      });
     });
   });
 }
@@ -198,7 +133,7 @@ function _uploadFile(source, destination, sftp) {
           else resolve();
         });
       } else if (stats.isDirectory()) {
-        const f = path3.basename(source);
+        const f = path.basename(source);
         reject(new Error(`Overwriting directory ${destination} with the file ${f} is not allowed. Remove the directory manually.`));
       } else {
         reject(new Error("Remote path is symlink"));
@@ -210,33 +145,29 @@ 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);
+          const lstat2 = fs.lstatSync(source);
           if (lstat2.isFile()) {
-            const dest = path3.join(destination, Object.keys(sourceFiles)[0]).replace(/\\/g, "/");
+            const dest = path.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;
           }
         }
         let sourceDir = source;
-        const lstat = fs3.lstatSync(source);
+        const lstat = fs.lstatSync(source);
         if (lstat.isSymbolicLink()) {
-          sourceDir = fs3.readlinkSync(source);
+          sourceDir = fs.readlinkSync(source);
         }
         const promises = [];
         Object.entries(sourceFiles).map(([baseName, absPath]) => {
-          const dest = path3.join(destination, baseName).replace(/\\/g, "/");
+          const dest = path.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 +184,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 +204,6 @@ async function connect(sshConfig) {
       });
     });
   } catch (e) {
-    console.error("Connection failed", e);
     conn.destroy();
     throw e;
   }
@@ -309,7 +239,7 @@ function getFileMap(file) {
   const parts = theFile.split("/");
   if (parts.length == 1) return { [parts[0]]: false };
   else {
-    const aFile = path3.join(...parts.slice(1)).replace(/\\/g, "/");
+    const aFile = path.join(...parts.slice(1)).replace(/\\/g, "/");
     const fileMapEntry = getFileMap(aFile);
     return { [parts[0]]: fileMapEntry };
   }
@@ -327,13 +257,13 @@ function getCredentials(options) {
     if (uzduKeyPath) {
       const resolvedKeyPath = resolvePath(uzduKeyPath);
       try {
-        privateKey = fs3.readFileSync(resolvedKeyPath);
+        privateKey = fs.readFileSync(resolvedKeyPath);
       } catch (e) {
         throw new Error(`Not found private Key file ${resolvedKeyPath}`);
       }
     } 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 +275,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 path2 = 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: path2 };
   return connectConfig;
 }
 function getRemoteDestination(sftpUrl) {
@@ -363,31 +310,33 @@ function getRemoteDestination(sftpUrl) {
   const execArray = sftpUrlRegex.exec(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;
+  const path2 = execArray.groups.path;
+  return normilizeSftpPath(execArray.groups?.path) || "";
+}
+function normilizeSftpPath(path2) {
+  if (path2 == void 0) return void 0;
+  const re = /^(?<first>[^\/]*)(?<root>\/)?(?<second>.*)?/g;
   re.lastIndex = 0;
-  const execPathArray = re.exec(path4);
+  const execPathArray = re.exec(path2);
   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 = path2;
   }
-  const destination = dest.replace(/\/+$/, "");
+  const destination = dest != "/" ? dest.replace(/\/+$/, "") : dest;
   return destination;
 }
 
 export {
   upload,
-  azure_exports,
-  upload2,
-  s3_exports,
-  upload3,
-  getCredentials,
+  execute,
   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/chunk-XU5JZHWK.js

@@ -0,0 +1,133 @@
+import {
+  __export,
+  listFiles
+} from "./chunk-WWXWWCCX.js";
+
+// src/azure.ts
+var azure_exports = {};
+__export(azure_exports, {
+  default: () => upload
+});
+import { BlobServiceClient } from "@azure/storage-blob";
+import path from "path";
+import fs from "fs";
+async function upload(dir, options, metadataFile = ".metadata.json") {
+  if (!options.connectionString) throw Error("Uploader needs connection string for Azure Blob Storage. Provide AZURE_STORAGE_CONNECTION_STRING environment variable!");
+  const opts = Object.assign({}, { container: "$web" }, options);
+  const blobServiceClient = BlobServiceClient.fromConnectionString(options.connectionString);
+  const isDebug = process.env.DEBUG && process.env.DEBUG.toLowerCase() === "true";
+  const containerClient = blobServiceClient.getContainerClient(opts.container);
+  let dist = path.resolve(process.cwd(), dir);
+  const files = await listFiles(dir);
+  let metadata;
+  try {
+    const metadataJson = fs.readFileSync(path.join(dir, metadataFile), { encoding: "utf-8" });
+    metadata = JSON.parse(metadataJson);
+  } catch (e) {
+  }
+  if (Object.keys(files).length == 1) {
+    const lstat = fs.lstatSync(dist);
+    if (lstat.isFile()) {
+      dist = path.dirname(dist);
+    }
+  }
+  await Promise.all(Object.entries(files).map(async ([file, absFile]) => {
+    let blobObj;
+    if (metadata) {
+      blobObj = metadata[file];
+    }
+    const blockBlobClient = containerClient.getBlockBlobClient(file);
+    const blobHTTPHeaders = {};
+    if (blobObj?.headers) {
+      const { CacheControl, ContentType } = blobObj.headers;
+      blobHTTPHeaders.blobCacheControl = CacheControl;
+      blobHTTPHeaders.blobContentType = ContentType;
+    }
+    const localFilePath = absFile;
+    await blockBlobClient.uploadFile(localFilePath, { blobHTTPHeaders });
+  }));
+}
+
+// src/s3.ts
+var s3_exports = {};
+__export(s3_exports, {
+  default: () => upload2
+});
+import { S3Client } from "@aws-sdk/client-s3";
+import { Upload } from "@aws-sdk/lib-storage";
+import fs2 from "fs";
+import path2 from "path";
+async function upload2(dir, s3config, metadataFile = ".metadata.json") {
+  if (!s3config.accessKeyId || !s3config.secretAccessKey) {
+    throw new Error("AWS credentials not found in environment variables AWS_KEY_ID and AWS_SECRET_KEY.");
+  }
+  if (!s3config.region) {
+    throw new Error('Neither "region" in the bucket address nor AWS_REGION environment variable was found.');
+  }
+  if (!s3config.bucket) {
+    throw new Error("Amazon S3 bucket name is required");
+  }
+  const { accessKeyId, secretAccessKey, region, endpoint } = s3config;
+  const client = new S3Client({
+    credentials: {
+      accessKeyId,
+      secretAccessKey
+    },
+    region,
+    endpoint
+  });
+  let dist = path2.resolve(process.cwd(), dir);
+  const files = await listFiles(dist);
+  let metadata;
+  try {
+    const metadataJson = fs2.readFileSync(path2.join(dir, metadataFile), { encoding: "utf-8" });
+    metadata = JSON.parse(metadataJson);
+  } catch (e) {
+  }
+  if (Object.keys(files).length == 1) {
+    const lstat = fs2.lstatSync(dist);
+    if (lstat.isFile()) {
+      dist = path2.dirname(dist);
+    }
+  }
+  await Promise.all(Object.entries(files).map(async ([file, absFile]) => {
+    const filePath = absFile;
+    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,
+      Body: fileContent
+    };
+    if (metadata) {
+      const blobObj = metadata[file];
+      if (blobObj && blobObj.headers) {
+        const { CacheControl, ContentType } = blobObj.headers;
+        if (CacheControl) params.CacheControl = CacheControl;
+        if (ContentType) params.ContentType = ContentType;
+      }
+    }
+    return new Upload({
+      client,
+      params,
+      tags: [],
+      queueSize: 4,
+      // optional concurrency configuration
+      partSize: 1024 * 1024 * 5,
+      // optional size of each part, in bytes, at least 5MB
+      leavePartsOnError: false
+      // optional manually handle dropped parts
+    }).done();
+  }));
+}
+
+export {
+  upload,
+  azure_exports,
+  upload2,
+  s3_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-exec.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/lib/uzdu-exec.js

@@ -0,0 +1,28 @@
+import {
+  execute
+} from "./chunk-2E5O5JIN.js";
+import {
+  outputConfiguration
+} from "./chunk-WWXWWCCX.js";
+
+// src/uzdu-exec.ts
+import { Command, Option } from "commander";
+import { consola } from "consola";
+var command = new Command();
+command.description("Execute commands on remote machine").name("uzdu exec");
+command.command("ssh").description("Execute commands via SSH. In addition to sshUrl consider using environment variables UZDU_SSH_KEY_PATH, UZDU_SSH_KEY, UZDU_SSH_PASSWORD").argument("<sshUrl>", "the URL format ssh://[user[:password]@]host[:port]").argument("command", "single line command").addOption(
+  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 (sshUrl, command2, options, thisCommand) => {
+  try {
+    options.callback = (value) => {
+      if (value.message) consola.log(value.message);
+      if (value.error) consola.error(value.error);
+    };
+    await execute(sshUrl, [command2], options);
+  } catch (e) {
+    thisCommand.error(e.message || e, { exitCode: 127, code: "ssh.upload.error" });
+  }
+});
+command.configureOutput(outputConfiguration);
+command.showHelpAfterError(true);
+command.parse();

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,20 @@
 import {
-  getCredentials,
-  upload as upload2,
-  upload2 as upload3,
-  upload3 as upload4
-} from "./chunk-ACV2CMWZ.js";
+  upload as upload3,
+  upload2 as upload4
+} from "./chunk-XU5JZHWK.js";
 import {
   upload
-} from "./chunk-7B56UNA6.js";
+} from "./chunk-LFEIDM4S.js";
+import {
+  upload as upload2
+} from "./chunk-2E5O5JIN.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,10 +39,10 @@ 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);
+    await upload4(from, config);
   } catch (e) {
     thisCommand.error(e.message || e, { exitCode: 53, code: "aws.upload.error" });
   }
@@ -72,14 +73,14 @@ 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 = {
       connectionString,
       container
     };
-    await upload2(from, azOpt);
+    await upload3(from, azOpt);
   } catch (e) {
     thisCommand.error(e.message || e, { exitCode: 43, code: "az.upload.error" });
   }
@@ -88,10 +89,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 upload2(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

@@ -1,23 +1,25 @@
 #! /usr/bin/env node
 import {
   azure_exports,
-  s3_exports,
-  ssh_exports
-} from "./chunk-ACV2CMWZ.js";
+  s3_exports
+} from "./chunk-XU5JZHWK.js";
 import {
   http_exports
-} from "./chunk-7B56UNA6.js";
+} from "./chunk-LFEIDM4S.js";
+import {
+  ssh_exports
+} from "./chunk-2E5O5JIN.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.18";
+  version = "1.1.1";
   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 +35,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.18",
+  "version": "1.1.1",
   "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"