Skip to content
Back to search

ethanhq

Ethan Guo's Claude Code plugins — currently cc-fleet (provider LLM teammates / subagents).

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/ethanhq--cc-fleet/badge.svg)](/listings/ethanhq--cc-fleet)

HTML

<a href="/listings/ethanhq--cc-fleet"><img src="/api/listings/ethanhq--cc-fleet/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

These steps run a script from the network that findsafeskills does not scan.

**0. Install Claude Code first** — cc-fleet drives the official `claude` CLI, so install it if you don't have it yet (skip if `claude` is already on your PATH):

**macOS / Linux:**

curl -fsSL https://claude.ai/install.sh | bash

**Windows (PowerShell):**

irm https://claude.ai/install.ps1 | iex

**1. Install cc-fleet with the one-line script (recommended)** — one command does it all: downloads and verifies the CLI, puts it on your PATH (with a `ccf` alias, so `ccf` launches it from then on), and installs the Claude Code plugin (skill + session hook) via the marketplace. Ready to use right after:

**macOS / Linux:**

curl -fsSL https://raw.githubusercontent.com/ethanhq/cc-fleet/main/install.sh | sh

**Windows (PowerShell):**

irm https://raw.githubusercontent.com/ethanhq/cc-fleet/main/install.ps1 | iex

**Codex plugin** — to drive cc-fleet from a Codex session, after the install above run `codex plugin marketplace add ethanhq/cc-fleet` then `codex plugin add cc-fleet`.

> Other channels (npm / go install / Releases / source) and adding the Claude Code plugin, installer overrides, and requirements & maintenance live in **[Install & maintenance](docs/install.md)**.

**Common commands:**

ccf                      # open the interactive TUI
ccf doctor               # health check: dependencies, providers, plugin status
ccf update               # self-update by install channel + refresh the plugin
ccf uninstall --all      # remove the binary and plugin too

Once installed, run `ccf` to register a provider and start delegating.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 15 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. {
  2. "name": "ethanhq",
  3. "owner": {
  4. "name": "Ethan Guo",
  5. "email": "ethanguo.dev@gmail.com"
  6. },
  7. "description": "Ethan Guo's Claude Code plugins — currently cc-fleet (provider LLM teammates / subagents).",
  8. "plugins": [
  9. {
  10. "name": "cc-fleet",
  11. "source": "./",
  12. "description": "Run any third-party LLM provider with an Anthropic-compatible API as real Claude Code agent-team teammates (terminal claude inside tmux or iTerm2) or one-shot subagents via the cc-fleet CLI — driven just like native teammates; your main session's own auth (OAuth or API key) is untouched, provider workers bill the provider key."
  13. }
  14. ]
  15. }
README.md · README · 355 lines · 2 findings marked

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. ![cc-fleet — plug any third-party model into Claude Code's Dynamic Workflows, Agent Teams, and Subagents](docs/assets/cc-fleet-banner.png)
  2. <h1 align="center">🚢 cc-fleet</h1>
  3. <p align="center"><strong>🤖 Plug any third-party model into Claude Code's ⚙️ Dynamic Workflows, 👥 Agent Teams, and ⚡ Subagents — from DeepSeek · GLM · Kimi · Qwen … to your Codex subscription, with your main session's auth untouched; no Claude subscription needed to run a full Claude Code on any provider 🚀</strong></p>
  4. <div align="center">
  5. [![Release](https://img.shields.io/github/v/release/ethanhq/cc-fleet?style=for-the-badge&color=2ea043&label=release)](https://github.com/ethanhq/cc-fleet/releases) [![npm](https://img.shields.io/npm/v/@ethanhq/cc-fleet?style=for-the-badge&color=cb3837)](https://www.npmjs.com/package/@ethanhq/cc-fleet) [![Platform](https://img.shields.io/badge/platform-Linux%20%7C%20macOS%20%7C%20Windows-8957e5?style=for-the-badge)](https://github.com/ethanhq/cc-fleet/releases) [![License](https://img.shields.io/badge/license-Apache%202.0-1f6feb?style=for-the-badge)](LICENSE)
  6. **English** · [简体中文](docs/README_zh.md)
  7. </div>
  8. ---
  9. Claude Code's multi-agent orchestration — Dynamic Workflows, Agent Teams, Subagents — only runs Anthropic's own models. cc-fleet lets any model with an Anthropic- or OpenAI-compatible API, even your Codex subscription, join as a workflow leaf, a long-lived teammate, or a one-shot subagent — scheduled by your main session, **with the same identity and capabilities as a native Claude agent**.
  10. Every third-party worker is a real `claude` process with its LLM backend swapped to the provider, so Claude Code drives it exactly like a native agent. Your main session's own auth (OAuth subscription or API key) is untouched, and provider keys never enter env, argv, or shell history — **zero leak risk**.
  11. **Two steps to get going**: one-line install, register a provider. Then state your intent in Claude Code with `/workflow`, `/team`, or `/subagent` — or just describe the task in plain language, and Claude figures out the rest.
  12. No Claude subscription? `ccf run <provider>` starts an interactive session driven by that provider — **the same `claude` you know**, just running on the provider's model.
  13. cc-fleet can be driven from Codex too: a Codex plugin gives a Codex session the same fan-out — `cc-fleet subagent` and `cc-fleet workflow`, with the `claude` engine as the worker. (Teammates stay Claude-Code-only.)
  14. ## Install
  15. **0. Install Claude Code first** — cc-fleet drives the official `claude` CLI, so install it if you don't have it yet (skip if `claude` is already on your PATH):
  16. **macOS / Linux:**
  17. ```bash
  18. curl -fsSL https://claude.ai/install.sh | bash
  19. ```
  20. **Windows (PowerShell):**
  21. ```powershell
  22. irm https://claude.ai/install.ps1 | iex
  23. ```
  24. **1. Install cc-fleet with the one-line script (recommended)** — one command does it all: downloads and verifies the CLI, puts it on your PATH (with a `ccf` alias, so `ccf` launches it from then on), and installs the Claude Code plugin (skill + session hook) via the marketplace. Ready to use right after:
  25. **macOS / Linux:**
  26. ```bash
  27. curl -fsSL https://raw.githubusercontent.com/ethanhq/cc-fleet/main/install.sh | sh
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 44 on GitHub
  28. ```
  29. **Windows (PowerShell):**
  30. ```powershell
  31. irm https://raw.githubusercontent.com/ethanhq/cc-fleet/main/install.ps1 | iex
  32. ```
  33. **Codex plugin** — to drive cc-fleet from a Codex session, after the install above run `codex plugin marketplace add ethanhq/cc-fleet` then `codex plugin add cc-fleet`.
  34. > Other channels (npm / go install / Releases / source) and adding the Claude Code plugin, installer overrides, and requirements & maintenance live in **[Install & maintenance](docs/install.md)**.
  35. **Common commands:**
  36. ```bash
  37. ccf # open the interactive TUI
  38. ccf doctor # health check: dependencies, providers, plugin status
  39. ccf update # self-update by install channel + refresh the plugin
  40. ccf uninstall --all # remove the binary and plugin too
  41. ```
  42. Once installed, run `ccf` to register a provider and start delegating.
  43. ## Quickstart
  44. <table>
  45. <tr>
  46. <td width="50%" valign="top">
  47. <div align="center">
  48. **🔌 Provider management — one API key, connected**
  49. <img src="docs/assets/demo-provider.webp" alt="provider management demo" width="100%" />
  50. </div>
  51. 1. **`ccf` opens the TUI**; choose Add provider
  52. 2. **Pick any Anthropic / OpenAI-compatible vendor**
  53. 3. **Enter the API key and default model**; optionally an effort level and a Claude permission mode
  54. 4. **Save and go**; add more models and toggle them in the list, `s` sets the default, `d` deletes
  55. 5. **(Optional) Add Codex**: reuse an existing OAuth, or log in fresh
  56. </td>
  57. <td width="50%" valign="top">
  58. <div align="center">
  59. **🖥️ `ccf run` — run Claude Code on any provider**
  60. <img src="docs/assets/demo-run.webp" alt="ccf run demo" width="100%" />
  61. </div>
  62. 1. **`ccf run` launches an interactive `claude` on your default provider**; `ccf run <provider>` picks one
  63. 2. **All tools, the full REPL**; no Anthropic subscription, your main session's login untouched
  64. 3. **Switch anytime mid-session**: `/model` for the model, `/effort` for thinking effort, `Shift+Tab` for permission mode
  65. </td>
  66. </tr>
  67. <tr>
  68. <td width="50%" valign="top">
  69. <div align="center">
  70. **⚙️ Dynamic Workflows — the same orchestration API as native workflows**
  71. <img src="docs/assets/demo-workflow.webp" alt="dynamic workflow demo" width="100%" />
  72. </div>
  73. 1. **`/workflow` to kick it off, or just tell Claude**: "map each module with deepseek, glm drafts an audit checklist per module, gpt synthesizes"
  74. 2. **Claude writes the JS script and runs it in the background** — no tokens off your main session
  75. 3. **`workflow wait` blocks until it finishes** — event-driven, no polling
  76. 4. **The TUI board shows every leaf and phase live** — `x` to hold / `r` to rerun a single leaf or a whole phase
  77. </td>
  78. <td width="50%" valign="top">
  79. <div align="center">
  80. **👥 Agent Teams — native multi-agent collaboration in tmux panes**
  81. <img src="docs/assets/demo-team.webp" alt="agent team demo" width="100%" />
  82. </div>
  83. 1. **`/team` to kick it off, or just tell Claude**: "start a glm and a deepseek teammate, then compare their strengths"
  84. 2. **Each teammate is a real `claude` process working live in a side tmux pane** — mix providers in one team, hand follow-ups across turns
  85. 3. **The TUI board shows each teammate's full inbox and status**; `h` hides / `s` shows a pane — split in the foreground or run in the background
  86. </td>
  87. </tr>
  88. <tr>
  89. <td width="50%" valign="top">
  90. <div align="center">
  91. **⚡ Subagents — the lightest one-shot delegation**
  92. <img src="docs/assets/demo-subagent.webp" alt="subagent demo" width="100%" />
  93. </div>
  94. 1. **`/subagent` to kick it off, or just tell Claude**: "fan out kimi, qwen, and glm over these three files in parallel"
  95. 2. **Claude runs the models and collects results synchronously** — dispatch as many in parallel as you like
  96. 3. **`slim-ro` read-only mode**: let a provider analyze your repo safely, without touching code
  97. 4. **The TUI board shows each job's prompt, answer, and spend**
  98. </td>
  99. <td width="50%" valign="top">
  100. <div align="center">
  101. **📊 The TUI board — your whole fleet on one screen**
  102. <img src="docs/assets/demo-tui.webp" alt="TUI board demo" width="100%" />
  103. </div>
  104. 1. **After `ccf` launches, press `Tab` for the Agents Board** — every Workflow / Team / Subagent laid out by project → session
  105. 2. **Open any one for detail**: a Workflow's run → phase → leaf progress tree, a Team's teammate inbox, each drilling into prompt, answer, and spend
  106. 3. **Act inside the board**: `x` / `r` to stop or rerun, `p` to pin against cleanup, `c` to clear finished, `d` to delete, `h` / `s` to hide or show a pane
  107. 4. **Finished teams stay on record**; the UI follows your system light / dark theme
  108. </td>
  109. </tr>
  110. </table>
  111. ## Deep dive
  112. cc-fleet's capabilities fall into two groups:
  113. - **Three delegation lanes** (Workflow / Agent Team / Subagent) — scheduled automatically by Claude: say what you want and the skills pick the lane and the model for you, no manual choice.
  114. - **Provider and `ccf run`** — tools you configure and use directly.
  115. ---
  116. ### ⚙️ Dynamic Workflows
  117. <table>
  118. <tr>
  119. <td width="50%" align="center"><img src="docs/assets/workflow-board.webp" width="100%" /><br/><sub>Agents Board: the phase → leaf tree</sub></td>
  120. <td width="50%" align="center"><img src="docs/assets/workflow-leaf.webp" width="100%" /><br/><sub>drill into one leaf: full prompt and synthesized output</sub></td>
  121. </tr>
  122. </table>
  123. **Orchestration API**: multi-phase orchestration lives in a JavaScript file, with an API identical to Claude Code's native Workflow tool — `agent()` starts a node, `parallel()` fans out, `pipeline()` chains a flow. The one difference is that `agent()` takes a `provider` option to assign each node's model, so different vendors mix and run in parallel within a single run:
  124. ```js
  125. const meta = {
  126. name: "api audit",
  127. description: "map endpoints, then draft audit checklists",
  128. phases: [{ title: "map" }, { title: "build" }, { title: "judge" }],
  129. };
  130. phase("map");
  131. const maps = (await parallel(
  132. ["auth", "billing", "users"].map((m) =>
  133. () => agent("List the exported endpoints in module " + m, { provider: "deepseek" }))
  134. )).filter(Boolean);
  135. phase("build");
  136. const checklists = await pipeline(maps,
  137. (endpoints, _, i) => agent("Draft an audit checklist:\n" + endpoints,
  138. { provider: "glm", label: "build:" + i }));
  139. phase("judge");
  140. const verdict = await agent("Pick the strongest one and say why:\n" + checklists.join("\n---\n"),
  141. { provider: "claude", model: "opus", label: "judge" });
  142. return { checklists, verdict };
  143. ```
  144. **Running and managing**: once kicked off, the whole run executes in a background engine, managed by a small command set. Runs are journaled by content hash, and budgets cap spend in USD or tokens:
  145. ```bash
  146. RUN=$(ccf workflow run audit.js) # starts in the background, prints the run id
  147. ccf workflow wait "$RUN" --timeout 10m # blocks until done, event-driven
  148. ccf workflow stop "$RUN" --leaf build:1 # hold a single leaf (run keeps going)
  149. ccf workflow restart "$RUN" --leaf build:1 # resume it
  150. ccf workflow run audit.js --resume "$RUN" # replay the journal, finished leaves hit cache
  151. ```
  152. **Holding and restarting**: `ccf workflow stop --leaf` / `--phase` doesn't fail the run — it just pauses the named node: the run keeps going and other nodes carry on, until you `restart` it to run again. If every node currently running gets paused, the whole run settles into a *parked* state that needs you to step in before it continues.
  153. **Wait without polling**: `ccf workflow wait` blocks until the run ends, then exits — drop it in the background and come back when it exits, no repeated checking. The exit code states the outcome: `0` succeeded, `1` failed, `3` parked and waiting, `124` wait timed out (run still going), `130` interrupted.
  154. **Budget-adaptive**: `budget.spent()` / `budget.remaining()` are readable live inside the script (USD or tokens), so a workflow can decide for itself whether to dispatch another batch.
  155. **Mixing in your own subscription**: a node assigned `provider: "claude"` runs on your **own** Claude login — the `judge` above uses your subscription, not a provider key, which suits a synthesis-and-finish node.
  156. ---
  157. ### 👥 Agent Teams
  158. <table>
  159. <tr>
  160. <td width="50%" align="center"><img src="docs/assets/team-panes.webp" width="100%" /><br/><sub>four teammates working side by side in tmux panes</sub></td>
  161. <td width="50%" align="center"><img src="docs/assets/team-board.webp" width="100%" /><br/><sub>a teammate's overview / messages / output on the board</sub></td>
  162. </tr>
  163. </table>
  164. **Prerequisites**: Agent Team is the only lane that needs setup up front, and it **doesn't support Windows yet**. Before you use it:
  165. 1. **Claude Code ≥ 2.1.278, the terminal `claude`, inside tmux or iTerm2** (`tmux new-session -s work`) so teammate panes can show up alongside you. The Claude desktop app, `claude -p` and SDK sessions have no agent team — there, Claude uses subagents and workflows instead;
  166. 2. **Run the one-time setup**: the first time you start `ccf` with a provider enabled, it offers to do this for you — or run it yourself, then restart `claude`:
  167. ```bash
  168. cc-fleet teammate setup --yes --teammate-mode tmux
  169. ```
  170. It installs a small launcher (`~/.config/cc-fleet/bin/claude-teammate`), one `ccf-<provider>` agent type per provider (`~/.claude/agents/ccf-*.md`), and in `~/.claude/settings.json` turns on agent teams and points `CLAUDE_CODE_TEAMMATE_COMMAND` at the launcher; `--teammate-mode tmux` makes teammates open as split panes (an existing `auto` / `tmux` / `iterm2` is left alone). Without `--yes` it only lists what it would change. `cc-fleet teammate setup --remove --yes` undoes it.
  171. **How they collaborate**: each teammate is a native Claude Code teammate — Claude starts it with the `Agent` tool using a `ccf-<provider>` agent type (`ccf-glm.strong` for the strong slot), assigns work with native `SendMessage`, and the launcher runs that teammate's `claude` on the provider. Teammates stay alive across turns so you can keep adding tasks. One team can use several providers at once, then have one teammate gather and compare the results. Before each teammate, Claude runs `cc-fleet teammate check`, and a plugin hook blocks a provider teammate that would silently run on Claude instead.
  172. **Permission inheritance**: Claude Code hands each teammate your main session's permission posture (plan / acceptEdits / default), exactly as for its own teammates.
  173. **Park and restore**: `ccf hide <name>@<team>` tucks a teammate's pane out of the way while the process keeps running — messages and context are never lost — and `ccf show` brings it back. Claude Code closes its teammates when you exit `claude`; to end one early, Claude asks it to shut down or stops it. `ccf teardown` is for leftovers — say, after the lead crashed: it kills only provider teammates it can verify (pane, exact command line, process start time), and never touches your lead, native teammates, or Claude Code's team files. `ccf ps` lists them with a state (`running`, `orphaned`, `failed`, `bypassed`).
  174. **Outside tmux**: with `teammateMode` set to `tmux`, Claude Code runs the teammates on its own background tmux server (`claude-swarm-<pid>`), exactly the same flow with the pane just not on screen; `ccf ps --json` shows the `tmux_socket_path` to attach with `tmux -S <path> attach`.
  175. ---
  176. ### ⚡ Subagents
  177. <table>
  178. <tr>
  179. <td width="50%" align="center"><img src="docs/assets/subagent-fanout.webp" width="100%" /><br/><sub>fan out three subagents in parallel from one ask</sub></td>
  180. <td width="50%" align="center"><img src="docs/assets/subagent-board.webp" width="100%" /><br/><sub>the job list and one job's detail</sub></td>
  181. </tr>
  182. </table>
  183. **Three run modes**: the default **slim** sends the model a trimmed system prompt with a narrowed tool set, so the first request is much smaller than a full session — cheaper and faster on metered providers. `--profile slim-ro` is read-only, with tools cut to inspection only (Bash / Glob / Grep / Read / Skill) and no creating, editing, or deleting files, so a provider can read code and check logs without touching your workspace. Use `--profile full` when you need full-session capability.
  184. **Tool trimming and parallelism**: `--tools` takes a comma-separated list to set exactly which tools are open (a replacement, not an addition to the defaults), `--skills=false` turns off the Skill tool, and `--mcp` controls whether the host MCP config carries over. A subagent builds no team, takes no pane, and holds no locks, so running many against one provider doesn't interfere — ideal for large batches in parallel.
  185. **Background and wake-up**: add `--background` to send a long job to the background, then `ccf subagent-status <job> --wait` blocks until it's done and wakes the session that launched it — no repeated checking. Each job is capped by spend (USD), turns, and timeout, and a failure returns a fixed `error_code` your program can branch on.
  186. **Structured result**: with `--json` you get a result object with fixed fields, easy for scripts to parse — besides the answer text it includes the model id that actually responded, the call's spend, token usage, turns, and session_id.
  187. **Run key nodes on your own subscription**: as with Workflow, setting the provider to the reserved name `claude` (`ccf subagent claude --model opus …`) uses your own Claude login and bills your subscription — good for a synthesis-and-finish node, not large parallel batches.
  188. ---
  189. ### 🧩 Drive from Codex
  190. cc-fleet plugs into **OpenAI Codex** too: a Codex plugin lets a Codex session fan out the same provider workers — one-shot or batch **subagents** (`cc-fleet subagent`) and multi-phase JS **workflows** (`cc-fleet workflow`), each a real `claude` process on the provider's model. Install it with `codex plugin marketplace add ethanhq/cc-fleet` then `codex plugin add cc-fleet` (the `cc-fleet` and `claude` binaries install separately). The teammate lane stays Claude-Code-only; from Codex you get the subagent and workflow fan-out.
  191. ---
  192. ### 🔌 Provider management
  193. <table>
  194. <tr>
  195. <td width="50%" align="center"><img src="docs/assets/provider-presets.webp" width="100%" /><br/><sub>presets for many vendors</sub></td>
  196. <td width="50%" align="center"><img src="docs/assets/provider-config.webp" width="100%" /><br/><sub>set each tier's model, effort, and permission</sub></td>
  197. </tr>
  198. </table>
  199. **Broad compatibility**: works with any Anthropic- or OpenAI-compatible API endpoint — the former includes DeepSeek, Kimi, GLM, Qwen, and more; the latter Groq, Together, Fireworks, a local vLLM, and OpenAI itself. Common vendors ship as presets — select one and the endpoint and protocol are filled in, no manual entry; for anything not listed, pick *Custom* and enter the address.
  200. **Model tiers**: each provider can carry **default / strong / fast** model slots, each separately taggable with 1M context and a reasoning effort. So Claude just asks for "the strong model" — no hardcoded model IDs. `ccf default <provider>` sets the fleet-wide default provider, and any call that doesn't name one goes to it.
  201. **Multi-key rotation**: one provider can hold several API keys, rotated by `off` / `round_robin` / `random` to spread quota and avoid rate limits.
  202. **API key protection**: a key is fetched only at request time, emitted once, and never written into environment variables, command-line arguments, or shell history. A worker keeps the main session's credentials out two ways: its environment is cleared of Anthropic credentials and cloud-backend switches, and its provider profile blanks the same keys in case your Claude Code settings set them (organization-managed settings are the one layer a profile can't override), so the two never leak into each other. On disk it's saved `0600`, readable only by you, or handed to `pass`, 1Password, Vault, or your OS keyring; every UI and log shows the key masked (`sk-…238`).
  203. **Codex (ChatGPT subscription)**: one device-code login and your ChatGPT subscription becomes a regular provider — usable across Workflow / Team / Subagent / run.
  204. > [!WARNING]
  205. > **Codex is unofficial.** Reusing a ChatGPT subscription outside the codex CLI may violate OpenAI's terms, and `ccf codex login` asks you to confirm first. The OAuth token lives only inside the local conversion daemon; cc-fleet keeps its own login chain and never writes the codex CLI's auth (without its own login, the codex provider on the default credential rides it read-only).
  206. ---
  207. ### 🖥️ `ccf run`
  208. <table>
  209. <tr>
  210. <td width="50%" align="center"><img src="docs/assets/run-launch.webp" width="100%" /><br/><sub>one-line launch: ccf run / ccf run codex</sub></td>
  211. <td width="50%" align="center"><img src="docs/assets/run-session.webp" width="100%" /><br/><sub>inside, it's a full claude — here on gpt-5.5</sub></td>
  212. </tr>
  213. </table>
  214. **Launch**: `ccf run <provider>` opens an interactive `claude` on the named provider; with no provider (`ccf run`) it resolves to the fleet-wide default.
  215. ```bash
  216. ccf run deepseek # an interactive claude, on DeepSeek, billing the provider key
  217. ```
  218. **It's just native claude**: `ccf run` adds no extra process layer — it replaces itself with `claude`, cc-fleet steps out entirely, and from then on it's a plain `claude` process whose feel and exit behavior match typing `claude` yourself.
  219. **Credentials isolated automatically**: even if you run it from inside a logged-in Claude Code session, it first clears any leftover Anthropic auth from the environment and uses the chosen provider's auth instead — so billing lands on the provider's key, never your own subscription.
  220. **Flags**:
  221. - `--model strong / fast` — override the default with the provider's strong or fast model
  222. - `--permission-mode` — set the permission posture
  223. - `-- <claude args>` — everything after is passed through verbatim to the underlying `claude`
  224. > [!NOTE]
  225. > This lane is for hands-on interactive use: it needs a real terminal and doesn't support pipes or redirects — for non-interactive, one-shot output use a Subagent instead.
  226. ## Documentation
  227. - **[CLI reference & advanced usage](docs/cli.md)** — every command, flag, and envelope.
  228. - **[Writing workflows](docs/workflows.md)** — the JS scripting API for the workflow lane.
  229. - **[Architecture](docs/architecture.md)** — how the teammate launcher, key safety, the conversion daemon, and the workflow engine actually work.
  230. - `ccf <cmd> --help` — always authoritative.
  231. ## Contributing
  232. PRs are very welcome — bug fixes, new provider presets, docs, tests, features. Please read the **[contribution guide](.github/CONTRIBUTING.md)** first; a few house rules:
  233. - **UI changes and bug fixes need a screenshot or GIF** in the PR.
  234. - **AI-*assisted*** commits credit the tool with a `Co-Authored-By` trailer.
  235. - **Fully AI-*authored*** PRs add an autonomous-PR marker at the bottom of the PR body.
  236. ## License
  237. [Apache-2.0](LICENSE).
install.ps1 · Bundled script · 191 lines · 3 findings marked
  1. # install.ps1 — one-line installer for cc-fleet on Windows.
  2. #
  3. # Downloads a prebuilt binary from GitHub Releases (no Go toolchain, no clone),
  4. # installs cc-fleet.exe plus the ccf.exe alias, and — if Claude Code is present —
  5. # installs the cc-fleet skill via the plugin.
  6. #
  7. # irm https://raw.githubusercontent.com/ethanhq/cc-fleet/main/install.ps1 | iex
    • Note: Runs a downloaded PowerShell script (iex / Invoke-Expression)
    • Line 7 on GitHub
  8. #
  9. # Args don't survive `irm | iex`; use env vars to override the defaults:
    • Note: Runs a downloaded PowerShell script (iex / Invoke-Expression)
    • Line 9 on GitHub
  10. # $env:CCF_VERSION = 'vX.Y.Z' # install a specific release (default: latest)
  11. # $env:CCF_PREFIX = 'C:\dir' # install dir (default: %LOCALAPPDATA%\cc-fleet\bin)
  12. # $env:CCF_BASE_URL = '...' # asset base (mirror or local file:/// test)
  13. #
  14. # Windows PowerShell 5.1 compatible. The body runs in a child scope so that under
  15. # `irm | iex` the strict mode / error preference don't leak into the caller's
  16. # session, and a failure can't close the caller's console.
  17. & {
  18. Set-StrictMode -Version Latest
  19. $ErrorActionPreference = 'Stop'
  20. [Net.ServicePointManager]::SecurityProtocol = [Net.ServicePointManager]::SecurityProtocol -bor [Net.SecurityProtocolType]::Tls12
  21. $REPO = 'ethanhq/cc-fleet' # GitHub owner/repo (Release source + plugin marketplace)
  22. $MARKETPLACE = 'ethanhq' # claude plugin marketplace name
  23. $PLUGIN = 'cc-fleet' # claude plugin name
  24. $SCOPE = 'user' # plugin install scope
  25. function Die($msg) { throw "install.ps1: $msg" }
  26. # --- platform detection -------------------------------------------------------
  27. switch ($env:PROCESSOR_ARCHITECTURE) {
  28. 'AMD64' { $arch = 'amd64' }
  29. 'ARM64' { $arch = 'arm64' }
  30. default { Die "unsupported architecture '$($env:PROCESSOR_ARCHITECTURE)' (cc-fleet supports amd64 and arm64)" }
  31. }
  32. # --- prefix -------------------------------------------------------------------
  33. if ($env:CCF_PREFIX) {
  34. $PREFIX = $env:CCF_PREFIX
  35. } else {
  36. $PREFIX = Join-Path $env:LOCALAPPDATA 'cc-fleet\bin'
  37. }
  38. # --- resolve version ----------------------------------------------------------
  39. $VERSION = $env:CCF_VERSION
  40. if ($VERSION -and ($VERSION -notlike 'v*')) { $VERSION = "v$VERSION" }
  41. if (-not $VERSION -and -not $env:CCF_BASE_URL) {
  42. # Read the tag from the /releases/latest redirect — no JSON parsing needed.
  43. # -MaximumRedirection 0 stops at the 3xx and returns the response carrying the
  44. # Location header; 5.1 also emits a non-terminating error we suppress with
  45. # -ErrorAction so the script's 'Stop' preference can't abort the call. Should
  46. # only an exception carry the response, read .Response defensively: its shape
  47. # varies across editions and an unguarded read throws under StrictMode (#54).
  48. $loc = $null
  49. try {
  50. $resp = Invoke-WebRequest -Uri "https://github.com/$REPO/releases/latest" -MaximumRedirection 0 -UseBasicParsing -ErrorAction SilentlyContinue
  51. if ($resp) { $loc = $resp.Headers['Location'] }
  52. } catch {
  53. $r = $null
  54. if ($_.Exception.PSObject.Properties['Response']) { $r = $_.Exception.Response }
  55. if ($r -is [System.Net.HttpWebResponse]) {
  56. $loc = $r.Headers['Location']
  57. } elseif ($r) {
  58. $loc = "$($r.Headers.Location)"
  59. }
  60. }
  61. if ($loc) { $VERSION = ($loc -split '/tag/')[-1] }
  62. if (-not $VERSION) { Die "could not resolve the latest version; set `$env:CCF_VERSION = 'vX.Y.Z'" }
  63. }
  64. # Asset base: the dir holding the zip + checksums.txt. CCF_BASE_URL overrides it
  65. # for a mirror or a local test (e.g. file:///path/to/dist).
  66. if ($env:CCF_BASE_URL) {
  67. $ASSET_BASE = $env:CCF_BASE_URL
  68. } else {
  69. $ASSET_BASE = "https://github.com/$REPO/releases/download/$VERSION"
  70. }
  71. $ZIP = "cc-fleet-windows-$arch.zip"
  72. # --- download + verify --------------------------------------------------------
  73. $tmp = Join-Path ([IO.Path]::GetTempPath()) ("cc-fleet-" + [Guid]::NewGuid().ToString('N'))
  74. New-Item -ItemType Directory -Path $tmp -Force | Out-Null
  75. try {
  76. $zipPath = Join-Path $tmp $ZIP
  77. $sumPath = Join-Path $tmp 'checksums.txt'
  78. $verLabel = if ($VERSION) { $VERSION } else { 'local' }
  79. Write-Host "==> Downloading $ZIP ($verLabel)"
  80. Invoke-WebRequest -Uri "$ASSET_BASE/$ZIP" -OutFile $zipPath -UseBasicParsing
  81. Invoke-WebRequest -Uri "$ASSET_BASE/checksums.txt" -OutFile $sumPath -UseBasicParsing
  82. $expected = $null
  83. foreach ($line in Get-Content $sumPath) {
  84. $parts = $line -split '\s+', 2
  85. if ($parts.Count -eq 2 -and $parts[1].Trim() -eq $ZIP) { $expected = $parts[0].Trim(); break }
  86. }
  87. if (-not $expected) { Die "no checksum for $ZIP in checksums.txt" }
  88. $actual = (Get-FileHash -Algorithm SHA256 -Path $zipPath).Hash
  89. if ($expected -ne $actual) {
  90. Write-Host " expected $expected"
  91. Write-Host " actual $actual"
  92. Die "checksum mismatch for $ZIP"
  93. }
  94. Write-Host "==> Checksum OK"
  95. # --- extract + install binary ---------------------------------------------
  96. Expand-Archive -Path $zipPath -DestinationPath $tmp -Force
  97. $extract = Join-Path $tmp "cc-fleet-windows-$arch" # archive wraps in this dir
  98. New-Item -ItemType Directory -Path $PREFIX -Force | Out-Null
  99. # No symlinks on Windows — copy the exe to both names.
  100. Copy-Item -Path (Join-Path $extract 'cc-fleet.exe') -Destination (Join-Path $PREFIX 'cc-fleet.exe') -Force
  101. Copy-Item -Path (Join-Path $extract 'cc-fleet.exe') -Destination (Join-Path $PREFIX 'ccf.exe') -Force
  102. Write-Host "==> Installed $PREFIX\cc-fleet.exe (+ ccf alias)"
  103. # Install manifest (co-located with the binary): `uninstall --all` reads it
  104. # to choose the removal commands; self-update is unsupported on Windows.
  105. $manifest = "{`"method`":`"tarball`",`"plugin_scope`":`"$SCOPE`",`"skill`":`"plugin`"}"
  106. Set-Content -Path (Join-Path $PREFIX '.cc-fleet-install.json') -Value $manifest -Encoding ascii
  107. } finally {
  108. Remove-Item -Recurse -Force $tmp -ErrorAction SilentlyContinue
  109. }
  110. # --- skill --------------------------------------------------------------------
  111. if (Get-Command claude -ErrorAction SilentlyContinue) {
  112. # Redirected native stderr becomes error records in 5.1, which 'Stop' would
  113. # turn terminating — an already-added marketplace must stay a no-op.
  114. $prevEap = $ErrorActionPreference
  115. $ErrorActionPreference = 'Continue'
  116. claude plugin marketplace add $REPO --scope $SCOPE 2>$null | Out-Null
  117. $ErrorActionPreference = $prevEap
  118. claude plugin install "$PLUGIN@$MARKETPLACE" --scope $SCOPE
  119. if ($LASTEXITCODE -eq 0) {
  120. Write-Host "==> Installed the cc-fleet skill via plugin (scope: $SCOPE)"
  121. Write-Host " uninstall: claude plugin uninstall $PLUGIN@$MARKETPLACE"
  122. } else {
  123. Write-Host "==> Could not install the plugin automatically. To add the skill, run:"
  124. Write-Host " claude plugin marketplace add $REPO --scope $SCOPE"
  125. Write-Host " claude plugin install $PLUGIN@$MARKETPLACE --scope $SCOPE"
  126. }
  127. } else {
  128. Write-Host "==> 'claude' not on PATH - skipped plugin install. To add the skill later:"
  129. Write-Host " claude plugin marketplace add $REPO --scope $SCOPE"
  130. Write-Host " claude plugin install $PLUGIN@$MARKETPLACE --scope $SCOPE"
  131. }
  132. # --- Claude Code precondition note --------------------------------------------
  133. if (-not (Get-Command claude -ErrorAction SilentlyContinue)) {
  134. Write-Host ""
  135. Write-Host "==> Note: Claude Code ('claude') was not found on PATH."
  136. Write-Host " cc-fleet drives Claude Code - install it to run subagents / workflows:"
  137. Write-Host " https://docs.anthropic.com/claude-code"
  138. }
  139. # --- PATH check + next steps --------------------------------------------------
  140. $userPath = [Environment]::GetEnvironmentVariable('Path', 'User')
  141. $onPath = $false
  142. if ($userPath) {
  143. foreach ($p in ($userPath -split ';')) {
  144. if ($p.Trim().TrimEnd('\') -ieq $PREFIX.TrimEnd('\')) { $onPath = $true; break }
  145. }
  146. }
  147. if ($onPath) {
  148. Write-Host "==> $PREFIX is already on your user PATH."
  149. } else {
  150. if ($userPath) { $newPath = "$userPath;$PREFIX" } else { $newPath = $PREFIX }
  151. [Environment]::SetEnvironmentVariable('Path', $newPath, 'User')
  152. Write-Host ""
  153. Write-Host "==> Added $PREFIX to your user PATH. Open a new terminal for it to take effect."
  154. }
  155. Write-Host ""
  156. Write-Host "==> Next steps"
  157. Write-Host ""
  158. Write-Host " cc-fleet # launch the interactive TUI - register a provider and get started"
  159. Write-Host " # (config is auto-created on first save; no init needed)"
  160. Write-Host " cc-fleet doctor # optional: run the health checks"
  161. Write-Host ""
  162. Write-Host " The live teammate lane needs tmux (unix only); subagent / workflow / run work here."
  163. }
install.sh · Bundled script · 271 lines · 3 findings marked
  1. #!/usr/bin/env sh
  2. # install.sh — one-line installer for cc-fleet.
  3. #
  4. # Downloads a prebuilt binary from GitHub Releases (no Go toolchain, no clone),
  5. # installs `cc-fleet` plus the `ccf` alias, and — by default — installs the
  6. # cc-fleet skill via the Claude Code plugin.
  7. #
  8. # curl -fsSL https://raw.githubusercontent.com/ethanhq/cc-fleet/main/install.sh | sh
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 8 on GitHub
  9. #
  10. # Pass flags after `| sh -s --`, e.g.:
  11. # curl -fsSL .../install.sh | sh -s -- --prefix /usr/local/bin --skill none
  12. #
  13. # For a from-source build instead, clone the repo and run `make install`.
  14. set -eu
  15. REPO="ethanhq/cc-fleet" # GitHub owner/repo (Release source + plugin marketplace)
  16. MARKETPLACE="ethanhq" # claude plugin marketplace name (.claude-plugin/marketplace.json)
  17. PLUGIN="cc-fleet" # claude plugin name
  18. SKILL_NAME="cc-fleet" # skill dir under ~/.claude/skills/ (for --skill global)
  19. PREFIX="${HOME}/.local/bin"
  20. SKILL_MODE="plugin" # plugin | global | none
  21. SCOPE="user" # user | project | local (only for --skill plugin)
  22. VERSION="" # empty => latest release
  23. usage() {
  24. cat <<EOF
  25. install.sh — install prebuilt cc-fleet from GitHub Releases.
  26. Usage:
  27. curl -fsSL https://raw.githubusercontent.com/${REPO}/main/install.sh | sh
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 32 on GitHub
  28. curl -fsSL .../install.sh | sh -s -- [options]
  29. Options:
  30. --skill plugin|global|none How to install the skill. Default: plugin.
  31. plugin = via Claude Code plugin (also adds the
  32. SessionStart hook).
  33. global = copy the per-lane skills into ~/.claude/skills/.
  34. none = binary only.
  35. --scope user|project|local Plugin install scope (--skill plugin). Default: user.
  36. --prefix DIR Install the binary into DIR. Default: ${HOME}/.local/bin.
  37. --version vX.Y.Z Install a specific release. Default: latest.
  38. -h, --help Show this help and exit.
  39. EOF
  40. }
  41. while [ $# -gt 0 ]; do
  42. case "$1" in
  43. --skill) SKILL_MODE="${2:?--skill needs a value}"; shift 2 ;;
  44. --skill=*) SKILL_MODE="${1#--skill=}"; shift ;;
  45. --scope) SCOPE="${2:?--scope needs a value}"; shift 2 ;;
  46. --scope=*) SCOPE="${1#--scope=}"; shift ;;
  47. --prefix) PREFIX="${2:?--prefix needs a value}"; shift 2 ;;
  48. --prefix=*) PREFIX="${1#--prefix=}"; shift ;;
  49. --version) VERSION="${2:?--version needs a value}"; shift 2 ;;
  50. --version=*) VERSION="${1#--version=}"; shift ;;
  51. -h|--help) usage; exit 0 ;;
  52. *) echo "install.sh: unknown argument: $1" >&2; echo "Run with --help for usage." >&2; exit 2 ;;
  53. esac
  54. done
  55. case "$SKILL_MODE" in plugin|global|none) ;; *) echo "install.sh: --skill must be plugin|global|none" >&2; exit 2 ;; esac
  56. case "$SCOPE" in user|project|local) ;; *) echo "install.sh: --scope must be user|project|local" >&2; exit 2 ;; esac
  57. # --- platform detection -------------------------------------------------------
  58. os="$(uname -s)"
  59. case "$os" in
  60. Linux) os="linux" ;;
  61. Darwin) os="darwin" ;;
  62. *) echo "install.sh: unsupported OS '$os' (this installer supports linux and darwin)." >&2
  63. echo " On Windows run in PowerShell: irm https://raw.githubusercontent.com/${REPO}/main/install.ps1 | iex" >&2
  64. echo " or install via npm: npm install -g @ethanhq/cc-fleet" >&2
  65. exit 1 ;;
  66. esac
  67. arch="$(uname -m)"
  68. case "$arch" in
  69. x86_64|amd64) arch="amd64" ;;
  70. arm64|aarch64) arch="arm64" ;;
  71. *) echo "install.sh: unsupported architecture '$arch' (cc-fleet supports amd64 and arm64)" >&2; exit 1 ;;
  72. esac
  73. # --- helpers ------------------------------------------------------------------
  74. have() { command -v "$1" >/dev/null 2>&1; }
  75. download() { # url dest
  76. if have curl; then
  77. curl -fsSL "$1" -o "$2"
  78. elif have wget; then
  79. wget -qO "$2" "$1"
  80. else
  81. echo "install.sh: need curl or wget to download" >&2; exit 1
  82. fi
  83. }
  84. sha256_of() { # file -> stdout hash
  85. if have sha256sum; then
  86. sha256sum "$1" | awk '{print $1}'
  87. elif have shasum; then
  88. shasum -a 256 "$1" | awk '{print $1}'
  89. else
  90. echo "" # no tool available
  91. fi
  92. }
  93. # --- resolve version ----------------------------------------------------------
  94. if [ -n "$VERSION" ]; then
  95. case "$VERSION" in v*) ;; *) VERSION="v${VERSION}" ;; esac
  96. fi
  97. if [ -z "$VERSION" ] && [ -z "${CCF_BASE_URL:-}" ]; then
  98. # Read the tag from the /releases/latest redirect — no JSON parsing needed.
  99. if have curl; then
  100. VERSION="$(curl -fsSLI -o /dev/null -w '%{url_effective}' "https://github.com/${REPO}/releases/latest" | sed 's#.*/tag/##')"
  101. fi
  102. [ -n "$VERSION" ] || { echo "install.sh: could not resolve the latest version; pass --version vX.Y.Z" >&2; exit 1; }
  103. fi
  104. # Asset base: the dir holding the tarball + checksums.txt. CCF_BASE_URL overrides
  105. # it for a mirror or a local test (e.g. file:///path/to/dist).
  106. ASSET_BASE="${CCF_BASE_URL:-https://github.com/${REPO}/releases/download/${VERSION}}"
  107. TARBALL="cc-fleet-${os}-${arch}.tar.gz"
  108. # --- download + verify --------------------------------------------------------
  109. tmp="$(mktemp -d)"
  110. trap 'rm -rf "$tmp"' EXIT
  111. echo "==> Downloading ${TARBALL} (${VERSION:-local})"
  112. download "${ASSET_BASE}/${TARBALL}" "${tmp}/${TARBALL}"
  113. download "${ASSET_BASE}/checksums.txt" "${tmp}/checksums.txt"
  114. expected="$(awk -v f="${TARBALL}" '$2 == f {print $1}' "${tmp}/checksums.txt")"
  115. actual="$(sha256_of "${tmp}/${TARBALL}")"
  116. if [ -z "$expected" ]; then
  117. echo "install.sh: no checksum for ${TARBALL} in checksums.txt" >&2; exit 1
  118. elif [ -z "$actual" ]; then
  119. echo "install.sh: no sha256 tool (sha256sum/shasum) found — cannot verify download" >&2; exit 1
  120. elif [ "$expected" != "$actual" ]; then
  121. echo "install.sh: checksum mismatch for ${TARBALL}" >&2
  122. echo " expected ${expected}" >&2
  123. echo " actual ${actual}" >&2
  124. exit 1
  125. fi
  126. echo "==> Checksum OK"
  127. # --- extract + install binary -------------------------------------------------
  128. tar -xzf "${tmp}/${TARBALL}" -C "${tmp}"
  129. extract="${tmp}/cc-fleet-${os}-${arch}" # archives wrap in this dir
  130. mkdir -p "${PREFIX}"
  131. # Copy to a temp file in the same dir, then rename over the target: the rename
  132. # gives a new inode, so a running cc-fleet keeps its old file and macOS never
  133. # pairs the new bytes with a stale code signature (overwriting in place makes
  134. # every later launch die with SIGKILL).
  135. tmpbin="${PREFIX}/.cc-fleet.tmp.$$"
  136. cp "${extract}/cc-fleet" "$tmpbin" && chmod 0755 "$tmpbin" && mv -f "$tmpbin" "${PREFIX}/cc-fleet" \
  137. || { rm -f "$tmpbin"; echo "install.sh: could not install ${PREFIX}/cc-fleet" >&2; exit 1; }
  138. # Relative symlink (os.Executable() resolves it, so a teammate's apiKeyHelper
  139. # still points at the real cc-fleet path).
  140. ln -sf cc-fleet "${PREFIX}/ccf"
  141. echo "==> Installed ${PREFIX}/cc-fleet (+ ccf alias)"
  142. # Install manifest (co-located with the binary) so `cc-fleet update` self-updates
  143. # in place without guessing the method, preserves the plugin scope, and leaves
  144. # the plugin alone for a --skill none/global install.
  145. cat > "${PREFIX}/.cc-fleet-install.json" <<EOF
  146. {"method":"tarball","plugin_scope":"${SCOPE}","skill":"${SKILL_MODE}"}
  147. EOF
  148. # --- skill --------------------------------------------------------------------
  149. case "$SKILL_MODE" in
  150. plugin)
  151. if have claude; then
  152. claude plugin marketplace add "${REPO}" --scope "${SCOPE}" >/dev/null 2>&1 || true
  153. if claude plugin install "${PLUGIN}@${MARKETPLACE}" --scope "${SCOPE}"; then
  154. echo "==> Installed the cc-fleet skill via plugin (scope: ${SCOPE})"
  155. echo " uninstall: claude plugin uninstall ${PLUGIN}@${MARKETPLACE}"
  156. else
  157. echo "==> Could not install the plugin automatically. To add the skill, run:" >&2
  158. echo " claude plugin marketplace add ${REPO} --scope ${SCOPE}" >&2
  159. echo " claude plugin install ${PLUGIN}@${MARKETPLACE} --scope ${SCOPE}" >&2
  160. fi
  161. else
  162. echo "==> 'claude' not on PATH — skipped plugin install. To add the skill later:"
  163. echo " claude plugin marketplace add ${REPO} --scope ${SCOPE}"
  164. echo " claude plugin install ${PLUGIN}@${MARKETPLACE} --scope ${SCOPE}"
  165. fi
  166. ;;
  167. global)
  168. root="${HOME}/.claude/skills"
  169. rm -rf "${root}/cc-fleet" # drop the legacy single skill so it can't compete
  170. for lane in subagent team workflow; do
  171. mkdir -p "${root}/cc-fleet-${lane}"
  172. cp "${extract}/skills/${lane}/SKILL.md" "${root}/cc-fleet-${lane}/SKILL.md"
  173. done
  174. rm -rf "${root}/cc-fleet-shared"
  175. mkdir -p "${root}/cc-fleet-shared"
  176. cp "${extract}/skills/cc-fleet-shared/"*.md "${root}/cc-fleet-shared/"
  177. # Migrate the legacy un-namespaced shared dir, but only when every file is a
  178. # known cc-fleet doc BY NAME AND CONTENT — never delete another tool's dir,
  179. # even one that happens to use the same generic filenames. (POSIX sh — this
  180. # script runs under `sh`.)
  181. if [ -d "${root}/shared" ]; then
  182. owned=yes
  183. for f in "${root}/shared"/* "${root}/shared"/.[!.]* "${root}/shared"/..?*; do
  184. [ -e "$f" ] || continue
  185. case "$(basename "$f")" in
  186. cli-reference.md|providers.md|routing.md|troubleshooting.md)
  187. grep -q cc-fleet "$f" 2>/dev/null || owned=no ;;
  188. *) owned=no ;;
  189. esac
  190. done
  191. if [ "$owned" = yes ]; then
  192. rm -rf "${root}/shared"
  193. echo "==> Migrated: removed the legacy ${root}/shared (cc-fleet docs only)"
  194. else
  195. echo "==> Note: ${root}/shared contains non-cc-fleet files — left in place"
  196. fi
  197. fi
  198. echo "==> Installed the per-lane cc-fleet skills (global) to ${root}/"
  199. ;;
  200. none)
  201. echo "==> Skipped skill install (--skill none)"
  202. ;;
  203. esac
  204. # --- Claude Code precondition note --------------------------------------------
  205. if ! have claude; then
  206. cat <<EOF
  207. ==> Note: Claude Code ('claude') was not found on PATH.
  208. cc-fleet drives Claude Code — install it to run teammates / subagents / workflows:
  209. https://docs.anthropic.com/claude-code
  210. EOF
  211. fi
  212. # --- PATH check + next steps --------------------------------------------------
  213. case ":${PATH}:" in
  214. *":${PREFIX}:"*) echo "==> ${PREFIX} is already on PATH." ;;
  215. *)
  216. cat <<EOF
  217. ${PREFIX} is not on your PATH. Add this to your shell rc
  218. (~/.zshrc, ~/.bashrc, ~/.profile):
  219. export PATH="${PREFIX}:\$PATH"
  220. EOF
  221. ;;
  222. esac
  223. cat <<EOF
  224. ==> Next steps
  225. cc-fleet # launch the interactive TUI — register a provider and get started
  226. # (config is auto-created on first save; no init needed)
  227. cc-fleet doctor # optional: run the health checks
  228. cc-fleet update # later: update cc-fleet + the plugin to the latest release
  229. tmux is needed only for live teammates; subagent / workflow / run work without it.
  230. Provider teammates: run 'cc-fleet teammate setup --yes --teammate-mode tmux' once (terminal claude inside tmux or iTerm2, Claude Code ≥ 2.1.278).
  231. EOF

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.