Phase 1 complete: Core/DBus decoupling, main entry refactor, interface_simple.py syntax fix

TODO.md

@@ -6,6 +6,7 @@
 - ✅ **D-Bus Signal Emission**: Fixed all dbus-next signal emission calls to use direct function calls instead of `.emit()`, resolving 'function object has no attribute emit' errors
 - ✅ **apt-layer.sh Integration**: Updated apt-layer.sh and related scriptlets to use the correct service name and ensure proper daemon status detection and management
 - ✅ **End-to-End D-Bus Testing**: Successfully tested D-Bus method/property calls and signal emission via busctl and apt-layer.sh, confirming full integration and correct daemon operation after VM reboot and service migration
+- ✅ **Phase 1: Foundation & Core Decoupling**: Core daemon logic is now fully decoupled from D-Bus. The core daemon is pure Python with no D-Bus dependencies, D-Bus setup is consolidated in the main entry point, D-Bus interfaces are thin wrappers with no business logic, and all circular imports are eliminated. Also fixed a syntax error in interface_simple.py.
 
 ### Daemon Integration (COMPLETED)
 - ✅ **D-Bus Interface**: Complete D-Bus interface implementation with sysroot and transaction interfaces
@@ -163,11 +164,12 @@
 ## Next Phase 🎯
 
 ### Full dbus-next Migration & Architecture Decoupling (PLANNED)
-- 🎯 **Phase 1: Foundation & Core Decoupling**
+- ✅ **Phase 1: Foundation & Core Decoupling**
-  - Create centralized `AptOstreeDaemon` class with pure Python logic (no D-Bus dependencies)
+  - Core daemon is pure Python, no D-Bus dependencies
-  - Consolidate D-Bus setup in main entry point (`apt_ostree_new.py` or similar)
+  - D-Bus setup consolidated in main entry point (`apt_ostree_new.py`)
-  - Refine `interface_simple.py` to pure D-Bus interface definitions using `dbus-next`
+  - D-Bus interfaces are thin wrappers, no business logic
-  - Eliminate circular imports and architectural impedance mismatch
+  - Circular imports eliminated
+  - Syntax error in interface_simple.py fixed
 - 🎯 **Phase 2: Implementing dbus-next Correctly & Decoupling Logic**
   - Implement all D-Bus properties using `@dbus_property` decorators
   - Correctly define and emit D-Bus signals using `@signal()` and `.emit()`

src/apt-ostree.py/docs/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## [Unreleased]
 
+### Added
+- **Phase 1: Foundation & Core Decoupling**: Major architectural refactor.
+  - Core daemon logic is now pure Python with no D-Bus dependencies.
+  - D-Bus setup is consolidated in the main entry point (`apt_ostree_new.py`).
+  - D-Bus interfaces are thin wrappers with no business logic, delegating to the core daemon.
+  - All circular imports between D-Bus and core logic eliminated.
+
+### Fixed
+- **Syntax Error**: Fixed unterminated string literal and missing newline in `interface_simple.py` that prevented daemon startup.
+
 ### Added
 - **Enhanced Logging System**: Comprehensive logging enhancement with advanced features
   - **Advanced Log Rotation**: Implemented size-based, time-based, and hybrid rotation strategies

src/apt-ostree.py/python/apt_ostree_dbus/interface_simple.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """
 Simplified D-Bus interface for apt-ostree using dbus-next
-Following rpm-ostree architectural patterns
+Thin wrapper around core daemon logic - no business logic here
 """
 
 import asyncio
@@ -13,23 +13,17 @@ from dbus_next import BusType, DBusError
 from dbus_next.aio import MessageBus
 from dbus_next.service import ServiceInterface, method, signal, dbus_property, PropertyAccess
 
-# Removed to avoid circular import - sysroot is passed via daemon_instance
-from utils.shell_integration import ShellIntegration
-
 
 class AptOstreeSysrootInterface(ServiceInterface):
-    """Sysroot interface following rpm-ostree patterns"""
+    """Sysroot interface - thin D-Bus wrapper around core daemon"""
-    
+    def __init__(self, core_daemon):
-    def __init__(self, daemon_instance):
         super().__init__("org.debian.aptostree1.Sysroot")
-        self.daemon = daemon_instance
+        self.core_daemon = core_daemon
-        # Pass progress callback to ShellIntegration
-        self.shell_integration = ShellIntegration(progress_callback=self._progress_callback)
         self.logger = logging.getLogger('dbus.sysroot')
         
         # Properties
         self._booted = ""
-        self._path = self.daemon.sysroot.path if hasattr(self.daemon, 'sysroot') else "/"
+        self._path = self.core_daemon.get_sysroot_path()
         self._active_transaction = ""
         self._active_transaction_path = ""
         self._deployments = {}
@@ -50,209 +44,220 @@ class AptOstreeSysrootInterface(ServiceInterface):
         """Signal emitted when system status changes"""
         pass
 
-    @method()
+    def _progress_callback(self, transaction_id: str, operation: str, progress: float, message: str):
-    async def GetStatus(self) -> 's':
+        """Progress callback that emits D-Bus signals"""
-        """Get system status as JSON string"""
-        try:
-            status = {
-                'daemon_running': True,
-                'sysroot_path': self.daemon.sysroot.path,
-                'active_transactions': len(self.daemon.get_active_transactions()) if hasattr(self.daemon, 'get_active_transactions') else 0,
-                'test_mode': True  # We're running in test mode
-            }
-            # Emit status changed signal as JSON string
-            self.StatusChanged(json.dumps(status))
-            return json.dumps(status)
-        except Exception as e:
-            self.logger.error(f"GetStatus failed: {e}")
-            return json.dumps({'error': str(e)})
-
-    def _progress_callback(self, transaction_id, operation, progress, message):
         try:
             self.TransactionProgress(transaction_id, operation, progress, message)
             self.logger.debug(f"Emitted TransactionProgress: {transaction_id} {operation} {progress}% {message}")
         except Exception as e:
             self.logger.error(f"Failed to emit TransactionProgress signal: {e}")
 
+    @method()
+    async def GetStatus(self) -> 's':
+        """Get system status as JSON string - delegates to core daemon"""
+        try:
+            # Delegate to core daemon
+            status = await self.core_daemon.get_status()
+            
+            # Emit status changed signal
+            self.StatusChanged(json.dumps(status))
+            return json.dumps(status)
+        except Exception as e:
+            self.logger.error(f"GetStatus failed: {e}")
+            return json.dumps({'error': str(e)})
+
     @method()
     async def InstallPackages(self, packages: 'as', live_install: 'b' = False) -> 's':
-        """Install packages using apt-layer.sh integration"""
+        """Install packages - delegates to core daemon"""
-        transaction_id = f"install_{int(time.time())}"
         try:
             self.logger.info(f"Installing packages: {packages}")
-            # Emit start signal
+            
-            self.TransactionProgress(transaction_id, "install", 0.0, f"Starting installation of {len(packages)} packages")
+            # Delegate to core daemon with progress callback
-            result = await self.shell_integration.install_packages(packages, live_install)
+            result = await self.core_daemon.install_packages(
-            # Emit completion signal
+                packages, 
-            success = result.get('success', False)
+                live_install, 
-            progress = 100.0 if success else 0.0
+                progress_callback=self._progress_callback
-            message = f"Installation {'completed' if success else 'failed'}: {result.get('message', 'Unknown error')}"
+            )
-            self.TransactionProgress(transaction_id, "install", progress, message)
+            
             # Emit property changed for active transactions
-            self.PropertyChanged("org.debian.aptostree1.Sysroot", "ActiveTransaction", transaction_id if success else "")
+            if result.get('success', False):
+                self.PropertyChanged("org.debian.aptostree1.Sysroot", "ActiveTransaction", result.get('transaction_id', ""))
             return json.dumps(result)
         except Exception as e:
             self.logger.error(f"InstallPackages failed: {e}")
-            self.TransactionProgress(transaction_id, "install", 0.0, f"Installation failed: {str(e)}")
+            self._progress_callback("install", "install", 0.0, f"Installation failed: {str(e)}")
             return json.dumps({'success': False, 'error': str(e)})
 
     @method()
     async def RemovePackages(self, packages: 'as', live_remove: 'b' = False) -> 's':
-        """Remove packages using apt-layer.sh integration"""
+        """Remove packages - delegates to core daemon"""
-        transaction_id = f"remove_{int(time.time())}"
         try:
             self.logger.info(f"Removing packages: {packages}")
-            self.TransactionProgress(transaction_id, "remove", 0.0, f"Starting removal of {len(packages)} packages")
+            
-            result = await self.shell_integration.remove_packages(packages, live_remove)
+            # Delegate to core daemon with progress callback
-            success = result.get('success', False)
+            result = await self.core_daemon.remove_packages(
-            progress = 100.0 if success else 0.0
+                packages, 
-            message = f"Removal {'completed' if success else 'failed'}: {result.get('message', 'Unknown error')}"
+                live_remove, 
-            self.TransactionProgress(transaction_id, "remove", progress, message)
+                progress_callback=self._progress_callback
-            self.PropertyChanged("org.debian.aptostree1.Sysroot", "ActiveTransaction", transaction_id if success else "")
+            )
+            
+            # Emit property changed for active transactions
+            if result.get('success', False):
+                self.PropertyChanged("org.debian.aptostree1.Sysroot", "ActiveTransaction", result.get('transaction_id', ""))
             return json.dumps(result)
         except Exception as e:
             self.logger.error(f"RemovePackages failed: {e}")
-            self.TransactionProgress(transaction_id, "remove", 0.0, f"Removal failed: {str(e)}")
+            self._progress_callback("remove", "remove", 0.0, f"Removal failed: {str(e)}")
-            return json.dumps({'success': False, 'error': str(e)})
-
-    @method()
-    def ComposeFSCreate(self, source_dir: 's', layer_path: 's', digest_store: 's') -> 's':
-        """Create ComposeFS layer using apt-layer.sh integration"""
-        try:
-            self.logger.info(f"Creating ComposeFS layer: {source_dir} -> {layer_path}")
-            
-            # This is synchronous, so no await needed
-            result = self.shell_integration.composefs_create(source_dir, layer_path, digest_store)
-            
-            return json.dumps(result)
-        except Exception as e:
-            self.logger.error(f"ComposeFSCreate failed: {e}")
             return json.dumps({'success': False, 'error': str(e)})
 
     @method()
     async def Deploy(self, deployment_id: 's') -> 's':
-        """Deploy a specific deployment"""
+        """Deploy a specific deployment - delegates to core daemon"""
-        transaction_id = f"deploy_{int(time.time())}"
         try:
             self.logger.info(f"Deploying: {deployment_id}")
-            self.TransactionProgress(transaction_id, "deploy", 0.0, f"Starting deployment of {deployment_id}")
+            
-            result = self.shell_integration.deploy_layer_sync(deployment_id)
+            # Delegate to core daemon with progress callback
-            self.logger.info(f"Deploy result: {result}")
+            result = await self.core_daemon.deploy_layer(
-            success = result.get('success', False)
+                deployment_id,
-            progress = 100.0 if success else 0.0
+                progress_callback=self._progress_callback
-            message = f"Deployment {'completed' if success else 'failed'}: {result.get('message', 'Unknown error')}"
+            )
-            self.TransactionProgress(transaction_id, "deploy", progress, message)
+            
-            self.PropertyChanged("org.debian.aptostree1.Sysroot", "ActiveTransaction", transaction_id if success else "")
+            # Emit property changed for active transactions
+            if result.get('success', False):
+                self.PropertyChanged("org.debian.aptostree1.Sysroot", "ActiveTransaction", result.get('transaction_id', ""))
             return json.dumps(result)
         except Exception as e:
             self.logger.error(f"Deploy failed: {e}")
-            self.TransactionProgress(transaction_id, "deploy", 0.0, f"Deployment failed: {str(e)}")
+            self._progress_callback("deploy", "deploy", 0.0, f"Deployment failed: {str(e)}")
             return json.dumps({'success': False, 'error': str(e)})
 
     @method()
     async def Upgrade(self) -> 's':
-        """Upgrade the system"""
+        """Upgrade the system - delegates to core daemon"""
-        transaction_id = f"upgrade_{int(time.time())}"
         try:
             self.logger.info("Upgrading system")
-            self.TransactionProgress(transaction_id, "upgrade", 0.0, "Starting system upgrade")
+            
-            result = self.shell_integration.get_system_status_sync()
+            # Delegate to core daemon with progress callback
-            self.logger.info(f"Upgrade result: {result}")
+            result = await self.core_daemon.upgrade_system(
-            success = result.get('success', False)
+                progress_callback=self._progress_callback
-            progress = 100.0 if success else 0.0
+            )
-            message = f"Upgrade {'completed' if success else 'failed'}: {result.get('message', 'Unknown error')}"
+            
-            self.TransactionProgress(transaction_id, "upgrade", progress, message)
+            # Emit property changed for active transactions
-            self.PropertyChanged("org.debian.aptostree1.Sysroot", "ActiveTransaction", transaction_id if success else "")
+            if result.get('success', False):
+                self.PropertyChanged("org.debian.aptostree1.Sysroot", "ActiveTransaction", result.get('transaction_id', ""))
             return json.dumps(result)
         except Exception as e:
             self.logger.error(f"Upgrade failed: {e}")
-            self.TransactionProgress(transaction_id, "upgrade", 0.0, f"Upgrade failed: {str(e)}")
+            self._progress_callback("upgrade", "upgrade", 0.0, f"Upgrade failed: {str(e)}")
             return json.dumps({'success': False, 'error': str(e)})
 
     @method()
     async def Rollback(self) -> 's':
-        """Rollback to previous deployment"""
+        """Rollback to previous deployment - delegates to core daemon"""
-        transaction_id = f"rollback_{int(time.time())}"
         try:
             self.logger.info("Rolling back system")
-            self.TransactionProgress(transaction_id, "rollback", 0.0, "Starting system rollback")
+            
-            result = self.shell_integration.rollback_layer_sync()
+            # Delegate to core daemon with progress callback
-            self.logger.info(f"Rollback result: {result}")
+            result = await self.core_daemon.rollback_system(
-            success = result.get('success', False)
+                progress_callback=self._progress_callback
-            progress = 100.0 if success else 0.0
+            )
-            message = f"Rollback {'completed' if success else 'failed'}: {result.get('message', 'Unknown error')}"
+            
-            self.TransactionProgress(transaction_id, "rollback", progress, message)
+            # Emit property changed for active transactions
-            self.PropertyChanged("org.debian.aptostree1.Sysroot", "ActiveTransaction", transaction_id if success else "")
+            if result.get('success', False):
+                self.PropertyChanged("org.debian.aptostree1.Sysroot", "ActiveTransaction", result.get('transaction_id', ""))
             return json.dumps(result)
         except Exception as e:
             self.logger.error(f"Rollback failed: {e}")
-            self.TransactionProgress(transaction_id, "rollback", 0.0, f"Rollback failed: {str(e)}")
+            self._progress_callback("rollback", "rollback", 0.0, f"Rollback failed: {str(e)}")
             return json.dumps({'success': False, 'error': str(e)})
 
-    @method()
+    # D-Bus Properties - thin wrappers around core daemon properties
-    def CreateComposeFSLayer(self, source_dir: 's', layer_path: 's', digest_store: 's') -> 's':
-        """Create ComposeFS layer with proper parameters"""
-        try:
-            self.logger.info(f"Creating ComposeFS layer: {source_dir} -> {layer_path}")
-            
-            # Use synchronous method to avoid event loop issues
-            result = self.shell_integration.create_composefs_layer_sync(source_dir, layer_path, digest_store)
-            
-            return json.dumps(result)
-        except Exception as e:
-            self.logger.error(f"CreateComposeFSLayer failed: {e}")
-            return json.dumps({'success': False, 'error': str(e)})
-
-    # D-Bus Properties
     @dbus_property(access=PropertyAccess.READ)
     def Booted(self) -> 's':
-        return self._booted
+        """booted deployment - delegates to core daemon"""
+        try:
+            return self.core_daemon.get_booted_deployment()
+        except Exception as e:
+            self.logger.error(f"Booted property failed: {e}")
+            return ""
 
     @dbus_property(access=PropertyAccess.READ)
     def Path(self) -> 's':
-        return self._path
+        """Get sysroot path - delegates to core daemon"""
+        try:
+            return self.core_daemon.get_sysroot_path()
+        except Exception as e:
+            self.logger.error(f"Path property failed: {e}")
+            return "/"
 
     @dbus_property(access=PropertyAccess.READWRITE)
     def ActiveTransaction(self) -> 's':
-        return self._active_transaction
+        """active transaction - delegates to core daemon"""
+        try:
+            transaction = self.core_daemon.get_active_transaction()
+            return transaction.transaction_id if transaction else ""
+        except Exception as e:
+            self.logger.error(f"ActiveTransaction property failed: {e}")
+            return ""
     @ActiveTransaction.setter
     def ActiveTransaction(self, value: 's'):
-        self._active_transaction = value
+        self.logger.warning("ActiveTransaction is read-only from core daemon")
 
     @dbus_property(access=PropertyAccess.READWRITE)
     def ActiveTransactionPath(self) -> 's':
-        return self._active_transaction_path
+        """active transaction path - delegates to core daemon"""
+        try:
+            transaction = self.core_daemon.get_active_transaction()
+            return transaction.path if transaction else ""
+        except Exception as e:
+            self.logger.error(f"ActiveTransactionPath property failed: {e}")
+            return ""
     @ActiveTransactionPath.setter
     def ActiveTransactionPath(self, value: 's'):
-        self._active_transaction_path = value
+        self.logger.warning("ActiveTransactionPath is read-only from core daemon")
 
     @dbus_property(access=PropertyAccess.READ)
     def Deployments(self) -> 's':
-        return json.dumps(self._deployments)
+        """Get deployments - delegates to core daemon"""
+        try:
+            deployments = self.core_daemon.get_deployments()
+            return json.dumps(deployments)
+        except Exception as e:
+            self.logger.error(f"Deployments property failed: {e}")
+            return json.dumps({})
 
     @dbus_property(access=PropertyAccess.READWRITE)
     def AutomaticUpdatePolicy(self) -> 's':
-        return self._automatic_update_policy
+        """automatic update policy - delegates to core daemon"""
+        try:
+            return self.core_daemon.get_auto_update_policy()
+        except Exception as e:
+            self.logger.error(f"AutomaticUpdatePolicy property failed: {e}")
+            return "manual"
+    
     @AutomaticUpdatePolicy.setter
     def AutomaticUpdatePolicy(self, value: 's'):
-        self._automatic_update_policy = value
+        """automatic update policy - delegates to core daemon"""
+        try:
+            self.core_daemon.set_auto_update_policy(value)
+            self.PropertyChanged("org.debian.aptostree1.Sysroot", "AutomaticUpdatePolicy", value)
+        except Exception as e:
+            self.logger.error(f"Failed to set AutomaticUpdatePolicy: {e}")
 
 
 class AptOstreeOSInterface(ServiceInterface):
-    """OS interface for deployment management"""
+    """OS interface - thin D-Bus wrapper around core daemon"""
     
-    def __init__(self, daemon_instance):
+    def __init__(self, core_daemon):
         super().__init__("org.debian.aptostree1.OS")
-        self.daemon = daemon_instance
+        self.core_daemon = core_daemon
-        self.shell_integration = ShellIntegration()
         self.logger = logging.getLogger('dbus.os')
 
     @method()
     def GetBootedDeployment(self) -> 's':
-        """Get currently booted deployment"""
+        """Get currently booted deployment - delegates to core daemon"""
         try:
-            # This would get the booted deployment from sysroot
+            booted = self.core_daemon.get_booted_deployment()
-            booted = self.daemon.sysroot.get_booted_deployment()
             return json.dumps({'booted_deployment': booted})
         except Exception as e:
             self.logger.error(f"GetBootedDeployment failed: {e}")
@@ -260,10 +265,9 @@ class AptOstreeOSInterface(ServiceInterface):
 
     @method()
     def GetDefaultDeployment(self) -> 's':
-        """Get default deployment"""
+        """Get default deployment - delegates to core daemon"""
         try:
-            # This would get the default deployment from sysroot
+            default = self.core_daemon.get_default_deployment()
-            default = self.daemon.sysroot.get_default_deployment()
             return json.dumps({'default_deployment': default})
         except Exception as e:
             self.logger.error(f"GetDefaultDeployment failed: {e}")
@@ -271,41 +275,37 @@ class AptOstreeOSInterface(ServiceInterface):
 
     @method()
     def ListDeployments(self) -> 's':
-        """List all deployments"""
+        """List all deployments - delegates to core daemon"""
         try:
-            # This would list all deployments from sysroot
+            deployments = self.core_daemon.get_deployments()
-            deployments = self.daemon.sysroot.get_deployments()
             return json.dumps({'deployments': deployments})
         except Exception as e:
             self.logger.error(f"ListDeployments failed: {e}")
             return json.dumps({'error': str(e)})
 
 
+# Legacy main function for backward compatibility - will be removed in Phase 2
 async def main():
-    """Main daemon function"""
+    """gacy main function - kept for backward compatibility during transition"""
     logging.basicConfig(level=logging.INFO)
-    logger = logging.getLogger('daemon')
+    logger = logging.getLogger('daemon')  
-    
+    logger.info("Starting apt-ostree daemon with dbus-next (legacy mode)")
-    logger.info("Starting apt-ostree daemon with dbus-next")
     
     # Create D-Bus connection
     bus = await MessageBus(bus_type=BusType.SYSTEM).connect()
     
-    # Create daemon instance (simplified for testing)
+    # Create mock daemon for legacy compatibility
     class MockDaemon:
         def __init__(self):
             self.sysroot = MockSysroot()
     
     class MockSysroot:
         def __init__(self):
-            self.path = "/"
+            self.path = "/"      
-        
         def get_booted_deployment(self):
             return "debian/24.04/x86_64/desktop"
-        
         def get_default_deployment(self):
             return "debian/24.04/x86_64/desktop"
-        
         def get_deployments(self):
             return {
                 "debian/24.04/x86_64/desktop": {
@@ -322,13 +322,11 @@ async def main():
     os_interface = AptOstreeOSInterface(daemon)
     
     bus.export("/org/debian/aptostree1/Sysroot", sysroot_interface)
-    bus.export("/org/debian/aptostree1/OS/default", os_interface)  # Use /default path for compatibility
+    bus.export("/org/debian/aptostree1/OS/default", os_interface)
     
     # Request D-Bus name
-    await bus.request_name("org.debian.aptostree1")
+    await bus.request_name("org.debian.aptostree1")  
-    
+    logger.info("Daemon started successfully (legacy mode)")   
-    logger.info("Daemon started successfully")
-    
     # Keep the daemon running
     try:
         await asyncio.Event().wait()  # Wait forever
@@ -337,5 +335,5 @@ async def main():
         bus.disconnect()
 
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     asyncio.run(main()) 

src/apt-ostree.py/python/apt_ostree_new.py

@@ -0,0 +1,187 @@
+#!/usr/bin/env python3
+"""
+apt-ostree Daemon - New dbus-next implementation with proper decoupling
+Atomic package management system for Debian/Ubuntu inspired by rpm-ostree
+"""
+
+import asyncio
+import argparse
+import logging
+import signal
+import sys
+import os
+from pathlib import Path
+from typing import Optional
+
+# Add the current directory to Python path for imports
+sys.path.insert(0, str(Path(__file__).parent))
+
+from core.daemon import AptOstreeDaemon
+from apt_ostree_dbus.interface_simple import AptOstreeSysrootInterface, AptOstreeOSInterface
+from dbus_next.aio import MessageBus
+from dbus_next import BusType
+
+class AptOstreeNewDaemon:
+    """New daemon using dbus-next implementation with proper decoupling"""
+    
+    def __init__(self, pid_file: str = None, config: dict = None):
+        self.pid_file = pid_file
+        self.config = config or {}
+        self.running = False
+        self.logger = logging.getLogger('daemon')
+        
+        # Core daemon instance (pure Python, no D-Bus dependencies)
+        self.core_daemon: Optional[AptOstreeDaemon] = None
+        
+        # D-Bus components
+        self.bus: Optional[MessageBus] = None
+        self.sysroot_interface: Optional[AptOstreeSysrootInterface] = None
+        self.os_interface: Optional[AptOstreeOSInterface] = None
+        
+    def _write_pid_file(self):
+        """Write PID to file"""
+        if self.pid_file:
+            try:
+                with open(self.pid_file, 'w') as f:
+                    f.write(str(os.getpid()))
+                os.chmod(self.pid_file, 0o644)
+            except Exception as e:
+                print(f"Failed to write PID file: {e}", file=sys.stderr)
+    
+    def _remove_pid_file(self):
+        """Remove PID file"""
+        if self.pid_file and os.path.exists(self.pid_file):
+            try:
+                os.unlink(self.pid_file)
+            except Exception as e:
+                print(f"Failed to remove PID file: {e}", file=sys.stderr)
+    
+    def _setup_signal_handlers(self):
+        """Setup signal handlers for graceful shutdown"""
+        def signal_handler(signum, frame):
+            self.logger.info(f"Received signal {signum}, shutting down...")
+            self.running = False
+        
+        signal.signal(signal.SIGINT, signal_handler)
+        signal.signal(signal.SIGTERM, signal_handler)
+    
+    async def _setup_dbus(self):
+        """Setup D-Bus connection and interfaces"""
+        try:
+            # Connect to system bus
+            self.bus = await MessageBus(bus_type=BusType.SYSTEM).connect()
+            
+            # Create D-Bus interfaces with core daemon instance
+            self.sysroot_interface = AptOstreeSysrootInterface(self.core_daemon)
+            self.os_interface = AptOstreeOSInterface(self.core_daemon)
+            
+            # Export interfaces
+            self.bus.export("/org/debian/aptostree1/Sysroot", self.sysroot_interface)
+            self.bus.export("/org/debian/aptostree1/OS/default", self.os_interface)
+            
+            # Request D-Bus name
+            await self.bus.request_name("org.debian.aptostree1")
+            
+            self.logger.info("D-Bus interfaces exported successfully")
+            return True
+        except Exception as e:
+            self.logger.error(f"Failed to setup D-Bus: {e}")
+            return False
+    
+    async def _cleanup_dbus(self):
+        """Cleanup D-Bus connection"""
+        if self.bus:
+            try:
+                self.bus.disconnect()
+                self.logger.info("D-Bus connection closed")
+            except Exception as e:
+                self.logger.error(f"Error closing D-Bus connection: {e}")
+    
+    async def run(self):
+        """Run the daemon with proper decoupling"""
+        try:
+            # Write PID file if specified
+            if self.pid_file:
+                self._write_pid_file()
+            
+            # Setup signal handlers
+            self._setup_signal_handlers()
+            
+            self.logger.info("Starting apt-ostree daemon (dbus-next implementation)")
+            
+            # Initialize core daemon (pure Python logic)
+            self.core_daemon = AptOstreeDaemon(self.config, self.logger)
+            if not await self.core_daemon.initialize():
+                self.logger.error("Failed to initialize core daemon")
+                return 1
+            
+            # Setup D-Bus interfaces (thin wrapper around core daemon)
+            if not await self._setup_dbus():
+                self.logger.error("Failed to setup D-Bus interfaces")
+                return 1
+            
+            self.running = True
+            self.logger.info("Daemon started successfully")
+            
+            # Keep the daemon running
+            try:
+                await asyncio.Event().wait()  # Wait forever
+            except KeyboardInterrupt:
+                self.logger.info("Received interrupt signal")
+            
+        except Exception as e:
+            self.logger.error(f"Daemon error: {e}")
+            return 1
+        finally:
+            # Cleanup in reverse order
+            await self._cleanup_dbus()
+            if self.core_daemon:
+                await self.core_daemon.shutdown()
+            self._remove_pid_file()
+            self.running = False
+        
+        return 0
+
+def parse_arguments():
+    """Parse command line arguments"""
+    parser = argparse.ArgumentParser(description='apt-ostree System Management Daemon (dbus-next)')
+    parser.add_argument('--daemon', action='store_true', 
+                       help='Run as daemon (default behavior)')
+    parser.add_argument('--pid-file', type=str,
+                       help='Write PID to specified file')
+    parser.add_argument('--foreground', action='store_true',
+                       help='Run in foreground (for debugging)')
+    parser.add_argument('--config', type=str,
+                       help='Path to configuration file')
+    return parser.parse_args()
+
+def main():
+    """Main entry point"""
+    args = parse_arguments()
+    
+    # Check if running as root (required for system operations)
+    if os.geteuid() != 0:
+        print("apt-ostree daemon must be run as root", file=sys.stderr)
+        return 1
+    
+    # Setup basic logging
+    logging.basicConfig(
+        level=logging.INFO,
+        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    )
+    
+    # Load configuration (placeholder for now)
+    config = {
+        'daemon.auto_update_policy': 'none',
+        'daemon.idle_exit_timeout': 0,
+        'sysroot.path': '/',
+        'sysroot.test_mode': True
+    }
+    
+    daemon = AptOstreeNewDaemon(pid_file=args.pid_file, config=config)
+    
+    # Run the daemon
+    return asyncio.run(daemon.run())
+
+if __name__ == "__main__":
+    sys.exit(main())