feat(core): implement customizable block duration with smart session lock

- Add block duration global setting (15m to 24h) in the dashboard UI.
- Replace dynamic reset intervals with an immutable `NEXT_RESET_KEY` in `SessionStorage`.
- Implement a smart gatekeeper in `StorageFacade` to prevent time-travel bypass during active blocks.
- Add localized i18n keys and values for the new duration options.

Author: YazanAmmar

src/core/storage/index.ts

@@ -37,6 +37,14 @@ class StorageFacade {
     return false;
   }
 
+  public async isAnyPlatformBlocked(): Promise<boolean> {
+    const platforms: PlatformId[] = ['youtube_shorts', 'youtube_watch', 'instagram', 'global'];
+    for (const p of platforms) {
+      if (await this.isCurrentlyBlocked(p)) return true;
+    }
+    return false;
+  }
+
   async resetGlobalSettings() {
     return this.settings.resetGlobalSettings();
   }
@@ -111,6 +119,21 @@ class StorageFacade {
     return this.settings.setTrackingMode(mode);
   }
 
+  async getBlockDuration() {
+    return this.settings.getBlockDuration();
+  }
+
+  async setBlockDuration(minutes: number) {
+    await this.settings.setBlockDuration(minutes);
+
+    const isAnyBlocked = await this.isAnyPlatformBlocked();
+    if (!isAnyBlocked) {
+      const lastReset = (await this.driver.get<number>('limitra_last_reset')) || Date.now();
+      const newNextReset = lastReset + minutes * 60 * 1000;
+      await this.driver.set('limitra_next_reset', newNextReset);
+    }
+  }
+
   // Analytics
   async getCount(platform: PlatformId) {
     return this.stats.getCount(platform);

src/core/storage/session.ts

@@ -1,25 +1,45 @@
 import { StorageDriver } from './driver';
 import { StatsStorage } from './stats';
 import { PlatformId } from '../../types';
+import { DEFAULT_GLOBAL_SETTINGS } from './settings';
 
 const LAST_RESET_KEY = 'limitra_last_reset';
-const RESET_INTERVAL_MS = 6 * 60 * 60 * 1000; // 6 hours
+const NEXT_RESET_KEY = 'limitra_next_reset';
 
 export class SessionStorage {
   constructor(
     private driver: StorageDriver,
     private stats: StatsStorage,
   ) {}
 
+  private async getDurationMs(): Promise<number> {
+    const mins =
+      (await this.driver.get<number>('limitra_block_duration')) ??
+      DEFAULT_GLOBAL_SETTINGS.blockDuration;
+    return mins * 60 * 1000;
+  }
+
   async ensureSession(platforms: PlatformId[]): Promise<boolean> {
     const lastReset = await this.driver.get<number>(LAST_RESET_KEY);
+    let nextReset = await this.driver.get<number>(NEXT_RESET_KEY);
     const now = Date.now();
-    if (!lastReset || now - lastReset >= RESET_INTERVAL_MS) {
+
+    if (!nextReset && lastReset) {
+      const intervalMs = await this.getDurationMs();
+      nextReset = lastReset + intervalMs;
+      await this.driver.set(NEXT_RESET_KEY, nextReset);
+    }
+
+    if (!lastReset || !nextReset || now >= nextReset) {
       for (const platform of platforms) {
         await this.stats.resetCount(platform);
         await this.stats.setTimeSpent(platform, 0);
       }
+
+      const intervalMs = await this.getDurationMs();
       await this.driver.set<number>(LAST_RESET_KEY, now);
+      await this.driver.set<number>(NEXT_RESET_KEY, now + intervalMs);
+
       return true;
     }
     return false;
@@ -41,7 +61,11 @@ export class SessionStorage {
   }
 
   async getNextResetTime(): Promise<number> {
+    const nextReset = await this.driver.get<number>(NEXT_RESET_KEY);
+    if (nextReset) return nextReset;
+
     const lastReset = (await this.driver.get<number>(LAST_RESET_KEY)) || Date.now();
-    return lastReset + RESET_INTERVAL_MS;
+    const intervalMs = await this.getDurationMs();
+    return lastReset + intervalMs;
   }
 }

src/core/storage/settings.ts

@@ -6,6 +6,7 @@ export const DEFAULT_GLOBAL_SETTINGS = {
   theme: 'auto',
   quoteTone: 'random',
   trackingMode: 'strict',
+  blockDuration: 180, // 3 hours
 };
 
 export class SettingsStorage {
@@ -16,6 +17,7 @@ export class SettingsStorage {
     await this.setTheme(DEFAULT_GLOBAL_SETTINGS.theme);
     await this.setQuoteTone(DEFAULT_GLOBAL_SETTINGS.quoteTone);
     await this.setTrackingMode(DEFAULT_GLOBAL_SETTINGS.trackingMode);
+    await this.setBlockDuration(DEFAULT_GLOBAL_SETTINGS.blockDuration);
   }
 
   // General settings
@@ -47,6 +49,17 @@ export class SettingsStorage {
     await this.driver.set('limitra_tracking_mode', mode);
   }
 
+  async getBlockDuration(): Promise<number> {
+    return (
+      (await this.driver.get<number>('limitra_block_duration')) ??
+      DEFAULT_GLOBAL_SETTINGS.blockDuration
+    );
+  }
+
+  async setBlockDuration(minutes: number): Promise<void> {
+    await this.driver.set('limitra_block_duration', minutes);
+  }
+
   // Platform-specific settings
   async getLimit(platform: PlatformId): Promise<number> {
     return (await this.driver.get<number>(`limitra_${platform}_limit`)) ?? 0;

src/i18n/locales/ar.ts

@@ -60,6 +60,14 @@ const ar: LocaleStrings = {
     cancelBtn: 'إلغاء',
     resettingBtn: 'جاري الاستعادة...',
     modalBadgeWarning: 'تحذير',
+    blockDurationLabel: 'مدة الحظر',
+    descBlockDuration: 'حدد المدة التي ستبقى فيها المنصة محظورة بعد تجاوز الحد المسموح.',
+    duration15m: '15 دقيقة',
+    duration1h: 'ساعة واحدة',
+    duration3h: '3 ساعات',
+    duration6h: '6 ساعات',
+    duration12h: '12 ساعة',
+    duration24h: '24 ساعة',
   },
   tones: {
     random: 'عشوائي',

src/i18n/locales/en.ts

@@ -62,6 +62,14 @@ const en: LocaleStrings = {
     cancelBtn: 'Cancel',
     resettingBtn: 'Resetting...',
     modalBadgeWarning: 'WARNING',
+    blockDurationLabel: 'Block Duration',
+    descBlockDuration: 'Select how long a platform remains blocked after reaching the limit.',
+    duration15m: '15 Minutes',
+    duration1h: '1 Hour',
+    duration3h: '3 Hours',
+    duration6h: '6 Hours',
+    duration12h: '12 Hours',
+    duration24h: '24 Hours',
   },
   tones: {
     random: 'Random',

src/i18n/types.ts

@@ -59,6 +59,14 @@ export interface LocaleStrings {
     cancelBtn: string;
     resettingBtn: string;
     modalBadgeWarning: string;
+    blockDurationLabel: string;
+    descBlockDuration: string;
+    duration15m: string;
+    duration1h: string;
+    duration3h: string;
+    duration6h: string;
+    duration12h: string;
+    duration24h: string;
   };
   tones: {
     random: string;

src/ui/settings/index.html

@@ -134,6 +134,25 @@ <h5 class="setting-title" id="lbl-dash-tracking">Tracking Mode</h5>
                     </select>
                   </div>
                 </div>
+
+                <div class="setting-item">
+                  <div class="setting-info">
+                    <h5 class="setting-title" id="lbl-dash-duration">Block Duration</h5>
+                    <p class="setting-desc" id="desc-dash-duration">
+                      Select how long a platform remains blocked after reaching the limit.
+                    </p>
+                  </div>
+                  <div class="setting-control">
+                    <select id="dash-duration" class="brutal-select">
+                      <option value="15" id="opt-dur-15m">15 Minutes</option>
+                      <option value="60" id="opt-dur-1h">1 Hour</option>
+                      <option value="180" id="opt-dur-3h">3 Hours</option>
+                      <option value="360" id="opt-dur-6h">6 Hours</option>
+                      <option value="720" id="opt-dur-12h">12 Hours</option>
+                      <option value="1440" id="opt-dur-24h">24 Hours</option>
+                    </select>
+                  </div>
+                </div>
               </div>
             </div>
 

src/ui/settings/index.ts

@@ -62,6 +62,16 @@ function updateUITexts() {
     'group-customization': t.dashboard.groupCustomization,
     'group-security': t.dashboard.groupSecurity,
 
+    // Block Duration
+    'lbl-dash-duration': t.dashboard.blockDurationLabel,
+    'desc-dash-duration': t.dashboard.descBlockDuration,
+    'opt-dur-15m': t.dashboard.duration15m,
+    'opt-dur-1h': t.dashboard.duration1h,
+    'opt-dur-3h': t.dashboard.duration3h,
+    'opt-dur-6h': t.dashboard.duration6h,
+    'opt-dur-12h': t.dashboard.duration12h,
+    'opt-dur-24h': t.dashboard.duration24h,
+
     // Data
     'group-data': t.dashboard.groupData,
     'lbl-dash-reset': t.dashboard.resetTitle,
@@ -169,6 +179,13 @@ async function init() {
     await storage.setQuoteTone(target.value);
   });
 
+  const dashDurationInput = document.getElementById('dash-duration') as HTMLSelectElement;
+  dashDurationInput.value = String(await storage.getBlockDuration());
+  dashDurationInput.addEventListener('change', async (event) => {
+    const target = event.target as HTMLSelectElement;
+    await storage.setBlockDuration(Number(target.value));
+  });
+
   const btnResetSettings = document.getElementById('btn-reset-settings') as HTMLButtonElement;
   if (btnResetSettings) {
     btnResetSettings.addEventListener('click', async () => {
@@ -220,6 +237,9 @@ async function init() {
           updateTrackingDescription(currentTracking);
         });
       }
+      if (changes['limitra_block_duration']) {
+        dashDurationInput.value = String(changes['limitra_block_duration'].newValue);
+      }
       if (changes['limitra_quote_tone']) {
         dashToneInput.value = String(changes['limitra_quote_tone'].newValue);
       }