@akanjs/devkit 3.0.0-beta.9 → 3.0.0

package/commandDecorators/commandBuilder.ts

@@ -2,6 +2,7 @@ import type {
   App,
   ArgMeta,
   ArgsOption,
+  ArgType,
   CommandContext,
   Exec,
   InternalArgMeta,
@@ -13,9 +14,14 @@ import type {
   Sys,
 } from "./argMeta";
 import { normalizePrimitiveArgType } from "./argMeta";
-import { assertUniqueDependencies, type DependencyInstanceMap, injectDependencies } from "./dependencyBuilder";
+import {
+  assertUniqueDependencies,
+  type DependencyCls,
+  type DependencyInstanceMap,
+  type DependencyKey,
+  injectDependencies,
+} from "./dependencyBuilder";
 import { COMMAND_META, type CommandCls, type TargetMeta, type TargetOption } from "./targetMeta";
-import type { DependencyCls, DependencyKey } from "./types";
 
 type PrimitiveValue<T extends PrimitiveArgType> = T extends StringConstructor
   ? string
@@ -23,11 +29,7 @@ type PrimitiveValue<T extends PrimitiveArgType> = T extends StringConstructor
     ? number
     : boolean;
 type MaybeNullable<Value, Option> = Option extends { nullable: true } ? Value | null : Value;
-/**
- * The literal union a static `enum` declares, or `never` for a `DynamicEnum` — a function does not extend
- * a readonly array, so a runtime-resolved choice list falls back to the primitive type. `{ label, value }`
- * choices contribute their `value`.
- */
+// A DynamicEnum yields never (a function is no readonly array), so ArgValue falls back to the primitive type.
 type EnumValue<Option> = Option extends { enum: infer Choices }
   ? Choices extends readonly (infer Choice)[]
     ? Choice extends { value: infer Value }
@@ -73,6 +75,14 @@ type CommandHandler<Deps extends readonly DependencyCls[], Params extends unknow
   ...args: Params
 ) => unknown | Promise<unknown>;
 
+const argMetaOf = (
+  type: ArgType,
+  name: string,
+  primitive: PrimitiveArgType,
+  argsOption: object | undefined,
+  idx: number,
+): ArgMeta => ({ name, argsOption: { ...argsOption, type: normalizePrimitiveArgType(primitive) }, key: "", idx, type });
+
 class TargetBuilder<Deps extends readonly DependencyCls[], Params extends unknown[] = [], Context = object> {
   readonly #args: (ArgMeta | InternalArgMeta)[];
 
@@ -83,56 +93,29 @@ class TargetBuilder<Deps extends readonly DependencyCls[], Params extends unknow
     this.#args = args;
   }
 
+  #add<NextParams extends unknown[], NextContext = Context>(...argMetas: (ArgMeta | InternalArgMeta)[]) {
+    return new TargetBuilder<Deps, NextParams, NextContext>(this.targetOption, [...this.#args, ...argMetas]);
+  }
+
   arg<Type extends PrimitiveArgType, const Option extends ArgsOption<Context> = ArgsOption<Context>>(
     name: string,
     type: Type,
     argsOption: Option = {} as Option,
-  ): TargetBuilder<Deps, AddArg<Params, Type, Option>, Context> {
-    return new TargetBuilder<Deps, AddArg<Params, Type, Option>, Context>(this.targetOption, [
-      ...this.#args,
-      {
-        name,
-        argsOption: { ...argsOption, type: normalizePrimitiveArgType(type) },
-        key: "",
-        idx: this.#args.length,
-        type: "Argument",
-      } as ArgMeta<CommandContext>,
-    ]);
+  ) {
+    return this.#add<AddArg<Params, Type, Option>>(argMetaOf("Argument", name, type, argsOption, this.#args.length));
   }
 
   option<Type extends PrimitiveArgType, const Option extends ArgsOption<Context> = ArgsOption<Context>>(
     name: string,
     type: Type,
     argsOption: Option = {} as Option,
-  ): TargetBuilder<Deps, AddArg<Params, Type, Option>, Context> {
-    return new TargetBuilder<Deps, AddArg<Params, Type, Option>, Context>(this.targetOption, [
-      ...this.#args,
-      {
-        name,
-        argsOption: { ...argsOption, type: normalizePrimitiveArgType(type) },
-        key: "",
-        idx: this.#args.length,
-        type: "Option",
-      } as ArgMeta<CommandContext>,
-    ]);
+  ) {
+    return this.#add<AddArg<Params, Type, Option>>(argMetaOf("Option", name, type, argsOption, this.#args.length));
   }
 
-  with<const Tokens extends readonly InternalArgToken[]>(
-    ...tokens: Tokens
-  ): TargetBuilder<Deps, AddInternalArgs<Params, Tokens>, AddInternalContext<Context, Tokens>> {
-    return new TargetBuilder<Deps, AddInternalArgs<Params, Tokens>, AddInternalContext<Context, Tokens>>(
-      this.targetOption,
-      [
-        ...this.#args,
-        ...tokens.map(
-          (token, offset) =>
-            ({
-              key: "",
-              idx: this.#args.length + offset,
-              type: token.type,
-            }) satisfies InternalArgMeta,
-        ),
-      ],
+  with<const Tokens extends readonly InternalArgToken[]>(...tokens: Tokens) {
+    return this.#add<AddInternalArgs<Params, Tokens>, AddInternalContext<Context, Tokens>>(
+      ...tokens.map((token, offset) => ({ key: "", idx: this.#args.length + offset, type: token.type })),
     );
   }
 
@@ -174,22 +157,8 @@ const createContext = <Deps extends readonly DependencyCls[]>(): CommandBuilderC
   public: createTarget<Deps>("public"),
   cloud: createTarget<Deps>("cloud"),
   dev: createTarget<Deps>("dev"),
-  arg: (name, type, argsOption) =>
-    ({
-      name,
-      argsOption: { ...(argsOption ?? {}), type: normalizePrimitiveArgType(type) },
-      key: "",
-      idx: -1,
-      type: "Argument",
-    }) as ArgMeta<CommandContext>,
-  option: (name, type, argsOption) =>
-    ({
-      name,
-      argsOption: { ...(argsOption ?? {}), type: normalizePrimitiveArgType(type) },
-      key: "",
-      idx: -1,
-      type: "Option",
-    }) as ArgMeta<CommandContext>,
+  arg: (name, type, argsOption) => argMetaOf("Argument", name, type, argsOption, -1),
+  option: (name, type, argsOption) => argMetaOf("Option", name, type, argsOption, -1),
 });
 
 const buildCommandMeta = (definitions: Record<string, TargetDefinition>) => {

package/commandDecorators/commandDecorators.test.ts

@@ -125,7 +125,7 @@ describe("command helper metadata", () => {
 
     const commandHelp = stripAnsi(formatCommandHelp(HelpCommand, "buildApp"));
     expect(commandHelp).toContain("akan build-app [app]");
-    expect(commandHelp).toContain("--write");
+    expect(commandHelp).toContain("--write, --no-write");
     expect(commandHelp).toContain("[default: true]");
     expect(commandHelp).toContain("Fast, Full");
   });
@@ -243,8 +243,6 @@ describe("enum arg choices", () => {
     expect(await getOptionValue(optionMeta(["text", "json"]), { format: "json" }, context)).toBe("json");
   });
 
-  // Before this check `akan quality --format yaml` reached the script as "yaml" while the declaration
-  // claimed the parameter was "text" | "json".
   test("rejects an undeclared value in commander's wording", async () => {
     await expect(getOptionValue(optionMeta(["text", "json"]), { format: "yaml" }, context)).rejects.toThrow(
       "option '--format' argument 'yaml' is invalid. Allowed choices are text, json.",
@@ -269,8 +267,6 @@ describe("enum arg choices", () => {
     await expect(getOptionValue(labelled, { format: "JSON output" }, context)).rejects.toThrow("is invalid");
   });
 
-  // A DynamicEnum resolves against a context that is not populated yet, and the interactive select is its
-  // only consumer, so an explicit value passes through unchecked rather than being rejected wrongly.
   test("leaves a dynamic choice list unchecked", async () => {
     expect(
       await getOptionValue(
@@ -291,11 +287,7 @@ describe("enum arg type inference", () => {
     CommandContainer.clear();
   });
 
-  /**
-   * Compile-time only. Nothing here can fail at runtime: if `enum` stops narrowing, the parameter widens
-   * to the primitive and these calls stop typechecking, so the regression surfaces in `akan typecheck`
-   * rather than in fifteen `as "a" | "b"` casts creeping back into the command files.
-   */
+  //? Compile-time only: if `enum` stops narrowing, the parameter widens and these calls stop typechecking.
   const expectLiteral = <Expected>(_value: Expected) => undefined;
 
   test("a static enum narrows the exec parameter to its declared choices", () => {

package/commandDecorators/dependencyBuilder.ts

@@ -1,4 +1,13 @@
-import type { DependencyCls, DependencyKey, DependencyKind } from "./types";
+export type Cls<T = unknown> = new (...args: unknown[]) => T;
+
+export type DependencyKind = "command" | "script" | "runner";
+export type DependencyKey<RefName extends string, Kind extends DependencyKind> = `${RefName}${Capitalize<Kind>}`;
+
+export type DependencyCls<T = unknown, Key extends string = string> = (new () => T) & {
+  readonly dependencyKey: Key;
+  readonly dependencyKind: DependencyKind;
+  readonly refName: string;
+};
 
 type UnionToIntersection<Union> = (Union extends unknown ? (value: Union) => void : never) extends (
   value: infer Intersection,

package/commandDecorators/helpFormatter.ts

@@ -1,191 +1,119 @@
 import chalk from "chalk";
 
 import { type EnumChoice, getArgMetas } from "./argMeta";
+import { camelToKebabCase } from "./camelToKebabCase";
 import { type CommandCls, getTargetMetas } from "./targetMeta";
 
-const camelToKebabCase = (str: string) => str.replace(/([A-Z])/g, "-$1").toLowerCase();
 const formatChoice = (choice: EnumChoice) => (typeof choice === "object" ? choice.label : choice.toString());
 
 const groupCommands = (commands: CommandCls[]) => {
-  const groups = new Map<string, { name: string; commands: { key: string; args: string[]; desc?: string }[] }>();
-
+  const groups = new Map<string, { key: string; args: string[]; desc?: string }[]>();
   for (const command of commands) {
-    const className = command.name.replace("Command", "");
-    const groupName = className;
-
-    if (!groups.has(groupName)) {
-      groups.set(groupName, { name: groupName, commands: [] });
-    }
-
-    const targetMetas = getTargetMetas(command);
-    for (const targetMeta of targetMetas) {
-      // Skip devOnly commands in help
+    const group = groups.getOrInsert(command.name.replace("Command", ""), []);
+    for (const targetMeta of getTargetMetas(command)) {
       if (targetMeta.targetOption.devOnly) continue;
-
       const [allArgMetas] = getArgMetas(command, targetMeta.key);
       const args = allArgMetas
         .filter((arg) => arg.type !== "Option")
         .map((arg) => {
           if (arg.type === "Workspace") return "";
           if (arg.type === "Module") return "[sys:module]";
-          if (arg.type === "Argument") {
-            return `[${arg.name}]`;
-          }
+          if (arg.type === "Argument") return `[${arg.name}]`;
           return `[${arg.type.toLowerCase()}]`;
         })
         .filter(Boolean);
-
-      const group = groups.get(groupName);
-      if (group) {
-        group.commands.push({
-          key: camelToKebabCase(targetMeta.key),
-          args,
-          desc: targetMeta.targetOption.desc,
-        });
-      }
+      group.push({ key: camelToKebabCase(targetMeta.key), args, desc: targetMeta.targetOption.desc });
     }
   }
-
   return groups;
 };
 
 export const formatHelp = (commands: CommandCls[], version: string) => {
-  const groups = groupCommands(commands);
-  const lines: string[] = [];
-
-  // Header
-  lines.push("");
-  lines.push(chalk.bold.cyan("  ╔═══════════════════════════════════════════════════╗"));
-  lines.push(
+  const lines = [
+    "",
+    chalk.bold.cyan("  ╔═══════════════════════════════════════════════════╗"),
     chalk.bold.cyan("  ║") +
       chalk.bold.white("              Akan.js Framework CLI            ") +
       chalk.bold.cyan("    ║"),
-  );
-  lines.push(chalk.bold.cyan("  ╚═══════════════════════════════════════════════════╝"));
-  lines.push("");
-  lines.push(chalk.gray(`  Version: ${version}`));
-  lines.push("");
-
-  // Usage
-  lines.push(chalk.bold.yellow("  USAGE"));
-  lines.push("");
-  lines.push(chalk.gray("    $ ") + chalk.white("akan") + chalk.gray(" <command> [options]"));
-  lines.push("");
-
-  // Commands by category
-  lines.push(chalk.bold.yellow("  COMMANDS"));
-  lines.push("");
-
-  for (const [groupName, group] of groups) {
-    // Skip empty groups (all commands are devOnly)
-    if (group.commands.length === 0) continue;
-
-    lines.push(chalk.bold.magenta(`    ${groupName}`));
-    lines.push("");
-
-    for (const cmd of group.commands) {
-      const cmdName = chalk.green(cmd.key);
-      const cmdArgs = cmd.args.length > 0 ? chalk.gray(` ${cmd.args.join(" ")}`) : "";
-
-      // Format description: wrap if too long
-      if (cmd.desc) {
-        const maxLineLength = 70;
-        const cmdPrefix = `      ${cmdName}${cmdArgs}`;
-        const indent = "        ";
-
-        if (cmdPrefix.length + cmd.desc.length + 3 < maxLineLength) {
-          // Single line
-          lines.push(`${cmdPrefix}  ${chalk.gray(cmd.desc)}`);
-        } else {
-          // Multi-line
-          lines.push(cmdPrefix);
-          lines.push(`${indent}${chalk.gray(cmd.desc)}`);
-        }
-      } else {
-        lines.push(`      ${cmdName}${cmdArgs}`);
-      }
+    chalk.bold.cyan("  ╚═══════════════════════════════════════════════════╝"),
+    "",
+    chalk.gray(`  Version: ${version}`),
+    "",
+    chalk.bold.yellow("  USAGE"),
+    "",
+    chalk.gray("    $ ") + chalk.white("akan") + chalk.gray(" <command> [options]"),
+    "",
+    chalk.bold.yellow("  COMMANDS"),
+    "",
+  ];
+  for (const [groupName, cmds] of groupCommands(commands)) {
+    if (cmds.length === 0) continue;
+    lines.push(chalk.bold.magenta(`    ${groupName}`), "");
+    for (const cmd of cmds) {
+      const cmdPrefix = `      ${chalk.green(cmd.key)}${cmd.args.length > 0 ? chalk.gray(` ${cmd.args.join(" ")}`) : ""}`;
+      if (!cmd.desc) lines.push(cmdPrefix);
+      else if (cmdPrefix.length + cmd.desc.length + 3 < 70) lines.push(`${cmdPrefix}  ${chalk.gray(cmd.desc)}`);
+      else lines.push(cmdPrefix, `        ${chalk.gray(cmd.desc)}`);
     }
     lines.push("");
   }
-
-  // Global Options
-  lines.push(chalk.bold.yellow("  OPTIONS"));
-  lines.push("");
-  lines.push(`      ${chalk.green("-v, --verbose")}      ${chalk.gray("Enable verbose output")}`);
-  lines.push(`      ${chalk.green("-h, --help")}         ${chalk.gray("Display this help message")}`);
-  lines.push(`      ${chalk.green("-V, --version")}      ${chalk.gray("Output version number")}`);
-  lines.push("");
-
-  // Examples
-  lines.push(chalk.bold.yellow("  EXAMPLES"));
-  lines.push("");
-  lines.push(chalk.gray("    # Create a new workspace"));
-  lines.push(chalk.white("    $ akan create-workspace myproject"));
-  lines.push("");
-  lines.push(chalk.gray("    # Start development server"));
-  lines.push(chalk.white("    $ akan start myapp"));
-  lines.push("");
-  lines.push(chalk.gray("    # Create a new module"));
-  lines.push(chalk.white("    $ akan create-module userProfile"));
-  lines.push("");
-
-  // Footer
-  lines.push(chalk.gray("  Documentation: ") + chalk.cyan("https://akanjs.com/docs"));
-  lines.push(chalk.gray("  Report issues: ") + chalk.cyan("https://github.com/akan-team/akanjs/issues"));
-  lines.push("");
-
+  lines.push(
+    chalk.bold.yellow("  OPTIONS"),
+    "",
+    `      ${chalk.green("-v, --verbose")}      ${chalk.gray("Enable verbose output")}`,
+    `      ${chalk.green("-h, --help")}         ${chalk.gray("Display this help message")}`,
+    `      ${chalk.green("-V, --version")}      ${chalk.gray("Output version number")}`,
+    "",
+    chalk.bold.yellow("  EXAMPLES"),
+    "",
+    chalk.gray("    # Create a new workspace"),
+    chalk.white("    $ akan create-workspace myproject"),
+    "",
+    chalk.gray("    # Start development server"),
+    chalk.white("    $ akan start myapp"),
+    "",
+    chalk.gray("    # Create a new module"),
+    chalk.white("    $ akan create-module userProfile"),
+    "",
+    chalk.gray("  Documentation: ") + chalk.cyan("https://akanjs.com/docs"),
+    chalk.gray("  Report issues: ") + chalk.cyan("https://github.com/akan-team/akanjs/issues"),
+    "",
+  );
   return lines.join("\n");
 };
 
 export const formatCommandHelp = (command: CommandCls, key: string) => {
-  const [allArgMetas, argMetas] = getArgMetas(command, key);
+  const [allArgMetas, optionArgs] = getArgMetas(command, key);
   const kebabKey = camelToKebabCase(key);
-  const lines: string[] = [];
-
-  const targetMetas = getTargetMetas(command);
-  const targetMeta = targetMetas.find((t) => t.key === key);
-  const commandDesc = targetMeta?.targetOption.desc;
-
-  lines.push("");
-  lines.push(chalk.bold.cyan(`  Command: ${kebabKey}`));
-  if (commandDesc) {
-    lines.push(chalk.gray(`  ${commandDesc}`));
-  }
-  lines.push("");
-
-  // Usage
-  const args = allArgMetas
-    .filter((arg) => arg.type !== "Option")
+  const commandDesc = getTargetMetas(command).find((t) => t.key === key)?.targetOption.desc;
+  const nonOptionArgs = allArgMetas.filter((arg) => arg.type !== "Option");
+  const args = nonOptionArgs
     .map((arg) => {
       if (arg.type === "Workspace") return "";
       if (arg.type === "Module") return "[sys:module]";
       if (arg.type === "Apps") return "[apps...]";
-      if (arg.type === "Argument") {
-        return `[${camelToKebabCase(arg.name)}]`;
-      }
+      if (arg.type === "Argument") return `[${camelToKebabCase(arg.name)}]`;
       return `[${arg.type.toLowerCase()}]`;
     })
     .filter(Boolean)
     .join(" ");
 
-  lines.push(chalk.bold.yellow("  USAGE"));
-  lines.push("");
-  lines.push(chalk.gray("    $ ") + chalk.white(`akan ${kebabKey}`) + (args ? chalk.gray(` ${args}`) : ""));
-  lines.push("");
-
-  // Arguments
-  const nonOptionArgs = allArgMetas.filter((arg) => arg.type !== "Option");
+  const lines = ["", chalk.bold.cyan(`  Command: ${kebabKey}`)];
+  if (commandDesc) lines.push(chalk.gray(`  ${commandDesc}`));
+  lines.push(
+    "",
+    chalk.bold.yellow("  USAGE"),
+    "",
+    chalk.gray("    $ ") + chalk.white(`akan ${kebabKey}`) + (args ? chalk.gray(` ${args}`) : ""),
+    "",
+  );
   if (nonOptionArgs.length > 0) {
-    lines.push(chalk.bold.yellow("  ARGUMENTS"));
-    lines.push("");
-
+    lines.push(chalk.bold.yellow("  ARGUMENTS"), "");
     for (const arg of nonOptionArgs) {
       if (arg.type === "Workspace") continue;
-
       let argName: string;
       let argDesc: string;
       let example = "";
-
       if (arg.type === "Argument") {
         argName = camelToKebabCase(arg.name);
         argDesc = arg.argsOption.desc ?? "";
@@ -200,24 +128,19 @@ export const formatCommandHelp = (command: CommandCls, key: string) => {
         argName = arg.type.toLowerCase();
         argDesc = `${arg.type} name in this workspace`;
       }
-
       lines.push(`      ${chalk.green(argName)}      ${chalk.gray(argDesc)}${example}`);
     }
-
     lines.push("");
   }
 
-  // Options
-  const optionArgs = argMetas.filter((a) => a.type === "Option");
   if (optionArgs.length > 0) {
-    lines.push(chalk.bold.yellow("  OPTIONS"));
-    lines.push("");
-
+    lines.push(chalk.bold.yellow("  OPTIONS"), "");
     for (const arg of optionArgs) {
       const opt = arg.argsOption;
       const flag = opt.flag ? `-${opt.flag}, ` : "";
       const kebabName = camelToKebabCase(arg.name);
-      const optName = `${flag}--${kebabName}`;
+      const negation = opt.type === "boolean" && opt.default === true ? `, --no-${kebabName}` : "";
+      const optName = `${flag}--${kebabName}${negation}`;
       const optDesc = opt.desc ?? "";
       const defaultVal = opt.default !== undefined ? chalk.gray(` [default: ${String(opt.default)}]`) : "";
       const choices = opt.enum

package/commandDecorators/index.ts

@@ -1,8 +1,6 @@
 export * from "./argMeta";
 export * from "./command";
 export * from "./commandBuilder";
-export * from "./commandMeta";
 export * from "./dependencyBuilder";
 export * from "./helpFormatter";
 export * from "./targetMeta";
-export * from "./types";

package/commandDecorators/targetMeta.ts

@@ -1,5 +1,6 @@
 import type { ArgMeta, InternalArgMeta } from "./argMeta";
-import type { DependencyCls } from "./types";
+import { camelToKebabCase } from "./camelToKebabCase";
+import type { Cls, DependencyCls } from "./dependencyBuilder";
 
 export const COMMAND_META: unique symbol = Symbol("akan.command.meta");
 
@@ -22,12 +23,7 @@ export const getTargetMetas = (command: CommandCls): TargetMeta[] => {
   return [...targetMetaMap.values()];
 };
 
-const camelToKebabCase = (str: string) => str.replace(/([A-Z])/g, "-$1").toLowerCase();
-
-/**
- * CLI names a target answers to. Shared with the command-manifest generator so a lazily-loaded CLI
- * resolves `argv[2]` to the same module that `runCommands` would have registered it under.
- */
+/** Shared with the command-manifest generator, so a lazily loaded CLI maps argv[2] to the module runCommands would. */
 export const getTargetCommandNames = (targetMeta: TargetMeta): string[] => {
   const kebabKey = camelToKebabCase(targetMeta.key);
   if (targetMeta.targetOption.short !== true) return [kebabKey];
@@ -48,3 +44,9 @@ export interface TargetOption {
   runsOnWorkspaceRoot?: boolean;
   stdio?: boolean;
 }
+
+export const Commands = () => {
+  return (target: Cls) => {
+    // not implemented yet
+  };
+};

package/createTunnel.ts

@@ -1,18 +1,6 @@
-import type { SshOptions } from "akanjs/base";
-
 import { type AppExecutor, WorkspaceExecutor } from "./executors";
 import { createSshTunnel } from "./sshTunnel";
 
-const getSshTunnelOptions = (app: AppExecutor, environment: string): SshOptions => {
-  const { serveDomain, repoName } = WorkspaceExecutor.getBaseDevEnv();
-  return {
-    host: `${app.name}-${environment}.${serveDomain}`,
-    port: process.env.SSH_TUNNEL_PORT ? parseInt(process.env.SSH_TUNNEL_PORT) : 32767,
-    username: process.env.SSH_TUNNEL_USERNAME ?? "root",
-    password: process.env.SSH_TUNNEL_PASSWORD ?? repoName,
-  };
-};
-
 interface TunnelOption {
   app: AppExecutor;
   environment: string;
@@ -22,7 +10,7 @@ export const createTunnel = async (
   service: "redis" | "postgres",
   { app, environment, port = service === "postgres" ? 5432 : 6379 }: TunnelOption,
 ) => {
-  const sshOptions: SshOptions = getSshTunnelOptions(app, environment);
+  const { serveDomain, repoName } = WorkspaceExecutor.getBaseDevEnv();
   await createSshTunnel({
     localHost: "0.0.0.0",
     localPort: port,
@@ -30,7 +18,12 @@ export const createTunnel = async (
     srcPort: port,
     dstHost: `${service}-0.${service}-svc.${app.name}-${environment}.svc.cluster.local`,
     dstPort: service === "postgres" ? 5432 : 6379,
-    sshOptions,
+    sshOptions: {
+      host: `${app.name}-${environment}.${serveDomain}`,
+      port: process.env.SSH_TUNNEL_PORT ? parseInt(process.env.SSH_TUNNEL_PORT) : 32767,
+      username: process.env.SSH_TUNNEL_USERNAME ?? "root",
+      password: process.env.SSH_TUNNEL_PASSWORD ?? repoName,
+    },
   });
   return `localhost:${port}`;
 };