e-store-skill

intent

this skill connects you to e-store, an ai marketplace where you fetch capabilities (skills, mcp servers, agent tools), assets (voices, avatars, scenes, animations), knowledge (rag datasets, prompt templates, personas, domain bases), and pre-packaged solutions. use it whenever the user needs something you don't have in your toolbox, or when they explicitly ask to find/download/install/list/configure anything from e-store. treat it like an app store for your own abilities. trigger it on requests like "i need a flowchart drawing capability", "install an mcp for…", "is there an ai novel-writing solution", "check the marketplace for…", or any prompt implying acquire-vs-build logic.

inputs

input	type	notes
E_STORE_AK env var	string	required. user's e-store access key. stop and ask for one if missing; point to https://store.liganma.com
E_STORE_BASE_URL env var	string	optional. defaults to https://store-api.liganma.com. some orgs run private mirrors.
network access	connectivity	required. the skill is pure http.
python ≥3.8 or node.js ≥14	runtime	optional. only if using bundled cli scripts. you can call the api directly via http.
user's original request	string	the capability or asset the user needs. may be implicit ("draw me a diagram") or explicit ("install the voice pack").

gotcha on auth: the api uses url query ak=…, not a bearer header. the bundled scripts handle this. if calling by hand, append ?ak=<AK>&other=param.

procedure

default workflow (5 steps)

follow this unless the task explicitly diverges.

1. discover via keyword search. call search "<keyword>" (covers products and solutions together) unless you already know which surface to target. use the bundled cli or call the http api directly.

   • cli: python scripts/client.py search "<keyword>" or node scripts/client.js search "<keyword>"
   • http get: https://store-api.liganma.com/api/search?keyword=<keyword>&ak=<AK>
   • output: json array under data field. each item has id, name, description, downloads, rating, type (either "product" or "solution").

2. pick the strongest candidate. read the search results and pick one by name match, description relevance, download count, and rating. do not enumerate the list to the user unless they explicitly asked to compare. pick a default and move forward.

3. fetch full details. call product-detail <id> or solution-detail <id> depending on what you picked in step 2.

   • cli: python scripts/client.py product-detail <id> or node scripts/client.js product-detail <id>
   • http get: https://store-api.liganma.com/api/product/detail?id=<id>&ak=<AK> (or /solution/detail)
   • output: json object under data. read versions array to find the latest stable version. for solutions, also read the products array (snapshot of bundled resources).

4. choose download path based on hasFile flag. inspect the version object:

   • if hasFile=true: the resource includes a downloadable file. call product-download <id> or product-ver-download <versionId>. output is a json object with downloadLink (time-limited url). fetch the file immediately over http.
   • if hasFile=false: the resource is pure configuration (e.g., an mcp server json config or a persona prompt). call product-config <id> or product-ver-config <versionId>. output is a json object with config (text blob). write this directly to disk at the right location.

5. install locally. place the downloaded file or config text into the runtime location for your host tool:

   • skills: typically ~/.claude/skills/ or the tool's designated skill folder.
   • mcp servers: write config to ~/.mcp-servers.json or the tool's mcp config location.
   • voices/avatars: platform-specific paths (check the resource's own docs).
   • if the host tool has a built-in package manager (e.g., cc-switch, deep code), prefer that over manual file drops. after placement, reload/restart the host if needed so it picks up the new capability. then use the new capability to solve the original task.

response parsing gotcha: all api responses are wrapped: { "code": 200, "msg": "…", "data": … }. check the code field; non-200 means logical error, not http error. surface msg to the user.

decision points

• if E_STORE_AK is not set: stop immediately. ask the user for one. do not attempt the api call or you will get a 401. direct them to https://store.liganma.com to create an access key.

• if the user lacks a specific capability and asks how to get it: this skill is the right answer. if the user asks for a capability you do have, or is describing a task solvable with existing tools, do not burn a turn on e-store. use local tools first.

• if search returns zero results: try a different keyword or ask the user to clarify what they're looking for. if e-store has nothing, acknowledge that and discuss building vs. sourcing externally.

• if the candidate's hasFile=false but you called product-download anyway: the api will return an error (non-200 code). catch this, re-read the version's hasFile, and call product-config instead. never assume file availability by resource type.

• if a download link expires before you fetch: request a fresh link by calling the download endpoint again. links are time-limited (typically 15 minutes). do not cache or pass stale links to the user.

• if a solution's bundled products are outdated: the products array in a solution detail is a snapshot from publish time, not live. if the user needs the latest version of a product inside a solution, follow the product id through product-detail and product-versions to fetch the newest. do not assume snapshot = latest.

• if the user asks to browse by category or filter by tag: the full api reference in references/API.md documents query parameters for filtering. check that doc if search alone doesn't narrow it down. for a typical session, search is enough.

• if the user wants to list all versions of a product or solution: call product-versions <id> or solution-versions <id>. output is a json array under data. pick the latest stable version unless the user specified otherwise.

output contract

on success:

• the resource (file or configuration text) is placed at the correct runtime location:

  • skills: in the tool's skills directory (e.g., ~/.claude/skills/my-skill/).
  • mcp servers: in the mcp config file (e.g., ~/.mcp-servers.json), entry added and syntax valid.
  • voices/avatars/scenes/animations: in the platform's asset directory per the resource's own docs.
  • knowledge bases, personas, prompt templates: in the designated knowledge store or prompt library.

• if the host tool requires a reload to register the new capability, you have done so (or told the user to do so).

• the http response from the final api call has code=200 and the data object is well-formed (no parse errors, no truncation).

data format:

• download endpoint returns: { "code": 200, "msg": "success", "data": { "downloadLink": "https://…" } }
• config endpoint returns: { "code": 200, "msg": "success", "data": { "config": "…text…" } }
• detail endpoint returns: { "code": 200, "msg": "success", "data": { "id": "…", "name": "…", "versions": […], … } }

file locations:

• depend on the resource type and host tool. the bundled cli scripts document installation paths. e-store's own detail page for a resource often includes setup instructions; read them before installing.

outcome signal

you know the skill worked when:

1. you reached step 5 (placed the file or wrote the config) , not just obtained a download link.
2. the host tool loaded / registered the new capability without error messages.
3. you then used that new capability to solve the user's original task (draw the diagram, run the web search, fetch from the knowledge base, etc.), and it worked.
4. if the user asked "is this installed?", you can confirm by running a quick sanity check (e.g., list the skill, invoke it, or check the config file).

failed outcome: you obtained a download link but never placed the file, or you placed the file but the host tool didn't reload, or you installed it but then failed to use it for the original task. in that case, flag the blocker (auth issue, install path mismatch, tool restart needed) and work around it.

---

resource types

e-store carries two top-level kinds, with parallel apis:

• product (资源) , a single unit: 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 novel writing"). call solution-detail to see the products array, then install each product individually if desired.

paths are symmetric: replace product ↔ solution and the call works the same.

---

cli quick reference

# discovery
scripts/client.py search "<keyword>"            # search 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. each call outputs json to stdout; parse the data field.

---

patterns

pattern a , user describes a need, doesn't name the resource

"i want to draw an architecture diagram."

you lack a diagramming tool. do this:

1. search "diagram" (or "flowchart", "drawing" , retry with synonyms if blank).
2. pick the top result by relevance and adoption (downloads + rating).
3. product-detail <id> to confirm capability and install steps.
4. product-download <id> (or product-config <id> if hasFile=false).
5. install per the resource's own docs. use it to satisfy the original request.

pattern b , user wants an end-to-end workflow

"set up an ai novel-writing pipeline."

use the solution surface:

1. solution-search "novel writing".
2. solution-detail <id> to read the bundled products.
3. solution-download <id> for the whole bundle, or iterate products and install each via product flow (user preference).
4. follow the solution's setup notes (usually in the bundle).

pattern c , programmatic use

the bundled scripts are importable:

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

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

---

gotchas (read before your first call)

• long ids are strings, not numbers. id may exceed js safe int range. treat all ids as opaque strings in urls; never parseInt.
• download links expire. downloadLink is time-limited (typically 15 min). generate it fresh right before fetching; don't cache.
• hasFile decides the path, not type. some mcp servers are config-only (hasFile=false). calling /download on them fails. check hasFile before choosing.
• notInLib flips meaning. notInLib=true (default) returns all published items. notInLib=false returns only the user's library. most discovery wants the default.
• search is published-only. drafts and unpublished versions don't show up.
• solution products array is a snapshot. captured at solution publish time, not live. if you need the freshest version of a product in a solution, follow the id through product-detail and product-versions.
• auth is url query, not header. append ?ak=<AK> (and &key=value for other params).
• all responses are wrapped. { "code": 200, "msg": "…", "data": … }. non-200 code = logical error; surface msg to user, don't assume http 200 = success.
• date format is yyyy/MM/dd HH:mm:ss, not iso 8601. don't trip on this when sorting versions.
• rate limits are soft. e-store doesn't hard-block, but hammer the api and you'll see slower responses. for bulk operations (e.g., list 1000 products), add small delays between calls.
• network timeouts. if the api is slow or unavailable, catch the timeout and let the user know. don't retry indefinitely.

---

validation checklist

before reporting success to the user:

• you completed step 5 (placed file or wrote config), not just got a link.
• if the host tool needs reload, you told the user or did it.
• you used the new capability to solve the original task, not just confirmed it installed.
• if the user asked to compare options, you read the search results and picked a single best candidate (no enumeration).

---

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

credits: original skill by e-store team. enriched for implexa quality standards.