machineconfig 5.15__py3-none-any.whl → 7.66__py3-none-any.whl

machineconfig/scripts/python/helpers_devops/cli_share_file.py

@@ -0,0 +1,137 @@
+import typer
+# import platform
+# import sys
+from typing import Annotated
+
+
+def share_file_receive(code_args: Annotated[list[str], typer.Argument(help="Receive code or relay command. Examples: '7121-donor-olympic-bicycle' or '--relay 10.17.62.206:443 7121-donor-olympic-bicycle'")],
+) -> None:
+    """Receive a file using croc with relay server.
+Usage examples:
+    devops network receive 7121-donor-olympic-bicycle
+    devops network receive -- --relay 10.17.62.206:443 7121-donor-olympic-bicycle
+    devops network receive -- croc --relay 10.17.62.206:443 7121-donor-olympic-bicycle
+"""
+    from machineconfig.utils.installer_utils.installer_cli import install_if_missing
+    install_if_missing(which="croc")
+    import platform
+    import sys
+
+    is_windows = platform.system() == "Windows"
+
+    # If no args passed via typer, try to get them from sys.argv directly
+    # This handles the case where -- was used and arguments weren't parsed by typer
+    if not code_args or (len(code_args) == 1 and code_args[0] in ['--relay', 'croc']):
+        # Find the index of 'rx' or 'receive' in sys.argv and get everything after it
+        try:
+            for i, arg in enumerate(sys.argv):
+                if arg in ['rx', 'receive', 'r'] and i + 1 < len(sys.argv):
+                    code_args = sys.argv[i + 1:]
+                    break
+        except Exception:
+            pass
+
+    # Join all arguments
+    input_str = " ".join(code_args)
+    tokens = input_str.split()
+
+    # Parse input to extract relay server and secret code
+    relay_server: str | None = None
+    secret_code: str | None = None
+
+    # Remove 'croc' and 'export' from tokens if present
+    tokens = [t for t in tokens if t not in ['croc', 'export']]
+
+    # Look for --relay flag and capture next token
+    relay_idx = -1
+    for i, token in enumerate(tokens):
+        if token == '--relay' and i + 1 < len(tokens):
+            relay_server = tokens[i + 1]
+            relay_idx = i
+            break
+
+    # Look for CROC_SECRET= prefix in any token
+    for token in tokens:
+        if token.startswith('CROC_SECRET='):
+            secret_code = token.split('=', 1)[1].strip('"').strip("'")
+            break
+
+    # If no secret code found yet, look for tokens with dashes (typical pattern: number-word-word-word)
+    # Skip relay server and relay flag
+    if not secret_code:
+        for i, token in enumerate(tokens):
+            if '-' in token and not token.startswith('-') and token != relay_server:
+                if relay_idx >= 0 and (i == relay_idx or i == relay_idx + 1):
+                    continue  # Skip relay server parts
+                secret_code = token
+                break
+
+    if not secret_code and not relay_server:
+        typer.echo(f"❌ Error: Could not parse croc receive code from input: {input_str}", err=True)
+        typer.echo("Usage:", err=True)
+        typer.echo("  devops network receive 7121-donor-olympic-bicycle", err=True)
+        typer.echo("  devops network receive -- --relay 10.17.62.206:443 7121-donor-olympic-bicycle", err=True)
+        raise typer.Exit(code=1)
+
+    # Build the appropriate script for current OS
+    if is_windows:
+        # Windows PowerShell format: croc --relay server:port secret-code --yes
+        relay_arg = f"--relay {relay_server}" if relay_server else ""
+        code_arg = f"{secret_code}" if secret_code else ""
+        script = f"""croc {relay_arg} {code_arg} --yes""".strip()
+    else:
+        # Linux/macOS Bash format: CROC_SECRET="secret-code" croc --relay server:port --yes
+        relay_arg = f"--relay {relay_server}" if relay_server else ""
+        if secret_code:
+            script = f"""export CROC_SECRET="{secret_code}"
+croc {relay_arg} --yes""".strip()
+        else:
+            script = f"""croc {relay_arg} --yes""".strip()
+
+    from machineconfig.utils.code import exit_then_run_shell_script, print_code
+    print_code(code=script, desc="🚀 Receiving file with croc", lexer="bash" if platform.system() != "Windows" else "powershell")
+    exit_then_run_shell_script(script=script, strict=False)
+
+
+def share_file_send(path: Annotated[str, typer.Argument(help="Path to the file or directory to send")],
+                    zip_folder: Annotated[bool, typer.Option("--zip", help="Zip folder before sending")] = False,
+                    code: Annotated[str | None, typer.Option("--code", "-c", help="Codephrase used to connect to relay")] = None,
+                    text: Annotated[str | None, typer.Option("--text", "-t", help="Send some text")] = None,
+                    qrcode: Annotated[bool, typer.Option("--qrcode", "--qr", help="Show receive code as a qrcode")] = False,
+                    ) -> None:
+    """Send a file using croc with relay server."""
+    from machineconfig.utils.installer_utils.installer_cli import install_if_missing
+    install_if_missing(which="croc")
+    # Get relay server IP from environment or use default
+    import socket
+    import platform
+    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    s.connect(('8.8.8.8',80))
+    local_ip_v4 = s.getsockname()[0]
+    s.close()
+    relay_port = "443"
+    is_windows = platform.system() == "Windows"
+
+    # Build command parts
+    relay_arg = f"--relay {local_ip_v4}:{relay_port} --ip {local_ip_v4}:{relay_port}"
+    zip_arg = "--zip" if zip_folder else ""
+    text_arg = f"--text '{text}'" if text else ""
+    qrcode_arg = "--qrcode" if qrcode else ""
+    path_arg = f"{path}" if not text else ""
+
+    if is_windows:
+        # Windows PowerShell format
+        code_arg = f"--code {code}" if code else ""
+        script = f"""croc {relay_arg} send {zip_arg} {code_arg} {qrcode_arg} {text_arg} {path_arg}"""
+    else:
+        # Linux/macOS Bash format
+        if code:
+            script = f"""export CROC_SECRET="{code}"
+croc {relay_arg} send {zip_arg} {qrcode_arg} {text_arg} {path_arg}"""
+        else:
+            script = f"""croc {relay_arg} send {zip_arg} {qrcode_arg} {text_arg} {path_arg}"""
+
+    typer.echo(f"🚀 Sending file: {path}. Use: devops network receive")
+    from machineconfig.utils.code import exit_then_run_shell_script, print_code
+    print_code(code=script, desc="🚀 sending file with croc", lexer="bash" if platform.system() != "Windows" else "powershell")
+    exit_then_run_shell_script(script=script, strict=False)

machineconfig/scripts/python/helpers_devops/cli_share_server.py

@@ -0,0 +1,141 @@
+from pathlib import Path
+from typing import Optional, Annotated
+from machineconfig.scripts.python.helpers_devops.cli_share_file import share_file_receive, share_file_send
+import typer
+
+
+def display_share_url(local_ip_v4: str, port: int, protocol: str = "http") -> None:
+    """Display a flashy, unmissable share URL announcement."""
+    from rich.console import Console
+    from rich.panel import Panel
+    from rich.text import Text
+    from rich.align import Align
+    console = Console()
+    # Create the main message with styling
+    url_text = Text(f"{protocol}://{local_ip_v4}:{port}", style="bold bright_cyan underline")
+    message = Text.assemble(
+        ("🚀 ", "bright_red"),
+        ("Share server is now accessible at: ", "bright_white bold"),
+        url_text,
+        (" 🚀", "bright_red")
+    )
+    # Create a fancy panel with borders and styling
+    panel = Panel(
+        Align.center(message),
+        title="[bold bright_green]🌐 SHARE SERVER READY 🌐[/bold bright_green]",
+        subtitle="[italic bright_yellow]⚡ Click the link above to access your shared files! ⚡[/italic bright_yellow]",
+        border_style="bright_magenta",
+        padding=(1, 2),
+        expand=False
+    )
+    # Print with extra spacing and attention-grabbing elements
+    console.print(panel)
+
+
+def web_file_explorer(
+    path: Annotated[str, typer.Argument(help="Path to the file or directory to share")],
+    port: Annotated[Optional[int], typer.Option("--port", "-p", help="Port to run the share server on (default: 8080)")] = None,
+    username: Annotated[Optional[str], typer.Option("--username", "-u", help="Username for share access (default: current user)")] = None,
+    password: Annotated[Optional[str], typer.Option("--password", "-w", help="Password for share access (default: from ~/dotfiles/creds/passwords/quick_password)")] = None,
+    over_internet: Annotated[bool, typer.Option("--over-internet", "-i", help="Expose the share server over the internet using ngrok")] = False,
+    backend: Annotated[str, typer.Option("--backend", "-b", help="Backend to use: filebrowser (default), miniserve, or easy-sharing")] = "filebrowser"
+) -> None:
+    from machineconfig.utils.installer_utils.installer_cli import install_if_missing
+    
+    if backend not in ["filebrowser", "miniserve", "easy-sharing"]:
+        typer.echo(f"❌ ERROR: Invalid backend '{backend}'. Must be one of: filebrowser, miniserve, easy-sharing", err=True)
+        raise typer.Exit(code=1)
+    
+    install_if_missing(which=backend)
+    if over_internet:
+        install_if_missing(which="ngrok")
+    
+    if username is None:
+        import getpass
+        username = getpass.getuser()
+    
+    if password is None:
+        pwd_path = Path.home().joinpath("dotfiles/creds/passwords/quick_password")
+        if pwd_path.exists():
+            password = pwd_path.read_text(encoding="utf-8").strip()
+        else:
+            typer.echo(f"⚠️  WARNING: Password not provided and default password file does not exist.\nPath: {pwd_path}\nUsing default password: 'quick_password' (insecure!)", err=True)
+            raise typer.Exit(code=1)
+
+    if port is None:
+        port = 8080
+
+    import socket
+    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    s.connect(('8.8.8.8', 80))
+    local_ip_v4 = s.getsockname()[0]
+    s.close()
+
+    protocol = "http"
+    display_share_url(local_ip_v4, port, protocol)
+    
+    path_obj = Path(path).resolve()
+    if not path_obj.exists():
+        typer.echo(f"❌ ERROR: Path does not exist: {path}", err=True)
+        raise typer.Exit(code=1)
+    
+    if backend == "filebrowser":
+        db_path = Path.home().joinpath(".config/filebrowser/filebrowser.db")
+        db_path.parent.mkdir(parents=True, exist_ok=True)
+        command = f"""
+filebrowser users add {username} "{password}" --database {db_path}
+filebrowser --address 0.0.0.0 --port {port} --root "{path_obj}" --database {db_path}
+"""
+    elif backend == "miniserve":
+        command = f"""miniserve --port {port} --interfaces 0.0.0.0 --auth {username}:{password} --upload-files --mkdir --enable-tar --enable-tar-gz --enable-zip --qrcode "{path_obj}" """
+    elif backend == "easy-sharing":
+        command = f"""easy-sharing --port {port} --username {username} --password "{password}" "{path_obj}" """
+    else:
+        typer.echo(f"❌ ERROR: Unknown backend '{backend}'", err=True)
+        raise typer.Exit(code=1)
+
+    from machineconfig.utils.code import exit_then_run_shell_script
+    exit_then_run_shell_script(script=command, strict=False)
+    # import subprocess
+    # import time
+    # server_process: subprocess.Popen[bytes]
+    # server_process = subprocess.Popen(command, shell=True)
+    # processes = [server_process]
+    # if over_internet:
+    #     ngrok_process = subprocess.Popen(f"ngrok http {port}", shell=True)
+    #     processes.append(ngrok_process)
+    #     time.sleep(3)
+    #     try:
+    #         import requests
+    #         response = requests.get("http://localhost:4040/api/tunnels")
+    #         data = response.json()
+    #         public_url = data['tunnels'][0]['public_url']
+    #         print(f"🌐 Ngrok tunnel ready: {public_url}")
+    #     except Exception as e:
+    #         print(f"Could not retrieve ngrok URL: {e}")
+    
+    # try:
+    #     while True:
+    #         print(f"Share server ({backend}) is running. Press Ctrl+C to stop.")
+    #         time.sleep(2)
+    # except KeyboardInterrupt:
+    #     print("\nTerminating processes...")
+    #     for p in processes:
+    #         p.terminate()
+    #         p.wait()
+
+
+def get_share_file_app():
+    app = typer.Typer(name="share-file", help="Send or receive files using croc with relay server.")
+    app.command(name="send", no_args_is_help=True, hidden=False, help="[s] send files from here.")(share_file_send)
+    app.command(name="s", no_args_is_help=True, hidden=True, help="[s] send files from here.")(share_file_send)
+    app.command(name="receive", no_args_is_help=True, hidden=False, help="[r] receive files to here.")(share_file_receive)
+    app.command(name="r", no_args_is_help=True, hidden=True, help="[r] receive files to here.")(share_file_receive)
+    return app
+
+def main_with_parser():
+    typer.run(web_file_explorer)
+
+
+if __name__ == "__main__":
+    pass

machineconfig/scripts/python/{share_terminal.py → helpers_devops/cli_terminal.py}

@@ -1,8 +1,8 @@
-
-
 from pathlib import Path
 from typing import Optional, Annotated
 import typer
+import subprocess
+import time
 
 
 
@@ -49,19 +49,6 @@ def display_terminal_url(local_ip_v4: str, port: int, protocol: str = "http") ->
     # console.print("🔥" * 60 + "\n", style="bright_red bold")
 
 
-def install_ttyd():
-    # uv run --python 3.13 --with machineconfig devops install ttyd
-    from machineconfig.utils.installer_utils.installer_abc import check_tool_exists
-    exists = check_tool_exists("ttyd")
-    if exists:
-        print("✅ ttyd is already installed.")
-        return
-    print("⏳ ttyd not found. Installing...")
-    from machineconfig.utils.installer_utils.installer import main
-    main(which="ttyd")
-
-
-
 def main(
     port: Annotated[Optional[int], typer.Option("--port", "-p", help="Port to run the terminal server on (default: 7681)")] = None,
     username: Annotated[Optional[str], typer.Option("--username", "-u", help="Username for terminal access (default: current user)")] = None,
@@ -70,9 +57,13 @@ def main(
     ssl: Annotated[bool, typer.Option("--ssl", "-S", help="Enable SSL")] = False,
     ssl_cert: Annotated[Optional[str], typer.Option("--ssl-cert", "-C", help="SSL certificate file path")] = None,
     ssl_key: Annotated[Optional[str], typer.Option("--ssl-key", "-K", help="SSL key file path")] = None,
-    ssl_ca: Annotated[Optional[str], typer.Option("--ssl-ca", "-A", help="SSL CA file path for client certificate verification")] = None
+    ssl_ca: Annotated[Optional[str], typer.Option("--ssl-ca", "-A", help="SSL CA file path for client certificate verification")] = None,
+    over_internet: Annotated[bool, typer.Option("--over-internet", "-i", help="Expose the terminal over the internet using ngrok")] = False
 ) -> None:
-    install_ttyd()
+    from machineconfig.utils.installer_utils.installer_cli import install_if_missing
+    install_if_missing("ttyd")
+    if over_internet: install_if_missing("ngrok")
+
     if username is None:
         import getpass
         username = getpass.getuser()
@@ -128,12 +119,33 @@ def main(
             start_command = "powershell"
         else:
             start_command = "bash"
-    code = f"""
-#!/bin/bash
-ttyd --writable -t enableSixel=true {ssl_args} --port {port} --credential "{username}:{password}" -t 'theme={{"background": "black"}}' {start_command}
-"""
-    from machineconfig.utils.code import run_shell_script
-    run_shell_script(code)
+    
+    ttyd_cmd = f"ttyd --writable -t enableSixel=true {ssl_args} --port {port} --credential \"{username}:{password}\" -t 'theme={{\"background\": \"black\"}}' {start_command}"
+    ttyd_process = subprocess.Popen(ttyd_cmd, shell=True)
+    processes = [ttyd_process]
+    
+    if over_internet:
+        ngrok_process = subprocess.Popen(f"ngrok http {port}", shell=True)
+        processes.append(ngrok_process)
+        time.sleep(3)
+        try:
+            import requests
+            response = requests.get("http://localhost:4040/api/tunnels")
+            data = response.json()
+            public_url = data['tunnels'][0]['public_url']
+            print(f"🌐 Ngrok tunnel ready: {public_url}")
+        except Exception as e:
+            print(f"Could not retrieve ngrok URL: {e}")
+    
+    try:
+        while True:
+            print("Terminal server is running. Press Ctrl+C to stop.")
+            time.sleep(2)
+    except KeyboardInterrupt:
+        print("\nTerminating processes...")
+        for p in processes:
+            p.terminate()
+            p.wait()
 
 
 def main_with_parser():

machineconfig/scripts/python/helpers_devops/cli_utils.py

@@ -0,0 +1,96 @@
+
+
+import typer
+from typing import Annotated, Optional
+
+
+def merge_pdfs(
+        pdfs: Annotated[list[str], typer.Argument(..., help="Paths to the PDF files to merge.")],
+        output: Annotated[Optional[str], typer.Option("--output", "-o", help="Output merged PDF file path.")] = None,
+        compress: Annotated[bool, typer.Option("--compress", "-c", help="Compress the output PDF.")] = False,
+    ) -> None:
+    def merge_pdfs_internal(pdfs: list[str], output: str | None, compress: bool) -> None:
+        from pypdf import PdfReader, PdfWriter
+        writer = PdfWriter()
+        for pdf_path in pdfs:
+            reader = PdfReader(pdf_path)
+            for page in reader.pages:
+                writer.add_page(page)
+        output_path = output if output else "merged.pdf"
+        if compress:
+            try:
+                for p in writer.pages:
+                    try:
+                        # PageObject.compress_content_streams exists in pypdf
+                        p.compress_content_streams()
+                    except Exception:
+                        # best-effort: ignore per-page compression failures
+                        continue
+            except Exception:
+                pass
+            try:
+                writer.compress_identical_objects()
+            except Exception:
+                # non-fatal if this fails
+                pass
+        writer.write(output_path)
+        print(f"✅ Merged PDF saved to: {output_path}")
+    from machineconfig.utils.meta import lambda_to_python_script
+    code = lambda_to_python_script(lambda : merge_pdfs_internal(pdfs=pdfs, output=output, compress=compress),
+                                   in_global=True, import_module=False)
+    from machineconfig.utils.code import run_shell_script, get_uv_command_executing_python_script
+    uv_command, _py_file = get_uv_command_executing_python_script(python_script=code, uv_with=["pypdf"], uv_project_dir=None)
+    run_shell_script(uv_command)
+
+
+def compress_pdf(
+        pdf_input: Annotated[str, typer.Argument(..., help="Path to the input PDF file to compress.")],
+        output: Annotated[Optional[str], typer.Option("--output", "-o", help="Output compressed PDF file path.")] = None,
+        quality: Annotated[int, typer.Option("--quality", "-q", help="JPEG quality for image compression (0-100, 0=no change, 100=best).")] = 85,
+        image_dpi: Annotated[int, typer.Option("--image-dpi", "-d", help="Target DPI for image resampling. If set, images above this DPI will be downsampled.")] = 0,
+        # remove_images: Annotated[bool, typer.Option("--remove-images", "-r", help="Remove all images from the PDF.")] = False,
+        compress_streams: Annotated[bool, typer.Option("--compress-streams", "-c", help="Compress uncompressed streams.")] = True,
+        use_objstms: Annotated[bool, typer.Option("--object-streams", "-s", help="Use object streams for additional compression.")] = True,
+    ) -> None:
+    def compress_pdf_internal(pdf_input: str, output: str | None, quality: int, image_dpi: int, compress_streams: bool, use_objstms: bool) -> None:
+        import pymupdf
+        from pathlib import Path
+        output_path = output if output else pdf_input.replace(".pdf", "_compressed.pdf")
+        doc = pymupdf.open(pdf_input)
+        try:
+            # if remove_images:
+            #     for page in doc:
+            #         page.remove_images()
+            if quality > 0 or image_dpi > 0:
+                doc.rewrite_images(
+                    dpi_threshold=image_dpi if image_dpi > 0 else None,
+                    dpi_target=max(72, image_dpi - 10) if image_dpi > 72 else 72,
+                    quality=quality,
+                    lossy=True,
+                    lossless=True,
+                )
+            doc.save(
+                output_path,
+                deflate=compress_streams,
+                garbage=3,
+                use_objstms=1 if use_objstms else 0,
+            )
+            input_size = Path(pdf_input).stat().st_size
+            output_size = Path(output_path).stat().st_size
+            ratio = (1 - output_size / input_size) * 100
+            print(f"✅ Compressed PDF saved to: {output_path}")
+            print(f"   Original: {input_size / 1024 / 1024:.2f} MB")
+            print(f"   Compressed: {output_size / 1024 / 1024:.2f} MB")
+            print(f"   Reduction: {ratio:.1f}%")
+        finally:
+            doc.close()
+    from machineconfig.utils.meta import lambda_to_python_script
+    code = lambda_to_python_script(
+        lambda: compress_pdf_internal(pdf_input=pdf_input, output=output, quality=quality, image_dpi=image_dpi, compress_streams=compress_streams, use_objstms=use_objstms),
+        in_global=True,
+        import_module=False,
+    )
+    from machineconfig.utils.code import run_shell_script, get_uv_command_executing_python_script
+    uv_command, _py_file = get_uv_command_executing_python_script(python_script=code, uv_with=["pymupdf"], uv_project_dir=None)
+    run_shell_script(uv_command)
+

machineconfig/scripts/python/{devops_backup_retrieve.py → helpers_devops/devops_backup_retrieve.py}

@@ -2,33 +2,30 @@
 
 # import subprocess
 from machineconfig.utils.io import read_ini
-from machineconfig.utils.path_extended import PathExtended
 from machineconfig.utils.source_of_truth import LIBRARY_ROOT, DEFAULTS_PATH
 from machineconfig.utils.code import print_code
 from machineconfig.utils.options import choose_cloud_interactively, choose_from_options
-from machineconfig.scripts.python.helpers.helpers2 import ES
+from machineconfig.scripts.python.helpers_cloud.helpers2 import ES
 from platform import system
 from typing import Any, Literal, Optional
 from rich.console import Console
 from rich.panel import Panel
+from pathlib import Path
 import tomllib
 
 
 OPTIONS = Literal["BACKUP", "RETRIEVE"]
 
 
-def main_backup_retrieve(direction: OPTIONS, which: Optional[str] = None) -> None:
+def main_backup_retrieve(direction: OPTIONS, which: Optional[str], cloud: Optional[str]) -> None:
     console = Console()
-
     try:
-        cloud: str = read_ini(DEFAULTS_PATH)["general"]["rclone_config_name"]
+        cloud = read_ini(DEFAULTS_PATH)["general"]["rclone_config_name"]
         console.print(Panel(f"⚠️  DEFAULT CLOUD CONFIGURATION\n🌥️  Using default cloud: {cloud}", title="[bold blue]Cloud Configuration[/bold blue]", border_style="blue"))
     except (FileNotFoundError, KeyError, IndexError):
         console.print(Panel("🔍 DEFAULT CLOUD NOT FOUND\n🔄 Please select a cloud configuration from the options below", title="[bold red]Error: Cloud Not Found[/bold red]", border_style="red"))
         cloud = choose_cloud_interactively()
-
     bu_file: dict[str, Any] = tomllib.loads(LIBRARY_ROOT.joinpath("profile/backup.toml").read_text(encoding="utf-8"))
-
     console.print(Panel(f"🧰 LOADING BACKUP CONFIGURATION\n📄 File: {LIBRARY_ROOT.joinpath('profile/backup.toml')}", title="[bold blue]Backup Configuration[/bold blue]", border_style="blue"))
 
     if system() == "Linux":
@@ -59,13 +56,13 @@ def main_backup_retrieve(direction: OPTIONS, which: Optional[str] = None) -> Non
         flags += "e" if item["encrypt"] == "True" else ""
         flags += "r" if item["rel2home"] == "True" else ""
         flags += "o" if system().lower() in item_name else ""
-        console.print(Panel(f"📦 PROCESSING: {item_name}\n📂 Path: {PathExtended(item['path']).as_posix()}\n🏳️  Flags: {flags or 'None'}", title=f"[bold blue]Processing Item: {item_name}[/bold blue]", border_style="blue"))
+        console.print(Panel(f"📦 PROCESSING: {item_name}\n📂 Path: {Path(item['path']).as_posix()}\n🏳️  Flags: {flags or 'None'}", title=f"[bold blue]Processing Item: {item_name}[/bold blue]", border_style="blue"))
         if flags:
             flags = "-" + flags
         if direction == "BACKUP":
-            program += f"""\ncloud_copy "{PathExtended(item["path"]).as_posix()}" $cloud {flags}\n"""
+            program += f"""\ncloud_copy "{Path(item["path"]).as_posix()}" $cloud {flags}\n"""
         elif direction == "RETRIEVE":
-            program += f"""\ncloud_copy $cloud "{PathExtended(item["path"]).as_posix()}" {flags}\n"""
+            program += f"""\ncloud_copy $cloud "{Path(item["path"]).as_posix()}" {flags}\n"""
         else:
             console.print(Panel('❌ ERROR: INVALID DIRECTION\n⚠️  Direction must be either "BACKUP" or "RETRIEVE"', title="[bold red]Error: Invalid Direction[/bold red]", border_style="red"))
             raise RuntimeError(f"Unknown direction: {direction}")