feat,refactor: rework getHistory, return Notification objects

Add static methods for managing delivered notifications via the
UNUserNotificationCenter API:
- getHistory() returns all delivered notifications still in Notification Center
- remove(id) removes one or more notifications by identifier
- removeAll() removes all delivered notifications

These methods build on the custom id support to enable full notification
lifecycle management from the main process.

docs/api/notification.md

@@ -76,11 +76,87 @@ app.whenReady().then(() => {
 })
 ```
 
+#### `Notification.getHistory()` _macOS_
+
+Returns `Promise<Notification[]>` - Resolves with an array of `Notification` objects representing all delivered notifications still present in Notification Center.
+
+Each returned `Notification` is a live object connected to the corresponding delivered notification. Interaction events (`click`, `reply`, `action`, `close`) will fire on these objects when the user interacts with the notification in Notification Center. This is useful after an app restart to re-attach event handlers to notifications from a previous session.
+
+The returned notifications have their `id`, `groupId`, `title`, `subtitle`, and `body` properties populated from what macOS provides. Other properties (e.g., `actions`, `silent`, `icon`) are not available from delivered notifications and will have default values.
+
+> [!NOTE]
+> Like all macOS notification APIs, this method requires the application to be
+> code-signed. In unsigned development builds, notifications are not delivered
+> to Notification Center and this method will resolve with an empty array.
+
+> [!NOTE]
+> Unlike notifications created with `new Notification()`, notifications returned
+> by `getHistory()` will remain visible in Notification Center when the object
+> is garbage collected.
+
+```js
+const { Notification, app } = require('electron')
+
+app.whenReady().then(async () => {
+  // Restore notifications from a previous session
+  const notifications = await Notification.getHistory()
+  for (const n of notifications) {
+    console.log(`Found delivered notification: ${n.id} - ${n.title}`)
+    n.on('click', () => {
+      console.log(`User clicked: ${n.id}`)
+    })
+    n.on('reply', (event) => {
+      console.log(`User replied to ${n.id}: ${event.reply}`)
+    })
+  }
+  // Keep references so events continue to fire
+})
+```
+
+#### `Notification.remove(id)` _macOS_
+
+* `id` (string | string[]) - The notification identifier(s) to remove. These correspond to the `id` values set in the [`Notification` constructor](#new-notificationoptions).
+
+Removes one or more delivered notifications from Notification Center by their identifier(s).
+
+```js
+const { Notification } = require('electron')
+
+// Remove a single notification
+Notification.remove('my-notification-id')
+
+// Remove multiple notifications
+Notification.remove(['msg-1', 'msg-2', 'msg-3'])
+```
+
+#### `Notification.removeAll()` _macOS_
+
+Removes all of the app's delivered notifications from Notification Center.
+
+```js
+const { Notification } = require('electron')
+
+Notification.removeAll()
+```
+
+#### `Notification.removeGroup(groupId)` _macOS_
+
+* `groupId` string - The group identifier of the notifications to remove. This corresponds to the `groupId` value set in the [`Notification` constructor](#new-notificationoptions).
+
+Removes all delivered notifications with the given `groupId` from Notification Center.
+
+```js
+const { Notification } = require('electron')
+
+// Remove all notifications in the 'chat-thread-1' group
+Notification.removeGroup('chat-thread-1')
+```
+
 ### `new Notification([options])`
 
 * `options` Object (optional)
-  * `id` string (optional) _macOS_ - A unique identifier for the notification, mapping to `UNNotificationRequest`'s [`identifier`](https://developer.apple.com/documentation/usernotifications/unnotificationrequest/identifier) property. Defaults to a random UUID if not provided or if an empty string is passed. This can be used to remove or update previously delivered notifications.
-  * `groupId` string (optional) _macOS_ - A string identifier used to visually group notifications together in Notification Center. Maps to `UNNotificationContent`'s [`threadIdentifier`](https://developer.apple.com/documentation/usernotifications/unnotificationcontent/threadidentifier) property.
+  * `id` string (optional) _macOS_ - A unique identifier for the notification, mapping to `UNNotificationRequest`'s [`identifier`](https://developer.apple.com/documentation/usernotifications/unnotificationrequest/identifier) property. Defaults to a random UUID if not provided or if an empty string is passed. Use this identifier with [`Notification.remove()`](#notificationremoveid-macos) to remove specific delivered notifications, or with [`Notification.getHistory()`](#notificationgethistory-macos) to identify them.
+  * `groupId` string (optional) _macOS_ - A string identifier used to visually group notifications together in Notification Center. Maps to `UNNotificationContent`'s [`threadIdentifier`](https://developer.apple.com/documentation/usernotifications/unnotificationcontent/threadidentifier) property. Use this identifier with [`Notification.removeGroup()`](#notificationremovegroupgroupid-macos) to remove all notifications in a group.
   * `title` string (optional) - A title for the notification, which will be displayed at the top of the notification window when it is shown.
   * `subtitle` string (optional) _macOS_ - A subtitle for the notification, which will be displayed below the title.
   * `body` string (optional) - The body text of the notification, which will be displayed below the title or subtitle.

lib/browser/api/notification.ts

@@ -2,6 +2,10 @@ const binding = process._linkedBinding('electron_browser_notification');
 
 const ElectronNotification = binding.Notification;
 ElectronNotification.isSupported = binding.isSupported;
+ElectronNotification.getHistory = binding.getHistory;
+ElectronNotification.remove = binding.remove;
+ElectronNotification.removeAll = binding.removeAll;
+ElectronNotification.removeGroup = binding.removeGroup;
 
 if (process.platform === 'win32' && binding.handleActivation) {
   ElectronNotification.handleActivation = binding.handleActivation;

shell/browser/api/electron_api_notification.cc

@@ -5,6 +5,7 @@
 #include "shell/browser/api/electron_api_notification.h"
 
 #include "base/functional/bind.h"
+#include "base/strings/utf_string_conversions.h"
 #include "base/uuid.h"
 #include "build/build_config.h"
 #include "content/public/browser/browser_task_traits.h"
@@ -13,10 +14,12 @@
 #include "shell/browser/browser.h"
 #include "shell/browser/electron_browser_client.h"
 #include "shell/common/gin_converters/image_converter.h"
+#include "shell/common/gin_converters/value_converter.h"
 #include "shell/common/gin_helper/dictionary.h"
 #include "shell/common/gin_helper/error_thrower.h"
 #include "shell/common/gin_helper/handle.h"
 #include "shell/common/gin_helper/object_template_builder.h"
+#include "shell/common/gin_helper/promise.h"
 #include "shell/common/node_includes.h"
 #include "url/gurl.h"
 
@@ -72,27 +75,29 @@ Notification::Notification(gin::Arguments* args) {
   presenter_ = static_cast<ElectronBrowserClient*>(ElectronBrowserClient::Get())
                    ->GetNotificationPresenter();
 
-  gin::Dictionary opts(nullptr);
-  if (args->GetNext(&opts)) {
-    opts.Get("id", &id_);
-    opts.Get("groupId", &group_id_);
-    opts.Get("title", &title_);
-    opts.Get("subtitle", &subtitle_);
-    opts.Get("body", &body_);
-    opts.Get("icon", &icon_);
-    opts.Get("silent", &silent_);
-    opts.Get("replyPlaceholder", &reply_placeholder_);
-    opts.Get("urgency", &urgency_);
-    opts.Get("hasReply", &has_reply_);
-    opts.Get("timeoutType", &timeout_type_);
-    opts.Get("actions", &actions_);
-    opts.Get("sound", &sound_);
-    opts.Get("closeButtonText", &close_button_text_);
-    opts.Get("toastXml", &toast_xml_);
-  }
+  if (args) {
+    gin::Dictionary opts(nullptr);
+    if (args->GetNext(&opts)) {
+      opts.Get("id", &id_);
+      opts.Get("groupId", &group_id_);
+      opts.Get("title", &title_);
+      opts.Get("subtitle", &subtitle_);
+      opts.Get("body", &body_);
+      opts.Get("icon", &icon_);
+      opts.Get("silent", &silent_);
+      opts.Get("replyPlaceholder", &reply_placeholder_);
+      opts.Get("urgency", &urgency_);
+      opts.Get("hasReply", &has_reply_);
+      opts.Get("timeoutType", &timeout_type_);
+      opts.Get("actions", &actions_);
+      opts.Get("sound", &sound_);
+      opts.Get("closeButtonText", &close_button_text_);
+      opts.Get("toastXml", &toast_xml_);
+    }
 
-  if (id_.empty())
-    id_ = base::Uuid::GenerateRandomV4().AsLowercaseString();
+    if (id_.empty())
+      id_ = base::Uuid::GenerateRandomV4().AsLowercaseString();
+  }
 }
 
 Notification::~Notification() {
@@ -342,6 +347,115 @@ void Notification::HandleActivation(v8::Isolate* isolate,
 }
 #endif
 
+// static
+v8::Local<v8::Promise> Notification::GetHistory(v8::Isolate* isolate) {
+  gin_helper::Promise<v8::Local<v8::Value>> promise(isolate);
+  v8::Local<v8::Promise> handle = promise.GetHandle();
+
+  auto* presenter =
+      static_cast<ElectronBrowserClient*>(ElectronBrowserClient::Get())
+          ->GetNotificationPresenter();
+  if (!presenter) {
+    promise.Resolve(v8::Array::New(isolate));
+    return handle;
+  }
+
+  presenter->GetDeliveredNotifications(base::BindOnce(
+      [](gin_helper::Promise<v8::Local<v8::Value>> promise,
+         electron::NotificationPresenter* presenter,
+         std::vector<electron::NotificationInfo> notifications) {
+        v8::Isolate* isolate = promise.isolate();
+        v8::HandleScope handle_scope(isolate);
+
+        v8::Local<v8::Array> result =
+            v8::Array::New(isolate, notifications.size());
+        for (size_t i = 0; i < notifications.size(); i++) {
+          const auto& info = notifications[i];
+
+          // Create a live Notification object for each delivered notification.
+          auto* notif = new Notification(/*args=*/nullptr);
+          notif->id_ = info.id;
+          notif->group_id_ = info.group_id;
+          notif->title_ = base::UTF8ToUTF16(info.title);
+          notif->subtitle_ = base::UTF8ToUTF16(info.subtitle);
+          notif->body_ = base::UTF8ToUTF16(info.body);
+
+          // Register with the presenter so click/reply events route here.
+          if (presenter) {
+            notif->notification_ =
+                presenter->CreateNotification(notif, notif->id_);
+            if (notif->notification_)
+              notif->notification_->Restore();
+          }
+
+          auto handle = gin_helper::CreateHandle(isolate, notif);
+          result
+              ->Set(isolate->GetCurrentContext(), static_cast<uint32_t>(i),
+                    handle.ToV8())
+              .Check();
+        }
+
+        promise.Resolve(result.As<v8::Value>());
+      },
+      std::move(promise), presenter));
+
+  return handle;
+}
+
+// static
+void Notification::Remove(gin::Arguments* args) {
+  auto* presenter =
+      static_cast<ElectronBrowserClient*>(ElectronBrowserClient::Get())
+          ->GetNotificationPresenter();
+  if (!presenter)
+    return;
+
+  // Accept either a single string or an array of strings.
+  // Peek at the value type first to avoid gin::Arguments cursor issues.
+  v8::Local<v8::Value> val;
+  if (!args->GetNext(&val)) {
+    args->ThrowTypeError("Expected a string or array of strings");
+    return;
+  }
+
+  if (val->IsString()) {
+    std::string id;
+    gin::ConvertFromV8(args->isolate(), val, &id);
+    presenter->RemoveDeliveredNotifications({id});
+  } else if (val->IsArray()) {
+    std::vector<std::string> ids;
+    if (!gin::ConvertFromV8(args->isolate(), val, &ids)) {
+      args->ThrowTypeError("Expected a string or array of strings");
+      return;
+    }
+    presenter->RemoveDeliveredNotifications(ids);
+  } else {
+    args->ThrowTypeError("Expected a string or array of strings");
+  }
+}
+
+// static
+void Notification::RemoveAll() {
+  auto* presenter =
+      static_cast<ElectronBrowserClient*>(ElectronBrowserClient::Get())
+          ->GetNotificationPresenter();
+  if (!presenter)
+    return;
+
+  presenter->RemoveAllDeliveredNotifications();
+}
+
+// static
+void Notification::RemoveGroup(const std::string& group_id) {
+  auto* presenter =
+      static_cast<ElectronBrowserClient*>(ElectronBrowserClient::Get())
+          ->GetNotificationPresenter();
+  if (!presenter)
+    return;
+
+  presenter->RemoveDeliveredNotificationsByGroupId(group_id);
+}
+
 void Notification::FillObjectTemplate(v8::Isolate* isolate,
                                       v8::Local<v8::ObjectTemplate> templ) {
   gin::ObjectTemplateBuilder(isolate, GetClassName(), templ)
@@ -395,6 +509,10 @@ void Initialize(v8::Local<v8::Object> exports,
 #if BUILDFLAG(IS_WIN)
   dict.SetMethod("handleActivation", &Notification::HandleActivation);
 #endif
+  dict.SetMethod("getHistory", &Notification::GetHistory);
+  dict.SetMethod("remove", &Notification::Remove);
+  dict.SetMethod("removeAll", &Notification::RemoveAll);
+  dict.SetMethod("removeGroup", &Notification::RemoveGroup);
 }
 
 }  // namespace

shell/browser/api/electron_api_notification.h

@@ -38,6 +38,10 @@ class Notification final : public gin_helper::DeprecatedWrappable<Notification>,
                            public NotificationDelegate {
  public:
   static bool IsSupported();
+  static v8::Local<v8::Promise> GetHistory(v8::Isolate* isolate);
+  static void Remove(gin::Arguments* args);
+  static void RemoveAll();
+  static void RemoveGroup(const std::string& group_id);
 
 #if BUILDFLAG(IS_WIN)
   // Register a callback to handle all notification activations.

shell/browser/notifications/mac/cocoa_notification.h

@@ -24,6 +24,7 @@ class CocoaNotification : public Notification {
   // Notification:
   void Show(const NotificationOptions& options) override;
   void Dismiss() override;
+  void Restore() override;
 
   void NotificationDisplayed();
   void NotificationReplied(const std::string& reply);
@@ -38,6 +39,7 @@ class CocoaNotification : public Notification {
   void LogAction(const char* action);
   void ScheduleNotification(UNMutableNotificationContent* content);
 
+  bool is_restored_ = false;
   UNNotificationRequest* __strong notification_request_;
 };
 

shell/browser/notifications/mac/cocoa_notification.mm

@@ -31,7 +31,10 @@ CocoaNotification::CocoaNotification(NotificationDelegate* delegate,
     : Notification(delegate, presenter) {}
 
 CocoaNotification::~CocoaNotification() {
-  if (notification_request_)
+  // Don't remove from Notification Center if this was a restored notification.
+  // Restored notifications are observed, not owned — destruction should just
+  // disconnect the event handler, not remove the visible notification.
+  if (notification_request_ && !is_restored_)
     [[UNUserNotificationCenter currentNotificationCenter]
         removeDeliveredNotificationsWithIdentifiers:@[
           notification_request_.identifier
@@ -233,6 +236,24 @@ void CocoaNotification::ScheduleNotification(
        }];
 }
 
+void CocoaNotification::Restore() {
+  // Create a minimal UNNotificationRequest with just the identifier so that
+  // GetNotification() can match this object when the user interacts with the
+  // notification in Notification Center.
+  NSString* identifier = base::SysUTF8ToNSString(notification_id());
+  UNMutableNotificationContent* content =
+      [[UNMutableNotificationContent alloc] init];
+  notification_request_ =
+      [UNNotificationRequest requestWithIdentifier:identifier
+                                           content:content
+                                           trigger:nil];
+  is_restored_ = true;
+
+  if (electron::debug_notifications) {
+    LOG(INFO) << "Notification restored (" << [identifier UTF8String] << ")";
+  }
+}
+
 void CocoaNotification::Dismiss() {
   if (notification_request_)
     [[UNUserNotificationCenter currentNotificationCenter]

shell/browser/notifications/mac/notification_presenter_mac.h

@@ -24,6 +24,15 @@ class NotificationPresenterMac : public NotificationPresenter {
   NotificationPresenterMac();
   ~NotificationPresenterMac() override;
 
+  // NotificationPresenter
+  void GetDeliveredNotifications(
+      GetDeliveredNotificationsCallback callback) override;
+  void RemoveDeliveredNotifications(
+      const std::vector<std::string>& identifiers) override;
+  void RemoveAllDeliveredNotifications() override;
+  void RemoveDeliveredNotificationsByGroupId(
+      const std::string& group_id) override;
+
   NotificationImageRetainer* image_retainer() { return image_retainer_.get(); }
   scoped_refptr<base::SequencedTaskRunner> image_task_runner() {
     return image_task_runner_;

shell/browser/notifications/mac/notification_presenter_mac.mm

@@ -2,11 +2,16 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#include "base/logging.h"
-#include "base/task/thread_pool.h"
-
 #include "shell/browser/notifications/mac/notification_presenter_mac.h"
 
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "base/logging.h"
+#include "base/strings/sys_string_conversions.h"
+#include "base/task/sequenced_task_runner.h"
+#include "base/task/thread_pool.h"
 #include "shell/browser/notifications/mac/cocoa_notification.h"
 #include "shell/browser/notifications/mac/notification_center_delegate.h"
 
@@ -80,4 +85,72 @@ Notification* NotificationPresenterMac::CreateNotificationObject(
   return new CocoaNotification(delegate, this);
 }
 
+void NotificationPresenterMac::GetDeliveredNotifications(
+    GetDeliveredNotificationsCallback callback) {
+  scoped_refptr<base::SequencedTaskRunner> task_runner =
+      base::SequencedTaskRunner::GetCurrentDefault();
+
+  __block GetDeliveredNotificationsCallback block_callback =
+      std::move(callback);
+
+  [[UNUserNotificationCenter currentNotificationCenter]
+      getDeliveredNotificationsWithCompletionHandler:^(
+          NSArray<UNNotification*>* _Nonnull notifications) {
+        std::vector<NotificationInfo> results;
+        results.reserve([notifications count]);
+
+        for (UNNotification* notification in notifications) {
+          UNNotificationContent* content = notification.request.content;
+          NotificationInfo info;
+          info.id = base::SysNSStringToUTF8(notification.request.identifier);
+          info.title = base::SysNSStringToUTF8(content.title);
+          info.subtitle = base::SysNSStringToUTF8(content.subtitle);
+          info.body = base::SysNSStringToUTF8(content.body);
+          info.group_id = base::SysNSStringToUTF8(content.threadIdentifier);
+          results.push_back(std::move(info));
+        }
+
+        task_runner->PostTask(
+            FROM_HERE,
+            base::BindOnce(std::move(block_callback), std::move(results)));
+      }];
+}
+
+void NotificationPresenterMac::RemoveDeliveredNotifications(
+    const std::vector<std::string>& identifiers) {
+  NSMutableArray* ns_identifiers =
+      [NSMutableArray arrayWithCapacity:identifiers.size()];
+  for (const auto& id : identifiers) {
+    [ns_identifiers addObject:base::SysUTF8ToNSString(id)];
+  }
+  [[UNUserNotificationCenter currentNotificationCenter]
+      removeDeliveredNotificationsWithIdentifiers:ns_identifiers];
+}
+
+void NotificationPresenterMac::RemoveAllDeliveredNotifications() {
+  [[UNUserNotificationCenter currentNotificationCenter]
+      removeAllDeliveredNotifications];
+}
+
+void NotificationPresenterMac::RemoveDeliveredNotificationsByGroupId(
+    const std::string& group_id) {
+  NSString* target_group = base::SysUTF8ToNSString(group_id);
+  UNUserNotificationCenter* center =
+      [UNUserNotificationCenter currentNotificationCenter];
+
+  [center getDeliveredNotificationsWithCompletionHandler:^(
+              NSArray<UNNotification*>* _Nonnull notifications) {
+    NSMutableArray* matching_ids = [NSMutableArray array];
+    for (UNNotification* notification in notifications) {
+      if ([notification.request.content.threadIdentifier
+              isEqualToString:target_group]) {
+        [matching_ids addObject:notification.request.identifier];
+      }
+    }
+    if (matching_ids.count > 0) {
+      [center removeDeliveredNotificationsWithIdentifiers:matching_ids];
+    }
+  }];
+}
+
 }  // namespace electron

shell/browser/notifications/notification.cc

@@ -22,6 +22,15 @@ NotificationOptions& NotificationOptions::operator=(NotificationOptions&&) =
     default;
 NotificationOptions::~NotificationOptions() = default;
 
+NotificationInfo::NotificationInfo() = default;
+NotificationInfo::~NotificationInfo() = default;
+NotificationInfo::NotificationInfo(const NotificationInfo&) = default;
+NotificationInfo& NotificationInfo::operator=(const NotificationInfo&) =
+    default;
+NotificationInfo::NotificationInfo(NotificationInfo&&) noexcept = default;
+NotificationInfo& NotificationInfo::operator=(NotificationInfo&&) noexcept =
+    default;
+
 NotificationAction::NotificationAction() = default;
 NotificationAction::~NotificationAction() = default;
 NotificationAction::NotificationAction(const NotificationAction&) = default;

shell/browser/notifications/notification.h

@@ -59,6 +59,21 @@ struct NotificationOptions {
   ~NotificationOptions();
 };
 
+struct NotificationInfo {
+  std::string id;
+  std::string title;
+  std::string subtitle;
+  std::string body;
+  std::string group_id;
+
+  NotificationInfo();
+  ~NotificationInfo();
+  NotificationInfo(const NotificationInfo&);
+  NotificationInfo& operator=(const NotificationInfo&);
+  NotificationInfo(NotificationInfo&&) noexcept;
+  NotificationInfo& operator=(NotificationInfo&&) noexcept;
+};
+
 class Notification {
  public:
   virtual ~Notification();
@@ -75,6 +90,11 @@ class Notification {
   // as can happen on some platforms including Windows.
   virtual void Remove() {}
 
+  // Restores a previously delivered notification for event handling without
+  // re-showing it. Sets up platform state so interaction events (click, reply,
+  // etc.) route to this object.
+  virtual void Restore() {}
+
   // Should be called by derived classes.
   void NotificationClicked();
   void NotificationDismissed(bool should_destroy = true,

shell/browser/notifications/notification_presenter.cc

@@ -44,4 +44,24 @@ void NotificationPresenter::CloseNotificationWithId(
   }
 }
 
+void NotificationPresenter::GetDeliveredNotifications(
+    GetDeliveredNotificationsCallback callback) {
+  // Default: return empty list. Overridden on macOS.
+  std::move(callback).Run({});
+}
+
+void NotificationPresenter::RemoveDeliveredNotifications(
+    const std::vector<std::string>& identifiers) {
+  // Default: no-op. Overridden on macOS.
+}
+
+void NotificationPresenter::RemoveAllDeliveredNotifications() {
+  // Default: no-op. Overridden on macOS.
+}
+
+void NotificationPresenter::RemoveDeliveredNotificationsByGroupId(
+    const std::string& group_id) {
+  // Default: no-op. Overridden on macOS.
+}
+
 }  // namespace electron

shell/browser/notifications/notification_presenter.h

@@ -8,12 +8,14 @@
 #include <memory>
 #include <set>
 #include <string>
+#include <vector>
 
+#include "base/functional/callback.h"
 #include "base/memory/weak_ptr.h"
+#include "shell/browser/notifications/notification.h"
 
 namespace electron {
 
-class Notification;
 class NotificationDelegate;
 
 class NotificationPresenter {
@@ -22,11 +24,22 @@ class NotificationPresenter {
 
   virtual ~NotificationPresenter();
 
+  using GetDeliveredNotificationsCallback =
+      base::OnceCallback<void(std::vector<NotificationInfo>)>;
+
   base::WeakPtr<Notification> CreateNotification(
       NotificationDelegate* delegate,
       const std::string& notification_id);
   void CloseNotificationWithId(const std::string& notification_id);
 
+  virtual void GetDeliveredNotifications(
+      GetDeliveredNotificationsCallback callback);
+  virtual void RemoveDeliveredNotifications(
+      const std::vector<std::string>& identifiers);
+  virtual void RemoveAllDeliveredNotifications();
+  virtual void RemoveDeliveredNotificationsByGroupId(
+      const std::string& group_id);
+
   std::set<Notification*> notifications() const { return notifications_; }
 
   // disable copy

spec/api-notification-spec.ts

@@ -261,4 +261,223 @@ describe('Notification module', () => {
   });
 
   // TODO(sethlu): Find way to test init with notification icon?
+
+  describe('static methods', () => {
+    ifit(process.platform === 'darwin')('getHistory returns a promise that resolves to an array', async () => {
+      const result = Notification.getHistory();
+      expect(result).to.be.a('promise');
+      const history = await result;
+      expect(history).to.be.an('array');
+    });
+
+    ifit(process.platform === 'darwin')('remove does not throw with a string argument', () => {
+      expect(() => Notification.remove('nonexistent-id')).to.not.throw();
+    });
+
+    ifit(process.platform === 'darwin')('remove does not throw with an array argument', () => {
+      expect(() => Notification.remove(['id-1', 'id-2'])).to.not.throw();
+    });
+
+    ifit(process.platform === 'darwin')('remove throws with no arguments', () => {
+      expect(() => (Notification.remove as any)()).to.throw(/Expected a string or array of strings/);
+    });
+
+    ifit(process.platform === 'darwin')('remove throws with an invalid argument type', () => {
+      expect(() => (Notification.remove as any)(123)).to.throw(/Expected a string or array of strings/);
+    });
+
+    ifit(process.platform === 'darwin')('removeAll does not throw', () => {
+      expect(() => Notification.removeAll()).to.not.throw();
+    });
+
+    ifit(process.platform === 'darwin')('getHistory returns Notification instances with correct properties', async () => {
+      const n = new Notification({
+        id: 'history-test-id',
+        title: 'history test',
+        subtitle: 'history subtitle',
+        body: 'history body',
+        groupId: 'history-group',
+        silent: true
+      });
+
+      const shown = once(n, 'show');
+      n.show();
+      await shown;
+
+      const history = await Notification.getHistory();
+      // getHistory requires code-signed builds to return results;
+      // skip the content assertions if Notification Center is empty.
+      if (history.length > 0) {
+        const found = history.find((item: any) => item.id === 'history-test-id');
+        expect(found).to.not.be.undefined();
+        expect(found).to.be.an.instanceOf(Notification);
+        expect(found.title).to.equal('history test');
+        expect(found.subtitle).to.equal('history subtitle');
+        expect(found.body).to.equal('history body');
+        expect(found.groupId).to.equal('history-group');
+      }
+
+      n.close();
+    });
+
+    ifit(process.platform === 'darwin')('getHistory returned notifications can be shown and closed', async () => {
+      const n = new Notification({
+        id: 'history-show-close',
+        title: 'show close test',
+        body: 'body',
+        silent: true
+      });
+
+      const shown = once(n, 'show');
+      n.show();
+      await shown;
+
+      const history = await Notification.getHistory();
+      if (history.length > 0) {
+        const found = history.find((item: any) => item.id === 'history-show-close');
+        expect(found).to.not.be.undefined();
+        // Calling show() and close() on a restored notification should not throw
+        expect(() => {
+          found.show();
+          found.close();
+        }).to.not.throw();
+      }
+
+      Notification.removeAll();
+    });
+
+    ifit(process.platform === 'darwin')('remove removes a notification by id', async () => {
+      const n = new Notification({
+        id: 'remove-test-id',
+        title: 'remove test',
+        body: 'remove body',
+        silent: true
+      });
+
+      const shown = once(n, 'show');
+      n.show();
+      await shown;
+
+      Notification.remove('remove-test-id');
+
+      // Give the notification center a moment to process the removal
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      const history = await Notification.getHistory();
+      const found = history.find((item: any) => item.id === 'remove-test-id');
+      expect(found).to.be.undefined();
+    });
+
+    ifit(process.platform === 'darwin')('remove accepts an array of ids', async () => {
+      const n1 = new Notification({
+        id: 'remove-array-1',
+        title: 'test 1',
+        body: 'body 1',
+        silent: true
+      });
+      const n2 = new Notification({
+        id: 'remove-array-2',
+        title: 'test 2',
+        body: 'body 2',
+        silent: true
+      });
+
+      const shown1 = once(n1, 'show');
+      n1.show();
+      await shown1;
+
+      const shown2 = once(n2, 'show');
+      n2.show();
+      await shown2;
+
+      Notification.remove(['remove-array-1', 'remove-array-2']);
+
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      const history = await Notification.getHistory();
+      const found1 = history.find((item: any) => item.id === 'remove-array-1');
+      const found2 = history.find((item: any) => item.id === 'remove-array-2');
+      expect(found1).to.be.undefined();
+      expect(found2).to.be.undefined();
+    });
+
+    ifit(process.platform === 'darwin')('removeAll removes all notifications', async () => {
+      const n = new Notification({
+        id: 'remove-all-test',
+        title: 'removeAll test',
+        body: 'body',
+        silent: true
+      });
+
+      const shown = once(n, 'show');
+      n.show();
+      await shown;
+
+      Notification.removeAll();
+
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      const history = await Notification.getHistory();
+      const found = history.find((item: any) => item.id === 'remove-all-test');
+      expect(found).to.be.undefined();
+    });
+
+    ifit(process.platform === 'darwin')('remove does not throw with an empty array', () => {
+      expect(() => Notification.remove([])).to.not.throw();
+    });
+
+    ifit(process.platform === 'darwin')('remove does not throw with an empty string', () => {
+      expect(() => Notification.remove('')).to.not.throw();
+    });
+
+    ifit(process.platform === 'darwin')('removeGroup does not throw', () => {
+      expect(() => Notification.removeGroup('nonexistent-group')).to.not.throw();
+    });
+
+    ifit(process.platform === 'darwin')('removeGroup removes notifications by groupId', async () => {
+      const n1 = new Notification({
+        id: 'group-keep',
+        title: 'keep',
+        body: 'body',
+        groupId: 'group-a',
+        silent: true
+      });
+      const n2 = new Notification({
+        id: 'group-remove-1',
+        title: 'remove 1',
+        body: 'body',
+        groupId: 'group-b',
+        silent: true
+      });
+      const n3 = new Notification({
+        id: 'group-remove-2',
+        title: 'remove 2',
+        body: 'body',
+        groupId: 'group-b',
+        silent: true
+      });
+
+      for (const n of [n1, n2, n3]) {
+        const shown = once(n, 'show');
+        n.show();
+        await shown;
+      }
+
+      Notification.removeGroup('group-b');
+
+      // Give the notification center a moment to fetch and remove
+      await new Promise(resolve => setTimeout(resolve, 500));
+
+      const history = await Notification.getHistory();
+      // In code-signed builds, group-a notification should remain
+      // while group-b notifications should be gone
+      const foundB1 = history.find((item: any) => item.id === 'group-remove-1');
+      const foundB2 = history.find((item: any) => item.id === 'group-remove-2');
+      expect(foundB1).to.be.undefined();
+      expect(foundB2).to.be.undefined();
+
+      // Clean up
+      Notification.removeAll();
+    });
+  });
 });

typings/internal-ambient.d.ts

@@ -118,6 +118,10 @@ declare namespace NodeJS {
 
   interface NotificationBinding {
     isSupported(): boolean;
+    getHistory(): Promise<Electron.Notification[]>;
+    remove(id: string | string[]): void;
+    removeAll(): void;
+    removeGroup(groupId: string): void;
     Notification: typeof Electron.Notification;
     // Windows-only callback for cold-start notification activation
     handleActivation?: (callback: (details: ActivationArgumentsInternal) => void) => void;