Feishu Lark CLI

    1

    Drive the official Feishu/Lark CLI from an agent: 23 domains, real shortcuts, safe writes, approvals

    Free

    Security scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Feishu Lark CLI

    Example session with this skill installed

    Send the 1.2.0 release note to the team chat and put the three open blockers into the sprint bitable.

    • Read your context and instructions
    • Compiled the feishu lark cli

    Resolved the chat and the Base table, then:

    1. im +chat-search --query "release" -> chat_id oc_xxx, confirmed with the user.
    2. im +messages-send --chat-id oc_xxx --text "<release note>" -> ok, exit 0, message id returned.
    3. base +field-list then base +record-list -> the sprint table's real field names.
    4. base +record-batch-create (previewed with --dry-run first) -> 3 records written; re-read shows 17 -> 20.
      Note: two blockers had no owner, so the owner field was left empty rather than guessed.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    A playbook for driving the official Feishu/Lark CLI (lark-cli) from an AI agent, verified against the 1.0.98 binary's own help output. One vendor in depth, not a cross-platform bridge: everything is lark-cli and the Feishu/Lark API, with no DingTalk or WeCom path.

    What it gives the agent:

    • The verified command surface. All 23 Lark domains with their real +shortcut verbs — messages and chats, docs, Base records (batch create, update, upsert, delete, search), sheet cells, calendar events, tasks, approvals — plus the typed-command form (<domain> <resource> <method>) for API methods with no shortcut, schema <service.resource.method> for one method's parameters and scopes, and api GET /open-apis/... as the escape hatch.
    • The embedded domain guides. The binary ships model-written guides (lark-cli skills list, lark-cli skills read lark-base) and every domain's --help points at its own. The skill makes that step 0, which is why it can stay short and still be deep.
    • The mechanics that get mishandled. Each command's --help prints read | write | high-risk-write; a high-risk write exits 10 and needs the user's explicit confirmation before the command is re-run with --yes. --dry-run previews any API call without executing it, --jq filters output, --page-all avoids the first-page mistake, success is the envelope's ok == true, errors are JSON on stderr, and path arguments accept only paths relative to the working directory (with a cwd parameter for anything else).
    • The auth lifecycle as it behaves. App initialization (config init --new) is a separate phase from account sign-in (device code plus QR); config.configured=false means the first phase never happened; login_wait blocks for at most 600 seconds and can simply be called again while the user is still on their phone.

    It adds a command-for-the-job table that maps a user's sentence onto a domain, a command and the ids it needs, plus setup for Windows, macOS and Linux: where the binary comes from, how to verify it, and how to keep app secrets on stdin instead of the command line. The DeepSeek Harness plugin dsh-feishu-cli is one install path that exposes these as agent tools and a sign-in panel; on any other client the same commands run in a shell.

    It covers lark-cli only: Meegle (Feishu Projects) needs the separate meegle-cli, and there is no DingTalk or WeCom path. Command names move between CLI versions, and the reference plugin's README occasionally lags the binary (its chips say im +chats-list and base +records-list; 1.0.98 has +chat-list and +record-list), so the skill sends the agent to <domain> --help and skills read rather than trusting a hard-coded verb. Every call runs under the user's own Feishu identity and granted scopes; nothing here bypasses the tenant permission model. Commands are spawned directly, so there is no shell: pipes, redirects and variable expansion do not work.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 6 days ago

    • Free with an Agensi account

    Requires

    GitHub
    Feishu
    Larksuite
    Npmmirror
    Feishu or Lark account
    Custom app initialized in the tenant
    lark-cli 1.0.98 for your platform
    Approved scopes for the domains you use
    Network access to the Feishu/Lark API
    Node.js

    Permissions

    Allowed Hosts

    open.feishu.cn
    open.larksuite.com
    registry.npmmirror.com
    github.com

    File Scopes

    ~/.lark-cli
    ~/.dsh/feishu-cli/bin
    OS
    temp
    directory

    Network calls go to the Feishu/Lark open platform (made by the CLI, as the signed-in user) and, only on first install, to the CLI download sources. Credentials are owned by `lark-cli` in `~/.lark-cli` with tokens in the OS credential store; the plugin keeps no copy and writes no telemetry. The binary is verified against a built-in SHA-256 before it is executed. The host list records the CLI's own targets rather than documented per-brand endpoints; the reference plugin pins `open.feishu.cn` in its tests and records the tenant brand in `config show`.

    Listed6 days ago

    What's inside

    Frequently Asked Questions

    Yes. The skill drives the official `lark-cli`, which serves both `feishu.cn` and `larksuite.com` tenants, and the command vocabulary is identical; `config show` records which brand the signed-in app belongs to. Tenant policy, not the command set, is what differs — enterprise tenants may require administrator approval for app creation or scopes.

    No. The recommended setup creates and authorizes your own custom app through the CLI's one-step flow, and `config show` returns the secret already masked. If you supply credentials yourself, pass the value through the tool's stdin parameter to a command using `--app-secret-stdin`, so it never appears in argv, the process list or logs.

    Yes, within the scopes you granted — and the CLI marks those commands. Each command's `--help` states read | write | high-risk-write; a high-risk write exits 10 and is only re-run with `--yes` after the user confirms. The skill instructs the agent to preview with `--dry-run` first, show the exact command, and never confirm on the user's behalf. Several spreadsheet and drive commands are irreversible and fail-fast, which the reference notes explicitly.

    No. The plugin is one install path: it exposes `feishu_cli` and `feishu_auth` as agent tools and adds a sign-in panel with the QR flow and CLI download. On Claude Code, Codex CLI, Cursor or anything else with shell access, install `lark-cli` yourself, put it on PATH or set `LARK_CLI_BIN`, and run the same argv.

    Run `lark-cli <domain> --help` for the live verb list, or `lark-cli skills read lark-<domain>` for the embedded guide that explains which command fits the task. The skill flags the version-dependent spots and names the spellings verified against 1.0.98, so the agent looks things up instead of guessing.

    New in Productivity