screeps-deploy-action/index.js

const { ScreepsAPI } = require("screeps-api");
const core = require("@actions/core");
const fs = require("fs");
const glob = require("glob");
const path = require("path");

/**
 * Reads files matching a glob pattern into a dictionary.
 * @param {string} pattern - Glob pattern to match files.
 * @param {string} prefix - Directory prefix for file paths.
 * @returns {Promise<Object>} - Promise resolving to a dictionary of file contents keyed by filenames.
 */
function readFilesIntoDict(pattern, prefix) {
  // Prepend the prefix to the glob pattern
  const globPattern = prefix ? path.join(prefix, pattern) : pattern;

  return new Promise((resolve, reject) => {
    glob(globPattern, (err, files) => {
      if (err) {
        return reject(err);
      }

      let fileDict = {};
      let readPromises = [];

      files.forEach((file) => {
        let readPromise = fs.promises.readFile(file, "utf8").then((content) => {
          // Remove the prefix from the filename and drop the file suffix
          let key = file;
          if (prefix && file.startsWith(prefix)) {
            key = key.slice(prefix.length);
          }
          key = path.basename(key, path.extname(key)); // Drop the file suffix

          fileDict[key] = content;
        });

        readPromises.push(readPromise);
      });

      // Use Promise.all to ensure all files are read before resolving
      Promise.all(readPromises)
        .then(() => resolve(fileDict))
        .catch(reject);
    });
  });
}

/**
 * Validates the provided authentication credentials.
 * @param {string} token - The authentication token.
 * @param {string} username - The username.
 * @param {string} password - The password.
 * @returns {string|null} - Returns an error message if validation fails, otherwise null.
 */
function validateAuthentication(token, username, password) {
  if (token) {
    if (username || password) {
      return "Token is defined along with username and/or password.";
    }
  } else {
    if (!username && !password) {
      return "Neither token nor password and username are defined.";
    }
    if (username && !password) {
      return "Username is defined but no password is provided.";
    }
    if (!username && password) {
      return "Password is defined but no username is provided.";
    }
  }
  return null; // No errors found
}

/**
 * Posts code to Screeps server.
 */
async function postCode() {
  const protocol = core.getInput("protocol") || "https";
  const hostname = core.getInput("hostname") || "screeps.com";
  const port = core.getInput("port") || "443";
  const path = core.getInput("path") || "/";

  const token = core.getInput("token") || undefined;
  const username = core.getInput("username") || undefined;
  const password = core.getInput("password") || undefined;
  const prefix = core.getInput("source-prefix");
  const pattern = core.getInput("pattern") || "*.js";
  const branch = core.getInput("branch") || "default";

  const files_to_push = await readFilesIntoDict(pattern, prefix);

  Object.keys(files_to_push).forEach((key) => {
    core.info(`Key: ${key}`);
  });

  core.info(files_to_push);

  const login_arguments = {
    token: token,
    protocol: protocol,
    hostname: hostname,
    port: port,
    path: path,
  };

  core.info(`Trying to upload the following files to ${branch}:`);
  Object.keys(login_arguments).forEach((key) => {
    core.info(`Key: ${key}`);
  });

  const errorMessage = validateAuthentication(token, username, password);
  if (errorMessage) {
    core.error(errorMessage);
    return;
  }
  let api;
  if (token) {
    api = new ScreepsAPI(login_arguments);
  } else {
    core.info(`Logging into as usewr ${username}`);
    api = new ScreepsAPI();
    api.auth(username, password, login_arguments);
  }
  const response = await api.code.set(branch, files_to_push);
  core.info(JSON.stringify(response, null, 2));
}

postCode();