using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using Box.V2.Config;
using Box.V2.JWTAuth;

namespace BoxDownloadAllFiles {
    class Program {
        static void Main (string[] args) {
            ExecuteMainAsync ().Wait ();
        }

        private static async Task ExecuteMainAsync () {
            using (FileStream fs = new FileStream ($"./config.json", FileMode.Open)) {
                var session = new BoxJWTAuth (BoxConfig.CreateFromJsonFile (fs));
                var client = session.AdminClient (session.AdminToken ());
                var folderId = "987654321";
                var folder = await client.FoldersManager.GetInformationAsync (folderId);
                var folderName = folder.Name;
                var localFolderPath = Path.Combine (Directory.GetCurrentDirectory (), folderName);
                ResetLocalFolder (localFolderPath);

                var items = await client.FoldersManager.GetFolderItemsAsync (folderId, 1000, autoPaginate : true);
                var fileDownloadTasks = new List<Task> ();
                var files = items.Entries.Where (i => i.Type == "file");
                foreach (var file in files) {
                    fileDownloadTasks.Add (client.FilesManager.DownloadStreamAsync (file.Id).ContinueWith ((t) => {
                        var localFile = File.Create (Path.Combine (localFolderPath, file.Name));
                        return t.Result.CopyToAsync (localFile);
                    }));
                }
                await Task.WhenAll (fileDownloadTasks);
            }
        }

        private static void ResetLocalFolder (string localFolderPath) {
            if (!Directory.Exists (localFolderPath)) {
                Directory.CreateDirectory (localFolderPath);
            } else {
                foreach (var file in Directory.EnumerateFiles (localFolderPath)) {
                    File.Delete (Path.Combine (localFolderPath, file));
                }
                Directory.Delete (localFolderPath);
                Directory.CreateDirectory (localFolderPath);
            }
        }
    }
}

package com.box;

import com.box.sdk.BoxConfig;
import com.box.sdk.BoxDeveloperEditionAPIConnection;
import com.box.sdk.BoxFile;
import com.box.sdk.BoxFolder;
import com.box.sdk.BoxItem;
import java.io.BufferedReader;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

public class Playground {

    public static void main(String[] args) throws Exception {
        Path configPath = Paths.get("config.json");
        Path currentDir = Paths.get("").toAbsolutePath();
        try (BufferedReader reader = Files.newBufferedReader(configPath, Charset.forName("UTF-8"))) {
            BoxConfig boxConfig = BoxConfig.readFrom(reader);
            BoxDeveloperEditionAPIConnection client = BoxDeveloperEditionAPIConnection.getAppEnterpriseConnection(boxConfig);
            String folderId = "987654321";
            BoxFolder folder = new BoxFolder(client, folderId);
            String folderName = folder.getInfo().getName();
            Path localFolderPath = currentDir.resolve(Paths.get(folderName));
            if (!Files.exists(localFolderPath)) {
                localFolderPath = Files.createDirectory(localFolderPath);
            } else {
                localFolderPath = resetLocalFolder(localFolderPath);
            }

            for (BoxItem.Info itemInfo: folder) {
                if (itemInfo instanceof BoxFile.Info) {
                    BoxFile.Info fileInfo = (BoxFile.Info) itemInfo;
                    BoxFile file = new BoxFile(client, fileInfo.getID());
                    String localFilePath = localFolderPath.resolve(Paths.get(fileInfo.getName())).toAbsolutePath().toString();
                    FileOutputStream stream = new FileOutputStream(localFilePath);
                    file.download(stream);
                    stream.close();
                }
            }

        }
    }

    static Path resetLocalFolder(Path localFolderPath) throws IOException {
        Files.list(localFolderPath).forEach(file -> {
            System.out.println(file.getFileName());
            try {
                Files.delete(file.toAbsolutePath());
            } catch (IOException e) {}
        });
        Files.delete(localFolderPath);
        localFolderPath = Files.createDirectory(localFolderPath);
        return localFolderPath;
    }
}

"use strict";
const box = require("box-node-sdk");
const fs = require("fs");
const util = require("util");
const path = require("path");
let configFile = fs.readFileSync("config.json");
configFile = JSON.parse(configFile);

let session = box.getPreconfiguredInstance(configFile);
let client = session.getAppAuthClient("enterprise");
client._useIterators = true;

let folderId = "987654321";
let folderName;
let localFolderPath;
client.folders
    .get(folderId, null)
    .then(folderInfo => {
        folderName = folderInfo.name;

        return client.folders.getItems(folderId, { limit: 1000 });
    })
    .then(folderItemsIterator => {
        return autoPage(folderItemsIterator);
    })
    .then(folderItems => {
          console.log(folderName);
          console.log(folderItems.length);
          let files = folderItems.filter(item => {
              return item.type === "file";
          });
          console.log(files);
          localFolderPath = createLocalFolder(folderName);
          let downloadPromises = [];
          files.forEach(file => {
              downloadPromises.push(
                  client.files.getReadStream(file.id, null).then(stream => {
                      let output = fs.createWriteStream(
                        path.join(localFolderPath, file.name)
                      );
                      stream.pipe(output);
                  })
              );
          });
          return Promise.all(downloadPromises);
    })
    .then(() => {
        console.log("Downloaded all files...");
        console.log(fs.readdirSync(localFolderPath));
    });

function createLocalFolder(folderName) {
    let localFolderName = path.join(__dirname, folderName);
    try {
        fs.mkdirSync(localFolderName);
    } catch (e) {
        if (e.code === "EEXIST") {
            resetLocalFolder(localFolderName);
            fs.mkdirSync(localFolderName);
        } else {
            throw e;
        }
    }
    return localFolderName;
}

function resetLocalFolder(localFolderName) {
    if (fs.existsSync(localFolderName)) {
        fs.readdirSync(localFolderName).forEach(localFileName => {
            console.log(localFileName);
            fs.unlinkSync(path.join(localFolderName, localFileName));
        });
        fs.rmdirSync(localFolderName);
    }
}

function autoPage(iterator) {
    let collection = [];
    let moveToNextItem = () => {
        return iterator.next().then(item => {
            if (item.value) {
                collection.push(item.value);
            }
            if (item.done !== true) {
                return moveToNextItem();
            } else {
                return collection;
            }
        });
    };
    return moveToNextItem();
}