Commander provides a full development and runtime environment for developing custom Slack apps. There are a number of advantages to using Commander to develop, host, and maintain your custom apps.

You don’t need your own server

Commander lets you host and run Slack apps in the Nimbella Cloud, so you don’t have to deploy your own server. After you create a listing for your custom app on the Slack API apps page, you create one slash command and point the slash command’s Request URL to a Commander URL. Your app’s custom code lives in the Nimbella cloud, and Nimbella servers respond to slash commands developed for your app.

The slash command you create for your custom app at the Slack API site serves as a command prefix for your app’s commands. When users run commands for the app, they always begin with this prefix. For example, if you have a custom app called DevOps with a command prefix of /devops, then your app responds to any slash commands that have the form /devops <command>.

Selective listening

Most custom Slack apps function as bots, listening to all messages in a public channel and responding to direct requests. The apps you create with Commander don't read messages in channels. They only respond to slash commands with the appropriate command prefix. This means you don't have to worry about your custom Slack app reading messages in your public or private channels.

Create custom commands and administer your app right in Slack

After you install the Commander app in Slack, you can create custom slash commands and administer your custom app from the Slack interface. See the tutorial in the Quickstart Guide for an example of creating a custom slash command in the Slack UI.

Easy to code

Commands are written in JavaScript, and premium versions of Commander allow other options such as the Node.js runtime. This means custom apps can be developed by app developers or even DevOps staff who know shell scripting.

Advanced features

• Administrators assign user roles to control who can administer your custom app, who can write code for the commands, and who can run the slash commands.
• You can set up recurring tasks and triggers that run commands without user input.
• You can create encrypted parameter values, called secrets, which keep sensitive information from being viewed by users or being stored in Slack’s history.
• You can import and export command sets to either use someone else’s code or share your own.

Security

There's nothing you need to do to secure your app. The signatures of incoming requests from Slack users issuing Slack commands are verified to ensure they are coming from Slack. See Security.

Commander /nc slash commands rely on the concept of a current app. If you are just creating commands that run with /nc itself, you only have one app you are working with, the “nc” app. So, if you are just developing commands that run with the /nc prefix, your current app will always be “nc”.

If you create a custom Slack app and connect that custom Slack app to Commander with the app_add command, that app will become your “current app”. If you have multiple apps in your workspace, you can use the app_current command to verify which app is being treated as the current app or make another app the current one.

Show the current app:

User 7:41 PM
/nc app_current 

Commander App 7:41 PM

Your current app is devops

Switch to the accounting app:

User 7:41 PM
/nc app_current accounting 

Commands support a variety of parameter definitions and Commander automatically parses parameters so they can be accessed easily in your source code.

When you create a command, you specify the parameters the command takes by enclosing parameter names in angle brackets. For example, the following command_create command creates a command for your custom app that will take two parameters:

User 7:41 PM
/nc command_create add_host <hostname> <ip_addr> 

In the code for the command, you can access the command's parameters by name using params:

if (params.hostname == 'a.nimbella.com') {

But also, the default generated command source code creates local variables as a convenience:

 const {
    Hostname,
    Ip_addr
  } = params;

This means you can access the parameters by name in a function without params:

if (hostname == 'a.nimbella.com') {

When a user runs this command in Slack, they add parameter values as in the following example (assuming the command prefix for the custom app is /devops):

User 7:41 PM
/devops add_host a.com 100.200.3.4 

If you’re working on a command and discover you want to change the command's parameters, you can change them with the command_params command. For example, if you wanted to add a TTL parameter to the add_host command you created above:

User 7:41 PM
/nc command_params add_host <hostname> <ip_addr> <ttl> 

Note: If you use /nc command_params to create new parameters, the command source code is not regenerated, so to access those parameters directly by name without using params, you'll need to add them to the list of local variables in the code first.

Parameter values with white space

When a command is run in your custom app, parameter values that include white space should be enclosed in a pair of either double or single quotes. For example, if you have a print command with a <msg> parameter, the value could be:

User 7:41 PM
/devops print "This parameter has multiple words" 

This command passes the value This parameter has multiple words to the command source. If you want to pass a parameter value that includes the double quotes, use single quotes to enclose the string, such as:

User 7:41 PM
/devops print ‘“Life is what happens when you're busy making other plans.” - John Lennon’ 

Note: On Apple computers (and potentially others), double quotes appear entered as either Unicode left or right double quotes. If the string starts with a Unicode left quote, a Unicode right quote will be expected to end it.

Optional command parameter

A list of parameters can end with one optional parameter in square brackets, such as the [<ttl>] parameter in this example:

User 7:41 PM
/nc command_create add_host <hostname> <ip_addr> [<ttl>] 

This command can be run with either the first two parameters or all three, so either of these commands is valid:

User 7:41 PM
/devops add_host a.nimbella.com 1.2.3.4 

User 7:41 PM
/devops add_host a.nimbella.com 1.2.3.4 300 

Parameter options

The parameter definition for a command can also include options. Options are preceded with a hyphen (-). Options can be either be flags or named options. Here's an example that contains a flag option -detail and a named option -ttl with value ttl_value:

User 7:41 PM
/nc command_create add_host <hostname> <ip_addr> [-detail] [-ttl <ttl_value>] 

In the source code for the command, you can check to see if a flag option is present either by using the params variable:

if (params.detail) {

or by its name alone, because the default generated code creates a local variable with the name of the option:

if (detail) {

Similarly, you can check if a named option exists by its name alone and check its value using the name of the value:

if (ttl && ttl_value == 30) {

The add_host command created above with the -detail and -ttl options can be run in any of the following ways:

User 7:41 PM
/devops add_host a.com 1.2.3.4 

User 7:41 PM
/devops add_host a.com 1.2.3.4 -detail 

User 7:41 PM
/devops add_host a.com 1.2.3.4 -ttl 90 -detail 

Note:

• Options may not be used when an optional command parameter is present.
• When options are specified, they must be specified at the end of the parameter definition.

Variable number of arguments

Command parameter definitions support varargs, a variable number of arguments. A parameter definition for a command with varargs ends with the ellipsis notation (…). The following example specifies that the add_host command can take any number of parameters:

User 7:41 PM
/nc command_create add_host ... 

When varargs is used, you must code the command parameters to be parsed. In the command source code, the text of the full command, including the command prefix and all parameters, is available in commandText:

let parts = commandText.split(" ");
let cmdPrefix = parts[0];
let cmd = parts[1];

Note: If you use varargs, your parameter definition cannot include any optional command parameters or parameter options.

Slack Encodings

Slack automatically encodes certain input values. For example, if you type this command into Slack:

/nc route53_add www.example.com 1.2.3.4

Slack will see the www.example.com parameter and since it looks like a hostname, it automatically encodes www.example.com as a clickable link in the Slack interface.

Additionally, it encodes the value when sent as a parameter to the function. If a user typed the command above, the route53_add function would see this value as the first parameter:

https://www.example.com|www.example.com

instead of just www.example.com.

Slack also isn't entirely consistent when encoding values. For example, if you type a full URI such as https://www.example.com in Slack, it will encode it as just <https://www.example.com> which is the parameter the function receives.

A convenient way to extract the URI from an encoded parameter is to match the parameter string against the following regex: ^<?([^|>]*)[|\w]*>?$. This will tolerate the brackets <> that wrap the URI, and will ignore all text after | if it's present. When the string matches, the first regex group contains the decoded URI.

Slack also automatically decodes values in the above format. For example, if you output the value in the brackets above to print in Slack,

Slack will just display www.example.com and it will be a clickable link that will direct to https://www.example.com.

Make sure you’re logged into your Slack workspace before starting.

1. Go to https://api.slack.com/apps.

2. Click Create New App.

   

3. In the Create a Slack App panel, enter the following information. a. For AppName, enter DevOps. b. For Development Slack Workspace, choose your workspace.

   

4. Click Create App to close the panel and create the app. This returns you to the Basic Information page.

Assuming you’ll have a number of apps with various slash commands, it can get difficult to keep them all straight, and Slack doesn’t have a formal namespace built into their commands. We’ll create a slash command in the DevOps app that will serve as the command prefix for all the commands that we create for that app.

1. On the Basic Information page, click Slash Commands.

   

2. Click Create New Command.

   

3. On the Create New Command page, enter the following information: a. For Command, enter /devops. b. For Request URL, enter https://nimbella.com. We’ll go back and change this URL after we get the correct one for this app. c. For Short Description, enter DevOps Operations. d. Select the checkbox for Escape channels, users, and links sent to your app.

   

4. In the Preview section, check your entries. As shown in this screenshot, the preview shows the information you entered and the slash command as it will be typed into Slack.

5. Click Save.

This returns you to the Slash Commands page.

1. In the left sidebar menu, in the Settings section click Install App.

2. Click Install App to Workspace.

   

3. Accept the default permissions and click Allow. If the app is installed successfully, you’ll see a screen with the OAuth access token.

   

We’ll use the Commander app’s /nc command to add our DevOps app to Commander.

First, let’s talk about the syntax of the Nimbella Commander app_add command that’s used to add an app to Commander:

User 7:41 PM
/nc app_add <app-name> <command-prefix> 

The parameters in this command are:

• <app-name> This will be the lower-case version of our app name, in this case devops
• <command-prefix> The command prefix that we created in the last task. In this case, /devops.

To connect the DevOps app to Commander:

1. In Slack, run the following command:

   

   User 7:41 PM
   /nc app_add devops /devops 

   You should see a Commander response that looks something like this:

   

   Commander App 7:41 PM
   

   The devops app has been added. Please attach this Request URL to the /devops command in Slack: https://apigcp.nimbella.io/api/v1/web/just-an-example-1234-5678/app_000/router

2. Copy the URL that appears in the response.

3. Go to https://api.slack.com/apps.

4. In the App Name list, select the DevOps app.

   

5. Click Add features and functionality.

   

6. In the Features section in the left sidebar, click Slash Commands.

   

7. Click the Edit icon to the right of the /devops command.

   

8. Replace the Request URL with the one that you copied.

   

9. Click Save.

The/devops slash command (which will serve as the command prefix) is now connected to Commander. From now on, you’ll use Commander’s /nc slash commands to create commands for the DevOps app, as we’ll do in the next section.

Now we’re ready to create our first command in our DevOps app. We’ll use Commander right in Slack to create a print command, with a parameter that we can then use for various types of notifications in our DevOps app. We’ll use this command in our GitHub example in the Triggers section to notify us that something has changed in our GitHub repository.

1. In Slack, enter the following slash command exactly as it appears here, including the angle brackets:

   

   User 7:41 PM
   /nc command_create print <msg> 

   You’ll see a response similar to the following:

   

   Commander App 7:41 PM
   

   Created command print <msg>, edit the code

2. Click the link to edit the Commander code for the command.

3. Find this line in the source code:

   "This is a default response for a newly created command with text: " + commandText

   Change the line to this:

   text: msg

4. Click Save.

5. In Slack, test the command by entering the command prefix (devops), followed by the command (print), followed by a text string for the msg parameter

   

   User 7:41 PM
   /devops print Howdy! 

   If your print message has more than one word, surround it with single or double quotes or else you’ll get a response that a parameter was not found. You should see the Slack response shown in this screenshot, coming from your custom app and displaying the print message.

Note that we created the command with an/nc slash command, but we ran the command in in our DevOps app with our /devops command prefix.

Use the app_list command.

• List all the apps in your Slack workspace that are connected to Commander:

  

  User 7:41 PM
  /nc app_list 

If your command source code is written in JavaScript and your command requires additional npm (Node Package Manager) packages to run, you can install them in your JavaScript source code with this function, which accepts an array of npm packages to install:

async function install(pkgs) {
  pkgs = pkgs.join(' ');
  return new Promise((resolve, reject) => {
    const { exec } = require('child_process');
    exec(`npm install ${pkgs}`, (err, stdout, stderr) => {
      if (err) reject(err);
      else resolve();
    });
  });
}

The following example shows the install() function being used to install two npm packages:

let packages = [ 'read-installed', 'chalk' ];
await install(packages);

After installing the npm packages, they can be used as they normally would with require(). This example shows the read-installed package being used:

var readInstalled = require('read-installed');
readInstalled("/", { depth: 0, dev: true }, function(err, map) { … })

Note: The installation of npm packages takes a little time, so commands that install packages will start up slower than those that do not.

To speed up subsequent runs of a command function that installs packages, the package references returned from the require() statement can be moved into global variables in the command source code and the packages are only loaded if those values are undefined. This method will cause the packages to be installed the first time the command is executed. Note that they do not need to be installed if the same execution environment is used again by the underling serverless platform. When serverless function environments are reused in a serverless platform, the globals can maintain their previous values.

For example, if the readInstalled variable above was global, the code could look like this:

var readInstalled;
function _command(...) {
  if (!readInstalled) {
    let packages = [ 'read-installed', 'chalk' ];
    await install(packages);
    readInstalled = require('read-installed');
  }
}

The first time the code is executed, readInstalled is undefined and the packages loaded. If the environment is reused later by the underlying serverless platform, the readInstalled value can be used without installing the packages.

For examples of assigning these user roles, see Commands to manage users and user groups.

Admin

In Commander, every custom Slack app starts with one administrative user: the Slack user who initially adds the custom app to Commander. It’s up to that admin to assign other Slack users as admins for that app. Admins in turn can assign users as coders for specific commands in the app and as runners of specific commands in the app.

Admins can also create user groups to make it easier to set coder and runner roles for multiple users. See the command examples below.

Admins have no restrictions on what they can do when it comes to an app. Only admin users can create commands, assign roles to other users, and perform other administrative tasks. Admins can do anything that coders and runners can do.

Coder

The coder role is associated with specific commands. A Slack user with a coder role for a command is allowed to edit the source code for the command and also run the command. App admins manage the list of coders for commands. Coders are automatically runners for the commands they can edit.

Runner

The runner role is associated with specific commands ii the custom app. A Slack user with a runner role for a command is allowed to run that command. They cannot run commands in the Commander app.

Instead of assigning Coder and Runner roles to individual users, admins can combine users into user groups to make it easier to set coder and runner roles for multiple users. The entire user group can then be added or removed as coders or runners for a command.

Manage admin users

Use the app_admins command to list, add, or remove Slack users as admins for the current app. A plus (+) in front of a user name adds the user to the list and a minus (-) removes a user from the list.

Note: There must be a space between the plus (+) and minus (-) signs and the user to be added or removed as admins for the current app.

• List the users who are admins for the current app:
  

  User 7:41 PM
  /nc app_admins 

  

  Commander App 7:41 PM
  

  devops admins: Sam, Jill

• Add Bill and Mary and remove Larry as admins for the current app:
  

  User 7:41 PM
  /nc app_admins + @Bill + @Mary - @Larry 

Manage coder users

Use command_coders to list, add, or remove users as coders for particular commands.

• View the current list of coders for the add_host command:
  

  User 7:41 PM
  /nc command_coders add_host 
• Add Jim and Bob and remove John as coders for the print command:
  

  User 7:41 PM
  /nc command_coders print + @Jim + @Bob - @John 

Manage users who run commands

Use command_runners to list, add, or remove users as runners for particular custom commands.

• Add Joe and Sue and remove John as runners for the print command:
  

  User 7:41 PM
  /nc command_runners print + @Joe + @Sue - @John 

Allow anyone to run a custom command

There is a special user group that always exists called anyone, which includes every Slack user. If you want to allow a command to be run by anyone, you can add the anyone group to the list of command runners:

• Let anyone run the print command:
  

  User 7:41 PM
  /nc command_runners print + anyone 

Create user groups

Use group_create to create a user group.

• Create a user group called devgroup1:
  

  User 7:41 PM
  /nc group_create devgroup1 

List, add, or remove members of a user group

Use the group_members command.

• Add Sue to devgroup1:
  

  User 7:41 PM
  /nc group_members devgroup1 + @Sue 
• Add Jim, Bob, and John and remove Sue from devgroup1:
  

  User 7:41 PM
  /nc group_members devgroup1 + @Jim + @Bob + John - @Sue 
• List the members of devgroup1:
  

  User 7:41 PM
  /nc group_members devgroup1 

  

  Commander App 7:41 PM
  

  devgroup1 members: Jim, Bob, John

List all user groups

Use the group_list command.

• List all user groups for the current app.
  

  User 7:41 PM
  /nc group_list 

  

  Commander App 7:41 PM
  

  devgroup1

Delete a user group

Use the group_delete command to delete a user group. Only the named group of users is deleted, the command does not affect the Slack users themselves in any way.

• Delete the user group devgroup1:
  

  User 7:41 PM
  /nc group_delete devgroup1 

Add a user group to a command

We gave examples of using command_coders and command_runners to add users as coders and runners respectively. Here are two examples of adding a user group instead.

• Add the user group devgroup1 as coders for the print command:

  

  User 7:41 PM
  /nc command_coders print + devgroup1 

• Add the user group bookkeeping as runners for the bills command:

  

  User 7:41 PM
  /nc command_runners bills + bookkeeping 

Use the secret_list command.

• List this user’s secret key-value pairs and all global secret key-value pairs:

  

  User 7:41 PM
  /nc secret_list 

  The output is a list of keys with their encrypted values. Only the beginning and end of the encrypted values are shown for each secret because the encrypted values can get rather long.

Use the secret_delete command in Slack with the name of the secret key.

• Delete the secret key-value pair named gc_key:

  

  User 7:41 PM
  /nc secret_delete gc_key 

Once added to your app, decrypted secret values can be accessed in source code using the secrets input parameter.

• Example code that accesses a secret value with the key mySecretApiKey:

  async function my_command(params, text, secrets = {}) {
    if (!secrets.mySecretApiKey) {
      return { text: "you need a mySecretApiKey secret to run this command" };
    }
    .. connect to API using secrets.mySecretApiKey ..
  }

• Look in the command source code under the secrets input parameter. For example:

  awsConnection = createAwsConnection(secrets.awsKey);
  gwpConnection = createGwpConnection(secrets.gwpKey);
  …

In Commander, a channel is associated with an incoming webhook that can post into that channel. To allow your app to post in a channel, you must first create an incoming webhook for that channel in a custom Slack app, then add it to Commander using the channel_add command. You can use this command with a public, private or locked channel. When you add a channel, a message is posted into that channel to let you know the channel was added to Commander.

Here’s how to create a channel and add it to Commander. In this example, let’s add a channel called #devops-output to the custom DevOps app that was created in the Quickstart Guide.

To create a channel in your custom Slack app:

1. If you want to use a channel other than one that already exists in Slack, create it. In this example, we created a #devops-output channel.
2. Go to https://api.slack.com/apps.
3. Select the DevOps app.
4. Click Add features and functionality.
5. Click Incoming Webhooks.
6. Enable Incoming Webhooks.
7. Click Add New Webhook to Workspace.
8. Select the channel you want the task to output to and click Allow.
9. Click Copy for the webhook URL you just created.
10. In Slack, run the following command, substituting the values for channel name and webhook URL:

User 7:41 PM
/nc channel_add #devops-output <webhook URL> 

Replace <webhook URL> by pasting in the webhook URL that you copied in the previous step.

Example:

User 7:41 PM
/nc channel_add #devops-output https://hooks.slack.com/services/BAHCHA1928/BGHA018481/6jaKjsAHhADKJAd 

Note: After you add the channel, you need to set the channel for your task or trigger. See the Tasks and Triggers sections for example commands.

Use the channel_list command.

• To list all channels added to the current app:
  

  User 7:41 PM
  /nc channel_list 

Use the channel_delete command with the channel name as a parameter.

• Delete the #devops-output channel from Commander:
  

  User 7:41 PM
  /nc channel_delete #devops-output 

Note: This command does not delete the channel's incoming webhook from Slack. To delete the channel's incoming webhook, delete it from Slack using api.slack.com.

Use the task_create command with parameters for the task name, output channel, and the command to run.

Create a task called mytask, output to the #general channel, and run the print command with the parameter “Hello World”:

User 7:41 PM
/nc task_create mytask #general print "Hello World" 

Use task_rate. The command includes the optional parameters <value> and <unit> to set the rate, where <value> is a number and <unit> is one of: minute, minutes, hour, hours, day or days.

Notes: After you set the rate, use task_start to start the task. If a task is running, it must be stopped with task_stop before the rate can be changed.

• View the task rate for mytask:
  

  User 7:41 PM
  /nc task_rate mytask 
• Set the task rate for mytask to 15 minutes:
  

  User 7:41 PM
  /nc task_rate mytask 15 minutes 
• Set the task rate for mytask to one day:
  

  User 7:41 PM
  /nc task_rate mytask 1 day 

Use task_start. You can also restart a task with this command after using task_stop.

• Start mytask:

  

  User 7:41 PM
  /nc task_start mytask 

Use task_stop. Stopping a task doesn't delete it or change it, it just stops the task from running. You can view or set the schedule or rate of a task with the task_rate and task_interval commands. A task must be stopped to change its schedule or rate.

• Stop mytask:

  

  User 7:41 PM
  /nc task_stop mytask 

Use task_list to output a list of all tasks in the current app and their states.

• To list all tasks and their states:

  

  User 7:41 PM
  /nc task_list 

Use task_info to show the following information about the task:

• Name
• Creator
• Schedule or rate
• Status (stopped or running).
• If the task was started or stopped, the time it started running or when it was stopped is shown.

This information appears in the command output.

• Show the task information for mytask:

  

  User 7:41 PM
  /nc task_info 

Use task_channel to view or set the channel associated with a task.

• View the channel used for mytask:

  

  User 7:41 PM
  /nc task_channel mytask 

If you’re setting or changing the task channel, be sure that the channel has been created in your Slack app and added to Commander.

• Set or change the task output channel for mytask to #general:

  

  User 7:41 PM
  /nc task_channel mytask #general 

Use task_delete to delete a specific task.

• Delete mytask:

  

  User 7:41 PM
  /nc task_delete mytask 

As an example, you might want to set up a webhook for Github push events where a Github push (a transfer of commits to a repository) causes a command to be run to notify users in a Slack channel that a push took place. Here’s the sequence of tasks to set this up, with detailed instructions following:

1. Choose which Slack output channel you want to use (add a channel to Commander if you haven’t already) and which command to trigger. In this case, we’ll use the existing #general channel and the print command that was in the Quickstart Guide tutorial
2. Create a trigger with an output channel and output message, using trigger_create. This command outputs an incoming URL in the Nimbella Cloud.
3. Use this incoming URL to create an external webhook in GitHub that notifies the incoming URL each time there’s a push in the repository.

Github has documentation about their webhooks on developer.github.com, but here are basic instructions:

To set up a trigger for a GitHub webhook to print Slack notifications when there’s a repository push:

1. In Slack, create a trigger called GHpushTrigger that writes the output from the print command to the #general channel:

   

   User 7:41 PM
   /nc trigger_create GHpushTrigger #general print “Hey there’s been a push in your GitHub repo!” 

   

   Commander App 7:41 PM
   

   created trigger printTrigger with incoming URL https://agigcp.nimbella.com/AHC901230/nc/v1

2. Copy the incoming URL in the response.

3. In GitHub, choose your repository.
4. Click the Settings tab.
5. Click Webhooks in the left sidebar.
6. Click Add Webhook.
7. In the Payload URL field, paste the incoming URL of the trigger you created.
8. Select application/json as the Content type.
9. Select Just the push event.
10. Make sure the Active checkbox is selected and click Save webhook.

Now any Github push event in the GitHub repository will cause the print command to be run and the output sent to the #general channel.

Access GitHub event information

When Github sends an event using a webhook, it puts information about the event in an "X-Github-Event" HTTP header. The params.__trigger variable in your command has all the HTTP headers and parameters of the incoming request, so you can access the Github event information with params.__trigger.X-Github-Event:

JSON.stringify(params.__trigger.X-Github-Event, null, 2)

Disable a trigger

Use trigger_disable. Disabling a trigger doesn't delete it or change it, it just stops the task from running the command.

• Disable the GHpushTrigger trigger:
  

  User 7:41 PM
  /nc trigger_disable GHpushTrigger 

Re-enable a trigger

The trigger_create command automatically enables the trigger, but if you run the trigger_disable command, you can re-enable the disabled trigger using trigger_enable.

• Re-enable GHpushTrigger:
  

  User 7:41 PM
  /nc trigger_enable GHpushTrigger 

Info about a trigger

The trigger_info command shows information about a trigger.

List all triggers

Use the trigger_list command to get a list of all the triggers in the current app.

• List all triggers in the current app:
  

  User 7:41 PM
  /nc trigger_list 

View/set the channel associated with a trigger:

Use trigger_channel.

• View the channel associated with GHpushTrigger:
  

  User 7:41 PM
  /nc trigger_channel GHpushTrigger 
• Set the channel associated with GHpushTrigger:
  

  User 7:41 PM
  /nc trigger_channel GHpushTrigger #general 

Delete a trigger

Use the trigger_delete command.

Note: If you delete a trigger, you should first delete the external webhook that is calling it so you don't end up with a webhook that continues to call an endpoint that doesn't exist.

• Delete the GHpushTrigger trigger:
  

  User 7:41 PM
  /nc trigger_delete GHpushTrigger 

Nimbella maintains links to commonly used command sets that can be installed using single-word names. For example, there is a billing command set that contains billing commands for common cloud services, such as Amazon Web Services. See the Example command sets section for a list of the example command sets available.

Note: Many of the commands in the billing command set require API keys to allow the command source to obtain billing information from the various cloud providers. For example, to use the awsbill command, you must create secrets for awsCostExplorerAccessKeyId, awsCostExplorerSecretAccessKeyId, and awsCostExplorerRegion. See the Secrets section for how to access information and API keys that need to be added to run the commands that require them. The various commands will output what API keys are required when they are run and what secrets are missing that they need.

Install a command set

• Install the billing command set in the current app, along with the source for the commands:

  

  User 7:41 PM
  /nc csm_install billing 

Output: List of commands installed.

Use csm_commands at any time to see the list of commands that were installed in this command set:

• List the commands installed with the billing command set:

  

  User 7:41 PM
  /nc csm_commands billing 

Customize and edit the source code of any of the installed commands using command_code to get a link to edit the command's source code.

• Retrieve a link to the awsbill command’s source code:

  

  User 7:41 PM
  /nc command_code awsbill 

The Github repository has a commands.yaml file in its root directory that contains the OpenCSI YAML definition of the command set. You can publish your own command set for others to use by putting a commands.yaml file for the command set into a GitHub repository. The commands.yaml file contains the definition of each command along with links to the source code for each command.

Anyone Installing this command set from Github would use the following command:

User 7:41 PM
/nc csm_install github:<name>/<project> 

A third way to install a command set from an external location is by specifying the full URL of the command set YAML definition.

• Install a command set YAML from the URL https://a.b.com/commands.yaml:

  

  User 7:41 PM
  /nc csm_install https://a.b.com/commands.yaml 

Update an externally loaded command set

If an externally loaded command set is updated, you can update the source for all the commands from the source location with csm_update.

• Update the billing command set:

  

  User 7:41 PM
  /nc csm_update billing 

Notes:

• Any changes you made to the source code of the commands in the set are overwritten by running csm_update.
• Github runs a caching service in front of the Github web site, so if a command set is updated on Github an update may not immediately reflect the changes to the command set.

List all the command sets and commands in each command set

The csm_list command outputs all the command sets in the current app and also all the commands in each command set. There are no parameters.

• List all command sets and all commands in each set in the current app:

  

  User 7:41 PM
  /nc csm_list 

  

  Commander App 7:41 PM
  

  billing: awsbill, datadogbill

  The output shows there is one command set (billing) with two commands: awsbill and datadogbill

List the commands in a specified command set

Use csm_commands to see the list of commands included in one command set:

• List the commands installed with the billing command set:

  

  User 7:41 PM
  /nc csm_commands billing 

Show information about a command set

The csm_info command provides the following information for a specified command set that was loaded with csm_install:

• Name of the command set
• URL location
• Version number
• Description of the command set

Note: This command doesn’t work with command sets created with csm_create.

Uninstall a command set

Use csm_uninstall to uninstall a command set.

Note: This command also deletes all the source code for the commands in the set, even if the source has been modified. To prevent this, delete the command set instead.

• Uninstall the billing command set:

  

  User 7:41 PM
  /nc csm_uninstall billing 

Delete a command set

Use csm_delete to delete a named command set. Only the command set is deleted – the commands in the set are unaffected by this command. If you want to delete the commands as well, use the csm_uninstall command instead.

• Delete the billing command set from the current app:

  

  User 7:41 PM
  /nc csm_delete myset 

First, create a command set, then add and remove commands in a second step.

Create a command set

Use the csm_create command to create an internal command set.

• Create a command set called myset:

  

  User 7:41 PM
  /nc csm_create myset 

Add and remove commands

Use csm_commands to add and remove commands from a command set. Use plus signs to add and minus signs to remove. Leave a space after the plus or minus sign.

• Add the commands mycommand1 and mycommand2 to the myset command set:

  

  User 7:41 PM
  /nc csm_commands myset + mycommand1 + mycommand2 

The csm_commands command without the optional parameters lists the commands included in this command set.

Export an OpenCSI definition of your internal command set

The csm_export command outputs an OpenCSI definition for a command set. You can copy that definition to an external location, such as into a commands.yaml file in a Github repository, then put in references to the source code for the commands.

• Output an OpenCSI definition for the myset command set:

  

  User 7:41 PM
  /nc csm_export myset 

A large number of pre-built command sets are available. All command sets include source code.

The list of command sets that can be installed with single word names is available here:

https://github.com/nimbella/command-sets

See Example 1 for how to install and view the commands in the billing command set.

When you add an app to Commander, an account is automatically created for you and tied to your Slack workspace. All apps added to the same Slack workspace share the same account.

Accounts have plan information (paid/unpaid) and various limits associated with them.

• To view the account information associated with your Slack workspace, including the plan and limits, use account_info.
• If you want to increase your account limits and upgrade your plan, use the account_upgrade command to start the upgrade process for your Slack workspace. This command outputs a web link that will take you to a web page showing your upgrade options and various plan costs.