dxfl 0.1.7 → 0.1.8

package/dist/deploy.js

@@ -7,28 +7,19 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
 import fs from "fs";
 import path from "path";
-import crypto from "crypto";
-import mime from "mime";
 import { WebsiteApi } from "guichet-sdk-ts";
-import { S3Client, ListObjectsV2Command, DeleteObjectsCommand, HeadObjectCommand, } from "@aws-sdk/client-s3";
-import { Upload } from "@aws-sdk/lib-storage";
 import { PromisePool } from "@supercharge/promise-pool";
 import { openApiConf } from "./auth.js";
-const MD5METAFIELD = "dfl-md5sum";
+import { deleteBucketFile, deleteBucketFiles, getBucket, getBucketFiles, putEmptyObjectRedirect, uploadFile, } from "./bucket.js";
+import { confirmationPrompt, filterMap, formatBytesHuman, formatCount, getFileMd5, sum, } from "./utils.js";
+import { equalBucketRedirect, getBucketConfig, putBucketWebsiteConfig, readConfigFile, } from "./website_config.js";
 // Walks through the local directory at path `dir`, and for each file it contains, returns :
 // - `localPath`: its path on the local filesystem (includes `dir`). On windows, this path
 //    will typically use `\` as separator.
 // - `s3Path`: an equivalent path as we would store it in an S3 bucket, using '/' as separator.
-//   This path includes `s3Prefix` as a prefix if provided. If `s3Prefix` is null, `s3Path`
+//   This path includes `s3Prefix` as a prefix if provided. If `s3Prefix` is undefined, `s3Path`
 //    is relative to the root (of the form "a/b/c", instead of "/a/b/c" if `s3Prefix` is "").
 function getLocalFiles(dir, s3Prefix) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -46,265 +37,333 @@ function getLocalFiles(dir, s3Prefix) {
         return files.flat();
     });
 }
-function getFileMd5(file) {
+function getLocalFilesWithInfo(localFolder) {
     return __awaiter(this, void 0, void 0, function* () {
-        var _a, e_1, _b, _c;
-        const hash = crypto.createHash('md5');
-        try {
-            for (var _d = true, _e = __asyncValues(fs.createReadStream(file)), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
-                _c = _f.value;
-                _d = false;
-                const chunk = _c;
-                hash.update(chunk);
+        const localPaths = yield getLocalFiles(localFolder).catch(err => {
+            if (err.errno == -2) {
+                throw `directory '${localFolder}' does not exist`;
             }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+            else {
+                throw err;
             }
-            finally { if (e_1) throw e_1.error; }
-        }
-        return hash.digest('hex');
+        });
+        return yield Promise.all(localPaths.map((_a) => __awaiter(this, [_a], void 0, function* ({ localPath, s3Path }) {
+            const [stat, localMd5] = yield Promise.all([
+                fs.promises.stat(localPath),
+                getFileMd5(localPath),
+            ]);
+            return {
+                localPath,
+                s3Path,
+                size: stat.size,
+                md5: localMd5,
+            };
+        })));
     });
 }
-function getBucketFiles(client, Bucket) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const files = new Map();
-        let done = false;
-        let cmd = new ListObjectsV2Command({ Bucket });
-        while (!done) {
-            const resp = yield client.send(cmd);
-            if (resp.$metadata.httpStatusCode != 200) {
-                // TODO: better error handling?
-                console.error(resp);
-                process.exit(1);
-            }
-            if (resp.Contents) {
-                for (const item of resp.Contents) {
-                    if (item.Key) {
-                        files.set(item.Key, { size: item.Size });
-                    }
-                }
-            }
-            if (resp.NextContinuationToken) {
-                cmd = new ListObjectsV2Command({
-                    Bucket,
-                    ContinuationToken: resp.NextContinuationToken
-                });
-            }
-            else {
-                done = true;
-            }
+function computeDeployPlan(localFiles, remoteFiles, localCfg, remoteCfg) {
+    // We raise an error if a file is both present locally and is the source of a
+    // redirection.
+    // This is to avoid any ambiguous behavior in dxfl: since the contents of the source of
+    // a redirection do not matter, we ask the user to clarify by deleting either the file
+    // or the redirection.
+    const localRedirectSources = filterMap([...localFiles], f => {
+        const target = localCfg.object_redirects.get(f.s3Path);
+        const ret = target
+            ? [f, target]
+            : undefined;
+        return ret;
+    });
+    if (localRedirectSources.length > 0) {
+        console.error("Error: the following local files are also the source of a redirection:");
+        for (const [f, target] of localRedirectSources) {
+            console.error(`  ${f.localPath} (redirect to: ${target})`);
+        }
+        console.error("\nIt does not make sense for a local file to also be the source of a redirection,\n" +
+            "because its contents will never be read.");
+        console.error("Please delete these files or the corresponding redirections.");
+        process.exit(1);
+    }
+    // Compute object redirects that need to be set because the redirection is new,
+    // the target was changed, or because the source object changed.
+    // (See `redirectsToDelete` below for the "delete" case.)
+    const redirectsToApply = filterMap([...localCfg.object_redirects], ([source, target]) => {
+        let prev_target = remoteCfg.object_redirects.get(source);
+        if (prev_target === undefined) {
+            return { action: "add", source, target };
+        }
+        else if (prev_target != target) {
+            return { action: "update", source, target, prev_target };
         }
-        return files;
     });
+    // Compute object redirects that need to be removed
+    const redirectsToDelete = filterMap([...remoteCfg.object_redirects], ([source, target]) => {
+        if (localCfg.object_redirects.get(source) == undefined) {
+            return { action: "delete", source, prev_target: target };
+        }
+    });
+    const redirects = redirectsToApply.concat(redirectsToDelete);
+    // Compute files to delete: files that are present in the bucket but not locally,
+    // and were not the source of a redirection.
+    // NOTE: the code to apply redirect changes takes care of deleting redirect sources
+    // when needed; `filesToDelete` is only about user-managed files. Thus, we do not
+    // delete files that were source of a redirection here.
+    // NOTE: we delete (and show it to the user) files that were a user file but become
+    // the source of a redirection; this reflects the fact that their contents is deleted.
+    const filesToDelete = [...remoteFiles]
+        .filter(([name, _]) => !localFiles.find(({ s3Path }) => s3Path == name) &&
+        !remoteCfg.object_redirects.has(name))
+        .map(([name, { size }]) => ({ name, size }));
+    // Compute files to upload, i.e files that either:
+    // - are missing on the remote
+    // - have a md5 that differs from their remote ETag,
+    // - have a local size that differs from its remote size
+    let filesToUpload = localFiles.filter(({ s3Path, size, md5 }) => {
+        const remoteFile = remoteFiles.get(s3Path);
+        return !remoteFile || remoteFile.etag != md5 || remoteFile.size != size;
+    });
+    return {
+        localFiles,
+        remoteFiles,
+        filesToDelete,
+        filesToUpload,
+        redirects,
+        index_page: { from: remoteCfg.index_page, to: localCfg.index_page },
+        error_page: { from: remoteCfg.error_page, to: localCfg.error_page },
+        bucket_redirects: {
+            from: remoteCfg.bucket_redirects,
+            to: localCfg.bucket_redirects,
+        },
+    };
 }
-function formatBytes(bytes) {
-    if (bytes < 1000) {
-        return `${bytes}B`;
+function diffBucketRedirects(from, to) {
+    // best-effort diff of bucket redirects
+    const redirects_from = new Map(from.map(r => [r.prefix, r]));
+    const redirects_to = new Map(to.map(r => [r.prefix, r]));
+    const added = new Map(redirects_to);
+    for (const [p, _] of redirects_from) {
+        added.delete(p);
     }
-    bytes /= 1000;
-    if (bytes < 1000) {
-        return `${bytes.toFixed(2)}KB`;
+    const updated = new Map();
+    for (const [p, r] of redirects_from) {
+        const r2 = redirects_to.get(p);
+        if (r2 && !equalBucketRedirect(r, r2)) {
+            updated.set(p, [r, r2]);
+        }
     }
-    bytes /= 1000;
-    if (bytes < 1000) {
-        return `${bytes.toFixed(2)}MB`;
+    const deleted = new Map(redirects_from);
+    for (const [p, _] of redirects_to) {
+        deleted.delete(p);
     }
-    bytes /= 1000;
-    return `${bytes.toFixed(2)}GB`;
+    return { added, updated, deleted };
 }
-function uploadFile(client, Bucket, Key, Body, md5, display) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        // use `path.posix` because `Key` is a path in a bucket that uses `/` as separator.
-        let ContentType = (_a = mime.getType(path.posix.extname(Key))) !== null && _a !== void 0 ? _a : undefined;
-        // add charset=utf-8 by default on text files (TODO: allow the user to override this)
-        if (ContentType && ContentType.startsWith("text/")) {
-            ContentType = ContentType + "; charset=utf-8";
-        }
-        // store the md5 checksum in the object metadata; it will be used to skip
-        // subsequent uploads if the file has not changed.
-        const Metadata = { [MD5METAFIELD]: md5 };
-        const params = { Bucket, Key, Body, ContentType, Metadata };
-        const parallelUpload = new Upload({ client, params });
-        parallelUpload.on("httpUploadProgress", progress => {
-            function writeLine() {
-                process.stdout.write(`Sending ${progress.Key}`);
-                if (progress.loaded && progress.total &&
-                    !(progress.loaded == progress.total && progress.part == 1)) {
-                    process.stdout.write(` (${formatBytes(progress.loaded)}/${formatBytes(progress.total)})`);
-                }
-                process.stdout.write("\n");
-            }
-            ;
-            if (progress.Key) {
-                if (display.lines.has(progress.Key)) {
-                    const offset = display.nblines - display.lines.get(progress.Key);
-                    process.stdout.moveCursor(0, -offset);
-                    process.stdout.clearLine(1);
-                    writeLine();
-                    process.stdout.moveCursor(0, offset - 1);
-                }
-                else {
-                    display.lines.set(progress.Key, display.nblines);
-                    display.nblines++;
-                    writeLine();
-                }
+function printPlan(plan, details) {
+    function showBucketRedirectTarget(r) {
+        const to = r.to.kind == "replace" ? `${r.to.target}` : `${r.to.prefix}*`;
+        const proto = r.protocol ? `${r.protocol}://` : "";
+        const hostname = r.hostname ? `${r.hostname}/` : "";
+        const status = r.status ? ` status=${r.status}` : "";
+        const if_error = r.if_error ? `  if_error=${r.if_error}` : "";
+        return `${proto}${hostname}${to}${status}${if_error}`;
+    }
+    function showBucketRedirect(r) {
+        return `${r.prefix}* -> ${showBucketRedirectTarget(r)}`;
+    }
+    function printSummary(nb, action, bytes) {
+        if (nb > 0) {
+            process.stdout.write(`  ${formatCount(nb, "file")} ${action}`);
+            if (bytes) {
+                process.stdout.write(` (${formatBytesHuman(bytes)})`);
             }
-        });
-        yield parallelUpload.done();
-    });
-}
-function deleteFiles(client, Bucket, files) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (files.length == 0) {
-            return null;
+            process.stdout.write("\n");
         }
-        return yield client.send(new DeleteObjectsCommand({
-            Bucket,
-            Delete: {
-                Objects: files.map(f => { return { Key: f.name }; }),
-            },
-        }));
-    });
-}
-// Checks whether a remote file needs to be updated by its local copy.
-//
-// We first check whether files differ, and if not compare the md5 checksum we
-// previously stored in the object metadata (if it exists) with the local file's
-// md5 checksum.
-function needsUpdate(client, localFile, localMd5, Bucket, Key, remoteSize) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (remoteSize) {
-            const localSize = (yield fs.promises.stat(localFile)).size;
-            if (localSize == 0 /* stat can return 0 in case of error */
-                || localSize != remoteSize) {
-                return true;
+    }
+    // collect bucket redirects
+    const bredirects = diffBucketRedirects(plan.bucket_redirects.from, plan.bucket_redirects.to);
+    // collect object redirects
+    const oredirects_added = plan.redirects.filter(r => r.action == "add");
+    const oredirects_updated = plan.redirects.filter(r => r.action == "update");
+    const oredirects_deleted = plan.redirects.filter(r => r.action == "delete");
+    // print
+    if (details == "summary") {
+        const sizeRemote = sum([...plan.remoteFiles.values()].map(f => { var _a; return (_a = f.size) !== null && _a !== void 0 ? _a : 0; }));
+        const sizeLocal = sum(plan.localFiles.map(f => f.size));
+        const sizeSent = sum(plan.filesToUpload.map(f => f.size));
+        const sizeDeleted = sum(plan.filesToDelete.map(f => { var _a; return (_a = f.size) !== null && _a !== void 0 ? _a : 0; }));
+        let filesUnchanged = new Map(plan.localFiles.map(f => [f.s3Path, f.size]));
+        for (const f of plan.filesToUpload) {
+            filesUnchanged.delete(f.s3Path);
+        }
+        const sizeUnchanged = sum([...filesUnchanged.values()]);
+        printSummary(plan.filesToUpload.length, "uploaded", sizeSent);
+        printSummary(plan.filesToDelete.length, "deleted", sizeDeleted);
+        printSummary(filesUnchanged.size, "unchanged", sizeUnchanged);
+        const items = [
+            [bredirects.added.size + oredirects_added.length, "added"],
+            [bredirects.updated.size + oredirects_updated.length, "modified"],
+            [bredirects.deleted.size + oredirects_deleted.length, "deleted"],
+        ];
+        const sentence = filterMap(items, ([nb, action]) => {
+            if (nb > 0) {
+                return `${formatCount(nb, "redirect")} ${action}`;
             }
+        }).join(", ");
+        if (sentence != "") {
+            process.stdout.write(`  ${sentence}\n`);
         }
-        // fetch metadata for the object and see if we previously stored its md5
-        const resp = yield client.send(new HeadObjectCommand({ Bucket, Key }));
-        if (resp.$metadata.httpStatusCode != 200) {
-            // TODO: better error handling?
-            throw resp;
+        process.stdout.write(`  size: ${formatBytesHuman(sizeRemote)} -> ${formatBytesHuman(sizeLocal)}\n`);
+    }
+    else {
+        for (const file of plan.filesToDelete) {
+            process.stdout.write(`  Delete ${file.name} (${file.size ? formatBytesHuman(file.size) : "?B"})\n`);
         }
-        const remoteMd5 = resp.Metadata ? resp.Metadata[MD5METAFIELD] : null;
-        if (!remoteMd5) {
-            return true;
+        for (const file of plan.filesToUpload) {
+            process.stdout.write(`  Send ${file.s3Path} (${formatBytesHuman(file.size)})\n`);
         }
-        // we have a remote md5, compare it with the local one
-        return (localMd5 != remoteMd5);
-    });
+        // print redirects
+        for (const [_, r] of bredirects.added) {
+            process.stdout.write(`  Add redirect ${showBucketRedirect(r)}\n`);
+        }
+        for (const { source, target } of oredirects_added) {
+            process.stdout.write(`  Add redirect ${source} -> ${target}\n`);
+        }
+        for (const [_, [r_before, r]] of bredirects.updated) {
+            process.stdout.write(`  Update redirect ${showBucketRedirect(r)} (was: ${showBucketRedirectTarget(r_before)})`);
+        }
+        for (const { source, target, prev_target } of oredirects_updated) {
+            process.stdout.write(`  Update redirect ${source} -> ${target} (was: ${prev_target})\n`);
+        }
+        for (const [_, r] of bredirects.deleted) {
+            process.stdout.write(`  Delete redirect ${showBucketRedirect(r)}\n`);
+        }
+        for (const { source, prev_target } of oredirects_deleted) {
+            process.stdout.write(`  Delete redirect ${source} -> ${prev_target}\n`);
+        }
+    }
+    // print other (index, error page)
+    function s(s) {
+        return s !== null && s !== void 0 ? s : "<undefined>";
+    }
+    if (plan.index_page.from != plan.index_page.to) {
+        process.stdout.write(`  Update index_page: ${s(plan.index_page.from)} -> ${s(plan.index_page.to)}\n`);
+    }
+    if (plan.error_page.from != plan.error_page.to) {
+        process.stdout.write(`  Update error_page: ${s(plan.error_page.from)} -> ${s(plan.error_page.to)}\n`);
+    }
 }
-export function deploy(vhost, localFolder, options) {
+function applyDeployPlan(bucket, plan) {
     return __awaiter(this, void 0, void 0, function* () {
-        const conf = yield openApiConf();
-        // Get paths of the local files to deploy
-        const localPaths = yield getLocalFiles(localFolder, "").catch(err => {
-            if (err.errno = -2) {
-                console.error(`Error: directory '${localFolder}' does not exist`);
-            }
-            else {
-                console.error(err);
-            }
-            process.exit(1);
-        });
-        // Compute local file sizes
-        const localFiles = yield Promise.all(localPaths.map((_a) => __awaiter(this, [_a], void 0, function* ({ localPath, s3Path }) {
-            return { localPath, s3Path, size: (yield fs.promises.stat(localPath)).size };
-        })));
-        // Get website info from guichet (bucket name and keys)
-        const api = new WebsiteApi(conf);
-        let vhostInfo = yield api.getWebsite({ vhost }).catch(err => {
-            if (err.response.status == 404) {
-                console.error(`Error: website '${vhost}' does not exist`);
+        // Delete files.
+        // Do this before sending new files to avoid hitting the size quota
+        // unnecessarily.
+        yield deleteBucketFiles(bucket, plan.filesToDelete);
+        // Apply object redirects.
+        // Since the source of object redirects cannot be user files (cf the
+        // check at the beginning of `computeDeployPlan`, we can do this before
+        // uploading user files.
+        // Furthermore, in the case of a previously uploaded user file that now
+        // becomes the source of a redirection (thus truncating it), we free
+        // space in the bucket by doing so, so we should do it before uploading.
+        yield PromisePool.for(plan.redirects)
+            .withConcurrency(50)
+            .handleError(err => {
+            throw err;
+        })
+            .process((r) => __awaiter(this, void 0, void 0, function* () {
+            if (r.action == "delete") {
+                yield deleteBucketFile(bucket, r.source);
             }
             else {
-                console.error(err);
+                yield putEmptyObjectRedirect(bucket, r.source, r.target);
             }
-            process.exit(1);
-        });
-        // List the files currently stored in the bucket
-        // @FIXME this info could be returned by the guichet API
-        const s3client = new S3Client({
-            endpoint: "https://garage.deuxfleurs.fr",
-            region: "garage",
-            forcePathStyle: true,
-            credentials: {
-                accessKeyId: vhostInfo.accessKeyId,
-                secretAccessKey: vhostInfo.secretAccessKey,
-            },
+        }));
+        // Upload files
+        yield PromisePool.for(plan.filesToUpload)
+            .withConcurrency(50)
+            .handleError(err => {
+            throw err;
+        })
+            .process((f) => __awaiter(this, void 0, void 0, function* () {
+            process.stdout.write(`  Send ${f.s3Path} (${formatBytesHuman(f.size)})\n`);
+            yield uploadFile(bucket, f.s3Path, f.localPath);
+        }));
+        // Apply bucket redirects & global config
+        yield putBucketWebsiteConfig(bucket, plan.index_page.to, plan.error_page.to, plan.bucket_redirects.to);
+    });
+}
+function deployMain(website, localFolder, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (options.dryRun && options.yes) {
+            throw "options --yes and --dry-run cannot be passed at the same time";
+        }
+        // TODO: make this configurable
+        const website_config_path = "deuxfleurs.toml";
+        // Read and validate the local configuration file before doing anything else
+        const localWebsiteConfig = yield readConfigFile(website_config_path).catch(err => {
+            throw `while reading ${website_config_path}:\n${err}`;
         });
-        const Bucket = vhostInfo.vhost.name;
-        const remoteFiles = yield getBucketFiles(s3client, Bucket);
-        // Delete files that are present in the bucket but not locally.
-        // Do this before sending the new files to avoid hitting the size quota
-        // unnecessarily.
-        const filesToDelete = [...remoteFiles]
-            .filter(([name, _]) => !localFiles.find(({ s3Path }) => s3Path == name))
-            .map(([name, { size }]) => ({ name, size }));
-        for (const file of filesToDelete) {
-            process.stdout.write(`Deleting ${file.name}\n`);
+        process.stdout.write("Fetching the website configuration and metadata...\n");
+        const [localFiles, [bucket, remoteFiles, remoteWebsiteConfig]] = yield Promise.all([
+            // Get paths & size of the local files to deploy
+            getLocalFilesWithInfo(localFolder),
+            // Get the bucket, list of files stored in the bucket, and bucket website config
+            (() => __awaiter(this, void 0, void 0, function* () {
+                const guichet = yield openApiConf();
+                const api = new WebsiteApi(guichet);
+                const bucket = yield getBucket(api, website);
+                const remoteFiles = yield getBucketFiles(bucket);
+                // This can be slow because it needs to query each object in the bucket.
+                const remoteWebsiteConfig = yield getBucketConfig(bucket, [
+                    ...remoteFiles.keys(),
+                ]);
+                return [bucket, remoteFiles, remoteWebsiteConfig];
+            }))(),
+        ]);
+        // Compute the deploy plan
+        const plan = computeDeployPlan(localFiles, remoteFiles, localWebsiteConfig, remoteWebsiteConfig);
+        // If --dry-run: display the plan and return
+        if (options.dryRun) {
+            printPlan(plan, "full");
+            process.stdout.write("\nSummary:\n");
+            printPlan(plan, "summary");
+            return;
         }
-        // If not in dry-run mode, send the delete command
-        if (!options.dryRun) {
-            const resp = yield deleteFiles(s3client, Bucket, filesToDelete);
-            if (resp && resp.$metadata.httpStatusCode != 200) {
-                // TODO: better error handling?
-                console.error(resp);
-                process.exit(1);
+        // If not --yes: show the plan summary, ask for confirmation before proceeding
+        if (!options.yes) {
+            process.stdout.write("The following changes will be made:\n");
+            printPlan(plan, "summary");
+            process.stdout.write("\n");
+            const ok = yield confirmationPrompt(() => {
+                process.stdout.write("Details of planned changes:\n");
+                printPlan(plan, "full");
+            });
+            if (!ok) {
+                return;
             }
         }
-        // Upload files.
-        let displaystate = {
-            lines: new Map(),
-            nblines: 0
-        };
-        let filesSent = [];
-        function processFile(f) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const remoteFile = remoteFiles.get(f.s3Path);
-                const localMd5 = yield getFileMd5(f.localPath);
-                if (!remoteFile ||
-                    (yield needsUpdate(s3client, f.localPath, localMd5, Bucket, f.s3Path, remoteFile.size))) {
-                    filesSent.push({ s3Path: f.s3Path, size: f.size });
-                    if (options.dryRun) {
-                        process.stdout.write(`Sending ${f.s3Path}\n`);
-                    }
-                    else {
-                        yield uploadFile(s3client, Bucket, f.s3Path, fs.createReadStream(f.localPath), localMd5, displaystate);
-                    }
-                }
-            });
+        // Apply the deploy plan
+        yield applyDeployPlan(bucket, plan);
+        // Display a summary if --yes was used
+        if (options.yes) {
+            process.stdout.write("\nSummary:\n");
+            printPlan(plan, "summary");
         }
-        ;
-        // Control concurrency while uploading
-        yield PromisePool
-            .for(localFiles)
-            .withConcurrency(6)
-            .process(processFile);
-        // Display a summary
-        function sum(a) { return a.reduce(((x, y) => x + y), 0); }
-        function formatFiles(n) {
-            if (n == 1) {
-                return `${n} file `;
+    });
+}
+export function deploy(website, localFolder, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            yield deployMain(website, localFolder, options);
+        }
+        catch (err) {
+            if (typeof err == "string" || (err === null || err === void 0 ? void 0 : err.name) === "AbortError") {
+                console.error(`Error: ${err}`);
             }
             else {
-                return `${n} files`;
+                console.error("Error:");
+                console.error(err);
             }
+            process.exit(1);
         }
-        const sizeSent = sum(filesSent.map((f) => f.size));
-        const sizeDeleted = sum(filesToDelete.map((f) => { var _a; return (_a = f.size) !== null && _a !== void 0 ? _a : 0; }));
-        let filesUnchanged = new Map(localFiles.map((f) => [f.s3Path, f.size]));
-        for (const f of filesSent) {
-            filesUnchanged.delete(f.s3Path);
-        }
-        const sizeUnchanged = sum([...filesUnchanged.values()]);
-        process.stdout.write("\nSummary:\n");
-        process.stdout.write(`${formatFiles(filesSent.length)} uploaded (${formatBytes(sizeSent)})\n`);
-        process.stdout.write(`${formatFiles(filesToDelete.length)} deleted (${formatBytes(sizeDeleted)})\n`);
-        process.stdout.write(`${formatFiles(filesUnchanged.size)} unchanged (${formatBytes(sizeUnchanged)})\n`);
     });
 }