Cate Extension Development Skill
Build, test, and publish extension panels for Cate's infinite canvas.
The skill documentation clearly describes a default-deny security model based on scopes, user consent requirements, mandatory binding to 127.0.0.1 for servers, and security review during publishing. It also provides clear rollback and recovery paths (e.g., restart, republish). Publisher identity is unverified, but the documentation does not conceal risks. Deductions: least privilege, confirmation, and rollback are described but lack actual execution evidence or implementation details, and publisher is unverified.
The skill documentation is self-consistent, providing clear build, test, and publish flows, and explicit error handling (e.g., 'cannot proceed' explanations). However, static review cannot verify actual behavior, and no reproducible test cases or error handling examples are provided. Deductions: happy path plausible but tests, edge cases, and error handling evidence are thin.
The skill's target scenario is clear (creating Cate extensions), with clear boundaries (e.g., no terminal scope) and trigger conditions (using manifest, cateApi, etc.). However, environment fitness is insufficient: core functionality may depend on external services on GitHub, potentially inaccessible from mainland China. Deductions: non-fit boundaries not explicitly stated, and network environment requirements not fully disclosed.
Documentation is well-structured with layered information (from overview to detailed API), includes installation guides, examples, and FAQs (via references), and declares known limitations. However, it lacks version history, a complete changelog, and maintenance responsibility statements. Deductions: versioning and governance incomplete, publisher unverified.
The skill claims to accomplish creating, testing, and publishing extensions, with concrete steps and validation methods (e.g., ./build.sh). However, static review cannot verify actual output quality, and no sample outputs are provided. Marginal value over manual work is high, but evidence is limited. Deductions: core task completion plausible but output completeness and direct usability evidence insufficient.
Documentation provides build and test commands, but static review cannot reproduce execution. Although CI workflow files (ci.yml) show builds and tests on multiple platforms, they do not cover the skill's key paths with independently reproducible results. Deductions: no execution evidence; relies on author description and static files.
- The skill's core functionality may rely on GitHub-hosted services (e.g., cate-extensions repository), which may be inaccessible from mainland China networks; consider alternatives.
- Publisher identity is unverified; although security mechanisms are described, actual security should be validated in a real environment.
- Static review cannot verify runtime behavior; it is recommended to test the skill's key paths in a real environment.
What does this skill do, and when should you use it?
This skill guides you through creating extensions for Cate's infinite canvas, including frontend-only panels and server-backed extensions with local servers. It details the manifest (manifest.json), scopes (cateApi), and the window.cate host API, and explains how to publish to the official catalog. It distinguishes between frontend-only and server-backed forms, and outlines the local development loop and the submission flow to the catalog repository.
Creates a new Cate extension project structure on request, including manifest.json, README.md, and optionally package configuration and source directories. Guides writing manifest fields such as id, version, category, panels, server, and cateApi scopes. Explains each window.cate API method and its corresponding scope for accessing theme, storage, editor, workspace, canvas, agent, browser, file drops, and UI notifications. Provides instructions for running the extension locally: sideloading a folder or using a local catalog. Finally, explains how to publish to the cate-extensions catalog repository, including syncing the UI kit, running build.sh for validation, and automatic publication via PR merge.
- A Cate user wants to create a small private workspace panel, like a JSON formatter or note viewer, and scaffolds inline in the current workspace.
- A developer building a public extension that should use the shared UI kit and standard publishing flow clones the catalog repo and scaffolds at extensions/<id>/.
- A developer needing filesystem, network, or process access for their internal tool opts for a server-backed extension with a Node server.
- A developer wants to add a new panel to an existing extension or modify the manifest to request additional scopes.
- A developer wants to submit an extension to the official catalog and needs to understand the PR review and release mechanics.
What are this skill's strengths and limitations?
- Provides clear step-by-step guidance from scaffolding to publishing.
- Includes a comprehensive reference of the window.cate API with a scope table.
- Clarifies the difference between frontend-only and server-backed extensions.
- Emphasizes security practices (HOST binding, scope minimization).
- Includes a pre-submit checklist.
- Is specific to Cate extensions and not applicable to other software.
- External services (like the catalog repo) are not covered in detail but URLs are provided.
- No actual example code is given; you need to reference shipped extensions.
- Testing requirements are not detailed, only mentioning vitest as a convention.
How do you install this skill?
The skill itself requires no installation as it's provided as part of a skill repository. To use it, ensure your agent has access to this skill file (SKILL.md). To set up Cate, download the latest release from the GitHub releases page.
How do you use this skill?
Invoke the skill with a request like 'Create a Cate extension for my project'. Then follow the guidance: decide between frontend-only and server-backed, choose whether to scaffold in the catalog repo or inline. Edit manifest.json, declare the required scopes (cateApi), and implement the frontend referencing the window.cate API documentation. Test locally via sideloading a folder. Finally, submit a PR to the cate-extensions repo following the publishing section.