# aipanel-installer

Adopt this skill: https://proskills.md/skills/other/simmzl-aipanel-integrations-openclaw-installer-skill

Page: https://proskills.md/skills/other/simmzl-aipanel-integrations-openclaw-installer-skill
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: integrations/openclaw-installer-skill/SKILL.md
size: 3406
upstream: https://github.com/simmzl/aipanel/blob/main/integrations/openclaw-installer-skill/SKILL.md

```text
---
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.
```

## File: README.md
upstream: https://github.com/simmzl/aipanel/blob/main/README.md

````text
# 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**.

[中文说明](./README.zh-CN.md)

## 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

| Desktop | Mobile |
| --- | --- |
| ![AIPanel desktop home](docs/assets/screenshots/desktop-home.png) | ![AIPanel mobile home](docs/assets/screenshots/mobile-home.png) |

## 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

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

### Step 2. Install the installer skill locally

For OpenClaw, install the skill with:

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

Default target path:

```bash
~/.openclaw/skills/aipanel-installer
```

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

```bash
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:

- install and authorize the Feishu CLI: <https://github.com/larksuite/cli>
- make sure your Vercel CLI or deployment capability is already logged in

### 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:

```bash
node scripts/installer/cli.mjs continue
```

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

```bash
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:

- [One-command installer plan](docs/product/aipanel-one-command-installer-plan.md)
- [Installer phase 1](docs/product/aipanel-installer-phase-1.md)
- [OpenClaw integration](docs/integrations/openclaw.md)

## Manual deploy

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

[![Deploy with Vercel](https://vercel.com/button)](https://vercel.com/new/clone?repository-url=https://github.com/simmzl/AIPanel)

Canonical envs:

```env
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:

- [Vercel deployment](docs/deploy/vercel.md)
- [Feishu app + Bitable setup](docs/datasource/feishu-bitable.md)
- [Troubleshooting](docs/troubleshooting.md)

## 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
bash integrations/install-scripts/install-openclaw-installer-skill.sh
bash integrations/install-scripts/install-openclaw-skill.sh
```

Optional render steps:

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

## Architecture

![AIPanel architecture](docs/assets/diagrams/aipanel-architecture.svg)

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:

- [Docs index](docs/README.md)
- [Architecture overview](docs/architecture.md)
- [OpenClaw integration](docs/integrations/openclaw.md)
- [Contributing](./CONTRIBUTING.md)

Operational docs:

- [Troubleshooting](docs/troubleshooting.md)
- [Open-source readiness checklist](docs/product/open-source-readiness-checklist.md)
- [Roadmap](docs/product/roadmap.md)

## 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.
````
