convez.ai
SkillDevOps & InfraestruturaIntermediário
tuannv14

Claude Team Toolkit

tuannv14/claude-team-toolkit

15 integrações multi-conta para dev, QA e líderes de time

Ver no GitHub
BomPluginScore · de 0 a 100

Pack de 15 skills multi-conta para Claude Code integrado com Trello, Azure DevOps, Heroku, Shopify, Firebase, Sentry, Slack, Postgres e ferramentas mobile (React Native, Fastlane, Maestro). Inclui perfis de conta isolados, auditoria, gates de segurança e workflow único de testes em XLSX.

Instalação

$npx convez-ai tuannv14/claude-team-toolkit

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
1
Forks
0
Acompanhando
0
Saúde
100%
Último commit
há 2 meses
Versão
v0.13.1
Issues abertas
1
Contribuidores
1

Casos de uso

  • Gerenciar múltiplas contas de serviços (pessoal/trabalho/cliente) de forma isolada
  • Automatizar testes mobile com Maestro e converter casos de teste de XLSX
  • Integrar pipelines CI/CD (Azure DevOps, Heroku, Firebase, Fastlane)
  • Executar checks de segurança (Brakeman, bundler-audit) e testes de carga (k6)

Veredito

Toolkit robusto e bem-estruturado para times de engenharia que trabalham com múltiplas contas e plataformas. Implementação sólida de auditoria e segurança, mas requer setup inicial e conhecimento técnico de cada serviço integrado.

README

A tradução para o português deste README ainda está na fila.

claude-team-toolkit

CI License: MIT Version Skills Claude Code ClaudePluginHub

Team-ready Claude Code skill pack — for dev, QA, QC, testers, and team leads.

A Claude Code plugin bundling 15 integration skills your whole team can install once and start using immediately. All skills support multiple accounts via INI profile files (AWS-style), so personal/work/client accounts stay isolated and switchable on demand.

What's included

Service integrations (multi-account)

SkillSlash commandWhat it does
trello/trelloBoards, lists, cards, comments via Trello REST API
azure-devops/azure-devopsRepos, PRs, work items, pipelines (Services + self-hosted Server)
heroku/herokuApps, dynos, releases, config vars, logs, pipelines (Platform API v3)
sentry/sentryIssues, events, releases (Sentry SaaS + self-hosted)
slack/slackPost messages, threads, file uploads, channel/user lookup
firebase/firebaseRemote Config, App Distribution, Crashlytics symbols, Functions, Hosting (multi-project)
shopify/shopifyShopify Admin GraphQL API — products/orders/customers/inventory/draft orders (multi-store, latest API 2026-04)
postgres/postgresRead-only queries, EXPLAIN plans, schema, indexes, locks

Mobile (React Native, iOS, Android)

SkillSlash commandWhat it does
react-native/react-nativeDaily RN ops: run/clean/bundle/log/version/icons/splash
maestro/maestroMobile E2E with YAML flows (alternative to Detox)
fastlane/fastlaneiOS+Android release: TestFlight, App Store, Play Console, code signing

Testing & quality

SkillSlash commandWhat it does
rspec/rspecRun specs, parse failures, parallel, coverage, bisect
rails-security/rails-securityBrakeman static scan + bundler-audit CVE check (combined, with diff against base branch)
k6/k6Load/stress/soak/spike tests with environment profiles
xlsx-testcases ⭐/xlsx-testcasesConvert XLSX test cases → Maestro YAML / Detox / Markdown + sync to Azure DevOps Test Plans

Install

Option A — via Claude Code plugin marketplace

# In Claude Code:
/plugin marketplace add tuannv14/claude-team-toolkit
/plugin install claude-team-toolkit

Option B — clone manually

git clone https://github.com/tuannv14/claude-team-toolkit.git
# Then: /plugin marketplace add <local-path>

One-time setup

bash lib/install.sh

This:

  1. Copies shared helpers to ~/.claude-team-toolkit/lib/ (every skill sources from there).
  2. Verifies dependencies: curl, jq, base64, awk, sed.
  3. Creates audit log directory ~/.claude-team-toolkit/audit.log (mode 600).

Quick start

1. Install dependencies

Most skills need curl + jq. Some need extras:

SkillExtra dependency
heroku, sentry, slack, trello, azure-devopscurl, jq
firebasefirebase-tools (npm install -g firebase-tools)
postgrespsql (PostgreSQL client)
rspec, rails-securityRuby project with bundler (gems: brakeman, bundler-audit)
k6k6 binary (k6 version)
maestromaestro binary (curl -Ls "https://get.maestro.mobile.dev" | bash)
react-nativeNode 18+, Yarn/npm, Watchman, Xcode (iOS), Android Studio (Android)
fastlaneRuby + gem 'fastlane' in project Gemfile
xlsx-testcasespython3 + delegates to anthropic-skills:xlsx for parsing

2. Configure your first account

# In Claude Code:
/trello configure
/azure-devops configure
/heroku configure
# ... etc.

Each configure is interactive and:

  • Prompts for the credentials it needs
  • Validates against the live API before saving
  • Writes to ~/.<service>/credentials with mode 0600
  • Refuses to save if validation fails

3. Use it

/trello card https://trello.com/c/AbCd1234
/azure-devops pr-list MyRepo MyProject
/heroku scale my-app web=3
/sentry issues --query "is:unresolved age:-24h"
/slack post "#deploys" "v2.1.0 shipped"
/postgres query "SELECT count(*) FROM users"
/rspec run spec/models/user_spec.rb
/rails-security audit
/rails-security diff main
/k6 run tests/load.js --profile staging

Multi-account workflow

All credential-based skills follow the same INI profile pattern (modeled after AWS CLI). Add unlimited profiles per service: personal, work, multiple clients, dev/staging/prod environments — each isolated.

Which skills support multi-account

SkillCredentials filePer-profile fields
trello~/.trello/credentialskey, token
azure-devops~/.azure-devops/credentialsorg_url, pat, api_version, project, insecure
heroku~/.heroku/credentialsapi_key, default_app, require_confirm
sentry~/.sentry/credentialsapi_url, auth_token, org, project
slack~/.slack/credentialsbot_token, default_channel, require_confirm
firebase~/.firebase/credentialsproject_id, service_account, ios_app_id, android_app_id
shopify~/.shopify/credentialsshop_domain, access_token, api_version, require_confirm (supports multi-store and multi-app on the same store via separate profiles)
postgres~/.postgres/credentialshost, port, database, user, password, sslmode, read_only, require_confirm
maestro~/.maestro/profiles.iniplatform, device, app_id, flows_dir, cloud_api_key
fastlane~/.fastlane/credentialsappstore_api_*, google_play_json_key, match_*
k6~/.k6/credentialsbase_url, auth_header, vus, duration, require_confirm
rspec~/.rspec/credentialsproject_path, rails_env, workers, seed_strategy

No multi-account (purely local, no remote auth): react-native, rails-security, xlsx-testcases (the latter reuses the /azure-devops profile when syncing to Test Plans).

See examples/ for sanitized credential templates.

How to add and switch profiles

# 1) Add accounts interactively (skill validates against live API before saving)
/trello configure                              # creates [default]
/trello configure                              # add another → name it "work"
/trello configure                              # add another → name it "client_a"

# 2) Manage them
/trello profile list                           # show all profiles, * marks active
/trello profile current                        # show active + masked token
/trello profile use work                       # set "work" as active default
/trello profile remove client_a                # delete a profile

# 3) Use them
/trello --profile client_a boards              # one-off override (highest priority)
TRELLO_PROFILE=work /trello cards <listId>     # via env var (per-shell session)
/trello boards                                 # uses active profile or [default]

Same dispatch commands across all 12 multi-account skills. Replace trello with azure-devops, heroku, sentry, slack, firebase, shopify, postgres, k6, maestro, fastlane, or rspec.

Profile resolution priority

When you call a skill, the active profile is resolved in this order (first match wins):

  1. --profile <name> flag — highest priority, per-call override
  2. <SERVICE>_PROFILE env var — per-shell session
    • TRELLO_PROFILE, HEROKU_PROFILE, SENTRY_PROFILE, SLACK_PROFILE, FIREBASE_PROFILE, SHOPIFY_PROFILE, PG_PROFILE, K6_PROFILE, MAESTRO_PROFILE, FASTLANE_PROFILE, RSPEC_PROFILE
    • azure-devops accepts both AZDO_PROFILE and AZURE_DEVOPS_PROFILE
  3. ~/.<service>/active_profile — written by profile use, persists across sessions
  4. [default] section — fallback if nothing else is set

How Claude auto-detects which skill to use

Claude reads each skill's frontmatter description at session start (~1,005 tokens total for all 15 skills, measured with tiktoken cl100k_base) to route incoming requests:

You sayClaude routes to
"fetch this trello card" / paste https://trello.com/c/... URL/trello card <id>
"list azure devops PRs" / mention an ADO repo/azure-devops pr-list
"scale my heroku app" / "promote staging to prod"/heroku scale or /heroku promote
"any sentry errors today?"/sentry issues
"post this to slack"/slack post
"deploy firebase functions"/firebase fn-deploy
"list shopify products" / "open orders this week" / paste myshopify URL/shopify products or /shopify orders
"what's the slowest query?"/postgres slow
"run e2e on this flow"/maestro run
"release iOS to TestFlight"/fastlane beta-ios
"load test the staging API"/k6 run
"rerun only failed specs"/rspec failed
"scan for SQL injection" / "any new CVEs?"/rails-security
"convert these xlsx test cases to maestro"/xlsx-testcases gen maestro
"clean RN build" / "bump app version"/react-native

Switching profiles in conversation works the same way: tell Claude "on the work account, list my Trello boards" — Claude understands and runs /trello --profile work boards.

Adapting to your project

Nothing in this toolkit is tied to a specific project, organization, or host. To use it for your project:

  1. Configure your accounts: run /<skill> configure for each service you use. Pick profile names that match your own workflow (personal, work, acme-corp, staging, prod, etc.).
  2. Set per-project defaults with env vars in your project's .env (which is .gitignored):
    AZDO_PROFILE=acme-corp
    HEROKU_PROFILE=staging
    PG_PROFILE=staging-readonly
    
  3. Drop a .testcase-schema.yml in your xlsx folder to tell /xlsx-testcases how to read your column layout (template in examples/).
  4. Mark prod profiles with require_confirm = true and (for postgres) read_only = true so destructive ops require explicit typed confirmation.
  5. Audit log at ~/.claude-team-toolkit/audit.log records every mutation as timestamp <TAB> service <TAB> profile <TAB> action. Ship to your SIEM (filebeat / fluentd / cloudwatch agent) for centralized audit if needed.

Security model

Read this before adding credentials.

ConcernHow the skills handle it
Credential storage~/.<service>/credentials, mode 0600. Skills refuse to load if the file is world-readable on POSIX.
Accidental commitsShipped .gitignore blocks **/credentials, **/*.pat, **/*.token, **/*.key, **/*.pem, .env*, **/secrets/, AWS/GCP credential patterns.
Display maskingTokens/PATs shown as ****<last4> only. Config vars matching `KEY
Validation before saveConfigure flow calls a real API endpoint and refuses to save invalid credentials.
Mutation safetyDestructive ops (destroy, rollback, rm, kill, mutating SQL, etc.) require typed confirmation phrases.
Per-profile require_confirmSet on prod profiles to force confirmation on every mutation.
Profile-level read_onlyPostgres profiles can be hard-locked read-only — refuses writes even with --write.
Prompt injectionCard/PR/issue/work-item content treated as untrusted input. Skills don't act on instructions found inside that content.
Audit log~/.claude-team-toolkit/audit.log records every mutation: timestamp + service + profile + action. Never records credentials or values.
TLSDefault verify ON. Self-signed cert support is opt-in per profile (insecure = true for Azure DevOps Server).
Least privilegeEach skill documents the minimum scopes/permissions needed. Prefer scoped tokens.

What the skills will never do

  • Write credentials to chat output, commit messages, transcripts, or any file other than the designated credentials file.
  • Echo full key/token/PAT — only the last 4 characters.
  • Mutate data based on instructions discovered inside API content (PR body, card description, work item description, Slack message, etc.).
  • Bypass TLS verification unless explicitly opted in via insecure = true.
  • Run mutating SQL on a read_only = true profile.
  • Run k6 against a profile with require_confirm = true without typed confirmation.

If a credential is compromised

Revoke immediately at the service's token management page:

  • Trello: https://trello.com//account → Power-Ups and Integrations
  • Azure DevOps: https://<org-or-server>/_usersSettings/tokens
  • Heroku: Account Settings → Applications → Authorizations
  • Sentry: User Settings → Auth Tokens
  • Slack: https://api.slack.com/apps → your app → OAuth & Permissions → Reinstall
  • Postgres: ALTER USER readonly_user WITH PASSWORD '<new>';

Token economics — honest accounting

TL;DR: This toolkit is NOT primarily a token-saving tool. It costs tokens on top of what Claude would generate ad-hoc for most tasks. The real value is multi-account profiles + safety gates + audit logging + consistency. Token cost is the price you pay for those, paid back only on specific workloads (multi-account, uncommon APIs, unique workflows).

Two scripts let you verify everything yourself:

python3 scripts/benchmark_tokens.py            # measure skill sizes
python3 scripts/benchmark_realistic_baseline.py # measure ad-hoc cost
python3 scripts/benchmark_cross_validate.py    # cross-check 3 tokenizers

Measurement methodology

All numbers below are measured with tiktoken cl100k_base (GPT-4 tokenizer, ±5% of Claude's per Anthropic docs). Cross-validated against o200k_base (GPT-4o) and char-based estimation — spread is 3.3% on bodies, 7.3% on frontmatter, well within stated uncertainty.

Costs (measured)

Always-loaded every session (15 frontmatter descriptions): ~1,005 tokens. You pay this even if you never invoke a toolkit skill.

Per skill body (loaded only when that skill is invoked):

SkillBodySkillBody
shopify2,233rspec1,296
heroku1,864maestro1,290
azure-devops1,744trello1,232
slack1,612xlsx-testcases1,172
k61,586react-native1,154
rails-security1,562sentry1,366
postgres1,529firebase1,314
fastlane1,123Average1,471

Honest comparison vs ad-hoc Claude

We measured 18 realistic "without skill" responses (what Claude generates ad-hoc for typical tasks). Mean cost: 163 tokens per task (median 167, range 104–232). Most APIs in this toolkit are well-known to Claude — it generates concise correct curl/jq commands in 100–250 tokens.

ScenarioWithout toolkitWith toolkitVerdict
1 skill × 1 invocation~163~2,676toolkit costs ~16× more
1 skill × 5 invocations~815~3,476toolkit costs ~4× more
3 skills × 4 invocations~1,956~7,818toolkit costs ~4× more
5 skills × 5 invocations~4,075~13,360toolkit costs ~3× more

For pure token consumption on common APIs, ad-hoc Claude is cheaper.

Where the toolkit DOES save tokens

The pure comparison above ignores three real-world cost categories that the toolkit eliminates and ad-hoc Claude has to pay each time:

  1. Multi-account auth context — without a skill, every task on a different account requires re-explaining "use this key/token, this region, this api version". Conservatively ~200 tokens of auth context per call. With profiles, switching is --profile work (≤5 tokens).

  2. Retries on uncommon APIs — Azure DevOps Server (api-version 5.1 quirks), Maestro YAML schema, Shopify GraphQL field names, Heroku Platform-API-specific headers. Empirical retry rate 35–55% on first ad-hoc attempt, retry costs ~50% of original. With skill: zero retries because the body has the exact pattern.

  3. Unique workflows — xlsx-testcases is the clearest case. Claude cannot generate the xlsx → Maestro YAML pipeline ad-hoc within a reasonable token budget. Measured ad-hoc baseline: 2,500+ tokens with high retry probability. With skill: 1,372 tokens body + 200 completion. This skill alone justifies the toolkit for QA teams using xlsx test cases.

Including these effects, on multi-account workflows or uncommon APIs the toolkit reaches break-even at 5–10 invocations per skill per session and saves significantly beyond that. On well-known single-account APIs (GitHub via curl, simple Slack post), it never pays for itself.

What you actually buy

This is the real value proposition, not token savings:

FeatureWhy it matters
Multi-account profilesOne pattern across 12 services. No more "which key for which client?"
Audit logging~/.claude-team-toolkit/audit.log records every mutation (timestamp + service + profile + action). Never logs credentials. Compliance/debug ready.
Safety gatesctt_confirm typed confirmation for destructive ops (rollback, destroy, drop, kill, scale). Profile-level require_confirm=true for prod.
StandardizationSame dispatch pattern across all skills → predictable for new team members.
Security defaultschmod 600 enforced, refuse world-readable, mask tokens as ****<last4>, validate creds against live API before save.
xlsx-testcasesUnique workflow not buildable ad-hoc within reasonable token budget.
No --dangerously-skip-permissionsStandard tool allowlist. Audit trail per skill invocation.

When to use this toolkit

  • ✅ Team with 2+ accounts per service (clients, dev/staging/prod)
  • ✅ QA teams writing tests in xlsx and need runnable specs
  • ✅ Rails + RN teams wanting one consistent toolkit
  • ✅ Compliance/audit requirements (mutations need an audit trail)
  • ✅ Working with uncommon APIs (Azure DevOps Server, self-hosted Sentry)
  • ✅ Onboarding new devs/QAs (standardized commands across services)

When NOT to use this toolkit

  • ❌ Solo project, single account per service
  • ❌ Only need 1–2 skills occasionally
  • ❌ Already have CLI alternatives that work fine (e.g., aws s3 directly)
  • ❌ One-shot ad-hoc tasks on well-known APIs

Reproducing these numbers

Run the benchmarks yourself to verify for your stack:

python3 scripts/benchmark_tokens.py             # full skill measurements
python3 scripts/benchmark_realistic_baseline.py # 18 sample ad-hoc responses
python3 scripts/benchmark_cross_validate.py     # 3-method cross-check

All scripts use the public tiktoken library. No API key needed.

Tips to minimize token cost

  • Run bash lib/install.sh once at install — not per session.
  • Set <SERVICE>_PROFILE env var once per shell — not --profile foo per call.
  • Use profile use <name> to set a persistent default.
  • Don't run configure repeatedly — one-time per profile.
  • Fork and remove unused skills — each skill folder you delete drops ~70 always-loaded tokens. If you only need 5 skills, this halves the base cost.

Why curl + jq, not MCP?

Each MCP server's tool schemas cost roughly ~500 tokens per tool loaded into every Task tool invocation. A single 10-tool MCP server eats more context than this entire toolkit's always-loaded skill descriptions combined (~1,100 tokens for all 16 skills).

claude-team-toolkit ships zero MCP dependencies — pure bash plumbing (curl + jq + lib/credentials.sh). You pay only:

  • The frontmatter description (1 line per skill, ~25 tokens) — always loaded
  • The skill body (~700–1,500 tokens) — loaded only when that skill is invoked
  • Reference files (e.g., shopify/commands.md) — loaded only when the SKILL.md tells the model to load them

No MCP server schemas. No node_modules. No daemon. No "10-MCP cap" to worry about.

If you do need MCP-backed integrations (e.g., GitHub via the official MCP server), mix and match — claude-team-toolkit doesn't fight your MCP setup, it just doesn't add to it.


Architecture

claude-team-toolkit/
├── .claude-plugin/plugin.json
├── .gitignore                       # blocks credential leaks
├── LICENSE                          # MIT
├── README.md
├── lib/
│   ├── credentials.sh               # shared: load_creds, mask, parse_ini, profiles
│   ├── confirm.sh                   # shared: destructive op confirmation
│   └── install.sh                   # one-time setup (run once after install)
└── skills/
    ├── trello/SKILL.md
    ├── azure-devops/SKILL.md
    ├── heroku/SKILL.md
    ├── sentry/SKILL.md
    ├── slack/SKILL.md
    ├── firebase/SKILL.md
    ├── postgres/SKILL.md
    ├── react-native/SKILL.md
    ├── maestro/SKILL.md
    ├── fastlane/SKILL.md
    ├── rspec/SKILL.md
    ├── rails-security/SKILL.md
    ├── k6/SKILL.md
    └── xlsx-testcases/SKILL.md

Token efficiency

  • All skills source ~/.claude-team-toolkit/lib/credentials.sh — no duplicated helper code per skill.
  • Frontmatter description is precise so Claude only loads the relevant skill body.
  • Verbose API references (full WIQL syntax, full Heroku endpoint catalog) are on-demand — referenced from the skill but loaded only when needed.

For team leads

  • The toolkit is stateless at the team level — each user has their own credentials. Nothing is shared across machines.
  • Recommend the team use least-privilege scopes — each SKILL.md documents the minimum permissions needed per operation.
  • For internal Azure DevOps Server with self-signed certs, decide once whether to enable insecure = true and document for the team.
  • For prod-sensitive services (heroku, slack, postgres, k6), set require_confirm = true on the relevant profile so every mutation goes through an explicit prompt.
  • Audit log at ~/.claude-team-toolkit/audit.log is per-user — for centralized audit, ship it to your SIEM via filebeat / fluentd / cloudwatch agent.

Roadmap

PRs welcome. Planned skills:

  • Jira — issues, sprints, comments
  • GitLab — MRs, issues, pipelines
  • Linear — issues, cycles
  • Notion — pages, databases
  • Datadog — metrics, monitors
  • PagerDuty — incidents, on-call
  • Lighthouse — perf audits

Contributing

See CONTRIBUTING.md for setup, skill design rules, security checklist, and trim policy.

Quick rules:

  • New skills must source lib/credentials.sh (no duplicated helpers)
  • Frontmatter description ≤ 40 words
  • Mutating ops must use ctt_confirm + ctt_audit_log
  • No real credentials, internal hostnames, or project names anywhere

Examples

Sanitized templates in examples/ — copy to your config locations:

  • examples/trello-credentials.example → ~/.trello/credentials
  • examples/azure-devops-credentials.example → ~/.azure-devops/credentials
  • examples/.testcase-schema.example.yml → your xlsx folder
  • examples/.env.example → your project root

Reporting security issues

Don't open a public issue. Email 96.tuan.nv@gmail.com with subject [SECURITY] claude-team-toolkit.


License

MIT — see LICENSE.

Ver o original no GitHub

Bom para

Relacionados