@catladder/cli 3.48.0 → 4.0.1

package/src/commands/project/commandTriggerCronjob.ts

@@ -0,0 +1,99 @@
+import type { V1ObjectMeta } from "@kubernetes/client-node";
+import { V1Job } from "@kubernetes/client-node";
+import { defineCommand } from "../../core/defineCommand";
+import { getk8sApiBatch, getk8sApiBatchBeta } from "../../k8sApi";
+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";
+
+const getCronjobChoices = async (namespace: string) => {
+  const {
+    body: { items: jobs },
+  } = await getk8sApiBatchBeta().listNamespacedCronJob(namespace);
+  return jobs.map((j: any) => j.metadata.name) as string[];
+};
+
+const runCronjob = async (
+  io: { log: (msg: string) => void },
+  namespace: string,
+  jobName: string,
+) => {
+  const {
+    body: { items: jobs },
+  } = await getk8sApiBatchBeta().listNamespacedCronJob(namespace);
+
+  const cronjob = jobs.find((j: any) => j.metadata.name === jobName);
+  const jobSpec = (cronjob as any).spec.jobTemplate.spec;
+
+  const job = new V1Job();
+  const metadata: Partial<V1ObjectMeta> = {
+    name: `manual-${Math.round(Date.now() / 1000)}-${(cronjob as any).metadata.name}`,
+  };
+
+  job.metadata = metadata as V1ObjectMeta;
+  job.spec = jobSpec;
+  try {
+    const result = await getk8sApiBatch().createNamespacedJob(namespace, job);
+    io.log("");
+    io.log(
+      `yeah, you got a job, man. 😺 ${(result as any).body.metadata.name}`,
+    );
+    io.log("");
+  } catch (e: any) {
+    logError(io, "command failed", e.body);
+  }
+};
+
+export const commandTriggerCronjobGeneral = defineCommand({
+  name: "kube trigger-cronjob",
+  description: "trigger cronjob",
+  group: "general",
+  inputs: {
+    namespace: {
+      type: "string",
+      message: "kubernetes namespace",
+      positional: true,
+    },
+    jobName: {
+      type: "string",
+      message: "Which cronjob? 🤔",
+      choices: async (ctx) => getCronjobChoices(await ctx.get("namespace")),
+    },
+  },
+  execute: async (ctx) => {
+    const namespace = await ctx.get("namespace");
+    const jobName = await ctx.get("jobName");
+    await runCronjob(ctx, namespace, jobName);
+  },
+});
+
+export const commandTriggerCronjobProject = defineCommand({
+  name: "project trigger-cronjob",
+  description: "trigger cronjob",
+  group: "project",
+  inputs: {
+    envComponent: {
+      type: "string",
+      message: "environment:component",
+      positional: true,
+      choices: async () => envAndComponents(),
+    },
+    jobName: {
+      type: "string",
+      message: "Which cronjob? 🤔",
+      choices: async (ctx) => {
+        const envComponent = await ctx.get("envComponent");
+        const namespace = await getProjectNamespace(envComponent);
+        return getCronjobChoices(namespace);
+      },
+    },
+  },
+  execute: async (ctx) => {
+    const envComponent = await ctx.get("envComponent");
+    await ensureCluster(ctx, envComponent);
+    const namespace = await getProjectNamespace(envComponent);
+    const jobName = await ctx.get("jobName");
+    await runCronjob(ctx, namespace, jobName);
+  },
+});

package/src/commands/security/commandSecurityAuditCiJob.ts

@@ -0,0 +1,91 @@
+import { defineCommand } from "../../core/defineCommand";
+import { Gitlab } from "@gitbeaker/rest";
+import {
+  evaluateSecurityAudit,
+  makeSecurityAuditOverview,
+} from "../../security/evaluateSecurityAudit";
+import {
+  createSecurityAuditMergeRequest,
+  SECURITY_AUDIT_FILE_NAME,
+} from "../../security/createSecurityAuditMergeRequest";
+
+const GITLAB_HOST = "https://git.panter.ch";
+
+export const commandSecurityAuditCiJob = defineCommand({
+  name: "security audit ci-job",
+  description:
+    "Evaluates security audit document. Creates MR with template if missing.",
+  group: "security",
+  inputs: {
+    path: { type: "string", message: "path to project root", positional: true },
+    token: {
+      type: "string",
+      message: "GitLab token (api scope)",
+      positional: true,
+    },
+    mainBranch: {
+      type: "string",
+      message: "main branch name",
+      positional: true,
+    },
+    projectId: {
+      type: "string",
+      message: "GitLab project ID",
+      positional: true,
+    },
+    userId: {
+      type: "string",
+      message: "GitLab user ID (assignee)",
+      positional: true,
+    },
+  },
+  execute: async (ctx) => {
+    const path = await ctx.get("path");
+    const evaluation = await evaluateSecurityAudit({ path });
+
+    if (evaluation.isErr()) {
+      ctx.log("could not evaluate security audit document");
+      ctx.log("creating new merge request with security audit template...");
+
+      const token = await ctx.get("token");
+      const mainBranch = await ctx.get("mainBranch");
+      const projectId = await ctx.get("projectId");
+      const userId = await ctx.get("userId");
+
+      const api = new Gitlab({ host: GITLAB_HOST, token });
+
+      const mr = await createSecurityAuditMergeRequest({
+        api,
+        mainBranch,
+        projectId,
+        userId: parseInt(userId),
+      });
+
+      if (mr.isErr()) {
+        ctx.log(
+          `could not create merge request with security audit template: ${mr.error}`,
+        );
+        process.exitCode = 1;
+        return;
+      }
+
+      ctx.log("security audit merge request created successfully");
+      ctx.log(
+        `please finish the MR by updating SECURITY.md document: ${mr.value.web_url}`,
+      );
+      process.exitCode = 1;
+      return;
+    }
+
+    if (evaluation.value.score.answeredTopics === 0) {
+      ctx.log("audit document has no answered topics");
+      ctx.log(
+        `please answer security topics in ${SECURITY_AUDIT_FILE_NAME} by adding responsible people and check/cross in the table`,
+      );
+      process.exitCode = 1;
+      return;
+    }
+
+    ctx.log(makeSecurityAuditOverview(evaluation.value));
+  },
+});

package/src/commands/security/commandSecurityAuditCreate.ts

@@ -0,0 +1,58 @@
+import { defineCommand } from "../../core/defineCommand";
+import { Gitlab } from "@gitbeaker/rest";
+import { createSecurityAuditMergeRequest } from "../../security/createSecurityAuditMergeRequest";
+
+const GITLAB_HOST = "https://git.panter.ch";
+
+export const commandSecurityAuditCreate = defineCommand({
+  name: "security audit create",
+  description: "Creates a MR with the latest security audit template document",
+  group: "security",
+  inputs: {
+    token: {
+      type: "string",
+      message: "GitLab token (api scope)",
+      positional: true,
+    },
+    mainBranch: {
+      type: "string",
+      message: "main branch name",
+      positional: true,
+    },
+    projectId: {
+      type: "string",
+      message: "GitLab project ID",
+      positional: true,
+    },
+    userId: {
+      type: "string",
+      message: "GitLab user ID (assignee)",
+      positional: true,
+    },
+  },
+  execute: async (ctx) => {
+    const token = await ctx.get("token");
+    const mainBranch = await ctx.get("mainBranch");
+    const projectId = await ctx.get("projectId");
+    const userId = await ctx.get("userId");
+
+    const api = new Gitlab({ host: GITLAB_HOST, token });
+
+    const result = await createSecurityAuditMergeRequest({
+      api,
+      mainBranch,
+      projectId,
+      userId: parseInt(userId),
+    });
+
+    if (result.isErr()) {
+      ctx.log(`could not create security audit merge request: ${result.error}`);
+      process.exitCode = 1;
+    } else {
+      ctx.log("security audit merge request created successfully");
+      ctx.log(
+        `please finish the MR by updating SECURITY.md document: ${result.value.web_url}`,
+      );
+    }
+  },
+});

package/src/commands/security/commandSecurityAuditEvaluate.ts

@@ -0,0 +1,30 @@
+import { defineCommand } from "../../core/defineCommand";
+import {
+  evaluateSecurityAudit,
+  makeSecurityAuditOverview,
+} from "../../security/evaluateSecurityAudit";
+import { SECURITY_AUDIT_FILE_NAME } from "../../security/createSecurityAuditMergeRequest";
+
+export const commandSecurityAuditEvaluate = defineCommand({
+  name: "security audit evaluate",
+  description: "Evaluates security audit document in given path",
+  group: "security",
+  inputs: {
+    path: { type: "string", message: "path to project root", positional: true },
+  },
+  execute: async (ctx) => {
+    const path = await ctx.get("path");
+    ctx.log("evaluating security audit document...");
+
+    const result = await evaluateSecurityAudit({ path });
+    if (result.isErr()) {
+      ctx.log(`${result.error}`);
+      ctx.log(
+        `please make sure the security audit document ${SECURITY_AUDIT_FILE_NAME} is in the repository`,
+      );
+      process.exitCode = 1;
+    } else {
+      ctx.log(makeSecurityAuditOverview(result.value));
+    }
+  },
+});

package/src/completion.ts

@@ -0,0 +1,272 @@
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import type { CommandDef, InputDef } from "./core/types";
+
+/**
+ * Generate completions for the current command line.
+ *
+ * @param allCommands - All registered command definitions
+ * @param words - The words typed so far (argv without the binary name)
+ * @param cursorWord - The word currently being completed (may be empty)
+ * @returns Array of completion strings
+ */
+export async function getCompletions(
+  allCommands: CommandDef[],
+  words: string[],
+  cursorWord: string,
+): Promise<string[]> {
+  // Try to find a command by matching the longest prefix of words.
+  // E.g., for words ["project", "cloudsql", "restore-db", "--source"],
+  // we match "project cloudsql restore-db" and treat ["--source"] as args.
+  const matched = findCommand(allCommands, words);
+
+  if (matched) {
+    const { command, argsAfterCommand } = matched;
+
+    // Check if cursor is a --flag name
+    if (cursorWord.startsWith("--")) {
+      return getFlagCompletions(command, cursorWord);
+    }
+
+    // Check if previous word was a --flag (complete its value)
+    const prevWord = argsAfterCommand[argsAfterCommand.length - 1];
+    if (prevWord?.startsWith("--")) {
+      const flagName = prevWord.replace(/^--/, "");
+      const inputName = flagNameToInputName(flagName);
+      const inputDef = command.inputs[inputName];
+      if (inputDef && "choices" in inputDef && inputDef.choices) {
+        return resolveChoicesForCompletion(inputDef, cursorWord);
+      }
+      return [];
+    }
+
+    // Complete positional inputs
+    const positionalInputs = getPositionalInputs(command);
+    const positionalArgs = argsAfterCommand.filter((w) => !w.startsWith("--"));
+    const positionalIndex = positionalArgs.length;
+    const targetInput = positionalInputs[positionalIndex];
+
+    if (targetInput) {
+      const [, inputDef] = targetInput;
+      if ("choices" in inputDef && inputDef.choices) {
+        return resolveChoicesForCompletion(inputDef, cursorWord);
+      }
+    }
+    return [];
+  }
+
+  // No command matched. Complete subcommand names at the current level.
+  const typed = words.join(" ");
+  const prefix = typed ? typed + " " : "";
+
+  const nextParts = new Set<string>();
+  for (const cmd of allCommands) {
+    if (cmd.name.startsWith(prefix)) {
+      const rest = cmd.name.slice(prefix.length);
+      const nextPart = rest.split(" ")[0];
+      if (nextPart && nextPart.startsWith(cursorWord)) {
+        nextParts.add(nextPart);
+      }
+    }
+  }
+
+  return [...nextParts].sort();
+}
+
+/**
+ * Find a command by matching the longest prefix of words against command names.
+ * Returns the matched command and the remaining words (args/flags after the command name).
+ */
+function findCommand(
+  allCommands: CommandDef[],
+  words: string[],
+): { command: CommandDef; argsAfterCommand: string[] } | null {
+  // Try longest match first
+  for (let i = words.length; i >= 1; i--) {
+    const candidate = words.slice(0, i).join(" ");
+    const command = allCommands.find((c) => c.name === candidate);
+    if (command) {
+      return { command, argsAfterCommand: words.slice(i) };
+    }
+  }
+  return null;
+}
+
+function getPositionalInputs(command: CommandDef): [string, InputDef][] {
+  return Object.entries(command.inputs).filter(([, def]) => def.positional);
+}
+
+function getFlagCompletions(command: CommandDef, cursorWord: string): string[] {
+  const flags: string[] = [];
+  for (const [name, inputDef] of Object.entries(command.inputs)) {
+    if (inputDef.positional) continue;
+    const flagName = `--${name.replace(/([A-Z])/g, "-$1").toLowerCase()}`;
+    flags.push(flagName);
+  }
+  flags.push("--inputs");
+  flags.push("--yes");
+  return flags.filter((f) => f.startsWith(cursorWord));
+}
+
+function flagNameToInputName(flagName: string): string {
+  return flagName.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+
+async function resolveChoicesForCompletion(
+  inputDef: InputDef,
+  cursorWord: string,
+): Promise<string[]> {
+  if (!("choices" in inputDef) || !inputDef.choices) return [];
+  try {
+    // Create a minimal ctx that returns empty for any get() call.
+    // This works for choices functions that don't depend on other inputs
+    // (like envAndComponents). For dependent choices, completion won't work
+    // but that's acceptable -- those are typically non-positional.
+    const noopCtx = {
+      get: () => Promise.reject(new Error("not available during completion")),
+      log: () => {},
+      confirm: () => Promise.resolve(true),
+      promptDirect: () =>
+        Promise.reject(new Error("not available during completion")),
+    };
+    const choices = await inputDef.choices(noopCtx);
+    return choices
+      .map((c) => (typeof c === "string" ? c : c.value))
+      .filter((v) => v.startsWith(cursorWord));
+  } catch {
+    // If choices function fails (e.g., needs other inputs), return nothing
+    return [];
+  }
+}
+
+/**
+ * Generate the zsh completion script.
+ * The script discovers the local catladder binary at completion time,
+ * so it works without a global install.
+ */
+export function generateZshCompletionScript(): string {
+  return `
+###-begin-catladder-completions-###
+# Find catladder binary by walking up from cwd
+_catladder_find_binary() {
+  local dir="$PWD"
+  while [[ "$dir" != "/" ]]; do
+    if [[ -x "$dir/node_modules/.bin/catladder" ]]; then
+      echo "$dir/node_modules/.bin/catladder"
+      return
+    fi
+    # Also check for catladder-dev (monorepo development)
+    if [[ -x "$dir/cli/bin/catladder-dev" ]]; then
+      echo "$dir/cli/bin/catladder-dev"
+      return
+    fi
+    dir="\${dir:h}"
+  done
+  # Fall back to global
+  if command -v catladder &>/dev/null; then
+    echo "catladder"
+  elif command -v catladder-dev &>/dev/null; then
+    echo "catladder-dev"
+  fi
+}
+
+# Run completion with given offset (number of words to skip before CLI args)
+_catladder_do_complete() {
+  local skip=$1
+  local catladder_bin=$(_catladder_find_binary)
+  [[ -z "$catladder_bin" ]] && return
+
+  local -a completions
+  local current_word="\${words[$CURRENT]}"
+  local -a cmd_words=(\${words:$skip:$((CURRENT-skip-1))})
+
+  completions=(\${(f)"$($catladder_bin __complete -- "\${cmd_words[*]}" "$current_word" 2>/dev/null)"})
+
+  if [[ \${#completions[@]} -gt 0 ]]; then
+    compadd -a completions
+  fi
+}
+
+# catladder <TAB>
+_catladder_completions() { _catladder_do_complete 1; }
+
+# yarn catladder <TAB>
+_yarn_catladder_completions() {
+  [[ $CURRENT -le 2 || "\${words[2]}" != "catladder" ]] && return
+  _catladder_do_complete 2
+}
+
+compdef _catladder_completions catladder
+compdef _catladder_completions catladder-dev
+compdef _yarn_catladder_completions yarn
+###-end-catladder-completions-###
+`.trim();
+}
+
+const BEGIN_MARKER = "###-begin-catladder-completions-###";
+const END_MARKER = "###-end-catladder-completions-###";
+
+function getZshrcPath(): string {
+  return join(homedir(), ".zshrc");
+}
+
+/**
+ * Install completions by writing the script directly into .zshrc.
+ */
+export async function installCompletions(): Promise<void> {
+  const zshrcPath = getZshrcPath();
+
+  let content = "";
+  if (existsSync(zshrcPath)) {
+    content = readFileSync(zshrcPath, "utf-8");
+  }
+
+  if (content.includes(BEGIN_MARKER)) {
+    // Replace existing
+    const startIdx = content.indexOf(BEGIN_MARKER);
+    const endIdx = content.indexOf(END_MARKER) + END_MARKER.length;
+    content =
+      content.slice(0, startIdx) +
+      generateZshCompletionScript() +
+      content.slice(endIdx);
+    writeFileSync(zshrcPath, content);
+    console.log(`Updated catladder completions in ${zshrcPath}`);
+  } else {
+    writeFileSync(
+      zshrcPath,
+      content + "\n" + generateZshCompletionScript() + "\n",
+    );
+    console.log(`Installed catladder completions in ${zshrcPath}`);
+  }
+  console.log(`Restart your shell or run: source ${zshrcPath}`);
+}
+
+/**
+ * Remove completions from .zshrc.
+ */
+export async function uninstallCompletions(): Promise<void> {
+  const zshrcPath = getZshrcPath();
+  if (!existsSync(zshrcPath)) {
+    console.log("No .zshrc found");
+    return;
+  }
+
+  const content = readFileSync(zshrcPath, "utf-8");
+
+  if (!content.includes(BEGIN_MARKER)) {
+    console.log("No catladder completions found in " + zshrcPath);
+    return;
+  }
+
+  const startIdx = content.indexOf(BEGIN_MARKER);
+  const endIdx = content.indexOf(END_MARKER) + END_MARKER.length;
+  const cleaned = (content.slice(0, startIdx) + content.slice(endIdx)).replace(
+    /\n{3,}/g,
+    "\n\n",
+  );
+
+  writeFileSync(zshrcPath, cleaned);
+  console.log(`Removed catladder completions from ${zshrcPath}`);
+  console.log(`Restart your shell or run: source ${zshrcPath}`);
+}

package/src/config/getProjectConfig.ts

@@ -11,7 +11,7 @@ import {
   getSecretVarName,
 } from "@catladder/pipeline";
 
-import type { CommandInstance } from "vorpal";
+import type { IO } from "../core/types";
 import { getAllVariables, getVariableValueByRawName } from "../utils/gitlab";
 
 import { getGitRoot } from "../utils/projects";
@@ -121,20 +121,20 @@ export const getEnvironment = async (env: string, componentName: string) => {
 };
 
 export const getGitlabVar = async (
-  vorpal: CommandInstance,
+  io: IO,
   env: string,
   componentName: string,
   variableName: string,
 ) => {
   const rawVariableName = getSecretVarName(env, componentName, variableName);
-  return await getVariableValueByRawName(vorpal, rawVariableName);
+  return await getVariableValueByRawName(io, rawVariableName);
 };
 
 const resolveSecrets = async (
-  vorpal: CommandInstance | null,
+  io: IO | null,
   varSets: EnvironmentEnvVars[],
 ): Promise<Record<string, string>> => {
-  const allVariablesInGitlab = await getAllVariables(vorpal);
+  const allVariablesInGitlab = await getAllVariables(io);
 
   return Object.fromEntries(
     varSets.flatMap(({ envVars, secretEnvVarKeys }) =>
@@ -158,7 +158,7 @@ const resolveSecrets = async (
 };
 
 export const getEnvVarsResolved = async (
-  vorpal: CommandInstance | null,
+  io: IO | null,
   env: string,
   componentName: string | null,
 ) => {
@@ -170,7 +170,7 @@ export const getEnvVarsResolved = async (
 
   // in the pipeline the secrets alreadyy exists  and bash will expand them
   // but here we need to manually load them
-  return resolveSecrets(vorpal, [
+  return resolveSecrets(io, [
     {
       envVars: envionment.envVars,
       secretEnvVarKeys: envionment.secretEnvVarKeys,
@@ -183,12 +183,12 @@ export const getEnvVarsResolved = async (
  * is used to get job only vars that should also be editable locally with catladder.
  */
 export const getJobOnlyEnvVarsResolved = async (
-  vorpal: CommandInstance,
+  io: IO,
   env: string,
   componentName: string,
 ) => {
   const envionment = await getEnvironment(env, componentName);
-  return resolveSecrets(vorpal, [
+  return resolveSecrets(io, [
     envionment.jobOnlyVars.build,
     envionment.jobOnlyVars.deploy,
   ]);

package/src/core/defineCommand.ts

@@ -0,0 +1,32 @@
+import type { CommandDef, InputDef } from "./types";
+
+/**
+ * Type-safe builder for command definitions.
+ * Infers TInputs from the definition object so that
+ * `ctx.get("...")` is fully typed.
+ *
+ * @example
+ * ```ts
+ * export const myCommand = defineCommand({
+ *   name: "my-command",
+ *   description: "Does something",
+ *   inputs: {
+ *     envComponent: { type: "string", message: "env:component", positional: true },
+ *     podName: { type: "string", message: "Which pod?", choices: async () => ["a", "b"] },
+ *     mr: { type: "number", message: "Which MR?" },
+ *     confirmed: { type: "boolean", message: "Continue?" },
+ *   },
+ *   execute: async (ctx) => {
+ *     const env = await ctx.get("envComponent");  // string
+ *     const pod = await ctx.get("podName");        // string
+ *     const mr = await ctx.get("mr");              // number
+ *     const ok = await ctx.get("confirmed");       // boolean
+ *   },
+ * });
+ * ```
+ */
+export function defineCommand<const TInputs extends Record<string, InputDef>>(
+  def: CommandDef<TInputs>,
+): CommandDef<TInputs> {
+  return def;
+}

package/src/core/index.ts

@@ -0,0 +1,23 @@
+export type {
+  CommandContext,
+  CommandDef,
+  IO,
+  InputDef,
+  InputResultType,
+  InputsSchema,
+  StringInputDef,
+  StringArrayInputDef,
+  NumberInputDef,
+  BooleanInputDef,
+  PromptChoice,
+  ChoicesFn,
+} from "./types";
+export { MissingInputError } from "./types";
+export { defineCommand } from "./defineCommand";
+export {
+  registerCommand,
+  getCommand,
+  getAllCommands,
+  getCommandsByGroup,
+} from "./registry";
+export { runCommand } from "./runner";

package/src/core/registry.ts

@@ -0,0 +1,22 @@
+import type { CommandDef } from "./types";
+
+const commands: Map<string, CommandDef> = new Map();
+
+export function registerCommand(def: CommandDef): void {
+  if (commands.has(def.name)) {
+    throw new Error(`Command "${def.name}" is already registered`);
+  }
+  commands.set(def.name, def);
+}
+
+export function getCommand(name: string): CommandDef | undefined {
+  return commands.get(name);
+}
+
+export function getAllCommands(): CommandDef[] {
+  return Array.from(commands.values());
+}
+
+export function getCommandsByGroup(group: string): CommandDef[] {
+  return getAllCommands().filter((c) => c.group === group);
+}