Agent skill

Lark Event

by appleweiping in appleweiping/WEIPING_WIKI

Lark/Feishu real-time event listening / subscribing / consuming: stream events as NDJSON via lark-cli event consume <EventKey (covers IM message receive, reactions, chat member changes, etc.).

MITAuto-check passedProductivity & Automation

Install Lark Event

skills CLI
$ npx skills add appleweiping/WEIPING_WIKI --skill lark-event -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install appleweiping/WEIPING_WIKI lark-event --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/appleweiping/WEIPING_WIKI.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skill/lark-cli/skills/lark-event .claude/skills/lark-event && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
lark-event
GitHub stars
119
Token cost
~1.9k tokens
SKILL.md length
792 words
Files
2 (incl. references)
Skills in repo
51
Repo updated
First seen
Licence
MIT

At a glance

Lark/Feishu real-time event listening / subscribing / consuming: stream events as NDJSON via lark-cli event consume <EventKey (covers IM message receive, reactions, chat member changes, etc.).

  • Works in 3 steps: lark-cli event list --json → pick a… → lark-cli event schema --json → read… → lark-cli event consume [--jq ''] → consume
  • Real-time message processing
  • SKILL.md covers Core commands, Common flags, Examples and Call flow, plus 3 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Lark Event is an agent skill from appleweiping/WEIPING_WIKI. Lark/Feishu real-time event listening / subscribing / consuming: stream events as NDJSON via lark-cli event consume <EventKey (covers IM message receive, reactions, chat member changes, etc.). Use for Lark bots, real-time message processing, long-running subscribers, streaming webhook/push handlers. Supports --max-events / --timeout bounded runs and a stderr ready-marker contract — designed for AI agents running as subprocesses.

Its SKILL.md is about 1.9k tokens, which your agent loads only when the skill is triggered. The skill folder holds 2 other files, including reference files (for example `references/lark-event-im.md`).

It sits in Productivity & Automation, covering Messaging and chat bots. It works with Feishu (Lark). The repository describes itself as: knowledge base managed with an LLM workflow. The licence is MIT.

When your agent uses it

  • Real-time message processing
  • Long-running subscribers
  • Streaming webhook/push handlers

Example prompts

  • “/lark-event”

Workflow steps

3 steps, taken from the first numbered list in SKILL.md.

  1. lark-cli event list --json → pick a legal key
  2. lark-cli event schema --json → read resolved_output_schema + jq_root_path to determine field paths
  3. lark-cli event consume [--jq ''] → consume

What it can do on your machine

Read from SKILL.md and the folder at commit 76fdc42. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are bash and json).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Lark Event loads about 1.9k tokens when it runs, and up to ~3k if it reads all its reference files. Until then it costs about 113 tokens; SKILL.md has 792 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~113
When it runs · the whole SKILL.md, loaded when a task matches
~1.9k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~3k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from appleweiping/WEIPING_WIKI at commit 76fdc42, republished under its MIT licence (© appleweiping). 792 words, ~1,923 tokens.

Download SKILL.mdSave it as .claude/skills/lark-event/SKILL.md (or your agent's skills folder). This skill also uses 1 other file; get the full folder from GitHub.
name
lark-event
description
Lark/Feishu real-time event listening / subscribing / consuming: stream events as NDJSON via `lark-cli event consume <EventKey>` (covers IM message receive, reactions, chat member changes, etc.). Use for Lark bots, real-time message processing, long-running subscribers, streaming webhook/push handlers. Supports `--max-events` / `--timeout` bounded runs and a stderr ready-marker contract — designed for AI agents running as subprocesses.
version
1.0.0
metadata.cliHelp
lark-cli event --help

Lark Events

Prerequisite: Read ../lark-shared/SKILL.md first for authentication, --as user/bot switching, Permission denied handling, and safety rules.

Core commands

CommandPurpose
lark-cli event list [--json]List all subscribable EventKeys
lark-cli event schema <EventKey> [--json]Show an EventKey's params and output schema
lark-cli event consume <EventKey> [flags]Blocking consume; events → stdout NDJSON
lark-cli event status [--json] [--fail-on-orphan]Inspect the local bus daemon status
lark-cli event stop [--all] [--force]Stop the bus daemon

Common flags

FlagDescription
--param key=value / -pBusiness params (repeatable; comma-separated for multi-value). Unknown keys fail with valid names listed inline
--jq <expr>jq expression to filter / transform each event; empty output skips the event
--max-events NExit after N events. Default 0 = unlimited
--timeout DExit after duration D (e.g. 30s, 2m). Default 0 = no timeout. Whichever of --max-events / --timeout fires first wins
--output-dir <dir>Write each event as a file (relative paths only; prevents traversal)
--quietSuppress stderr diagnostics. AI should not use this — it silences the ready marker
--as user|bot|autoIdentity for the session (see lark-shared)

Examples

bash
# Default: stream every event for the key (no filter, no projection)
lark-cli event consume im.message.receive_v1 --as bot

# Grab one sample event to inspect payload shape
lark-cli event consume im.message.receive_v1 --max-events 1 --timeout 30s --as bot

# Run for 10 minutes then auto-exit
lark-cli event consume im.message.receive_v1 --timeout 10m --as bot

# Consume multiple EventKeys concurrently (one shape per process, no dispatcher)
lark-cli event consume im.message.receive_v1          --as bot > receive.ndjson &
lark-cli event consume im.message.reaction.created_v1 --as bot > reaction.ndjson &
wait

Call flow

  1. lark-cli event list --json → pick a legal key
  2. lark-cli event schema <key> --json → read resolved_output_schema + jq_root_path to determine field paths
  3. lark-cli event consume <key> [--jq '<expr>'] → consume

Subprocess contract

Ready marker

event consume's stderr emits a fixed line [event] ready event_key=<key>. Parent processes should block on stderr until this line appears, then start reading stdout. Do not fall back to sleep.

stdin EOF = graceful exit

event consume treats stdin close as a shutdown signal (wired for AI subprocess callers). < /dev/null / nohup / systemd's default StandardInput=null will cause an immediate graceful exit (stderr reason: signal). To keep running:

  • Feed stdin a source that never EOFs: < <(tail -f /dev/null)
  • Or run bounded: --max-events N / --timeout D
Exit codes & reason

On exit, the last stderr line is [event] exited — received N event(s) in Xs (reason: ...).

exit codereasonTrigger
0reason: limit--max-events reached
0reason: timeout--timeout reached
0reason: signalCtrl+C / SIGTERM / stdin EOF
non-0Error: ... (no exited line)Startup / runtime failure (permissions, network, params, config)

Orchestrators should treat reason: limit/timeout/signal (all exit 0) as "business completion" and non-zero as "failure".

Never kill -9

Avoid kill -9 on consume processes: for EventKeys with a PreConsume hook (those that register server-side subscriptions via OAPI), kill -9 skips the OAPI unsubscribe and leaks server-side subscriptions (symptoms: "subscription already exists" on restart, duplicate event delivery). Prefer SIGTERM or closing stdin.

One consume, one EventKey (multi-key = multi-shell)

The command takes exactly one positional argument; k1,k2 and wildcards are unsupported. Listening to N keys means N subprocesses — this is intentional:

  • One shape per process stdout; no dispatcher logic required in the AI
  • Fault isolation (one key failing doesn't affect others)
  • Independent --as / --jq / --max-events / --timeout per key

All N consumers share a single bus daemon (UDS local IPC), so the overhead is small

Show full SKILL.md (320 more words)Show less

Writing jq via schema

event schema <key> --json is the source of truth for writing --jq. Four things to look at:

(1) Where fields start — see jq_root_path

  • Value "." → fields are at the top level, write .chat_id
  • Value ".event" → fields are inside a V2 envelope, write .event.chat_id

(2) Field list and types — see resolved_output_schema.properties.<name>

Each field carries type / description, and some also have format. Snippet (from event schema im.message.receive_v1 --json):

json
{
  "chat_id":     {"type":"string", "format":"chat_id",      "description":"Chat ID, prefixed with oc_"},
  "sender_id":   {"type":"string", "format":"open_id",      "description":"Sender open_id, prefixed with ou_"},
  "create_time": {"type":"string", "format":"timestamp_ms", "description":"Send time as ms-epoch string"}
}

(3) Field semantics — see the format tag

Lark-defined semantic tags (not JSON Schema's standard format). Common values: open_id / chat_id / message_id / timestamp_ms / email. Purpose: distinguish "same string type, different meanings" fields so you can reverse-lookup via API or convert formats.

(4) Decoded state — read the field's description

event consume runs Process hooks that may pre-decode some payload fields (flattening V2 envelopes, rendering .content to plain text, etc.) — behavior differs from raw OAPI. Always read the field's description before writing jq, especially for generic field names like content / data / body / payload.

Why it matters: blindly applying fromjson to an already-decoded text field makes jq error on every event and silently drop it — the consumer looks alive but emits nothing, with only a single WARN line buried on stderr. (This is the general behavior: any jq runtime error skips the event with a one-line WARN; the loop does not abort.)

Don't shortcut the schema: when projecting event schema --json with jq, do not strip .description from properties — that's the field that tells you whether a field is already decoded. Dump the full property objects, not just keys.


Aside: --param's valid parameters also live in the schema — the params section lists name / type / required / enum / default / description; section missing = this key accepts no --param.

Topic index

TopicReferenceCoverage
IMreferences/lark-event-im.mdCatalog of 11 IM EventKeys + shape notes (flat vs V2 envelope) + im.message.receive_v1 field gotchas (sender_id is open_id only; .content is plain text except for interactive cards) + common jq recipes (filter by chat_type / message_type / sender)

© appleweiping, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 1 other file (references) in skill/lark-cli/skills/lark-event of appleweiping/WEIPING_WIKI.

  • SKILL.md
  • references/lark-event-im.md

Open the folder on GitHubat commit 76fdc42

Compare with similar skills

Lark Event next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Lark Event compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Lark Event this skillappleweiping/WEIPING_WIKI119—~1.9kAutomated safety check: PassMIT
Feishu BridgeAlexAnys/feishu-openclaw3171 repos~615Automated safety check: PassNone
Lark Eventrongxinzy/RongxinAI1543 repos~2.7kAutomated safety check: PassAGPL-3.0
Feishucodewhale-hq/Codewhale41k—~413Automated safety check: PassMIT
Feishu NotifyAI4Scientist/nano-scientist1284 repos~1.6kAutomated safety check: PassNone
Feishu LarkOpenClaudia/openclaudia-skills713—~7.4kAutomated safety check: NotesMIT

Similar skills

  • Feishu Bridge

    AlexAnys/feishu-openclaw

    Connect a Feishu (Lark) bot to Clawdbot via WebSocket long-connection.

    317 GitHub starsUsed in 1 repo~615 tokens
    Productivity & AutomationAuto-check passed
  • Lark Event

    rongxinzy/RongxinAI

    Lark/Feishu real-time event listening / subscribing / consuming: stream events as NDJSON via lark-cli event consume <EventKey (covers IM messages/reactions/chat changes, Approval status changes…

    154 GitHub starsUsed in 3 repos~2.7k tokens
    Productivity & AutomationAuto-check passed
  • Feishu

    codewhale-hq/Codewhale

    Work with Feishu or Lark bots, docs, sheets, bitables, approval flows, and OpenAPI/MCP setup without hardcoding credentials.

    41k GitHub stars~413 tokensUpdated today
    Productivity & AutomationAuto-check passed
  • Feishu Notify

    AI4Scientist/nano-scientist

    Send notifications to Feishu/Lark. An agent skill from AI4Scientist/nano-scientist.

    128 GitHub starsUsed in 4 repos~1.6k tokens
    Productivity & AutomationAuto-check passed
  • Feishu Lark

    OpenClaudia/openclaudia-skills

    Send messages and interactive cards to Feishu (飞书) and Lark channels via webhooks or Bot API.

    713 GitHub stars~7.4k tokensUpdated 21 days ago
    Productivity & AutomationAuto-check: notes
  • Add Feishu

    sugarforever/01coder-agent-skills

    Add Feishu (飞书/Lark) as a channel. An agent skill from sugarforever/01coder-agent-skills.

    137 GitHub stars~1.4k tokensUpdated 3 mo ago
    Productivity & AutomationAuto-check: notes

More from appleweiping/WEIPING_WIKI

All 51 skills in this repo
  • Communication Assistant

    appleweiping/WEIPING_WIKI

    Unified lazy-mode communication assistant for Vipin across WhatsApp, WeChat, QQ, Feishu/Lark, and email.

    119 GitHub stars~1.1k tokensUpdated 1 mo ago
    Auto-check passed
  • Content Refinement Agent

    appleweiping/WEIPING_WIKI

    Step 5 of the PaperOrchestra pipeline (arXiv:2604.05018). An agent skill from appleweiping/WEIPING_WIKI.

    119 GitHub stars~3k tokensUpdated 1 mo ago
    Auto-check passed
  • Chrome Automation

    appleweiping/WEIPING_WIKI

    Connect to and control Google Chrome browser using agent-browser with CDP (Chrome DevTools Protocol).

    119 GitHub starsUsed in 1 repo~5.3k tokens
    Auto-check: warnings
  • Email Assistant

    appleweiping/WEIPING_WIKI

    Personal Gmail and Google Workspace email assistant for Vipin.

    119 GitHub stars~1.3k tokensUpdated 1 mo ago
    Auto-check passed
  • Wechat Video Channel Publish

    appleweiping/WEIPING_WIKI

    A skill your agent uses when the user wants to log into 微信视频号, validate cookie state, upload videos, set scheduled publish time, fill long description, set a cover image, or save drafts through a…

    119 GitHub stars~765 tokensUpdated 1 mo ago
    Auto-check passed
  • Feishu Bridge

    appleweiping/WEIPING_WIKI

    Route Feishu/Lark content access for Codex. An agent skill from appleweiping/WEIPING_WIKI.

    119 GitHub stars~906 tokensUpdated 1 mo ago
    Auto-check passed

Works with

Questions about Lark Event

What does Lark Event do?

Lark/Feishu real-time event listening / subscribing / consuming: stream events as NDJSON via lark-cli event consume <EventKey (covers IM message receive, reactions, chat member changes, etc.). Lark Event is an agent skill from appleweiping/WEIPING_WIKI.).

When should I use Lark Event?

Lark Event fits situations like: real-time message processing; long-running subscribers; streaming webhook/push handlers.

How do I install Lark Event in Claude Code?

Run `npx skills add appleweiping/WEIPING_WIKI --skill lark-event -a claude-code`. Or copy the skill folder (skill/lark-cli/skills/lark-event in appleweiping/WEIPING_WIKI) into .claude/skills/lark-event in your project. Claude Code loads it when a task matches its description.

How do I install Lark Event in Codex?

Run `npx skills add appleweiping/WEIPING_WIKI --skill lark-event -a codex`. Or copy the skill folder (skill/lark-cli/skills/lark-event in appleweiping/WEIPING_WIKI) into .agents/skills/lark-event in your project. Codex loads it when a task matches its description.

Can I use Lark Event in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add appleweiping/WEIPING_WIKI --skill lark-event -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/lark-event, .gemini/skills/lark-event, .github/skills/lark-event and .opencode/skills/lark-event in your project.

What does Lark Event need to run?

SKILL.md names no scripts, command-line tools or credentials: Lark Event is instructions for the agent only.

Does Lark Event access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Lark Event safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Lark Event use?

Lark Event is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Lark Event use?

About 1.9k tokens (SKILL.md is roughly 7.7k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 1.1k tokens, read only when the agent opens those files.

What are the alternatives to Lark Event?

Skills that share tags, products or a category with Lark Event: Feishu Bridge (AlexAnys/feishu-openclaw, 317 stars), Lark Event (rongxinzy/RongxinAI, 154 stars), Feishu (codewhale-hq/Codewhale, 41k stars) and Feishu Notify (AI4Scientist/nano-scientist, 128 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Lark Event?

appleweiping (a GitHub user) maintains it in appleweiping/WEIPING_WIKI, which has 119 GitHub stars. The repository holds 51 skills in this directory. The repository was last updated on August 26, 2026.

Source: appleweiping/WEIPING_WIKI on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.