openk8s 1.0.4 → 1.1.0

package/src/lib/k8s/detail-builders/pod-builder.ts

@@ -3,35 +3,60 @@ import {
   buildEnvLine, formatContainerState, formatEnvFromSource,
   formatProbe, formatValueFrom, formatVolumeSource,
 } from "../resource-parser";
+import { formatAge } from "../k8s-format";
 import type { ResourceDetailSection } from "../types";
 import type { KubernetesResource } from "../resource-parser";
 
+interface ContainerInfo {
+  record: Record<string, unknown>;
+  isInit: boolean;
+  statusEntry: Record<string, unknown> | undefined;
+}
+
+function collectContainers(spec: Record<string, unknown>, status: Record<string, unknown>): ContainerInfo[] {
+  const statusMap = new Map<string, Record<string, unknown>>();
+  for (const key of ["containerStatuses", "initContainerStatuses"] as const) {
+    for (const entry of asArray(status[key]).map(asRecord)) {
+      if (entry && asString(entry.name)) {
+        statusMap.set(asString(entry.name) ?? "", entry);
+      }
+    }
+  }
+
+  const collect = (field: string, isInit: boolean): ContainerInfo[] =>
+    asArray(spec[field])
+      .map(asRecord)
+      .filter((entry): entry is Record<string, unknown> => entry !== undefined)
+      .map((record) => {
+        const name = asString(record.name) ?? "";
+        return { record, isInit, statusEntry: statusMap.get(name) };
+      });
+
+  return [...collect("initContainers", true), ...collect("containers", false)];
+}
+
+function containerLabel(info: ContainerInfo): string {
+  const name = asString(info.record.name) ?? "container";
+  return info.isInit ? `${name} (init)` : name;
+}
+
 export function buildPodSections(resource: KubernetesResource): ResourceDetailSection[] {
   const spec = resource.spec ?? {};
   const status = resource.status ?? {};
+  const containers = collectContainers(spec, status);
 
-  const containerStatuses = new Map(
-    asArray(status.containerStatuses)
-      .map((entry) => asRecord(entry))
-      .filter((entry): entry is Record<string, unknown> => Boolean(entry && asString(entry.name)))
-      .map((entry) => [asString(entry.name) ?? "", entry]),
-  );
-
-  const containers = asArray(spec.containers)
-    .map((entry) => asRecord(entry))
-    .filter((entry): entry is Record<string, unknown> => entry !== undefined);
-
-  const containerLines = containers.map((container) => {
-    const name = asString(container.name) ?? "container";
-    const statusEntry = containerStatuses.get(name);
+  const containerLines = containers.map((info) => {
+    const name = containerLabel(info);
+    const statusEntry = info.statusEntry;
     const ready = asBoolean(statusEntry?.ready);
     const restartCount = asNumber(statusEntry?.restartCount);
 
-    return `${name}  image ${asString(container.image) ?? "-"}  ready ${ready === undefined ? "-" : ready ? "yes" : "no"}  restarts ${restartCount ?? 0}  state ${formatContainerState(statusEntry?.state)}`;
+    return `${name}  image ${asString(info.record.image) ?? "-"}  ready ${ready === undefined ? "-" : ready ? "yes" : "no"}  restarts ${restartCount ?? 0}  state ${formatContainerState(statusEntry?.state)}`;
   });
 
-  const environmentLines = containers.flatMap((container) => {
-    const containerName = asString(container.name) ?? "container";
+  const environmentLines = containers.flatMap((info) => {
+    const containerName = containerLabel(info);
+    const container = info.record;
     const envLines = asArray(container.env)
       .map((entry) => asRecord(entry))
       .filter((entry): entry is Record<string, unknown> => entry !== undefined)
@@ -78,8 +103,9 @@ export function buildPodSections(resource: KubernetesResource): ResourceDetailSe
     return [...envLines, ...envFromLines];
   });
 
-  const portLines = containers.flatMap((container) => {
-    const containerName = asString(container.name) ?? "container";
+  const portLines = containers.flatMap((info) => {
+    const containerName = containerLabel(info);
+    const container = info.record;
 
     return asArray(container.ports)
       .map((entry) => asRecord(entry))
@@ -92,8 +118,9 @@ export function buildPodSections(resource: KubernetesResource): ResourceDetailSe
       });
   });
 
-  const mountLines = containers.flatMap((container) => {
-    const containerName = asString(container.name) ?? "container";
+  const mountLines = containers.flatMap((info) => {
+    const containerName = containerLabel(info);
+    const container = info.record;
 
     return asArray(container.volumeMounts)
       .map((entry) => asRecord(entry))
@@ -105,8 +132,9 @@ export function buildPodSections(resource: KubernetesResource): ResourceDetailSe
       });
   });
 
-  const probeLines = containers.map((container) => {
-    const containerName = asString(container.name) ?? "container";
+  const probeLines = containers.map((info) => {
+    const containerName = containerLabel(info);
+    const container = info.record;
     return `${containerName}: readiness ${formatProbe(container.readinessProbe)} | liveness ${formatProbe(container.livenessProbe)} | startup ${formatProbe(container.startupProbe)}`;
   });
 
@@ -116,7 +144,7 @@ export function buildPodSections(resource: KubernetesResource): ResourceDetailSe
     .map((entry) => {
       const type = asString(entry.type) ?? "Condition";
       const conditionStatus = asString(entry.status) ?? "Unknown";
-      const transition = asString(entry.lastTransitionTime) ?? "unknown";
+      const transition = formatAge(asString(entry.lastTransitionTime));
       return `${type}: ${conditionStatus}  transitioned ${transition}`;
     });
 

package/src/lib/k8s/detail-builders/rbac-builder.ts

@@ -1,36 +1,34 @@
-import { asArray, asRecord, asString } from "../resource-parser";
+import { asArray, asRecord, asString, recordsOf } from "../resource-parser";
 import type { ResourceDetailSection } from "../types";
 import type { KubernetesResource } from "../resource-parser";
 
+function asStringOrDash(value: unknown): string {
+  return asString(value) ?? "-";
+}
+
 export function buildRoleSections(resource: KubernetesResource): ResourceDetailSection[] {
-  const raw = resource as unknown as Record<string, unknown>;
-  const rules = asArray(raw.rules)
-    .map((r) => asRecord(r))
-    .filter((r): r is Record<string, unknown> => r !== undefined)
-    .map((r) => {
-      const verbs = asArray(r.verbs).map((v) => String(v)).join(",");
-      const resources = asArray(r.resources).map((res) => String(res)).join(",");
-      const apiGroups = asArray(r.apiGroups).map((g) => String(g) || '""').join(",");
-      return `[${apiGroups}] ${resources}: ${verbs}`;
-    });
+  const raw = asRecord(resource) ?? {};
+  const rules = recordsOf(raw.rules).map((r) => {
+    const verbs = asArray(r.verbs).map(asStringOrDash).join(",");
+    const resources = asArray(r.resources).map(asStringOrDash).join(",");
+    const apiGroups = asArray(r.apiGroups).map((g) => asString(g) ?? '""').join(",");
+    return `[${apiGroups}] ${resources}: ${verbs}`;
+  });
 
   return [{ title: "Rules", lines: rules.length > 0 ? rules : ["No rules"] }];
 }
 
 export function buildRoleBindingSections(resource: KubernetesResource): ResourceDetailSection[] {
-  const raw = resource as unknown as Record<string, unknown>;
+  const raw = asRecord(resource) ?? {};
   const roleRef = asRecord(raw.roleRef);
   const refLines = roleRef
     ? [`${asString(roleRef.kind) ?? "-"} / ${asString(roleRef.name) ?? "-"}`]
     : ["No roleRef"];
 
-  const subjects = asArray(raw.subjects)
-    .map((s) => asRecord(s))
-    .filter((s): s is Record<string, unknown> => s !== undefined)
-    .map((s) => {
-      const ns = asString(s.namespace);
-      return `${asString(s.kind) ?? "-"}  ${ns ? `${ns}/` : ""}${asString(s.name) ?? "-"}`;
-    });
+  const subjects = recordsOf(raw.subjects).map((s) => {
+    const ns = asString(s.namespace);
+    return `${asString(s.kind) ?? "-"}  ${ns ? `${ns}/` : ""}${asString(s.name) ?? "-"}`;
+  });
 
   return [
     { title: "RoleRef", lines: refLines },
@@ -39,16 +37,9 @@ export function buildRoleBindingSections(resource: KubernetesResource): Resource
 }
 
 export function buildServiceAccountSections(resource: KubernetesResource): ResourceDetailSection[] {
-  const raw = resource as unknown as Record<string, unknown>;
-  const secrets = asArray(raw.secrets)
-    .map((s) => asRecord(s))
-    .filter((s): s is Record<string, unknown> => s !== undefined)
-    .map((s) => asString(s.name) ?? "-");
-
-  const imagePullSecrets = asArray(raw.imagePullSecrets)
-    .map((s) => asRecord(s))
-    .filter((s): s is Record<string, unknown> => s !== undefined)
-    .map((s) => asString(s.name) ?? "-");
+  const raw = asRecord(resource) ?? {};
+  const secrets = recordsOf(raw.secrets).map((s) => asString(s.name) ?? "-");
+  const imagePullSecrets = recordsOf(raw.imagePullSecrets).map((s) => asString(s.name) ?? "-");
 
   return [
     { title: "Secrets", lines: secrets.length > 0 ? secrets : ["None"] },

package/src/lib/k8s/k8s-format.ts

@@ -3,17 +3,22 @@ export function formatAge(value?: string | undefined): string {
     return "-";
   }
 
-  // Normalize helm-style timestamps: "2024-05-12 10:30:00.123456789 +0000 UTC"
-  // into ISO 8601: "2024-05-12T10:30:00.123+00:00"
-  // Standard ISO strings (from kubectl) pass through unchanged.
-  const normalized = value
-    .replace(/ [A-Z]+$/, "")           // strip trailing timezone name: " UTC", " EST"
-    .replace(/(\.\d{3})\d*/, "$1")     // truncate sub-millisecond digits
-    .replace(" ", "T")                 // first space → T (date/time separator)
-    .replace(" ", "")                  // second space (before offset) → removed
+  // Standard ISO strings (from kubectl) pass through unchanged (sub-ms digits are truncated).
+  // Helm-style timestamps ("2024-05-12 10:30:00.123456789 +0000 UTC") are normalized to ISO 8601.
+  const isHelmFormat = value.includes(" ");
+  const strippedTz = value.replace(/ [A-Z]+$/, ""); // strip trailing timezone name: " UTC", " EST"
+  const hasNumericOffset = /[+-]\d{4}$/.test(strippedTz);
+  const normalized = strippedTz
+    .replace(/(\.\d{3})\d*/, "$1") // truncate sub-millisecond digits
+    .replace(" ", "T") // first space → T (date/time separator)
+    .replace(" ", "") // second space (before offset, if any) → removed
     .replace(/([+-]\d{2})(\d{2})$/, "$1:$2"); // +0000 → +00:00
 
-  const created = new Date(normalized);
+  // Helm timestamps are UTC. If a helm-format value lacked a numeric offset,
+  // append Z so it parses as UTC rather than the host's local timezone.
+  const iso = isHelmFormat && !hasNumericOffset ? `${normalized}Z` : normalized;
+
+  const created = new Date(iso);
 
   if (Number.isNaN(created.valueOf())) {
     return "-";

package/src/lib/k8s/resource-detail-builder.ts

@@ -1,6 +1,6 @@
 import type { ResourceDetail, ResourceKind } from "./types";
 import { isPodKind } from "./resource-parser";
-import type { KubernetesResource, KubernetesMetadata } from "./resource-parser";
+import type { KubernetesResource } from "./resource-parser";
 
 export { type KubernetesMetadata, type KubernetesResource } from "./resource-parser";
 

package/src/lib/k8s/resource-parser.ts

@@ -19,12 +19,17 @@ export function asRecord(value: unknown): Record<string, unknown> | undefined {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? (value as Record<string, unknown>) : undefined;
 }
 
+/**
+ * Returns the value if it is a non-empty string, otherwise undefined.
+ * Note: an explicitly-empty string is treated as absent — callers that need
+ * to preserve empty strings should read the field directly.
+ */
 export function asString(value: unknown): string | undefined {
   return typeof value === "string" && value.length > 0 ? value : undefined;
 }
 
 export function asNumber(value: unknown): number | undefined {
-  return typeof value === "number" ? value : undefined;
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
 }
 
 export function asBoolean(value: unknown): boolean | undefined {
@@ -35,6 +40,16 @@ export function asArray(value: unknown): unknown[] {
   return Array.isArray(value) ? value : [];
 }
 
+/**
+ * Returns the records (objects) within an array, dropping non-object entries.
+ * Convenience for the common `asArray(x).map(asRecord).filter(isRecord)` pattern.
+ */
+export function recordsOf(value: unknown): Record<string, unknown>[] {
+  return asArray(value)
+    .map(asRecord)
+    .filter((entry): entry is Record<string, unknown> => entry !== undefined);
+}
+
 export function summarizeLabels(labels?: Record<string, string> | undefined): string {
   const pairs = Object.entries(labels ?? {});
 
@@ -150,7 +165,7 @@ export function formatContainerState(value: unknown): string {
   const state = asRecord(value);
 
   if (!state) {
-    return "waiting";
+    return "unknown";
   }
 
   if (state.running) {

package/src/lib/k8s/types.ts

@@ -1,6 +1,6 @@
 export type PaneId = "clusters" | "resources" | "inspector";
 
-export type OverlayId = "cluster-switcher" | "namespace-switcher" | "delete-confirm" | "port-forward" | "logs" | "scale" | "container-picker" | "helm-rollback";
+export type OverlayId = "cluster-switcher" | "namespace-switcher" | "delete-confirm" | "port-forward" | "port-forward-list" | "logs" | "scale" | "container-picker" | "helm-rollback" | "notification-history" | "help";
 
 export type InspectorTab = "summary" | "yaml" | "events" | "describe";
 
@@ -105,10 +105,18 @@ export interface AppError {
 
 export type NotificationTone = "info" | "success" | "warning" | "danger";
 
+export interface NotificationAction {
+  id: string;
+  label: string;
+}
+
 export interface Notification {
   id: string;
   tone: NotificationTone;
   message: string;
+  persistent: boolean;
+  createdAt: number;
+  actions: NotificationAction[];
 }
 
 export interface PodMetricEntry {
@@ -158,6 +166,7 @@ export interface AppState {
   revealedSecretValues: Record<string, string>;
   activePortForwards: ActivePortForward[];
   notifications: Notification[];
+  notificationHistory: Notification[];
   podMetrics: Record<string, { cpu: string; memory: string }>;
   nodeMetrics: Record<string, { cpu: string; memory: string; cpuPct: number; memPct: number }>;
   helmRollbackRevision: string;

package/src/lib/kubectl/__tests__/metrics-utils.test.ts

@@ -35,12 +35,21 @@ describe("parseMemBytes", () => {
   test("Ki", () => expect(parseMemBytes("512Ki")).toBe(512 * 1024));
   test("Mi", () => expect(parseMemBytes("256Mi")).toBe(256 * 1024 ** 2));
   test("Gi", () => expect(parseMemBytes("2Gi")).toBe(2 * 1024 ** 3));
+  test("Ti", () => expect(parseMemBytes("1Ti")).toBe(1024 ** 4));
+  test("Pi", () => expect(parseMemBytes("1Pi")).toBe(1024 ** 5));
+  test("Ei", () => expect(parseMemBytes("1Ei")).toBe(1024 ** 6));
   test("K (decimal)", () => expect(parseMemBytes("1000K")).toBe(1000 * 1000));
   test("M (decimal)", () => expect(parseMemBytes("10M")).toBe(10 * 1000 ** 2));
   test("G (decimal)", () => expect(parseMemBytes("1G")).toBe(1000 ** 3));
+  test("T (decimal)", () => expect(parseMemBytes("1T")).toBe(1000 ** 4));
+  test("P (decimal)", () => expect(parseMemBytes("1P")).toBe(1000 ** 5));
+  test("E (decimal)", () => expect(parseMemBytes("1E")).toBe(1000 ** 6));
   test("plain bytes", () => expect(parseMemBytes("1024")).toBe(1024));
   test("empty string", () => expect(parseMemBytes("")).toBe(0));
   test("invalid", () => expect(parseMemBytes("abc")).toBe(0));
+  test("does not match K before Ki (order-dependent regression guard)", () => {
+    expect(parseMemBytes("100Ki")).toBe(100 * 1024);
+  });
 });
 
 // ── formatCpu ────────────────────────────────────────────────────────────────

package/src/lib/kubectl/kubectl-helpers.ts

@@ -1,4 +1,5 @@
 import { formatAge } from "../k8s/k8s-format";
+import { asRecord, asString } from "../k8s/resource-parser";
 import type { ResourceKind, ResourceRef } from "../k8s/types";
 import type { GenericListItem } from "./kubectl-types";
 
@@ -6,6 +7,12 @@ export function normalizeKind(kind: string): string {
   return kind.trim().toLowerCase();
 }
 
+export const HELM_RELEASE_KIND = "helmreleases";
+
+export function isHelmRelease(ref: { kind: string } | undefined): ref is { kind: string } {
+  return ref !== undefined && normalizeKind(ref.kind) === HELM_RELEASE_KIND;
+}
+
 export function normalizeResourceTarget(ref: ResourceRef): string {
   const kind = normalizeKind(ref.kind);
   return `${kind}/${ref.name}`;
@@ -77,8 +84,8 @@ export function supportsScale(ref: ResourceRef): boolean {
   return ["deployment", "deployments", "statefulset", "statefulsets", "replicaset", "replicasets"].includes(kind);
 }
 
-export function parseKubectlError(stderr: string, args: string[]): Error {
-  const message = stderr.trim() || `kubectl ${args.join(" ")} failed`;
+export function parseKubectlError(stderr: string, args: string[], command = "kubectl"): Error {
+  const message = stderr.trim() || `${command} ${args.join(" ")} failed`;
   return new Error(message);
 }
 
@@ -114,9 +121,7 @@ export function resourceStatus(resource: GenericListItem): string {
   }
 
   if (kind === "rolebinding" || kind === "clusterrolebinding") {
-    const subjects = Array.isArray((resource as unknown as Record<string, unknown>).subjects)
-      ? ((resource as unknown as Record<string, unknown>).subjects as unknown[])
-      : [];
+    const subjects = Array.isArray(resource.subjects) ? resource.subjects : [];
     return `${subjects.length} subjects`;
   }
 
@@ -164,9 +169,9 @@ export function resourceSummary(resource: GenericListItem): string {
   }
 
   if (kind === "node") {
-    const nodeInfo = (status.nodeInfo ?? {}) as Record<string, unknown>;
-    const kubeletVersion = typeof nodeInfo.kubeletVersion === "string" ? nodeInfo.kubeletVersion : "";
-    const labels = (resource as unknown as { metadata?: { labels?: Record<string, string> } }).metadata?.labels ?? {};
+    const nodeInfo = asRecord(status.nodeInfo) ?? {};
+    const kubeletVersion = asString(nodeInfo.kubeletVersion) ?? "";
+    const labels = resource.metadata?.labels ?? {};
     const roles = Object.keys(labels)
       .filter((k) => k.startsWith("node-role.kubernetes.io/"))
       .map((k) => k.replace("node-role.kubernetes.io/", ""))
@@ -175,14 +180,14 @@ export function resourceSummary(resource: GenericListItem): string {
   }
 
   if (kind === "role" || kind === "clusterrole") {
-    const rules = (resource as unknown as { rules?: unknown[] }).rules ?? [];
+    const rules = Array.isArray(resource.rules) ? resource.rules : [];
     return `${rules.length} rules`;
   }
 
   if (kind === "rolebinding" || kind === "clusterrolebinding") {
-    const roleRef = (resource as unknown as { roleRef?: Record<string, unknown> }).roleRef;
+    const roleRef = resource.roleRef;
     if (roleRef) {
-      return `\u2192 ${roleRef.kind ?? ""}/${roleRef.name ?? ""}`;
+      return `\u2192 ${asString(roleRef.kind) ?? ""}/${asString(roleRef.name) ?? ""}`;
     }
     return "";
   }

package/src/lib/kubectl/kubectl-service.ts

@@ -84,6 +84,24 @@ export type {
 
 const KUBECTL_TIMEOUT_MS = 15_000;
 
+interface NamespacedOptions {
+  context: string;
+  namespace?: string | undefined;
+  namespaced?: boolean | undefined;
+}
+
+function buildContextArgs(options: NamespacedOptions): string[] {
+  const args = ["--context", options.context];
+  if (options.namespaced && options.namespace !== undefined) {
+    args.push("-n", options.namespace);
+  }
+  return args;
+}
+
+function buildHelmBaseArgs(options: { context: string; namespace: string }): string[] {
+  return ["--kube-context", options.context, "-n", options.namespace];
+}
+
 export class KubectlService {
   async isAvailable(): Promise<boolean> {
     try {
@@ -213,13 +231,19 @@ export class KubectlService {
     jsonArgs.push("-o", "json");
     yamlArgs.push("-o", "yaml");
 
-    const [resource, yaml, describe] = await Promise.all([
+    const [resource, yaml, describeResult] = await Promise.allSettled([
       runJson<KubernetesResource>({ command: "kubectl", args: jsonArgs, timeoutMs: KUBECTL_TIMEOUT_MS }),
       runText({ command: "kubectl", args: yamlArgs, timeoutMs: KUBECTL_TIMEOUT_MS }),
-      runText({ command: "kubectl", args: describeArgs, timeoutMs: KUBECTL_TIMEOUT_MS }).catch(() => ""),
+      runText({ command: "kubectl", args: describeArgs, timeoutMs: KUBECTL_TIMEOUT_MS }),
     ]);
 
-    return buildResourceDetail({ resourceKind: options.resourceKind, resource, yaml, describe });
+    if (resource.status !== "fulfilled") {
+      throw resource.reason;
+    }
+    const yamlText = yaml.status === "fulfilled" ? yaml.value : "";
+    const describe = describeResult.status === "fulfilled" ? describeResult.value : "";
+
+    return buildResourceDetail({ resourceKind: options.resourceKind, resource: resource.value, yaml: yamlText, describe });
   }
 
   async listResourceEvents(options: ListResourceEventsOptions): Promise<EventItem[]> {
@@ -284,11 +308,7 @@ export class KubectlService {
       throw new Error(`Logs are not supported yet for ${options.resourceRef.kind}`);
     }
 
-    const args = ["--context", options.context];
-
-    if (options.namespaced) {
-      args.push("-n", options.namespace);
-    }
+    const args = buildContextArgs(options);
 
     const tail = options.logOptions?.tail ?? 120;
     const since = options.logOptions?.since;
@@ -307,7 +327,7 @@ export class KubectlService {
     }
 
     if (logTarget.includeAllPods) {
-      args.push("--all-pods=true");
+      args.push("--all-containers=true");
     }
 
     if (options.container) {
@@ -325,11 +345,7 @@ export class KubectlService {
       throw new Error(`Scale is not supported yet for ${options.resourceRef.kind}`);
     }
 
-    const args = ["--context", options.context];
-
-    if (options.namespaced) {
-      args.push("-n", options.namespace);
-    }
+    const args = buildContextArgs(options);
 
     args.push("scale", normalizeResourceTarget(options.resourceRef), `--replicas=${options.replicas}`);
 
@@ -341,11 +357,7 @@ export class KubectlService {
       throw new Error(`Rollout restart is not supported yet for ${options.resourceRef.kind}`);
     }
 
-    const args = ["--context", options.context];
-
-    if (options.namespaced) {
-      args.push("-n", options.namespace);
-    }
+    const args = buildContextArgs(options);
 
     args.push("rollout", "restart", normalizeResourceTarget(options.resourceRef));
 
@@ -357,11 +369,7 @@ export class KubectlService {
       return this.uninstallHelmRelease(options);
     }
 
-    const args = ["--context", options.context];
-
-    if (options.namespaced) {
-      args.push("-n", options.namespace);
-    }
+    const args = buildContextArgs(options);
 
     args.push("delete", normalizeResourceTarget(options.resourceRef));
 
@@ -369,26 +377,18 @@ export class KubectlService {
   }
 
   startShell(options: StartShellOptions): ChildProcess {
-    const args = ["--context", options.context];
-
-    if (options.namespaced) {
-      args.push("-n", options.namespace);
-    }
+    const args = buildContextArgs(options);
 
     const kind = normalizeKind(options.resourceRef.kind);
     const target = kind === "pod" || kind === "pods" ? `pod/${options.resourceRef.name}` : normalizeResourceTarget(options.resourceRef);
 
     args.push("exec", "-it", target, "--", "sh", "-lc", "exec ${SHELL:-/bin/sh}");
 
-    return startPersistentProcess({ command: "kubectl", args, stdio: "inherit" });
+    return startPersistentProcess({ command: "kubectl", args, stdio: ["inherit", "inherit", "pipe"] });
   }
 
   editResource(options: EditResourceOptions): ChildProcess {
-    const args = ["--context", options.context];
-
-    if (options.namespaced) {
-      args.push("-n", options.namespace);
-    }
+    const args = buildContextArgs(options);
 
     args.push("edit", normalizeResourceTarget(options.resourceRef));
 
@@ -529,7 +529,7 @@ export class KubectlService {
     const parsed = await runJson<SecretResponse>({ command: "kubectl", args, timeoutMs: KUBECTL_TIMEOUT_MS });
     const encoded = parsed.data?.[options.key];
 
-    if (!encoded) {
+    if (encoded === undefined) {
       throw new Error(`Key "${options.key}" not found in secret "${options.name}"`);
     }
 
@@ -547,7 +547,7 @@ export class KubectlService {
   }
 
   private async listHelmReleases(options: ListResourcesOptions): Promise<ResourceListItem[]> {
-    const args = ["list", "--kube-context", options.context, "-n", options.namespace, "-o", "json"];
+    const args = ["list", ...buildHelmBaseArgs(options), "-o", "json"];
     const result = await runCommand({ command: "helm", args, timeoutMs: KUBECTL_TIMEOUT_MS });
     const items = JSON.parse(result.stdout) as HelmListItem[];
 
@@ -564,7 +564,7 @@ export class KubectlService {
   }
 
   private async getHelmReleaseDetail(options: GetResourceDetailOptions): Promise<ResourceDetail> {
-    const baseArgs = ["--kube-context", options.context, "-n", options.namespace];
+    const baseArgs = buildHelmBaseArgs(options);
 
     const [statusResult, valuesResult] = await Promise.all([
       runCommand({ command: "helm", args: ["status", options.name, ...baseArgs, "-o", "json"], timeoutMs: KUBECTL_TIMEOUT_MS }),
@@ -621,7 +621,7 @@ export class KubectlService {
   private async uninstallHelmRelease(options: DeleteResourceOptions): Promise<void> {
     await runCommand({
       command: "helm",
-      args: ["uninstall", options.resourceRef.name, "--kube-context", options.context, "-n", options.namespace],
+      args: ["uninstall", options.resourceRef.name, ...buildHelmBaseArgs(options)],
       timeoutMs: KUBECTL_TIMEOUT_MS,
     });
   }

package/src/lib/kubectl/kubectl-types.ts

@@ -142,14 +142,23 @@ export interface GenericListItem {
     name?: string | undefined;
     namespace?: string | undefined;
     creationTimestamp?: string | undefined;
+    labels?: Record<string, string> | undefined;
   } | undefined;
   spec?: Record<string, unknown> | undefined;
   status?: Record<string, unknown> | undefined;
+  // Event-only fields
   type?: string | undefined;
   reason?: string | undefined;
   message?: string | undefined;
   lastTimestamp?: string | undefined;
   firstTimestamp?: string | undefined;
+  // RBAC fields
+  rules?: unknown[] | undefined;
+  roleRef?: Record<string, unknown> | undefined;
+  subjects?: unknown[] | undefined;
+  // ServiceAccount fields
+  secrets?: unknown[] | undefined;
+  imagePullSecrets?: unknown[] | undefined;
 }
 
 export interface GenericListResponse {
@@ -218,7 +227,7 @@ export interface HelmStatusResponse {
 }
 
 export interface ApiResourcesResponse {
-  resources: ApiResourceItem[];
+  resources?: ApiResourceItem[] | undefined;
 }
 
 export interface ApiResourceItem {

package/src/lib/kubectl/metrics-utils.ts

@@ -8,16 +8,30 @@ export function parseCpuNano(value: string): number {
 
 export function parseMemBytes(value: string): number {
   if (!value) return 0;
-  const units: Record<string, number> = {
-    Ki: 1024, Mi: 1024 ** 2, Gi: 1024 ** 3, Ti: 1024 ** 4,
-    K: 1000, M: 1000 ** 2, G: 1000 ** 3, T: 1000 ** 4,
-  };
-  for (const [suffix, mult] of Object.entries(units)) {
+  // Order matters: multi-character (binary) suffixes must be checked before their
+  // single-letter decimal counterparts (e.g. "Ki" before "K").
+  const units: Array<[string, number]> = [
+    ["Ei", 1024 ** 6],
+    ["Pi", 1024 ** 5],
+    ["Ti", 1024 ** 4],
+    ["Gi", 1024 ** 3],
+    ["Mi", 1024 ** 2],
+    ["Ki", 1024],
+    ["E", 1000 ** 6],
+    ["P", 1000 ** 5],
+    ["T", 1000 ** 4],
+    ["G", 1000 ** 3],
+    ["M", 1000 ** 2],
+    ["K", 1000],
+  ];
+  for (const [suffix, mult] of units) {
     if (value.endsWith(suffix)) {
-      return Number.parseFloat(value) * mult;
+      const n = Number.parseFloat(value);
+      return Number.isFinite(n) ? n * mult : 0;
     }
   }
-  return Number.parseFloat(value) || 0;
+  const n = Number.parseFloat(value);
+  return Number.isFinite(n) ? n : 0;
 }
 
 export function formatCpu(nano: number): string {