Loading...

lark-apps

Original：🇨🇳 Chinese

Translated

Feishu Miaoda Apps (lark-cli apps): Deploy local HTML files or directories as accessible, shareable Miaoda apps (static websites / web pages) and return access URLs; it also provides management capabilities such as app creation, update, listing, and setting access scopes (specific for designated visibility / public for open internet access / tenant for all enterprise members). Use this when users say phrases like 'Develop PPT / slides / presentations / demoable demos with HTML / web pages', 'Deploy / publish HTML / static websites / web pages / dist directories', 'Deploy HTML files in /xxx to Miaoda using lark-cli', 'Develop xxx and deploy it as a shareable website / accessible link / shareable URL', 'Generate a PPT / page / demo that can be shared with others', or mention keywords such as Miaoda / miaoda / apps / app_id / access scope / open-to-tenant / open-to-public. **Deployment Strategy: When users explicitly mention 'Deploy / publish / share / accessible / shareable URL', directly use `apps +html-publish` for automatic deployment and return the URL; when users only express vague intentions like 'Demoable / write a PPT / create a demo', after completing the HTML, first ask 'Do you want to deploy it to Miaoda for sharing?' before making a decision.**

352installs

Sourcelarksuite/cli

Added on2026-05-21

NPX Install

npx skill4agent add larksuite/cli lark-apps

Tags

Translated version includes tags in frontmatter

lark-cli feishu-miaoda static-site-deployment app-management html-publishing

SKILL.md Content (Chinese)

View Translation Comparison →

Apps (v1)

bash

# 常用示例
lark-cli apps +create           --name "客户调研问卷" --app-type HTML
lark-cli apps +html-publish     --app-id app_xxx --path ./dist
lark-cli apps +access-scope-set --app-id app_xxx --scope tenant

Prerequisites — Must Read Before Execution

CRITICAL — Before performing the corresponding operations, you MUST use the Read tool to read the following files, none can be omitted:

```
../lark-shared/SKILL.md
```
— Authentication, permission handling, global parameters (applicable to all operations)
Create App (
apps +create
) → Must read
```
lark-apps-create.md
```
Update App Metadata (
apps +update
) → Must read
```
lark-apps-update.md
```
(partial update, unpassed fields remain unchanged)
Publish HTML / PPT / Static Website (
apps +html-publish
) → Must read
```
lark-apps-html-publish.md
```
(
```
--path
```
file vs directory, tar.gz packaging without filtering)
Set Access Scope (
apps +access-scope-set
) → Must read
```
lark-apps-access-scope-set.md
```
(mutual exclusion check for specific / public / tenant, targets JSON structure)

Failing to read the above files before performing operations will lead to incorrect parameter selection, violation of mutual exclusion rules, or incorrect file packaging.

Identity and One-Time Authorization

Miaoda apps are users' personal assets, use
--as user
uniformly (the CLI default

--as auto

will automatically fall to user according to shortcut declarations).

Obtain all scopes of this domain in one go before the first operation to avoid triggering a new round of authorization for each command's first run:

bash

lark-cli auth login --domain apps

End-to-End Process (HTML / PPT / Static Website Publishing)

Step 1: Determine whether the user's intention is "Explicit Deployment" or "Demo Only":

User Expression	Intention	Handling
"Deploy HTML in ./xxx", "Publish to Miaoda", "Develop xxx and deploy it as a shareable website / accessible link", "Generate a shareable URL"	Explicit Deployment / Sharing	Do not pause to ask questions, directly follow step 1→2 in the table below after completing the HTML
"Write a PPT / slides / presentation with HTML", "Create a demoable demo", "Write a page introducing xxx" (no mention of deployment / sharing / URL)	Demo Only	After completing the HTML, first output the local file path + brief description, proactively ask: "Do you want to deploy it to Miaoda for sharing with others?" Follow step 1→2 only if the user agrees; stop if the user says no

Step 2: After the user agrees to deploy / has explicitly requested deployment, follow the complete process below and return the final URL to the user:

Step	Command	Description
1. Create New App	`apps +create --name "<App name based on content theme>" --app-type HTML` → Get `app_id` from the response	Default to creating a new app (do not attempt to search / enumerate existing apps). When the user explicitly wants to reuse an existing app, ask them to provide either a Miaoda app link or app_id string (see "Quick Decisions" below); `--app-type` is required, currently only `HTML` is supported (case-sensitive), to be expanded in the future
1.5 Precheck	Run `apps +html-publish --app-id <id> --path <path> --dry-run` and check the `warnings` field	If sensitive files like `.git` / `.env` / `.pem` / `.key` are detected, stop* and list the warnings to the user; proceed to step 2 only after user confirmation; do not remove `--dry-run` to publish without confirmation
2. Publish HTML	`apps +html-publish --app-id <id> --path <file or directory>`	Mandatory step
3. Set Access Scope (Optional)	`apps +access-scope-set --app-id <id> --scope tenant\|public\|specific ...`	Use when users say "Make it public / visible to all employees / accessible to Alice / shareable on the internet", etc.

Script to report to users:

App "{name}" has been published, access link:
{url}

If the user does not specify an access scope but the scenario clearly requires sharing, proactively ask "Do you want to set it as visible to all enterprise members / open to the internet?", but do not ask unnecessarily.

Quick Decisions

When users explicitly say "Deploy / publish HTML in ./xxx", "Develop xxx and deploy it as a shareable website / accessible link", "Deploy to Miaoda" → Directly follow step 1→2 in the "End-to-End Process", use
```
apps +html-publish
```
for automatic deployment and return the URL, do not ask for confirmation
When users only say "Write a PPT / slides / presentation / demo with HTML", "Develop a demoable page" (no mention of deployment / sharing / URL) → After completing the HTML, first output the local path + brief description, proactively ask "Do you want to deploy it to Miaoda for sharing?", only proceed to publish if the user agrees; do not deploy without permission, but do not forget to ask
When users say "Open App X to all employees / the entire company" → Use
```
--scope tenant
```
, do not pass other flags
When users say "Make it public / accessible to anyone / visible on the internet" → Use
```
--scope public --require-login=<bool>
```
, choose one
When users say "Only allow Alice / a certain department / a certain group to access" → Use
```
--scope specific --targets <JSON>
```
; first convert names to
```
ou_id
```
using
```
contact +search-user
```
, convert group names to
```
chat_id
```
using
```
im +chat-search
```
If the user does not provide an app_id → Default to creating a new app with
apps +create --name "<Name based on content theme>" --app-type HTML
. Do not attempt to search / enumerate existing apps — The command to list apps is not visible to the Agent, and forcing a call will only waste an OAPI request. If the user explicitly wants to reuse an existing app, ask them to provide one of the following:
- Miaoda app link: In the format
```
https://miaoda.feishu.cn/app/app_xxxxxxxxxxxxx
```
  (or with trailing slash
```
/app/app_xxx/
```
  ) — The
```
app_id
```
  is the path segment after
```
/app/
```
  (starting with
```
app_
```
  ). Simple way to extract from URL:
```
APP_ID=$(echo "$URL" | sed -E 's|.*/app/([^/?#]+).*|\1|')
```
- app_id string: Directly provided by the user as
```
app_xxxxxxxxxxxxx
```
  , no further processing needed
```
--path
```
can accept either a single HTML file or a directory; directories will be recursively packaged into tar.gz without filtering, remind users to pass clean output directories (e.g.,
```
./dist
```
) to avoid packaging
```
.git
```
/
```
node_modules
```
together
```
apps +update
```
only updates passed fields, unpassed fields remain unchanged; at least one of
```
--name
```
/
```
--description
```
must be passed, otherwise it will be directly blocked during the Validate stage
The three scopes for
```
apps +access-scope-set
```
are mutually exclusive: specific requires
```
--targets
```
and does not allow
```
--require-login
```
; public requires
```
--require-login
```
and does not allow
```
--targets
```
/
```
--apply-enabled
```
/
```
--approver
```
; tenant does not allow any other flags
When failing, prioritize relaying
error.hint
(executable repair suggestions provided by the CLI); if hint is empty, fallback to
```
error.message
```
; do not repeat the envelope JSON as-is to the user

Shortcuts (Recommended for Priority Use)

Shortcuts are advanced encapsulations of common operations (

lark-cli apps +<verb> [flags]

). Use shortcuts preferentially for operations that have them.

Shortcut	Description
`+create`	Create a Miaoda app (name / description / icon-url)
`+update`	Partially update app name / description (only send passed fields)
`+access-scope-set`	Set app access scope (specific / public / tenant, mutual exclusion check)
`+html-publish`	Deploy local HTML files / directories / PPT / static websites as shareable Miaoda apps and return access URLs (call directly when users explicitly request deployment / sharing; ask users whether to deploy first when only "demoable" is mentioned)