e-store-skill#

This skill connects you to e-store, 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#

RequirementNotesE_STORE_AK environment variableRequired. The user's e-store Access Key. Ask if missing.E_STORE_BASE_URL environment variableOptional. Defaults to https://store-api.liganma.com.Python ≥ 3.8 or Node.js ≥ 14Only 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 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
• e-store website: https://store.liganma.com
• This skill's marketplace page: https://store.liganma.com/detail?id=1248353041200058368