Add: Full inventory sync without Steam 10-day restriction

Created inventorySync.js that:
- Fetches FULL CS2 inventory using authenticated Steam API
- No 10-day restriction (user is logged in to their own account)
- Filters CS2 skins only (excludes cases, stickers, etc.)
- Sends inventory to backend /api/inventory/sync endpoint
- Shows success/error notifications
- Can be triggered via window.CS2SyncInventory()

This allows users to import ALL their inventory items, including
items purchased less than 10 days ago, WITHOUT needing SteamAuth.

Next steps:
- Add script to manifest.json
- Create backend /api/inventory/sync endpoint
- Add sync button to extension popup

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: rainerstudios

src/inventorySync.js

@@ -0,0 +1,286 @@
+// Steam Inventory Sync - Fetch full inventory and send to backend
+(() => {
+    'use strict';
+
+    const InventorySyncer = {
+        initialized: false,
+        syncing: false,
+
+        log(...args) {
+            console.log('[CS2 Inventory Sync]', ...args);
+        },
+
+        init() {
+            if (this.initialized) return;
+            this.initialized = true;
+
+            this.log('Initializing inventory syncer...');
+
+            // Listen for sync triggers from popup/content script
+            window.addEventListener('message', (event) => {
+                if (event.data && event.data.type === 'CS2_SYNC_INVENTORY') {
+                    this.log('📨 Received sync inventory request');
+                    this.syncInventory();
+                }
+            });
+
+            // Also expose global function for manual triggers
+            window.CS2SyncInventory = () => this.syncInventory();
+
+            this.log('✅ Inventory syncer initialized');
+        },
+
+        async syncInventory() {
+            if (this.syncing) {
+                this.log('⏸️ Sync already in progress, skipping...');
+                return {
+                    success: false,
+                    error: 'Sync already in progress'
+                };
+            }
+
+            this.syncing = true;
+            this.log('🔄 Starting inventory sync...');
+
+            try {
+                // Step 1: Get Steam ID
+                const steamId = await this.getSteamId();
+                if (!steamId) {
+                    throw new Error('Could not determine Steam ID');
+                }
+
+                this.log(`✅ Steam ID: ${steamId}`);
+
+                // Step 2: Fetch CS2 inventory
+                const inventory = await this.fetchCS2Inventory(steamId);
+                this.log(`✅ Fetched ${inventory.length} CS2 items`);
+
+                // Step 3: Send to backend
+                const result = await this.sendToBackend(inventory, steamId);
+                this.log('✅ Sync complete:', result);
+
+                // Notify user
+                this.showNotification('success', `Synced ${inventory.length} items`);
+
+                return {
+                    success: true,
+                    itemCount: inventory.length,
+                    result
+                };
+
+            } catch (error) {
+                this.log('❌ Sync failed:', error);
+                this.showNotification('error', error.message);
+
+                return {
+                    success: false,
+                    error: error.message
+                };
+            } finally {
+                this.syncing = false;
+            }
+        },
+
+        async getSteamId() {
+            // Try to get from g_steamID global
+            if (typeof g_steamID !== 'undefined' && g_steamID) {
+                return g_steamID;
+            }
+
+            // Try to parse from page URL (e.g., /profiles/76561199094452064)
+            const urlMatch = window.location.pathname.match(/\/profiles\/(\d+)/);
+            if (urlMatch) {
+                return urlMatch[1];
+            }
+
+            // Try to get from profile data
+            if (typeof UserYou !== 'undefined' && UserYou?.strSteamId) {
+                return UserYou.strSteamId;
+            }
+
+            return null;
+        },
+
+        async fetchCS2Inventory(steamId) {
+            this.log('📡 Fetching CS2 inventory from Steam...');
+
+            // Steam Inventory API - authenticated endpoint (no 10-day restriction!)
+            const url = `https://steamcommunity.com/inventory/${steamId}/730/2?l=english&count=5000`;
+
+            const response = await fetch(url, {
+                credentials: 'include', // Important: includes auth cookies
+                headers: {
+                    'Accept': 'application/json'
+                }
+            });
+
+            if (!response.ok) {
+                throw new Error(`Steam API returned ${response.status}`);
+            }
+
+            const data = await response.json();
+
+            if (!data.assets || !data.descriptions) {
+                throw new Error('Invalid inventory response from Steam');
+            }
+
+            this.log(`📦 Raw inventory: ${data.assets.length} assets, ${data.descriptions.length} descriptions`);
+
+            // Map assets to descriptions
+            const inventory = data.assets.map(asset => {
+                // Find matching description
+                const desc = data.descriptions.find(d =>
+                    d.classid === asset.classid &&
+                    d.instanceid === asset.instanceid
+                );
+
+                if (!desc) return null;
+
+                // Only include skins with float values (exclude cases, stickers, etc.)
+                if (!this.isCS2Skin(desc.market_hash_name)) {
+                    return null;
+                }
+
+                return {
+                    assetid: asset.assetid,
+                    classid: asset.classid,
+                    instanceid: asset.instanceid,
+                    amount: asset.amount,
+                    name: desc.name,
+                    market_hash_name: desc.market_hash_name,
+                    type: desc.type,
+                    icon_url: desc.icon_url,
+                    tradable: desc.tradable ? 1 : 0,
+                    marketable: desc.marketable ? 1 : 0,
+                    commodity: desc.commodity ? 1 : 0,
+                    market_actions: desc.market_actions,
+                    descriptions: desc.descriptions,
+                    tags: desc.tags
+                };
+            }).filter(item => item !== null);
+
+            return inventory;
+        },
+
+        isCS2Skin(marketHashName) {
+            if (!marketHashName) return false;
+
+            const conditions = [
+                'Factory New',
+                'Minimal Wear',
+                'Field-Tested',
+                'Well-Worn',
+                'Battle-Scarred'
+            ];
+
+            return conditions.some(condition => marketHashName.includes(condition));
+        },
+
+        async sendToBackend(inventory, steamId) {
+            this.log('📤 Sending inventory to backend...');
+
+            // Get backend URL from storage or use default
+            const backendUrl = await this.getBackendUrl();
+
+            const payload = {
+                steamId: steamId,
+                inventory: inventory,
+                timestamp: new Date().toISOString(),
+                appId: 730,
+                contextId: 2
+            };
+
+            this.log(`📤 Sending ${inventory.length} items to ${backendUrl}`);
+
+            const response = await fetch(`${backendUrl}/api/inventory/sync`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify(payload),
+                credentials: 'include' // Include session cookies
+            });
+
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`Backend returned ${response.status}: ${errorText}`);
+            }
+
+            const result = await response.json();
+            return result;
+        },
+
+        async getBackendUrl() {
+            // Try to get from chrome storage
+            if (typeof chrome !== 'undefined' && chrome.storage) {
+                return new Promise((resolve) => {
+                    chrome.storage.sync.get(['backendUrl'], (result) => {
+                        resolve(result.backendUrl || 'https://steamledger.com');
+                    });
+                });
+            }
+
+            return 'https://steamledger.com';
+        },
+
+        showNotification(type, message) {
+            // Create a toast notification
+            const notification = document.createElement('div');
+            notification.style.cssText = `
+                position: fixed;
+                top: 20px;
+                right: 20px;
+                background: ${type === 'success' ? '#4CAF50' : '#f44336'};
+                color: white;
+                padding: 16px 24px;
+                border-radius: 4px;
+                font-family: Arial, sans-serif;
+                font-size: 14px;
+                z-index: 999999;
+                box-shadow: 0 4px 12px rgba(0,0,0,0.3);
+                animation: slideIn 0.3s ease;
+            `;
+
+            notification.innerHTML = `
+                <strong>CS2 Inventory Sync</strong><br/>
+                ${message}
+            `;
+
+            // Add slide-in animation
+            const style = document.createElement('style');
+            style.textContent = `
+                @keyframes slideIn {
+                    from {
+                        transform: translateX(400px);
+                        opacity: 0;
+                    }
+                    to {
+                        transform: translateX(0);
+                        opacity: 1;
+                    }
+                }
+            `;
+            document.head.appendChild(style);
+
+            document.body.appendChild(notification);
+
+            // Remove after 3 seconds
+            setTimeout(() => {
+                notification.style.animation = 'slideIn 0.3s ease reverse';
+                setTimeout(() => notification.remove(), 300);
+            }, 3000);
+        }
+    };
+
+    // Initialize when script loads
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', () => InventorySyncer.init());
+    } else {
+        InventorySyncer.init();
+    }
+
+    // Expose for debugging
+    window.InventorySyncer = InventorySyncer;
+
+    console.log('🔄 CS2 Inventory Sync Script Loaded!', new Date().toLocaleTimeString());
+})();