@r3ply/cli 0.0.1

package/dist/index.mjs

@@ -0,0 +1,2007 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/index.ts
+import { program as program2 } from "commander";
+
+// src/cmds/init.ts
+import { Command } from "commander";
+import dayjs2 from "dayjs";
+
+// src/tty/init.ts
+var init_exports = {};
+__export(init_exports, {
+  print_initialized_new_project: () => print_initialized_new_project,
+  print_warn_force_is_set: () => print_warn_force_is_set
+});
+import chalk from "chalk";
+import path from "path";
+import { highlight } from "cli-highlight";
+import TOML from "@iarna/toml";
+function print_warn_force_is_set() {
+  console.debug(
+    `--force=true ${tty_default.txt.warn("overwrites any preexisting .r3ply dir!\n")}`
+  );
+}
+function print_initialized_new_project(r3ply_dir, signet_config, format) {
+  console.info(
+    `Initialized empty r3ply project at ${chalk.greenBright(path.dirname(r3ply_dir))}`,
+    `
+
+${tty_default.txt.help("Add the following site entry to your config:")}`,
+    `
+
+${highlight(format == "toml" ? TOML.stringify(signet_config) : JSON.stringify(signet_config, null, 2))}`,
+    `
+${tty_default.txt.help("Help:")} You can generate a config with ${tty_default.txt.help("`re generate config`")} if you have not already.`
+  );
+}
+
+// src/tty/generate.ts
+var generate_exports = {};
+__export(generate_exports, {
+  print_config: () => print_config,
+  print_email: () => print_email,
+  print_mail_to_link: () => print_mail_to_link,
+  print_signet: () => print_signet
+});
+import chalk2 from "chalk";
+import { highlight as highlight2 } from "cli-highlight";
+import TOML2 from "@iarna/toml";
+function print_mail_to_link(query) {
+  if (query == "") {
+    console.debug(
+      tty_default.txt.help(
+        `# hint: use options, e.g. '--to', otherwise mailto link will be mostly empty.`
+      )
+    );
+  }
+  console.log(chalk2.blueBright(`mailto:${query}`));
+}
+function print_signet(signet, format) {
+  console.log(
+    highlight2(
+      format == "toml" ? TOML2.stringify({
+        site: [{ ...signet }]
+      }) : JSON.stringify(
+        {
+          site: [{ ...signet }]
+        },
+        null,
+        2
+      )
+    )
+  );
+}
+function print_config(site_config, format) {
+  console.log(
+    highlight2(
+      format == "toml" ? TOML2.stringify(site_config) : JSON.stringify(site_config, null, 2)
+    )
+  );
+}
+function print_email(email) {
+  console.log(highlight2(email, { language: "yaml" }));
+}
+
+// src/tty/simulate.ts
+var simulate_exports = {};
+__export(simulate_exports, {
+  print_comment_via_email_initial: () => print_comment_via_email_initial,
+  print_comment_via_email_response: () => print_comment_via_email_response,
+  print_github_moderation_event: () => print_github_moderation_event,
+  print_ignored_moderation_channels: () => print_ignored_moderation_channels,
+  print_local_moderation_event: () => print_local_moderation_event
+});
+import { highlight as highlight3 } from "cli-highlight";
+
+// src/util.ts
+import path2 from "path";
+import fs from "fs";
+import { Result } from "oxide.ts";
+var util;
+((util2) => {
+  class CLIError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "CLIError";
+    }
+  }
+  util2.CLIError = CLIError;
+  async function find_up(filename, cwd = process.cwd()) {
+    let currentDir = cwd;
+    do {
+      const file_path = path2.join(currentDir, filename);
+      const result = await Result.safe(fs.promises.access(file_path));
+      if (result.isOk()) return file_path;
+      currentDir = path2.dirname(currentDir);
+    } while (currentDir !== path2.dirname(currentDir));
+    return void 0;
+  }
+  util2.find_up = find_up;
+  function unsafeUnwrap(result) {
+    return result.unwrapOrElse(() => {
+      throw new CLIError(result.unwrapErr()?.message ?? String(result.unwrapErr()));
+    });
+  }
+  util2.unsafeUnwrap = unsafeUnwrap;
+  async function read_stdin() {
+    if (process.stdin.isTTY) return "";
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+      chunks.push(chunk);
+    }
+    return Buffer.concat(
+      chunks.map((c) => Buffer.isBuffer(c) ? c : Buffer.from(c))
+    ).toString("utf8");
+  }
+  util2.read_stdin = read_stdin;
+  function random_int(ceiling, floor = 0) {
+    return Math.floor(Math.random() * (ceiling - floor)) + floor;
+  }
+  util2.random_int = random_int;
+  function collect_opts(value, previous = []) {
+    return previous.concat([value]);
+  }
+  util2.collect_opts = collect_opts;
+  function split_list(param) {
+    return param.split(",").map((item) => item.trim());
+  }
+  util2.split_list = split_list;
+  function print_w_quiet_and_filter_opts(params, condition) {
+    const { quiet, filter } = params;
+    if (filter) {
+      if (filter == true || filter.some((stage) => {
+        if (condition.includes("=")) {
+          return condition.includes(stage);
+        } else {
+          return stage.startsWith(condition);
+        }
+      })) {
+        return print_w_quiet(quiet, condition);
+      } else {
+        return false;
+      }
+    }
+    return print_w_quiet(quiet, condition);
+  }
+  util2.print_w_quiet_and_filter_opts = print_w_quiet_and_filter_opts;
+  function print_w_quiet(quiet, condition) {
+    if (quiet) {
+      if (quiet == true) {
+        return false;
+      } else {
+        if (quiet.some((stage) => {
+          if (condition.startsWith(stage)) {
+            if (condition.includes("=")) {
+              return condition == stage;
+            } else {
+              return true;
+            }
+          } else {
+            return false;
+          }
+        })) {
+          return false;
+        } else return true;
+      }
+    } else {
+      return true;
+    }
+  }
+})(util || (util = {}));
+
+// src/tty/simulate.ts
+import TOML3 from "@iarna/toml";
+function print_comment_via_email_initial(email, options) {
+  if (util.print_w_quiet_and_filter_opts(options, "email")) {
+    if (options.heading) console.log(`${tty_default.txt.info("# === Input Email ===")}`);
+    console.log(
+      highlight3(email.replace(/\r/g, ""), {
+        language: "yaml",
+        ignoreIllegals: true
+      }) + "\n\n"
+    );
+  }
+}
+function print_comment_via_email_response(cli_system_config, {
+  site_config_path,
+  site_config
+}, email_event_response, options, format) {
+  if (util.print_w_quiet_and_filter_opts(options, "config")) {
+    if (util.print_w_quiet_and_filter_opts(options, "config=system")) {
+      if (options.heading)
+        console.log(`${tty_default.txt.info("# === Comment: System Config ===\n")}`);
+      console.log(
+        format == "toml" ? highlight3(
+          `# Generated using site config 
+${TOML3.stringify(cli_system_config)}`,
+          { language: "toml", ignoreIllegals: true }
+        ) + "\n" : highlight3(
+          `/* Generated using site config*/ 
+${JSON.stringify(cli_system_config, null, 2)}`,
+          { language: "json", ignoreIllegals: true }
+        ) + "\n"
+      );
+    }
+    if (util.print_w_quiet_and_filter_opts(options, "config=site")) {
+      if (options.heading)
+        console.log(`${tty_default.txt.info("# === Comment: Site Config ===\n")}`);
+      console.log(
+        format == "toml" ? `${highlight3(
+          `# From path ${site_config_path} 
+${TOML3.stringify(site_config)}`,
+          { language: "toml", ignoreIllegals: true }
+        )}` : `${highlight3(
+          `/* From path ${site_config_path} */ 
+${JSON.stringify(site_config, null, 2)}`,
+          { language: "json", ignoreIllegals: true }
+        )}
+`
+      );
+    }
+  }
+  if (util.print_w_quiet_and_filter_opts(options, "prescreen")) {
+    if (options.heading)
+      console.log(
+        tty_default.txt.info("# === Comment: Prescreening Results ===") + "\n"
+      );
+    if (email_event_response.prescreening.isOk()) {
+      const result = email_event_response.prescreening.unwrap();
+      delete result.comments_configured.general_comments;
+      delete result.comments_configured.email_comments;
+      console.log(
+        format == "toml" ? highlight3(TOML3.stringify(result), {
+          language: "toml",
+          ignoreIllegals: true
+        }) : highlight3(JSON.stringify(result, null, 2), {
+          language: "json",
+          ignoreIllegals: true
+        }) + "\n"
+      );
+    } else {
+      console.log(tty_default.txt.warn("# Prescreening failed checks:\n"));
+      const prescreen_failures = email_event_response.prescreening.unwrapErr();
+      if (prescreen_failures.r3ply_is_disabled.result == "fail") {
+        console.log(
+          format == "toml" ? highlight3(
+            TOML3.stringify({
+              r3ply_is_disabled: prescreen_failures.r3ply_is_disabled.errors
+            })
+          ) : highlight3(
+            JSON.stringify(
+              {
+                r3ply_is_disabled: prescreen_failures.r3ply_is_disabled.errors
+              },
+              null,
+              2
+            ) + "\n"
+          )
+        );
+      }
+      if (prescreen_failures.comments_accepted.result == "fail") {
+        console.log(
+          format == "toml" ? highlight3(
+            TOML3.stringify({
+              comments_accepted: prescreen_failures.comments_accepted.errors
+            })
+          ) : highlight3(
+            JSON.stringify(
+              {
+                comments_accepted: prescreen_failures.comments_accepted.errors
+              },
+              null,
+              2
+            ) + "\n"
+          )
+        );
+      }
+      if (prescreen_failures.comments_configured.result == "fail") {
+        console.log(
+          format == "toml" ? highlight3(
+            TOML3.stringify({
+              comments_configured: prescreen_failures.comments_configured.errors
+            })
+          ) : highlight3(
+            JSON.stringify(
+              {
+                comments_configured: prescreen_failures.comments_configured.errors
+              },
+              null,
+              2
+            )
+          )
+        );
+      }
+      if (prescreen_failures.email_size_bytes.result == "fail") {
+        console.log(
+          format == "toml" ? highlight3(
+            TOML3.stringify({
+              email_size_bytes: prescreen_failures.email_size_bytes.errors
+            })
+          ) : highlight3(
+            JSON.stringify(
+              {
+                email_size_bytes: prescreen_failures.email_size_bytes.errors
+              },
+              null,
+              2
+            )
+          )
+        );
+      }
+    }
+  }
+  const receive_details = email_event_response.received;
+  if (receive_details) {
+    if (util.print_w_quiet_and_filter_opts(options, "receive")) {
+      if (options.heading) {
+        console.log(tty_default.txt.info("# === Comment: Comment Received ===") + "\n");
+        if (receive_details.isOk()) {
+          console.log(
+            format == "toml" ? highlight3(TOML3.stringify(receive_details.unwrap()), {
+              language: "toml",
+              ignoreIllegals: true
+            }) : highlight3(JSON.stringify(receive_details.unwrap()), {
+              language: "json",
+              ignoreIllegals: true
+            }) + "\n"
+          );
+        } else {
+          console.log(tty_default.txt.warn(receive_details.unwrapErr() + "\n"));
+        }
+      }
+    }
+  }
+  const deliverable_details = email_event_response.deliverable;
+  if (deliverable_details) {
+    if (util.print_w_quiet_and_filter_opts(options, "deliverable")) {
+      if (options.heading)
+        console.log(
+          `${tty_default.txt.info("# === Comment: Deliverability Details ===")}
+`
+        );
+      if (deliverable_details.isOk()) {
+        const result = deliverable_details.unwrap();
+        delete result.email;
+        console.log(
+          format == "toml" ? `${highlight3("# Note: `From` is redacted\n" + TOML3.stringify(result), { language: "toml", ignoreIllegals: true })}` : `${highlight3("/* Note: `From` is redacted */\n" + JSON.stringify(result, null, 2), { language: "json", ignoreIllegals: true })}
+`
+        );
+      } else {
+        console.log(`${tty_default.txt.warn(deliverable_details.unwrapErr())}
+`);
+      }
+    }
+  }
+  const prepare_details = email_event_response.prepared;
+  if (prepare_details) {
+    if (util.print_w_quiet_and_filter_opts(options, "prepare")) {
+      if (options.heading)
+        console.log(`${tty_default.txt.info("# === Comment: Template Context ===\n")}`);
+      if (prepare_details.isOk()) {
+        console.log(
+          format == "toml" ? `${highlight3("# These are the values available to your templates\n\n" + TOML3.stringify(prepare_details.unwrap()), { language: "toml", ignoreIllegals: true })}` : `${highlight3("/* These are the values available to your templates */\n" + JSON.stringify(prepare_details.unwrap(), null, 2), { language: "json", ignoreIllegals: true })}
+`
+        );
+      } else {
+        console.log(tty_default.txt.warn(prepare_details.unwrapErr() + "\n"));
+      }
+    }
+  }
+  const process_details = email_event_response.comment;
+  if (process_details) {
+    if (util.print_w_quiet_and_filter_opts(options, "comment")) {
+      if (options.heading)
+        console.log(`${tty_default.txt.info("# === Comment: Processed ===")}
+`);
+      if (process_details.isOk()) {
+        console.log(highlight3(process_details.unwrap()));
+      } else {
+        console.log(tty_default.txt.warn(process_details.unwrapErr() + "\n"));
+      }
+    }
+  }
+}
+function print_local_moderation_event(request, ticket, count, options, format) {
+  if (util.print_w_quiet_and_filter_opts(options, "moderation")) {
+    if (util.print_w_quiet_and_filter_opts(options, `moderation=local_${count}`)) {
+      if (options.heading)
+        console.log(tty_default.txt.info(`# === Moderation: Local[${count}] ===
+`));
+      if (request.isOk()) {
+        const partial_request = request.unwrap();
+        delete partial_request["send"];
+        partial_request.args = request.unwrap().args;
+        partial_request.args.comment = "[elided... see above (or add `comment` to --filter`)]";
+        const result_string = format == "toml" ? TOML3.stringify({
+          request: partial_request
+        }).replace(
+          "[request]",
+          "# `bypass` asks to skip moderation altogether. For local moderation it has no effect.\n[request]"
+        ).replace(
+          /^(\s*)\[request\.args\]/m,
+          (_, spaces) => `${spaces}# \`relative_path\` is relative to project root.${spaces}[request.args]`
+        ) : JSON.stringify(
+          {
+            request: partial_request
+          },
+          null,
+          2
+        ).replace(
+          /^(\s*)"bypass":/m,
+          (_, spaces) => `${spaces}/* \`bypass\` asks to skip moderation altogether. For local moderation it has no effect. */
+${spaces}"bypass":`
+        ).replace(
+          /^(\s*)"args":/m,
+          (_, spaces) => `${spaces}/* \`relative_path\` is relative to project root. */
+${spaces}"args":`
+        ) + "\n";
+        const request_comment = format == "toml" ? `#################################
+# Request portion of moderation #
+#################################
+` : `/*********************************
+ * Request portion of moderation *
+ *********************************/
+`;
+        console.log(
+          highlight3(request_comment + "\n" + result_string, {
+            language: format
+          })
+        );
+        if (ticket) {
+          if (ticket.details.isOk()) {
+            const ticket_details = ticket.details.unwrap();
+            const ticket_string = format == "toml" ? TOML3.stringify({
+              ticket: ticket_details
+            }).replace(
+              "[ticket.local]",
+              "# `ticket.local` is the response to a request for local moderation.\n[ticket.local]"
+            ) : JSON.stringify(
+              {
+                ticket: ticket_details
+              },
+              null,
+              2
+            ).replace(
+              /^(\s*)"local":/m,
+              (_, spaces) => `${spaces}/* \`ticket.local\` is the response to a request for local moderation. */
+${spaces}"local":`
+            );
+            const ticket_comment = format == "toml" ? `################################
+# Ticket portion of moderation #
+################################
+` : `/********************************
+ * Ticket portion of moderation *
+ ********************************/
+`;
+            console.log(
+              highlight3(ticket_comment + "\n" + ticket_string, {
+                language: format
+              })
+            );
+          } else {
+            const error = ticket.details.unwrapErr();
+            console.log(tty_default.txt.warn(`Error: ${error.message}`));
+          }
+        }
+      } else {
+        const error = request.unwrapErr();
+        console.log(tty_default.txt.warn(`Moderation skipped: ${error.message}`));
+      }
+      console.log();
+    }
+  }
+}
+function print_github_moderation_event(request, ticket, count, options, format) {
+  if (util.print_w_quiet_and_filter_opts(options, "moderation")) {
+    if (util.print_w_quiet_and_filter_opts(options, `moderation=github_${count}`)) {
+      if (options.heading)
+        console.log(
+          tty_default.txt.info(`# === Moderation: GitHub[${count}] (MOCKED) ===
+`)
+        );
+      if (request.isOk()) {
+        const partial_request = request.unwrap();
+        delete partial_request["send"];
+        partial_request.args = request.unwrap().args;
+        partial_request.args.comment_data = "[elided... see above (or add `comment` to --filter`)]";
+        const result_string = format == "toml" ? TOML3.stringify({
+          request: partial_request
+        }).replace(
+          "[request]",
+          "# `bypass` would request to skip moderation altogether.\n[request]"
+        ).replace(
+          /^(\s*)\[request\.args\]/m,
+          (_, spaces) => `${spaces}# Arguments that would be sent to create a GitHub PR${spaces}[request.args]`
+        ) : JSON.stringify(
+          {
+            request: partial_request
+          },
+          null,
+          2
+        ).replace(
+          /^(\s*)"bypass":/m,
+          (_, spaces) => `${spaces}/* \`bypass\` would request to skip moderation altogether. */
+${spaces}"bypass":`
+        ).replace(
+          /^(\s*)"args":/m,
+          (_, spaces) => `${spaces}/* Arguments that would be sent to create a GitHub PR */
+${spaces}"args":`
+        ) + "\n";
+        const request_comment = format == "toml" ? `#################################
+# Request portion of moderation #
+#################################
+` : `/*********************************
+ * Request portion of moderation *
+ *********************************/
+`;
+        console.log(
+          highlight3(request_comment + "\n" + result_string, {
+            language: format
+          })
+        );
+        if (ticket) {
+          if (ticket.details.isOk()) {
+            const ticket_details = ticket.details.unwrap();
+            const ticket_string = format == "toml" ? TOML3.stringify({
+              ticket: ticket_details
+            }).replace(
+              "[ticket.github]",
+              "# `ticket.local` is the response to a request for local moderation.\n[ticket.local]"
+            ) : JSON.stringify(
+              {
+                ticket: ticket_details
+              },
+              null,
+              2
+            ).replace(
+              "[ticket.github]",
+              "# `ticket.local` is the response to a request for local moderation.\n[ticket.local]"
+            ).replace(
+              /^(\s*)"github":/m,
+              (_, spaces) => `${spaces}/* \`ticket.local\` is the response to a request for local moderation. */
+${spaces}"github":`
+            );
+            const ticket_comment = format == "toml" ? `################################
+# Ticket portion of moderation #
+################################
+` : `/********************************
+ * Ticket portion of moderation *
+ ********************************/
+`;
+            console.log(
+              highlight3(ticket_comment + "\n" + ticket_string, {
+                language: format
+              })
+            );
+          } else {
+            const error = ticket.details.unwrapErr();
+            console.log(tty_default.txt.warn(`Error: ${error.message}`));
+          }
+        }
+      } else {
+        const error = request.unwrapErr();
+        console.log(tty_default.txt.warn(`Moderation skipped: ${error.message}`));
+      }
+      console.log();
+    }
+  }
+}
+function print_ignored_moderation_channels(ignored_moderation_types, not_implemented_moderation_results, options, format) {
+  if (util.print_w_quiet_and_filter_opts(options, "moderation")) {
+    if (util.print_w_quiet_and_filter_opts(options, `moderation=other`)) {
+      if (options.heading)
+        console.log(tty_default.txt.info(`# === Moderation: Other ===
+`));
+      const ignored_moderation = format == "toml" ? TOML3.stringify({
+        ignored: ignored_moderation_types
+      }).replace(
+        "ignored",
+        "# moderation channels in your config that were ignored by the CLI (they're unsupported)\nignored"
+      ) : JSON.stringify(
+        {
+          ignored: ignored_moderation_types
+        },
+        null,
+        2
+      ).replace(
+        /^(\s*)"ignored":/m,
+        (_, spaces) => `${spaces}/* moderation channels in your config that were ignored by the CLI (they're unsupported) */
+${spaces}"ignored":`
+      ) + "\n";
+      console.log(highlight3(ignored_moderation));
+      const not_implemented_mod = format == "toml" ? TOML3.stringify({
+        not_implemented: not_implemented_moderation_results
+      }) : JSON.stringify(
+        {
+          not_implemented: not_implemented_moderation_results
+        },
+        null,
+        2
+      );
+      console.log(
+        format == "toml" ? highlight3(
+          "# unexpected moderation results that haven't been fully implemented\n" + not_implemented_mod
+        ) : highlight3(
+          "/* unexpected moderation results that haven't been fully implemented */\n" + not_implemented_mod
+        )
+      );
+    }
+  }
+}
+
+// src/tty/cache.ts
+var cache_exports = {};
+__export(cache_exports, {
+  print_serving_cache: () => print_serving_cache
+});
+function print_serving_cache(cache_dir, options) {
+  if (options.reset) console.log(`Resetting cache at ${cache_dir}`);
+  console.log(
+    `Static server running at http://${options.interface}:${options.port}`
+  );
+  console.log(`Serving files from: ${cache_dir}`);
+}
+
+// src/tty/index.ts
+import chalk3 from "chalk";
+function txt_info(...text) {
+  return chalk3.whiteBright(text);
+}
+function txt_help(...text) {
+  return chalk3.yellowBright(text);
+}
+function txt_warn(...text) {
+  return chalk3.redBright(text);
+}
+var tty_default = {
+  txt: {
+    info: txt_info,
+    help: txt_help,
+    warn: txt_warn
+  },
+  cmds: {
+    init: init_exports,
+    generate: generate_exports,
+    simulate: simulate_exports,
+    cache: cache_exports
+  }
+};
+
+// src/lib.ts
+import path3 from "path";
+import fs2 from "fs";
+import { Result as Result2, Option } from "oxide.ts";
+import fg from "fast-glob";
+import TOML4 from "@iarna/toml";
+import {
+  R3plySiteConfig,
+  R3plySystemConfig
+} from "@r3ply/schema/config";
+import chalk4 from "chalk";
+import { RiMarkov } from "rita";
+import { fileURLToPath } from "url";
+import {
+  SignetIssuer
+} from "@r3ply/lib";
+import dayjs from "dayjs";
+import { build_email } from "@r3ply/wasm";
+import crypto from "crypto";
+import { mailbox } from "typescript-mailbox-parser";
+var project;
+((project2) => {
+  const R3PLY_DIR = ".r3ply";
+  const CONFIG_GLOB_PATTERNS = [
+    `**/r3ply/config.{toml,json}`,
+    `**/r3ply.config.{toml,json}`
+  ];
+  const CLI_SYSTEM_CONFIG_FILENAME = "r3ply.system.config.toml";
+  const CLI_SETTINGS_FILENAME = "r3ply.cli.settings.toml";
+  const SIGNET_KEY_FILENAME = "signet.key";
+  const ENCRYPT_EMAIL_KEY_FILENAME = "encrypt_email.key";
+  project2.DEFAULT_SITE_DOMAIN = "site.local.test";
+  project2.DEFAULT_R3PLY_DOMAIN = "cli.r3ply.test";
+  project2.DEFAULT_SIGNET_KEY = "6eFnDQTHov/yKkhLp/HdZDSU/vryNJ4XeNOgX2XBCVI=";
+  project2.DEFAULT_EMAIL_KEY = "f+466zchScGV5oiKq4W5hxCct1iXBuwgRUnx8tBSuQQ=";
+  project2.DEFAULT_CLI_SIGNET_LABEL = "CLI";
+  const DEFAULT_STATIC_DIR = "static";
+  const CACHE_DIR = "cache";
+  async function find_r3ply_dir(cwd) {
+    const find_result = util.find_up(".r3ply", cwd).then((path4) => {
+      if (path4) return path4;
+      else
+        throw new util.CLIError(
+          `No ${R3PLY_DIR} directory found. ${chalk4.yellow(`You can run ${chalk4.white("`re init`")} to initialize one.`)}`
+        );
+    });
+    return Result2.safe(find_result);
+  }
+  project2.find_r3ply_dir = find_r3ply_dir;
+  async function find_project_dir(cwd) {
+    return find_r3ply_dir(cwd).then((r3ply_dir) => {
+      return r3ply_dir.map((r3ply_dir2) => path3.dirname(r3ply_dir2));
+    });
+  }
+  project2.find_project_dir = find_project_dir;
+  async function find_site_config_files(from_dir, file_glob) {
+    if (file_glob)
+      return Result2.safe(fg.async([file_glob], { dot: true, cwd: from_dir }));
+    else
+      return Result2.safe(
+        fg.async(CONFIG_GLOB_PATTERNS, { dot: true, cwd: from_dir })
+      );
+  }
+  project2.find_site_config_files = find_site_config_files;
+  async function find_static_dir(cwd) {
+    const r3ply_dir = find_r3ply_dir(cwd).then((result) => result.unwrap());
+    const static_dir = path3.join(await r3ply_dir, DEFAULT_STATIC_DIR);
+    return static_dir;
+  }
+  project2.find_static_dir = find_static_dir;
+  async function get_static_dir(cwd, reset = false) {
+    const static_dir = await find_static_dir(cwd);
+    const access = await Result2.safe(fs2.promises.access(static_dir));
+    if (access.isOk()) {
+      return static_dir;
+    } else {
+      return fs2.promises.mkdir(static_dir).then((_) => static_dir);
+    }
+  }
+  project2.get_static_dir = get_static_dir;
+  async function find_cache_dir(cwd) {
+    const static_dir = await find_static_dir(cwd);
+    const cache_dir = path3.join(await static_dir, CACHE_DIR);
+    return cache_dir;
+  }
+  project2.find_cache_dir = find_cache_dir;
+  async function get_cache_dir(cwd, reset = false) {
+    const cache_dir = await find_cache_dir(cwd);
+    const access = await Result2.safe(fs2.promises.access(cache_dir));
+    if (access.isOk()) {
+      if (reset) await clean_cache(cwd);
+      return cache_dir;
+    } else {
+      return fs2.promises.mkdir(cache_dir, { recursive: true }).then((_) => cache_dir);
+    }
+  }
+  project2.get_cache_dir = get_cache_dir;
+  async function clean_cache(cwd) {
+    const cache_dir = await find_cache_dir(cwd);
+    const access = await Result2.safe(fs2.promises.access(cache_dir));
+    if (access.isOk()) {
+      await fs2.promises.rm(cache_dir, { recursive: true, force: true }).then((_) => fs2.promises.mkdir(cache_dir));
+    } else {
+      throw new util.CLIError(`No cache found at ${cache_dir}`);
+    }
+  }
+  project2.clean_cache = clean_cache;
+  async function add_comment_to_cache(cwd, comment) {
+    const cache_dir = await get_cache_dir(cwd);
+    const comment_path = path3.join(cache_dir, comment.path);
+    const parent = path3.dirname(comment_path);
+    await fs2.promises.mkdir(parent, { recursive: true });
+    return fs2.promises.writeFile(
+      comment_path,
+      JSON.stringify(comment.content, null, 2)
+    );
+  }
+  project2.add_comment_to_cache = add_comment_to_cache;
+  async function get_comment_from_cache(cwd, comment) {
+    const cache_dir = await get_cache_dir(cwd);
+    const comment_path = path3.join(cache_dir, comment.path);
+    const access = await Result2.safe(fs2.promises.access(comment_path));
+    if (access.isOk()) {
+      return fs2.promises.readFile(comment_path).then((bytes) => JSON.parse(bytes.toString()));
+    } else {
+      return [];
+    }
+  }
+  project2.get_comment_from_cache = get_comment_from_cache;
+  async function evict_comments_from_cache(cwd, at_path, max_age_seconds) {
+    const cache_dir = await get_cache_dir(cwd);
+    const comments_path = path3.join(cache_dir, at_path);
+    return walk(comments_path);
+    async function walk(dir) {
+      const entries = await fs2.promises.readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const full_path = path3.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          return walk(full_path);
+        } else {
+          return fs2.promises.readFile(full_path).then(
+            (bytes) => JSON.parse(bytes.toString())
+          ).then((comments) => {
+            const new_comments = [];
+            const now_unix = dayjs().unix();
+            for (const comment of comments) {
+              const comment_sent_unix = dayjs(comment.email.date).unix();
+              const age = now_unix - comment_sent_unix;
+              if (age <= max_age_seconds) new_comments.push(comment);
+              else
+                console.debug(
+                  `Deleting comment with ID "${comment.comment.id}" as it is ${age} seconds old.`
+                );
+            }
+            return fs2.promises.writeFile(
+              full_path,
+              JSON.stringify(new_comments, null, 2)
+            );
+          });
+        }
+      }
+    }
+  }
+  project2.evict_comments_from_cache = evict_comments_from_cache;
+  async function get_site_config_path(cwd, config_path) {
+    const full_config_path = (async () => {
+      const project_dir = util.unsafeUnwrap(await find_project_dir(cwd));
+      if (config_path) {
+        const relative_files = util.unsafeUnwrap(
+          await find_site_config_files(cwd, config_path)
+        );
+        if (relative_files.length == 0)
+          throw new util.CLIError(
+            `No config found at ${path3.resolve(cwd, config_path)}`
+          );
+        else if (relative_files.length > 1)
+          throw new util.CLIError(
+            `Multiple matches found: ${JSON.stringify(relative_files, null, 2)}`
+          );
+        else return path3.resolve(cwd, relative_files[0]);
+      } else {
+        const relative_files = util.unsafeUnwrap(
+          await find_site_config_files(project_dir)
+        );
+        if (relative_files.length == 0)
+          throw new util.CLIError(`No r3ply config found within ${chalk4.white(project_dir)}. ${chalk4.yellow(`You can run ${chalk4.white("`re generate config`")} to generate one. (Make sure to save it to the expected file path, e.g. ${chalk4.white('"r3ply.config.toml"')}.)`)}`);
+        else if (relative_files.length > 1)
+          throw new util.CLIError(
+            `Multiple matches found: ${JSON.stringify(relative_files, null, 2)}`
+          );
+        else return path3.resolve(project_dir, relative_files[0]);
+      }
+    })();
+    return Result2.safe(full_config_path);
+  }
+  project2.get_site_config_path = get_site_config_path;
+  async function parse_site_config(cwd, config_path) {
+    const parsed_site_config = get_site_config_path(cwd, config_path).then((full_config_path) => util.unsafeUnwrap(full_config_path)).then((full_config_path) => {
+      return fs2.promises.readFile(full_config_path).then((site_config_bytes) => site_config_bytes.toString()).then(
+        (site_config_str) => full_config_path.endsWith(".toml") ? TOML4.parse(site_config_str) : JSON.parse(site_config_str)
+      ).then((site_config_json) => R3plySiteConfig.parse(site_config_json));
+    });
+    return Result2.safe(parsed_site_config);
+  }
+  project2.parse_site_config = parse_site_config;
+  async function get_site_config(cwd, config_path) {
+    const site_config = parse_site_config(cwd, config_path).then((parsed_site_config) => util.unsafeUnwrap(parsed_site_config)).then(
+      (parsed_site_config) => Option(parsed_site_config.value).expect(
+        JSON.stringify(parsed_site_config.errors, null, 2)
+      )
+    );
+    return Result2.safe(site_config);
+  }
+  project2.get_site_config = get_site_config;
+  async function resolve_config(cwd, config_option) {
+    const site_config_path = await resolve_config_path(cwd, config_option);
+    return util.unsafeUnwrap(await get_site_config(cwd, site_config_path));
+  }
+  project2.resolve_config = resolve_config;
+  async function resolve_config_path(cwd, config_option) {
+    let site_config_path;
+    if (config_option) {
+      site_config_path = util.unsafeUnwrap(
+        await project2.get_site_config_path(cwd, config_option)
+      );
+    } else {
+      const project_dir = util.unsafeUnwrap(await project2.find_project_dir(cwd));
+      const cli_settings = util.unsafeUnwrap(
+        await project2.get_cli_settings(cwd)
+      );
+      site_config_path = util.unsafeUnwrap(
+        await project2.get_site_config_path(
+          project_dir,
+          cli_settings.default_config_path
+        )
+      );
+    }
+    return site_config_path;
+  }
+  project2.resolve_config_path = resolve_config_path;
+  async function get_cli_system_config(cwd) {
+    const r3ply_dir = find_r3ply_dir(cwd);
+    const result = r3ply_dir.then((r3ply_dir2) => {
+      return fs2.promises.readFile(
+        path3.resolve(
+          util.unsafeUnwrap(r3ply_dir2),
+          CLI_SYSTEM_CONFIG_FILENAME
+        )
+      );
+    }).then((text) => {
+      return R3plySystemConfig.parse(text.toString()).value;
+    });
+    return Result2.safe(result);
+  }
+  project2.get_cli_system_config = get_cli_system_config;
+  async function get_cli_settings(cwd) {
+    const r3ply_dir = util.unsafeUnwrap(await project2.find_r3ply_dir(cwd));
+    const cli_settings_path = path3.resolve(r3ply_dir, CLI_SETTINGS_FILENAME);
+    const settings = Result2.safe(
+      fs2.promises.readFile(cli_settings_path).then((bytes) => bytes.toString()).then((settings2) => TOML4.parse(settings2))
+    );
+    return settings;
+  }
+  project2.get_cli_settings = get_cli_settings;
+  async function set_cli_settings(cwd, new_settings) {
+    const r3ply_dir = util.unsafeUnwrap(await project2.find_r3ply_dir(cwd));
+    const cli_settings_path = path3.resolve(r3ply_dir, CLI_SETTINGS_FILENAME);
+    return Result2.safe(
+      fs2.promises.writeFile(cli_settings_path, TOML4.stringify(new_settings))
+    );
+  }
+  project2.set_cli_settings = set_cli_settings;
+  project2.dereference_local_file = async (base_uri, file_uri_ref) => {
+    const resolver = resolve_file_relative_to_site_config(base_uri);
+    return resolver(file_uri_ref);
+  };
+  function resolve_file_relative_to_site_config(config_path) {
+    const file_resolver = (file_uri) => {
+      if (file_uri) {
+        const r3ply_site_config_dir = path3.dirname(config_path);
+        const fully_qualified_file_path = path3.join(
+          r3ply_site_config_dir,
+          file_uri
+        );
+        return fs2.promises.readFile(fully_qualified_file_path).then((file_at_path_bytes) => file_at_path_bytes.toString());
+      } else return Promise.resolve(void 0);
+    };
+    return file_resolver;
+  }
+  project2.resolve_file_relative_to_site_config = resolve_file_relative_to_site_config;
+  async function init_r3ply_project_at(cwd, { force, rotateKeys }, dir) {
+    const new_r3ply_dir = path3.join(cwd, dir ?? "", R3PLY_DIR);
+    let parent_project_exists = find_r3ply_dir(new_r3ply_dir);
+    const signet_key = rotateKeys ? crypto.randomBytes(32).toString("base64") : project2.DEFAULT_SIGNET_KEY;
+    const email_key = rotateKeys ? crypto.randomBytes(32).toString("base64") : project2.DEFAULT_EMAIL_KEY;
+    let system_config = R3plySystemConfig({
+      domains: [project2.DEFAULT_R3PLY_DOMAIN],
+      admin: [
+        {
+          name: "Guybrush Threepwood",
+          email: "guybrush@example.com"
+        }
+      ]
+    }).value;
+    const result = parent_project_exists.then((parent_project_exists2) => {
+      const file_access = Result2.safe(fs2.promises.access(new_r3ply_dir));
+      return file_access.then(async (file_access2) => {
+        if (file_access2.isErr() || force) {
+          if (file_access2.isOk() && force) {
+            await fs2.promises.rm(new_r3ply_dir, {
+              recursive: true,
+              force: true
+            });
+            parent_project_exists2 = await find_r3ply_dir(new_r3ply_dir);
+          }
+          if (parent_project_exists2.isOk()) {
+            throw new util.CLIError(
+              `Nested r3ply project. There is already a parent directory initialized at ${chalk4.blue("`" + parent_project_exists2.unwrap() + "`")}.${chalk4.yellow("(Nested projects can lead to strange effects)")}`
+            );
+          }
+          return fs2.promises.mkdir(new_r3ply_dir).then(() => {
+            return fs2.promises.writeFile(
+              path3.resolve(new_r3ply_dir, SIGNET_KEY_FILENAME),
+              signet_key
+            ).then((_) => {
+              return fs2.promises.writeFile(
+                path3.resolve(new_r3ply_dir, ENCRYPT_EMAIL_KEY_FILENAME),
+                email_key
+              );
+            }).then((_) => {
+              return fs2.promises.writeFile(
+                path3.resolve(new_r3ply_dir, CLI_SYSTEM_CONFIG_FILENAME),
+                TOML4.stringify(system_config)
+              );
+            }).then((_) => {
+              return fs2.promises.writeFile(
+                path3.resolve(new_r3ply_dir, CLI_SETTINGS_FILENAME),
+                ""
+              );
+            }).then((_) => {
+              return fs2.promises.writeFile(
+                path3.resolve(new_r3ply_dir, ".gitignore"),
+                "static/cache"
+              );
+            }).then((_) => {
+              return {
+                r3ply_dir: new_r3ply_dir,
+                signet_key,
+                encrypt_email_key: email_key
+              };
+            });
+          });
+        } else {
+          throw new util.CLIError(
+            `Project already initialized at \`${chalk4.white(path3.dirname(new_r3ply_dir))}\`.`
+          );
+        }
+      });
+    });
+    return Result2.safe(result);
+  }
+  project2.init_r3ply_project_at = init_r3ply_project_at;
+  async function get_keys(cwd) {
+    return find_r3ply_dir(cwd).then((r3ply_dir) => {
+      const signet_key = fs2.promises.readFile(
+        path3.resolve(util.unsafeUnwrap(r3ply_dir), SIGNET_KEY_FILENAME)
+      ).then((buffer) => buffer.toString());
+      const encrypt_email_key = fs2.promises.readFile(
+        path3.resolve(
+          util.unsafeUnwrap(r3ply_dir),
+          ENCRYPT_EMAIL_KEY_FILENAME
+        )
+      ).then((buffer) => buffer.toString());
+      return Promise.all([signet_key, encrypt_email_key]).then(
+        ([signet_key2, encrypt_email_key2]) => {
+          return { signet_key: signet_key2, encrypt_email_key: encrypt_email_key2 };
+        }
+      );
+    });
+  }
+  project2.get_keys = get_keys;
+  async function set_default_cli_config_path(cwd, config_path) {
+    const project_dir = util.unsafeUnwrap(await find_project_dir(cwd));
+    const proposed_path = path3.resolve(project_dir, config_path);
+    const relative = path3.relative(project_dir, proposed_path);
+    if (relative.startsWith(".."))
+      throw new util.CLIError(
+        `Config path can not be outside of project directory "${project_dir}"`
+      );
+    const settings = util.unsafeUnwrap(await get_cli_settings(cwd));
+    settings["default_config_path"] = config_path;
+    return set_cli_settings(cwd, settings);
+  }
+  project2.set_default_cli_config_path = set_default_cli_config_path;
+})(project || (project = {}));
+var generate;
+((generate2) => {
+  function date(floor = Math.floor(Date.now() / 1e3) - 31536e4, ceiling = Math.floor(Date.now() / 1e3)) {
+    return util.random_int(ceiling, floor) * 1e3;
+  }
+  generate2.date = date;
+  function email_addr() {
+    const first = first_names[util.random_int(first_names.length)];
+    const last = last_names[util.random_int(last_names.length)];
+    const name = `${first} ${last}`;
+    const birthyear = util.random_int(1990, 1899);
+    const domain = `${domains[util.random_int(domains.length)]}.${tlds[util.random_int(tlds.length)]}`;
+    const local = `${first}.${Math.random() > 0.5 ? birthyear : last}`;
+    const addr = `${local}@${domain}`;
+    const mailbox4 = `${first} ${last} <${addr}>`;
+    return { name, domain, local, addr, mailbox: mailbox4 };
+  }
+  generate2.email_addr = email_addr;
+  function message_id(domain) {
+    return `${crypto.randomUUID()}@${domain}`;
+  }
+  generate2.message_id = message_id;
+  function subject(url) {
+    const site_path = site_paths[util.random_int(0, site_paths.length)];
+    const site_slug = site_slugs[util.random_int(0, site_slugs.length)];
+    return new URL(path3.join(site_path, site_slug), url).href;
+  }
+  generate2.subject = subject;
+  function comment_body(seed) {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path3.dirname(__filename);
+    const modelPath = path3.resolve(__dirname, "comments-markov-model.json");
+    const model_data = fs2.promises.readFile(modelPath, "utf-8");
+    const markov = model_data.then(
+      (model_data2) => RiMarkov.fromJSON(model_data2)
+    );
+    return markov.then(
+      (markov2) => markov2.generate({
+        maxLength: 36,
+        temperature: 1,
+        allowDuplicates: true,
+        seed
+      })
+    );
+  }
+  generate2.comment_body = comment_body;
+  async function email(site_domain, r3ply_domain, options) {
+    let from;
+    if (options?.from) {
+      from = parse_email_addr(options.from);
+    } else {
+      from = generate2.email_addr();
+    }
+    const message_id2 = options?.messageId || generate2.message_id(from.domain);
+    const date2 = dayjs(options?.date ?? new Date(generate2.date()));
+    const to = parse_email_addr(options?.to || `${site_domain}@${r3ply_domain}`);
+    const subject_url = new URL(`https://${to.local}/`);
+    const subject2 = options?.subject || generate2.subject(subject_url);
+    const body = options?.body || await generate2.comment_body().catch(
+      () => generate2.comment_body().catch(() => generate2.comment_body())
+    );
+    const email2 = Result2.safe(
+      () => build_email(
+        message_id2,
+        BigInt(date2.unix()),
+        from.name,
+        from.addr,
+        to.addr,
+        subject2,
+        body
+      )
+    );
+    return email2.unwrap();
+  }
+  generate2.email = email;
+  function parse_email_addr(email2) {
+    const result = mailbox(email2);
+    if (!result.ok)
+      throw new util.CLIError(
+        `Unable to parse email ${email2}, errors: ${JSON.stringify(result)}.`
+      );
+    result.local = result.local.replace(/^"(.*)"$/, "$1");
+    return result;
+  }
+  async function signet(key, cli_system, {
+    domain,
+    r3ply,
+    issued,
+    label
+  }) {
+    if (r3ply == project.DEFAULT_R3PLY_DOMAIN) {
+      return SignetIssuer(key, cli_system)(domain, r3ply, {
+        issued_date: issued,
+        label
+      });
+    } else {
+      return fetch(
+        new URL(
+          `https://${r3ply}/signet/${domain}${issued ? `/${issued}` : ""}`
+        )
+      ).then((response) => {
+        if (response.ok)
+          return response.json().then((json) => {
+            return { ...json, label };
+          });
+        else
+          return response.text().then((text) => {
+            throw new util.CLIError(text);
+          });
+      });
+    }
+  }
+  generate2.signet = signet;
+  function config(site_config) {
+    return TOML4.stringify(site_config);
+  }
+  generate2.config = config;
+})(generate || (generate = {}));
+var domains = [
+  "ghostpirate",
+  "lemonhead",
+  "grog",
+  "monkeyisland",
+  "tryscummvm",
+  "bananapicker",
+  "meleeisland",
+  "stanzboatz",
+  "chickenpulley",
+  "drinkgrog",
+  "dontdrinkgrog"
+];
+var tlds = ["com", "net", "us", "biz", "org", "io"];
+var first_names = [
+  "LeChuck",
+  "Guybrush",
+  "Elaine",
+  "Herman",
+  "Stan",
+  "Otis",
+  "Wally",
+  "Carla",
+  "Meathook",
+  "Morgan",
+  "Murray",
+  "Bob",
+  "Horatio",
+  "Ignatius",
+  "Winslow",
+  "Charles",
+  "Kate",
+  "Largo",
+  "Rum",
+  "Guy",
+  "Haggis",
+  "Cutthroat",
+  "Bobby",
+  "Frank",
+  "Plunder",
+  "Crimpdigit",
+  "Jolene",
+  "Dinghy",
+  "Belinda",
+  "Betsy",
+  "Dread",
+  "Esteban",
+  "Rapp",
+  "Doro",
+  "Santiago",
+  "Betty",
+  "Biff",
+  "Clarence",
+  "Indy",
+  "Henry",
+  "Sallah",
+  "Marion",
+  "Sophia",
+  "Jock",
+  "Shorty",
+  "Kazim",
+  "Marcus",
+  "Vogel"
+];
+var last_names = [
+  "'Ghost' Pirate",
+  "Threepwood",
+  "Marley",
+  "Toothrot",
+  "Sunderson",
+  "Fettucini",
+  "Scabb",
+  "Rottingham",
+  "Ozzie",
+  "Seepgood",
+  "Van Helgen",
+  "de Singe",
+  "Bloodnose",
+  "D'Oro",
+  "Weatherby",
+  "Nipikin",
+  "Pegnose",
+  "Hook",
+  "Flambe",
+  "Griswold",
+  "Booty",
+  "Bone",
+  "Lemonhead",
+  "Terror",
+  "Snugglecakes",
+  "Hartman",
+  "Deadeye",
+  "Graves",
+  "McMutton",
+  "Tannen",
+  "Seagull",
+  "Plank",
+  "Drake",
+  "Montezuma",
+  "Ravenwood",
+  "Donovan",
+  "Oxley",
+  "Brody",
+  "Katanga",
+  "Molotov",
+  "Spalko",
+  "Reinhardt",
+  "Belloq",
+  "Dietrich",
+  "McHale",
+  "Voller",
+  "Strasser",
+  "Krell",
+  "Egon"
+];
+var site_slugs = [
+  "how-I-met-herman-toothrot",
+  "finding-dads-diary",
+  "lechucks-curse-explained",
+  "secrets-of-monkey-island",
+  "guybrushs-best-comebacks",
+  "stan-and-his-neverending-sales",
+  "elaine-marley-the-real-hero",
+  "murray-the-talking-skull",
+  "top-10-insults-from-monkey-island",
+  "puzzle-solutions-you-forgot",
+  "escape-from-monkey-island-review",
+  "where-is-plunder-island",
+  "fettucini-brothers-circus",
+  "monkey-island-easter-eggs",
+  "worst-ways-to-die-in-monkey-island",
+  "indiana-jones-and-the-fate-of-atlantis-retrospective",
+  "top-5-foes-of-indiana-jones",
+  "finding-the-lost-dialog-of-plato",
+  "short-rounds-missing-adventure",
+  "best-action-scenes-in-indy-games",
+  "henry-jones-sr-quotes",
+  "why-marion-ravenwood-rules",
+  "greatest-puzzles-in-fate-of-atlantis",
+  "monkey-kombat-strategy-guide",
+  "the-many-faces-of-lechuck",
+  "deadly-traps-in-indiana-jones-games",
+  "sophia-hapgood-character-analysis",
+  "replaying-last-crusade",
+  "jock-lindsey-indianas-best-sidekick",
+  "marcus-brody-memorial",
+  "did-the-nazis-win-in-fate-of-atlantis",
+  "monkey-island-hidden-dialogue",
+  "lost-scenes-from-indiana-jones-games",
+  "why-we-need-more-point-and-click-adventures",
+  "best-inventory-items-in-monkey-island",
+  "fate-of-atlantis-secret-ending",
+  "best-quotes-from-monkey-island",
+  "worst-decisions-in-indy-games",
+  "stan-never-blinks-conspiracy",
+  "top-5-worst-ways-to-lose-in-monkey-island",
+  "replaying-monkey-island-in-2025",
+  "who-really-invented-grog",
+  "cut-content-from-monkey-island",
+  "why-monkey-island-3a-needs-to-happen",
+  "best-easter-eggs-in-indiana-jones-games",
+  "toughest-fights-in-monkey-island",
+  "horrible-ways-to-die-in-indiana-jones-games",
+  "ultimate-guide-to-monkey-island-lore",
+  "worst-npc-in-monkey-island",
+  "is-guybrush-a-good-pirate"
+];
+var site_paths = [
+  "blog",
+  "posts",
+  "articles",
+  "reviews",
+  "retrospectives",
+  "guides",
+  "walkthroughs",
+  "tips",
+  "secrets",
+  "features",
+  "history",
+  "interviews",
+  "behind-the-scenes",
+  "lore",
+  "characters",
+  "analysis",
+  "easter-eggs",
+  "strategy",
+  "rankings",
+  "opinion"
+];
+var moderation;
+((moderation2) => {
+  async function write_comment_locally(cwd, args, dryrun = false) {
+    const project_dir = util.unsafeUnwrap(await project.find_project_dir(cwd));
+    const proposed_path = path3.join(project_dir, args.relative_path);
+    const path_rel_to_proj = path3.relative(project_dir, proposed_path);
+    if (path_rel_to_proj.startsWith(".."))
+      throw new util.CLIError(
+        `Can't write comment to '${proposed_path}' because path is outside r3ply project directory!`
+      );
+    else {
+      if (!dryrun) {
+        fs2.writeFileSync(proposed_path, args.comment);
+      }
+      return proposed_path;
+    }
+  }
+  moderation2.write_comment_locally = write_comment_locally;
+  function mock_github_api_fetcher() {
+    const result = async (args) => {
+      const pr_num = 123;
+      const result2 = {
+        repo: {
+          owner: args.repo_owner,
+          name: args.repo_name,
+          url: `https://github.com/${args.repo_owner}/${args.repo_name}`
+        },
+        comment: {
+          path: args.new_comment_filepath
+        },
+        commit: {
+          message: args.new_comment_filepath
+        },
+        pr: {
+          branch: {
+            base: args.target_branch,
+            head: args.source_branch
+          },
+          url: `https://api.github.com/repos/${args.repo_owner}/${args.repo_name}/pulls/${pr_num}`,
+          html_url: `https://github.com/${args.repo_owner}/${args.repo_name}/pulls/${pr_num}`,
+          diff_url: `https://github.com/${args.repo_owner}/${args.repo_name}/pulls/${pr_num}.diff`,
+          patch_url: `https://github.com/${args.repo_owner}/${args.repo_name}/pulls/${pr_num}.patch`,
+          issue_url: `https://github.com/${args.repo_owner}/${args.repo_name}/issues/${pr_num}`,
+          commits_url: `https://github.com/${args.repo_owner}/${args.repo_name}/pulls/${pr_num}/commits`,
+          comments_url: `https://github.com/${args.repo_owner}/${args.repo_name}/pulls/${pr_num}/comments`,
+          statuses_url: `https://github.com/${args.repo_owner}/${args.repo_name}/pulls/${pr_num}/statuses/6dcb09b5b57875f334f61aebed695e2e4193db5e`,
+          number: pr_num,
+          state: "open",
+          title: args.pr?.msg_title ?? "",
+          body: args.pr?.msg_body ?? "",
+          created_at: (/* @__PURE__ */ new Date()).toISOString(),
+          commits: 1,
+          additions: 1,
+          deletions: 0,
+          changed_files: 1
+        }
+      };
+      return result2;
+    };
+    return result;
+  }
+  moderation2.mock_github_api_fetcher = mock_github_api_fetcher;
+})(moderation || (moderation = {}));
+
+// src/cmds/init.ts
+import { SignetIssuer as SignetIssuer2 } from "@r3ply/lib";
+function init_cmd(cwd) {
+  const init_cmd2 = new Command("init").description("initialize a new r3ply project (at current directory)").option(
+    "--date <YYYY-MM-DD>",
+    "set date of CLI issued signet",
+    dayjs2().format("YYYY-MM-DD")
+  ).option("-f, --force", "overwrite an existing r3ply project", false).option(
+    "--rotate-keys",
+    "regenerate anonymization and encryption keys",
+    false
+  ).action(async (options) => {
+    if (options.force) tty_default.cmds.init.print_warn_force_is_set();
+    return project.init_r3ply_project_at(cwd, options).then(async (result) => {
+      const system_config = util.unsafeUnwrap(
+        await project.get_cli_system_config(cwd)
+      );
+      const { r3ply_dir, signet_key } = util.unsafeUnwrap(result);
+      const signet = await SignetIssuer2(signet_key, system_config)(
+        project.DEFAULT_SITE_DOMAIN,
+        project.DEFAULT_R3PLY_DOMAIN,
+        {
+          issued_date: options.date,
+          label: project.DEFAULT_CLI_SIGNET_LABEL
+        }
+      );
+      const signet_config = {
+        site: [signet]
+      };
+      tty_default.cmds.init.print_initialized_new_project(
+        r3ply_dir,
+        signet_config,
+        init_cmd2.parent.opts().format
+      );
+    });
+  });
+  return init_cmd2;
+}
+var init_default = init_cmd;
+
+// src/cmds/config.ts
+import { Command as Command2, program } from "commander";
+import chalk5 from "chalk";
+function config_cmd(cwd) {
+  const config_cmd2 = new Command2("config").description("r3ply config commands");
+  config_cmd2.command("validate").description("validate your r3ply configuration").action(async () => {
+    const parent_opts = config_cmd2.parent.opts();
+    return config_validate(cwd, { ...parent_opts });
+  });
+  config_cmd2.command("set-default <path>").description("the default config path r3ply will use").action(async (path4) => {
+    return util.unsafeUnwrap(await project.set_default_cli_config_path(cwd, path4));
+  });
+  const generate_alias = config_cmd2.command("generate").addHelpText(
+    "before",
+    chalk5.yellowBright("(alias for generate config, see usage below)\n")
+  ).description("Alias for generate config").action(async () => {
+    program.parseAsync(["generate", "config"], { from: "user" });
+  });
+  generate_alias.helpInformation = (ctx) => {
+    const foo = generate_default(cwd).commands.find((c) => c.name() == "config")?.helpInformation(ctx);
+    return foo || "See `re generate config` for more";
+  };
+  return config_cmd2;
+}
+async function config_validate(cwd, options) {
+  const site_config_path = await project.resolve_config_path(
+    cwd,
+    options.config
+  );
+  const site_config = util.unsafeUnwrap(
+    await project.parse_site_config(cwd, site_config_path)
+  );
+  if (!site_config.valid)
+    throw new util.CLIError(
+      `config failed validation:
+
+${JSON.stringify(site_config.errors, null, 2)}`
+    );
+}
+var config_default = config_cmd;
+
+// src/cmds/generate.ts
+import { Command as Command3 } from "commander";
+import dayjs3 from "dayjs";
+import { R3plySiteConfig as R3plySiteConfig2 } from "@r3ply/schema/config";
+import { mailbox as mailbox2 } from "typescript-mailbox-parser";
+import { Result as Result3 } from "oxide.ts";
+function generate_cmd(cwd) {
+  const generate_cmd2 = new Command3("generate").description(
+    "generate useful text"
+  );
+  const config_cmd2 = generate_cmd2.command("config").description("generate a config").option("--site <domain>", `site domain`, project.DEFAULT_SITE_DOMAIN).option(
+    "--r3ply <r3ply domain>",
+    `r3ply domain`,
+    project.DEFAULT_R3PLY_DOMAIN
+  ).option(
+    "--date <YYYY-MM-DD>",
+    "date signet issued",
+    dayjs3().format("YYYY-MM-DD")
+  ).option(
+    "--label <string>",
+    'e.g. "prod", "test"',
+    project.DEFAULT_CLI_SIGNET_LABEL
+  ).option("--comments <comment-source>", "options are: email", "email").option("--moderation <channel>", "See below", "local").addHelpText(
+    "after",
+    `
+Moderation <channel> options: <github | webhook | local>`
+  ).option("--verbose", "include more defaults explicitly", false).action(async (options) => {
+    const parent_opts = generate_cmd2.parent.opts();
+    return generate_config(cwd, { ...options, ...parent_opts });
+  });
+  const mailto_cmd = generate_cmd2.command("mailto [body]").description("generate a one-off `mailto:` link").option("--to <email>", "to header of email", util.collect_opts, []).option("--subject <string>", "subject header of email").option("--cc <email>", "cc header of email", util.collect_opts, []).option("--bcc <email>", "bcc header of email", util.collect_opts, []).action(async (body, options) => {
+    return generate_mailto(body, options);
+  });
+  const signet_cmd = generate_cmd2.command("signet").description("get a signet issued").option("--site <domain>", `site domain`, project.DEFAULT_SITE_DOMAIN).option(
+    "--r3ply <r3ply domain>",
+    `r3ply domain`,
+    project.DEFAULT_R3PLY_DOMAIN
+  ).option("--date <YYYY-MM-DD>", "date issued", dayjs3().format("YYYY-MM-DD")).option(
+    "--label <string>",
+    'e.g. "prod", "test"',
+    project.DEFAULT_CLI_SIGNET_LABEL
+  ).action(async (options) => {
+    const parent_opts = generate_cmd2.parent.opts();
+    return generate_signet(cwd, { ...options, ...parent_opts });
+  });
+  const email_cmd = generate_cmd2.command("email").description("Generate a comment as an email, based on your config").argument("[input]", "Input text (can also accept pipe)").option("--message-id <id>", "Message-ID header").option("--date <date>", "Date header", "now (UTC)").option("--from <address>", "From header").option("--to <address>", "To header").option("--subject <url | path>", "Email subject").option("--body <text>", "Email body").action(
+    async (input, options) => {
+      const parent_opts = generate_cmd2.parent.opts();
+      return generate_email(cwd, input, { ...options, ...parent_opts });
+    }
+  );
+  return generate_cmd2;
+}
+async function generate_config(cwd, options) {
+  const site = await project.get_keys(cwd).then(
+    (keys) => project.get_cli_system_config(cwd).then((system_config) => {
+      return generate.signet(
+        keys.signet_key,
+        util.unsafeUnwrap(system_config),
+        {
+          domain: options.site,
+          r3ply: options.r3ply,
+          issued: options.date,
+          label: options.label
+        }
+      );
+    })
+  );
+  const minimal_comments_config = { [options.comments]: { enabled: true } };
+  const minimal_github_config = {
+    owner: "<YOUR_GITHUB_USERNAME>",
+    repo: "<YOUR_PROJECT>",
+    "file_path_{}": "comment_{{ comment.id[:8] }}.json"
+  };
+  const minimal_webhook_config = {
+    url: "https://TODO"
+  };
+  const minimal_local_config = {
+    "file_path_{}": "comment_{{ comment.id[:8] }}.json"
+  };
+  const parsed = R3plySiteConfig2({
+    site: [{ ...site, label: options.label }],
+    // if --verbose is false it's removed later (set here to preserve desired key order for TOML)
+    comments: minimal_comments_config,
+    moderation: {
+      [options.moderation]: [
+        (() => {
+          if (options.moderation == "github") {
+            return minimal_github_config;
+          } else if (options.moderation == "webhook") {
+            return minimal_webhook_config;
+          } else if (options.moderation == "local") {
+            return minimal_local_config;
+          } else {
+            throw new util.CLIError(`Unknown moderation type: ${options.moderation}`);
+          }
+        })()
+      ]
+    }
+  });
+  const config_json = parsed.value;
+  if (options.verbose == false) {
+    config_json.comments = minimal_comments_config;
+  }
+  tty_default.cmds.generate.print_config(config_json, options.format);
+  return;
+}
+async function generate_mailto(body, { to, subject, cc, bcc }) {
+  if (!process.stdin.isTTY) {
+    body = await new Promise((resolve, reject) => {
+      let data = "";
+      process.stdin.setEncoding("utf8");
+      process.stdin.on("data", (chunk) => data += chunk);
+      process.stdin.on("end", () => resolve(data));
+      process.stdin.on("error", reject);
+    });
+  }
+  function parse_email_addr(str) {
+    const mb = mailbox2(str);
+    if (!mb.ok)
+      throw new util.CLIError(
+        `Invalid email '${str}', errors ${JSON.stringify(mb.errors)}`
+      );
+    else {
+      if (mb.name) {
+        return `${mb.name} <${mb.addr}>`;
+      } else return mb.addr;
+    }
+  }
+  const params = {
+    to: to.map(parse_email_addr).join(","),
+    subject,
+    cc: cc.map(parse_email_addr).join(","),
+    bcc: bcc.map(parse_email_addr).join(","),
+    body: body ? body.replace(/\r?\n/g, "\r\n") : void 0
+  };
+  const query = Object.entries(params).filter(([_, v]) => v !== void 0 && v !== "").map(([k, v]) => `?${encodeURIComponent(k)}=${encodeURIComponent(v)}`).join("&");
+  tty_default.cmds.generate.print_mail_to_link(query);
+}
+async function generate_signet(cwd, options) {
+  const keys = await project.get_keys(cwd);
+  const cli_system_config = util.unsafeUnwrap(
+    await project.get_cli_system_config(cwd)
+  );
+  const signet = await generate.signet(keys.signet_key, cli_system_config, {
+    domain: options.site,
+    r3ply: options.r3ply,
+    issued: options.date,
+    label: options.label
+  });
+  tty_default.cmds.generate.print_signet(signet, options.format);
+}
+async function generate_email(cwd, input, options) {
+  if (options.date == "now (UTC)") options.date = (/* @__PURE__ */ new Date()).toUTCString();
+  let site_config = await project.resolve_config(
+    cwd,
+    options.config
+  );
+  const site = site_config.site[util.random_int(site_config.site.length)];
+  if (!input && !process.stdin.isTTY) {
+    input = await util.read_stdin();
+  }
+  const email = Result3.safe(
+    // --body overrides input
+    generate.email(site.domain, site.r3ply, { body: input, ...options })
+  );
+  await email.then(async (email2) => {
+    if (email2.isOk()) {
+      tty_default.cmds.generate.print_email(email2.unwrap());
+    } else {
+      throw email2.unwrapErr();
+    }
+  });
+}
+var generate_default = generate_cmd;
+
+// src/cmds/simulate.ts
+import { Command as Command4 } from "commander";
+import { Result as Result4 } from "oxide.ts";
+import { R3ply, moderation as mod_todo2, util as r3ply_util2 } from "@r3ply/lib";
+import { mailbox as mailbox3 } from "typescript-mailbox-parser";
+function simulate_cmd(cwd) {
+  const simulate_cmd2 = new Command4("simulate").description(
+    "simulate receiving a comment using your r3ply config"
+  );
+  simulate_cmd2.command("email").argument("[input]", "Input text (can also accept pipe)").option("--moderate", "Moderate comment (local-only)", false).option("--dry-run", "Print output only", false).option("--message-id <id>", "Message-ID header").option("--date <date>", "Date header", "now (UTC)").option("--from <address>", "From header").option("--to <address>", "To header").option("--subject <url | path>", "Email subject").option("--body <text>", "Email body").option("--no-heading", "Hide headings for each stage of simulation", true).option(
+    "-q, --quiet [stage...]",
+    `silence output at \`stages\` (or all output if stages is blank).`,
+    util.split_list
+  ).option(
+    "-f, --filter [stage...]",
+    `filter output at \`stages\` (or all output if stages is blank).`,
+    util.split_list
+  ).addHelpText(
+    "after",
+    `
+Filtering/Silencing:
+<stage> = <email | config | prescreen | receive | deliverable | prepare | comment | moderation | notify>
+For substages add \`=\` after the stage name. Options are config=<site | system>, moderation=<github | webhook | local>
+If a substage is an array you can append an underscore + index to specify which element, e.g. moderation=local_0`
+  ).addHelpText(
+    "after",
+    `
+Examples:
+$ cat hello.txt | re simulate email --filter comment
+$ re simulate email --subject /demo/ --silence prescreen,receive,deliverable
+$ re simulate email --moderate --dry-run --body "testing" --filter comment,moderation=local_0`
+  ).action(
+    async (input, options, cmd) => {
+      const parent_opts = simulate_cmd2.parent.opts();
+      return simulate(cwd, input, { ...options, ...parent_opts });
+    }
+  );
+  return simulate_cmd2;
+}
+async function simulate(cwd, input, options) {
+  if (options.date == "now (UTC)") options.date = (/* @__PURE__ */ new Date()).toUTCString();
+  let site_config_path = await project.resolve_config_path(
+    cwd,
+    options.config
+  );
+  let site_config_result = await Result4.safe(
+    project.resolve_config(cwd, options.config)
+  );
+  let site_config = site_config_result.expect(
+    "Error while opening config (hint: run `re config validate` to debug)"
+  );
+  site_config = await r3ply_util2.config.resolve_references(
+    site_config,
+    site_config_path,
+    project.dereference_local_file
+  );
+  const cli_system_config = util.unsafeUnwrap(
+    await project.get_cli_system_config(cwd)
+  );
+  const signet = ((to) => {
+    let site_domain = (() => {
+      if (to) {
+        const mb = mailbox3(to);
+        if (!mb.ok)
+          throw new util.CLIError(
+            `Unable to parse --to '${to}', reasons: ${JSON.stringify(mb)}`
+          );
+        else {
+          return mb.local;
+        }
+      } else {
+        return project.DEFAULT_SITE_DOMAIN;
+      }
+    })();
+    const site = site_config.site.find((k) => k.domain == site_domain);
+    if (site) {
+      return site;
+    } else {
+      return site_config.site[util.random_int(site_config.site.length)];
+    }
+  })(options.to);
+  if (!input && !process.stdin.isTTY) input = await util.read_stdin();
+  const email = await generate.email(signet.domain, signet.r3ply, { body: input, ...options }).then((email2) => {
+    tty_default.cmds.simulate.print_comment_via_email_initial(email2, options);
+    return email2;
+  });
+  const keys = await project.get_keys(cwd);
+  const r3ply = R3ply(cli_system_config);
+  const file_writer = (args) => moderation.write_comment_locally(cwd, args, options.dryRun);
+  const local_moderation_channel = mod_todo2.LocalModeration(file_writer);
+  const github_moderation_channel = mod_todo2.GitHubModeration(
+    moderation.mock_github_api_fetcher()
+  );
+  const handle_email_comment = r3ply.comments.viaEmail(
+    keys.signet_key,
+    keys.encrypt_email_key,
+    {},
+    [local_moderation_channel, github_moderation_channel]
+  );
+  const email_comment_result = await Result4.safe(
+    handle_email_comment([site_config, new TextEncoder().encode(email)])
+  );
+  if (email_comment_result.isErr()) {
+    throw email_comment_result.unwrapErr();
+  }
+  const email_event_response = email_comment_result.unwrap();
+  tty_default.cmds.simulate.print_comment_via_email_response(
+    cli_system_config,
+    { site_config_path, site_config },
+    email_event_response,
+    options,
+    options.format
+  );
+  if (site_config.comments?.cache && email_event_response.prepared?.unwrap()) {
+    const ctx = email_event_response.prepared?.unwrap();
+    const domain = ctx.r3ply.site;
+    const path4 = ctx.comment.subject.path;
+    const comment_path = `comments/pending/${domain}${path4}/index.html`;
+    const pending_comments = await project.get_comment_from_cache(cwd, {
+      path: comment_path
+    });
+    project.add_comment_to_cache(cwd, {
+      path: comment_path,
+      content: [...pending_comments, ctx]
+    });
+  }
+  if (options.moderate && email_event_response.moderation) {
+    const supported_mod_channels = ["local", "github"];
+    for (const moderation_channel_type of supported_mod_channels) {
+      for (const [index, { type, request }] of email_event_response.moderation.filter((m) => m.type == moderation_channel_type).entries()) {
+        switch (type) {
+          case "local": {
+            const print = tty_default.cmds.simulate.print_local_moderation_event;
+            if (request.isOk()) {
+              const ticket = await request.unwrap().send();
+              print(
+                request,
+                ticket,
+                index,
+                options,
+                options.format
+              );
+            } else {
+              print(
+                request,
+                void 0,
+                index,
+                options,
+                options.format
+              );
+            }
+            break;
+          }
+          case "github": {
+            const print = tty_default.cmds.simulate.print_github_moderation_event;
+            if (request.isOk()) {
+              const ticket = await request.unwrap().send();
+              print(
+                request,
+                ticket,
+                index,
+                options,
+                options.format
+              );
+            } else {
+              print(
+                request,
+                void 0,
+                index,
+                options,
+                options.format
+              );
+            }
+            break;
+          }
+          default:
+            break;
+        }
+      }
+    }
+    if (site_config.moderation) {
+      const ignored_moderation_results = Object.keys(
+        site_config.moderation
+      ).filter(
+        (moderation_key) => !supported_mod_channels.includes(moderation_key)
+      );
+      const other_moderation_results = email_event_response.moderation.filter(
+        (r) => !supported_mod_channels.includes(r.type)
+      );
+      tty_default.cmds.simulate.print_ignored_moderation_channels(
+        ignored_moderation_results,
+        other_moderation_results,
+        options,
+        options.format
+      );
+    }
+  }
+}
+var simulate_default = simulate_cmd;
+
+// src/cmds/cache.ts
+import { Command as Command5 } from "commander";
+import http from "http";
+import handler from "serve-handler";
+function cache_cmd(cwd) {
+  const cache_cmd2 = new Command5("cache").description("manage comment cache");
+  cache_cmd2.command("serve").description("serves cached comments").option("--interface <INTERFACE>", "Interface to bind on", "127.0.0.1").option(
+    "--port <PORT>",
+    "Which port to use",
+    (str) => {
+      const num = Number.parseInt(str);
+      if (Number.isNaN(num))
+        throw new util.CLIError(`Port must be a number, received ${str}`);
+      return num;
+    },
+    2274
+  ).option("--reset", "Clears cache on startup", false).action(async (options, cmd) => {
+    serve(cwd, options);
+  });
+  cache_cmd2.command("clean").description("deletes cache").action(async () => {
+    return project.clean_cache(cwd);
+  });
+  cache_cmd2.command("evict").description("evict stale pending comments").option(
+    "--ttl <MAX_AGE_SECONDS>",
+    "Max age allowed for comments in seconds",
+    (str) => {
+      const num = Number.parseInt(str);
+      if (Number.isNaN(num))
+        throw new util.CLIError(`ttl must be a number, received ${str}`);
+      return num;
+    },
+    259200
+  ).action(async (options) => {
+    return project.evict_comments_from_cache(
+      cwd,
+      "comments/pending/",
+      options.ttl
+    );
+  });
+  return cache_cmd2;
+}
+async function serve(cwd, options) {
+  const cache_dir = await project.get_cache_dir(cwd, options.reset);
+  const static_dir = await project.find_static_dir(cwd);
+  const server = http.createServer(
+    (req, res) => handler(req, res, {
+      public: static_dir,
+      cleanUrls: true,
+      headers: [
+        {
+          source: "**",
+          headers: [{ key: "Access-Control-Allow-Origin", value: "*" }]
+        },
+        {
+          source: "/cache/comments/pending/**/index.html",
+          headers: [
+            { key: "Content-Type", value: "application/json" },
+            {
+              key: "Cache-Control",
+              value: "no-store, no-cache, must-revalidate, proxy-revalidate, max-age=0"
+            },
+            {
+              key: "Pragma",
+              value: "no-cache"
+            },
+            {
+              key: "Expires",
+              value: "0"
+            }
+          ]
+        }
+      ]
+    })
+  );
+  return new Promise((resolve) => {
+    server.listen(options.port, options.interface, () => {
+      tty_default.cmds.cache.print_serving_cache(cache_dir, options);
+      resolve();
+    });
+  });
+}
+var cache_default = cache_cmd;
+
+// src/index.ts
+var allowed_formats = ["toml", "json"];
+function validate_format(value) {
+  if (!allowed_formats.includes(value.toLowerCase())) {
+    throw new util.CLIError(`Format must be one of: ${allowed_formats.join(" | ")}.`);
+  }
+  return value.toLowerCase();
+}
+program2.name("re").version("0.0.1").description("CLI for r3ply").option("--config <path>", "specify path to config").option(
+  "--format <toml | json>",
+  "format to use with file output",
+  validate_format,
+  "toml"
+);
+program2.addCommand(init_default(process.cwd()));
+program2.addCommand(config_default(process.cwd()));
+program2.addCommand(generate_default(process.cwd()));
+program2.addCommand(simulate_default(process.cwd()));
+program2.addCommand(cache_default(process.cwd()));
+program2.parseAsync(process.argv).catch((error) => {
+  if (error instanceof util.CLIError) {
+    program2.error(tty_default.txt.warn(error.message));
+  } else {
+    program2.error(error?.stack ?? String(error));
+  }
+});