zebra-day 0.0.32__py3-none-any.whl → 1.0.2__py3-none-any.whl

zebra_day/cli/__init__.py

@@ -0,0 +1,240 @@
+"""zebra_day CLI - Zebra Printer Fleet Management CLI using Typer."""
+
+import os
+import sys
+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
+from zebra_day.cli.gui import gui_app
+from zebra_day.cli.printer import printer_app
+from zebra_day.cli.template import template_app
+from zebra_day.cli.cognito import cognito_app
+
+console = Console()
+
+app = typer.Typer(
+    name="zday",
+    help="zebra_day - Zebra Printer Fleet Management CLI",
+    add_completion=True,
+    no_args_is_help=True,
+)
+
+# Register subcommand groups
+app.add_typer(gui_app, name="gui", help="Web UI server management")
+app.add_typer(printer_app, name="printer", help="Printer fleet management")
+app.add_typer(template_app, name="template", help="ZPL template management")
+app.add_typer(cognito_app, name="cognito", help="Cognito authentication management")
+
+
+def _get_version() -> str:
+    """Get zebra_day version."""
+    try:
+        from importlib.metadata import version
+        return version("zebra_day")
+    except Exception:
+        return "dev"
+
+
+@app.command("version")
+def version():
+    """Show zebra_day version."""
+    console.print(f"zebra_day [cyan]{_get_version()}[/cyan]")
+
+
+@app.command("info")
+def info():
+    """Show zebra_day configuration and status."""
+    table = Table(title="zebra_day Info")
+    table.add_column("Property", style="cyan")
+    table.add_column("Value")
+
+    # Version
+    table.add_row("Version", _get_version())
+    table.add_row("Python", sys.version.split()[0])
+
+    # XDG Paths
+    table.add_row("Config Dir", str(xdg.get_config_dir()))
+    table.add_row("Data Dir", str(xdg.get_data_dir()))
+    table.add_row("Logs Dir", str(xdg.get_logs_dir()))
+    table.add_row("Cache Dir", str(xdg.get_cache_dir()))
+
+    # Printer config
+    printer_cfg = xdg.get_printer_config_path()
+    if printer_cfg.exists():
+        table.add_row("Printer Config", f"[green]{printer_cfg}[/green]")
+    else:
+        table.add_row("Printer Config", f"[yellow]not found[/yellow] [dim]({printer_cfg})[/dim]")
+
+    # Check if GUI server is running
+    pid_file = xdg.get_state_dir() / "gui.pid"
+    if pid_file.exists():
+        try:
+            pid = int(pid_file.read_text().strip())
+            os.kill(pid, 0)
+            table.add_row("GUI Server", f"[green]Running[/green] (PID {pid})")
+        except (ValueError, ProcessLookupError, PermissionError):
+            table.add_row("GUI Server", "[dim]Stopped[/dim]")
+    else:
+        table.add_row("GUI Server", "[dim]Stopped[/dim]")
+
+    console.print(table)
+
+
+@app.command("status")
+def status(
+    json_output: bool = typer.Option(False, "--json", "-j", help="Output as JSON"),
+):
+    """Show printer fleet status, network connectivity, and service health."""
+    import json as json_mod
+
+    status_data = {
+        "gui_server": {"running": False, "pid": None, "url": None},
+        "printers": {"configured": 0, "labs": []},
+        "config": {"exists": False, "path": None},
+    }
+
+    # Check GUI server
+    pid_file = xdg.get_state_dir() / "gui.pid"
+    if pid_file.exists():
+        try:
+            pid = int(pid_file.read_text().strip())
+            os.kill(pid, 0)
+            status_data["gui_server"]["running"] = True
+            status_data["gui_server"]["pid"] = pid
+            status_data["gui_server"]["url"] = "http://0.0.0.0:8118"
+        except (ValueError, ProcessLookupError, PermissionError):
+            pass
+
+    # Check printer config
+    printer_cfg = xdg.get_printer_config_path()
+    status_data["config"]["path"] = str(printer_cfg)
+    if printer_cfg.exists():
+        status_data["config"]["exists"] = True
+        try:
+            import zebra_day.print_mgr as zdpm
+            zp = zdpm.zpl()
+            if hasattr(zp, "printers") and "labs" in zp.printers:
+                labs = list(zp.printers["labs"].keys())
+                status_data["printers"]["labs"] = labs
+                total_printers = sum(
+                    len([k for k in zp.printers["labs"][lab].keys()])
+                    for lab in labs
+                )
+                status_data["printers"]["configured"] = total_printers
+        except Exception:
+            pass
+
+    if json_output:
+        console.print(json_mod.dumps(status_data, indent=2))
+        return
+
+    # Human-readable output
+    console.print("\n[bold]Service Status[/bold]")
+    if status_data["gui_server"]["running"]:
+        console.print(f"  [green]●[/green] GUI Server: [green]Running[/green] (PID {status_data['gui_server']['pid']})")
+        console.print(f"    URL: [cyan]{status_data['gui_server']['url']}[/cyan]")
+    else:
+        console.print("  [dim]○[/dim] GUI Server: [dim]Not running[/dim]")
+
+    console.print("\n[bold]Printer Fleet[/bold]")
+    if status_data["config"]["exists"]:
+        console.print(f"  [green]●[/green] Config: [green]Loaded[/green]")
+        console.print(f"    Printers: {status_data['printers']['configured']}")
+        console.print(f"    Labs: {', '.join(status_data['printers']['labs']) or 'none'}")
+    else:
+        console.print("  [yellow]○[/yellow] Config: [yellow]Not found[/yellow]")
+        console.print(f"    Run [cyan]zday bootstrap[/cyan] to initialize")
+    console.print()
+
+
+@app.command("bootstrap")
+def bootstrap(
+    ip_stub: Optional[str] = typer.Option(None, "--ip-stub", "-i", help="IP stub for printer scan (e.g., 192.168.1)"),
+    skip_scan: bool = typer.Option(False, "--skip-scan", "-s", help="Skip printer network scan"),
+    json_output: bool = typer.Option(False, "--json", "-j", help="Output as JSON"),
+):
+    """Initialize configuration, scan for printers, and setup first-time environment.
+
+    This is the recommended first-time setup command. It will:
+    1. Create XDG configuration directories
+    2. Initialize printer configuration
+    3. Scan the network for Zebra printers (unless --skip-scan)
+    """
+    import json as json_mod
+    import time
+    import socket
+
+    result = {
+        "config_dir": str(xdg.get_config_dir()),
+        "data_dir": str(xdg.get_data_dir()),
+        "printers_found": 0,
+        "labs": [],
+    }
+
+    if not json_output:
+        console.print("\n[bold cyan]zebra_day Bootstrap[/bold cyan]\n")
+        console.print("[green]✓[/green] Config directory: " + result["config_dir"])
+        console.print("[green]✓[/green] Data directory: " + result["data_dir"])
+
+    if skip_scan:
+        if not json_output:
+            console.print("[dim]Skipping printer scan (--skip-scan)[/dim]")
+    else:
+        # Determine IP stub
+        if not ip_stub:
+            try:
+                s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+                s.connect(("8.8.8.8", 80))
+                local_ip = s.getsockname()[0]
+                s.close()
+                ip_stub = ".".join(local_ip.split(".")[:-1])
+            except Exception:
+                ip_stub = "192.168.1"
+
+        if not json_output:
+            console.print(f"\n[cyan]→[/cyan] Scanning network for Zebra printers ({ip_stub}.*)...")
+            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)
+
+            if hasattr(zp, "printers") and "labs" in zp.printers:
+                for lab in zp.printers["labs"]:
+                    printers_in_lab = len([k for k in zp.printers["labs"][lab].keys()])
+                    result["printers_found"] += printers_in_lab
+                    result["labs"].append(lab)
+
+            if not json_output:
+                console.print(f"[green]✓[/green] Scan complete: {result['printers_found']} printer(s) found")
+                if result["labs"]:
+                    console.print(f"    Labs: {', '.join(result['labs'])}")
+        except Exception as e:
+            if not json_output:
+                console.print(f"[yellow]⚠[/yellow] Scan error: {e}")
+
+    if json_output:
+        console.print(json_mod.dumps(result, indent=2))
+    else:
+        console.print("\n[bold green]✓ Bootstrap complete![/bold green]")
+        console.print("\n[bold]Next steps:[/bold]")
+        console.print("  zday gui start     Start the web UI")
+        console.print("  zday printer list  Show configured printers")
+        console.print("  zday info          Show configuration details")
+        console.print()
+
+
+def main():
+    """Main CLI entry point."""
+    app()
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
+

zebra_day/cli/cognito.py

@@ -0,0 +1,121 @@
+"""Cognito authentication management commands for zebra_day CLI.
+
+This module delegates to daylily-cognito if available, otherwise provides
+basic status and info commands.
+"""
+
+import os
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+console = Console()
+
+
+def _is_cognito_available() -> bool:
+    """Check if daylily-cognito is installed."""
+    try:
+        from daylily_cognito.cli import cognito_app as _  # noqa: F401
+        return True
+    except ImportError:
+        return False
+
+
+def _get_cognito_app() -> typer.Typer:
+    """Get the Cognito CLI app, either from daylily-cognito or a fallback."""
+    if _is_cognito_available():
+        # Import and return the full cognito CLI from daylily-cognito
+        from daylily_cognito.cli import cognito_app
+        return cognito_app
+    else:
+        # Return a minimal fallback app
+        return _create_fallback_app()
+
+
+def _create_fallback_app() -> typer.Typer:
+    """Create a fallback cognito app with basic commands."""
+    app = typer.Typer(help="Cognito authentication management (limited - daylily-cognito not installed)")
+
+    @app.command("status")
+    def status():
+        """Show current Cognito authentication configuration."""
+        table = Table(title="Cognito Configuration")
+        table.add_column("Variable", style="cyan")
+        table.add_column("Value")
+        table.add_column("Status")
+
+        pool_id = os.environ.get("COGNITO_USER_POOL_ID")
+        client_id = os.environ.get("COGNITO_APP_CLIENT_ID")
+        region = os.environ.get("COGNITO_REGION", os.environ.get("AWS_DEFAULT_REGION"))
+
+        if pool_id:
+            # Truncate for display
+            display = pool_id[:15] + "..." if len(pool_id) > 15 else pool_id
+            table.add_row("COGNITO_USER_POOL_ID", display, "[green]Set[/green]")
+        else:
+            table.add_row("COGNITO_USER_POOL_ID", "-", "[yellow]Not set[/yellow]")
+
+        if client_id:
+            display = client_id[:15] + "..." if len(client_id) > 15 else client_id
+            table.add_row("COGNITO_APP_CLIENT_ID", display, "[green]Set[/green]")
+        else:
+            table.add_row("COGNITO_APP_CLIENT_ID", "-", "[yellow]Not set[/yellow]")
+
+        if region:
+            table.add_row("COGNITO_REGION", region, "[green]Set[/green]")
+        else:
+            table.add_row("COGNITO_REGION", "-", "[yellow]Not set[/yellow]")
+
+        console.print(table)
+
+        # Summary
+        if pool_id and client_id:
+            console.print("\n[green]✓[/green] Cognito is configured")
+            console.print("  Start server with: [cyan]zday gui start --auth cognito[/cyan]")
+        else:
+            console.print("\n[yellow]⚠[/yellow] Cognito is not fully configured")
+            console.print("  Set environment variables or install daylily-cognito for full management")
+
+    @app.command("info")
+    def info():
+        """Display information about Cognito setup requirements."""
+        console.print("\n[bold]Cognito Authentication Setup[/bold]\n")
+        console.print("To enable Cognito authentication for zebra_day:\n")
+
+        console.print("[bold]1. Install auth dependencies:[/bold]")
+        console.print("   [cyan]pip install -e \".[auth]\"[/cyan]\n")
+
+        console.print("[bold]2. Set environment variables:[/bold]")
+        console.print("   [cyan]export COGNITO_USER_POOL_ID=your-pool-id[/cyan]")
+        console.print("   [cyan]export COGNITO_APP_CLIENT_ID=your-client-id[/cyan]")
+        console.print("   [cyan]export COGNITO_REGION=us-west-2[/cyan]  # optional\n")
+
+        console.print("[bold]3. Start server with authentication:[/bold]")
+        console.print("   [cyan]zday gui start --auth cognito[/cyan]\n")
+
+        if not _is_cognito_available():
+            console.print("[dim]For full Cognito management (create, teardown), install daylily-cognito:[/dim]")
+            console.print("[dim]  pip install daylily-cognito[/dim]")
+
+    @app.command("create")
+    def create():
+        """Create/configure a Cognito user pool (requires daylily-cognito)."""
+        console.print("[yellow]⚠[/yellow] This command requires daylily-cognito")
+        console.print("  Install with: [cyan]pip install -e \".[auth]\"[/cyan]")
+        raise typer.Exit(1)
+
+    @app.command("teardown")
+    def teardown():
+        """Remove Cognito configuration (requires daylily-cognito)."""
+        console.print("[yellow]⚠[/yellow] This command requires daylily-cognito")
+        console.print("  Install with: [cyan]pip install -e \".[auth]\"[/cyan]")
+        raise typer.Exit(1)
+
+    return app
+
+
+# Export the cognito app - either the full version from daylily-cognito or the fallback
+cognito_app = _get_cognito_app()
+

zebra_day/cli/gui.py

@@ -0,0 +1,255 @@
+"""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()
+PID_FILE = STATE_DIR / "gui.pid"
+
+
+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
+
+
+@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"),
+):
+    """Start the zebra_day web UI server."""
+    _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")
+
+    # Build command
+    cmd = [
+        sys.executable,
+        "-c",
+        f"from zebra_day.web.app import run_server; run_server(host='{host}', port={port}, reload={reload}, auth='{auth}')",
+    ]
+
+    # Set up environment
+    env = os.environ.copy()
+    env["PYTHONUNBUFFERED"] = "1"
+    env["ZEBRA_DAY_AUTH_MODE"] = auth
+
+    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]http://{host}:{port}[/cyan]")
+        console.print(f"   Logs: [dim]{log_file}[/dim]")
+    else:
+        console.print(f"[green]✓[/green]  Starting server on [cyan]http://{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()
+        console.print(f"[green]●[/green]  Server is [green]running[/green] (PID {pid})")
+        console.print(f"   URL: [cyan]http://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)
+