Preface¶

DeepSeek Harness (abbreviated as DSH) splits the agent runtime into a set of pluggable hosts. The official repository’s slogan is “Everything is a Plugin”. When a task finishes, you need to make a decision, or you want to sync conclusions to your colleagues, many people still stare at the output in their terminal or web interface. Team communication often happens on Slack, but terminal notifications and desktop pop-ups cannot solve the problem of “putting the agent into a Slack channel”.

The community plugin dsh-slack bridges this gap: it allows the current DSH agent to send messages to Slack, list channels, and use Socket Mode to receive messages from channels and direct messages into the in-process inbox, then reply in threads. It is maintained by STARDUSTLC666 and categorized under “Notifications & Integrations”. This article is compiled after cross-verifying the plugin directory page, GitHub repository README, and source code, with the version based on 0.2.3 in the repository’s package.json.

First, clarify the ecological boundary: DSH itself is the open-source agent harness by DeepSeek; the community plugin directory is an independent site for retrieving and installing community plugins, and has no official affiliation with DeepSeek / HyperMind. Do not treat it as an official app store.

What is it¶

dsh-slack is a community plugin running inside the DSH host process. After installation, it registers four tools for the model: slack_notify, slack_channels, slack_inbox, and slack_reply. The positioning given on the directory page is to enable two-way communication between the DSH agent and Slack.

The repository README clearly breaks down the capabilities by version:
- v0.1: Only supports one-way notifications from agent → Slack.
- v0.2: Added Socket Mode to support two-way communication from Slack messages → agent. Incoming messages are handled via slack_inbox, and thread replies use slack_reply.

If the App-Level Token is not configured, the plugin will not crash, only printing a warning, and slack_inbox will return an empty queue, reverting to one-way mode. Sending messages, listing channels, and thread replies are still available (provided the bot token is properly configured).

GitHub repository address: https://github.com/STARDUSTLC666/dsh-slack
Plugin directory details page: https://deepseek-harness-plugin.com/zh-CN/plugins/dsh-slack/

As of 2026-08-18, both the directory page and GitHub repository show 4 stars; the primary language is TypeScript. The repository README and package.json list the license as MIT; no standalone LICENSE file is detected in the GitHub repository metadata, so you should check the repository yourself before installing.

Core Functions¶

The four tools correspond to four practical functions, which respectively call the Slack Web API’s chat.postMessage and conversations.list under the hood.

1. slack_notify: Send a Markdown text message to a channel or thread
Required parameters are channel (channel name like #general, or channel ID) and text. Optional parameter thread_ts is used to reply to the thread of an existing message. On success, it returns the ts and channel of the message, which can later be passed to thread_ts.

2. slack_channels: List channels visible to the bot
No parameters required. The source code will automatically paginate along next_cursor, requests both public and private channels (types: public_channel,private_channel), and deduplicates by channel ID. v0.2.3 added a page limit (20 pages in the source code) to prevent infinite loops from abnormal cursors, which is more useful than just fetching the first page when there are many channels in the enterprise workspace.

3. slack_inbox: Read messages received via Socket Mode
The inbox is an in-process memory queue with a capacity of 200 messages, with newer messages first; once full, the oldest messages are dropped. Slack events are delivered at least once, and the queue deduplicates messages by channel + ts + user + text. Optional parameters:
- limit: Maximum number of messages to return, default 10, range 1–50.
- markRead=true: Atomically consume and clear the queue after returning, avoiding the risk of new messages being accidentally deleted during the gap between “first list then clear”.

The queue will be cleared after restarting the DSH process and will not be persisted to disk.

4. slack_reply: Reply to a specific message in the inbox by thread
Required parameters: channel, text, thread_ts. The thread_ts should come from the ts field returned by slack_inbox. Under the hood, it also uses chat.postMessage, just with the thread_ts parameter attached.

In addition, three implementation details are worth mentioning separately:
- Socket Mode, no public callback URL required. The traditional Slack Events API requires exposing an HTTPS endpoint for Slack to push events; Socket Mode uses a long connection initiated by the client to Slack to receive events. This works on local machines, internal networks, and development machines without public IPs. After enabling it, you need an App-Level Token (starting with xapp-) and subscribe to message.channels (public channels) and message.im (bot direct messages).
- Customizable slackApiUrl. The source code’s config.ts parses this field, and the default value is the official https://slack.com/api/. The directory page and repository description state that this can be used to connect to a proxy gateway; the comments also mention that this address can be overridden for Enterprise Grid and local protocol-level testing. The WebClient is cached by token + slackApiUrl, and the client will be rebuilt if the configuration changes.
- Built-in fake Slack server for protocol-level acceptance testing. The repository’s test/fake-slack-server.mjs starts a zero-dependency local HTTP service that simulates chat.postMessage and conversations.list; running pnpm run test:protocol will use the official @slack/web-api to send real HTTP requests to http://127.0.0.1:3999/api/, verifying payloads, authentication headers, and Chinese error mappings. This is development and testing infrastructure, not a runtime dependency.

All error messages are in Chinese, which can be read directly by both models and humans. Common mappings include: token not configured, invalid_auth, channel_not_found, not_in_channel (the bot has not been invited to the channel), token_revoked / missing_scope / not_authed, channel archived, single message over 40,000 characters, and rate limiting. The plugin will still load when the token is missing (lazy loading), and will only throw an error when actually calling the send message, list channels, or reply tools.

v0.2 explicitly does not include: RTM, and interactive components such as buttons, modals, and slash command replies. The README’s roadmap states that v0.3 plans to add interactive components and a persistent inbox, which are not available as of now.

Installation and Activation¶

The plugin runs with the permissions of the current DSH process, and may execute code during installation. Please check the source code repository and license before installing; if you need reproducible installations, pin the commit hash.

The installation command given on the directory page, run in the DeepSeek Harness terminal:

dsh plugin add github:STARDUSTLC666/dsh-slack

To pin a specific commit, append the hash to the repository name as shown on the directory page:

dsh plugin add github:STARDUSTLC666/dsh-slack#<commit>

The repository README also records an installation method by profile (install into the web profile, take effect after restart):

dsh plugin --profile web add dsh-slack

The two command sources are different: the former is based on the original text of the plugin directory, and the latter comes from the GitHub README. After installation, you need to restart the DSH Web service for the four tools to be visible to the model.

Configure Slack App and Tokens¶

The configuration is written in the profile’s cordis.patch.yml, overriding the entry with id: slack. The override replaces the entire config section and does not merge fields with default values. Available options are based on the README table:

The source code additionally supports slackApiUrl. If you need to use a proxy gateway or local fake server, you can add this field in the same config section; it is not currently listed in the README’s configuration table.

Priority: config.token takes precedence over DSH_SLACK_TOKEN, and config.appToken takes precedence over DSH_SLACK_APP_TOKEN. The README recommends using environment variables to avoid writing tokens into configuration files:

export DSH_SLACK_TOKEN=xoxb-your-bot-token
export DSH_SLACK_APP_TOKEN=xapp-your-app-level-token

If writing into the profile (path as per the README example: $DSH_HOME/profiles/web/cordis.patch.yml):

- id: slack
  config:
    token: 'xoxb-your-bot-token'
    appToken: 'xapp-your-app-level-token'
    defaultChannel: '#general'

The steps to create a Slack App and obtain tokens are organized below based on the repository README (the app is created in the Slack official App management dashboard):
1. Create a new app (From scratch) and select the target workspace.
2. In OAuth & Permissions → Bot Token Scopes, check chat:write (send messages) and channels:read (list channels).
3. Authorize via Install to Workspace, then copy the Bot User OAuth Token (starting with xoxb-).
4. Run /invite @your-bot in the target channel. This step is required for private channels, otherwise you will encounter not_in_channel.

You only need to complete the above steps to send notifications. To receive messages, enable Socket Mode additionally:
1. Enable Socket Mode in the App dashboard.
2. Generate Token and Scopes, check connections:write, and save the one-time displayed xapp- token.
3. Subscribe to bot events in Event Subscriptions: message.channels, message.im.
4. Configure the App-Level Token into appToken or DSH_SLACK_APP_TOKEN, then restart the DSH Web service. The plugin will automatically establish the connection; Slack SDK will automatically retry on Socket Mode network errors, and the plugin only logs warnings without crashing.

Typical Usage¶

After installation and restart, the model can directly call these four tools. The following JSON shapes come from the return conventions in the README for easy parameter reference.

Send a notification:

{
  "channel": "#general",
  "text": "Build completed, artifacts are in dist/"
}

A successful slack_notify response looks like:

{ "ts": "1700000000.000100", "channel": "#general" }

List visible channels (no parameters), returns:

{ "channels": [{ "id": "C001", "name": "general" }, { "id": "C002", "name": "random" }] }

Read the inbox and mark messages as read after retrieval:

{ "limit": 10, "markRead": true }

Each returned message contains ts, channel, user, and text. Use the ts from one of the messages for a thread reply:

{
  "channel": "C001",
  "text": "Got it, I'll check the logs.",
  "thread_ts": "1700000000.000100"
}

When developing the plugin or running protocol regression testing, you do not need to connect to a real Slack instance. The repository provides:

pnpm install
pnpm build
pnpm test
pnpm run test:protocol

pnpm test covers parameter compilation, configuration parsing (including environment variable fallback), four tool registrations, Chinese error messages when configuration is missing, injected fake client assertions for postMessage (including thread_ts), inbox capacity/deduplication/atomic drain, Socket Mode event parsing, and not crashing when appToken is missing. test:protocol uses the real SDK HTTP requests against the local fake server.

Applicable Scenarios and Notes¶

It is suitable for these scenarios:
- Your team already collaborates on Slack, and you want the agent to send round results, build statuses, or items requiring confirmation to a specified channel.
- Your development machine or internal network has no public callback address, but you still want to send messages from channels or bot direct messages into the agent.
- You need to list existing channels and pin replies to original messages via threads, instead of sending new notifications separately.
- You need to access the Slack API via an enterprise proxy or self-built gateway, and can override slackApiUrl.

In the same category, the directory page also includes desktop notification plugins (such as dsh-notification, dsh-web-ui-notify) and the Feishu channel plugin dsh-lark. They solve the problems of “reminding you to check the terminal” or “receiving Feishu messages”, which are different from “entering a Slack channel for two-way sending and receiving”, so you can choose based on your workspace.

Please clarify the following restrictions before use:
- The plugin runs with the permissions of the current DSH process, and can access everything accessible to that process. Check the source code, dependencies (runtime dependencies are the official @slack/web-api and @slack/socket-mode), and license before installing.
- Do not commit tokens to Git. Using environment variables takes precedence over writing xoxb- / xapp- into YAML files.
- slack_inbox is not persisted, and will be cleared after restart; the capacity is 200, so it cannot be used as a historical archive.
- defaultChannel is only a prompt for now, and you must still pass the channel parameter when calling the tool.
- Buttons, modals, slash command replies, and RTM are not supported.
- The bot must be invited to the target channel; this step is especially easy to miss for private channels.
- The source code filters messages with subtypes and messages with bot_id to avoid feeding the bot’s own messages back into the inbox.

Summary¶

dsh-slack wraps Slack sending and receiving into four tools callable by the model: notification, list channels, inbox, and thread reply. v0.2 uses Socket Mode to add the reverse channel without exposing a public webhook; slackApiUrl facilitates connecting to proxies or local fake servers; the repository includes built-in protocol-level acceptance tests. It is a community-maintained DSH plugin, not an official DeepSeek application.

Plugin directory page: https://deepseek-harness-plugin.com/zh-CN/plugins/dsh-slack/
Source code: https://github.com/STARDUSTLC666/dsh-slack
DSH itself: https://github.com/deepseek-ai/deepseek-harness