fix(runner): support chaining kubectl commands with && || ; in K8s CLI action

[RamanKharchee]

Description

The K8s CLI action (kubectl_command_executor) fails when two valid kubectl commands are joined with &&. Reported in nudgebee/nudgebee-enterprise#33447 (runbook template "Clean Up Evicted and Failed Pods"):

kubectl get pods -n <ns> --field-selector status.phase=Failed -o wide && kubectl get pods -n <ns> --field-selector status.phase=Succeeded -o wide

error: name cannot be provided when a selector is specified

Root cause: KubectlExecutor.Run tokenized the command with shlex.Split and exec'd a single kubectl with no shell (exec.CommandContext(ctx, "kubectl", args...)). shlex treats && as an ordinary word, so every token from && onward (&&, kubectl, get, pods, …) became positional NAME arguments of the first kubectl get pods. With --field-selector also set, kubectl emits exactly name cannot be provided when a selector is specified. Only the first verb was ever allowlist-checked.

What changed

runner/pkg/kube/exec.go:

• Split the command into segments on the sequential operators &&, ||, ; and run each as its own kubectl process, with shell short-circuit semantics (&& runs on success, || on failure, ; always). &&/|| are equal-precedence, left-associative, so evaluating left-to-right against the carried exit code reproduces bash for mixed chains. stdout/stderr are aggregated; exit_code is the last executed command's status.
• Every segment's verb is validated against the read-only allowlist before any segment runs — so get pods && delete pod foo is rejected atomically, not after executing the read half. The per-command allowlist guarantee is preserved for each command, not just the first.
• Pipes and redirects are rejected with a clear error. Without a shell we can't pipe anyway, and piping to a non-kubectl binary (grep, awk) would escape the verb allowlist — out of scope by design.
• Single (unchained) commands are unchanged: one segment, same behavior as before.

runner/pkg/kube/exec_test.go: the exact reported command, per-segment allowlist enforcement (0 executions on rejection), all five short-circuit cases, AllowWrite chained mutations, pipe/redirect rejection, empty-segment rejection.

Type of change

• Bug fix (non-breaking change which fixes an issue)

How Has This Been Tested?

• go test ./pkg/kube/ — all pass (existing + new)
• go vet ./pkg/kube/ and gofmt — clean
• golangci-lint — blocked locally by a go1.25-vs-module-go1.26.3 toolchain mismatch; relies on CI to lint

Review Notes → Risks & Counterarguments

• Security is the crux. The read-only allowlist previously only checked the first verb. This change validates every chained segment up front and refuses to execute any if one fails validation. If you review one thing, review validateSegment being called for all segments before runSegments, and TestKubectl_Chained_ValidatesEverySegment.
• Pipes/redirects unsupported. Rejected rather than shelled out, to keep the "kubectl-only, verb-allowlisted" model. If users need | grep, that's a separate, larger decision (would need a shell + full-string verb parsing).
• Glued operators (a&&b with no surrounding spaces) are not split — shlex yields them as one token. Standard usage has spaces around operators (as in the report). Noted as a known minor limitation rather than adding a raw-string pre-parser that would fight shlex quoting.
• Cross-repo issue: the fix lives here (k8s-agent) but the issue is on nudgebee-enterprise, so GitHub won't auto-close it — please close nudgebee/nudgebee-enterprise#33447 manually on merge.

🤖 Generated with Claude Code

[gemini-code-assist]

Code Review

This pull request introduces support for sequentially chaining multiple kubectl commands using &&, ||, and ; operators, while explicitly rejecting unsupported shell operators like pipes and redirects. It also ensures that all command segments are validated against the read-only allowlist before any execution begins. The review feedback suggests improving context cancellation handling by checking ctx.Err() at the start of the execution loop and immediately after running a command segment. Additionally, it is recommended to gracefully handle trailing semicolons, which are currently incorrectly rejected as empty segments.

[github-actions]

📦 Image Tags Updated

I've automatically updated the image tags in `charts/nudgebee-agent/values.yaml` to the latest versions from GHCR for the `main` branch.

The image tags are now synchronized with the latest builds and ready for release.

[RamanKharchee]

Addressed all three @gemini-code-assist comments in 2fe5d3c:

1. Context cancellation (HIGH, ×2) — runSegments now checks ctx.Err() at the top of the loop (won't start another kubectl after a cancel/deadline) and immediately after cmd.Run() (a context-killed process returns an ExitError that must not be read as a normal non-zero kubectl exit — which would otherwise look like success on the last segment). Both paths return the aggregated output plus the context error and stop the chain.

2. Trailing ; (MEDIUM) — kubectl get pods ; is now accepted as the valid shell no-op it is (the trailing empty segment is dropped). A bare/empty command restores the clearer empty command after stripping prefix message. Leading, trailing, and doubled &&/|| stay rejected.

3. Extracted execResult() to avoid repeating the result-map literal across the new early returns.

Added tests: TestKubectl_Chained_RespectsCancelledContext (no segment runs, error propagates) and TestKubectl_Chained_AcceptsTrailingSemicolon.

go test ./pkg/kube/, go vet, gofmt all clean.

(Note: the branch also picked up an automated chore: update image tags commit from release automation — unrelated to this change; my review fix is rebased on top of it.)

[gemini-code-assist]

Thanks for the detailed update, @RamanKharchee. The implementation of segment-based execution, context-aware cancellation, and the robust test suite for short-circuiting and validation logic looks excellent. The approach to handle ExitError specifically to avoid false positives on context cancellation is exactly the right way to handle that edge case. Everything looks solid and ready to go.