qalita 2.3.2__py3-none-any.whl → 2.5.2__py3-none-any.whl

qalita/__main__.py

@@ -18,19 +18,19 @@ pass_config = click.make_pass_decorator(Config, ensure=True)
 @click.option(
     "--ui",
     is_flag=True,
-    default=os.environ.get("QALITA_AGENT_UI", False),
+    default=os.environ.get("QALITA_WORKER_UI", False),
     help="Open the local web UI dashboard",
 )
 @click.option(
     "--port",
-    default=os.environ.get("QALITA_AGENT_UI_PORT", 7070),
+    default=os.environ.get("QALITA_WORKER_UI_PORT", 7070),
     show_default=True,
     type=int,
     help="Port for the local web UI",
 )
 @click.option(
     "--host",
-    default=os.environ.get("QALITA_AGENT_UI_HOST", "localhost"),
+    default=os.environ.get("QALITA_WORKER_UI_HOST", "localhost"),
     show_default=True,
     help="Host interface to bind the local web UI",
 )
@@ -45,14 +45,218 @@ def cli(ctx, ui=False, port=7070, host="localhost"):
     ----------------------------------------------------------------------------"""
     if ui:
         try:
+            import subprocess
+            import sys
+            import threading
+            import time
             from qalita.web.app import run_dashboard_ui
-        except Exception as exc:
-            logger.error(f"Unable to start web UI: {exc}")
-        else:
+
             # Instantiate a Config to pass into the UI
             cfg = Config()
             cfg.load_source_config(verbose=False)
-            run_dashboard_ui(cfg, host=host, port=port)
+
+            # Flask API runs on port + 1 (e.g., 7071 if UI is 7070)
+            flask_port = port + 1
+            flask_host = host
+
+            # Start Flask API in a separate thread
+            def run_flask():
+                run_dashboard_ui(cfg, host=flask_host, port=flask_port)
+
+            flask_thread = threading.Thread(target=run_flask, daemon=True)
+            flask_thread.start()
+
+            # Wait a bit for Flask to start
+            time.sleep(1)
+
+            # Start Next.js frontend
+            frontend_dir = os.path.join(os.path.dirname(__file__), "..", "frontend")
+            if not os.path.isdir(frontend_dir):
+                logger.error(f"Frontend directory not found: {frontend_dir}")
+                logger.error("Please run 'npm install' and 'npm run build' in the frontend directory first")
+                raise SystemExit(1)
+
+            # Check Node.js version (Next.js 16 requires >= 20.9.0)
+            # Try to use nvm's node if available, otherwise use system node
+            node_cmd = "node"
+            nvm_node_path = None
+
+            # Check for nvm in common locations
+            nvm_paths = [
+                os.path.expanduser("~/.nvm/versions/node"),
+                os.path.expanduser("~/.config/nvm/versions/node"),
+            ]
+
+            # Try to find Node.js 20+ in nvm directories
+            for nvm_base in nvm_paths:
+                if os.path.isdir(nvm_base):
+                    try:
+                        # List directories and find the highest v20+ version
+                        versions = []
+                        for item in os.listdir(nvm_base):
+                            if item.startswith("v20.") or item.startswith("v21.") or item.startswith("v22."):
+                                versions.append(item)
+                        if versions:
+                            # Sort and get the highest version
+                            versions.sort(reverse=True)
+                            nvm_node_path = os.path.join(nvm_base, versions[0], "bin", "node")
+                            if os.path.exists(nvm_node_path):
+                                node_cmd = nvm_node_path
+                                logger.info(f"Using Node.js from nvm: {nvm_node_path}")
+                                break
+                    except Exception:
+                        pass
+
+            try:
+                node_version_result = subprocess.run(
+                    [node_cmd, "--version"],
+                    capture_output=True,
+                    text=True,
+                    check=True,
+                )
+                node_version = node_version_result.stdout.strip()
+                # Extract major and minor version numbers
+                version_parts = node_version.lstrip("v").split(".")
+                major_version = int(version_parts[0])
+                minor_version = int(version_parts[1]) if len(version_parts) > 1 else 0
+
+                if major_version < 20 or (major_version == 20 and minor_version < 9):
+                    logger.error(f"Node.js version {node_version} is installed, but Next.js 16 requires Node.js >= 20.9.0")
+                    logger.error("Please upgrade Node.js to version 20.9.0 or higher")
+                    if not nvm_node_path:
+                        logger.error("If you're using nvm, make sure to run: nvm use 20")
+                    logger.error("You can install Node.js from https://nodejs.org/ or use nvm: nvm install 20")
+                    raise SystemExit(1)
+                logger.info(f"Node.js version: {node_version}")
+
+            except (subprocess.CalledProcessError, FileNotFoundError, ValueError) as e:
+                logger.error("Node.js is not installed or not found in PATH")
+                logger.error("Please install Node.js >= 20.9.0 from https://nodejs.org/")
+                logger.error("Or use nvm: nvm install 20 && nvm use 20")
+                raise SystemExit(1)
+
+            # Set environment variable for Flask API URL and configure PATH for Node.js
+            env = os.environ.copy()
+            env["FLASK_API_URL"] = f"http://{flask_host}:{flask_port}"
+            env["PORT"] = str(port)
+            env["HOSTNAME"] = host
+
+            # Determine which node/npm to use and ensure they're in PATH
+            import platform
+            if nvm_node_path:
+                node_bin = nvm_node_path
+                node_bin_dir = os.path.dirname(nvm_node_path)
+                npm_cmd = os.path.join(node_bin_dir, "npm")
+                if not os.path.exists(npm_cmd):
+                    npm_cmd = "npm"  # Fallback
+                # Ensure nvm's bin directory is FIRST in PATH so npm uses the right node
+                current_path = env.get("PATH", "")
+                path_parts = current_path.split(":") if current_path else []
+                # Remove node_bin_dir if it's already there
+                path_parts = [p for p in path_parts if p != node_bin_dir]
+                # Put nvm's bin directory first
+                env["PATH"] = f"{node_bin_dir}:{':'.join(path_parts)}"
+            else:
+                node_bin = "node.exe" if platform.system() == "Windows" else "node"
+                npm_cmd = "npm"
+
+            # Check if node_modules exists, if not, try to install
+            node_modules_path = os.path.join(frontend_dir, "node_modules")
+            if not os.path.exists(node_modules_path):
+                logger.info("Installing Next.js dependencies...")
+                install_result = subprocess.run(
+                    [npm_cmd, "install"],
+                    cwd=frontend_dir,
+                    capture_output=True,
+                    env=env,
+                )
+                if install_result.returncode != 0:
+                    logger.error("Failed to install Next.js dependencies")
+                    logger.error(install_result.stderr.decode() if install_result.stderr else "Unknown error")
+                    raise SystemExit(1)
+
+            logger.info(f"Starting Flask API on http://{flask_host}:{flask_port}")
+            logger.info(f"Starting Next.js frontend on http://{host}:{port}")
+            logger.info(f"QALITA CLI UI is running. Open http://{host}:{port}")
+
+            # Check for production build (standalone mode)
+            if os.path.exists(os.path.join(frontend_dir, ".next", "standalone")):
+                # Use next start from frontend directory instead of standalone
+                # This ensures static files are served correctly
+                logger.info("Running Next.js in production mode (standalone build detected)...")
+                next_bin = os.path.join(frontend_dir, "node_modules", ".bin", "next")
+                if os.path.exists(next_bin):
+                    subprocess.run(
+                        [node_bin, next_bin, "start", "-p", str(port), "-H", host],
+                        cwd=frontend_dir,
+                        env=env,
+                    )
+                else:
+                    subprocess.run(
+                        [npm_cmd, "start"],
+                        cwd=frontend_dir,
+                        env=env,
+                    )
+            elif os.path.exists(os.path.join(frontend_dir, ".next", "server")):
+                # Production build exists but not standalone, use next start directly with args
+                logger.info("Running Next.js in production mode...")
+                next_bin = os.path.join(frontend_dir, "node_modules", ".bin", "next")
+                if not os.path.exists(next_bin):
+                    # Fallback to npm start
+                    subprocess.run(
+                        [npm_cmd, "start"],
+                        cwd=frontend_dir,
+                        env=env,
+                    )
+                else:
+                    subprocess.run(
+                        [node_bin, next_bin, "start", "-p", str(port), "-H", host],
+                        cwd=frontend_dir,
+                        env=env,
+                    )
+            else:
+                # Development mode - use next directly with node from nvm
+                logger.info("Running Next.js in development mode...")
+                next_cli = os.path.join(frontend_dir, "node_modules", "next", "dist", "bin", "next")
+                next_bin = os.path.join(frontend_dir, "node_modules", ".bin", "next")
+
+                # Try to use the actual Next.js CLI file directly (no shebang issues)
+                if os.path.exists(next_cli):
+                    logger.info(f"Using Node.js: {node_bin} to run Next.js")
+                    subprocess.run(
+                        [node_bin, next_cli, "dev", "-p", str(port), "-H", host],
+                        cwd=frontend_dir,
+                        env=env,
+                    )
+                elif os.path.exists(next_bin):
+                    # Use node to execute next script (node ignores shebang when called directly)
+                    logger.info(f"Using Node.js: {node_bin} to run Next.js")
+                    subprocess.run(
+                        [node_bin, next_bin, "dev", "-p", str(port), "-H", host],
+                        cwd=frontend_dir,
+                        env=env,
+                    )
+                else:
+                    # Fallback: use npm but ensure PATH is set correctly
+                    logger.warning("next binary not found, trying npm with PATH override...")
+                    # Verify node version in env before running
+                    verify_result = subprocess.run(
+                        [node_bin, "--version"],
+                        capture_output=True,
+                        text=True,
+                        env=env,
+                    )
+                    if verify_result.returncode == 0:
+                        logger.info(f"Node.js version in env: {verify_result.stdout.strip()}")
+                    subprocess.run(
+                        [npm_cmd, "run", "dev", "--", "-p", str(port), "-H", host],
+                        cwd=frontend_dir,
+                        env=env,
+                    )
+        except Exception as exc:
+            logger.error(f"Unable to start web UI: {exc}")
+            import traceback
+            traceback.print_exc()
         raise SystemExit(0)
     # If invoked without a subcommand and without --ui, show help
     if ctx.invoked_subcommand is None:
@@ -70,11 +274,11 @@ def version():
 
 
 def add_commands_to_cli():
-    from qalita.commands import agent, source, pack
+    from qalita.commands import worker, source, pack
 
     # Add pack command group to cli
     cli.add_command(pack.pack)
-    cli.add_command(agent.agent)
+    cli.add_command(worker.worker)
     cli.add_command(source.source)