@catladder/cli 0.0.0

package/src/index.ts

@@ -0,0 +1,17 @@
+import updateNotifier from "update-notifier";
+import { argv } from "yargs";
+import catenv from "./apps/catenv/catenv";
+import shell from "./apps/shell/shell";
+import packageInfos from "./packageInfos";
+
+// tslint:disable-next-line:no-var-requires
+
+updateNotifier({
+  pkg: packageInfos,
+}).notify();
+
+if (argv.catenv) {
+  catenv();
+} else {
+  shell();
+}

package/src/k8sApi/index.ts

@@ -0,0 +1,17 @@
+import {
+  KubeConfig,
+  CoreV1Api,
+  BatchV1Api,
+  BatchV1beta1Api,
+} from "@kubernetes/client-node";
+
+const kc = new KubeConfig();
+
+kc.loadFromDefault();
+
+const k8sApi = kc.makeApiClient(CoreV1Api);
+
+export const k8sApiBatch = kc.makeApiClient(BatchV1Api);
+export const k8sApiBatchBeta = kc.makeApiClient(BatchV1beta1Api);
+
+export default k8sApi;

package/src/packageInfos.ts

@@ -0,0 +1,4 @@
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const ownPkg = require("../package.json");
+
+export default ownPkg;

package/src/types/child-process-promise.d.ts

@@ -0,0 +1 @@
+declare module 'child-process-promise'

package/src/types/command-exists-promise.d.ts

@@ -0,0 +1 @@
+declare module "command-exists-promise";

package/src/types/git-repo-name.d.ts

@@ -0,0 +1 @@
+declare module "git-repo-name";

package/src/types/types.ts

@@ -0,0 +1,20 @@
+export type Env = "dev-local" | "prod" | "dev" | "stage" | "review";
+
+export type KubernetesSecretName = string;
+export interface ISecrets {
+  [key: string]: KubernetesSecretName;
+}
+export interface IValueFile {
+  env?: {
+    public?: {
+      [key: string]: string;
+    };
+    secret?: ISecrets;
+  };
+  cloudsql?: {
+    enabled: boolean;
+    instanceId?: string;
+    region?: string;
+    projectId?: string;
+  };
+}

package/src/types/yawn-yaml.d.ts

@@ -0,0 +1 @@
+declare module "yawn-yaml/cjs";

package/src/utils/cluster.ts

@@ -0,0 +1,21 @@
+import { exec } from "child-process-promise";
+import { findKey } from "lodash";
+import clusters from "../config/clusters";
+export const getCurrentContext = async () =>
+  (await exec("kubectl config current-context")).stdout.trim();
+
+export const getCurrentConnectedClusterName = async () => {
+  const currentContext = await getCurrentContext();
+  return findKey(clusters, { fullName: currentContext });
+};
+
+export const getClusterByName = (name: string) => {
+  return clusters[name];
+};
+
+export const getAllClusterNames = () => Object.keys(clusters);
+
+export const connectToCluster = async (clusterName: string) => {
+  const { connect } = getClusterByName(clusterName);
+  await connect();
+};

package/src/utils/dashboardToken.ts

@@ -0,0 +1,20 @@
+import { exec } from "child-process-promise";
+import clipboardy from "clipboardy";
+export const getToken = async () => {
+  const { stdout } = await exec(
+    `kubectl -n kube-system describe secret $(kubectl -n kube-system get secret | awk '/^deployment-controller-token-/{print $1}') | awk '$1=="token:"{print $2}'`
+  );
+  return stdout;
+};
+
+export async function printToken() {
+  await this.log(
+    "you will need to pass a token to the dashboard. We will copy it to your clipboard!"
+  );
+  const token = await getToken();
+  await this.log("");
+  await this.log(token);
+  await this.log("");
+  await clipboardy.write(token);
+  await this.log("");
+}

package/src/utils/files.ts

@@ -0,0 +1,18 @@
+import fs from "fs-extra";
+import yaml from "js-yaml";
+
+const readFile = async (file: string) =>
+  fs.readFile(file, { encoding: "utf-8" });
+
+export const readFileOrError = async (filePath: string) => {
+  try {
+    const file = await readFile(filePath);
+    return [null, file];
+  } catch (e) {
+    return [e];
+  }
+};
+
+export const readYaml = async (filename: string) => {
+  return yaml.load(await readFile(filename));
+};

package/src/utils/formatEnvVars.ts

@@ -0,0 +1,7 @@
+import { isObject, mapValues } from "lodash";
+
+export default (envVars = {}) => {
+  return mapValues(envVars, value =>
+    isObject(value) ? JSON.stringify(value) : `${value}`
+  );
+};

package/src/utils/getEditor.ts

@@ -0,0 +1,16 @@
+/* eslint-disable @typescript-eslint/no-var-requires */
+import { spawn } from "child-process-promise";
+import commandExists from "command-exists-promise";
+
+let cmd: string;
+export default async () => {
+  if (!cmd) {
+    cmd = (await commandExists("code")) ? "code --wait" : "vim";
+  }
+
+  return {
+    open: async (path: string) => {
+      await spawn(`${cmd} ${path}`, { shell: true, stdio: "inherit" });
+    },
+  };
+};

package/src/utils/gitlab.ts

@@ -0,0 +1,80 @@
+import { exec } from "child-process-promise";
+import fetch from "node-fetch";
+import open from "open";
+import { CommandInstance } from "vorpal";
+import { getPreference, hasPreference, setPreference } from "./preferences";
+
+const TOKEN_KEY = "gitlab-personal-access-token";
+export const getGitlabToken = async (vorpal: CommandInstance) => {
+  if (!(await hasPreference(TOKEN_KEY))) {
+    vorpal.log("");
+    vorpal.log(
+      "☝ in order to access the api, we need a personal access token"
+    );
+    vorpal.log("Its best to create one specifically for catladder");
+    vorpal.log("");
+    vorpal.log("☝ we open up the settings page for you!");
+    vorpal.log("");
+    const { shouldContinue } = await vorpal.prompt({
+      default: true,
+      message: "Ok",
+      name: "shouldContinue",
+      type: "prompt",
+    });
+
+    open("https://git.panter.ch/-/profile/personal_access_tokens");
+
+    vorpal.log("Please type in gitlab's personal access token");
+
+    const { personalToken } = await vorpal.prompt({
+      type: "string",
+      name: "personalToken",
+      default: "",
+      message: "Your personal access token ",
+    });
+    if (personalToken) {
+      await setPreference(TOKEN_KEY, personalToken);
+    }
+  }
+  return getPreference(TOKEN_KEY);
+};
+
+export const doGitlabRequest = async (
+  vorpal: CommandInstance,
+  path: string,
+  data?: any
+) => {
+  const rootToken = await getGitlabToken(vorpal);
+  const result = await fetch(`https://git.panter.ch/api/v4/${path}`, {
+    method: data ? "POST" : "GET",
+    headers: {
+      "Content-Type": "application/json",
+      "Private-Token": rootToken,
+    },
+    body: JSON.stringify(data),
+  });
+
+  if (result.status >= 200 && result.status < 400) {
+    return result.json();
+  }
+
+  throw new Error(
+    `Could not send request to gitlab api: ${result.status} "${
+      result.statusText
+    }".\nResponse: ${JSON.stringify(await result.json(), null, 2)}`
+  );
+};
+
+export const getProjectInfo = async (vorpal: CommandInstance): Promise<any> => {
+  const gitRemoteOriginUrl = (
+    await exec("git config --get remote.origin.url")
+  ).stdout.trim();
+  const projectPath = /(https:\/\/|git@)git\.panter\.ch[:/](.*)\.git/g.exec(
+    gitRemoteOriginUrl
+  );
+  const project = await doGitlabRequest(
+    vorpal,
+    `projects/${encodeURIComponent(projectPath[2])}`
+  );
+  return project;
+};

package/src/utils/log.ts

@@ -0,0 +1,13 @@
+export const logError = (
+  cmd: any,
+  message: string,
+  additionalMessage?: any
+) => {
+  cmd.log("");
+  cmd.log(`[ERROR] 🙀 :${message}`);
+  cmd.log("");
+  if (additionalMessage) {
+    cmd.log(additionalMessage);
+    cmd.log("");
+  }
+};

package/src/utils/passwordstore/index.ts

@@ -0,0 +1,192 @@
+import { exec, spawn } from "child-process-promise";
+import commandExists from "command-exists-promise";
+import dayjs from "dayjs";
+
+import { readFile, writeFile } from "fs-extra";
+import yaml from "js-yaml";
+import { withFile } from "tmp-promise";
+import formatEnvVars from "../formatEnvVars";
+import getEditor from "../getEditor";
+import { getPreference, hasPreference, setPreference } from "../preferences";
+
+const DEBUG = false;
+
+const unlockBitwarden = async () => {
+  console.error("");
+  console.error("# Bitwarden is locked, please unlock:");
+  console.error("");
+  const promise = spawn("bw", ["unlock", "--raw"], {
+    stdio: ["inherit", "pipe", "inherit"],
+  });
+  let session = null;
+  promise.childProcess.stdout.on(
+    "data",
+    (d: any) => (session = d.toString("utf-8"))
+  );
+  await promise;
+  await setPreference("bwsession", session);
+};
+const loginBitwarden = async () => {
+  console.error("");
+  console.error("# Please login to Bitwarden:");
+  console.error("");
+  const promise = spawn("bw", ["login", "--raw"], {
+    stdio: ["inherit", "pipe", "inherit"],
+  });
+  let session = null;
+  promise.childProcess.stdout.on(
+    "data",
+    (d: any) => (session = d.toString("utf-8"))
+  );
+  await promise;
+  await setPreference("bwsession", session);
+  await syncBitwarden(true); // needs syncing to work properly afterwards
+};
+
+const execBitwardenCommand = async (command: string): Promise<any> => {
+  if (!(await hasPreference("bwsession"))) {
+    await loginBitwarden();
+  }
+  const session = await getPreference("bwsession");
+  const fullCommand = `BW_SESSION='${session}' bw ${command} --raw --nointeraction`;
+  if (DEBUG) {
+    console.log(fullCommand);
+    console.time(fullCommand);
+  }
+  try {
+    const { stdout } = await exec(fullCommand);
+    if (DEBUG) {
+      console.timeEnd(fullCommand);
+    }
+
+    if (!stdout) {
+      return null;
+    }
+    try {
+      return JSON.parse(stdout);
+    } catch (e) {
+      // no json
+      return stdout;
+    }
+  } catch (e) {
+    const isLocked = e.toString().includes("Vault is locked");
+    const notLoggedIn = e.toString().includes("You are not logged in");
+    if (isLocked) {
+      await unlockBitwarden();
+      return execBitwardenCommand(command);
+    } else if (notLoggedIn) {
+      await loginBitwarden();
+      return execBitwardenCommand(command);
+    } else {
+      console.error(e);
+
+      console.log("wooops", e.message);
+    }
+  }
+};
+
+export const getCollection = async (collectionName: string) => {
+  return execBitwardenCommand(`get collection ${collectionName}`);
+};
+
+export const getOrganization = async (organizationName: string) => {
+  return execBitwardenCommand(`get organization ${organizationName}`);
+};
+
+let catladderCollectionId: string;
+
+const getCatladderCollectionId = async () => {
+  if (!catladderCollectionId) {
+    catladderCollectionId = (await getCollection("catladder")).id;
+  }
+  return catladderCollectionId;
+};
+
+let panterOrganizationId: string;
+const getPanterOrganizationId = async () => {
+  if (!panterOrganizationId) {
+    panterOrganizationId = (await getOrganization("Panter AG")).id;
+  }
+  return panterOrganizationId;
+};
+
+const encode = (data: any) =>
+  Buffer.from(JSON.stringify(data)).toString("base64");
+
+export const hasBitwarden = () => commandExists("bw");
+
+const getItem = async (path: string) => {
+  return execBitwardenCommand(`get item ${path}`);
+};
+
+export const readPass = async (path: string) => {
+  const result = await getItem(path);
+
+  return result.notes || result.login?.password;
+};
+
+const update = async (type: string, itemId: string, value: any) => {
+  const result = await execBitwardenCommand(
+    `edit ${type} ${itemId} ${encode(value)}`
+  );
+
+  return result;
+};
+
+const MAX_SYNC_AGE_IN_MINUTES = 30;
+export const syncBitwarden = async (force = true) => {
+  const lastSync = (await hasPreference("bwLastSync"))
+    ? await getPreference("bwLastSync")
+    : null;
+  if (
+    force ||
+    !lastSync ||
+    dayjs().diff(lastSync, "minutes") >= MAX_SYNC_AGE_IN_MINUTES
+  ) {
+    await execBitwardenCommand("sync");
+    await setPreference("bwLastSync", new Date().toISOString());
+  } else {
+    // skip
+  }
+};
+export const insertPass = async (path: string, content: string) => {
+  const value = {
+    type: 2,
+    secureNote: { type: 0 },
+    name: path,
+
+    notes: content,
+    collectionIds: [await getCatladderCollectionId()],
+  };
+  const result = await execBitwardenCommand(`create item ${encode(value)}`);
+  await share(result.id);
+};
+
+const share = async (itemId: string) =>
+  execBitwardenCommand(
+    `share ${itemId} ${await getPanterOrganizationId()} ${encode([
+      await getCatladderCollectionId(),
+    ])}`
+  );
+
+export const editPass = async (path: string) => {
+  const item = await getItem(path);
+
+  await withFile(async ({ path: tmpFilePath }) => {
+    await writeFile(tmpFilePath, item.notes);
+    await (await getEditor()).open(tmpFilePath);
+    const newContent = (await readFile(tmpFilePath)).toString("utf-8");
+
+    await update("item", item.id, {
+      ...item,
+      notes: newContent,
+    });
+  }, { postfix: ".yml" });
+};
+
+export const readPassEnvVars = async (path: string) => {
+  // make sure that you have pulled pass beforehand
+  const yamlstring = await readPass(path);
+  // if a value is an object, we convert it to strings
+  return formatEnvVars(yaml.load(yamlstring));
+};

package/src/utils/portForward.ts

@@ -0,0 +1,52 @@
+import { spawn } from "child-process-promise";
+
+const portForwards = new Map();
+
+export const stopPortForward = async (name: string) => {
+  const old = portForwards.get(name);
+
+  if (old) {
+    try {
+      old.childProcess.kill();
+      await old;
+    } catch (e) {
+      //
+    }
+    portForwards.delete(name);
+  }
+};
+
+export const getAllRunningPortForwards = () => {
+  return Array.from(portForwards.keys());
+};
+export const startPortForward = async (
+  podname: string,
+  localPort: number,
+  remotePort: number,
+  namespace: string
+) => {
+  const name = `${namespace}/${podname}/${localPort}:${remotePort}`;
+  // stop if already there
+  if (portForwards.has(name)) {
+    stopPortForward(name);
+  }
+  const promise = spawn(
+    "kubectl",
+    ["port-forward", podname, `${localPort}:${remotePort}`, "-n", namespace],
+    {
+      env: {
+        ...process.env,
+        DEBUG: "",
+      },
+    }
+  );
+  portForwards.set(name, promise);
+  // wait a moment so that is surley started, unfortunatly we don't know that
+  await new Promise((r) => setTimeout(r, 1000));
+};
+
+export const stopAllPortForwards = async () => {
+  getAllRunningPortForwards().forEach((name) => {
+    stopPortForward(name);
+  });
+};

package/src/utils/preferences/index.ts

@@ -0,0 +1,33 @@
+import fs from "fs-extra";
+import { homedir } from "os";
+
+import yaml from "js-yaml";
+const directory = `${homedir()}/.catladder`;
+const file = `${directory}/preferences.yml`;
+
+const getPreferences = async () => {
+  if (!(await fs.pathExists(file))) {
+    await fs.createFile(file);
+  }
+  return yaml.load(await fs.readFile(file, { encoding: "utf-8" })) ?? {};
+};
+
+export const hasPreference = async (key: string) => {
+  const preferences = await getPreferences();
+  return key in preferences;
+};
+export const getPreference = async (key: string) => {
+  const preferences = await getPreferences();
+  return preferences[key];
+};
+
+export const setPreference = async (key: string, value: string | number) => {
+  const preferences = await getPreferences();
+
+  const newPreferences = {
+    ...preferences,
+    [key]: value,
+  };
+
+  await fs.writeFile(file, yaml.safeDump(newPreferences));
+};