Cloud Commander

Cloud file manager with console and editor

View Project on GitHub

Find typo? Help fix it.

Cloud Commander v11.8.3

Main Blog Live(Heroku Heroku, Now Now)

Cloud Commander a file manager for the web with console and editor. Will help you manage the server and work with files, directories and programs in browser from any computer, mobile or tablet.

Cloud Commander



The installation of file manager is very simple.

npm i cloudcmd -g

When in trouble use:

npm i cloudcmd -g --force


For starting just type in console:


Cloud Commander supports command line parameters:

Parameter Operation
-h, --help display help and exit
-v, --version display version and exit
-s, --save save configuration
-o, --online load scripts from remote servers
-a, --auth enable authorization
-u, --username set username
-p, --password set password
-c, --config configuration file path
--show-config show config values
--show-file-name show file name in view and edit
--editor set editor: “dword”, “edward” or “deepword”
--packer set packer: “tar” or “zip”
--root set root directory
--prefix set url prefix
--prefix-socket set prefix for url connection
--port set port number
--progress show progress of file operations
--confirm-copy confirm copy
--confirm-move confirm move
--open open web browser when server started
--name set tab name in web browser
--one-file-panel show one file panel
--keys-panel show keys panel
--contact enable contact
--config-dialog enable config dialog
--config-auth enable auth change in config dialog
--console enable console
--sync-console-path sync console path
--terminal enable terminal
--terminal-path set terminal path
--terminal-command set command to run in terminal (shell by default)
--terminal-auto-restart restart command on exit
--vim enable vim hot keys
--columns set visible columns
--export enable export of config through a server
--export-token authorization token used by export server
--import enable import of config
--import-token authorization token used to connect to export server
--import-url url of an import server
--import-listen enable listen on config updates from import server
--dropbox enable dropbox integration
--dropbox-token set dropbox token
--log enable logging
--no-show-config do not show config values
--no-server do not start server
--no-auth disable authorization
--no-online load scripts from local server
--no-open do not open web browser when server started
--no-name set default tab name in web browser
--no-keys-panel hide keys panel
--no-one-file-panel show two file panels
--no-progress do not show progress of file operations
--no-confirm-copy do not confirm copy
--no-confirm-move do not confirm move
--no-config-dialog disable config dialog
--no-config-auth disable auth change in config dialog
--no-console disable console
--no-sync-console-path do not sync console path
--no-contact disable contact
--no-terminal disable terminal
--no-terminal-command set default shell to run in terminal
--no-terminal-auto-restart do not restart command on exit
--no-vim disable vim hot keys
--no-columns set default visible columns
--no-export disable export config through a server
--no-import disable import of config
--no-import-listen disable listen on config updates from import server
--no-show-file-name do not show file name in view and edit
--no-dropbox disable dropbox integration
--no-dropbox-token unset dropbox token
--no-log disable logging

If no parameters given Cloud Commander reads information from ~/.cloudcmd.json and use port from it (8000 default). if port variables PORT isn’t exist.

To begin use, type in address bar of your browser:



If you installed Cloud Commander with npm, stop application and re-install it:

npm install cloudcmd -g

Then start it again and reload the page.

Hot keys

Key Operation
F1 help
F2 rename
F3 view
Shift + F3 view as markdown
F4 edit
Shift + F4 edit in vim mode
F5 copy
Alt + F5 pack
F6 rename/move
F7 new directory
Shift + F7 new file
F8, Delete remove
Shift + Delete remove without prompt
F9 menu
Alt + F9 extract
F10 config
* select/unselect all
+ expand selection
- shrink selection
Ctrl + x cut to buffer
Ctrl + с copy to buffer
Ctrl + v paste from buffer
Ctrl + z clear buffer
Ctrl + p copy path
Ctrl + r refresh
Ctrl + d clear local storage
Ctrl + a select all files in a panel
Ctrl + m rename selected files in editor
Shift + Ctrl + m rename selected files in vim mode of editor
Ctrl + u swap panels
Ctrl + F3 sort by name
Ctrl + F5 sort by date
Ctrl + F6 sort by size
Up, Down, Enter file system navigation
Alt + Left/Right show content of directory under cursor in target panel
Alt + g go to directory
Ctrl + \ go to the root directory
Tab move via panels
Page Up up on one page
Page Down down on one page
Home to begin of list
End to end of list
Space select current file (and get size of directory)
Insert select current file (and move to next)
F9 context menu
~ console
Ctrl + Click open file on new tab


When --vim option provided, or configuration parameter vim set, next hot keys become available:

Key Operation
j navigate to next file
k navigate to previous file
dd remove current file
G navigate to bottom file
gg navigate to top file
v visual mode
y copy (selected in visual mode files)
p paste files
Esc unselect all
/ find file in current directory
n navigate to next found file
N navigate to previous found file

Commands can be joined, for example:

Drag and Drop

Next file operations are accessible through Drag and Drop.

Drag Mouse Button Key Origin Destination Operation
Left   Panel Panel copy files
Left Shift Panel Panel rename/move files
Left   Panel Desktop download files
Left   Desktop Panel upload files




Hot keys

Key Operation
F3 open
Esc close



Hot keys

Key Operation
F4 open
Shift + F4 open in vim mode
Esc close

For more details see Edward hot keys.



Hot keys

Key Operation
~ open
Ctrl + p paste path of current directory
Esc close

For more details see console hot keys.




Terminal disabled and not installed by default. To use it you should install gritty with:

npm i gritty -g

And then set the path of a terminal with:

cloudcmd --terminal --terminal-path `gritty --path` --save


If you can’t install gritty on Windows try to install windows-build-tools first:

npm install windows-build-tools -g

Then get path of a gritty with:

gritty --path

It will returns something like:


Set this path as --terminal-path with:

cloudcmd --save --terminal --terminal-path "C:\Users\coderaiser\AppData\Roaming\npm\node_modules\gritty"

After that you can use terminal in the same way as a console.

Hot keys

Key Operation
Shift + ~ open
Shift + Esc close

Environment Variables

Every program executed in console or terminal has these environment variables:

On Unix you can use it this way:




Hot keys

Key Operation
F10 open
Esc close

When you change one of options file ~/.cloudcmd.json would be saved. It could be edited manually with any text editor. Here is description of options:

    "name"                  : "",       // set tab name in web browser
    "auth"                  : false,    // enable http authentication
    "username"              : "root",   // username for authentication
    "password"              : "toor",   // password hash for authentication
    "algo"                  : "sha512WithRSAEncryption", // cryptographic algorithm
    "editor"                : "edward", // default, could be "dword" or "edward"
    "packer"                : "tar",    // default, could be "tar" or "zip"
    "diff"                  : true,     // when save - send patch, not whole file
    "zip"                   : true,     // zip text before send / unzip before save
    "buffer"                : true,     // buffer for copying files
    "dirStorage"            : true,     // store directory listing
    "online"                : false,    // do not load js files from cdn
    "open"                  : true,     // open web browser when server started
    "oneFilePanel"          : false,    // show one file panel
    "keysPanel"             : true,     // show classic panel with buttons of keys
    "port"                  : 8000,     // http port
    "ip"                    : null,     // ip or null(default)
    "root"                  : "/",      // root directory
    "prefix"                : "",       // url prefix
    "prefixSocket"          : "",       // prefix for socket connection
    "progress"              : true,     // show progress of file operations
    "confirmCopy"           : true,     // confirm copy
    "confirmMove"           : true,     // confirm move
    "showConfig"            : false,    // show config at startup
    "showFileName"          : false     // do not show file name in view and edit
    "contact"               : true,     // enable contact
    "configDialog"          : true,     // enable config dialog
    "configAuth"            : true,     // enable auth change in config dialog
    "console"               : true,     // enable console
    "syncConsolePath"       : false     // do not sync console path
    "terminal"              : false,    // disable terminal
    "terminalPath"          : '',       // path of a terminal
    "terminalCommand"       : '',       // set command to run in terminal
    "terminalAutoRestart"   : true,     // restart command on exit
    "vim"                   : false,    // disable vim hot keys
    "columns"               : "name-size-date-owner-mode", // set visible columns
    "export"                : false,    // enable export of config through a server
    "exportToken"           : "root",   // token used by export server
    "import"                : false,    // enable import of config 
    "import-url"            : "http://localhost:8000",   // url of an export server
    "importToken"           : "root",   // token used to connect to export server
    "importListen"          : false,    // listen on config updates
    "dropbox"               : false,    // disable dropbox integration
    "dropboxToken"          : "",       // unset dropbox token
    "log"                   : true      // logging

Environment Variables

Some config options can be overridden with environment variables such:


Being able to configure Cloud Commander remotely opens the doors to using it as microservice and that’s what distribute options set out to do. There is an export server and import client and they enabled with --export and --import accordingly. There is a token it should be the same in --import-token and --export-token. To use import you should provide --import-url to import client so it can connect to an export server. There is 2 ways import client can receive config from an export server:

There is an example of using distribute options in Cloud Commander to get config from remote instance. Here is an export server:

[email protected]:~$ cloudcmd --port 1234 --export --export-token=cloudcmd

And import client:

[email protected]:~$ cloudcmd --name importer --port 4321 --import-url --import-token=cloudcmd --no-server --save

Here is the log of export server:

url: http://localhost:1234/
2018.08.23 13:41:45 -> export: try to auth from importer []
2018.08.23 13:41:45 -> export: connected to importer []
2018.08.23 13:41:45 -> export: config send to importer[]
2018.08.23 13:41:45 -> export: disconnected importer []

And log of import client:

2018.08.23 13:47:36 -> import: try to auth to
2018.08.23 13:47:36 -> import: connected to
2018.08.23 13:47:36 -> import: config received from
2018.08.23 13:47:36 -> import: disconnected from

When import client uses --import-listen persistent connection used and client receives live updates from the import server.

Export server omit next configuration fields:


Right mouse click button shows context menu with items:

Hot keys

Key Operation
F9 open
Esc close

One file panel

Cloud Commander can work in one panel mode when screen size can not accommodate second panel or via --one-file-panel options flag. It could happen when mobile device, tablet or small window size used to work with file manager.

One file panel

Using as Middleware

Cloud Commander could be used as middleware for node.js applications based on and express:

Init package.json:

npm init -y

Install dependencies:

npm i cloudcmd express -S

And create index.js:

const http = require('http');
const cloudcmd = require('cloudcmd');
const io = require('');
const app = require('express')();

const port = 1337;
const prefix = '/';

const server = http.createServer(app);
const socket = io.listen(server, {
    path: `{prefix}`

const config = {
    name: 'cloudcmd :)'

const plugins = [
    __dirname + '/plugin.js'

const filePicker = {
    data: {
        FilePicker: {
            key: 'key'

// override option from json/modules.json
const modules = {

app.use(prefix, cloudcmd({
    socket,  // used by Config, Edit (optional) and Console (required)
    config,  // config data (optional)
    plugins, // optional
    modules, // optional


And you are ready to go.


If you want to enable authorization you can pass credentials in a config. To generate password you can install criton with npm i criton --save and use it or any other way to generate a hash of a password.

const criton = require('criton');
const algo = 'sha512WithRSAEncryption'; // default

// you can generate hash dynamically
const password = criton('root', algo);

// or use pregenerated hash as well

const auth = true;
const username = 'root';

const config = {
    algo, // optional


Standard practices say no non-root process gets to talk to the Internet on a port less than 1024. Anyway I suggest you to start Cloud Commander as non-root. How it could be solved? There is a couple easy and fast ways. One of them is port forwarding.


Just run shell/ for default options.

iptables -t nat -L # look rules before
iptables -t nat -A PREROUTING -p tcp --dport 80 -j REDIRECT --to-ports 8000
iptables -t nat -A PREROUTING -p tcp --dport 443 -j REDIRECT --to-ports 4430
iptables -t nat -L # look rules after

You should see something like this ( 8000 and 4430 should be in config as port and sslPort )

target     prot opt source               destination
REDIRECT   tcp  --  anywhere             anywhere             tcp dpt:http redir ports 8000
REDIRECT   tcp  --  anywhere             anywhere             tcp dpt:https redir ports 4430

If you would want to get things back just clear rules ( 1 and 2 it’s rule numbers, in your list they could differ).

iptables -t nat -D PREROUTING 2
iptables -t nat -D PREROUTING 1


Get nginx. On Linux it could be done this way:

sudo apt-get install nginx #for ubuntu and debian

Then make host file /etc/nginx/sites-available/ ( is your domain name) with content:

server {
    listen 80;
    client_max_body_size 100m;
    access_log /var/log/nginx/;
    location / {

If you want add SSL, add a couple lines to server block:

server {
    listen 443;
    client_max_body_size 100m;
    ssl                  on;
    ssl_certificate      /home/coderaiser/cloudcmd/ssl/ssl.crt;
    ssl_certificate_key  /home/coderaiser/cloudcmd/ssl/ssl.key;
    access_log /var/log/nginx/;
    location / {

For WebSocket support (nginx >= v1.3.13) modify server block:

    location / {
        proxy_http_version  1.1;
        proxy_set_header    Upgrade $http_upgrade;
        proxy_set_header    Connection "upgrade";


If you need redirection from http to https, it’s simple:

server {
    listen 80;
    rewrite ^$request_uri? permanent; #301 redirect
    access_log /var/log/nginx/;
# create symlink of this file
ln -s ./sites-available/ ./sites-enabled
# restart nginx
/etc/init.d/nginx restart


Cloud Commander could be easily deployed to Heroku.

Deploy to Heroku


Cloud Commander could be used as docker container this way:

docker run -t --rm -v ~:/root -v /:/mnt/fs -w=/root -p 8000:8000 coderaiser/cloudcmd

Config would be read from home directory, hosts root file system would be mount to /mnt/fs, 8000 port would be exposed to hosts port.

Also you could use docker compose with docker-compose.yml:

version: '2'
      - 8000:8000
      - ~:/root
      - /:/mnt/fs
    image: coderaiser/cloudcmd

When you create this file run:

docker-compose up


Dropbox support integrated into Cloud Commander and you can switch from local file system to a dropbox account. All you need to do is set --dropbox option and generate dropbox token for you account.

This can look like this:

cloudcmd --dropbox --dropbox-token your-dropbox-token

Using dropbox remember that there is no remote support of a console and terminal. Progress of file operation also not supported. There is only basic support, but you can do next things with files and directories:

Get involved

There is a lot ways to be involved in Cloud Commander development:

Version history

Special Thanks