accli 2.0.0b4__tar.gz → 2.0.0rc4__tar.gz

{accli-2.0.0b4 → accli-2.0.0rc4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: accli
-Version: 2.0.0b4
+Version: 2.0.0rc4
 Summary: IIASA Accelerator Client
 Author-email: Wrufesh S <wrufesh@gmail.com>
 License: The MIT License (MIT)
@@ -39,7 +39,7 @@ Requires-Dist: requests>=2.25.1
 Requires-Dist: jsonschema>=4.5.1
 Requires-Dist: pydantic>=2.0
 Requires-Dist: GitPython
-Requires-Dist: hf-xet>=1.4.3
+Requires-Dist: hf-xet==1.5.2
 Dynamic: license-file
 
 # Accelerator Terminal Client and Python API
@@ -138,8 +138,8 @@ Usage: accli [OPTIONS] COMMAND [ARGS]...
 
 ### Handling self-signed certificates
 
-1. Copy and paste certificates from `<control_services_backend>/certs/public.crt` as
-   `./certs/dev-backend.crt` and `<accelerator_service>/minio_certs/public.crt` as
+1. Copy and paste certificates from `<control_services_backend>/certs/ca.crt` as
+   `./certs/dev-backend.crt` and `<accelerator_service>/minio_certs/ca.crt` as
    `./certs/dev-minio-ca.crt`.
 2. Run
    ```

{accli-2.0.0b4 → accli-2.0.0rc4}/README.md

@@ -94,8 +94,8 @@ Usage: accli [OPTIONS] COMMAND [ARGS]...
 
 ### Handling self-signed certificates
 
-1. Copy and paste certificates from `<control_services_backend>/certs/public.crt` as
-   `./certs/dev-backend.crt` and `<accelerator_service>/minio_certs/public.crt` as
+1. Copy and paste certificates from `<control_services_backend>/certs/ca.crt` as
+   `./certs/dev-backend.crt` and `<accelerator_service>/minio_certs/ca.crt` as
    `./certs/dev-minio-ca.crt`.
 2. Run
    ```

{accli-2.0.0b4 → accli-2.0.0rc4}/accli/AcceleratorTaskDispatcher.py

@@ -139,10 +139,10 @@ class JobDispatchModel(BaseModel):
 class WKubeTaskMeta(BaseModel):
     required_cores: float
     required_ram: float
-    required_storage_local: float
+    required_storage_local: Optional[float] = None
 
     # is ignored if it is a callback and child of non-free node jobs
-    required_storage_workflow: float
+    required_storage_workflow: Optional[float] = None
 
     job_secrets: Optional[dict] = {}
 

{accli-2.0.0b4 → accli-2.0.0rc4}/accli/CsvRegionalTimeseriesValidator.py

@@ -205,8 +205,8 @@ class CsvRegionalTimeseriesValidator:
             for key in self.errors:
                 print(f"[bold red]Invalid data:[/bold red] {self.errors[key]}")
                 print(f"[bold red]Error:[/bold red] {key}")
-            print("[bold red]Data is not valid against selected template. ⚠️⚠️")
+            print("[bold red]Data is not valid against selected template.[/bold red]")
             typer.Exit(1)
         else:
-            print("[bold green]Data validated against selected template.[/bold green] 🎉🎉")
+            print("[bold green]Data validated against selected template.[/bold green]")
             typer.Exit(0)

{accli-2.0.0b4 → accli-2.0.0rc4}/accli/_version.py

@@ -1,3 +1,3 @@
 # Please strictly put double quote to use this info for git tag 
 # Read a developer guide for git tag command with regex
-VERSION = "v2.0.0-beta.4"
+VERSION = "v2.0.0-c4"

{accli-2.0.0b4 → accli-2.0.0rc4}/accli/cleanup-nfs.ps1

@@ -22,14 +22,16 @@ if (-not $isAdmin) {
 
 Write-Host "=== Reverting accli Windows NFS Client Configuration ===" -ForegroundColor Cyan
 
-# 1. Unregister Scheduled Task
-Write-Host "Removing accli-mount-nfs Scheduled Task..." -ForegroundColor Yellow
+# 1. Unregister Scheduled Tasks
+Write-Host "Removing Scheduled Tasks..." -ForegroundColor Yellow
 if (Get-Command Unregister-ScheduledTask -ErrorAction SilentlyContinue) {
     Unregister-ScheduledTask -TaskName "accli-mount-nfs" -Confirm:$false -ErrorAction SilentlyContinue | Out-Null
+    Unregister-ScheduledTask -TaskName "accli-umount-nfs" -Confirm:$false -ErrorAction SilentlyContinue | Out-Null
 } else {
     schtasks /delete /tn "accli-mount-nfs" /f 2> $null | Out-Null
+    schtasks /delete /tn "accli-umount-nfs" /f 2> $null | Out-Null
 }
-Write-Host "[OK] Scheduled Task removed." -ForegroundColor Green
+Write-Host "[OK] Scheduled Tasks removed." -ForegroundColor Green
 
 # 2. Delete Registry Policy Keys
 Write-Host "Removing registry policies (EnableLinkedConnections, AnonymousUid, AnonymousGid)..." -ForegroundColor Yellow

{accli-2.0.0b4 → accli-2.0.0rc4}/accli/cli.py

@@ -141,7 +141,7 @@ def dispatch(
         verify_cert=(not ACCLI_DEBUG)
     )
 
-    # ✅ Resolve the workflow file path properly
+    #  Resolve the workflow file path properly
     if os.path.isabs(workflow_filename):
         workflow_filepath = workflow_filename
     else:
@@ -152,9 +152,9 @@ def dispatch(
 
     workflow_dir = os.path.dirname(workflow_filepath)
 
-    # ✅ Temporarily switch to the workflow file's directory
+    #  Temporarily switch to the workflow file's directory
     with pushd(workflow_dir):
-        # ✅ Import the module dynamically
+        #  Import the module dynamically
         spec = importlib.util.spec_from_file_location("workflow", workflow_filepath)
         module = importlib.util.module_from_spec(spec)
         spec.loader.exec_module(module)
@@ -300,12 +300,6 @@ def copy(
         verify_cert=(not ACCLI_DEBUG),
     )
 
-    def make_token_refresher(slug: str):
-        def refresher() -> tuple[str, int]:
-            token_str, _, exp_time = exchange_refresh_token(slug)
-            return token_str, exp_time
-        return refresher
-
     if is_src_remote:
         # Download flow: acc://[project_slug]/[remote_prefix] -> local destination
         source_parsed = source[len("acc://"):]
@@ -336,7 +330,7 @@ def copy(
         else:
             dest_path.parent.mkdir(parents=True, exist_ok=True)
 
-        download_infos = []
+        files_to_download = []
         for filename in filenames:
             # Filename returned usually starts with project_slug/
             if filename.startswith(f"{project_slug}/"):
@@ -378,32 +372,98 @@ def copy(
 
             local_dest.parent.mkdir(parents=True, exist_ok=True)
 
-            download_infos.append(
-                hf_xet.PyXetDownloadInfo(
-                    destination_path=str(local_dest.resolve()),
-                    hash=merkle_hash,
-                    file_size=file_size
-                )
+            files_to_download.append(
+                (str(local_dest.resolve()), merkle_hash, file_size)
             )
 
-        if not download_infos:
+        if not files_to_download:
             print("[bold red]ERROR: No valid files identified for download.[/bold red]")
             raise typer.Exit(1)
 
-        print(f"[bold cyan]Downloading {len(download_infos)} files using hf-xet...[/bold cyan]")
-        try:
-            hf_xet.download_files(
-                files=download_infos,
-                endpoint=cas_endpoint,
-                token_info=(cas_token, expires_at),
-                token_refresher=make_token_refresher(project_slug),
-                progress_updater=None,
-                request_headers=None
-            )
-            print("[bold green]✔ Download completed successfully![/bold green]")
-        except Exception as e:
-            print(f"[bold red]ERROR: Download failed: {e}[/bold red]")
-            raise typer.Exit(1)
+        MAX_FILES_PER_BATCH = 100
+        MAX_BYTES_PER_BATCH = 10 * 1024 * 1024 * 1024 # 10 GB
+        
+        batches = []
+        current_batch = []
+        current_batch_size = 0
+        
+        for item in files_to_download:
+            size = item[2]
+            if size >= MAX_BYTES_PER_BATCH and not current_batch:
+                batches.append([item])
+                continue
+                
+            if len(current_batch) >= MAX_FILES_PER_BATCH or current_batch_size + size > MAX_BYTES_PER_BATCH:
+                batches.append(current_batch)
+                current_batch = []
+                current_batch_size = 0
+                
+            current_batch.append(item)
+            current_batch_size += size
+            
+        if current_batch:
+            batches.append(current_batch)
+
+        print(f"[bold cyan]Downloading {len(files_to_download)} files in {len(batches)} batches using hf-xet...[/bold cyan]")
+        
+        refresh_url = f"{server_url.rstrip('/')}/api/v1/oauth/device/cas-token/"
+        refresh_headers = {"Authorization": f"Bearer {cas_token}"}
+        
+        with Progress(
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(),
+            TaskProgressColumn(),
+            TimeElapsedColumn(),
+        ) as progress:
+            total_size = sum(item[2] for item in files_to_download)
+            overall_task = progress.add_task("[green]Total Download Progress...", total=total_size)
+            
+            completed_in_previous_batches = 0
+            
+            session = hf_xet.XetSession()
+            for batch_index, batch_items in enumerate(batches, 1):
+                progress.print(f"[cyan]Processing batch {batch_index}/{len(batches)}...[/cyan]")
+                
+                # capture current completed_in_previous_batches in a local scope to avoid late binding issues
+                file_tasks = {}
+                
+                def make_progress_handler(base_completed):
+                    def on_progress(group_report, item_reports):
+                        progress.update(overall_task, completed=base_completed + group_report.total_bytes_completed)
+                        for item_id, item in item_reports.items():
+                            if item_id not in file_tasks:
+                                file_tasks[item_id] = progress.add_task(f"[blue]{item.item_name}", total=item.total_bytes)
+                            
+                            progress.update(file_tasks[item_id], completed=item.bytes_completed)
+                            
+                            # Hide completed tasks to keep the UI clean when downloading thousands of files
+                            if item.bytes_completed >= item.total_bytes:
+                                progress.update(file_tasks[item_id], visible=False)
+                    return on_progress
+                    
+                try:
+                    with session.new_file_download_group(
+                        endpoint=cas_endpoint,
+                        token=cas_token,
+                        token_expiry_unix_secs=expires_at,
+                        token_refresh_url=refresh_url,
+                        token_refresh_headers=refresh_headers,
+                        progress_callback=make_progress_handler(completed_in_previous_batches),
+                        progress_interval_ms=500,
+                    ) as group:
+                        for dest_path, hash_val, size_val in batch_items:
+                            info = hf_xet.XetFileInfo(hash_val, size_val)
+                            group.start_download_file(info, dest_path)
+                            
+                    batch_size = sum(item[2] for item in batch_items)
+                    completed_in_previous_batches += batch_size
+                    progress.update(overall_task, completed=completed_in_previous_batches)
+                    progress.print(f"[bold green][OK] Batch {batch_index} completed successfully![/bold green]")
+                except Exception as e:
+                    progress.print(f"[bold red]ERROR: Download failed for batch {batch_index}: {e}[/bold red]")
+                    raise typer.Exit(1)
+
+        print("[bold green][OK] Download completed successfully![/bold green]")
 
     else:
         # Upload flow: local source -> acc://[project_slug]/[remote_path]
@@ -456,65 +516,137 @@ def copy(
             print("[bold yellow]No files to upload.[/bold yellow]")
             raise typer.Exit(0)
 
-        print(f"[bold cyan]Uploading {len(local_paths)} files using hf-xet...[/bold cyan]")
-        try:
-            upload_results = hf_xet.upload_files(
-                file_paths=[str(p) for p in local_paths],
-                endpoint=cas_endpoint,
-                token_info=(cas_token, expires_at),
-                token_refresher=make_token_refresher(project_slug),
-                progress_updater=None,
-                _repo_type=None,
-                request_headers=None,
-                sha256s=None,
-                skip_sha256=False
-            )
-        except Exception as e:
-            print(f"[bold red]ERROR: Upload failed: {e}[/bold red]")
-            raise typer.Exit(1)
+        MAX_FILES_PER_BATCH = 100
+        MAX_BYTES_PER_BATCH = 10 * 1024 * 1024 * 1024 # 10 GB
+        
+        batches = []
+        current_batch_paths = []
+        current_batch_remote = []
+        current_batch_size = 0
+        
+        for local_p, remote_n in zip(local_paths, remote_filenames):
+            size = local_p.stat().st_size
+            if size >= MAX_BYTES_PER_BATCH and not current_batch_paths:
+                batches.append(([local_p], [remote_n]))
+                continue
+                
+            if len(current_batch_paths) >= MAX_FILES_PER_BATCH or current_batch_size + size > MAX_BYTES_PER_BATCH:
+                batches.append((current_batch_paths, current_batch_remote))
+                current_batch_paths = []
+                current_batch_remote = []
+                current_batch_size = 0
+                
+            current_batch_paths.append(local_p)
+            current_batch_remote.append(remote_n)
+            current_batch_size += size
+            
+        if current_batch_paths:
+            batches.append((current_batch_paths, current_batch_remote))
 
-        # Compute SHA-256 locally and register metadata in database
-        print("[cyan]Computing SHA-256 hashes and registering metadata...[/cyan]")
-        registration_items = []
-        for local_path, remote_filename, upload_info in zip(local_paths, remote_filenames, upload_results):
-            sha256_hash = compute_sha256(str(local_path))
-            registration_items.append({
-                "filename": f"{project_slug}/{remote_filename}",
-                "merkle_hash": upload_info.hash,
-                "sha256": sha256_hash,
-                "file_size": upload_info.file_size,
-                "content_type": "application/octet-stream"
-            })
-
-        headers = {
-            "Content-Type": "application/json",
-            "X-Project-Slug": project_slug,
-            "Authorization": f"Bearer {cas_token}"
-        }
+        print(f"[bold cyan]Uploading {len(local_paths)} files in {len(batches)} batches using hf-xet...[/bold cyan]")
+        
+        refresh_url = f"{server_url.rstrip('/')}/api/v1/oauth/device/cas-token/"
+        refresh_headers = {"Authorization": f"Bearer {cas_token}"}
+        
+        with Progress(
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(),
+            TaskProgressColumn(),
+            TimeElapsedColumn(),
+        ) as progress:
+            total_size = sum(p.stat().st_size for p in local_paths)
+            overall_task = progress.add_task("[green]Total Upload Progress...", total=total_size)
+            
+            completed_in_previous_batches = 0
+            
+            session = hf_xet.XetSession()
+            for batch_index, (b_paths, b_remotes) in enumerate(batches, 1):
+                progress.print(f"[cyan]Processing batch {batch_index}/{len(batches)}...[/cyan]")
+                
+                file_tasks = {}
+                
+                def make_progress_handler(base_completed):
+                    def on_progress(group_report, item_reports):
+                        progress.update(overall_task, completed=base_completed + group_report.total_bytes_completed)
+                        for item_id, item in item_reports.items():
+                            if item_id not in file_tasks:
+                                file_tasks[item_id] = progress.add_task(f"[blue]{item.item_name}", total=item.total_bytes)
+                            
+                            progress.update(file_tasks[item_id], completed=item.bytes_completed)
+                            
+                            # Hide completed tasks to keep the UI clean
+                            if item.bytes_completed >= item.total_bytes:
+                                progress.update(file_tasks[item_id], visible=False)
+                    return on_progress
+                    
+                try:
+                    with session.new_upload_commit(
+                        endpoint=cas_endpoint,
+                        token=cas_token,
+                        token_expiry_unix_secs=expires_at,
+                        token_refresh_url=refresh_url,
+                        token_refresh_headers=refresh_headers,
+                        progress_callback=make_progress_handler(completed_in_previous_batches),
+                        progress_interval_ms=500,
+                    ) as commit:
+                        handles = []
+                        for p in b_paths:
+                            sha = compute_sha256(str(p))
+                            h = commit.start_upload_file(str(p), sha256=sha)
+                            handles.append((p, sha, h))
+                        
+                    upload_results = [(p, sha, h.result()) for p, sha, h in handles]
+                except Exception as e:
+                    progress.print(f"[bold red]ERROR: Upload failed for batch {batch_index}: {e}[/bold red]")
+                    raise typer.Exit(1)
 
-        try:
-            response = requests.post(
-                register_url,
-                json={"items": registration_items},
-                headers=headers,
-                verify=(not ACCLI_DEBUG)
-            )
-            response.raise_for_status()
-            print("[bold green]✔ Upload and bulk metadata registration completed successfully![/bold green]")
-        except requests.exceptions.HTTPError as e:
-            detail = None
-            try:
-                detail = e.response.json().get("detail")
-            except Exception:
-                pass
-            if detail:
-                print(f"[bold red]ERROR: Bulk metadata registration failed: {detail}[/bold red]")
-            else:
-                print(f"[bold red]ERROR: Bulk metadata registration failed: {e}[/bold red]")
-            raise typer.Exit(1)
-        except Exception as e:
-            print(f"[bold red]ERROR: Bulk metadata registration failed: {e}[/bold red]")
-            raise typer.Exit(1)
+                progress.print("[cyan]Computing SHA-256 hashes and registering metadata for batch...[/cyan]")
+                registration_items = []
+                for local_path, remote_filename, (p, sha256_hash, upload_info) in zip(b_paths, b_remotes, upload_results):
+                    registration_items.append({
+                        "filename": f"{project_slug}/{remote_filename}",
+                        "merkle_hash": upload_info.xet_info.hash,
+                        "sha256": sha256_hash,
+                        "file_size": upload_info.xet_info.file_size,
+                        "content_type": "application/octet-stream"
+                    })
+
+                headers = {
+                    "Content-Type": "application/json",
+                    "X-Project-Slug": project_slug,
+                    "Authorization": f"Bearer {cas_token}"
+                }
+
+                try:
+                    response = requests.post(
+                        register_url,
+                        json={"items": registration_items},
+                        headers=headers,
+                        verify=(not ACCLI_DEBUG)
+                    )
+                    response.raise_for_status()
+                    
+                    batch_size = sum(p.stat().st_size for p in b_paths)
+                    completed_in_previous_batches += batch_size
+                    progress.update(overall_task, completed=completed_in_previous_batches)
+                    
+                    progress.print(f"[bold green][OK] Batch {batch_index} registered successfully![/bold green]")
+                except requests.exceptions.HTTPError as e:
+                    detail = None
+                    try:
+                        detail = e.response.json().get("detail")
+                    except Exception:
+                        pass
+                    if detail:
+                        progress.print(f"[bold red]ERROR: Bulk metadata registration failed for batch {batch_index}: {detail}[/bold red]")
+                    else:
+                        progress.print(f"[bold red]ERROR: Bulk metadata registration failed for batch {batch_index}: {e}[/bold red]")
+                    raise typer.Exit(1)
+                except Exception as e:
+                    progress.print(f"[bold red]ERROR: Bulk metadata registration failed for batch {batch_index}: {e}[/bold red]")
+                    raise typer.Exit(1)
+
+        print("[bold green][OK] Upload completed successfully![/bold green]")
 
 
 # --- Mount commands group ---
@@ -710,6 +842,7 @@ def mount_start(
     from . import mount_downloader
     import platform
     import re
+    import json
     
     sys_name = platform.system()
     
@@ -738,6 +871,27 @@ def mount_start(
 
     # Standardize mount_point and handle defaults / auto-selection
     if sys_name == "Windows":
+        # Check if the daemon is already running to prevent double mount
+        import subprocess
+        try:
+            task_check = subprocess.run(["tasklist", "/FI", "IMAGENAME eq hf-mount-nfs.exe"], capture_output=True, text=True)
+            if "hf-mount-nfs.exe" in task_check.stdout:
+                config_file = Path("C:/ProgramData/accli/mount_config.json")
+                active_msg = ""
+                if config_file.is_file():
+                    try:
+                        import json
+                        cfg = json.loads(config_file.read_text(encoding="utf-8"))
+                        active_msg = f" for project '{cfg.get('project_slug')}' at '{cfg.get('mount_point')}'"
+                    except Exception:
+                        pass
+                print(f"[bold red]ERROR: A mount daemon is already running{active_msg}.[/bold red]")
+                print("[yellow]Please run 'accli mount stop' to unmount before starting a new mount.[/yellow]")
+                raise typer.Exit(1)
+        except Exception as e:
+            if isinstance(e, typer.Exit):
+                raise e
+
         if mount_point is None:
             # Auto-detect available drive letter starting with W
             try:
@@ -917,6 +1071,8 @@ def mount_start(
                     print("[yellow]Falling back to UAC elevation...[/yellow]")
                     has_task = False
             except Exception as e:
+                if isinstance(e, typer.Exit) or type(e).__name__ == "Exit":
+                    raise e
                 print(f"[bold red]ERROR: Task Scheduler trigger failed: {e}[/bold red]")
                 print("[yellow]Falling back to UAC elevation...[/yellow]")
                 has_task = False
@@ -1108,8 +1264,9 @@ def mount_stop(
                             print(f"[bold red]ERROR: You requested to stop '{mount_point_abs}', but the active daemon is mounted at '{active_mount}'.[/bold red]")
                             print(f"[yellow]To stop the server, please run: accli mount stop {active_mount}[/yellow]")
                             raise typer.Exit(1)
-                except Exception:
-                    pass
+                except Exception as e:
+                    if isinstance(e, typer.Exit) or type(e).__name__ == "Exit":
+                        raise e
     else:
         if mount_point is None:
             try:
@@ -1128,28 +1285,71 @@ def mount_stop(
         print(f"[bold cyan]Stopping mount at '[white]{mount_point_abs}[/white]' on Windows...[/bold cyan]")
         import subprocess
         
-        # 1. Run Windows standard umount command
-        res = subprocess.run(["C:\\Windows\\System32\\umount.exe", "-f", str(mount_point_abs)], capture_output=True, text=True)
-        
-        # 2. Stop the scheduled task (which terminates the elevated daemon background process tree)
-        try:
-            subprocess.run(["schtasks", "/end", "/tn", "accli-mount-nfs"], capture_output=True)
-        except Exception:
-            pass
-        
-        # 2. Selective Kill: Target and terminate only the specific process using the target mount point using a PowerShell command-line filter
+        # Determine if current user is admin
         try:
-            escaped_mount_point = str(mount_point_abs).replace("'", "''")
-            kill_cmd = [
-                "powershell.exe", "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command",
-                f"Get-CimInstance Win32_Process -Filter \"name='hf-mount-nfs.exe'\" | "
-                f"Where-Object {{ $_.CommandLine -like '*{escaped_mount_point}*' }} | "
-                f"ForEach-Object {{ Stop-Process -Id $_.ProcessId -Force }}"
-            ]
-            subprocess.run(kill_cmd, capture_output=True)
+            import ctypes
+            is_admin = ctypes.windll.shell32.IsUserAnAdmin() != 0
         except Exception:
-            # Fallback to killing all instances if selective filter fails
-            subprocess.run(["taskkill", "/f", "/im", "hf-mount-nfs.exe"], capture_output=True)
+            is_admin = False
+
+        # 1. Unmap the network drive in the user session
+        res = subprocess.run(["C:\\Windows\\System32\\umount.exe", "-f", str(mount_point_abs)], capture_output=True, text=True)
+        if res.returncode != 0:
+            # Fallback to force-releasing using net use
+            subprocess.run(["net", "use", str(mount_point_abs), "/delete", "/y"], capture_output=True)
+
+        # 2. Terminate the background daemon
+        has_umount_task = False
+        if not is_admin:
+            try:
+                task_check = subprocess.run(["schtasks", "/query", "/tn", "accli-umount-nfs"], capture_output=True, text=True)
+                if task_check.returncode == 0:
+                    has_umount_task = True
+            except Exception:
+                pass
+
+        if has_umount_task:
+            print("[cyan]Triggering elevated NFS daemon termination via Task Scheduler...[/cyan]")
+            subprocess.run(["schtasks", "/run", "/tn", "accli-umount-nfs"], capture_output=True)
+            # Poll for up to 5 seconds to ensure hf-mount-nfs.exe has fully terminated
+            import time
+            for _ in range(10):
+                time.sleep(0.5)
+                task_check = subprocess.run(["tasklist", "/FI", "IMAGENAME eq hf-mount-nfs.exe"], capture_output=True, text=True)
+                if "hf-mount-nfs.exe" not in task_check.stdout:
+                    break
+        else:
+            # If admin or task scheduler gateway is not registered, stop/kill directly
+            if is_admin:
+                try:
+                    subprocess.run(["schtasks", "/end", "/tn", "accli-mount-nfs"], capture_output=True)
+                except Exception:
+                    pass
+                try:
+                    escaped_mount_point = str(mount_point_abs).replace("'", "''")
+                    kill_cmd = [
+                        "powershell.exe", "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command",
+                        f"Get-CimInstance Win32_Process -Filter \"name='hf-mount-nfs.exe'\" | "
+                        f"Where-Object {{ $_.CommandLine -like '*{escaped_mount_point}*' }} | "
+                        f"ForEach-Object {{ Stop-Process -Id $_.ProcessId -Force }}"
+                    ]
+                    subprocess.run(kill_cmd, capture_output=True)
+                except Exception:
+                    # Fallback to killing all instances if selective filter fails
+                    subprocess.run(["taskkill", "/f", "/im", "hf-mount-nfs.exe"], capture_output=True)
+            else:
+                # Standard user with no task registered - need UAC to end task/kill process
+                print("[yellow]Notice: Task Scheduler gateway is not active. Requesting UAC elevation to terminate daemon...[/yellow]")
+                ps_command = (
+                    "Start-Process powershell.exe -ArgumentList '-NoProfile -ExecutionPolicy Bypass -Command "
+                    "\"Stop-ScheduledTask -TaskName accli-mount-nfs -ErrorAction SilentlyContinue; "
+                    "Get-CimInstance Win32_Process -Filter \\\"name=''hf-mount-nfs.exe''\\\" | Stop-Process -Force -ErrorAction SilentlyContinue\"' "
+                    "-Verb RunAs -Wait"
+                )
+                subprocess.run([
+                    "powershell.exe", "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command",
+                    ps_command
+                ], capture_output=True)
         
         if res.returncode == 0 or "successfully" in res.stdout or "successfully" in res.stderr:
             print("[bold green][OK] Mount stopped successfully.[/bold green]")
@@ -1246,21 +1446,40 @@ def mount_status(
     args = [str(hf_mount_bin), "status"]
 
     import subprocess
+    active_mounts = []
+
+    # 1. Query hf-mount status directly
     try:
         result = subprocess.run(args, capture_output=True, text=True)
         if result.returncode == 0:
             stdout = result.stdout.strip()
-            if not stdout:
-                print("[cyan]No running mounts found.[/cyan]")
-            else:
-                print("[bold cyan]Active Mounts:[/bold cyan]")
-                print(stdout)
-        else:
-            print(f"[bold red][ERROR] Failed to retrieve mount status (exit code {result.returncode}):[/bold red]")
-            if result.stderr:
-                print(f"[red]{result.stderr}[/red]")
-            raise typer.Exit(result.returncode)
-    except Exception as e:
-        print(f"[bold red]ERROR: Failed to execute status process: {e}[/bold red]")
-        raise typer.Exit(1)
+            if stdout:
+                for line in stdout.splitlines():
+                    if line.strip():
+                        active_mounts.append(line.strip())
+    except Exception:
+        pass
+
+    # 2. Fallback: parse system mount table on Linux to find localhost NFS or FUSE hf-mounts
+    if not active_mounts and platform.system() == "Linux":
+        try:
+            if os.path.exists("/proc/mounts"):
+                with open("/proc/mounts", "r") as f:
+                    for line in f:
+                        parts = line.strip().split()
+                        if len(parts) >= 3:
+                            dev, mnt_point, fstype = parts[0], parts[1], parts[2]
+                            is_nfs_localhost = (fstype == "nfs" and dev.startswith("127.0.0.1:"))
+                            is_fuse_hf = ("hf-mount" in dev or "hf-mount" in fstype)
+                            if is_nfs_localhost or is_fuse_hf:
+                                active_mounts.append(f"{mnt_point}   ({fstype} via {dev})")
+        except Exception:
+            pass
+
+    if not active_mounts:
+        print("[cyan]No running mounts found.[/cyan]")
+    else:
+        print("[bold cyan]Active Mounts:[/bold cyan]")
+        for m in active_mounts:
+            print(m)