# Cloud Commander: web-based file manager with a built-in console and editor

> Cloud Commander is an MIT-licensed Node.js file manager that runs in the browser, exposing the server's filesystem with a two-panel view, a terminal console and a text editor. It installs as a global npm package and also embeds as Express middleware, but the README documents no authentication mechanism.

**coderaiser/cloudcmd** — ✨☁️📁✨ Cloud Commander file manager for the web with console and editor.

- Repository: https://github.com/coderaiser/cloudcmd
- Website: https://cloudcmd.io
- Stars: 2,034 · Forks: 268
- Language: JavaScript
- License: MIT
- Published: 2026-10-11 · Updated: 2026-10-11 · Language: en
- Canonical page: https://hysenlabs.com/projects/coderaiser-cloudcmd

## A browser-based file manager that also serves as Express middleware

Cloud Commander addresses the problem of remote filesystem access without requiring SSH clients, FTP software or VPN software on the connecting machine. Opening a browser to port 8000 shows a dual-panel file manager, a terminal console and a text editor, all running over HTTP and WebSocket connections managed by socket.io.

Primary users are developers who need occasional file access to a remote server, homelab operators who want a graphical interface for a NAS, and teams embedding file management into an existing Node.js application. The middleware path is the distinguishing feature: Cloud Commander can mount inside an Express app rather than running as a standalone process, letting an existing application expose file management on an internal route.

Cloud Commander is listed as an "orthodox" file manager in package.json's keywords, a term for the two-panel layout familiar from Midnight Commander: each panel shows a different directory, and files are copied, moved or renamed between them with keyboard shortcuts rather than drag and drop. Repository topics include linux, macos, windows and android, indicating cross-platform support. Docker images exist for amd64 and arm64 architectures in both linux and linux-alpine variants, and the current version is 19.21.1, published on 2026-09-29. A live demo is available at https://cloudcmd-zdp6.onrender.com.

## Installing globally with npm and opening port 8000

Global installation uses a single npm command:

```
npm i cloudcmd -g
```

After installation, starting the server requires one more:

```sh
cloudcmd
```

With the server running, opening http://localhost:8000 in a browser shows the file manager interface. No configuration is required for a local session.

For the middleware path, initializing a new package first with npm init -y, then installing cloudcmd, express and socket.io together works as the README shows:

```
npm i cloudcmd express socket.io -S
```

Socket.io is listed in the middleware example as required for the console component. Config and Edit also use the socket connection, noted as optional. Running Cloud Commander without socket.io removes those three features from the interface.

Package.json registers cloudcmd as a binary at bin/cloudcmd.js and lists server/cloudcmd.js as the main entry point. Package type is module, meaning all server-side code uses ES module import syntax rather than CommonJS require. Version is 19.21.1 and the package name is cloudcmd.

## Embedding Cloud Commander in an Express application with socket.io

Using Cloud Commander as middleware requires connecting an HTTP server, a socket.io server and an Express app in a single index.js file. The README gives a full working example starting with these imports:

```js
import http from 'node:http';
import {cloudcmd} from 'cloudcmd';
import {Server} from 'socket.io';
import express from 'express';

const app = express();
const port = 1337;
const prefix = '/';
const server = http.createServer(app);
const socket = new Server(server, {
    path: `${prefix}socket.io`,
});
server.listen(port);
```

The cloudcmd export is then passed to app.use with four possible arguments: socket (required for the console), config for configuration data, modules for overriding module settings, and configManager for an external configuration manager. Port 1337 in the README example is the application port, separate from the standalone mode's default port 8000. Changing prefix mounts Cloud Commander under a different route within the same application, which is how you'd share a server with other routes.

The cloudcmd export also exposes createConfigManager and configPath for constructing an external configuration manager. A name field in the config object changes the displayed title inside the interface. The README shows the config set to {name: 'cloudcmd :)'} in the full example. The complete index.js, including all optional arguments and the filePicker module override, is documented on the README.

## Docker images for four architecture and type combinations

Docker images are provided for four combinations: amd64 linux, arm64 (arm/v8) linux, amd64 linux-alpine and arm64 (arm/v8) linux-alpine. The image name is coderaiser/cloudcmd on Docker Hub.

Running the container requires two volume mounts and a port mapping. Home directory mounts to /root where Cloud Commander reads its config, and the host root filesystem mounts to /mnt/fs:

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

For a persistent setup, the repository includes a docker-compose.yml:

```yml
version: "2"
services:
  web:
    ports:
      - 8000:8000
    volumes:
      - ~:/root
      - /:/mnt/fs
    image: coderaiser/cloudcmd
```

Both the docker run command and the compose file expose port 8000. Mounting /:/mnt/fs gives the container process access to the entire host filesystem under that path. Anyone who can reach port 8000 on the host can read and write anywhere the container's user has permission, which is the same security consideration that applies to the non-Docker installation and is worth addressing before any remote deployment.

## Client and server split: separate directories, rspack bundling and Playwright tests

Repository layout separates client and server code explicitly. Server code lives in server/, browser-side code in client/, shared utilities in common/, and templates in html/ and tmpl/. CSS goes in css/, static assets in static/ and fonts in font/.

Bundling configuration appears in both rspack.config.js and webpack.config.js at the repository root, with an additional .rspack/ directory. Rspack is a Rust-based webpack-compatible bundler; the README does not document which is primary for releases.

Test directories are test/ for unit tests and test-e2e/ for end-to-end tests, with playwright.config.js at the root governing the end-to-end suite. Configuration data lives under json/. A .cloudcmd.menu.js file at the root suggests a plugin mechanism for the context menu.

Files app.json and manifest.yml appear at the top level alongside deno.json. The Node.js tooling dominates the configuration, and the repository topics and documentation focus on Node.js, but deno.json's presence suggests some compatibility work exists outside the main Node.js path. Package.json scripts all delegate to madrun, a script runner, rather than calling tools directly.

## Authentication is absent from the documentation: what that means for port 8000

Cloud Commander's README gives no authentication configuration at all. No username, password, session token or IP allowlist appears anywhere in the documented options. The cloudcmd() middleware call in the index.js example accepts no auth argument, and the standalone cloudcmd command accepts no auth flag.

For local development where only one user is on the network, that gap is harmless. A developer running cloudcmd on a laptop with no incoming connections takes no meaningful risk. For a remote server with a publicly reachable network address, port 8000 without authentication means anyone who discovers the port can browse, edit and delete files up to the process's permission boundary.

Mounting /:/mnt/fs in the Docker example amplifies this: it places the entire host filesystem under /mnt/fs inside the browser interface. A reverse proxy with HTTP basic auth or mutual TLS at the network layer is the gap to fill before a remote deployment. HTTPS termination at the proxy also matters, because Cloud Commander by default sends filesystem data over unencrypted HTTP.

FileBrowser is an alternative worth comparing: it is a Go-based web file manager with built-in user accounts, per-user permissions and HTTPS support. It does not offer embedded middleware mode, so teams who need the Express integration path would not find a drop-in replacement there.

## v19.21.1, MIT licence, and funding through Open Collective and Patreon

Current version is v19.21.1, released on 2026-09-29. Preceding releases were v19.21.0 on 2026-09-18 and v19.20.8 on 2026-09-16, a cadence of multiple releases per month. A ChangeLog file at the repository root tracks changes, and the project's blog is at https://blog.cloudcmd.io.

Licence is MIT, per the repository metadata, the README and the LICENSE file at the root. Package.json lists funding at https://opencollective.com/cloudcmd, and the README also links to the author's Patreon at https://patreon.com/coderaiser. Those are the two documented support channels.

Repository includes a CONTRIBUTING.md and a CODE_OF_CONDUCT.md. A community wiki is linked in the README for site translations, hosted on the GitHub wiki. The Gitter channel at https://gitter.im/cloudcmd/hello appears in the README badges for community questions.

Deploy-to-platform support appears through app.json (likely Heroku) and a link to InstaPods in the README badges. The repository includes a HELP.md at the top level for user documentation beyond the README itself.

## Conclusion

Cloud Commander suits a developer or small team that needs browser access to a server's filesystem without setting up a full file transfer protocol. Embed it in an existing Express application where socket.io is already in use, or install it globally and run cloudcmd for a quick local session. Skip it if you need per-user authentication or built-in TLS: the README documents neither, and exposing port 8000 without additional controls gives full filesystem access to anyone who reaches that port. Before any network-accessible deployment, place it behind a reverse proxy that handles both.

## FAQ

### What is Cloud Commander?

Cloud Commander is a Node.js application that provides a web-based file manager with a two-panel view, a terminal console and a text editor, accessible from a browser at port 8000. It runs as a standalone global npm package or as Express middleware using socket.io.

### How do I install Cloud Commander?

Run npm i cloudcmd -g to install globally, then run cloudcmd to start the server. Open http://localhost:8000 in a browser to reach the file manager. No configuration is required for a local session.

### Does Cloud Commander have authentication?

The README does not document any authentication mechanism. No username, password or IP restriction option appears in the documentation, which means anyone who can reach port 8000 has full access to the filesystem the process can read.

### Can Cloud Commander run in Docker?

Yes. The repository provides a Docker image at coderaiser/cloudcmd on Docker Hub, with builds for amd64 and arm64 architectures in linux and linux-alpine variants. A docker-compose.yml is included at the repository root.

### How do I embed Cloud Commander in an existing Express app?

Install cloudcmd, express and socket.io, then import cloudcmd from 'cloudcmd', create an HTTP server and a socket.io Server, and mount Cloud Commander with app.use. The cloudcmd export accepts socket (required for the console), config, modules and configManager as arguments.

## Sources

- [coderaiser/cloudcmd on GitHub](https://github.com/coderaiser/cloudcmd)
- [License: MIT](https://github.com/coderaiser/cloudcmd/blob/master/LICENSE)
- [Project website](https://cloudcmd.io)
- [README](https://github.com/coderaiser/cloudcmd/blob/master/README.md)
- [Releases](https://github.com/coderaiser/cloudcmd/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/coderaiser-cloudcmd