dc-securex 2.5.3__tar.gz → 2.9.6__tar.gz

{dc_securex-2.5.3 → dc_securex-2.9.6}/CHANGELOG.md

@@ -1,5 +1,135 @@
 # Changelog
 
+## [2.9.6] - 2026-01-15
+
+### Fixed
+- **Instant Position Restoration**: The `restore_role` function now attempts to set the correct position immediately after creation as a fast-track fallback.
+- **Hierarchy Ground-Truth**: Re-added `fetch_member` to ensure the bot always uses its real-time rank when calculating legal position moves.
+
+## [2.9.5] - 2026-01-15
+
+### Fixed
+- **Cache-Sync Restoration**: Ensured that the in-memory backup cache is updated instantly after an ID swap.
+- This fixes issues where the repair logic would use stale role/channel IDs from memory even after the file was updated.
+
+## [2.9.3] - 2026-01-15
+
+### Fixed
+- **Exhaustive Structural Repair**: Maximized restoration success for role and channel positions.
+  - Implemented **Name-Based Fallback** (enables position repairs even before ID swaps propagate).
+  - Added **Strict Hierarchy Validation** (prevents illegal position edits and provides clear debug logging).
+  - Fixed a `SyntaxError` in `BackupManager` indentation from the previous build.
+
+## [2.9.2] - 2026-01-15
+
+### Fixed
+- **Atomic Structural Repair**: Fixed a critical race condition where rapid-fire role/channel restorations would lose their "Smart ID Swaps".
+  - Implemented **Per-Guild Async Locks** in `BackupManager` to synchronize all backup file read/write operations.
+  - Ensures that ID mapping updates are atomic and never overwritten during high-concurrency events (nukes).
+  - Enhanced role matching logic for more robust structural repairs.
+
+## [2.9.1] - 2026-01-15
+
+### Fixed
+- **Highly Robust Structural Repair**: Fixed issues where role positions were not updating due to cache staleness and rapid-fire events.
+  - Added **Async Locking and Debouncing** to repair methods (prevents rate limits and race conditions during mass deletions).
+  - Switched to Ground-Truth fetching (`fetch_roles` and `fetch_channels`) to bypass cache issues.
+  - Increased event-settling delay to 2 seconds for guaranteed position application.
+
+## [2.9.0] - 2026-01-15
+
+### Fixed
+- **Smart Role Restoration**: Restored roles now correctly have their positions updated.
+  - Implemented **Smart ID Swapping** for roles (ID mapping in backup).
+  - Enhanced `repair_role_structure` and `repair_channel_structure` with fresh cache fetching and event-settling delays.
+  - Ensures structural integrity is restored even when role IDs change.
+
+## [2.8.9] - 2026-01-15
+
+### Fixed
+- Final cleanup of monitor-to-event architecture.
+
+## [2.8.8] - 2026-01-15
+
+### Changed
+- **Pure Event-Driven Architecture**: Completely removed background polling loops (`ChannelPositionMonitor`, `RolePositionMonitor`).
+- **Integrated Structural Repairs**: Re-implemented the monitor's structural enforcement logic directly into `BackupManager` as `repair_channel_structure` and `repair_role_structure`.
+- **Instant Response**: Structural repairs are now triggered reactively by event handlers (deletion/update) instead of waiting for a 300ms loop.
+- **Zero Idle Overhead**: No background tasks are running during idle periods, saving CPU and API quota.
+
+## [2.8.7] - 2026-01-15
+
+### Improved
+- **Reactive Structural Repairs**: Event handlers now instantly trigger the monitor's `_check_guild_roles` and `_check_guild_channels` logic after restoration.
+  - Fixes issues where role/channel positions were not updated fast enough by the background loop.
+  - Combines the speed of event-driven repairs with the robustness of background monitoring.
+
+## [2.8.6] - 2026-01-15
+
+### Fixed
+- **Restored Background Monitoring**: Re-implemented `ChannelPositionMonitor` and `RolePositionMonitor` (300ms polling) to ensure 100% structural integrity during rapid nukes.
+- **Coordination Logic**: Re-added `processing_channel_deletions` to prevent race conditions between handlers and monitors.
+
+## [2.8.5] - 2026-01-14
+
+### Changed
+- **Major Architecture Refactor**: This version supercedes all previous 2.x releases.
+- **Removed Monitors**: Background polling loops (`ChannelPositionMonitor`, `RolePositionMonitor`) are completely removed.
+- **Event-Driven Positioning**: Position restoration and structural repairs are now triggered directly by event handlers using bulk Discord APIs.
+- **Efficiency**: Near-zero idle overhead. Structural integrity is now maintained reactively.
+
+## [2.6.0] - 2026-01-14
+
+### New Features
+- **Full State Synchronization**: Authorized actions now instantly update the backup
+  - **Authorized Updates**: Manual channel edits (permissions, positions, names) by authorized users are now auto-updated in the backup.
+  - **Authorized Creations/Deletions**: Fully integrated in previous patches, now polished in 2.6.0.
+- **Improved Monitoring**: The Channel Monitor now perfectly coordinates with event handlers, eliminating race conditions for authorized actions.
+
+## [2.5.9] - 2026-01-14
+
+### New Features
+- **Auto-Backup for Authorized Creations**: When an authorized user creates a channel, it is immediately added to the backup
+  - Ensures the channel monitor knows about the new channel instantly
+  - Prevents any potential conflicts and keeps the backup up-to-date
+  - Compliments the Authorized Deletion fix from 2.5.8
+
+## [2.5.8] - 2026-01-14
+
+### Critical Fix
+- **Race Condition Solved**: Fixed issue where Monitor restored "authorized" deletions before Handler could verify them
+  - Implemented `processing_channel_deletions` coordination set
+  - Monitor now pauses restoration if a channel is currently being processed by the ChannelHandler
+  - Ensures Authorized Deletions are correctly removed from backup BEFORE Monitor acts
+
+## [2.5.7] - 2026-01-14
+
+### Hotfix
+- **Fixed Syntax Error**: Resolved indentation issue in `restore_channel` missing `except` block
+- Confirmed valid syntax for 2.5.6 features (Authorized Deletion Handling)
+
+## [2.5.6] - 2026-01-14
+
+### Critical Fix
+- **Authorized Deletion Handling**: Fixed issue where the monitor would restore channels deleted by authorized users
+  - When an authorized user deletes a channel, it is now explicitly removed from the backup
+  - This prevents the 300ms monitor from flagging it as "missing" and restoring it
+
+## [2.5.5] - 2026-01-14
+
+### Critical Fix
+- **Channel Restoration Spam Fix**: Implemented ID swapping in `restore_channel`
+  - When a channel is restored (getting a new ID), the backup file is instantly updated with the new ID
+  - Prevents the monitor from continuously detecting the old ID as "missing" and creating duplicates
+  - Essential for the self-healing monitor to work correctly
+
+## [2.5.4] - 2026-01-14
+
+### Fixed
+- **Startup Bug**: Fixed `ChannelPositionMonitor` not starting automatically
+  - Added `channel_position_monitoring` argument to `enable()` (defaults to True)
+  - Properly initializes the monitor loop on startup
+
 ## [2.5.3] - 2026-01-14
 
 ### Verified

{dc_securex-2.5.3 → dc_securex-2.9.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dc-securex
-Version: 2.5.3
+Version: 2.9.6
 Summary: Backend-only Discord anti-nuke protection SDK
 Home-page: https://github.com/yourusername/securex-antinuke-sdk
 Author: SecureX Team

{dc_securex-2.5.3 → dc_securex-2.9.6}/dc_securex.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dc-securex
-Version: 2.5.3
+Version: 2.9.6
 Summary: Backend-only Discord anti-nuke protection SDK
 Home-page: https://github.com/yourusername/securex-antinuke-sdk
 Author: SecureX Team

{dc_securex-2.5.3 → dc_securex-2.9.6}/dc_securex.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ LICENSE
 MANIFEST.in
 README.md
 pyproject.toml
+setup.cfg
 setup.py
 dc_securex.egg-info/PKG-INFO
 dc_securex.egg-info/SOURCES.txt
@@ -31,10 +32,8 @@ securex/backup/__pycache__/__init__.cpython-312.pyc
 securex/backup/__pycache__/manager.cpython-312.pyc
 securex/handlers/__init__.py
 securex/handlers/channel.py
-securex/handlers/channel_monitor.py
 securex/handlers/member.py
 securex/handlers/role.py
-securex/handlers/role_monitor.py
 securex/handlers/webhook.py
 securex/handlers/__pycache__/__init__.cpython-312.pyc
 securex/handlers/__pycache__/channel.cpython-312.pyc

{dc_securex-2.5.3 → dc_securex-2.9.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dc-securex"
-version = "2.5.3"
+version = "2.9.6"
 description = "Backend-only Discord anti-nuke protection SDK"
 readme = "README.md"
 requires-python = ">=3.8"

{dc_securex-2.5.3 → dc_securex-2.9.6}/securex/backup/manager.py

@@ -25,6 +25,13 @@ class BackupManager:
         self._role_cache: Dict[int, Dict] = {}     # {guild_id: role_backup_data}
         self._cache_loaded = False
         self._refresh_task = None
+        self._guild_locks: Dict[int, asyncio.Lock] = {}
+
+    def _get_guild_lock(self, guild_id: int) -> asyncio.Lock:
+        """Get or create an async lock for a specific guild"""
+        if guild_id not in self._guild_locks:
+            self._guild_locks[guild_id] = asyncio.Lock()
+        return self._guild_locks[guild_id]
     
     async def create_backup(self, guild_id: int) -> BackupInfo:
         """Create complete backup for a guild"""
@@ -167,8 +174,9 @@ class BackupManager:
             if not backup_file.exists():
                 return None
             
-            with open(backup_file, 'r') as f:
-                backup = json.load(f)
+            async with self._get_guild_lock(guild.id):
+                with open(backup_file, 'r') as f:
+                    backup = json.load(f)
             
             # Find channel in backup
             ch_data = None
@@ -245,12 +253,138 @@ class BackupManager:
                     except Exception as e:
                         print(f"Error restoring permission: {e}")
             
+            # CRITICAL: Update backup with NEW ID to prevent infinite restoration loop
+            # The monitor looks for IDs in the backup. If we don't update it,
+            # it will keep seeing the old ID as "missing" and restore it again.
+            try:
+                ch_data["id"] = new_channel.id
+                
+                # Update the ID in the backup list in memory
+                for i, ch in enumerate(backup["channels"]):
+                    if ch["id"] == target_id:
+                        backup["channels"][i] = ch_data
+                        break
+                
+                # Save backup file
+                async with self._get_guild_lock(guild.id):
+                    with open(backup_file, 'w') as f:
+                        json.dump(backup, f, indent=2)
+                    
+                    # Update in-memory cache
+                    self._channel_cache[guild.id] = backup
+            except Exception as e:
+                print(f"Error updating backup ID: {e}")
+
             return new_channel
             
         except Exception as e:
             print(f"Error restoring channel: {e}")
             return None
-    
+
+    async def remove_channel_from_backup(self, guild: discord.Guild, channel_id: int):
+        """Remove a channel from backup (used when authorized user deletes it)"""
+        try:
+            backup_file = self.backup_dir / f"channels_{guild.id}.json"
+            if not backup_file.exists():
+                return
+            
+            with open(backup_file, 'r') as f:
+                backup = json.load(f)
+            
+            # Remove channel with matching ID
+            original_len = len(backup["channels"])
+            backup["channels"] = [ch for ch in backup["channels"] if ch["id"] != channel_id]
+            
+            if len(backup["channels"]) < original_len:
+                # Save changes
+                with open(backup_file, 'w') as f:
+                    json.dump(backup, f, indent=2)
+                # print(f"✅ Removed authorized deletion from backup: {channel_id}")
+                
+        except Exception as e:
+            print(f"Error removing channel from backup: {e}")
+            
+    async def add_channel_to_backup(self, guild: discord.Guild, channel: discord.abc.GuildChannel):
+        """Add a new channel to backup (used when authorized user creates it)"""
+        try:
+            backup_file = self.backup_dir / f"channels_{guild.id}.json"
+            if not backup_file.exists():
+                return
+            
+            with open(backup_file, 'r') as f:
+                backup = json.load(f)
+            
+            # Create channel data object
+            ch_data = {
+                "id": channel.id,
+                "name": channel.name,
+                "type": str(channel.type),
+                "position": channel.position,
+                "category_id": channel.category_id if hasattr(channel, "category_id") else None
+            }
+            
+            # Add permissions
+            perms_data = {}
+            for target, overwrite in channel.overwrites.items():
+                perms_data[str(target.id)] = {
+                    "type": "role" if isinstance(target, discord.Role) else "member",
+                    "allow": overwrite.pair()[0].value,
+                    "deny": overwrite.pair()[1].value
+                }
+            if perms_data:
+                ch_data["permissions"] = perms_data
+
+            # Add to backup list
+            backup["channels"].append(ch_data)
+            
+            # Save changes
+            with open(backup_file, 'w') as f:
+                json.dump(backup, f, indent=2)
+            # print(f"✅ Added authorized creation to backup: {channel.name}")
+            
+        except Exception as e:
+            print(f"Error adding channel to backup: {e}")
+
+    async def update_channel_in_backup(self, guild: discord.Guild, channel: discord.abc.GuildChannel):
+        """Update channel in backup (used when authorized user updates it)"""
+        try:
+            backup_file = self.backup_dir / f"channels_{guild.id}.json"
+            if not backup_file.exists():
+                return
+            
+            with open(backup_file, 'r') as f:
+                backup = json.load(f)
+            
+            # Find and update channel
+            for i, ch_data in enumerate(backup["channels"]):
+                if ch_data["id"] == channel.id:
+                    # Update fields
+                    ch_data["name"] = channel.name
+                    ch_data["position"] = channel.position
+                    ch_data["category_id"] = channel.category_id if hasattr(channel, "category_id") else None
+                    
+                    # Update permissions
+                    perms_data = {}
+                    for target, overwrite in channel.overwrites.items():
+                        perms_data[str(target.id)] = {
+                            "type": "role" if isinstance(target, discord.Role) else "member",
+                            "allow": overwrite.pair()[0].value,
+                            "deny": overwrite.pair()[1].value
+                        }
+                    if perms_data:
+                        ch_data["permissions"] = perms_data
+                    
+                    backup["channels"][i] = ch_data
+                    break
+            
+            # Save changes
+            with open(backup_file, 'w') as f:
+                json.dump(backup, f, indent=2)
+            # print(f"✅ Updated authorized changes in backup: {channel.name}")
+            
+        except Exception as e:
+            print(f"Error updating channel in backup: {e}")
+
     async def restore_channel_permissions(self, guild: discord.Guild, channel_id: int) -> bool:
         """Restore channel permissions from backup"""
         try:
@@ -304,8 +438,9 @@ class BackupManager:
             if not backup_file.exists():
                 return False
             
-            with open(backup_file, 'r') as f:
-                backup = json.load(f)
+            async with self._get_guild_lock(guild.id):
+                with open(backup_file, 'r') as f:
+                    backup = json.load(f)
             
             # Find role in backup
             for role_data in backup["roles"]:
@@ -320,12 +455,41 @@ class BackupManager:
                         reason="SecureX: Restoring deleted role"
                     )
                     
-                    # Position will be corrected by RolePositionMonitor within 300ms
-                    print(f"✅ Restored role: {new_role.name} (position will be auto-corrected)")
+                    # Immediate Position Attempt (Optional/Safe fallback)
+                    try:
+                        me = await guild.fetch_member(self.bot.user.id)
+                        if role_data["position"] < me.top_role.position:
+                            await new_role.edit(position=role_data["position"], reason="SecureX: Immediate restoration")
+                            print(f"✅ Restored role: {new_role.name} at position {role_data['position']}")
+                        else:
+                            print(f"✅ Restored role: {new_role.name} (Position correction deferred to repair logic)")
+                    except Exception as e:
+                        print(f"✅ Restored role: {new_role.name} (Position error: {e})")
                     
-                    return True
+                    # SMART ID SWAP: Update backup file with the new ID
+                    try:
+                        async with self._get_guild_lock(guild.id):
+                            # Re-read to ensure we don't overwrite other parallel swaps
+                            with open(backup_file, 'r') as f:
+                                backup = json.load(f)
+                                
+                            role_data["id"] = new_role.id
+                            for i, r in enumerate(backup["roles"]):
+                                if r["name"] == new_role.name: # Robust matching
+                                    backup["roles"][i]["id"] = new_role.id
+                                    break
+                            
+                            with open(backup_file, 'w') as f:
+                                json.dump(backup, f, indent=2)
+                                
+                            # Update in-memory cache
+                            self._role_cache[guild.id] = backup
+                    except Exception as e:
+                        print(f"Error updating backup role ID: {e}")
+                    
+                    return new_role
             
-            return False
+            return None
             
         except Exception as e:
             print(f"Error restoring role: {e}")
@@ -362,7 +526,151 @@ class BackupManager:
         except Exception as e:
             print(f"Error restoring role permissions: {e}")
             return False
-    
+
+    async def repair_channel_structure(self, guild: discord.Guild):
+        """
+        Exhaustive channel structure repair with name-based fallback.
+        """
+        if self.sdk._repair_channel_lock.locked():
+            return 
+            
+        async with self.sdk._repair_channel_lock:
+            try:
+                await asyncio.sleep(2) # Debounce
+                
+                # Ground truth
+                channels = await guild.fetch_channels()
+                current_channels_by_id = {c.id: c for c in channels}
+                current_channels_by_name = {(type(c), c.name): c for c in channels}
+                
+                backup_file = self.backup_dir / f"channels_{guild.id}.json"
+                if not backup_file.exists(): return
+
+                async with self._get_guild_lock(guild.id):
+                    with open(backup_file, 'r') as f:
+                        backup = json.load(f)
+
+                positions_to_fix = {}
+                
+                for ch_data in backup["channels"]:
+                    channel = current_channels_by_id.get(ch_data["id"])
+                    
+                    # Name-based fallback (for just-restored channels whose ID mapping hasn't settled)
+                    if not channel:
+                        # Try matching by name and type
+                        for c in channels:
+                            if c.name == ch_data["name"] and ch_data["type"].lower() in str(type(c)).lower():
+                                channel = c
+                                break
+                    
+                    if not channel: continue
+
+                    # 1. Category Repair
+                    target_cat_id = ch_data.get("category_id")
+                    if target_cat_id:
+                        current_cat_id = channel.category.id if channel.category else None
+                        if current_cat_id != target_cat_id:
+                            target_cat = current_channels_by_id.get(target_cat_id)
+                            if target_cat and isinstance(target_cat, discord.CategoryChannel):
+                                try:
+                                    await channel.edit(category=target_cat, reason="SecureX: Structural Repair")
+                                except: pass
+
+                    # 2. Position Track
+                    if channel.position != ch_data["position"]:
+                        positions_to_fix[channel] = ch_data["position"]
+
+                    # 3. Permissions Repair
+                    if ch_data.get("permissions"):
+                        if len(channel.overwrites) != len(ch_data["permissions"]):
+                            await self.restore_channel_permissions(guild, channel.id)
+
+                if positions_to_fix:
+                    print(f"🔧 [Repair] Fixing {len(positions_to_fix)} channel positions in {guild.name}...")
+                    await guild.edit(positions=positions_to_fix, reason="SecureX: Structural Repair")
+
+            except Exception as e:
+                print(f"Error in exhaustive repair_channel_structure: {e}")
+
+    async def repair_role_structure(self, guild: discord.Guild):
+        """
+        Exhaustive role structure repair with name-based fallback and hierarchy checks.
+        """
+        if self.sdk._repair_role_lock.locked():
+            return
+
+        async with self.sdk._repair_role_lock:
+            try:
+                await asyncio.sleep(2) # Debounce
+                
+                roles = await guild.fetch_roles()
+                current_roles_by_id = {r.id: r for r in roles}
+                
+                backup_file = self.backup_dir / f"roles_{guild.id}.json"
+                if not backup_file.exists(): return
+
+                async with self._get_guild_lock(guild.id):
+                    with open(backup_file, 'r') as f:
+                        backup = json.load(f)
+
+                positions_to_fix = {}
+                # GROUND TRUTH: Force fetch member to get latest top_role
+                me = await guild.fetch_member(self.bot.user.id)
+                bot_top_role = me.top_role
+                
+                for role_data in backup["roles"]:
+                    role = current_roles_by_id.get(role_data["id"])
+                    
+                    # Name-based fallback
+                    if not role:
+                        for r in roles:
+                            if r.name == role_data["name"] and not r.is_default():
+                                role = r
+                                break
+                    
+                    if not role or role.is_default():
+                        continue
+                        
+                    # Check Hierarchy Power
+                    if role >= bot_top_role:
+                        # Log if we can't move it because but is too low
+                        # print(f"⚠️ Cannot repair role '{role.name}' - Bot hierarchy too low.")
+                        continue
+
+                    # 1. Permissions Fix
+                    if role.permissions.value != role_data["permissions"]:
+                        try:
+                            await role.edit(
+                                permissions=discord.Permissions(role_data["permissions"]),
+                                reason="SecureX: Structural Repair"
+                            )
+                        except: pass
+
+                    # 2. Position Track
+                    if role.position != role_data["position"]:
+                        # Double check we don't try to move it above the bot
+                        target_pos = role_data["position"]
+                        if target_pos < bot_top_role.position:
+                            positions_to_fix[role] = target_pos
+
+                if positions_to_fix:
+                    print(f"🔧 [Repair] Fixing {len(positions_to_fix)} role positions in {guild.name}...")
+                    try:
+                        await guild.edit_role_positions(
+                            positions=positions_to_fix, 
+                            reason="SecureX: Structural Repair"
+                        )
+                        print(f"✅ Successfully updated {len(positions_to_fix)} role positions.")
+                    except discord.Forbidden:
+                        print("❌ Failed to fix role positions: 403 Forbidden (Check bot permissions and hierarchy)")
+                    except Exception as e:
+                        print(f"❌ Error fixing role positions: {e}")
+
+            except Exception as e:
+                print(f"Error in exhaustive repair_role_structure: {e}")
+
+
+
     async def restore_category_children(self, guild: discord.Guild, old_category_id: int, new_category: discord.CategoryChannel):
         """
         Restore all child channels that belonged to a category.

{dc_securex-2.5.3 → dc_securex-2.9.6}/securex/client.py

@@ -11,8 +11,6 @@ from .handlers.channel import ChannelHandler
 from .handlers.role import RoleHandler
 from .handlers.member import MemberHandler
 from .handlers.webhook import WebhookHandler
-from .handlers.role_monitor import RolePositionMonitor
-from .handlers.channel_monitor import ChannelPositionMonitor
 from .utils.whitelist import WhitelistManager
 from .utils.punishment import PunishmentExecutor
 from .models import ThreatEvent, BackupInfo
@@ -107,8 +105,11 @@ class SecureX:
         self.role_handler = RoleHandler(self)
         self.member_handler = MemberHandler(self)
         self.webhook_handler = WebhookHandler(self)
-        self.role_monitor = RolePositionMonitor(self)
-        self.channel_monitor = ChannelPositionMonitor(self)
+        
+        # Track channels being processed to prevent event overlap logic
+        self.processing_channel_deletions = set()
+        self._repair_role_lock = asyncio.Lock()
+        self._repair_channel_lock = asyncio.Lock()
         
         # Register instant audit log event listener (v2.0) - for PUNISHMENT
         self._register_audit_log_listener()
@@ -410,7 +411,6 @@ class SecureX:
         guild_id: Optional[int] = None,
         whitelist: Optional[List[int]] = None,
         auto_backup: bool = True,
-        role_position_monitoring: bool = True,
         punishments: Optional[Dict[str, str]] = None,
         timeout_duration: int = 600,
         notify_user: bool = True
@@ -432,7 +432,6 @@ class SecureX:
         # Preload all caches into memory
         await self.whitelist.preload_all()
         await self.backup_manager.preload_all()
-        await self.role_monitor.preload_all()
         
         # Populate whitelist cache for instant O(1) lookups
         if guild_id:
@@ -467,10 +466,6 @@ class SecureX:
             # Start cache auto-refresh (every 10 minutes)
             self.backup_manager.start_auto_refresh()
         
-        if role_position_monitoring:
-            # Start role position monitoring
-            self.role_monitor.start()
-        
         self.timeout_duration = timeout_duration
         self.notify_punished_user = notify_user
         

{dc_securex-2.5.3 → dc_securex-2.9.6}/securex/handlers/channel.py

@@ -45,6 +45,10 @@ class ChannelHandler:
                             pass
                         except Exception as e:
                             print(f"Error deleting channel: {e}")
+                    else:
+                        print(f"✅ Authorized creation detected: #{channel.name}")
+                        # CRITICAL: Add to backup immediately so Monitor knows about it
+                        await self.backup_manager.add_channel_to_backup(guild, channel)
                     break
                     
         except Exception as e:
@@ -54,6 +58,10 @@ class ChannelHandler:
     async def on_channel_delete(self, channel: discord.abc.GuildChannel):
         """Detect and restore unauthorized channel deletion"""
         try:
+            # COORDINATION: Inform the monitor we are processing this channel
+            # This prevents the monitor from attempting a restore until we check audit logs
+            self.sdk.processing_channel_deletions.add(channel.id)
+            
             guild = channel.guild
             print(f"🔍 Channel deleted: {channel.name} (ID: {channel.id})")
             await asyncio.sleep(1)
@@ -71,6 +79,10 @@ class ChannelHandler:
                         # Restore the channel (returns new channel object or None)
                         new_channel = await self.backup_manager.restore_channel(guild, channel)
                         
+                        # Use the backup manager logic to restore structure immediately
+                        if new_channel:
+                            await self.backup_manager.repair_channel_structure(guild)
+                        
                         if new_channel:
                             print(f"✅ Restored: {new_channel.name}")
                             
@@ -83,11 +95,19 @@ class ChannelHandler:
                             print(f"❌ Failed to restore channel: {channel.name} (not found in backup?)")
                     else:
                         print(f"⏭️ Skipping restoration - user is authorized")
+                        # CRITICAL: Remove from backup so Monitor doesn't restore it
+                        await self.backup_manager.remove_channel_from_backup(guild, channel.id)
                     break
                 else:
                     print(f"⚠️ Audit entry target mismatch: {entry.target.id} != {channel.id}")
+                    
         except Exception as e:
             print(f"Error in channel_delete handler: {e}")
+        finally:
+            # Always remove from processing set
+            if hasattr(self.sdk, 'processing_channel_deletions'):
+                self.sdk.processing_channel_deletions.discard(channel.id)
+
     
     async def on_channel_update(self, before: discord.abc.GuildChannel, after: discord.abc.GuildChannel):
         """Detect unauthorized channel updates"""
@@ -108,6 +128,10 @@ class ChannelHandler:
                             # Restore channel permissions
                             restored = await self.backup_manager.restore_channel_permissions(guild, after.id)
                             
+                            # Use the backup manager logic to restore structure immediately
+                            if restored:
+                                await self.backup_manager.repair_channel_structure(guild)
+                            
                             # Create threat event
                             threat = ThreatEvent(
                                 type="channel_update",
@@ -122,6 +146,10 @@ class ChannelHandler:
                             
                             # Trigger callback
                             await self.sdk._trigger_callbacks('threat_detected', threat)
+                        else:
+                            # Authorized update - Update backup!
+                            print(f"✅ Authorized update detected: #{after.name}")
+                            await self.backup_manager.update_channel_in_backup(guild, after)
                         break
         except Exception as e:
             print(f"Error in channel_update handler: {e}")

{dc_securex-2.5.3 → dc_securex-2.9.6}/securex/handlers/role.py

@@ -62,6 +62,10 @@ class RoleHandler:
                         # Restore role from backup
                         restored = await self.backup_manager.restore_role(guild, role.id)
                         
+                        # Use the backup manager logic to restore structure immediately
+                        if restored:
+                            await self.backup_manager.repair_role_structure(guild)
+                        
                         threat = ThreatEvent(
                             type="role_delete",
                             guild_id=guild.id,
@@ -94,6 +98,10 @@ class RoleHandler:
                             # Restore role to backup state
                             restored = await self.backup_manager.restore_role_permissions(guild, after.id)
                             
+                            # Use the backup manager logic to restore structure immediately
+                            if restored:
+                                await self.backup_manager.repair_role_structure(guild)
+                            
                             threat = ThreatEvent(
                                 type="role_update",
                                 guild_id=guild.id,

{dc_securex-2.5.3 → dc_securex-2.9.6}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="dc-securex",
-    version="2.5.3",
+    version="2.9.6",
     author="SecureX Team",
     author_email="contact@securex.dev",
     description="Backend-only Discord anti-nuke protection SDK - Build your own UI!",

dc_securex-2.5.3/securex/handlers/channel_monitor.py

@@ -1,128 +0,0 @@
-"""
-Channel position and permission monitoring - background task.
-"""
-import discord
-import asyncio
-import json
-from pathlib import Path
-from typing import List, Tuple, Dict, Any, Union
-
-class ChannelPositionMonitor:
-    """
-    Background monitor that checks and restores channel positions, permissions,
-    and missing channels every 300ms.
-    """
-    
-    def __init__(self, sdk):
-        self.sdk = sdk
-        self.bot = sdk.bot
-        self.backup_dir = sdk.backup_dir
-        self.enabled = False
-        self._task = None
-    
-    def start(self):
-        """Start the channel monitoring task"""
-        if not self.enabled:
-            self.enabled = True
-            self._task = self.bot.loop.create_task(self._monitor_loop())
-            print("🔍 Channel Monitor: Started (300ms checks)")
-    
-    def stop(self):
-        """Stop the monitoring task"""
-        if self.enabled and self._task:
-            self.enabled = False
-            self._task.cancel()
-            print("🛑 Channel Monitor: Stopped")
-    
-    async def _monitor_loop(self):
-        """Main monitoring loop - runs every 300ms"""
-        await self.bot.wait_until_ready()
-        
-        while self.enabled and not self.bot.is_closed():
-            try:
-                await self._check_all_guilds()
-                await asyncio.sleep(0.3)
-            except asyncio.CancelledError:
-                break
-            except Exception as e:
-                print(f"Error in channel monitor: {e}")
-                await asyncio.sleep(0.3)
-    
-    async def _check_all_guilds(self):
-        """Check channels for all guilds"""
-        for guild in self.bot.guilds:
-            try:
-                await self._check_guild_channels(guild)
-            except Exception as e:
-                print(f"Error checking channels for {guild.name}: {e}")
-
-    async def _check_guild_channels(self, guild: discord.Guild):
-        """Check and restore channel positions/permissions/missing channels"""
-        try:
-            # Get backup file
-            backup_file = self.backup_dir / f"channels_{guild.id}.json"
-            if not backup_file.exists():
-                return
-            
-            with open(backup_file, 'r') as f:
-                backup = json.load(f)
-            
-            # Build current snapshot {channel_id: channel_obj}
-            current_channels = {c.id: c for c in guild.channels}
-            
-            # Iterate through BACKUP channels (the source of truth)
-            for ch_data in backup["channels"]:
-                channel_id = ch_data["id"]
-                channel = current_channels.get(channel_id)
-                
-                # 1. Missing Channel Detection
-                if not channel:
-                    # Channel exists in backup but not in guild -> RESTORE IT!
-                    # print(f"⚠️ Missing channel found in backup: {ch_data['name']} ({channel_id})")
-                    try:
-                        # Use the new restore_channel logic that accepts ID
-                        await self.sdk.backup_manager.restore_channel(guild, channel_id)
-                        # Slightly longer sleep on create to prevent rate limits
-                        await asyncio.sleep(0.1) 
-                    except Exception as e:
-                        print(f"Error restoring missing channel {channel_id}: {e}")
-                    continue
-                
-                # 2. Check Position
-                if channel.position != ch_data["position"]:
-                    try:
-                        await channel.edit(position=ch_data["position"], reason="SecureX: Auto-restoring position")
-                        # print(f"🔧 Fixed position for #{channel.name}")
-                    except Exception:
-                        pass
-                
-                # 3. Check Category
-                expected_cat_id = ch_data.get("category_id")
-                current_cat_id = channel.category.id if channel.category else None
-                
-                if expected_cat_id != current_cat_id:
-                    try:
-                        if expected_cat_id:
-                            category = guild.get_channel(expected_cat_id)
-                            if category and isinstance(category, discord.CategoryChannel):
-                                await channel.edit(category=category, reason="SecureX: Auto-restoring category")
-                        else:
-                            # Should be None (no category)
-                            await channel.edit(category=None, reason="SecureX: Auto-restoring category")
-                    except Exception:
-                        pass
-
-                # 4. Check Permissions (Simplified)
-                # We check if the number of overwrites matches. Deep comparison is too heavy for 300ms.
-                # If they differ, we restore permissions.
-                # Note: Backup might have simplified perms, so this is a heuristic.
-                backup_perms = ch_data.get("permissions", {})
-                if len(channel.overwrites) != len(backup_perms):
-                    try:
-                         await self.sdk.backup_manager.restore_channel_permissions(guild, channel.id)
-                    except Exception:
-                        pass
-                
-        except Exception as e:
-            # print(f"Error checking guild {guild.id}: {e}")
-            pass

dc_securex-2.5.3/securex/handlers/role_monitor.py

@@ -1,164 +0,0 @@
-"""
-Role position monitoring - background task that checks every 5 seconds.
-"""
-import discord
-import asyncio
-import json
-from pathlib import Path
-from typing import List, Tuple
-
-
-class RolePositionMonitor:
-    """
-    Background monitor that checks and restores role positions every 5 seconds.
-    Uses Discord's bulk endpoint for efficient updates.
-    """
-    
-    def __init__(self, sdk):
-        self.sdk = sdk
-        self.bot = sdk.bot
-        self.backup_dir = sdk.backup_dir
-        self.enabled = False
-        self._task = None
-        
-        # In-memory cache for role positions (instant lookups)
-        self._role_cache: dict = {}  # {guild_id: {role_id: position}}
-    
-    def start(self):
-        """Start the role position monitoring task"""
-        if not self.enabled:
-            self.enabled = True
-            self._task = self.bot.loop.create_task(self._monitor_loop())
-            print("🔍 Role Position Monitor: Started (300ms checks)")
-    
-    def stop(self):
-        """Stop the monitoring task"""
-        if self.enabled and self._task:
-            self.enabled = False
-            self._task.cancel()
-            print("🛑 Role Position Monitor: Stopped")
-    
-    async def _monitor_loop(self):
-        """Main monitoring loop - runs every 300ms"""
-        await self.bot.wait_until_ready()
-        
-        while self.enabled and not self.bot.is_closed():
-            try:
-                await self._check_all_guilds()
-                await asyncio.sleep(0.3)  # Check every 300ms
-            except asyncio.CancelledError:
-                break
-            except Exception as e:
-                print(f"Error in role position monitor: {e}")
-                await asyncio.sleep(0.3)
-    
-    async def _check_all_guilds(self):
-        """Check role positions for all guilds"""
-        for guild in self.bot.guilds:
-            try:
-                await self._check_guild_positions(guild)
-            except Exception as e:
-                print(f"Error checking positions for {guild.name}: {e}")
-    
-    async def _check_guild_positions(self, guild: discord.Guild):
-        """Check and restore role positions for a specific guild"""
-        try:
-            # Get backup file
-            backup_file = self.backup_dir / f"roles_{guild.id}.json"
-            if not backup_file.exists():
-                return
-            
-            with open(backup_file, 'r') as f:
-                backup = json.load(f)
-            
-            # Use guild.roles snapshot for efficient lookup
-            # Build a dict: {role_id: role_object} from cached roles
-            current_roles = {role.id: role for role in guild.roles}
-            
-            # Collect all mismatched roles
-            role_position_pairs: List[Tuple[discord.Role, int]] = []
-            
-            for role_data in backup["roles"]:
-                role = current_roles.get(role_data["id"])
-                if not role:
-                    continue  # Role was deleted
-                
-                # Check if position matches
-                if role.position != role_data["position"]:
-                    role_position_pairs.append((role, role_data["position"]))
-            
-            # If we found mismatches, restore using bulk endpoint
-            if role_position_pairs:
-                print(f"🔧 Restoring {len(role_position_pairs)} role positions in {guild.name}")
-                
-                try:
-                    # Build payload for bulk update
-                    # Discord API expects: {role_object: new_position}
-                    positions_dict = {
-                        role: expected_pos
-                        for role, expected_pos in role_position_pairs
-                    }
-                    
-                    # Use Discord's bulk role positions endpoint
-                    await guild.edit_role_positions(
-                        positions=positions_dict,
-                        reason="SecureX: Bulk position restore"
-                    )
-                    
-                    print(f"✅ Restored {len(role_position_pairs)} role positions in {guild.name}")
-                    
-                except discord.Forbidden as e:
-                    print(f"⚠️ Missing permissions to modify role positions: {e}")
-                except Exception as e:
-                    print(f"Error restoring role positions: {e}")
-                    # Fallback to individual updates
-                    await self._fallback_individual_updates(guild, role_position_pairs)
-        
-        except Exception as e:
-            print(f"Error in _check_guild_positions: {e}")
-    
-    async def _fallback_individual_updates(self, guild: discord.Guild, role_position_pairs: List[Tuple[discord.Role, int]]):
-        """Fallback to individual role updates if bulk fails"""
-        print(f"⚠️ Falling back to individual updates for {len(role_position_pairs)} roles")
-        
-        for role, expected_pos in role_position_pairs:
-            try:
-                await role.edit(position=expected_pos, reason="SecureX: Position restore")
-                await asyncio.sleep(0.5)  # Rate limit
-            except Exception as e:
-                print(f"Error updating {role.name}: {e}")
-
-    async def _load_guild_cache(self, guild_id: int):
-        """Load role positions from backup into cache"""
-        try:
-            backup_file = self.backup_dir / f"roles_{guild_id}.json"
-            if backup_file.exists():
-                with open(backup_file, 'r') as f:
-                    backup = json.load(f)
-                
-                # Store positions in cache: {role_id: position}
-                self._role_cache[guild_id] = {
-                    role_data["id"]: role_data["position"]
-                    for role_data in backup.get("roles", [])
-                }
-        except Exception as e:
-            print(f"Error loading role cache for guild {guild_id}: {e}")
-    
-    async def preload_all(self):
-        """Preload all role positions into cache on startup"""
-        print("🔄 Preloading role positions into cache...")
-        count = 0
-        
-        for backup_file in self.backup_dir.glob("roles_*.json"):
-            try:
-                guild_id = int(backup_file.stem.replace("roles_", ""))
-                await self._load_guild_cache(guild_id)
-                count += 1
-            except Exception as e:
-                print(f"Error preloading role backup {backup_file}: {e}")
-        
-        print(f"✅ Cached role positions for {count} guilds")
-    
-    def update_cache(self, guild_id: int):
-        """Update cache after role backup (sync wrapper for async method)"""
-        asyncio.create_task(self._load_guild_cache(guild_id))