A full-featured framework for building command line applications (cli) with node.js
A full-featured framework for building command line applications (cli) with node.js, including help generation, colored output, verbosity control, custom logger, coercion and casting, typos suggestions, and auto-complete for bash/zsh/fish.
Simply add Caporal as a dependency:
$ npm install caporal
# Or if you are using yarn (https://yarnpkg.com/lang/en/)
$ yarn add caporal
Angled brackets (e.g. <item>) indicate required input. Square brackets (e.g. [env]) indicate optional input.
#!/usr/bin/env node
const prog = require('caporal');
prog
.version('1.0.0')
// you specify arguments using .argument()
// 'app' is required, 'env' is optional
.command('deploy', 'Deploy an application')
.argument('<app>', 'App to deploy', /^myapp|their-app$/)
.argument('[env]', 'Environment to deploy on', /^dev|staging|production$/, 'local')
// you specify options using .option()
// if --tail is passed, its value is required
.option('--tail <lines>', 'Tail <lines> lines of logs after deploy', prog.INT)
.action(function(args, options, logger) {
// args and options are objects
// args = {"app": "myapp", "env": "production"}
// options = {"tail" : 100}
});
prog.parse(process.argv);
// ./myprog deploy myapp production --tail 100
Or else if you prefer typescript
#!/usr/bin/env node
import * as prog from 'caporal';
prog
.version('1.0.0')
// you specify arguments using .argument()
// 'app' is required, 'env' is optional
.command('deploy', 'Deploy an application')
.argument('<app>', 'App to deploy', /^myapp|their-app$/)
.argument('[env]', 'Environment to deploy on', /^dev|staging|production$/, 'local')
// you specify options using .option()
// if --tail is passed, its value is required
.option('--tail <lines>', 'Tail <lines> lines of logs after deploy', prog.INT)
.action(function(args, options, logger) {
// args and options are objects
// args = {"app": "myapp", "env": "production"}
// options = {"tail" : 100}
});
prog.parse(process.argv);
// ./myprog deploy myapp production --tail 100
You can use ... to indicate variadic arguments. In that case, the resulted value will be an array.
Note: Only the last argument of a command can be variadic !
#!/usr/bin/env node
const prog = require('caporal');
prog
.version('1.0.0')
.command('deploy', 'Our deploy command')
// 'app' and 'env' are required
// and you can pass additional environments
.argument('<app>', 'App to deploy')
.argument('<env>', 'Environment')
.argument('[other-env...]', 'Other environments')
.action(function(args, options, logger) {
console.log(args);
// {
// "app": "myapp",
// "env": "production",
// "otherEnv": ["google", "azure"]
// }
});
prog.parse(process.argv);
// ./myprog deploy myapp production aws google azure
For a very simple program with just one command, you can omit the .command() call:
#!/usr/bin/env node
const prog = require('caporal');
prog
.version('1.0.0')
.description('A simple program that says "biiiip"')
.action(function(args, options, logger) {
logger.info("biiiip")
});
prog.parse(process.argv);
You can pass arguments and options directly to Caporal API.
#!/usr/bin/env node
const prog = require('caporal');
prog
.version('1.0.0')
.command('deploy', 'Our deploy command')
.argument('<app>', 'App to deploy')
.argument('<env>', 'Environment')
.option('--how-much <amount>', 'How much app to deploy', prog.INT, 1)
.action(function(args, options, logger) {
logger.info(args);
logger.info(options);
// {
// "app": "myapp",
// "env": "production"
// }
// {
// "howMuch": 2
// }
});
prog.exec(['deploy', 'myapp', 'env'], {
howMuch: 2
});
Inside your action(), use the logger argument (third one) to log informations.
#!/usr/bin/env node
const prog = require('caporal');
prog
.version('1.0.0')
.command('deploy', 'The deploy command')
.action((args, options, logger) => {
// Available methods:
// - logger.debug('message')
// - logger.info('message') or logger.log('level', 'message')
// - logger.warn('message')
// - logger.error('message')
logger.info("Application deployed !");
});
prog.parse(process.argv);
The default logging level is 'info'. The predefined options can be used to change the logging level:
-v, --verbose: Set the logging level to 'debug' so debug() logs will be output.--quiet, --silent: Set the logging level to 'warn' so only warn() and error() logs will be output.Caporal uses winston for logging. You can provide your own winston-compatible logger using .logger() the following way:
#!/usr/bin/env node
const prog = require('caporal');
const myLogger = require('/path/to/my/logger.js');
prog
.version('1.0.0')
.logger(myLogger)
.command('foo', 'Foo command description')
.action((args, options, logger) => {
logger.info("Foo !!");
});
prog.parse(process.argv);
-v, --verbose: Set the logging level to 'debug' so debug() logs will be output.--quiet, --silent: Set the logging level to 'warn' so only warn() and error() logs will be output.You can apply coercion and casting using various validators:
INT (or INTEGER): Check option looks like an int and cast it with parseInt()FLOAT: Will Check option looks like a float and cast it with parseFloat()BOOL (or BOOLEAN): Check for string like 0, 1, true, false, on, off and cast itLIST (or ARRAY): Transform input to array by splitting it on commaREPEATABLE: Make the option repeatable, eg ./mycli -f foo -f bar -f joe#!/usr/bin/env node
const prog = require('caporal');
prog
.version('1.0.0')
.command('order pizza')
.option('--number <num>', 'Number of pizza', prog.INT, 1)
.option('--kind <kind>', 'Kind of pizza', /^margherita|hawaiian$/)
.option('--discount <amount>', 'Discount offer', prog.FLOAT)
.option('--add-ingredients <ingredients>', 'Ingredients', prog.LIST)
.action(function(args, options) {
// options.kind = 'margherita'
// options.number = 1
// options.addIngredients = ['pepperoni', 'onion']
// options.discount = 1.25
});
prog.parse(process.argv);
// ./myprog order pizza --kind margherita --discount=1.25 --add-ingredients=pepperoni,onion
#!/usr/bin/env node
const prog = require('caporal');
prog
.version('1.0.0')
.command('concat') // concat files
.option('-f <file>', 'File to concat', prog.REPEATABLE)
.action(function(args, options) {
});
prog.parse(process.argv);
// Usage:
// ./myprog concat -f file1.txt -f file2.txt -f file3.txt
Using this method, you can check and cast user input. Make the check fail by throwing an Error,
and cast input by returning a new value from your function.
#!/usr/bin/env node
const prog = require('caporal');
prog
.version('1.0.0')
.command('order pizza')
.option('--kind <kind>', 'Kind of pizza', function(opt) {
if (['margherita', 'hawaiian'].includes(opt) === false) {
throw new Error("You can only order margherita or hawaiian pizza!");
}
return opt.toUpperCase();
})
.action(function(args, options) {
// options = { "kind" : "MARGHERITA" }
});
prog.parse(process.argv);
// ./myprog order pizza --kind margherita
Using an Array, Caporal will check that it contains the argument/option passed.
Note: It is not possible to cast user input with this method, only checking it, so it's basically only interesting for strings, but a major advantage is that this method will allow autocompletion of arguments and option values.
#!/usr/bin/env node
const prog = require('caporal');
prog
.version('1.0.0')
.command('order pizza')
.option('--kind <kind>', 'Kind of pizza', ["margherita", "hawaiian"])
.action(function(args, options) {
});
prog.parse(process.argv);
// ./myprog order pizza --kind margherita
Simply pass a RegExp object to test against it. Note: It is not possible to cast user input with this method, only checking it, so it's basically only interesting for strings.
#!/usr/bin/env node
const prog = require('caporal');
prog
.version('1.0.0')
.command('order pizza')
.option('--kind <kind>', 'Kind of pizza', /^margherita|hawaiian$/)
.action(function(args, options) {
});
prog.parse(process.argv);
// ./myprog order pizza --kind margherita
By default, Caporal will output colors for help and errors.
This behaviour can be disabled by passing --no-color.
Caporal automatically generates help/usage instructions for you.
Help can be displayed using -h or --help options, or with the default help command.
You can add some custom help to the whole program or to specific commands using .help(text, options?). The text, even if multi-line, will be, optionally, automatically indented.
Multiple help sections, with custom names, are supported.
#!/usr/bin/env node
const prog = require('caporal');
prog
.version('1.0.0')
.help('my global help') // here our custom help for the whole program
.command('order pizza')
.action(function(args, options) {
});
prog.parse(process.argv);
#!/usr/bin/env node
const prog = require('caporal');
prog
.version('1.0.0')
// first command
.command('order')
.help('my help for the order command') // here our custom help for the `order` command
.action(function(args, options) {
})
// second command
.command('cancel')
.help('my help for the cancel command') // here our custom help for the `cancel` command
.action(function(args, options) {
})
prog.parse(process.argv);
Caporal will automatically make suggestions for option typos.
Caporal comes with an auto-completion feature out of the box for bash, zsh, and fish,
thanks to tabtab.
For this feature to work, you will have to:
$PATH (this is the case if your app is installed globally using npm install -g <myapp>)# For bash
source <(myapp completion bash)
# or add it to your .bashrc to make it persist
echo "source <(myapp completion bash)" >> ~/.bashrc \
&& source ~/.bashrc
# For zsh
source <(myapp completion zsh)
# or add it to your .zshrc to make it persist
echo "source <(myapp completion zsh)" >> ~/.zshrc \
&& source ~/.zshrc
# For fish
source <(myapp completion fish)
# or add it to your config.fish to make it persist
echo "source <(myapp completion fish)" >> ~/.config/fish/config.fish \
&& source ~/.config/fish/config.fish
By default, it will autocomplete commands and option names. Also, options having an Array validator will be autocompleted.
#!/usr/bin/env node
const prog = require('caporal');
prog
.version('1.0.0')
// the "order" command
.command('order', 'Order a pizza')
.alias('give-it-to-me')
// <kind> will be auto-magicaly autocompleted by providing the user with 3 choices
.argument('<kind>', 'Kind of pizza', ["margherita", "hawaiian", "fredo"])
.argument('<from-store>', 'Which store to order from')
// enable auto-completion for <from-store> argument using a sync function returning an array
.complete(function() {
return ['store-1', 'store-2', 'store-3', 'store-4', 'store-5'];
})
.argument('<account>', 'Which account id to use')
// enable auto-completion for <account> argument using a Promise
.complete(function() {
return Promise.resolve(['account-1', 'account-2']);
})
.option('-n, --number <num>', 'Number of pizza', prog.INT, 1)
.option('-d, --discount <amount>', 'Discount offer', prog.FLOAT)
.option('-p, --pay-by <mean>', 'Pay by option')
// enable auto-completion for -p | --pay-by option using a Promise
.complete(function() {
return Promise.resolve(['cash', 'credit-card']);
})
// -e | --extra will be auto-magicaly autocompleted by providing the user with 3 choices
.option('-e, --extra <ingredients>', 'Add extra ingredients', ['pepperoni', 'onion', 'cheese'])
.action(function(args, options, logger) {
logger.info("Command 'order' called with:");
logger.info("arguments: %j", args);
logger.info("options: %j", options);
})
// the "return" command
.command('return', 'Return an order')
.argument('<order-id>', 'Order id')
// enable auto-completion for <order-id> argument using a Promise
.complete(function() {
return Promise.resolve(['#82792', '#71727', '#526Z52']);
})
.argument('<to-store>', 'Store id')
.option('--ask-change <other-kind-pizza>', 'Ask for other kind of pizza')
// enable auto-completion for --ask-change option using a Promise
.complete(function() {
return Promise.resolve(["margherita", "hawaiian", "fredo"]);
})
.option('--say-something <something>', 'Say something to the manager')
.action(function(args, options, logger) {
logger.info("Command 'return' called with:");
logger.info("arguments: %j", args);
logger.info("options: %j", options);
});
prog.parse(process.argv);
require('caporal')Returns a Program instance.
.version(version) : ProgramSet the version of your program. You may want to use your package.json version to fill it:
const myProgVersion = require('./package.json').version;
const prog = require('caporal');
prog
.version(myProgVersion)
// [...]
prog.parse(process.argv);
Your program will then automaticaly handle -V and --version options:
matt@mb:~$ ./my-program --version
1.0.0
.help(text, options?) : ProgramAdd a program-level help section.
By default the optional options parameter is:
{
indent: true, // If `true` the text will be automatically indented
name: "MORE INFO" // The name of the section
}
.command(name, description) -> CommandSet up a new command with name and description. Multiple commands can be added to one program. Returns a {Command}.
const prog = require('caporal');
prog
.version('1.0.0')
// one command
.command('walk', 'Make the player walk')
.action((args, options, logger) => { logger.log("I'm walking !")}) // you must attach an action for your command
// a second command
.command('run', 'Make the player run')
.action((args, options, logger) => { logger.log("I'm running !")})
// a command may have multiple words
.command('cook pizza', 'Make the player cook a pizza')
.argument('<kind>', 'Kind of pizza')
.action((args, options, logger) => { logger.log("I'm cooking a pizza !")})
// [...]
prog.parse(process.argv);
.logger([logger]) -> Program | winstonGet or set the logger instance. Without argument, it returns the logger instance (winston by default). With the logger argument, it sets a new logger.
.argument(synopsis, description, [validator, [defaultValue]]) -> CommandAdd an argument to the command. Can be called multiple times to add several arguments.
<my-required-arg> or [my-optional-arg].option(synopsis, description, [validator, [defaultValue, [required]]) -> CommandAdd an option to the command. Can be called multiple times to add several options.
false.help(text, options?) -> CommandAdd a command-level help section.
By default the optional options parameter is:
{
indent: true, // If `true` the text will be automatically indented
name: "" // The name of the section, by default this line won't be displayed
}
.action(action) -> CommandDefine the action, e.g a Function, for the current command.
The action callback will be called with 3 arguments:
// sync action
const prog = require('caporal');
prog
.version('1.0.0')
.command('walk', 'Make the player walk')
.action((args, options, logger) => {
logger.log("I'm walking !")
});
You can make your actions async by using Promises:
// async action
const prog = require('caporal');
prog
.version('1.0.0')
.command('walk', 'Make the player walk')
.action((args, options, logger) => {
return new Promise(/* ... */);
});
.alias(alias) -> CommandDefine an alias for the current command. A command can only have one alias.
const prog = require('caporal');
prog
.version('1.0.0')
// one command
.command('walk', 'Make the player walk')
.alias('w')
.action((args, options, logger) => { logger.log("I'm walking !")});
prog.parse(process.argv);
// ./myapp w
// same as
// ./myapp walk
.complete(completer) -> CommandDefine an auto-completion handler for the latest argument or option added to the command.
Array or a Promise which resolves to an Array..visible(visibility?) -> Boolean | CommandGet or set the visibility value of this command. By default it's true, if you set it to false it will be omitted from the help message.
const prog = require('caporal');
prog
.version('1.0.0')
// one command
.command('walk', 'Make the player walk')
.visible ( false )
prog.parse(process.argv);
Caporal is strongly inspired by commander.js and Symfony Console. Caporal makes use of the following npm packages:
Copyright © Matthias ETIENNE
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
The Software is provided “as is”, without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and noninfringement. In no event shall the authors or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with the software or the use or other dealings in the Software.
FAQs
A full-featured framework for building command line applications (cli) with node.js
The npm package caporal receives a total of 44,806 weekly downloads. As such, caporal popularity was classified as popular.
We found that caporal demonstrated a not healthy version release cadence and project activity because the last version was released a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
In this segment of the Risky Business podcast, Feross Aboukhadijeh and Patrick Gray discuss the challenges of tracking malware discovered in open source softare.
Research
Security News
A threat actor's playbook for exploiting the npm ecosystem was exposed on the dark web, detailing how to build a blockchain-powered botnet.
Security News
NVD’s backlog surpasses 20,000 CVEs as analysis slows and NIST announces new system updates to address ongoing delays.