uzdu 1.0.14 → 1.0.16

package/README.md

@@ -1,9 +1,14 @@
 # UZDU – Universal Zip archiver, Downloader and Uploader for Node.js/Deno/Bun
 
 
-[![Release](https://github.com/denis-kalinin/uzdu/actions/workflows/release.yml/badge.svg?event=workflow_dispatch)](https://github.com/denis-kalinin/uzdu/actions/workflows/release.yml)
+
+[![NPM Version](https://img.shields.io/npm/v/uzdu)](https://www.npmjs.com/package/uzdu)
 [![NPM Downloads](https://img.shields.io/npm/dm/uzdu)](https://www.npmjs.com/package/uzdu)
+[![Release](https://github.com/denis-kalinin/uzdu/actions/workflows/release.yml/badge.svg?event=workflow_dispatch)](https://github.com/denis-kalinin/uzdu/actions/workflows/release.yml)
+![GitHub commit activity](https://img.shields.io/github/commit-activity/y/denis-kalinin/uzdu)
+
 
+## For users
 
 UZDU is a convinient tool to deploy files to a web server. If you're a DevOps enthusiast and prefer to stay in your familiar <span>Node.js</span> environment, you can deploy using this tool.
 
@@ -22,18 +27,24 @@ Bun:
 bunx uzdu -h
 ```
 
-## uploading
+### uploading
 
-- [Amazon S3](https://docs.aws.amazon.com/s3/) `npx uzdu up aws -h`
-- [Azure Blob Storage](https://azure.microsoft.com/en-us/products/storage/blobs) `npx uzdu up 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 up http -h`
-- SSH/SCP `npx uzdu up ssh -h`
+- [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`
 
-## downloading
+### downloading
 
-- http `npx uzdu down http -h`
+- http `npx uzdu download http -h`
 
-## working with zip-archives
+### working with zip-archives
 
 - zip `npx uzdu zip -h`
-- unzip `npx uzdu unzip -h`
+- unzip `npx uzdu unzip -h`
+
+
+## For developers
+
+1. [Gif flow guide](docs/git-flow.md)
+2. [Semantic release](docs/semantic-release.md)

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

@@ -1,8 +1,14 @@
 import {
+  __export,
   listFiles
-} from "./chunk-KZ5VMI45.js";
+} from "./chunk-OIXJ4D3Z.js";
 
 // src/http.ts
+var http_exports = {};
+__export(http_exports, {
+  download: () => download,
+  upload: () => upload
+});
 import fs from "fs";
 import path from "path";
 var isDebug = process.env.DEBUG?.toLowerCase() === "true";
@@ -12,7 +18,7 @@ async function upload(dirOrFile, url, headers) {
   const files = await listFiles(distr);
   if (isDebug) console.log(`files to upload:  ${files.length}`);
   let singleUrl;
-  if (files.length == 1) {
+  if (Object.keys(files).length == 1) {
     const lstat = fs.lstatSync(distr);
     if (lstat.isFile()) {
       distr = path.dirname(distr);
@@ -20,9 +26,9 @@ async function upload(dirOrFile, url, headers) {
     }
   }
   const fixedBaseUrl = url.href.endsWith("/") ? url : new URL(`${url.href}/`);
-  await Promise.all(files.map(async (file) => {
+  await Promise.all(Object.entries(files).map(async ([file, absFile]) => {
     if (isDebug) console.log(`filename: ${file}`);
-    const localFilePath = path.resolve(distr, file);
+    const localFilePath = absFile;
     const fileUrl = singleUrl || new URL(`${fixedBaseUrl}${file}`);
     if (isDebug) console.log(`uploading ${localFilePath} => ${fileUrl}`);
     await uploadFile(localFilePath, fileUrl, headers);
@@ -89,5 +95,6 @@ async function download(url, headers) {
 
 export {
   upload,
-  download
+  download,
+  http_exports
 };

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

@@ -1,4 +1,26 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
 // src/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  addMetadata: () => addMetadata,
+  checkIsFile: () => checkIsFile,
+  doUnzip: () => doUnzip,
+  getEnvironment: () => getEnvironment,
+  initEnvironment: () => initEnvironment,
+  listBlobs: () => listBlobs,
+  listFiles: () => listFiles,
+  makeZip: () => makeZip,
+  outputConfiguration: () => outputConfiguration,
+  resolvePath: () => resolvePath,
+  safeIndex: () => safeIndex,
+  shouldBeDirectory: () => shouldBeDirectory,
+  shouldBeFile: () => shouldBeFile
+});
 import fs from "fs";
 import os from "os";
 import JSZip from "jszip";
@@ -55,14 +77,7 @@ async function createBlobObject(filePath, rootDir, blobDir = "") {
 function getEnvironment(file = ".env") {
   const envFilePath = path.resolve(process.cwd(), file);
   const txt = fs.readFileSync(envFilePath, { encoding: "utf-8" });
-  const lines = txt.split(/\r?\n/);
-  const isComment = /^\s*#/;
-  return lines.reduce((acc, line) => {
-    if (isComment.test(line)) return acc;
-    const [key, ...rest] = line.split("=");
-    if (rest.length > 0) acc[key.trim()] = rest.join("=").trim();
-    return acc;
-  }, {});
+  return parseEnvironment(txt);
 }
 function initEnvironment(env) {
   Object.keys(env).forEach((key) => process.env[key] = env[key]);
@@ -71,22 +86,36 @@ async function listFiles(rootDir, _dir) {
   if (!_dir) {
     const lstat = fs.lstatSync(rootDir);
     if (lstat.isFile()) {
-      return [path.basename(rootDir)];
+      return { [path.basename(rootDir)]: rootDir };
     }
   }
   const cwd = _dir || rootDir;
   const files = fs.readdirSync(cwd, { withFileTypes: true });
   const fileList = await files.reduce(async (acc, file) => {
     const filePath = path.join(cwd, file.name);
+    let newAcc = {};
     if (file.isDirectory()) {
       const filesInDir = await listFiles(rootDir, filePath);
-      (await acc).push(...filesInDir);
+      newAcc = { ...await acc, ...filesInDir };
+    } else if (file.isSymbolicLink()) {
+      const symLinkAbsoluteTargetPath = path.resolve(cwd, fs.readlinkSync(filePath));
+      const lstat = fs.lstatSync(symLinkAbsoluteTargetPath);
+      if (lstat.isDirectory()) {
+        const filesInDir = await listFiles(rootDir, filePath);
+        newAcc = { ...await acc, ...filesInDir };
+      } else if (lstat.isFile()) {
+        newAcc = { ...await acc, [filePath]: filePath.split(path.sep).join(path.posix.sep) };
+      } else if (lstat.isSymbolicLink()) {
+        const filesInDir = await listFiles(rootDir, filePath);
+        newAcc = { ...await acc, ...filesInDir };
+      }
     } else {
       const relativeFilePath = path.relative(rootDir, filePath).split(path.sep).join(path.posix.sep);
-      (await acc).push(relativeFilePath);
+      const absPath = path.resolve(rootDir, filePath).split(path.sep).join(path.posix.sep);
+      newAcc = { ...await acc, [relativeFilePath]: absPath };
     }
-    return await acc;
-  }, Promise.resolve([]));
+    return newAcc;
+  }, Promise.resolve({}));
   return fileList;
 }
 async function addMetadata(distributive, metadataFilename = ".metadata.json") {
@@ -111,10 +140,9 @@ async function getMetadata(dir, metadataFile) {
 async function makeZip(fromDir, zipFilePath) {
   const zip = new JSZip();
   const files = await listFiles(fromDir);
-  files.forEach((file) => {
-    const filePath = path.join(fromDir, file);
-    const readStream = fs.createReadStream(filePath);
-    zip.file(file, readStream, { binary: true });
+  Object.entries(files).forEach(([basePath, absPath]) => {
+    const readStream = fs.createReadStream(absPath);
+    zip.file(basePath, readStream, { binary: true });
   });
   return new Promise((resolve, reject) => {
     zip.generateNodeStream({ type: "nodebuffer", streamFiles: true }).pipe(fs.createWriteStream(zipFilePath)).on("finish", function() {
@@ -151,6 +179,12 @@ function checkIsFile(file) {
   const lstat = fs.lstatSync(absPath);
   return lstat.isFile();
 }
+function shouldBeFile(file) {
+  if (!checkIsFile(file)) {
+    const absPath = path.resolve(file);
+    throw new Error(`${file} is a directory, SHOULD be a file. Check [${absPath}]`);
+  }
+}
 function shouldBeDirectory(directory) {
   const lstat = fs.lstatSync(directory);
   if (!lstat.isDirectory) {
@@ -176,8 +210,29 @@ function resolvePath(filePath) {
   }
   return path.resolve(process.cwd(), filePath);
 }
+var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
+function parseEnvironment(src) {
+  const obj = {};
+  let lines = src.toString();
+  lines = lines.replace(/\r\n?/mg, "\n");
+  let match;
+  while ((match = LINE.exec(lines)) != null) {
+    const key = match[1];
+    let value = match[2] || "";
+    value = value.trim();
+    const maybeQuote = value[0];
+    value = value.replace(/^(['"`])([\s\S]*)\1$/mg, "$2");
+    if (maybeQuote === '"') {
+      value = value.replace(/\\n/g, "\n");
+      value = value.replace(/\\r/g, "\r");
+    }
+    obj[key] = value;
+  }
+  return obj;
+}
 
 export {
+  __export,
   getEnvironment,
   initEnvironment,
   listFiles,
@@ -187,6 +242,6 @@ export {
   checkIsFile,
   shouldBeDirectory,
   outputConfiguration,
-  safeIndex,
-  resolvePath
+  resolvePath,
+  utils_exports
 };

package/lib/chunk-T7RDOCPF.js

@@ -0,0 +1,379 @@
+import {
+  __export,
+  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();
+  }));
+}
+
+// src/ssh.ts
+var ssh_exports = {};
+__export(ssh_exports, {
+  getConnectConfig: () => getConnectConfig,
+  getCredentials: () => getCredentials,
+  getDirMap: () => getDirMap,
+  getMakeDirs: () => getMakeDirs,
+  getRemoteDestination: () => getRemoteDestination,
+  upload: () => upload3
+});
+import { Client } from "ssh2";
+import fs3 from "fs";
+import path3 from "path";
+import deepmerge from "deepmerge";
+async function upload3(source, sftpUrl, sshCredentials) {
+  await new Promise((resolve, reject) => {
+    fs3.stat(source, async (err, stats) => {
+      if (stats.isSymbolicLink()) {
+        reject(new Error(`${source} is symlink`));
+      } else {
+        let sshConnection;
+        try {
+          const _connectConfig = getConnectConfig(sftpUrl);
+          const _sshCredentials = sshCredentials || getCredentials();
+          const connectConfig = { ..._connectConfig, ..._sshCredentials };
+          sshConnection = await connect(connectConfig);
+          const files = await listFiles(source);
+          const destination = getRemoteDestination(sftpUrl);
+          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();
+        }
+      }
+    });
+  });
+}
+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();
+        });
+      }
+    });
+  });
+}
+function _uploadFile(source, destination, sftp) {
+  return new Promise((resolve, reject) => {
+    sftp.stat(destination, async (err, stats) => {
+      if (err) {
+        sftp.fastPut(source, destination, {}, (err2) => {
+          if (err2) reject(err2);
+          else resolve();
+        });
+      } else if (stats.isFile()) {
+        sftp.fastPut(source, destination, {}, (err2) => {
+          if (err2) reject(err2);
+          else resolve();
+        });
+      } else if (stats.isDirectory()) {
+        const f = path3.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"));
+      }
+    });
+  });
+}
+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 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);
+        if (lstat.isSymbolicLink()) {
+          sourceDir = fs3.readlinkSync(source);
+        }
+        const promises = [];
+        Object.entries(sourceFiles).map(([baseName, absPath]) => {
+          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);
+            });
+          });
+          promises.push(promise);
+        });
+        await Promise.all(promises);
+        resolve();
+      }
+    });
+  });
+}
+async function connect(sshConfig) {
+  const conn = new Client();
+  try {
+    return await new Promise((resolve, reject) => {
+      conn.on("error", (e) => {
+        reject(new Error(`Target host error: ${e}`));
+      }).on("ready", () => {
+        resolve(conn);
+      }).connect({
+        timeout: 5,
+        port: 22,
+        algorithms: {
+          cipher: [
+            "aes128-ctr",
+            "aes192-ctr",
+            "aes256-ctr",
+            "aes256-cbc",
+            "aes128-cbc"
+            //"aes128-gcm", ////"aes128-gcm@openssh.com", //"aes256-gcm", ////"aes256-gcm@openssh.com", ////"aes192-cbc",
+          ]
+        },
+        ...sshConfig
+      });
+    });
+  } catch (e) {
+    console.error("Connection failed", e);
+    conn.destroy();
+    throw e;
+  }
+}
+function getMakeDirs(fileMap, destination) {
+  const kv = Object.entries(fileMap);
+  const hasSubdirs = kv.some((keyVal) => !!keyVal[1]);
+  if (!hasSubdirs) return false;
+  const subdirs = kv.reduce((acc, curr) => {
+    if (curr[1]) {
+      const res = getMakeDirs(curr[1]);
+      const prefix = destination ? [destination, curr[0]].join("/") : curr[0];
+      if (res) {
+        const pathes = res.map((apath) => [prefix, apath].join("/"));
+        acc.push(...pathes);
+      } else acc.push(prefix);
+    }
+    return acc;
+  }, []);
+  return subdirs;
+}
+function getDirMap(files) {
+  let fileMap = {};
+  Object.keys(files).map((file) => {
+    const leaf = getFileMap(file);
+    fileMap = deepmerge(fileMap, leaf);
+  });
+  return fileMap;
+}
+function getFileMap(file) {
+  let theFile = file;
+  if (file.indexOf("/") == 0) theFile = file.substring(1);
+  const parts = theFile.split("/");
+  if (parts.length == 1) return { [parts[0]]: false };
+  else {
+    const aFile = path3.join(...parts.slice(1)).replace(/\\/g, "/");
+    const fileMapEntry = getFileMap(aFile);
+    return { [parts[0]]: fileMapEntry };
+  }
+}
+function getCredentials(options) {
+  if (options?.dotenv) {
+    const theEnv = getEnvironment(options.dotenv);
+    initEnvironment(theEnv);
+  }
+  const uzduKey = process.env.UZDU_SSH_KEY;
+  let password = void 0;
+  let privateKey = uzduKey;
+  if (!privateKey) {
+    const uzduKeyPath = options?.privateKeyPath || process.env.UZDU_SSH_KEY_PATH;
+    if (uzduKeyPath) {
+      const resolvedKeyPath = resolvePath(uzduKeyPath);
+      try {
+        privateKey = fs3.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");
+      password = uzduPassword;
+    }
+  }
+  const authConfig = password ? {
+    password
+  } : {
+    privateKey
+  };
+  return authConfig;
+}
+var sftpUrlRegex = /^sftp:\/\/(?:(?<username>[\w\.\-]{1,32})(?::(?<password>.+))?@)?(?:(?<host>[\w\.\-]+)|\[(?<ipv6>[\d:]+)\])(?::(?<port>\d{1,5}))?\/(?<path>.*)$/g;
+function getConnectConfig(sftpUrl) {
+  sftpUrlRegex.lastIndex = 0;
+  const execArray = sftpUrlRegex.exec(sftpUrl);
+  const { groups } = execArray ?? {};
+  const host = groups?.host || groups?.ipv6;
+  if (!host) throw new Error(`Wrong URL "${sftpUrl}": host or ivp6 is not specified`);
+  const username = groups?.username;
+  const password = groups?.password;
+  const _port = parseInt(groups.port);
+  const port = isNaN(_port) ? void 0 : _port;
+  const connectConfig = { username, password, host, port };
+  return connectConfig;
+}
+function getRemoteDestination(sftpUrl) {
+  sftpUrlRegex.lastIndex = 0;
+  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 destination = path4.replace(/\/+$/, "").replace(/^~/, ".");
+  return destination;
+}
+
+export {
+  upload,
+  azure_exports,
+  upload2,
+  s3_exports,
+  upload3,
+  getCredentials,
+  ssh_exports
+};

package/lib/uzdu-copy.js

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

package/lib/uzdu-download.js

@@ -1,11 +1,11 @@
 import {
   download
-} from "./chunk-2WNHNCUV.js";
+} from "./chunk-7B56UNA6.js";
 import {
   getEnvironment,
   initEnvironment,
   outputConfiguration
-} from "./chunk-KZ5VMI45.js";
+} from "./chunk-OIXJ4D3Z.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-KZ5VMI45.js";
+} from "./chunk-OIXJ4D3Z.js";
 
 // src/uzdu-metadata.ts
 import { Argument, Command } from "commander";

package/lib/uzdu-unzip.js

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

package/lib/uzdu-upload.js

@@ -1,306 +1,22 @@
+import {
+  getCredentials,
+  upload as upload2,
+  upload2 as upload3,
+  upload3 as upload4
+} from "./chunk-T7RDOCPF.js";
 import {
   upload
-} from "./chunk-2WNHNCUV.js";
+} from "./chunk-7B56UNA6.js";
 import {
   getEnvironment,
   initEnvironment,
-  listFiles,
   outputConfiguration,
   resolvePath,
-  safeIndex,
   shouldBeDirectory
-} from "./chunk-KZ5VMI45.js";
+} from "./chunk-OIXJ4D3Z.js";
 
 // src/uzdu-upload.ts
 import { Argument, Command, Option } from "commander";
-
-// src/azure.ts
-import { BlobServiceClient } from "@azure/storage-blob";
-import path from "path";
-import fs from "fs";
-async function upload2(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 (files.length == 1) {
-    const lstat = fs.lstatSync(dist);
-    if (lstat.isFile()) {
-      dist = path.dirname(dist);
-    }
-  }
-  await Promise.all(files.map(async (file) => {
-    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 = path.resolve(dist, file);
-    await blockBlobClient.uploadFile(localFilePath, { blobHTTPHeaders });
-  }));
-}
-
-// src/s3.ts
-import { S3Client } from "@aws-sdk/client-s3";
-import { Upload } from "@aws-sdk/lib-storage";
-import fs2 from "fs";
-import path2 from "path";
-async function upload3(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 (files.length == 1) {
-    const lstat = fs2.lstatSync(dist);
-    if (lstat.isFile()) {
-      dist = path2.dirname(dist);
-    }
-  }
-  await Promise.all(files.map(async (file) => {
-    const filePath = path2.resolve(dist, file);
-    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();
-  }));
-}
-
-// src/ssh.ts
-import { Client } from "ssh2";
-import fs3 from "fs";
-import path3 from "path";
-import deepmerge from "deepmerge";
-async function upload4(source, destination, sshConfig) {
-  await new Promise((resolve, reject) => {
-    fs3.stat(source, async (err, stats) => {
-      if (stats.isSymbolicLink()) {
-        reject(new Error(`${source} is symlink`));
-      } else {
-        const sshConnection = await connect(sshConfig);
-        try {
-          const files = await listFiles(source);
-          const _destination = destination.replace(/\/+$/, "");
-          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();
-        }
-      }
-    });
-  });
-}
-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();
-        });
-      }
-    });
-  });
-}
-function _uploadFile(source, destination, sftp) {
-  return new Promise((resolve, reject) => {
-    sftp.stat(destination, async (err, stats) => {
-      if (err) {
-        sftp.fastPut(source, destination, {}, (err2) => {
-          if (err2) reject(err2);
-          else resolve();
-        });
-      } else if (stats.isFile()) {
-        sftp.fastPut(source, destination, {}, (err2) => {
-          if (err2) reject(err2);
-          else resolve();
-        });
-      } else if (stats.isDirectory()) {
-        const f = path3.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"));
-      }
-    });
-  });
-}
-function uploadFiles(sources, source, destination, sshConnection) {
-  return new Promise((resolve, reject) => {
-    sshConnection.sftp(async (err, sftp) => {
-      if (err) {
-        console.error("uploadFiles error");
-        reject(err);
-      } else {
-        if (sources.length == 1) {
-          const lstat = fs3.lstatSync(source);
-          if (lstat.isFile()) {
-            const dest = path3.join(destination, sources[0]).replace(/\\/g, "/");
-            const src = source;
-            console.log(`Uploading file ${src} => ${dest}`);
-            await _uploadFile(src, dest, sftp).then(() => resolve()).catch((e) => {
-              console.error(src);
-              reject(e);
-            });
-            return;
-          }
-        }
-        const promises = [];
-        sources.map((f) => {
-          const dest = path3.join(destination, f).replace(/\\/g, "/");
-          const src = path3.join(source, f).replace(/\\/g, "/");
-          console.log(`Uploading ${src} => ${dest}`);
-          const promise = new Promise((res, rej) => {
-            _uploadFile(src, dest, sftp).then(() => res()).catch((e) => {
-              console.error(src);
-              rej(e);
-            });
-          });
-          promises.push(promise);
-        });
-        await Promise.all(promises);
-        resolve();
-      }
-    });
-  });
-}
-async function connect(sshConfig) {
-  const conn = new Client();
-  try {
-    return await new Promise((resolve, reject) => {
-      conn.on("error", (e) => {
-        reject(new Error(`Target host error: ${e}`));
-      }).on("ready", () => {
-        resolve(conn);
-      }).connect({
-        timeout: 99,
-        port: 22,
-        algorithms: {
-          cipher: [
-            "aes128-ctr",
-            "aes192-ctr",
-            "aes256-ctr",
-            "aes256-cbc",
-            "aes128-cbc"
-            //"aes128-gcm", ////"aes128-gcm@openssh.com", //"aes256-gcm", ////"aes256-gcm@openssh.com", ////"aes192-cbc",
-          ]
-        },
-        ...sshConfig
-      });
-    });
-  } catch (e) {
-    console.error("Connection failed", e);
-    conn.destroy();
-    throw e;
-  }
-}
-function getMakeDirs(fileMap, destination) {
-  const kv = Object.entries(fileMap);
-  const hasSubdirs = kv.some((keyVal) => !!keyVal[1]);
-  if (!hasSubdirs) return false;
-  const subdirs = kv.reduce((acc, curr) => {
-    if (curr[1]) {
-      const res = getMakeDirs(curr[1]);
-      const prefix = destination ? [destination, curr[0]].join("/") : curr[0];
-      if (res) {
-        const pathes = res.map((apath) => [prefix, apath].join("/"));
-        acc.push(...pathes);
-      } else acc.push(prefix);
-    }
-    return acc;
-  }, []);
-  return subdirs;
-}
-function getDirMap(files) {
-  let fileMap = {};
-  files.map((file) => {
-    const leaf = getFileMap(file);
-    fileMap = deepmerge(fileMap, leaf);
-  });
-  return fileMap;
-}
-function getFileMap(file) {
-  let theFile = file;
-  if (file.indexOf("/") == 0) theFile = file.substring(1);
-  const parts = theFile.split("/");
-  if (parts.length == 1) return { [parts[0]]: false };
-  else {
-    const aFile = path3.join(...parts.slice(1)).replace(/\\/g, "/");
-    const fileMapEntry = getFileMap(aFile);
-    return { [parts[0]]: fileMapEntry };
-  }
-}
-
-// src/uzdu-upload.ts
-import fs4 from "fs";
 var command = new Command();
 command.description("Upload to Azure, AWS and HTTP server").name("uzdu upload");
 command.command("aws").description("upload to AWS S3").argument("<from>", "the directory to upload to the <bucket>").argument("<bucket>", 'the AWS S3 bucket[:region[:endpoint]], e.g. "mybucket", "mybucket:us-east-2" or "mybucket:my-region:https://my-s3-provider/endpoint". [:region] overrides S3_REGION environment variable. Expects environment variables S3_ACCESS_KEY_ID and S3_SECRET_ACCESS_KEY.').addOption(
@@ -368,44 +84,12 @@ command.command("azure").alias("az").description("upload to Azure Blob Storage")
     thisCommand.error(e.message || e, { exitCode: 43, code: "az.upload.error" });
   }
 });
-command.command("ssh").description("upload with SSH").argument("<source>", "source directory or file to upload <to_server>").argument("<destination>", "desitnation directory or file").option("--target <target>", "server hostname/ip-address and optional SSH-port, e.g. 10.100.0.1:22").addOption(
+command.command("ssh").description("upload via SFTP. In addition to sftpURL consider using environment variables UZDU_SSH_KEY_PATH, UZDU_SSH_KEY, UZDU_SSH_PASSWORD").argument("<source>", "source directory or file to upload into <ssh_server>").argument("<sftpUrl>", "the URL format: sftp://[user[:password]@]host[:port]/path/to/file").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("--targetUsername [targetUsername]", "SSH username for <target>").default("root")).addOption(new Option("--targetKey [targetKey]", "SSH private key")).addOption(new Option("--targetPassword [targetPassword]", "SSH password")).action(async (source, destination, options, thisCommand) => {
+).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 {
-    if (options.dotenv) {
-      const theEnv = getEnvironment(options.dotenv);
-      initEnvironment(theEnv);
-    }
-    const hostParts = options.target.split(":");
-    const host = hostParts[0];
-    const sPort = safeIndex(hostParts, 1) || 22;
-    const port = Number(sPort);
-    const conConfig = {
-      host,
-      port,
-      username: options.targetUsername
-    };
-    const privKeyPath = options.targetKey;
-    let password = void 0;
-    let privateKey = void 0;
-    if (privKeyPath) {
-      const resolvedKeyPath = resolvePath(options.targetKey);
-      try {
-        privateKey = fs4.readFileSync(resolvedKeyPath);
-      } catch (e) {
-        throw new Error(`Not found private Key file ${resolvedKeyPath}`);
-      }
-    } else {
-      if (!options.targetPassword) throw new Error("Either --targetPassword or --targetKey should be specified");
-      password = options.targetPassword;
-    }
-    const authConfig = password ? {
-      password
-    } : {
-      privateKey
-    };
-    const sshConfig = { ...conConfig, ...authConfig };
-    await upload4(resolvePath(source), destination, sshConfig);
+    const sshCredentials = getCredentials(options);
+    await upload4(resolvePath(source), sftpUrl, sshCredentials);
   } 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-KZ5VMI45.js";
+} from "./chunk-OIXJ4D3Z.js";
 
 // src/uzdu-zip.ts
 import { Command } from "commander";

package/lib/uzdu.d.ts

@@ -1,6 +1,192 @@
 #! /usr/bin/env node
-import { Command } from 'commander';
+import { OutputConfiguration } from 'commander';
+import { ConnectConfig } from 'ssh2';
 
-declare const program: Command;
+interface BlobObject {
+    /**
+     * blob key
+     */
+    key: string;
+    headers?: {
+        CacheControl?: string;
+        ContentType?: string;
+    };
+}
+/**
+ *
+ * @param rootDir a local directory with files to be uploaded
+ * @param blobDir a storage directory (e.g. "a", "a/b") where files from rootDir
+ * will be uploaded. Default is "";
+ * @returns a list of {@link BlobObject}
+ */
+declare function listBlobs(rootDir: string, blobDir?: string, _dir?: string): Promise<BlobObject[]>;
+declare function getEnvironment(file?: string): Record<string, string>;
+/**
+ * @param env a parameter structure to be added to {@link process.env}
+ */
+declare function initEnvironment(env: {
+    [key: string]: string;
+}): void;
+/**
+ *
+ * @param rootDir
+ * @param _dir
+ * @returns map, where key is path relative to rootDir, value is absolute filepath
+ */
+declare function listFiles(rootDir: string, _dir?: string): Promise<Record<string, string>>;
+/**
+ * Add metadata about files in the `distributive` directory
+ * @param distributive path to the directory with files
+ * @param metadataFilename a name of the metadata file that will be added to the `distributive` directory, default is `.metadata.json`
+ * @returns the same `distributive` path as in the parameter
+ */
+declare function addMetadata(distributive: string, metadataFilename?: string): Promise<string>;
+/**
+ *
+ * @param fromDir
+ * @param zipFilePath
+ * @param metadata a json with metadata
+ * @returns
+ */
+declare function makeZip(fromDir: string, zipFilePath: string): Promise<string>;
+/**
+ *
+ * @param fromZip
+ * @param toDir
+ * @returns resolved toDir
+ */
+declare function doUnzip(fromZip: string, toDir: string): Promise<string>;
+declare function checkIsFile(file: string): boolean;
+declare function shouldBeFile(file: string): void;
+declare function shouldBeDirectory(directory: string): void;
+declare const outputConfiguration: OutputConfiguration;
+/**
+ * @param arr
+ * @param index
+ * @returns element[`index`] from array `arr` or undefined
+ */
+declare function safeIndex<T>(arr: T[], index: number): T | undefined;
+/**
+ * Resolves paths that start with a tilde to the user's home directory.
+ *
+ * @param filePath '~/GitHub/Repo/file.png'
+ * @return '/home/bob/GitHub/Repo/file.png'
+ */
+declare function resolvePath(filePath: string): string;
 
-export { program };
+type utils_BlobObject = BlobObject;
+declare const utils_addMetadata: typeof addMetadata;
+declare const utils_checkIsFile: typeof checkIsFile;
+declare const utils_doUnzip: typeof doUnzip;
+declare const utils_getEnvironment: typeof getEnvironment;
+declare const utils_initEnvironment: typeof initEnvironment;
+declare const utils_listBlobs: typeof listBlobs;
+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_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 };
+}
+
+declare function upload$3(dirOrFile: string, url: URL, headers?: string[]): Promise<void>;
+declare function download(url: URL, headers?: string[]): Promise<Response>;
+
+declare const http_download: typeof download;
+declare namespace http {
+  export { http_download as download, upload$3 as upload };
+}
+
+interface S3Config {
+    accessKeyId: string;
+    secretAccessKey: string;
+    region?: string;
+    endpoint?: string;
+    bucket: string;
+}
+declare function upload$2(dir: string, s3config: S3Config, metadataFile?: string): Promise<void>;
+
+type s3_S3Config = S3Config;
+declare namespace s3 {
+  export { type s3_S3Config as S3Config, upload$2 as default };
+}
+
+interface AzureStorageOptions {
+    connectionString: string;
+    container?: string;
+}
+declare function upload$1(dir: string, options: AzureStorageOptions, metadataFile?: string): Promise<void>;
+
+type azure_AzureStorageOptions = AzureStorageOptions;
+declare namespace azure {
+  export { type azure_AzureStorageOptions as AzureStorageOptions, upload$1 as default };
+}
+
+type SshCredentials = {
+    password: string;
+    privateKey?: undefined;
+} | {
+    password?: undefined;
+    privateKey: Buffer | string;
+};
+declare function upload(source: string, sftpUrl: string, sshCredentials?: SshCredentials): Promise<void>;
+type FileMapEntry = {
+    [key: string]: false | FileMapEntry;
+};
+declare function getMakeDirs(fileMap: FileMapEntry, destination?: string): false | string[];
+declare function getDirMap(files: Record<string, string>): FileMapEntry;
+/**
+ *
+ * @param options
+ * @returns
+ */
+declare function getCredentials(options?: {
+    privateKeyPath?: string;
+    dotenv?: string;
+}): {
+    password: string;
+    privateKey?: undefined;
+} | {
+    privateKey: Buffer | string;
+    password?: undefined;
+};
+/**
+ * Get SSH ConnectionConfig from sftp URL.
+ * The general format for the URL is:
+ * `sftp://[user[:password]@]host[:port]/path/to/file`
+ *
+ * Examples:
+ * ```
+ * sftp://ubuntu:pa55w0rd@example.com/opt/file
+ * sftp://root@[2001:db8::5]:222/opt/file
+ * sftp://203.0.113.5/opt/file
+ * ```
+ * @param sftpUrl
+ *
+ * @throws Wrong URL: host or ivp6 is not specified
+ */
+declare function getConnectConfig(sftpUrl: string): ConnectConfig;
+/**
+ *
+ * @param sftpUrl
+ * @returns path on remote ssh server
+ * @throws Wrong sfpt URL
+ * @throws Wrong URL: path is not specified
+ */
+declare function getRemoteDestination(sftpUrl: string): string;
+
+type ssh_SshCredentials = SshCredentials;
+declare const ssh_getConnectConfig: typeof getConnectConfig;
+declare const ssh_getCredentials: typeof getCredentials;
+declare const ssh_getDirMap: typeof getDirMap;
+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 { azure, http, s3, ssh, utils };

package/lib/uzdu.js

@@ -1,14 +1,23 @@
 #! /usr/bin/env node
 import {
-  outputConfiguration
-} from "./chunk-KZ5VMI45.js";
+  azure_exports,
+  s3_exports,
+  ssh_exports
+} from "./chunk-T7RDOCPF.js";
+import {
+  http_exports
+} from "./chunk-7B56UNA6.js";
+import {
+  outputConfiguration,
+  utils_exports
+} from "./chunk-OIXJ4D3Z.js";
 
 // src/uzdu.ts
 import { Command } from "commander";
 var version;
 var description;
 try {
-  version = "1.0.14";
+  version = "1.0.16";
   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,5 +42,9 @@ main().catch((e) => {
   process.exit(20);
 });
 export {
-  program
+  azure_exports as azure,
+  http_exports as http,
+  s3_exports as s3,
+  ssh_exports as ssh,
+  utils_exports as utils
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uzdu",
-  "version": "1.0.14",
+  "version": "1.0.16",
   "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"