openk8s 1.0.0 → 1.0.2

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

@@ -0,0 +1,248 @@
+import type { ChildProcess } from "node:child_process";
+
+import type { ResourceKind, ResourceRef, LogOptions } from "../k8s/types";
+
+export interface ListNamespacesOptions {
+  context: string;
+}
+
+export interface ListResourceKindsOptions {
+  context: string;
+}
+
+export interface ListResourcesOptions {
+  context: string;
+  namespace: string;
+  resourceKind: ResourceKind;
+}
+
+export interface GetResourceDetailOptions {
+  context: string;
+  namespace: string;
+  resourceKind: ResourceKind;
+  name: string;
+}
+
+export interface ListResourceEventsOptions {
+  context: string;
+  namespace: string;
+  resourceRef: ResourceRef;
+  namespaced: boolean;
+}
+
+export interface EditResourceOptions {
+  context: string;
+  namespace: string;
+  resourceRef: ResourceRef;
+  namespaced: boolean;
+}
+
+export interface HelmUpgradeValuesOptions {
+  context: string;
+  namespace: string;
+  name: string;
+  chart: string;
+  valuesFile: string;
+}
+
+export interface HelmRollbackOptions {
+  context: string;
+  namespace: string;
+  name: string;
+  revision?: number | undefined;
+}
+
+export interface HelmUpgradeOptions {
+  context: string;
+  namespace: string;
+  name: string;
+  chart: string;
+}
+
+export type PodMetricsMap = Record<string, { cpu: string; memory: string }>;
+export type NodeMetricsMap = Record<string, { cpu: string; memory: string; cpuPct: number; memPct: number }>;
+
+export interface StreamLogsOptions {
+  context: string;
+  namespace: string;
+  resourceRef: ResourceRef;
+  namespaced: boolean;
+  container?: string | undefined;
+  logOptions?: LogOptions | undefined;
+}
+
+export interface StreamLogsResult {
+  target: string;
+  child: ChildProcess;
+}
+
+export interface ScaleResourceOptions {
+  context: string;
+  namespace: string;
+  resourceRef: ResourceRef;
+  namespaced: boolean;
+  replicas: number;
+}
+
+export interface RolloutRestartOptions {
+  context: string;
+  namespace: string;
+  resourceRef: ResourceRef;
+  namespaced: boolean;
+}
+
+export interface DeleteResourceOptions {
+  context: string;
+  namespace: string;
+  resourceRef: ResourceRef;
+  namespaced: boolean;
+}
+
+export interface StartShellOptions {
+  context: string;
+  namespace: string;
+  resourceRef: ResourceRef;
+  namespaced: boolean;
+}
+
+export interface StartPortForwardOptions {
+  context: string;
+  namespace: string;
+  resourceRef: ResourceRef;
+  namespaced: boolean;
+  localPort: number;
+  remotePort: number;
+}
+
+export interface GetSecretValueOptions {
+  context: string;
+  namespace: string;
+  name: string;
+  key: string;
+}
+
+export interface GetAllSecretValuesOptions {
+  context: string;
+  namespace: string;
+  name: string;
+}
+
+export interface KubeConfigContextResponse {
+  contexts?: Array<{ name?: string | undefined }> | undefined;
+  "current-context"?: string | undefined;
+}
+
+export interface NamespaceListResponse {
+  items?: Array<{ metadata?: { name?: string | undefined } | undefined }> | undefined;
+}
+
+export interface GenericListItem {
+  kind?: string | undefined;
+  metadata?: {
+    name?: string | undefined;
+    namespace?: string | undefined;
+    creationTimestamp?: string | undefined;
+  } | undefined;
+  spec?: Record<string, unknown> | undefined;
+  status?: Record<string, unknown> | undefined;
+  type?: string | undefined;
+  reason?: string | undefined;
+  message?: string | undefined;
+  lastTimestamp?: string | undefined;
+  firstTimestamp?: string | undefined;
+}
+
+export interface GenericListResponse {
+  apiVersion?: string | undefined;
+  kind?: string | undefined;
+  items?: GenericListItem[] | undefined;
+}
+
+export interface EventListResponse {
+  items?: EventResponseItem[] | undefined;
+}
+
+export interface SecretResponse {
+  data?: Record<string, string> | undefined;
+}
+
+export interface EventResponseItem {
+  metadata?: {
+    creationTimestamp?: string | undefined;
+  } | undefined;
+  involvedObject?: {
+    kind?: string | undefined;
+    name?: string | undefined;
+    namespace?: string | undefined;
+  } | undefined;
+  reason?: string | undefined;
+  message?: string | undefined;
+  type?: string | undefined;
+  source?: {
+    component?: string | undefined;
+    host?: string | undefined;
+  } | undefined;
+  reportingComponent?: string | undefined;
+  firstTimestamp?: string | undefined;
+  lastTimestamp?: string | undefined;
+}
+
+export interface HelmListItem {
+  name: string;
+  namespace: string;
+  revision: string;
+  updated: string;
+  status: string;
+  chart: string;
+  app_version: string;
+}
+
+export interface HelmStatusResponse {
+  name: string;
+  namespace: string;
+  version: number;
+  info: {
+    first_deployed: string;
+    last_deployed: string;
+    status: string;
+    notes?: string | undefined;
+    description?: string | undefined;
+  };
+  chart: {
+    metadata: {
+      name: string;
+      version: string;
+      appVersion?: string | undefined;
+    };
+  };
+}
+
+export interface ApiResourcesResponse {
+  resources: ApiResourceItem[];
+}
+
+export interface ApiResourceItem {
+  name: string;
+  singularName: string;
+  namespaced: boolean;
+  group?: string;
+  version: string;
+  kind: string;
+  verbs: string[];
+  shortNames?: string[];
+}
+
+export interface PodMetricsItem {
+  metadata?: { name?: string };
+  containers?: Array<{ usage?: { cpu?: string; memory?: string } }>;
+}
+
+export interface NodeMetricsItem {
+  metadata?: { name?: string };
+  usage?: { cpu?: string; memory?: string };
+}
+
+export interface AllocatableCapacity {
+  cpu: number;
+  memory: number;
+}

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

@@ -0,0 +1,33 @@
+export function parseCpuNano(value: string): number {
+  if (!value) return 0;
+  if (value.endsWith("n")) return Number.parseInt(value, 10);
+  if (value.endsWith("m")) return Number.parseInt(value, 10) * 1_000_000;
+  const n = Number.parseFloat(value);
+  return Number.isFinite(n) ? n * 1_000_000_000 : 0;
+}
+
+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)) {
+    if (value.endsWith(suffix)) {
+      return Number.parseFloat(value) * mult;
+    }
+  }
+  return Number.parseFloat(value) || 0;
+}
+
+export function formatCpu(nano: number): string {
+  if (nano >= 1_000_000_000) return `${(nano / 1_000_000_000).toFixed(2)}`;
+  return `${Math.round(nano / 1_000_000)}m`;
+}
+
+export function formatMem(bytes: number): string {
+  if (bytes >= 1024 ** 3) return `${(bytes / 1024 ** 3).toFixed(1)}Gi`;
+  if (bytes >= 1024 ** 2) return `${Math.round(bytes / 1024 ** 2)}Mi`;
+  if (bytes >= 1024) return `${Math.round(bytes / 1024)}Ki`;
+  return `${bytes}B`;
+}

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

@@ -1,6 +1,15 @@
 import { spawn, type ChildProcess, type StdioOptions } from "node:child_process";
 
 const DEFAULT_TIMEOUT_MS = 15_000;
+let shutdownController: AbortController | undefined;
+
+export function setAbortController(controller: AbortController): void {
+  shutdownController = controller;
+}
+
+export function abortRunningProcesses(): void {
+  shutdownController?.abort();
+}
 
 export interface RunCommandOptions {
   command: string;
@@ -28,6 +37,24 @@ export function runCommand(options: RunCommandOptions): Promise<CommandResult> {
       reject(new Error(`${options.command} ${options.args.slice(0, 4).join(" ")} timed out after ${timeoutMs / 1_000}s`));
     }, timeoutMs);
 
+    const onShutdown = (): void => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timeoutId);
+      child.kill("SIGTERM");
+      reject(new Error("Application shutting down"));
+    };
+
+    if (shutdownController) {
+      if (shutdownController.signal.aborted) {
+        onShutdown();
+        return;
+      }
+      shutdownController.signal.addEventListener("abort", onShutdown, { once: true });
+    }
+
     let stdout = "";
     let stderr = "";