---
title: "SlackCLI"
summary: "@slack/cli-test / SlackCLI"
url: "https://docs.slack.dev/tools/node-slack-sdk/reference/cli-test/variables/SlackCLI"
type: "guide"
---

Source: https://docs.slack.dev/tools/node-slack-sdk/reference/cli-test/variables/SlackCLI

[@slack/cli-test](https://docs.slack.dev/tools/node-slack-sdk/reference/cli-test.md) / SlackCLI

# Variable: SlackCLI

```
const SlackCLI: object;
```

Defined in: [cli/index.ts:22](https://github.com/slackapi/node-slack-sdk/blob/main/packages/cli-test/src/cli/index.ts#L22)

Set of functions to spawn and interact with Slack Platform CLI processes and commands

## Type Declaration {#type-declaration}

### app {#app}

```
app: object;
```

#### app.delete {#appdelete}

```
delete: (args) => Promise<string> = del;
```

`slack app delete`

##### Parameters {#parameters}

###### args {#args}

`ProjectCommandArguments`

##### Returns {#returns}

`Promise`<`string`\>

command output

#### app.install {#appinstall}

```
install: (args) => Promise<string>;
```

`slack app install`

##### Parameters {#parameters-1}

###### args {#args-1}

`ProjectCommandArguments`

##### Returns {#returns-1}

`Promise`<`string`\>

command output

#### app.list {#applist}

```
list: (args) => Promise<string>;
```

`slack app list`

##### Parameters {#parameters-2}

###### args {#args-2}

`ProjectCommandArguments`

##### Returns {#returns-2}

`Promise`<`string`\>

command output

### auth {#auth}

```
auth: object;
```

#### auth.loginChallengeExchange {#authloginchallengeexchange}

```
loginChallengeExchange: (args) => Promise<string>;
```

`slack login --no-prompt --challenge --ticket`

##### Parameters {#parameters-3}

###### args {#args-3}

`AuthLoginChallengeExchangeArugments`

##### Returns {#returns-3}

`Promise`<`string`\>

#### auth.loginNoPrompt {#authloginnoprompt}

```
loginNoPrompt: (args?) => Promise<{  authTicket: string;  authTicketSlashCommand: string;  output: string;}>;
```

`slack login --no-prompt`; initiates a CLI login flow. The `authTicketSlashCommand` returned should be entered into the Slack client, and the challenge code retrieved and fed into the `loginChallengeExchange` method to complete the CLI login flow.

##### Parameters {#parameters-4}

###### args? {#args-4}

`AuthLoginNoPromptArguments`

##### Returns {#returns-4}

`Promise`<{ `authTicket`: `string`; `authTicketSlashCommand`: `string`; `output`: `string`; }>

#### auth.logout {#authlogout}

```
logout: (args?) => Promise<string>;
```

`slack logout`

##### Parameters {#parameters-5}

###### args? {#args-5}

Omit<SlackCLIGlobalOptions, "team"> & (Pick<SlackCLIGlobalOptions, "team"> | { all?: boolean | undefined; })

##### Returns {#returns-5}

`Promise`<`string`\>

command output

### collaborator {#collaborator}

```
collaborator: object;
```

#### collaborator.add {#collaboratoradd}

```
add: (args) => Promise<string>;
```

`slack collaborators add`

##### Parameters {#parameters-6}

###### args {#args-6}

`ProjectCommandArguments` & `CollaboratorEmail`

##### Returns {#returns-6}

`Promise`<`string`\>

command output

#### collaborator.list {#collaboratorlist}

```
list: (args) => Promise<string>;
```

`slack collaborators list`

##### Parameters {#parameters-7}

###### args {#args-7}

`ProjectCommandArguments`

##### Returns {#returns-7}

`Promise`<`string`\>

command output

#### collaborator.remove {#collaboratorremove}

```
remove: (args) => Promise<string>;
```

`slack collaborators remove`

##### Parameters {#parameters-8}

###### args {#args-8}

`ProjectCommandArguments` & `CollaboratorEmail`

##### Returns {#returns-8}

`Promise`<`string`\>

command output

### datastore {#datastore}

```
datastore: object;
```

#### datastore.datastoreDelete {#datastoredatastoredelete}

```
datastoreDelete: (args) => Promise<string>;
```

`slack datastore delete`

##### Parameters {#parameters-9}

###### args {#args-9}

`ProjectCommandArguments` & `Pick`<`DatastoreCommandArguments`, `"datastoreName"` | `"primaryKeyValue"`\>

##### Returns {#returns-9}

`Promise`<`string`\>

command output

#### datastore.datastoreGet {#datastoredatastoreget}

```
datastoreGet: (args) => Promise<string>;
```

`slack datastore get`

##### Parameters {#parameters-10}

###### args {#args-10}

`ProjectCommandArguments` & `Pick`<`DatastoreCommandArguments`, `"datastoreName"` | `"primaryKeyValue"`\>

##### Returns {#returns-10}

`Promise`<`string`\>

command output

#### datastore.datastorePut {#datastoredatastoreput}

```
datastorePut: (args) => Promise<string>;
```

`slack datastore put`

##### Parameters {#parameters-11}

###### args {#args-11}

`ProjectCommandArguments` & `Pick`<`DatastoreCommandArguments`, `"datastoreName"` | `"putItem"`\>

##### Returns {#returns-11}

`Promise`<`string`\>

command output

#### datastore.datastoreQuery {#datastoredatastorequery}

```
datastoreQuery: (args) => Promise<string>;
```

`slack datastore query`

##### Parameters {#parameters-12}

###### args {#args-12}

`ProjectCommandArguments` & `Pick`<`DatastoreCommandArguments`, `"datastoreName"` | `"queryExpression"` | `"queryExpressionValues"`\>

##### Returns {#returns-12}

`Promise`<`string`\>

command output

### env {#env}

```
env: object;
```

#### env.list {#envlist}

```
list: (args) => Promise<string>;
```

`slack env list`

##### Parameters {#parameters-13}

###### args {#args-13}

`ProjectCommandArguments`

##### Returns {#returns-13}

`Promise`<`string`\>

command output

#### env.set {#envset}

```
set: (args) => Promise<string>;
```

`slack env set`

##### Parameters {#parameters-14}

###### args {#args-14}

`ProjectCommandArguments` & `EnvCommandArguments`

##### Returns {#returns-14}

`Promise`<`string`\>

command output

#### env.unset {#envunset}

```
unset: (args) => Promise<string>;
```

`slack env unset`

##### Parameters {#parameters-15}

###### args {#args-15}

`ProjectCommandArguments` & `Pick`<`EnvCommandArguments`, `"secretKey"`\>

##### Returns {#returns-15}

`Promise`<`string`\>

command output

### externalAuth {#externalauth}

```
externalAuth: object;
```

#### externalAuth.add {#externalauthadd}

```
add: (args) => Promise<string>;
```

`slack external-auth add`

##### Parameters {#parameters-16}

###### args {#args-16}

`ProjectCommandArguments` & `Pick`<`ExternalAuthCommandArguments`, `"provider"`\>

##### Returns {#returns-16}

`Promise`<`string`\>

command output

#### externalAuth.addSecret {#externalauthaddsecret}

```
addSecret: (args) => Promise<string>;
```

`slack external-auth add-secret`

##### Parameters {#parameters-17}

###### args {#args-17}

`ProjectCommandArguments` & `Omit`<`ExternalAuthCommandArguments`, `"all"`\>

##### Returns {#returns-17}

`Promise`<`string`\>

command output

#### externalAuth.remove {#externalauthremove}

```
remove: (args) => Promise<string>;
```

`slack external-auth remove`

##### Parameters {#parameters-18}

###### args {#args-18}

`ProjectCommandArguments` & `Omit`<`ExternalAuthCommandArguments`, `"secret"`\>

##### Returns {#returns-18}

`Promise`<`string`\>

command output

#### externalAuth.selectAuth {#externalauthselectauth}

```
selectAuth: (args) => Promise<string>;
```

`slack external-auth select-auth`

##### Parameters {#parameters-19}

###### args {#args-19}

`ProjectCommandArguments` & `Pick`<`ExternalAuthCommandArguments`, `"provider"`\> & `object`

##### Returns {#returns-19}

`Promise`<`string`\>

command output

### function {#function}

```
function: object = func;
```

#### function.access {#functionaccess}

```
access: (args) => Promise<string>;
```

`slack function access`

##### Parameters {#parameters-20}

###### args {#args-20}

`ProjectCommandArguments` & `FunctionAccessArguments`

##### Returns {#returns-20}

`Promise`<`string`\>

command output

### manifest {#manifest}

```
manifest: object;
```

#### manifest.info {#manifestinfo}

```
info: (args) => Promise<string>;
```

`slack manifest info`

##### Parameters {#parameters-21}

###### args {#args-21}

`ProjectCommandArguments` & `object`

##### Returns {#returns-21}

`Promise`<`string`\>

command output

#### manifest.validate {#manifestvalidate}

```
validate: (args) => Promise<string>;
```

`slack manifest validate`

##### Parameters {#parameters-22}

###### args {#args-22}

`ProjectCommandArguments`

##### Returns {#returns-22}

`Promise`<`string`\>

command output

### platform {#platform}

```
platform: object;
```

#### platform.activity {#platformactivity}

```
activity: (args) => Promise<string>;
```

`slack platform activity`

##### Parameters {#parameters-23}

###### args {#args-23}

`ProjectCommandArguments` & `object`

##### Returns {#returns-23}

`Promise`<`string`\>

command output

#### platform.activityTailStart {#platformactivitytailstart}

```
activityTailStart: (args) => Promise<ShellProcess>;
```

`slack platform activity` but waits for a specified sequence then returns the shell At the specific point where the sequence is found to continue with test

##### Parameters {#parameters-24}

###### args {#args-24}

`ProjectCommandArguments` & `StringWaitArgument` & `TimeoutArgument`

##### Returns {#returns-24}

`Promise`<`ShellProcess`\>

command output

#### platform.activityTailStop {#platformactivitytailstop}

```
activityTailStop: (args) => Promise<string>;
```

Waits for a specified string in the provided `activityTailStart` process output, kills the process then returns the output

##### Parameters {#parameters-25}

###### args {#args-25}

`StringWaitArgument` & `ProcessArgument` & `TimeoutArgument`

##### Returns {#returns-25}

`Promise`<`string`\>

command output

#### platform.deploy {#platformdeploy}

```
deploy: (args) => Promise<string>;
```

`slack deploy`

##### Parameters {#parameters-26}

###### args {#args-26}

`ProjectCommandArguments` & `Omit`<`RunDeployArguments`, `"cleanup"`\>

##### Returns {#returns-26}

`Promise`<`string`\>

command output

#### platform.runStart {#platformrunstart}

```
runStart: (args) => Promise<ShellProcess>;
```

start `slack run`. `runStop` must be used to stop the `run` process returned by this method.

##### Parameters {#parameters-27}

###### args {#args-27}

`ProjectCommandArguments` & `RunDeployArguments` & `TimeoutArgument`

##### Returns {#returns-27}

`Promise`<`ShellProcess`\>

shell object to kill it explicitly in the test case via `runStop`

#### platform.runStop {#platformrunstop}

```
runStop: (args) => Promise<void>;
```

stop `slack run`

##### Parameters {#parameters-28}

###### args {#args-28}

`ProcessArgument` & `TimeoutArgument` & `object`

##### Returns {#returns-28}

`Promise`<`void`\>

### project {#project}

```
project: object;
```

#### project.create {#projectcreate}

```
create: (args) => Promise<string>;
```

`slack create`

##### Parameters {#parameters-29}

###### args {#args-29}

`ProjectCommandArguments` & `object`

##### Returns {#returns-29}

`Promise`<`string`\>

command output

### stopSession {#stopsession}

```
stopSession: (args) => Promise<void>;
```

Delete app and Log out of current team session

#### Parameters {#parameters-30}

##### args {#args-30}

`Partial`<`ProjectCommandArguments`\> & `object`

#### Returns {#returns-30}

`Promise`<`void`\>

### trigger {#trigger}

```
trigger: object;
```

#### trigger.access {#triggeraccess}

```
access: (args) => Promise<string>;
```

`slack trigger access`

##### Parameters {#parameters-31}

###### args {#args-31}

`ProjectCommandArguments` & `TriggerAccessArguments`

##### Returns {#returns-31}

`Promise`<`string`\>

command output

#### trigger.create {#triggercreate}

```
create: (args) => Promise<string>;
```

`slack trigger create`

##### Parameters {#parameters-32}

###### args {#args-32}

`ProjectCommandArguments` & `CreateArguments`

##### Returns {#returns-32}

`Promise`<`string`\>

command output

#### trigger.delete {#triggerdelete}

```
delete: (args) => Promise<string> = del;
```

`slack trigger delete`

##### Parameters {#parameters-33}

###### args {#args-33}

`ProjectCommandArguments` & `TriggerIdArgument`

##### Returns {#returns-33}

`Promise`<`string`\>

command output

#### trigger.info {#triggerinfo}

```
info: (args) => Promise<string>;
```

`slack trigger info`

##### Parameters {#parameters-34}

###### args {#args-34}

`ProjectCommandArguments` & `TriggerIdArgument`

##### Returns {#returns-34}

`Promise`<`string`\>

command output

#### trigger.list {#triggerlist}

```
list: (args) => Promise<string>;
```

`slack trigger list`

##### Parameters {#parameters-35}

###### args {#args-35}

`ProjectCommandArguments` & `object`

##### Returns {#returns-35}

`Promise`<`string`\>

command output

#### trigger.update {#triggerupdate}

```
update: (args) => Promise<string>;
```

`slack trigger update`

##### Parameters {#parameters-36}

###### args {#args-36}

`ProjectCommandArguments` & TriggerIdArgument & (CreateFromFile | Partial<CreateFromArguments>)

##### Returns {#returns-36}

`Promise`<`string`\>

command output

### version {#version}

```
version: object;
```

#### version.version {#versionversion}

```
version: () => Promise<string>;
```

`slack version`

##### Returns {#returns-37}

`Promise`<`string`\>

command output