comfygit 0.3.6__py3-none-any.whl → 0.3.10__py3-none-any.whl

comfygit_cli/env_commands.py

@@ -88,6 +88,57 @@ class EnvironmentCommands:
             sys.exit(1)
         return active
 
+    def _get_python_version(self, env: Environment) -> str:
+        """Get Python version from environment."""
+        python_version_file = env.cec_path / ".python-version"
+        if python_version_file.exists():
+            return python_version_file.read_text(encoding="utf-8").strip()
+        return "3.12"
+
+    def _get_or_probe_backend(
+        self, env: Environment, override: str | None = None
+    ) -> tuple[str, bool]:
+        """Get torch backend from file or probe if missing.
+
+        Args:
+            env: Environment to get backend for
+            override: Optional explicit backend override
+
+        Returns:
+            Tuple of (backend_string, was_probed) where was_probed is True
+            if we had to auto-probe because no backend was configured.
+        """
+        if override:
+            return override, False
+
+        had_backend = env.pytorch_manager.has_backend()
+
+        try:
+            python_version = self._get_python_version(env)
+            backend = env.pytorch_manager.ensure_backend(python_version)
+
+            was_probed = not had_backend
+            if was_probed:
+                print("⚠️  No PyTorch backend configured. Auto-detecting...")
+                print(f"✓ Backend detected and saved: {backend}")
+                print("   To change: cg env-config torch-backend set <backend>")
+
+            return backend, was_probed
+        except Exception as e:
+            print(f"✗ Error probing PyTorch backend: {e}")
+            print("   Try setting it explicitly: cg env-config torch-backend set <backend>")
+            sys.exit(1)
+
+    def _show_legacy_manager_notice(self, env: Environment) -> None:
+        """Show legacy manager notice if environment uses symlinked manager."""
+        try:
+            status = env.get_manager_status()
+            if status.is_legacy:
+                print("")
+                print("Legacy manager detected. Run 'cg manager update' to migrate.")
+        except Exception:
+            pass  # Silently fail - notice is informational only
+
     def _format_size(self, size_bytes: int) -> str:
         """Format bytes as human-readable size."""
         for unit in ("B", "KB", "MB", "GB"):
@@ -174,7 +225,7 @@ class EnvironmentCommands:
 
     # === Commands that operate ON environments ===
 
-    @with_env_logging("env create")
+    @with_env_logging("create")
     def create(self, args: argparse.Namespace, logger=None) -> None:
         """Create a new environment."""
         # Ensure workspace exists, creating it if necessary
@@ -220,7 +271,7 @@ class EnvironmentCommands:
             print(f"  • Add nodes: cg -e {args.name} node add <node-name>")
             print(f"  • Set as active: cg use {args.name}")
 
-    @with_env_logging("env use")
+    @with_env_logging("use")
     def use(self, args: argparse.Namespace, logger=None) -> None:
         """Set the active environment."""
         from comfygit_cli.utils.progress import create_model_sync_progress
@@ -237,7 +288,7 @@ class EnvironmentCommands:
         print(f"✓ Active environment set to: {args.name}")
         print("You can now run commands without the -e flag")
 
-    @with_env_logging("env delete")
+    @with_env_logging("delete")
     def delete(self, args: argparse.Namespace, logger=None) -> None:
         """Delete an environment."""
         # Check that environment exists (don't require active environment)
@@ -270,7 +321,122 @@ class EnvironmentCommands:
 
     # === Commands that operate IN environments ===
 
-    @with_env_logging("env run")
+    # === Environment Configuration ===
+
+    @with_env_logging("env-config torch-backend show")
+    def env_config_torch_show(self, args: argparse.Namespace, logger=None) -> None:
+        """Show current PyTorch backend setting for this environment."""
+        env = self._get_env(args)
+
+        backend = env.pytorch_manager.get_backend()
+        backend_file = env.pytorch_manager.backend_file
+        versions = env.pytorch_manager.get_versions()
+
+        print(f"PyTorch Backend: {backend}")
+        if versions:
+            for pkg, ver in versions.items():
+                print(f"   {pkg}={ver}")
+
+        if backend_file.exists():
+            print(f"   Source: {backend_file}")
+        else:
+            print("   Source: auto-detected (no .pytorch-backend file)")
+            print()
+            print(f"💡 To save this setting: cg env-config torch-backend set {backend}")
+
+    @with_env_logging("env-config torch-backend set")
+    def env_config_torch_set(self, args: argparse.Namespace, logger=None) -> None:
+        """Set PyTorch backend for this environment.
+
+        Probes for exact versions and stores both backend and version pins.
+        """
+        from comfygit_core.utils.pytorch_prober import PyTorchProbeError
+
+        env = self._get_env(args)
+        backend = args.backend
+
+        # Validate backend format
+        if not env.pytorch_manager.is_valid_backend(backend):
+            print(f"✗ Invalid backend: {backend}")
+            print()
+            print("Valid formats:")
+            print("  • cu118, cu121, cu124, cu126, cu128 (CUDA)")
+            print("  • cpu")
+            print("  • rocm6.2, rocm6.3 (AMD)")
+            print("  • xpu (Intel)")
+            sys.exit(1)
+
+        # Read python version
+        python_version_file = env.cec_path / ".python-version"
+        python_version = (
+            python_version_file.read_text(encoding="utf-8").strip()
+            if python_version_file.exists()
+            else "3.12"
+        )
+
+        # Probe and set backend with versions
+        print(f"🔍 Probing PyTorch versions for {backend} (Python {python_version})...")
+        try:
+            resolved = env.pytorch_manager.probe_and_set_backend(python_version, backend)
+        except PyTorchProbeError as e:
+            print(f"✗ Error probing PyTorch: {e}")
+            sys.exit(1)
+
+        # Show what was stored
+        versions = env.pytorch_manager.get_versions()
+        print(f"✓ PyTorch backend set to: {resolved}")
+        if versions:
+            for pkg, ver in versions.items():
+                print(f"   {pkg}={ver}")
+        print()
+        print("Run 'cg sync' to apply the new backend configuration.")
+
+    @with_env_logging("env-config torch-backend detect")
+    def env_config_torch_detect(self, args: argparse.Namespace, logger=None) -> None:
+        """Auto-detect recommended PyTorch backend using uv probe."""
+        from comfygit_core.utils.pytorch_prober import PyTorchProbeError, probe_pytorch_versions
+
+        env = self._get_env(args)
+        backend_file = env.pytorch_manager.backend_file
+
+        # Read python version from file
+        python_version_file = env.cec_path / ".python-version"
+        python_version = (
+            python_version_file.read_text(encoding="utf-8").strip()
+            if python_version_file.exists()
+            else "3.12"
+        )
+
+        # Probe for recommended backend
+        print(f"🔍 Probing PyTorch compatibility for Python {python_version}...")
+        try:
+            _, detected = probe_pytorch_versions(python_version, "auto")
+        except PyTorchProbeError as e:
+            print(f"✗ Error probing PyTorch: {e}")
+            sys.exit(1)
+
+        # Get current backend (if any)
+        if env.pytorch_manager.has_backend():
+            current = env.pytorch_manager.get_backend()
+        else:
+            current = "(not configured)"
+
+        print(f"Detected backend: {detected}")
+        print(f"Current backend:  {current}")
+
+        if backend_file.exists():
+            print(f"   Source: {backend_file}")
+        else:
+            print("   Source: not configured")
+
+        if current != detected and current != "(not configured)":
+            print()
+            print(f"💡 Consider updating: cg env-config torch-backend set {detected}")
+        elif current == "(not configured)":
+            print()
+            print(f"💡 Set the backend: cg env-config torch-backend set {detected}")
+
+    @with_env_logging("run")
     def run(self, args: argparse.Namespace) -> None:
         """Run ComfyUI in the specified environment."""
         RESTART_EXIT_CODE = 42
@@ -278,14 +444,32 @@ class EnvironmentCommands:
         comfyui_args = args.args if hasattr(args, 'args') else []
         no_sync = getattr(args, 'no_sync', False)
 
+        # Handle torch-backend: use override, read from file, or probe if missing
+        torch_backend_override = getattr(args, 'torch_backend', None)
+        torch_backend, was_probed = self._get_or_probe_backend(env, torch_backend_override)
+
+        if torch_backend_override:
+            print(f"🔧 Using PyTorch backend override: {torch_backend}")
+        elif was_probed:
+            print(f"✓ Backend detected and saved: {torch_backend}")
+            print(f"   To change: cg env-config torch-backend set <backend>")
+        else:
+            print(f"🔧 Using PyTorch backend: {torch_backend}")
+
         current_branch = env.get_current_branch()
         branch_display = f" (on {current_branch})" if current_branch else " (detached HEAD)"
 
         while True:
             # Sync before running (unless --no-sync)
+            # Use explicit override if provided, otherwise None (backend is now in file)
             if not no_sync:
                 print(f"🔄 Syncing environment: {env.name}")
-                env.sync(preserve_workflows=True, remove_extra_nodes=False)
+                env.sync(
+                    preserve_workflows=True,
+                    remove_extra_nodes=False,
+                    backend_override=torch_backend_override if torch_backend_override else None,
+                    verbose=True,
+                )
 
             print(f"🎮 Starting ComfyUI in environment: {env.name}{branch_display}")
             if comfyui_args:
@@ -300,6 +484,54 @@ class EnvironmentCommands:
 
             sys.exit(result.returncode)
 
+    @with_env_logging("sync")
+    def sync(self, args: argparse.Namespace, logger=None) -> None:
+        """Sync environment packages and dependencies."""
+        env = self._get_env(args)
+
+        # Handle torch-backend: use override, read from file, or probe if missing
+        torch_backend_override = getattr(args, 'torch_backend', None)
+        torch_backend, was_probed = self._get_or_probe_backend(env, torch_backend_override)
+
+        if torch_backend_override:
+            print(f"🔧 Using PyTorch backend override: {torch_backend}")
+        elif was_probed:
+            print(f"✓ Backend detected and saved: {torch_backend}")
+            print(f"   To change: cg env-config torch-backend set <backend>")
+        else:
+            print(f"🔧 Using PyTorch backend: {torch_backend}")
+
+        print(f"\n🔄 Syncing environment: {env.name}")
+
+        verbose = getattr(args, 'verbose', False)
+
+        try:
+            # Use explicit override if provided, otherwise None (backend is now in file)
+            result = env.sync(
+                dry_run=False,
+                model_strategy="skip",  # Sync command focuses on packages
+                remove_extra_nodes=False,  # Don't remove nodes, just sync
+                verbose=verbose,
+                backend_override=torch_backend_override if torch_backend_override else None,
+            )
+
+            if result.success:
+                print("\n✓ Sync complete")
+                if result.packages_synced:
+                    print(f"   Packages synced: {result.packages_synced}")
+                if result.dependency_groups_installed:
+                    print(f"   Dependency groups: {', '.join(result.dependency_groups_installed)}")
+            else:
+                print("\n⚠️  Sync completed with warnings")
+                for error in result.errors:
+                    print(f"   • {error}")
+
+        except Exception as e:
+            if logger:
+                logger.error(f"Sync failed: {e}", exc_info=True)
+            print(f"\n✗ Sync failed: {e}", file=sys.stderr)
+            sys.exit(1)
+
     def manifest(self, args: argparse.Namespace) -> None:
         """Show environment manifest (pyproject.toml configuration)."""
         env = self._get_env(args)
@@ -359,7 +591,7 @@ class EnvironmentCommands:
             # Default: raw TOML (exact file representation)
             print(tomlkit.dumps(config))
 
-    @with_env_logging("env status")
+    @with_env_logging("status")
     def status(self, args: argparse.Namespace) -> None:
         """Show environment status using semantic methods."""
         env = self._get_env(args)
@@ -391,6 +623,9 @@ class EnvironmentCommands:
 
             print("\n✓ No workflows")
             print("✓ No uncommitted changes")
+
+            # Show legacy manager notice even in clean state
+            self._show_legacy_manager_notice(env)
             return
 
         # Show environment name with branch
@@ -541,6 +776,9 @@ class EnvironmentCommands:
         # Suggested actions - smart and contextual
         self._show_smart_suggestions(status)
 
+        # Show legacy manager notice if applicable
+        self._show_legacy_manager_notice(env)
+
     # Removed: _has_uninstalled_packages - this logic is now in core's WorkflowAnalysisStatus
 
     def _print_workflow_issues(self, wf_analysis: WorkflowAnalysisStatus, verbose: bool = False) -> None:
@@ -867,7 +1105,7 @@ class EnvironmentCommands:
 
     # === Node management ===
 
-    @with_env_logging("env node add")
+    @with_env_logging("node add")
     def node_add(self, args: argparse.Namespace, logger=None) -> None:
         """Add custom node(s) - directly modifies pyproject.toml."""
         env = self._get_env(args)
@@ -906,7 +1144,7 @@ class EnvironmentCommands:
                 for node_id, error in failed_nodes:
                     print(f"  • {node_id}: {error}")
 
-            print(f"\nRun 'cg -e {env.name} env status' to review changes")
+            print(f"\nRun 'cg -e {env.name} status' to review changes")
             return
 
         # Single node mode (original behavior)
@@ -965,9 +1203,9 @@ class EnvironmentCommands:
         else:
             print(f"✓ Node '{node_info.name}' added to pyproject.toml")
 
-        print(f"\nRun 'cg -e {env.name} env status' to review changes")
+        print(f"\nRun 'cg -e {env.name} status' to review changes")
 
-    @with_env_logging("env node remove")
+    @with_env_logging("node remove")
     def node_remove(self, args: argparse.Namespace, logger=None) -> None:
         """Remove custom node(s) - handles filesystem immediately."""
         env = self._get_env(args)
@@ -1006,7 +1244,7 @@ class EnvironmentCommands:
                 for node_id, error in failed_nodes:
                     print(f"  • {node_id}: {error}")
 
-            print(f"\nRun 'cg -e {env.name} env status' to review changes")
+            print(f"\nRun 'cg -e {env.name} status' to review changes")
             return
 
         # Single node mode (original behavior)
@@ -1044,9 +1282,9 @@ class EnvironmentCommands:
             if result.filesystem_action == "deleted":
                 print("   (cached globally, can reinstall)")
 
-        print(f"\nRun 'cg -e {env.name} env status' to review changes")
+        print(f"\nRun 'cg -e {env.name} status' to review changes")
 
-    @with_env_logging("env node prune")
+    @with_env_logging("node prune")
     def node_prune(self, args: argparse.Namespace, logger=None) -> None:
         """Remove unused custom nodes from environment."""
         env = self._get_env(args)
@@ -1115,7 +1353,7 @@ class EnvironmentCommands:
                 print(f"  • {node_id}: {error}")
             sys.exit(1)
 
-    @with_env_logging("env node list")
+    @with_env_logging("node list")
     def node_list(self, args: argparse.Namespace) -> None:
         """List custom nodes in the environment."""
         env = self._get_env(args)
@@ -1140,7 +1378,7 @@ class EnvironmentCommands:
 
             print(f"  • {node.registry_id or node.name} ({node.source}){version_suffix}")
 
-    @with_env_logging("env node update")
+    @with_env_logging("node update")
     def node_update(self, args: argparse.Namespace, logger=None) -> None:
         """Update a custom node."""
         from comfygit_core.strategies.confirmation import (
@@ -1188,7 +1426,7 @@ class EnvironmentCommands:
 
     # === Constraint management ===
 
-    @with_env_logging("env constraint add")
+    @with_env_logging("constraint add")
     def constraint_add(self, args: argparse.Namespace, logger=None) -> None:
         """Add constraint dependencies to [tool.uv]."""
         env = self._get_env(args)
@@ -1209,7 +1447,7 @@ class EnvironmentCommands:
         print(f"✓ Added {len(args.packages)} constraint(s) to pyproject.toml")
         print(f"\nRun 'cg -e {env.name} constraint list' to view all constraints")
 
-    @with_env_logging("env constraint list")
+    @with_env_logging("constraint list")
     def constraint_list(self, args: argparse.Namespace) -> None:
         """List constraint dependencies from [tool.uv]."""
         env = self._get_env(args)
@@ -1225,7 +1463,7 @@ class EnvironmentCommands:
         for constraint in constraints:
             print(f"  • {constraint}")
 
-    @with_env_logging("env constraint remove")
+    @with_env_logging("constraint remove")
     def constraint_remove(self, args: argparse.Namespace, logger=None) -> None:
         """Remove constraint dependencies from [tool.uv]."""
         env = self._get_env(args)
@@ -1256,7 +1494,7 @@ class EnvironmentCommands:
 
     # === Python dependency management ===
 
-    @with_env_logging("env py add")
+    @with_env_logging("py add")
     def py_add(self, args: argparse.Namespace, logger=None) -> None:
         """Add Python dependencies to the environment."""
         env = self._get_env(args)
@@ -1316,7 +1554,7 @@ class EnvironmentCommands:
             print(f"\n✓ Added {len(args.packages)} package(s) to dependencies")
         print(f"\nRun 'cg -e {env.name} status' to review changes")
 
-    @with_env_logging("env py remove")
+    @with_env_logging("py remove")
     def py_remove(self, args: argparse.Namespace, logger=None) -> None:
         """Remove Python dependencies from the environment."""
         env = self._get_env(args)
@@ -1390,7 +1628,7 @@ class EnvironmentCommands:
 
         print(f"\nRun 'cg -e {env.name} status' to review changes")
 
-    @with_env_logging("env py remove-group")
+    @with_env_logging("py remove-group")
     def py_remove_group(self, args: argparse.Namespace, logger=None) -> None:
         """Remove an entire dependency group."""
         env = self._get_env(args)
@@ -1407,7 +1645,7 @@ class EnvironmentCommands:
         print(f"\n✓ Removed dependency group '{group_name}'")
         print(f"\nRun 'cg -e {env.name} py list --all' to view remaining groups")
 
-    @with_env_logging("env py uv")
+    @with_env_logging("py uv")
     def py_uv(self, args: argparse.Namespace, logger=None) -> None:
         """Direct UV command passthrough for advanced users."""
         env = self._get_env(args)
@@ -1434,7 +1672,7 @@ class EnvironmentCommands:
         )
         sys.exit(result.returncode)
 
-    @with_env_logging("env py list")
+    @with_env_logging("py list")
     def py_list(self, args: argparse.Namespace) -> None:
         """List Python dependencies."""
         env = self._get_env(args)
@@ -1473,7 +1711,7 @@ class EnvironmentCommands:
 
     # === Git-based operations ===
 
-    @with_env_logging("env repair")
+    @with_env_logging("repair")
     def repair(self, args: argparse.Namespace, logger=None) -> None:
         """Repair environment to match pyproject.toml (for manual edits or git operations)."""
         env = self._get_env(args)
@@ -1653,7 +1891,7 @@ class EnvironmentCommands:
         print("✓ Changes applied successfully!")
         print(f"\nEnvironment '{env.name}' is ready to use")
 
-    @with_env_logging("env checkout")
+    @with_env_logging("checkout")
     def checkout(self, args: argparse.Namespace, logger=None) -> None:
         """Checkout commits, branches, or files."""
         from .strategies.rollback import AutoRollbackStrategy, InteractiveRollbackStrategy
@@ -1694,7 +1932,7 @@ class EnvironmentCommands:
             print(f"✗ Checkout failed: {e}", file=sys.stderr)
             sys.exit(1)
 
-    @with_env_logging("env branch")
+    @with_env_logging("branch")
     def branch(self, args: argparse.Namespace, logger=None) -> None:
         """Manage branches."""
         env = self._get_env(args)
@@ -1738,7 +1976,7 @@ class EnvironmentCommands:
             print(f"✗ Branch operation failed: {e}", file=sys.stderr)
             sys.exit(1)
 
-    @with_env_logging("env switch")
+    @with_env_logging("switch")
     def switch(self, args: argparse.Namespace, logger=None) -> None:
         """Switch to branch."""
         env = self._get_env(args)
@@ -1753,7 +1991,7 @@ class EnvironmentCommands:
             print(f"✗ Switch failed: {e}", file=sys.stderr)
             sys.exit(1)
 
-    @with_env_logging("env reset")
+    @with_env_logging("reset")
     def reset_git(self, args: argparse.Namespace, logger=None) -> None:
         """Reset HEAD to ref (git-native reset)."""
         from .strategies.rollback import InteractiveRollbackStrategy
@@ -1783,7 +2021,7 @@ class EnvironmentCommands:
             print(f"✗ Reset failed: {e}", file=sys.stderr)
             sys.exit(1)
 
-    @with_env_logging("env merge")
+    @with_env_logging("merge")
     def merge(self, args: argparse.Namespace, logger=None) -> None:
         """Merge branch into current with atomic conflict resolution."""
         env = self._get_env(args)
@@ -1878,7 +2116,7 @@ class EnvironmentCommands:
             print(f"✗ Merge failed: {e}", file=sys.stderr)
             sys.exit(1)
 
-    @with_env_logging("env revert")
+    @with_env_logging("revert")
     def revert(self, args: argparse.Namespace, logger=None) -> None:
         """Revert a commit."""
         env = self._get_env(args)
@@ -1893,7 +2131,7 @@ class EnvironmentCommands:
             print(f"✗ Revert failed: {e}", file=sys.stderr)
             sys.exit(1)
 
-    @with_env_logging("env commit")
+    @with_env_logging("commit")
     def commit(self, args: argparse.Namespace, logger=None) -> None:
         """Commit workflows with optional issue resolution."""
         env = self._get_env(args)
@@ -1976,7 +2214,7 @@ class EnvironmentCommands:
 
     # === Git remote operations ===
 
-    @with_env_logging("env pull")
+    @with_env_logging("pull")
     def pull(self, args: argparse.Namespace, logger=None) -> None:
         """Pull from remote and repair environment."""
         env = self._get_env(args)
@@ -1985,15 +2223,23 @@ class EnvironmentCommands:
         if not env.git_manager.has_remote(args.remote):
             print(f"✗ Remote '{args.remote}' not configured")
             print()
-            print("💡 Set up a remote first:")
-            print(f"   cg remote add {args.remote} <url>")
+            # Check if other remotes exist
+            remotes = env.git_manager.list_remotes()
+            if remotes:
+                remote_names = list({r[0] for r in remotes})  # Unique names
+                print("💡 Use an existing remote:")
+                print(f"   cg pull -r {remote_names[0]}")
+            else:
+                print("💡 Set up a remote first:")
+                print(f"   cg remote add {args.remote} <url>")
             sys.exit(1)
 
         # Preview mode - read-only, just show what would change
+        branch = getattr(args, 'branch', None)
         if getattr(args, "preview", False):
             try:
                 print(f"Fetching from {args.remote}...")
-                diff = env.preview_pull(remote=args.remote)
+                diff = env.preview_pull(remote=args.remote, branch=branch)
 
                 if not diff.has_changes:
                     if diff.is_already_merged:
@@ -2037,7 +2283,7 @@ class EnvironmentCommands:
             else:
                 # Check for conflicts before pull
                 print(f"Checking for conflicts with {args.remote}...")
-                diff = env.preview_pull(remote=args.remote)
+                diff = env.preview_pull(remote=args.remote, branch=branch)
                 if diff.has_conflicts:
                     # Interactive conflict resolution
                     from .strategies.conflict_resolver import InteractiveConflictResolver
@@ -2066,6 +2312,18 @@ class EnvironmentCommands:
 
             print(f"📥 Pulling from {args.remote}...")
 
+            # Handle torch-backend: use override, read from file, or probe if missing
+            torch_backend_override = getattr(args, 'torch_backend', None)
+            torch_backend, was_probed = self._get_or_probe_backend(env, torch_backend_override)
+
+            if torch_backend_override:
+                print(f"🔧 Using PyTorch backend override: {torch_backend}")
+            elif was_probed:
+                print(f"🔧 Auto-detected PyTorch backend: {torch_backend}")
+                print(f"   To save: cg env-config torch-backend set {torch_backend}")
+            else:
+                print(f"🔧 Using PyTorch backend: {torch_backend}")
+
             # Create callbacks for node and model progress (reuse repair command patterns)
             from comfygit_core.models.workflow import BatchDownloadCallbacks, NodeInstallCallbacks
             from .utils.progress import create_progress_callback
@@ -2103,12 +2361,16 @@ class EnvironmentCommands:
             )
 
             # Pull and repair with progress callbacks
+            force = getattr(args, 'force', False)
             result = env.pull_and_repair(
                 remote=args.remote,
+                branch=branch,
                 model_strategy=getattr(args, 'models', 'all'),
                 model_callbacks=model_callbacks,
                 node_callbacks=node_callbacks,
                 strategy_option=strategy_option,
+                force=force,
+                backend_override=torch_backend,
             )
 
             # Extract sync result for summary
@@ -2184,7 +2446,7 @@ class EnvironmentCommands:
             print(f"✗ Pull failed: {e}", file=sys.stderr)
             sys.exit(1)
 
-    @with_env_logging("env push")
+    @with_env_logging("push")
     def push(self, args: argparse.Namespace, logger=None) -> None:
         """Push commits to remote."""
         env = self._get_env(args)
@@ -2201,8 +2463,15 @@ class EnvironmentCommands:
         if not env.git_manager.has_remote(args.remote):
             print(f"✗ Remote '{args.remote}' not configured")
             print()
-            print("💡 Set up a remote first:")
-            print(f"   cg remote add {args.remote} <url>")
+            # Check if other remotes exist
+            remotes = env.git_manager.list_remotes()
+            if remotes:
+                remote_names = list({r[0] for r in remotes})  # Unique names
+                print("💡 Use an existing remote:")
+                print(f"   cg push -r {remote_names[0]}")
+            else:
+                print("💡 Set up a remote first:")
+                print(f"   cg remote add {args.remote} <url>")
             sys.exit(1)
 
         try:
@@ -2246,7 +2515,7 @@ class EnvironmentCommands:
             print(f"✗ Push failed: {e}", file=sys.stderr)
             sys.exit(1)
 
-    @with_env_logging("env remote")
+    @with_env_logging("remote")
     def remote(self, args: argparse.Namespace, logger=None) -> None:
         """Manage git remotes."""
         env = self._get_env(args)
@@ -2699,3 +2968,73 @@ class EnvironmentCommands:
                     print(f"    {m.actual_category}/{m.name} → {expected}/")
             else:
                 print("✓ No changes needed - all dependencies already resolved")
+
+    # ================================================================================
+    # Manager Commands - Per-environment comfygit-manager management
+    # ================================================================================
+
+    @with_env_logging("manager status")
+    def manager_status(self, args: argparse.Namespace, logger: Any = None) -> None:
+        """Show manager version and update availability."""
+        env = self._get_env(args)
+
+        status = env.get_manager_status()
+
+        print("comfygit-manager")
+        print(f"   Current: {status.current_version or 'not installed'}")
+        print(f"   Latest:  {status.latest_version or 'unknown'}")
+
+        if status.is_legacy:
+            print("   Legacy installation (symlinked)")
+            print(f"   Run 'cg -e {env.name} manager update' to migrate")
+        elif not status.is_tracked:
+            print("   Not installed")
+            print(f"   Run 'cg -e {env.name} manager update' to install")
+        elif status.update_available:
+            print("   Update available!")
+        else:
+            print("   Up to date")
+
+    @with_env_logging("manager update")
+    def manager_update(self, args: argparse.Namespace, logger: Any = None) -> None:
+        """Update or migrate comfygit-manager."""
+        from comfygit_core.strategies.confirmation import AutoConfirmStrategy, InteractiveConfirmStrategy
+
+        env = self._get_env(args)
+        version = getattr(args, 'version', None) or "latest"
+        use_yes = getattr(args, 'yes', False)
+
+        # Ensure backend is configured (same as sync/run commands)
+        had_backend = env.pytorch_manager.has_backend()
+        if not had_backend:
+            print("⚠️  No PyTorch backend configured. Auto-detecting...")
+            python_version = self._get_python_version(env)
+            backend = env.pytorch_manager.ensure_backend(python_version)
+            print(f"✓ Backend detected and saved: {backend}")
+            print("   To change: cg env-config torch-backend set <backend>\n")
+
+        status = env.get_manager_status()
+
+        if status.is_legacy:
+            print("Migrating comfygit-manager to per-environment installation...")
+        elif not status.is_tracked:
+            print("Installing comfygit-manager...")
+        else:
+            print("Updating comfygit-manager...")
+
+        strategy = AutoConfirmStrategy() if use_yes else InteractiveConfirmStrategy()
+
+        try:
+            result = env.update_manager(version=version, confirmation_strategy=strategy)
+
+            if result.changed:
+                print(f"   {result.message}")
+                print("\n   Restart this environment to use the new version")
+            else:
+                print(f"   {result.message}")
+
+        except Exception as e:
+            print(f"   Failed to update manager: {e}", file=sys.stderr)
+            if logger:
+                logger.error(f"Manager update failed: {e}", exc_info=True)
+            sys.exit(1)