kubeagent 0.1.0

package/dist/notify/telegram.d.ts

@@ -0,0 +1,8 @@
+import type { Issue } from "../monitor/types.js";
+import type { TelegramChannel } from "../config.js";
+export declare function sendTelegramQuestion(channel: TelegramChannel, question: string, choices: string[] | undefined, clusterContext?: string): Promise<void>;
+export declare function sendTelegram(issues: Issue[], channel: TelegramChannel, clusterContext?: string): Promise<void>;
+export declare function testTelegramCredentials(botToken: string, chatId: string): Promise<{
+    ok: boolean;
+    error?: string;
+}>;

package/dist/notify/telegram.js

@@ -0,0 +1,63 @@
+const TELEGRAM_API = "https://api.telegram.org";
+function formatTelegramMessage(issues, clusterContext) {
+    const ctx = clusterContext ? ` — \`${clusterContext}\`` : "";
+    const header = `⚠ *KubeAgent Alert*${ctx}`;
+    const lines = issues.map((i) => {
+        const icon = i.severity === "critical" ? "🔴" : "🟡";
+        const ns = i.namespace ? ` \`${i.namespace}\`` : "";
+        return `${icon} ${i.message}${ns}`;
+    });
+    const critical = issues.filter((i) => i.severity === "critical").length;
+    const warning = issues.filter((i) => i.severity === "warning").length;
+    const summary = [
+        critical ? `${critical} critical` : "",
+        warning ? `${warning} warning` : "",
+    ].filter(Boolean).join(", ");
+    return [header, summary, "", ...lines].join("\n");
+}
+async function postToTelegram(channel, text) {
+    const url = `${TELEGRAM_API}/bot${channel.bot_token}/sendMessage`;
+    try {
+        const res = await fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ chat_id: channel.chat_id, text, parse_mode: "Markdown" }),
+        });
+        if (!res.ok) {
+            const body = await res.json().catch(() => ({}));
+            console.error(`Telegram error: ${body.description ?? res.statusText}`);
+        }
+    }
+    catch (err) {
+        console.error(`Telegram error: ${err.message}`);
+    }
+}
+export async function sendTelegramQuestion(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._`
+        : `${question}\n\n_Answer required via terminal._`;
+    await postToTelegram(channel, `❓ *KubeAgent needs input*${ctx}\n\n${body}`);
+}
+export async function sendTelegram(issues, channel, clusterContext) {
+    await postToTelegram(channel, formatTelegramMessage(issues, clusterContext));
+}
+export async function testTelegramCredentials(botToken, chatId) {
+    try {
+        const res = await fetch(`${TELEGRAM_API}/bot${botToken}/sendMessage`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                chat_id: chatId,
+                text: "✅ *KubeAgent* connected successfully\\! You'll receive cluster alerts here\\.",
+                parse_mode: "MarkdownV2",
+            }),
+        });
+        const body = await res.json();
+        return body.ok ? { ok: true } : { ok: false, error: body.description };
+    }
+    catch (err) {
+        return { ok: false, error: err.message };
+    }
+}

package/dist/notify/webhook.d.ts

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

package/dist/notify/webhook.js

@@ -0,0 +1,49 @@
+function formatMessage(issues) {
+    const header = `**KubeAgent Alert** — ${issues.length} issue(s) detected\n`;
+    const body = issues
+        .map((i) => {
+        const icon = i.severity === "critical" ? "\u{1F534}" : "\u{1F7E1}";
+        return `${icon} **${i.kind}**: ${i.message}`;
+    })
+        .join("\n");
+    return header + body;
+}
+export async function sendWebhook(issues, config) {
+    const message = formatMessage(issues);
+    let payload;
+    switch (config.type) {
+        case "discord":
+            payload = { content: message };
+            break;
+        case "slack":
+        case "mattermost":
+        default:
+            payload = { text: message };
+            break;
+    }
+    // Validate URL to prevent SSRF
+    try {
+        const url = new URL(config.url);
+        if (!["https:", "http:"].includes(url.protocol)) {
+            console.error(`Webhook error: unsupported protocol ${url.protocol}`);
+            return;
+        }
+    }
+    catch {
+        console.error(`Webhook error: invalid URL ${config.url}`);
+        return;
+    }
+    try {
+        const response = await fetch(config.url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(payload),
+        });
+        if (!response.ok) {
+            console.error(`Webhook failed: ${response.status} ${response.statusText}`);
+        }
+    }
+    catch (err) {
+        console.error(`Webhook error: ${err.message}`);
+    }
+}

package/dist/onboard/cluster-scan.d.ts

@@ -0,0 +1,42 @@
+import { type KubectlOptions } from "../kubectl.js";
+export interface NodeInfo {
+    name: string;
+    roles: string[];
+    version: string;
+    os: string;
+}
+export interface DeploymentInfo {
+    name: string;
+    namespace: string;
+    replicas: number;
+    image: string;
+}
+export interface StatefulSetInfo {
+    name: string;
+    namespace: string;
+    replicas: number;
+    image: string;
+}
+export interface ServiceInfo {
+    name: string;
+    namespace: string;
+    type: string;
+    ports: string;
+}
+export interface IngressInfo {
+    name: string;
+    namespace: string;
+    hosts: string[];
+    tls: boolean;
+}
+export interface ClusterInfo {
+    context: string;
+    nodes: NodeInfo[];
+    namespaces: string[];
+    deployments: DeploymentInfo[];
+    statefulsets: StatefulSetInfo[];
+    services: ServiceInfo[];
+    ingresses: IngressInfo[];
+}
+export declare function scanCluster(options: KubectlOptions): Promise<ClusterInfo>;
+export declare function formatClusterMarkdown(info: ClusterInfo): string;

package/dist/onboard/cluster-scan.js

@@ -0,0 +1,103 @@
+import { kubectlJson } from "../kubectl.js";
+export async function scanCluster(options) {
+    const context = options.context ?? "default";
+    // Nodes
+    const nodesRaw = (await kubectlJson(["get", "nodes"], options));
+    const nodes = nodesRaw.items.map((n) => ({
+        name: n.metadata.name,
+        roles: Object.keys(n.metadata.labels)
+            .filter((l) => l.startsWith("node-role.kubernetes.io/"))
+            .map((l) => l.replace("node-role.kubernetes.io/", "")),
+        version: n.status.nodeInfo.kubeletVersion,
+        os: n.status.nodeInfo.osImage,
+    }));
+    // Namespaces
+    const nsRaw = (await kubectlJson(["get", "namespaces"], options));
+    const namespaces = nsRaw.items.map((n) => n.metadata.name);
+    // Deployments
+    const deplRaw = (await kubectlJson(["get", "deployments", "--all-namespaces"], options));
+    const deployments = deplRaw.items.map((d) => ({
+        name: d.metadata.name,
+        namespace: d.metadata.namespace,
+        replicas: d.spec.replicas,
+        image: d.spec.template.spec.containers[0]?.image ?? "unknown",
+    }));
+    // StatefulSets
+    const ssRaw = (await kubectlJson(["get", "statefulsets", "--all-namespaces"], options));
+    const statefulsets = ssRaw.items.map((s) => ({
+        name: s.metadata.name,
+        namespace: s.metadata.namespace,
+        replicas: s.spec.replicas,
+        image: s.spec.template.spec.containers[0]?.image ?? "unknown",
+    }));
+    // Services
+    const svcRaw = (await kubectlJson(["get", "services", "--all-namespaces"], options));
+    const services = svcRaw.items.map((s) => ({
+        name: s.metadata.name,
+        namespace: s.metadata.namespace,
+        type: s.spec.type,
+        ports: (s.spec.ports ?? []).map((p) => `${p.port}/${p.protocol}`).join(", "),
+    }));
+    // Ingresses
+    const ingRaw = (await kubectlJson(["get", "ingresses", "--all-namespaces"], options));
+    const ingresses = ingRaw.items.map((i) => ({
+        name: i.metadata.name,
+        namespace: i.metadata.namespace,
+        hosts: (i.spec.rules ?? []).map((r) => r.host),
+        tls: (i.spec.tls?.length ?? 0) > 0,
+    }));
+    return { context, nodes, namespaces, deployments, statefulsets, services, ingresses };
+}
+export function formatClusterMarkdown(info) {
+    const lines = [];
+    lines.push(`# Cluster: ${info.context}`, "");
+    // Nodes
+    lines.push("## Nodes", "");
+    lines.push("| Name | Roles | Version | OS |");
+    lines.push("|------|-------|---------|-----|");
+    for (const n of info.nodes) {
+        lines.push(`| ${n.name} | ${n.roles.join(", ")} | ${n.version} | ${n.os} |`);
+    }
+    lines.push("");
+    // Namespaces
+    lines.push("## Namespaces", "");
+    lines.push(info.namespaces.map((n) => `- \`${n}\``).join("\n"));
+    lines.push("");
+    // Deployments
+    lines.push("## Deployments", "");
+    lines.push("| Name | Namespace | Replicas | Image |");
+    lines.push("|------|-----------|----------|-------|");
+    for (const d of info.deployments) {
+        lines.push(`| ${d.name} | ${d.namespace} | ${d.replicas} | \`${d.image}\` |`);
+    }
+    lines.push("");
+    // StatefulSets
+    if (info.statefulsets.length > 0) {
+        lines.push("## StatefulSets", "");
+        lines.push("| Name | Namespace | Replicas | Image |");
+        lines.push("|------|-----------|----------|-------|");
+        for (const s of info.statefulsets) {
+            lines.push(`| ${s.name} | ${s.namespace} | ${s.replicas} | \`${s.image}\` |`);
+        }
+        lines.push("");
+    }
+    // Services
+    lines.push("## Services", "");
+    lines.push("| Name | Namespace | Type | Ports |");
+    lines.push("|------|-----------|------|-------|");
+    for (const s of info.services) {
+        lines.push(`| ${s.name} | ${s.namespace} | ${s.type} | ${s.ports} |`);
+    }
+    lines.push("");
+    // Ingresses
+    if (info.ingresses.length > 0) {
+        lines.push("## Ingresses", "");
+        lines.push("| Name | Namespace | Hosts | TLS |");
+        lines.push("|------|-----------|-------|-----|");
+        for (const i of info.ingresses) {
+            lines.push(`| ${i.name} | ${i.namespace} | ${i.hosts.join(", ")} | ${i.tls ? "Yes" : "No"} |`);
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}

package/dist/onboard/code-scan.d.ts

@@ -0,0 +1,9 @@
+export interface TechStack {
+    language: string;
+    framework: string;
+    runtimeVersion: string;
+    dependencies: string[];
+    buildTool: string;
+}
+export declare function detectTechStack(codePath: string): TechStack;
+export declare function formatProjectMarkdown(projectName: string, codePath: string, stack: TechStack, extraNotes?: string): string;

package/dist/onboard/code-scan.js

@@ -0,0 +1,114 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+export function detectTechStack(codePath) {
+    const stack = {
+        language: "Unknown",
+        framework: "Unknown",
+        runtimeVersion: "Unknown",
+        dependencies: [],
+        buildTool: "Unknown",
+    };
+    // Check composer.json (PHP)
+    const composerPath = join(codePath, "composer.json");
+    if (existsSync(composerPath)) {
+        try {
+            const composer = JSON.parse(readFileSync(composerPath, "utf-8"));
+            stack.language = "PHP";
+            stack.runtimeVersion = composer.require?.php ?? "Unknown";
+            const deps = { ...composer.require, ...composer["require-dev"] };
+            stack.dependencies = Object.keys(deps).slice(0, 20);
+            if (deps["laravel/framework"])
+                stack.framework = "Laravel";
+            else if (deps["symfony/framework-bundle"])
+                stack.framework = "Symfony";
+            else if (deps["yiisoft/yii"])
+                stack.framework = "Yii";
+            stack.buildTool = "Composer";
+        }
+        catch { /* ignore parse errors */ }
+        return stack;
+    }
+    // Check package.json (Node.js)
+    const packagePath = join(codePath, "package.json");
+    if (existsSync(packagePath)) {
+        try {
+            const pkg = JSON.parse(readFileSync(packagePath, "utf-8"));
+            stack.language = "TypeScript/JavaScript";
+            const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+            stack.dependencies = Object.keys(deps).slice(0, 20);
+            if (deps.next)
+                stack.framework = "Next.js";
+            else if (deps.nuxt)
+                stack.framework = "Nuxt";
+            else if (deps.react)
+                stack.framework = "React";
+            else if (deps.vue)
+                stack.framework = "Vue";
+            else if (deps.express)
+                stack.framework = "Express";
+            if (existsSync(join(codePath, "tsconfig.json"))) {
+                stack.language = "TypeScript";
+            }
+            stack.runtimeVersion = pkg.engines?.node ?? "Unknown";
+            stack.buildTool = deps.vite ? "Vite" : deps.webpack ? "Webpack" : "npm";
+        }
+        catch { /* ignore */ }
+        return stack;
+    }
+    // Check go.mod (Go)
+    const goModPath = join(codePath, "go.mod");
+    if (existsSync(goModPath)) {
+        const goMod = readFileSync(goModPath, "utf-8");
+        stack.language = "Go";
+        stack.buildTool = "go";
+        const goVersionMatch = goMod.match(/^go\s+(\S+)/m);
+        if (goVersionMatch)
+            stack.runtimeVersion = goVersionMatch[1];
+        const moduleMatch = goMod.match(/^module\s+(\S+)/m);
+        if (moduleMatch)
+            stack.dependencies.push(moduleMatch[1]);
+        const requireMatches = goMod.matchAll(/^\s+(\S+)\s+\S+/gm);
+        for (const m of requireMatches) {
+            if (m[1] && !m[1].startsWith("//")) {
+                stack.dependencies.push(m[1]);
+            }
+        }
+        stack.dependencies = stack.dependencies.slice(0, 20);
+        stack.framework = "stdlib";
+        return stack;
+    }
+    return stack;
+}
+export function formatProjectMarkdown(projectName, codePath, stack, extraNotes) {
+    const lines = [];
+    lines.push(`# ${projectName}`, "");
+    lines.push(`**Code path:** \`${codePath}\``);
+    lines.push(`**Language:** ${stack.language}`);
+    lines.push(`**Framework:** ${stack.framework}`);
+    lines.push(`**Runtime version:** ${stack.runtimeVersion}`);
+    lines.push(`**Build tool:** ${stack.buildTool}`);
+    lines.push("");
+    if (stack.dependencies.length > 0) {
+        lines.push("## Key Dependencies", "");
+        for (const dep of stack.dependencies) {
+            lines.push(`- \`${dep}\``);
+        }
+        lines.push("");
+    }
+    // Check for Dockerfile
+    if (existsSync(join(codePath, "Dockerfile"))) {
+        const dockerfile = readFileSync(join(codePath, "Dockerfile"), "utf-8");
+        const fromMatch = dockerfile.match(/^FROM\s+(\S+)/m);
+        if (fromMatch) {
+            lines.push(`## Docker`, "");
+            lines.push(`Base image: \`${fromMatch[1]}\``);
+            lines.push("");
+        }
+    }
+    if (extraNotes) {
+        lines.push("## Notes", "");
+        lines.push(extraNotes);
+        lines.push("");
+    }
+    return lines.join("\n");
+}

package/dist/onboard/index.d.ts

@@ -0,0 +1 @@
+export declare function onboard(): Promise<void>;