@catladder/cli 0.0.0-next-95928577 → 0.0.0-next-e7541a00

package/src/commands/project/commandOpenEnv.ts

@@ -0,0 +1,27 @@
+import open from "open";
+import { defineCommand } from "../../core/defineCommand";
+import { getEnvironment, parseChoice } from "../../config/getProjectConfig";
+import { ensureCluster } from "../../apps/cli/commands/project/utils/ensureCluster";
+import { envAndComponents } from "../../apps/cli/commands/project/utils/autocompletions";
+
+export const commandOpenEnv = defineCommand({
+  name: "project open env",
+  description: "open the live environment",
+  group: "project",
+  inputs: {
+    envComponent: {
+      type: "string",
+      message: "environment:component",
+      positional: true,
+      choices: async () => envAndComponents(),
+    },
+  },
+  execute: async (ctx) => {
+    const envComponent = await ctx.get("envComponent");
+    const { env, componentName } = parseChoice(envComponent);
+    await ensureCluster(ctx, envComponent);
+    const environment = await getEnvironment(env, componentName);
+    const url = environment.envVars.ROOT_URL;
+    open(url.toString());
+  },
+});

package/src/commands/project/commandOpenGit.ts

@@ -0,0 +1,12 @@
+import { exec } from "child-process-promise";
+import { defineCommand } from "../../core/defineCommand";
+
+export const commandOpenGit = defineCommand({
+  name: "project open git",
+  description: "open the repo on gitlab / github in your browser",
+  group: "project",
+  inputs: {},
+  execute: async () => {
+    await exec("npx git-open");
+  },
+});

package/src/commands/project/commandOpenLogs.ts

@@ -0,0 +1,46 @@
+import { isOfDeployType } from "@catladder/pipeline";
+import { defineCommand } from "../../core/defineCommand";
+import {
+  getPipelineContextByChoice,
+  parseChoice,
+} from "../../config/getProjectConfig";
+import { openGoogleCloudLogs } from "../../kubernetes/openKubernetesDashboards";
+import { openGoogleCloudDashboard } from "../../gcloud/openDashboard";
+import { envAndComponents } from "../../apps/cli/commands/project/utils/autocompletions";
+import { hasDeployType } from "../availability";
+
+export const commandOpenLogs = defineCommand({
+  name: "project logs open",
+  description: "open logs for a component (Google Cloud Logging)",
+  group: "project",
+  isAvailable: hasDeployType("kubernetes", "google-cloudrun"),
+  inputs: {
+    envComponent: {
+      type: "string",
+      message: "environment:component",
+      positional: true,
+      choices: async () => envAndComponents(),
+    },
+  },
+  execute: async (ctx) => {
+    const envComponent = await ctx.get("envComponent");
+    const { env, componentName } = parseChoice(envComponent);
+    const context = await getPipelineContextByChoice(env, componentName);
+    const deployConfig = context.deploy?.config;
+
+    if (isOfDeployType(deployConfig, "kubernetes")) {
+      await openGoogleCloudLogs(ctx, context);
+    } else if (isOfDeployType(deployConfig, "google-cloudrun")) {
+      const serviceName = context.environment.fullName.toLowerCase();
+      await openGoogleCloudDashboard(
+        ctx,
+        `run/detail/${deployConfig.region}/${serviceName}/observability/logs`,
+        {
+          project: deployConfig.projectId,
+        },
+      );
+    } else {
+      ctx.log(`Unsupported deploy type for open-logs: ${deployConfig?.type}`);
+    }
+  },
+});

package/src/commands/project/commandPortForward.ts

@@ -0,0 +1,76 @@
+import { defineCommand } from "../../core/defineCommand";
+import { getProjectPodNames } from "../../kubernetes";
+import { logError } from "../../utils/log";
+import { startKubePortForward } from "../../kubernetes/portForward";
+import { getProjectNamespace } from "../../utils/projects";
+import { ensureCluster } from "../../apps/cli/commands/project/utils/ensureCluster";
+import { parseChoice } from "../../config/parseChoice";
+import { getPipelineContextByChoice } from "../../config/getProjectConfig";
+import { isOfDeployType } from "@catladder/pipeline";
+import { startPortForwardCommand } from "../../utils/portForwards";
+import open from "open";
+import { envAndComponents } from "../../apps/cli/commands/project/utils/autocompletions";
+import { hasDeployType } from "../availability";
+
+export const commandPortForward = defineCommand({
+  name: "project port-forward",
+  description: "start port-forwarding",
+  group: "project",
+  isAvailable: hasDeployType("kubernetes", "google-cloudrun"),
+  inputs: {
+    envComponent: {
+      type: "string",
+      message: "environment:component",
+      positional: true,
+      choices: async () => envAndComponents(),
+    },
+    podName: {
+      type: "string",
+      message: "Which pod? 🤔",
+      choices: async (ctx) => getProjectPodNames(await ctx.get("envComponent")),
+    },
+    localPort: { type: "number", message: "Local port: " },
+    remotePort: { type: "number", message: "Remote port: " },
+    mr: { type: "number", message: "Which mr 🤔 " },
+  },
+  execute: async (ctx) => {
+    const envComponent = await ctx.get("envComponent");
+    const { env, componentName } = parseChoice(envComponent);
+    const context = await getPipelineContextByChoice(env, componentName);
+
+    if (isOfDeployType(context.deploy?.config, "kubernetes")) {
+      await ensureCluster(ctx, envComponent);
+      const namespace = await getProjectNamespace(envComponent);
+      const podNames = await getProjectPodNames(envComponent);
+      if (podNames.length === 0) {
+        logError(ctx, "sorry, no pods found");
+        return;
+      }
+      const podName = await ctx.get("podName");
+      const localPort = await ctx.get("localPort");
+      const remotePort = await ctx.get("remotePort");
+      return startKubePortForward(podName, localPort, remotePort, namespace);
+    }
+
+    if (isOfDeployType(context.deploy?.config, "google-cloudrun")) {
+      if (!isOfDeployType(context.deploy?.config, "google-cloudrun")) {
+        throw new Error("not cloud run");
+      }
+
+      const { fullName } = context.environment;
+      let serviceName: string = fullName.toString();
+      if (context.environment.envType === "review") {
+        const mr = await ctx.get("mr");
+        serviceName = serviceName
+          .toString()
+          .replace("-review-", "-review-mr" + mr + "-");
+      }
+
+      const { projectId, region } = context.deploy.config;
+      const command = `gcloud beta run services proxy ${serviceName} --project ${projectId} --region ${region}`;
+
+      await startPortForwardCommand(`cloudRun/${serviceName}`, command);
+      open("http://localhost:8080");
+    }
+  },
+});

package/src/commands/project/commandProjectRestoreDb.ts

@@ -0,0 +1,203 @@
+import { defineCommand } from "../../core/defineCommand";
+import {
+  getAllPipelineContexts,
+  getEnvVarsResolved,
+  getPipelineContextByChoice,
+} from "../../config/getProjectConfig";
+import { hasCloudSql } from "../availability";
+import type { CloudSqlBackgroundProxy } from "../../gcloud/cloudSql/startProxy";
+import { startCloudSqlProxyInBackground } from "../../gcloud/cloudSql/startProxy";
+import { parseConnectionString } from "../../gcloud/cloudSql/parseConnectionString";
+import { spawnCopyDb } from "../../gcloud/cloudSql/copyDb";
+import type { ComponentContext } from "@catladder/pipeline";
+import { isOfDeployType } from "@catladder/pipeline";
+
+const componentHasCloudSql = (context: ComponentContext) => {
+  const deployConfig = context.deploy?.config;
+  if (isOfDeployType(deployConfig, "google-cloudrun")) {
+    return !!deployConfig.cloudSql;
+  }
+  if (isOfDeployType(deployConfig, "kubernetes")) {
+    return !!deployConfig.values?.cloudsql?.enabled;
+  }
+  return false;
+};
+
+export const commandProjectRestoreDb = defineCommand({
+  name: "project cloudsql restore-db",
+  description: "restores a project db from one source to another target",
+  group: "project",
+  isAvailable: hasCloudSql(),
+  inputs: {
+    source: {
+      type: "string",
+      message: "Source instance? 🤔 ",
+      choices: async () => {
+        const allContexts = await getAllPipelineContexts(undefined, {
+          includeLocal: true,
+        });
+        const sortByEnv = (a: string, b: string) => {
+          const aLocal = a.startsWith("local:");
+          const bLocal = b.startsWith("local:");
+          if (aLocal !== bLocal) return aLocal ? 1 : -1;
+          return a.localeCompare(b);
+        };
+        return allContexts
+          .filter(componentHasCloudSql)
+          .map((c: any) => `${c.env}:${c.name}`)
+          .sort(sortByEnv);
+      },
+    },
+    target: {
+      type: "string",
+      message: "target env? 🤔 ",
+      choices: async () => {
+        const allContexts = await getAllPipelineContexts(undefined, {
+          includeLocal: true,
+        });
+        const sortByEnv = (a: string, b: string) => {
+          const aLocal = a.startsWith("local:");
+          const bLocal = b.startsWith("local:");
+          if (aLocal !== bLocal) return aLocal ? 1 : -1;
+          return a.localeCompare(b);
+        };
+        return allContexts
+          .filter(componentHasCloudSql)
+          .map((c: any) => {
+            const value = `${c.env}:${c.name}`;
+            const isProd = c.environment.envType === "prod";
+            return {
+              name: isProd ? `⚠️ ${value}` : value,
+              value,
+            };
+          })
+          .sort((a: any, b: any) => sortByEnv(a.value, b.value));
+      },
+    },
+    confirmInstance: {
+      type: "string",
+      message: "confirm: ",
+    },
+  },
+  execute: async (ctx) => {
+    const source = await ctx.get("source");
+
+    const [sourceEnv, sourceComponent] = source.split(":");
+    const sourceContext = await getPipelineContextByChoice(
+      sourceEnv,
+      sourceComponent,
+    );
+    const sourceEnvVars = await getEnvVarsResolved(
+      ctx,
+      sourceContext.env,
+      sourceContext.name,
+    );
+
+    let sourceProxy: CloudSqlBackgroundProxy;
+    let sourceDbName: string;
+    let sourceUsername: string;
+    let sourcePassword: string;
+    let targetUsername: string;
+    let targetPassword: string;
+    let targetProxy: CloudSqlBackgroundProxy;
+    let sourcePort: number;
+    let targetPort: number;
+    let targetDbName: string;
+
+    const closeAll = () => {
+      sourceProxy?.stop();
+      targetProxy?.stop();
+    };
+
+    if (sourceEnv === "local") {
+      const parsersResult = parseConnectionString(
+        sourceEnvVars.DATABASE_URL.toString(),
+      );
+      sourcePort = parsersResult.hosts?.[0]?.port;
+      sourceUsername = parsersResult.username;
+      sourcePassword = parsersResult.password;
+      sourceDbName = parsersResult.endpoint;
+    } else {
+      sourcePort = 54399;
+      sourceProxy = await startCloudSqlProxyInBackground({
+        instanceName:
+          sourceEnvVars.CLOUD_SQL_INSTANCE_CONNECTION_NAME.toString(),
+        localPort: sourcePort,
+      });
+      sourceUsername = sourceEnvVars.DB_USER.toString();
+      sourcePassword = sourceEnvVars.DB_PASSWORD.toString();
+      sourceDbName = sourceEnvVars.DB_NAME?.toString();
+    }
+
+    const target = await ctx.get("target");
+
+    const [targetEnv, targetComponent] = target.split(":");
+    const targetContext = await getPipelineContextByChoice(
+      targetEnv,
+      targetComponent,
+    );
+    const targetEnvVars = await getEnvVarsResolved(
+      ctx,
+      targetContext.env,
+      targetContext.name,
+    );
+
+    if (targetEnv === "local") {
+      const parsersResult = parseConnectionString(
+        targetEnvVars.DATABASE_URL.toString(),
+      );
+      targetPort = parsersResult.hosts?.[0]?.port;
+      targetUsername = parsersResult.username;
+      targetPassword = parsersResult.password;
+      targetDbName = parsersResult.endpoint;
+    } else {
+      targetPort = 54499;
+      targetProxy = await startCloudSqlProxyInBackground({
+        instanceName:
+          targetEnvVars.CLOUD_SQL_INSTANCE_CONNECTION_NAME.toString(),
+        localPort: targetPort,
+      });
+      targetUsername = targetEnvVars.DB_USER.toString();
+      targetPassword = targetEnvVars.DB_PASSWORD.toString();
+      targetDbName = targetEnvVars.DB_NAME.toString();
+    }
+
+    const shouldContinue = await ctx.confirm(
+      `This will drop ${targetEnv}/${targetDbName} and replace it with ${sourceEnv}/${sourceDbName}. Continue? 🤔 `,
+    );
+    if (!shouldContinue) {
+      ctx.log("abort");
+      closeAll();
+      return;
+    }
+
+    if (targetContext.environment.envType === "prod") {
+      ctx.log(
+        `\n🚨 You are overriding a production environment. Please type in ${targetEnvVars.CLOUD_SQL_INSTANCE_CONNECTION_NAME} to continue\n\n`,
+      );
+      const confirmInstance = await ctx.get("confirmInstance");
+      if (
+        confirmInstance !== targetEnvVars.CLOUD_SQL_INSTANCE_CONNECTION_NAME
+      ) {
+        ctx.log("abort");
+        closeAll();
+        return;
+      }
+    }
+
+    try {
+      await spawnCopyDb({
+        targetPassword,
+        targetPort,
+        targetUsername,
+        sourceUsername,
+        sourcePassword,
+        sourcePort,
+        sourceDbName,
+        targetDbName,
+      });
+    } finally {
+      closeAll();
+    }
+  },
+});

package/src/commands/project/commandRenewToken.ts

@@ -0,0 +1,12 @@
+import { defineCommand } from "../../core/defineCommand";
+import { setupAccessTokens } from "../../apps/cli/commands/project/setup/setupAccessTokens";
+
+export const commandRenewToken = defineCommand({
+  name: "project renew-token",
+  description: "Configures the project access token for semantic release.",
+  group: "project",
+  inputs: {},
+  execute: async (ctx) => {
+    await setupAccessTokens(ctx);
+  },
+});

package/src/commands/project/commandSecretsClearBackups.ts

@@ -0,0 +1,19 @@
+import { defineCommand } from "../../core/defineCommand";
+import { clearBackups } from "../../utils/gitlab";
+
+export const commandSecretsClearBackups = defineCommand({
+  name: "project secrets-clear-backups",
+  description: "clears all backups",
+  group: "project",
+  inputs: {
+    keep: {
+      type: "number",
+      message: "How many backups should we keep? 🤔",
+      default: 1,
+    },
+  },
+  execute: async (ctx) => {
+    const keep = await ctx.get("keep");
+    await clearBackups(ctx, keep);
+  },
+});

package/src/commands/project/commandSecurityEvaluate.ts

@@ -0,0 +1,22 @@
+import { defineCommand } from "../../core/defineCommand";
+import {
+  evaluateSecurityAudit,
+  makeSecurityAuditOverview,
+} from "../../security/evaluateSecurityAudit";
+import { getGitRoot } from "../../utils/projects";
+
+export const commandSecurityEvaluate = defineCommand({
+  name: "project security-evaluate",
+  description: "evaluate project's security audit document",
+  group: "project",
+  inputs: {},
+  execute: async (ctx) => {
+    const gitRoot = await getGitRoot();
+    const result = await evaluateSecurityAudit({ path: gitRoot });
+    if (result.isErr()) {
+      ctx.log(`Could not evaluate security audit document: ${result.error}`);
+    } else {
+      ctx.log(makeSecurityAuditOverview(result.value));
+    }
+  },
+});

package/src/commands/project/commandSetup.ts

@@ -0,0 +1,21 @@
+import { defineCommand } from "../../core/defineCommand";
+import { setupProject } from "../../apps/cli/commands/project/setup";
+
+export const commandSetup = defineCommand({
+  name: "project setup",
+  description:
+    "Initializes all environments and creates required resources, service accounts, etc.",
+  group: "project",
+  inputs: {
+    component: {
+      type: "string",
+      message: "component name",
+      positional: true,
+      required: false,
+    },
+  },
+  execute: async (ctx) => {
+    const component = await ctx.get("component");
+    await setupProject(ctx, component);
+  },
+});

package/src/commands/project/k8s/commandDeletePods.ts

@@ -0,0 +1,55 @@
+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";
+import { hasDeployType } from "../../availability";
+
+export const commandDeletePods = defineCommand({
+  name: "project k8s delete-pods",
+  description: "delete / restart pods",
+  group: "project",
+  isAvailable: hasDeployType("kubernetes"),
+
+  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}'`);
+      }
+    }
+  },
+});

package/src/commands/project/k8s/commandDeleteProject.ts

@@ -0,0 +1,35 @@
+import { exec } from "child-process-promise";
+import { defineCommand } from "../../../core/defineCommand";
+import { getProjectNamespace } from "../../../utils/projects";
+import { envAndComponents } from "../../../apps/cli/commands/project/utils/autocompletions";
+import { hasDeployType } from "../../availability";
+
+export const commandDeleteProject = defineCommand({
+  name: "project k8s delete",
+  description: "deletes a environment of a project (it deletes the namespace)",
+  group: "project",
+  isAvailable: hasDeployType("kubernetes"),
+  inputs: {
+    envComponent: {
+      type: "string",
+      message: "environment:component",
+      positional: true,
+      choices: async () => envAndComponents(),
+    },
+  },
+  execute: async (ctx) => {
+    const envComponent = await ctx.get("envComponent");
+    const namespace = await getProjectNamespace(envComponent);
+    const shouldContinue = await ctx.confirm(
+      "This will delete the namespace. All data will be lost. Continue? 🤔 ",
+    );
+    if (!shouldContinue) {
+      return;
+    }
+    const fullCommand = `kubectl delete namespace ${namespace}`;
+    const { stdout } = await exec(fullCommand, {
+      env: { ...process.env, DEBUG: "" },
+    });
+    ctx.log(stdout);
+  },
+});

package/src/commands/project/k8s/commandGetShell.ts

@@ -0,0 +1,41 @@
+import { defineCommand } from "../../../core/defineCommand";
+import { getProjectPods } from "../../../kubernetes";
+
+import { getProjectNamespace } from "../../../utils/projects";
+import { getShell } from "../../../utils/shell";
+import { ensureCluster } from "../../../apps/cli/commands/project/utils/ensureCluster";
+import { envAndComponents } from "../../../apps/cli/commands/project/utils/autocompletions";
+import { hasDeployType } from "../../availability";
+
+export const commandGetShell = defineCommand({
+  name: "project k8s get-shell",
+  description: "get a shell to a pod in the environment",
+  group: "project",
+  isAvailable: hasDeployType("kubernetes"),
+  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 pods = await getProjectPods(envComponent);
+        return pods
+          .filter((p: any) => p.status.phase == "Running")
+          .map((r: any) => r.metadata.name);
+      },
+    },
+  },
+  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 getShell(namespace, podName);
+  },
+});

package/src/commands/project/k8s/commandListPods.ts

@@ -0,0 +1,32 @@
+import { stringify } from "yaml";
+import { pick } from "lodash-es";
+import { defineCommand } from "../../../core/defineCommand";
+import { getProjectPods } from "../../../kubernetes";
+import { ensureCluster } from "../../../apps/cli/commands/project/utils/ensureCluster";
+import { envAndComponents } from "../../../apps/cli/commands/project/utils/autocompletions";
+import { hasDeployType } from "../../availability";
+
+export const commandListPods = defineCommand({
+  name: "project k8s list-pods",
+  description: "list pods of local project",
+  group: "project",
+  isAvailable: hasDeployType("kubernetes"),
+  inputs: {
+    envComponent: {
+      type: "string",
+      message: "environment:component",
+      positional: true,
+      choices: async () => envAndComponents(),
+    },
+  },
+  execute: async (ctx) => {
+    const envComponent = await ctx.get("envComponent");
+    await ensureCluster(ctx, envComponent);
+    const pods = await getProjectPods(envComponent);
+    ctx.log(
+      stringify(
+        pods.map((p: any) => pick(p, ["metadata.name", "status.startTime"])),
+      ),
+    );
+  },
+});

package/src/commands/project/k8s/commandNamespace.ts

@@ -0,0 +1,23 @@
+import { defineCommand } from "../../../core/defineCommand";
+import { getProjectNamespace } from "../../../utils/projects";
+import { envAndComponents } from "../../../apps/cli/commands/project/utils/autocompletions";
+import { hasDeployType } from "../../availability";
+
+export const commandNamespace = defineCommand({
+  name: "project k8s namespace",
+  description: "show namespace of local project",
+  group: "project",
+  isAvailable: hasDeployType("kubernetes"),
+  inputs: {
+    envComponent: {
+      type: "string",
+      message: "environment:component",
+      positional: true,
+      choices: async () => envAndComponents(),
+    },
+  },
+  execute: async (ctx) => {
+    const envComponent = await ctx.get("envComponent");
+    ctx.log(await getProjectNamespace(envComponent));
+  },
+});

package/src/commands/project/k8s/commandPauseProject.ts

@@ -0,0 +1,35 @@
+import { exec } from "child-process-promise";
+import { defineCommand } from "../../../core/defineCommand";
+import { getProjectNamespace } from "../../../utils/projects";
+import { envAndComponents } from "../../../apps/cli/commands/project/utils/autocompletions";
+import { hasDeployType } from "../../availability";
+
+export const commandPauseProject = defineCommand({
+  name: "project k8s pause",
+  description: "halts all running pods (scales to 0)",
+  group: "project",
+  isAvailable: hasDeployType("kubernetes"),
+  inputs: {
+    envComponent: {
+      type: "string",
+      message: "environment:component",
+      positional: true,
+      choices: async () => envAndComponents(),
+    },
+  },
+  execute: async (ctx) => {
+    const envComponent = await ctx.get("envComponent");
+    const namespace = await getProjectNamespace(envComponent);
+    const shouldContinue = await ctx.confirm(
+      "This will STOP all running pods. You will need to manually scale back up or re-deploy. Continue? 🤔 ",
+    );
+    if (!shouldContinue) {
+      return;
+    }
+    const fullCommand = `kubectl scale statefulset,deployment --all --replicas=0 --namespace=${namespace}`;
+    const { stdout } = await exec(fullCommand, {
+      env: { ...process.env, DEBUG: "" },
+    });
+    ctx.log(stdout);
+  },
+});