kubeagent 0.1.29 → 0.1.30

package/dist/auth.js

@@ -133,7 +133,8 @@ export async function loginBrowser(serverUrl, appUrl) {
             }
             console.log(`\nOpening browser for authentication...`);
             console.log(`If the browser didn't open, visit:\n  ${authUrl}`);
-            console.log(`Or on a headless/remote machine, run:  kubeagent login --device\n`);
+            console.log(`Or on a headless/remote machine, run:  kubeagent login --device`);
+            console.log(`\nTip: if you signed up with email/password, check your inbox and verify your email first, then approve here.\n`);
         });
         // Timeout after 5 minutes
         const timeoutId = setTimeout(() => {

package/dist/cli.js

@@ -37,14 +37,17 @@ program
     .option("-c, --context <context>", "Kubernetes context")
     .action(async (opts) => {
     try {
-        const issues = await runChecks({ context: opts.context });
+        const { issues, podCount, nodeCount, namespaceCount } = await runChecks({ context: opts.context }, true);
+        const clusterName = opts.context ?? "current context";
+        const summary = chalk.dim(`Checked ${podCount} pod${podCount !== 1 ? "s" : ""}, ${nodeCount} node${nodeCount !== 1 ? "s" : ""}, ${namespaceCount} namespace${namespaceCount !== 1 ? "s" : ""} on ${chalk.bold(clusterName)}`);
         if (issues.length === 0) {
-            console.log(chalk.green("All clear. No issues detected."));
+            console.log(summary + " — " + chalk.green("All clear."));
         }
         else {
+            console.log(summary + "\n");
             for (const issue of issues) {
                 const color = issue.severity === "critical" ? chalk.red : chalk.yellow;
-                console.log(color(`[${issue.severity}] ${issue.message}`));
+                console.log(color(`[${issue.severity}] [${clusterName}] ${issue.message}`));
             }
         }
     }

package/dist/monitor/index.d.ts

@@ -2,7 +2,14 @@ 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 interface CheckSummary {
+    issues: Issue[];
+    podCount: number;
+    nodeCount: number;
+    namespaceCount: number;
+}
 export declare function runChecks(options: KubectlOptions): Promise<Issue[]>;
+export declare function runChecks(options: KubectlOptions, withSummary: true): Promise<CheckSummary>;
 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): {

package/dist/monitor/index.js

@@ -33,7 +33,7 @@ function deduplicateIssues(issues) {
         return true;
     });
 }
-export async function runChecks(options) {
+export async function runChecks(options, withSummary) {
     const allIssues = [];
     // Get all pods across namespaces
     const podList = (await kubectlJson(["get", "pods", "--all-namespaces"], options));
@@ -44,7 +44,18 @@ export async function runChecks(options) {
     // 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);
+    const issues = deduplicateIssues(allIssues);
+    if (!withSummary)
+        return issues;
+    // Fetch namespace count (non-fatal)
+    const nsList = await kubectlJson(["get", "namespaces"], options)
+        .catch(() => ({ items: [] }));
+    return {
+        issues,
+        podCount: podList.items.length,
+        nodeCount: nodeList.items.length,
+        namespaceCount: nsList.items.length,
+    };
 }
 // How long a pod must be Pending before it's reported as an issue.
 const PENDING_GRACE_MS = 60_000;

package/dist/update-notifier.js

@@ -1,8 +1,32 @@
 import chalk from "chalk";
 import { createRequire } from "node:module";
+import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
 const require = createRequire(import.meta.url);
 const { version: currentVersion } = require("../package.json");
 const REGISTRY_URL = "https://registry.npmjs.org/kubeagent/latest";
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+function cacheFilePath() {
+    return join(homedir(), ".kubeagent", "update-check.json");
+}
+function readCache() {
+    try {
+        return JSON.parse(readFileSync(cacheFilePath(), "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+function writeCache(cache) {
+    try {
+        mkdirSync(join(homedir(), ".kubeagent"), { recursive: true });
+        writeFileSync(cacheFilePath(), JSON.stringify(cache), "utf-8");
+    }
+    catch {
+        // Non-fatal
+    }
+}
 function isNewer(latest, current) {
     const parse = (v) => v.replace(/^v/, "").split(".").map(Number);
     const [lMaj, lMin, lPatch] = parse(latest);
@@ -15,22 +39,40 @@ function isNewer(latest, current) {
 }
 export async function checkForUpdate() {
     try {
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), 3000);
-        const res = await fetch(REGISTRY_URL, { signal: controller.signal });
-        clearTimeout(timeout);
-        if (!res.ok)
-            return;
-        const data = (await res.json());
-        const latest = data.version;
+        const now = Date.now();
+        const cache = readCache();
+        // Fetch from registry if no cache or cache is stale (> 24h)
+        let latest;
+        if (cache && now - cache.checkedAt < CACHE_TTL_MS) {
+            latest = cache.latestVersion;
+        }
+        else {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 3000);
+            const res = await fetch(REGISTRY_URL, { signal: controller.signal });
+            clearTimeout(timeout);
+            if (!res.ok)
+                return;
+            const data = (await res.json());
+            latest = data.version;
+            if (latest) {
+                writeCache({ checkedAt: now, latestVersion: latest, shownAt: cache?.shownAt });
+            }
+        }
         if (!latest || !isNewer(latest, currentVersion))
             return;
+        // Show notification at most once per 24h regardless of how many commands are run
+        if (cache?.shownAt && now - cache.shownAt < CACHE_TTL_MS)
+            return;
         console.log("\n" +
             chalk.yellow(`  Update available: ${currentVersion} → ${latest}`) +
             "\n" +
             chalk.dim("  Run ") +
             chalk.cyan("npm update -g kubeagent") +
             chalk.dim(" to update\n"));
+        // Record that we showed the notification; always use `now` for checkedAt so
+        // a fresh registry fetch isn't overwritten by the stale cached timestamp.
+        writeCache({ checkedAt: now, latestVersion: latest, shownAt: now });
     }
     catch {
         // Network errors, timeouts — silently ignore

package/package.json

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