@catladder/cli 0.0.0-new-release-a895e12e → 0.0.0-new-cli-80ac360a

package/src/commands/general/commandKubeListNamespaces.ts

@@ -0,0 +1,15 @@
+import { defineCommand } from "../../core/defineCommand";
+import { getk8sApi } from "../../k8sApi";
+
+export const commandKubeListNamespaces = defineCommand({
+  name: "kube-list-namespaces",
+  description: "list all namespaces",
+  group: "general",
+  inputs: {},
+  execute: async (ctx) => {
+    const k8sApi = getk8sApi();
+    const res = await k8sApi.listNamespace();
+    const namespaces = res.body.items.map((n: any) => n.metadata.name);
+    ctx.log(namespaces.join("\n"));
+  },
+});

package/src/commands/general/commandKubeListPods.ts

@@ -0,0 +1,21 @@
+import { defineCommand } from "../../core/defineCommand";
+import { getk8sApi } from "../../k8sApi";
+
+export const commandKubeListPods = defineCommand({
+  name: "kube-list-pods",
+  description: "list all pods of namespace",
+  group: "general",
+  inputs: {
+    namespace: {
+      type: "string",
+      message: "kubernetes namespace",
+      positional: true,
+    },
+  },
+  execute: async (ctx) => {
+    const namespace = await ctx.get("namespace");
+    const k8sApi = getk8sApi();
+    const res = await k8sApi.listNamespacedPod(namespace);
+    ctx.log(res.body.items.map((n: any) => n.metadata.name).join("\n"));
+  },
+});

package/src/commands/general/commandKubeListSecrets.ts

@@ -0,0 +1,21 @@
+import { defineCommand } from "../../core/defineCommand";
+import { getk8sApi } from "../../k8sApi";
+
+export const commandKubeListSecrets = defineCommand({
+  name: "kube-list-secrets",
+  description: "show secrets",
+  group: "general",
+  inputs: {
+    namespace: {
+      type: "string",
+      message: "kubernetes namespace",
+      positional: true,
+    },
+  },
+  execute: async (ctx) => {
+    const namespace = await ctx.get("namespace");
+    const k8sApi = getk8sApi();
+    const res = await k8sApi.listNamespacedSecret(namespace);
+    ctx.log(res.body.items.map((n: any) => n.metadata.name).join("\n"));
+  },
+});

package/src/commands/general/commandKubePortForward.ts

@@ -0,0 +1,35 @@
+import { defineCommand } from "../../core/defineCommand";
+import { getk8sApi } from "../../k8sApi";
+import { startKubePortForward } from "../../kubernetes/portForward";
+
+export const commandKubePortForward = defineCommand({
+  name: "kube-port-forward",
+  description: "start port-forwarding",
+  group: "general",
+  inputs: {
+    namespace: {
+      type: "string",
+      message: "kubernetes namespace",
+      positional: true,
+    },
+    podName: {
+      type: "string",
+      message: "Which pod? 🤔",
+      choices: async (ctx) => {
+        const namespace = await ctx.get("namespace");
+        const k8sApi = getk8sApi();
+        const res = await k8sApi.listNamespacedPod(namespace);
+        return res.body.items.map((i: any) => i.metadata.name);
+      },
+    },
+    localPort: { type: "number", message: "Local port: " },
+    remotePort: { type: "number", message: "Remote port: " },
+  },
+  execute: async (ctx) => {
+    const namespace = await ctx.get("namespace");
+    const podName = await ctx.get("podName");
+    const localPort = await ctx.get("localPort");
+    const remotePort = await ctx.get("remotePort");
+    return startKubePortForward(podName, localPort, remotePort, namespace);
+  },
+});

package/src/commands/general/commandKubeStopPortforward.ts

@@ -0,0 +1,15 @@
+import { defineCommand } from "../../core/defineCommand";
+import { stopPortForward } from "../../utils/portForwards";
+
+export const commandKubeStopPortforward = defineCommand({
+  name: "kube-stop-portforward",
+  description: "stop a running port forward",
+  group: "general",
+  inputs: {
+    name: { type: "string", message: "port forward name", positional: true },
+  },
+  execute: async (ctx) => {
+    const name = await ctx.get("name");
+    stopPortForward(name.trim());
+  },
+});

package/src/commands/index.ts

@@ -0,0 +1,46 @@
+// General commands
+export { commandKubeCurrentContext } from "./general/commandKubeCurrentContext";
+export { commandKubeListNamespaces } from "./general/commandKubeListNamespaces";
+export { commandKubeListSecrets } from "./general/commandKubeListSecrets";
+export { commandKubeListPods } from "./general/commandKubeListPods";
+export { commandKubeStopPortforward } from "./general/commandKubeStopPortforward";
+export { commandKubeGetShell } from "./general/commandKubeGetShell";
+export { commandKubePortForward } from "./general/commandKubePortForward";
+
+// Project commands
+export { commandNamespace } from "./project/commandNamespace";
+export { commandEnvVars } from "./project/commandEnvVars";
+export { commandListPods } from "./project/commandListPods";
+export { commandGetShell } from "./project/commandGetShell";
+export { commandPortForward } from "./project/commandPortForward";
+export { commandDeletePods } from "./project/commandDeletePods";
+export { commandPauseProject } from "./project/commandPauseProject";
+export { commandDeleteProject } from "./project/commandDeleteProject";
+export { commandOpenEnv } from "./project/commandOpenEnv";
+export { commandOpenLogs } from "./project/commandOpenLogs";
+export { commandOpenGit } from "./project/commandOpenGit";
+export { commandCloudSqlProxy } from "./project/commandCloudSqlProxy";
+export { commandConfigSecrets } from "./project/commandConfigSecrets";
+export { commandSecretsClearBackups } from "./project/commandSecretsClearBackups";
+export {
+  commandTriggerCronjobGeneral,
+  commandTriggerCronjobProject,
+} from "./project/commandTriggerCronjob";
+export { commandRenewToken } from "./project/commandRenewToken";
+export { commandGetMyTotalWorktime } from "./project/commandGetMyTotalWorktime";
+export { commandSetup } from "./project/commandSetup";
+export { commandCiJobOpen, commandCiJobLog } from "./project/commandGitlabCi";
+export { commandProjectRestoreDb } from "./project/commandProjectRestoreDb";
+export { commandSecurityEvaluate } from "./project/commandSecurityEvaluate";
+
+// MongoDB commands
+export { commandMongoGetShell } from "./mongodb/commandMongoGetShell";
+export { commandMongoPortForward } from "./mongodb/commandMongoPortForward";
+export { commandMongoDestroyMember } from "./mongodb/commandMongoDestroyMember";
+
+// CloudSQL commands
+export { commandRestoreDb } from "./cloudSQL/commandRestoreDb";
+
+// Fun commands
+export { commandDadjoke } from "./fun/commandDadjoke";
+export { commandStarwars } from "./fun/commandStarwars";

package/src/commands/mongodb/commandMongoDestroyMember.ts

@@ -0,0 +1,133 @@
+import { exec } from "child-process-promise";
+import { defineCommand } from "../../core/defineCommand";
+import { getProjectPvcs } from "../../kubernetes";
+import { logError } from "../../utils/log";
+import { getProjectNamespace } from "../../utils/projects";
+import { ensureCluster } from "../../apps/cli/commands/project/utils/ensureCluster";
+import { getMongoDbPodsWithReplInfo } from "../../apps/cli/commands/mongodb/utils";
+import { envAndComponents } from "../../apps/cli/commands/project/utils/autocompletions";
+
+const removeFinalizer = async (
+  namespace: string,
+  type: "pod" | "pv" | "pvc",
+  name: string,
+) =>
+  exec(
+    `kubectl patch --namespace ${namespace} ${type} ${name} -p '{"metadata":{"finalizers":null}}'`,
+  );
+
+const deleteResource = async (
+  namespace: string,
+  type: "pod" | "pv" | "pvc",
+  name: string,
+) => exec(`kubectl delete --namespace ${namespace} ${type} ${name}`);
+
+const removeFinalizerAndDelete = async (
+  namespace: string,
+  type: "pod" | "pv" | "pvc",
+  name: string,
+) => {
+  return Promise.all([
+    removeFinalizer(namespace, type, name),
+    await deleteResource(namespace, type, name),
+  ]);
+};
+
+export const commandMongoDestroyMember = defineCommand({
+  name: "project-mongo-destroy-member",
+  description: "DESTROY a member of a replicaset in order to reinitialize it",
+  group: "mongodb",
+  inputs: {
+    envComponent: {
+      type: "string",
+      message: "environment:component",
+      positional: true,
+      choices: async () => envAndComponents(),
+    },
+    podName: {
+      type: "string",
+      message: "Which pod? 🤔",
+      choices: async (ctx) => {
+        const envComponent = await ctx.get("envComponent");
+        const mongodbPods = await getMongoDbPodsWithReplInfo(envComponent);
+        const secondaries = mongodbPods.filter((pod: any) => !pod.isMaster);
+        return secondaries.map((p: any) => ({
+          name: `[ secondary ] ${p.podName}`,
+          value: p.podName,
+        }));
+      },
+    },
+  },
+  execute: async (ctx) => {
+    const envComponent = await ctx.get("envComponent");
+    await ensureCluster(ctx, envComponent);
+    ctx.log(
+      "this command tries to delete a (secondary) member of the replicaset, it's persistent volume claim (pvc) and the volume",
+    );
+    ctx.log("");
+    ctx.log(
+      "this is useful, if you update the stateful set with new volume configuration (different size or storage class)",
+    );
+    ctx.log("");
+    ctx.log(
+      "Kubernetes will usually recreate the missing member with the updated config and mongodb will start synchronizing the new member.",
+    );
+    ctx.log("");
+    ctx.log(
+      "This works without downtime, but should be done when load on the db is low. Also it has not been tested with large dbs (> 10gi)",
+    );
+    ctx.log("");
+    ctx.log(
+      "Deleting the volume and claim often stuck, just wait or cancel and restart.",
+    );
+    ctx.log("");
+
+    const understood = await ctx.confirm("DO YOU UNDERSTAND?");
+    if (!understood) {
+      throw new Error("abort");
+    }
+
+    const namespace = await getProjectNamespace(envComponent);
+    const pvcs = await getProjectPvcs(envComponent);
+
+    const podName = await ctx.get("podName");
+
+    const thePvc = pvcs.find(
+      (pvc: any) => pvc.metadata.name === `datadir-${podName}`,
+    );
+    if (!thePvc) {
+      logError(ctx, `sorry, no pvc found for ${podName}`);
+      return;
+    }
+
+    const shouldContinue = await ctx.confirm(
+      "THIS WILL DESTROY THE POD, ITS VOLUME AND ALL ITS DATA 🙀🙀🙀!!! continue? 🤔",
+    );
+    if (!shouldContinue) {
+      throw new Error("abort");
+    }
+
+    ctx.log("destroying volume...");
+    try {
+      await removeFinalizerAndDelete(
+        namespace,
+        "pv",
+        (thePvc as any).spec.volumeName,
+      );
+    } catch (e: any) {
+      ctx.log(e.message);
+    }
+    ctx.log("destroying volume claim...");
+    try {
+      await removeFinalizerAndDelete(
+        namespace,
+        "pvc",
+        (thePvc as any).metadata.name,
+      );
+    } catch (e: any) {
+      ctx.log(e.message);
+    }
+    ctx.log("destroying pod...");
+    await removeFinalizerAndDelete(namespace, "pod", podName);
+  },
+});

package/src/commands/mongodb/commandMongoGetShell.ts

@@ -0,0 +1,36 @@
+import { defineCommand } from "../../core/defineCommand";
+
+import { getProjectNamespace } from "../../utils/projects";
+import { ensureCluster } from "../../apps/cli/commands/project/utils/ensureCluster";
+import {
+  getMongodbShell,
+  getProjectMongodbAllPodsSortedWithLabel,
+} from "../../apps/cli/commands/mongodb/utils";
+import { envAndComponents } from "../../apps/cli/commands/project/utils/autocompletions";
+
+export const commandMongoGetShell = defineCommand({
+  name: "project-mongo-get-shell",
+  description: "get a shell to a mongodb in the environment",
+  group: "mongodb",
+  inputs: {
+    envComponent: {
+      type: "string",
+      message: "environment:component",
+      positional: true,
+      choices: async () => envAndComponents(),
+    },
+    podName: {
+      type: "string",
+      message: "Which pod? 🤔",
+      choices: async (ctx) =>
+        getProjectMongodbAllPodsSortedWithLabel(await ctx.get("envComponent")),
+    },
+  },
+  execute: async (ctx) => {
+    const envComponent = await ctx.get("envComponent");
+    await ensureCluster(ctx, envComponent);
+    const namespace = await getProjectNamespace(envComponent);
+    const podName = await ctx.get("podName");
+    return getMongodbShell(namespace, podName);
+  },
+});

package/src/commands/mongodb/commandMongoPortForward.ts

@@ -0,0 +1,56 @@
+import { defineCommand } from "../../core/defineCommand";
+import { getEnvVarsResolved, parseChoice } from "../../config/getProjectConfig";
+
+import { startKubePortForward } from "../../kubernetes/portForward";
+import { getProjectNamespace } from "../../utils/projects";
+import { ensureCluster } from "../../apps/cli/commands/project/utils/ensureCluster";
+import { getProjectMongodbAllPodsSortedWithLabel } from "../../apps/cli/commands/mongodb/utils";
+import clipboard from "clipboardy";
+import { envAndComponents } from "../../apps/cli/commands/project/utils/autocompletions";
+
+export const commandMongoPortForward = defineCommand({
+  name: "project-mongo-port-forward",
+  description: "port forward to a mongodb",
+  group: "mongodb",
+  inputs: {
+    envComponent: {
+      type: "string",
+      message: "environment:component",
+      positional: true,
+      choices: async () => envAndComponents(),
+    },
+    podName: {
+      type: "string",
+      message: "Which pod? 🤔",
+      choices: async (ctx) =>
+        getProjectMongodbAllPodsSortedWithLabel(await ctx.get("envComponent")),
+    },
+    localPort: {
+      type: "number",
+      message: "Local port: ",
+      default: 30000,
+    },
+  },
+  execute: async (ctx) => {
+    const envComponent = await ctx.get("envComponent");
+    await ensureCluster(ctx, envComponent);
+    const namespace = await getProjectNamespace(envComponent);
+    const podName = await ctx.get("podName");
+
+    const localPort = await ctx.get("localPort");
+    const { env, componentName } = parseChoice(envComponent);
+    const envVars = await getEnvVarsResolved(ctx, env, componentName);
+    const MONGODB_ROOT_PASSWORD = envVars?.MONGODB_ROOT_PASSWORD;
+    const connectionUrl = `mongodb://root:${MONGODB_ROOT_PASSWORD}@localhost:${localPort}`;
+    clipboard.writeSync(connectionUrl);
+    ctx.log("");
+    ctx.log("username: root");
+    ctx.log(`password: ${MONGODB_ROOT_PASSWORD}`);
+    ctx.log(`connection string: ${connectionUrl}`);
+    ctx.log("");
+    ctx.log("👆 connection string has been copied to your clipboard!");
+    ctx.log("");
+
+    return startKubePortForward(podName, localPort, 27017, namespace);
+  },
+});

package/src/commands/project/commandCloudSqlProxy.ts

@@ -0,0 +1,189 @@
+import type { ComponentContext } from "@catladder/pipeline";
+import {
+  createKubernetesCloudsqlBaseValues,
+  getDeployConfigType,
+  isOfDeployType,
+} from "@catladder/pipeline";
+import clipboard from "clipboardy";
+import { defineCommand } from "../../core/defineCommand";
+import {
+  getEnvVarsResolved,
+  getPipelineContextByChoice,
+  parseChoice,
+} from "../../config/getProjectConfig";
+import {
+  ERROR_NOT_INSTALLED,
+  startCloudSqlProxyInCurrentShell,
+} from "../../gcloud/cloudSql/startProxy";
+import { logError, logLines, logWarning } from "../../utils/log";
+import type { IO } from "../../core/types";
+import { envAndComponents } from "../../apps/cli/commands/project/utils/autocompletions";
+
+type ProxyInfo = {
+  instanceName: string;
+  DB_NAME: string;
+  DB_PASSWORD: string;
+  DB_USER: string;
+};
+
+const getProxyInfoForKubernetes = async (
+  io: IO,
+  context: ComponentContext,
+): Promise<ProxyInfo> => {
+  if (!isOfDeployType(context.deploy?.config, "kubernetes")) {
+    throw new Error("unsupported");
+  }
+  const envVars = await getEnvVarsResolved(io, context.env, context.name);
+  const cloudSqlValues = createKubernetesCloudsqlBaseValues(context);
+  const DB_PASSWORD = (
+    envVars?.DB_PASSWORD || envVars?.POSTGRESQL_PASSWORD
+  )?.toString();
+  const DB_NAME = cloudSqlValues.cloudsql.fullDbName.toString();
+  const instanceName = cloudSqlValues.cloudsql.instanceConnectionName;
+  return { instanceName, DB_PASSWORD, DB_NAME, DB_USER: "postgres" };
+};
+
+const getProxyInfoForCloudRun = async (
+  io: IO,
+  context: ComponentContext,
+): Promise<ProxyInfo> => {
+  if (
+    !isOfDeployType(context.deploy?.config, "google-cloudrun") ||
+    !context.deploy?.config.cloudSql
+  ) {
+    const deployType = getDeployConfigType(context.deploy?.config);
+    const errorMessage =
+      deployType === "google-cloudrun"
+        ? `DeployConfig is missing the cloudSql property`
+        : `Unsupported DeployConfig type: ${deployType}`;
+    logError(io, errorMessage);
+    throw new Error(errorMessage);
+  }
+  const envVars = await getEnvVarsResolved(io, context.env, context.name);
+  return {
+    instanceName: context.deploy?.config.cloudSql.instanceConnectionName,
+    DB_PASSWORD: envVars?.DB_PASSWORD?.toString(),
+    DB_NAME: context.environment.envVars.DB_NAME.toString(),
+    DB_USER: envVars?.DB_USER?.toString(),
+  };
+};
+
+const getProxyInfo = async (io: IO, context: ComponentContext) => {
+  if (isOfDeployType(context.deploy?.config, "kubernetes")) {
+    return getProxyInfoForKubernetes(io, context);
+  } else if (isOfDeployType(context.deploy?.config, "google-cloudrun")) {
+    return getProxyInfoForCloudRun(io, context);
+  }
+  throw new Error(`unsupported environment: ${context.deploy?.config?.type}`);
+};
+
+const getDbUrl = (
+  { DB_PASSWORD, DB_NAME, DB_USER }: ProxyInfo,
+  localPort: string,
+  additional: string = "",
+) =>
+  `DATABASE_URL="postgresql://${DB_USER}:${DB_PASSWORD}@localhost:${localPort}/${DB_NAME}${additional}"`;
+
+const getJdbcUrl = (
+  { DB_PASSWORD, DB_NAME, DB_USER }: ProxyInfo,
+  localPort: string,
+) =>
+  `DATABASE_JDBC_URL="jdbc:postgresql://localhost:${localPort}/${DB_NAME}?schema=public&user=${DB_USER}&password=${DB_PASSWORD}"`;
+
+export const commandCloudSqlProxy = defineCommand({
+  name: "project-cloud-sql-proxy",
+  description: "proxy to cloud sql db",
+  group: "project",
+  inputs: {
+    envComponent: {
+      type: "string",
+      message: "environment:component",
+      positional: true,
+      choices: async () => envAndComponents(),
+    },
+    localPort: {
+      type: "number",
+      message: "Local port: ",
+      default: 54320,
+    },
+  },
+  execute: async (ctx) => {
+    const envComponent = await ctx.get("envComponent");
+    const { env, componentName } = parseChoice(envComponent);
+    if (!componentName) {
+      logWarning(ctx, "need componentName");
+      return;
+    }
+
+    const context = await getPipelineContextByChoice(env, componentName);
+
+    if (env === "review") {
+      logWarning(
+        ctx,
+        "connection string does not include mr information on review environments",
+      );
+    }
+
+    const localPort = await ctx.get("localPort");
+
+    const proxyInfo = await getProxyInfo(ctx, context);
+
+    const psqlEnvVars = {
+      PGPASSWORD: proxyInfo.DB_PASSWORD,
+      PGUSER: proxyInfo.DB_USER,
+      PGDATABASE: proxyInfo.DB_NAME,
+      PGHOST: "localhost",
+      PGPORT: localPort,
+    };
+    const lipbqEnvVarDeclarations = Object.entries(psqlEnvVars).map(
+      ([key, value]) => `${key}="${value}"`,
+    );
+    const dbUrl = getDbUrl(proxyInfo, String(localPort));
+    const jdbcUrl = getJdbcUrl(proxyInfo, String(localPort));
+
+    clipboard.writeSync(
+      [
+        "",
+        "## CloudSQL proxy connection .env variables",
+        dbUrl,
+        jdbcUrl,
+        "## DATABASE_URL with schema=public parameter (e. g. Prisma requires this):",
+        `# ${getDbUrl(proxyInfo, String(localPort), `?schema=public`)}`,
+        "## Env variables for libpq (e.g. psql client https://www.postgresql.org/docs/current/libpq-envars.html#LIBPQ-ENVARS)",
+        ...lipbqEnvVarDeclarations,
+        "",
+      ].join("\n"),
+    );
+
+    logLines(
+      ctx,
+      null,
+      "Connection strings env variables DATABASE_URL and those for the 'psql' client (copied to your clipboard for .env file):",
+      dbUrl,
+      jdbcUrl,
+      ...lipbqEnvVarDeclarations,
+      null,
+      "DATABASE_URL with schema=public parameter (e. g. Prisma requires this):",
+      getDbUrl(proxyInfo, String(localPort), `?schema=public`),
+      null,
+    );
+
+    try {
+      await startCloudSqlProxyInCurrentShell({
+        instanceName: proxyInfo.instanceName,
+        localPort,
+      });
+    } catch (error) {
+      if (!(error instanceof Error)) throw error;
+      if (error.message !== ERROR_NOT_INSTALLED) throw error;
+      logError(
+        ctx,
+        error.message,
+        null,
+        "Please install the Cloud SQL Auth Proxy from:",
+        `https://cloud.google.com/sql/docs/postgres/connect-auth-proxy#install`,
+        null,
+      );
+    }
+  },
+});

package/src/commands/project/commandConfigSecrets.ts

@@ -0,0 +1,30 @@
+import { defineCommand } from "../../core/defineCommand";
+import { projectConfigSecrets } from "../../apps/cli/commands/project/commandConfigSecrets";
+import { envAndComponents } from "../../apps/cli/commands/project/utils/autocompletions";
+
+// This command delegates to the existing implementation which uses
+// editAsFile (opens editor) and has retry loops with confirm prompts.
+// Full migration to CommandIO would require reworking the editor flow,
+// so for now we bridge it.
+export const commandConfigSecrets = defineCommand({
+  name: "project-config-secrets",
+  description: "setup/update secrets stored in pass",
+  group: "project",
+  inputs: {
+    envComponent: {
+      type: "string",
+      message: "environment:component",
+      positional: true,
+      choices: async () => envAndComponents(),
+    },
+  },
+  execute: async (ctx) => {
+    const envComponent = await ctx.get("envComponent");
+    // Bridge: the existing implementation accepts CommandInstance-like
+    // objects for logging and prompting. Since it uses this.prompt()
+    // internally (not ctx.prompt), we pass ctx which satisfies the
+    // IO interface for logging. The interactive prompts inside
+    // projectConfigSecrets will need a deeper migration later.
+    await projectConfigSecrets(ctx, envComponent);
+  },
+});

package/src/commands/project/commandDeletePods.ts

@@ -0,0 +1,53 @@
+import { defineCommand } from "../../core/defineCommand";
+import { getk8sApi } from "../../k8sApi";
+import { getProjectPodNames } from "../../kubernetes";
+import { logError } from "../../utils/log";
+import { getProjectNamespace } from "../../utils/projects";
+import { ensureCluster } from "../../apps/cli/commands/project/utils/ensureCluster";
+import { envAndComponents } from "../../apps/cli/commands/project/utils/autocompletions";
+
+export const commandDeletePods = defineCommand({
+  name: "project-delete-pods",
+  description: "delete / restart pods",
+  group: "project",
+
+  inputs: {
+    envComponent: {
+      type: "string",
+      message: "environment:component",
+      positional: true,
+      choices: async () => envAndComponents(),
+    },
+    selectedPodNames: {
+      type: "string[]",
+      message: "Which pods to delete / restart ? 🤔  ",
+      choices: async (ctx) => getProjectPodNames(await ctx.get("envComponent")),
+    },
+  },
+
+  execute: async (ctx) => {
+    const envComponent = await ctx.get("envComponent");
+    await ensureCluster(ctx, envComponent);
+    const namespace = await getProjectNamespace(envComponent);
+
+    const selectedPodNames = await ctx.get("selectedPodNames");
+
+    ctx.log(
+      "the following pods will be DELETED 🙀 (and therefore restarted 😸)",
+    );
+    ctx.log("");
+    selectedPodNames.forEach((n: string) => ctx.log(n));
+    ctx.log("");
+
+    const shouldContinue = await ctx.confirm("Continue ? 🤔  ");
+
+    ctx.log("");
+    const k8sApi = getk8sApi();
+    if (shouldContinue) {
+      for (const podName of selectedPodNames) {
+        await k8sApi.deleteNamespacedPod(podName, namespace, "true");
+        ctx.log(`deleted pod '${podName}'`);
+      }
+    }
+  },
+});