thunderbird-patch-review

Simple email patch review tool for Thunderbird

background.js (9847B)

 // Background script: patch detection on displayed messages, opening the
 // review tab, and servicing requests from it (series data, compose replies,
 // apply/edit through the patchHost experiment).
 //
 // MV2 background pages can't be ES modules, so shared code is pulled in
 // with dynamic import().
 
 "use strict";
 
 const MBOX_FROM = "From nobody Mon Sep 17 00:00:00 2001\n";
 
 let modulesPromise = null;
 function mods() {
   if (!modulesPromise) {
     modulesPromise = Promise.all([
       import(messenger.runtime.getURL("modules/patch-detect.js")),
       import(messenger.runtime.getURL("modules/series.js")),
       import(messenger.runtime.getURL("modules/sourcehut.js")),
     ]).then((loaded) => Object.assign({}, ...loaded));
   }
   return modulesPromise;
 }
 
 async function getConfig() {
   const found = await messenger.storage.local.get("config");
   return Object.assign({ editor: "", strategy: "am3", mappings: [] }, found.config);
 }
 
 // Apply, the directory chooser, and the editor launch are backed by the
 // patchHost experiment bundled under api/patchHost/. It always ships with
 // the extension, but its privileged code can still fail to load on a
 // Thunderbird whose internals moved; turn that into a normal error reply.
 function host() {
   if (!messenger.patchHost) {
     throw new Error(
       "the bundled patchHost helper did not load (incompatible Thunderbird version?)"
     );
   }
   return messenger.patchHost;
 }
 
 // ---------------------------------------------------------------------------
 // Detection: the single toolbar ("Review") button lights up when the current
 // selection — or the displayed message, in standalone message tabs — looks
 // like a patch. (The message-header button was dropped: the multi-message
 // summary view has no header toolbar, so it could never cover threads.)
 
 messenger.browserAction.disable();
 
 async function updateAction(tabId, messages) {
   try {
     const { isPatchMessage, parseSubject, getPlainBody } = await mods();
     let patch = messages.some((message) => Boolean(parseSubject(message.subject)));
     if (!patch && messages.length === 1) {
       // Subject gave no hint; look for a diff in the body (single message
       // only — fetching every body of a large selection would be wasteful).
       patch = isPatchMessage(messages[0].subject, await getPlainBody(messages[0].id));
     }
     await messenger.browserAction[patch ? "enable" : "disable"](tabId);
   } catch (e) {
     console.warn("patch-review: detection failed", e);
   }
 }
 
 messenger.mailTabs.onSelectedMessagesChanged.addListener((tab, selected) =>
   updateAction(tab.id, (selected && selected.messages) || [])
 );
 
 // Covers messages opened in their own tab or window, where no mail-tab
 // selection exists.
 messenger.messageDisplay.onMessageDisplayed.addListener((tab, message) =>
   updateAction(tab.id, [message])
 );
 
 async function openReview(messageId) {
   await messenger.tabs.create({
     url: messenger.runtime.getURL(`review/review.html?mid=${messageId}`),
   });
 }
 
 messenger.browserAction.onClicked.addListener(async (tab) => {
   let list = [];
   try {
     const selected = await messenger.mailTabs.getSelectedMessages(tab.id);
     list = (selected && selected.messages) || [];
   } catch (e) {
     // Not a mail tab; fall through to the displayed message.
   }
   if (!list.length) {
     const displayed = await messenger.messageDisplay.getDisplayedMessage(tab.id);
     if (displayed) {
       list = [displayed];
     }
   }
   const { parseSubject } = await mods();
   const message = list.find((header) => parseSubject(header.subject)) || list[0];
   if (message) {
     await openReview(message.id);
   }
 });
 
 // ---------------------------------------------------------------------------
 // Repo resolution: match the message's List-Id (or author) against the
 // configured mappings.
 
 async function listKeysFor(messageId) {
   const keys = [];
   try {
     const full = await messenger.messages.getFull(messageId);
     const listId = full.headers && full.headers["list-id"];
     if (listId && listId.length) {
       keys.push(listId[0]);
     }
   } catch (e) {
     // headers unavailable; fall through to author only
   }
   return keys;
 }
 
 function resolveRepo(config, keys) {
   for (const mapping of config.mappings || []) {
     if (!mapping.match || !mapping.repo) {
       continue;
     }
     if (keys.some((k) => k && k.toLowerCase().includes(mapping.match.toLowerCase()))) {
       return mapping.repo;
     }
   }
   return "";
 }
 
 // ---------------------------------------------------------------------------
 // Requests from the review tab.
 
 messenger.runtime.onMessage.addListener((request, sender, sendResponse) => {
   handle(request)
     .then(sendResponse)
     .catch((e) => sendResponse({ ok: false, error: e.message || String(e) }));
   return true; // async response
 });
 
 async function handle(request) {
   const m = await mods();
 
   switch (request.type) {
     case "get-series": {
       const anchor = await messenger.messages.get(request.messageId);
       const series = await m.collectSeries(anchor);
       const keys = [...(await listKeysFor(request.messageId)), anchor.author];
       const config = await getConfig();
       const { lastRepo } = await messenger.storage.local.get("lastRepo");
       return {
         ok: true,
         series,
         anchorHeaderMessageId: anchor.headerMessageId,
         // Explicit mapping first, otherwise the last path that was applied to.
         repo: resolveRepo(config, keys) || lastRepo || "",
         listKeys: keys,
         isSourcehut: m.isSourcehutList([
           ...keys,
           ...(anchor.recipients || []),
           ...(anchor.ccList || []),
         ]),
         config,
       };
     }
 
     case "send-review": {
       // mode "send": send each reply immediately (the compose window opens
       // and closes; the WebExtension API has no headless send).
       // mode "preview": leave the compose windows open for the user.
       const send = request.mode === "send";
       const status = m.SOURCEHUT_STATUSES.includes(request.status) ? request.status : null;
       const errors = [];
       let done = 0;
       for (const [i, reply] of request.replies.entries()) {
         const details = {
           isPlainText: true,
           plainTextBody: reply.body,
         };
         // One status update per patchset: only the first reply carries it.
         if (status && i === 0) {
           details.customHeaders = [{ name: m.STATUS_HEADER, value: status }];
         }
         const tab = await messenger.compose.beginReply(reply.messageId, "replyToAll", details);
         if (!send) {
           done++;
           continue;
         }
         try {
           await messenger.compose.sendMessage(tab.id, { mode: "sendNow" });
           done++;
         } catch (e) {
           // Leave the failed compose window open so nothing is lost.
           errors.push(`reply ${i + 1}: ${e.message}`);
         }
       }
       return {
         ok: errors.length === 0,
         sent: send ? done : 0,
         opened: send ? 0 : done,
         error: errors.length ? `Some replies were not sent:\n${errors.join("\n")}` : undefined,
       };
     }
 
     case "apply-series": {
       const config = await getConfig();
       // Remember the path for the next review, until it is changed again.
       await messenger.storage.local.set({ lastRepo: request.repo });
       const patches = [];
       for (const messageId of request.messageIds) {
         patches.push(await rawMessage(messageId));
       }
       return host().apply(request.repo, config.strategy || "am3", patches, Boolean(request.noHooks));
     }
 
     // Forwarded to patchHost.check(): classifies the series as already
     // applied, applicable, or conflicting against the repository's HEAD.
     case "check-series": {
       const config = await getConfig();
       const patches = [];
       for (const messageId of request.messageIds) {
         patches.push(await rawMessage(messageId));
       }
       return host().check(request.repo, config.strategy || "am3", patches);
     }
 
     case "open-editor": {
       const config = await getConfig();
       return host().openEditor(request.repo, config.editor || "", request.files || []);
     }
 
     case "download-series": {
       const parts = [];
       for (const messageId of request.messageIds) {
         const raw = await rawMessage(messageId);
         parts.push(raw.endsWith("\n") ? raw : raw + "\n");
       }
       const url = URL.createObjectURL(new Blob(parts, { type: "application/mbox" }));
       try {
         await messenger.downloads.download({
           url,
           filename: `${request.filename || "patchset"}.mbox`,
           saveAs: true,
         });
       } catch (e) {
         if (/cancel/i.test(e.message || "")) {
           return { ok: true, cancelled: true };
         }
         throw e;
       } finally {
         // Give the download time to read the blob before releasing it.
         setTimeout(() => URL.revokeObjectURL(url), 120000);
       }
       return { ok: true };
     }
 
     case "pick-repo":
       // Native directory chooser; the repo field doubles as its start dir.
       return host().pickDir(request.start || "");
 
     case "describe-repo":
       // Resolve a path to its repository name + current branch (or an error
       // for not-a-repo). Used by the toolbar to display the target repo.
       return host().describe(request.repo || "");
 
     case "ping-host":
       return host().ping();
 
     default:
       throw new Error(`unknown request: ${request.type}`);
   }
 }
 
 /** Raw RFC822 source with an mbox From_ separator, as git am expects. */
 async function rawMessage(messageId) {
   let raw = await messenger.messages.getRaw(messageId);
   if (raw && typeof raw !== "string") {
     raw = await raw.text(); // newer TB returns a File
   }
   if (!raw.startsWith("From ")) {
     raw = MBOX_FROM + raw;
   }
   return raw;
 }