kubeagent 0.1.2 → 0.1.4

package/dist/auth.js

@@ -152,9 +152,16 @@ export async function createApiKey(auth, name) {
     return data;
 }
 export async function showAccount(auth) {
-    const res = await fetch(`${auth.serverUrl}/v1/balance`, {
-        headers: { Authorization: `ApiKey ${auth.apiKey ?? auth.token}` },
-    });
+    const url = `${auth.serverUrl}/v1/balance`;
+    let res;
+    try {
+        res = await fetch(url, {
+            headers: { Authorization: `ApiKey ${auth.apiKey ?? auth.token}` },
+        });
+    }
+    catch (err) {
+        throw new Error(`Could not reach server at ${url} — is it running?\n  (${err.message})`);
+    }
     if (!res.ok) {
         throw new Error(`Failed to fetch account info (${res.status})`);
     }

package/dist/cli.js

@@ -108,12 +108,20 @@ program
         if (serverSlack.connected && serverSlack.webhookUrl) {
             const alreadyConfigured = config.notifications.channels.some((ch) => ch.type === "slack" && ch.webhook_url === serverSlack.webhookUrl);
             if (!alreadyConfigured) {
-                config.notifications.channels.unshift({
+                const dashboardChannel = {
                     type: "slack",
                     webhook_url: serverSlack.webhookUrl,
                     label: serverSlack.teamName ?? serverSlack.channelName ?? "KubeAgent",
                     severity: "warning",
-                });
+                };
+                config.notifications.channels.unshift(dashboardChannel);
+                // Persist to local config so it survives restarts and shows in `notify list`
+                const savedConfig = loadConfig();
+                const alreadySaved = savedConfig.notifications.channels.some((ch) => ch.type === "slack" && ch.webhook_url === serverSlack.webhookUrl);
+                if (!alreadySaved) {
+                    savedConfig.notifications.channels.unshift(dashboardChannel);
+                    saveConfig(savedConfig);
+                }
                 console.log(chalk.dim(`  Slack: ${serverSlack.teamName ?? ""}${serverSlack.channelName ? ` ${serverSlack.channelName}` : ""} (from dashboard)\n`));
             }
         }

package/dist/notify/setup.js

@@ -1,7 +1,7 @@
 import readline from "node:readline";
 import chalk from "chalk";
 import { sendSlack } from "./slack.js";
-import { testTelegramCredentials } from "./telegram.js";
+import { testTelegramCredentials, autoDetectTelegramChatId } from "./telegram.js";
 async function ask(question, hint) {
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     const hintStr = hint ? chalk.dim(` (${hint})`) : "";
@@ -43,16 +43,28 @@ export async function setupSlack() {
 }
 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"));
+    console.log(chalk.dim("  1. Create a bot via @BotFather and copy its token"));
+    console.log(chalk.dim("  2. Start a chat with your bot, or add it to a group/channel\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;
+    // Auto-detect chat ID
+    console.log(chalk.dim("\n  Now send any message to your bot (or the group/channel where it was added)."));
+    process.stdout.write(chalk.cyan("  Waiting for a message (30s)..."));
+    const detected = await autoDetectTelegramChatId(bot_token);
+    let chat_id;
+    if (detected) {
+        console.log(chalk.green(` detected: ${detected}`));
+        chat_id = detected;
+    }
+    else {
+        console.log(chalk.yellow(" timed out."));
+        console.log(chalk.dim("  Find it manually: send a message to your bot, then visit:"));
+        console.log(chalk.dim(`  https://api.telegram.org/bot${bot_token}/getUpdates\n`));
+        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

package/dist/notify/telegram.d.ts

@@ -2,6 +2,7 @@ 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 autoDetectTelegramChatId(botToken: string): Promise<string | null>;
 export declare function testTelegramCredentials(botToken: string, chatId: string): Promise<{
     ok: boolean;
     error?: string;

package/dist/notify/telegram.js

@@ -43,6 +43,35 @@ export async function sendTelegramQuestion(channel, question, choices, clusterCo
 export async function sendTelegram(issues, channel, clusterContext) {
     await postToTelegram(channel, formatTelegramMessage(issues, clusterContext));
 }
+export async function autoDetectTelegramChatId(botToken) {
+    const url = `${TELEGRAM_API}/bot${botToken}/getUpdates`;
+    const deadline = Date.now() + 30_000;
+    let offset = 0;
+    // Clear any pending updates first so we only see new messages
+    try {
+        const clearRes = await fetch(`${url}?offset=-1`);
+        const clearData = await clearRes.json();
+        if (clearData.ok && clearData.result.length > 0) {
+            offset = clearData.result[clearData.result.length - 1].update_id + 1;
+        }
+    }
+    catch { /* ignore */ }
+    while (Date.now() < deadline) {
+        try {
+            const res = await fetch(`${url}?offset=${offset}&timeout=5&limit=1`);
+            const data = await res.json();
+            if (data.ok && data.result.length > 0) {
+                const update = data.result[0];
+                offset = update.update_id + 1;
+                const chat = update.message?.chat ?? update.channel_post?.chat ?? update.my_chat_member?.chat;
+                if (chat)
+                    return String(chat.id);
+            }
+        }
+        catch { /* ignore, keep polling */ }
+    }
+    return null;
+}
 export async function testTelegramCredentials(botToken, chatId) {
     try {
         const res = await fetch(`${TELEGRAM_API}/bot${botToken}/sendMessage`, {

package/package.json

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

package/dist/notify/webhook.d.ts

@@ -1,3 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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}`);
-    }
-}