kubeagent 0.1.0

package/dist/kubectl.js

@@ -0,0 +1,57 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { dbg } from "./debug.js";
+const execFileAsync = promisify(execFile);
+export class KubectlError extends Error {
+    stderr;
+    exitCode;
+    constructor(message, stderr, exitCode) {
+        super(message);
+        this.stderr = stderr;
+        this.exitCode = exitCode;
+        this.name = "KubectlError";
+    }
+}
+export function parseKubectlJson(raw) {
+    if (!raw.trim()) {
+        throw new KubectlError("Empty kubectl output");
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        throw new KubectlError(`Failed to parse kubectl output: ${raw.slice(0, 200)}`);
+    }
+}
+export async function kubectl(args, options = {}) {
+    const fullArgs = [...args];
+    if (options.context) {
+        fullArgs.unshift("--context", options.context);
+    }
+    if (options.namespace) {
+        fullArgs.unshift("-n", options.namespace);
+    }
+    dbg("kubectl", `kubectl ${fullArgs.join(" ")}`);
+    try {
+        const { stdout, stderr } = await execFileAsync("kubectl", fullArgs, {
+            timeout: (options.timeout ?? 30) * 1000,
+            maxBuffer: 10 * 1024 * 1024,
+        });
+        dbg("kubectl", `exit 0, stdout ${stdout.length}B${stderr ? `, stderr: ${stderr.slice(0, 200)}` : ""}`);
+        if (stderr && !stdout) {
+            throw new KubectlError(`kubectl error: ${stderr}`, stderr);
+        }
+        return stdout;
+    }
+    catch (err) {
+        if (err instanceof KubectlError)
+            throw err;
+        const e = err;
+        dbg("kubectl", `failed: ${e.message}`, { stderr: e.stderr, code: e.code });
+        throw new KubectlError(e.message ?? "kubectl failed", e.stderr, e.code);
+    }
+}
+export async function kubectlJson(args, options = {}) {
+    const output = await kubectl([...args, "-o", "json"], options);
+    return parseKubectlJson(output);
+}

package/dist/monitor/checks.d.ts

@@ -0,0 +1,71 @@
+import type { Issue } from "./types.js";
+interface PodStatus {
+    metadata: {
+        name: string;
+        namespace: string;
+    };
+    status: {
+        phase: string;
+        reason?: string;
+        containerStatuses?: Array<{
+            name: string;
+            state: {
+                waiting?: {
+                    reason?: string;
+                };
+                terminated?: {
+                    reason?: string;
+                };
+                running?: Record<string, unknown>;
+            };
+            lastState?: {
+                terminated?: {
+                    reason?: string;
+                };
+            };
+            restartCount: number;
+        }>;
+    };
+}
+interface NodeStatus {
+    metadata: {
+        name: string;
+    };
+    status: {
+        conditions: Array<{
+            type: string;
+            status: string;
+            reason?: string;
+        }>;
+    };
+}
+export declare function findPodIssues(podList: {
+    items: PodStatus[];
+}): Issue[];
+interface JobStatus {
+    metadata: {
+        name: string;
+        namespace: string;
+    };
+    status: {
+        failed?: number;
+        succeeded?: number;
+        active?: number;
+        conditions?: Array<{
+            type: string;
+            status: string;
+            reason?: string;
+            message?: string;
+        }>;
+    };
+    spec?: {
+        backoffLimit?: number;
+    };
+}
+export declare function findJobIssues(jobList: {
+    items: JobStatus[];
+}): Issue[];
+export declare function findNodeIssues(nodeList: {
+    items: NodeStatus[];
+}): Issue[];
+export {};

package/dist/monitor/checks.js

@@ -0,0 +1,167 @@
+export function findPodIssues(podList) {
+    const issues = [];
+    const now = new Date();
+    for (const pod of podList.items) {
+        const ns = pod.metadata.namespace;
+        const name = pod.metadata.name;
+        // Check Pending phase
+        if (pod.status.phase === "Pending") {
+            issues.push({
+                kind: "pod_pending",
+                severity: "warning",
+                namespace: ns,
+                resource: name,
+                message: `Pod ${name} is Pending in ${ns}`,
+                details: { phase: pod.status.phase },
+                timestamp: now,
+            });
+            continue;
+        }
+        // Check Failed phase (includes Evicted)
+        if (pod.status.phase === "Failed") {
+            if (pod.status.reason === "Evicted") {
+                issues.push({
+                    kind: "pod_evicted",
+                    severity: "warning",
+                    namespace: ns,
+                    resource: name,
+                    message: `Pod ${name} was Evicted in ${ns}`,
+                    details: { reason: "Evicted" },
+                    timestamp: now,
+                });
+            }
+            else {
+                issues.push({
+                    kind: "pod_failed",
+                    severity: "critical",
+                    namespace: ns,
+                    resource: name,
+                    message: `Pod ${name} is in Failed phase in ${ns}`,
+                    details: { phase: "Failed", reason: pod.status.reason },
+                    timestamp: now,
+                });
+            }
+            continue;
+        }
+        // Check Unknown phase
+        if (pod.status.phase === "Unknown") {
+            issues.push({
+                kind: "pod_failed",
+                severity: "critical",
+                namespace: ns,
+                resource: name,
+                message: `Pod ${name} is in Unknown phase in ${ns} (node may be unreachable)`,
+                details: { phase: "Unknown" },
+                timestamp: now,
+            });
+            continue;
+        }
+        for (const cs of pod.status.containerStatuses ?? []) {
+            const waitReason = cs.state.waiting?.reason;
+            const lastTermReason = cs.lastState?.terminated?.reason;
+            if (waitReason === "CrashLoopBackOff") {
+                issues.push({
+                    kind: "pod_crashloop",
+                    severity: "critical",
+                    namespace: ns,
+                    resource: name,
+                    message: `Container ${cs.name} in ${name} is CrashLoopBackOff (${cs.restartCount} restarts)`,
+                    details: { container: cs.name, restartCount: cs.restartCount },
+                    timestamp: now,
+                });
+            }
+            else if (waitReason === "ImagePullBackOff" || waitReason === "ErrImagePull") {
+                issues.push({
+                    kind: "pod_image_pull",
+                    severity: "critical",
+                    namespace: ns,
+                    resource: name,
+                    message: `Container ${cs.name} in ${name} has ${waitReason}`,
+                    details: { container: cs.name, reason: waitReason },
+                    timestamp: now,
+                });
+            }
+            else if (lastTermReason === "OOMKilled") {
+                issues.push({
+                    kind: "pod_oom",
+                    severity: "critical",
+                    namespace: ns,
+                    resource: name,
+                    message: `Container ${cs.name} in ${name} was OOMKilled (${cs.restartCount} restarts)`,
+                    details: { container: cs.name, restartCount: cs.restartCount },
+                    timestamp: now,
+                });
+            }
+            else if (waitReason === "Error" || cs.state.terminated?.reason === "Error") {
+                issues.push({
+                    kind: "pod_error",
+                    severity: "warning",
+                    namespace: ns,
+                    resource: name,
+                    message: `Container ${cs.name} in ${name} is in Error state`,
+                    details: { container: cs.name },
+                    timestamp: now,
+                });
+            }
+        }
+    }
+    return issues;
+}
+export function findJobIssues(jobList) {
+    const issues = [];
+    const now = new Date();
+    for (const job of jobList.items) {
+        const ns = job.metadata.namespace;
+        const name = job.metadata.name;
+        const failedCondition = job.status.conditions?.find((c) => c.type === "Failed" && c.status === "True");
+        if (failedCondition) {
+            issues.push({
+                kind: "job_failed",
+                severity: "critical",
+                namespace: ns,
+                resource: name,
+                message: `Job ${name} failed in ${ns}: ${failedCondition.reason ?? "unknown reason"}`,
+                details: {
+                    reason: failedCondition.reason,
+                    message: failedCondition.message,
+                    failed: job.status.failed ?? 0,
+                },
+                timestamp: now,
+            });
+        }
+    }
+    return issues;
+}
+export function findNodeIssues(nodeList) {
+    const issues = [];
+    const now = new Date();
+    const pressureTypes = ["MemoryPressure", "DiskPressure", "PIDPressure"];
+    for (const node of nodeList.items) {
+        const name = node.metadata.name;
+        for (const cond of node.status.conditions) {
+            if (cond.type === "Ready" && cond.status !== "True") {
+                issues.push({
+                    kind: "node_not_ready",
+                    severity: "critical",
+                    namespace: "",
+                    resource: name,
+                    message: `Node ${name} is NotReady: ${cond.reason ?? "unknown"}`,
+                    details: { reason: cond.reason },
+                    timestamp: now,
+                });
+            }
+            if (pressureTypes.includes(cond.type) && cond.status === "True") {
+                issues.push({
+                    kind: "node_pressure",
+                    severity: "warning",
+                    namespace: "",
+                    resource: name,
+                    message: `Node ${name} has ${cond.type}`,
+                    details: { conditionType: cond.type },
+                    timestamp: now,
+                });
+            }
+        }
+    }
+    return issues;
+}

package/dist/monitor/index.d.ts

@@ -0,0 +1,7 @@
+import { type KubectlOptions } from "../kubectl.js";
+import type { Issue } from "./types.js";
+export type IssueCallback = (issues: Issue[]) => void | Promise<void>;
+export declare function runChecks(options: KubectlOptions): Promise<Issue[]>;
+export declare function startMonitor(options: KubectlOptions, intervalMs: number, onIssues: IssueCallback): {
+    stop: () => void;
+};

package/dist/monitor/index.js

@@ -0,0 +1,126 @@
+import { kubectlJson } from "../kubectl.js";
+import { findPodIssues, findNodeIssues, findJobIssues } from "./checks.js";
+import chalk from "chalk";
+function deduplicateIssues(issues) {
+    // First pass: deduplicate exact duplicates
+    const seen = new Set();
+    const deduped = issues.filter((issue) => {
+        const key = `${issue.kind}:${issue.namespace}:${issue.resource}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+    // Second pass: group multiple pods of the same kind in the same namespace.
+    // If there are N pods with the same kind+namespace, keep only the first and
+    // annotate its message so the agent knows it's representative.
+    const groupCounts = new Map();
+    for (const issue of deduped) {
+        const gk = `${issue.kind}:${issue.namespace}`;
+        groupCounts.set(gk, (groupCounts.get(gk) ?? 0) + 1);
+    }
+    const groupSeen = new Set();
+    return deduped.filter((issue) => {
+        const gk = `${issue.kind}:${issue.namespace}`;
+        const count = groupCounts.get(gk) ?? 1;
+        if (count <= 1)
+            return true;
+        if (groupSeen.has(gk))
+            return false;
+        groupSeen.add(gk);
+        // Annotate the representative issue
+        issue.message = `${issue.message} (+${count - 1} similar in ${issue.namespace})`;
+        return true;
+    });
+}
+export async function runChecks(options) {
+    const allIssues = [];
+    // Get all pods across namespaces
+    const podList = (await kubectlJson(["get", "pods", "--all-namespaces"], options));
+    allIssues.push(...findPodIssues(podList));
+    // Get nodes
+    const nodeList = (await kubectlJson(["get", "nodes"], options));
+    allIssues.push(...findNodeIssues(nodeList));
+    // Get failed jobs
+    const jobList = (await kubectlJson(["get", "jobs", "--all-namespaces", "--field-selector=status.failed>0"], options).catch(() => ({ items: [] })));
+    allIssues.push(...findJobIssues(jobList));
+    return deduplicateIssues(allIssues);
+}
+// How long a pod must be Pending before it's reported as an issue.
+const PENDING_GRACE_MS = 60_000;
+export function startMonitor(options, intervalMs, onIssues) {
+    let running = true;
+    let inFlight = false;
+    // Tracks when each pending pod was first seen: "namespace/name" -> Date
+    const pendingSince = new Map();
+    let pendingRecheckTimer = null;
+    const tick = async () => {
+        if (!running || inFlight)
+            return;
+        inFlight = true;
+        const ts = new Date().toLocaleTimeString("en-GB", { hour: "2-digit", minute: "2-digit", second: "2-digit" });
+        process.stdout.write(chalk.dim(`  ${ts}  checking...`));
+        try {
+            const allIssues = await runChecks(options);
+            const now = new Date();
+            const pendingIssues = allIssues.filter((i) => i.kind === "pod_pending");
+            const otherIssues = allIssues.filter((i) => i.kind !== "pod_pending");
+            // Remove pods that are no longer pending
+            const currentPendingKeys = new Set(pendingIssues.map((i) => `${i.namespace}/${i.resource}`));
+            for (const key of pendingSince.keys()) {
+                if (!currentPendingKeys.has(key))
+                    pendingSince.delete(key);
+            }
+            // Separate newly pending from those that have exceeded the grace period
+            let hasNewPending = false;
+            const reportablePending = [];
+            for (const issue of pendingIssues) {
+                const key = `${issue.namespace}/${issue.resource}`;
+                if (!pendingSince.has(key)) {
+                    pendingSince.set(key, now);
+                    hasNewPending = true;
+                    process.stdout.write(chalk.dim(`\n  ○  ${issue.resource} (${issue.namespace}) is Pending — rechecking in ${PENDING_GRACE_MS / 1000}s`));
+                }
+                else if (now.getTime() - pendingSince.get(key).getTime() >= PENDING_GRACE_MS) {
+                    reportablePending.push(issue);
+                }
+            }
+            // Schedule a one-shot recheck for newly discovered pending pods
+            if (hasNewPending && !pendingRecheckTimer && running) {
+                pendingRecheckTimer = setTimeout(() => {
+                    pendingRecheckTimer = null;
+                    void tick();
+                }, PENDING_GRACE_MS);
+            }
+            const reportableIssues = [...otherIssues, ...reportablePending];
+            if (reportableIssues.length > 0 && running) {
+                process.stdout.write("\r\x1b[K");
+                await onIssues(reportableIssues);
+            }
+            else if (!hasNewPending) {
+                process.stdout.write(chalk.dim(`  ✔ all clear\n`));
+            }
+            else {
+                process.stdout.write("\n");
+            }
+        }
+        catch (err) {
+            process.stdout.write("\n");
+            console.error(chalk.red("Monitor check failed:"), err.message);
+        }
+        finally {
+            inFlight = false;
+        }
+    };
+    // Run immediately, then on interval
+    tick();
+    const timer = setInterval(tick, intervalMs);
+    return {
+        stop: () => {
+            running = false;
+            clearInterval(timer);
+            if (pendingRecheckTimer)
+                clearTimeout(pendingRecheckTimer);
+        },
+    };
+}

package/dist/monitor/types.d.ts

@@ -0,0 +1,11 @@
+export type Severity = "info" | "warning" | "critical";
+export type IssueKind = "pod_crashloop" | "pod_oom" | "pod_image_pull" | "pod_pending" | "pod_failed" | "pod_evicted" | "pod_error" | "node_not_ready" | "node_pressure" | "cert_expiring" | "resource_high" | "job_failed" | "rollout_stuck";
+export interface Issue {
+    kind: IssueKind;
+    severity: Severity;
+    namespace: string;
+    resource: string;
+    message: string;
+    details: Record<string, unknown>;
+    timestamp: Date;
+}

package/dist/monitor/types.js

@@ -0,0 +1 @@
+export {};

package/dist/notify/index.d.ts

@@ -0,0 +1,5 @@
+import type { Issue } from "../monitor/types.js";
+import type { KubeAgentConfig, NotificationChannel } from "../config.js";
+export declare function sendNotification(issues: Issue[], config: KubeAgentConfig, clusterContext?: string): Promise<void>;
+export declare function broadcastQuestion(question: string, choices: string[] | undefined, config: KubeAgentConfig, clusterContext?: string): Promise<void>;
+export declare function describeChannel(channel: NotificationChannel): string;

package/dist/notify/index.js

@@ -0,0 +1,40 @@
+import { sendSlack, sendSlackQuestion } from "./slack.js";
+import { sendTelegram, sendTelegramQuestion } from "./telegram.js";
+const SEVERITY_ORDER = { info: 0, warning: 1, critical: 2 };
+export async function sendNotification(issues, config, clusterContext) {
+    if (!config.notifications.channels.length)
+        return;
+    await Promise.all(config.notifications.channels.map(async (channel) => {
+        const minLevel = SEVERITY_ORDER[channel.severity];
+        const filtered = issues.filter((i) => SEVERITY_ORDER[i.severity] >= minLevel);
+        if (!filtered.length)
+            return;
+        switch (channel.type) {
+            case "slack":
+                await sendSlack(filtered, channel, clusterContext);
+                break;
+            case "telegram":
+                await sendTelegram(filtered, channel, clusterContext);
+                break;
+        }
+    }));
+}
+export async function broadcastQuestion(question, choices, config, clusterContext) {
+    if (!config.notifications.channels.length)
+        return;
+    await Promise.all(config.notifications.channels.map((channel) => {
+        switch (channel.type) {
+            case "slack": return sendSlackQuestion(channel, question, choices, clusterContext);
+            case "telegram": return sendTelegramQuestion(channel, question, choices, clusterContext);
+        }
+    }));
+}
+export function describeChannel(channel) {
+    const label = channel.label ? ` (${channel.label})` : "";
+    switch (channel.type) {
+        case "slack":
+            return `Slack${label}  ${channel.webhook_url.slice(0, 40)}…  min: ${channel.severity}`;
+        case "telegram":
+            return `Telegram${label}  chat: ${channel.chat_id}  min: ${channel.severity}`;
+    }
+}

package/dist/notify/setup.d.ts

@@ -0,0 +1,4 @@
+import type { NotificationChannel, SlackChannel, TelegramChannel } from "../config.js";
+export declare function setupSlack(): Promise<SlackChannel | null>;
+export declare function setupTelegram(): Promise<TelegramChannel | null>;
+export declare function interactiveAddChannel(): Promise<NotificationChannel | null>;

package/dist/notify/setup.js

@@ -0,0 +1,88 @@
+import readline from "node:readline";
+import chalk from "chalk";
+import { sendSlack } from "./slack.js";
+import { testTelegramCredentials } from "./telegram.js";
+async function ask(question, hint) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const hintStr = hint ? chalk.dim(` (${hint})`) : "";
+    return new Promise((resolve) => {
+        rl.question(chalk.cyan(`  ${question}${hintStr}: `), (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+async function pickSeverity() {
+    console.log(chalk.dim("\n  Minimum severity to notify:"));
+    console.log(`    ${chalk.cyan("1")}. warning  ${chalk.dim("— warning + critical")}`);
+    console.log(`    ${chalk.cyan("2")}. critical ${chalk.dim("— critical only")}`);
+    console.log(`    ${chalk.cyan("3")}. info     ${chalk.dim("— everything")}`);
+    const ans = await ask("Choice", "1");
+    const map = { "1": "warning", "2": "critical", "3": "info" };
+    return map[ans] ?? "warning";
+}
+export async function setupSlack() {
+    console.log(chalk.bold("\n  Slack Setup"));
+    console.log(chalk.dim("  Create an incoming webhook at: https://api.slack.com/apps\n"));
+    const webhook_url = await ask("Webhook URL");
+    if (!webhook_url)
+        return null;
+    const label = await ask("Label (optional)", "e.g. #alerts");
+    const severity = await pickSeverity();
+    const channel = { type: "slack", webhook_url, severity, label: label || undefined };
+    // Test it
+    process.stdout.write(chalk.dim("\n  Sending test message..."));
+    await sendSlack([{ kind: "pod_pending", severity: "warning", namespace: "test", resource: "kubeagent-test", message: "KubeAgent Slack integration working ✓", details: {}, timestamp: new Date() }], channel);
+    console.log(chalk.green(" sent!"));
+    const confirmed = await ask("Did you receive it? [y/N]");
+    if (confirmed.toLowerCase() !== "y") {
+        console.log(chalk.yellow("  Webhook not confirmed — channel not saved."));
+        return null;
+    }
+    return channel;
+}
+export async function setupTelegram() {
+    console.log(chalk.bold("\n  Telegram Setup"));
+    console.log(chalk.dim("  1. Create a bot via @BotFather and copy the token"));
+    console.log(chalk.dim("  2. Start a chat with your bot (or add it to a group)"));
+    console.log(chalk.dim("  3. Get your chat ID: message the bot, then visit:"));
+    console.log(chalk.dim("     https://api.telegram.org/bot<TOKEN>/getUpdates\n"));
+    const bot_token = await ask("Bot token");
+    if (!bot_token)
+        return null;
+    const chat_id = await ask("Chat ID");
+    if (!chat_id)
+        return null;
+    const label = await ask("Label (optional)", "e.g. ops-alerts");
+    const severity = await pickSeverity();
+    // Test credentials
+    process.stdout.write(chalk.dim("\n  Sending test message..."));
+    const result = await testTelegramCredentials(bot_token, chat_id);
+    if (!result.ok) {
+        console.log(chalk.red(` failed: ${result.error}`));
+        console.log(chalk.dim("  Check your bot token and chat ID."));
+        return null;
+    }
+    console.log(chalk.green(" sent!"));
+    const confirmed = await ask("Did you receive it? [y/N]");
+    if (confirmed.toLowerCase() !== "y") {
+        console.log(chalk.yellow("  Not confirmed — channel not saved."));
+        return null;
+    }
+    return { type: "telegram", bot_token, chat_id, severity, label: label || undefined };
+}
+export async function interactiveAddChannel() {
+    console.log(chalk.bold("\nAdd notification channel:\n"));
+    console.log(`  ${chalk.cyan("1")}. Slack`);
+    console.log(`  ${chalk.cyan("2")}. Telegram`);
+    console.log(`  ${chalk.cyan("3")}. Cancel\n`);
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const choice = await new Promise((resolve) => {
+        rl.question(chalk.cyan("  Choice [1]: "), (a) => { rl.close(); resolve(a.trim()); });
+    });
+    if (choice === "3" || choice === "")
+        return null;
+    if (choice === "2")
+        return setupTelegram();
+    return setupSlack();
+}

package/dist/notify/slack.d.ts

@@ -0,0 +1,4 @@
+import type { Issue } from "../monitor/types.js";
+import type { SlackChannel } from "../config.js";
+export declare function sendSlackQuestion(channel: SlackChannel, question: string, choices: string[] | undefined, clusterContext?: string): Promise<void>;
+export declare function sendSlack(issues: Issue[], channel: SlackChannel, clusterContext?: string): Promise<void>;

package/dist/notify/slack.js

@@ -0,0 +1,76 @@
+function formatSlackMessage(issues, clusterContext) {
+    const critical = issues.filter((i) => i.severity === "critical");
+    const warning = issues.filter((i) => i.severity === "warning");
+    const header = clusterContext
+        ? `*KubeAgent Alert* — \`${clusterContext}\``
+        : `*KubeAgent Alert*`;
+    const lines = issues.map((i) => {
+        const icon = i.severity === "critical" ? "🔴" : "🟡";
+        const ns = i.namespace ? ` \`${i.namespace}\`` : "";
+        return `${icon} ${i.message}${ns}`;
+    });
+    const summary = [
+        critical.length ? `${critical.length} critical` : "",
+        warning.length ? `${warning.length} warning` : "",
+    ].filter(Boolean).join(", ");
+    return {
+        blocks: [
+            {
+                type: "header",
+                text: { type: "plain_text", text: "⚠ KubeAgent Alert", emoji: true },
+            },
+            {
+                type: "section",
+                text: { type: "mrkdwn", text: `${header}\n${summary}` },
+            },
+            { type: "divider" },
+            {
+                type: "section",
+                text: { type: "mrkdwn", text: lines.join("\n") },
+            },
+        ],
+    };
+}
+async function postToSlack(channel, payload) {
+    try {
+        const url = new URL(channel.webhook_url);
+        if (!["https:", "http:"].includes(url.protocol)) {
+            console.error(`Slack: invalid URL protocol`);
+            return;
+        }
+    }
+    catch {
+        console.error(`Slack: invalid webhook URL`);
+        return;
+    }
+    try {
+        const res = await fetch(channel.webhook_url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(payload),
+        });
+        if (!res.ok) {
+            console.error(`Slack webhook failed: ${res.status} ${res.statusText}`);
+        }
+    }
+    catch (err) {
+        console.error(`Slack webhook error: ${err.message}`);
+    }
+}
+export async function sendSlackQuestion(channel, question, choices, clusterContext) {
+    const ctx = clusterContext ? ` — \`${clusterContext}\`` : "";
+    const choiceLines = choices?.map((c, i) => `${i + 1}. ${c}`) ?? [];
+    const body = choiceLines.length
+        ? `${question}\n\n${choiceLines.join("\n")}\n\n_Answer via terminal or reply in your incident channel._`
+        : `${question}\n\n_Answer required via terminal._`;
+    await postToSlack(channel, {
+        blocks: [
+            { type: "header", text: { type: "plain_text", text: "❓ KubeAgent needs input", emoji: true } },
+            { type: "section", text: { type: "mrkdwn", text: `*Question*${ctx}` } },
+            { type: "section", text: { type: "mrkdwn", text: body } },
+        ],
+    });
+}
+export async function sendSlack(issues, channel, clusterContext) {
+    await postToSlack(channel, formatSlackMessage(issues, clusterContext));
+}