Bump node version to 24 and update dependencies.

README.md

@@ -57,5 +57,5 @@ If you can use plain SSH keys that may be easier.
 
 # Compatibility with custom runners
 
-The latest version of this action runs on `node20`.
-If your custom runner doesn't support `node20` yet, you can pin the action to `v2.0` which runs on `node16`.
+The latest version of this action runs on `node24`.
+If your custom runner doesn't support `node24` yet, you can pin the action to `v2.1` which runs on `node20`.

action.yml

@@ -9,5 +9,5 @@ inputs:
     description: git credentials to use
 
 runs:
-  using: node20
-  main: lib/main.js
+  using: node24
+  main: lib/main.mjs

lib/main.mjs

@@ -0,0 +1,58 @@
+import * as core from '@actions/core';
+import * as exec from '@actions/exec';
+import { promises as fs } from 'fs';
+import * as process from 'process';
+import * as os from 'os';
+function xdg_config_home() {
+    const xdg_config_home = process.env['XDG_CONFIG_HOME'];
+    if (xdg_config_home)
+        return xdg_config_home;
+    return `${os.homedir()}/.config`;
+}
+function non_empty_trimmed_lines(input) {
+    return input.split(/\r?\n/)
+        .map(line => line.trim())
+        .filter(line => line.length > 0);
+}
+async function run() {
+    const credentials = non_empty_trimmed_lines(core.getInput('credentials', { required: true }));
+    for (const credential of credentials) {
+        core.setSecret(credential);
+    }
+    // Get the current credentials so we can avoid adding duplicates.
+    // On self-hosted runners, the credentials file could be retained between runs, so we don't want to add duplicates.
+    await fs.mkdir(`${xdg_config_home()}/git`, { recursive: true });
+    const file = await fs.open(`${xdg_config_home()}/git/credentials`, "a+", 0o600);
+    try {
+        const contents = (await file.readFile()).toString();
+        const old_credentials = new Set(non_empty_trimmed_lines(contents));
+        for (const credential of old_credentials) {
+            core.setSecret(credential);
+        }
+        const new_credentials = credentials.filter(entry => !old_credentials.has(entry));
+        // If the file didn't end with a newline, add one.
+        if (contents.length > 0 && !contents.endsWith("\n")) {
+            await file.write("\n");
+        }
+        // Add credentials that aren't already in the file.
+        for (const credential of new_credentials) {
+            await file.write(credential + "\n");
+        }
+    }
+    finally {
+        await file.close();
+    }
+    // Add git configuration.
+    await exec.exec('git', ['config', '--global', 'credential.helper', 'store']);
+    await exec.exec('git', ['config', '--global', '--replace-all', 'url.https://github.com/.insteadOf', 'ssh://git@github.com/']);
+    await exec.exec('git', ['config', '--global', '--add', 'url.https://github.com/.insteadOf', 'git@github.com:']);
+}
+run().catch(error => {
+    if (error instanceof Error) {
+        core.setFailed(error.message);
+    }
+    else {
+        core.setFailed(String(error));
+    }
+});
+//# sourceMappingURL=data:application/json;base64,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