@catladder/cli 0.0.0-vars-07a720d0 → 0.0.0-vitest-8a770211

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

@@ -1,17 +1,105 @@
-import { isOfDeployType } from "@catladder/pipeline";
-import { spawn } from "child-process-promise";
-import { writeFile } from "fs-extra";
-import { withFile } from "tmp-promise";
-import Vorpal from "vorpal";
-import { GOOGLE_CLOUD_SQL_PASS_PATH } from "../../../../config/constants";
+import type { ComponentContext } from "@catladder/pipeline";
 import {
-  getEnvVars,
+  createKubernetesCloudsqlBaseValues,
+  getDeployConfigType,
+  isOfDeployType,
+} from "@catladder/pipeline";
+import type Vorpal from "vorpal";
+import type { CommandInstance } from "vorpal";
+import clipboard from "clipboardy";
+import {
+  getEnvVarsResolved,
   getPipelineContextByChoice,
-  getProjectConfig,
   parseChoice,
 } from "../../../../config/getProjectConfig";
-import { readPass } from "../../../../utils/passwordstore";
 import { envAndComponents } from "./utils/autocompletions";
+import {
+  ERROR_NOT_INSTALLED,
+  startCloudSqlProxyInCurrentShell,
+} from "../../../../gcloud/cloudSql/startProxy";
+import { logError, logLines, logWarning } from "../../../../utils/log";
+
+type ProxyInfo = {
+  instanceName: string;
+  DB_NAME: string;
+  DB_PASSWORD: string;
+  DB_USER: string;
+};
+
+const getProxyInfo = (context: ComponentContext) => {
+  if (isOfDeployType(context.deploy?.config, "kubernetes")) {
+    return getProxyInfoForKubernetes(this, context);
+  } else if (isOfDeployType(context.deploy?.config, "google-cloudrun")) {
+    return getProxyInfoForCloudRun(this, context);
+  }
+  throw new Error(`unsupported environment: ${context.deploy?.config?.type}`);
+};
+
+const getProxyInfoForKubernetes = async (
+  vorpal: CommandInstance,
+  context: ComponentContext,
+): Promise<ProxyInfo> => {
+  if (!isOfDeployType(context.deploy?.config, "kubernetes")) {
+    throw new Error("unsupported");
+  }
+
+  const envVars = await getEnvVarsResolved(vorpal, context.env, context.name);
+  // bit hacky, would be nicer if we would also declare this through env vars
+  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 (
+  vorpal: CommandInstance,
+  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(vorpal, errorMessage);
+    throw new Error(errorMessage);
+  }
+  const envVars = await getEnvVarsResolved(vorpal, 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 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 default async (vorpal: Vorpal) =>
   vorpal
@@ -19,9 +107,19 @@ export default async (vorpal: Vorpal) =>
     .autocomplete(await envAndComponents())
     .action(async function ({ envComponent }) {
       const { env, componentName } = parseChoice(envComponent);
+      if (!componentName) {
+        logWarning(this, "need componentName");
+        return;
+      }
 
-      const config = await getProjectConfig();
-      // skynet-164509:europe-west6:pvl-cyclomania-review=tcp:5432
+      const context = await getPipelineContextByChoice(env, componentName);
+
+      if (env === "review") {
+        logWarning(
+          this,
+          "connection string does not include mr information on review environments",
+        );
+      }
 
       const { localPort } = await this.prompt({
         type: "number",
@@ -30,46 +128,67 @@ export default async (vorpal: Vorpal) =>
         message: "Local port: ",
       });
 
-      const POSTGRESQL_PASSWORD = (await getEnvVars(this, env, componentName))
-        ?.POSTGRESQL_PASSWORD;
+      const proxyInfo = await getProxyInfo(context);
 
-      const context = await getPipelineContextByChoice(env, componentName);
-      if (!isOfDeployType(context.componentConfig.deploy, "kubernetes")) {
-        throw new Error("currently only supported for kubernetes deployment");
-      }
-      this.log("");
-      this.log(`postgres-PW: ${POSTGRESQL_PASSWORD}`);
-      this.log("");
-      this.log(
-        `POSTGRESQL_URL=postgresql://postgres:${POSTGRESQL_PASSWORD}@localhost:${localPort}/${context.environment.envVars.KUBE_APP_NAME}?schema=public`
+      /**
+       * Env variables for libpq (e.g. psql client)
+       * https://www.postgresql.org/docs/current/libpq-envars.html#LIBPQ-ENVARS
+       */
+      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}"`,
       );
-      this.log("");
-
-      const values = context.componentConfig.deploy.values;
+      const dbUrl = getDbUrl(proxyInfo, localPort);
+      const jdbcUrl = getJdbcUrl(proxyInfo, localPort);
 
-      const projectId =
-        values?.cloudsql?.projectId ||
-        context.componentConfig.deploy.cluster?.projectId;
-
-      const defaultInstanceId = `${config.customerName}-${config.appName}-${env}`;
-      const instanceId = values?.cloudsql?.instanceId || defaultInstanceId;
-
-      const defaultRegion = "europe-west6"; // currently hardcoded
-      const region = values?.cloudsql?.region || defaultRegion;
-
-      const instanceName = `${projectId}:${region}:${instanceId}=tcp:${localPort}`;
+      clipboard.writeSync(
+        [
+          "",
+          "## CloudSQL proxy connection .env variables",
+          dbUrl,
+          jdbcUrl,
+          "## DATABASE_URL with schema=public parameter (e. g. Prisma requires this):",
+          `# ${getDbUrl(proxyInfo, 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"),
+      );
 
-      const cloudsqlCredentials = await readPass(GOOGLE_CLOUD_SQL_PASS_PATH);
-      await withFile(async ({ path: tmpFilePath }) => {
-        await writeFile(tmpFilePath, cloudsqlCredentials);
+      logLines(
+        this,
+        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, localPort, `?schema=public`),
+        null,
+      );
 
-        await spawn(
-          "cloud_sql_proxy",
-          ["-instances", instanceName, "-credential_file", tmpFilePath],
-          {
-            stdio: "inherit",
-            shell: true,
-          }
+      try {
+        await startCloudSqlProxyInCurrentShell({
+          instanceName: proxyInfo.instanceName,
+          localPort,
+        });
+      } catch (error) {
+        if (!(error instanceof Error)) throw error;
+        if (error.message !== ERROR_NOT_INSTALLED) throw error;
+        logError(
+          this,
+          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/apps/cli/commands/project/commandConfigSecrets.ts

@@ -1,19 +1,18 @@
-/* eslint-disable no-constant-condition */
+import { getSecretVarName } from "@catladder/pipeline";
 import { stripIndents } from "common-tags";
 import { difference } from "lodash";
-import Vorpal, { CommandInstance } from "vorpal";
-import { GOOGLE_CLOUD_SQL_PASS_PATH } from "../../../../config/constants";
+import type { CommandInstance } from "vorpal";
+import type Vorpal from "vorpal";
 import {
   getAllComponentsWithAllEnvsHierarchical,
   getEnvironment,
-  getEnvVars,
-  getPipelineContextByChoice,
+  getEnvVarsResolved,
+  getJobOnlyEnvVarsResolved,
   getProjectComponents,
   parseChoice,
 } from "../../../../config/getProjectConfig";
 import { editAsFile } from "../../../../utils/editAsFile";
 import { upsertAllVariables } from "../../../../utils/gitlab";
-import { hasBitwarden, readPass } from "../../../../utils/passwordstore";
 import { delay } from "../../../../utils/promise";
 import { allEnvsAndAllComponents } from "./utils/autocompletions";
 
@@ -38,30 +37,65 @@ const resolveJson = (v: Vars) =>
                 } catch (e) {
                   return [key, value];
                 }
-              })
+              }),
             ),
-          ])
+          ]),
         ),
       ];
-    })
+    }),
   );
+
+const getSecretEnvVarKeysToConfigure = async (
+  env: string,
+  componentName: string,
+) => {
+  const { secretEnvVarKeys, jobOnlyVars } = await getEnvironment(
+    env,
+    componentName,
+  );
+  return [
+    ...jobOnlyVars.build.secretEnvVarKeys,
+    ...jobOnlyVars.deploy.secretEnvVarKeys,
+    ...secretEnvVarKeys,
+  ]
+    .filter((k) => !k.hidden)
+    .map((k) => k.key);
+};
 const getEnvVarsToEdit = async (
   instance: CommandInstance,
   env: string,
-  componentName: string
+  componentName: string,
 ) => {
-  const { secretEnvVarKeys } = await getEnvironment(env, componentName);
+  const secretEnvVarKeys = await getSecretEnvVarKeysToConfigure(
+    env,
+    componentName,
+  );
 
-  const allEnvVars = await getEnvVars(instance, env, componentName);
+  const normalEnvVars = await getEnvVarsResolved(instance, env, componentName);
+  const jobOnlyEnvVars = await getJobOnlyEnvVarsResolved(
+    instance,
+    env,
+    componentName,
+  );
+  const allEnvVars = {
+    ...normalEnvVars,
+    ...jobOnlyEnvVars,
+  };
   return Object.fromEntries(
-    secretEnvVarKeys.map((key) => [key, allEnvVars[key]])
+    secretEnvVarKeys.map((key) => {
+      const value = allEnvVars[key];
+      // due to some quirky way to resolve these variables, unset variables have the $CL_ prefix, so we remove thouse here
+      const variableIsNotSet =
+        value === "$" + getSecretVarName(env, componentName, key);
+      return [key, variableIsNotSet ? "🚨 FILL ME" : value];
+    }),
   );
 };
 const doItFor = async (
   instance: CommandInstance,
   envAndComponents: {
     [componentName: string]: string[];
-  }
+  },
 ) => {
   let valuesToEdit: Vars = Object.fromEntries(
     await Promise.all(
@@ -72,11 +106,11 @@ const doItFor = async (
             envs.map(async (env) => [
               env,
               await getEnvVarsToEdit(instance, env, componentName),
-            ])
-          )
+            ]),
+          ),
         ),
-      ])
-    )
+      ]),
+    ),
   );
   let hasErrors = true;
   while (hasErrors) {
@@ -87,11 +121,11 @@ const doItFor = async (
 
         ${Object.entries(envAndComponents)
           .map(
-            ([componentName, envs]) => `- ${componentName}: ${envs.join(", ")}`
+            ([componentName, envs]) => `- ${componentName}: ${envs.join(", ")}`,
           )
           .join("\n")}
 
-        `
+        `,
     );
     // check for errors
     hasErrors = false;
@@ -101,14 +135,18 @@ const doItFor = async (
           ? Object.keys(valuesToEdit[componentName][env])
           : [];
         // check whether newValues have the exact number of keys
-        const { secretEnvVarKeys } = await getEnvironment(env, componentName);
+        const secretEnvVarKeys = await getSecretEnvVarKeysToConfigure(
+          env,
+          componentName,
+        );
+
         const extranous = difference(usedKeys, secretEnvVarKeys);
         const missing = difference(secretEnvVarKeys, usedKeys);
 
         if (extranous.length > 0 || missing.length > 0) {
           instance.log("");
           instance.log(
-            `😿 Oh no! There is something wrong with "${componentName}"`
+            `😿 Oh no! There is something wrong with "${componentName}"`,
           );
           instance.log("");
           if (extranous.length > 0) {
@@ -138,39 +176,21 @@ const doItFor = async (
       }
     }
   }
+  instance.log("");
   instance.log("upserting all variables, please wait...");
   instance.log("");
   for (const [componentName, envs] of Object.entries(envAndComponents)) {
     for (const env of envs) {
+      instance.log("upserting " + env + ":" + componentName + "...\n");
       await upsertAllVariables(
         instance,
         valuesToEdit[componentName][env],
         env,
-        componentName
+        componentName,
       );
-
-      if (hasBitwarden()) {
-        // add cloud sql secret if needed.
-        // TODO: this is legacy, in the future we want to have one service account per app
-
-        const context = await getPipelineContextByChoice(env, componentName);
-        if (
-          context.componentConfig.deploy &&
-          context.componentConfig.deploy.values?.cloudsql?.enabled
-        ) {
-          await upsertAllVariables(
-            instance,
-            {
-              cloudsqlProxyCredentials: await readPass(
-                GOOGLE_CLOUD_SQL_PASS_PATH
-              ),
-            },
-            env,
-            componentName
-          );
-        }
-      }
+      instance.log("");
       instance.log("✅ " + env + ":" + componentName);
+      instance.log("--------------------------------\n");
     }
   }
   instance.log("done! 😻");
@@ -179,7 +199,7 @@ const doItFor = async (
 
 export const projectConfigSecrets = async (
   vorpal: CommandInstance,
-  envComponent?: string
+  envComponent?: string,
 ) => {
   if (!envComponent) {
     const allEnvAndcomponents = await getAllComponentsWithAllEnvsHierarchical();
@@ -192,7 +212,7 @@ export const projectConfigSecrets = async (
       const components = await getProjectComponents();
       await doItFor(
         vorpal,
-        Object.fromEntries(components.map((c) => [c, [env]]))
+        Object.fromEntries(components.map((c) => [c, [env]])),
       );
     }
     if (componentName) {
@@ -207,7 +227,7 @@ export default async (vorpal: Vorpal) => {
   vorpal
     .command(
       "project-config-secrets [envComponent]",
-      "setup/update secrets stored in pass"
+      "setup/update secrets stored in pass",
     )
     .autocomplete(await allEnvsAndAllComponents())
     .action(async function ({ envComponent }) {

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

@@ -1,11 +1,9 @@
-import Vorpal from "vorpal";
+import type Vorpal from "vorpal";
 import { getk8sApi } from "../../../../k8sApi";
+import { getProjectPodNames } from "../../../../kubernetes";
 
 import { logError } from "../../../../utils/log";
-import {
-  getProjectNamespace,
-  getProjectPodNames,
-} from "../../../../utils/projects";
+import { getProjectNamespace } from "../../../../utils/projects";
 import { envAndComponents } from "./utils/autocompletions";
 import ensureCluster from "./utils/ensureCluster";
 
@@ -29,7 +27,7 @@ export default async (vorpal: Vorpal) =>
       });
 
       this.log(
-        "the following pods will be DELETED 🙀 (and therefore restarted 😸)"
+        "the following pods will be DELETED 🙀 (and therefore restarted 😸)",
       );
       this.log("");
       selectedPodNames.forEach((n: string) => this.log(n));

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

@@ -1,4 +1,4 @@
-import Vorpal from "vorpal";
+import type Vorpal from "vorpal";
 import { exec } from "child-process-promise";
 import { getProjectNamespace } from "../../../../utils/projects";
 import { envAndComponents } from "./utils/autocompletions";
@@ -7,7 +7,7 @@ export default async (vorpal: Vorpal) =>
   vorpal
     .command(
       "project-delete <envComponent>",
-      "deletes a environment of a project (it deletes the namespace)"
+      "deletes a environment of a project (it deletes the namespace)",
     )
     .autocomplete(await envAndComponents())
     .action(async function ({ envComponent }) {

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

@@ -1,5 +1,8 @@
-import Vorpal from "vorpal";
-import { getEnvVars, parseChoice } from "../../../../config/getProjectConfig";
+import type Vorpal from "vorpal";
+import {
+  getEnvVarsResolved,
+  parseChoice,
+} from "../../../../config/getProjectConfig";
 import { envAndComponents } from "./utils/autocompletions";
 
 export default async (vorpal: Vorpal) =>
@@ -8,8 +11,8 @@ export default async (vorpal: Vorpal) =>
     .autocomplete(await envAndComponents())
     .action(async function ({ envComponent }) {
       const { env, componentName } = parseChoice(envComponent);
-      const envvars = await getEnvVars(this, env, componentName);
+      const envvars = await getEnvVarsResolved(this, env, componentName);
       Object.keys(envvars).forEach((key) =>
-        this.log(`${key}: ${envvars[key]}`)
+        this.log(`${key}: ${envvars[key]}`),
       );
     });

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

@@ -1,14 +1,14 @@
 import { spawn } from "child-process-promise";
-import Vorpal from "vorpal";
+import type Vorpal from "vorpal";
 
 export default async (vorpal: Vorpal) =>
   vorpal
     .command(
       "project-get-my-total-worktime",
-      "show the total worktime that you spent on a project"
+      "show the total worktime that you spent on a project",
     )
     .action(async () => {
-      await spawn("sh", ["-c", "curl -L http://bit.ly/10hA8iC | bash"], {
+      await spawn("sh", ["-c", "curl -s -L http://bit.ly/3VQEKNq | bash"], {
         stdio: ["pipe", "inherit", "pipe"],
       });
     });

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

@@ -1,9 +1,7 @@
-import Vorpal from "vorpal";
+import type Vorpal from "vorpal";
+import { getProjectPods } from "../../../../kubernetes";
 import { logError } from "../../../../utils/log";
-import {
-  getProjectNamespace,
-  getProjectPodNames,
-} from "../../../../utils/projects";
+import { getProjectNamespace } from "../../../../utils/projects";
 import { getShell } from "../../../../utils/shell";
 
 import { envAndComponents } from "./utils/autocompletions";
@@ -13,21 +11,24 @@ export default async (vorpal: Vorpal) =>
   vorpal
     .command(
       "project-get-shell <envComponent>",
-      "get a shell to a pod in the environment"
+      "get a shell to a pod in the environment",
     )
     .autocomplete(await envAndComponents())
     .action(async function ({ envComponent }) {
       await ensureCluster.call(this, envComponent);
       const namespace = await getProjectNamespace(envComponent);
-      const podNames = await getProjectPodNames(envComponent);
-      if (podNames.length === 0) {
-        logError(this, "sorry, no pods found");
+      const pods = await getProjectPods(envComponent);
+      const runningPodNames = pods
+        .filter((p) => p.status.phase == "Running")
+        .map((r) => r.metadata.name);
+      if (runningPodNames.length === 0) {
+        logError(this, "sorry, no running pods found");
         return;
       }
       const { podName } = await this.prompt({
         type: "list",
         name: "podName",
-        choices: podNames,
+        choices: runningPodNames,
         message: "Which pod? 🤔",
       });
 

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

@@ -1,7 +1,8 @@
 import { exec } from "child-process-promise";
 import { last } from "lodash";
 import open from "open";
-import Vorpal, { CommandInstance } from "vorpal";
+import type { CommandInstance } from "vorpal";
+import type Vorpal from "vorpal";
 import {
   doGitlabRequest,
   getGitlabToken,
@@ -39,7 +40,7 @@ const promptJob = async (vorpal: CommandInstance, projectId: any, ctx: any) => {
 
   const jobsToName = (jo: any[]) =>
     jo.map(
-      (j: any) => `${j.ref}-${j.name}-${j.user.username}-${j.status}-${j.id}`
+      (j: any) => `${j.ref}-${j.name}-${j.user.username}-${j.status}-${j.id}`,
     );
 
   const preferredJobs = jobs.filter((j: any) => j.commit.id === commitId);
@@ -83,13 +84,13 @@ export default async (vorpal: Vorpal) => {
       while (!finished) {
         const trace = await exec(
           `curl -s --header "PRIVATE-TOKEN: ${await getGitlabToken(
-            this
-          )}" "https://git.panter.ch/api/v4/projects/${projectId}/jobs/${id}/trace"`
+            this,
+          )}" "https://git.panter.ch/api/v4/projects/${projectId}/jobs/${id}/trace"`,
         );
 
         const job = await doGitlabRequest(
           this,
-          `projects/${projectId}/jobs/${id}`
+          `projects/${projectId}/jobs/${id}`,
         );
 
         if (trace.stdout) {

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

@@ -1,7 +1,7 @@
-import { dump } from "js-yaml";
+import { stringify } from "yaml";
 import { pick } from "lodash";
-import Vorpal from "vorpal";
-import { getProjectPods } from "../../../../utils/projects";
+import type Vorpal from "vorpal";
+import { getProjectPods } from "../../../../kubernetes";
 import { envAndComponents } from "./utils/autocompletions";
 import ensureCluster from "./utils/ensureCluster";
 
@@ -13,6 +13,8 @@ export default async (vorpal: Vorpal) =>
       await ensureCluster.call(this, envComponent);
       const pods = await getProjectPods(envComponent);
       this.log(
-        dump(pods.map((p) => pick(p, ["metadata.name", "status.startTime"])))
+        stringify(
+          pods.map((p) => pick(p, ["metadata.name", "status.startTime"])),
+        ),
       );
     });

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

@@ -1,4 +1,4 @@
-import Vorpal from "vorpal";
+import type Vorpal from "vorpal";
 import { getProjectNamespace } from "../../../../utils/projects";
 import { envAndComponents } from "./utils/autocompletions";
 
@@ -6,7 +6,7 @@ export default async (vorpal: Vorpal) =>
   vorpal
     .command(
       "project-namespace <envComponent>",
-      "show namespace of local project"
+      "show namespace of local project",
     )
     .autocomplete(await envAndComponents())
     .action(async function ({ envComponent }) {

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

@@ -1,5 +1,5 @@
 import open from "open";
-import Vorpal from "vorpal";
+import type Vorpal from "vorpal";
 import {
   getEnvironment,
   parseChoice,
@@ -16,7 +16,7 @@ export default async (vorpal: Vorpal) =>
       const { env, componentName } = parseChoice(envComponent);
       await ensureCluster.call(this, envComponent);
       const environment = await getEnvironment(env, componentName);
-      const url = environment.url;
+      const url = environment.envVars.ROOT_URL;
 
-      open(url);
+      open(url.toString());
     });