kubeagent 0.1.5 → 0.1.6

package/dist/cli.js

@@ -14,6 +14,7 @@ import { onboard } from "./onboard/index.js";
 import { runChecks } from "./monitor/index.js";
 import { startMonitor } from "./monitor/index.js";
 import { handleIssues } from "./orchestrator.js";
+import { sendResolve } from "./notify/index.js";
 import { diagnose } from "./diagnoser/index.js";
 import { buildSystemPrompt } from "./kb/loader.js";
 import { join } from "node:path";
@@ -131,6 +132,8 @@ program
     }
     const { stop } = startMonitor({ context }, interval, async (issues) => {
         await handleIssues(issues, config, context, noInteractive);
+    }, async (resolvedKeys) => {
+        await sendResolve(resolvedKeys, config, context);
     });
     // Handle graceful shutdown
     process.on("SIGINT", () => {

package/dist/config.d.ts

@@ -25,7 +25,20 @@ export interface TelegramChannel {
     severity: NotificationSeverity;
     label?: string;
 }
-export type NotificationChannel = SlackChannel | TelegramChannel;
+export interface WebhookChannel {
+    type: "webhook";
+    url: string;
+    secret?: string;
+    severity: NotificationSeverity;
+    label?: string;
+}
+export interface PagerDutyChannel {
+    type: "pagerduty";
+    routing_key: string;
+    severity: NotificationSeverity;
+    label?: string;
+}
+export type NotificationChannel = SlackChannel | TelegramChannel | WebhookChannel | PagerDutyChannel;
 export declare const ALL_ACTIONS: readonly ["restart_pod", "rollout_restart", "scale_deployment", "set_resources"];
 export type RemediationAction = (typeof ALL_ACTIONS)[number];
 export interface KubeAgentConfig {

package/dist/monitor/index.d.ts

@@ -1,7 +1,10 @@
 import { type KubectlOptions } from "../kubectl.js";
 import type { Issue } from "./types.js";
 export type IssueCallback = (issues: Issue[]) => void | Promise<void>;
+export type ResolveCallback = (resolvedKeys: string[]) => void | Promise<void>;
 export declare function runChecks(options: KubectlOptions): Promise<Issue[]>;
-export declare function startMonitor(options: KubectlOptions, intervalMs: number, onIssues: IssueCallback): {
+export declare function computeResolvedKeys(activeKeys: Set<string>, currentKeys: Set<string>): string[];
+export declare function updateActiveKeys(activeKeys: Set<string>, resolvedKeys: string[], currentKeys: Set<string>): void;
+export declare function startMonitor(options: KubectlOptions, intervalMs: number, onIssues: IssueCallback, onResolved?: ResolveCallback): {
     stop: () => void;
 };

package/dist/monitor/index.js

@@ -48,11 +48,21 @@ export async function runChecks(options) {
 }
 // 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) {
+export function computeResolvedKeys(activeKeys, currentKeys) {
+    return [...activeKeys].filter((k) => !currentKeys.has(k));
+}
+export function updateActiveKeys(activeKeys, resolvedKeys, currentKeys) {
+    for (const k of resolvedKeys)
+        activeKeys.delete(k);
+    for (const k of currentKeys)
+        activeKeys.add(k);
+}
+export function startMonitor(options, intervalMs, onIssues, onResolved) {
     let running = true;
     let inFlight = false;
     // Tracks when each pending pod was first seen: "namespace/name" -> Date
     const pendingSince = new Map();
+    const activeIssueKeys = new Set();
     let pendingRecheckTimer = null;
     const tick = async () => {
         if (!running || inFlight)
@@ -93,6 +103,18 @@ export function startMonitor(options, intervalMs, onIssues) {
                 }, PENDING_GRACE_MS);
             }
             const reportableIssues = [...otherIssues, ...reportablePending];
+            // Resolve tracking
+            const currentKeys = new Set(reportableIssues.map((i) => `${i.kind}:${i.namespace}:${i.resource}`));
+            const resolvedKeys = computeResolvedKeys(activeIssueKeys, currentKeys);
+            updateActiveKeys(activeIssueKeys, resolvedKeys, currentKeys);
+            if (resolvedKeys.length > 0 && onResolved && running) {
+                try {
+                    await onResolved(resolvedKeys);
+                }
+                catch (err) {
+                    console.error("Resolve callback failed:", err.message);
+                }
+            }
             if (reportableIssues.length > 0 && running) {
                 process.stdout.write("\r\x1b[K");
                 await onIssues(reportableIssues);

package/dist/monitor/resolve.test.d.ts

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

package/dist/monitor/resolve.test.js

@@ -0,0 +1,21 @@
+import { describe, it, expect } from "vitest";
+import { computeResolvedKeys, updateActiveKeys } from "./index.js";
+describe("resolve tracking", () => {
+    it("returns keys that disappeared since last tick", () => {
+        const active = new Set(["pod_crashloop:prod:web", "pod_oom:prod:worker"]);
+        const current = new Set(["pod_oom:prod:worker"]);
+        expect(computeResolvedKeys(active, current)).toEqual(["pod_crashloop:prod:web"]);
+    });
+    it("returns empty array when nothing cleared", () => {
+        const active = new Set(["pod_crashloop:prod:web"]);
+        const current = new Set(["pod_crashloop:prod:web"]);
+        expect(computeResolvedKeys(active, current)).toEqual([]);
+    });
+    it("updates active set correctly after resolve", () => {
+        const active = new Set(["pod_crashloop:prod:web", "pod_oom:prod:worker"]);
+        const current = new Set(["pod_oom:prod:worker", "node_not_ready::node1"]);
+        const resolved = computeResolvedKeys(active, current);
+        updateActiveKeys(active, resolved, current);
+        expect([...active].sort()).toEqual(["node_not_ready::node1", "pod_oom:prod:worker"]);
+    });
+});

package/dist/notify/index.d.ts

@@ -2,4 +2,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 sendResolve(resolvedKeys: string[], config: KubeAgentConfig, clusterContext?: string): Promise<void>;
 export declare function describeChannel(channel: NotificationChannel): string;

package/dist/notify/index.js

@@ -1,5 +1,7 @@
 import { sendSlack, sendSlackQuestion } from "./slack.js";
 import { sendTelegram, sendTelegramQuestion } from "./telegram.js";
+import { sendWebhook } from "./webhook.js";
+import { sendPagerDuty, resolvePagerDuty } from "./pagerduty.js";
 const SEVERITY_ORDER = { info: 0, warning: 1, critical: 2 };
 export async function sendNotification(issues, config, clusterContext) {
     if (!config.notifications.channels.length)
@@ -16,6 +18,12 @@ export async function sendNotification(issues, config, clusterContext) {
             case "telegram":
                 await sendTelegram(filtered, channel, clusterContext);
                 break;
+            case "webhook":
+                await sendWebhook(filtered, channel, clusterContext);
+                break;
+            case "pagerduty":
+                await sendPagerDuty(filtered, channel, clusterContext);
+                break;
         }
     }));
 }
@@ -26,6 +34,19 @@ export async function broadcastQuestion(question, choices, config, clusterContex
         switch (channel.type) {
             case "slack": return sendSlackQuestion(channel, question, choices, clusterContext);
             case "telegram": return sendTelegramQuestion(channel, question, choices, clusterContext);
+            case "webhook":
+            case "pagerduty":
+                return;
+        }
+    }));
+}
+export async function sendResolve(resolvedKeys, config, clusterContext) {
+    if (!config.notifications.channels.length)
+        return;
+    const pdKeys = resolvedKeys.map((k) => `kubeagent:${k}`);
+    await Promise.all(config.notifications.channels.map(async (channel) => {
+        if (channel.type === "pagerduty") {
+            await resolvePagerDuty(pdKeys, channel);
         }
     }));
 }
@@ -36,5 +57,9 @@ export function describeChannel(channel) {
             return `Slack${label}  ${channel.webhook_url.slice(0, 40)}…  min: ${channel.severity}`;
         case "telegram":
             return `Telegram${label}  chat: ${channel.chat_id}  min: ${channel.severity}`;
+        case "webhook":
+            return `Webhook${label}  ${channel.url.slice(0, 40)}…  min: ${channel.severity}`;
+        case "pagerduty":
+            return `PagerDuty${label}  key: ${channel.routing_key.slice(0, 8)}…  min: ${channel.severity}`;
     }
 }

package/dist/notify/pagerduty.d.ts

@@ -0,0 +1,9 @@
+import type { Issue } from "../monitor/types.js";
+import type { PagerDutyChannel } from "../config.js";
+export declare function dedupKey(issue: Issue): string;
+export declare function sendPagerDuty(issues: Issue[], channel: PagerDutyChannel, clusterContext?: string): Promise<void>;
+export declare function resolvePagerDuty(dedupKeys: string[], channel: PagerDutyChannel): Promise<void>;
+export declare function testPagerDutyCredentials(routingKey: string): Promise<{
+    ok: boolean;
+    error?: string;
+}>;

package/dist/notify/pagerduty.js

@@ -0,0 +1,75 @@
+const PD_ENDPOINT = "https://events.pagerduty.com/v2/enqueue";
+export function dedupKey(issue) {
+    return `kubeagent:${issue.kind}:${issue.namespace}:${issue.resource}`;
+}
+async function postToPagerDuty(body) {
+    try {
+        const res = await fetch(PD_ENDPOINT, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(10_000),
+        });
+        if (!res.ok)
+            console.error(`PagerDuty: ${res.status} ${res.statusText}`);
+    }
+    catch (err) {
+        console.error(`PagerDuty error: ${err.message}`);
+    }
+}
+export async function sendPagerDuty(issues, channel, clusterContext) {
+    await Promise.all(issues.map((issue) => postToPagerDuty({
+        routing_key: channel.routing_key,
+        event_action: "trigger",
+        dedup_key: dedupKey(issue),
+        payload: {
+            summary: issue.message,
+            source: clusterContext ?? "kubeagent",
+            severity: issue.severity,
+            timestamp: issue.timestamp.toISOString(),
+            custom_details: {
+                namespace: issue.namespace,
+                resource: issue.resource,
+                kind: issue.kind,
+            },
+        },
+    })));
+}
+export async function resolvePagerDuty(dedupKeys, channel) {
+    await Promise.all(dedupKeys.map((key) => postToPagerDuty({
+        routing_key: channel.routing_key,
+        event_action: "resolve",
+        dedup_key: key,
+    })));
+}
+export async function testPagerDutyCredentials(routingKey) {
+    const testKey = "kubeagent-test";
+    try {
+        const res = await fetch(PD_ENDPOINT, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                routing_key: routingKey,
+                event_action: "trigger",
+                dedup_key: testKey,
+                payload: { summary: "KubeAgent PagerDuty integration test", source: "kubeagent", severity: "info" },
+            }),
+            signal: AbortSignal.timeout(10_000),
+        });
+        if (!res.ok) {
+            const body = await res.json().catch(() => ({}));
+            return { ok: false, error: body.message ?? `HTTP ${res.status}` };
+        }
+        // Fire-and-forget cleanup — don't let resolve failure affect the result
+        fetch(PD_ENDPOINT, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ routing_key: routingKey, event_action: "resolve", dedup_key: testKey }),
+            signal: AbortSignal.timeout(10_000),
+        }).catch(() => { });
+        return { ok: true };
+    }
+    catch (err) {
+        return { ok: false, error: err.message };
+    }
+}

package/dist/notify/pagerduty.test.d.ts

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

package/dist/notify/pagerduty.test.js

@@ -0,0 +1,97 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+const mockFetch = vi.fn();
+vi.stubGlobal("fetch", mockFetch);
+const channel = { type: "pagerduty", routing_key: "R0123456789abcdef", severity: "warning" };
+const issue = { kind: "pod_crashloop", severity: "critical", namespace: "prod", resource: "api-web", message: "Pod crash-looping (3 times)", details: {}, timestamp: new Date("2026-01-01T00:00:00Z") };
+describe("sendPagerDuty", () => {
+    beforeEach(() => {
+        mockFetch.mockReset();
+        mockFetch.mockResolvedValue({ ok: true, status: 202, json: async () => ({ status: "success" }) });
+    });
+    it("POSTs to PagerDuty Events API v2", async () => {
+        const { sendPagerDuty } = await import("./pagerduty.js");
+        await sendPagerDuty([issue], channel, "hetzner-prod");
+        expect(mockFetch.mock.calls[0][0]).toBe("https://events.pagerduty.com/v2/enqueue");
+    });
+    it("sends trigger with correct dedup_key", async () => {
+        const { sendPagerDuty } = await import("./pagerduty.js");
+        await sendPagerDuty([issue], channel);
+        const body = JSON.parse(mockFetch.mock.calls[0][1].body);
+        expect(body.event_action).toBe("trigger");
+        expect(body.dedup_key).toBe("kubeagent:pod_crashloop:prod:api-web");
+        expect(body.routing_key).toBe("R0123456789abcdef");
+    });
+    it("maps critical severity correctly", async () => {
+        const { sendPagerDuty } = await import("./pagerduty.js");
+        await sendPagerDuty([{ ...issue, severity: "critical" }], channel);
+        const body = JSON.parse(mockFetch.mock.calls[0][1].body);
+        expect(body.payload.severity).toBe("critical");
+    });
+    it("maps warning severity correctly", async () => {
+        const { sendPagerDuty } = await import("./pagerduty.js");
+        await sendPagerDuty([{ ...issue, severity: "warning" }], channel);
+        const body = JSON.parse(mockFetch.mock.calls[0][1].body);
+        expect(body.payload.severity).toBe("warning");
+    });
+    it("maps info severity correctly", async () => {
+        const { sendPagerDuty } = await import("./pagerduty.js");
+        await sendPagerDuty([{ ...issue, severity: "info" }], channel);
+        const body = JSON.parse(mockFetch.mock.calls[0][1].body);
+        expect(body.payload.severity).toBe("info");
+    });
+    it("fires one request per issue", async () => {
+        const { sendPagerDuty } = await import("./pagerduty.js");
+        await sendPagerDuty([issue, { ...issue, kind: "pod_oom", resource: "worker" }], channel);
+        expect(mockFetch).toHaveBeenCalledTimes(2);
+    });
+    it("does not throw on non-2xx", async () => {
+        mockFetch.mockResolvedValue({ ok: false, status: 400, statusText: "Bad Request", json: async () => ({}) });
+        const { sendPagerDuty } = await import("./pagerduty.js");
+        await expect(sendPagerDuty([issue], channel)).resolves.not.toThrow();
+    });
+});
+describe("resolvePagerDuty", () => {
+    beforeEach(() => {
+        mockFetch.mockReset();
+        mockFetch.mockResolvedValue({ ok: true, status: 202, json: async () => ({}) });
+    });
+    it("sends resolve events for each dedup key", async () => {
+        const { resolvePagerDuty } = await import("./pagerduty.js");
+        await resolvePagerDuty(["kubeagent:pod_crashloop:prod:api-web", "kubeagent:pod_oom:prod:worker"], channel);
+        expect(mockFetch).toHaveBeenCalledTimes(2);
+        const body0 = JSON.parse(mockFetch.mock.calls[0][1].body);
+        expect(body0.event_action).toBe("resolve");
+        expect(body0.dedup_key).toBe("kubeagent:pod_crashloop:prod:api-web");
+    });
+    it("does not throw on error", async () => {
+        mockFetch.mockRejectedValue(new Error("network failure"));
+        const { resolvePagerDuty } = await import("./pagerduty.js");
+        await expect(resolvePagerDuty(["kubeagent:pod_crashloop:prod:api-web"], channel)).resolves.not.toThrow();
+    });
+});
+describe("testPagerDutyCredentials", () => {
+    beforeEach(() => {
+        mockFetch.mockReset();
+        mockFetch.mockResolvedValue({ ok: true, status: 202, json: async () => ({}) });
+    });
+    it("returns ok:true when trigger succeeds", async () => {
+        const { testPagerDutyCredentials } = await import("./pagerduty.js");
+        const result = await testPagerDutyCredentials("R0123456789abcdef");
+        expect(result.ok).toBe(true);
+        expect(result.error).toBeUndefined();
+    });
+    it("returns ok:false with error when trigger fails", async () => {
+        mockFetch.mockResolvedValue({ ok: false, status: 400, statusText: "Bad Request", json: async () => ({ message: "Invalid routing key" }) });
+        const { testPagerDutyCredentials } = await import("./pagerduty.js");
+        const result = await testPagerDutyCredentials("bad-key");
+        expect(result.ok).toBe(false);
+        expect(result.error).toBe("Invalid routing key");
+    });
+    it("returns ok:false on network error", async () => {
+        mockFetch.mockRejectedValue(new Error("ECONNREFUSED"));
+        const { testPagerDutyCredentials } = await import("./pagerduty.js");
+        const result = await testPagerDutyCredentials("R0123456789abcdef");
+        expect(result.ok).toBe(false);
+        expect(result.error).toBe("ECONNREFUSED");
+    });
+});

package/dist/notify/setup.d.ts

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

package/dist/notify/setup.js

@@ -2,6 +2,11 @@ import readline from "node:readline";
 import chalk from "chalk";
 import { sendSlack } from "./slack.js";
 import { testTelegramCredentials, autoDetectTelegramChatId } from "./telegram.js";
+import { testPagerDutyCredentials } from "./pagerduty.js";
+import { sendWebhook } from "./webhook.js";
+import { loadAuth } from "../auth.js";
+import { registerWebhook } from "../proxy-client.js";
+import { randomBytes } from "node:crypto";
 async function ask(question, hint) {
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     const hintStr = hint ? chalk.dim(` (${hint})`) : "";
@@ -83,18 +88,86 @@ export async function setupTelegram() {
     }
     return { type: "telegram", bot_token, chat_id, severity, label: label || undefined };
 }
+export async function setupWebhook() {
+    console.log(chalk.bold("\n  Webhook Setup"));
+    console.log(chalk.dim("  POST JSON alerts to any HTTP endpoint.\n"));
+    const url = await ask("Webhook URL", "https://...");
+    if (!url)
+        return null;
+    const label = await ask("Label (optional)", "e.g. n8n-alerts");
+    const severity = await pickSeverity();
+    // Generate secret server-side if logged in, otherwise locally
+    let secret;
+    const auth = loadAuth();
+    if (auth?.apiKey) {
+        process.stdout.write(chalk.dim("\n  Generating secret via KubeAgent server..."));
+        const result = await registerWebhook(auth, url, label || undefined, severity);
+        if (result.secret) {
+            secret = result.secret;
+            console.log(chalk.green(" done!"));
+        }
+        else {
+            secret = randomBytes(32).toString("hex");
+            console.log(chalk.yellow(" failed, generated locally."));
+        }
+    }
+    else {
+        secret = randomBytes(32).toString("hex");
+    }
+    console.log(chalk.bold.yellow("\n  ⚠ Copy this Bearer token — it won't be shown again:"));
+    console.log(chalk.green(`  ${secret}\n`));
+    console.log(chalk.dim("  Configure your endpoint to verify: Authorization: Bearer <token>\n"));
+    const channel = { type: "webhook", url, secret, severity, label: label || undefined };
+    process.stdout.write(chalk.dim("  Sending test payload..."));
+    await sendWebhook([{ kind: "pod_pending", severity: "warning", namespace: "test", resource: "kubeagent-test", message: "KubeAgent webhook 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("  Not confirmed — channel not saved."));
+        return null;
+    }
+    return channel;
+}
+export async function setupPagerDuty() {
+    console.log(chalk.bold("\n  PagerDuty Setup"));
+    console.log(chalk.dim("  Get your routing key: PagerDuty → Services → Integrations → Events API v2\n"));
+    const routing_key = await ask("Routing key");
+    if (!routing_key)
+        return null;
+    const label = await ask("Label (optional)", "e.g. prod-cluster");
+    const severity = await pickSeverity();
+    process.stdout.write(chalk.dim("\n  Sending test event to PagerDuty..."));
+    const result = await testPagerDutyCredentials(routing_key);
+    if (!result.ok) {
+        console.log(chalk.red(` failed: ${result.error}`));
+        return null;
+    }
+    console.log(chalk.green(` accepted (test event triggered and resolved)`));
+    const confirmed = await ask("Did you receive it in PagerDuty? [y/N]");
+    if (confirmed.toLowerCase() !== "y") {
+        console.log(chalk.yellow("  Not confirmed — channel not saved."));
+        return null;
+    }
+    return { type: "pagerduty", routing_key, 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`);
+    console.log(`  ${chalk.cyan("3")}. Webhook`);
+    console.log(`  ${chalk.cyan("4")}. PagerDuty`);
+    console.log(`  ${chalk.cyan("5")}. 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 === "")
+    if (choice === "5" || choice === "")
         return null;
     if (choice === "2")
         return setupTelegram();
+    if (choice === "3")
+        return setupWebhook();
+    if (choice === "4")
+        return setupPagerDuty();
     return setupSlack();
 }

package/dist/notify/webhook.d.ts

@@ -0,0 +1,3 @@
+import type { Issue } from "../monitor/types.js";
+import type { WebhookChannel } from "../config.js";
+export declare function sendWebhook(issues: Issue[], channel: WebhookChannel, clusterContext?: string): Promise<void>;

package/dist/notify/webhook.js

@@ -0,0 +1,42 @@
+export async function sendWebhook(issues, channel, clusterContext) {
+    try {
+        const url = new URL(channel.url);
+        if (!["https:", "http:"].includes(url.protocol)) {
+            console.error("Webhook: invalid URL protocol");
+            return;
+        }
+    }
+    catch {
+        console.error("Webhook: invalid URL");
+        return;
+    }
+    const payload = {
+        cluster: clusterContext ?? null,
+        timestamp: new Date().toISOString(),
+        issues: issues.map((i) => ({
+            kind: i.kind,
+            severity: i.severity,
+            namespace: i.namespace,
+            resource: i.resource,
+            message: i.message,
+            details: i.details,
+            timestamp: i.timestamp.toISOString(),
+        })),
+    };
+    const headers = { "Content-Type": "application/json" };
+    if (channel.secret)
+        headers["Authorization"] = `Bearer ${channel.secret}`;
+    try {
+        const res = await fetch(channel.url, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(payload),
+            signal: AbortSignal.timeout(10_000),
+        });
+        if (!res.ok)
+            console.error(`Webhook: ${res.status} ${res.statusText}`);
+    }
+    catch (err) {
+        console.error(`Webhook error: ${err.message}`);
+    }
+}

package/dist/notify/webhook.test.d.ts

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

package/dist/notify/webhook.test.js

@@ -0,0 +1,53 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+const mockFetch = vi.fn();
+vi.stubGlobal("fetch", mockFetch);
+const channel = { type: "webhook", url: "https://example.com/hook", secret: "testsecret", severity: "warning" };
+const issue = { kind: "pod_crashloop", severity: "critical", namespace: "prod", resource: "api-web", message: "Pod crash-looping", details: { restartCount: 3 }, timestamp: new Date("2026-01-01T00:00:00Z") };
+describe("sendWebhook", () => {
+    beforeEach(() => {
+        mockFetch.mockReset();
+        mockFetch.mockResolvedValue({ ok: true, status: 200, statusText: "OK" });
+    });
+    it("POSTs to the configured URL", async () => {
+        const { sendWebhook } = await import("./webhook.js");
+        await sendWebhook([issue], channel, "hetzner-prod");
+        expect(mockFetch).toHaveBeenCalledOnce();
+        expect(mockFetch.mock.calls[0][0]).toBe("https://example.com/hook");
+        expect(mockFetch.mock.calls[0][1].method).toBe("POST");
+    });
+    it("sends Authorization: Bearer header when secret is set", async () => {
+        const { sendWebhook } = await import("./webhook.js");
+        await sendWebhook([issue], channel, "hetzner-prod");
+        expect(mockFetch.mock.calls[0][1].headers["Authorization"]).toBe("Bearer testsecret");
+    });
+    it("omits Authorization header when no secret", async () => {
+        const noSecretChannel = { ...channel, secret: undefined };
+        const { sendWebhook } = await import("./webhook.js");
+        await sendWebhook([issue], noSecretChannel);
+        expect(mockFetch.mock.calls[0][1].headers["Authorization"]).toBeUndefined();
+    });
+    it("includes cluster, timestamp, and issues in payload", async () => {
+        const { sendWebhook } = await import("./webhook.js");
+        await sendWebhook([issue], channel, "hetzner-prod");
+        const body = JSON.parse(mockFetch.mock.calls[0][1].body);
+        expect(body.cluster).toBe("hetzner-prod");
+        expect(body.issues).toHaveLength(1);
+        expect(body.issues[0].kind).toBe("pod_crashloop");
+    });
+    it("does not throw on non-2xx response", async () => {
+        mockFetch.mockResolvedValue({ ok: false, status: 500, statusText: "Error" });
+        const { sendWebhook } = await import("./webhook.js");
+        await expect(sendWebhook([issue], channel)).resolves.not.toThrow();
+    });
+    it("does not throw on network error", async () => {
+        mockFetch.mockRejectedValue(new Error("network failure"));
+        const { sendWebhook } = await import("./webhook.js");
+        await expect(sendWebhook([issue], channel)).resolves.not.toThrow();
+    });
+    it("rejects invalid URL without throwing", async () => {
+        const badChannel = { ...channel, url: "not-a-url" };
+        const { sendWebhook } = await import("./webhook.js");
+        await expect(sendWebhook([issue], badChannel)).resolves.not.toThrow();
+        expect(mockFetch).not.toHaveBeenCalled();
+    });
+});

package/dist/proxy-client.d.ts

@@ -13,3 +13,6 @@ export declare function reportIncident(auth: AuthState, incident: {
     actionTaken?: string;
     verified?: boolean;
 }): Promise<void>;
+export declare function registerWebhook(auth: AuthState, url: string, label: string | undefined, severity: string): Promise<{
+    secret?: string;
+}>;

package/dist/proxy-client.js

@@ -70,3 +70,22 @@ export async function reportIncident(auth, incident) {
         body: JSON.stringify(incident),
     });
 }
+export async function registerWebhook(auth, url, label, severity) {
+    const apiKey = auth.apiKey ?? auth.token;
+    try {
+        const res = await fetch(`${auth.serverUrl}/integrations/webhook`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `ApiKey ${apiKey}`,
+            },
+            body: JSON.stringify({ url, label, severity }),
+        });
+        if (!res.ok)
+            return {};
+        return (await res.json());
+    }
+    catch {
+        return {};
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kubeagent",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "AI-powered Kubernetes management CLI",
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",