fix notification ui and auto-start trigger

Author: yujonglee

apps/desktop/src/components/event-listeners.tsx

@@ -9,7 +9,10 @@ import {
 import { getCurrentWebviewWindowLabel } from "@hypr/plugin-windows";
 
 import * as main from "../store/tinybase/store/main";
-import { getOrCreateSessionForEventId } from "../store/tinybase/store/sessions";
+import {
+  createSession,
+  getOrCreateSessionForEventId,
+} from "../store/tinybase/store/sessions";
 import { useTabs } from "../store/zustand/tabs";
 
 function useUpdaterEvents() {
@@ -43,13 +46,22 @@ function useUpdaterEvents() {
 function useNotificationEvents() {
   const store = main.UI.useStore(main.STORE_ID);
   const openNew = useTabs((state) => state.openNew);
-  const pendingEventId = useRef<string | null>(null);
+  const pendingAutoStart = useRef<{ eventId: string | null } | null>(null);
+  const storeRef = useRef(store);
+  const openNewRef = useRef(openNew);
+
+  useEffect(() => {
+    storeRef.current = store;
+    openNewRef.current = openNew;
+  }, [store, openNew]);
 
   useEffect(() => {
-    if (pendingEventId.current && store) {
-      const eventId = pendingEventId.current;
-      pendingEventId.current = null;
-      const sessionId = getOrCreateSessionForEventId(store, eventId);
+    if (pendingAutoStart.current && store) {
+      const { eventId } = pendingAutoStart.current;
+      pendingAutoStart.current = null;
+      const sessionId = eventId
+        ? getOrCreateSessionForEventId(store, eventId)
+        : createSession(store);
       openNew({
         type: "sessions",
         id: sessionId,
@@ -64,37 +76,42 @@ function useNotificationEvents() {
     }
 
     let unlisten: UnlistenFn | null = null;
+    let cancelled = false;
 
     void notificationEvents.notificationEvent
       .listen(({ payload }) => {
         if (
-          (payload.type === "notification_confirm" ||
-            payload.type === "notification_accept") &&
-          payload.event_id
+          payload.type === "notification_confirm" ||
+          payload.type === "notification_accept"
         ) {
-          if (!store) {
-            pendingEventId.current = payload.event_id;
+          const currentStore = storeRef.current;
+          if (!currentStore) {
+            pendingAutoStart.current = { eventId: payload.event_id };
             return;
           }
-          const sessionId = getOrCreateSessionForEventId(
-            store,
-            payload.event_id,
-          );
-          openNew({
+          const sessionId = payload.event_id
+            ? getOrCreateSessionForEventId(currentStore, payload.event_id)
+            : createSession(currentStore);
+          openNewRef.current({
             type: "sessions",
             id: sessionId,
             state: { view: null, autoStart: true },
           });
         }
       })
       .then((f) => {
-        unlisten = f;
+        if (cancelled) {
+          f();
+        } else {
+          unlisten = f;
+        }
       });
 
     return () => {
+      cancelled = true;
       unlisten?.();
     };
-  }, [store, openNew]);
+  }, []);
 }
 
 export function EventListeners() {

apps/desktop/src/components/task-manager.tsx

@@ -16,6 +16,7 @@ import {
   checkEventNotifications,
   EVENT_NOTIFICATION_INTERVAL,
   EVENT_NOTIFICATION_TASK_ID,
+  type NotifiedEventsMap,
 } from "../services/event-notification";
 import * as main from "../store/tinybase/store/main";
 import * as settings from "../store/tinybase/store/settings";
@@ -27,7 +28,7 @@ export function TaskManager() {
   const queries = main.UI.useQueries(main.STORE_ID);
 
   const settingsStore = settings.UI.useStore(settings.STORE_ID);
-  const notifiedEventsRef = useRef<Set<string>>(new Set());
+  const notifiedEventsRef = useRef<NotifiedEventsMap>(new Map());
 
   useSetTask(CALENDAR_SYNC_TASK_ID, async () => {
     await syncCalendarEvents(

apps/desktop/src/services/apple-calendar/fetch/incoming.ts

@@ -9,6 +9,18 @@ import type {
   IncomingParticipants,
 } from "./types";
 
+export class CalendarFetchError extends Error {
+  constructor(
+    public readonly calendarTrackingId: string,
+    public readonly cause: string,
+  ) {
+    super(
+      `Failed to fetch events for calendar ${calendarTrackingId}: ${cause}`,
+    );
+    this.name = "CalendarFetchError";
+  }
+}
+
 export async function fetchIncomingEvents(ctx: Ctx): Promise<{
   events: IncomingEvent[];
   participants: IncomingParticipants;
@@ -24,7 +36,7 @@ export async function fetchIncomingEvents(ctx: Ctx): Promise<{
       });
 
       if (result.status === "error") {
-        return [];
+        throw new CalendarFetchError(trackingId, result.error);
       }
 
       return result.data;

apps/desktop/src/services/apple-calendar/fetch/index.ts

@@ -1,3 +1,3 @@
 export { fetchExistingEvents } from "./existing";
-export { fetchIncomingEvents } from "./incoming";
+export { CalendarFetchError, fetchIncomingEvents } from "./incoming";
 export type { ExistingEvent, IncomingEvent } from "./types";

apps/desktop/src/services/apple-calendar/index.ts

@@ -2,7 +2,11 @@ import type { Queries } from "tinybase/with-schemas";
 
 import type { Schemas, Store } from "../../store/tinybase/store/main";
 import { createCtx } from "./ctx";
-import { fetchExistingEvents, fetchIncomingEvents } from "./fetch";
+import {
+  CalendarFetchError,
+  fetchExistingEvents,
+  fetchIncomingEvents,
+} from "./fetch";
 import {
   executeForEventsSync,
   executeForParticipantsSync,
@@ -28,8 +32,23 @@ async function run(store: Store, queries: Queries<Schemas>) {
     return null;
   }
 
-  const { events: incoming, participants: incomingParticipants } =
-    await fetchIncomingEvents(ctx);
+  let incoming;
+  let incomingParticipants;
+
+  try {
+    const result = await fetchIncomingEvents(ctx);
+    incoming = result.events;
+    incomingParticipants = result.participants;
+  } catch (error) {
+    if (error instanceof CalendarFetchError) {
+      console.error(
+        `[calendar-sync] Aborting sync due to fetch error: ${error.message}`,
+      );
+      return null;
+    }
+    throw error;
+  }
+
   const existing = fetchExistingEvents(ctx);
 
   const eventsOut = syncEvents(ctx, { incoming, existing });

apps/desktop/src/services/event-notification/index.ts

@@ -7,33 +7,42 @@ export const EVENT_NOTIFICATION_TASK_ID = "eventNotification";
 export const EVENT_NOTIFICATION_INTERVAL = 30 * 1000; // 30 sec
 
 const NOTIFY_WINDOW_MS = 5 * 60 * 1000; // 5 minutes before
+const NOTIFIED_EVENTS_TTL_MS = 10 * 60 * 1000; // 10 minutes TTL for cleanup
+
+export type NotifiedEventsMap = Map<string, number>;
 
 export function checkEventNotifications(
   store: main.Store,
   settingsStore: settings.Store,
-  notifiedEvents: Set<string>,
+  notifiedEvents: NotifiedEventsMap,
 ) {
   const notificationEnabled = settingsStore?.getValue("notification_event");
   if (!notificationEnabled || !store) {
     return;
   }
 
-  const now = new Date();
+  const now = Date.now();
+
+  for (const [key, timestamp] of notifiedEvents) {
+    if (now - timestamp > NOTIFIED_EVENTS_TTL_MS) {
+      notifiedEvents.delete(key);
+    }
+  }
 
   store.forEachRow("events", (eventId, _forEachCell) => {
     const event = store.getRow("events", eventId);
     if (!event?.started_at) return;
 
     const startTime = new Date(String(event.started_at));
-    const timeUntilStart = startTime.getTime() - now.getTime();
+    const timeUntilStart = startTime.getTime() - now;
     const notificationKey = `event-${eventId}-${startTime.getTime()}`;
 
     if (timeUntilStart > 0 && timeUntilStart <= NOTIFY_WINDOW_MS) {
       if (notifiedEvents.has(notificationKey)) {
         return;
       }
 
-      notifiedEvents.add(notificationKey);
+      notifiedEvents.set(notificationKey, now);
 
       const title = String(event.title || "Upcoming Event");
       const minutesUntil = Math.ceil(timeUntilStart / 60000);

apps/desktop/src/store/tinybase/store/sessions.ts

@@ -6,6 +6,22 @@ import * as main from "./main";
 
 type Store = NonNullable<ReturnType<typeof main.UI.useStore>>;
 
+export function createSession(store: Store, title?: string): string {
+  const sessionId = id();
+  store.setRow("sessions", sessionId, {
+    title: title ?? "",
+    created_at: new Date().toISOString(),
+    raw_md: "",
+    enhanced_md: "",
+    user_id: DEFAULT_USER_ID,
+  });
+  void analyticsCommands.event({
+    event: "note_created",
+    has_event_id: false,
+  });
+  return sessionId;
+}
+
 export function getOrCreateSessionForEventId(
   store: Store,
   eventId: string,

crates/notification-linux/examples/test_notification.rs

@@ -3,24 +3,19 @@ use gtk::prelude::*;
 use notification_linux::*;
 
 fn main() {
-    // Initialize GTK
     gtk::init().expect("Failed to initialize GTK");
 
     let notification = Notification::builder()
         .title("Test Notification")
         .message("This is a test notification from hyprnote")
-        .url("https://example.com")
         .timeout(std::time::Duration::from_secs(5))
         .build();
 
-    // Queue the notification on the default main context
     show(&notification);
 
-    // Quit the GTK main loop after 10 seconds so the example exits
     glib::timeout_add_seconds_local_once(10, || {
         gtk::main_quit();
     });
 
-    // Drive the GTK / GLib event loop so the queued closure runs
     gtk::main();
 }

crates/notification-macos/examples/test_notification.rs

@@ -47,18 +47,23 @@ fn main() {
     std::thread::spawn(|| {
         std::thread::sleep(Duration::from_millis(200));
 
+        setup_notification_accept_handler(|id| {
+            println!("accept: {}", id);
+        });
         setup_notification_confirm_handler(|id| {
             println!("confirm: {}", id);
         });
         setup_notification_dismiss_handler(|id| {
             println!("dismiss: {}", id);
         });
+        setup_notification_timeout_handler(|id| {
+            println!("timeout: {}", id);
+        });
 
         let notification = Notification::builder()
             .key("test_notification")
             .title("Test Notification")
             .message("Hover/click should now react")
-            .url("https://example.com")
             .timeout(Duration::from_secs(30))
             .build();
 

crates/notification-macos/swift-lib/src/lib.swift

@@ -134,7 +134,7 @@ class ClickableView: NSView {
       notification.key.withCString { keyPtr in
         rustOnNotificationConfirm(keyPtr)
       }
-      notification.dismissWithUserAction()
+      notification.dismiss()
     }
   }
 
@@ -239,30 +239,30 @@ class ActionButton: NSButton {
     wantsLayer = true
     isBordered = false
     bezelStyle = .rounded
-    controlSize = .regular
-    font = NSFont.systemFont(ofSize: 14, weight: .semibold)
+    controlSize = .small
+    font = NSFont.systemFont(ofSize: 12, weight: .medium)
     focusRingType = .none
 
     contentTintColor = NSColor(calibratedWhite: 0.1, alpha: 1.0)
     if #available(macOS 11.0, *) {
       bezelColor = NSColor(calibratedWhite: 0.9, alpha: 1.0)
     }
 
-    layer?.cornerRadius = 10
+    layer?.cornerRadius = 8
     layer?.backgroundColor = NSColor(calibratedWhite: 0.95, alpha: 0.9).cgColor
     layer?.borderColor = NSColor(calibratedWhite: 0.7, alpha: 0.5).cgColor
     layer?.borderWidth = 0.5
 
     layer?.shadowColor = NSColor(calibratedWhite: 0.0, alpha: 0.5).cgColor
-    layer?.shadowOpacity = 0.3
-    layer?.shadowRadius = 3
+    layer?.shadowOpacity = 0.2
+    layer?.shadowRadius = 2
     layer?.shadowOffset = CGSize(width: 0, height: 1)
   }
 
   override var intrinsicContentSize: NSSize {
     var s = super.intrinsicContentSize
-    s.width += 22
-    s.height = max(28, s.height + 4)
+    s.width += 12
+    s.height = max(24, s.height + 2)
     return s
   }
 
@@ -547,8 +547,7 @@ class NotificationManager {
 
     NSLayoutConstraint.activate([
       contentView.leadingAnchor.constraint(equalTo: effectView.leadingAnchor, constant: 12),
-      contentView.trailingAnchor.constraint(
-        equalTo: effectView.trailingAnchor, constant: -35),
+      contentView.trailingAnchor.constraint(equalTo: effectView.trailingAnchor, constant: -12),
       contentView.topAnchor.constraint(equalTo: effectView.topAnchor, constant: 9),
       contentView.bottomAnchor.constraint(equalTo: effectView.bottomAnchor, constant: -9),
     ])
@@ -617,8 +616,14 @@ class NotificationManager {
     textStack.addArrangedSubview(titleLabel)
     textStack.addArrangedSubview(bodyLabel)
 
+    let actionButton = ActionButton()
+    actionButton.title = "Take notes"
+    actionButton.notification = notification
+    actionButton.setContentHuggingPriority(.required, for: .horizontal)
+
     container.addArrangedSubview(iconContainer)
     container.addArrangedSubview(textStack)
+    container.addArrangedSubview(actionButton)
 
     return container
   }