@catladder/cli 3.48.0 → 4.0.1

package/package.json

@@ -53,7 +53,7 @@
     }
   ],
   "license": "MIT",
-  "version": "3.48.0",
+  "version": "4.0.1",
   "scripts": {
     "lint": "eslint \"src/**/*.ts\"",
     "lint:fix": "eslint \"src/**/*.ts\" --fix",
@@ -66,7 +66,6 @@
     "build:watch": "tsc-watch --onSuccess \"yarn dev:own-catenv\""
   },
   "bin": {
-    "catci": "./bin/catci",
     "catenv": "./bin/catenv",
     "catladder": "./bin/catladder"
   },
@@ -80,6 +79,7 @@
     "@babel/core": "^7.29.0",
     "@babel/plugin-syntax-typescript": "^7.28.6",
     "@gitbeaker/rest": "^39.28.0",
+    "@inquirer/prompts": "^8.4.3",
     "@kubernetes/client-node": "^0.16.2",
     "@tsconfig/node14": "^1.0.1",
     "@types/common-tags": "^1.8.4",
@@ -90,13 +90,13 @@
     "@types/request": "^2.48.12",
     "@types/tmp": "^0.2.3",
     "@types/update-notifier": "^2.5.0",
-    "@types/vorpal": "^1.12.0",
     "@types/websocket": "^0.0.40",
     "@types/yargs": "^17.0.33",
     "babel-plugin-transform-inline-environment-variables": "^0.4.4",
     "child-process-promise": "^2.2.1",
     "clipboardy": "^2.0.0",
     "command-exists-promise": "^2.0.2",
+    "commander": "^14.0.3",
     "common-tags": "^1.8.2",
     "connection-string-parser": "^1.0.4",
     "date-fns": "^3.6.0",
@@ -111,7 +111,6 @@
     "tsc-alias": "^1.8.16",
     "tsc-watch": "^7.2.0",
     "typescript": "^5.4.5",
-    "vorpal": "^1.12.0",
     "yaml": "^2.5.0"
   },
   "dependencies": {

package/scripts/bundle

@@ -2,5 +2,3 @@
 ncc build dist/cli/src/catenv.js -o dist/bundles/catenv -e 'tsx/cjs/api' $( ((SHOULD_MINIFY == 1)) && printf %s '-m')
 
 ncc build dist/cli/src/cli.js -o dist/bundles/cli -e 'tsx/cjs/api' $( ((SHOULD_MINIFY == 1)) && printf %s '-m')
-
-ncc build dist/cli/src/catci.js -o dist/bundles/catci -e 'tsx/cjs/api' $( ((SHOULD_MINIFY == 1)) && printf %s '-m')

package/src/adapters/baseContext.ts

@@ -0,0 +1,68 @@
+import type {
+  CommandContext,
+  CommandDef,
+  InputDef,
+  InputResultType,
+  InputsSchema,
+  OptionalInput,
+} from "../core/types";
+
+/**
+ * Base class for CommandContext implementations.
+ * Handles caching, the `get()` method, and `promptDirect` delegation.
+ * Subclasses only implement the adapter-specific resolution logic.
+ */
+export abstract class BaseContext<TInputs extends InputsSchema>
+  implements CommandContext<TInputs>
+{
+  private cache = new Map<string, Promise<any>>();
+
+  constructor(protected readonly command: CommandDef<TInputs>) {}
+
+  abstract log(message: string): void;
+  abstract confirm(message: string): Promise<boolean>;
+
+  /**
+   * Resolve a single input value. Called once per input (result is cached).
+   * Implementations check pre-supplied values, prompt interactively, use defaults, or throw.
+   */
+  protected abstract resolveInput<P extends InputDef>(
+    name: string,
+    spec: P,
+  ): Promise<InputResultType<P>>;
+
+  get<K extends keyof TInputs & string>(
+    name: K,
+  ): Promise<OptionalInput<TInputs[K]>> {
+    if (!this.cache.has(name)) {
+      const spec = this.command.inputs[name];
+      if (!spec) {
+        return Promise.reject(
+          new Error(
+            `Input "${name}" is not declared in command "${this.command.name}"`,
+          ),
+        );
+      }
+      // For optional inputs (required: false), catch MissingInputError
+      // and return undefined instead of prompting
+      if (spec.required === false) {
+        this.cache.set(
+          name,
+          this.resolveInput(name, spec).catch((err) => {
+            if (err?.name === "MissingInputError") return undefined;
+            throw err;
+          }),
+        );
+      } else {
+        this.cache.set(name, this.resolveInput(name, spec));
+      }
+    }
+    return this.cache.get(name)!;
+  }
+
+  async promptDirect<P extends InputDef>(
+    spec: P & { name: string },
+  ): Promise<InputResultType<P>> {
+    return this.resolveInput(spec.name, spec);
+  }
+}

package/src/adapters/programmatic.ts

@@ -0,0 +1,88 @@
+import type {
+  CommandDef,
+  IO,
+  InputDef,
+  InputResultType,
+  InputsSchema,
+} from "../core/types";
+import { MissingInputError } from "../core/types";
+import { BaseContext } from "./baseContext";
+
+export interface ProgrammaticOptions {
+  /** Pre-supplied values keyed by input name */
+  inputs?: Record<string, unknown>;
+  /** Called on every log message. Defaults to no-op. */
+  onLog?: (message: string) => void;
+}
+
+class ProgrammaticContext<
+  TInputs extends InputsSchema,
+> extends BaseContext<TInputs> {
+  private inputs: Record<string, unknown>;
+  private onLog?: (message: string) => void;
+
+  constructor(command: CommandDef<TInputs>, options: ProgrammaticOptions) {
+    super(command);
+    this.inputs = options.inputs ?? {};
+    this.onLog = options.onLog;
+  }
+
+  log(message: string): void {
+    this.onLog?.(message);
+  }
+
+  async confirm(): Promise<boolean> {
+    return true; // programmatic mode always confirms
+  }
+
+  protected async resolveInput<P extends InputDef>(
+    name: string,
+    spec: P,
+  ): Promise<InputResultType<P>> {
+    if (name in this.inputs && this.inputs[name] !== undefined) {
+      return this.inputs[name] as InputResultType<P>;
+    }
+    if ("default" in spec && spec.default !== undefined) {
+      return spec.default as InputResultType<P>;
+    }
+    throw new MissingInputError(name, spec.message);
+  }
+}
+
+/**
+ * Create a CommandContext that resolves inputs from pre-supplied values.
+ * Used for non-interactive CLI mode and programmatic invocation.
+ */
+export function createProgrammaticContext<TInputs extends InputsSchema>(
+  command: CommandDef<TInputs>,
+  options: ProgrammaticOptions = {},
+): ProgrammaticContext<TInputs> {
+  return new ProgrammaticContext(command, options);
+}
+
+/**
+ * Create a bare IO instance for helper functions that only need log + promptDirect.
+ */
+export function createProgrammaticIO(options: ProgrammaticOptions = {}): IO {
+  const { inputs = {}, onLog } = options;
+
+  return {
+    log(message: string): void {
+      onLog?.(message);
+    },
+    async confirm(): Promise<boolean> {
+      return true;
+    },
+    async promptDirect<P extends InputDef>(
+      spec: P & { name: string },
+    ): Promise<InputResultType<P>> {
+      if (spec.name in inputs && inputs[spec.name] !== undefined) {
+        return inputs[spec.name] as InputResultType<P>;
+      }
+      if ("default" in spec && spec.default !== undefined) {
+        return spec.default as InputResultType<P>;
+      }
+      throw new MissingInputError(spec.name, spec.message);
+    },
+  };
+}

package/src/adapters/terminal.ts

@@ -0,0 +1,207 @@
+import type {
+  CommandDef,
+  IO,
+  InputDef,
+  InputResultType,
+  InputsSchema,
+  PromptChoice,
+} from "../core/types";
+import { MissingInputError } from "../core/types";
+import { BaseContext } from "./baseContext";
+
+/**
+ * Resolve choices from a choices function.
+ */
+async function resolveChoices(
+  choices: (ctx: any) => PromptChoice[] | Promise<PromptChoice[]>,
+  ctx: any,
+): Promise<{ name: string; value: string }[]> {
+  const raw = await choices(ctx);
+  return raw.map((c) => (typeof c === "string" ? { name: c, value: c } : c));
+}
+
+/**
+ * Prompt the user interactively using @inquirer/prompts.
+ * The UI is determined by the value type + presence of choices.
+ */
+async function promptInteractive<P extends InputDef>(
+  spec: P & { name: string },
+  ctx: any,
+): Promise<InputResultType<P>> {
+  const inquirer = await import("@inquirer/prompts");
+
+  switch (spec.type) {
+    case "string": {
+      if (spec.choices) {
+        const choices = await resolveChoices(spec.choices, ctx);
+        return inquirer.select({
+          message: spec.message,
+          choices,
+        }) as Promise<InputResultType<P>>;
+      }
+      return inquirer.input({
+        message: spec.message,
+        default: spec.default,
+      }) as Promise<InputResultType<P>>;
+    }
+    case "string[]": {
+      if (spec.choices) {
+        const choices = await resolveChoices(spec.choices, ctx);
+        return inquirer.checkbox({
+          message: spec.message,
+          choices,
+        }) as Promise<InputResultType<P>>;
+      }
+      const raw = await inquirer.input({ message: spec.message });
+      return (
+        raw ? raw.split(",").map((s: string) => s.trim()) : []
+      ) as InputResultType<P>;
+    }
+    case "number":
+      return inquirer.number({
+        message: spec.message,
+        default: spec.default,
+      }) as Promise<InputResultType<P>>;
+    case "boolean":
+      return inquirer.confirm({
+        message: spec.message,
+        default: spec.default,
+      }) as Promise<InputResultType<P>>;
+    default:
+      throw new Error(`Unsupported input type: ${(spec as InputDef).type}`);
+  }
+}
+
+export interface TerminalOptions {
+  /** Pre-supplied values from CLI flags/positional args, keyed by input name */
+  cliOptions?: Record<string, unknown>;
+  /** Pre-supplied values from --inputs JSON flag */
+  jsonInputs?: Record<string, unknown>;
+  /** Whether interactive prompts are allowed (default: auto-detect from TTY) */
+  interactive?: boolean;
+  /** If true, all confirm() calls return true without prompting (--yes flag) */
+  yes?: boolean;
+}
+
+class TerminalContext<
+  TInputs extends InputsSchema,
+> extends BaseContext<TInputs> {
+  constructor(
+    command: CommandDef<TInputs>,
+    private options: TerminalOptions,
+  ) {
+    super(command);
+  }
+
+  log(message: string): void {
+    console.log(message);
+  }
+
+  async confirm(message: string): Promise<boolean> {
+    if (this.options.yes) return true;
+    const isInteractive =
+      this.options.interactive ?? process.stdin.isTTY === true;
+    if (!isInteractive) return true;
+    const inquirer = await import("@inquirer/prompts");
+    return inquirer.confirm({ message });
+  }
+
+  protected async resolveInput<P extends InputDef>(
+    name: string,
+    spec: P,
+  ): Promise<InputResultType<P>> {
+    const { cliOptions = {}, jsonInputs = {}, interactive } = this.options;
+    const isInteractive = interactive ?? process.stdin.isTTY === true;
+
+    // Helper: validate a pre-supplied value against choices if they exist
+    const validateAgainstChoices = async (value: unknown): Promise<void> => {
+      if (!("choices" in spec) || !spec.choices) return;
+      const choices = await resolveChoices(spec.choices, this);
+      const validValues = choices.map((c) => c.value);
+      if (Array.isArray(value)) {
+        const invalid = (value as string[]).filter(
+          (v) => !validValues.includes(v),
+        );
+        if (invalid.length > 0) {
+          throw new Error(
+            `Invalid value(s) for "${name}": ${invalid.join(", ")}. Valid choices: ${validValues.join(", ")}`,
+          );
+        }
+      } else if (!validValues.includes(value as string)) {
+        throw new Error(
+          `Invalid value for "${name}": "${value}". Valid choices: ${validValues.join(", ")}`,
+        );
+      }
+    };
+
+    // 1. CLI flag or positional arg
+    if (name in cliOptions && cliOptions[name] !== undefined) {
+      await validateAgainstChoices(cliOptions[name]);
+      return cliOptions[name] as InputResultType<P>;
+    }
+
+    // 2. JSON inputs
+    if (name in jsonInputs && jsonInputs[name] !== undefined) {
+      await validateAgainstChoices(jsonInputs[name]);
+      return jsonInputs[name] as InputResultType<P>;
+    }
+
+    // 3. Default (check before prompting, so optional inputs with defaults don't prompt)
+    if ("default" in spec && spec.default !== undefined) {
+      return spec.default as InputResultType<P>;
+    }
+
+    // 4. Optional inputs: don't prompt, throw so baseContext returns undefined
+    if (spec.required === false) {
+      throw new MissingInputError(name, spec.message);
+    }
+
+    // 5. Interactive prompt
+    if (isInteractive) {
+      return promptInteractive({ ...spec, name }, this);
+    }
+
+    // 6. Throw
+    throw new MissingInputError(name, spec.message);
+  }
+}
+
+/**
+ * Create a CommandContext for terminal usage.
+ */
+export function createTerminalContext<TInputs extends InputsSchema>(
+  command: CommandDef<TInputs>,
+  options: TerminalOptions = {},
+): TerminalContext<TInputs> {
+  return new TerminalContext(command, options);
+}
+
+/**
+ * Create a bare IO instance for terminal helper functions.
+ */
+export function createTerminalIO(options: TerminalOptions = {}): IO {
+  return {
+    log(message: string): void {
+      console.log(message);
+    },
+    async confirm(message: string): Promise<boolean> {
+      if (options.yes) return true;
+      const isInteractive = options.interactive ?? process.stdin.isTTY === true;
+      if (!isInteractive) return true;
+      const inquirer = await import("@inquirer/prompts");
+      return inquirer.confirm({ message });
+    },
+    async promptDirect<P extends InputDef>(
+      spec: P & { name: string },
+    ): Promise<InputResultType<P>> {
+      const isInteractive = options.interactive ?? process.stdin.isTTY === true;
+      if (isInteractive) {
+        return promptInteractive(spec, null);
+      }
+      if ("default" in spec && spec.default !== undefined) {
+        return spec.default as InputResultType<P>;
+      }
+      throw new MissingInputError(spec.name, spec.message);
+    },
+  };
+}

package/src/apps/catenv/catenv.ts

@@ -11,6 +11,7 @@ import {
 
 type Options = {
   verbose?: boolean;
+  printVariables?: boolean;
 };
 export default async (choice?: Choice, options?: Options) => {
   const config = await getProjectConfig();
@@ -28,7 +29,8 @@ export default async (choice?: Choice, options?: Options) => {
     writeDotEnvFiles(context, choice),
 
     writeDTsFiles(context, choice),
-
-    printVariables(context, choice),
+    options?.printVariables
+      ? printVariables(context, choice)
+      : Promise.resolve(),
   ]);
 };

package/src/apps/catenv/printVariables.ts

@@ -14,10 +14,6 @@ const getAllVariablesToPrint = async (config: Config, choice?: Choice) => {
   );
 
   if (currentComponent) {
-    // don't print vars if dotenv is enabled
-    if (config.components[currentComponent].dotEnv ?? true) {
-      return {};
-    }
     return await getEnvVarsResolved(null, env, currentComponent);
   } else {
     // when in a monorep and not in a subapp, merge all env vars.
@@ -25,10 +21,6 @@ const getAllVariablesToPrint = async (config: Config, choice?: Choice) => {
     // so we also add prefixed variants
     return await Object.keys(config.components).reduce(
       async (acc, componentName) => {
-        // don't print vars if dotenv is enabled
-        if (config.components[componentName].dotEnv ?? true) {
-          return await acc;
-        }
         const subappvars = await getEnvVarsResolved(null, env, componentName);
         delete subappvars["_ALL_ENV_VAR_KEYS"];
         return {

package/src/apps/cli/commands/project/commandConfigSecrets.ts

@@ -1,8 +1,7 @@
 import { getSecretVarName } from "@catladder/pipeline";
 import { stripIndents } from "common-tags";
 import { difference } from "lodash";
-import type { CommandInstance } from "vorpal";
-import type Vorpal from "vorpal";
+import type { IO } from "../../../../core/types";
 import {
   getAllComponentsWithAllEnvsHierarchical,
   getEnvironment,
@@ -14,7 +13,6 @@ import {
 import { editAsFile } from "../../../../utils/editAsFile";
 import { upsertAllVariables } from "../../../../utils/gitlab";
 import { delay } from "../../../../utils/promise";
-import { allEnvsAndAllComponents } from "./utils/autocompletions";
 
 type Vars = {
   [env: string]: {
@@ -62,7 +60,7 @@ const getSecretEnvVarKeysToConfigure = async (
     .map((k) => k.key);
 };
 const getEnvVarsToEdit = async (
-  instance: CommandInstance,
+  instance: IO,
   env: string,
   componentName: string,
 ) => {
@@ -92,7 +90,7 @@ const getEnvVarsToEdit = async (
   );
 };
 const doItFor = async (
-  instance: CommandInstance,
+  instance: IO,
   envAndComponents: {
     [componentName: string]: string[];
   },
@@ -161,12 +159,7 @@ const doItFor = async (
           }
 
           await delay(1000);
-          const { shouldContinue } = await instance.prompt({
-            default: true,
-            message: "Try again? 🤔",
-            name: "shouldContinue",
-            type: "confirm",
-          });
+          const shouldContinue = await instance.confirm("Try again? 🤔");
 
           if (!shouldContinue) {
             throw new Error("abort");
@@ -197,40 +190,22 @@ const doItFor = async (
   instance.log("");
 };
 
-export const projectConfigSecrets = async (
-  vorpal: CommandInstance,
-  envComponent?: string,
-) => {
+export const projectConfigSecrets = async (io: IO, envComponent?: string) => {
   if (!envComponent) {
     const allEnvAndcomponents = await getAllComponentsWithAllEnvsHierarchical();
-    await doItFor(vorpal, allEnvAndcomponents);
+    await doItFor(io, allEnvAndcomponents);
   } else {
     const { env, componentName } = parseChoice(envComponent);
 
     // componentName can be null. in this case, iterate over all  components
     if (!componentName) {
       const components = await getProjectComponents();
-      await doItFor(
-        vorpal,
-        Object.fromEntries(components.map((c) => [c, [env]])),
-      );
+      await doItFor(io, Object.fromEntries(components.map((c) => [c, [env]])));
     }
     if (componentName) {
-      await doItFor(vorpal, {
+      await doItFor(io, {
         [componentName]: [env],
       });
     }
   }
 };
-
-export default async (vorpal: Vorpal) => {
-  vorpal
-    .command(
-      "project-config-secrets [envComponent]",
-      "setup/update secrets stored in pass",
-    )
-    .autocomplete(await allEnvsAndAllComponents())
-    .action(async function ({ envComponent }) {
-      return await projectConfigSecrets(this, envComponent);
-    });
-};

package/src/apps/cli/commands/project/setup/index.ts

@@ -1,4 +1,4 @@
-import type { CommandInstance } from "vorpal";
+import type { IO } from "../../../../../core/types";
 import { getAllPipelineContexts } from "../../../../../config/getProjectConfig";
 import { setupAccessTokens } from "./setupAccessTokens";
 import { setupContext } from "./setupContext";
@@ -7,7 +7,7 @@ import { setupAgents } from "./setupAgents";
 import { logSection } from "./logSection";
 
 export const setupProject = async (
-  instance: CommandInstance,
+  instance: IO,
   onlyComponents?: string | string[],
 ) => {
   const allContext = await getAllPipelineContexts(onlyComponents);

package/src/apps/cli/commands/project/setup/logSection.ts

@@ -1,7 +1,7 @@
-import type { CommandInstance } from "vorpal";
+import type { IO } from "../../../../../core/types";
 
 export const logSection = async (
-  instance: CommandInstance,
+  instance: IO,
   title: string,
   work: () => Promise<void>,
 ) => {

package/src/apps/cli/commands/project/setup/setupAccessTokens.ts

@@ -1,10 +1,10 @@
-import type { CommandInstance } from "vorpal";
+import type { IO } from "../../../../../core/types";
 import { add, format } from "date-fns";
 import { doGitlabRequest, getProjectInfo } from "../../../../../utils/gitlab";
 
 const TOKEN_NAME = "semantic-release";
 
-export const setupAccessTokens = async (instance: CommandInstance) => {
+export const setupAccessTokens = async (instance: IO) => {
   const { id: projectId } = await getProjectInfo(instance);
 
   const projectTokens = await doGitlabRequest(

package/src/apps/cli/commands/project/setup/setupAgents.ts

@@ -1,4 +1,4 @@
-import type { CommandInstance } from "vorpal";
+import type { IO } from "../../../../../core/types";
 import { doGitlabRequest, getProjectInfo } from "../../../../../utils/gitlab";
 import { getProjectConfig } from "../../../../../config/getProjectConfig";
 import { getGitRemoteHostAndPath } from "../../../../../git/gitProjectInformation";
@@ -60,14 +60,14 @@ type WebhookData = {
 };
 
 const listTriggerTokens = async (
-  instance: CommandInstance,
+  instance: IO,
   projectId: string,
 ): Promise<TriggerToken[]> => {
   return await doGitlabRequest(instance, `projects/${projectId}/triggers`);
 };
 
 const deleteTriggerToken = async (
-  instance: CommandInstance,
+  instance: IO,
   projectId: string,
   triggerId: number,
 ): Promise<void> => {
@@ -80,7 +80,7 @@ const deleteTriggerToken = async (
 };
 
 const createTriggerToken = async (
-  instance: CommandInstance,
+  instance: IO,
   projectId: string,
   description: string,
 ): Promise<TriggerToken> => {
@@ -93,14 +93,14 @@ const createTriggerToken = async (
 };
 
 const listWebhooks = async (
-  instance: CommandInstance,
+  instance: IO,
   projectId: string,
 ): Promise<Webhook[]> => {
   return await doGitlabRequest(instance, `projects/${projectId}/hooks`);
 };
 
 const createWebhook = async (
-  instance: CommandInstance,
+  instance: IO,
   projectId: string,
   webhookData: WebhookData,
 ): Promise<Webhook> => {
@@ -113,7 +113,7 @@ const createWebhook = async (
 };
 
 const updateWebhook = async (
-  instance: CommandInstance,
+  instance: IO,
   projectId: string,
   hookId: number,
   webhookData: WebhookData,
@@ -127,7 +127,7 @@ const updateWebhook = async (
 };
 
 const setupAgentWebhook = async (
-  instance: CommandInstance,
+  instance: IO,
   projectId: string,
   agentName: string,
   triggerToken: string,
@@ -231,7 +231,7 @@ const setupAgentWebhook = async (
 };
 
 const setupAgentTriggerToken = async (
-  instance: CommandInstance,
+  instance: IO,
   projectId: string,
   agentName: string,
 ): Promise<TriggerToken> => {
@@ -266,7 +266,7 @@ const setupAgentTriggerToken = async (
 };
 
 const setupAgent = async (
-  instance: CommandInstance,
+  instance: IO,
   agentName: string,
   agentConfig: AgentConfig,
 ) => {
@@ -287,7 +287,7 @@ const setupAgent = async (
   instance.log(`✅ Agent ${agentName} setup complete!`);
 };
 
-export const setupAgents = async (instance: CommandInstance) => {
+export const setupAgents = async (instance: IO) => {
   const config = await getProjectConfig();
 
   instance.log("");