Preface¶

The core philosophy of DeepSeek Harness (dsh) is “everything is a plugin”: models, tools, sessions, sandboxes, loops, and interfaces can all be replaced at the configuration layer without modifying the framework source code. Many people are already running agents locally with dsh web, but the biggest bottleneck is often the entry point: when you’re on your phone, your tasks are still stuck in the terminal; when a colleague shares a screenshot or requirement in a Feishu group, you have to copy it back to the web interface.

If you build a bot following the standard practices of Feishu’s open platform, you usually need to create an app, enable event subscriptions, and prepare a public network callback URL. There are already multiple Feishu/Lark bridges in the community, and the dsh-lark-link package integrates QR code app creation, card-based mode switching, outbound outbox, and inbound request retransmission into a single plugin.

This article is collated after cross-verifying with the community directory details page, GitHub repository README, package.json, and CHANGELOG (current npm version 0.3.3): what it is, which installation commands to use, how to use it in Feishu, and what the default Full access permission actually means.

What is it¶

dsh-lark-link is a session and messaging community plugin. Its GitHub repository is amlyczz/dsh-lark-link, maintained by amlyczz (signed as “小斯syzs” in the README), licensed under MIT, and primarily written in TypeScript. It was added to the community directory on 2026-08-06; the repository was created on 2026-08-13, and as of the day this article was verified, it had 17 GitHub stars. The npm package name is also dsh-lark-link, with the current version 0.3.3.

It solves a very specific problem: connecting an already running DSH agent to Feishu/Lark. Sending a message in a private chat or group will trigger a complete Harness round (with access to bash, files, sub-agents, workflows, and other tools), rather than wrapping it as a simple question-answering chatbot. Each Feishu session corresponds to an independent Agent; the bridge session itself is a native DSH session, and you can continue to view chats, streaming outputs, and tool cards in the Web GUI.

The README clearly states that this project is a community plugin and has no affiliation with DeepSeek, Feishu, or Lark. The community directory deepseek-harness-plugin.com is an independent site and not the official app store for DeepSeek / HyperGAI.

Core Features¶

QR code app creation, no need to manually configure the open platform¶

After executing /lark setup on the DSH side, a QR code will be displayed in the panel for creating a Feishu app, which will automatically subscribe to message events, full group chat, and emoji permissions. The README summarizes this process as going live in about 30 seconds, with no requirement to manually configure a callback URL or prepare a public network server. If you already have an existing app, you can also use the manual channel via DSH_LARK_APP_ID / DSH_LARK_APP_SECRET.

Credentials are written to DSH’s credentials service, not into configuration files. Commands like /lark start, /lark stop, /lark restart, and /lark status manage the bridge lifecycle; /lark uninstall-clean is used to clear credentials and state directories.

Outbound outbox + inbound request retransmission¶

Reliability is the most carefully designed part of this plugin, split into two lines:
1. Outbox: Persistent JSONL outbox with at-least-once delivery, idempotent keys, and parallel delivery by channel. Failed messages will be queued without blocking subsequent deliveries, and will automatically resume delivery if the process is killed or dsh is restarted. Starting from version 0.3.0, replies to bridge commands (/status, /help, /mode, etc.) also go through the Outbox instead of being sent directly.
2. Inbound WAL: If a user’s message has been accepted by the Agent but the plugin is hot-upgraded or dsh is restarted mid-processing, the request will be retriggered based on the write-ahead log after restart. The number of pending retransmissions can be viewed via /status and the Web panel. The CHANGELOG clearly states the boundary: only plain text requests are recorded; commands, images, and files are not included in retransmission. By default, up to 2 replays are allowed within a 30-minute window to avoid infinite loops.

The connection layer also includes probe-driven controlled reconnection and QuotaGovernor quota circuit breaking. After version 0.3.0, the circuit breaker will automatically reset and reconnect when the quota window expires, eliminating the need for manual /lark restart. HTTP proxies in the environment will be actively avoided to prevent the Feishu SDK from using the wrong protocol.

Card-based commands and multi-mode agents¶

Commands like /mode, //permission, and /model in Feishu all use radio button cards, allowing one-click switching, with models grouped by provider. The currently listed shipped presets in the README are standard / code / minimal / cordis, and you can also use presets created in the GUI; the default agentPreset is code (for multi-step tool call execution).

Permissions are divided into three tiers: read-only, workspace write, and Full access, with the default being Full access (permissionMode=danger-full-access), which grants full sandbox access and sets approval to never. Group chats default to groupPolicy=open, meaning triggers do not require @mentions.

Commands follow a three-level分流: bridge-specific commands are handled by the bridge; natively registered DSH commands (such as /goal, /compact) are executed natively; all other /xxx commands and regular messages are injected directly into the Agent. The README emphasizes that there is no interception or access control. Skills do not require prefixes like /skill:name — just describe the task directly.

If the model calls ask_user_question, it will be converted into a Feishu intent confirmation card (with option buttons, dropdown multi-select, and custom input), and the Agent will resume execution after receiving the reply. A random “received” emoji will be added to incoming messages, and a DONE reaction will be added upon completion. The emoji set is filtered based on Feishu’s valid values to avoid invalid emojis returning 400 errors.

Media, sessions, and Web GUI¶

Inbound: Feishu images are stored as attachments for use by vision models; files are processed with bounded text extraction and inserted into the prompt. Outbound: the model can use lark_send_local_file to send back local images or files, with workspace whitelisting, size validation, and format downgrade following Feishu’s file_type rules.

If the reply is detected as Markdown (headings, lists, code blocks, tables, etc.), it will be sent as a CardKit card; plain text is still sent as a text message. Streaming output is disabled by default, but you can enable CardKit schema 2.0 streaming cards in real time with /lark-config streaming.enabled=true.

For sessions: /new starts a new session in the current workspace (without entering the Agent); /workspace <path> switches workspaces, supporting ~ for path expansion; session IDs are persisted across restarts. Starting from version 0.3.1, workspace, model, and mode overrides are isolated by session key, preventing switching in one chat from leaking to other sessions due to Agent reconstruction.

The bridge Agent is a native DSH session, and chats, streaming outputs, tool cards, and settings are still rendered by the Web GUI; sessions are grouped into their corresponding workspaces, and you can view Outbox and retransmission counts in the panel.

/doctor diagnostic package¶

Sending /doctor in Feishu will return a ZIP file containing the full DSH session log for the current session, anonymized configuration, and the ISSUE.md template. The README positions this package as something you can share with any AI or send to the maintainer’s Feishu group to troubleshoot issues, rather than just relying on error text.

Installation and Activation¶

Prerequisites from the repository README and package.json:
- Node.js ≥ 24 (the engines.node field specifies >=24.0.0)
- DeepSeek Harness has already been installed, for example npm i -g @deepseek-ai/dsh

The installation command given on the community directory page is:

dsh plugin add github:amlyczz/dsh-lark-link

The directory page also notes that for reproducible installations, you can pin the commit hash:

dsh plugin add github:amlyczz/dsh-lark-link#commit

Replace commit with the actual commit hash. The plugin is distributed as an official bundle (dsh.bundle + cordis.patch.yml in package.json), and will be added to the dsh.profile.bundles layer of the current profile after installation.

The repository README currently recommends installing pre-built artifacts from npm and specifying the web profile (to let Feishu and the GUI share the same configuration):

dsh plugin --profile web add dsh-lark-link@latest --ignore-scripts

To upgrade:

dsh plugin --profile web update dsh-lark-link --latest --ignore-scripts

The reason for --ignore-scripts is written in the README: a transitive dependency of the Feishu SDK, protobufjs, has an ignorable postinstall script, and pnpm 11’s security policy may block it and return a non-zero exit code; skipping the script will still leave protobufjs functional. You can omit this flag if your local pnpm has globally allowed the script. Installing from GitHub source requires prepare builds and allowBuilds permissions; for offline environments, you can first run npm pack, then use dsh plugin --profile web add ./dsh-lark-link-<version>.tgz --ignore-scripts.

Both installation paths point to the same repository. The directory page commands follow the page’s original text; for daily use, the npm + --profile web method from the README skips a source code build. You should review the source code and MIT license before installing. The plugin runs with the permissions of the current dsh process, and may execute code during installation.

After installation, start the Web GUI:

dsh web

In the GUI input box or terminal, execute:

/lark setup
/lark start

Then search for the newly created bot in Feishu and send any message. If you receive a reaction receipt and a complete reply, the end-to-end connection is successful. Group chats do not require @mentions by default.

Typical Usage¶

The following commands and configurations are from the repository README and can be reproduced as written.

1. Switch modes, permissions, and models in Feishu¶

Send the following messages in a conversation with the bot:

/mode
/permission
/model

A radio button card will pop up. /mode switches between standard, code, minimal, cordis, and GUI-created presets; /permission switches between read-only, workspace write, and Full access; /model lists available models grouped by provider. Selecting an option will take effect for the current session.

2. Hot-update configuration¶

/lark-config groupPolicy=mention
/lark-config agentPreset=standard
/lark-config streaming.enabled=true

/lark-config takes effect immediately and is persisted. Common configuration keys are as follows (default values follow the README):

3. Sessions, workspaces, and diagnostics¶

/new
/workspace ~/projects/demo
/status
/sessions
/help
/doctor
/stop

/new starts a new session; /workspace switches workspaces; /status shows connection, Outbox, retransmission, and session health; /doctor returns a ZIP diagnostic package; /stop cancels the current task. Native DSH commands such as /goal and /compact will be executed in Feishu and the results will be sent back.

Applicable Scenarios and Notes¶

This tool is particularly suitable for these scenarios:
- You are already running DeepSeek Harness locally and want to use Feishu private chats or groups as a mobile entry point
- You need card-based mode/model switching instead of memorizing a series of slash commands
- You care about whether text messages and replies can be retransmitted after process crashes or plugin hot-upgrades
- You want bridge sessions to continue appearing in the dsh web workspace instead of having a separate chat history

Before using, please clarify the permission boundaries. The following points are all from the directory page or repository documentation, not additional additions:
1. The plugin runs with the permissions of the current dsh process. The directory page notes that it may execute code during installation. Review the GitHub source code and MIT license before installing; pin the commit hash for production or reproducible environments.
2. Default Full access. permissionMode defaults to danger-full-access, granting full sandbox access and setting approval to never. This means that a single message in Feishu can execute native bash commands and write files on your local machine. Before sharing the bot or adding it to a group, you should lower the permission to read-only or workspace write, and use allowlist to restrict open_ids.
3. Group chats do not require @mentions by default. When groupPolicy=open and allowlist is empty, any message in the group will be sent to the Agent. A more secure option is to change it to mention or keywords mode and fill in the whitelist.
4. Inbound retransmission only covers plain text. Images, files, and command messages are not included in the WAL; do not interpret “zero loss” as guaranteeing retransmission for all message types.
5. Runtime requires Node.js ≥ 24. Insufficient versions will prevent installation or operation.
6. This is a community plugin. It has no official affiliation with DeepSeek, Feishu, or Lark; the community directory is not an official store. The repository README provides the maintainer’s Feishu group for feedback, which is not an official support channel.

Architecturally, the bridge is a Cordis plugin layered as host → inbound → application → outbound → sessions. The README notes that the repository includes 162 unit and integration tests, with CI running type checks, tests, and builds on push/PR. These are the test scales claimed by the repository, and do not represent regression results on your local machine.

Summary¶

dsh-lark-link connects DeepSeek Harness to Feishu: QR code app creation, card-based mode switching, media transfer, and handles crashes and restarts with the Outbox and inbound WAL. It reuses native DSH sessions and the Web GUI, so the same session is visible on both Feishu and the web interface, rather than having two separate bot instances.

The default Full access, open group chat policy, and empty whitelist are three settings you should modify before connecting the bot to an actual group. Review the source code and license before installing the plugin, and pin the commit hash for reproducible installations.

Directory page: https://deepseek-harness-plugin.com/zh-CN/plugins/dsh-lark-link/

GitHub: https://github.com/amlyczz/dsh-lark-link

npm: https://www.npmjs.com/package/dsh-lark-link