phio 0.3.4 → 0.4.0

package/vendor/ftp-deploy/sftpDeploy.ts

@@ -0,0 +1,233 @@
+import fs from "fs";
+import SftpClient from "ssh2-sftp-client";
+import { IFileList, IDiff, syncFileDescription, currentSyncFileVersion, IFtpDeployArgumentsWithDefaults } from "./types";
+import { HashDiff } from "./HashDiff";
+import { ILogger, retryRequest, ITimings, applyExcludeFilter, formatNumber } from "./utilities";
+import prettyBytes from "pretty-bytes";
+import { prettyError } from "./errorHandling";
+import { ensureSftpDir, SFTPSyncProvider } from "./sftpSyncProvider";
+import { getLocalFiles } from "./localFiles";
+import { readPrivateKeyForSsh2 } from "./sshPrivateKey";
+
+async function downloadFileList(client: SftpClient, logger: ILogger, path: string): Promise<IFileList> {
+    const tempFileNameHack = ".ftp-deploy-sync-server-state-buffer-file---delete.json";
+
+    await retryRequest(logger, async () => await client.fastGet(path, tempFileNameHack));
+
+    const fileAsString = fs.readFileSync(tempFileNameHack, { encoding: "utf-8" });
+    const fileAsObject = JSON.parse(fileAsString) as IFileList;
+
+    fs.unlinkSync(tempFileNameHack);
+
+    return fileAsObject;
+}
+
+function createLocalState(localFiles: IFileList, logger: ILogger, args: IFtpDeployArgumentsWithDefaults): void {
+    logger.verbose(`Creating local state at ${args["local-dir"]}${args["state-name"]}`);
+    fs.writeFileSync(`${args["local-dir"]}${args["state-name"]}`, JSON.stringify(localFiles, undefined, 4), {
+        encoding: "utf8",
+    });
+    logger.verbose("Local state created");
+}
+
+async function connect(client: SftpClient, args: IFtpDeployArgumentsWithDefaults, logger: ILogger) {
+    if (!args["private-key-path"]) {
+        throw new Error(`SFTP deploy requires "private-key-path"`);
+    }
+
+    const privateKey = readPrivateKeyForSsh2(args["private-key-path"]);
+
+    try {
+        await client.connect({
+            host: args.server,
+            port: args.port,
+            username: args.username,
+            privateKey,
+            readyTimeout: args.timeout,
+        });
+    } catch (error) {
+        logger.all("Failed to connect over SFTP. Check host, port, username, and deploy key registration.");
+        throw error;
+    }
+
+    const serverDir = args["server-dir"].replace(/\/$/, "") || ".";
+    await retryRequest(logger, async () => await client.realPath(serverDir));
+}
+
+async function getServerFiles(
+    client: SftpClient,
+    logger: ILogger,
+    timings: ITimings,
+    args: IFtpDeployArgumentsWithDefaults
+): Promise<IFileList> {
+    try {
+        await ensureSftpDir(client, logger, timings, ".");
+
+        if (args["dangerous-clean-slate"]) {
+            logger.all(`----------------------------------------------------------------`);
+            logger.all(
+                "🗑️ Removing all files on the server because 'dangerous-clean-slate' was set, this will make the deployment very slow..."
+            );
+            if (args["dry-run"] === false) {
+                const entries = await client.list(".");
+                for (const entry of entries) {
+                    if (entry.name === "." || entry.name === "..") continue;
+                    if (entry.type === "d") {
+                        await client.rmdir(entry.name, true);
+                    } else {
+                        await client.delete(entry.name);
+                    }
+                }
+            }
+            logger.all("Clear complete");
+
+            throw new Error("dangerous-clean-slate was run");
+        }
+
+        const serverFiles = await downloadFileList(client, logger, args["state-name"]);
+        logger.all(`----------------------------------------------------------------`);
+        logger.all(
+            `Last published on 📅 ${new Date(serverFiles.generatedTime).toLocaleDateString(undefined, {
+                weekday: "long",
+                year: "numeric",
+                month: "long",
+                day: "numeric",
+                hour: "numeric",
+                minute: "numeric",
+            })}`
+        );
+
+        if (args.exclude.length > 0) {
+            const filteredData = serverFiles.data.filter((item) =>
+                applyExcludeFilter({ path: item.name, isDirectory: () => item.type === "folder" }, args.exclude)
+            );
+            serverFiles.data = filteredData;
+        }
+
+        return serverFiles;
+    } catch (error) {
+        logger.all(`----------------------------------------------------------------`);
+        logger.all(`No file exists on the server "${args["server-dir"] + args["state-name"]}" - this must be your first publish! 🎉`);
+        logger.all(`The first publish will take a while... but once the initial sync is done only differences are published!`);
+        logger.all(`If you get this message and its NOT your first publish, something is wrong.`);
+
+        return {
+            description: syncFileDescription,
+            version: currentSyncFileVersion,
+            generatedTime: new Date().getTime(),
+            data: [],
+        };
+    }
+}
+
+export async function deploySftp(args: IFtpDeployArgumentsWithDefaults, logger: ILogger, timings: ITimings): Promise<void> {
+    timings.start("total");
+
+    logger.all(`----------------------------------------------------------------`);
+    logger.all(`🚀 Thanks for using ftp-deploy. Let's deploy some stuff!   `);
+    logger.all(`----------------------------------------------------------------`);
+    logger.verbose(`Using the following include filters: ${JSON.stringify(args.include)}`);
+    logger.verbose(`Using the following excludes filters: ${JSON.stringify(args.exclude)}`);
+
+    timings.start("hash");
+    const localFiles = await getLocalFiles(args, logger);
+    timings.stop("hash");
+
+    createLocalState(localFiles, logger, args);
+
+    const client = new SftpClient();
+
+    let totalBytesUploaded = 0;
+    try {
+        timings.start("connecting");
+        await connect(client, args, logger);
+        timings.stop("connecting");
+
+        const serverFiles = await getServerFiles(client, logger, timings, args);
+
+        timings.start("logging");
+        const diffTool: IDiff = new HashDiff();
+
+        logger.standard(`----------------------------------------------------------------`);
+        logger.standard(`Local Files:\t${formatNumber(localFiles.data.length)}`);
+        logger.standard(`Server Files:\t${formatNumber(serverFiles.data.length)}`);
+        logger.standard(`----------------------------------------------------------------`);
+        logger.standard(`Calculating differences between client & server`);
+        logger.standard(`----------------------------------------------------------------`);
+        logger.verbose(`Local files:`, JSON.stringify(localFiles, null, 2));
+        logger.verbose(`Server files:`, JSON.stringify(serverFiles, null, 2));
+
+        const diffs = diffTool.getDiffs(localFiles, serverFiles);
+
+        diffs.upload
+            .filter((itemUpload) => itemUpload.type === "folder")
+            .map((itemUpload) => {
+                logger.standard(`📁 Create: ${itemUpload.name}`);
+            });
+
+        diffs.upload
+            .filter((itemUpload) => itemUpload.type === "file")
+            .map((itemUpload) => {
+                logger.standard(`📄 Upload: ${itemUpload.name}`);
+            });
+
+        diffs.replace.map((itemReplace) => {
+            logger.standard(`🔁 File replace: ${itemReplace.name}`);
+        });
+
+        diffs.delete
+            .filter((itemUpload) => itemUpload.type === "file")
+            .map((itemDelete) => {
+                logger.standard(`📄 Delete: ${itemDelete.name}    `);
+            });
+
+        diffs.delete
+            .filter((itemUpload) => itemUpload.type === "folder")
+            .map((itemDelete) => {
+                logger.standard(`📁 Delete: ${itemDelete.name}    `);
+            });
+
+        diffs.same.map((itemSame) => {
+            if (itemSame.type === "file") {
+                logger.standard(`⚖️  File content is the same, doing nothing: ${itemSame.name}`);
+            }
+        });
+        timings.stop("logging");
+
+        totalBytesUploaded = diffs.sizeUpload + diffs.sizeReplace;
+
+        timings.start("upload");
+        try {
+            const syncProvider = new SFTPSyncProvider(
+                client,
+                logger,
+                timings,
+                args["local-dir"],
+                args["server-dir"],
+                args["state-name"],
+                args["dry-run"]
+            );
+            await syncProvider.syncLocalToServer(diffs);
+        } finally {
+            timings.stop("upload");
+        }
+    } catch (error) {
+        prettyError(logger, args, error);
+        throw error;
+    } finally {
+        await client.end();
+        timings.stop("total");
+    }
+
+    const uploadSpeed = prettyBytes(totalBytesUploaded / (timings.getTime("upload") / 1000));
+
+    logger.all(`----------------------------------------------------------------`);
+    logger.all(`Time spent hashing: ${timings.getTimeFormatted("hash")}`);
+    logger.all(`Time spent connecting to server: ${timings.getTimeFormatted("connecting")}`);
+    logger.all(`Time spent deploying: ${timings.getTimeFormatted("upload")} (${uploadSpeed}/second)`);
+    logger.all(`  - changing dirs: ${timings.getTimeFormatted("changingDir")}`);
+    logger.all(`  - logging: ${timings.getTimeFormatted("logging")}`);
+    logger.all(`----------------------------------------------------------------`);
+    logger.all(`Total time: ${timings.getTimeFormatted("total")}`);
+    logger.all(`----------------------------------------------------------------`);
+}

package/vendor/ftp-deploy/sftpSyncProvider.ts

@@ -0,0 +1,188 @@
+import prettyBytes from "pretty-bytes";
+import type SftpClient from "ssh2-sftp-client";
+import { DiffResult, IFilePath } from "./types";
+import { ISyncProvider } from "./syncProvider";
+import { ILogger, pluralize, retryRequest, ITimings } from "./utilities";
+
+export async function ensureSftpDir(
+    client: SftpClient,
+    logger: ILogger,
+    timings: ITimings,
+    folder: string
+): Promise<void> {
+    timings.start("changingDir");
+    logger.verbose(`  ensuring dir ${folder}`);
+
+    await retryRequest(logger, async () => {
+        const target = folder === "." || folder === "" ? "." : folder;
+        if (target !== ".") {
+            const exists = await client.exists(target);
+            if (!exists) {
+                await client.mkdir(target, true);
+            }
+            await client.realPath(target);
+        }
+    });
+
+    logger.verbose(`  dir ready`);
+    timings.stop("changingDir");
+}
+
+export class SFTPSyncProvider implements ISyncProvider {
+    constructor(
+        client: SftpClient,
+        logger: ILogger,
+        timings: ITimings,
+        localPath: string,
+        serverPath: string,
+        stateName: string,
+        dryRun: boolean
+    ) {
+        this.client = client;
+        this.logger = logger;
+        this.timings = timings;
+        this.localPath = localPath;
+        this.serverPath = serverPath;
+        this.stateName = stateName;
+        this.dryRun = dryRun;
+    }
+
+    private client: SftpClient;
+    private logger: ILogger;
+    private timings: ITimings;
+    private localPath: string;
+    private serverPath: string;
+    private dryRun: boolean;
+    private stateName: string;
+
+    private getFileBreadcrumbs(fullPath: string): IFilePath {
+        const pathSplit = fullPath.split("/");
+        const file = pathSplit?.pop() ?? "";
+        const folders = pathSplit.filter((folderName) => folderName != "");
+
+        return {
+            folders: folders.length === 0 ? null : folders,
+            file: file === "" ? null : file,
+        };
+    }
+
+    private async upDir(dirCount: number | null | undefined): Promise<void> {
+        if (typeof dirCount !== "number") {
+            return;
+        }
+
+        for (let i = 0; i < dirCount; i++) {
+            await retryRequest(this.logger, async () => await this.client.realPath(".."));
+        }
+    }
+
+    async createFolder(folderPath: string) {
+        this.logger.all(`creating folder "${folderPath + "/"}"`);
+
+        if (this.dryRun === true) {
+            return;
+        }
+
+        const path = this.getFileBreadcrumbs(folderPath + "/");
+
+        if (path.folders === null) {
+            this.logger.verbose(`  no need to change dir`);
+        } else {
+            await ensureSftpDir(this.client, this.logger, this.timings, path.folders.join("/"));
+        }
+
+        await this.upDir(path.folders?.length);
+
+        this.logger.verbose(`  completed`);
+    }
+
+    async removeFile(filePath: string) {
+        this.logger.all(`removing "${filePath}"`);
+
+        if (this.dryRun === false) {
+            try {
+                await retryRequest(this.logger, async () => await this.client.delete(filePath));
+            } catch (e: any) {
+                const message = `${e?.message ?? e}`.toLowerCase();
+                if (message.includes("no such file") || message.includes("not found")) {
+                    this.logger.standard("File not found or you don't have access to the file - skipping...");
+                } else {
+                    throw e;
+                }
+            }
+        }
+        this.logger.verbose(`  file removed`);
+        this.logger.verbose(`  completed`);
+    }
+
+    async removeFolder(folderPath: string) {
+        const absoluteFolderPath =
+            "/" +
+            (this.serverPath.startsWith("./") ? this.serverPath.replace("./", "") : this.serverPath) +
+            folderPath;
+        this.logger.all(`removing folder "${absoluteFolderPath}"`);
+
+        if (this.dryRun === false) {
+            await retryRequest(this.logger, async () => await this.client.rmdir(folderPath));
+        }
+
+        this.logger.verbose(`  completed`);
+    }
+
+    async uploadFile(filePath: string, type: "upload" | "replace" = "upload") {
+        const typePresent = type === "upload" ? "uploading" : "replacing";
+        const typePast = type === "upload" ? "uploaded" : "replaced";
+        this.logger.all(`${typePresent} "${filePath}"`);
+
+        if (this.dryRun === false) {
+            await retryRequest(
+                this.logger,
+                async () => await this.client.fastPut(this.localPath + filePath, filePath)
+            );
+        }
+
+        this.logger.verbose(`  file ${typePast}`);
+    }
+
+    async syncLocalToServer(diffs: DiffResult) {
+        const totalCount = diffs.delete.length + diffs.upload.length + diffs.replace.length;
+
+        this.logger.all(`----------------------------------------------------------------`);
+        this.logger.all(
+            `Making changes to ${totalCount} ${pluralize(totalCount, "file/folder", "files/folders")} to sync server state`
+        );
+        this.logger.all(
+            `Uploading: ${prettyBytes(diffs.sizeUpload)} -- Deleting: ${prettyBytes(diffs.sizeDelete)} -- Replacing: ${prettyBytes(diffs.sizeReplace)}`
+        );
+        this.logger.all(`----------------------------------------------------------------`);
+
+        for (const file of diffs.upload.filter((item) => item.type === "folder")) {
+            await this.createFolder(file.name);
+        }
+
+        for (const file of diffs.upload.filter((item) => item.type === "file").filter((item) => item.name !== this.stateName)) {
+            await this.uploadFile(file.name, "upload");
+        }
+
+        for (const file of diffs.replace.filter((item) => item.type === "file").filter((item) => item.name !== this.stateName)) {
+            await this.uploadFile(file.name, "replace");
+        }
+
+        for (const file of diffs.delete.filter((item) => item.type === "file")) {
+            await this.removeFile(file.name);
+        }
+
+        for (const file of diffs.delete.filter((item) => item.type === "folder")) {
+            await this.removeFolder(file.name);
+        }
+
+        this.logger.all(`----------------------------------------------------------------`);
+        this.logger.all(`🎉 Sync complete. Saving current server state to "${this.serverPath + this.stateName}"`);
+        if (this.dryRun === false) {
+            await retryRequest(
+                this.logger,
+                async () => await this.client.fastPut(this.localPath + this.stateName, this.stateName)
+            );
+        }
+    }
+}

package/vendor/ftp-deploy/sshPrivateKey.ts

@@ -0,0 +1,66 @@
+import { createPrivateKey, randomBytes } from 'crypto'
+import { readFileSync } from 'fs'
+
+const writeSshString = (value: Buffer | string) => {
+  const buf = Buffer.isBuffer(value) ? value : Buffer.from(value)
+  const len = Buffer.alloc(4)
+  len.writeUInt32BE(buf.length)
+  return Buffer.concat([len, buf])
+}
+
+export const isPkcs8PrivateKey = (pem: string) => /-----BEGIN PRIVATE KEY-----/.test(pem)
+
+/** ssh2 only accepts OpenSSH / legacy PEM formats, not PKCS#8 Ed25519. */
+export const pkcs8Ed25519ToOpenSshPrivateKeyPem = (pem: string, comment = 'phio') => {
+  const key = createPrivateKey(pem)
+  if (key.asymmetricKeyType !== 'ed25519') {
+    throw new Error('Deploy key must be Ed25519')
+  }
+
+  const jwk = key.export({ format: 'jwk' }) as { d: string; x: string }
+  const seed = Buffer.from(jwk.d, 'base64url')
+  const pub = Buffer.from(jwk.x, 'base64url')
+  const pubWire = Buffer.concat([writeSshString('ssh-ed25519'), writeSshString(pub)])
+
+  const check = randomBytes(4)
+  const privPlain = Buffer.concat([
+    check,
+    check,
+    writeSshString('ssh-ed25519'),
+    writeSshString(pub),
+    writeSshString(Buffer.concat([seed, pub])),
+    writeSshString(comment),
+  ])
+
+  const blockSize = 8
+  const padLen = blockSize - (privPlain.length % blockSize)
+  const padding = Buffer.alloc(padLen)
+  for (let i = 0; i < padLen; i++) {
+    padding[i] = i + 1
+  }
+
+  const blob = Buffer.concat([
+    Buffer.from('openssh-key-v1\0'),
+    writeSshString('none'),
+    writeSshString('none'),
+    writeSshString(''),
+    (() => {
+      const count = Buffer.alloc(4)
+      count.writeUInt32BE(1)
+      return count
+    })(),
+    writeSshString(pubWire),
+    writeSshString(Buffer.concat([privPlain, padding])),
+  ])
+
+  const b64 = blob.toString('base64').replace(/.{70}/g, '$&\n')
+  return `-----BEGIN OPENSSH PRIVATE KEY-----\n${b64}\n-----END OPENSSH PRIVATE KEY-----\n`
+}
+
+export const readPrivateKeyForSsh2 = (privateKeyPath: string) => {
+  const pem = readFileSync(privateKeyPath, 'utf8')
+  if (isPkcs8PrivateKey(pem)) {
+    return pkcs8Ed25519ToOpenSshPrivateKeyPem(pem)
+  }
+  return pem
+}

package/vendor/ftp-deploy/syncProvider.ts

@@ -0,0 +1,189 @@
+import prettyBytes from "pretty-bytes";
+import type * as ftp from "basic-ftp";
+import { DiffResult, ErrorCode, IFilePath } from "./types";
+import { ILogger, pluralize, retryRequest, ITimings } from "./utilities";
+
+export async function ensureDir(client: ftp.Client, logger: ILogger, timings: ITimings, folder: string): Promise<void> {
+    timings.start("changingDir");
+    logger.verbose(`  changing dir to ${folder}`);
+
+    await retryRequest(logger, async () => await client.ensureDir(folder));
+
+    logger.verbose(`  dir changed`);
+    timings.stop("changingDir");
+}
+
+export interface ISyncProvider {
+    createFolder(folderPath: string): Promise<void>;
+    removeFile(filePath: string): Promise<void>;
+    removeFolder(folderPath: string): Promise<void>;
+
+    /**
+     * @param file file can include folder(s)
+     * Note working dir is modified and NOT reset after upload
+     * For now we are going to reset it - but this will be removed for performance
+     */
+    uploadFile(filePath: string, type: "upload" | "replace"): Promise<void>;
+
+    syncLocalToServer(diffs: DiffResult): Promise<void>;
+}
+
+export class FTPSyncProvider implements ISyncProvider {
+    constructor(client: ftp.Client, logger: ILogger, timings: ITimings, localPath: string, serverPath: string, stateName: string, dryRun: boolean) {
+        this.client = client;
+        this.logger = logger;
+        this.timings = timings;
+        this.localPath = localPath;
+        this.serverPath = serverPath;
+        this.stateName = stateName;
+        this.dryRun = dryRun;
+    }
+
+    private client: ftp.Client;
+    private logger: ILogger;
+    private timings: ITimings;
+    private localPath: string;
+    private serverPath: string;
+    private dryRun: boolean;
+    private stateName: string;
+
+
+    /**
+     * Converts a file path (ex: "folder/otherfolder/file.txt") to an array of folder and a file path
+     * @param fullPath 
+     */
+    private getFileBreadcrumbs(fullPath: string): IFilePath {
+        // todo see if this regex will work for nonstandard folder names
+        // todo what happens if the path is relative to the root dir? (starts with /)
+        const pathSplit = fullPath.split("/");
+        const file = pathSplit?.pop() ?? ""; // get last item
+        const folders = pathSplit.filter(folderName => folderName != "");
+
+        return {
+            folders: folders.length === 0 ? null : folders,
+            file: file === "" ? null : file
+        };
+    }
+
+    /**
+     * Navigates up {dirCount} number of directories from the current working dir
+     */
+    private async upDir(dirCount: number | null | undefined): Promise<void> {
+        if (typeof dirCount !== "number") {
+            return;
+        }
+
+        // navigate back to the starting folder
+        for (let i = 0; i < dirCount; i++) {
+            await retryRequest(this.logger, async () => await this.client.cdup());
+        }
+    }
+
+    async createFolder(folderPath: string) {
+        this.logger.all(`creating folder "${folderPath + "/"}"`);
+
+        if (this.dryRun === true) {
+            return;
+        }
+
+        const path = this.getFileBreadcrumbs(folderPath + "/");
+
+        if (path.folders === null) {
+            this.logger.verbose(`  no need to change dir`);
+        }
+        else {
+            await ensureDir(this.client, this.logger, this.timings, path.folders.join("/"));
+        }
+
+        // navigate back to the root folder
+        await this.upDir(path.folders?.length);
+
+        this.logger.verbose(`  completed`);
+    }
+
+    async removeFile(filePath: string) {
+        this.logger.all(`removing "${filePath}"`);
+
+        if (this.dryRun === false) {
+            try {
+                await retryRequest(this.logger, async () => await this.client.remove(filePath));
+            }
+            catch (e: any) {
+                // this error is common when a file was deleted on the server directly
+                if (e.code === ErrorCode.FileNotFoundOrNoAccess) {
+                    this.logger.standard("File not found or you don't have access to the file - skipping...");
+                }
+                else {
+                    throw e;
+                }
+            }
+        }
+        this.logger.verbose(`  file removed`);
+
+        this.logger.verbose(`  completed`);
+    }
+
+    async removeFolder(folderPath: string) {
+        const absoluteFolderPath = "/" + (this.serverPath.startsWith("./") ? this.serverPath.replace("./", "") : this.serverPath) + folderPath;
+        this.logger.all(`removing folder "${absoluteFolderPath}"`);
+
+        if (this.dryRun === false) {
+            await retryRequest(this.logger, async () => await this.client.removeDir(absoluteFolderPath));
+        }
+
+        this.logger.verbose(`  completed`);
+    }
+
+    async uploadFile(filePath: string, type: "upload" | "replace" = "upload") {
+        const typePresent = type === "upload" ? "uploading" : "replacing";
+        const typePast = type === "upload" ? "uploaded" : "replaced";
+        this.logger.all(`${typePresent} "${filePath}"`);
+
+        if (this.dryRun === false) {
+            await retryRequest(this.logger, async () => await this.client.uploadFrom(this.localPath + filePath, filePath));
+        }
+
+        this.logger.verbose(`  file ${typePast}`);
+    }
+
+    async syncLocalToServer(diffs: DiffResult) {
+        const totalCount = diffs.delete.length + diffs.upload.length + diffs.replace.length;
+
+        this.logger.all(`----------------------------------------------------------------`);
+        this.logger.all(`Making changes to ${totalCount} ${pluralize(totalCount, "file/folder", "files/folders")} to sync server state`);
+        this.logger.all(`Uploading: ${prettyBytes(diffs.sizeUpload)} -- Deleting: ${prettyBytes(diffs.sizeDelete)} -- Replacing: ${prettyBytes(diffs.sizeReplace)}`);
+        this.logger.all(`----------------------------------------------------------------`);
+
+        // create new folders
+        for (const file of diffs.upload.filter(item => item.type === "folder")) {
+            await this.createFolder(file.name);
+        }
+
+        // upload new files
+        for (const file of diffs.upload.filter(item => item.type === "file").filter(item => item.name !== this.stateName)) {
+            await this.uploadFile(file.name, "upload");
+        }
+
+        // replace new files
+        for (const file of diffs.replace.filter(item => item.type === "file").filter(item => item.name !== this.stateName)) {
+            // note: FTP will replace old files with new files. We run replacements after uploads to limit downtime
+            await this.uploadFile(file.name, "replace");
+        }
+
+        // delete old files
+        for (const file of diffs.delete.filter(item => item.type === "file")) {
+            await this.removeFile(file.name);
+        }
+
+        // delete old folders
+        for (const file of diffs.delete.filter(item => item.type === "folder")) {
+            await this.removeFolder(file.name);
+        }
+
+        this.logger.all(`----------------------------------------------------------------`);
+        this.logger.all(`🎉 Sync complete. Saving current server state to "${this.serverPath + this.stateName}"`);
+        if (this.dryRun === false) {
+            await retryRequest(this.logger, async () => await this.client.uploadFrom(this.localPath + this.stateName, this.stateName));
+        }
+    }
+}