⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

v1.0.0

aipanel-installer

simmzl@simmzl⭐ 6 stars· last commit 2mo ago· 0 open issues

Create, continue, recover, and verify AIPanel installations through a conversational one-command flow. Use when a user wants to start creating AIPanel, deploy a new AIPanel instance, resume an interrupted installation, check installer progress, or finish the final setup inputs needed before deployment.

Choose how to use this skill

You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.

1. Native installer

This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.

Do not guess an installer command or replace an existing version without reviewing the diff.

2. Complete package recommended

Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.

No complete ProSkills package is published for this listing yet.

3. Prompt-only

Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.

Need only the instruction file?

Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.

No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.

—/10

// RATINGS

⭐GitHub Stars
⭐ 6 on GitHubGitHub ↗

New / niche

🟢ProSkills Score
—
📍

Not yet listed on ClawHub or SkillsMP

// README

AIPanel

AIPanel is a lightweight bookmark and ops panel backed by Feishu Bitable, designed so humans and AI agents can operate the same structured dataset.

中文说明

What it is

AIPanel combines three pieces into one practical workflow:

  • a lightweight web panel for browsing and maintaining bookmarks
  • a Feishu Bitable-backed data model as the canonical data source
  • an AI-driven installer / operator path for setup and day-to-day maintenance

The browser is the human interface. Feishu Bitable is the canonical data source. OpenClaw is the default documented agent path. Claude Code, Cursor, and similar repo-aware AI coding agents can also drive the same installer flow when pointed at this repository.

Why AIPanel

Most bookmark dashboards are UI-first. AIPanel is different:

  • Shared canonical data source — bookmarks, categories, and ordering live in Feishu Bitable
  • Agent-first workflow — the same dataset can be operated by a person in the browser or by an AI agent
  • Practical UI — fast browsing, search, pinning, editing, and category maintenance without heavy admin overhead
  • Small deployment surface — one Vercel project, one Feishu app, one Bitable table
  • AI-installable — the repo includes an installer skill and installer CLI flow instead of relying only on a long manual setup document

Preview

DesktopMobile
AIPanel desktop homeAIPanel mobile home

Core capabilities

  • password-protected web panel
  • bookmark browsing and search
  • pinned and recent items
  • category tabs and drag-based category reordering
  • create / edit / delete bookmark flows
  • metadata fetching from target URLs
  • Feishu Bitable-backed API layer
  • agent operations against the same dataset
  • one-command installer path for agent-driven setup

How installation works

AIPanel supports two setup paths:

1. Recommended: AI-assisted install

Use this when you want an agent to help create the Feishu data source, assemble envs, deploy to Vercel, and guide the final setup.

Copy this sentence to your agent:

Please help me install this: https://github.com/simmzl/AIPanel/blob/main/README.md

After installation, if you want to import your current browser bookmarks, you can export them from your browser as an HTML file and provide that file to the AI agent helping you with setup, so it can import them into the Feishu Bitable used by AIPanel.

2. Manual install

Use this when you prefer to deploy directly through Vercel and configure Feishu / envs yourself.

Both paths end in the same architecture and env model.

Quick start: AI-assisted install

Step 1. Clone the repo

git clone https://github.com/simmzl/AIPanel.git
cd AIPanel

Step 2. Install the installer skill locally

For OpenClaw, install the skill with:

bash integrations/install-scripts/install-openclaw-installer-skill.sh

Default target path:

~/.openclaw/skills/aipanel-installer

If your AI agent uses a different local skill directory, copy the rendered installer skill from:

skills/aipanel-installer/

Step 3. Make sure required capabilities are already authorized

Before asking an agent to install AIPanel, make sure:

  • Feishu / Lark access is ready
  • Vercel deployment access is ready

Recommended:

Step 4. Ask your agent to start the install flow

Examples:

  • OpenClaw: 开始创建 AIPanel
  • Claude Code / Cursor / similar agents: ask the agent to continue the installer flow from:
node scripts/installer/cli.mjs continue

If the flow needs to create real Feishu or Vercel resources, the execution path becomes:

node scripts/installer/cli.mjs continue --execute

Step 5. Provide only the final required inputs when asked

The installer is designed to minimize questions.

In the common case, the only user-provided inputs are:

  • ACCESS_PASSWORD
  • FEISHU_APP_SECRET matching the auto-detected FEISHU_APP_ID

Step 6. Let the installer finish the rest

The installer flow handles:

  • preflight
  • Feishu Bitable creation
  • env assembly
  • Vercel deployment
  • final verify

Related docs:

Manual deploy

If you prefer the manual path, deploy the web app directly and configure the required envs yourself.

Deploy with Vercel

Canonical envs:

APP_NAME=AIPanel
ACCESS_PASSWORD=change-this-to-a-real-password
JWT_SECRET=change-this-to-a-long-random-secret
FEISHU_APP_ID=cli_xxx
FEISHU_APP_SECRET=xxx
FEISHU_BITABLE_APP_TOKEN=bascn_xxx
FEISHU_BITABLE_TABLE_ID=tblxxxxxx
FEISHU_BITABLE_SOURCE_URL=https://your-domain.feishu.cn/base/xxxxxxxx?table=tblxxxxxx

Manual setup docs:

Agent integration

You can use AIPanel without OpenClaw.

OpenClaw is the default documented agent integration in this repo, but it is not the only possible one. AIPanel’s installer and data model can also be driven by Claude Code, Cursor, and similar AI coding agents.

This repository currently ships with two agent-facing skills for OpenClaw:

  • aipanel-installer — start, continue, recover, and verify installation
  • aipanel-feishu-bitable — operate the deployed Feishu Bitable data source

Install both OpenClaw skills from the repo root:

bash integrations/install-scripts/install-openclaw-installer-skill.sh
bash integrations/install-scripts/install-openclaw-skill.sh

Optional render steps:

node scripts/render-openclaw-installer-skill.mjs
node scripts/render-openclaw-skill.mjs

Architecture

AIPanel architecture

AIPanel uses a Feishu-first architecture:

  • Vercel hosts the web app and API
  • Feishu Bitable is the canonical data source
  • AI agents operate setup and data workflows when needed
  • Browser UI is the human-facing control surface

Repository guide

If you are new to the repo, start here:

Operational docs:

Project status

License: MIT
Deployment target: Vercel + Feishu Bitable

Current state:

  • the web panel is deployable and usable as a real product
  • Feishu Bitable is the canonical data source
  • the OpenClaw skill path is available
  • the installer skill and installer CLI flow are implemented for AI-assisted setup

Environment naming

Use these canonical env names in setup and documentation:

  • FEISHU_BITABLE_APP_TOKEN
  • FEISHU_BITABLE_TABLE_ID

Public docs and deployments should use these names consistently.

Summary

AIPanel is a practical bookmark panel for people who want one shared Feishu-backed dataset that both humans and AI agents can operate through a lightweight web UI and an agent-driven workflow.

// HOW IT'S BUILT

// FILES

2 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

  • integrations/openclaw-installer-skill/SKILL.md3.3 KBupstream ↗
    ---
    name: aipanel-installer
    description: Create, continue, recover, and verify AIPanel installations through a conversational one-command flow. Use when a user wants to start creating AIPanel, deploy a new AIPanel instance, resume an interrupted installation, check installer progress, or finish the final setup inputs needed before deployment.
    ---
    
    # AIPanel Installer
    
    Drive the AIPanel installer as a conversational workflow.
    
    This skill is responsible for the **instance creation path**:
    
    - start a new AIPanel installation
    - continue a paused installation
    - report installer progress
    - collect the final user inputs
    - finish Vercel deployment
    - verify the deployed result
    
    Do **not** use this skill for normal bookmark/category CRUD on an already-installed panel. That remains the job of `aipanel-feishu-bitable`.
    
    ## Workflow
    
    When a user says things like:
    
    - 开始创建 AIPanel
    - 创建 AIPanel
    - 安装 AIPanel
    - 继续 AIPanel 安装
    - 恢复 AIPanel 安装
    - 看看 AIPanel 装到哪一步了
    
    follow this sequence:
    
    1. Prefer `node scripts/installer/cli.mjs continue` as the single orchestration entrypoint
    2. Use `node scripts/installer/cli.mjs continue --execute` when the flow needs to create real Feishu or Vercel resources
    3. Use `node scripts/installer/cli.mjs status` when you only need a conversational progress summary
    4. Use `node scripts/installer/cli.mjs verify` when you need to re-check the final deployment result
    
    ## Final user inputs
    
    The installer should minimize questions.
    
    By default, only ask the user for:
    
    - `ACCESS_PASSWORD`
    - `FEISHU_APP_SECRET`
    
    The installer should:
    
    - auto-generate `JWT_SECRET`
    - auto-detect `FEISHU_APP_ID`
    - auto-create `FEISHU_BITABLE_APP_TOKEN`
    - auto-create `FEISHU_BITABLE_TABLE_ID`
    - auto-create `FEISHU_BITABLE_SOURCE_URL`
    
    ## Asking for Feishu App Secret
    
    When asking for `FEISHU_APP_SECRET`, always include the detected `FEISHU_APP_ID` in the message.
    
    Use wording equivalent to:
    
    > 请提供与我自动识别到的 Feishu App ID `cli_xxx` 对应的 App Secret。
    
    Never ask for an App Secret without naming the App ID it must match.
    
    If `FEISHU_APP_ID` is not available, do not pretend the secret request is unambiguous. Report the block and ask the user to fix the local Feishu/Lark auth context first.
    
    ## Progress reporting
    
    Keep user-visible updates short and stage-based.
    
    Good examples:
    
    - 前置检查通过,正在创建 Feishu 数据源。
    - Feishu 数据源已经创建完成,现在只差访问密码和 App Secret。
    - Vercel 部署已完成,正在验证面板是否可访问。
    
    Avoid dumping raw CLI logs unless the user explicitly asks.
    
    ## Recovery rules
    
    Prefer resume over restart.
    
    - If Feishu app/table/source URL already exist in installer state, reuse them.
    - If only final inputs are missing, ask for them instead of re-running earlier stages.
    - If Vercel project info already exists, continue from deploy-related steps when possible.
    - If the user returns later and says “继续”, inspect state first and continue from the current stage.
    
    Read details as needed:
    
    - `references/flow.md`
    - `references/recovery.md`
    - `references/prompts.md`
    
    ## Success criteria
    
    Before claiming completion, confirm at least:
    
    - a deployment URL exists
    - the deploy step succeeded
    - the installer state contains the final deployment URL
    
    If verification is incomplete, say so explicitly rather than overstating success.
    
  • README.mdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

Plain-text copy, no login: /skill-bundles/simmzl-aipanel-integrations-openclaw-installer-skill.md

// REPO STATS

6 stars
0 open issues
Last commit: 2mo ago