Merge pull request #65 from BambooFury/feat/free-weekend

Feat/free weekend

Author: BambooFury

.github/workflows/release-please.yml

@@ -11,9 +11,57 @@ permissions:
 jobs:
   release-please:
     runs-on: ubuntu-latest
+    outputs:
+      release_created: ${{ steps.release.outputs.release_created }}
+      tag_name: ${{ steps.release.outputs.tag_name }}
     steps:
       - uses: googleapis/release-please-action@v4
+        id: release
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
           config-file: release-please-config.json
           manifest-file: .release-please-manifest.json
+
+  build-asset:
+    needs: release-please
+    if: ${{ needs.release-please.outputs.release_created == 'true' }}
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ needs.release-please.outputs.tag_name }}
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Build plugin
+        run: npm run build
+
+      - name: Stage release files
+        run: |
+          mkdir -p _release/auto-claim
+          cp plugin.json _release/auto-claim/
+          cp README.md _release/auto-claim/
+          cp LICENSE _release/auto-claim/
+          cp -r backend _release/auto-claim/
+          cp -r .millennium _release/auto-claim/
+
+      - name: Create zip archive
+        run: |
+          cd _release
+          zip -r "../auto-claim-${{ needs.release-please.outputs.tag_name }}.zip" auto-claim
+
+      - name: Upload to release
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: ${{ needs.release-please.outputs.tag_name }}
+          files: auto-claim-*.zip
+          token: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -11,5 +11,6 @@ settings.json
 widget_settings.json
 pending_toasts.json
 claim_inflight.json
+free_weekend_cache.json
 
 webkit/_assets.generated.ts

backend/main.lua

@@ -186,6 +186,7 @@ local SETTINGS_FILE     = PLUGIN_DIR .. "\\settings.json"
 local WIDGETS_FILE      = PLUGIN_DIR .. "\\widget_settings.json"
 local CACHE_FILE        = PLUGIN_DIR .. "\\free_games_cache.json"
 local TOASTS_FILE       = PLUGIN_DIR .. "\\pending_toasts.json"
+local WEEKEND_FILE      = PLUGIN_DIR .. "\\free_weekend_cache.json"
 local CLAIM_LOCK_FILE   = PLUGIN_DIR .. "\\claim_inflight.json"
 local CLAIM_LOCK_TTL    = 60
 
@@ -329,6 +330,17 @@ function save_free_games_cache_ipc(data)
     return 1
 end
 
+function load_free_weekend_cache_ipc()
+    return read_file(WEEKEND_FILE) or "[]"
+end
+
+function save_free_weekend_cache_ipc(data)
+    local payload = extract_payload(data)
+    if not _is_valid_json_payload(payload, "array") then return 0 end
+    write_file(WEEKEND_FILE, payload)
+    return 1
+end
+
 
 local _CURL_MAX_BYTES = 8 * 1024 * 1024
 local _CURL_TIMEOUT_S = 15

frontend/index.tsx

@@ -3,6 +3,7 @@ import React, { useState, useEffect, useCallback } from 'react';
 import { SettingsTab, WidgetSettings } from './settings';
 import { MIN_POLL_INTERVAL_MIN } from './constants';
 import { runScan } from './scanner';
+import { scanFreeWeekend, WeekendGame } from './scanner/freeweekend';
 type Empty = [];
 type StrIn = [{ payload: string }];
 
@@ -12,6 +13,8 @@ const loadSettings      = callable<Empty, string>('load_settings_ipc');
 const _logPluginIPC     = callable<StrIn, number>('log_plugin');
 const saveFreeGamesCache = callable<StrIn, number>('save_free_games_cache_ipc');
 const loadFreeGamesCache = callable<Empty, string>('load_free_games_cache_ipc');
+const saveFreeWeekendCache = callable<StrIn, number>('save_free_weekend_cache_ipc');
+const loadFreeWeekendCache = callable<Empty, string>('load_free_weekend_cache_ipc');
 const _loadWidgetIPC    = callable<Empty, string>('load_widget_settings_ipc');
 const _saveWidgetIPC    = callable<StrIn, number>('save_widget_settings_ipc');
 const popToasts         = callable<Empty, string>('pop_toasts_ipc');
@@ -476,7 +479,7 @@ async function startPolling(): Promise<void> {
       const wRaw = await withTimeout(_loadWidgetIPC(), 1000, '');
       if (wRaw) {
         const w = JSON.parse(wRaw);
-        if (w && (w.filterMode === 'all' || w.filterMode === 'games')) {
+          if (w && (w.filterMode === 'all' || w.filterMode === 'games' || w.filterMode === 'weekend')) {
           cachedWidgetFilterMode = w.filterMode;
           return;
         }
@@ -618,6 +621,68 @@ async function startPolling(): Promise<void> {
       log(`processGame error for ${game.name}: ${String(e)}`);
     }
   }
+  
+  function showWeekendNotification(game: WeekendGame): void {
+    const untilStr = new Date(game.until * 1000)
+      .toLocaleDateString('en-US', { month: 'short', day: 'numeric' });
+    toaster.toast({
+      title: 'Free Weekend!',
+      body:  `${game.name} is free to play until ${untilStr}.`,
+      logo: React.createElement('img', {
+        src: `https://cdn.akamai.steamstatic.com/steam/apps/${game.appid}/header.jpg`,
+        style: { width: '40px', height: '40px', objectFit: 'cover', borderRadius: '4px' },
+      }),
+      onClick: () => { (window as any).SteamClient?.Apps?.ShowStore?.(game.appid, 0); },
+      duration:  12000,
+      sound:     1,
+      playSound: true,
+      showToast: true,
+    });
+  }
+
+  async function runWeekendScan(): Promise<void> {
+    try {
+      const result = await scanFreeWeekend({ info: (m) => log(m), warn: (m) => log(m) });
+      if (!result) {
+        log('Weekend scan failed — keeping previous list');
+        return;
+      }
+
+      let prev: WeekendGame[] = [];
+      try {
+        prev = JSON.parse(await withTimeout(loadFreeWeekendCache(), 3000, '[]') || '[]');
+      } catch {}
+      const prevIds = new Set(prev.map((g) => g.appid));
+
+      const nowSec = Date.now() / 1000;
+      const merged = [...result];
+      for (const p of prev) {
+        if (p.until > nowSec && !merged.some((g) => g.appid === p.appid)) merged.push(p);
+      }
+
+      try {
+        await withTimeout(saveFreeWeekendCache({ payload: JSON.stringify(merged) }), 3000, 0);
+      } catch {}
+      log(`Weekend scan complete — ${merged.length} game(s) playable for free`);
+      
+      let notify = true;
+      try {
+        const sraw = await withTimeout(loadSettings(), 2000, '');
+        if (sraw) notify = ({ ...DEFAULTS, ...JSON.parse(sraw) } as Settings).notifyOnGrab;
+      } catch {}
+      if (!notify) return;
+      
+      for (const g of result) {
+        if (prevIds.has(g.appid)) continue;
+        if (isAlreadyInLibrary(g.appid)) continue;
+        log(`Free weekend detected: ${g.name} (${g.appid})`);
+        showWeekendNotification(g);
+        await new Promise((r) => setTimeout(r, 1500));
+      }
+    } catch (e) {
+      log(`runWeekendScan error: ${String(e)}`);
+    }
+  }
 
   async function runOneScan(): Promise<boolean> {
     await reloadState();
@@ -737,6 +802,15 @@ async function startPolling(): Promise<void> {
   }
 
   await triggerScan('initial');
+  const WEEKEND_SCAN_INTERVAL_MS = 6 * 60 * 60 * 1000;
+  let lastWeekendScanMs = Date.now();
+  void runWeekendScan();
+  _trackInterval(() => {
+    if (Date.now() - lastWeekendScanMs >= WEEKEND_SCAN_INTERVAL_MS) {
+      lastWeekendScanMs = Date.now();
+      void runWeekendScan();
+    }
+  }, 10 * 60 * 1000);
 
   const pollManualScanRequest = async () => {
     const manualRequestedAt = await consumeManualScanRequest();

frontend/scanner/freeweekend.ts

@@ -0,0 +1,107 @@
+import { callable } from '@steambrew/client';
+import type { ScannerLogger } from './types';
+import { safeFetch, safeParse } from './http';
+
+const fetchUrlViaCurl = callable<[{ payload: string }], string>('fetch_url_via_curl_ipc');
+
+const QUERY_URL = 'https://api.steampowered.com/IStoreQueryService/Query/v1/?input_json=';
+const PAGE_SIZE = 1000;
+const MAX_PAGES = 30;
+
+export interface WeekendGame {
+  appid: number;
+  name:  string;
+  type:  'weekend';
+  until: number;
+}
+
+interface QueryStoreItem {
+  appid?: number;
+  name?:  string;
+  free_weekend?: { start_time?: number; end_time?: number };
+}
+
+interface QueryResponse {
+  response?: {
+    metadata?:    { total_matching_records?: number };
+    store_items?: QueryStoreItem[];
+  };
+}
+
+function buildPageUrl(start: number): string {
+  const input = {
+    query: {
+      start,
+      count: PAGE_SIZE,
+      filters: {
+        type_filters:  { include_apps: true },
+        price_filters: { min_discount_percent: 1 },
+      },
+    },
+    context:      { language: 'english', country_code: 'US' },
+    data_request: {},
+  };
+  return QUERY_URL + encodeURIComponent(JSON.stringify(input));
+}
+
+async function fetchPage(url: string, log?: ScannerLogger): Promise<string | null> {
+  const res = await safeFetch(url, 30000, log);
+  if (res && res.status === 200 && res.body) return res.body;
+
+  try {
+    const body = await fetchUrlViaCurl({ payload: url });
+    return body || null;
+  } catch (e: any) {
+    log?.warn(`[weekend] curl IPC threw: ${e?.message || e}`);
+    return null;
+  }
+}
+
+export async function scanFreeWeekend(log?: ScannerLogger): Promise<WeekendGame[] | null> {
+  const found: WeekendGame[] = [];
+  const seen  = new Set<number>();
+  const now   = Date.now() / 1000;
+
+  let start = 0;
+  let total = Infinity;
+
+  for (let page = 0; page < MAX_PAGES && start < total; page++) {
+    const body = await fetchPage(buildPageUrl(start), log);
+    if (!body) {
+      log?.warn(`[weekend] page ${page} unreachable — aborting weekend scan`);
+      return null;
+    }
+
+    const data = safeParse<QueryResponse>(body, log, `(weekend page ${page})`);
+    if (!data || !data.response) return null;
+
+    const items = Array.isArray(data.response.store_items) ? data.response.store_items : [];
+    const meta  = data.response.metadata;
+    if (meta && typeof meta.total_matching_records === 'number') {
+      total = meta.total_matching_records;
+    }
+
+    for (const it of items) {
+      const appid = typeof it.appid === 'number' ? it.appid : 0;
+      const fw    = it.free_weekend;
+      if (!appid || !fw || seen.has(appid)) continue;
+
+      const until = typeof fw.end_time === 'number' ? fw.end_time : 0;
+      if (until <= now) continue;
+
+      seen.add(appid);
+      found.push({
+        appid,
+        name: typeof it.name === 'string' && it.name ? it.name : 'AppID ' + appid,
+        type: 'weekend',
+        until,
+      });
+    }
+
+    if (items.length === 0) break;
+    start += items.length;
+  }
+
+  log?.info(`[weekend] scan ok — ${found.length} free-weekend game(s)`);
+  return found;
+}

webkit/ipc.ts

@@ -5,18 +5,13 @@ type Empty = [];
 
 export const loadPluginSettingsIPC = callable<Empty, string>('load_settings_ipc');
 export const savePluginSettingsIPC = callable<StrIn, number>('save_settings_ipc');
-
 export const loadWidgetSettingsIPC = callable<Empty, string>('load_widget_settings_ipc');
 export const saveWidgetSettingsIPC = callable<StrIn, number>('save_widget_settings_ipc');
-
 export const loadFreeGamesCacheIPC = callable<Empty, string>('load_free_games_cache_ipc');
+export const loadFreeWeekendCacheIPC = callable<Empty, string>('load_free_weekend_cache_ipc');
 export const loadGrabbedIPC        = callable<Empty, string>('load_grabbed_ipc');
-
 export const pushToastIPC = callable<StrIn, number>('push_toast_ipc');
-
 export const logIPC = callable<StrIn, number>('log_plugin');
-
-
 export const tryAcquireClaimLockIPC = callable<StrIn, number>('try_acquire_claim_lock_ipc');
 export const releaseClaimLockIPC    = callable<StrIn, number>('release_claim_lock_ipc');
 

webkit/settings.ts

@@ -38,7 +38,7 @@ export let initialWidgetRaw = '';
 
 const VALID_PANEL_SIDES: PanelSide[]  = ['left', 'right'];
 const VALID_TAB_STYLES: TabStyle[]    = ['slim', 'large', 'floating'];
-const VALID_FILTER_MODES: FilterMode[] = ['games', 'all'];
+const VALID_FILTER_MODES: FilterMode[] = ['games', 'all', 'weekend'];
 
 function isPanelSide(v: any):  v is PanelSide  { return VALID_PANEL_SIDES.indexOf(v)  !== -1; }
 function isTabStyle(v: any):   v is TabStyle   { return VALID_TAB_STYLES.indexOf(v)   !== -1; }

webkit/types.ts

@@ -4,8 +4,9 @@ export type FreeGame = {
   type?: string;
   header?: string;
   capsule?: string;
+  until?: number;
 };
 
 export type PanelSide = 'left' | 'right';
 export type TabStyle  = 'slim' | 'large' | 'floating';
-export type FilterMode = 'games' | 'all';
+export type FilterMode = 'games' | 'all' | 'weekend';