dorky 1.2.2 → 2.0.0

package/To-Do

@@ -0,0 +1,24 @@
+Add stages for variables.
+Fix workflow with CI instead of npm i.
+Convert to TypeScript.
+
+
+Possible commands to add =>
+- node bin/index.js --init [aws|google-drive]
+- node bin/index.js --add [file-names]
+- node bin/index.js --list
+- node bin/index.js --push
+- node bin/index.js --pull
+
+{
+    "stage-1-files": {
+        "abc.txt": {
+            "mime-type": "text/plain",
+            "checksum": ""
+        }
+    },
+    "uploaded-files": ["uid1"]
+}
+
+checksum of the file contents will be the encrypted string in md5
+option to avoid checksum (used when file size is large)

package/bin/index.js

@@ -0,0 +1,395 @@
+#!/usr/bin/env node
+
+const yargs = require("yargs");
+const { existsSync, mkdirSync, writeFileSync } = require("fs");
+const chalk = require("chalk");
+const { glob } = require("glob");
+const path = require("path");
+const fs = require("fs");
+const mimeTypes = require("mime-types");
+const md5 = require('md5');
+const EOL = require("os").type() == "Darwin" ? "\r\n" : "\n";
+const { GetObjectCommand, PutObjectCommand, S3Client } = require("@aws-sdk/client-s3");
+const { authenticate } = require('@google-cloud/local-auth');
+const { google } = require('googleapis');
+
+// Google Drive config ************************************************************
+const SCOPES = ['https://www.googleapis.com/auth/drive'];
+const CREDENTIALS_PATH = path.join(__dirname, "../google-drive-credentials.json");
+const TOKEN_PATH = path.join(process.cwd(), '.dorky/credentials.json');
+// ********************************************************************************
+
+const figlet = `
+      __            __          \t
+  .--|  |-----.----|  |--.--.--.\t
+  |  _  |  _  |   _|    <|  |  |\t
+  |_____|_____|__| |__|__|___  |\t
+                         |_____|\t
+`;
+// Should display the process.env.AWS_ACCESS_KEY, process.env.AWS_SECRET_KEY, process.env.AWS_REGION, process.env.BUCKET_NAME to be set
+const usage = `${figlet}`;
+let randomColor = null;
+do {
+    const randomHex = Math.floor(Math.random() * 16777215).toString(16);
+    randomColor = `#${randomHex}`;
+} while (randomColor[2] === "f" || randomColor[3] === "f");
+// randomColor[2].match(/[a-f]/g).length ? true : false || randomColor[3].match(/[a-f]/g).length ? true : false
+console.log(chalk.bgHex(randomColor)(usage));
+
+if (process.argv.slice(2).length === 0) {
+    process.argv.push("--help");
+}
+
+var args = yargs
+    .option("init", { alias: "i", describe: "Initialize dorky project", type: "string", demandOption: false })
+    .option("list", { alias: "l", describe: "List files in dorky", type: "string", demandOption: false })
+    .option("add", { alias: "a", describe: "Add files to push or pull", type: "array", demandOption: false })
+    .option("rm", { alias: "r", describe: "Remove files from push or pull", type: "array", demandOption: false })
+    .option("push", { alias: "ph", describe: "Push files to storage", type: "string", demandOption: false })
+    .option("pull", { alias: "pl", describe: "Pull files from storage", type: "string", demandOption: false })
+    .option("migrate", { alias: "m", describe: "Migrate dorky project to another storage", type: "string", demandOption: false })
+    .help('help')
+    .strict()
+    .argv
+
+if (Object.keys(args).length == 2) {
+    yargs.showHelp()
+}
+
+function setupFilesAndFolders(metaData, credentials) {
+    console.log("Initializing dorky project");
+    if (existsSync(".dorky")) {
+        console.log("Dorky is already initialised in this project.");
+    } else {
+        mkdirSync(".dorky");
+        console.log(chalk.bgGreen("Created .dorky folder."));
+        writeFileSync(".dorky/metadata.json", JSON.stringify(metaData, null, 2));
+        console.log(chalk.bgGreen("Created .dorky/metadata.json file."));
+        writeFileSync(".dorkyignore", "");
+        console.log(chalk.bgGreen("Created .dorkyignore file."));
+        writeFileSync(".dorky/credentials.json", JSON.stringify(credentials, null, 2));
+        console.log(chalk.bgGreen("Created .dorky/credentials.json file."));
+    }
+}
+
+async function authorizeGoogleDriveClient() {
+    async function loadSavedCredentialsIfExist() {
+        try {
+            const content = await fs.readFileSync(TOKEN_PATH);
+            const credentials = JSON.parse(content);
+            return google.auth.fromJSON(credentials);
+        } catch (err) {
+            return null;
+        }
+    }
+    let client = await loadSavedCredentialsIfExist();
+    if (client) {
+        return client;
+    }
+    client = await authenticate({
+        scopes: SCOPES,
+        keyfilePath: CREDENTIALS_PATH,
+    });
+    return client;
+}
+
+async function init(storage) {
+    const metaData = { "stage-1-files": {}, "uploaded-files": {} };
+    var credentials;
+    switch (storage) {
+        case "aws":
+            credentials = { storage: "aws", acessKey: process.env.AWS_ACCESS_KEY, secretKey: process.env.AWS_SECRET_KEY, region: process.env.AWS_REGION, bucket: process.env.BUCKET_NAME }
+            setupFilesAndFolders(metaData, credentials);
+            break;
+        case "google-drive":
+            const client = await authorizeGoogleDriveClient();
+            credentials = { storage: "google-drive", ...client.credentials };
+            setupFilesAndFolders(metaData, credentials);
+            break;
+        default:
+            console.log("Please provide a valid storage option <aws|google-drive>");
+            break;
+    }
+}
+
+async function list() {
+    console.log(chalk.red("Listing files that can be added:"));
+    const exclusions = fs.readFileSync(".dorkyignore").toString().split(EOL);
+    const src = process.cwd();
+    const files = await glob(path.join(src, "**/*"));
+    const filteredFiles = files.filter((file) => {
+        for (let i = 0; i < exclusions.length; i++) {
+            if (file.includes(exclusions[i])) return false;
+        }
+        return true;
+    });
+    filteredFiles.forEach((file) => console.log(chalk.red(`- ${file}`)));
+    console.log(chalk.green("\nList of files that are already added:"));
+    const metaData = JSON.parse(fs.readFileSync(".dorky/metadata.json"));
+    const addedFiles = Object.keys(metaData["stage-1-files"]);
+    addedFiles.forEach((file) => console.log(chalk.green(`- ${file}`)));
+}
+
+function add(listOfFiles) {
+    console.log("Adding files to stage-1 to push to storage");
+    const metaData = JSON.parse(fs.readFileSync(".dorky/metadata.json"));
+    listOfFiles.forEach((file) => {
+        if (!fs.existsSync(file)) {
+            console.log(chalk.red(`File ${file} does not exist.`));
+            return;
+        }
+        const fileContents = fs.readFileSync(file);
+        const fileType = mimeTypes.lookup(file);
+        metaData["stage-1-files"][file] = {
+            "mime-type": fileType ? fileType : "application/octet-stream",
+            "hash": md5(fileContents)
+        };
+    });
+    fs.writeFileSync(".dorky/metadata.json", JSON.stringify(metaData, null, 2));
+    listOfFiles.map((file) => console.log(chalk.green(`Added ${file} to stage-1.`)));
+}
+
+function rm(listOfFiles) {
+    console.log(chalk.red("Removing files from stage-1"));
+    const metaData = JSON.parse(fs.readFileSync(".dorky/metadata.json"));
+    listOfFiles = listOfFiles.filter((file) => {
+        if (metaData["stage-1-files"][file] == undefined) return false;
+        delete metaData["stage-1-files"][file];
+        return true;
+    });
+    fs.writeFileSync(".dorky/metadata.json", JSON.stringify(metaData, null, 2));
+    if (listOfFiles.length) listOfFiles.map((file) => console.log(chalk.red(`Removed ${file} from stage-1.`)));
+    else console.log(chalk.red("No files found that can be removed."));
+}
+
+function checkCredentials() {
+    const credentials = JSON.parse(fs.readFileSync(".dorky/credentials.json"));
+    // This only works for AWS S3, add credential checker for google drive also, fix this => TP | 2024-09-28 16:04:41
+    if (credentials.accessKey && credentials.secretKey && credentials.region && credentials.bucket) {
+        if (process.env.AWS_ACCESS_KEY && process.env.AWS_SECRET_KEY && process.env.AWS_REGION && process.env.BUCKET_NAME) {
+            return true;
+        } else {
+            console.log(chalk.red("Please provide credentials in .dorky/credentials.json"));
+            return false;
+        }
+    } else return true;
+}
+
+function push() {
+    if (!checkCredentials()) {
+        console.log(chalk.red("Please setup credentials in environment variables or in .dorky/credentials.json"));
+        return;
+    }
+    console.log("Pushing files to storage");
+    const metaData = JSON.parse(fs.readFileSync(".dorky/metadata.json"));
+    const stage1Files = metaData["stage-1-files"];
+    const pushedFiles = metaData["uploaded-files"];
+    var filesToPush = [];
+    Object.keys(stage1Files).map((file) => {
+        if (pushedFiles[file]) {
+            if (stage1Files[file]["hash"] != pushedFiles[file]["hash"]) filesToPush.push(file);
+        } else filesToPush.push(file);
+    });
+    filesToPush = filesToPush.map((file) => {
+        return {
+            "name": file,
+            "mime-type": stage1Files[file]["mime-type"],
+            "hash": stage1Files[file]["hash"]
+        }
+    });
+    const credentials = JSON.parse(fs.readFileSync(".dorky/credentials.json"));
+    switch (credentials.storage) {
+        case "aws":
+            pushToS3(filesToPush, credentials);
+            break;
+        case "google-drive":
+            pushToGoogleDrive(filesToPush);
+            break;
+        default:
+            console.log("Please provide a valid storage option <aws|google-drive>");
+            break;
+    }
+    metaData["uploaded-files"] = metaData["stage-1-files"];
+    fs.writeFileSync(".dorky/metadata.json", JSON.stringify(metaData, null, 2));
+    console.log(chalk.green("Pushed files to storage"));
+}
+
+function pushToS3(files, credentials) {
+    const s3 = new S3Client({
+        credentials: {
+            accessKeyId: credentials.acessKey ?? process.env.AWS_ACCESS_KEY,
+            secretAccessKey: credentials.secretKey ?? process.env.AWS_SECRET_KEY
+        },
+        region: credentials.awsRegion ?? process.env.AWS_REGION
+    });
+    const bucketName = credentials.bucket ?? process.env.BUCKET_NAME;
+    Promise.all(files.map(async (file) => {
+        const rootFolder = path.basename(process.cwd());
+        const pathToFile = path.join(rootFolder, file.name);
+        await s3.send(
+            new PutObjectCommand({
+                Bucket: bucketName,
+                Key: pathToFile,
+                Body: fs.readFileSync(file.name).toString(),
+            })
+        );
+        console.log(chalk.green(`Pushed ${pathToFile} to storage.`));
+    }));
+}
+
+
+async function pushToGoogleDrive(files) {
+    async function getOrCreateFolderId(folderPath, drive) {
+        const folders = folderPath.split(path.sep);
+        let parentId = 'root';
+        for (const folder of folders) {
+            const res = await drive.files.list({
+                q: `name='${folder}' and mimeType='application/vnd.google-apps.folder' and '${parentId}' in parents`,
+                fields: 'files(id, name)',
+                spaces: 'drive'
+            });
+            if (res.data.files.length > 0) {
+                parentId = res.data.files[0].id;
+            } else {
+                const folderMetadata = {
+                    name: folder,
+                    mimeType: 'application/vnd.google-apps.folder',
+                    parents: [parentId],
+                };
+                const folderRes = await drive.files.create({
+                    requestBody: folderMetadata,
+                    fields: 'id',
+                });
+                parentId = folderRes.data.id;
+            }
+        }
+        return parentId;
+    }
+    console.log("Uploading to google drive");
+    const client = await authorizeGoogleDriveClient();
+    const drive = google.drive({ version: 'v3', auth: client });
+    for (const file of files) {
+        const rootFolder = path.basename(process.cwd());
+        const pathToFile = path.join(rootFolder, file.name);
+        const requestBody = {
+            name: path.basename(file.name),
+            parents: [await getOrCreateFolderId(pathToFile.split("/").slice(0, -1).join("/"), drive)],
+            fields: 'id',
+        };
+        const media = {
+            mimeType: file["mime-type"],
+            body: fs.createReadStream(path.join(process.cwd(), file.name)),
+        };
+        try {
+            await drive.files.create({
+                requestBody,
+                media: media,
+            });
+            console.log(chalk.green(`Pushed ${file.name} to storage.`));
+        } catch (err) {
+            console.log(err);
+            throw err;
+        }
+    }
+}
+
+function pull() {
+    if (!checkCredentials()) {
+        console.log(chalk.red("Please setup credentials in environment variables or in .dorky/credentials.json"));
+        return;
+    }
+    console.log("Pulling files from storage");
+    const metaData = JSON.parse(fs.readFileSync(".dorky/metadata.json"));
+    const filesToPull = metaData["uploaded-files"];
+    const credentials = JSON.parse(fs.readFileSync(".dorky/credentials.json"));
+    switch (credentials.storage) {
+        case "aws":
+            pullFromS3(filesToPull, credentials);
+            break;
+        case "google-drive":
+            pullFromGoogleDrive(filesToPull);
+            break;
+        default:
+            console.log("Please provide a valid storage option <aws|google-drive>");
+            break;
+    }
+}
+
+function pullFromS3(files, credentials) {
+    const s3 = new S3Client({
+        credentials: {
+            accessKeyId: credentials.acessKey ?? process.env.AWS_ACCESS_KEY,
+            secretAccessKey: credentials.secretKey ?? process.env.AWS_SECRET_KEY
+        },
+        region: credentials.awsRegion ?? process.env.AWS_REGION
+    });
+    const bucketName = credentials.bucket ?? process.env.BUCKET_NAME;
+    Promise.all(Object.keys(files).map(async (file) => {
+        const rootFolder = path.basename(process.cwd());
+        const pathToFile = path.join(rootFolder, file);
+        const { Body } = await s3.send(
+            new GetObjectCommand({
+                Bucket: bucketName,
+                Key: pathToFile,
+            })
+        );
+        const dir = path.dirname(file);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        fs.writeFileSync(file, await Body.transformToString());
+        console.log(chalk.green(`Pulled ${file} from storage.`));
+    }));
+}
+
+async function pullFromGoogleDrive(files) {
+    console.log("Downloading from google drive");
+    files = Object.keys(files).map((file) => {
+        return { name: file, ...files[file] };
+    });
+
+    const client = await authorizeGoogleDriveClient();
+    const drive = google.drive({ version: "v3", auth: client });
+    try {
+        files.map(async (file) => {
+            const res = await drive.files.list({
+                q: `name='${path.basename(file.name)}' and mimeType!='application/vnd.google-apps.folder'`,
+                fields: 'files(id, name)',
+                spaces: 'drive'
+            });
+            if (res.data.files.length === 0) {
+                console.log(chalk.red(`File ${file.name} not found in Google Drive.`));
+                return;
+            }
+            const _file = await drive.files.get({ fileId: res.data.files[0].id, alt: "media" });
+            const dir = path.dirname(file.name);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            fs.writeFileSync(file.name, await _file.data.text(), "utf-8");
+            console.log(chalk.green(`Pulled ${file.name} from storage.`));
+            //         const res = await drive.files.list({
+            //             q: `name='${file.name}'`,
+            //             fields: 'files(id, name)',
+            //             spaces: 'drive'
+            //         });
+            //         const _file = await drive.files.get({ fileId: res.data.files[0].id, alt: "media" });
+            //         fs.writeFile(file.name, await _file.data.text(), "utf-8", (err) => {
+            //             if (err) {
+            //                 console.log(err);
+            //                 throw err;
+            //             }
+            //             console.log(chalk.green(`Pulled ${file.name} from storage.`));
+            //         });
+        });
+    } catch (err) {
+        throw err;
+    }
+}
+
+if (Object.keys(args).includes("init")) init(args.init);
+if (Object.keys(args).includes("list")) list(args.list);
+if (Object.keys(args).includes("add")) add(args.add);
+if (Object.keys(args).includes("rm")) rm(args.rm);
+if (Object.keys(args).includes("push")) push();
+if (Object.keys(args).includes("pull")) pull(); 

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "dorky",
-  "version": "1.2.2",
+  "version": "2.0.0",
   "description": "DevOps Records Keeper.",
-  "main": "index.js",
   "bin": {
-    "dorky": "index.js"
+    "dorky": "bin/index.js"
   },
   "scripts": {
-    "test": "echo \"Error: no test specified\""
+    "start": "node bin/index.js",
+    "test": "mocha"
   },
   "repository": {
     "type": "git",
@@ -25,9 +25,19 @@
     "url": "https://github.com/trishantpahwa/dorky/issues"
   },
   "homepage": "https://github.com/trishantpahwa/dorky#readme",
+  "devDependencies": {
+    "tsc": "^2.0.4",
+    "typescript": "^5.5.4"
+  },
   "dependencies": {
-    "@aws-sdk/client-s3": "^3.309.0",
+    "@aws-sdk/client-s3": "^3.658.1",
+    "@google-cloud/local-auth": "^3.0.1",
     "chalk": "^4.1.2",
-    "glob": "^7.2.0"
+    "glob": "^11.0.0",
+    "googleapis": "^144.0.0",
+    "md5": "^2.3.0",
+    "mime-type": "^4.0.0",
+    "mime-types": "^2.1.35",
+    "yargs": "^17.7.2"
   }
 }

package/index.js

@@ -1,547 +0,0 @@
-#!/usr/bin/env node
-
-const glob = require("glob");
-const path = require("path");
-const chalk = require("chalk");
-const fs = require("fs");
-const { EOL } = require("os");
-const {
-  S3Client,
-  ListObjectsCommand,
-  PutObjectCommand,
-  DeleteObjectsCommand,
-  GetObjectCommand,
-} = require("@aws-sdk/client-s3");
-const { exit } = require("process");
-const { createHash } = require("crypto");
-
-let s3Client, bucketName;
-
-// Initializes project, creates a new .dorky folder, and adds a metadata file to it, and creates a .dorkyignore file.
-function initializeProject() {
-  if (fs.existsSync(".dorky")) {
-    console.log(
-      "Dorky project already initialized. Remove .dorky folder to reinitialize."
-    );
-  } else {
-    fs.mkdirSync(".dorky");
-    console.log(chalk.bgGreen("Created .dorky folder."));
-    fs.writeFileSync(
-      ".dorky/metadata.json",
-      JSON.stringify({ "stage-1-files": [], "uploaded-files": [] })
-    );
-    console.log(chalk.bgGreen("Created .dorky/metadata.json file."));
-    fs.writeFileSync(".dorkyignore", "");
-    console.log(chalk.bgGreen("Created .dorkyignore file."));
-    fs.writeFileSync(".dorky/.dorkyhash", "");
-    console.log(chalk.bgGreen("Created .dorkyhash file."));
-  }
-}
-
-// Lists all the files that are not excluded explicitly.
-function listFiles() {
-  let exclusions = fs.readFileSync("./.dorkyignore").toString().split(EOL);
-  exclusions = exclusions.filter((exclusion) => exclusion !== "");
-  if (exclusions[0] == "") exclusions = [];
-  var getDirectories = function (src, callback) {
-    glob(src + "/**/*", callback);
-  };
-
-  function excludeIsPresent(element) {
-    let present = false;
-    let i = 0;
-    while (i < exclusions.length) {
-      if (element.includes(exclusions[i])) present = true;
-      i += 1;
-    }
-    return present;
-  }
-  getDirectories(process.cwd(), function (err, res) {
-    if (err) {
-      console.log("Error", err);
-    } else {
-      let listOfFiles;
-      listOfFiles = res
-        .filter((element) => !excludeIsPresent(element))
-        .map((file) => path.relative(process.cwd(), file));
-      console.log(chalk.green("Found files:"));
-      listOfFiles.map((file) => console.log("\t" + chalk.bgGrey(file)));
-    }
-  });
-}
-
-// Pushes changes to S3 bucket.
-function pushChanges() {
-  console.log("Pushing files to server.");
-  let rootFolder;
-  if (process.cwd().includes("\\")) {
-    rootFolder = process.cwd().split("\\").pop();
-  } else if (process.cwd().includes("/")) {
-    rootFolder = process.cwd().split("/").pop();
-  } else rootFolder = process.cwd();
-  console.log(rootFolder);
-  async function rootFolderExists(rootFolder) {
-    const bucketParams = { Bucket: bucketName };
-    const response = await s3Client.send(new ListObjectsCommand(bucketParams));
-    if (
-      response.Contents.filter(
-        (object) => object.Key.split("/")[0] == rootFolder
-      ).length > 0
-    ) {
-      let metaData = JSON.parse(
-        fs.readFileSync(path.join(".dorky", "metadata.json")).toString()
-      );
-      // Get removed files
-      let removed = metaData["uploaded-files"].filter(
-        (x) => !metaData["stage-1-files"].includes(x)
-      );
-      // Uploaded added files.
-      let added = metaData["stage-1-files"].filter(
-        (x) => !metaData["uploaded-files"].includes(x)
-      );
-
-      added.map(async (file) => {
-        if (metaData["uploaded-files"].includes(file)) return;
-        else {
-          const putObjectParams = {
-            Bucket: bucketName,
-            Key: path
-              .join(rootFolder, path.relative(process.cwd(), file))
-              .split("\\")
-              .join("/"),
-            Body: fs
-              .readFileSync(path.relative(process.cwd(), file))
-              .toString(),
-          };
-          // Upload records
-          try {
-            const uploadResponse = await s3Client.send(
-              new PutObjectCommand(putObjectParams)
-            );
-            if (uploadResponse) console.log(chalk.green("Uploaded " + file));
-          } catch (err) {
-            console.log(
-              "Unable to upload file " +
-              path
-                .join(rootFolder, path.relative(process.cwd(), file))
-                .replace(/\\/g, "/")
-            );
-            console.log(err);
-          }
-          metaData["uploaded-files"].push(file);
-        }
-      });
-
-      if (removed.length) {
-        const removedObjectParams = {
-          Bucket: bucketName,
-          Delete: {
-            Objects: removed.map((file) => {
-              return { Key: file };
-            }),
-            Quiet: true,
-          },
-        };
-
-        // Delete removed records, doesn't delete immediately.
-        try {
-          const deleteResponse = s3Client.send(
-            new DeleteObjectsCommand(removedObjectParams)
-          );
-          if (deleteResponse) {
-            console.log("Deleted removed files:");
-            removed.map((file) => console.log(chalk.bgRed(file)));
-          }
-        } catch (err) {
-          console.log("Unable to delete files.");
-          console.log(err);
-        }
-      }
-      if (metaData["uploaded-files"] != metaData["stage-1-files"]) {
-        metaData["uploaded-files"] = Array.from(
-          new Set(metaData["stage-1-files"])
-        );
-        fs.writeFileSync(
-          path.join(".dorky", "metadata.json"),
-          JSON.stringify(metaData)
-        );
-        putObjectParams = {
-          Bucket: bucketName,
-          Key: path
-            .relative(
-              process.cwd(),
-              path.join(rootFolder.toString(), "metadata.json")
-            )
-            .replace(/\\/g, "/"),
-          Body: JSON.stringify(metaData),
-        };
-        try {
-          const uploadResponse = await s3Client.send(
-            new PutObjectCommand(putObjectParams)
-          );
-          if (uploadResponse)
-            console.log(
-              chalk.green(
-                "Uploaded " + path.join(rootFolder.toString(), "metadata.json")
-              )
-            );
-        } catch (err) {
-          console.log(
-            "Unable to upload file " +
-            path
-              .join(
-                rootFolder,
-                path.relative(
-                  process.cwd(),
-                  path.join(rootFolder.toString(), "metadata.json")
-                )
-              )
-              .replace(/\\/g, "/")
-          );
-          console.log(err);
-        }
-      } else {
-        console.log("Nothing to push");
-      }
-    } else {
-      let metaData = JSON.parse(
-        fs.readFileSync(path.join(".dorky", "metadata.json")).toString()
-      );
-      metaData["stage-1-files"].map(async (file) => {
-        if (metaData["uploaded-files"].includes(file)) return;
-        else {
-          const putObjectParams = {
-            Bucket: bucketName,
-            Key: path
-              .join(rootFolder, path.relative(process.cwd(), file))
-              .replace(/\\/g, "/"),
-            Body: fs
-              .readFileSync(path.relative(process.cwd(), file))
-              .toString(),
-          };
-          // Upload records
-          try {
-            const uploadResponse = await s3Client.send(
-              new PutObjectCommand(putObjectParams)
-            );
-            if (uploadResponse) console.log(chalk.green("Uploaded " + file));
-          } catch (err) {
-            console.log(
-              "Unable to upload file " +
-              path
-                .join(rootFolder, path.relative(process.cwd(), file))
-                .replace(/\\/g, "/")
-            );
-            console.log(err);
-          }
-          metaData["uploaded-files"].push(file);
-        }
-      });
-      metaData["uploaded-files"] = Array.from(
-        new Set(metaData["uploaded-files"])
-      );
-      fs.writeFileSync(
-        path.join(".dorky", "metadata.json"),
-        JSON.stringify(metaData)
-      );
-      putObjectParams = {
-        Bucket: bucketName,
-        Key: path
-          .relative(
-            process.cwd(),
-            path.join(rootFolder.toString(), "metadata.json")
-          )
-          .replace(/\\/g, "/"),
-        Body: JSON.stringify(metaData),
-      };
-      // Upload metadata.json
-      try {
-        const uploadResponse = await s3Client.send(
-          new PutObjectCommand(putObjectParams)
-        );
-        if (uploadResponse)
-          console.log(
-            chalk.green(
-              "Uploaded " + path.join(rootFolder.toString(), "metadata.json")
-            )
-          );
-      } catch (err) {
-        console.log(
-          "Unable to upload file " +
-          path
-            .join(rootFolder, path.relative(process.cwd(), file))
-            .replace(/\\/g, "/")
-        );
-        console.log(err);
-      }
-    }
-  }
-  rootFolderExists(rootFolder);
-}
-
-async function pullChanges() {
-  console.log("Pulling files from server.");
-  let rootFolder;
-  if (process.cwd().includes("\\")) {
-    rootFolder = process.cwd().split("\\").pop();
-  } else if (process.cwd().includes("/")) {
-    rootFolder = process.cwd().split("/").pop();
-  } else rootFolder = process.cwd();
-  const bucketParams = { Bucket: bucketName };
-  const getObjectsResponse = await s3Client.send(
-    new ListObjectsCommand(bucketParams)
-  );
-  if (
-    getObjectsResponse.Contents.filter(
-      (object) => object.Key.split("/")[0] == rootFolder
-    ).length > 0
-  ) {
-    if (
-      getObjectsResponse.Contents.filter(
-        (object) => object.Key == rootFolder + "/metadata.json"
-      ).length > 0
-    ) {
-      const params = {
-        Bucket: bucketName,
-        Key: rootFolder + "/metadata.json",
-      };
-      s3Client.send(new GetObjectCommand(params), async (err, data) => {
-        if (err) console.error(err);
-        else {
-          let metaData = JSON.parse(await data.Body.transformToString());
-          // Pull metadata.json
-          const METADATA_FILE = ".dorky/metadata.json";
-          fs.writeFileSync(METADATA_FILE, JSON.stringify(metaData));
-          let pullFileParams;
-          metaData["uploaded-files"].map((file) => {
-            pullFileParams = {
-              Bucket: bucketName,
-              Key: rootFolder + "/" + file,
-            };
-            s3Client.send(
-              new GetObjectCommand(pullFileParams),
-              async (err, data) => {
-                if (err) console.log(err);
-                else {
-                  console.log("Creating file " + file);
-                  let fileData = await data.Body.transformToString();
-                  let subDirectories;
-                  if (process.cwd().includes("\\")) {
-                    subDirectories = path
-                      .relative(process.cwd(), file)
-                      .split("\\");
-                  } else if (process.cwd().includes("/")) {
-                    subDirectories = path
-                      .relative(process.cwd(), file)
-                      .split("/");
-                  } else subDirectories = path.relative(process.cwd(), file);
-                  subDirectories.pop();
-                  if (process.platform === "win32") {
-                    subDirectories = subDirectories.join("\\");
-                  } else if (
-                    process.platform === "linux" ||
-                    process.platform === "darwin"
-                  ) {
-                    subDirectories = subDirectories.join("/");
-                  }
-                  if (subDirectories.length)
-                    fs.mkdirSync(subDirectories, { recursive: true });
-                  fs.writeFileSync(
-                    path.relative(process.cwd(), file),
-                    fileData
-                  );
-                }
-              }
-            );
-          });
-        }
-      });
-    } else {
-      console.log("Metadata doesn't exist");
-    }
-  } else {
-    console.error(chalk.red("Failed to pull folder, as it doesn't exist"));
-  }
-}
-
-if (
-  process.env.BUCKET_NAME &&
-  process.env.AWS_ACCESS_KEY &&
-  process.env.AWS_SECRET_KEY &&
-  process.env.AWS_REGION
-) {
-  bucketName = process.env.BUCKET_NAME;
-  s3Client = new S3Client({
-    region: process.env.AWS_REGION,
-    credentials: {
-      accessKeyId: process.env.AWS_ACCESS_KEY,
-      secretAccessKey: process.env.AWS_SECRET_KEY,
-    },
-  });
-  if (fs.existsSync(".dorky")) {
-    const credentials = [
-      `AWS_ACCESS_KEY=${process.env.AWS_ACCESS_KEY}`,
-      `AWS_SECRET_KEY=${process.env.AWS_SECRET_KEY}`,
-      `AWS_REGION=${process.env.AWS_REGION}`,
-      `BUCKET_NAME=${process.env.BUCKET_NAME}`,
-    ];
-    fs.writeFileSync(".dorky/.credentials", credentials.join("\n"));
-  }
-} else {
-  if (fs.existsSync(".dorky")) {
-    if (fs.existsSync(".dorky/.credentials")) {
-      const credentials = fs
-        .readFileSync(".dorky/.credentials", "utf8")
-        .toString()
-        .split("\n");
-      if (credentials.length < 4) {
-        console.log(
-          chalk.red(
-            "Set BUCKET_NAME, AWS_ACCESS_KEY, AWS_SECRET_KEY and AWS_REGION first."
-          )
-        );
-        exit();
-      }
-      const region = credentials
-        .filter((credential) => credential.includes("AWS_REGION"))[0]
-        .split("=")[1];
-      const accessKey = credentials
-        .filter((credential) => credential.includes("AWS_ACCESS_KEY"))[0]
-        .split("=")[1];
-      const secretKey = credentials
-        .filter((credential) => credential.includes("AWS_SECRET_KEY"))[0]
-        .split("=")[1];
-      bucketName = credentials
-        .filter((credential) => credential.includes("BUCKET_NAME"))[0]
-        .split("=")[1];
-      s3Client = new S3Client({
-        region: region,
-        credentials: {
-          accessKeyId: accessKey,
-          secretAccessKey: secretKey,
-        },
-      });
-      console.log(chalk.blue("Set credentials from file."));
-    } else {
-      console.log(
-        chalk.red(
-          "Set BUCKET_NAME, AWS_ACCESS_KEY, AWS_SECRET_KEY and AWS_REGION first."
-        )
-      );
-      exit();
-    }
-  } else {
-    console.log(
-      chalk.red(
-        "Unable to find .dorky folder, please reinitialize the project in the root folder or set the BUCKET_NAME, AWS_ACCESS_KEY, AWS_SECRET_KEY and AWS_REGION in environment variables."
-      )
-    );
-    exit();
-  }
-}
-
-const args = process.argv.splice(2, 2);
-
-if (args.length == 0) {
-  const figlet = `
-      __            __          
-  .--|  .-----.----|  |--.--.--.
-  |  _  |  _  |   _|    <|  |  |
-  |_____|_____|__| |__|__|___  |
-                         |_____| 
-  `;
-  console.log(figlet);
-  const helpMessage = `Help message:\ninit\t Initializes a dorky project.\nlist\t Lists files in current root directory.\npush\t Pushes changes to S3 bucket.\npull\t Pulls changes from S3 bucket to local root folder.`;
-  console.log(helpMessage);
-} else if (args.length == 1) {
-  if (args[0] == "init") initializeProject();
-  if (args[0] == "list") listFiles();
-  if (args[0] == "push") pushChanges();
-  if (args[0] == "pull") pullChanges();
-} else if (args.length == 2) {
-  if (args[0] == "add") {
-    const METADATA_FILE = ".dorky/metadata.json";
-    const HASHES_FILE = ".dorky/.dorkyhash";
-    const file = args[1];
-    if (fs.existsSync(file)) {
-      const hashes = {};
-      fs.readFileSync(HASHES_FILE)
-        .toString()
-        .split("\n")
-        .filter((hash) => hash)
-        .map((hash) => {
-          hashes[hash.split("=")[0]] = hash.split("=")[1];
-        });
-      if (Object.keys(hashes).includes(file)) {
-        // File already staged
-        const fileContent = fs.readFileSync(file).toString();
-        const currentHash = createHash("md5")
-          .update(fileContent)
-          .digest("base64")
-          .split("==")[0];
-        const hashToCompare = hashes[file];
-        if (currentHash == hashToCompare) {
-          console.log(
-            chalk.red(
-              `File ${chalk.bgRed(
-                chalk.white(file)
-              )} hasn\'t been modified since last push.`
-            )
-          );
-          return;
-        } else {
-          console.log(chalk.green(`Staging ${file} since has been modified.`));
-          hashes[file] = currentHash;
-          const updatedFileContent = Object.entries(hashes).map(
-            (fileAndHash) => {
-              return fileAndHash.join("=");
-            }
-          );
-          fs.writeFileSync(HASHES_FILE, updatedFileContent.join("\n"));
-          const metaData = JSON.parse(fs.readFileSync(METADATA_FILE));
-          // Clear from uploaded files
-          const uploadedFiles = new Set(metaData["uploaded-files"]);
-          uploadedFiles.delete(file);
-          metaData["uploaded-files"] = Array.from(uploadedFiles);
-          fs.writeFileSync(METADATA_FILE, JSON.stringify(metaData));
-          console.log(
-            `Updated ${chalk.bgGreen(
-              chalk.white(file)
-            )}, ready to push the updates from it.`
-          );
-        }
-      } else {
-        // New file
-        const fileContent = fs.readFileSync(file).toString();
-        hashes[file] = createHash("md5")
-          .update(fileContent)
-          .digest("base64")
-          .split("==")[0];
-        const updatedFileContent = Object.entries(hashes).map((fileAndHash) => {
-          return fileAndHash.join("=");
-        });
-        fs.writeFileSync(HASHES_FILE, updatedFileContent.join("\n"));
-        console.log(
-          `Tracking updates from ${chalk.bgGreen(chalk.white(file))}`
-        );
-      }
-      const metaData = JSON.parse(fs.readFileSync(METADATA_FILE));
-      const stage1Files = new Set(metaData["stage-1-files"]);
-      stage1Files.add(file);
-      metaData["stage-1-files"] = Array.from(stage1Files);
-      fs.writeFileSync(METADATA_FILE, JSON.stringify(metaData));
-      console.log(chalk.bgGreen("Success"));
-      console.log(chalk.green(`Added file ${file} successfully to stage-1.`));
-    } else {
-      console.log(chalk.bgRed("Error"));
-      console.log(chalk.red(`\tFile ${file} doesn\'t exist`));
-    }
-  } else if (args[0] == "reset") {
-    const METADATA_FILE = ".dorky/metadata.json";
-    const metaData = JSON.parse(fs.readFileSync(METADATA_FILE));
-    const file = args[1];
-    resetFileIndex = metaData["stage-1-files"].indexOf(file);
-    metaData["stage-1-files"].splice(resetFileIndex, 1);
-    fs.writeFileSync(METADATA_FILE, JSON.stringify(metaData));
-  }
-}