Control a DeepSeek Harness agent from Feishu/Lark: send a task by DM, an agent runs it with your configured model and replies in the chat, and a feishu_send tool lets the agent push results. Uses lark-cli's WebSocket connection, so no public webhook is needed, and ships a resident launcher. Note: the plugin does not check who sent a message, so anyone who can DM the bot — by default, members of the Feishu tenant the app belongs to — can drive an agent running with the host's own model credentials and file permissions. Setup is not one `dsh plugin add`: `lark-cli` must be installed and authenticated once, and a Feishu self-built app with the permissions the README lists is required.
Install
# from npm (prebuilt)
dsh plugin --profile web add dsh-feishu-remote
# from GitHub (first run asks for allowBuilds approval — follow the hint, retry)
dsh plugin --profile web add github:ShiXiangYu2/dsh-feishu-remote
Any plugin you install runs third-party code with your own permissions — it can read your files, use your credentials, and reach the network, and tool approvals don’t sandbox it. GitHub-sourced plugins also run build scripts at install time — pnpm blocks those until you allow them, so an install can stop with ERR_PNPM_GIT_DEP_PREPARE_NOT_ALLOWED or ERR_PNPM_IGNORED_BUILDS; dsh prints the exact key to add under allowBuilds in your profile’s pnpm-workspace.yaml, and the install works on the next run. Allowing a build is a trust decision: only install sources you trust, and pin a commit (github:owner/repo#sha).
README
Control your DeepSeek Harness agent from Feishu / Lark on your phone. Send a task by DM — get the result back in chat. Fully working closed loop.
✨ What it does
- 📨 Feishu → Agent → Feishu: DM your bot a task (e.g.
2+3等于几?), a DSH agent runs it with your configured LLM, and the answer comes back to the chat. - 🖼️ Image understanding: send a screenshot or photo — it's downloaded and analyzed by a vision model (Qwen3-VL), then the agent replies with what it sees.
- 🎨 Image generation round-trip: the agent can generate an image (
generate_image), download it locally (feishu_download), and send the actual image back to your Feishu chat (feishu_send_image) — not just a link. - 📤 Agent → Feishu: the model gets
feishu_send/feishu_send_image/feishu_downloadtools to push results, files, and generated images to any user or chat. - 🧹 Retention cleanup: downloaded images are kept for 7 days (configurable via
FEISHU_IMG_RETENTION_DAYS), then auto-deleted — no unbounded disk growth. - 🤖 Long connection: uses
lark-cli's WebSocket event bus — no public webhook server needed, works on localhost/LAN/private servers. - 🔒 Secure: reuses
lark-cli's OS-keychain credential storage and permission system; event listener runs unsandboxed by design (it must hold the WebSocket).
🚀 Install
0. Prerequisites
A Feishu/Lark self-built app with:
- Bot ability enabled
- Event subscription
im.message.receive_v1(long-connection mode) - Permissions:
im:message,im:message:send_as_bot,im:message.p2p_msg:readonly,im:chat:read,im:resource - A published version
- (Setup in the Feishu developer console — the CLI can enable the bot ability via API, but events/permissions need the console.)
lark-cliinstalled & authenticated once:
npm i -g @larksuite/cli
lark-cli config init # paste your App ID / Secret
lark-cli auth login --recommend # scan QR to authorize
1. Install the plugin
dsh plugin --profile demo add github:ShiXiangYu2/dsh-feishu-remote
The bundle contains two pieces:
index.js— the Cordis plugin: registers thefeishu_sendmodel tool and attempts an in-process event listener.feishu-resident.mjs— the recommended resident launcher: boots the web profile and runs the long-connection event loop in a detached process (see below).
2. Configure the model
The DSH profile must have a working LLM route (e.g. DeepSeek via SiliconFlow):
# profile cordis.patch.yml
- id: llm-deepseek
config:
apiKeyEnv: SILICONFLOW_API_KEY
baseURL: https://api.siliconflow.cn/v1
thinking: disabled
reasoningEffort: off
models:
- id: deepseek-ai/DeepSeek-V3.2
name: DeepSeek-V3.2 (via SiliconFlow)
contextWindow: 65536
maxTokens: 8192
- id: agent-default-model
config:
provider: deepseek-official
model: deepseek-ai/DeepSeek-V3.2
3. Run the resident (recommended)
The closed loop must live in a long-lived process. Use the included resident launcher:
# Adjust the absolute paths in feishu-resident.mjs (LARK_HOME, CLI) to your setup.
DSH_HOME=~/.dsh SILICONFLOW_API_KEY=sk-... \
node --import tsx/esm feishu-resident.mjs
It boots the web profile, spawns lark-cli event consume as a detached process (holding stdin open via a tail -f /dev/null pipe so the listener never exits on EOF), and for each inbound DM: ack → create agent → run task → extract final text → reply.
4. Use it
DM your Feishu bot anything, e.g. 帮我总结一下 ~/projects 的 README — the agent runs and the result comes back to the chat.
🛠 Tools
| Tool | Description |
|---|---|
feishu_send |
Model-facing: send a message to a Feishu user (ou_) or chat (oc_). |
feishu_send_image |
Model-facing: send a local image file to a Feishu user or chat. |
feishu_download |
Model-facing: download a URL to a local file (so generated images can be sent via feishu_send_image). |
🔌 How it works
Feishu DM ──► lark-cli event consume (WebSocket long-connection, detached process)
│ NDJSON event on stdout
▼
feishu-resident.mjs (long-lived process)
│ image? → download (messages-resources-download)
│ → vision describe (Qwen3-VL via SiliconFlow)
│ agents.create + followup(task) + whenIdle()
▼
final assistant text (ev.data.message.content)
│ lark-cli im +messages-send
▼
Feishu chat reply
Image handling
- The event content for an image arrives as
[Image: img_v3_xxx]. - The resident detects that pattern, downloads the resource via
lark-cli im +messages-resources-download(using the event's realmessage_id- the
image_key), then asks a SiliconFlow vision model (Qwen/Qwen3-VL-8B-Instruct, overridable withFEISHU_VISION_MODEL) to describe the picture.
- the
- The description is prepended to the user's message and fed to the DSH agent, so the agent can reason about the image and reply in Feishu.
- Downloaded images land in the
IMG_DIR(/root/dsh /feishu-imagesby default; the download command requires a relative--outputpath, so the residentcds into that directory first).
⚠️ Notes
- Why a resident process? DSH's shell service binds background processes to the calling plugin fiber; a listener started inside a plugin's
apply()is killed when the fiber settles. The resident launcher owns the listener in its own process, so it survives. - Text extraction: the final answer is read from the session log's
assistant/messageevents (ev.data.message.content, mirroring the official headlesssummarize()). - Long tasks: replies are truncated to the final text block; very long runs may exceed Feishu message limits.
- lark-cli event output streams as NDJSON on stdout (stderr carries
[event]log lines) — both are parsed.
📄 License
MIT
Links
More in this category
xmanrui/dsh-im★ 3737
Connect IM bots to DeepSeek Harness via QR codes or bot credentials (9 channels: Feishu, WeChat, DingTalk, WeCom, QQ, Slack, Telegram, Discord, and WhatsApp).
shaobeichen/dsh-pocket★ 3092
Remote phone access to the DSH Web UI: scan a QR code for LAN or public (cloudflared tunnel) access with real-time sync, a mobile-adaptive layout, and a settings tab.
c1overzz/dsh-bili-scroll★ 1459
Let your DSH agent browse Bilibili on its own, read subtitles, write a daily digest, and @ you when it finds something worth your attention.
OpenPetsHQ/openpets#dsh★ 1399
Bridges DeepSeek Harness lifecycle status, errors, and approval requests to a locally running OpenPets desktop companion.
inclusionAI/Avernet#deepseek-harness-channel-bcn★ 608
Connects DeepSeek Harness to Avernet's Bot Collaboration Network over WebSocket V2, with automatic onboarding, isolated agent sessions, tool-call events, and multi-bot routing tools.
zaofan-make/dsh-qqbot★ 270
QQ official bot channel (enhanced fork of tencent-connect/dsh-qqbot): full agent chat in groups and DMs, rich media, an auto-tagged sticker library with AI image replies, join approval, mute and broadcast, scheduled wakeups, remote approvals over QQ, interactive cards, multi-account instances, extensions, member profiles, and token-saving value-scored wakeups.
Community comments
Comments are public GitHub Discussions. Loading them connects to GitHub and Giscus; a GitHub account is required to post.