openk8s 0.0.1 → 1.0.1

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

@@ -0,0 +1,308 @@
+import type { ResourceDetailLine, ResourceDetailSection } from "./types";
+
+export interface KubernetesMetadata {
+  name?: string | undefined;
+  namespace?: string | undefined;
+  creationTimestamp?: string | undefined;
+  labels?: Record<string, string> | undefined;
+}
+
+export interface KubernetesResource {
+  apiVersion?: string | undefined;
+  kind?: string | undefined;
+  metadata?: KubernetesMetadata | undefined;
+  spec?: Record<string, unknown> | undefined;
+  status?: Record<string, unknown> | undefined;
+}
+
+export function asRecord(value: unknown): Record<string, unknown> | undefined {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? (value as Record<string, unknown>) : undefined;
+}
+
+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;
+}
+
+export function asBoolean(value: unknown): boolean | undefined {
+  return typeof value === "boolean" ? value : undefined;
+}
+
+export function asArray(value: unknown): unknown[] {
+  return Array.isArray(value) ? value : [];
+}
+
+export function summarizeLabels(labels?: Record<string, string> | undefined): string {
+  const pairs = Object.entries(labels ?? {});
+
+  if (pairs.length === 0) {
+    return "none";
+  }
+
+  return pairs
+    .slice(0, 6)
+    .map(([key, value]) => `${key}=${value}`)
+    .join(", ");
+}
+
+export function summarizeIngressHosts(spec: Record<string, unknown>): string | undefined {
+  const rules = asArray(spec.rules);
+  const hosts = rules
+    .map((rule) => asString(asRecord(rule)?.host))
+    .filter((host): host is string => host !== undefined);
+
+  return hosts.length > 0 ? hosts.join(", ") : undefined;
+}
+
+export function isPodKind(kind: string): boolean {
+  const normalized = kind.trim().toLowerCase();
+  return normalized === "pod" || normalized === "pods";
+}
+
+export function normalizeKind(kind: string): string {
+  return kind.trim().toLowerCase();
+}
+
+export function supportsDirectPortForward(kind: string): boolean {
+  const normalized = normalizeKind(kind);
+
+  return [
+    "pod",
+    "pods",
+    "service",
+    "services",
+    "deployment",
+    "deployments",
+    "replicaset",
+    "replicasets",
+    "statefulset",
+    "statefulsets",
+  ].includes(normalized);
+}
+
+export function flattenSections(sections: ResourceDetailSection[]): string[] {
+  return sections.flatMap((section) => [
+    section.title,
+    ...section.lines.map((line) => `  ${typeof line === "string" ? line : line.text}`),
+  ]);
+}
+
+export function asPort(value: unknown): number | undefined {
+  if (typeof value === "number" && Number.isInteger(value) && value > 0 && value <= 65_535) {
+    return value;
+  }
+
+  if (typeof value === "string" && /^\d+$/.test(value)) {
+    const parsed = Number.parseInt(value, 10);
+    return parsed > 0 && parsed <= 65_535 ? parsed : undefined;
+  }
+
+  return undefined;
+}
+
+export function suggestedLocalPort(remotePort: number): number {
+  if (remotePort === 80) {
+    return 8080;
+  }
+
+  if (remotePort === 443) {
+    return 8443;
+  }
+
+  return remotePort;
+}
+
+export function extractContainerPorts(specValue: unknown): number[] {
+  const spec = asRecord(specValue);
+
+  if (!spec) {
+    return [];
+  }
+
+  const ports = asArray(spec.containers)
+    .map((container) => asRecord(container))
+    .filter((container): container is Record<string, unknown> => container !== undefined)
+    .flatMap((container) =>
+      asArray(container.ports)
+        .map((port) => asPort(asRecord(port)?.containerPort))
+        .filter((port): port is number => port !== undefined),
+    );
+
+  return [...new Set(ports)];
+}
+
+export function extractContainerNames(specValue: unknown): string[] {
+  const spec = asRecord(specValue);
+
+  if (!spec) {
+    return [];
+  }
+
+  return asArray(spec.containers)
+    .map((container) => asString(asRecord(container)?.name))
+    .filter((name): name is string => name !== undefined);
+}
+
+export function formatContainerState(value: unknown): string {
+  const state = asRecord(value);
+
+  if (!state) {
+    return "waiting";
+  }
+
+  if (state.running) {
+    return "running";
+  }
+
+  if (state.waiting) {
+    return `waiting (${asString(asRecord(state.waiting)?.reason) ?? "unknown"})`;
+  }
+
+  if (state.terminated) {
+    return `terminated (${asString(asRecord(state.terminated)?.reason) ?? "unknown"})`;
+  }
+
+  return "unknown";
+}
+
+export function formatValueFrom(value: unknown): string {
+  const valueFrom = asRecord(value);
+
+  if (!valueFrom) {
+    return "-";
+  }
+
+  const fieldRef = asRecord(valueFrom.fieldRef);
+  if (fieldRef) {
+    return `field:${asString(fieldRef.fieldPath) ?? "unknown"}`;
+  }
+
+  const resourceFieldRef = asRecord(valueFrom.resourceFieldRef);
+  if (resourceFieldRef) {
+    return `resource:${asString(resourceFieldRef.resource) ?? "unknown"}`;
+  }
+
+  const configMapKeyRef = asRecord(valueFrom.configMapKeyRef);
+  if (configMapKeyRef) {
+    return `configmap:${asString(configMapKeyRef.name) ?? "unknown"}/${asString(configMapKeyRef.key) ?? "key"}`;
+  }
+
+  const secretKeyRef = asRecord(valueFrom.secretKeyRef);
+  if (secretKeyRef) {
+    return `secret:${asString(secretKeyRef.name) ?? "unknown"}/${asString(secretKeyRef.key) ?? "key"}`;
+  }
+
+  return "-";
+}
+
+export function buildEnvLine(
+  id: string,
+  text: string,
+  revealedText?: string | undefined,
+  secretRef?: ResourceDetailLine["secretRef"],
+): ResourceDetailLine {
+  return revealedText
+    ? {
+        id,
+        text,
+        revealedText,
+        revealable: true,
+        secretRef,
+      }
+    : {
+        id,
+        text,
+      };
+}
+
+export function formatEnvFromSource(value: unknown): string {
+  const envFrom = asRecord(value);
+
+  if (!envFrom) {
+    return "-";
+  }
+
+  const prefix = asString(envFrom.prefix);
+  const configMapRef = asRecord(envFrom.configMapRef);
+  if (configMapRef) {
+    return `${prefix ? `${prefix} <= ` : ""}configmap:${asString(configMapRef.name) ?? "unknown"}`;
+  }
+
+  const secretRef = asRecord(envFrom.secretRef);
+  if (secretRef) {
+    return `${prefix ? `${prefix} <= ` : ""}secret:${asString(secretRef.name) ?? "unknown"}`;
+  }
+
+  return "-";
+}
+
+export function formatProbe(value: unknown): string {
+  const probe = asRecord(value);
+
+  if (!probe) {
+    return "disabled";
+  }
+
+  const httpGet = asRecord(probe.httpGet);
+  if (httpGet) {
+    return `http ${asString(httpGet.path) ?? "/"} port ${String(httpGet.port ?? "?")}`;
+  }
+
+  const tcpSocket = asRecord(probe.tcpSocket);
+  if (tcpSocket) {
+    return `tcp port ${String(tcpSocket.port ?? "?")}`;
+  }
+
+  const exec = asRecord(probe.exec);
+  if (exec) {
+    const command = asArray(exec.command)
+      .map((part) => asString(part))
+      .filter((part): part is string => part !== undefined)
+      .join(" ");
+    return `exec ${command || "command"}`;
+  }
+
+  const grpc = asRecord(probe.grpc);
+  if (grpc) {
+    return `grpc port ${String(grpc.port ?? "?")}`;
+  }
+
+  return "configured";
+}
+
+export function formatVolumeSource(value: unknown): string {
+  const volume = asRecord(value);
+
+  if (!volume) {
+    return "unknown";
+  }
+
+  if (volume.configMap) {
+    return `configmap:${asString(asRecord(volume.configMap)?.name) ?? "unknown"}`;
+  }
+
+  if (volume.secret) {
+    return `secret:${asString(asRecord(volume.secret)?.secretName) ?? "unknown"}`;
+  }
+
+  if (volume.persistentVolumeClaim) {
+    return `pvc:${asString(asRecord(volume.persistentVolumeClaim)?.claimName) ?? "unknown"}`;
+  }
+
+  if (volume.projected) {
+    return "projected";
+  }
+
+  if (volume.emptyDir) {
+    return "emptyDir";
+  }
+
+  if (volume.downwardAPI) {
+    return "downwardAPI";
+  }
+
+  return "other";
+}

package/src/lib/k8s/types.ts

@@ -0,0 +1,164 @@
+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 InspectorTab = "summary" | "yaml" | "events" | "describe";
+
+export type LoadStatus = "idle" | "loading" | "ready" | "error";
+
+export type PortForwardStatus = "starting" | "ready";
+
+export interface LogOptions {
+  tail: number;
+  since?: string | undefined;
+  previous: boolean;
+}
+
+export interface ClusterContext {
+  name: string;
+  isCurrent: boolean;
+}
+
+export interface NamespaceItem {
+  name: string;
+}
+
+export interface ResourceKind {
+  name: string;
+  namespaced: boolean;
+  group?: string | undefined;
+  shortNames: string[];
+}
+
+export interface ResourceRef {
+  kind: string;
+  name: string;
+  namespace?: string | undefined;
+}
+
+export interface ResourceListItem {
+  ref: ResourceRef;
+  status: string;
+  age: string;
+  summary: string;
+}
+
+export interface ResourcePortForward {
+  localPort: number;
+  remotePort: number;
+}
+
+export interface ResourceDetailLine {
+  id: string;
+  text: string;
+  /** The actual value shown when the user reveals a concealed line (e.g. a secret reference). */
+  revealedText?: string | undefined;
+  revealable?: boolean | undefined;
+  /**
+   * Present when this line is backed by a Kubernetes Secret.
+   * key is set for a specific key ref; omitted for envFrom (all keys).
+   */
+  secretRef?: { name: string; key?: string | undefined } | undefined;
+}
+
+export interface ResourceDetailSection {
+  title: string;
+  lines: Array<string | ResourceDetailLine>;
+}
+
+export interface ResourceDetail {
+  ref: ResourceRef;
+  summaryLines: string[];
+  summarySections: ResourceDetailSection[];
+  yaml: string;
+  describe?: string | undefined;
+  replicas?: number | undefined;
+  portForwards?: ResourcePortForward[] | undefined;
+  containers?: string[] | undefined;
+  helmChart?: string | undefined;
+}
+
+export interface EventItem {
+  type: string;
+  reason: string;
+  message: string;
+  age: string;
+  source: string;
+}
+
+export interface ActivePortForward {
+  id: string;
+  context: string;
+  namespace: string;
+  namespaced: boolean;
+  ref: ResourceRef;
+  localPort: number;
+  remotePort: number;
+  status: PortForwardStatus;
+  message?: string | undefined;
+}
+
+export interface AppError {
+  message: string;
+  detail?: string | undefined;
+}
+
+export type NotificationTone = "info" | "success" | "warning" | "danger";
+
+export interface Notification {
+  id: string;
+  tone: NotificationTone;
+  message: string;
+}
+
+export interface PodMetricEntry {
+  cpu: string;
+  memory: string;
+}
+
+export interface NodeMetricEntry {
+  cpu: string;
+  memory: string;
+  cpuPct: number;
+  memPct: number;
+}
+
+export interface AppState {
+  activePane: PaneId;
+  overlay?: OverlayId | undefined;
+  inspectorTab: InspectorTab;
+  kubectlAvailable: boolean;
+  statusMessage: string;
+  error?: AppError | undefined;
+  contexts: ClusterContext[];
+  contextsStatus: LoadStatus;
+  activeContext?: string | undefined;
+  namespaces: NamespaceItem[];
+  namespacesStatus: LoadStatus;
+  activeNamespace: string;
+  resourceKinds: ResourceKind[];
+  resourceKindsStatus: LoadStatus;
+  selectedKind: string;
+  resources: ResourceListItem[];
+  resourcesStatus: LoadStatus;
+  resourceFilter: string;
+  selectedResourceName?: string | undefined;
+  selectedResourceNames: string[];
+  selectedResourceDetail?: ResourceDetail | undefined;
+  selectedResourceDetailStatus: LoadStatus;
+  events: EventItem[];
+  eventsStatus: LoadStatus;
+  logsTarget?: string | undefined;
+  logsText: string;
+  logsStatus: LoadStatus;
+  logsContainer?: string | undefined;
+  logsOptions: LogOptions;
+  revealedDetailLineIds: string[];
+  /** Maps line ID → fetched plaintext secret value for lines that have been revealed */
+  revealedSecretValues: Record<string, string>;
+  activePortForwards: ActivePortForward[];
+  notifications: Notification[];
+  podMetrics: Record<string, { cpu: string; memory: string }>;
+  nodeMetrics: Record<string, { cpu: string; memory: string; cpuPct: number; memPct: number }>;
+  helmRollbackRevision: string;
+}