zebra-day 0.0.37__py3-none-any.whl → 2.0.0__py3-none-any.whl

zebra_day/cli/gui.py

@@ -0,0 +1,338 @@
+"""GUI server management commands for zebra_day CLI."""
+
+import os
+import signal
+import subprocess
+import sys
+import time
+from datetime import datetime
+from pathlib import Path
+from typing import Optional, Literal
+
+import typer
+from rich.console import Console
+
+from zebra_day import paths as xdg
+
+gui_app = typer.Typer(help="Web UI server management commands")
+console = Console()
+
+# PID and log file locations
+STATE_DIR = xdg.get_state_dir()
+LOG_DIR = xdg.get_logs_dir()
+CONFIG_DIR = xdg.get_config_dir()
+PID_FILE = STATE_DIR / "gui.pid"
+DEFAULT_CERT_DIR = CONFIG_DIR / "certs"
+DEFAULT_CERT_FILE = DEFAULT_CERT_DIR / "server.crt"
+DEFAULT_KEY_FILE = DEFAULT_CERT_DIR / "server.key"
+
+
+def _ensure_dirs():
+    """Ensure state and log directories exist."""
+    STATE_DIR.mkdir(parents=True, exist_ok=True)
+    LOG_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def _get_log_file() -> Path:
+    """Get timestamped log file path."""
+    ts = datetime.now().strftime("%Y%m%d_%H%M%S")
+    return LOG_DIR / f"gui_{ts}.log"
+
+
+def _get_latest_log() -> Optional[Path]:
+    """Get the most recent log file."""
+    logs = sorted(LOG_DIR.glob("gui_*.log"), reverse=True)
+    return logs[0] if logs else None
+
+
+def _get_pid() -> Optional[int]:
+    """Get the running server PID if exists."""
+    if PID_FILE.exists():
+        try:
+            pid = int(PID_FILE.read_text().strip())
+            os.kill(pid, 0)
+            return pid
+        except (ValueError, ProcessLookupError, PermissionError):
+            PID_FILE.unlink(missing_ok=True)
+    return None
+
+
+def _check_auth_dependencies() -> bool:
+    """Check if auth dependencies are available."""
+    try:
+        import jose  # noqa: F401
+        return True
+    except ImportError:
+        return False
+
+
+def _resolve_ssl_paths(
+    cert: Optional[str], key: Optional[str]
+) -> tuple[Optional[str], Optional[str], bool]:
+    """
+    Resolve SSL certificate and key paths.
+
+    Priority:
+    1. Explicit --cert/--key arguments
+    2. SSL_CERT_PATH/SSL_KEY_PATH environment variables
+    3. Default paths in ~/.config/zebra_day/certs/
+
+    Returns:
+        Tuple of (cert_path, key_path, use_https)
+    """
+    cert_path = cert
+    key_path = key
+
+    # Check environment variables
+    if not cert_path:
+        cert_path = os.environ.get("SSL_CERT_PATH")
+    if not key_path:
+        key_path = os.environ.get("SSL_KEY_PATH")
+
+    # Check default paths
+    if not cert_path and DEFAULT_CERT_FILE.exists():
+        cert_path = str(DEFAULT_CERT_FILE)
+    if not key_path and DEFAULT_KEY_FILE.exists():
+        key_path = str(DEFAULT_KEY_FILE)
+
+    # Validate both exist
+    if cert_path and key_path:
+        if Path(cert_path).exists() and Path(key_path).exists():
+            return cert_path, key_path, True
+
+    return None, None, False
+
+
+@gui_app.command("start")
+def start(
+    port: int = typer.Option(8118, "--port", "-p", help="Port to run the server on"),
+    host: str = typer.Option("0.0.0.0", "--host", "-h", help="Host to bind to"),
+    auth: str = typer.Option("none", "--auth", "-a", help="Authentication mode: none or cognito"),
+    reload: bool = typer.Option(False, "--reload", "-r", help="Enable auto-reload (foreground)"),
+    background: bool = typer.Option(True, "--background/--foreground", "-b/-f", help="Run in background"),
+    cert: Optional[str] = typer.Option(None, "--cert", help="Path to SSL certificate file"),
+    key: Optional[str] = typer.Option(None, "--key", help="Path to SSL private key file"),
+    no_https: bool = typer.Option(False, "--no-https", help="Disable HTTPS even if certificates are available"),
+):
+    """Start the zebra_day web UI server.
+
+    By default, HTTPS is enabled if certificates are found in:
+    - Explicit --cert/--key arguments
+    - SSL_CERT_PATH/SSL_KEY_PATH environment variables
+    - ~/.config/zebra_day/certs/server.crt and server.key
+
+    Use --no-https to force HTTP mode.
+    """
+    _ensure_dirs()
+
+    # Validate auth option
+    if auth not in ("none", "cognito"):
+        console.print(f"[red]✗[/red] Invalid auth mode: {auth}. Use 'none' or 'cognito'.")
+        raise typer.Exit(1)
+
+    # Check if already running
+    pid = _get_pid()
+    if pid:
+        console.print(f"[yellow]⚠[/yellow]  Server already running (PID {pid})")
+        console.print(f"   URL: [cyan]http://{host}:{port}[/cyan]")
+        return
+
+    # Check auth dependencies if cognito mode
+    if auth == "cognito":
+        if not _check_auth_dependencies():
+            console.print("[red]✗[/red]  Authentication requested but python-jose is not installed")
+            console.print("   Install with: [cyan]pip install -e \".[auth]\"[/cyan]")
+            raise typer.Exit(1)
+
+        # Check required env vars
+        missing = []
+        if not os.environ.get("COGNITO_USER_POOL_ID"):
+            missing.append("COGNITO_USER_POOL_ID")
+        if not os.environ.get("COGNITO_APP_CLIENT_ID"):
+            missing.append("COGNITO_APP_CLIENT_ID")
+        if missing:
+            console.print("[red]✗[/red]  Cognito auth enabled but environment variables missing:")
+            for var in missing:
+                console.print(f"   • {var}")
+            raise typer.Exit(1)
+        console.print("[green]✓[/green]  Cognito authentication enabled")
+
+    # Resolve SSL paths
+    cert_path, key_path, use_https = _resolve_ssl_paths(cert, key)
+
+    if no_https:
+        use_https = False
+        cert_path = None
+        key_path = None
+
+    protocol = "https" if use_https else "http"
+
+    if use_https:
+        console.print(f"[green]✓[/green]  HTTPS enabled")
+        console.print(f"   Certificate: [dim]{cert_path}[/dim]")
+        console.print(f"   Private key: [dim]{key_path}[/dim]")
+    else:
+        console.print("[yellow]⚠[/yellow]  Running in HTTP mode (insecure)")
+        console.print("   For HTTPS, generate certificates with mkcert:")
+        console.print(f"   [dim]mkdir -p {DEFAULT_CERT_DIR}[/dim]")
+        console.print(f"   [dim]mkcert -cert-file {DEFAULT_CERT_FILE} -key-file {DEFAULT_KEY_FILE} localhost 127.0.0.1 ::1[/dim]")
+
+    # Build command with SSL parameters
+    ssl_args = ""
+    if use_https and cert_path and key_path:
+        ssl_args = f", ssl_certfile='{cert_path}', ssl_keyfile='{key_path}'"
+
+    cmd = [
+        sys.executable,
+        "-c",
+        f"from zebra_day.web.app import run_server; run_server(host='{host}', port={port}, reload={reload}, auth='{auth}'{ssl_args})",
+    ]
+
+    # Set up environment
+    env = os.environ.copy()
+    env["PYTHONUNBUFFERED"] = "1"
+    env["ZEBRA_DAY_AUTH_MODE"] = auth
+    if cert_path:
+        env["SSL_CERT_PATH"] = cert_path
+    if key_path:
+        env["SSL_KEY_PATH"] = key_path
+
+    if reload:
+        background = False
+        console.print("[dim]Auto-reload enabled (foreground mode)[/dim]")
+
+    if background:
+        log_file = _get_log_file()
+        log_f = open(log_file, "w", buffering=1)
+
+        proc = subprocess.Popen(
+            cmd,
+            stdout=log_f,
+            stderr=subprocess.STDOUT,
+            start_new_session=True,
+            cwd=Path.cwd(),
+            env=env,
+        )
+
+        time.sleep(2)
+        if proc.poll() is not None:
+            log_f.close()
+            console.print("[red]✗[/red]  Server failed to start. Check logs:")
+            console.print(f"   [dim]{log_file}[/dim]")
+            if log_file.exists():
+                content = log_file.read_text().strip()
+                if content:
+                    console.print("\n[dim]--- Last error ---[/dim]")
+                    for line in content.split("\n")[-10:]:
+                        console.print(f"   {line}")
+            raise typer.Exit(1)
+
+        PID_FILE.write_text(str(proc.pid))
+        console.print(f"[green]✓[/green]  Server started (PID {proc.pid})")
+        console.print(f"   URL: [cyan]{protocol}://{host}:{port}[/cyan]")
+        console.print(f"   Logs: [dim]{log_file}[/dim]")
+    else:
+        console.print(f"[green]✓[/green]  Starting server on [cyan]{protocol}://{host}:{port}[/cyan]")
+        console.print("   Press Ctrl+C to stop\n")
+        try:
+            result = subprocess.run(cmd, cwd=Path.cwd(), env=env)
+            if result.returncode != 0:
+                raise typer.Exit(result.returncode)
+        except KeyboardInterrupt:
+            console.print("\n[yellow]⚠[/yellow]  Server stopped")
+
+
+@gui_app.command("stop")
+def stop():
+    """Stop the zebra_day web UI server."""
+    pid = _get_pid()
+    if not pid:
+        console.print("[yellow]⚠[/yellow]  No server running")
+        return
+
+    try:
+        os.kill(pid, signal.SIGTERM)
+        for _ in range(10):
+            time.sleep(0.5)
+            try:
+                os.kill(pid, 0)
+            except ProcessLookupError:
+                break
+        else:
+            os.kill(pid, signal.SIGKILL)
+
+        PID_FILE.unlink(missing_ok=True)
+        console.print(f"[green]✓[/green]  Server stopped (was PID {pid})")
+    except ProcessLookupError:
+        PID_FILE.unlink(missing_ok=True)
+        console.print("[yellow]⚠[/yellow]  Server was not running")
+    except PermissionError:
+        console.print(f"[red]✗[/red]  Permission denied stopping PID {pid}")
+        raise typer.Exit(1)
+
+
+@gui_app.command("status")
+def status():
+    """Check the status of the zebra_day web UI server."""
+    pid = _get_pid()
+    if pid:
+        log_file = _get_latest_log()
+        # Check if HTTPS is likely enabled based on cert availability
+        _, _, use_https = _resolve_ssl_paths(None, None)
+        protocol = "https" if use_https else "http"
+        console.print(f"[green]●[/green]  Server is [green]running[/green] (PID {pid})")
+        console.print(f"   URL: [cyan]{protocol}://0.0.0.0:8118[/cyan]")
+        if log_file:
+            console.print(f"   Logs: [dim]{log_file}[/dim]")
+    else:
+        console.print("[dim]○[/dim]  Server is [dim]not running[/dim]")
+
+
+@gui_app.command("logs")
+def logs(
+    lines: int = typer.Option(50, "--tail", "-n", help="Number of lines to show"),
+    follow: bool = typer.Option(False, "--follow", "-f", help="Follow log output"),
+    all_logs: bool = typer.Option(False, "--all", "-a", help="List all log files"),
+):
+    """View zebra_day web UI server logs."""
+    if all_logs:
+        log_files = sorted(LOG_DIR.glob("gui_*.log"), reverse=True)
+        if not log_files:
+            console.print("[yellow]⚠[/yellow]  No log files found.")
+            return
+        console.print(f"[bold]Server log files ({len(log_files)}):[/bold]")
+        for lf in log_files[:20]:
+            size = lf.stat().st_size
+            console.print(f"  {lf.name}  [dim]({size:,} bytes)[/dim]")
+        return
+
+    log_file = _get_latest_log()
+    if not log_file:
+        console.print("[yellow]⚠[/yellow]  No log file found. Start the server first.")
+        return
+
+    if follow:
+        console.print(f"[dim]Following {log_file.name} (Ctrl+C to stop)[/dim]\n")
+        try:
+            subprocess.run(["tail", "-f", "-n", str(lines), str(log_file)])
+        except KeyboardInterrupt:
+            console.print("\n")
+    else:
+        console.print(f"[dim]Showing last {lines} lines of {log_file.name}[/dim]\n")
+        try:
+            subprocess.run(["tail", "-n", str(lines), str(log_file)])
+        except Exception as e:
+            console.print(f"[red]✗[/red]  Error reading log: {e}")
+
+
+@gui_app.command("restart")
+def restart(
+    port: int = typer.Option(8118, "--port", "-p", help="Port to run the server on"),
+    host: str = typer.Option("0.0.0.0", "--host", "-h", help="Host to bind to"),
+    auth: str = typer.Option("none", "--auth", "-a", help="Authentication mode: none or cognito"),
+):
+    """Restart the zebra_day web UI server."""
+    stop()
+    time.sleep(1)
+    start(port=port, host=host, auth=auth, reload=False, background=True)
+

zebra_day/cli/printer.py

@@ -0,0 +1,168 @@
+"""Printer fleet management commands for zebra_day CLI."""
+
+import json
+import socket
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from zebra_day import paths as xdg
+
+printer_app = typer.Typer(help="Printer fleet management commands")
+console = Console()
+
+
+def _get_local_ip() -> str:
+    """Get local IP address."""
+    try:
+        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        s.connect(("8.8.8.8", 80))
+        ip = s.getsockname()[0]
+        s.close()
+        return ip
+    except Exception:
+        return "127.0.0.1"
+
+
+@printer_app.command("scan")
+def scan(
+    ip_stub: Optional[str] = typer.Option(None, "--ip-stub", "-i", help="IP stub to scan (e.g., 192.168.1)"),
+    wait: float = typer.Option(0.25, "--wait", "-w", help="Seconds to wait per IP probe"),
+    lab: str = typer.Option("scan-results", "--lab", "-l", help="Lab name to assign found printers"),
+    json_output: bool = typer.Option(False, "--json", "-j", help="Output as JSON"),
+):
+    """Scan network for Zebra printers."""
+    # Determine IP stub if not provided
+    if not ip_stub:
+        local_ip = _get_local_ip()
+        ip_stub = ".".join(local_ip.split(".")[:-1])
+
+    if not json_output:
+        console.print(f"[cyan]→[/cyan] Scanning {ip_stub}.* for Zebra printers...")
+        console.print("[dim]  This may take a few minutes...[/dim]")
+
+    try:
+        import zebra_day.print_mgr as zdpm
+        zp = zdpm.zpl()
+        zp.probe_zebra_printers_add_to_printers_json(
+            ip_stub=ip_stub,
+            scan_wait=str(wait),
+            lab=lab,
+        )
+
+        found = []
+        if hasattr(zp, "printers") and "labs" in zp.printers and lab in zp.printers["labs"]:
+            for name, info in zp.printers["labs"][lab].items():
+                if isinstance(info, dict) and info.get("ip_address") not in ["dl_png"]:
+                    found.append({
+                        "name": name,
+                        "ip": info.get("ip_address"),
+                        "model": info.get("model", "unknown"),
+                        "serial": info.get("serial", "unknown"),
+                    })
+
+        if json_output:
+            console.print(json.dumps(found, indent=2))
+        else:
+            console.print(f"\n[green]✓[/green] Found {len(found)} printer(s)")
+            if found:
+                table = Table()
+                table.add_column("Name", style="cyan")
+                table.add_column("IP Address")
+                table.add_column("Model")
+                table.add_column("Serial")
+                for p in found:
+                    table.add_row(p["name"], p["ip"], p["model"], p["serial"])
+                console.print(table)
+
+    except Exception as e:
+        if json_output:
+            console.print(json.dumps({"error": str(e)}))
+        else:
+            console.print(f"[red]✗[/red] Scan error: {e}")
+        raise typer.Exit(1)
+
+
+@printer_app.command("list")
+def list_printers(
+    lab: Optional[str] = typer.Option(None, "--lab", "-l", help="Filter by lab name"),
+    json_output: bool = typer.Option(False, "--json", "-j", help="Output as JSON"),
+):
+    """List configured printers."""
+    try:
+        import zebra_day.print_mgr as zdpm
+        zp = zdpm.zpl()
+
+        printers = []
+        if hasattr(zp, "printers") and "labs" in zp.printers:
+            for lab_name, lab_printers in zp.printers["labs"].items():
+                if lab and lab_name != lab:
+                    continue
+                for name, info in lab_printers.items():
+                    if isinstance(info, dict):
+                        printers.append({
+                            "lab": lab_name,
+                            "name": name,
+                            "ip": info.get("ip_address", "unknown"),
+                            "model": info.get("model", "unknown"),
+                            "styles": info.get("label_zpl_styles", []),
+                        })
+
+        if json_output:
+            console.print(json.dumps(printers, indent=2))
+            return
+
+        if not printers:
+            console.print("[yellow]⚠[/yellow] No printers configured")
+            console.print("   Run [cyan]zday printer scan[/cyan] to discover printers")
+            return
+
+        table = Table(title="Configured Printers")
+        table.add_column("Lab", style="cyan")
+        table.add_column("Name")
+        table.add_column("IP Address")
+        table.add_column("Model")
+        table.add_column("Label Styles")
+        for p in printers:
+            styles = ", ".join(p["styles"][:2])
+            if len(p["styles"]) > 2:
+                styles += f" (+{len(p['styles'])-2})"
+            table.add_row(p["lab"], p["name"], p["ip"], p["model"], styles)
+        console.print(table)
+
+    except Exception as e:
+        if json_output:
+            console.print(json.dumps({"error": str(e)}))
+        else:
+            console.print(f"[red]✗[/red] Error: {e}")
+        raise typer.Exit(1)
+
+
+@printer_app.command("test")
+def test_print(
+    printer_name: str = typer.Argument(..., help="Printer name or IP address"),
+    lab: str = typer.Option("scan-results", "--lab", "-l", help="Lab containing the printer"),
+    label_style: str = typer.Option("tube_2inX1in", "--style", "-s", help="Label style to print"),
+):
+    """Send a test print to a specific printer."""
+    try:
+        import zebra_day.print_mgr as zdpm
+        zp = zdpm.zpl()
+
+        console.print(f"[cyan]→[/cyan] Sending test print to {printer_name}...")
+        result = zp.print_zpl(
+            lab=lab,
+            printer_name=printer_name,
+            uid_barcode="TEST-PRINT",
+            alt_a="Test Label",
+            alt_b="zebra_day CLI",
+            label_zpl_style=label_style,
+        )
+        console.print(f"[green]✓[/green] Test print sent successfully")
+
+    except Exception as e:
+        console.print(f"[red]✗[/red] Print error: {e}")
+        raise typer.Exit(1)
+

zebra_day/cli/template.py

@@ -0,0 +1,176 @@
+"""ZPL template management commands for zebra_day CLI."""
+
+import json
+import os
+import subprocess
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from zebra_day import paths as xdg
+
+template_app = typer.Typer(help="ZPL template management commands")
+console = Console()
+
+
+def _get_template_dirs() -> list[Path]:
+    """Get all template directories."""
+    from importlib.resources import files
+
+    dirs = []
+    # XDG data directory
+    xdg_styles = xdg.get_label_styles_dir()
+    if xdg_styles.exists():
+        dirs.append(xdg_styles)
+
+    # Package directory
+    try:
+        pkg_styles = Path(str(files("zebra_day"))) / "etc" / "label_styles"
+        if pkg_styles.exists():
+            dirs.append(pkg_styles)
+    except Exception:
+        pass
+
+    return dirs
+
+
+def _find_template(name: str) -> Optional[Path]:
+    """Find a template file by name."""
+    for template_dir in _get_template_dirs():
+        # Try exact match
+        for ext in ["", ".zpl", ".txt"]:
+            path = template_dir / f"{name}{ext}"
+            if path.exists():
+                return path
+        # Try with zpl_ prefix
+        for ext in ["", ".zpl", ".txt"]:
+            path = template_dir / f"zpl_{name}{ext}"
+            if path.exists():
+                return path
+    return None
+
+
+@template_app.command("list")
+def list_templates(
+    json_output: bool = typer.Option(False, "--json", "-j", help="Output as JSON"),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Show full paths"),
+):
+    """List available ZPL templates."""
+    templates = []
+
+    for template_dir in _get_template_dirs():
+        for f in template_dir.iterdir():
+            if f.is_file() and not f.name.startswith("."):
+                if f.suffix in [".zpl", ".txt", ""] or f.name.startswith("zpl_"):
+                    templates.append({
+                        "name": f.stem,
+                        "path": str(f),
+                        "size": f.stat().st_size,
+                        "source": "user" if "zebra_day" not in str(template_dir) else "package",
+                    })
+
+    # Dedupe by name, prefer user templates
+    seen = {}
+    for t in templates:
+        if t["name"] not in seen or t["source"] == "user":
+            seen[t["name"]] = t
+    templates = list(seen.values())
+
+    if json_output:
+        console.print(json.dumps(templates, indent=2))
+        return
+
+    if not templates:
+        console.print("[yellow]⚠[/yellow] No templates found")
+        return
+
+    table = Table(title="ZPL Templates")
+    table.add_column("Name", style="cyan")
+    table.add_column("Source")
+    table.add_column("Size")
+    if verbose:
+        table.add_column("Path", style="dim")
+
+    for t in sorted(templates, key=lambda x: x["name"]):
+        source_style = "[green]user[/green]" if t["source"] == "user" else "[dim]package[/dim]"
+        if verbose:
+            table.add_row(t["name"], source_style, f"{t['size']} bytes", t["path"])
+        else:
+            table.add_row(t["name"], source_style, f"{t['size']} bytes")
+
+    console.print(table)
+
+
+@template_app.command("preview")
+def preview(
+    template_name: str = typer.Argument(..., help="Template name to preview"),
+    output: Optional[str] = typer.Option(None, "--output", "-o", help="Output PNG file path"),
+):
+    """Generate a PNG preview of a ZPL template."""
+    template_path = _find_template(template_name)
+    if not template_path:
+        console.print(f"[red]✗[/red] Template not found: {template_name}")
+        raise typer.Exit(1)
+
+    console.print(f"[cyan]→[/cyan] Generating preview for {template_name}...")
+
+    try:
+        import zebra_day.print_mgr as zdpm
+        zp = zdpm.zpl()
+
+        # Read template
+        zpl_content = template_path.read_text()
+
+        # Generate PNG
+        if not output:
+            output_path = xdg.get_generated_files_dir() / f"{template_name}_preview.png"
+        else:
+            output_path = Path(output)
+
+        result = zp.generate_label_png(zpl_content, str(output_path), False)
+        console.print(f"[green]✓[/green] Preview generated: {output_path}")
+
+    except Exception as e:
+        console.print(f"[red]✗[/red] Preview error: {e}")
+        raise typer.Exit(1)
+
+
+@template_app.command("edit")
+def edit(
+    template_name: str = typer.Argument(..., help="Template name to edit"),
+    editor: Optional[str] = typer.Option(None, "--editor", "-e", help="Editor command"),
+):
+    """Open a ZPL template in an editor."""
+    template_path = _find_template(template_name)
+    if not template_path:
+        console.print(f"[red]✗[/red] Template not found: {template_name}")
+        raise typer.Exit(1)
+
+    # Determine editor
+    if not editor:
+        editor = os.environ.get("VISUAL") or os.environ.get("EDITOR") or "vi"
+
+    console.print(f"[cyan]→[/cyan] Opening {template_path} with {editor}...")
+    try:
+        subprocess.run([editor, str(template_path)])
+    except Exception as e:
+        console.print(f"[red]✗[/red] Error opening editor: {e}")
+        raise typer.Exit(1)
+
+
+@template_app.command("show")
+def show(
+    template_name: str = typer.Argument(..., help="Template name to display"),
+):
+    """Display the contents of a ZPL template."""
+    template_path = _find_template(template_name)
+    if not template_path:
+        console.print(f"[red]✗[/red] Template not found: {template_name}")
+        raise typer.Exit(1)
+
+    console.print(f"[dim]# {template_path}[/dim]\n")
+    console.print(template_path.read_text())
+