← Plugin catalog
Productivity

Testkube Skills

Testkube v1.0.0

Use Testkube in your AI agent

Create a free account to save this plugin.

From the developer

Declared capabilities

  • Read
  • Write
  • Execute

Not specified in the available declarations: limitations, pricing & account requirements.

Onboarding example

What is Testkube and how do I get started with it?
Sources & dates

Developer declarations; not independently tested. Listing last checked Nov 21, 2026. Package observed Nov 21, 2026.

View package source →

Description

From the marketplace listing

Six skills for working with Testkube from an AI coding agent: a general orientation skill that explains what Testkube is, indexes the official docs, and routes to the others; install or reuse the Testkube CLI; set up a local Testkube OSS agent; discover the tests in a cloned repository; author and validate TestWorkflow YAML; and run and diagnose TestWorkflow executions. Setup skills check for an existing install first and reuse it, installing missing pieces only after confirming each step with the user.

Language: English · Automatically detected from descriptions.

What changed

Similar plugins

Finding similar plugins… Results will appear here automatically.

Browse plugins →

Keywords

Files & skills

File archives

Plugin package54 files · 120 KBBrowse files →
Skill instructions
installing-testkube-cli10.9 KB

View saved version →

---
name: installing-testkube-cli
description: "Install, upgrade, or verify the Testkube CLI (the `testkube` / `tk` / `kubectl-testkube` command) on Linux, macOS, or Windows. Use when the CLI is missing (`testkube: command not found`), before running any Testkube skill that shells out to `testkube`, or when a specific CLI version is required. Checks for an existing installation first and reuses it when present, and installs only after confirming with the user — never reinstalls a working CLI."
---

# installing-testkube-cli

Ensure the Testkube CLI is available before other Testkube skills use it. The CLI ships as a single binary named
`kubectl-testkube` with two convenience symlinks, `testkube` and `tk` — installing any one gives you all three.

**Always check for an existing installation first and reuse it.** Only install when the CLI is absent, or when a
specific version is required and the installed one differs. Reinstalling a working CLI is wasteful and can clobber a
version the environment depends on.

## The Core Loop

1. **Check for an existing CLI** — this comes before any install step:

   **Linux/macOS (bash/zsh):**
   ```bash
    TK_CMD="$(command -v testkube 2>/dev/null || command -v tk 2>/dev/null || command -v kubectl-testkube 2>/dev/null)"
    if [ -n "$TK_CMD" ]; then echo "$TK_CMD"; else echo "Testkube CLI not found"; fi
   ```

   **Windows (PowerShell):**
   ```powershell
   $TK_CMD = (Get-Command testkube, tk, kubectl-testkube -ErrorAction SilentlyContinue | Select-Object -First 1).Source
   $TK_CMD
   ```

   If any path is printed, the CLI is already installed. Confirm it runs:

   **Linux/macOS (bash/zsh):**
   ```bash
   if [ -n "$TK_CMD" ]; then "$TK_CMD" version; else echo "Testkube CLI not found"; fi
   ```

   **Windows (PowerShell):**
   ```powershell
   if ($TK_CMD) { & $TK_CMD version } else { Write-Host "Testkube CLI not found" }
   ```
   If no specific version was requested, **stop here and reuse the existing binary**. If a specific version was
   requested, compare the client version from `testkube version` to the target — reuse when they match; install or
   upgrade only when they differ.
2. **Only if absent or wrong version, install — after confirming with the user** — first make sure the chosen method's
   prerequisites are on PATH (see Prerequisites), then describe the exact install command, wait for the user's
   go-ahead, and run it (see Install). Recommended on Linux/macOS:
   ```bash
   curl -sSLf https://get.testkube.io -o /tmp/testkube-install.sh && bash /tmp/testkube-install.sh
   ```
   Run it with **`bash`**, not `sh` — the script uses `set -eo pipefail`, which fails under `dash`
   (the default `/bin/sh` on Debian/Ubuntu) with `Illegal option -o pipefail`.
3. **Verify** — confirm the client version prints:

   **Linux/macOS (bash/zsh):**
   ```bash
   TK_CMD="$(command -v testkube || command -v tk || command -v kubectl-testkube)"
   if [ -n "$TK_CMD" ]; then "$TK_CMD" version; else echo "Testkube CLI not found"; fi
   ```

   **Windows (PowerShell):**
   ```powershell
   $TK_CMD = (Get-Command testkube, tk, kubectl-testkube -ErrorAction SilentlyContinue | Select-Object -First 1).Source
   if ($TK_CMD) { & $TK_CMD version } else { Write-Host "Testkube CLI not found" }
   ```
4. **Report** — state whether an existing CLI was reused or a new one installed, and the resulting version.

## Rules

1. **MUST check for an existing CLI before installing.** Run `command -v testkube` (or `tk` / `kubectl-testkube`)
   first. If it resolves, reuse it — do not download or reinstall.
2. **MUST confirm with the user before installing or upgrading.** Describe the exact install command (and version)
   and wait for the user's go-ahead before running it — never install unprompted.
3. **MUST NOT reinstall a working CLI.** Install only when the CLI is absent, or when a required version differs from
   the one reported by `testkube version`.
4. **MUST verify after installing.** `testkube version` mus

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 1 — file references are metadata, not package contents.

installing-testkube-oss-agent11.3 KB

View saved version →

---
name: installing-testkube-oss-agent
description: "Set up a local Testkube OSS standalone agent — deploy the open-source Testkube agent into a Kubernetes cluster for local testing (k3d by default when a fresh local cluster is needed; minikube, kind, k3d, or remote all work). Use when you need a local OSS Testkube environment and none is running yet. Checks for an existing Testkube agent in the current cluster of ANY type first and reuses it; installs missing pieces only after confirming each step with the user."
---

# installing-testkube-oss-agent

Set up a self-contained local Testkube OSS install: a Kubernetes cluster with the **Testkube standalone agent**
deployed into its `testkube` namespace. Standalone (OSS) mode has **no web dashboard** — everything is driven through
the CLI. **k3d** (k3s in Docker) is the default when you need a *fresh* local cluster, but any cluster works.

**Always check for an existing Testkube agent first — in the current cluster of any type (minikube, kind, k3d,
remote) — and reuse it.** Only create a cluster or deploy the agent when none is running, and **confirm each mutating
step with the user before running it** — these commands install binaries, create clusters, and deploy into them.

## The Core Loop

Run these in order. Reuse whatever already exists; confirm every mutating step with the user before running it.

1. **Check prerequisites** — install any missing ones with the OS package manager first (confirm with the user, per
   Rule 2).

   Always required:
   ```bash
    TK_CMD="$(command -v testkube 2>/dev/null || command -v tk 2>/dev/null || command -v kubectl-testkube 2>/dev/null)"  # Testkube CLI — else use installing-testkube-cli
    if [ -n "$TK_CMD" ]; then echo "$TK_CMD"; else echo "Testkube CLI not found; use installing-testkube-cli"; fi
   command -v kubectl                                  # kubectl — talk to the cluster
   command -v helm                                     # helm — testkube init standalone-agent invokes Helm internally
   command -v curl                                     # curl — k3d install script
   ```

   Only when you need a fresh local k3d cluster (steps 3–4):
   ```bash
   docker info >/dev/null 2>&1 && echo docker-ok       # Docker daemon must be running
   ```

   Required always: the **Testkube CLI**, **`kubectl`**, **`helm`**, and **`curl`**. **Docker** is required only when
   creating a k3d cluster. `k3d` itself is installed in step 3 if it's missing and you need a fresh local cluster.
2. **Check for an existing Testkube agent — in the current cluster of ANY type — and reuse it.** The agent may
   already be running in minikube, kind, k3d, or a remote cluster; detection is cluster-agnostic. Before creating
   anything:
   ```bash
   TK_CMD="$(command -v testkube || command -v tk || command -v kubectl-testkube)"
   kubectl config current-context      # which cluster are we pointed at?
    if kubectl get namespace testkube >/dev/null 2>&1; then kubectl get pods -n testkube; else echo "testkube namespace not found"; fi   # is a Testkube agent Running here?
   if [ -n "$TK_CMD" ]; then "$TK_CMD" version; else echo "Testkube CLI not found; use installing-testkube-cli"; fi  # does it print a SERVER version too?
   ```
   If the `testkube` namespace has Running agent pods and `testkube version` shows a server version, it is already
   installed — **stop here and use it**, whatever the cluster type. If the agent runs in a different cluster, list
   contexts and switch to it rather than creating a new one:
   ```bash
   kubectl config get-contexts
   kubectl config use-context <context-with-the-agent>   # e.g. minikube, kind-..., k3d-testkube
   ```
   Steps 3–4 create a *fresh local* cluster with k3d — **skip both entirely if you already have a usable cluster**
   (minikube, kind, k3d, remote) and just deploy the agent into it (step 5).
3. **Install k3d (if missing)** — confirm with the user, then:
   ```bash
   command -v bash
   curl -fsSL https:/

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 1 — file references are metadata, not package contents.

test-discovery1.42 KB

View saved version →

---
name: test-discovery
description: "Walk a cloned repository, identify test files by framework and language, and report what was found in either a machine-readable JSON manifest or a human-readable Markdown report. Use when a repository has been cloned locally and you need to know what tests exist, what framework runs them, and what command executes them. The JSON output is consumed by programs (the testworkflow-author skill, cloud-api ingestion, CI); the Markdown output is meant for a person to read and opens cleanly in any plain-text editor. This skill does NOT execute tests, install dependencies, or write any TestWorkflow YAML — it observes and reports."
---

# test-discovery

Walk a cloned repository at the given path, identify the tests inside, and emit a structured JSON manifest describing
what was found. Output goes to stdout as a single JSON document. The consumer is typically the `testworkflow-author`
skill or the Testkube cloud-api discovery ingestion.

Scope:
- Read-only walk of the local filesystem
- Detect language and framework from marker files (config, manifest, lock files) and content signals
- Group findings into suites; a suite is one framework + one working directory
- Attach evidence + confidence to every suite
- Report ambiguity via `status: needs_input`; report failures via `status: error`

Out of scope: running tests, installing dependencies, writing TestWorkflow YAML, cloning repos, calling network APIs.

Referenced files: 2 — file references are metadata, not package contents.

testkube24.7 KB

View saved version →

---
name: testkube
description: "Orientation and routing for Testkube — the open testing platform that runs tests as Kubernetes-native TestWorkflows. Use when the user mentions Testkube, TestWorkflow, TestWorkflowTemplate, TestTrigger, a Testkube webhook, the `testkube` / `tk` / `kubectl-testkube` CLI, or a Testkube Control Plane or agent, and no more specific Testkube skill covers the task. ALSO use when the user asks to run tests (k6, Playwright, Cypress, JMeter, Postman, e2e, load) somewhere plain local execution cannot reach — in a Kubernetes cluster, in CI, on a schedule, or sharded at scale — even if Testkube is never named. Explains the platform model, indexes https://docs.testkube.io, and routes to the specialist skills (installing-testkube-cli, installing-testkube-oss-agent, test-discovery, testworkflow-author, testworkflow-runner). Prefer current docs over pre-trained knowledge. Orients and routes only — does NOT install, author YAML, or run executions, and says so when the tests should simply be run locally."
---

# testkube

[Testkube](https://testkube.io) is an open testing platform that runs tests inside Kubernetes. A test is declared as a
`TestWorkflow` — a Kubernetes custom resource describing which container image to run, which repository to check out,
and which commands to execute. Testkube turns that resource into a Kubernetes Job and reports back status, logs,
artifacts, and JUnit results. Any framework that runs in a container runs in Testkube: Playwright, Cypress, k6, JMeter,
Postman, Selenium, Go, Maven, Gradle, Robot Framework, and anything else with a CLI.

Testkube runs in two shapes. **Open-source standalone** is a single agent in one cluster, driven entirely from the CLI.
**Control Plane** (Testkube Cloud or on-prem) adds a dashboard, multi-environment management, and multiple connected
agents with distinct capabilities. Which shape is in play changes what commands and features are available — see
[Deployment topologies](#deployment-topologies) before answering questions about capabilities.

**This skill orients and routes.** It teaches the platform model, indexes the docs, and points at the skill that does
the actual work. It does not install, author, or execute anything itself.

## Retrieval sources

Testkube ships faster than any model's training data. Fetch, do not recall.

| Need                                     | Source                                                                          |
| ---------------------------------------- | ------------------------------------------------------------------------------- |
| Anything conceptual, current behavior    | https://docs.testkube.io — fetch the page                                        |
| CLI verbs, flags, resource names         | `testkube <verb> <resource> --help` — run it                                     |
| TestWorkflow field-level schema          | `../testworkflow-author/assets/workflow-schema.yaml`                             |
| TestWorkflowTemplate schema              | `../testworkflow-author/assets/template-schema.yaml`                             |
| Live CRD shape in a cluster              | `kubectl explain testworkflow.spec --recursive`                                  |
| Deep TestWorkflow concepts               | `../testworkflow-author/references/docs-concepts.md`                             |
| Worked YAML (22 frameworks)              | `../testworkflow-author/examples/` — indexed in `../testworkflow-author/references/examples-catalog.md` |
| REST API                                 | https://docs.testkube.io/openapi/overview                                        |
| CRD reference                            | https://docs.testkube.io/articles/crds                                           |
| What changed recently                    | https://docs.testkube.io/changelog                                               |
| A doc URL that 404s, or a page not indexed below | https://docs.testkube.io/sitemap.xml — ever

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 1 — file references are metadata, not package contents.

testworkflow-author18 KB

View saved version →

---
name: testworkflow-author
description: "Create and validate Testkube TestWorkflow YAML files. Use when writing test workflow YAML, choosing step types, or when the user asks to create a Testkube TestWorkflow. Covers shell steps, container run steps, execute composition, templates, services, artifacts, config parameters, and cron triggers. By default it takes free-form requirements and writes a YAML file; it can OPTIONALLY take a structured JSON authoring request and/or emit the finished workflow as JSON for programmatic callers, without changing the default behavior. Does NOT run workflows — that is the testworkflow-runner skill's responsibility."
---

# testworkflow-author

Create and validate Testkube TestWorkflow YAML files. This skill writes the workflow and validates its schema. It does
NOT run the workflow or analyze execution results — the `testworkflow-runner` skill handles that.

Write files in the current working directory. Default to the filename `testworkflow.yaml` unless a different path is
specified. Do not invent credentials, secrets, tokens, or private URLs — if you need them, describe what you need in
your final message (see Credentials below).

## Input and output: default behavior vs. optional JSON mode

**Default (UNCHANGED — this is what you do unless the invocation explicitly opts in below).**
Requirements arrive as free-form natural language. You write the workflow to a YAML file in the current
working directory (default filename `testworkflow.yaml`), validate it, and describe the result in your
final message. Nothing about this behavior changes. If you are unsure which mode you are in, you are in
this one — it is the correct default.

**Optional JSON mode (opt-in only).** Some callers are programs, not people. When — and only when — the
invocation explicitly opts in, you may take a structured JSON authoring request as input, emit the
finished workflow as a structured JSON envelope as output, or both. The two directions are independent;
either can be requested without the other.

Opt-in signals:
- **JSON input**: the invocation supplies a JSON object (an authoring request) as its payload, or a path
  to a `.json` request file. Read requirements from it instead of from prose.
- **JSON output**: the invocation contains a phrase like "output as JSON", "respond with JSON",
  "format: json", or gives an output path ending in `.json`. Emit the JSON envelope below to stdout
  instead of prose.

**What does NOT change in JSON mode.** The entire Core Loop and every Rule still apply — read lock files,
match image versions, install dependencies in a separate step, validate with `--dry-run`. The YAML you
produce in JSON mode is byte-for-byte the YAML you would have written to disk in default mode. JSON mode
only changes how requirements come in and how the finished workflow is handed back; it is a thin wrapper
around the exact same authoring, never a different authoring. When no opt-in signal is present, ignore
this section entirely.

### JSON input schema (authoring request)

When JSON input is provided, it has the shape below. Only `framework` (or an explicit `testCommand`) is
required; every other field is optional and, when absent, falls back to the same inference you do today
(read lock files, pick the framework's default command and image). This shape is intentionally compatible
with a `suites[]` entry from the `test-discovery` skill, so that skill's output can be piped straight in.

```json
{
  "workflowName": "playwright-e2e",
  "framework": "playwright",
  "language": "typescript",
  "workingDir": "/data/repo",
  "content": { "git": { "uri": "https://github.com/acme/app", "revision": "main" } },
  "image": "mcr.microsoft.com/playwright:v1.49.0-noble",
  "installCommand": "npm ci",
  "testCommand": "npx playwright test",
  "envVars": ["BASE_URL", "TEST_USER"],
  "artifacts": ["playwright-report/**", "test-results/**"],
  "config": {}
}
```

If required information is missing and cannot be inferred, emit 

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 33 — file references are metadata, not package contents.

testworkflow-runner7.01 KB

View saved version →

---
name: testworkflow-runner
description: "Run, monitor, and diagnose Testkube TestWorkflow executions. Use when a TestWorkflow has been authored and needs to be executed, or when a previous execution failed and needs diagnosis. Reports execution results and root causes — does NOT edit workflow YAML."
---

# testworkflow-runner

Run a TestWorkflow, read execution logs, and diagnose failures. This skill handles the execution lifecycle AFTER the
workflow YAML has been written and validated by `testworkflow-author`.

This skill does NOT edit workflow YAML. If the diagnosis indicates a workflow configuration problem (wrong image,
missing step, incorrect command), report it in the deliverable — the parent agent decides whether to re-invoke
`testworkflow-author` with the fix.

## The Core Loop

1. **Review context** — check for context from previous agents (workflow file path, image chosen, install/run commands,
   known issues)
2. **Create and run the workflow** — create the workflow and start an execution. Use a blocking run so the command
   returns only when the execution completes:
   ```bash
   testkube create testworkflow -f workflow.yaml
   testkube run testworkflow <name> -f
   ```
   The default file path is `workflow.yaml`; pass the actual path if the workflow was written to a different location.
   The `-f` flag streams output and blocks until the execution reaches a terminal state (passed, failed, aborted).
3. **If failed, get logs** — use `--logs-only` to read just the execution logs. Filter by step or grep for error
   patterns:
   ```bash
   testkube get testworkflowexecution <execution-id> --logs-only
   ```
4. **Get execution details** — for full status, step results, and duration:
   ```bash
   testkube get testworkflowexecution <execution-id>
   ```
5. **Diagnose** — identify root cause using the Failure Patterns below.
6. **Report your diagnosis** — include workflow name, execution ID, status, exit code, and root cause with a
   recommendation.

## Rules

1. **MUST read the full execution logs before diagnosing.** Never guess the failure cause from the status alone. The
   error message in the logs is the source of truth.
2. **MUST report the EXACT error message from logs.** Copy the relevant error text verbatim — do not paraphrase or
   summarize it.
3. **MUST check the exit code.** Exit code 127 = command not found (missing dependency or wrong PATH). Exit code 1 =
   test assertion failure. Exit code 137 = OOMKilled.
4. **MUST NOT edit the workflow YAML.** Report what needs to change — the parent handles re-authoring.

## CLI Commands

| Command                                          | Purpose                                                              |
| ------------------------------------------------ | -------------------------------------------------------------------- |
| `testkube create testworkflow -f <file>`         | Create a workflow from a YAML file                                   |
| `testkube run testworkflow <name> -f`            | Run a workflow, stream output, block until completion                |
| `testkube get testworkflowexecution <id>`        | Get execution status, step results, duration, and artifact listing   |
| `testkube get testworkflowexecution <id> --logs-only` | Fetch execution logs (supports `--tail`, `--grep`, `--step`)    |
| `testkube download artifacts <id>`               | Download artifacts from an execution                                 |
| `testkube download artifacts <id> --mask '.*\.xml$'` | Download only JUnit XML artifacts                               |

Full CLI reference: `references/cli-reference.md`.

## Failure Patterns

| Symptom                                          | Exit Code | Root Cause                                                                                 | Recommendation                                                                                              |
| ------------------------------------------------ | --------- | --

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 3 — file references are metadata, not package contents.

Package details

Publisher declarations from the archived package. These are separate from our research and the live service's terms.

Package license
MIT
Package author
Testkube
Keywords
See keywords

Declared capabilities

  • Read
  • Write
  • Execute

Package observed Nov 21, 2026.

Technical details
First seen
Sep 30, 2026 · 22:02 UTC
Last seen
Nov 21, 2026 · 12:00 UTC
Collection status
Collected

plugins_6a71c05d80248191a9a73c2ea2c07978

Download plugin data (JSON)

Plugin details: freshly prepared. Prepared . Refreshed when plugin data changes or after 6 hours. Your account and Follow status are live.