quantum-framework 0.18.0__py3-none-any.whl

quantum_admin/services/_component_test_generator.py

@@ -0,0 +1,205 @@
+"""
+Quantum Admin - Component Test Generator
+
+(Copied from components/admin/_test_generator.py, which generated imports from
+the old src/ layout — `from core.parser import ...` — so every generated test
+failed with ModuleNotFoundError. The imports now use the quantum package.)
+
+Analyzes a .q component file and generates pytest test code
+based on the component's structure (actions, queries, feature tags).
+"""
+import os
+import re
+from datetime import datetime
+
+
+class ComponentTestGenerator:
+    def __init__(self, component_path, base_dir):
+        self.component_path = component_path
+        self.base_dir = base_dir
+        self.full_path = os.path.join(base_dir, 'components', component_path)
+        self.content = ''
+        self.component_name = ''
+        self.actions = []
+        self.queries = []
+        self.feature_tags = set()
+
+    def analyze(self):
+        """Parse the .q file and extract structure."""
+        if not os.path.isfile(self.full_path):
+            return
+
+        with open(self.full_path, 'r', encoding='utf-8', errors='ignore') as f:
+            self.content = f.read()
+
+        # Component name
+        m = re.search(r'<q:component\s+name="([^"]+)"', self.content)
+        if m:
+            self.component_name = m.group(1)
+        else:
+            self.component_name = os.path.splitext(os.path.basename(self.component_path))[0]
+
+        # Actions with their params
+        self.actions = []
+        action_pattern = re.compile(
+            r'<q:action\s+name="([^"]+)"[^>]*>(.*?)</q:action>',
+            re.DOTALL
+        )
+        param_pattern = re.compile(
+            r'<q:param\s+([^>]+)/>'
+        )
+        for am in action_pattern.finditer(self.content):
+            action_name = am.group(1)
+            action_body = am.group(2)
+            params = []
+            for pm in param_pattern.finditer(action_body):
+                attrs = pm.group(1)
+                pname = ''
+                ptype = 'string'
+                prequired = False
+                nm = re.search(r'name="([^"]+)"', attrs)
+                if nm:
+                    pname = nm.group(1)
+                tm = re.search(r'type="([^"]+)"', attrs)
+                if tm:
+                    ptype = tm.group(1)
+                if 'required="true"' in attrs:
+                    prequired = True
+                if pname:
+                    params.append({
+                        'name': pname,
+                        'type': ptype,
+                        'required': prequired,
+                    })
+            self.actions.append({
+                'name': action_name,
+                'params': params,
+            })
+
+        # Queries
+        self.queries = []
+        query_pattern = re.compile(r'<q:query\s+name="([^"]+)"')
+        for qm in query_pattern.finditer(self.content):
+            self.queries.append(qm.group(1))
+
+        # Feature tags
+        tag_pattern = re.compile(r'<q:(\w+)')
+        self.feature_tags = set(tag_pattern.findall(self.content))
+        self.feature_tags.discard('component')
+        self.feature_tags.discard('param')
+
+    def generate(self):
+        """Generate pytest code based on analysis."""
+        lines = []
+        ts = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+        sanitized = self.component_path.replace('/', '_').replace('.q', '')
+
+        # Header
+        lines.append(f'"""')
+        lines.append(f'Auto-generated tests for {self.component_name}')
+        lines.append(f'Component: components/{self.component_path}')
+        lines.append(f'Generated: {ts}')
+        lines.append(f'"""')
+        lines.append(f'import os')
+        lines.append(f'import sys')
+        lines.append(f'import pytest')
+        lines.append(f'')
+        lines.append(f'# Setup path')
+        lines.append(f"BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))")
+        lines.append(f'')
+        lines.append(f"COMPONENT_PATH = os.path.join(BASE_DIR, 'components', '{self.component_path}')")
+        lines.append(f'')
+
+        # Smoke test class
+        lines.append(f'class TestSmoke{self.component_name}:')
+        lines.append(f'    """Smoke tests: verify the component parses without errors."""')
+        lines.append(f'')
+        lines.append(f'    def test_component_file_exists(self):')
+        lines.append(f'        """Component .q file should exist on disk."""')
+        lines.append(f'        assert os.path.isfile(COMPONENT_PATH), f"Component file not found: {{COMPONENT_PATH}}"')
+        lines.append(f'')
+        lines.append(f'    def test_parse_without_errors(self):')
+        lines.append(f'        """Component should parse into a valid AST."""')
+        lines.append(f'        from quantum.core.parser import QuantumParser')
+        lines.append(f'        parser = QuantumParser()')
+        lines.append(f'        with open(COMPONENT_PATH, "r", encoding="utf-8") as f:')
+        lines.append(f'            source = f.read()')
+        lines.append(f'        ast = parser.parse(source)')
+        lines.append(f'        assert ast is not None, "Parser returned None"')
+        lines.append(f'')
+
+        # Action test classes
+        for action in self.actions:
+            aname = action['name']
+            class_name = aname[0].upper() + aname[1:]
+            lines.append(f'')
+            lines.append(f'class TestAction{class_name}:')
+            lines.append(f'    """Tests for action: {aname}"""')
+            lines.append(f'')
+
+            required_params = [p for p in action['params'] if p['required']]
+            all_params = action['params']
+
+            if all_params:
+                lines.append(f'    def test_valid_params(self):')
+                lines.append(f'        """Action {aname} should accept all required params."""')
+                lines.append(f'        from quantum.core.parser import QuantumParser')
+                lines.append(f'        parser = QuantumParser()')
+                lines.append(f'        with open(COMPONENT_PATH, "r", encoding="utf-8") as f:')
+                lines.append(f'            source = f.read()')
+                lines.append(f'        ast = parser.parse(source)')
+                lines.append(f'        # Verify the action node exists in AST')
+                lines.append(f'        found = False')
+                lines.append(f'        for node in getattr(ast, "children", getattr(ast, "statements", [])):')
+                lines.append(f'            if hasattr(node, "name") and getattr(node, "name", None) == "{aname}":')
+                lines.append(f'                found = True')
+                lines.append(f'                break')
+                lines.append(f'        assert found, "Action {aname} not found in AST"')
+                lines.append(f'')
+
+            for param in required_params:
+                pname = param['name']
+                lines.append(f'    def test_missing_{pname}(self):')
+                lines.append(f'        """Omitting required param {pname} should be detectable."""')
+                lines.append(f'        # The action requires "{pname}" — verifying param definition exists')
+                lines.append(f'        import re')
+                lines.append(f'        with open(COMPONENT_PATH, "r", encoding="utf-8") as f:')
+                lines.append(f'            source = f.read()')
+                lines.append(f'        pattern = r\'<q:param\\s+[^>]*name="{pname}"[^>]*required="true"\'')
+                lines.append(f'        assert re.search(pattern, source), "Required param {pname} not found in component"')
+                lines.append(f'')
+
+        # Query test classes
+        for qname in self.queries:
+            class_name = qname[0].upper() + qname[1:]
+            lines.append(f'')
+            lines.append(f'class TestQuery{class_name}:')
+            lines.append(f'    """Tests for query: {qname}"""')
+            lines.append(f'')
+            lines.append(f'    def test_query_node_exists(self):')
+            lines.append(f'        """AST should contain a QueryNode with name={qname}."""')
+            lines.append(f'        from quantum.core.parser import QuantumParser')
+            lines.append(f'        from quantum.core.ast_nodes import QueryNode')
+            lines.append(f'        parser = QuantumParser()')
+            lines.append(f'        with open(COMPONENT_PATH, "r", encoding="utf-8") as f:')
+            lines.append(f'            source = f.read()')
+            lines.append(f'        ast = parser.parse(source)')
+            lines.append(f'        # Walk AST to find QueryNode')
+            lines.append(f'        def find_queries(node):')
+            lines.append(f'            results = []')
+            lines.append(f'            if isinstance(node, QueryNode):')
+            lines.append(f'                results.append(node)')
+            lines.append(f'            for child in getattr(node, "children", getattr(node, "statements", [])):')
+            lines.append(f'                results.extend(find_queries(child))')
+            lines.append(f'            return results')
+            lines.append(f'        queries = find_queries(ast)')
+            lines.append(f'        names = [getattr(q, "name", "") for q in queries]')
+            lines.append(f'        assert "{qname}" in names, f"QueryNode {qname} not found. Found: {{names}}"')
+            lines.append(f'')
+
+        # Summary
+        lines.append(f'')
+        lines.append(f'# Summary: {len(self.actions)} action(s), {len(self.queries)} query/queries, tags: {", ".join(sorted(self.feature_tags)) or "none"}')
+        lines.append(f'')
+
+        return '\n'.join(lines)

quantum_admin/services/_yaml_editor.py

@@ -0,0 +1,82 @@
+"""Edita valores de um YAML de configuração preservando comentários e ordem.
+
+components/admin/settings.q regravava quantum.config.yaml com yaml.dump: todo
+comentário do arquivo sumia — inclusive os avisos de segurança sobre host e
+debug —, e um erro de escrita era engolido. Sem ruamel.yaml no projeto, este
+editor cobre o caso do admin: chaves de primeiro nível dentro de uma seção
+(`server.port`), valores escalares.
+
+Nunca grava algo diferente do pedido: depois de editar o texto, relê o
+resultado com yaml.safe_load e confere que (1) cada chave pedida tem o valor
+pedido e (2) todo o resto continua igual. Se não, levanta e o arquivo fica como
+estava. A gravação é atômica.
+"""
+
+import copy
+import os
+import re
+from pathlib import Path
+from typing import Any, Dict, Tuple
+
+import yaml
+
+
+class YamlEditError(RuntimeError):
+    """A edição não produziria exatamente o arquivo pedido; nada foi gravado."""
+
+
+def _formatar(valor: Any) -> str:
+    texto = yaml.safe_dump(valor, default_flow_style=True, allow_unicode=True).strip()
+    if texto.endswith("..."):
+        texto = texto[:-3].strip()
+    return texto
+
+
+def editar_texto(texto: str, valores: Dict[Tuple[str, str], Any]) -> str:
+    linhas = texto.splitlines()
+    for (secao, chave), valor in valores.items():
+        inicio = next((i for i, l in enumerate(linhas) if re.match(rf"^{re.escape(secao)}\s*:\s*(#.*)?$", l)), None)
+        if inicio is None:
+            if linhas and linhas[-1].strip():
+                linhas.append("")
+            linhas.extend([f"{secao}:", f"  {chave}: {_formatar(valor)}"])
+            continue
+        fim = next((i for i in range(inicio + 1, len(linhas))
+                    if linhas[i] and not linhas[i].startswith((" ", "\t", "#"))), len(linhas))
+        filhos = [i for i in range(inicio + 1, fim) if re.match(r"^(\s+)[^\s#]", linhas[i])]
+        recuo = re.match(r"^(\s+)", linhas[filhos[0]]).group(1) if filhos else "  "
+        alvo = next((i for i in filhos if re.match(rf"^{re.escape(recuo)}{re.escape(chave)}\s*:", linhas[i])), None)
+        if alvo is None:
+            linhas.insert(inicio + 1, f"{recuo}{chave}: {_formatar(valor)}")
+            continue
+        m = re.match(rf"^({re.escape(recuo)}{re.escape(chave)}\s*:\s*)(.*?)(\s+#.*)?$", linhas[alvo])
+        linhas[alvo] = f"{m.group(1)}{_formatar(valor)}{m.group(3) or ''}"
+    return "\n".join(linhas) + ("\n" if texto.endswith("\n") or not texto else "")
+
+
+def gravar_valores(arquivo: Path, valores: Dict[Tuple[str, str], Any]) -> Dict:
+    """Aplica `valores` ao arquivo (criando se não existir) e devolve o YAML resultante."""
+    arquivo = Path(arquivo)
+    original = arquivo.read_text(encoding="utf-8") if arquivo.is_file() else ""
+    antes = yaml.safe_load(original) or {}
+    if not isinstance(antes, dict):
+        raise YamlEditError(f"{arquivo} does not contain a mapping")
+
+    novo_texto = editar_texto(original, valores)
+    try:
+        depois = yaml.safe_load(novo_texto) or {}
+    except yaml.YAMLError as exc:
+        raise YamlEditError(f"editing {arquivo} would produce invalid YAML: {exc}") from exc
+
+    esperado = copy.deepcopy(antes)
+    for (secao, chave), valor in valores.items():
+        if not isinstance(esperado.get(secao), dict):
+            esperado[secao] = {}
+        esperado[secao][chave] = valor
+    if depois != esperado:
+        raise YamlEditError(f"editing {arquivo} would change more than was asked; nothing was written")
+
+    temporario = arquivo.with_name(arquivo.name + ".tmp")
+    temporario.write_text(novo_texto, encoding="utf-8")
+    os.replace(temporario, arquivo)
+    return depois

quantum_admin/services/apps.py

@@ -0,0 +1,330 @@
+"""Serviços da tela de uma aplicação (components/admin/app/[name].q).
+
+admin.projects.by_name / files / update / config / save_config
+admin.environments.list / create / update / delete / create_defaults
+admin.servers.status / start / stop / log
+
+O que a tela fazia e estava quebrado, e mudou:
+  - "iniciar servidor" rodava src/cli/runner.py, que não existe desde a troca
+    de src/ para quantum/: o processo morria na hora, o PID era gravado e o
+    botão não fazia nada. Agora roda `python -m quantum.cli.runner start` na
+    pasta do projeto;
+  - "parar" no Windows usava taskkill /F sem /T: o filho do reloader
+    sobrevivia e seguia servindo. Agora usa quantum.cli.server_process.stop_server
+    com o .quantum.pid que o próprio servidor grava (pai e filho);
+  - salvar a config gravava qualquer caminho e engolia erro de escrita.
+    Agora o caminho fica dentro da raiz, o YAML precisa ser um mapeamento e a
+    gravação é atômica;
+  - ambientes ficavam embutidos no projects.yaml; agora são os do
+    environment_service do backend (banco), com variáveis, porta e branch.
+"""
+
+import json
+import os
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+import yaml
+
+from quantum.services import service
+from quantum_admin.services._base import connectors, pasta_de_configuracao, raiz, sessao, status_do_processo
+from quantum_admin.services.projects import ProjectError, _pasta, get_project
+
+STATUS_VALIDOS = ("active", "archived", "error")
+
+
+def _projeto(db, project_id):
+    from quantum_admin.backend import crud
+    projeto = crud.get_project(db, int(project_id))
+    if projeto is None:
+        raise ProjectError(f"no project with id {project_id}")
+    return projeto
+
+
+# --------------------------------------------------------------------------- projeto
+
+@service("admin.projects.update")
+def update_project(project_id: int, name: str = "", description: str = None, status: str = ""):
+    from quantum_admin.backend import models
+    with sessao() as db:
+        projeto = _projeto(db, project_id)
+        nome = (name or "").strip()
+        if nome and nome.lower() != (projeto.name or "").lower():
+            if len(nome) < 2:
+                raise ProjectError("the project name needs at least 2 characters")
+            if db.query(models.Project).filter(models.Project.name.ilike(nome)).first():
+                raise ProjectError(f"a project named {nome!r} already exists")
+        if nome:
+            projeto.name = nome
+        if description is not None:
+            projeto.description = description.strip()
+        if status:
+            if status not in STATUS_VALIDOS:
+                raise ProjectError(f"status must be one of {', '.join(STATUS_VALIDOS)}")
+            projeto.status = status
+    return get_project(project_id)
+
+
+@service("admin.projects.config")
+def project_config(project_id: int):
+    """O quantum.config.yaml do projeto, em texto (para o editor) e interpretado."""
+    with sessao() as db:
+        caminho = _projeto(db, project_id).source_path
+    arquivo = _pasta(caminho) / "quantum.config.yaml"
+    texto = arquivo.read_text(encoding="utf-8") if arquivo.is_file() else ""
+    try:
+        interpretado = yaml.safe_load(texto) or {}
+        erro = None
+    except yaml.YAMLError as exc:
+        interpretado, erro = {}, str(exc)
+    return {"path": str(arquivo), "exists": arquivo.is_file(), "text": texto,
+            "server": (interpretado.get("server") or {}) if isinstance(interpretado, dict) else {},
+            "error": erro}
+
+
+@service("admin.projects.save_config")
+def save_project_config(project_id: int, config_yaml: str):
+    try:
+        interpretado = yaml.safe_load(config_yaml or "")
+    except yaml.YAMLError as exc:
+        raise ProjectError(f"invalid YAML: {exc}")
+    if interpretado is not None and not isinstance(interpretado, dict):
+        raise ProjectError("the configuration must be a YAML mapping (key: value)")
+    with sessao() as db:
+        caminho = _projeto(db, project_id).source_path
+    pasta = _pasta(caminho)
+    pasta.mkdir(parents=True, exist_ok=True)
+    arquivo = pasta / "quantum.config.yaml"
+    temporario = arquivo.with_name(arquivo.name + ".tmp")
+    temporario.write_text(config_yaml or "", encoding="utf-8")
+    os.replace(temporario, arquivo)
+    return project_config(project_id)
+
+
+@service("admin.projects.by_name")
+def project_by_name(name: str):
+    """O projeto da URL /admin/app/<nome> (nome sem diferença de maiúsculas)."""
+    from quantum_admin.backend import models
+    with sessao() as db:
+        projeto = db.query(models.Project).filter(models.Project.name.ilike((name or "").strip())).first()
+        if projeto is None:
+            raise ProjectError(f"no project named {name!r}")
+        project_id = projeto.id
+    return get_project(project_id)
+
+
+def _rota(relativo: str) -> str:
+    """components/loja/index.q -> /loja (ROUTE-1)."""
+    partes = relativo[:-2].split("/")
+    if partes[-1] == "index":
+        partes = partes[:-1]
+    return "/" + "/".join(partes)
+
+
+@service("admin.projects.files")
+def project_files(project_id: int):
+    """Componentes, rotas, estáticos e tamanho em disco da pasta do projeto."""
+    import re
+    with sessao() as db:
+        caminho = _projeto(db, project_id).source_path
+    pasta = _pasta(caminho)
+    componentes = []
+    pasta_componentes = pasta / "components"
+    for arquivo in sorted(pasta_componentes.rglob("*.q")) if pasta_componentes.is_dir() else []:
+        relativo = arquivo.relative_to(pasta_componentes).as_posix()
+        conteudo = arquivo.read_text(encoding="utf-8", errors="ignore")
+        nome = re.search(r'<q:component\s+name="([^"]+)"', conteudo)
+        componentes.append({
+            "name": nome.group(1) if nome else arquivo.stem, "path": relativo,
+            "source": arquivo.relative_to(raiz()).as_posix(), "lines": conteudo.count("\n") + 1,
+            "size": arquivo.stat().st_size, "route": _rota(relativo), "dynamic": "[" in relativo,
+            "tags": sorted(set(re.findall(r"<q:(\w+)", conteudo)) - {"component", "param"}),
+        })
+    estaticos = pasta / "static"
+    tamanho = sum(f.stat().st_size for f in pasta.rglob("*") if f.is_file()) if pasta.is_dir() else 0
+    return {"components": componentes,
+            "static_files": sum(1 for f in estaticos.rglob("*") if f.is_file()) if estaticos.is_dir() else 0,
+            "disk_size": f"{tamanho / 1048576:.1f} MB" if tamanho >= 1048576 else f"{tamanho / 1024:.1f} KB"}
+
+
+# --------------------------------------------------------------------------- ambientes
+
+def _ambiente_publico(env) -> dict:
+    variaveis = json.loads(env.env_vars_json) if env.env_vars_json else {}
+    return {"id": env.id, "project_id": env.project_id, "name": env.name, "display_name": env.display_name,
+            "order": env.order, "port": env.port, "branch": env.branch, "health_url": env.health_url,
+            "requires_approval": bool(env.requires_approval), "is_active": bool(env.is_active),
+            "variables": variaveis,
+            # O mesmo formato que create/update aceitam: NOME=valor por linha.
+            "variables_text": "\n".join(f"{k}={v}" for k, v in variaveis.items())}
+
+
+def _variaveis(texto_ou_dict):
+    """'CHAVE=valor' por linha (como o formulário da tela) ou um dict."""
+    if isinstance(texto_ou_dict, dict):
+        return {str(k): str(v) for k, v in texto_ou_dict.items()}
+    variaveis = {}
+    for linha in (texto_ou_dict or "").splitlines():
+        linha = linha.strip()
+        if not linha or linha.startswith("#"):
+            continue
+        if "=" not in linha:
+            raise ProjectError(f"variable line must be NAME=value: {linha!r}")
+        chave, valor = linha.split("=", 1)
+        variaveis[chave.strip()] = valor.strip()
+    return variaveis
+
+
+def _servico_de_ambientes(db):
+    from quantum_admin.backend.environment_service import EnvironmentService
+    return EnvironmentService(db=db)
+
+
+@service("admin.environments.list")
+def list_environments(project_id: int):
+    with sessao() as db:
+        _projeto(db, project_id)
+        return [_ambiente_publico(e) for e in _servico_de_ambientes(db).list_environments(int(project_id),
+                                                                                         active_only=False)]
+
+
+@service("admin.environments.create")
+def create_environment(project_id: int, name: str, display_name: str = "", port: int = None,
+                       branch: str = "main", variables="", health_url: str = ""):
+    nome = (name or "").strip().lower()
+    if not nome:
+        raise ProjectError("environment name is required")
+    with sessao() as db:
+        _projeto(db, project_id)
+        servico = _servico_de_ambientes(db)
+        if servico.get_environment_by_name(int(project_id), nome):
+            raise ProjectError(f"environment {nome!r} already exists in this project")
+        env = servico.create_environment(int(project_id), {
+            "name": nome, "display_name": display_name or None, "port": int(port) if port else None,
+            "branch": branch or "main", "env_vars": _variaveis(variables), "health_url": health_url or None})
+        return _ambiente_publico(env)
+
+
+@service("admin.environments.update")
+def update_environment(environment_id: int, display_name: str = None, port: int = None, branch: str = None,
+                       variables=None, health_url: str = None):
+    dados = {k: v for k, v in {"display_name": display_name, "branch": branch, "health_url": health_url}.items()
+             if v is not None}
+    if port not in (None, ""):
+        dados["port"] = int(port)
+    with sessao() as db:
+        servico = _servico_de_ambientes(db)
+        env = servico.update_environment(int(environment_id), dados) if dados else servico.get_environment(
+            int(environment_id))
+        if env is None:
+            raise ProjectError(f"no environment with id {environment_id}")
+        if variables is not None:
+            servico.set_env_vars(int(environment_id), _variaveis(variables))
+            env = servico.get_environment(int(environment_id))
+        return _ambiente_publico(env)
+
+
+@service("admin.environments.delete")
+def delete_environment(environment_id: int):
+    with sessao() as db:
+        if not _servico_de_ambientes(db).delete_environment(int(environment_id)):
+            raise ProjectError(f"no environment with id {environment_id}")
+    return {"deleted": int(environment_id)}
+
+
+@service("admin.environments.create_defaults")
+def create_default_environments(project_id: int):
+    with sessao() as db:
+        _projeto(db, project_id)
+        return [_ambiente_publico(e) for e in _servico_de_ambientes(db).create_default_environments(int(project_id))]
+
+
+# --------------------------------------------------------------------------- servidor do projeto
+
+def _pasta_do_projeto(project_id):
+    with sessao() as db:
+        projeto = _projeto(db, project_id)
+        nome, caminho = projeto.name, projeto.source_path
+    pasta = _pasta(caminho)
+    if not (pasta / "quantum.config.yaml").is_file():
+        raise ProjectError(f"{caminho}/quantum.config.yaml not found; save a configuration first")
+    return nome, pasta
+
+
+def _log(nome):
+    pasta = pasta_de_configuracao() / "logs"
+    pasta.mkdir(parents=True, exist_ok=True)
+    return pasta / f"{nome}.log"
+
+
+@service("admin.servers.status")
+def server_status(project_id: int):
+    nome, pasta = _pasta_do_projeto(project_id)
+    from quantum.cli.server_process import pid_alive, read_pids
+    arquivo = pasta / ".quantum.pid"
+    try:
+        vivos = [p for p in read_pids(arquivo) if pid_alive(p)]
+    except (OSError, ValueError):
+        vivos = []
+    processo = status_do_processo(nome)
+    return {"running": bool(vivos) or processo["running"], "pids": vivos or ([processo["pid"]] if processo["pid"] else [])}
+
+
+@service("admin.servers.start")
+def start_server(project_id: int, port: int = None, wait: float = 15.0):
+    """Sobe `quantum start` na pasta do projeto e espera o arquivo de PID aparecer."""
+    nome, pasta = _pasta_do_projeto(project_id)
+    if server_status(project_id)["running"]:
+        raise ProjectError(f"{nome} is already running")
+    comando = [sys.executable, "-m", "quantum.cli.runner", "start", "--config", "quantum.config.yaml"]
+    if port:
+        comando += ["--port", str(int(port))]
+    import quantum
+    ambiente = dict(os.environ)
+    pacote = str(Path(quantum.__file__).resolve().parents[1])
+    ambiente["PYTHONPATH"] = os.pathsep.join(p for p in (pacote, ambiente.get("PYTHONPATH")) if p)
+    log = open(_log(nome), "a", encoding="utf-8")
+    opcoes = {"stdout": log, "stderr": subprocess.STDOUT, "cwd": str(pasta), "env": ambiente}
+    if os.name == "nt":
+        opcoes["creationflags"] = subprocess.CREATE_NEW_PROCESS_GROUP
+    processo = subprocess.Popen(comando, **opcoes)
+    log.close()
+    pids = pasta_de_configuracao() / "pids"
+    pids.mkdir(parents=True, exist_ok=True)
+    (pids / f"{nome}.pid").write_text(str(processo.pid), encoding="utf-8")
+
+    limite = time.time() + float(wait)
+    while time.time() < limite:
+        if processo.poll() is not None:
+            raise ProjectError(f"{nome} exited with code {processo.returncode}; see the log: "
+                               f"{server_log(project_id, 20)['text']}")
+        if (pasta / ".quantum.pid").is_file():
+            return server_status(project_id)
+        time.sleep(0.2)
+    return server_status(project_id)
+
+
+@service("admin.servers.stop")
+def stop_server(project_id: int):
+    nome, pasta = _pasta_do_projeto(project_id)
+    from quantum.cli import server_process
+    arquivo = pasta / ".quantum.pid"
+    if arquivo.is_file():
+        server_process.stop_server(arquivo)
+    else:
+        processo = status_do_processo(nome)
+        if processo["running"]:
+            server_process._terminate(processo["pid"], True)
+    (pasta_de_configuracao() / "pids" / f"{nome}.pid").unlink(missing_ok=True)
+    return server_status(project_id)
+
+
+@service("admin.servers.log")
+def server_log(project_id: int, lines: int = 50):
+    with sessao() as db:
+        nome = _projeto(db, project_id).name
+    arquivo = _log(nome)
+    texto = arquivo.read_text(encoding="utf-8", errors="replace") if arquivo.is_file() else ""
+    return {"text": "".join(texto.splitlines(keepends=True)[-int(lines):])}

quantum_admin/services/auth.py

@@ -0,0 +1,61 @@
+"""Login das telas .q do admin (admin.auth.*).
+
+Usa o auth_service do backend — as mesmas credenciais do FastAPI
+(ADMIN_PASSWORD, ou a senha gerada e impressa na subida). A tela de login .q
+chama admin.auth.login e, se `ok`, grava na sessão o que AUTH-1 exige
+(session.authenticated, session.sessionExpiry, session.userRole).
+
+Acrescenta o que a biblioteca não tinha: depois de MAX_FALHAS tentativas
+erradas para o mesmo usuário em JANELA segundos, o login fica bloqueado por
+JANELA segundos — sem isso, nada limitava tentar senhas em sequência. A
+mensagem de falha é a mesma para usuário inexistente e senha errada.
+"""
+
+import threading
+import time
+
+from quantum.services import service
+
+MAX_FALHAS = 5
+JANELA = 300
+
+_falhas = {}
+_trava = threading.Lock()
+
+
+def _auth():
+    from quantum_admin.backend.auth_service import get_auth_service
+    return get_auth_service()
+
+
+def _bloqueado_ate(usuario, agora):
+    with _trava:
+        recentes = [t for t in _falhas.get(usuario, []) if agora - t < JANELA]
+        _falhas[usuario] = recentes
+        return recentes[0] + JANELA if len(recentes) >= MAX_FALHAS else None
+
+
+@service("admin.auth.login")
+def login(username: str, password: str):
+    usuario = (username or "").strip()
+    agora = time.time()
+    ate = _bloqueado_ate(usuario, agora)
+    if ate is not None:
+        return {"ok": False, "locked": True,
+                "error": f"too many failed attempts; try again in {int(ate - agora) + 1} seconds"}
+    resultado = _auth().authenticate(usuario, password or "") if usuario and password else None
+    if not resultado:
+        with _trava:
+            _falhas.setdefault(usuario, []).append(agora)
+        return {"ok": False, "locked": False, "error": "invalid username or password"}
+    with _trava:
+        _falhas.pop(usuario, None)
+    horas = max(1, int(resultado.get("expires_in", 3600) // 3600))
+    return {"ok": True, "username": resultado["user"]["username"], "role": resultado["user"]["role"],
+            "expires_in_hours": horas}
+
+
+def _reset():
+    """Testes."""
+    with _trava:
+        _falhas.clear()