Preface¶

DeepSeek Harness (dsh) treats models, tools, sessions, sandboxes, and interfaces as replaceable plugins, officially described as “Everything is a plugin”. This allows local coding agents to be freely assembled according to profiles, but most entry points for work still remain tied to web pages or terminals in front of the computer: once you leave your workstation, you have to wait until you return to the machine to check task progress, approve changes, or make on-the-spot decisions.

Feishu / Lark has become the daily collaboration platform for many teams. Connecting the local dsh to private chats, group chats, and topics means moving command control from the desktop to a mobile phone, without having to move the agent to a public network server. There are multiple Feishu integration entries in the “Notifications & Integrations” category of the community plugin directory. This article introduces dsh-lark-bot maintained by PlutoKeating: it not only bridges conversations to Feishu, but also integrates project workspaces, parallel tasks, role assignments, and Feishu self-rescue after crashes into a single bridge system.

The following content is collated after cross-verifying with the community directory details page, GitHub repository README / package.json, npm package page, and official DeepSeek Harness documentation. The community plugin directory is an independent site and has no official affiliation with DeepSeek / HyperGryph. Do not treat it as an official app store.

What is this¶

dsh-lark-bot is a notification and integration plugin that bridges the local DeepSeek Harness to Feishu / Lark bots. It is maintained by PlutoKeating, with source code at PlutoKeating/dsh-lark-bot, licensed under AGPL-3.0, and primarily written in TypeScript. The homologous packages on npm are dsh-lark-bot and dsh-feishu-bot, with the current version 0.15.0 (consistent across npm and the repository package.json as of 2026-08-17). The GitHub repository currently has 20 stars; the community directory page shows 12 stars, which is closer to the snapshot at the time of inclusion.

The positioning on the directory page is: bridge DeepSeek Harness to Feishu / Lark bots, with complete project workspace management. The repository README is more specific: command your local coding agent in private chats, group chats, and topics, send messages to receive streaming cards and tool call progress, and consolidate conversations, tasks, cards, and project workspaces into the same collaboration flow. The repository also states that this is an unofficial community tool, not affiliated with or endorsed by DeepSeek or ByteDance / Feishu (Lark).

It solves scenarios like: you are already collaborating on Feishu, but do not want to switch back to the dsh web page on your computer just to modify a line of code or view a diff; nor do you want to expose public network callback addresses. The bridge uses WebSocket long connections via the Feishu Open Platform, and the README explicitly states that no public network server, domain name, or intranet penetration is required.

Core Features¶

The repository README breaks down capabilities into several sections, and only the parts that align across both materials are covered below.

Feishu Channel & Streaming Cards¶

After successful binding, the bridge engine runs within the dsh process. You can send messages directly in private chats, and need to @bot in group chats and topics. Replies present thinking, tool calls, and outputs as streaming cards. You can use /density to switch the card density between compact / standard / detailed. Images in Feishu messages will be downloaded to the local media directory before being passed to dsh; text files will have their content read and injected into the task context.

The default adapter is the official @deepseek-ai/dsh-sdk-client (DSH_LARK_ADAPTER=sdk). Switch to acp when approval cards are needed; headless is a legacy subprocess fallback; web drives the local dsh web agent, making the web interface the sole writer of the session. The README explicitly states that SDK/ACP handshake and real task streaming validation have been completed against dsh 0.1.0-rc.6 (last validated on 2026-08-15).

Project Workspaces¶

This is the differentiator emphasized on the directory page. You can use the following commands in Feishu:
- /cd <path>: Switch working directory and reset the session
- /ws list / /ws save <name> / /ws use <name> / /ws remove <name>: View, save, switch, and delete named workspaces

When the session runs in a Git repository, the bot will create an isolated worktree for each session under ~/.dsh-lark/profiles/<profile>/worktrees/, and copy the project-level AGENTS.md. For non-Git directories, the specified path will be used directly. Workspace status is saved locally at ~/.dsh-lark and no third-party telemetry is involved.

Parallel Tasks & Multi-Role¶

The same scope (private chat / group chat / topic) allows 2 parallel tasks by default, which can be adjusted with /concurrency or the environment variable DSH_LARK_SCOPE_CONCURRENCY; setting it to 1 enables strict serial execution. Successive messages will become independent runs, each using a separate dsh session. /status lists all running runs, and /stop terminates all tasks in the current scope at once.

Administrators can use /role save to define roles such as PM, developer, or documenter (persona, model preferences, tool guidelines, role rules), then use /role set <role> to bind the role to the current scope. Role definitions are persisted in ~/.dsh-lark/profiles/<profile>/roles.json. The role model takes precedence over the default model, but is still subordinate to /model use in the current session.

Archiving, Cross-Session Notifications & Question Cards¶

Each Feishu scope retains the last 40 conversations by default, which can be adjusted with /retention; messages exceeding the retention window will be archived to ~/.dsh-lark/profiles/<profile>/archives/ (Markdown + JSONL, the directory itself is a Git repository). /archive can manually archive, view, and clean up archives.

There are two ways to send cross-session notifications: administrators can send /notify <scope|chatId> <text>; the agent side has a built-in lark_notify tool that can push messages to other groups or topics and @ specified members after a task ends. The callback listens on 127.0.0.1 with a random token generated each startup, and is not exposed to the public network.

When the agent needs approval or additional information, it will pop up a question card (single-select / multi-select / free text) via lark_ask_user, and the task will resume after the answer is submitted; a watchdog will pause execution during the waiting period. Users can also actively send structured questions with /ask, in the reverse direction.

In-Conversation Model & Key Management¶

/model, /providers, /provider, and /key directly read and write dsh official configuration (~/.dsh/settings.yaml and ~/.dsh/.credentials.yaml, the same storage protocol as the web Settings → Models page), and take effect in the next request without restarting the bot. Settings only save apiKeyEnv references, while literal keys are stored in the credential file (permission 0600) and will not be echoed in chat replies. The repository reminds: entering keys in Feishu conversations will expose them to visible members of that conversation, so it is recommended to only use this in private chats, or use environment variables / the dsh web interface to enter keys.

Safety Net Guardian¶

The setup command installs a minimal guardian independent of dsh by default (Linux systemd user unit / macOS LaunchAgent / Windows startup item). The guardian runs silently when dsh is normal; when the process goes offline or the profile fails to boot, it takes over the Feishu channel, so users do not need to touch the command line:
- /safemode: Enter core safe mode only (dsh-base + dsh-headless, no third-party plugins loaded)
- /safemode plugins: List installed plugins for the faulty profile
- /safemode status / /safemode stop / /safemode exit: View status, stop tasks, exit, and return the channel

You can skip installing the guardian with --no-guardian; uninstall it separately with dsh-lark-bot guardian uninstall.

Installation & Activation¶

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

dsh plugin add github:PlutoKeating/dsh-lark-bot

For reproducible installations, the directory page recommends appending the commit hash to the repository:

dsh plugin add github:PlutoKeating/dsh-lark-bot#<commit>

The repository README presents another path for end users, calling it the “one-time installation command”: it locates the local dsh, pre-approves the pnpm build strategy, then executes a version-pinned dsh plugin --profile dsh-lark add dsh-lark-bot@<version>, and installs the safety net guardian by default.

npx dsh-lark-bot@latest setup --profile dsh-lark

The prerequisites are listed in docs/QUICK_START.md: Node.js ≥ 22.19, DeepSeek Harness installed locally with DEEPSEEK_API_KEY configured, and a Feishu / Lark account. The engines field in package.json matches the README. If you encounter ERR_PNPM_IGNORED_BUILDS when manually running dsh plugin add, the README requires adding allowBuilds: { protobufjs: true } to the profile’s pnpm-workspace.yaml before retrying.

Start and complete the first binding:

dsh --profile dsh-lark

The first startup will print a QR code in the terminal, which you can scan with the Feishu / Lark app to create or select a PersonalAgent application. If you already have credentials, you can skip scanning the code:

DSH_LARK_APP_ID=cli_xxx DSH_LARK_APP_SECRET=<secret> DSH_LARK_TENANT=feishu \
  dsh --profile dsh-lark

DSH_LARK_TENANT is either feishu (domestic Feishu) or lark (international version). To uninstall:

dsh plugin --profile dsh-lark remove dsh-lark-bot

Local status will remain in ~/.dsh-lark after uninstallation; if you installed the guardian, you also need to run dsh-lark-bot guardian uninstall. Starting from v0.12.0, you can upgrade the package and guardian with npx dsh-lark-bot@latest upgrade --profile dsh-lark --yes.

Typical Usage¶

After binding is complete, sending ordinary messages to the bot in Feishu will start an agent task in the current workspace. The common commands listed in the repository can be summarized as these groups:

Core environment variables (full list in README, template in repository .env.example):

If you encounter startup errors, first run dsh-lark-bot doctor, which will check the profile, working directory, and perform a real handshake test for the current adapter.

Applicable Scenarios & Notes¶

This tool is suitable for developers and small teams who already use Feishu / Lark for daily communication and want to command the local dsh via mobile phones or group chats, especially those who need multi-project isolation, role assignments, parallel tasks, and session archiving. The directory page lists similar plugins under the “Notifications & Integrations” category, including dsh-lark (Feishu bot channel) and desktop notification plugins; the choice depends on whether you need additional capabilities such as workspaces, parallel tasks, and guardians, rather than whether there is an “official” marker on the directory page.

You need to clarify the permission boundaries before use. The directory page states: the plugin runs with the permissions of the current dsh process, and may execute code during installation. You should inspect the source code repository and license before installing. The package.json declares workshop permissions including file read/write, outbound network, local listening, process spawning, credential read/write, and harness tools and events. The “Permissions & Data” section of the README corresponds to: Feishu app_id / app_secret are written in plaintext to the local ~/.dsh-lark/config.json (file permission 600); read and write the working directories specified by /cd and /ws (including executing shell commands and modifying files); create WebSockets to the Feishu Open Platform and send task contexts to the DeepSeek API. Data only flows locally, between Feishu and DeepSeek, and the repository states that no telemetry is collected.

The license is AGPL-3.0, and you must fulfill the source code obligations under this license when copying, modifying, or providing services over the network, and you cannot treat it the same as “installing a random MIT plugin”. Compatibility is pinned to dsh 0.1.0-rc.6 and Node.js ≥ 22.19; platforms include Linux / macOS / Windows. Known limitations include: ACP mode sessions start fresh each time with no resumption; the SDK protocol does not yet support mid-turn cancel, and /stop will close the corresponding runtime and rebuild it; Feishu document comments and rich text replies are still planned features and not yet implemented.

The README added an official channel statement on 2026-08-17: the only official repository is PlutoKeating/dsh-lark-bot, and the only official npm package is dsh-lark-bot (the homologous dsh-feishu-bot, maintained by plutokeating). The project never provides Windows .exe files or “download and double-click to run” installation packages. The fake repository tarraencompassing61/dsh-lark-bot documented on the same day lures users with exe downloads, so do not retrieve attachments from such pages.

Summary¶

dsh-lark-bot bridges the local DeepSeek Harness to Feishu / Lark: conversations use streaming cards, projects use workspaces and git worktrees for isolation, multiple tasks can run in parallel in the same chat, and models and keys can be modified within conversations. The safety net guardian installed by default with setup is the layer that allows you to send /safemode from Feishu for self-rescue after dsh crashes. It is a community-maintained AGPL-3.0 plugin, not an official product of DeepSeek or Feishu; you only need to read the source code, verify the license, and recognize the single repository PlutoKeating/dsh-lark-bot before installing.

Community Directory Page: https://deepseek-harness-plugin.com/zh-CN/plugins/dsh-lark-bot/

GitHub Repository: https://github.com/PlutoKeating/dsh-lark-bot