Preface¶

DeepSeek Harness (dsh) is an open-source agent runtime developed by DeepSeek AI, whose core philosophy is “Everything is a plugin”: models, tools, sessions, approval workflows, and interfaces can all be replaced or combined via plugins. The official repository notes that the project is still in developer preview, and interfaces may be subject to breaking changes in future updates. When launched with npx @deepseek-ai/dsh web in the current version, the default web interface is available at http://127.0.0.1:3080.

For many teams, the real bottleneck is not “whether the agent can run”, but “working in Feishu while tasks are stuck on the local terminal”. Changing a requirement, approving a tool call, or checking progress all require switching back to the local machine. The community plugin directory includes a category of “Notifications & Integrations” plugins to fill this gap. This article introduces dsh-lark-bridge: one such plugin that turns Feishu/Lark private chats, group chats, and topics into control planes for DeepSeek Harness, letting you send tasks and receive progress cards directly in the chat.

Important note: The community plugin directory deepseek-harness-plugin.com is an independent site and has no official affiliation with DeepSeek / Huanqiufang. It should not be treated as an official app store. The directory currently hosts approximately 287 plugins, with about 9 categorized under “Notifications & Integrations”. Always review the source code and license before installing any plugin.

What is it¶

dsh-lark-bridge is a two-way Feishu/Lark controller for DeepSeek Harness. The GitHub repository is maintained by imetn, categorized under “Notifications & Integrations” in the plugin directory, and licensed under MIT. The version listed in package.json is 0.1.0, it is primarily written in TypeScript, and requires Node.js 22+. The repository README states that it has been validated against DeepSeek Harness 0.1.0-rc.6. At the time of writing, the directory page and GitHub repo both have 7 stars.

It solves a specific problem: send a task in Feishu, and the Bridge will route it to the corresponding Harness Project and Session, updating progress in-place with a native Feishu card. Approvals, questions, files, images, and control commands all work through the same chat session. Communication uses WebSocket long connections via the Feishu Open Platform, eliminating the need to expose a public webhook yourself.

Repository address: https://github.com/imetn/dsh-lark-bridge
Plugin directory page: https://deepseek-harness-plugin.com/zh-CN/plugins/dsh-lark-bridge/

Core Features¶

Based on the repository README and SECURITY.md, the documented capabilities are as follows:

1. Create, continue, correct, stop, resume, and inspect Harness Sessions directly from Feishu.
2. Each group can be bound to an independent Project, working directory, model pipeline, access policy, and card view.
3. By default, each topic or thread corresponds to an isolated Session; replies in the same topic share context.
4. The same card can be updated in-place during execution to show completed, blocked, canceled, or failed status. The card only displays length-limited, redacted tool summaries, and does not show the model’s hidden chain of thought. The original task appears as a quoted reply in Feishu, and the card body will not repeat the task text.
5. Use card buttons to approve a tool call or answer the Agent’s structured questions. Each approval button only authorizes that single operation.
6. Receive text, images, and files; the Agent can send secure files from the workspace back to Feishu via lark_deliver. Outbound files must fall within the Project’s workspaceRoot, and symlink escapes will be rejected.
7. Card density can be set to compact, standard, or developer, configurable per Project or current Session.
8. Uses WebSocket long connections, no public callback service deployment required.

The default mapping between Feishu entities and Harness entities is summarized in this table:

The default setting is groupSessionScope: thread. The sender mode will preserve independent Sessions for each group member; the chat mode lets the entire group share a single Session, and the README explicitly notes that this should only be used when you explicitly need shared context.

Installation and Activation¶

The installation command provided on the plugin directory page should be run in the DeepSeek Harness terminal:

dsh plugin add github:imetn/dsh-lark-bridge

dsh will pull the plugin from GitHub and add it to the current configuration. Plugins run with the permissions of the current dsh process, and may execute code during installation. Always review the source repository and license before installing. For reproducible installations, pin the commit hash as specified on the directory page:

dsh plugin add github:imetn/dsh-lark-bridge#<commit>

Replace <commit> with the commit hash you have reviewed, do not copy the placeholder directly.

Running just this command will not automatically create a Feishu app, write credentials, or generate a lark Profile. The repository README recommends using the setup wizard for onboarding. Prerequisites include: Node.js 22+, pnpm, a working DeepSeek Harness model configuration, an installed dsh CLI, or a local copy of the official Harness source code. Navigate to the Project directory you want the bot to control and run:

pnpm dlx github:imetn/dsh-lark-bridge setup --project "$PWD"

The wizard will perform the following steps: open the official Feishu/Lark authorization page to create a new bot app; only request the messaging, attachment, emoji, event, and card callback permissions required by the Bridge; write the App Secret to a Harness credentials file readable only by the Owner, not into the Profile; install the plugin, idempotently write the lark Profile, bind authorized users, and start the Bridge; after the platform returns the user’s Open ID, the bot will send a welcome card.

The automated flow uses createOnly: true by default, and will not select or modify existing apps. For Feishu tenants, add --brand larkoffice; for international Lark users, add --brand lark:

pnpm dlx github:imetn/dsh-lark-bridge setup --project "$PWD" --brand larkoffice

If your enterprise already has an existing app, the command will only validate credentials and write the local Harness configuration, without modifying the existing app:

printf '%s' "$LARK_APP_SECRET" | pnpm dlx github:imetn/dsh-lark-bridge setup \
  --project "$PWD" \
  --app-id cli_xxxxxxxxxxxxxxxx \
  --app-secret-stdin

If enterprise policies block one-click app creation, add --manual. The wizard will open the developer dashboard and prompt you to enter the App ID and App Secret. For manual creation, you will need to: enable bot capabilities, select long connections, publish a version, and configure the permissions and events listed in the README, primarily including im:message.p2p_msg:readonly, im:message.group_at_msg:readonly, im:message:send_as_bot, im:resource; receiving inbound attachments additionally requires im:message:readonly; the message event im.message.receive_v1; and the card callback card.action.trigger. For group chats, only request @bot message permissions, no need to read all group messages.

package.json declares a dsh.bundle.patch pointing to ./cordis.patch.yml, with the official discovery keyword dsh-plugin. The repository includes pre-built lib/ files and packages the official Feishu SDK, and the README notes that no local build is required when installing from Git.

Typical Usage¶

First send:

/status

in a private chat with the bot, then send a small task. The reply card will display the Project, results, elapsed time, and information corresponding to the current view. The button tests on the welcome card are optional; you can send text tasks directly without clicking them. You can check the local connection status at any time with:

pnpm dlx github:imetn/dsh-lark-bridge doctor

Common control commands are listed in the README — do not use custom slash commands:
- Text or attachments: Continue the current Agent
- /steer <content>: Supplement or correct the most recent step during execution
- /stop: Cancel the current task
- /approve, /reject: Text fallbacks for handling a pending tool approval
- /new: Create a new Session
- /sessions, /resume: List or resume Sessions belonging to the current Feishu source
- /projects, /project: List or select Projects in private chat
- /bind [project-id], /unbind: Manage Project bindings for group chats
- /view compact|standard|developer: Switch the card density for the current Session
- /commands, /help: View native Harness commands or Bridge help

If there is only one available Project in the Profile, the Owner will be automatically bound when they @ the bot in a group chat for the first time. If multiple Projects exist, send @bot /bind [project-id] to select one. Card buttons also support stopping tasks, creating new sessions, checking status, approving requests, switching views, and answering structured questions.

The differences between the three card view modes are as follows:
- compact: Results, elapsed time, and key actions
- standard: Compact view plus Project, model, recent tool names, tool count, and total tokens
- developer: Standard view plus cwd, Session ID, redacted tool summaries and elapsed time, input/output/cache tokens

The wizard will write to ~/.dsh/profiles/lark/cordis.patch.yml. For multiple Projects, append entries to this file as shown in the README, for example:

- id: dsh-lark-bridge
  config:
    appId: cli_xxxxxxxxxxxxxxxx
    appSecretRef: DSH_LARK_APP_SECRET
    brand: feishu
    defaultProjectId: web
    groupSessionScope: thread
    projects:
      - id: web
        name: Web App
        cwd: /absolute/path/to/web-app
        workspaceRoot: /absolute/path/to/web-app
        cardPreset: developer
      - id: ios
        name: iOS App
        cwd: /absolute/path/to/ios-app
        workspaceRoot: /absolute/path/to/ios-app
        cardPreset: compact

Each Project can also set chatIds, allowedOpenIds, provider, model, and inboundDir. Group bindings created via Feishu are saved to a Bridge state file readable only by the Owner; static chatIds take priority.

There are two common points of confusion. First, dsh --profile lark only starts the Bridge, and does not serve the HTTP web interface; http://127.0.0.1:3080 belongs to the separate dsh web command. Second, common troubleshooting steps listed in the README: if you cannot receive messages, check if the app version has been published, if long connections are enabled, and if all required events and permissions are configured; if group chats are unresponsive, first add the bot to the group and @ it; if card buttons are unresponsive, add the card.action.trigger event — text tasks, /approve, and /reject will still work.

Use Cases and Cautions¶

This tool is ideal for individual developers and small teams already using DeepSeek Harness who communicate daily via Feishu/Lark: they want to assign tasks, check progress, and approve tool calls from their phones or group chats without keeping their local terminal open constantly. For multi-repository workflows, you can bind each group to a different Project, and use topics to isolate Sessions.

It is not suitable as a “gateway to expose Harness publicly on the internet”. As clearly stated in SECURITY.md: the Bridge turns authorized Feishu users into remote entry points for the local Harness Agent, and every allowed open_id should be treated as an operator with the full capabilities of that Harness profile. The Bridge cannot replace Harness sandboxes, approval policies, operating system permissions, or credential storage.

Keep these boundaries in mind when installing and using:
- The plugin directory and README both emphasize that plugins run with the permissions of the current dsh process; always review source code and licenses before installing; pin commits for reproducible installations.
- Store the App Secret in a Harness credentials file readable only by the Owner, a key manager, or a protected process environment — do not write it into the Profile, and do not expose it in chats, logs, screenshots, or commits.
- SECURITY.md recommends keeping allowAllUsers and allowAllGroups disabled, using global allowedOpenIds and restricted Project lists; keep requireMention: true; bind only one Project per group; set workspaceRoot to the smallest necessary directory.
- Owners are bound via official authorized identities, or use one-time, 10-minute valid /claim pairing codes stored as hashes.
- Inbound attachments use 0700 directories and 0600 files, and filenames will be sanitized with random suffixes added.
- Redaction follows common secret key patterns, and abnormal formats may slip through; authorized operators can perform any action allowed by the underlying Harness profile. Group members can see messages visible to the group, even if only some members can interact with the bot.
- WebSocket event delivery is not a distributed lock: multiple Bridge processes connected to the same Feishu app may split events and in-memory interaction state. One Feishu app should map to one Bridge, and separate production and development apps.
- DeepSeek Harness is still in developer preview, and this plugin has only been validated against 0.1.0-rc.6. Verify the plugin’s peer dependencies before upgrading Harness.

There are other Feishu integration plugins in the same directory, such as dsh-lark, with different maintainers and licenses. This article only references the official directory page and repository documentation for dsh-lark-bridge, and does not attribute capabilities from other plugins to this one.

Conclusion¶

dsh-lark-bridge takes a restrained approach: it does not build a separate web console, but instead maps Feishu chats to Harness Projects and Sessions, using cards to deliver progress, approvals, and files directly in chat. For teams already using Feishu for daily collaboration, this path is far more convenient than repeatedly switching back to the local terminal.

This is an MIT-licensed community project, not an official DeepSeek application. Before installing, review the source code and license, pin the commit hash, tighten Feishu app permissions and local Harness approval policies, then start sending tasks directly from your chat window.

Plugin directory page: https://deepseek-harness-plugin.com/zh-CN/plugins/dsh-lark-bridge/
GitHub: https://github.com/imetn/dsh-lark-bridge
DeepSeek Harness: https://github.com/deepseek-ai/deepseek-harness