setup-uv/src/utils/inputs.ts

import path from "node:path";
import * as core from "@actions/core";
import { getConfigValueFromTomlFile } from "./config-file";

export enum CacheLocalSource {
  Input,
  Config,
  Env,
  Default,
}

export interface CacheLocalPath {
  path: string;
  source: CacheLocalSource;
}

export interface SetupInputs {
  workingDirectory: string;
  version: string;
  versionFile: string;
  pythonVersion: string;
  activateEnvironment: boolean;
  venvPath: string;
  checksum: string;
  enableCache: boolean;
  restoreCache: boolean;
  saveCache: boolean;
  cacheSuffix: string;
  cacheLocalPath?: CacheLocalPath;
  cacheDependencyGlob: string;
  pruneCache: boolean;
  cachePython: boolean;
  ignoreNothingToCache: boolean;
  ignoreEmptyWorkdir: boolean;
  toolBinDir?: string;
  toolDir?: string;
  pythonDir: string;
  githubToken: string;
  manifestFile?: string;
  addProblemMatchers: boolean;
  resolutionStrategy: "highest" | "lowest";
}

export function loadInputs(): SetupInputs {
  const workingDirectory = core.getInput("working-directory");
  const version = core.getInput("version");
  const versionFile = getVersionFile(
    workingDirectory,
    core.getInput("version-file"),
  );
  const pythonVersion = core.getInput("python-version");
  const activateEnvironment = core.getBooleanInput("activate-environment");
  const venvPath = getVenvPath(
    workingDirectory,
    core.getInput("venv-path"),
    activateEnvironment,
  );
  const checksum = core.getInput("checksum");
  const enableCache = getEnableCache(core.getInput("enable-cache"));
  const restoreCache = core.getInput("restore-cache") === "true";
  const saveCache = core.getInput("save-cache") === "true";
  const cacheSuffix = core.getInput("cache-suffix") || "";
  const cacheLocalPath = getCacheLocalPath(
    workingDirectory,
    versionFile,
    enableCache,
  );
  const cacheDependencyGlob = getCacheDependencyGlob(
    workingDirectory,
    core.getInput("cache-dependency-glob"),
  );
  const pruneCache = core.getInput("prune-cache") === "true";
  const cachePython = core.getInput("cache-python") === "true";
  const ignoreNothingToCache =
    core.getInput("ignore-nothing-to-cache") === "true";
  const ignoreEmptyWorkdir = core.getInput("ignore-empty-workdir") === "true";
  const toolBinDir = getToolBinDir(
    workingDirectory,
    core.getInput("tool-bin-dir"),
  );
  const toolDir = getToolDir(workingDirectory, core.getInput("tool-dir"));
  const pythonDir = getUvPythonDir();
  const githubToken = core.getInput("github-token");
  const manifestFile = getManifestFile(core.getInput("manifest-file"));
  const addProblemMatchers = core.getInput("add-problem-matchers") === "true";
  const resolutionStrategy = getResolutionStrategy(
    core.getInput("resolution-strategy"),
  );

  return {
    activateEnvironment,
    addProblemMatchers,
    cacheDependencyGlob,
    cacheLocalPath,
    cachePython,
    cacheSuffix,
    checksum,
    enableCache,
    githubToken,
    ignoreEmptyWorkdir,
    ignoreNothingToCache,
    manifestFile,
    pruneCache,
    pythonDir,
    pythonVersion,
    resolutionStrategy,
    restoreCache,
    saveCache,
    toolBinDir,
    toolDir,
    venvPath,
    version,
    versionFile,
    workingDirectory,
  };
}

function getVersionFile(
  workingDirectory: string,
  versionFileInput: string,
): string {
  if (versionFileInput !== "") {
    const tildeExpanded = expandTilde(versionFileInput);
    return resolveRelativePath(workingDirectory, tildeExpanded);
  }
  return versionFileInput;
}

function getVenvPath(
  workingDirectory: string,
  venvPathInput: string,
  activateEnvironment: boolean,
): string {
  if (venvPathInput !== "") {
    if (!activateEnvironment) {
      core.warning("venv-path is only used when activate-environment is true");
    }
    const tildeExpanded = expandTilde(venvPathInput);
    return normalizePath(resolveRelativePath(workingDirectory, tildeExpanded));
  }
  return normalizePath(resolveRelativePath(workingDirectory, ".venv"));
}

function getEnableCache(enableCacheInput: string): boolean {
  if (enableCacheInput === "auto") {
    return process.env.RUNNER_ENVIRONMENT === "github-hosted";
  }
  return enableCacheInput === "true";
}

function getToolBinDir(
  workingDirectory: string,
  toolBinDirInput: string,
): string | undefined {
  if (toolBinDirInput !== "") {
    const tildeExpanded = expandTilde(toolBinDirInput);
    return resolveRelativePath(workingDirectory, tildeExpanded);
  }
  if (process.platform === "win32") {
    if (process.env.RUNNER_TEMP !== undefined) {
      return `${process.env.RUNNER_TEMP}${path.sep}uv-tool-bin-dir`;
    }
    throw Error(
      "Could not determine UV_TOOL_BIN_DIR. Please make sure RUNNER_TEMP is set or provide the tool-bin-dir input",
    );
  }
  return undefined;
}

function getToolDir(
  workingDirectory: string,
  toolDirInput: string,
): string | undefined {
  if (toolDirInput !== "") {
    const tildeExpanded = expandTilde(toolDirInput);
    return resolveRelativePath(workingDirectory, tildeExpanded);
  }
  if (process.platform === "win32") {
    if (process.env.RUNNER_TEMP !== undefined) {
      return `${process.env.RUNNER_TEMP}${path.sep}uv-tool-dir`;
    }
    throw Error(
      "Could not determine UV_TOOL_DIR. Please make sure RUNNER_TEMP is set or provide the tool-dir input",
    );
  }
  return undefined;
}

function getCacheLocalPath(
  workingDirectory: string,
  versionFile: string,
  enableCache: boolean,
): CacheLocalPath | undefined {
  const cacheLocalPathInput = core.getInput("cache-local-path");
  if (cacheLocalPathInput !== "") {
    const tildeExpanded = expandTilde(cacheLocalPathInput);
    return {
      path: resolveRelativePath(workingDirectory, tildeExpanded),
      source: CacheLocalSource.Input,
    };
  }
  const cacheDirFromConfig = getCacheDirFromConfig(
    workingDirectory,
    versionFile,
  );
  if (cacheDirFromConfig !== undefined) {
    return { path: cacheDirFromConfig, source: CacheLocalSource.Config };
  }
  if (process.env.UV_CACHE_DIR !== undefined) {
    core.info(`UV_CACHE_DIR is already set to ${process.env.UV_CACHE_DIR}`);
    return { path: process.env.UV_CACHE_DIR, source: CacheLocalSource.Env };
  }
  if (enableCache) {
    if (process.env.RUNNER_ENVIRONMENT === "github-hosted") {
      if (process.env.RUNNER_TEMP !== undefined) {
        return {
          path: `${process.env.RUNNER_TEMP}${path.sep}setup-uv-cache`,
          source: CacheLocalSource.Default,
        };
      }
      throw Error(
        "Could not determine UV_CACHE_DIR. Please make sure RUNNER_TEMP is set or provide the cache-local-path input",
      );
    }
    if (process.platform === "win32") {
      return {
        path: `${process.env.APPDATA}${path.sep}uv${path.sep}cache`,
        source: CacheLocalSource.Default,
      };
    }
    return {
      path: `${process.env.HOME}${path.sep}.cache${path.sep}uv`,
      source: CacheLocalSource.Default,
    };
  }
}

function getCacheDirFromConfig(
  workingDirectory: string,
  versionFile: string,
): string | undefined {
  for (const filePath of [versionFile, "uv.toml", "pyproject.toml"]) {
    const resolvedPath = resolveRelativePath(workingDirectory, filePath);
    try {
      const cacheDir = getConfigValueFromTomlFile(resolvedPath, "cache-dir");
      if (cacheDir !== undefined) {
        core.info(`Found cache-dir in ${resolvedPath}: ${cacheDir}`);
        return cacheDir;
      }
    } catch (err) {
      const message = (err as Error).message;
      core.warning(`Error while parsing ${filePath}: ${message}`);
      return undefined;
    }
  }
  return undefined;
}

export function getUvPythonDir(): string {
  if (process.env.UV_PYTHON_INSTALL_DIR !== undefined) {
    core.info(
      `UV_PYTHON_INSTALL_DIR is already set to ${process.env.UV_PYTHON_INSTALL_DIR}`,
    );
    return process.env.UV_PYTHON_INSTALL_DIR;
  }
  if (process.env.RUNNER_ENVIRONMENT !== "github-hosted") {
    if (process.platform === "win32") {
      return `${process.env.APPDATA}${path.sep}uv${path.sep}python`;
    }
    return `${process.env.HOME}${path.sep}.local${path.sep}share${path.sep}uv${path.sep}python`;
  }
  if (process.env.RUNNER_TEMP !== undefined) {
    return `${process.env.RUNNER_TEMP}${path.sep}uv-python-dir`;
  }
  throw Error(
    "Could not determine UV_PYTHON_INSTALL_DIR. Please make sure RUNNER_TEMP is set or provide the UV_PYTHON_INSTALL_DIR environment variable",
  );
}

function getCacheDependencyGlob(
  workingDirectory: string,
  cacheDependencyGlobInput: string,
): string {
  if (cacheDependencyGlobInput !== "") {
    return cacheDependencyGlobInput
      .split("\n")
      .map((part) => part.trim())
      .map((part) => expandTilde(part))
      .map((part) => resolveRelativePath(workingDirectory, part))
      .join("\n");
  }
  return cacheDependencyGlobInput;
}

function expandTilde(input: string): string {
  if (input.startsWith("~")) {
    return `${process.env.HOME}${input.substring(1)}`;
  }
  return input;
}

function normalizePath(inputPath: string): string {
  const normalized = path.normalize(inputPath);
  const root = path.parse(normalized).root;

  // Remove any trailing path separators, except when the whole path is the root.
  let trimmed = normalized;
  while (trimmed.length > root.length && trimmed.endsWith(path.sep)) {
    trimmed = trimmed.slice(0, -1);
  }

  return trimmed;
}

function resolveRelativePath(
  workingDirectory: string,
  inputPath: string,
): string {
  const hasNegation = inputPath.startsWith("!");
  const pathWithoutNegation = hasNegation ? inputPath.substring(1) : inputPath;

  const resolvedPath = path.resolve(workingDirectory, pathWithoutNegation);

  core.debug(
    `Resolving relative path ${inputPath} to ${hasNegation ? "!" : ""}${resolvedPath}`,
  );
  return hasNegation ? `!${resolvedPath}` : resolvedPath;
}

function getManifestFile(manifestFileInput: string): string | undefined {
  if (manifestFileInput !== "") {
    return manifestFileInput;
  }
  return undefined;
}

function getResolutionStrategy(
  resolutionStrategyInput: string,
): "highest" | "lowest" {
  if (resolutionStrategyInput === "lowest") {
    return "lowest";
  }
  if (resolutionStrategyInput === "highest" || resolutionStrategyInput === "") {
    return "highest";
  }
  throw new Error(
    `Invalid resolution-strategy: ${resolutionStrategyInput}. Must be 'highest' or 'lowest'.`,
  );
}