cloudseeding / tasks / checkNotifications.ts

import {
  agentContext,
  claimTaskThread,
  releaseTaskThread,
} from "../utils/agentContext.ts";
import { msFrom, msUntilNextWakeWindow } from "../utils/time.ts";
import { bsky } from "../utils/bsky.ts";
import { processNotification } from "../utils/processNotification.ts";

export const checkNotifications = async () => {
  if (!claimTaskThread()) {
    const newDelay = msFrom.minutes(2);
    console.log(
      `🔹 ${agentContext.agentBskyName} is busy, checking for notifications again in ${
        (newDelay * 1000) * 60
      } minutes…`,
    );
    // agentContext is busy, try to check notifications in 2 minutes.
    setTimeout(checkNotifications, newDelay);
    return;
  }

  const delay = msUntilNextWakeWindow(
    msFrom.minutes(30),
    msFrom.minutes(45),
  );

  if (delay !== 0) {
    setTimeout(checkNotifications, delay);
    console.log(
      `🔹 ${agentContext.agentBskyName} is currently asleep. scheduling next notification check for ${
        (delay / 1000 / 60 / 60).toFixed(2)
      } hours from now…`,
    );
    agentContext.notifDelayCurrent = agentContext.notifDelayMinimum;
    releaseTaskThread();
    return;
  }

  try {
    const allNotifications = await bsky.listNotifications({
      reasons: agentContext.supportedNotifTypes,
      limit: 50,
    });

    const startedProcessingTime: string = new Date().toISOString();

    const unreadNotifications = allNotifications.data.notifications.filter(
      (notif) => !notif.isRead,
    );

    if (unreadNotifications.length > 0) {
      console.log(
        `🔹 found ${unreadNotifications.length} notification(s), processing…`,
      );

      // resets delay for future notification checks since
      // it's likely agent actions might incur new ones
      agentContext.notifDelayCurrent = Math.max(
        agentContext.notifDelayCurrent / 4,
        agentContext.notifDelayMinimum,
      );

      // loop through all notifications until complete
      //
      let notificationCounter = 1;
      for (const notification of unreadNotifications) {
        console.log(
          `🔹 processing notification #${notificationCounter} of #${unreadNotifications.length} [${notification.reason} from @${notification.author.handle}]`,
        );
        await processNotification(notification);
        notificationCounter++;
      }

      // marks all notifications that were processed as seen
      // based on time from when retrieved instead of finished
      await bsky.updateSeenNotifications(startedProcessingTime);
      console.log(
        `🔹 done processing ${unreadNotifications.length} notification${
          unreadNotifications.length > 1 ? "s" : ""
        }…`,
      );
      // increases counter for notification processing session
      agentContext.processingCount++;
    } else {
      // increases delay to check notifications again later
      agentContext.notifDelayCurrent = Math.round(Math.min(
        agentContext.notifDelayCurrent *
          agentContext.notifDelayMultiplier,
        agentContext.notifDelayMaximum,
      ));

      console.log(
        "🔹 no notifications…",
        `checking again in ${
          (agentContext.notifDelayCurrent / 1000).toFixed(2)
        } seconds`,
      );
    }
  } catch (error) {
    console.error("Error in checkNotifications:", error);
    // since something went wrong, lets check for notifications again sooner
    agentContext.notifDelayCurrent = agentContext.notifDelayMinimum;
  } finally {
    // increment check count
    agentContext.checkCount++;
    // actually schedules next time to check for notifications
    setTimeout(checkNotifications, agentContext.notifDelayCurrent);
    // ends work
    releaseTaskThread();
  }
};