sliftutils 1.7.126 → 1.7.127

package/security/authorizedKeys/secureSSH.ts

@@ -8,7 +8,7 @@ import { deriveRevokeKey, REVOKE_KEY_LABEL, revokeRepoURL } from "./revokeSource
 import { revokedKeysInRepo } from "./unrevoke";
 import { expandHome } from "../helpers/paths";
 import { spawnPromise } from "../helpers/spawn";
-import { readRemoteFile, remoteCommandExists, runOverSSH, SUDO_PREAMBLE, writeRemoteFile } from "../helpers/remoteSSH";
+import { describeHost, readRemoteFile, remoteCommandExists, runOverSSH, SUDO_PREAMBLE, THIS_MACHINE, writeRemoteFile } from "../helpers/remoteSSH";
 
 const SERVICE_SOURCE = path.join(__dirname, "daemon", "portsecure.service");
 // The daemon runs from a checkout of this repo on the host, rather than from a copy we upload, so
@@ -22,12 +22,16 @@ const ROOT_AUTHORIZED_KEYS = "/root/.ssh/authorized_keys";
 const SERVICE_NAME = "portsecure";
 const MAX_ERROR_BODY_LENGTH = 500;
 const VERBS = ["add", "remove", "list", "update"];
-// The repo url is optional, and defaults to the repo the command is run from.
+// The host is optional, and without one everything happens on this machine. The repo url is
+// optional too, and defaults to the repo the command is run from.
 const USAGE = `Usage:
-  yarn securessh <host> add <repo-private-key> [repo-url]
-  yarn securessh <host> remove [repo-url]
-  yarn securessh <host> list
-  yarn securessh <host> update`;
+  yarn securessh [host] add <repo-private-key> [repo-url]
+  yarn securessh [host] remove [repo-url]
+  yarn securessh [host] list
+  yarn securessh [host] update
+
+With no host it acts on this machine, and still installs from github rather than from wherever
+this was run.`;
 
 async function pathExists(filePath: string) {
     try {
@@ -176,7 +180,19 @@ async function ensureRevokeReposExist(repoSources: string[]) {
         let revokeURL = revokeRepoURL(repoURL);
         let temporaryDirectory = await fs.mkdtemp(path.join(os.tmpdir(), "portsecure-revoke-"));
         let checkoutPath = path.join(temporaryDirectory, "repo");
-        let clone = await runLocal({ command: "git", args: ["clone", revokeURL, checkoutPath], allowFailure: true });
+        // On a machine that is already a portsecure host, the source's deploy key is right there,
+        // and the key derived from it is the one credential that repo is guaranteed to accept.
+        // Anywhere else, a person is running this and has their own access.
+        let ownKey = "";
+        if (await pathExists(sourceKeyPath(repoURL))) {
+            let derived = deriveRevokeKey(await fs.readFile(sourceKeyPath(repoURL), "utf8"));
+            ownKey = path.join(temporaryDirectory, "key");
+            await fs.writeFile(ownKey, derived.privateKeyFile, { mode: 0o600 });
+        }
+        let cloneRevoke = async (allowFailure: boolean) => ownKey
+            && await gitWithKey({ keyPath: ownKey, args: ["clone", revokeURL, checkoutPath], allowFailure })
+            || await runLocal({ command: "git", args: ["clone", revokeURL, checkoutPath], allowFailure });
+        let clone = await cloneRevoke(true);
         if (clone.status !== 0) {
             await fs.rm(temporaryDirectory, { recursive: true, force: true });
             throw new Error(
@@ -194,10 +210,15 @@ async function ensureRevokeReposExist(repoSources: string[]) {
             for (let args of [
                 ["-C", checkoutPath, "add", "-A"],
                 ["-C", checkoutPath, "-c", "user.email=portsecure@localhost", "-c", "user.name=portsecure", "commit", "-m", "initialise revoke repo"],
-                ["-C", checkoutPath, "push", "origin", "HEAD"],
             ]) {
                 await runLocal({ command: "git", args });
             }
+            let push = ["-C", checkoutPath, "push", "origin", "HEAD"];
+            if (ownKey) {
+                await gitWithKey({ keyPath: ownKey, args: push });
+            } else {
+                await runLocal({ command: "git", args: push });
+            }
         }
         await fs.rm(temporaryDirectory, { recursive: true, force: true });
         console.log(`${revokeURL} is ready`);
@@ -296,14 +317,24 @@ async function installDaemon(config: { host: string; hostLabel: string; repoSour
 
     // The checkout is brought to the latest commit rather than a copy being pushed, so what runs on
     // the host is exactly what is on github.
-    console.log(`Updating ${REMOTE_CHECKOUT_PATH} on ${host}`);
+    console.log(`Updating ${REMOTE_CHECKOUT_PATH} on ${describeHost(host)}`);
     await runOverSSH({
         host,
         script: `${SUDO_PREAMBLE}
 set -e
 $SUDO mkdir -p "${path.posix.dirname(REMOTE_CHECKOUT_PATH)}"
 if $SUDO test -d "${REMOTE_CHECKOUT_PATH}/.git"; then
+    # Stashed first, the way machine-alwaysup does it. Anything sitting modified in a host's
+    # checkout is either an accident or somebody editing the daemon in place, and either way it is
+    # worth keeping rather than quietly erasing. The identity is passed inline because a host has
+    # no git config of its own and stash writes a commit.
+    $SUDO git -C "${REMOTE_CHECKOUT_PATH}" add --all
+    $SUDO git -C "${REMOTE_CHECKOUT_PATH}" -c user.email=portsecure@localhost -c user.name=portsecure stash
     $SUDO git -C "${REMOTE_CHECKOUT_PATH}" fetch --prune origin
+    # A stash and a pull cannot cross a branch that has diverged, and a drifted checkout must not be
+    # able to leave a host running old code, so it is put on the remote's state rather than merged
+    # with it. set-head so that is the remote's default branch now, not the one it had at clone.
+    $SUDO git -C "${REMOTE_CHECKOUT_PATH}" remote set-head origin --auto
     $SUDO git -C "${REMOTE_CHECKOUT_PATH}" reset --hard origin/HEAD
 else
     $SUDO rm -rf "${REMOTE_CHECKOUT_PATH}"
@@ -368,7 +399,7 @@ async function requireRemoteWebhook(host: string) {
         throw new Error(
             `Expected a Discord webhook at ${DEFAULT_WEBHOOK_FILE_PATH} on ${host}, no such file exists.`
             + ` The daemon will not start without one.\n`
-            + `Set it up first:\n  yarn setupnotify ${host} <discord-webhook-url>`
+            + `Set it up first:\n  yarn setupnotify ${host} <discord-webhook-url>`.replace(" <discord", host && " <discord" || "<discord")
         );
     }
     return parseWebhookFile({ contents, sourceName: `${host}:${DEFAULT_WEBHOOK_FILE_PATH}` });
@@ -392,18 +423,22 @@ async function addSource(config: { host: string; keyPath: string; repoURL: strin
 
     let remoteConfig = await readRemoteConfig(host);
     if (remoteConfig.repoSources.includes(repoURL)) {
-        console.log(`${host} already has ${repoURL}, refreshing its key and the daemon.`);
+        console.log(`${describeHost(host)} already has ${repoURL}, refreshing its key and the daemon.`);
     }
 
-    // The merged result is what root ends up with, so our own key has to be somewhere in it.
-    console.log(`Checking our access to ${host} survives the merged keys`);
-    let ourFingerprint = await findAuthenticatingFingerprint(host);
+    // The merged result is what root ends up with, so our own key has to be somewhere in it. On
+    // this machine there is no ssh session to preserve, so there is nothing to check.
+    let ourFingerprint = "";
+    if (host) {
+        console.log(`Checking our access to ${describeHost(host)} survives the merged keys`);
+        ourFingerprint = await findAuthenticatingFingerprint(host);
+    }
     let inspectionPath = await cloneRepoForInspection({ repoURL, keyPath });
     let newKeys = await readRepoKeys(inspectionPath);
     // Whatever is applied on the host came from the existing sources, so it stays in the merge.
     let existingKeys = normalizeKeys(await readRemoteFile({ host, filePath: ROOT_AUTHORIZED_KEYS }) || "");
     let mergedFingerprints = await fingerprintKeys([...existingKeys, ...newKeys]);
-    if (!mergedFingerprints.includes(ourFingerprint)) {
+    if (ourFingerprint && !mergedFingerprints.includes(ourFingerprint)) {
         throw new Error(
             `Expected the key we use for ${host} to be in the merged keys, it is not.\n`
             + `Ours:   ${ourFingerprint}\n`
@@ -412,7 +447,9 @@ async function addSource(config: { host: string; keyPath: string; repoURL: strin
             + ` lock you out of ${host}. Add your public key to ${repoURL} first.`
         );
     }
-    console.log(`Our key ${ourFingerprint} is in the merged keys, access will survive.`);
+    if (ourFingerprint) {
+        console.log(`Our key ${ourFingerprint} is in the merged keys, access will survive.`);
+    }
 
     await ensureRevokeRepo({ keyPath, repoURL });
 
@@ -428,7 +465,7 @@ async function addSource(config: { host: string; keyPath: string; repoURL: strin
     }
 
     let webhookURL = await requireRemoteWebhook(host);
-    console.log(`${host} notifies ${webhookURL}`);
+    console.log(`${describeHost(host)} notifies ${webhookURL}`);
 
     await writeRemoteFile({
         host,
@@ -441,7 +478,7 @@ async function addSource(config: { host: string; keyPath: string; repoURL: strin
     let repoSources = remoteConfig.repoSources.filter(source => source !== repoURL);
     repoSources.push(repoURL);
     await installDaemon({ host, hostLabel: remoteConfig.hostLabel, repoSources });
-    console.log(`${repoURL} added to ${host}. ${repoSources.length} source(s) now merged.`);
+    console.log(`${repoURL} added to ${describeHost(host)}. ${repoSources.length} source(s) now merged.`);
 }
 
 async function removeSource(config: { host: string; repoURL: string }) {
@@ -455,9 +492,10 @@ async function removeSource(config: { host: string; repoURL: string }) {
     }
     let repoSources = remoteConfig.repoSources.filter(source => source !== repoURL);
 
-    if (repoSources.length) {
+    // On this machine there is no ssh session to preserve, so there is nothing to check.
+    if (repoSources.length && host) {
         // The keys left over are what root gets, so our own key has to be among them.
-        console.log(`Checking our access to ${host} survives without ${repoURL}`);
+        console.log(`Checking our access to ${describeHost(host)} survives without ${repoURL}`);
         let ourFingerprint = await findAuthenticatingFingerprint(host);
         let remainingKeys: string[] = [];
         for (let source of repoSources) {
@@ -485,47 +523,15 @@ $SUDO rm -f "${sourceKeyPath(repoURL)}"
 $SUDO rm -rf "${sourceRepoPath(repoURL)}"`,
     });
     await installDaemon({ host, hostLabel: remoteConfig.hostLabel, repoSources });
-    console.log(`${repoURL} removed from ${host}. ${repoSources.length} source(s) left.`);
+    console.log(`${repoURL} removed from ${describeHost(host)}. ${repoSources.length} source(s) left.`);
 }
 
 /** Answers "who can log into this box, and which repo says so". The paths the daemon uses are
     left out on purpose, they are plumbing rather than something to act on. */
-/** The daemon is installed from this checkout, so the checkout is brought up to date first.
-    Anything that stops the pull - a conflict, local commits, no upstream - stops the update too,
-    rather than quietly installing whatever happened to be on disk. */
-async function pullLocalCheckout() {
-    let topLevel = await spawnPromise({ command: "git", args: ["rev-parse", "--show-toplevel"], cwd: __dirname });
-    if (topLevel.status !== 0) {
-        throw new Error(
-            `Expected ${__dirname} to be inside a git checkout, it is not.`
-            + ` update installs the daemon from this checkout, so it has to be one.`
-        );
-    }
-    let repoPath = topLevel.stdout.trim();
-    let pull = await spawnPromise({ command: "git", args: ["pull", "--ff-only"], cwd: repoPath });
-    if (pull.status !== 0) {
-        throw new Error(
-            `Expected git pull in ${repoPath} to succeed, it did not, so nothing was installed.\n`
-            + `${(pull.stdout + pull.stderr).trim().slice(0, MAX_ERROR_BODY_LENGTH)}`
-        );
-    }
-    // The host installs from github, not from here, so local commits that have not been pushed
-    // are not what it will run.
-    let local = await spawnPromise({ command: "git", args: ["rev-parse", "HEAD"], cwd: repoPath });
-    let remote = await spawnPromise({ command: "git", args: ["rev-parse", "@{u}"], cwd: repoPath });
-    if (local.stdout.trim() !== remote.stdout.trim()) {
-        console.log(`WARNING: ${repoPath} has commits that are not pushed. The host installs from github,`);
-        console.log(`         so it will run the pushed version, not what is here.`);
-    }
-    console.log(`Pulled ${repoPath}`);
-}
 
 /** Pushes the current daemon onto a host that already has one, for when this code has moved on.
     Nothing about which keys the host trusts is touched. */
 async function updateDaemon(host: string) {
-    // Pulled before anything else, so a checkout that cannot be brought up to date fails here
-    // rather than after we have already started changing the host.
-    await pullLocalCheckout();
     let contents = await readRemoteFile({ host, filePath: REMOTE_CONFIG_PATH });
     if (!contents) {
         throw new Error(
@@ -538,16 +544,21 @@ async function updateDaemon(host: string) {
     await requireRemoteWebhook(host);
     await ensureRevokeReposExist(repoSources);
     await installDaemon({ host, hostLabel: parsed.hostLabel || host, repoSources });
-    console.log(`Updated the daemon on ${host}. ${repoSources.length} source(s), unchanged.`);
+    console.log(`Updated the daemon on ${describeHost(host)}, and restarted it.`);
+    console.log(`Its ${repoSources.length} key source(s) were left as they are, along with the keys and`);
+    console.log(`signers it has already accepted. Only the daemon itself changed:`);
+    for (let repoURL of repoSources) {
+        console.log(`  ${repoURL}`);
+    }
 }
 
 async function listSources(host: string) {
     let remoteConfig = await readRemoteConfig(host);
     if (!remoteConfig.repoSources.length) {
-        console.log(`${host} has no key sources. root's authorized_keys is left exactly as it is.`);
+        console.log(`${describeHost(host)} has no key sources. root's authorized_keys is left exactly as it is.`);
         return;
     }
-    console.log(`${host} lets root log in with the keys from ${remoteConfig.repoSources.length} repo(s):`);
+    console.log(`${describeHost(host)} lets root log in with the keys from ${remoteConfig.repoSources.length} repo(s):`);
     let merged = new Set<string>();
     for (let repoURL of remoteConfig.repoSources) {
         let keys = await readRemoteSourceKeys({ host, repoURL });
@@ -578,11 +589,16 @@ function parseArgs(argv: string[]) {
         throw new Error(`Expected one of ${VERBS.join(", ")}, was ${verbs.join(" and ")}\n${USAGE}`);
     }
     let verb = verbs[0];
-    let [host, ...rest] = argv.filter(arg => arg !== verb);
-    if (!host) {
-        throw new Error(`Expected a host, was nothing\n${USAGE}`);
-    }
-    return { verb, host, rest };
+    let positional = argv.filter(arg => arg !== verb);
+    // A host, when there is one, comes first and is a bare name or address. Everything else that
+    // can appear here is a path or a repo url, and those all carry a slash, which is what tells
+    // them apart. So no host at all means this machine.
+    let host = THIS_MACHINE;
+    if (positional.length && !/[\/~\\]/.test(positional[0])) {
+        host = positional[0];
+        positional = positional.slice(1);
+    }
+    return { verb, host, rest: positional };
 }
 
 export async function main() {

package/security/authorizedKeys/unrevoke.ts

@@ -4,17 +4,20 @@ import path from "path";
 import { runPromise } from "socket-function/src/runPromise";
 import { keyFingerprint, normalizeKeys } from "./authorizedKeys";
 import { revokeRepoURL } from "./revokeSource";
+import { signRepo } from "../signedFiles/signFiles";
 import { readRepoKeys } from "./authorizedKeys";
 import { expandHome } from "../helpers/paths";
 import { spawnPromise } from "../helpers/spawn";
 
 const UNREVOKES_DIR = "unrevoked";
 const REVOCATIONS_DIR = "revocations";
-const USAGE = `Usage: yarn unrevoke [keys-repo]
+const GIT_KEYWORD = "git";
+const COMMIT_MESSAGE = "unrevoke keys";
+const USAGE = `Usage: yarn unrevoke [keys-repo] [${GIT_KEYWORD}]
 
 Run this in a keys repo, or name one. It reads that repo's revoke repo and writes one unrevoke file
 naming every revocation in it, so the keys are accepted again once each machine's hour long wait
-passes.
+passes. It signs the result, and with ${GIT_KEYWORD} it commits and pushes it too.
 
 Keys that were revoked should normally be deleted from the repo instead. Unrevoking only matters
 for a key you still want.`;
@@ -92,17 +95,24 @@ export async function revokedKeysInRepo(config: { repoPath: string; sourceURL: s
     repo that actually holds keys and has an origin to clone from. */
 async function resolveKeysRepo(named: string | undefined) {
     let cwd = named && expandHome(named) || undefined;
-    let repoPath = (await runPromise("git rev-parse --show-toplevel", { quiet: true, cwd })).trim();
-    if (!repoPath) {
-        throw new Error(`Expected ${named || "the current directory"} to be inside a git repo, it is not.\n${USAGE}`);
+    // spawnPromise rather than runPromise, because these two are read for their value. runPromise
+    // returns stdout and stderr joined, so one git warning ends up glued to the front of the path.
+    let topLevel = await spawnPromise({ command: "git", args: ["rev-parse", "--show-toplevel"], cwd });
+    let repoPath = topLevel.stdout.trim();
+    if (topLevel.status !== 0 || !repoPath) {
+        throw new Error(
+            `Expected ${named || "the current directory"} to be inside a git repo, it is not.\n`
+            + `${(topLevel.stdout + topLevel.stderr).trim()}\n${USAGE}`
+        );
     }
     try {
         await readRepoKeys(repoPath);
     } catch (e) {
         throw new Error(`Expected ${repoPath} to be a keys repo, it holds no keys.\n${e}\n${USAGE}`);
     }
-    let originURL = (await runPromise("git remote get-url origin", { quiet: true, cwd: repoPath })).trim();
-    if (!originURL) {
+    let origin = await spawnPromise({ command: "git", args: ["remote", "get-url", "origin"], cwd: repoPath });
+    let originURL = origin.stdout.trim();
+    if (origin.status !== 0 || !originURL) {
         throw new Error(`Expected ${repoPath} to have an origin remote, it has none.\n${USAGE}`);
     }
     return { repoPath, originURL };
@@ -110,10 +120,12 @@ async function resolveKeysRepo(named: string | undefined) {
 
 export async function main() {
     let argv = process.argv.slice(2);
-    if (argv.length > 1) {
-        throw new Error(`Expected at most a keys repo, was ${argv.length} argument(s)\n${USAGE}`);
+    let pushToGit = argv.includes(GIT_KEYWORD);
+    let positional = argv.filter(arg => arg !== GIT_KEYWORD);
+    if (positional.length > 1) {
+        throw new Error(`Expected at most a keys repo, was ${positional.length} argument(s)\n${USAGE}`);
     }
-    let { repoPath, originURL } = await resolveKeysRepo(argv[0]);
+    let { repoPath, originURL } = await resolveKeysRepo(positional[0]);
 
     let revocations = await readRemoteRevocations({ sourceURL: originURL });
     if (!revocations.length) {
@@ -144,6 +156,20 @@ export async function main() {
     for (let revocation of revocations) {
         console.log(`  ${revocation.fingerprint} revoked by ${revocation.revokedBy || "?"} from ${revocation.attempt?.ip || "?"}`);
     }
-    console.log(`Each machine waits an hour after seeing it before the keys work again.`);
-    console.log(`Sign and publish it with:\n  yarn signfiles git`);
+
+    // Signed here rather than left as a step to remember. An unrevoke nobody signed does nothing at
+    // all, and the repo would sit there looking done while every machine ignored it.
+    await signRepo({ repoPath });
+
+    if (!pushToGit) {
+        console.log(`\nCommit and push it, and each machine will wait an hour after seeing it before`);
+        console.log(`those keys work again:`);
+        console.log(`\`\`\`\ngit add -A\ngit commit -m "${COMMIT_MESSAGE}"\ngit push\n\`\`\``);
+        return;
+    }
+    await runPromise(`git add -A`, { cwd: repoPath });
+    await runPromise(`git commit -m "${COMMIT_MESSAGE}"`, { cwd: repoPath });
+    await runPromise(`git push`, { cwd: repoPath });
+    console.log(`\nCommitted and pushed. Each machine waits an hour after seeing it before those`);
+    console.log(`keys work again.`);
 }

package/security/helpers/remoteSSH.ts

@@ -8,28 +8,39 @@ const MAX_ERROR_BODY_LENGTH = 500;
 // /etc is root owned, so fall back to sudo whenever the SSH user is not root.
 export const SUDO_PREAMBLE = `SUDO=""; if [ "$(id -u)" -ne 0 ]; then SUDO="sudo -n"; fi`;
 
+/** No host means this machine, so the very same script runs with nothing in front of it. Local and
+    remote then do exactly the same thing, rather than being two pieces of code that have to be kept
+    saying the same thing. */
+export const THIS_MACHINE = "";
+
+export function describeHost(host: string) {
+    return host || "this machine";
+}
+
 /** The host string is handed to ssh untouched. Users, keys and ports belong in the caller's ssh
     config, so BatchMode makes a missing setup fail immediately instead of prompting. */
 export async function runOverSSH(config: { host: string; script: string; input?: string; allowFailure?: boolean }) {
     let { host, script, input, allowFailure } = config;
     let result = await spawnPromise({
-        command: "ssh",
-        args: [
+        command: host && "ssh" || "sh",
+        args: host && [
             "-o", "BatchMode=yes",
             "-o", `ConnectTimeout=${SSH_CONNECT_TIMEOUT}`,
             host,
             script,
-        ],
+        ] || ["-c", script],
         input,
         inheritStderr: !allowFailure,
     });
     if (result.error) {
-        throw new Error(`Expected ssh to run against ${host}, failed with ${result.error.message}`);
+        throw new Error(`Expected to run against ${describeHost(host)}, failed with ${result.error.message}`);
     }
     if (result.status !== 0 && !allowFailure) {
+        let advice = host
+            && ` Non-interactive ssh access to ${host} has to work on its own - fix it in your ssh config.`
+            || "";
         throw new Error(
-            `Expected ssh to ${host} to exit 0, was ${result.status}.`
-            + ` Non-interactive ssh access to ${host} has to work on its own - fix it in your ssh config.\n`
+            `Expected the script on ${describeHost(host)} to exit 0, was ${result.status}.${advice}\n`
             + `${(result.stdout + result.stderr).trim().slice(0, MAX_ERROR_BODY_LENGTH)}`
         );
     }

package/security/notifications/discord.ts

@@ -72,8 +72,25 @@ async function readWebhookFile(filePath: string) {
     return parseWebhookFile({ contents, sourceName: filePath });
 }
 
+/** When the message was sent, in the sending machine's own time zone. Discord shows when it
+    received something, which is not the same thing when a machine has been offline or a send has
+    been retried, and the zone matters when the machines are not all in one place. */
+export function messageTimestamp(now: Date) {
+    let date = now.toLocaleDateString("en-CA");
+    let time = now.toLocaleTimeString("en-US", {
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+        hour12: true,
+        timeZoneName: "short",
+    });
+    return `${date} ${time}`;
+}
+
 async function postToWebhook(webhookURL: string, message: string) {
-    let content = message;
+    // Stamped once rather than per attempt, so a retry says when the thing happened rather than
+    // when we last managed to get it out.
+    let content = `\`${messageTimestamp(new Date())}\` ${message}`;
     if (content.length > DISCORD_MESSAGE_LIMIT) {
         content = content.slice(0, DISCORD_MESSAGE_LIMIT - 3) + "...";
     }

package/security/notifications/dist/discord.ts.cache

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule && mod.default) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
-//exports.stopDiscordNotifications = exports.sendDiscordNotification = exports.configureDiscordNotifications = exports.sendToWebhookURL = exports.formatWebhookFile = exports.redactWebhookURL = exports.parseWebhookFile = exports.DEFAULT_WEBHOOK_FILE_PATH = void 0;
+//exports.stopDiscordNotifications = exports.sendDiscordNotification = exports.configureDiscordNotifications = exports.sendToWebhookURL = exports.messageTimestamp = exports.formatWebhookFile = exports.redactWebhookURL = exports.parseWebhookFile = exports.DEFAULT_WEBHOOK_FILE_PATH = void 0;
 const promises_1 = __importDefault(require("fs/promises"));
 // PORTED CODE: security/authorizedKeys/daemon/portsecureDaemon.js embeds a hand port of this file in plain JS, so the
 // daemon can run with no dependencies. The two are expected to behave identically - if you change
@@ -67,8 +67,25 @@ async function readWebhookFile(filePath) {
     }
     return parseWebhookFile({ contents, sourceName: filePath });
 }
+/** When the message was sent, in the sending machine's own time zone. Discord shows when it
+    received something, which is not the same thing when a machine has been offline or a send has
+    been retried, and the zone matters when the machines are not all in one place. */
+function messageTimestamp(now) {
+    let date = now.toLocaleDateString("en-CA");
+    let time = now.toLocaleTimeString("en-US", {
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+        hour12: true,
+        timeZoneName: "short",
+    });
+    return `${date} ${time}`;
+}
+exports.messageTimestamp = messageTimestamp;
 async function postToWebhook(webhookURL, message) {
-    let content = message;
+    // Stamped once rather than per attempt, so a retry says when the thing happened rather than
+    // when we last managed to get it out.
+    let content = `\`${messageTimestamp(new Date())}\` ${message}`;
     if (content.length > DISCORD_MESSAGE_LIMIT) {
         content = content.slice(0, DISCORD_MESSAGE_LIMIT - 3) + "...";
     }
@@ -176,5 +193,5 @@ function stopDiscordNotifications() {
     notificationState = undefined;
 }
 exports.stopDiscordNotifications = stopDiscordNotifications;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"discord.js","sourceRoot":"","sources":["discord.ts"],"names":[],"mappings":"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","sourcesContent":["import fs from \"fs/promises\";\n\n// PORTED CODE: security/authorizedKeys/daemon/portsecureDaemon.js embeds a hand port of this file in plain JS, so the\n// daemon can run with no dependencies. The two are expected to behave identically - if you change\n// one, make the matching change in the other.\n\nexport const DEFAULT_WEBHOOK_FILE_PATH = \"/etc/portsecure/discord-webhook\";\nconst DEFAULT_CHECK_INTERVAL = 5 * 60 * 1000;\nconst VALID_WEBHOOK_PREFIXES = [\n    \"https://discord.com/api/webhooks/\",\n    \"https://discordapp.com/api/webhooks/\",\n    \"https://canary.discord.com/api/webhooks/\",\n];\nconst DISCORD_MESSAGE_LIMIT = 2000;\nconst MAX_ERROR_BODY_LENGTH = 500;\nconst MAX_SEND_ATTEMPTS = 3;\nconst REDACTED_TOKEN_VISIBLE = 8;\nconst DEFAULT_RATE_LIMIT_WAIT = 2 * 1000;\n\nlet notificationState: {\n    filePath: string;\n    webhookURL: string;\n    checkTimer: NodeJS.Timeout;\n} | undefined;\n\n// Discord webhooks are rate limited (roughly 5 requests per 2 seconds), so every send\n// goes through one chain instead of racing.\nlet sendChain: Promise<unknown> = Promise.resolve();\n\n/** Pulls the webhook URL out of webhook file contents. `sourceName` only appears in errors, so\n    callers can name a remote path. */\nexport function parseWebhookFile(config: { contents: string; sourceName: string }) {\n    let { contents, sourceName } = config;\n    let lines = contents.split(\"\\n\").map(line => line.trim()).filter(line => line && !line.startsWith(\"#\"));\n    let webhookURL = lines[0];\n    if (!webhookURL) {\n        throw new Error(`Expected a Discord webhook URL in ${sourceName}, the file has no usable lines`);\n    }\n    if (!VALID_WEBHOOK_PREFIXES.some(prefix => webhookURL.startsWith(prefix))) {\n        throw new Error(\n            `Expected a Discord webhook URL starting with one of ${VALID_WEBHOOK_PREFIXES.join(\", \")}, `\n            + `was ${webhookURL.slice(0, MAX_ERROR_BODY_LENGTH)} (in ${sourceName})`\n        );\n    }\n    return webhookURL;\n}\n\n/** Keeps the id and both ends of the token, so a reader can confirm which webhook replaced theirs\n    without receiving one they could post to. */\nexport function redactWebhookURL(webhookURL: string) {\n    let separatorIndex = webhookURL.lastIndexOf(\"/\");\n    let base = webhookURL.slice(0, separatorIndex + 1);\n    let token = webhookURL.slice(separatorIndex + 1);\n    if (token.length <= REDACTED_TOKEN_VISIBLE * 2) {\n        // Too short to show both ends without giving away the whole token.\n        return `${base}${token.slice(0, REDACTED_TOKEN_VISIBLE)}...`;\n    }\n    return `${base}${token.slice(0, REDACTED_TOKEN_VISIBLE)}...${token.slice(-REDACTED_TOKEN_VISIBLE)}`;\n}\n\nexport function formatWebhookFile(webhookURL: string) {\n    return `# portsecure Discord webhook. First non-comment line is used.\\n${webhookURL}\\n`;\n}\n\nasync function readWebhookFile(filePath: string) {\n    let contents;\n    try {\n        contents = await fs.readFile(filePath, \"utf8\");\n    } catch (e) {\n        throw new Error(`Expected a readable Discord webhook file at ${filePath}, ${e}`);\n    }\n    return parseWebhookFile({ contents, sourceName: filePath });\n}\n\nasync function postToWebhook(webhookURL: string, message: string) {\n    let content = message;\n    if (content.length > DISCORD_MESSAGE_LIMIT) {\n        content = content.slice(0, DISCORD_MESSAGE_LIMIT - 3) + \"...\";\n    }\n    for (let attempt = 1; attempt <= MAX_SEND_ATTEMPTS; attempt++) {\n        let response = await fetch(webhookURL, {\n            method: \"POST\",\n            headers: { \"Content-Type\": \"application/json\" },\n            body: JSON.stringify({ content }),\n        });\n        if (response.ok) {\n            return;\n        }\n        let body = (await response.text()).slice(0, MAX_ERROR_BODY_LENGTH);\n        if (response.status === 429 && attempt < MAX_SEND_ATTEMPTS) {\n            let retryAfter = Number(response.headers.get(\"retry-after\"));\n            let waitTime = retryAfter && retryAfter * 1000 || DEFAULT_RATE_LIMIT_WAIT;\n            await new Promise(resolve => setTimeout(resolve, waitTime));\n            continue;\n        }\n        throw new Error(\n            `Expected a 2xx response from the Discord webhook, was ${response.status} ${response.statusText}, body ${body}`\n        );\n    }\n}\n\nfunction queueSend(webhookURL: string, message: string) {\n    let send = () => postToWebhook(webhookURL, message);\n    let result = sendChain.then(send, send);\n    sendChain = result.catch(() => undefined);\n    return result;\n}\n\n/** Sends to an explicit webhook URL, for tooling that acts on a webhook before (or instead of)\n    configureDiscordNotifications - setup, migrations, connectivity checks. */\nexport function sendToWebhookURL(config: { webhookURL: string; message: string }) {\n    return queueSend(config.webhookURL, config.message);\n}\n\nasync function checkWebhookFileChanged() {\n    let state = notificationState;\n    if (!state) {\n        return;\n    }\n    let newWebhookURL;\n    try {\n        newWebhookURL = await readWebhookFile(state.filePath);\n    } catch (e) {\n        console.error(`portsecure: Discord webhook file is no longer readable, still using the loaded webhook. ${e}`);\n        return;\n    }\n    if (newWebhookURL === state.webhookURL) {\n        return;\n    }\n    // Warn the old channel first, with the new webhook redacted, so a stolen old webhook does not\n    // hand the attacker a usable new one.\n    try {\n        await queueSend(\n            state.webhookURL,\n            `**portsecure**: the Discord webhook in \\`${state.filePath}\\` changed to`\n            + ` \\`${redactWebhookURL(newWebhookURL)}\\`.`\n            + ` Notifications are moving to the new webhook and this channel will stop receiving them.`\n        );\n    } catch (e) {\n        console.error(`portsecure: failed to warn the old Discord webhook about the change. ${e}`);\n    }\n    state.webhookURL = newWebhookURL;\n}\n\n/** Must be called once on startup, before any notification is sent. Aborts the process if the\n    webhook file is missing or invalid, then re-checks the file on an interval and warns the old\n    webhook whenever it changes. */\nexport async function configureDiscordNotifications(config?: {\n    filePath?: string;\n    checkInterval?: number;\n}) {\n    if (notificationState) {\n        throw new Error(`Expected configureDiscordNotifications to be called once, was called again (already using ${notificationState.filePath})`);\n    }\n    let filePath = config?.filePath || DEFAULT_WEBHOOK_FILE_PATH;\n    let checkInterval = config?.checkInterval || DEFAULT_CHECK_INTERVAL;\n    let webhookURL;\n    try {\n        webhookURL = await readWebhookFile(filePath);\n    } catch (e) {\n        console.error(`portsecure: refusing to start without a valid Discord webhook file.\\n${e}`);\n        process.exit(1);\n    }\n    let checkTimer = setInterval(() => {\n        checkWebhookFileChanged().catch(e => console.error(`portsecure: Discord webhook file check failed. ${e}`));\n    }, checkInterval);\n    // The check should never be the reason the process stays alive.\n    checkTimer.unref();\n    notificationState = { filePath, webhookURL, checkTimer };\n    return { filePath, checkInterval };\n}\n\n// DO NOT add new calls to this. Every message goes to a real Discord server someone reads, so a\n// notification is only ever added when the user explicitly asks for that specific case. Startup,\n// success, errors, retries and recoveries all belong in a log instead.\nexport async function sendDiscordNotification(message: string) {\n    let state = notificationState;\n    if (!state) {\n        throw new Error(`Expected configureDiscordNotifications to be called before sending, was called with message ${message.slice(0, MAX_ERROR_BODY_LENGTH)}`);\n    }\n    await queueSend(state.webhookURL, message);\n}\n\nexport function stopDiscordNotifications() {\n    if (!notificationState) {\n        return;\n    }\n    clearInterval(notificationState.checkTimer);\n    notificationState = undefined;\n}\n"]}
- /* _JS_SOURCE_HASH = "d5d1b1a9e262cd5b805adb2fa7d074d1a92e9a99dd226550e7f055a9766ebd19"; */
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"discord.js","sourceRoot":"","sources":["discord.ts"],"names":[],"mappings":";;;;;;AAAA,2DAA6B;AAE7B,sHAAsH;AACtH,kGAAkG;AAClG,8CAA8C;AAEjC,QAAA,yBAAyB,GAAG,iCAAiC,CAAC;AAC3E,MAAM,sBAAsB,GAAG,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC;AAC7C,MAAM,sBAAsB,GAAG;IAC3B,mCAAmC;IACnC,sCAAsC;IACtC,0CAA0C;CAC7C,CAAC;AACF,MAAM,qBAAqB,GAAG,IAAI,CAAC;AACnC,MAAM,qBAAqB,GAAG,GAAG,CAAC;AAClC,MAAM,iBAAiB,GAAG,CAAC,CAAC;AAC5B,MAAM,sBAAsB,GAAG,CAAC,CAAC;AACjC,MAAM,uBAAuB,GAAG,CAAC,GAAG,IAAI,CAAC;AAEzC,IAAI,iBAIS,CAAC;AAEd,sFAAsF;AACtF,4CAA4C;AAC5C,IAAI,SAAS,GAAqB,OAAO,CAAC,OAAO,EAAE,CAAC;AAEpD;sCACsC;AACtC,SAAgB,gBAAgB,CAAC,MAAgD;IAC7E,IAAI,EAAE,QAAQ,EAAE,UAAU,EAAE,GAAG,MAAM,CAAC;IACtC,IAAI,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC;IACxG,IAAI,UAAU,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;IAC1B,IAAI,CAAC,UAAU,EAAE,CAAC;QACd,MAAM,IAAI,KAAK,CAAC,qCAAqC,UAAU,gCAAgC,CAAC,CAAC;IACrG,CAAC;IACD,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,UAAU,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC;QACxE,MAAM,IAAI,KAAK,CACX,uDAAuD,sBAAsB,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI;cAC1F,OAAO,UAAU,CAAC,KAAK,CAAC,CAAC,EAAE,qBAAqB,CAAC,QAAQ,UAAU,GAAG,CAC3E,CAAC;IACN,CAAC;IACD,OAAO,UAAU,CAAC;AACtB,CAAC;AAdD,4CAcC;AAED;gDACgD;AAChD,SAAgB,gBAAgB,CAAC,UAAkB;IAC/C,IAAI,cAAc,GAAG,UAAU,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;IACjD,IAAI,IAAI,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC,EAAE,cAAc,GAAG,CAAC,CAAC,CAAC;IACnD,IAAI,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC,cAAc,GAAG,CAAC,CAAC,CAAC;IACjD,IAAI,KAAK,CAAC,MAAM,IAAI,sBAAsB,GAAG,CAAC,EAAE,CAAC;QAC7C,mEAAmE;QACnE,OAAO,GAAG,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,sBAAsB,CAAC,KAAK,CAAC;IACjE,CAAC;IACD,OAAO,GAAG,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,sBAAsB,CAAC,MAAM,KAAK,CAAC,KAAK,CAAC,CAAC,sBAAsB,CAAC,EAAE,CAAC;AACxG,CAAC;AATD,4CASC;AAED,SAAgB,iBAAiB,CAAC,UAAkB;IAChD,OAAO,kEAAkE,UAAU,IAAI,CAAC;AAC5F,CAAC;AAFD,8CAEC;AAED,KAAK,UAAU,eAAe,CAAC,QAAgB;IAC3C,IAAI,QAAQ,CAAC;IACb,IAAI,CAAC;QACD,QAAQ,GAAG,MAAM,kBAAE,CAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;IACnD,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACT,MAAM,IAAI,KAAK,CAAC,+CAA+C,QAAQ,KAAK,CAAC,EAAE,CAAC,CAAC;IACrF,CAAC;IACD,OAAO,gBAAgB,CAAC,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,CAAC,CAAC;AAChE,CAAC;AAED;;qFAEqF;AACrF,SAAgB,gBAAgB,CAAC,GAAS;IACtC,IAAI,IAAI,GAAG,GAAG,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC;IAC3C,IAAI,IAAI,GAAG,GAAG,CAAC,kBAAkB,CAAC,OAAO,EAAE;QACvC,IAAI,EAAE,SAAS;QACf,MAAM,EAAE,SAAS;QACjB,MAAM,EAAE,SAAS;QACjB,MAAM,EAAE,IAAI;QACZ,YAAY,EAAE,OAAO;KACxB,CAAC,CAAC;IACH,OAAO,GAAG,IAAI,IAAI,IAAI,EAAE,CAAC;AAC7B,CAAC;AAVD,4CAUC;AAED,KAAK,UAAU,aAAa,CAAC,UAAkB,EAAE,OAAe;IAC5D,4FAA4F;IAC5F,sCAAsC;IACtC,IAAI,OAAO,GAAG,KAAK,gBAAgB,CAAC,IAAI,IAAI,EAAE,CAAC,MAAM,OAAO,EAAE,CAAC;IAC/D,IAAI,OAAO,CAAC,MAAM,GAAG,qBAAqB,EAAE,CAAC;QACzC,OAAO,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,qBAAqB,GAAG,CAAC,CAAC,GAAG,KAAK,CAAC;IAClE,CAAC;IACD,KAAK,IAAI,OAAO,GAAG,CAAC,EAAE,OAAO,IAAI,iBAAiB,EAAE,OAAO,EAAE,EAAE,CAAC;QAC5D,IAAI,QAAQ,GAAG,MAAM,KAAK,CAAC,UAAU,EAAE;YACnC,MAAM,EAAE,MAAM;YACd,OAAO,EAAE,EAAE,cAAc,EAAE,kBAAkB,EAAE;YAC/C,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,CAAC;SACpC,CAAC,CAAC;QACH,IAAI,QAAQ,CAAC,EAAE,EAAE,CAAC;YACd,OAAO;QACX,CAAC;QACD,IAAI,IAAI,GAAG,CAAC,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,qBAAqB,CAAC,CAAC;QACnE,IAAI,QAAQ,CAAC,MAAM,KAAK,GAAG,IAAI,OAAO,GAAG,iBAAiB,EAAE,CAAC;YACzD,IAAI,UAAU,GAAG,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC,CAAC;YAC7D,IAAI,QAAQ,GAAG,UAAU,IAAI,UAAU,GAAG,IAAI,IAAI,uBAAuB,CAAC;YAC1E,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC;YAC5D,SAAS;QACb,CAAC;QACD,MAAM,IAAI,KAAK,CACX,yDAAyD,QAAQ,CAAC,MAAM,IAAI,QAAQ,CAAC,UAAU,UAAU,IAAI,EAAE,CAClH,CAAC;IACN,CAAC;AACL,CAAC;AAED,SAAS,SAAS,CAAC,UAAkB,EAAE,OAAe;IAClD,IAAI,IAAI,GAAG,GAAG,EAAE,CAAC,aAAa,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;IACpD,IAAI,MAAM,GAAG,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IACxC,SAAS,GAAG,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;IAC1C,OAAO,MAAM,CAAC;AAClB,CAAC;AAED;8EAC8E;AAC9E,SAAgB,gBAAgB,CAAC,MAA+C;IAC5E,OAAO,SAAS,CAAC,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,OAAO,CAAC,CAAC;AACxD,CAAC;AAFD,4CAEC;AAED,KAAK,UAAU,uBAAuB;IAClC,IAAI,KAAK,GAAG,iBAAiB,CAAC;IAC9B,IAAI,CAAC,KAAK,EAAE,CAAC;QACT,OAAO;IACX,CAAC;IACD,IAAI,aAAa,CAAC;IAClB,IAAI,CAAC;QACD,aAAa,GAAG,MAAM,eAAe,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;IAC1D,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACT,OAAO,CAAC,KAAK,CAAC,2FAA2F,CAAC,EAAE,CAAC,CAAC;QAC9G,OAAO;IACX,CAAC;IACD,IAAI,aAAa,KAAK,KAAK,CAAC,UAAU,EAAE,CAAC;QACrC,OAAO;IACX,CAAC;IACD,8FAA8F;IAC9F,sCAAsC;IACtC,IAAI,CAAC;QACD,MAAM,SAAS,CACX,KAAK,CAAC,UAAU,EAChB,4CAA4C,KAAK,CAAC,QAAQ,eAAe;cACvE,MAAM,gBAAgB,CAAC,aAAa,CAAC,KAAK;cAC1C,yFAAyF,CAC9F,CAAC;IACN,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACT,OAAO,CAAC,KAAK,CAAC,wEAAwE,CAAC,EAAE,CAAC,CAAC;IAC/F,CAAC;IACD,KAAK,CAAC,UAAU,GAAG,aAAa,CAAC;AACrC,CAAC;AAED;;mCAEmC;AAC5B,KAAK,UAAU,6BAA6B,CAAC,MAGnD;IACG,IAAI,iBAAiB,EAAE,CAAC;QACpB,MAAM,IAAI,KAAK,CAAC,6FAA6F,iBAAiB,CAAC,QAAQ,GAAG,CAAC,CAAC;IAChJ,CAAC;IACD,IAAI,QAAQ,GAAG,CAAA,MAAM,aAAN,MAAM,uBAAN,MAAM,CAAE,QAAQ,KAAI,iCAAyB,CAAC;IAC7D,IAAI,aAAa,GAAG,CAAA,MAAM,aAAN,MAAM,uBAAN,MAAM,CAAE,aAAa,KAAI,sBAAsB,CAAC;IACpE,IAAI,UAAU,CAAC;IACf,IAAI,CAAC;QACD,UAAU,GAAG,MAAM,eAAe,CAAC,QAAQ,CAAC,CAAC;IACjD,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACT,OAAO,CAAC,KAAK,CAAC,wEAAwE,CAAC,EAAE,CAAC,CAAC;QAC3F,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACpB,CAAC;IACD,IAAI,UAAU,GAAG,WAAW,CAAC,GAAG,EAAE;QAC9B,uBAAuB,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,kDAAkD,CAAC,EAAE,CAAC,CAAC,CAAC;IAC/G,CAAC,EAAE,aAAa,CAAC,CAAC;IAClB,gEAAgE;IAChE,UAAU,CAAC,KAAK,EAAE,CAAC;IACnB,iBAAiB,GAAG,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU,EAAE,CAAC;IACzD,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,CAAC;AACvC,CAAC;AAvBD,sEAuBC;AAED,gGAAgG;AAChG,iGAAiG;AACjG,uEAAuE;AAChE,KAAK,UAAU,uBAAuB,CAAC,OAAe;IACzD,IAAI,KAAK,GAAG,iBAAiB,CAAC;IAC9B,IAAI,CAAC,KAAK,EAAE,CAAC;QACT,MAAM,IAAI,KAAK,CAAC,+FAA+F,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,qBAAqB,CAAC,EAAE,CAAC,CAAC;IAC9J,CAAC;IACD,MAAM,SAAS,CAAC,KAAK,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;AAC/C,CAAC;AAND,0DAMC;AAED,SAAgB,wBAAwB;IACpC,IAAI,CAAC,iBAAiB,EAAE,CAAC;QACrB,OAAO;IACX,CAAC;IACD,aAAa,CAAC,iBAAiB,CAAC,UAAU,CAAC,CAAC;IAC5C,iBAAiB,GAAG,SAAS,CAAC;AAClC,CAAC;AAND,4DAMC","sourcesContent":["import fs from \"fs/promises\";\n\n// PORTED CODE: security/authorizedKeys/daemon/portsecureDaemon.js embeds a hand port of this file in plain JS, so the\n// daemon can run with no dependencies. The two are expected to behave identically - if you change\n// one, make the matching change in the other.\n\nexport const DEFAULT_WEBHOOK_FILE_PATH = \"/etc/portsecure/discord-webhook\";\nconst DEFAULT_CHECK_INTERVAL = 5 * 60 * 1000;\nconst VALID_WEBHOOK_PREFIXES = [\n    \"https://discord.com/api/webhooks/\",\n    \"https://discordapp.com/api/webhooks/\",\n    \"https://canary.discord.com/api/webhooks/\",\n];\nconst DISCORD_MESSAGE_LIMIT = 2000;\nconst MAX_ERROR_BODY_LENGTH = 500;\nconst MAX_SEND_ATTEMPTS = 3;\nconst REDACTED_TOKEN_VISIBLE = 8;\nconst DEFAULT_RATE_LIMIT_WAIT = 2 * 1000;\n\nlet notificationState: {\n    filePath: string;\n    webhookURL: string;\n    checkTimer: NodeJS.Timeout;\n} | undefined;\n\n// Discord webhooks are rate limited (roughly 5 requests per 2 seconds), so every send\n// goes through one chain instead of racing.\nlet sendChain: Promise<unknown> = Promise.resolve();\n\n/** Pulls the webhook URL out of webhook file contents. `sourceName` only appears in errors, so\n    callers can name a remote path. */\nexport function parseWebhookFile(config: { contents: string; sourceName: string }) {\n    let { contents, sourceName } = config;\n    let lines = contents.split(\"\\n\").map(line => line.trim()).filter(line => line && !line.startsWith(\"#\"));\n    let webhookURL = lines[0];\n    if (!webhookURL) {\n        throw new Error(`Expected a Discord webhook URL in ${sourceName}, the file has no usable lines`);\n    }\n    if (!VALID_WEBHOOK_PREFIXES.some(prefix => webhookURL.startsWith(prefix))) {\n        throw new Error(\n            `Expected a Discord webhook URL starting with one of ${VALID_WEBHOOK_PREFIXES.join(\", \")}, `\n            + `was ${webhookURL.slice(0, MAX_ERROR_BODY_LENGTH)} (in ${sourceName})`\n        );\n    }\n    return webhookURL;\n}\n\n/** Keeps the id and both ends of the token, so a reader can confirm which webhook replaced theirs\n    without receiving one they could post to. */\nexport function redactWebhookURL(webhookURL: string) {\n    let separatorIndex = webhookURL.lastIndexOf(\"/\");\n    let base = webhookURL.slice(0, separatorIndex + 1);\n    let token = webhookURL.slice(separatorIndex + 1);\n    if (token.length <= REDACTED_TOKEN_VISIBLE * 2) {\n        // Too short to show both ends without giving away the whole token.\n        return `${base}${token.slice(0, REDACTED_TOKEN_VISIBLE)}...`;\n    }\n    return `${base}${token.slice(0, REDACTED_TOKEN_VISIBLE)}...${token.slice(-REDACTED_TOKEN_VISIBLE)}`;\n}\n\nexport function formatWebhookFile(webhookURL: string) {\n    return `# portsecure Discord webhook. First non-comment line is used.\\n${webhookURL}\\n`;\n}\n\nasync function readWebhookFile(filePath: string) {\n    let contents;\n    try {\n        contents = await fs.readFile(filePath, \"utf8\");\n    } catch (e) {\n        throw new Error(`Expected a readable Discord webhook file at ${filePath}, ${e}`);\n    }\n    return parseWebhookFile({ contents, sourceName: filePath });\n}\n\n/** When the message was sent, in the sending machine's own time zone. Discord shows when it\n    received something, which is not the same thing when a machine has been offline or a send has\n    been retried, and the zone matters when the machines are not all in one place. */\nexport function messageTimestamp(now: Date) {\n    let date = now.toLocaleDateString(\"en-CA\");\n    let time = now.toLocaleTimeString(\"en-US\", {\n        hour: \"2-digit\",\n        minute: \"2-digit\",\n        second: \"2-digit\",\n        hour12: true,\n        timeZoneName: \"short\",\n    });\n    return `${date} ${time}`;\n}\n\nasync function postToWebhook(webhookURL: string, message: string) {\n    // Stamped once rather than per attempt, so a retry says when the thing happened rather than\n    // when we last managed to get it out.\n    let content = `\\`${messageTimestamp(new Date())}\\` ${message}`;\n    if (content.length > DISCORD_MESSAGE_LIMIT) {\n        content = content.slice(0, DISCORD_MESSAGE_LIMIT - 3) + \"...\";\n    }\n    for (let attempt = 1; attempt <= MAX_SEND_ATTEMPTS; attempt++) {\n        let response = await fetch(webhookURL, {\n            method: \"POST\",\n            headers: { \"Content-Type\": \"application/json\" },\n            body: JSON.stringify({ content }),\n        });\n        if (response.ok) {\n            return;\n        }\n        let body = (await response.text()).slice(0, MAX_ERROR_BODY_LENGTH);\n        if (response.status === 429 && attempt < MAX_SEND_ATTEMPTS) {\n            let retryAfter = Number(response.headers.get(\"retry-after\"));\n            let waitTime = retryAfter && retryAfter * 1000 || DEFAULT_RATE_LIMIT_WAIT;\n            await new Promise(resolve => setTimeout(resolve, waitTime));\n            continue;\n        }\n        throw new Error(\n            `Expected a 2xx response from the Discord webhook, was ${response.status} ${response.statusText}, body ${body}`\n        );\n    }\n}\n\nfunction queueSend(webhookURL: string, message: string) {\n    let send = () => postToWebhook(webhookURL, message);\n    let result = sendChain.then(send, send);\n    sendChain = result.catch(() => undefined);\n    return result;\n}\n\n/** Sends to an explicit webhook URL, for tooling that acts on a webhook before (or instead of)\n    configureDiscordNotifications - setup, migrations, connectivity checks. */\nexport function sendToWebhookURL(config: { webhookURL: string; message: string }) {\n    return queueSend(config.webhookURL, config.message);\n}\n\nasync function checkWebhookFileChanged() {\n    let state = notificationState;\n    if (!state) {\n        return;\n    }\n    let newWebhookURL;\n    try {\n        newWebhookURL = await readWebhookFile(state.filePath);\n    } catch (e) {\n        console.error(`portsecure: Discord webhook file is no longer readable, still using the loaded webhook. ${e}`);\n        return;\n    }\n    if (newWebhookURL === state.webhookURL) {\n        return;\n    }\n    // Warn the old channel first, with the new webhook redacted, so a stolen old webhook does not\n    // hand the attacker a usable new one.\n    try {\n        await queueSend(\n            state.webhookURL,\n            `**portsecure**: the Discord webhook in \\`${state.filePath}\\` changed to`\n            + ` \\`${redactWebhookURL(newWebhookURL)}\\`.`\n            + ` Notifications are moving to the new webhook and this channel will stop receiving them.`\n        );\n    } catch (e) {\n        console.error(`portsecure: failed to warn the old Discord webhook about the change. ${e}`);\n    }\n    state.webhookURL = newWebhookURL;\n}\n\n/** Must be called once on startup, before any notification is sent. Aborts the process if the\n    webhook file is missing or invalid, then re-checks the file on an interval and warns the old\n    webhook whenever it changes. */\nexport async function configureDiscordNotifications(config?: {\n    filePath?: string;\n    checkInterval?: number;\n}) {\n    if (notificationState) {\n        throw new Error(`Expected configureDiscordNotifications to be called once, was called again (already using ${notificationState.filePath})`);\n    }\n    let filePath = config?.filePath || DEFAULT_WEBHOOK_FILE_PATH;\n    let checkInterval = config?.checkInterval || DEFAULT_CHECK_INTERVAL;\n    let webhookURL;\n    try {\n        webhookURL = await readWebhookFile(filePath);\n    } catch (e) {\n        console.error(`portsecure: refusing to start without a valid Discord webhook file.\\n${e}`);\n        process.exit(1);\n    }\n    let checkTimer = setInterval(() => {\n        checkWebhookFileChanged().catch(e => console.error(`portsecure: Discord webhook file check failed. ${e}`));\n    }, checkInterval);\n    // The check should never be the reason the process stays alive.\n    checkTimer.unref();\n    notificationState = { filePath, webhookURL, checkTimer };\n    return { filePath, checkInterval };\n}\n\n// DO NOT add new calls to this. Every message goes to a real Discord server someone reads, so a\n// notification is only ever added when the user explicitly asks for that specific case. Startup,\n// success, errors, retries and recoveries all belong in a log instead.\nexport async function sendDiscordNotification(message: string) {\n    let state = notificationState;\n    if (!state) {\n        throw new Error(`Expected configureDiscordNotifications to be called before sending, was called with message ${message.slice(0, MAX_ERROR_BODY_LENGTH)}`);\n    }\n    await queueSend(state.webhookURL, message);\n}\n\nexport function stopDiscordNotifications() {\n    if (!notificationState) {\n        return;\n    }\n    clearInterval(notificationState.checkTimer);\n    notificationState = undefined;\n}\n"]}
+ /* _JS_SOURCE_HASH = "be450922cec9e8a268e2a78f817bfedb88063a0b59db5b1a954d81c96169543a"; */

package/security/notifications/setupNotify.ts

@@ -1,16 +1,25 @@
 import { parseWebhookFile } from "./discord";
 import { ensureRemoteWebhook, REPLACE_KEYWORD } from "./remoteWebhook";
+import { describeHost, THIS_MACHINE } from "../helpers/remoteSSH";
 
-const USAGE = `Usage: yarn setupnotify <host> <discord-webhook-url> [${REPLACE_KEYWORD}]`;
+const USAGE = `Usage: yarn setupnotify [host] <discord-webhook-url> [${REPLACE_KEYWORD}]
+
+With no host it sets the webhook up on this machine.`;
 
 function parseArgs(argv: string[]) {
     let replace = argv.includes(REPLACE_KEYWORD);
     let positional = argv.filter(arg => arg !== REPLACE_KEYWORD);
-    if (positional.length !== 2) {
-        throw new Error(`Expected a host and a webhook URL, was ${positional.length} argument(s): ${positional.join(" ") || "(none)"}\n${USAGE}`);
+    if (!positional.length || positional.length > 2) {
+        throw new Error(
+            `Expected a webhook URL, and optionally a host before it, was ${positional.length}`
+            + ` argument(s): ${positional.join(" ") || "(none)"}\n${USAGE}`
+        );
     }
-    let [host, webhookURL] = positional;
-    // Validates the URL shape up front, so we never ssh anywhere with a bad webhook.
+    // The webhook url is the last one, so whatever comes before it is the host. Without one this
+    // machine is the target.
+    let webhookURL = positional[positional.length - 1];
+    let host = positional.length > 1 && positional[0] || THIS_MACHINE;
+    // Validates the URL shape up front, so we never go anywhere with a bad webhook.
     parseWebhookFile({ contents: webhookURL, sourceName: "the command line" });
     return { host, webhookURL, replace };
 }
@@ -19,11 +28,11 @@ export async function main() {
     let { host, webhookURL, replace } = parseArgs(process.argv.slice(2));
     let { outcome, filePath } = await ensureRemoteWebhook({ host, webhookURL, replace });
     if (outcome === "unchanged") {
-        console.log(`${host} already has this exact webhook in ${filePath}, nothing to do.`);
+        console.log(`${describeHost(host)} already has this exact webhook in ${filePath}, nothing to do.`);
         return;
     }
     if (outcome === "replaced") {
-        console.log(`Replaced the webhook on ${host} and notified the old one.`);
+        console.log(`Replaced the webhook on ${describeHost(host)} and notified the old one.`);
     }
-    console.log(`Wrote ${filePath} on ${host} (mode 600), and confirmed on the new webhook.`);
+    console.log(`Wrote ${filePath} on ${describeHost(host)} (mode 600), and confirmed on the new webhook.`);
 }