dorky 1.2.2 → 2.1.1

package/README.md

@@ -1,6 +1,7 @@
 # dorky
+
 ```
-     __            __          
+     __            __
  .--|  .-----.----|  |--.--.--.
  |  _  |  _  |   _|    <|  |  |
  |_____|_____|__| |__|__|___  |
@@ -17,9 +18,11 @@ Let us assume that we need to create a project.
 
 The project obviously contains some code and some secret variables like database information, API keys, etc. This data cannot be shared on public VCS (GitHub), but at times is required to be accessible remotely to be shared among reliable sources.
 
-Anyhow, we shall store it on a private storage, using **dorky**, that stores it on a S3.
+Anyhow, we shall store it on a private storage, using **dorky**, that stores it on a S3 or Google-Drive.
+
+## AWS S3
 
-## Steps to use:
+### Steps to use with S3:
 
 > Create a S3 bucket, AWS_ACCESS_KEY and AWS_SECRET_KEY.
 
@@ -27,16 +30,60 @@ Anyhow, we shall store it on a private storage, using **dorky**, that stores it
 
 > Please use your own repository, this repository `sample_project` is just for demonstration.
 
-### To push files to S3 bucket.
-1. Initialize dorky setup in the root folder of your project, using `dorky init`.
-2. List the files using `dorky list`, (make sure to add excluded file or folder patterns to .dorkyignore, to minimize the list).
-3. Add files to stage-1 using `dorky add file-name`.
-4. Push files to S3 bucket using `dorky push`.
+#### To list files in the project.
+
+1. Initialize dorky setup in the root folder of your project, using `dorky --init aws`.
+2. List the files using `dorky --list`.
+    > This command will not list the files that are excluded in `.dorkyignore`.
+
+#### To push files to S3 bucket.
+
+1. Initialize dorky setup in the root folder of your project, using `dorky --init aws`.
+2. List the files using `dorky --list`, (make sure to add excluded file or folder patterns to .dorkyignore, to minimize the list).
+3. Add files to stage-1 using `dorky --add file-name`.
+4. Push files to S3 bucket using `dorky --push`.
+
+#### To remove a file from project.
+
+1. Remove files using `dorky --rm file-name`. [Removes file from stage-1 <local>]
+2. Push files to S3 bucket using `dorky --push`. [Removes file from S3 bucket <remote>]
+
+#### To pull files from S3 bucket.
+
+1. Use `dorky --pull` to pull the files from S3 bucket.
+
+## Google Drive
+
+### Steps to use with Google Drive:
+
+![Dorky Usage](dorky-usage.svg "Dorky usage")
+
+> Please use your own repository, this repository `sample_project` is just for demonstration.
+
+#### To list files in the project.
+
+1. Initialize dorky setup in the root folder of your project, using `dorky --init google-drive`.
+2. List the files using `dorky --list`.
+    > This command will not list the files that are excluded in `.dorkyignore`.
+
+#### To push files to Google Drive.
+
+1. Initialize dorky setup in the root folder of your project, using `dorky --init google-drive`.
+2. List the files using `dorky --list`, (make sure to add excluded file or folder patterns to .dorkyignore, to minimize the list).
+3. Add files to stage-1 using `dorky --add file-name`.
+4. Push files to Google Drive using `dorky --push`.
+
+#### To remove a file from project.
+
+1. Remove files using `dorky --rm file-name`. [Removes file from stage-1 <local>]
+2. Push files to Google Drive using `dorky --push`. [Removes file from Google Drive <remote>]
+
+#### To pull files from Google Drive.
+
+1. Use `dorky --pull` to pull the files from Google Drive.
+
+## To-Do
 
-### To remove a file from project.
-1. Remove files using `dorky reset file-name`.
-2. Push files to S3 bucket using `dorky push`.
+[ ] Add stages for variables.
+[ ] Convert to TypeScript.
 
-### To pull files from S3 bucket.
-1. Initialize dorky project using `dorky init`.
-2. Use `dorky pull` to pull the files from S3 bucket.

package/bin/index.js

@@ -0,0 +1,394 @@
+#!/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");
+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 checkIfDorkyProject() {
+    if (!existsSync(".dorky") && !existsSync(".dorkyignore")) {
+        console.log(chalk.red("This is not a dorky project. Please run `dorky --init [aws|google-drive]` to initialize a dorky project."));
+        process.exit(1);
+    }
+}
+
+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() {
+    checkIfDorkyProject();
+    console.log(chalk.red("Listing files that can be added:"));
+    var exclusions = fs.readFileSync(".dorkyignore").toString().split(EOL);
+    exclusions = exclusions.filter((exclusion) => exclusion !== "");
+    const src = process.cwd();
+    const files = await glob(path.join(src, "**/*"), { dot: true });
+    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(`- ${path.relative(process.cwd(), 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) {
+    checkIfDorkyProject();
+    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) {
+    checkIfDorkyProject();
+    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() {
+    checkIfDorkyProject();
+    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() {
+    checkIfDorkyProject();
+    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.`));
+        });
+    } 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/google-drive-credentials.json

@@ -0,0 +1,16 @@
+{
+    "web": {
+        "client_id": "624017989162-l9r3hqnv0urve3e3eg0eika5oq81mgin.apps.googleusercontent.com",
+        "project_id": "sonic-mile-426408-u2",
+        "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+        "token_uri": "https://oauth2.googleapis.com/token",
+        "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
+        "client_secret": "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",
+        "javascript_origins": [
+            "http://localhost:3000"
+        ],
+        "redirect_uris": [
+            "http://localhost:3000/oauth2callback"
+        ]
+    }
+}

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "dorky",
-  "version": "1.2.2",
+  "version": "2.1.1",
   "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));
-  }
-}