· 1 observation
Technical updates · 1
Package or technical metadata updated
View technical comparison →Testkube v1.0.0
Use Testkube in your AI agent
From the developer
Not specified in the available declarations: limitations, pricing & account requirements.
What is Testkube and how do I get started with it?
Developer declarations; not independently tested. Listing last checked Nov 21, 2026. Package observed Nov 21, 2026.
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.
· 1 observation
Package or technical metadata updated
View technical comparison →· 2 observations
Package or technical metadata updated
View technical comparison →· 2 observations
Package or technical metadata updated
View technical comparison →Package or technical metadata updated
View technical comparison →Finding similar plugins… Results will appear here automatically.
Browse plugins →---
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` musPreview of the first 4,000 characters. Read full instructions →
Referenced files: 1 — file references are metadata, not package contents.
---
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.
--- 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.
--- 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.
---
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.
--- 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.
Publisher declarations from the archived package. These are separate from our research and the live service's terms.
Package observed Nov 21, 2026.
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.