The command line interface makes it easier to create, run, and deploy new apps.
During the current alpha testing phase, the command is slack, however you should expect this to change at some point.
The binaries for the CLI are available from the downloads page, with builds for both macOS, Windows, and Linux.
Deno required
Deno is currently a pre-requisite for using the CLI — if you do not have Deno installed, please do so first.
slack binary to a destination in your path (we recommend /usr/local/bin). For Windows, copy the .exe file into any location accessible in your path.slack version and verifying the version matches the one you downloaded.Before you can create an app, you must authenticate.
slack login — this will display some instructional text and a string to copy and paste in any channel in the test workspace. /hermesauthticket ABC123DEF...XYZ
/, and paste it into any channel in any workspace enabled for the beta. You are essentially calling a special slash command that will authenticate your app with Slack.slack auth info for information about your current auth sessionOnce a day, the CLI will check for updates after running any command. When an update is available, a notification will be displayed with a link where you can find and download the new version.
Update notifications can be disabled using a command-line flag or an environment variable. When running any command, you can append the --skip-update or -s flag. Alternatively, you can set the SLACK_SKIP_UPDATE environment variable and assign it any value.
$ slack help [command-name]
Provides help for the CLI as well as any command and sub-command name, for example:
$ slack help create
Additionally, the -h or --help flag can be used with any command and subcommand, e.g.:
$ slack workspace list --help
$ slack var add -h
$ slack app create [app-name] [flags]
$ slack create [app-name] [flags]
-t, --template string Template URL for your appCreates and initializes a new Slack app on your local machine from an optional template.
The command begins by creating the local app in a directory called slack_project ). If the directory happens to already exist, then it will try slack.yaml file will be updated use
After creating your local app, the command will now create the app manifest configuration. When it's complete, you'll see your app on https://api.slack.com/apps.
At this point, you have everything you need to start coding and deploying your app to Slack Cloud!
You can create an app from a template using the --template flag. This command supports many sources:
https:// Git repository:
https://github.com:slackapi/bolt-js-getting-started-appgit@ repository:
git@github.com:slackapi/bolt-js-getting-started-app.gitgit:// repository:
git://github.com/slackapi/bolt-js-getting-started-appssh:// Git repository:
ssh://username@host.xz/path/to/repo.git/slackapi/bolt-js-getting-started-app../path/to/bolt-js-getting-started-appWhen an app is created from a template, the slack.yaml and environments.yaml files will be created when missing.
$ slack auth login [flags]
$ slack login [flags]
--auth string An existing user token (e.g. xoxp-abc123...)loginLogin to a new workspace, or a previously authed workspace that has become inactive. Logging in is required before an app can be installed to a workspace or deployed to Slack's infrastructure.
A single developer can auth with multiple workspaces and authing with a new workspace does not invalidate any existing authentications. The auth list command will return a list of workspaces you are authed to.
If you are logged into multiple workspaces, running slack login will let you interactively choose a different workspace to make active. The active workspace determines where the app gets installed, deployed, run, etc.
$ slack auth info [flags]
$ slack info [flags]
infoView information about your current active authorization. Includes who owns the app and which workspace the app is installed to.
$ slack auth logout [flags]
$ slack logout [flags]
logoutInvalidate the session with a Slack workspace and delete your credentials.
$ slack cloud activity [flags]
$ slack activity [flags]
$ slack log [flags]
$ slack logs [flags]
--idle int time, in minutes, to continue without results before exiting (default: 5)-i, --interval int polling interval, in seconds (default: 3)-t, --tail continuously poll for new activityactivityloglogsGet app activity and log information for the hosted app. Anything that is logged via console.log() in an app's code will be shown here as well, which can be helpful for debugging. Use the -t or --tail flag to continuously poll for new activity while the app is running.
$ slack cloud deploy [flags]
$ slack deploy [flags]
Deploys the app to Slack-hosted infrastructure. Your app will be listed on the developer UI but you will only be able to manage it via the slack cli tool. You can also run this command to sync any changes you've made to your code to the installed version of the app.
$ slack cloud run [flags]
$ slack run [flags]
rundevstart-devDevelop locally without needing to deploy to Slack-hosted infrastructure. The cloud run command will automatically create a secure connection between your local machine and your Slack workspace (using Socket Mode) so that you can develop and test you application quickly and easily.
Changes made to your app will be automatically reflected live in your workspace when you save with no interventions required. Once you are happy with the state of your app, you can deploy using cloud deploy
$ slack tables put <row details> [flags]
The tables command interacts with the Tables API via the command line. The put subcommand adds a single row to an existing table, using the standard format for putting a new row, with the addition of the ID of the app. The app ID is required because the command could be run from anywhere, not just in the context of a particular app, or as part of an automation.
The JSON following the command should be enclosed in single quotes (').
$ slack tables put '{"table": "todos", "app": "A0123A45BCD", "row": {"id": "42", "description": "Create a PR", "status": "Done"}}'
$ slack tables query <query details> [flags]
The tables command interacts with the Tables API via the command line. The query subcommand queries a given table using the query expression syntax. The query command takes a full JSON expression, with the addition of the ID of the app. The app ID is required because the command could be run from anywhere, not just in the context of a particular app, or as part of an external automation.
$ slack tables query '{"table": "tasks", "app": "A0123A45BCD", "expression": "#status = :status", "expression_columns": {"#status": "status"}, "expression_values": {":status": "In Progress"}}'
It's also possible to omit the expression fields, which will return all the rows for a table.
$ slack tables query '{"table": "tasks", "app": "A0123A45BCD"}'
$ slack tables get <row details> [flags]
The tables command interacts with the Tables API via the command line. The get subcommand returns a single row given a table name and the ID of a row. The app ID is required because the command could be run from anywhere, not just in the context of a particular app, or as part of an automation.
$ slack tables get '{"table": "tasks", "app": "A0123A45BCD", "id": "3"}'
$ slack tables delete <row details> [flags]
The tables command interacts with the Tables API via the command line. The delete subcommand will remove a row by ID.
$ slack tables delete '{"table": "tasks", "app": "A0123A45BCD", "id": "3"}'
$ slack var add <variable name> <variable value> [flags]
Environment variables allow for persistent data storage for your application's runtime and behave similarly to the way standard Unix environment variables work. They are useful for storing configuration data for your app, such as an access token to another API, that you don't want to hard code into your app for security reasons or that you may need to update without wanting to re-deploy the application. The environment variable will be available locally
Environment variables are accessible in your application's code via the env object made available by the TypeScript SDK. For example, an environment variable named FOO would be accessed via:
${env["FOO"]}
Running var add command with a variable that already exists and a new value will set the variable to the new value.
$ slack var list [flags]
Shows a list of all variables set. The values are obscured for security.
$ slack var remove <variable name> [flags]
Removes a variable from usage. Any calls to the removed variable in code will almost certainly generate an error.
$ slack workspace install [flags]
Install the app to a workspace. You will have the option to install to a workspace that you have already authenticated into or have the option to auth into a new workspace.
This is the equivalent of installing an app to a workspace via the traditional app console or using the OAuth flow.
The first time the run or deploy commands are run, the app will be installed if it isn't already. You may need to call install again if you request new OAuth scopes for your application.
$ slack workspace list [flags]
List all of the workspaces where an app is installed.
$ slack environment remove <env> [flags]
Remove an app from a workspace and deletes the app's manifest.
$ slack doctor [flags]
Checks to make sure your local development environment has all the required prerequisites and system requirements for running and deploying an app.
$ slack version
Print the current version of the CLI.
$ slack --apihost string
Slack API host (default https://slack.com)
$ slack -e, --environment string
Specify the app environment
$ slack -f, --force
Force update app manifest
$ slack -h, --help
Help for slack commands. Use this flag with any command (e.g. slack create --help) to get more information about a specific command
$ slack -v, --verbose
When set, prints verbose debug logging
$ slack -s, --skip-update
Use to disable version update notifications.
In addition to being useful for setting up new projects and local development, the CLI can be integrated into test and deployment pipelines, for continuous integration and continuous deployment and other "headless" automation.
Running in a headless mode first requires authenticating using the --auth flag and passing along a user token. This will generate the authentication credentials required in a ~/.slack directory. Removing this directory will remove the authentication.
Once authenticated, any slack command can be run as normal and will use the established auth.
To make development easier, the CLI includes an integrated SDK. The most common use of the SDK will be the client object, which works similarly to the the way it does in Bolt for JavaScript. The client object can be used to call any Slack API method, like so:
const client = new SlackAPIClient("");
try{
client.call("conversations.list");
} catch (ex) { console.log("error: ", ex)};
The SDK is written in TypeScript with defined types, allows for features like code completion in supported IDEs. If you are using VS Code, new projects already include a .vscode folder with all of the type definitions needed to activate IntelliSense.
The SDK can also be versioned via the import_map.json file in the root of a project directory. This allows you to specify which version of the SDK you prefer to use by pointing to a versioned URL.
The latest version of the SDK will always point to https://slack.com/cloud/static/common/sdk/. Specific versions can be specified like so: https://slack.com/cloud/static/common/sdk@0.1.0/
These commands are deprecated and will no longer be supported. Please migrate to the updated commands.
$ slack new
Please use slack create instead.