sliftutils 1.7.125 → 1.7.127

package/security/authorizedKeys/dist/secureSSH.ts.cache

@@ -0,0 +1,539 @@
+"use strict";
+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.main = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const discord_1 = require("../notifications/discord");
+const authorizedKeys_1 = require("./authorizedKeys");
+const sources_1 = require("./sources");
+const revokeSource_1 = require("./revokeSource");
+const unrevoke_1 = require("./unrevoke");
+const paths_1 = require("../helpers/paths");
+const spawn_1 = require("../helpers/spawn");
+const remoteSSH_1 = require("../helpers/remoteSSH");
+const SERVICE_SOURCE = path_1.default.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
+// a host updates itself from github the same way anything else does. sliftutils is public, so this
+// needs no key.
+const SLIFTUTILS_URL = "https://github.com/sliftist/sliftutils.git";
+const REMOTE_CHECKOUT_PATH = "/opt/portsecure/sliftutils";
+const REMOTE_SERVICE_PATH = "/etc/systemd/system/portsecure.service";
+const REMOTE_CONFIG_PATH = "/etc/portsecure/daemon.json";
+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.
+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`;
+async function pathExists(filePath) {
+    try {
+        await promises_1.default.access(filePath);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+async function runLocal(config) {
+    let { command, args, cwd, allowFailure } = config;
+    let result = await (0, spawn_1.spawnPromise)({ command, args, cwd });
+    if (result.error) {
+        throw new Error(`Expected ${command} to run, failed with ${result.error.message}`);
+    }
+    if (result.status !== 0 && !allowFailure) {
+        throw new Error(`Expected ${command} ${args.join(" ")} to exit 0, was ${result.status}. `
+            + `${(result.stdout + result.stderr).trim().slice(0, MAX_ERROR_BODY_LENGTH)}`);
+    }
+    return result;
+}
+/** A private key cannot authenticate an https remote, so github urls are converted to the ssh form
+    the key can actually be used with. */
+function normalizeRepoURL(repoURL) {
+    let httpsMatch = repoURL.match(/^https?:\/\/([^/]+)\/(.+?)(?:\.git)?\/?$/);
+    if (!httpsMatch) {
+        return repoURL;
+    }
+    let [, host, repoPath] = httpsMatch;
+    return `git@${host}:${repoPath}.git`;
+}
+async function gitWithKey(config) {
+    let { keyPath, args, cwd, allowFailure } = config;
+    // core.sshCommand keeps key selection with the command instead of in the environment.
+    let sshCommand = `ssh -i ${keyPath} -o IdentitiesOnly=yes -o BatchMode=yes -o StrictHostKeyChecking=accept-new`;
+    let result = await (0, spawn_1.spawnPromise)({ command: "git", args: ["-c", `core.sshCommand=${sshCommand}`, ...args], cwd });
+    if (result.error) {
+        throw new Error(`Expected git to run, failed with ${result.error.message}`);
+    }
+    if (result.status !== 0 && !allowFailure) {
+        throw new Error(`Expected git ${args.join(" ")} to exit 0, was ${result.status}. `
+            + `${(result.stdout + result.stderr).trim().slice(0, MAX_ERROR_BODY_LENGTH)}`);
+    }
+    return result;
+}
+/** Asks ssh which key it actually authenticated with. This is the key that must survive the
+    daemon taking over authorized_keys, otherwise a deploy locks us out. */
+async function findAuthenticatingFingerprint(host) {
+    let result = await (0, spawn_1.spawnPromise)({
+        command: "ssh",
+        args: ["-v", "-o", "BatchMode=yes", "-o", "ConnectTimeout=10", host, "true"],
+    });
+    let verboseOutput = result.stderr || "";
+    if (result.status !== 0) {
+        throw new Error(`Expected to ssh into ${host}, failed. ${verboseOutput.slice(-MAX_ERROR_BODY_LENGTH)}`);
+    }
+    let acceptedMatch = verboseOutput.match(/Server accepts key:.*?(SHA256:[A-Za-z0-9+/=]+)/);
+    if (!acceptedMatch) {
+        throw new Error(`Expected ${host} to accept a public key, but the session did not authenticate with one.`
+            + ` portsecure disables password login, so key based access has to work first.`);
+    }
+    return acceptedMatch[1];
+}
+async function fingerprintKeys(keys) {
+    if (!keys.length) {
+        return [];
+    }
+    let temporaryDirectory = await promises_1.default.mkdtemp(path_1.default.join(os_1.default.tmpdir(), "portsecure-keys-"));
+    let keysPath = path_1.default.join(temporaryDirectory, "authorized_keys");
+    await promises_1.default.writeFile(keysPath, `${keys.join("\n")}\n`);
+    let result = await runLocal({ command: "ssh-keygen", args: ["-lf", keysPath], allowFailure: true });
+    await promises_1.default.rm(temporaryDirectory, { recursive: true, force: true });
+    let fingerprints = [];
+    for (let line of result.stdout.split("\n")) {
+        let match = line.match(/(SHA256:[A-Za-z0-9+/=]+)/);
+        if (match) {
+            fingerprints.push(match[1]);
+        }
+    }
+    return fingerprints;
+}
+async function cloneRepoForInspection(config) {
+    let { repoURL, keyPath } = config;
+    let temporaryDirectory = await promises_1.default.mkdtemp(path_1.default.join(os_1.default.tmpdir(), "portsecure-repo-"));
+    let repoPath = path_1.default.join(temporaryDirectory, "repo");
+    await gitWithKey({ keyPath, args: ["clone", "--depth", "1", repoURL, repoPath] });
+    return repoPath;
+}
+/** With no repo url given, the repo we are standing in is used. It has to actually hold keys
+    before we hand it to a host, so a stray working directory cannot be deployed by accident. */
+async function resolveRepoURL(passedURL) {
+    if (passedURL) {
+        return normalizeRepoURL(passedURL);
+    }
+    let topLevel = await runLocal({ command: "git", args: ["rev-parse", "--show-toplevel"], allowFailure: true });
+    if (topLevel.status !== 0) {
+        throw new Error(`Expected a repo url, or the current directory to be inside a git repo, it is not.\n${USAGE}`);
+    }
+    let repoPath = topLevel.stdout.trim();
+    try {
+        await (0, authorizedKeys_1.readRepoKeys)(repoPath);
+    }
+    catch (e) {
+        throw new Error(`Expected a repo url, or the current repo (${repoPath}) to hold keys, it does not.\n${e}\n${USAGE}`);
+    }
+    let origin = await runLocal({
+        command: "git",
+        args: ["remote", "get-url", "origin"],
+        cwd: repoPath,
+        allowFailure: true,
+    });
+    if (origin.status !== 0 || !origin.stdout.trim()) {
+        throw new Error(`Expected the current repo (${repoPath}) to have an origin remote, it has none.`
+            + ` The host clones the source itself, so a local path is no use to it.`);
+    }
+    let repoURL = normalizeRepoURL(origin.stdout.trim());
+    console.log(`No repo url given, using the current repo: ${repoURL}`);
+    return repoURL;
+}
+/** Every source's revoke repo has to exist and hold at least one commit, or the hosts using it
+    cannot record a revocation. Checked with this machine's own git credentials, since update is
+    not given any deploy key, and an empty repo is initialised rather than merely complained about.
+
+    A host that cannot write a revocation silently keeps accepting a key it just saw being misused,
+    which is the one failure this whole thing exists to prevent, so it is checked on every deploy
+    and not only when a source is first added. */
+async function ensureRevokeReposExist(repoSources) {
+    for (let repoURL of repoSources) {
+        let revokeURL = (0, revokeSource_1.revokeRepoURL)(repoURL);
+        let temporaryDirectory = await promises_1.default.mkdtemp(path_1.default.join(os_1.default.tmpdir(), "portsecure-revoke-"));
+        let checkoutPath = path_1.default.join(temporaryDirectory, "repo");
+        let clone = await runLocal({ command: "git", args: ["clone", revokeURL, checkoutPath], allowFailure: true });
+        if (clone.status !== 0) {
+            await promises_1.default.rm(temporaryDirectory, { recursive: true, force: true });
+            throw new Error(`Expected ${revokeURL} to exist, it does not, so ${repoURL} has nowhere to record a`
+                + ` revocation.\nCreate it, then run "yarn securessh <host> add" for that source to`
+                + ` register its deploy key.\n${(clone.stdout + clone.stderr).trim().slice(0, MAX_ERROR_BODY_LENGTH)}`);
+        }
+        let head = await runLocal({ command: "git", args: ["-C", checkoutPath, "rev-parse", "HEAD"], allowFailure: true });
+        if (head.status !== 0) {
+            console.log(`${revokeURL} is empty, giving it a first commit`);
+            await promises_1.default.writeFile(path_1.default.join(checkoutPath, "README.md"), `# revoked keys\n\nWritten by portsecure. Each file under revocations/ is one key that was used from an\n`
+                + `address it is not allowed from, and is no longer accepted anywhere.\n`);
+            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 });
+            }
+        }
+        await promises_1.default.rm(temporaryDirectory, { recursive: true, force: true });
+        console.log(`${revokeURL} is ready`);
+    }
+}
+/** The revoke repo has to exist and be writable before a host is set up, because a host that
+    cannot write a revocation cannot revoke a key that is being misused. The key for it is derived
+    from the source's, since github will not take one public key on two repos. */
+async function ensureRevokeRepo(config) {
+    let { keyPath, repoURL } = config;
+    let revokeURL = (0, revokeSource_1.revokeRepoURL)(repoURL);
+    let derived = (0, revokeSource_1.deriveRevokeKey)(await promises_1.default.readFile(keyPath, "utf8"));
+    let temporaryDirectory = await promises_1.default.mkdtemp(path_1.default.join(os_1.default.tmpdir(), "portsecure-revoke-"));
+    let derivedKeyPath = path_1.default.join(temporaryDirectory, "key");
+    await promises_1.default.writeFile(derivedKeyPath, derived.privateKeyFile, { mode: 0o600 });
+    let checkoutPath = path_1.default.join(temporaryDirectory, "repo");
+    let explain = (problem) => new Error(`${problem}\n`
+        + `Create ${revokeURL} and add this as a deploy key WITH WRITE ACCESS:\n`
+        + `  ${derived.publicKey} ${revokeSource_1.REVOKE_KEY_LABEL}\n`
+        + `It has to be this key: it is derived from ${keyPath}, and github will not accept the same`
+        + ` public key on two repositories.`);
+    console.log(`Checking ${revokeURL}`);
+    let clone = await gitWithKey({ keyPath: derivedKeyPath, args: ["clone", revokeURL, checkoutPath], allowFailure: true });
+    if (clone.status !== 0) {
+        throw explain(`Expected ${revokeURL} to be readable with the derived key, it is not.`);
+    }
+    // An empty repo has no branch for the daemon to clone, so it gets its first commit here. That
+    // doubles as the proof that we can write to it.
+    let head = await gitWithKey({ keyPath: derivedKeyPath, args: ["rev-parse", "HEAD"], cwd: checkoutPath, allowFailure: true });
+    if (head.status !== 0) {
+        await promises_1.default.writeFile(path_1.default.join(checkoutPath, "README.md"), `# revoked keys\n\nWritten by portsecure. Each file under revocations/ is one key that was used from an\n`
+            + `address it is not allowed from, and is no longer accepted anywhere.\n`);
+        for (let args of [
+            ["add", "-A"],
+            ["-c", "user.email=portsecure@localhost", "-c", "user.name=portsecure", "commit", "-m", "initialise revoke repo"],
+        ]) {
+            await gitWithKey({ keyPath: derivedKeyPath, args, cwd: checkoutPath });
+        }
+        let push = await gitWithKey({ keyPath: derivedKeyPath, args: ["push", "origin", "HEAD"], cwd: checkoutPath, allowFailure: true });
+        if (push.status !== 0) {
+            throw explain(`Expected write access to ${revokeURL}, the first push was refused.\n${(push.stdout + push.stderr).trim().slice(0, MAX_ERROR_BODY_LENGTH)}`);
+        }
+    }
+    else {
+        let dryRun = await gitWithKey({ keyPath: derivedKeyPath, args: ["push", "--dry-run", "origin", "HEAD"], cwd: checkoutPath, allowFailure: true });
+        if (dryRun.status !== 0) {
+            throw explain(`Expected write access to ${revokeURL}, a dry run push was refused.\n${(dryRun.stdout + dryRun.stderr).trim().slice(0, MAX_ERROR_BODY_LENGTH)}`);
+        }
+    }
+    await promises_1.default.rm(temporaryDirectory, { recursive: true, force: true });
+    console.log(`${revokeURL} is writable`);
+}
+async function readRemoteConfig(host) {
+    let contents = await (0, remoteSSH_1.readRemoteFile)({ host, filePath: REMOTE_CONFIG_PATH });
+    if (!contents) {
+        return { hostLabel: host, repoSources: [] };
+    }
+    let parsed = JSON.parse(contents);
+    return { hostLabel: parsed.hostLabel || host, repoSources: parsed.repoSources || [] };
+}
+/** Reads the keys a source's checkout currently holds on the host, so the merged result can be
+    worked out without needing that source's private key locally. */
+async function readRemoteSourceKeys(config) {
+    let { host, repoURL } = config;
+    let repoPath = (0, sources_1.sourceRepoPath)(repoURL);
+    let output = await (0, remoteSSH_1.runOverSSH)({
+        host,
+        script: `${remoteSSH_1.SUDO_PREAMBLE}
+if $SUDO test -f "${repoPath}/authorized_keys"; then
+    $SUDO cat "${repoPath}/authorized_keys"
+elif $SUDO test -d "${repoPath}"; then
+    $SUDO cat "${repoPath}"/*.pub 2>/dev/null || true
+fi`,
+        allowFailure: true,
+    });
+    return (0, authorizedKeys_1.normalizeKeys)(output.stdout);
+}
+async function installDaemon(config) {
+    let { host, hostLabel, repoSources } = config;
+    for (let command of ["node", "git", "yarn"]) {
+        if (!await (0, remoteSSH_1.remoteCommandExists)({ host, command })) {
+            throw new Error(`Expected ${command} to be installed on ${host}, it is not. Install it and rerun.`);
+        }
+    }
+    // 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}`);
+    await (0, remoteSSH_1.runOverSSH)({
+        host,
+        script: `${remoteSSH_1.SUDO_PREAMBLE}
+set -e
+$SUDO mkdir -p "${path_1.default.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}"
+    $SUDO git clone "${SLIFTUTILS_URL}" "${REMOTE_CHECKOUT_PATH}"
+fi
+$SUDO yarn --cwd "${REMOTE_CHECKOUT_PATH}" install --production --non-interactive
+# The single file daemon this replaced, left over on a host set up by an older version.
+$SUDO rm -f /opt/portsecure/portsecure-daemon.js`,
+    });
+    await (0, remoteSSH_1.writeRemoteFile)({
+        host,
+        filePath: REMOTE_CONFIG_PATH,
+        // Only what differs between machines. Every path the daemon uses is derived in the daemon
+        // itself, so there is nothing here to drift out of sync.
+        contents: JSON.stringify({ hostLabel, repoSources }, undefined, 4) + "\n",
+        fileMode: "600",
+        directoryMode: "700",
+    });
+    await (0, remoteSSH_1.writeRemoteFile)({
+        host,
+        filePath: REMOTE_SERVICE_PATH,
+        contents: await promises_1.default.readFile(SERVICE_SOURCE, "utf8"),
+        fileMode: "644",
+        directoryMode: "755",
+    });
+    await (0, remoteSSH_1.runOverSSH)({
+        host,
+        script: `${remoteSSH_1.SUDO_PREAMBLE}
+set -e
+$SUDO systemctl daemon-reload
+$SUDO systemctl enable ${SERVICE_NAME}
+$SUDO systemctl restart ${SERVICE_NAME}`,
+    });
+    let status = (await (0, remoteSSH_1.runOverSSH)({
+        host,
+        script: `systemctl is-active ${SERVICE_NAME} || true`,
+        allowFailure: true,
+    })).stdout.trim();
+    if (status !== "active") {
+        let journal = (await (0, remoteSSH_1.runOverSSH)({
+            host,
+            script: `${remoteSSH_1.SUDO_PREAMBLE}
+$SUDO journalctl -u ${SERVICE_NAME} -n 40 --no-pager || true`,
+            allowFailure: true,
+        })).stdout;
+        throw new Error(`Expected ${SERVICE_NAME} to be active on ${host}, was ${status}.\n${journal.slice(-2000)}`);
+    }
+    let stillReachable = await (0, remoteSSH_1.runOverSSH)({ host, script: "echo reachable", allowFailure: true });
+    if (stillReachable.stdout.trim() !== "reachable") {
+        throw new Error(`Expected ${host} to still be reachable after the daemon started, it is not.`
+            + ` Check console access immediately.`);
+    }
+}
+async function requireRemoteWebhook(host) {
+    let contents = await (0, remoteSSH_1.readRemoteFile)({ host, filePath: discord_1.DEFAULT_WEBHOOK_FILE_PATH });
+    if (!contents) {
+        throw new Error(`Expected a Discord webhook at ${discord_1.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>`);
+    }
+    return (0, discord_1.parseWebhookFile)({ contents, sourceName: `${host}:${discord_1.DEFAULT_WEBHOOK_FILE_PATH}` });
+}
+async function addSource(config) {
+    let { host, keyPath, repoURL } = config;
+    if (!await pathExists(keyPath)) {
+        throw new Error(`Expected a private key at ${keyPath}, no such file exists`);
+    }
+    console.log(`Checking ${repoURL} is reachable with ${keyPath}`);
+    let reachable = await gitWithKey({ keyPath, args: ["ls-remote", repoURL], allowFailure: true });
+    if (reachable.status !== 0) {
+        throw new Error(`Expected ${repoURL} to be reachable with ${keyPath}, git ls-remote failed.`
+            + ` The daemon would have no way to fetch keys.\n`
+            + `${(reachable.stdout + reachable.stderr).trim().slice(0, MAX_ERROR_BODY_LENGTH)}`);
+    }
+    let remoteConfig = await readRemoteConfig(host);
+    if (remoteConfig.repoSources.includes(repoURL)) {
+        console.log(`${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);
+    let inspectionPath = await cloneRepoForInspection({ repoURL, keyPath });
+    let newKeys = await (0, authorizedKeys_1.readRepoKeys)(inspectionPath);
+    // Whatever is applied on the host came from the existing sources, so it stays in the merge.
+    let existingKeys = (0, authorizedKeys_1.normalizeKeys)(await (0, remoteSSH_1.readRemoteFile)({ host, filePath: ROOT_AUTHORIZED_KEYS }) || "");
+    let mergedFingerprints = await fingerprintKeys([...existingKeys, ...newKeys]);
+    if (!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`
+            + `Merged: ${mergedFingerprints.join("\n        ") || "(none)"}\n`
+            + `The daemon replaces root's authorized_keys with the merged sources, so this would`
+            + ` 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.`);
+    await ensureRevokeRepo({ keyPath, repoURL });
+    // Deploying a repo that still holds a revoked key would hand it back to every machine.
+    let revoked = await (0, unrevoke_1.revokedKeysInRepo)({ repoPath: inspectionPath, sourceURL: repoURL });
+    if (revoked.length) {
+        throw new Error(`Expected ${repoURL} to hold no revoked keys, it holds ${revoked.length}:\n`
+            + revoked.map(entry => {
+                var _a;
+                return `  ${entry.revocation.fingerprint} revoked by`
+                    + ` ${entry.revocation.revokedBy || "?"} after use from ${((_a = entry.revocation.attempt) === null || _a === void 0 ? void 0 : _a.ip) || "?"}`;
+            }).join("\n")
+            + `\nDelete them from the repo, or run "yarn unrevoke" there to allow them again.`);
+    }
+    let webhookURL = await requireRemoteWebhook(host);
+    console.log(`${host} notifies ${webhookURL}`);
+    await (0, remoteSSH_1.writeRemoteFile)({
+        host,
+        filePath: (0, sources_1.sourceKeyPath)(repoURL),
+        contents: await promises_1.default.readFile(keyPath, "utf8"),
+        fileMode: "600",
+        directoryMode: "700",
+    });
+    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.`);
+}
+async function removeSource(config) {
+    let { host, repoURL } = config;
+    let remoteConfig = await readRemoteConfig(host);
+    if (!remoteConfig.repoSources.includes(repoURL)) {
+        throw new Error(`Expected ${repoURL} to be a source on ${host}, it is not.\n`
+            + `Configured:\n  ${remoteConfig.repoSources.join("\n  ") || "(none)"}`);
+    }
+    let repoSources = remoteConfig.repoSources.filter(source => source !== repoURL);
+    if (repoSources.length) {
+        // 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}`);
+        let ourFingerprint = await findAuthenticatingFingerprint(host);
+        let remainingKeys = [];
+        for (let source of repoSources) {
+            remainingKeys.push(...await readRemoteSourceKeys({ host, repoURL: source }));
+        }
+        let remainingFingerprints = await fingerprintKeys(remainingKeys);
+        if (!remainingFingerprints.includes(ourFingerprint)) {
+            throw new Error(`Expected the key we use for ${host} to still be in the remaining sources, it is not.\n`
+                + `Ours:      ${ourFingerprint}\n`
+                + `Remaining: ${remainingFingerprints.join("\n           ") || "(none)"}\n`
+                + `Removing ${repoURL} would lock you out of ${host}.`);
+        }
+    }
+    else {
+        // Nothing left to merge, so the daemon leaves root's authorized_keys exactly as it is.
+        console.log(`${repoURL} is the last source, so root's authorized_keys stays as it is now.`);
+    }
+    await requireRemoteWebhook(host);
+    await (0, remoteSSH_1.runOverSSH)({
+        host,
+        script: `${remoteSSH_1.SUDO_PREAMBLE}
+$SUDO rm -f "${(0, sources_1.sourceKeyPath)(repoURL)}"
+$SUDO rm -rf "${(0, sources_1.sourceRepoPath)(repoURL)}"`,
+    });
+    await installDaemon({ host, hostLabel: remoteConfig.hostLabel, repoSources });
+    console.log(`${repoURL} removed from ${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. */
+/** 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) {
+    let contents = await (0, remoteSSH_1.readRemoteFile)({ host, filePath: REMOTE_CONFIG_PATH });
+    if (!contents) {
+        throw new Error(`Expected ${host} to already have portsecure, ${REMOTE_CONFIG_PATH} does not exist.\n`
+            + `Set it up with:\n  yarn securessh ${host} add <repo-private-key> [repo-url]`);
+    }
+    let parsed = JSON.parse(contents);
+    let repoSources = parsed.repoSources || [];
+    await requireRemoteWebhook(host);
+    await ensureRevokeReposExist(repoSources);
+    await installDaemon({ host, hostLabel: parsed.hostLabel || host, repoSources });
+    console.log(`Updated the daemon on ${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) {
+    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.`);
+        return;
+    }
+    console.log(`${host} lets root log in with the keys from ${remoteConfig.repoSources.length} repo(s):`);
+    let merged = new Set();
+    for (let repoURL of remoteConfig.repoSources) {
+        let keys = await readRemoteSourceKeys({ host, repoURL });
+        console.log(`\n  ${repoURL}`);
+        if (!keys.length) {
+            console.log(`    grants no keys - the checkout is missing or empty`);
+            continue;
+        }
+        console.log(`    grants ${keys.length} key(s):`);
+        for (let key of keys) {
+            console.log(`      ${(0, authorizedKeys_1.summarizeKey)(key)}`);
+            merged.add(key);
+        }
+    }
+    if (remoteConfig.repoSources.length > 1) {
+        console.log(`\n${merged.size} key(s) in total once duplicates are merged.`);
+    }
+}
+/** The verb is a fixed word rather than a position, so it is pulled out of the arguments wherever
+    it was typed and everything left over is positional. */
+function parseArgs(argv) {
+    let verbs = argv.filter(arg => VERBS.includes(arg));
+    if (!verbs.length) {
+        throw new Error(`Expected one of ${VERBS.join(", ")} somewhere in the arguments, was ${argv.join(" ") || "(nothing)"}\n${USAGE}`);
+    }
+    if (verbs.length > 1) {
+        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 };
+}
+async function main() {
+    let { verb, host, rest } = parseArgs(process.argv.slice(2));
+    if (verb === "list") {
+        await listSources(host);
+        return;
+    }
+    if (verb === "update") {
+        if (rest.length) {
+            throw new Error(`Expected nothing after update, was ${rest.length} argument(s)\n${USAGE}`);
+        }
+        await updateDaemon(host);
+        return;
+    }
+    if (verb === "add") {
+        if (!rest.length || rest.length > 2) {
+            throw new Error(`Expected a private key and optionally a repo url, was ${rest.length} argument(s)\n${USAGE}`);
+        }
+        await addSource({ host, keyPath: (0, paths_1.expandHome)(rest[0]), repoURL: await resolveRepoURL(rest[1]) });
+        return;
+    }
+    if (rest.length > 1) {
+        throw new Error(`Expected at most a repo url to remove, was ${rest.length} argument(s)\n${USAGE}`);
+    }
+    await removeSource({ host, repoURL: await resolveRepoURL(rest[0]) });
+}
+exports.main = main;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"secureSSH.js","sourceRoot":"","sources":["secureSSH.ts"],"names":[],"mappings":"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","sourcesContent":["import fs from \"fs/promises\";\nimport os from \"os\";\nimport path from \"path\";\nimport { DEFAULT_WEBHOOK_FILE_PATH, parseWebhookFile } from \"../notifications/discord\";\nimport { normalizeKeys, readRepoKeys, summarizeKey } from \"./authorizedKeys\";\nimport { sourceKeyPath, sourceRepoPath } from \"./sources\";\nimport { deriveRevokeKey, REVOKE_KEY_LABEL, revokeRepoURL } from \"./revokeSource\";\nimport { revokedKeysInRepo } from \"./unrevoke\";\nimport { expandHome } from \"../helpers/paths\";\nimport { spawnPromise } from \"../helpers/spawn\";\nimport { readRemoteFile, remoteCommandExists, runOverSSH, SUDO_PREAMBLE, writeRemoteFile } from \"../helpers/remoteSSH\";\n\nconst SERVICE_SOURCE = path.join(__dirname, \"daemon\", \"portsecure.service\");\n// The daemon runs from a checkout of this repo on the host, rather than from a copy we upload, so\n// a host updates itself from github the same way anything else does. sliftutils is public, so this\n// needs no key.\nconst SLIFTUTILS_URL = \"https://github.com/sliftist/sliftutils.git\";\nconst REMOTE_CHECKOUT_PATH = \"/opt/portsecure/sliftutils\";\nconst REMOTE_SERVICE_PATH = \"/etc/systemd/system/portsecure.service\";\nconst REMOTE_CONFIG_PATH = \"/etc/portsecure/daemon.json\";\nconst ROOT_AUTHORIZED_KEYS = \"/root/.ssh/authorized_keys\";\nconst SERVICE_NAME = \"portsecure\";\nconst MAX_ERROR_BODY_LENGTH = 500;\nconst VERBS = [\"add\", \"remove\", \"list\", \"update\"];\n// The repo url is optional, and defaults to the repo the command is run from.\nconst USAGE = `Usage:\n  yarn securessh <host> add <repo-private-key> [repo-url]\n  yarn securessh <host> remove [repo-url]\n  yarn securessh <host> list\n  yarn securessh <host> update`;\n\nasync function pathExists(filePath: string) {\n    try {\n        await fs.access(filePath);\n        return true;\n    } catch (e) {\n        return false;\n    }\n}\n\nasync function runLocal(config: { command: string; args: string[]; cwd?: string; allowFailure?: boolean }) {\n    let { command, args, cwd, allowFailure } = config;\n    let result = await spawnPromise({ command, args, cwd });\n    if (result.error) {\n        throw new Error(`Expected ${command} to run, failed with ${result.error.message}`);\n    }\n    if (result.status !== 0 && !allowFailure) {\n        throw new Error(\n            `Expected ${command} ${args.join(\" \")} to exit 0, was ${result.status}. `\n            + `${(result.stdout + result.stderr).trim().slice(0, MAX_ERROR_BODY_LENGTH)}`\n        );\n    }\n    return result;\n}\n\n/** A private key cannot authenticate an https remote, so github urls are converted to the ssh form\n    the key can actually be used with. */\nfunction normalizeRepoURL(repoURL: string) {\n    let httpsMatch = repoURL.match(/^https?:\\/\\/([^/]+)\\/(.+?)(?:\\.git)?\\/?$/);\n    if (!httpsMatch) {\n        return repoURL;\n    }\n    let [, host, repoPath] = httpsMatch;\n    return `git@${host}:${repoPath}.git`;\n}\n\nasync function gitWithKey(config: { keyPath: string; args: string[]; cwd?: string; allowFailure?: boolean }) {\n    let { keyPath, args, cwd, allowFailure } = config;\n    // core.sshCommand keeps key selection with the command instead of in the environment.\n    let sshCommand = `ssh -i ${keyPath} -o IdentitiesOnly=yes -o BatchMode=yes -o StrictHostKeyChecking=accept-new`;\n    let result = await spawnPromise({ command: \"git\", args: [\"-c\", `core.sshCommand=${sshCommand}`, ...args], cwd });\n    if (result.error) {\n        throw new Error(`Expected git to run, failed with ${result.error.message}`);\n    }\n    if (result.status !== 0 && !allowFailure) {\n        throw new Error(\n            `Expected git ${args.join(\" \")} to exit 0, was ${result.status}. `\n            + `${(result.stdout + result.stderr).trim().slice(0, MAX_ERROR_BODY_LENGTH)}`\n        );\n    }\n    return result;\n}\n\n/** Asks ssh which key it actually authenticated with. This is the key that must survive the\n    daemon taking over authorized_keys, otherwise a deploy locks us out. */\nasync function findAuthenticatingFingerprint(host: string) {\n    let result = await spawnPromise({\n        command: \"ssh\",\n        args: [\"-v\", \"-o\", \"BatchMode=yes\", \"-o\", \"ConnectTimeout=10\", host, \"true\"],\n    });\n    let verboseOutput = result.stderr || \"\";\n    if (result.status !== 0) {\n        throw new Error(`Expected to ssh into ${host}, failed. ${verboseOutput.slice(-MAX_ERROR_BODY_LENGTH)}`);\n    }\n    let acceptedMatch = verboseOutput.match(/Server accepts key:.*?(SHA256:[A-Za-z0-9+/=]+)/);\n    if (!acceptedMatch) {\n        throw new Error(\n            `Expected ${host} to accept a public key, but the session did not authenticate with one.`\n            + ` portsecure disables password login, so key based access has to work first.`\n        );\n    }\n    return acceptedMatch[1];\n}\n\nasync function fingerprintKeys(keys: string[]) {\n    if (!keys.length) {\n        return [];\n    }\n    let temporaryDirectory = await fs.mkdtemp(path.join(os.tmpdir(), \"portsecure-keys-\"));\n    let keysPath = path.join(temporaryDirectory, \"authorized_keys\");\n    await fs.writeFile(keysPath, `${keys.join(\"\\n\")}\\n`);\n    let result = await runLocal({ command: \"ssh-keygen\", args: [\"-lf\", keysPath], allowFailure: true });\n    await fs.rm(temporaryDirectory, { recursive: true, force: true });\n    let fingerprints: string[] = [];\n    for (let line of result.stdout.split(\"\\n\")) {\n        let match = line.match(/(SHA256:[A-Za-z0-9+/=]+)/);\n        if (match) {\n            fingerprints.push(match[1]);\n        }\n    }\n    return fingerprints;\n}\n\nasync function cloneRepoForInspection(config: { repoURL: string; keyPath: string }) {\n    let { repoURL, keyPath } = config;\n    let temporaryDirectory = await fs.mkdtemp(path.join(os.tmpdir(), \"portsecure-repo-\"));\n    let repoPath = path.join(temporaryDirectory, \"repo\");\n    await gitWithKey({ keyPath, args: [\"clone\", \"--depth\", \"1\", repoURL, repoPath] });\n    return repoPath;\n}\n\n/** With no repo url given, the repo we are standing in is used. It has to actually hold keys\n    before we hand it to a host, so a stray working directory cannot be deployed by accident. */\nasync function resolveRepoURL(passedURL: string | undefined) {\n    if (passedURL) {\n        return normalizeRepoURL(passedURL);\n    }\n    let topLevel = await runLocal({ command: \"git\", args: [\"rev-parse\", \"--show-toplevel\"], allowFailure: true });\n    if (topLevel.status !== 0) {\n        throw new Error(`Expected a repo url, or the current directory to be inside a git repo, it is not.\\n${USAGE}`);\n    }\n    let repoPath = topLevel.stdout.trim();\n    try {\n        await readRepoKeys(repoPath);\n    } catch (e) {\n        throw new Error(\n            `Expected a repo url, or the current repo (${repoPath}) to hold keys, it does not.\\n${e}\\n${USAGE}`\n        );\n    }\n    let origin = await runLocal({\n        command: \"git\",\n        args: [\"remote\", \"get-url\", \"origin\"],\n        cwd: repoPath,\n        allowFailure: true,\n    });\n    if (origin.status !== 0 || !origin.stdout.trim()) {\n        throw new Error(\n            `Expected the current repo (${repoPath}) to have an origin remote, it has none.`\n            + ` The host clones the source itself, so a local path is no use to it.`\n        );\n    }\n    let repoURL = normalizeRepoURL(origin.stdout.trim());\n    console.log(`No repo url given, using the current repo: ${repoURL}`);\n    return repoURL;\n}\n\n/** Every source's revoke repo has to exist and hold at least one commit, or the hosts using it\n    cannot record a revocation. Checked with this machine's own git credentials, since update is\n    not given any deploy key, and an empty repo is initialised rather than merely complained about.\n\n    A host that cannot write a revocation silently keeps accepting a key it just saw being misused,\n    which is the one failure this whole thing exists to prevent, so it is checked on every deploy\n    and not only when a source is first added. */\nasync function ensureRevokeReposExist(repoSources: string[]) {\n    for (let repoURL of repoSources) {\n        let revokeURL = revokeRepoURL(repoURL);\n        let temporaryDirectory = await fs.mkdtemp(path.join(os.tmpdir(), \"portsecure-revoke-\"));\n        let checkoutPath = path.join(temporaryDirectory, \"repo\");\n        let clone = await runLocal({ command: \"git\", args: [\"clone\", revokeURL, checkoutPath], allowFailure: true });\n        if (clone.status !== 0) {\n            await fs.rm(temporaryDirectory, { recursive: true, force: true });\n            throw new Error(\n                `Expected ${revokeURL} to exist, it does not, so ${repoURL} has nowhere to record a`\n                + ` revocation.\\nCreate it, then run \"yarn securessh <host> add\" for that source to`\n                + ` register its deploy key.\\n${(clone.stdout + clone.stderr).trim().slice(0, MAX_ERROR_BODY_LENGTH)}`\n            );\n        }\n        let head = await runLocal({ command: \"git\", args: [\"-C\", checkoutPath, \"rev-parse\", \"HEAD\"], allowFailure: true });\n        if (head.status !== 0) {\n            console.log(`${revokeURL} is empty, giving it a first commit`);\n            await fs.writeFile(path.join(checkoutPath, \"README.md\"),\n                `# revoked keys\\n\\nWritten by portsecure. Each file under revocations/ is one key that was used from an\\n`\n                + `address it is not allowed from, and is no longer accepted anywhere.\\n`);\n            for (let args of [\n                [\"-C\", checkoutPath, \"add\", \"-A\"],\n                [\"-C\", checkoutPath, \"-c\", \"user.email=portsecure@localhost\", \"-c\", \"user.name=portsecure\", \"commit\", \"-m\", \"initialise revoke repo\"],\n                [\"-C\", checkoutPath, \"push\", \"origin\", \"HEAD\"],\n            ]) {\n                await runLocal({ command: \"git\", args });\n            }\n        }\n        await fs.rm(temporaryDirectory, { recursive: true, force: true });\n        console.log(`${revokeURL} is ready`);\n    }\n}\n\n/** The revoke repo has to exist and be writable before a host is set up, because a host that\n    cannot write a revocation cannot revoke a key that is being misused. The key for it is derived\n    from the source's, since github will not take one public key on two repos. */\nasync function ensureRevokeRepo(config: { keyPath: string; repoURL: string }) {\n    let { keyPath, repoURL } = config;\n    let revokeURL = revokeRepoURL(repoURL);\n    let derived = deriveRevokeKey(await fs.readFile(keyPath, \"utf8\"));\n\n    let temporaryDirectory = await fs.mkdtemp(path.join(os.tmpdir(), \"portsecure-revoke-\"));\n    let derivedKeyPath = path.join(temporaryDirectory, \"key\");\n    await fs.writeFile(derivedKeyPath, derived.privateKeyFile, { mode: 0o600 });\n    let checkoutPath = path.join(temporaryDirectory, \"repo\");\n\n    let explain = (problem: string) => new Error(\n        `${problem}\\n`\n        + `Create ${revokeURL} and add this as a deploy key WITH WRITE ACCESS:\\n`\n        + `  ${derived.publicKey} ${REVOKE_KEY_LABEL}\\n`\n        + `It has to be this key: it is derived from ${keyPath}, and github will not accept the same`\n        + ` public key on two repositories.`\n    );\n\n    console.log(`Checking ${revokeURL}`);\n    let clone = await gitWithKey({ keyPath: derivedKeyPath, args: [\"clone\", revokeURL, checkoutPath], allowFailure: true });\n    if (clone.status !== 0) {\n        throw explain(`Expected ${revokeURL} to be readable with the derived key, it is not.`);\n    }\n\n    // An empty repo has no branch for the daemon to clone, so it gets its first commit here. That\n    // doubles as the proof that we can write to it.\n    let head = await gitWithKey({ keyPath: derivedKeyPath, args: [\"rev-parse\", \"HEAD\"], cwd: checkoutPath, allowFailure: true });\n    if (head.status !== 0) {\n        await fs.writeFile(path.join(checkoutPath, \"README.md\"),\n            `# revoked keys\\n\\nWritten by portsecure. Each file under revocations/ is one key that was used from an\\n`\n            + `address it is not allowed from, and is no longer accepted anywhere.\\n`);\n        for (let args of [\n            [\"add\", \"-A\"],\n            [\"-c\", \"user.email=portsecure@localhost\", \"-c\", \"user.name=portsecure\", \"commit\", \"-m\", \"initialise revoke repo\"],\n        ]) {\n            await gitWithKey({ keyPath: derivedKeyPath, args, cwd: checkoutPath });\n        }\n        let push = await gitWithKey({ keyPath: derivedKeyPath, args: [\"push\", \"origin\", \"HEAD\"], cwd: checkoutPath, allowFailure: true });\n        if (push.status !== 0) {\n            throw explain(`Expected write access to ${revokeURL}, the first push was refused.\\n${(push.stdout + push.stderr).trim().slice(0, MAX_ERROR_BODY_LENGTH)}`);\n        }\n    } else {\n        let dryRun = await gitWithKey({ keyPath: derivedKeyPath, args: [\"push\", \"--dry-run\", \"origin\", \"HEAD\"], cwd: checkoutPath, allowFailure: true });\n        if (dryRun.status !== 0) {\n            throw explain(`Expected write access to ${revokeURL}, a dry run push was refused.\\n${(dryRun.stdout + dryRun.stderr).trim().slice(0, MAX_ERROR_BODY_LENGTH)}`);\n        }\n    }\n\n    await fs.rm(temporaryDirectory, { recursive: true, force: true });\n    console.log(`${revokeURL} is writable`);\n}\n\nasync function readRemoteConfig(host: string) {\n    let contents = await readRemoteFile({ host, filePath: REMOTE_CONFIG_PATH });\n    if (!contents) {\n        return { hostLabel: host, repoSources: [] as string[] };\n    }\n    let parsed = JSON.parse(contents) as { hostLabel?: string; repoSources?: string[] };\n    return { hostLabel: parsed.hostLabel || host, repoSources: parsed.repoSources || [] };\n}\n\n/** Reads the keys a source's checkout currently holds on the host, so the merged result can be\n    worked out without needing that source's private key locally. */\nasync function readRemoteSourceKeys(config: { host: string; repoURL: string }) {\n    let { host, repoURL } = config;\n    let repoPath = sourceRepoPath(repoURL);\n    let output = await runOverSSH({\n        host,\n        script: `${SUDO_PREAMBLE}\nif $SUDO test -f \"${repoPath}/authorized_keys\"; then\n    $SUDO cat \"${repoPath}/authorized_keys\"\nelif $SUDO test -d \"${repoPath}\"; then\n    $SUDO cat \"${repoPath}\"/*.pub 2>/dev/null || true\nfi`,\n        allowFailure: true,\n    });\n    return normalizeKeys(output.stdout);\n}\n\nasync function installDaemon(config: { host: string; hostLabel: string; repoSources: string[] }) {\n    let { host, hostLabel, repoSources } = config;\n    for (let command of [\"node\", \"git\", \"yarn\"]) {\n        if (!await remoteCommandExists({ host, command })) {\n            throw new Error(`Expected ${command} to be installed on ${host}, it is not. Install it and rerun.`);\n        }\n    }\n\n    // The checkout is brought to the latest commit rather than a copy being pushed, so what runs on\n    // the host is exactly what is on github.\n    console.log(`Updating ${REMOTE_CHECKOUT_PATH} on ${host}`);\n    await runOverSSH({\n        host,\n        script: `${SUDO_PREAMBLE}\nset -e\n$SUDO mkdir -p \"${path.posix.dirname(REMOTE_CHECKOUT_PATH)}\"\nif $SUDO test -d \"${REMOTE_CHECKOUT_PATH}/.git\"; then\n    # Stashed first, the way machine-alwaysup does it. Anything sitting modified in a host's\n    # checkout is either an accident or somebody editing the daemon in place, and either way it is\n    # worth keeping rather than quietly erasing. The identity is passed inline because a host has\n    # no git config of its own and stash writes a commit.\n    $SUDO git -C \"${REMOTE_CHECKOUT_PATH}\" add --all\n    $SUDO git -C \"${REMOTE_CHECKOUT_PATH}\" -c user.email=portsecure@localhost -c user.name=portsecure stash\n    $SUDO git -C \"${REMOTE_CHECKOUT_PATH}\" fetch --prune origin\n    # A stash and a pull cannot cross a branch that has diverged, and a drifted checkout must not be\n    # able to leave a host running old code, so it is put on the remote's state rather than merged\n    # with it. set-head so that is the remote's default branch now, not the one it had at clone.\n    $SUDO git -C \"${REMOTE_CHECKOUT_PATH}\" remote set-head origin --auto\n    $SUDO git -C \"${REMOTE_CHECKOUT_PATH}\" reset --hard origin/HEAD\nelse\n    $SUDO rm -rf \"${REMOTE_CHECKOUT_PATH}\"\n    $SUDO git clone \"${SLIFTUTILS_URL}\" \"${REMOTE_CHECKOUT_PATH}\"\nfi\n$SUDO yarn --cwd \"${REMOTE_CHECKOUT_PATH}\" install --production --non-interactive\n# The single file daemon this replaced, left over on a host set up by an older version.\n$SUDO rm -f /opt/portsecure/portsecure-daemon.js`,\n    });\n    await writeRemoteFile({\n        host,\n        filePath: REMOTE_CONFIG_PATH,\n        // Only what differs between machines. Every path the daemon uses is derived in the daemon\n        // itself, so there is nothing here to drift out of sync.\n        contents: JSON.stringify({ hostLabel, repoSources }, undefined, 4) + \"\\n\",\n        fileMode: \"600\",\n        directoryMode: \"700\",\n    });\n    await writeRemoteFile({\n        host,\n        filePath: REMOTE_SERVICE_PATH,\n        contents: await fs.readFile(SERVICE_SOURCE, \"utf8\"),\n        fileMode: \"644\",\n        directoryMode: \"755\",\n    });\n    await runOverSSH({\n        host,\n        script: `${SUDO_PREAMBLE}\nset -e\n$SUDO systemctl daemon-reload\n$SUDO systemctl enable ${SERVICE_NAME}\n$SUDO systemctl restart ${SERVICE_NAME}`,\n    });\n\n    let status = (await runOverSSH({\n        host,\n        script: `systemctl is-active ${SERVICE_NAME} || true`,\n        allowFailure: true,\n    })).stdout.trim();\n    if (status !== \"active\") {\n        let journal = (await runOverSSH({\n            host,\n            script: `${SUDO_PREAMBLE}\n$SUDO journalctl -u ${SERVICE_NAME} -n 40 --no-pager || true`,\n            allowFailure: true,\n        })).stdout;\n        throw new Error(`Expected ${SERVICE_NAME} to be active on ${host}, was ${status}.\\n${journal.slice(-2000)}`);\n    }\n\n    let stillReachable = await runOverSSH({ host, script: \"echo reachable\", allowFailure: true });\n    if (stillReachable.stdout.trim() !== \"reachable\") {\n        throw new Error(\n            `Expected ${host} to still be reachable after the daemon started, it is not.`\n            + ` Check console access immediately.`\n        );\n    }\n}\n\nasync function requireRemoteWebhook(host: string) {\n    let contents = await readRemoteFile({ host, filePath: DEFAULT_WEBHOOK_FILE_PATH });\n    if (!contents) {\n        throw new Error(\n            `Expected a Discord webhook at ${DEFAULT_WEBHOOK_FILE_PATH} on ${host}, no such file exists.`\n            + ` The daemon will not start without one.\\n`\n            + `Set it up first:\\n  yarn setupnotify ${host} <discord-webhook-url>`\n        );\n    }\n    return parseWebhookFile({ contents, sourceName: `${host}:${DEFAULT_WEBHOOK_FILE_PATH}` });\n}\n\nasync function addSource(config: { host: string; keyPath: string; repoURL: string }) {\n    let { host, keyPath, repoURL } = config;\n    if (!await pathExists(keyPath)) {\n        throw new Error(`Expected a private key at ${keyPath}, no such file exists`);\n    }\n\n    console.log(`Checking ${repoURL} is reachable with ${keyPath}`);\n    let reachable = await gitWithKey({ keyPath, args: [\"ls-remote\", repoURL], allowFailure: true });\n    if (reachable.status !== 0) {\n        throw new Error(\n            `Expected ${repoURL} to be reachable with ${keyPath}, git ls-remote failed.`\n            + ` The daemon would have no way to fetch keys.\\n`\n            + `${(reachable.stdout + reachable.stderr).trim().slice(0, MAX_ERROR_BODY_LENGTH)}`\n        );\n    }\n\n    let remoteConfig = await readRemoteConfig(host);\n    if (remoteConfig.repoSources.includes(repoURL)) {\n        console.log(`${host} already has ${repoURL}, refreshing its key and the daemon.`);\n    }\n\n    // The merged result is what root ends up with, so our own key has to be somewhere in it.\n    console.log(`Checking our access to ${host} survives the merged keys`);\n    let ourFingerprint = await findAuthenticatingFingerprint(host);\n    let inspectionPath = await cloneRepoForInspection({ repoURL, keyPath });\n    let newKeys = await readRepoKeys(inspectionPath);\n    // Whatever is applied on the host came from the existing sources, so it stays in the merge.\n    let existingKeys = normalizeKeys(await readRemoteFile({ host, filePath: ROOT_AUTHORIZED_KEYS }) || \"\");\n    let mergedFingerprints = await fingerprintKeys([...existingKeys, ...newKeys]);\n    if (!mergedFingerprints.includes(ourFingerprint)) {\n        throw new Error(\n            `Expected the key we use for ${host} to be in the merged keys, it is not.\\n`\n            + `Ours:   ${ourFingerprint}\\n`\n            + `Merged: ${mergedFingerprints.join(\"\\n        \") || \"(none)\"}\\n`\n            + `The daemon replaces root's authorized_keys with the merged sources, so this would`\n            + ` lock you out of ${host}. Add your public key to ${repoURL} first.`\n        );\n    }\n    console.log(`Our key ${ourFingerprint} is in the merged keys, access will survive.`);\n\n    await ensureRevokeRepo({ keyPath, repoURL });\n\n    // Deploying a repo that still holds a revoked key would hand it back to every machine.\n    let revoked = await revokedKeysInRepo({ repoPath: inspectionPath, sourceURL: repoURL });\n    if (revoked.length) {\n        throw new Error(\n            `Expected ${repoURL} to hold no revoked keys, it holds ${revoked.length}:\\n`\n            + revoked.map(entry => `  ${entry.revocation.fingerprint} revoked by`\n                + ` ${entry.revocation.revokedBy || \"?\"} after use from ${entry.revocation.attempt?.ip || \"?\"}`).join(\"\\n\")\n            + `\\nDelete them from the repo, or run \"yarn unrevoke\" there to allow them again.`\n        );\n    }\n\n    let webhookURL = await requireRemoteWebhook(host);\n    console.log(`${host} notifies ${webhookURL}`);\n\n    await writeRemoteFile({\n        host,\n        filePath: sourceKeyPath(repoURL),\n        contents: await fs.readFile(keyPath, \"utf8\"),\n        fileMode: \"600\",\n        directoryMode: \"700\",\n    });\n\n    let repoSources = remoteConfig.repoSources.filter(source => source !== repoURL);\n    repoSources.push(repoURL);\n    await installDaemon({ host, hostLabel: remoteConfig.hostLabel, repoSources });\n    console.log(`${repoURL} added to ${host}. ${repoSources.length} source(s) now merged.`);\n}\n\nasync function removeSource(config: { host: string; repoURL: string }) {\n    let { host, repoURL } = config;\n    let remoteConfig = await readRemoteConfig(host);\n    if (!remoteConfig.repoSources.includes(repoURL)) {\n        throw new Error(\n            `Expected ${repoURL} to be a source on ${host}, it is not.\\n`\n            + `Configured:\\n  ${remoteConfig.repoSources.join(\"\\n  \") || \"(none)\"}`\n        );\n    }\n    let repoSources = remoteConfig.repoSources.filter(source => source !== repoURL);\n\n    if (repoSources.length) {\n        // The keys left over are what root gets, so our own key has to be among them.\n        console.log(`Checking our access to ${host} survives without ${repoURL}`);\n        let ourFingerprint = await findAuthenticatingFingerprint(host);\n        let remainingKeys: string[] = [];\n        for (let source of repoSources) {\n            remainingKeys.push(...await readRemoteSourceKeys({ host, repoURL: source }));\n        }\n        let remainingFingerprints = await fingerprintKeys(remainingKeys);\n        if (!remainingFingerprints.includes(ourFingerprint)) {\n            throw new Error(\n                `Expected the key we use for ${host} to still be in the remaining sources, it is not.\\n`\n                + `Ours:      ${ourFingerprint}\\n`\n                + `Remaining: ${remainingFingerprints.join(\"\\n           \") || \"(none)\"}\\n`\n                + `Removing ${repoURL} would lock you out of ${host}.`\n            );\n        }\n    } else {\n        // Nothing left to merge, so the daemon leaves root's authorized_keys exactly as it is.\n        console.log(`${repoURL} is the last source, so root's authorized_keys stays as it is now.`);\n    }\n\n    await requireRemoteWebhook(host);\n    await runOverSSH({\n        host,\n        script: `${SUDO_PREAMBLE}\n$SUDO rm -f \"${sourceKeyPath(repoURL)}\"\n$SUDO rm -rf \"${sourceRepoPath(repoURL)}\"`,\n    });\n    await installDaemon({ host, hostLabel: remoteConfig.hostLabel, repoSources });\n    console.log(`${repoURL} removed from ${host}. ${repoSources.length} source(s) left.`);\n}\n\n/** Answers \"who can log into this box, and which repo says so\". The paths the daemon uses are\n    left out on purpose, they are plumbing rather than something to act on. */\n\n/** Pushes the current daemon onto a host that already has one, for when this code has moved on.\n    Nothing about which keys the host trusts is touched. */\nasync function updateDaemon(host: string) {\n    let contents = await readRemoteFile({ host, filePath: REMOTE_CONFIG_PATH });\n    if (!contents) {\n        throw new Error(\n            `Expected ${host} to already have portsecure, ${REMOTE_CONFIG_PATH} does not exist.\\n`\n            + `Set it up with:\\n  yarn securessh ${host} add <repo-private-key> [repo-url]`\n        );\n    }\n    let parsed = JSON.parse(contents) as { hostLabel?: string; repoSources?: string[] };\n    let repoSources = parsed.repoSources || [];\n    await requireRemoteWebhook(host);\n    await ensureRevokeReposExist(repoSources);\n    await installDaemon({ host, hostLabel: parsed.hostLabel || host, repoSources });\n    console.log(`Updated the daemon on ${host}, and restarted it.`);\n    console.log(`Its ${repoSources.length} key source(s) were left as they are, along with the keys and`);\n    console.log(`signers it has already accepted. Only the daemon itself changed:`);\n    for (let repoURL of repoSources) {\n        console.log(`  ${repoURL}`);\n    }\n}\n\nasync function listSources(host: string) {\n    let remoteConfig = await readRemoteConfig(host);\n    if (!remoteConfig.repoSources.length) {\n        console.log(`${host} has no key sources. root's authorized_keys is left exactly as it is.`);\n        return;\n    }\n    console.log(`${host} lets root log in with the keys from ${remoteConfig.repoSources.length} repo(s):`);\n    let merged = new Set<string>();\n    for (let repoURL of remoteConfig.repoSources) {\n        let keys = await readRemoteSourceKeys({ host, repoURL });\n        console.log(`\\n  ${repoURL}`);\n        if (!keys.length) {\n            console.log(`    grants no keys - the checkout is missing or empty`);\n            continue;\n        }\n        console.log(`    grants ${keys.length} key(s):`);\n        for (let key of keys) {\n            console.log(`      ${summarizeKey(key)}`);\n            merged.add(key);\n        }\n    }\n    if (remoteConfig.repoSources.length > 1) {\n        console.log(`\\n${merged.size} key(s) in total once duplicates are merged.`);\n    }\n}\n\n/** The verb is a fixed word rather than a position, so it is pulled out of the arguments wherever\n    it was typed and everything left over is positional. */\nfunction parseArgs(argv: string[]) {\n    let verbs = argv.filter(arg => VERBS.includes(arg));\n    if (!verbs.length) {\n        throw new Error(`Expected one of ${VERBS.join(\", \")} somewhere in the arguments, was ${argv.join(\" \") || \"(nothing)\"}\\n${USAGE}`);\n    }\n    if (verbs.length > 1) {\n        throw new Error(`Expected one of ${VERBS.join(\", \")}, was ${verbs.join(\" and \")}\\n${USAGE}`);\n    }\n    let verb = verbs[0];\n    let [host, ...rest] = argv.filter(arg => arg !== verb);\n    if (!host) {\n        throw new Error(`Expected a host, was nothing\\n${USAGE}`);\n    }\n    return { verb, host, rest };\n}\n\nexport async function main() {\n    let { verb, host, rest } = parseArgs(process.argv.slice(2));\n\n    if (verb === \"list\") {\n        await listSources(host);\n        return;\n    }\n    if (verb === \"update\") {\n        if (rest.length) {\n            throw new Error(`Expected nothing after update, was ${rest.length} argument(s)\\n${USAGE}`);\n        }\n        await updateDaemon(host);\n        return;\n    }\n    if (verb === \"add\") {\n        if (!rest.length || rest.length > 2) {\n            throw new Error(`Expected a private key and optionally a repo url, was ${rest.length} argument(s)\\n${USAGE}`);\n        }\n        await addSource({ host, keyPath: expandHome(rest[0]), repoURL: await resolveRepoURL(rest[1]) });\n        return;\n    }\n    if (rest.length > 1) {\n        throw new Error(`Expected at most a repo url to remove, was ${rest.length} argument(s)\\n${USAGE}`);\n    }\n    await removeSource({ host, repoURL: await resolveRepoURL(rest[0]) });\n}\n"]}
+ /* _JS_SOURCE_HASH = "3c90444025671cc3213dcfd869a36bc1c8cca2b502d5ce035d38986a40c7cf9f"; */