thunderbird-patch-review

Easy-to-use patch review interface for Thunderbird

Contribute: ~marcc/thunderbird-review-plugin@lists.sr.ht

git clone git://mccd.space/thunderbird-patch-review

implementation.js (7453B)

 // Privileged WebExtension Experiment behind Apply series, Browse... and
 // Open editor. It ships inside the .xpi, so installing the extension is the
 // whole install — there is no separate native messaging host.
 //
 // This file runs with full chrome privileges in Thunderbird's parent
 // process; everything privileged the add-on does lives here. It sticks to
 // long-stable platform APIs — Subprocess to run git and the editor,
 // nsIFilePicker for the directory chooser, IOUtils/PathUtils for the patch
 // workspace — and the fallbacks below cover the differences between
 // Thunderbird 115 and current.
 
 "use strict";
 
 /* globals ExtensionAPI, Services, IOUtils, PathUtils, AppConstants, ChromeUtils, Cc, Ci */
 
 // Platform modules moved from .jsm to .sys.mjs across the supported
 // Thunderbird range; try the ESM spelling first.
 function importModule(name) {
   try {
     return ChromeUtils.importESModule(`resource://gre/modules/${name}.sys.mjs`);
   } catch (e) {
     return ChromeUtils.import(`resource://gre/modules/${name}.jsm`);
   }
 }
 
 const { Subprocess } = importModule("Subprocess");
 
 /** Run a command to completion, stderr folded into stdout. */
 async function run(command, args) {
   const proc = await Subprocess.call({
     command,
     arguments: args,
     stderr: "stdout",
   });
   let output = "";
   let chunk;
   while ((chunk = await proc.stdout.readString())) {
     output += chunk;
   }
   const { exitCode } = await proc.wait();
   return { exitCode, output };
 }
 
 async function findGit() {
   try {
     return await Subprocess.pathSearch("git", Subprocess.getEnvironment());
   } catch (e) {
     // Thunderbird launched from a desktop entry or .app bundle may see a
     // minimal PATH; try the usual install locations before giving up.
     for (const candidate of ["/usr/local/bin/git", "/opt/homebrew/bin/git", "/usr/bin/git"]) {
       if (await IOUtils.exists(candidate)) {
         return candidate;
       }
     }
     throw new Error("git not found in PATH");
   }
 }
 
 // Verify repo is a git worktree and return a short description for the
 // toolbar. The name is the top-level dir basename (what the user picked);
 // the branch is the checked-out branch or detached short SHA.
 async function describeRepo(git, repo) {
   if (!repo) {
     throw new Error("no repository path given");
   }
   const check = await run(git, ["-C", repo, "rev-parse", "--is-inside-work-tree"]);
   if (check.exitCode !== 0) {
     throw new Error(`not a git repository: ${repo}`);
   }
   const showToplevel = await run(git, ["-C", repo, "rev-parse", "--show-toplevel"]);
   const toplevel = showToplevel.output.trim();
   const name = toplevel ? toplevel.replace(/[\\/]+$/, "").split(/[\\/]/).pop() : repo;
   let branch = await run(git, ["-C", repo, "symbolic-ref", "--short", "HEAD"]);
   if (branch.exitCode !== 0) {
     // Detached HEAD: fall back to the short commit hash.
     branch = await run(git, ["-C", repo, "rev-parse", "--short", "HEAD"]);
   }
   return { ok: true, repo: toplevel || repo, name, branch: branch.output.trim() };
 }
 
 async function ping() {
   const git = await findGit();
   const version = await run(git, ["--version"]);
   return { ok: true, git, version: version.output.trim() };
 }
 
 async function describe(repo) {
   const git = await findGit();
   return describeRepo(git, repo);
 }
 
 async function apply(repo, strategy, patches) {
   const git = await findGit();
   await describeRepo(git, repo);
   if (!patches.length) {
     throw new Error("no patches in request");
   }
 
   const work = PathUtils.join(
     PathUtils.tempDir,
     `patch-review.${Date.now()}.${Math.floor(Math.random() * 1e9)}`
   );
   await IOUtils.makeDirectory(work, { permissions: 0o700 });
   try {
     const args = ["-C", repo, "am"];
     if (strategy !== "am") {
       args.push("--3way");
     }
     for (const [i, patch] of patches.entries()) {
       const file = PathUtils.join(work, `${String(i + 1).padStart(4, "0")}.patch`);
       await IOUtils.writeUTF8(file, patch);
       args.push(file);
     }
     const am = await run(git, args);
     if (am.exitCode === 0) {
       return { ok: true, output: am.output };
     }
     const abort = await run(git, ["-C", repo, "am", "--abort"]);
     return {
       ok: false,
       output:
         am.output +
         abort.output +
         "(git am --abort ran; the repository is back to its previous state)\n",
     };
   } finally {
     IOUtils.remove(work, { recursive: true }).catch(() => {});
   }
 }
 
 async function pickDir(start) {
   const win = Services.wm.getMostRecentWindow(null);
   if (!win) {
     throw new Error("no window to attach the directory chooser to");
   }
   const picker = Cc["@mozilla.org/filepicker;1"].createInstance(Ci.nsIFilePicker);
   // nsIFilePicker.init took a window before Thunderbird ~125 and takes a
   // BrowsingContext after; whichever the running version rejects, throws.
   try {
     picker.init(win.browsingContext, "Choose repository", Ci.nsIFilePicker.modeGetFolder);
   } catch (e) {
     picker.init(win, "Choose repository", Ci.nsIFilePicker.modeGetFolder);
   }
   if (start) {
     try {
       const dir = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile);
       dir.initWithPath(start);
       if (dir.exists() && dir.isDirectory()) {
         picker.displayDirectory = dir;
       }
     } catch (e) {
       // Not a usable start path; the picker opens at its default.
     }
   }
   const rv = await new Promise((resolve) => picker.open(resolve));
   if (rv !== Ci.nsIFilePicker.returnOK || !picker.file) {
     return { ok: true, output: "", cancelled: true };
   }
   return { ok: true, output: picker.file.path };
 }
 
 async function openEditor(repo, editor, files) {
   const git = await findGit();
   await describeRepo(git, repo);
   const env = Subprocess.getEnvironment();
   let command = (editor || "").trim() || (env.EDITOR || "").trim();
   if (!command) {
     // Nothing configured anywhere: open the repository directory instead.
     command = { macosx: "open", win: "start" }[AppConstants.platform] || "xdg-open";
     files = ["."];
   }
 
   if (AppConstants.platform === "win") {
     const line = [command, ...files.map((f) => `"${f}"`)].join(" ");
     await Subprocess.call({
       command: env.ComSpec || "C:\\Windows\\System32\\cmd.exe",
       arguments: ["/s", "/c", line],
       workdir: repo,
       stderr: "ignore",
     });
   } else {
     // The command may carry flags ("code -n"); let sh split it and append
     // the files. Output goes to /dev/null so a chatty editor can never
     // fill the pipe, and the editor is not waited on.
     await Subprocess.call({
       command: "/bin/sh",
       arguments: ["-c", `exec ${command} "$@" >/dev/null 2>&1`, "patch-review-edit", ...files],
       workdir: repo,
       stderr: "ignore",
     });
   }
   return { ok: true, output: `launched: ${command}` };
 }
 
 /** Errors become {ok: false, error} so callers get one uniform shape. */
 async function guarded(fn) {
   try {
     return await fn();
   } catch (e) {
     return { ok: false, error: e.message || String(e) };
   }
 }
 
 var patchHost = class extends ExtensionAPI {
   getAPI() {
     return {
       patchHost: {
         ping: () => guarded(ping),
         describe: (repo) => guarded(() => describe(repo)),
         apply: (repo, strategy, patches) => guarded(() => apply(repo, strategy, patches)),
         pickDir: (start) => guarded(() => pickDir(start)),
         openEditor: (repo, editor, files) => guarded(() => openEditor(repo, editor, files)),
       },
     };
   }
 };