Skip to content
Back to search

jk

GitHub CLI-style interface for Jenkins controllers - create multibranch jobs, inspect config.xml, and manage runs, logs, artifacts, credentials, nodes, and queues

Safety scan

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

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/avivsinai/jenkins-cli with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/avivsinai/jenkins-cli'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/avivsinai--jenkins-cli/badge.svg)](/listings/avivsinai--jenkins-cli)

HTML

<a href="/listings/avivsinai--jenkins-cli"><img src="/api/listings/avivsinai--jenkins-cli/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.

Install the `jk` binary from the paths below. Homebrew uses [`avivsinai/tap`](https://github.com/avivsinai/homebrew-tap) (`jk`); Scoop uses [`avivsinai/scoop-bucket`](https://github.com/avivsinai/scoop-bucket). There is no Nix package and no PyPI project for this CLI.

Homebrew (macOS/Linux)

brew install avivsinai/tap/jk

Scoop (Windows)

scoop bucket add avivsinai https://github.com/avivsinai/scoop-bucket
scoop install jk

Go Install

# Install latest version
go install github.com/avivsinai/jenkins-cli/cmd/jk@latest

# Or install specific version
go install github.com/avivsinai/jenkins-cli/cmd/jk@v0.0.36

Binary will be installed to `$GOPATH/bin` (or `$HOME/go/bin` by default).

Binary Downloads

Download prebuilt binaries (macOS, Linux, Windows) or `.deb` packages from [GitHub Releases](https://github.com/avivsinai/jenkins-cli/releases).

From Source

git clone https://github.com/avivsinai/jenkins-cli.git
cd jenkins-cli
make build   # produces ./bin/jk

AI Coding Skill

Install the `jk` skill for Claude Code or Codex CLI:

<details open> <summary><b>Via skills (Recommended)</b></summary>

Using [Vercel's skills CLI](https://github.com/vercel-labs/add-skill):

npx skills add avivsinai/jenkins-cli -g -y

</details>

<details> <summary><b>Via skild registry</b></summary>

npx skild install @avivsinai/jk -t claude -y

</details>

<details> <summary><b>Via Skills Marketplace</b></summary>

> **Known Issue**: Claude Code uses SSH to clone marketplace repos, which fails without SSH keys configured. See [issue #14485](https://github.com/anthropics/claude-code/issues/14485). Use the skills or skild methods instead.

/plugin marketplace add avivsinai/skills-marketplace
/plugin install jk@avivsinai-marketplace

</details>

<details> <summary><b>Manual install</b></summary>

git clone https://github.com/avivsinai/jenkins-cli.git
cp -r jenkins-cli/skills/jk ~/.claude/skills/

</details>

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/plugin.json · Manifest · 23 lines
  1. {
  2. "name": "jk",
  3. "version": "0.0.45",
  4. "description": "GitHub CLI-style interface for Jenkins controllers - create multibranch jobs, inspect config.xml, and manage runs, logs, artifacts, credentials, nodes, and queues",
  5. "author": {
  6. "name": "Aviv Sinai",
  7. "url": "https://github.com/avivsinai"
  8. },
  9. "repository": "https://github.com/avivsinai/jenkins-cli",
  10. "license": "MIT",
  11. "skills": "./skills/",
  12. "keywords": [
  13. "jenkins",
  14. "ci",
  15. "cd",
  16. "pipeline",
  17. "multibranch",
  18. "builds",
  19. "devops",
  20. "cli",
  21. "automation"
  22. ]
  23. }
README.md · README · 390 lines
  1. # jk
  2. <p align="center"><em>GitHub CLI–style workflows for Jenkins controllers</em></p>
  3. <p align="center">
  4. <a href="https://github.com/avivsinai/jenkins-cli/releases/latest"><img src="https://img.shields.io/github/v/release/avivsinai/jenkins-cli" alt="Latest release"></a>
  5. <a href="LICENSE"><img src="https://img.shields.io/badge/License-MIT-blue.svg" alt="License: MIT"></a>
  6. <a href="go.mod"><img src="https://img.shields.io/badge/Go-1.26+-00ADD8.svg" alt="Go Version"></a>
  7. <a href="https://github.com/avivsinai/jenkins-cli/actions/workflows/ci.yml"><img src="https://github.com/avivsinai/jenkins-cli/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
  8. <a href="https://github.com/avivsinai/jenkins-cli/actions/workflows/gitleaks.yml"><img src="https://github.com/avivsinai/jenkins-cli/actions/workflows/gitleaks.yml/badge.svg" alt="Security"></a>
  9. <a href="https://scorecard.dev/viewer/?uri=github.com/avivsinai/jenkins-cli"><img src="https://api.scorecard.dev/projects/github.com/avivsinai/jenkins-cli/badge" alt="OpenSSF Scorecard"></a>
  10. </p>
  11. `jk` is a single Go binary for Jenkins operators. Search jobs across folders, trigger and follow runs, stream logs, download artifacts, and manage credentials, nodes, queues, and plugins. Output is human, JSON, or YAML.
  12. This is not the official Jenkins CLI (`jenkins-cli.jar`; [jenkins.io](https://www.jenkins.io/doc/book/managing/cli/)).
  13. **Status ([v0.0.36](https://github.com/avivsinai/jenkins-cli/releases/tag/v0.0.36), 11 Aug 2026):** released and tested against stock Jenkins LTS REST APIs. Auth, contexts, search, jobs, runs, logs, artifacts, tests, credentials, nodes, queue, and plugins ship today. Companion plugin, JCasC, events, and metrics are not in this binary. The version stays 0.x for that reason.
  14. ## Features
  15. - **Context-aware auth** – store multiple controllers, switch with `jk context use`, or pin a context via `JK_CONTEXT`.
  16. - **Friendly pipelines** – trigger, rerun, follow, and summarize jobs with human or JSON/YAML output.
  17. - **Job provisioning & config** – create Bitbucket-backed Multibranch Pipeline jobs, inspect raw `config.xml`, patch Jenkinsfile paths, and rescan multibranch jobs.
  18. - **Scriptable output** – `--format json|yaml`, `--jq`, and `--template` for machine-friendly pipelines; `--quiet` for scripting.
  19. - **Discovery-first runs** – filter with `--filter`, bound history with `--since`, group by parameters, and attach machine-readable metadata for agents.
  20. - **Artifacts & tests** – browse artifacts, download filtered sets, and surface aggregated test reports.
  21. - **Platform operations** – cordon nodes, manage credentials, inspect queues, and view installed plugins.
  22. - **GitHub CLI parity** – command structure and UX mirror `gh`, easing adoption in developer toolchains.
  23. ## Installation
  24. Install the `jk` binary from the paths below. Homebrew uses [`avivsinai/tap`](https://github.com/avivsinai/homebrew-tap) (`jk`); Scoop uses [`avivsinai/scoop-bucket`](https://github.com/avivsinai/scoop-bucket). There is no Nix package and no PyPI project for this CLI.
  25. ### Homebrew (macOS/Linux)
  26. ```bash
  27. brew install avivsinai/tap/jk
  28. ```
  29. ### Scoop (Windows)
  30. ```powershell
  31. scoop bucket add avivsinai https://github.com/avivsinai/scoop-bucket
  32. scoop install jk
  33. ```
  34. ### Go Install
  35. ```bash
  36. # Install latest version
  37. go install github.com/avivsinai/jenkins-cli/cmd/jk@latest
  38. # Or install specific version
  39. go install github.com/avivsinai/jenkins-cli/cmd/jk@v0.0.36
  40. ```
  41. Binary will be installed to `$GOPATH/bin` (or `$HOME/go/bin` by default).
  42. ### Binary Downloads
  43. Download prebuilt binaries (macOS, Linux, Windows) or `.deb` packages from [GitHub Releases](https://github.com/avivsinai/jenkins-cli/releases).
  44. ### From Source
  45. ```bash
  46. git clone https://github.com/avivsinai/jenkins-cli.git
  47. cd jenkins-cli
  48. make build # produces ./bin/jk
  49. ```
  50. ### AI Coding Skill
  51. Install the `jk` skill for Claude Code or Codex CLI:
  52. <details open>
  53. <summary><b>Via skills (Recommended)</b></summary>
  54. Using [Vercel's skills CLI](https://github.com/vercel-labs/add-skill):
  55. ```bash
  56. npx skills add avivsinai/jenkins-cli -g -y
  57. ```
  58. </details>
  59. <details>
  60. <summary><b>Via skild registry</b></summary>
  61. ```bash
  62. npx skild install @avivsinai/jk -t claude -y
  63. ```
  64. </details>
  65. <details>
  66. <summary><b>Via Skills Marketplace</b></summary>
  67. > **Known Issue**: Claude Code uses SSH to clone marketplace repos, which fails without SSH keys configured. See [issue #14485](https://github.com/anthropics/claude-code/issues/14485). Use the skills or skild methods instead.
  68. ```bash
  69. /plugin marketplace add avivsinai/skills-marketplace
  70. /plugin install jk@avivsinai-marketplace
  71. ```
  72. </details>
  73. <details>
  74. <summary><b>Manual install</b></summary>
  75. ```bash
  76. git clone https://github.com/avivsinai/jenkins-cli.git
  77. cp -r jenkins-cli/skills/jk ~/.claude/skills/
  78. ```
  79. </details>
  80. ## Quickstart
  81. Find jobs fast with `jk search` (alias for `jk run search`) before drilling into specific pipelines.
  82. ```bash
  83. jk auth login https://jenkins.company.example # authenticate and create a context
  84. jk context ls # list available contexts
  85. jk search --job-glob '*deploy-*' --limit 5 --json # discover job paths across folders
  86. jk job create auth-relay --folder platform/services --repo-owner playg --repository my-service-repo --script-path services/auth-relay/Jenkinsfile --credentials bitbucket-ro
  87. jk job config platform/services/auth-relay | rg scriptPath
  88. jk job configure platform/services/auth-relay --script-path services/auth-relay/Jenkinsfile
  89. jk job config platform/services/auth-relay | jk job configure platform/services/auth-relay --stdin
  90. jk job scan platform/services/auth-relay
  91. jk run ls team/app/pipeline --filter result=SUCCESS --since 7d --limit 5 --json --with-meta
  92. jk run ls team/app/pipeline --include-queued # include queued builds (shown as qN)
  93. jk run params team/app/pipeline # inspect inferred parameter metadata
  94. jk log team/app/pipeline 128 --follow # stream logs until completion
  95. jk log team/app/pipeline 128 --tail 40 --plain # last 40 lines of a completed console
  96. jk log team/app/pipeline 128 --grep '(?i)error|fail' --tail 20 --json # last 20 matching lines
  97. jk artifact download team/app/pipeline 128 -p "**/*.xml" -o out/
  98. ```
  99. Mutating commands do not automatically retry transport failures: Jenkins may
  100. have accepted the action before its reply was lost. Check the server state
  101. before submitting again. Read retries and one authentication/crumb refresh after
  102. a 401/403 response remain enabled.
  103. ### Source revisions in run output
  104. `run ls`, `run view`, and `search` prefer the job's `SCMRevisionAction`
  105. revision over shared-library checkouts. For GitHub pull requests built with a
  106. merge strategy, `commit` is the PR head, not Jenkins' synthetic merge commit.
  107. Branch and repository metadata are omitted when no current checkout can be
  108. matched to that revision; a matching branch name or historical checkout alone
  109. is insufficient. Controllers whose SCM revision exposes neither `hash` nor
  110. `pullHash` (including some Bitbucket/GitLab PR revisions) retain legacy checkout
  111. selection. A failed source-revision lookup is reported as an error.
  112. ### Watch a commit's build
  113. ```bash
  114. jk run watch team/app/main --commit <full-source-sha> --exit-status --timeout 20m
  115. jk run watch team/app/main --commit <full-source-sha> --json --timeout 20m
  116. ```
  117. `run watch` scans retained build history in newest-first pages for an exact full
  118. 40- or 64-character hexadecimal source SHA. If no build exists yet, it polls and
  119. shows queue reasons for the job without claiming that those queue entries belong
  120. to the commit. Once it finds a build, it pins that build number even if another
  121. build of the same commit starts later. Executor waits are correlated by the
  122. queue task's build URL, not by its display name.
  123. Progress goes to stderr and is printed only when the state changes; ETA-only
  124. changes are suppressed. JSON/YAML stdout contains one final result, including on
  125. timeout or cancellation. `--interval` defaults to `2s`; `--timeout 0` waits without
  126. a deadline. A timeout covers discovery and execution and exits 124; cancellation
  127. exits 130. With `--exit-status`, build results use the same codes as `run view`
  128. (SUCCESS 0, UNSTABLE 10, FAILURE 11, ABORTED 12, NOT_BUILT 13); an unknown terminal
  129. result exits 1. See the [watch output contract](docs/api.md#29-commit-watch-jk-run-watch---json).
  130. Log filters use Go regular expressions and apply `--grep` before `--tail`. They scan the complete console of a **completed** build; running builds and `--follow` cannot use these filters. Selected output is limited to 2 MiB: if the requested result does not fit, JSON/YAML reports `truncated: true` and `complete: false`. A line larger than 1 MiB fails explicitly. `--plain` keeps output free of headings and notices; use structured output when completeness matters.
  131. ### Jenkins SSO / Google OAuth
  132. `jk` uses Jenkins API tokens for scripted clients. If your controller uses Google OAuth, OpenID Connect, Okta, Azure AD, or another browser-based SSO realm, sign in to Jenkins in the browser first, open `/me/configure`, create a Jenkins API token, then run:
  133. ```bash
  134. jk auth login https://jenkins.company.example --username <jenkins-user-id> --with-token < jenkins-token.txt
  135. ```
  136. `--with-token` reads the token from standard input, so it never shows in the process list. `--token <JENKINS_API_TOKEN>` also works, but `ps` shows it.
  137. Use your Jenkins user ID for `--username`. For many Google/OIDC setups that is your email address, but some SSO realms use an opaque provider ID instead. If you are unsure, sign in to Jenkins in the browser and open `<jenkins-url>/whoAmI/api/json`; use the returned `name` value. If it reports `anonymous`, sign in first. Do not paste a Google OAuth access token into `--token` — Jenkins REST calls expect a Jenkins API token.
  138. This works because Jenkins validates API tokens before consulting the security realm, so SSO realms such as the `google-login` plugin do not block token-based CLI access (covered by an end-to-end test against a google-login controller).
  139. `jk auth login` verifies the credentials against the controller before finishing:
  140. - On success it reports the authenticated user (`Logged in to <url> as <user>`).
  141. - If Jenkins rejects the credentials (or treats them as anonymous), the login fails and the previous context, token, and active-context selection are restored — a typo can't clobber a working login. The error explains the API-token workflow and points to the browser `whoAmI` check above.
  142. - If the request is redirected to a sign-in page (Jenkins form login, `securityRealm/commenceLogin`, or an external identity provider), `jk` reports that the request never authenticated instead of failing on an HTML response. The same detection applies to every `jk` command, so an expired token against an SSO-fronted controller produces an actionable error.
  143. - If the controller cannot be reached, the credentials are saved unverified with a warning. Use `--no-verify` to skip the check entirely (for example when bootstrapping configuration before the controller is up).
  144. Service accounts cannot authenticate through a browser-based SSO realm like `google-login` — they never become Jenkins users, so they cannot hold API tokens. Jenkins itself still needs a Jenkins API token; a front door in front of Jenkins can admit the service account (see below).
  145. ### Front door (WAF, SSO proxy, Google IAP)
  146. Some controllers sit behind a front door that needs its own credential before a request reaches Jenkins (the controller answers by IP, but not through its DNS name). Add a `front_door` block to the context in `config.yaml`. `jk` keeps Jenkins Basic auth unchanged and also sends `<header>: Bearer <token>`, where the token is the output of `token_command`:
  147. ```yaml
  148. contexts:
  149. prod:
  150. url: https://jenkins.example.com
  151. username: alice@example.com
  152. front_door:
  153. mode: proxy-bearer-command
  154. header: Proxy-Authorization
  155. token_command: [gcloud, auth, print-identity-token, --audiences=<IAP_CLIENT_ID>]
  156. ```
  157. - `token_command` is an argv list. `jk` runs it without a shell before the first request, trims the output, and runs it again when the token is older than 30 minutes. For a service account, add `--impersonate-service-account=<sa-email>` to the gcloud command.
  158. - The header goes on every request to the context's host, including login verification and CSRF crumb requests. Redirects to other hosts (for example artifact downloads from object storage) do not get it.
  159. - `header` cannot be `Authorization`, because `jk` sends the Jenkins API token there. Google IAP accepts `Proxy-Authorization`.
  160. - If the command fails, the error names the context and the command. `jk` never prints the token.
  161. - If a first `jk auth login` is rejected with a 401, 403, or 407 that has no `X-Jenkins` header, the response came from the front door and the login error adds a hint pointing here.
  162. - Configure `front_door` in `config.yaml` first, then run `jk auth login <url> --name prod ...`. Login keeps the existing `front_door` block and verifies through the front door.
  163. ### Secret Storage
  164. By default, `jk` stores API tokens in the OS keychain. `--allow-insecure-store` or `JK_ALLOW_INSECURE_STORE=1` selects the encrypted file backend instead of trying native keyring backends. `KEYRING_BACKEND` remains an explicit backend override for advanced use.
  165. For noninteractive file-backend use, set `JK_KEYRING_PASSPHRASE` before running `jk`; compatible fallback variables are `KEYRING_FILE_PASSWORD` and `KEYRING_PASSWORD`.
  166. ### Headless authentication
  167. Set `JK_TOKEN` to supply the API token for the selected context without opening
  168. the keyring or storing the token. Context selection stays `--context` >
  169. `JK_CONTEXT` > active context. Empty environment variables are treated as unset.
  170. With no selected context, provide `JK_URL`, `JK_USER` (the Jenkins user ID) and
  171. `JK_TOKEN` together to use an ephemeral connection. For example, after your
  172. secrets manager supplies `JK_TOKEN`:
  173. ```bash
  174. export JK_URL=https://jenkins.example.com
  175. export JK_USER=automation
  176. jk run ls team/app/main --json
  177. jk auth status
  178. ```
  179. Nothing is written to config or the keyring. `auth status` reports
  180. `Credential source: environment` and never prints the token.
  181. `JK_URL` and `JK_USER` require the complete three-variable tuple. When a stored
  182. context is selected, those values must match its URL and user; they cannot
  183. silently redirect its credential to another controller. An explicitly selected
  184. missing context is an error. `JK_TOKEN` alone requires an existing selected
  185. context. Unset all three variables before `auth login` or `auth logout` to manage
  186. stored credentials; these commands do not persist or remove environment tokens.
  187. Structured `jk search` output already includes lightweight search metadata; `--with-meta` is only needed for `jk run ls` (`jk search` accepts it as a no-op for flag parity).
  188. Add `--json`, `--yaml`, or `--format json|yaml` to supported commands for machine-readable output. Use `--jq` or `--template` to select or reshape JSON results.
  189. ```bash
  190. # Extract a single field with jq
  191. jk run view team/app/pipeline 128 --format json --jq '.result'
  192. # Custom formatting with Go templates
  193. jk run view team/app/pipeline 128 --format json --template 'Result={{.result}}'
  194. ```
  195. ## Pipeline Stage and Step Logs
  196. With the optional [Pipeline Graph View plugin](https://plugins.jenkins.io/pipeline-graph-view/), inspect native Pipeline stages and labelled steps without parsing the combined console:
  197. ```bash
  198. jk run steps team/app/main 128
  199. jk run steps team/app/main 128 --json
  200. jk log team/app/main 128 --step 23 --plain
  201. ```
  202. Use the returned node IDs, since parallel branches and repeated labels can have the same name. `--step` accepts a stage or step ID and reads only that node's log, capped at 2 MiB. JSON/YAML includes `stepId`, `truncated` and `complete`; `complete` is false for an unfinished build or capped response. Step logs cannot currently be combined with `--follow`, `--tail` or `--grep`. An absent plugin or unsupported run produces an explicit capability error; ordinary console logs keep working without the plugin. These endpoints require only read access to the run.
  203. ## Job Commands
  204. Job provisioning and config management:
  205. ```bash
  206. # Create a Bitbucket-backed Multibranch Pipeline job
  207. jk job create auth-relay \
  208. --folder platform/services \
  209. --repo-owner playg \
  210. --repository my-service-repo \
  211. --script-path services/auth-relay/Jenkinsfile \
  212. --credentials bitbucket-ro \
  213. --branch-strategy all
  214. # Create a job of any type (Pipeline, Freestyle, Folder, ...) from a full config.xml
  215. jk job config platform/services/auth-relay > auth-relay.config.xml
  216. jk job create auth-relay-copy --folder platform/services --file auth-relay.config.xml
  217. # Fetch raw config.xml (stdout is always XML)
  218. jk job config platform/services/auth-relay > auth-relay.config.xml
  219. # Replace config.xml from a file or stdin
  220. jk job configure platform/services/auth-relay --file auth-relay.config.xml
  221. cat auth-relay.config.xml | jk job configure platform/services/auth-relay --stdin
  222. # Patch only the Jenkinsfile path inside a Multibranch Pipeline config
  223. jk job configure platform/services/auth-relay --script-path services/auth-relay/Jenkinsfile
  224. # Trigger a multibranch rescan
  225. jk job scan platform/services/auth-relay
  226. ```
  227. ## Test reports
  228. Inspect JUnit results with `jk test report <job> <build>` or show only failing
  229. cases with `jk test report <job> <build> --failed`. The filter includes both
  230. `FAILED` and `REGRESSION` cases and keeps aggregate counts for the whole report.
  231. Human case names and error details are single lines with control characters
  232. removed, capped at 160 and 1,024 Unicode characters respectively (plus an ellipsis).
  233. Add `--json` or `--yaml` for case failure details, full stack traces, `age` and
  234. `failedSince` when Jenkins supplies them.
  235. `jk run view <job> <build> --summary` includes at most five failed cases with
  236. their failure history and a short error detail. Names and details are bounded to
  237. 160 and 240 Unicode characters respectively (plus an ellipsis when truncated);
  238. stack traces remain available through `test report --failed --json`. When
  239. Jenkins omits `totalCount`, totals are derived from pass, fail and skip counts.
  240. ## Documentation
  241. - [Specification](docs/spec.md) - Architecture and design decisions
  242. - [API Contracts](docs/api.md) - JSON/YAML schemas for structured output
  243. - [Agent Cookbook](docs/agent-cookbook.md) - Automation recipes and examples
  244. - [Changelog](CHANGELOG.md) - Release notes and migration guidance
  245. ## Security
  246. This project uses automated secret scanning ([gitleaks](https://github.com/gitleaks/gitleaks)), dependency updates ([Dependabot](https://github.com/dependabot)), and security posture tracking ([OSSF Scorecard](https://github.com/ossf/scorecard)).
  247. Found a security issue? See our [security policy](SECURITY.md) for responsible disclosure.
  248. ## Community
  249. - Read the [code of conduct](CODE_OF_CONDUCT.md) and [contributing guide](CONTRIBUTING.md)
  250. - Ask questions or propose ideas via GitHub Discussions (coming soon) or issues
  251. - Follow the [support guidelines](SUPPORT.md) for help
  252. ## Development
  253. ### Quick Start
  254. ```bash
  255. # First-time setup
  256. make pre-commit-install # Install git hooks (gitleaks, formatting, etc.)
  257. # Standard workflow
  258. make build # Build the binary
  259. make test # Run unit tests
  260. make lint # Run linters
  261. make security # Run security checks (gitleaks + pre-commit)
  262. ```
  263. ### Full Test Suite
  264. ```bash
  265. make e2e # End-to-end tests (requires Docker)
  266. make e2e-up # Launch test Jenkins (port 28080)
  267. make e2e-down # Tear down test environment
  268. ```
  269. **Prerequisites:**
  270. - [golangci-lint](https://golangci-lint.run/) for linting
  271. - [gitleaks](https://github.com/gitleaks/gitleaks) for secret scanning
  272. - [pre-commit](https://pre-commit.com/) for git hooks
  273. - Docker/Colima for e2e tests
  274. **Note:** E2e tests require Docker. On macOS with Colima, use `colima start --network-address`. See [CONTRIBUTING.md](CONTRIBUTING.md#end-to-end-tests) for details. Skip with `JK_E2E_DISABLE=1 make test`.
  275. ### Before Submitting PRs
  276. ```bash
  277. make security # Gitleaks + pre-commit checks
  278. make lint # Run linter
  279. make test # Run tests
  280. ```
  281. ## License
  282. `jk` is available under the [MIT License](LICENSE).

Version history

  • v0.0.4511/11/2026

  • v0.0.4311/7/2026

  • v0.0.4210/26/2026

  • v0.0.4110/21/2026

Ratings and comments

Sign in to rate this skill.

Sign in

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