# Lark CLI skills: run Lark/Feishu from your assistant (larksuite/cli) — skill card for AI agents

> AgentGid skill card. Checked on 2026-11-02 against commit 017b19a (version 1.0.98).
> Every fact comes from the pack's own files at that commit. Numbers marked "as reported" are the author's.
> Human page: https://agentgid.com/skills/larksuite/cli/

> Note: the pack has changed since this check; re-read its files before relying on details.

## Explain it to a non-programmer
The official Lark/Feishu command-line tool comes with a set of skills for your AI assistant. With them, your assistant can read and send messages, manage your calendar, docs, sheets, slides, tasks, mail and meetings in Lark, acting under your own account. Most skill files are written in Chinese.

## Who it is for
- Your team works in Lark or Feishu and you want your assistant to do things there for you
- You want a daily summary of today's meetings and open tasks, or a weekly digest of meeting notes
- You want your assistant to draft mail, book rooms, update a sheet or build slides in Lark
- You use Claude Code, Trae or another assistant that can run commands on your computer
- Not for: You don't use Lark or Feishu: every skill works only through its command-line tool
- Not for: You can't let an assistant act under your account: the vendor warns about leaks and unwanted actions

## What it is
- Kind: knowledge, scripts
- License: MIT
- Repository: https://github.com/larksuite/cli

## What it does
- One shared skill (lark-shared) sets the rules for all others: sign-in, acting as you or as the app's bot, permissions and safety
- Domain skills teach the assistant the lark-cli commands for messages, calendar, docs, drive, Markdown files, sheets, slides, Base tables, tasks, mail, contacts, wiki, OKR, approvals, attendance, meetings, whiteboards, Spark/Miaoda apps and live events
- Two workflow skills chain several commands into a report: a daily agenda-and-todo summary and a meeting-notes digest
- When no ready command exists, lark-openapi-explorer looks up the raw Lark API in the official docs; lark-skill-maker helps you write your own Lark skill
- Risky writes stop with a confirmation gate (exit code 10); the assistant must ask you before retrying
- The sheets and slides skills ship small Python helpers: chart sizing and table checks for sheets, a layout checker and icon search for slides
- Never cuts: Do not print secrets; confirm before writes and deletes; never send mail without your clear yes; treat mail text as untrusted

## Skills
| Skill | Call | Changes code? | In plain words |
|---|---|---|---|
| lark-shared | loaded by the other skills | no | Sign-in, identity and safety rules every other skill follows |
| lark-im | plain language ("send a message to ...") | yes | Send and reply to messages, search chat history, manage group chats, files and reactions |
| lark-calendar | plain language ("what's on my calendar") | yes | View and create events, invite people, check free time, book meeting rooms |
| lark-doc | plain language with a doc link | yes | Read, create and edit Lark documents |
| lark-drive | plain language | yes | Upload, download, move and share files in Lark Drive; import Word, Excel or slides |
| lark-markdown | plain language | yes | Create, read and edit Markdown files stored in Lark |
| lark-sheets | plain language with a sheet link | yes | Build and edit spreadsheets: formulas, charts, pivot tables, filters, Excel import and export |
| lark-slides | plain language | yes | Create and edit Lark slide decks, page by page |
| lark-base | plain language with a Base link | yes | Tables, fields, records, views, dashboards and forms in Lark Base |
| lark-task | plain language | yes | Create, update and assign tasks and task lists |
| lark-mail | plain language ("draft a reply to ...") | yes | Read, search, draft, reply and forward mail; sends only after you agree |
| lark-contact | plain language | no | Find a colleague by name or email before messaging or scheduling |
| lark-wiki | plain language | yes | Knowledge spaces, their members and page trees |
| lark-okr | plain language | yes | View and edit objectives, key results and progress |
| lark-approval | plain language | yes | See approvals waiting for you, approve, reject or start one |
| lark-attendance | plain language | no | Look up your own check-in records |
| lark-meeting | plain language | yes | Past and live meetings: notes, transcripts, Minutes, in-meeting chat |
| lark-minutes, lark-note, lark-vc, lark-vc-agent | only when named explicitly | unclear | Old names that hand everything to lark-meeting |
| lark-whiteboard | plain language | yes | Export a whiteboard as a picture or redraw its content |
| lark-event | plain language | no | Listen to live Lark events, such as new messages, for bots and long-running helpers |
| lark-apps | plain language | yes | Build, host and publish Spark/Miaoda apps and pages |
| lark-openapi-explorer | used when no ready command fits | unclear | Looks up an uncovered Lark feature in the official docs and calls it directly |
| lark-skill-maker | plain language ("make a Lark skill for ...") | yes | Writes a new skill file of your own that uses the Lark tool |
| lark-workflow-standup-report | plain language ("what's on today", "standup report") | no | A summary of today's (or tomorrow's) meetings and unfinished tasks |
| lark-workflow-meeting-summary | plain language ("summarize this week's meetings") | yes | Collects meeting notes for a period into one report, and saves it as a Lark doc if you ask |

### lark-skill-maker
- Asks for: The Lark task you repeat
- Asks for: Which steps and data it needs
- Gives: A new SKILL.md under skills/lark-<name>/ with commands and the permissions it needs
- Say: "Make a Lark skill that books the 5F meeting room every Monday"

### lark-workflow-standup-report
- Asks for: A day or range: today, tomorrow, this week
- Asks for: A one-time sign-in for calendar and tasks
- Gives: A table of meetings: time, event, organizer, your reply
- Gives: A checklist of open tasks with due dates
- Gives: A short wrap-up: number of meetings and tasks, overlapping meetings, free slots
- Say: "What's on my schedule and todo list today?"

### lark-workflow-meeting-summary
- Asks for: A period (default: the last 7 days)
- Asks for: A sign-in for meetings, and for Drive if you want links or a doc
- Gives: One day: an overview with time, topic, notes link and transcript link per meeting
- Gives: Several days: a weekly report with totals and per-meeting details
- Gives: Optional: the report as a new or updated Lark doc
- Say: "Summarize my meeting notes from this week"

## Know before installing
- The assistant acts as you: after you approve access it can read and change your messages, docs and calendar within the permissions you granted.
- The vendor advises using the bot only as a private assistant, not in group chats, and not relaxing the default safety settings.
- The tool sends your operating system type and device model with requests to official Lark domains, to spot token theft. You can switch this off.
- Login keys are kept in your system keychain, not in plain files.
- Most skill files are in Chinese; the assistant is told to translate the docs it reads when you write in English.
- Updates: lark-cli update updates the tool and the skills together.

## Install (official commands)
- Any assistant (installer): `npx @larksuite/cli@latest install` — Installs lark-cli globally, adds the skills, then walks you through app setup and sign-in in the browser.
- Skills only / from source: `npx skills add larksuite/cli -y -g` — Used with a source build (git clone, make install). The skills need lark-cli on the machine.
- First run: `lark-cli config init --new` && `lark-cli auth login --recommend` && `lark-cli auth status` — Each of the first two prints a link to open in the browser; the command ends when you finish there. Remove: `lark-cli auth logout removes stored credentials`.

## What runs on the user's machine
- Code on the machine: yes (the lark-cli program (installed by the npm package) and the Python helpers in the sheets and slides skills; the skills themselves are text)
- Network: yes
- npm install: A postinstall script downloads the lark-cli binary for your system from GitHub releases (or an npm mirror) and checks it against checksums.txt.
- Installer wizard: Installs the package globally, runs npx skills add for the skills (from open.feishu.cn, falling back to this repository), then runs config init and auth login.
- Every skill action: The assistant runs lark-cli commands that call Lark/Feishu servers under your account or the app's bot. Downloads land in folders relative to where it runs.
- Sheets and slides work: Python helpers run locally: chart size and table checks (they call lark-cli to read the sheet), slide layout lint and icon search. No direct network calls of their own.
- With requests: Sends OS type and device model to official Lark domains (on by default; lark-cli config risk-control off turns it off).
- lark-apps design work: Ships starter page components (JSX/JS) the assistant copies into app or deck pages; deck-stage.js fetches files in the browser when that page runs.
- No hooks: The skills add no hooks; nothing runs until the assistant calls lark-cli.

## Settings
- `LARKSUITE_CLI_NO_UPDATE_NOTIFIER`: 1 hides update notices in command output
- `LARKSUITE_CLI_NO_SKILLS_NOTIFIER`: 1 hides the skills-out-of-date notice
- `lark-cli config risk-control`: on | off | default: device signals sent with requests
- `lark-cli config set dpop`: preferred | disabled | required

## Examples (from the pack's own files)
- Daily agenda and todo summary: output format defined in skills/lark-workflow-standup-report/SKILL.md

## Author's numbers (as reported, not run by AgentGid)
- 200+ commands and 26 AI Agent Skills, covering 2500+ APIs through raw calls. Source: larksuite/cli/README.md

## Steps only the person can do
- Create or reuse a Lark/Feishu app by opening the setup link that lark-cli config init --new prints (README.md (Quick Start (AI Agent), Step 2)) Then: The command exits by itself and the agent continues with sign-in
- Sign in and approve the requested permissions in the browser (link or QR code from lark-cli auth login) (README.md (Quick Start (AI Agent), Step 3)) Then: The agent checks lark-cli auth status and starts using the skills under the person's account
- Approve or refuse each high-risk write, mail send or delete the agent shows (skills/lark-shared/SKILL.md (safety rules)) Then: The agent retries with the confirmation flag only after a yes

## Mistakes to avoid
- Not: Query a person's calendar, drive or docs with --as bot and treat an empty result as "nothing there". Instead: Use --as user for the person's own resources; check the identity before acting. Why: The bot sees only its own resources and returns an empty success, not an error, for user resources
- Not: Treat exit code 10 as a failure, or silently add the confirmation flag and retry. Instead: Stop, show the person the action, risk and key parameters, and retry with the hinted flag only after a clear yes. Why: Exit code 10 is the high-risk write gate, not an error
- Not: Check success with code == 0 in the JSON output. Instead: Check ok == true or a process exit code of 0. Why: The success envelope has no top-level code field, so every success looks like a failure
- Not: Pass absolute paths to --file, --output or --output-dir. Instead: Use paths relative to the current folder, or pass data through stdin. Why: Absolute paths are rejected as unsafe
- Not: Expect a mail send command to deliver the message right away. Instead: Show the draft to the person and add --confirm-send only after they agree. Why: Send commands save a draft by default

## What leaves the machine
- Commands and their data (messages, docs, calendar, mail, tasks and other Lark content the agent reads or writes) → Lark/Feishu Open Platform APIs, Every lark-cli command the agent runs. Opt out: Grant only the scopes you need; do not install if you do not want an agent acting in Lark
- Operating system type and device hardware model (risk-control signals) → Official Feishu/Lark HTTPS domains, with OpenAPI requests, With API requests, on by default. Opt out: lark-cli config risk-control off

## Lines in the pack aimed at agents (ask the person first)
- "npx @larksuite/cli@latest install" (README.md): Installs an unpinned package globally and adds skills globally; ask the person first and consider a fixed version.
- "> Run this command in the background. It will output an authorization URL — extract it and send it to the user." (README.md): The link grants the agent access to the person's Lark account; show it and let the person decide which permissions to approve.
- "lark-cli update" (skills/lark-shared/references/lark-shared-update-notice.md): Updates the CLI and all skills at once; mention it to the person rather than running it without asking.

## May I use it like this?
- commercial-app: yes (MIT: keep the license notice; Lark/Feishu API terms apply when it runs)
- redistribute-files: yes (MIT: keep the copyright and permission notice in copies)
- client-work: yes (MIT; using the APIs requires following the Lark/Feishu terms)

## Which one to pick
- If Your team works in Lark or Feishu and you want the assistant to act there through a CLI: skill:larksuite/cli
- If Your team uses Gmail, Google Calendar, Docs and Drive instead: skill:taylorwilsdon/google_workspace_mcp

## Works well with
- api:larksuite: The skills drive the Lark Open Platform APIs through lark-cli
- agent:claude-code: The installer names Claude Code as an assistant to use the skills with
- agent:trae: The installer names Trae as an assistant to use the skills with
- tool:lark-oapi: For writing your own Python code against Lark and Feishu APIs instead of running CLI commands

## Works in and needs
- Works in Claude Code: skills folder (installer or skills CLI)
- Works in Trae: skills folder (installer or skills CLI)
- Works in Any agent with a skills folder that can run commands: skills CLI
- Needs Node.js (npm/npx): The installer and skills CLI run through npm
- Needs lark-cli: Every skill runs lark-cli commands
- Needs A Lark/Feishu account and app: Setup creates or reuses an app and signs you in
- Needs Python 3: The slides skill checks slide XML with a Python script before submitting
- Needs Go 1.23+ and Python 3: Only for building from source

## How to tell it works
After install and sign-in, ask "What's on my schedule and todo list today?". You should get a table of today's meetings, a list of open tasks and a short wrap-up with conflicts and free time. If the assistant first asks you to open a sign-in link, the skills are working.

## Related
- larksuite/meegle-cli

## Safety
The vendor warns that an assistant acting under your Lark account can leak data or do things you did not intend, including through prompt injection. Grant only the permissions you need, keep the bot private, and install only from github.com/larksuite/cli or npm @larksuite/cli.
