Fix daily notification plugin integration and bundling

- Change from dynamic to static imports for @timesafari/daily-notification-plugin
- Remove plugin from external dependencies in vite.config.capacitor.mts to ensure proper bundling
- Add debug logging to DailyNotificationSection for troubleshooting
- Update package-lock.json with latest dependencies

BUILDING.md

@@ -1156,9 +1156,6 @@ gem_path=$(which gem)
 shortened_path="${gem_path:h:h}"
 export GEM_HOME=$shortened_path
 export GEM_PATH=$shortened_path
-
-cd ios/App
-pod install
 ```
 
 ##### 1. Bump the version in package.json for `MARKETING_VERSION`, then `grep CURRENT_PROJECT_VERSION ios/App/App.xcodeproj/project.pbxproj` and add 1 for the numbered version;

android/app/build.gradle

@@ -31,8 +31,8 @@ android {
         applicationId "app.timesafari.app"
         minSdkVersion rootProject.ext.minSdkVersion
         targetSdkVersion rootProject.ext.targetSdkVersion
-        versionCode 48
-        versionName "1.1.3-beta"
+        versionCode 47
+        versionName "1.1.2"
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
         aaptOptions {
              // Files and dirs to omit from the packaged assets dir, modified to accommodate modern web apps.

android/app/capacitor.build.gradle

@@ -18,6 +18,7 @@ dependencies {
     implementation project(':capacitor-share')
     implementation project(':capacitor-status-bar')
     implementation project(':capawesome-capacitor-file-picker')
+    implementation project(':timesafari-daily-notification-plugin')
 
 }
 

android/app/src/main/AndroidManifest.xml

@@ -36,6 +36,30 @@
             android:grantUriPermissions="true">
             <meta-data android:name="android.support.FILE_PROVIDER_PATHS" android:resource="@xml/file_paths" />
         </provider>
+
+        <!-- Daily Notification Plugin Receivers -->
+        <receiver
+            android:name="com.timesafari.dailynotification.DailyNotificationReceiver"
+            android:enabled="true"
+            android:exported="false">
+            <intent-filter>
+                <action android:name="com.timesafari.daily.NOTIFICATION" />
+            </intent-filter>
+        </receiver>
+        <receiver
+            android:name="com.timesafari.dailynotification.BootReceiver"
+            android:directBootAware="true"
+            android:enabled="true"
+            android:exported="true">
+            <intent-filter android:priority="1000">
+                <!-- Delivered very early after reboot (before unlock) -->
+                <action android:name="android.intent.action.LOCKED_BOOT_COMPLETED" />
+                <!-- Delivered after the user unlocks / credential-encrypted storage is available -->
+                <action android:name="android.intent.action.BOOT_COMPLETED" />
+                <!-- Delivered after app update; great for rescheduling alarms without reboot -->
+                <action android:name="android.intent.action.MY_PACKAGE_REPLACED" />
+            </intent-filter>
+        </receiver>
     </application>
 
     <!-- Permissions -->
@@ -45,4 +69,15 @@
     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
     <uses-permission android:name="android.permission.CAMERA" />
     <uses-feature android:name="android.hardware.camera" android:required="true" />
+
+    <!-- Notification permissions -->
+    <!-- POST_NOTIFICATIONS required for Android 13+ (API 33+) -->
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+
+    <!-- SCHEDULE_EXACT_ALARM required for Android 12+ (API 31+) to schedule exact alarms -->
+    <!-- Note: On Android 12+, users can grant/deny this permission -->
+    <uses-permission android:name="android.permission.SCHEDULE_EXACT_ALARM" />
+
+    <!-- RECEIVE_BOOT_COMPLETED needed to reschedule notifications after device reboot -->
+    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
 </manifest>

android/app/src/main/assets/capacitor.plugins.json

@@ -34,5 +34,9 @@
 	{
 		"pkg": "@capawesome/capacitor-file-picker",
 		"classpath": "io.capawesome.capacitorjs.plugins.filepicker.FilePickerPlugin"
+	},
+	{
+		"pkg": "@timesafari/daily-notification-plugin",
+		"classpath": "com.timesafari.dailynotification.DailyNotificationPlugin"
 	}
 ]

android/capacitor.settings.gradle

@@ -28,3 +28,6 @@ project(':capacitor-status-bar').projectDir = new File('../node_modules/@capacit
 
 include ':capawesome-capacitor-file-picker'
 project(':capawesome-capacitor-file-picker').projectDir = new File('../node_modules/@capawesome/capacitor-file-picker/android')
+
+include ':timesafari-daily-notification-plugin'
+project(':timesafari-daily-notification-plugin').projectDir = new File('../node_modules/@timesafari/daily-notification-plugin/android')

package-lock.json

@@ -37,6 +37,7 @@
         "@pvermeer/dexie-encrypted-addon": "^3.0.0",
         "@simplewebauthn/browser": "^10.0.0",
         "@simplewebauthn/server": "^10.0.0",
+        "@timesafari/daily-notification-plugin": "file:../daily-notification-plugin",
         "@tweenjs/tween.js": "^21.1.1",
         "@types/qrcode": "^1.5.5",
         "@veramo/core": "^5.6.0",
@@ -149,6 +150,43 @@
         "vite": "^5.2.0"
       }
     },
+    "../daily-notification-plugin": {
+      "name": "@timesafari/daily-notification-plugin",
+      "version": "1.0.3",
+      "license": "MIT",
+      "workspaces": [
+        "packages/*"
+      ],
+      "dependencies": {
+        "@capacitor/core": "^6.2.1"
+      },
+      "devDependencies": {
+        "@capacitor/android": "^6.2.1",
+        "@capacitor/cli": "^6.2.1",
+        "@capacitor/ios": "^6.2.1",
+        "@types/jest": "^29.5.0",
+        "@types/jsdom": "^21.1.7",
+        "@types/node": "^20.19.0",
+        "@typescript-eslint/eslint-plugin": "^5.57.0",
+        "@typescript-eslint/parser": "^5.57.0",
+        "eslint": "^8.37.0",
+        "jest": "^29.5.0",
+        "jest-environment-jsdom": "^30.0.5",
+        "jsdom": "^26.1.0",
+        "markdownlint-cli2": "^0.18.1",
+        "prettier": "^2.8.7",
+        "rimraf": "^4.4.0",
+        "rollup": "^3.20.0",
+        "rollup-plugin-typescript2": "^0.31.0",
+        "standard-version": "^9.5.0",
+        "ts-jest": "^29.1.0",
+        "typescript": "~5.2.0",
+        "vite": "^7.1.9"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/@0no-co/graphql.web": {
       "version": "1.2.0",
       "resolved": "https://registry.npmjs.org/@0no-co/graphql.web/-/graphql.web-1.2.0.tgz",
@@ -9605,6 +9643,10 @@
         "node": ">=10"
       }
     },
+    "node_modules/@timesafari/daily-notification-plugin": {
+      "resolved": "../daily-notification-plugin",
+      "link": true
+    },
     "node_modules/@tootallnate/once": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/@tootallnate/once/-/once-2.0.0.tgz",

package.json

@@ -166,6 +166,7 @@
     "@pvermeer/dexie-encrypted-addon": "^3.0.0",
     "@simplewebauthn/browser": "^10.0.0",
     "@simplewebauthn/server": "^10.0.0",
+    "@timesafari/daily-notification-plugin": "file:../daily-notification-plugin",
     "@tweenjs/tween.js": "^21.1.1",
     "@types/qrcode": "^1.5.5",
     "@veramo/core": "^5.6.0",

src/components/notifications/DailyNotificationSection.vue

@@ -0,0 +1,781 @@
+<template>
+  <section
+    v-if="notificationsSupported"
+    id="sectionDailyNotifications"
+    class="bg-slate-100 rounded-md overflow-hidden px-4 py-4 mt-8 mb-8"
+    aria-labelledby="dailyNotificationsHeading"
+  >
+    <h2 id="dailyNotificationsHeading" class="mb-2 font-bold">
+      Daily Notifications
+      <button
+        class="text-slate-400 fa-fw cursor-pointer"
+        aria-label="Learn more about native notifications"
+        @click.stop="showNativeNotificationInfo"
+      >
+        <font-awesome icon="circle-question" aria-hidden="true" />
+      </button>
+    </h2>
+
+    <div class="flex items-center justify-between">
+      <div>Daily Notification</div>
+      <!-- Toggle switch -->
+      <div
+        class="relative ml-2 cursor-pointer"
+        role="switch"
+        :aria-checked="nativeNotificationEnabled"
+        :aria-label="
+          nativeNotificationEnabled
+            ? 'Disable daily notifications'
+            : 'Enable daily notifications'
+        "
+        tabindex="0"
+        @click="toggleNativeNotification"
+      >
+        <!-- input -->
+        <input
+          :checked="nativeNotificationEnabled"
+          type="checkbox"
+          class="sr-only"
+          tabindex="-1"
+          readonly
+        />
+        <!-- line -->
+        <div
+          class="block bg-slate-500 w-14 h-8 rounded-full transition"
+          :class="{
+            'bg-blue-600': nativeNotificationEnabled,
+          }"
+        ></div>
+        <!-- dot -->
+        <div
+          class="dot absolute left-1 top-1 bg-slate-400 w-6 h-6 rounded-full transition"
+          :class="{
+            'left-7 bg-white': nativeNotificationEnabled,
+          }"
+        ></div>
+      </div>
+    </div>
+
+    <!-- Show "Open Settings" button when permissions are denied -->
+    <div
+      v-if="
+        notificationsSupported &&
+        notificationStatus &&
+        notificationStatus.permissions.notifications === 'denied'
+      "
+      class="mt-2"
+    >
+      <button
+        class="w-full px-3 py-2 bg-blue-600 text-white rounded text-sm font-medium"
+        @click="openNotificationSettings"
+      >
+        Open Settings
+      </button>
+      <p class="text-xs text-slate-500 mt-1 text-center">
+        Enable notifications in Settings > App info > Notifications
+      </p>
+    </div>
+
+    <!-- Time input section - show when enabled OR when no time is set -->
+    <div
+      v-if="nativeNotificationEnabled || !nativeNotificationTimeStorage"
+      class="mt-2"
+    >
+      <div
+        v-if="nativeNotificationEnabled"
+        class="flex items-center justify-between mb-2"
+      >
+        <span
+          >Scheduled for:
+          <span v-if="nativeNotificationTime">{{
+            nativeNotificationTime
+          }}</span>
+          <span v-else class="text-slate-500">Not set</span></span
+        >
+        <button
+          class="text-blue-500 text-sm"
+          @click="editNativeNotificationTime"
+        >
+          {{ showTimeEdit ? "Cancel" : "Edit Time" }}
+        </button>
+      </div>
+
+      <!-- Time input (shown when editing or when no time is set) -->
+      <div v-if="showTimeEdit || !nativeNotificationTimeStorage" class="mt-2">
+        <label class="block text-sm text-slate-600 mb-1">
+          Notification Time
+        </label>
+        <div class="flex items-center gap-2">
+          <input
+            v-model="nativeNotificationTimeStorage"
+            type="time"
+            class="rounded border border-slate-400 px-2 py-2"
+            @change="onTimeChange"
+          />
+          <button
+            v-if="showTimeEdit || nativeNotificationTimeStorage"
+            class="px-3 py-2 bg-blue-600 text-white rounded"
+            @click="saveTimeChange"
+          >
+            Save
+          </button>
+        </div>
+        <p
+          v-if="!nativeNotificationTimeStorage"
+          class="text-xs text-slate-500 mt-1"
+        >
+          Set a time before enabling notifications
+        </p>
+      </div>
+    </div>
+
+    <!-- Loading state -->
+    <div v-if="loading" class="mt-2 text-sm text-slate-500">Loading...</div>
+  </section>
+</template>
+
+<script lang="ts">
+/**
+ * DailyNotificationSection Component
+ *
+ * A self-contained component for managing daily notification scheduling
+ * in AccountViewView. This component handles platform detection, permission
+ * requests, scheduling, and state management for daily notifications.
+ *
+ * Features:
+ * - Platform capability detection (hides on unsupported platforms)
+ * - Permission request flow
+ * - Schedule/cancel notifications
+ * - Time editing with HTML5 time input
+ * - Settings persistence
+ * - Plugin state synchronization
+ *
+ * @author Generated for TimeSafari Daily Notification Integration
+ * @component
+ */
+
+import { Component, Vue } from "vue-facing-decorator";
+import { PlatformServiceMixin } from "@/utils/PlatformServiceMixin";
+import { logger } from "@/utils/logger";
+import { PlatformServiceFactory } from "@/services/PlatformServiceFactory";
+import type {
+  NotificationStatus,
+  PermissionStatus,
+} from "@/services/PlatformService";
+import { createNotifyHelpers, TIMEOUTS } from "@/utils/notify";
+import type { NotificationIface } from "@/constants/app";
+
+/**
+ * Convert 24-hour time format ("09:00") to 12-hour display format ("9:00 AM")
+ */
+function formatTimeForDisplay(time24: string): string {
+  if (!time24) return "";
+  const [hours, minutes] = time24.split(":");
+  const hourNum = parseInt(hours);
+  const isPM = hourNum >= 12;
+  const displayHour =
+    hourNum === 0 ? 12 : hourNum > 12 ? hourNum - 12 : hourNum;
+  return `${displayHour}:${minutes} ${isPM ? "PM" : "AM"}`;
+}
+
+@Component({
+  name: "DailyNotificationSection",
+  mixins: [PlatformServiceMixin],
+})
+export default class DailyNotificationSection extends Vue {
+  $notify!: (notification: NotificationIface, timeout?: number) => void;
+
+  // Component state
+  notificationsSupported: boolean = false;
+  nativeNotificationEnabled: boolean = false;
+  nativeNotificationTime: string = ""; // Display format: "9:00 AM"
+  nativeNotificationTimeStorage: string = ""; // Plugin format: "09:00"
+  nativeNotificationTitle: string = "Daily Update";
+  nativeNotificationMessage: string = "Your daily notification is ready!";
+  showTimeEdit: boolean = false;
+  loading: boolean = false;
+  notificationStatus: NotificationStatus | null = null;
+
+  // Notify helpers
+  private notify!: ReturnType<typeof createNotifyHelpers>;
+
+  async created(): Promise<void> {
+    this.notify = createNotifyHelpers(this.$notify);
+  }
+
+  /**
+   * Initialize component state on mount
+   * Checks platform support and syncs with plugin state
+   *
+   * **Token Refresh on Mount:**
+   * - Refreshes native fetcher configuration to ensure plugin has valid token
+   * - This handles cases where app was closed for extended periods
+   * - Token refresh happens automatically without user interaction
+   *
+   * **App Resume Listener:**
+   * - Listens for Capacitor 'resume' event to refresh token when app comes to foreground
+   * - Ensures plugin always has fresh token for background prefetch operations
+   * - Cleaned up in `beforeDestroy()` lifecycle hook
+   */
+  async mounted(): Promise<void> {
+    await this.initializeState();
+    // Refresh native fetcher configuration on mount
+    // This ensures plugin has valid token even if app was closed for extended periods
+    await this.refreshNativeFetcherConfig();
+    // Listen for app resume events to refresh token when app comes to foreground
+    // This is part of the proactive token refresh strategy
+    document.addEventListener("resume", this.handleAppResume);
+  }
+
+  /**
+   * Cleanup on component destroy
+   */
+  beforeDestroy(): void {
+    document.removeEventListener("resume", this.handleAppResume);
+  }
+
+  /**
+   * Handle app resume event - refresh native fetcher configuration
+   *
+   * This method is called when the app comes to foreground (via Capacitor 'resume' event).
+   * It proactively refreshes the JWT token to ensure the plugin has valid authentication
+   * for background prefetch operations.
+   *
+   * **Why refresh on resume?**
+   * - Tokens expire after 72 hours
+   * - App may have been closed for extended periods
+   * - Refreshing ensures plugin has valid token for next prefetch cycle
+   * - No user interaction required - happens automatically
+   *
+   * @see {@link refreshNativeFetcherConfig} For implementation details
+   */
+  async handleAppResume(): Promise<void> {
+    logger.debug(
+      "[DailyNotificationSection] App resumed, refreshing native fetcher config",
+    );
+    await this.refreshNativeFetcherConfig();
+  }
+
+  /**
+   * Refresh native fetcher configuration with fresh JWT token
+   *
+   * This method ensures the daily notification plugin has a valid authentication token
+   * for background prefetch operations. It's called proactively to prevent token expiration
+   * issues during offline periods.
+   *
+   * **Refresh Triggers:**
+   * - Component mount (when notification settings page loads)
+   * - App resume (when app comes to foreground)
+   * - Notification enabled (when user enables daily notifications)
+   *
+   * **Token Refresh Strategy (Hybrid Approach):**
+   * - Tokens are valid for 72 hours (see `accessTokenForBackground`)
+   * - Tokens are refreshed proactively when app is already open
+   * - If token expires while offline, plugin uses cached content
+   * - Next time app opens, token is automatically refreshed
+   *
+   * **Why This Approach?**
+   * - No app wake-up required (tokens refresh when app is already open)
+   * - Works offline (72-hour validity supports extended offline periods)
+   * - Automatic (no user interaction required)
+   * - Includes starred plans (fetcher receives user's starred plans for prefetch)
+   * - Graceful degradation (if refresh fails, cached content still works)
+   *
+   * **Error Handling:**
+   * - Errors are logged but not shown to user (background operation)
+   * - Returns early if notifications not supported or disabled
+   * - Returns early if API server not configured
+   * - Failures don't interrupt user experience
+   *
+   * @returns Promise that resolves when refresh completes (or fails silently)
+   *
+   * @example
+   * ```typescript
+   * // Called automatically on mount/resume
+   * await this.refreshNativeFetcherConfig();
+   * ```
+   *
+   * @see {@link CapacitorPlatformService.configureNativeFetcher} For token generation
+   * @see {@link accessTokenForBackground} For 72-hour token generation
+   */
+  async refreshNativeFetcherConfig(): Promise<void> {
+    try {
+      const platformService = PlatformServiceFactory.getInstance();
+
+      // Early return: Only refresh if notifications are supported and enabled
+      // This prevents unnecessary work when notifications aren't being used
+      if (!this.notificationsSupported || !this.nativeNotificationEnabled) {
+        return;
+      }
+
+      // Get settings for API server and starred plans
+      // API server tells plugin where to fetch content from
+      // Starred plans tell plugin which plans to prefetch
+      const settings = await this.$accountSettings();
+      const apiServer = settings.apiServer || "";
+
+      if (!apiServer) {
+        logger.warn(
+          "[DailyNotificationSection] No API server configured, skipping native fetcher refresh",
+        );
+        return;
+      }
+
+      // Get starred plans from settings
+      // These are passed to the plugin so it knows which plans to prefetch
+      const starredPlanHandleIds = settings.starredPlanHandleIds || [];
+
+      // Configure native fetcher with fresh token
+      // The jwt parameter is ignored - configureNativeFetcher generates it automatically
+      // This ensures we always have a fresh token with current expiration time
+      await platformService.configureNativeFetcher({
+        apiServer,
+        jwt: "", // Will be generated automatically by configureNativeFetcher
+        starredPlanHandleIds,
+      });
+
+      logger.info(
+        "[DailyNotificationSection] Native fetcher configuration refreshed",
+      );
+    } catch (error) {
+      // Don't show error to user - this is a background operation
+      // Failures are logged for debugging but don't interrupt user experience
+      // If refresh fails, plugin will use existing token (if still valid) or cached content
+      logger.error(
+        "[DailyNotificationSection] Failed to refresh native fetcher config:",
+        error,
+      );
+    }
+  }
+
+  /**
+   * Initialize component state
+   * Checks platform support and syncs with plugin state
+   */
+  async initializeState(): Promise<void> {
+    try {
+      this.loading = true;
+      const platformService = PlatformServiceFactory.getInstance();
+
+      logger.debug(
+        "[DailyNotificationSection] Checking notification support...",
+      );
+
+      // Check if notifications are supported on this platform
+      // This also verifies plugin availability (returns null if plugin unavailable)
+      const status = await platformService.getDailyNotificationStatus();
+      if (status === null) {
+        // Notifications not supported or plugin unavailable - don't initialize
+        this.notificationsSupported = false;
+        logger.warn(
+          "[DailyNotificationSection] Notifications not supported or plugin unavailable - section will be hidden",
+        );
+        return;
+      }
+
+      logger.debug(
+        "[DailyNotificationSection] Notifications supported, status:",
+        status,
+      );
+
+      this.notificationsSupported = true;
+      this.notificationStatus = status;
+
+      // Plugin state is the source of truth
+      if (status.isScheduled && status.scheduledTime) {
+        // Plugin has a scheduled notification - sync UI to match
+        this.nativeNotificationEnabled = true;
+        this.nativeNotificationTimeStorage = status.scheduledTime;
+        this.nativeNotificationTime = formatTimeForDisplay(
+          status.scheduledTime,
+        );
+      } else {
+        // No plugin schedule - UI defaults to disabled
+        this.nativeNotificationEnabled = false;
+        this.nativeNotificationTimeStorage = "";
+        this.nativeNotificationTime = "";
+      }
+    } catch (error) {
+      logger.error("[DailyNotificationSection] Failed to initialize:", error);
+      this.notificationsSupported = false;
+    } finally {
+      this.loading = false;
+    }
+  }
+
+  /**
+   * Toggle notification on/off
+   */
+  async toggleNativeNotification(): Promise<void> {
+    // Prevent multiple simultaneous toggles
+    if (this.loading) {
+      logger.warn(
+        "[DailyNotificationSection] Toggle ignored - operation in progress",
+      );
+      return;
+    }
+
+    logger.info(
+      `[DailyNotificationSection] Toggling notification: ${this.nativeNotificationEnabled} -> ${!this.nativeNotificationEnabled}`,
+    );
+
+    if (this.nativeNotificationEnabled) {
+      await this.disableNativeNotification();
+    } else {
+      await this.enableNativeNotification();
+    }
+  }
+
+  /**
+   * Enable daily notification
+   */
+  async enableNativeNotification(): Promise<void> {
+    try {
+      this.loading = true;
+      const platformService = PlatformServiceFactory.getInstance();
+
+      // Check if we have a time set
+      if (!this.nativeNotificationTimeStorage) {
+        this.notify.error(
+          "Please set a notification time first",
+          TIMEOUTS.SHORT,
+        );
+        this.loading = false;
+        return;
+      }
+
+      // Check permissions first - this also verifies plugin availability
+      let permissions: PermissionStatus | null;
+      try {
+        permissions = await platformService.checkNotificationPermissions();
+        logger.info(
+          `[DailyNotificationSection] Permission check result:`,
+          permissions,
+        );
+      } catch (error) {
+        // Plugin may not be available or there's an error
+        logger.error(
+          "[DailyNotificationSection] Failed to check permissions (plugin may be unavailable):",
+          error,
+        );
+        this.notify.error(
+          "Unable to check notification permissions. The notification plugin may not be installed.",
+          TIMEOUTS.LONG,
+        );
+        this.nativeNotificationEnabled = false;
+        return;
+      }
+
+      if (permissions === null) {
+        // Platform doesn't support notifications or plugin unavailable
+        logger.warn(
+          "[DailyNotificationSection] Notifications not supported or plugin unavailable",
+        );
+        this.notify.error(
+          "Notifications are not supported on this platform or the plugin is not installed.",
+          TIMEOUTS.SHORT,
+        );
+        this.nativeNotificationEnabled = false;
+        return;
+      }
+
+      logger.info(
+        `[DailyNotificationSection] Permission state: ${permissions.notifications}`,
+      );
+
+      // If permissions are explicitly denied, don't try to request again
+      // (this prevents the plugin crash when handling denied permissions)
+      // Android won't show the dialog again if permissions are permanently denied
+      if (permissions.notifications === "denied") {
+        logger.warn(
+          "[DailyNotificationSection] Permissions already denied, directing user to settings",
+        );
+        this.notify.error(
+          "Notification permissions were denied. Tap 'Open Settings' to enable them.",
+          TIMEOUTS.LONG,
+        );
+        this.nativeNotificationEnabled = false;
+        return;
+      }
+
+      // Only request if permissions are in "prompt" state (not denied, not granted)
+      // This ensures we only call requestPermissions when Android will actually show a dialog
+      if (permissions.notifications === "prompt") {
+        logger.info(
+          "[DailyNotificationSection] Permission state is 'prompt', requesting permissions...",
+        );
+        try {
+          const result = await platformService.requestNotificationPermissions();
+          logger.info(
+            `[DailyNotificationSection] Permission request result:`,
+            result,
+          );
+          if (result === null) {
+            // Plugin unavailable or request failed
+            logger.error(
+              "[DailyNotificationSection] Permission request returned null",
+            );
+            this.notify.error(
+              "Unable to request notification permissions. The plugin may not be available.",
+              TIMEOUTS.LONG,
+            );
+            this.nativeNotificationEnabled = false;
+            return;
+          }
+          if (!result.notifications) {
+            // Permission request was denied
+            logger.warn(
+              "[DailyNotificationSection] Permission request denied by user",
+            );
+            this.notify.error(
+              "Notification permissions are required. Tap 'Open Settings' to enable them.",
+              TIMEOUTS.LONG,
+            );
+            this.nativeNotificationEnabled = false;
+            return;
+          }
+          // Permissions granted - continue
+          logger.info(
+            "[DailyNotificationSection] Permissions granted successfully",
+          );
+        } catch (error) {
+          // Handle permission request errors (including plugin crashes)
+          logger.error(
+            "[DailyNotificationSection] Permission request failed:",
+            error,
+          );
+          this.notify.error(
+            "Unable to request notification permissions. Tap 'Open Settings' to enable them.",
+            TIMEOUTS.LONG,
+          );
+          this.nativeNotificationEnabled = false;
+          return;
+        }
+      } else if (permissions.notifications !== "granted") {
+        // Unexpected state - shouldn't happen, but handle gracefully
+        logger.warn(
+          `[DailyNotificationSection] Unexpected permission state: ${permissions.notifications}`,
+        );
+        this.notify.error(
+          "Unable to determine notification permission status. Tap 'Open Settings' to check.",
+          TIMEOUTS.LONG,
+        );
+        this.nativeNotificationEnabled = false;
+        return;
+      } else {
+        logger.info("[DailyNotificationSection] Permissions already granted");
+      }
+
+      // Permissions are granted - continue with scheduling
+
+      // Schedule notification via PlatformService
+      await platformService.scheduleDailyNotification({
+        time: this.nativeNotificationTimeStorage, // "09:00" in local time
+        title: this.nativeNotificationTitle,
+        body: this.nativeNotificationMessage,
+        sound: true,
+        priority: "high",
+      });
+
+      // Update UI state
+      this.nativeNotificationEnabled = true;
+
+      // Refresh native fetcher configuration with fresh token
+      // This ensures plugin has valid authentication when notifications are first enabled
+      // Token will be valid for 72 hours, supporting offline prefetch operations
+      await this.refreshNativeFetcherConfig();
+
+      this.notify.success(
+        "Daily notification scheduled successfully",
+        TIMEOUTS.SHORT,
+      );
+    } catch (error) {
+      logger.error(
+        "[DailyNotificationSection] Failed to enable notification:",
+        error,
+      );
+      this.notify.error(
+        "Failed to schedule notification. Please try again.",
+        TIMEOUTS.LONG,
+      );
+      this.nativeNotificationEnabled = false;
+    } finally {
+      this.loading = false;
+    }
+  }
+
+  /**
+   * Disable daily notification
+   */
+  async disableNativeNotification(): Promise<void> {
+    try {
+      this.loading = true;
+      const platformService = PlatformServiceFactory.getInstance();
+
+      // Cancel notification via PlatformService
+      await platformService.cancelDailyNotification();
+
+      // Update UI state
+      this.nativeNotificationEnabled = false;
+      this.nativeNotificationTime = "";
+      this.nativeNotificationTimeStorage = "";
+      this.showTimeEdit = false;
+
+      this.notify.success("Daily notification disabled", TIMEOUTS.SHORT);
+    } catch (error) {
+      logger.error(
+        "[DailyNotificationSection] Failed to disable notification:",
+        error,
+      );
+      this.notify.error(
+        "Failed to disable notification. Please try again.",
+        TIMEOUTS.LONG,
+      );
+    } finally {
+      this.loading = false;
+    }
+  }
+
+  /**
+   * Show/hide time edit input
+   */
+  editNativeNotificationTime(): void {
+    this.showTimeEdit = !this.showTimeEdit;
+  }
+
+  /**
+   * Handle time input change
+   */
+  onTimeChange(): void {
+    // Time is already in nativeNotificationTimeStorage via v-model
+    // Just update display format
+    if (this.nativeNotificationTimeStorage) {
+      this.nativeNotificationTime = formatTimeForDisplay(
+        this.nativeNotificationTimeStorage,
+      );
+    }
+  }
+
+  /**
+   * Save time change and update notification schedule
+   */
+  async saveTimeChange(): Promise<void> {
+    if (!this.nativeNotificationTimeStorage) {
+      this.notify.error("Please select a time", TIMEOUTS.SHORT);
+      return;
+    }
+
+    // Update display format
+    this.nativeNotificationTime = formatTimeForDisplay(
+      this.nativeNotificationTimeStorage,
+    );
+
+    // If notification is enabled, update the schedule
+    if (this.nativeNotificationEnabled) {
+      await this.updateNotificationTime(this.nativeNotificationTimeStorage);
+    } else {
+      // Just update local state (time preference stored in component)
+      this.showTimeEdit = false;
+      this.notify.success("Notification time saved", TIMEOUTS.SHORT);
+    }
+  }
+
+  /**
+   * Update notification time
+   * If notification is enabled, immediately updates the schedule
+   */
+  async updateNotificationTime(newTime: string): Promise<void> {
+    // newTime is in "HH:mm" format from HTML5 time input
+    if (!this.nativeNotificationEnabled) {
+      // If notification is disabled, just update local state
+      this.nativeNotificationTimeStorage = newTime;
+      this.nativeNotificationTime = formatTimeForDisplay(newTime);
+      this.showTimeEdit = false;
+      return;
+    }
+
+    // Notification is enabled - update the schedule
+    try {
+      this.loading = true;
+      const platformService = PlatformServiceFactory.getInstance();
+
+      // 1. Cancel existing notification
+      await platformService.cancelDailyNotification();
+
+      // 2. Schedule with new time
+      await platformService.scheduleDailyNotification({
+        time: newTime, // "09:00" in local time
+        title: this.nativeNotificationTitle,
+        body: this.nativeNotificationMessage,
+        sound: true,
+        priority: "high",
+      });
+
+      // 3. Update local state
+      this.nativeNotificationTimeStorage = newTime;
+      this.nativeNotificationTime = formatTimeForDisplay(newTime);
+
+      this.notify.success(
+        "Notification time updated successfully",
+        TIMEOUTS.SHORT,
+      );
+      this.showTimeEdit = false;
+    } catch (error) {
+      logger.error(
+        "[DailyNotificationSection] Failed to update notification time:",
+        error,
+      );
+      this.notify.error(
+        "Failed to update notification time. Please try again.",
+        TIMEOUTS.LONG,
+      );
+    } finally {
+      this.loading = false;
+    }
+  }
+
+  /**
+   * Show info dialog about native notifications
+   */
+  showNativeNotificationInfo(): void {
+    // TODO: Implement info dialog or navigate to help page
+    this.notify.info(
+      "Daily notifications use your device's native notification system. They work even when the app is closed.",
+      TIMEOUTS.STANDARD,
+    );
+  }
+
+  /**
+   * Open app notification settings
+   */
+  async openNotificationSettings(): Promise<void> {
+    try {
+      const platformService = PlatformServiceFactory.getInstance();
+      const result = await platformService.openAppNotificationSettings();
+      if (result === null) {
+        this.notify.error(
+          "Unable to open settings. Please go to Settings > Apps > TimeSafari > Notifications manually.",
+          TIMEOUTS.LONG,
+        );
+      } else {
+        this.notify.success("Opening notification settings...", TIMEOUTS.SHORT);
+      }
+    } catch (error) {
+      logger.error(
+        "[DailyNotificationSection] Failed to open notification settings:",
+        error,
+      );
+      this.notify.error(
+        "Unable to open settings. Please go to Settings > Apps > TimeSafari > Notifications manually.",
+        TIMEOUTS.LONG,
+      );
+    }
+  }
+}
+</script>
+
+<style scoped>
+.dot {
+  transition: left 0.2s ease;
+}
+</style>

src/libs/crypto/index.ts

@@ -104,6 +104,71 @@ export const accessToken = async (did?: string) => {
   }
 };
 
+/**
+ * Generate a longer-lived access token for background operations
+ *
+ * This function creates JWT tokens with extended validity (default 72 hours) for use
+ * in background prefetch operations. The longer expiration period allows the daily
+ * notification plugin to work offline for extended periods without requiring the app
+ * to be in the foreground to refresh tokens.
+ *
+ * **Token Refresh Strategy (Hybrid Approach):**
+ * - Tokens are valid for 72 hours (configurable)
+ * - Tokens are refreshed proactively when:
+ *   - App comes to foreground (via Capacitor 'resume' event)
+ *   - Component mounts (DailyNotificationSection)
+ *   - Notifications are enabled
+ * - If token expires while offline, plugin uses cached content
+ * - Next time app opens, token is automatically refreshed
+ *
+ * **Why 72 Hours?**
+ * - Balances security (read-only prefetch operations) with offline capability
+ * - Reduces need for app to wake itself for token refresh
+ * - Allows plugin to work offline for extended periods (e.g., weekend trips)
+ * - Longer than typical prefetch windows (5 minutes before notification)
+ *
+ * **Security Considerations:**
+ * - Tokens are used only for read-only prefetch operations
+ * - Tokens are stored securely in plugin's Room database
+ * - Tokens are refreshed proactively to minimize exposure window
+ * - No private keys are exposed to native code
+ *
+ * @param {string} did - User DID (Decentralized Identifier) for token issuer
+ * @param {number} expirationMinutes - Optional expiration in minutes (defaults to 72 hours = 4320 minutes)
+ * @return {Promise<string>} JWT token with extended validity, or empty string if no DID provided
+ *
+ * @example
+ * ```typescript
+ * // Generate token with default 72-hour expiration
+ * const token = await accessTokenForBackground("did:ethr:0x...");
+ *
+ * // Generate token with custom expiration (24 hours)
+ * const token24h = await accessTokenForBackground("did:ethr:0x...", 24 * 60);
+ * ```
+ *
+ * @see {@link accessToken} For short-lived tokens (1 minute) for regular API requests
+ * @see {@link createEndorserJwtForDid} For JWT creation implementation
+ */
+export const accessTokenForBackground = async (
+  did?: string,
+  expirationMinutes?: number,
+): Promise<string> => {
+  if (!did) {
+    return "";
+  }
+
+  // Use provided expiration or default to 72 hours (4320 minutes)
+  // This allows background prefetch operations to work offline for extended periods
+  const expirationSeconds = expirationMinutes
+    ? expirationMinutes * 60
+    : 72 * 60 * 60; // Default 72 hours
+
+  const nowEpoch = Math.floor(Date.now() / 1000);
+  const endEpoch = nowEpoch + expirationSeconds;
+  const tokenPayload = { exp: endEpoch, iat: nowEpoch, iss: did };
+  return createEndorserJwtForDid(did, tokenPayload);
+};
+
 /**
  * Extract JWT from various URL formats
  * @param jwtUrlText The URL containing the JWT

src/services/AbsurdSqlDatabaseService.ts

@@ -21,8 +21,14 @@ import IndexedDBBackend from "absurd-sql/dist/indexeddb-backend";
 import { runMigrations } from "../db-sql/migration";
 import type { DatabaseService, QueryExecResult } from "../interfaces/database";
 import { logger } from "@/utils/logger";
-import { OperationQueue, QueueExecutor } from "./platforms/OperationQueue";
-import { QueuedOperation } from "./platforms/types";
+
+interface QueuedOperation {
+  type: "run" | "query";
+  sql: string;
+  params: unknown[];
+  resolve: (value: unknown) => void;
+  reject: (reason: unknown) => void;
+}
 
 interface AbsurdSqlDatabase {
   exec: (sql: string, params?: unknown[]) => Promise<QueryExecResult[]>;
@@ -37,7 +43,8 @@ class AbsurdSqlDatabaseService implements DatabaseService {
   private db: AbsurdSqlDatabase | null;
   private initialized: boolean;
   private initializationPromise: Promise<void> | null = null;
-  private operationQueue = new OperationQueue<AbsurdSqlDatabase>();
+  private operationQueue: Array<QueuedOperation> = [];
+  private isProcessingQueue: boolean = false;
 
   private constructor() {
     this.db = null;
@@ -154,30 +161,42 @@ class AbsurdSqlDatabaseService implements DatabaseService {
     this.processQueue();
   }
 
-  /**
-   * Create executor adapter for AbsurdSQL API
-   */
-  private createExecutor(): QueueExecutor<AbsurdSqlDatabase> {
-    return {
-      executeRun: async (db, sql, params) => {
-        return await db.run(sql, params);
-      },
-      executeQuery: async (db, sql, params) => {
-        return await db.exec(sql, params);
-      },
-    };
-  }
-
   private async processQueue(): Promise<void> {
-    if (!this.initialized || !this.db) {
+    if (this.isProcessingQueue || !this.initialized || !this.db) {
       return;
     }
 
-    await this.operationQueue.processQueue(
-      this.db,
-      this.createExecutor(),
-      "AbsurdSqlDatabaseService",
-    );
+    this.isProcessingQueue = true;
+
+    while (this.operationQueue.length > 0) {
+      const operation = this.operationQueue.shift();
+      if (!operation) continue;
+
+      try {
+        let result: unknown;
+        switch (operation.type) {
+          case "run":
+            result = await this.db.run(operation.sql, operation.params);
+            break;
+          case "query":
+            result = await this.db.exec(operation.sql, operation.params);
+            break;
+        }
+        operation.resolve(result);
+      } catch (error) {
+        logger.error(
+          "Error while processing SQL queue:",
+          error,
+          " ... for sql:",
+          operation.sql,
+          " ... with params:",
+          operation.params,
+        );
+        operation.reject(error);
+      }
+    }
+
+    this.isProcessingQueue = false;
   }
 
   private async queueOperation<R>(
@@ -185,24 +204,21 @@ class AbsurdSqlDatabaseService implements DatabaseService {
     sql: string,
     params: unknown[] = [],
   ): Promise<R> {
-    const operation: QueuedOperation = {
-      type,
-      sql,
-      params,
-      resolve: (_value: unknown) => {
-        // No-op, will be wrapped by OperationQueue
-      },
-      reject: () => {
-        // No-op, will be wrapped by OperationQueue
-      },
-    };
+    return new Promise<R>((resolve, reject) => {
+      const operation: QueuedOperation = {
+        type,
+        sql,
+        params,
+        resolve: (value: unknown) => resolve(value as R),
+        reject,
+      };
+      this.operationQueue.push(operation);
 
-    return this.operationQueue.queueOperation<R>(
-      operation,
-      this.initialized,
-      this.db,
-      () => this.processQueue(),
-    );
+      // If we're already initialized, start processing the queue
+      if (this.initialized && this.db) {
+        this.processQueue();
+      }
+    });
   }
 
   private async waitForInitialization(): Promise<void> {

src/services/PlatformService.ts

@@ -32,6 +32,68 @@ export interface PlatformCapabilities {
   isNativeApp: boolean;
 }
 
+/**
+ * Permission status for notifications
+ */
+export interface PermissionStatus {
+  /** Notification permission status */
+  notifications: "granted" | "denied" | "prompt";
+  /** Exact alarms permission status (Android only) */
+  exactAlarms?: "granted" | "denied" | "prompt";
+}
+
+/**
+ * Result of permission request
+ */
+export interface PermissionResult {
+  /** Whether notification permission was granted */
+  notifications: boolean;
+  /** Whether exact alarms permission was granted (Android only) */
+  exactAlarms?: boolean;
+}
+
+/**
+ * Status of scheduled daily notifications
+ */
+export interface NotificationStatus {
+  /** Whether a notification is currently scheduled */
+  isScheduled: boolean;
+  /** Scheduled time in "HH:mm" format (24-hour) */
+  scheduledTime?: string;
+  /** Last time the notification was triggered (ISO string) */
+  lastTriggered?: string;
+  /** Current permission status */
+  permissions: PermissionStatus;
+}
+
+/**
+ * Options for scheduling a daily notification
+ */
+export interface ScheduleOptions {
+  /** Time in "HH:mm" format (24-hour) in local time */
+  time: string;
+  /** Notification title */
+  title: string;
+  /** Notification body text */
+  body: string;
+  /** Whether to play sound (default: true) */
+  sound?: boolean;
+  /** Notification priority */
+  priority?: "high" | "normal" | "low";
+}
+
+/**
+ * Configuration for native fetcher background operations
+ */
+export interface NativeFetcherConfig {
+  /** API server URL */
+  apiServer: string;
+  /** JWT token for authentication */
+  jwt: string;
+  /** Array of starred plan handle IDs */
+  starredPlanHandleIds: string[];
+}
+
 /**
  * Platform-agnostic interface for handling platform-specific operations.
  * Provides a common API for file system operations, camera interactions,
@@ -209,6 +271,58 @@ export interface PlatformService {
    */
   retrieveSettingsForActiveAccount(): Promise<Record<string, unknown> | null>;
 
+  // Daily notification operations
+  /**
+   * Get the status of scheduled daily notifications
+   * @returns Promise resolving to notification status, or null if not supported
+   */
+  getDailyNotificationStatus(): Promise<NotificationStatus | null>;
+
+  /**
+   * Check notification permissions
+   * @returns Promise resolving to permission status, or null if not supported
+   */
+  checkNotificationPermissions(): Promise<PermissionStatus | null>;
+
+  /**
+   * Request notification permissions
+   * @returns Promise resolving to permission result, or null if not supported
+   */
+  requestNotificationPermissions(): Promise<PermissionResult | null>;
+
+  /**
+   * Schedule a daily notification
+   * @param options - Notification scheduling options
+   * @returns Promise that resolves when scheduled, or rejects if not supported
+   */
+  scheduleDailyNotification(options: ScheduleOptions): Promise<void>;
+
+  /**
+   * Cancel scheduled daily notification
+   * @returns Promise that resolves when cancelled, or rejects if not supported
+   */
+  cancelDailyNotification(): Promise<void>;
+
+  /**
+   * Configure native fetcher for background operations
+   * @param config - Native fetcher configuration
+   * @returns Promise that resolves when configured, or null if not supported
+   */
+  configureNativeFetcher(config: NativeFetcherConfig): Promise<void | null>;
+
+  /**
+   * Update starred plans for background fetcher
+   * @param plans - Starred plan IDs
+   * @returns Promise that resolves when updated, or null if not supported
+   */
+  updateStarredPlans(plans: { planIds: string[] }): Promise<void | null>;
+
+  /**
+   * Open the app's notification settings in the system settings
+   * @returns Promise that resolves when the settings page is opened, or null if not supported
+   */
+  openAppNotificationSettings(): Promise<void | null>;
+
   // --- PWA/Web-only methods (optional, only implemented on web) ---
   /**
    * Registers the service worker for PWA support (web only)

src/services/PlatformServiceFactory.ts

@@ -4,144 +4,76 @@ import { CapacitorPlatformService } from "./platforms/CapacitorPlatformService";
 import { ElectronPlatformService } from "./platforms/ElectronPlatformService";
 
 /**
- * HMR-safe global singleton storage for PlatformService
+ * Factory class for creating platform-specific service implementations.
+ * Implements the Singleton pattern to ensure only one instance of PlatformService exists.
  *
- * Uses multiple fallbacks to ensure persistence across module reloads:
- * 1. globalThis (standard, works in most environments)
- * 2. window (browser fallback)
- * 3. self (web worker fallback)
- */
-declare global {
-  // eslint-disable-next-line no-var
-  var __PLATFORM_SERVICE_SINGLETON__: PlatformService | undefined;
-}
-
-/**
- * Get the global object for singleton storage
- * Uses multiple fallbacks to ensure compatibility
- */
-function getGlobal(): typeof globalThis {
-  if (typeof globalThis !== "undefined") return globalThis;
-  if (typeof window !== "undefined") return window as typeof globalThis;
-  if (typeof self !== "undefined") return self as typeof globalThis;
-  // Fallback for Node.js environments
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  return {} as any;
-}
-
-/**
- * Factory function to create platform-specific service implementation
- *
- * Uses console.log instead of logger to avoid circular dependency
- * (logger imports PlatformServiceFactory)
- */
-function create(): PlatformService {
-  const which = import.meta.env?.VITE_PLATFORM ?? "web";
-
-  if (which === "capacitor") return new CapacitorPlatformService();
-  if (which === "electron") return new ElectronPlatformService();
-  return new WebPlatformService();
-}
-
-/**
- * Get or create the HMR-safe singleton instance of PlatformService
- *
- * Uses lazy initialization to avoid circular dependency issues at module load time.
- */
-function getPlatformSvc(): PlatformService {
-  const global = getGlobal();
-
-  const exists = global.__PLATFORM_SERVICE_SINGLETON__ !== undefined;
-
-  if (!exists) {
-    global.__PLATFORM_SERVICE_SINGLETON__ = create();
-    // Verify it was stored
-    if (!global.__PLATFORM_SERVICE_SINGLETON__) {
-      // eslint-disable-next-line no-console
-      console.error(
-        "[PlatformServiceFactory] ERROR: Singleton creation failed - storage returned undefined",
-      );
-    }
-  }
-
-  // Type guard: ensure singleton exists (should never be undefined at this point)
-  const singleton = global.__PLATFORM_SERVICE_SINGLETON__;
-  if (!singleton) {
-    // eslint-disable-next-line no-console
-    console.error(
-      "[PlatformServiceFactory] CRITICAL: Singleton is undefined after creation/retrieval",
-    );
-    // Fallback: create a new one
-    global.__PLATFORM_SERVICE_SINGLETON__ = create();
-    return global.__PLATFORM_SERVICE_SINGLETON__;
-  }
-
-  return singleton;
-}
-
-/**
- * HMR-safe singleton instance of PlatformService
- *
- * This is the ONLY way to access PlatformService throughout the application.
- * Do not create new instances of platform services directly.
- *
- * Uses lazy initialization via Proxy to avoid circular dependency issues at module load time.
+ * The factory determines which platform implementation to use based on the VITE_PLATFORM
+ * environment variable. Supported platforms are:
+ * - capacitor: Mobile platform using Capacitor
+ * - electron: Desktop platform using Electron with Capacitor
+ * - web: Default web platform (fallback)
  *
  * @example
  * ```typescript
- * import { PlatformSvc } from "./services/PlatformServiceFactory";
- * await PlatformSvc.takePicture();
+ * const platformService = PlatformServiceFactory.getInstance();
+ * await platformService.takePicture();
  * ```
  */
-export const PlatformSvc = new Proxy({} as PlatformService, {
-  get(_target, prop) {
-    const svc = getPlatformSvc();
-    const value = (svc as unknown as Record<string, unknown>)[prop as string];
-    // Bind methods to maintain 'this' context
-    if (typeof value === "function") {
-      return value.bind(svc);
-    }
-    return value;
-  },
-});
-
-// Preserve singleton across Vite HMR
-if (import.meta?.hot) {
-  import.meta.hot.accept(() => {
-    // Don't recreate on HMR - keep existing instance
-    const global = getGlobal();
-    if (!global.__PLATFORM_SERVICE_SINGLETON__) {
-      // Restore singleton if it was lost during HMR
-      global.__PLATFORM_SERVICE_SINGLETON__ = getPlatformSvc();
-    }
-  });
-  import.meta.hot.dispose(() => {
-    // Don't delete - keep the global instance
-    // The singleton will persist in globalThis/window/self
-  });
-}
-
-/**
- * Legacy factory class for backward compatibility
- * @deprecated Use `PlatformSvc` directly instead
- */
 export class PlatformServiceFactory {
+  private static instance: PlatformService | null = null;
+  private static callCount = 0; // Debug counter
+  private static creationLogged = false; // Only log creation once
+
   /**
-   * Gets the singleton instance of PlatformService.
-   * @deprecated Use `PlatformSvc` directly instead
+   * Gets or creates the singleton instance of PlatformService.
+   * Creates the appropriate platform-specific implementation based on environment.
+   *
+   * @returns {PlatformService} The singleton instance of PlatformService
    */
   public static getInstance(): PlatformService {
-    return PlatformSvc;
+    PlatformServiceFactory.callCount++;
+
+    if (PlatformServiceFactory.instance) {
+      // Normal case - return existing instance silently
+      return PlatformServiceFactory.instance;
+    }
+
+    // Only log when actually creating the instance
+    const platform = process.env.VITE_PLATFORM || "web";
+
+    if (!PlatformServiceFactory.creationLogged) {
+      // Use console for critical startup message to avoid circular dependency
+      // eslint-disable-next-line no-console
+      console.log(
+        `[PlatformServiceFactory] Creating singleton instance for platform: ${platform}`,
+      );
+      PlatformServiceFactory.creationLogged = true;
+    }
+
+    switch (platform) {
+      case "capacitor":
+        PlatformServiceFactory.instance = new CapacitorPlatformService();
+        break;
+      case "electron":
+        // Use a specialized electron service that extends CapacitorPlatformService
+        PlatformServiceFactory.instance = new ElectronPlatformService();
+        break;
+      case "web":
+      default:
+        PlatformServiceFactory.instance = new WebPlatformService();
+        break;
+    }
+
+    return PlatformServiceFactory.instance;
   }
 
   /**
    * Debug method to check singleton usage stats
    */
   public static getStats(): { callCount: number; instanceExists: boolean } {
-    const global = getGlobal();
     return {
-      callCount: 0, // Deprecated - no longer tracking
-      instanceExists: global.__PLATFORM_SERVICE_SINGLETON__ !== undefined,
+      callCount: PlatformServiceFactory.callCount,
+      instanceExists: PlatformServiceFactory.instance !== null,
     };
   }
 }

src/services/platforms/ElectronPlatformService.ts

@@ -22,6 +22,13 @@
 
 import { CapacitorPlatformService } from "./CapacitorPlatformService";
 import { logger } from "../../utils/logger";
+import {
+  NotificationStatus,
+  PermissionStatus,
+  PermissionResult,
+  ScheduleOptions,
+  NativeFetcherConfig,
+} from "../PlatformService";
 
 /**
  * Electron-specific platform service implementation.
@@ -166,4 +173,88 @@ export class ElectronPlatformService extends CapacitorPlatformService {
 
   // --- PWA/Web-only methods (no-op for Electron) ---
   public registerServiceWorker(): void {}
+
+  // Daily notification operations
+  // Override CapacitorPlatformService methods to return null/throw errors
+  // since Electron doesn't support native daily notifications
+
+  /**
+   * Get the status of scheduled daily notifications
+   * @see PlatformService.getDailyNotificationStatus
+   * @returns null - notifications not supported on Electron platform
+   */
+  async getDailyNotificationStatus(): Promise<NotificationStatus | null> {
+    return null;
+  }
+
+  /**
+   * Check notification permissions
+   * @see PlatformService.checkNotificationPermissions
+   * @returns null - notifications not supported on Electron platform
+   */
+  async checkNotificationPermissions(): Promise<PermissionStatus | null> {
+    return null;
+  }
+
+  /**
+   * Request notification permissions
+   * @see PlatformService.requestNotificationPermissions
+   * @returns null - notifications not supported on Electron platform
+   */
+  async requestNotificationPermissions(): Promise<PermissionResult | null> {
+    return null;
+  }
+
+  /**
+   * Schedule a daily notification
+   * @see PlatformService.scheduleDailyNotification
+   * @throws Error - notifications not supported on Electron platform
+   */
+  async scheduleDailyNotification(_options: ScheduleOptions): Promise<void> {
+    throw new Error(
+      "Daily notifications are not supported on Electron platform",
+    );
+  }
+
+  /**
+   * Cancel scheduled daily notification
+   * @see PlatformService.cancelDailyNotification
+   * @throws Error - notifications not supported on Electron platform
+   */
+  async cancelDailyNotification(): Promise<void> {
+    throw new Error(
+      "Daily notifications are not supported on Electron platform",
+    );
+  }
+
+  /**
+   * Configure native fetcher for background operations
+   * @see PlatformService.configureNativeFetcher
+   * @returns null - native fetcher not supported on Electron platform
+   */
+  async configureNativeFetcher(
+    _config: NativeFetcherConfig,
+  ): Promise<void | null> {
+    return null;
+  }
+
+  /**
+   * Update starred plans for background fetcher
+   * @see PlatformService.updateStarredPlans
+   * @returns null - native fetcher not supported on Electron platform
+   */
+  async updateStarredPlans(_plans: {
+    planIds: string[];
+  }): Promise<void | null> {
+    return null;
+  }
+
+  /**
+   * Open the app's notification settings in the system settings
+   * @see PlatformService.openAppNotificationSettings
+   * @returns null - not supported on Electron platform
+   */
+  async openAppNotificationSettings(): Promise<void | null> {
+    return null;
+  }
 }

src/services/platforms/OperationQueue.ts

@@ -1,135 +0,0 @@
-/**
- * Shared operation queue handler for database services
- *
- * Provides a reusable queue mechanism for database operations that need to
- * wait for initialization before execution.
- */
-
-import { QueuedOperation } from "./types";
-import { logger } from "../../utils/logger";
-
-export interface QueueExecutor<TDb> {
-  executeRun(db: TDb, sql: string, params: unknown[]): Promise<unknown>;
-  executeQuery(db: TDb, sql: string, params: unknown[]): Promise<unknown>;
-  executeRawQuery?(db: TDb, sql: string, params: unknown[]): Promise<unknown>;
-}
-
-export class OperationQueue<TDb> {
-  private operationQueue: Array<QueuedOperation> = [];
-  private isProcessingQueue: boolean = false;
-
-  /**
-   * Process queued operations
-   */
-  async processQueue(
-    db: TDb,
-    executor: QueueExecutor<TDb>,
-    serviceName: string,
-  ): Promise<void> {
-    if (this.isProcessingQueue || !db) {
-      return;
-    }
-
-    this.isProcessingQueue = true;
-
-    while (this.operationQueue.length > 0) {
-      const operation = this.operationQueue.shift();
-      if (!operation) continue;
-
-      try {
-        let result: unknown;
-        switch (operation.type) {
-          case "run":
-            result = await executor.executeRun(
-              db,
-              operation.sql,
-              operation.params,
-            );
-            break;
-          case "query":
-            result = await executor.executeQuery(
-              db,
-              operation.sql,
-              operation.params,
-            );
-            break;
-          case "rawQuery":
-            if (executor.executeRawQuery) {
-              result = await executor.executeRawQuery(
-                db,
-                operation.sql,
-                operation.params,
-              );
-            } else {
-              // Fallback to query if rawQuery not supported
-              result = await executor.executeQuery(
-                db,
-                operation.sql,
-                operation.params,
-              );
-            }
-            break;
-        }
-        operation.resolve(result);
-      } catch (error) {
-        logger.error(
-          `[${serviceName}] Error while processing SQL queue:`,
-          error,
-        );
-        logger.error(
-          `[${serviceName}] Failed operation - Type: ${operation.type}, SQL: ${operation.sql}`,
-        );
-        logger.error(
-          `[${serviceName}] Failed operation - Params:`,
-          operation.params,
-        );
-        operation.reject(error);
-      }
-    }
-
-    this.isProcessingQueue = false;
-  }
-
-  /**
-   * Queue an operation for later execution
-   *
-   * @param operation - Pre-constructed operation object (allows platform-specific parameter conversion)
-   * @param initialized - Whether the database is initialized
-   * @param db - Database connection (if available)
-   * @param onQueue - Callback to trigger queue processing
-   */
-  queueOperation<R>(
-    operation: QueuedOperation,
-    initialized: boolean,
-    db: TDb | null,
-    onQueue: () => void,
-  ): Promise<R> {
-    return new Promise<R>((resolve, reject) => {
-      // Wrap the operation's resolve/reject to match our Promise
-      const wrappedOperation: QueuedOperation = {
-        ...operation,
-        resolve: (value: unknown) => {
-          operation.resolve(value);
-          resolve(value as R);
-        },
-        reject: (reason: unknown) => {
-          operation.reject(reason);
-          reject(reason);
-        },
-      };
-      this.operationQueue.push(wrappedOperation);
-
-      // If already initialized, trigger queue processing
-      if (initialized && db) {
-        onQueue();
-      }
-    });
-  }
-
-  /**
-   * Get current queue length (for debugging)
-   */
-  getQueueLength(): number {
-    return this.operationQueue.length;
-  }
-}

src/services/platforms/WebPlatformService.ts

@@ -2,6 +2,11 @@ import {
   ImageResult,
   PlatformService,
   PlatformCapabilities,
+  NotificationStatus,
+  PermissionStatus,
+  PermissionResult,
+  ScheduleOptions,
+  NativeFetcherConfig,
 } from "../PlatformService";
 import { logger } from "../../utils/logger";
 import { QueryExecResult } from "@/interfaces/database";
@@ -677,4 +682,81 @@ export class WebPlatformService
   // generateInsertStatement, updateDefaultSettings, updateActiveDid,
   // getActiveIdentity, insertNewDidIntoSettings, updateDidSpecificSettings,
   // retrieveSettingsForActiveAccount are all inherited from BaseDatabaseService
+
+  // Daily notification operations
+  /**
+   * Get the status of scheduled daily notifications
+   * @see PlatformService.getDailyNotificationStatus
+   * @returns null - notifications not supported on web platform
+   */
+  async getDailyNotificationStatus(): Promise<NotificationStatus | null> {
+    return null;
+  }
+
+  /**
+   * Check notification permissions
+   * @see PlatformService.checkNotificationPermissions
+   * @returns null - notifications not supported on web platform
+   */
+  async checkNotificationPermissions(): Promise<PermissionStatus | null> {
+    return null;
+  }
+
+  /**
+   * Request notification permissions
+   * @see PlatformService.requestNotificationPermissions
+   * @returns null - notifications not supported on web platform
+   */
+  async requestNotificationPermissions(): Promise<PermissionResult | null> {
+    return null;
+  }
+
+  /**
+   * Schedule a daily notification
+   * @see PlatformService.scheduleDailyNotification
+   * @throws Error - notifications not supported on web platform
+   */
+  async scheduleDailyNotification(_options: ScheduleOptions): Promise<void> {
+    throw new Error("Daily notifications are not supported on web platform");
+  }
+
+  /**
+   * Cancel scheduled daily notification
+   * @see PlatformService.cancelDailyNotification
+   * @throws Error - notifications not supported on web platform
+   */
+  async cancelDailyNotification(): Promise<void> {
+    throw new Error("Daily notifications are not supported on web platform");
+  }
+
+  /**
+   * Configure native fetcher for background operations
+   * @see PlatformService.configureNativeFetcher
+   * @returns null - native fetcher not supported on web platform
+   */
+  async configureNativeFetcher(
+    _config: NativeFetcherConfig,
+  ): Promise<void | null> {
+    return null;
+  }
+
+  /**
+   * Update starred plans for background fetcher
+   * @see PlatformService.updateStarredPlans
+   * @returns null - native fetcher not supported on web platform
+   */
+  async updateStarredPlans(_plans: {
+    planIds: string[];
+  }): Promise<void | null> {
+    return null;
+  }
+
+  /**
+   * Open the app's notification settings in the system settings
+   * @see PlatformService.openAppNotificationSettings
+   * @returns null - not supported on web platform
+   */
+  async openAppNotificationSettings(): Promise<void | null> {
+    return null;
+  }
 }

src/services/platforms/sqlite.ts

@@ -1,20 +0,0 @@
-/**
- * Shared SQLite connection manager for Capacitor platform
- *
- * Ensures only one SQLiteConnection instance exists across the application,
- * preventing connection desync issues and unnecessary connection recreation.
- */
-
-import { CapacitorSQLite, SQLiteConnection } from "@capacitor-community/sqlite";
-
-/**
- * Native Capacitor SQLite plugin instance
- * This is the bridge to the native SQLite implementation
- */
-export const CAP_SQLITE = CapacitorSQLite;
-
-/**
- * Shared SQLite connection manager
- * Use this instance throughout the application - do not create new SQLiteConnection instances
- */
-export const SQLITE = new SQLiteConnection(CAP_SQLITE);

src/services/platforms/types.ts

@@ -1,13 +0,0 @@
-/**
- * Types for platform services
- */
-
-export interface QueuedOperation {
-  type: "run" | "query" | "rawQuery";
-  sql: string;
-  params: unknown[];
-  resolve: (value: unknown) => void;
-  reject: (reason: unknown) => void;
-}
-
-export type QueuedOperationType = QueuedOperation["type"];

src/utils/seedPhraseReminder.ts

@@ -1,5 +1,4 @@
 import { NotificationIface } from "@/constants/app";
-import router from "@/router";
 
 const SEED_REMINDER_KEY = "seedPhraseReminderLastShown";
 const REMINDER_COOLDOWN_MS = 24 * 60 * 60 * 1000; // 24 hours in milliseconds
@@ -54,8 +53,8 @@ export function createSeedReminderNotification(): NotificationIface {
     yesText: "Backup Identifier Seed",
     noText: "Remind me Later",
     onYes: async () => {
-      // Navigate to seed backup page using SPA routing
-      await router.push({ path: "/seed-backup" });
+      // Navigate to seed backup page
+      window.location.href = "/seed-backup";
     },
     onNo: async () => {
       // Mark as shown so it won't appear again for 24 hours

src/views/AccountViewView.vue

@@ -161,6 +161,9 @@
     </section>
     <PushNotificationPermission ref="pushNotificationPermission" />
 
+    <!-- Daily Notifications (Native) -->
+    <DailyNotificationSection />
+
     <!-- User Profile -->
     <section
       v-if="isRegistered"
@@ -790,6 +793,7 @@ import IdentitySection from "@/components/IdentitySection.vue";
 import RegistrationNotice from "@/components/RegistrationNotice.vue";
 import LocationSearchSection from "@/components/LocationSearchSection.vue";
 import UsageLimitsSection from "@/components/UsageLimitsSection.vue";
+import DailyNotificationSection from "@/components/notifications/DailyNotificationSection.vue";
 import {
   AppString,
   DEFAULT_IMAGE_API_SERVER,
@@ -858,6 +862,7 @@ interface UserNameDialogRef {
     RegistrationNotice,
     LocationSearchSection,
     UsageLimitsSection,
+    DailyNotificationSection,
   },
   mixins: [PlatformServiceMixin],
 })

src/views/DeepLinkRedirectView.vue

@@ -157,27 +157,11 @@ export default class DeepLinkRedirectView extends Vue {
     }
 
     try {
-      const capabilities = this.platformService.getCapabilities();
-
-      // If we're already in the native app, use router navigation instead
-      // of window.location.href (which doesn't work properly in Capacitor)
-      if (capabilities.isNativeApp) {
-        // Navigate directly using the router
-        const destinationPath = `/${this.destinationUrl}`;
-        this.$router.push(destinationPath).catch((error) => {
-          logger.error("Router navigation failed: " + errorStringForLog(error));
-          this.pageError =
-            "Unable to navigate to the destination. Please use a manual option below.";
-        });
-        return;
-      }
-
-      // For web contexts, use window.location.href to redirect to app
       // For mobile, try the deep link URL; for desktop, use the web URL
       const redirectUrl = this.isMobile ? this.deepLinkUrl : this.webUrl;
 
       // Method 1: Try window.location.href (works on most browsers)
-      window.location.href = redirectUrl; // Do not use this on native apps! The channel to Capacitor gets messed up.
+      window.location.href = redirectUrl;
 
       // Method 2: Fallback - create and click a link element
       setTimeout(() => {

vite.config.capacitor.mts

@@ -1,4 +1,21 @@
 import { defineConfig } from "vite";
 import { createBuildConfig } from "./vite.config.common.mts";
 
-export default defineConfig(async () => createBuildConfig('capacitor')); 
+export default defineConfig(async () => {
+  const baseConfig = await createBuildConfig('capacitor');
+
+  return {
+    ...baseConfig,
+    build: {
+      ...baseConfig.build,
+      rollupOptions: {
+        ...baseConfig.build?.rollupOptions,
+        // Note: @timesafari/daily-notification-plugin is NOT externalized
+        // because it needs to be bundled for dynamic imports to work in Capacitor WebView
+        output: {
+          ...baseConfig.build?.rollupOptions?.output,
+        }
+      }
+    }
+  };
+});