codeql-action/src/platform.ts

import fs from "fs";

import * as toolrunner from "@actions/exec/lib/toolrunner";
import * as io from "@actions/io";
import * as semver from "semver";

import type { ActionState, Logger } from "./action-common";
import { getErrorMessage } from "./util";

/** Platform identifiers used in CodeQL bundle asset names. */
export enum BundlePlatform {
  Linux64 = "linux64",
  LinuxArm64 = "linux-arm64",
  Osx64 = "osx64",
  Win64 = "win64",
}

/** Returns the bundle platform, or undefined when an all-platform bundle is required. */
export function getBundlePlatform(
  platform: NodeJS.Platform = process.platform,
  arch: NodeJS.Architecture = process.arch,
): BundlePlatform | undefined {
  switch (platform) {
    case "win32":
      return BundlePlatform.Win64;
    case "linux":
      return arch === "arm64"
        ? BundlePlatform.LinuxArm64
        : BundlePlatform.Linux64;
    case "darwin":
      return BundlePlatform.Osx64;
    default:
      return undefined;
  }
}

/**
 * Tries to determine the version of the Darwin kernel. We use this to approximate the macOS version based
 * on the Darwin kernel version so that we don't have to launch an external process. Note that the Darwin
 * kernel major version does not correspond perfectly to the macOS major version.
 *
 * @returns
 *  The version as either a semantic version object, the raw version string
 *  if it is not a semantic version, or `undefined` if we are not on macOS.
 */
export function darwinVersion(
  action: ActionState<["Base"]>,
): semver.SemVer | string | undefined {
  // Skip if we are not running on macOS.
  if (action.platform !== "darwin") {
    return undefined;
  }

  // Try to parse the kernel version string.
  const version = semver.parse(action.osRelease);

  if (version === null) {
    return action.osRelease;
  }

  return version;
}

/** The static path we check for a symbolic link to the (dynamic) Xcode location. */
export const XCODE_SELECT_LINK_PATH = "/private/var/db/xcode_select_link";

/** The pattern we expect to find in the Xcode path. */
export const XCODE_APP_FILENAME_PATTERN = new RegExp(
  /(?<filename>Xcode_(?<majorMinor>\d+(\.\d+)?).*\.app)/,
);

/**
 * Tries to determine the version of Xcode that is installed from the resolved symbolic link
 * at {@link XCODE_SELECT_LINK_PATH}.
 *
 * @param logger The logger to use.
 * @returns The Xcode version or `undefined` if it couldn't be determined.
 */
export function xcodeVersionFromLink(
  logger: Logger,
): semver.SemVer | undefined {
  try {
    // Read what the symbolic link points to. This will throw if `XCODE_SELECT_LINK_PATH` does not
    // exist (`ENOENT`) or is not a symbolic link (`EINVAL`).
    const xcodePath = fs.readlinkSync(XCODE_SELECT_LINK_PATH);

    if (xcodePath.trim() === "") {
      logger.debug(
        `Resolving ${XCODE_SELECT_LINK_PATH} unexpectedly returned nothing.`,
      );
      return undefined;
    }

    // Try to extract the version from the path.
    const matchResult = xcodePath.match(XCODE_APP_FILENAME_PATTERN);

    if (matchResult?.groups === undefined) {
      logger.debug(
        `Xcode path '${xcodePath}' does not contain expected pattern.`,
      );
      return undefined;
    }

    const majorMinor = matchResult.groups["majorMinor"];
    const version = semver.coerce(majorMinor);

    if (version === null) {
      logger.debug(`Couldn't parse '${majorMinor}' as a semantic version.`);
      return undefined;
    }
    return version;
  } catch (err) {
    logger.debug(`Unable to determine Xcode version: ${getErrorMessage(err)}`);
    return undefined;
  }
}

/**
 * Tries to determine the version of Xcode that is installed by running `xcrun xcodebuild -version`.
 *
 * @param logger The logger to use.
 * @returns The Xcode version or `undefined` if it couldn't be determined.
 */
export async function xcodeVersionFromXcodeBuild(
  logger: Logger,
): Promise<semver.SemVer | undefined> {
  try {
    const xcrun = await io.which("xcrun", true);
    let stdout = "";
    let stderr = "";

    const exitCode = await new toolrunner.ToolRunner(
      xcrun,
      ["xcodebuild", "-version"],
      {
        silent: true,
        ignoreReturnCode: true,
        listeners: {
          stdout: (data: Buffer) => {
            stdout += data.toString("utf-8");
          },
          stderr: (data: Buffer) => {
            stderr += data.toString("utf-8");
          },
        },
      },
    ).exec();

    if (exitCode !== 0) {
      logger.debug(`xcodebuild returned exit code ${exitCode}`);
      logger.debug(`stdout:\n${stdout}`);
      logger.debug(`stderr:\n${stderr}`);
      return undefined;
    }

    // The output contains a couple of lines, but we only care about the product version.
    const match = stdout.match(/^Xcode (\d+(\.\d+)?)/);

    if (match === null) {
      logger.debug(
        `Output doesn't appear to contain the Xcode product version.`,
      );
      logger.debug(`stdout:\n${stdout}`);
      logger.debug(`stderr:\n${stderr}`);
      return undefined;
    }

    // We expect the output to only be a version string. Try to parse it into a semver.
    const version = semver.coerce(match[1].trim());

    if (version === null) {
      logger.debug(
        `xcodebuild's output couldn't be parsed as a version:\n${stdout}`,
      );
      logger.debug(`stderr:\n${stderr}`);
      return undefined;
    }

    return version;
  } catch (err) {
    logger.debug(
      `Unable to determine Xcode version from xcodebuild: ${getErrorMessage(err)}`,
    );
    return undefined;
  }
}

/**
 * Tries to determine the version of the Xcode SDK that is installed by running
 * `xcrun --sdk macosx --show-sdk-version`.
 *
 * @param logger The logger to use.
 * @returns The Xcode SDK version or `undefined` if it couldn't be determined.
 */
export async function xcodeSdkVersion(
  logger: Logger,
): Promise<semver.SemVer | undefined> {
  try {
    const xcrun = await io.which("xcrun", true);
    let stdout = "";
    let stderr = "";

    const exitCode = await new toolrunner.ToolRunner(
      xcrun,
      ["--sdk", "macosx", "--show-sdk-version"],
      {
        silent: true,
        ignoreReturnCode: true,
        listeners: {
          stdout: (data: Buffer) => {
            stdout += data.toString("utf-8");
          },
          stderr: (data: Buffer) => {
            stderr += data.toString("utf-8");
          },
        },
      },
    ).exec();

    if (exitCode !== 0) {
      logger.debug(`xcrun returned exit code ${exitCode}`);
      logger.debug(`stdout:\n${stdout}`);
      logger.debug(`stderr:\n${stderr}`);
      return undefined;
    }

    // We expect the output to only be a version string. Try to parse it into a semver.
    const version = semver.coerce(stdout.trim());

    if (version === null) {
      logger.debug(
        `xcrun's output couldn't be parsed as a version:\n${stdout}`,
      );
      logger.debug(`stderr:\n${stderr}`);
      return undefined;
    }

    return version;
  } catch (err) {
    logger.debug(
      `Unable to determine Xcode SDK version: ${getErrorMessage(err)}`,
    );
    return undefined;
  }
}