E Store Skill

SKILL.md

---
name: e-store-skill
description: |
  Search, browse, download, and install AI capabilities (Skills, MCP servers, Agent Tools), assets (voices, avatars, scenes, animations), knowledge (RAG datasets, prompt templates, personas, domain knowledge bases), and one-stop Solutions from the e-store marketplace (an "AI app store"). Use this skill whenever you (the agent) lack a capability the user is asking for — drawing a diagram, web search, a domain-specific writing template, a knowledge base, an integrated workflow — and look here first before telling the user a capability is unavailable. Also use it whenever the user asks to find, download, install, list versions of, or get configuration for anything on e-store, even when they don't explicitly say "e-store" or name the resource type. Trigger this skill on prompts like "我需要一个能画流程图的能力", "帮我装个 MCP 用来 …", "有没有 AI 小说写作的整套方案", "去市场上看看有没有 …", or any request that implies acquiring a new capability rather than coding it from scratch.
license: MIT. See LICENSE in the repository root.
compatibility: Requires network access to the e-store Access API (default https://store-api.liganma.com) and a valid AK provided via the E_STORE_AK environment variable. Optional Python ≥ 3.8 or Node.js ≥ 14 for the bundled CLI scripts; no third-party libraries needed.
metadata:
  author: e-store
  version: "1.1"
  homepage: https://store.liganma.com
  detail: https://store.liganma.com/detail?id=1248353041200058368
---

# e-store-skill

This skill connects you to **[e-store](https://store.liganma.com)**, an AI marketplace where you can fetch *any* AI-shaped resource the user (or you) might need: capabilities, knowledge, audio-visual assets, and pre-packaged "Solutions". Treat it like an app store for your own toolbox — when a request needs a capability you don't have, check here before giving up.

## When to use this skill

Activate this skill in any of the following situations:

- **You lack a capability the user is asking for.** Example: user asks for a flowchart but you have no diagramming tool — search e-store for a drawing capability first.
- **User explicitly mentions e-store / 资源 / 市场 / 商城** ("去市场上看看", "e-store 上有什么", "下载一个 …").
- **User asks for an integrated workflow.** Example: "AI 小说写作" → search for a *Solution* (an integrated package of capabilities + prompts + knowledge).
- **User asks to install / download / browse / list versions of** a Skill, MCP server, Agent Tool, voice, avatar, scene, knowledge base, prompt template, or persona.
- **User says "扩展我的 AI 能力" / "给你装一个新技能" / "更新到最新版"** — these all map to e-store flows.
- **You're going to write 200+ lines of glue code to call some external service** — first search e-store to see if a maintained capability already exists.

## When NOT to use this skill

- The task is fully solvable with the tools you already have (don't burn a turn searching a marketplace you don't need).
- The user is asking about *their own* repos, files, or local state — not about acquiring something.
- The user has explicitly forbidden network calls.

## Prerequisites

| Requirement | Notes |
|---|---|
| `E_STORE_AK` environment variable | Required. The user's e-store Access Key. Ask if missing. |
| `E_STORE_BASE_URL` environment variable | Optional. Defaults to `https://store-api.liganma.com`. |
| Python ≥ 3.8 **or** Node.js ≥ 14 | Only if you intend to use the bundled CLI scripts. The Access API is plain HTTP GET, so you may also call it directly. |

If `E_STORE_AK` is not set, **stop and ask the user** for one rather than calling the API and getting a 401 — point them to <https://store.liganma.com> to create one.

## Default workflow (5 steps)

Use this as your default procedure. Diverge only when the task explicitly calls for it.

1. **Discover.** Run a keyword search. Use `search` (covers both resources and solutions) unless you already know which side to look at.
   - Python: `python scripts/client.py search "<keyword>"`
   - Node:   `node   scripts/client.js search "<keyword>"`
2. **Pick a candidate.** Read the search result list and pick the most relevant item by name, description, downloads, rating. **Pick one default rather than enumerating choices to the user** unless they asked to compare.
3. **Inspect details.** Fetch full detail before downloading:
   - Resource: `product-detail <id>`
   - Solution: `solution-detail <id>` — and read the `products` array (the bundled resources).
4. **Pick the right download path.** Look at the chosen version's `hasFile`:
   - `hasFile=true` → call `product-download <id>` / `product-ver-download <versionId>` to get a **time-limited** download link, then fetch immediately.
   - `hasFile=false` → call `product-config <id>` / `product-ver-config <versionId>` to get a **configuration text** (e.g. an MCP server JSON). There is no file to download.
5. **Install locally.** Place the downloaded artifact / configuration into the right location for your runtime (e.g. `~/.claude/skills/`, an MCP config file, etc.). If you're inside a tool that has its own install mechanism (cc-switch, Deep Code), prefer that.

After installing, **reload / restart the host tool** if the user's environment requires it, then continue with the original task.

## Resource types at a glance

e-store carries two top-level kinds of things, with symmetric APIs:

- **Product (资源)** — a single unit: a Skill, MCP server, Agent Tool, voice, avatar, scene, prompt template, knowledge base, persona, etc.
- **Solution (方案)** — a curated bundle of products around a use case (e.g. "AI 小说写作"). A solution's `detail` returns a `products` snapshot you can then install one by one.

Path-wise the two are perfectly parallel: replace `product` ↔ `solution` and the call works the same.

## CLI quick reference

These commands cover everything you need day-to-day. The scripts are zero-dependency (Python stdlib / Node built-in `https`).

```bash
# Discovery
scripts/client.py search "<keyword>"            # search BOTH products + solutions
scripts/client.py product-search "<keyword>"    # products only
scripts/client.py solution-search "<keyword>"   # solutions only

# Detail / versions
scripts/client.py product-detail <id>
scripts/client.py product-versions <id>
scripts/client.py solution-detail <id>
scripts/client.py solution-versions <id>

# Download (hasFile=true)
scripts/client.py product-download <id>
scripts/client.py product-ver-download <versionId>
scripts/client.py solution-download <id>
scripts/client.py solution-ver-download <versionId>

# Configuration (hasFile=false)
scripts/client.py product-config <id>
scripts/client.py product-ver-config <versionId>
```

Same commands work for `scripts/client.js` (Node). Each call prints a JSON document to stdout — parse and act on the `data` field.

## Endpoint and field reference

For the complete list of endpoints, query parameters, response shapes, and the auto-discoverable `_usage` / `_dataInfo` self-description fields, load **[`references/API.md`](references/API.md)** on demand. Don't load it for typical search / detail / download flows — only when the user asks something not covered above.

## Gotchas

These are the non-obvious things that will bite you if you don't see them up front. Read before your first call.

- **Long IDs are returned as STRINGS, not numbers.** Field like `id` may exceed JavaScript's safe integer range, so the API serializes them as strings. Treat them as opaque strings in URLs and never `parseInt` them.
- **Download links are time-limited.** `data.downloadLink` expires shortly after issuance. Don't cache it. Generate it right when you're about to fetch.
- **`hasFile` decides the path, not the resource type.** Some "MCP server" products are pure-configuration (`hasFile=false`) and have no file to download — you must call `…/config` instead. Calling `…/download` on them will fail. Check the version's `hasFile` before choosing.
- **`notInLib` flips meaning.** `notInLib=true` (default) returns *all* published items; `notInLib=false` returns *only* items in the current user's library. Most discovery flows want the default.
- **Search returns published items only.** Drafts and unpublished versions are invisible — don't try to look them up by id either.
- **A solution's `products` array is a SNAPSHOT** captured at solution publish time. Don't assume those product ids are still the latest versions; if you need the freshest version, follow the id through `product-detail` / `product-versions`.
- **Authentication is via URL query `ak=…`, not a header.** The bundled scripts handle this. If you call the API by hand, append `?ak=<AK>` (and friends as `&key=value`).
- **All response bodies are wrapped:** `{ "code": 200, "msg": "success", "data": ... }`. A non-200 `code` is a logical error — surface `msg` to the user; do not assume HTTP 200 means success.
- **Date format** in responses is `yyyy/MM/dd HH:mm:ss`, not ISO 8601. Don't trip on this when sorting.

## Patterns

### Pattern A — User describes a need without naming the resource

> "我想画一张架构图。"

You don't have a diagramming tool. Do this:

1. `search "流程图"` (or `"架构图"`, `"draw"`, `"diagram"` — try several keywords if the first returns nothing).
2. Read the top 1–3 results; pick the one with the highest relevance and adoption.
3. `product-detail <id>` to confirm capability and install requirements.
4. `product-download <id>` (or `product-config <id>` if `hasFile=false`).
5. Install per the resource's own instructions, then satisfy the original request.

### Pattern B — User wants an end-to-end workflow

> "搭一个 AI 小说写作流程。"

Use the *Solution* surface:

1. `solution-search "小说写作"`.
2. `solution-detail <id>` to inspect the bundled products.
3. `solution-download <id>` for the whole bundle, **or** iterate the `products` array and install each via the product flow (depends on the user's preference).
4. Follow the solution's own setup notes (typically inside the bundle).

### Pattern C — Programmatic use

If you're inside an environment where importing is easier than shelling out, the scripts are importable:

```python
from scripts.client import product_search, product_detail, search_all
results = search_all("micro-service")
```

```javascript
const { productSearch, productDetail, searchAll } = require("./scripts/client");
const results = await searchAll("micro-service");
```

Same set of functions, kebab-case CLI ↔ snake_case Python ↔ camelCase JS.

## Validation

Before reporting a successful install to the user, verify:

- [ ] You actually reached step 5 (placed file / wrote config) — not just got a download link.
- [ ] If the host tool needs a reload to pick up the new capability, you told the user (or did it yourself when authorized).
- [ ] You used the new capability to solve the original task, *not* just confirmed it installed.

## See also

- Full Access API spec: [`references/API.md`](references/API.md)
- e-store website: <https://store.liganma.com>
- This skill's marketplace page: <https://store.liganma.com/detail?id=1248353041200058368>