git-mirror

#!/usr/bin/env zx
// vim: set filetype=javascript :

import { URL } from "url";
import { GitHub } from "./zx/github.mjs";
import { GitLab } from "./zx/gitlab.mjs";
import { JetBrainsSpace } from "./zx/jetbrains-space.mjs";

$.verbose = false;

const ask_bool = async (prompt) => {
  return await question(`${prompt} [y/N] `).then((answer) => {
    return answer.toLowerCase() == "y";
  });
};

const read_file = async (filename) => {
  return await fs.readFile(filename, { encoding: "utf8" });
};

const generate_ssh_keypair = async (comment = "git-mirror") => {
  const filename = "/tmp/git-mirror-key";

  $`rm -f ${filename} ${filename}.pub`;

  await $`ssh-keygen -t ed25519 -C ${comment} -N '' -f ${filename}`;

  const [privateKey, publicKey] = await Promise.all([
    read_file(filename),
    read_file(`${filename}.pub`),
  ]);

  $`rm -f ${filename} ${filename}.pub`;

  return { privateKey, publicKey };
};

const allowed_default_branches = ["main", "master"];

async function get_repo_info() {
  let ret;

  ret = await $`git branch --show-current`;
  const current_branch = ret.stdout.trim();

  if (!allowed_default_branches.includes(current_branch)) {
    throw new Error(
      `Current branch: ${current_branch}, expected: ${allowed_default_branches.join(
        "/"
      )}`
    );
  }

  ret = await $`git remote`;
  const remote_names = ret.stdout.trim().split("\n");

  const remote = {};

  for (const remote_name of remote_names) {
    remote[remote_name] = {};

    ret = await $`git remote get-url --all ${remote_name}`;
    remote[remote_name]["fetch"] = ret.stdout
      .trim()
      .split("\n")
      .map((url) => new URL(url));

    ret = await $`git remote get-url --all --push ${remote_name}`;
    remote[remote_name]["push"] = ret.stdout
      .trim()
      .split("\n")
      .map((url) => new URL(url));

    remote[remote_name].url = remote[remote_name]["fetch"][0];
  }

  const project = remote.origin.fetch[0].pathname
    .replace(/^\//, "")
    .replace(/\.git$/, "");
  const [owner, name] = project.split("/");

  return {
    project,
    owner,
    name,
    remote,
    current_branch,
  };
}

async function refresh_repo_info(repo) {
  Object.assign(repo, await get_repo_info());
}

async function ensure_git_mirror_remote(repo, name, remote_url) {
  const url = new URL(remote_url);

  if (
    repo.remote.origin.url.host === url.host ||
    repo.remote[`origin-${name}`]
  ) {
    return;
  }

  await $`git remote add origin-${name} ${url.href}`;

  await refresh_repo_info(repo);
}

async function init_gitlab(repo) {
  const gitlab = await new GitLab({ id: "git-mirror" }).init();

  const get_mirror_project_settings = () => ({
    description: `Mirroring: ${repo.remote.origin.url.href}`,

    analytics_access_level: "disabled",
    builds_access_level: "disabled",
    container_registry_access_level: "disabled",
    feature_flags_access_level: "disabled",
    forking_access_level: "disabled",
    infrastructure_access_level: "disabled",
    issues_access_level: "disabled",
    merge_requests_access_level: "disabled",
    monitor_access_level: "disabled",
    operations_access_level: "disabled",
    packages_enabled: false,
    pages_access_level: "disabled",
    requirements_access_level: "disabled",
    security_and_compliance_access_level: "disabled",
    snippets_access_level: "disabled",
    wiki_access_level: "disabled",
  });

  async function create_mirror({ try_import = true, is_public = null } = {}) {
    gitlab.log.info(`Creating project: ${repo.project}...`);

    if (typeof is_public !== "boolean") {
      is_public = await ask_bool("Make project public?");
    }

    const import_url = try_import ? repo.remote.origin.url.href : null;

    const res = await gitlab.api("POST /projects", {
      body: {
        name: repo.name,
        import_url,
        visibility: is_public ? "public" : "private",
        ...get_mirror_project_settings(repo),
      },
    });

    if (res.ok) {
      gitlab.log.info(`Created project: ${repo.project}...`);
    } else if (try_import && res.status === 422) {
      gitlab.log.error(`Failed to create project: ${repo.project}...`);
      gitlab.log.error(`  Reason:  ${res.data.message}`);
      gitlab.log.info(`Trying again w/o initial import...`);
      return create_mirror({ try_import: false, is_public });
    } else {
      gitlab.log.error(`Failed to create project: ${repo.project}...`);
      throw res;
    }
  }

  async function update_mirror(project) {
    const res = await gitlab.api(`PUT /projects/${project.id}`, {
      body: get_mirror_project_settings(),
    });

    if (!res.ok) {
      throw res;
    }
  }

  async function ensure_mirror() {
    const res = await gitlab.api(
      `/projects/${encodeURIComponent(repo.project)}`
    );

    if (res.ok) {
      await update_mirror(res.data);
      gitlab.log.info(`Project Found: ${repo.project}`);
      return;
    }

    await create_mirror();
  }

  async function remove_mirror_branch_protection() {
    const res = await gitlab.api(
      `/projects/${encodeURIComponent(repo.project)}/protected_branches`
    );

    for (const item of res.data) {
      await gitlab.api(
        `DELETE /projects/${encodeURIComponent(
          repo.project
        )}/protected_branches/${item.name}`
      );
      gitlab.log.info(`Removed branch protection: ${item.name}`);
    }
  }

  await ensure_mirror();

  await remove_mirror_branch_protection();

  const remote_url = `https://gitlab.com/${repo.project}.git`;
  await ensure_git_mirror_remote(repo, "gitlab", remote_url);
}

async function init_jetbrains_space(repo) {
  const space = await new JetBrainsSpace({
    id: "git-mirror",
    site: "muniftanjim",
  }).init();

  const project_key = "key:PERSONAL";
  const base_url = `/projects/${project_key}/repositories/${repo.name}`;

  async function get_mirror_repository_settings_mirror_key(mirror) {
    const body = {
      remote: {
        url: mirror.url,
      },
    };

    let res = await space.api(
      `POST /projects/${project_key}/repositories/test-connection`,
      { body }
    );

    if (!res.ok) {
      throw res;
    }

    if (res.data.success) {
      space.log.info(`Successfully connected to remote ${body.remote.url}`);
      return null;
    }

    space.log.warn(res.data.reason.split("\n")[0]);

    const github_deploy_key_title = "muniftanjim.jetbrains.space:mirror";

    const github = new GitHub({ id: "git-mirror" });
    res = await github.api("/repos/{owner}/{repo}/keys", {
      jq: `.[] | select(.title=="${github_deploy_key_title}")`,
    });

    if (!res.ok) {
      throw res;
    }

    if (res.data) {
      res = await github.api(
        `DELETE /repos/{owner}/{repo}/keys/${res.data.id}`
      );

      if (!res.ok) {
        github.log.info(
          `Failed to remove old deploy key (${github_deploy_key_title})`
        );
        throw res;
      }

      github.log.info(`Removed old deploy key (${github_deploy_key_title})`);
    }

    const keypair = await generate_ssh_keypair(github_deploy_key_title);

    res = await github.api("POST /repos/{owner}/{repo}/keys", {
      fields: {
        title: github_deploy_key_title,
        key: keypair.publicKey,
        read_only: true,
      },
    });

    if (!res.ok) {
      github.log.error(`Failed to add deploy key (${github_deploy_key_title})`);
      throw res;
    }

    github.log.info(`Added deploy key (${github_deploy_key_title})`);

    body.remote.auth = {
      className: "RemoteRepositoryAuth.SSH",
      privateKey: keypair.privateKey,
      passphrase: "",
    };

    res = await space.api(
      `POST /projects/${project_key}/repositories/test-connection`,
      { body }
    );

    if (res.ok) {
      space.log.info(
        `Successfully connected to remote ${body.remote.url} using deploy key`
      );
      return keypair.privateKey;
    }

    space.log.error(`Failed to connect to remote: ${body.remote.url}`);
    throw res;
  }

  const repo_description = `Mirroring: ${repo.remote.origin.url.href}`;
  const get_mirror_repository_settings = async () => {
    const settings = {
      mirror: {
        version: "",
        url: `https://github.com/${repo.project}.git`,
        detachHEAD: false,
        fetchPeriodically: true,
        fetchBeforeGitCall: true,
        key: null,
        mirrorPullRequest: false,
      },
    };

    settings.mirror.key = await get_mirror_repository_settings_mirror_key(
      settings.mirror
    );

    if (settings.mirror.key) {
      settings.mirror.url = `git@github.com:${repo.project}.git`;
      settings.mirror.useAuthKey = true;
      settings.mirror.keyPassphrase = "";
    } else {
      settings.mirror.url = `https://github.com/${repo.project}.git`;
      settings.mirror.useAuthKey = null;
      settings.mirror.keyPassphrase = null;
    }

    return { settings };
  };

  async function create_mirror() {
    space.log.info(`Creating project: ${repo.name}...`);

    const { settings } = await get_mirror_repository_settings(repo);

    const info = {
      description: repo_description,
      remote: {
        url: settings.mirror.url,
        auth: settings.mirror.useAuthKey
          ? {
              className: "RemoteRepositoryAuth.SSH",
              privateKey: settings.mirror.key,
              passphrase: settings.mirror.keyPassphrase,
            }
          : null,
      },
      mirror: {
        syncPeriodically: settings.mirror.fetchPeriodically,
        syncOnFetch: settings.mirror.fetchBeforeGitCall,
        mirrorPullRequest: settings.mirror.mirrorPullRequest,
      },
    };

    const res = await space.api(`POST ${base_url}/migrate`, {
      body: info,
    });

    if (res.ok) {
      space.log.info(`Created project: ${repo.name}...`);
    } else {
      space.log.info(`Failed to create project: ${repo.name}...`);
      throw res;
    }
  }

  async function update_mirror() {
    let res = await space.api(`POST ${base_url}/settings`, {
      body: await get_mirror_repository_settings(),
    });

    if (!res.ok) {
      throw res;
    }

    res = await space.api(`POST ${base_url}/description`, {
      body: { description: repo_description },
    });

    if (!res.ok) {
      throw res;
    }
  }

  async function ensure_mirror() {
    const res = await space.api(base_url);

    if (res.ok) {
      await update_mirror();
      space.log.info(`Repository Found: ${res.data.name}`);
      return;
    }

    await create_mirror();
  }

  async function get_remote_url() {
    const res = await space.api(`${base_url}/url`);
    if (!res.ok) {
      throw res;
    }
    return res.data.httpUrl;
  }

  await ensure_mirror();

  const remote_url = await get_remote_url();
  await ensure_git_mirror_remote(repo, "jetbrains-space", remote_url);
}

const REMOTE_SERVICE = {
  gitlab: {
    init: init_gitlab,
    has_auto_sync: false,
  },
  ["jetbrains-space"]: {
    init: init_jetbrains_space,
    has_auto_sync: true,
  },
};

async function init(repo) {
  for (const remote of Object.values(REMOTE_SERVICE)) {
    await remote.init(repo);
  }
}

async function sync(repo) {
  $.verbose = true;
  for (const remote of Object.keys(REMOTE_SERVICE)) {
    if (
      !repo.remote[`origin-${remote}`] ||
      REMOTE_SERVICE[remote].has_auto_sync
    ) {
      continue;
    }

    await $`git push origin-${remote} --force --all --follow-tags`;
    // push non-annotated tags
    await $`git push origin-${remote} --force --tags`;
  }
  $.verbose = false;
}

const repo = await get_repo_info();

switch (argv._[0]) {
  case "init": {
    await init(repo);
    break;
  }
  case "sync": {
    await sync(repo);
    break;
  }
  default: {
    if (
      Object.keys(REMOTE_SERVICE).some(
        (remote) => !repo.remote[`origin-${remote}`]
      )
    ) {
      await init(repo);
    }

    await sync(repo);
  }
}