Cloud file manager with console and editor
Find typo? Help fix it.
Contact
Cloud Commander is a file manager for the web. It includes a command-line console and a text editor. Cloud Commander helps you manage your server and work with files, directories and programs in a web browser from any computer, mobile or tablet.
Installation is very simple:
cloudcmd
via npm
with:npm i cloudcmd -g
When in trouble, use:
npm i cloudcmd -g --force
To start the server, just run the global npm binary from your terminal:
cloudcmd
Cloud Commander supports the following 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-dot-files |
show dot files |
--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 |
--confirm-copy |
confirm copy |
--confirm-move |
confirm move |
--open |
open web browser when server starts |
--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 |
--theme |
set theme ‘light’ or ‘dark’” |
--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-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-themes |
set default visible themes |
--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 |
For options not specified by command-line parameters, Cloud Commander then reads configuration data from ~/.cloudcmd.json
. It uses port 8000
by default.
To begin using the web client, go to this PREFIX in your browser:
http://localhost:8000
If you installed Cloud Commander with npm
, stop the server. Then, reinstall it with:
npm install cloudcmd -g
Then, start the server again with cloudcmd
and reload the page.
Key | Operation |
---|---|
F1 |
help |
F2 |
show user menu |
F3 |
view, change directory |
Shift + F3 |
view raw file, change directory |
F4 |
edit |
F5 |
copy |
Alt + F5 |
pack |
F6 |
rename/move |
Shift + F6 |
rename current file |
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 |
: |
open Command Line |
Ctrl + X |
cut to buffer |
Ctrl + C |
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 |
Ctrl + U |
swap panels |
Ctrl + F3 |
sort by name |
Ctrl + F5 |
sort by date |
Ctrl + F6 |
sort by size |
Ctrl + Command + . |
show/hide dot files |
Up , Down |
file system navigation |
Enter |
change directory/view file |
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 |
Esc |
toggle vim hotkeys (file manager , editor ) |
When the --vim
option is provided, or the configuration parameter vim
is set, the following hotkeys become available:
Key | Operation |
---|---|
j |
navigate to next file |
k |
navigate to previous file |
dd |
remove current file |
G or $ |
navigate to bottom file |
gg or ^ |
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 |
md |
make directory |
mf |
make file |
tt |
show terminal |
e |
edit file |
Commands can be joined, for example:
5j
will navigate 5 files below current;d5j
will remove next 5 files;dG
will remove all files from current to bottom;These file operations are accessible with “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 |
Key | Operation |
---|---|
F3 |
open |
Esc |
close |
Key | Operation |
---|---|
F4 |
open |
Shift + F4 |
open in “vim” mode |
Esc |
close |
For more details see Edward hotkeys.
Key | Operation |
---|---|
~ |
open |
Ctrl + P |
paste path of current directory |
Esc |
close |
For more details see console hot keys.
The terminal is disabled and not installed by default. To use it, you should install gritty with:
npm i gritty -g
and then set the path for the 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 the path of gritty
with:
gritty --path
It will returns something like:
C:\Users\coderaiser\AppData\Roaming\npm\node_modules\gritty
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 Cloud Commander’s terminal in the same way as a normal shell console.
Key | Operation |
---|---|
Shift + ~ |
open |
Shift + Esc |
close |
Every program executed in Cloud Commander’s terminal has these environment variables:
ACTIVE_DIR
- directory that contains cursorPASSIVE_DIR
- directory with no cursorCURRENT_NAME
- name of a file under cursorCURRENT_PATH
- path to file under cursorOn Unix, you can use it this way:
~> echo $CURRENT_PATH
/home/coderaiser/cloudcmd/bin/cloudcmd.js
Key | Operation |
---|---|
F10 |
open |
Esc |
close |
When you change any options, the ~/.cloudcmd.json
file is automatically updated.
It can also be edited manually with any text editor.
Here’s a description of all 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
"confirmCopy": true, // confirm copy
"confirmMove": true, // confirm move
"showConfig": false, // show config at startup
"showDotFiles": true, // show dot files
"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
"themes": "name-size-date-owner-mode", // set visible themes
"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
}
Some config options can be overridden with environment variables, such as:
CLOUDCMD_NAME
- set tab name in web browserCLOUDCMD_OPEN
- open web browser when server startedCLOUDCMD_EDITOR
- set editorCLOUDCMD_COLUMNS
- set visible themesCLOUDCMD_THEME
- set themes “light” or “dark”CLOUDCMD_CONTACT
- enable contactCLOUDCMD_CONFIG_DIALOG
- enable config dialogCLOUDCMD_CONFIG_AUTH
- enable auth change in config dialogCLOUDCMD_CONSOLE
- enable consoleCLOUDCMD_SYNC_CONSOLE_PATH
- sync console pathCLOUDCMD_TERMINAL
- enable terminalCLOUDCMD_TERMINAL_PATH
- set terminal pathCLOUDCMD_TERMINAL_COMMAND
- set command to run in terminal (shell by default)CLOUDCMD_TERMINAL_AUTO_RESTART
- restart command on exitCLOUDCMD_KEYS_PANEL
- show keys panelCLOUDCMD_ONE_FILE_PANEL
- show one file panelCLOUDCMD_AUTH
- enable authenticationCLOUDCMD_USERNAME
- set usernameCLOUDCMD_PASSWORD
- set passwordCLOUDCMD_PREFIX
- set url prefixCLOUDCMD_ROOT
- set root directoryCLOUDCMD_VIM
- enable vim hot keysCLOUDCMD_CONFIRM_COPY
- confirm copyCLOUDCMD_CONFIRM_MOVE
- confirm moveCLOUDCMD_SHOW_FILE_NAME
- show file name in view and editCLOUDCMD_EXPORT
- enable export of config through a serverCLOUDCMD_EXPORT_TOKEN
- authorization token used by export serverCLOUDCMD_IMPORT
- enable import of configCLOUDCMD_IMPORT_TOKEN
- authorization token used to connect to export serverCLOUDCMD_IMPORT_URL
- url of an import serverCLOUDCMD_IMPORT_LISTEN
- enable listen on config updates from import serverWhen you press F2
Cloud Commander will read a file .cloudcmd.menu.js
by walking up parent directories, if can’t read it will try to read ~/.cloudcmd.menu.js
.
Let’s consider example user menu
works file:
const RENAME_FILE = 'Rename file';
export default {
'__settings': {
select: [RENAME_FILE],
run: false,
},
[`F2 - ${RENAME_FILE}`]: async ({DOM}) => {
await DOM.renameCurrent();
},
'D - Build Dev': async ({CloudCmd}) => {
await CloudCmd.TerminalRun.show({
command: 'npm run build:client:dev',
autoClose: false, // optional
closeMessage: 'Press any button to close Terminal', // optional
});
await CloudCmd.refresh();
},
'P - Build Prod': async ({CloudCmd}) => {
await CloudCmd.TerminalRun.show({
command: 'npm run build:client',
autoClose: true, // optional
});
await CloudCmd.refresh();
},
'C - Create User Menu File': async ({DOM, CloudCmd}) => {
const {CurrentInfo} = DOM;
const {dirPath} = CurrentInfo;
const path = `${dirPath}.cloudcmd.menu.js`;
const {prefix} = CloudCmd;
const data = await readDefaultMenu({
prefix,
});
await createDefaultMenu({
path,
data,
DOM,
CloudCmd,
});
},
};
async function createDefaultMenu({path, data, DOM, CloudCmd}) {
const {IO} = DOM;
await IO.write(path, data);
await CloudCmd.refresh();
DOM.setCurrentByName('.cloudcmd.menu.js');
await CloudCmd.EditFile.show();
}
async function readDefaultMenu({prefix}) {
const res = await fetch(`${prefix}/api/v1/user-menu/default`);
const data = await res.text();
return data;
}
You will have ability to run one of this 3 commands with help of double click, enter, or binded key (F2
, D
or P
in this example). Also you can run commands in terminal, or execute any built-in function of Cloud Commander
extended it’s interface. You can find more examples in User Menu Cookbook.
Here you can find API
that can be used in User Menu. DOM and CloudCmd two main objects you receive in arguments list using destructuring.
DOM contains all base functions of Cloud Commander
(rename, remove, download etc);
renameCurrent
- shows renames current file dialog, and does renaming.CloudCmd contains all modules (Terminal
, View
, Edit
, Config
, Console
etc);
TerminalRun
- module that shows Terminal
with a command
from options and closes terminal when everything is done.IO Files API
rename(from, to)
- rename from
into to
move(from, to, names)
- rename files with a names
from
into to
;copy(from, to, names)
- copy files with a names
from
into to
;createDirectory(path)
- create directory with a path
;Being able to configure Cloud Commander remotely opens the doors to using it as microservice, and that’s what the “distribute” options set out to do.
There is an export server and an import client, which are enabled with --export
and --import
respectively. There is a “token”, which should be the same in --import-token
and --export-token
. To use the import client, you should provide --import-url
to the client so it can connect to an export server.
There are two ways that the import client can receive configuration from an export server:
--import-listen
flag)Here’s an export server:
coderaiser@cloudcmd:~$ cloudcmd --port 1234 --export --export-token=cloudcmd
…and an import client:
coderaiser@cloudcmd:~$ cloudcmd --name importer --port 4321 --import-url http://127.0.0.1:1234 --import-token=cloudcmd --no-server --save
Here’s the log output from the export server:
url: http://localhost:1234/
2018.08.23 13:41:45 -> export: try to auth from importer [127.0.0.1:4321]
2018.08.23 13:41:45 -> export: connected to importer [127.0.0.1:4321]
2018.08.23 13:41:45 -> export: config send to importer [127.0.0.1:4321]
2018.08.23 13:41:45 -> export: disconnected importer [127.0.0.1:4321]
…and the log output from the import client:
2018.08.23 13:47:36 -> import: try to auth to http://127.0.0.1:1234
2018.08.23 13:47:36 -> import: connected to http://127.0.0.1:1234
2018.08.23 13:47:36 -> import: config received from http://127.0.0.1:1234
2018.08.23 13:47:36 -> import: disconnected from http://127.0.0.1:1234
When the import client uses --import-listen
, a persistent connection is used, and the client receives live updates from the import server.
The export server omits the following configuration fields:
auth
username
password
algo
name
ip
port
root
import
importUrl
importToken
export
exportToken
log
configDialog
Right-mouse click to show a context menu with these items:
authorization
is enabled)Key | Operation |
---|---|
F9 |
open |
Esc |
close |
Cloud Commander can work in one panel mode when your screen size can’t accommodate a second panel (such as on mobile or tablet), or via the --one-file-panel
options flag.
Cloud Commander can be used as middleware for node.js
applications based on socket.io and express:
Init package.json
:
npm init -y
Install dependencies:
npm i cloudcmd express socket.io -S
And create index.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`,
});
const config = {
name: 'cloudcmd :)',
};
const filePicker = {
data: {
FilePicker: {
key: 'key',
},
},
};
// override option from json/modules.json
const modules = {
filePicker,
};
const {
createConfigManager,
configPath,
} = cloudcmd;
const configManager = createConfigManager({
configPath,
});
app.use(prefix, cloudcmd({
socket, // used by Config, Edit (optional) and Console (required)
config, // config data (optional)
modules, // optional
configManager, // optional
}));
server.listen(port);
Here is example with two Config Managers
:
import http from 'node:http';
import cloudcmd from 'cloudcmd';
import {Server} from 'socket.io';
import express from 'express';
const app = express();
const port = 8000;
const prefix1 = '/1';
const prefix2 = '/2';
const {createConfigManager} = cloudcmd;
const server = http.createServer(app);
const socket1 = new Server(server, {
path: `${prefix1}/socket.io`,
});
const socket2 = new Server(server, {
path: `${prefix2}/socket.io`,
});
const configManager1 = createConfigManager();
configManager1('name', '1');
const configManager2 = createConfigManager();
configManager2('name', '2');
app.use(prefix1, cloudcmd({
socket: socket1,
configManager: configManager1,
}));
app.use(prefix2, cloudcmd({
socket: socket2,
configManager: configManager2,
}));
server.listen(port);
If you want to enable authorization, you can pass credentials to Cloud Commander with a config. To generate a password, you can install criton
with npm i criton --save
, and use it (or any other way) to generate a hash of a password.
import criton from 'criton';
const algo = 'sha512WithRSAEncryption';
// default
// you can generate a hash dynamically
const password = criton('root', algo);
// or use a pregenerated hash as well
'2b64f2e..ca5d9a9';
const auth = true;
const username = 'root';
const config = {
algo, // optional
auth,
username,
password,
};
Now you’re ready to go!
~/.cloudcmd.json
contains password hash because of security reason, if someone steal your config, he wouldn’t know your password, because hash is very strong and can be customized.
You should never write your password as plain text to ~/.cloudcmd.json
, you can generate password using cloudcmd
itself:
cloudcmd --username name --password password --auth --save --no-server
This command will create hash of your password and write it to ~/.cloudcmd.json
.
Standard practices dictate that no non-root process get to talk to the internet on a port less than 1024. Despite this, I suggest you start Cloud Commander as a non-root process. How can we get around this limitation? There’s a couple of fast & easy ways. One of them is port forwarding:
Just run shell/addtables.sh
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 (rule numbers 1 and 2; in your list they could differ).
iptables -t nat -D PREROUTING 2
iptables -t nat -D PREROUTING 1
Get nginx. On Linux, you can run:
sudo apt-get install nginx #for ubuntu and debian
Then, make a host file /etc/nginx/sites-available/io.cloudcmd.io (where, for example, io.cloudcmd.io is your domain name) with these contents:
server {
listen 80;
client_max_body_size 100m;
server_name io.cloudcmd.io;
access_log /var/log/nginx/io.cloudcmd.io.access.log;
location / {
proxy_pass http://127.0.0.1:8000/;
}
}
If you want add SSL, add a couple lines to the 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;
server_name io.cloudcmd.io;
access_log /var/log/nginx/io.cloudcmd.io.access.log;
location / {
proxy_pass http://127.0.0.1:8000/;
}
}
For WebSocket support, (nginx >= v1.3.13) modify the server
block like so:
location / {
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
proxy_pass http://127.0.0.1:8000/;
}
If you need redirection from http to https, simply use:
server {
listen 80;
server_name admin.cloudcmd.io;
rewrite ^ https://io.cloudcmd.io$request_uri? permanent; #301 redirect
access_log /var/log/nginx/io.cloudcmd.io.access.log;
}
# create a symlink of this file
ln -s ./sites-available/io.cloudcmd.io ./sites-enabled
# restart nginx
/etc/init.d/nginx restart
Cloud Commander
can be easily deployed to Heroku.
Cloud Commander
can be used as docker container like so:
docker run -t --rm -v ~:/root -v /:/mnt/fs -w=/root -p 8000:8000 coderaiser/cloudcmd
Configuration will be read from the home directory, the host’s root file system will be mounted to /mnt/fs
, and port 8000
port will exposed to the host’s port.
Also, you can use docker compose with docker-compose.yml
:
version: '2'
services:
web:
ports:
- 8000:8000
volumes:
- ~:/root
- /:/mnt/fs
image: coderaiser/cloudcmd
When you create this file, run:
docker-compose up
Dropbox support is integrated into Cloud Commander, and you can switch from your local file system to a Dropbox account.
All you need to do is set --dropbox
option and generate a dropbox token for your account.
This could look like this:
cloudcmd --dropbox --dropbox-token your-dropbox-token
While using Dropbox remember that there is no remote support for the console/terminal. Seeing the progress of file operations is also not supported. There’s only basic support, but you can do the following things with files and directories:
systemd
First, locate the command to run cloudcmd
which cloudcmd
take note of the result and create a systemd entry by executing
sudo nano /etc/systemd/system/cloudcmd.service
and use this template
[Unit]
Description = Cloud Commander
[Service]
TimeoutStartSec = 0
Restart = always
ExecStart = THE RESULT OF which cloudcmd WE'VE EXECUTED EARLIER
User = YOUR_USER
[Install]
WantedBy = multi-user.target
Don’t forget to change the line for ExecStart
and User
Save the changes and exit editor.
You may now enable cloudcmd and set it to autostart on boot by running:
sudo systemctl enable --now cloudcmd
FreeBSD
First, locate the command to run cloudcmd
which cloudcmd
take note of the result and create a rc script
vi /usr/local/etc/rc.d/cloudcmd
and use this template
!/bin/sh
#
# PROVIDE: cloudcmd
# REQUIRE: LOGIN
# KEYWORD: shutdown
# Author: IhatemyISP (ihatemyisp.net)
# Version: 1.0.0
# Description:
# This script runs Cloud Commander as a service under the supplied user on boot
# 1) Place file in /usr/local/etc/rc.d/
# 2) Add cloudcmd_enable="YES" to /etc/rc.conf
# 3) (Optional) To run as non-root, add cloudcmd_runAs="user" to /etc/rc.conf
# 4) (Optional) To pass Cloud Commander args, add cloudcmd_args="" to /etc/rc.conf
# Freebsd rc library
. /etc/rc.subr
# General Info
name="cloudcmd" # Safe name of program
program_name="cloudcmd" # Name of exec
title="CloudCommander" # Title to display in top/htop
# RC.config vars
load_rc_config $name # Loading rc config vars
: ${cloudcmd_enable="NO"} # Default: Do not enable Cloud Commander
: ${cloudcmd_runAs="root"} # Default: Run Cloud Commander as root
# Freebsd Setup
rcvar=cloudcmd_enable # Enables the rc.conf YES/NO flag
pidfile="/var/run/${program_name}.pid" # PID file location
# Env Setup
export HOME=$( getent passwd "$cloudcmd_runAs" | cut -d: -f6 ) # Gets the home directory of the runAs user
# Command Setup
exec_path="/usr/local/bin/${program_name}" # Path to the cloudcmd exec, /usr/local/bin/ when installed globally
output_file="/var/log/${program_name}.log" # Path to Cloud Commander output file
# Command
command="/usr/sbin/daemon"
command_args="-r -t ${title} -u ${cloudcmd_runAs} -o ${output_file} -P ${pidfile} ${exec_path} ${cloudcmd_args}"
# Loading Config
load_rc_config ${name}
run_rc_command "$1"
Enable autostart
echo cloudcmd_enable="YES" >> /etc/rc.conf
(Optional) Set user to run Cloud Commander as (default is root)
echo cloudcmd_runAs="user" >> /etc/rc.conf
Start the service (or just reboot)
service cloudcmd start
There are a lot of ways to be involved in Cloud Commander
development: