Log simplified

index.js

@@ -5,104 +5,112 @@ const { glob } = require("glob");
 const path = require("path");
 
 /**
- * Replaces specific placeholder strings within the provided content with corresponding dynamic values.
+ * Replaces placeholder strings in content with dynamic values.
  *
- * This function specifically targets three placeholders:
- * - {{gitHash}} is replaced with the current Git commit hash, obtained from the GITHUB_SHA environment variable.
- * - {{gitRef}} is replaced with the Git reference (branch or tag) that triggered the workflow, obtained from the GITHUB_REF environment variable.
- * - {{deployTime}} is replaced with the current ISO timestamp.
- *
- * Note: This function is designed for use within a GitHub Actions workflow where GITHUB_SHA and GITHUB_REF environment variables are automatically set.
- *
- * @param {string} content - The string content in which placeholders are to be replaced.
- * @returns {string} The content with placeholders replaced by their respective dynamic values.
+ * @param {string} content
+ * @param {string} hostname
+ * @returns {string}
  */
 function replacePlaceholders(content, hostname) {
   const deployTime = new Date().toISOString();
+  const gitHash = process.env.GITHUB_SHA;
+  const gitRef = process.env.GITHUB_REF;
+
+  core.info("Replacing placeholders:");
+  core.info(`  GITHUB_SHA: ${gitHash}`);
+  core.info(`  GITHUB_REF: ${gitRef}`);
+  core.info(`  deployTime: ${deployTime}`);
+  core.info(`  hostname: ${hostname}`);
+
   return content
-    .replace(/{{gitHash}}/g, process.env.GITHUB_SHA)
-    .replace(/{{gitRef}}/g, process.env.GITHUB_REF)
+    .replace(/{{gitHash}}/g, gitHash)
+    .replace(/{{gitRef}}/g, gitRef)
     .replace(/{{deployTime}}/g, deployTime)
     .replace(/{{hostname}}/g, hostname);
 }
 
 /**
- * Reads all files matching a specified pattern, replaces certain placeholders in their content, and writes the updated content back to the files.
+ * Replaces placeholders in files matched by glob.
  *
- * This function searches for files in the filesystem using the provided glob pattern, optionally prefixed. It reads each file,
- * uses the `replacePlaceholders` function to replace specific placeholders in the file's content, and then writes the modified content
- * back to the original file. This is useful for dynamically updating file contents in a batch process, such as during a build or deployment.
- *
- * @param {string} pattern - The glob pattern used to find files. Example: '*.js' for all JavaScript files.
- * @param {string} [prefix] - An optional directory prefix to prepend to the glob pattern. This allows searching within a specific directory.
- * @returns {Promise<string[]>} A promise that resolves with an array of file paths that were processed, or rejects with an error if the process fails.
+ * @param {string} pattern
+ * @param {string} [prefix]
+ * @param {string} hostname
+ * @returns {Promise<string[]>}
  */
-async function readReplaceAndWriteFiles(pattern, prefix, hostname) {
+function readReplaceAndWriteFiles(pattern, prefix, hostname) {
   return new Promise((resolve, reject) => {
     const globPattern = prefix ? path.join(prefix, pattern) : pattern;
 
-    glob(globPattern, async (err, files) => {
-      if (err) {
-        return reject(err);
-      }
-      let processPromises = [];
+    glob(globPattern, (err, files) => {
+      if (err) return reject(err);
 
-      files.forEach((file) => {
-        let processPromise = fs.promises
+      if (!files.length) {
+        core.warning(
+          `No files matched for placeholder replacement: ${globPattern}`,
+        );
+        return resolve([]);
+      }
+
+      core.info(`📝 Matched files for replacement:`);
+      files.forEach((file) => core.info(`  - ${file}`));
+
+      const promises = files.map((file) =>
+        fs.promises
           .readFile(file, "utf8")
           .then((content) => {
             content = replacePlaceholders(content, hostname);
             return fs.promises.writeFile(file, content);
-          });
+          })
+          .then(() => {
+            core.info(`Replaced placeholders in file: ${file}`);
+          }),
+      );
 
-        processPromises.push(processPromise);
-      });
-
-      try {
-        await Promise.all(processPromises);
-        resolve(files);
-      } catch (processError) {
-        reject(processError);
-      }
+      Promise.all(promises)
+        .then(() => {
+          core.info(
+            `Successfully replaced placeholders in ${files.length} file(s).`,
+          );
+          resolve(files);
+        })
+        .catch(reject);
     });
   });
 }
 
 /**
- * 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.
+ * Reads files into a dictionary of key → content.
+ *
+ * @param {string} pattern
+ * @param {string} prefix
+ * @returns {Promise<Object>}
  */
 function readFilesIntoDict(pattern, prefix) {
-  // Prepend the prefix to the glob pattern
-  const globPattern = prefix ? path.join(prefix, pattern) : pattern;
-
   return new Promise((resolve, reject) => {
+    const globPattern = prefix ? path.join(prefix, pattern) : pattern;
+
     glob(globPattern, (err, files) => {
-      if (err) {
-        return reject(err);
+      if (err) return reject(err);
+
+      if (!files.length) {
+        core.warning(`No files matched for upload: ${globPattern}`);
+      } else {
+        core.info(`📁 Matched files for upload:`);
+        files.forEach((file) => core.info(`  - ${file}`));
       }
 
-      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
+      const fileDict = {};
+      const readPromises = files.map((file) =>
+        fs.promises.readFile(file, "utf8").then((content) => {
           let key = file;
           if (prefix && file.startsWith(prefix)) {
             key = key.slice(prefix.length);
           }
-          key = path.basename(key, path.extname(key)); // Drop the file suffix
-
+          key = path.basename(key, path.extname(key));
           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);
@@ -111,96 +119,106 @@ function readFilesIntoDict(pattern, prefix) {
 }
 
 /**
- * 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.
+ * Validates provided credentials.
+ *
+ * @param {string} token
+ * @param {string} username
+ * @param {string} password
+ * @returns {string|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.";
-    }
+  if (token && (username || password)) {
+    return "Token is defined along with username and/or password.";
   }
-  return null; // No errors found
+  if (!token && (!username || !password)) {
+    return "Username and password must both be defined if token is not used.";
+  }
+  return null;
 }
 
 /**
- * Posts code to Screeps server.
+ * Main logic for uploading code to Screeps.
  */
-async function postCode() {
+function postCode() {
+  core.info("🟢 Starting Screeps upload action...");
+
   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 gitReplace = core.getInput("git-replace") || null;
 
-  if (gitReplace) {
-    await readReplaceAndWriteFiles(gitReplace, prefix, hostname);
-  }
-
-  const files_to_push = await readFilesIntoDict(pattern, prefix);
-
-  core.info(`Trying to upload the following files to ${branch}:`);
-  Object.keys(files_to_push).forEach((key) => {
-    core.info(`Key: ${key}`);
-  });
-
   const login_arguments = {
-    token: token,
-    username: username,
-    password: password,
-    protocol: protocol,
-    hostname: hostname,
-    port: port,
-    path: path,
+    token,
+    username,
+    password,
+    protocol,
+    hostname,
+    port,
+    path,
   };
 
-  core.info("login_arguments:");
-  core.info(JSON.stringify(login_arguments, null, 2));
+  core.info("🔧 Inputs:");
+  core.info(`  prefix: ${prefix}`);
+  core.info(`  pattern: ${pattern}`);
+  core.info(`  branch: ${branch}`);
+  core.info(`  gitReplace: ${gitReplace}`);
 
   const errorMessage = validateAuthentication(token, username, password);
   if (errorMessage) {
-    core.error(errorMessage);
-    return;
+    core.setFailed(errorMessage);
+    return Promise.reject(new Error(errorMessage));
   }
-  let api = new ScreepsAPI(login_arguments);
-  if (token) {
-    const response = await api.code.set(branch, files_to_push);
-    core.info(JSON.stringify(response, null, 2));
-    console.log(`Code set successfully to ${branch}`);
-  } else {
-    core.info(`Logging in as user ${username}`);
-    await Promise.resolve()
-      .then(() => api.auth(username, password, login_arguments))
-      .then(() => {
-        api.code.set(branch, files_to_push);
-      })
-      .then(() => {
-        console.log(`Code set successfully to ${branch}`);
-      })
-      .catch((err) => {
-        console.error("Error:", err);
+
+  const replacePromise = gitReplace
+    ? readReplaceAndWriteFiles(gitReplace, prefix, hostname)
+    : Promise.resolve();
+
+  return replacePromise
+    .then(() => readFilesIntoDict(pattern, prefix))
+    .then((files_to_push) => {
+      const fileCount = Object.keys(files_to_push).length;
+      core.info(`📦 Files prepared for upload: ${fileCount}`);
+
+      if (fileCount === 0) {
+        core.warning("No files were found to upload. Exiting.");
+        return;
+      }
+
+      core.info(`⬆️ Uploading to branch '${branch}':`);
+      Object.keys(files_to_push).forEach((key) => {
+        core.info(`  - ${key}`);
       });
-  }
+
+      const api = new ScreepsAPI(login_arguments);
+
+      if (token) {
+        return api.code.set(branch, files_to_push).then((response) => {
+          core.info(JSON.stringify(response, null, 2));
+          core.info(`✅ Code uploaded to branch '${branch}' using token.`);
+        });
+      } else {
+        core.info(`🔐 Logging in as user '${username}'...`);
+        return api
+          .auth(username, password, login_arguments)
+          .then(() => api.code.set(branch, files_to_push))
+          .then(() => {
+            core.info(`✅ Code uploaded to branch '${branch}' via basic auth.`);
+          });
+      }
+    });
 }
-postCode();
+
+// Kick off the process and ensure failures are surfaced
+postCode().catch((err) => {
+  core.setFailed(err.message || err);
+});
+
+core.info(`✅ Final Code uploaded to branch via basic auth.`);
+core.debug(`✅ DEBUG Final Code uploaded to branch via basic auth. DEBUG`);