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

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: "k8s 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,51 @@
+// 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 { commandEnvVars } from "./project/commandEnvVars";
+export { commandPortForward } from "./project/commandPortForward";
+export { commandOpenEnv } from "./project/commandOpenEnv";
+export { commandOpenGit } from "./project/commandOpenGit";
+export { commandCloudSqlProxy } from "./project/commandCloudSqlProxy";
+export { commandConfigSecrets } from "./project/commandConfigSecrets";
+export { commandSecretsClearBackups } from "./project/commandSecretsClearBackups";
+export { commandOpenLogs } from "./project/commandOpenLogs";
+export { commandTriggerCronjobGeneral } from "./project/k8s/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";
+
+// Project k8s commands
+export { commandNamespace } from "./project/k8s/commandNamespace";
+export { commandListPods } from "./project/k8s/commandListPods";
+export { commandGetShell } from "./project/k8s/commandGetShell";
+export { commandDeletePods } from "./project/k8s/commandDeletePods";
+export { commandPauseProject } from "./project/k8s/commandPauseProject";
+export { commandDeleteProject } from "./project/k8s/commandDeleteProject";
+export { commandTriggerCronjobProject } from "./project/k8s/commandTriggerCronjob";
+
+// MongoDB commands
+export { commandMongoGetShell } from "./mongodb/commandMongoGetShell";
+export { commandMongoPortForward } from "./mongodb/commandMongoPortForward";
+export { commandMongoDestroyMember } from "./mongodb/commandMongoDestroyMember";
+
+// CloudSQL commands
+export { commandRestoreDb } from "./cloudSQL/commandRestoreDb";
+
+// Security commands
+export { commandSecurityAuditCiJob } from "./security/commandSecurityAuditCiJob";
+export { commandSecurityAuditEvaluate } from "./security/commandSecurityAuditEvaluate";
+export { commandSecurityAuditCreate } from "./security/commandSecurityAuditCreate";
+
+// Fun commands
+export { commandDadjoke } from "./fun/commandDadjoke";
+export { commandStarwars } from "./fun/commandStarwars";

package/src/commands/mongodb/commandMongoDestroyMember.ts

@@ -0,0 +1,135 @@
+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";
+import { hasDeployType } from "../availability";
+
+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",
+  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 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,38 @@
+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";
+import { hasDeployType } from "../availability";
+
+export const commandMongoGetShell = defineCommand({
+  name: "project mongo get-shell",
+  description: "get a shell to a mongodb in the environment",
+  group: "mongodb",
+  isAvailable: hasDeployType("kubernetes"),
+  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,58 @@
+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";
+import { hasDeployType } from "../availability";
+
+export const commandMongoPortForward = defineCommand({
+  name: "project mongo port-forward",
+  description: "port forward to a mongodb",
+  group: "mongodb",
+  isAvailable: hasDeployType("kubernetes"),
+  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,191 @@
+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";
+import { hasCloudSql } from "../availability";
+
+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 cloudsql proxy",
+  description: "proxy to cloud sql db",
+  group: "project",
+  isAvailable: hasCloudSql(),
+  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,31 @@
+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,
+      required: false,
+      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/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 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/commandGitlabCi.ts

@@ -0,0 +1,122 @@
+import { exec } from "child-process-promise";
+import { last } from "lodash-es";
+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);
+      }
+    }
+  },
+});