quantum-framework 0.18.0__py3-none-any.whl

quantum_admin/services/repository.py

@@ -0,0 +1,223 @@
+"""Serviços das telas de leitura do repositório.
+
+admin.dashboard.stats    dashboard.q
+admin.features.list      features.q
+admin.agents.list        agents.q
+admin.source.read        source.q
+admin.databases.list     database.q
+admin.jobs.list          jobs.q
+
+Tudo só lê. O que as telas tinham de errado e mudou:
+  - dashboard.q e features.q procuravam src/core/features, src/core/parsers
+    e src/runtime/executors — pastas que não existem desde a troca de src/
+    para quantum/. O dashboard mostrava 0 features, 0 parsers e 0 executores,
+    e a tela de features vinha vazia. Agora lêem quantum/core/features e os
+    registros reais;
+  - source.q mostrava qualquer arquivo da raiz — .env, chaves, os YAML de
+    settings com as credenciais dos connectors. Agora esses são recusados, e
+    a checagem de caminho não aceita mais a pasta vizinha com o mesmo prefixo;
+  - database.q abria cada .db com sqlite3.connect normal (modo escrita, com
+    journal e trava, inclusive em bancos de aplicações rodando). Agora abre em
+    modo somente leitura.
+"""
+
+import datetime
+import re
+import sqlite3
+from pathlib import Path
+
+import yaml
+
+from quantum.services import service
+from quantum_admin.services._base import raiz
+
+PULAR = {".git", "__pycache__", "node_modules", ".venv", "venv", ".claude", "build", "dist"}
+TIPOS = {".q": "Quantum", ".py": "Python", ".yaml": "YAML", ".yml": "YAML", ".json": "JSON", ".html": "HTML",
+         ".css": "CSS", ".js": "JavaScript", ".md": "Markdown", ".txt": "Text"}
+ESTADOS_DE_JOB = ("pending", "running", "completed", "failed")
+SENSIVEIS_NOMES = re.compile(r"(^\.env(\..*)?$|\.pem$|\.key$|^id_(rsa|ed25519|ecdsa)|\.db$|\.sqlite3?$)", re.I)
+
+
+class RepositoryError(ValueError):
+    """Pedido inválido para as telas de leitura."""
+
+
+def _arquivos(pasta: Path, padrao: str):
+    if not pasta.is_dir():
+        return []
+    return [p for p in sorted(pasta.rglob(padrao)) if not PULAR.intersection(p.relative_to(pasta).parts)]
+
+
+def _tamanho(n: int) -> str:
+    if n >= 1048576:
+        return f"{n / 1048576:.1f} MB"
+    return f"{n / 1024:.1f} KB" if n >= 1024 else f"{n} B"
+
+
+def _registros():
+    from quantum.core.parser import QuantumParser
+    from quantum.runtime.component import ComponentRuntime
+    parser = QuantumParser()
+    registro = parser._parser_registry
+    tags = sum(1 for tag in registro.registered_tags
+               if type(registro.get_parser(tag)).__name__ != "HTMLParser")
+    return tags, ComponentRuntime(config={})._executor_registry.executor_count
+
+
+def _config_da_raiz() -> dict:
+    """quantum.config.yaml da raiz, ou {} se não houver ou não abrir."""
+    try:
+        return yaml.safe_load((raiz() / "quantum.config.yaml").read_text(encoding="utf-8")) or {}
+    except (OSError, yaml.YAMLError):
+        return {}
+
+
+def _pasta_de_features():
+    import quantum
+    return Path(quantum.__file__).resolve().parent / "core" / "features"
+
+
+@service("admin.dashboard.stats")
+def dashboard_stats():
+    base = raiz()
+    componentes = [p.relative_to(base / "components").as_posix() for p in _arquivos(base / "components", "*.q")]
+    tags, executores = _registros()
+    return {
+        "components": len(componentes), "component_list": componentes,
+        "features": len(list_features()["features"]),
+        "tests": len(_arquivos(base / "tests", "test_*.py")),
+        "parser_tags": tags, "executors": executores,
+        "examples": len(_arquivos(base / "examples", "*.q")),
+    }
+
+
+@service("admin.features.list")
+def list_features():
+    """Features de quantum/core/features, pelo manifest.yaml de cada uma."""
+    features = []
+    base = raiz()
+    for manifesto in sorted(_pasta_de_features().glob("*/manifest.yaml")):
+        pasta = manifesto.parent.name
+        # Só dá para abrir no leitor de código quando o pacote está dentro da raiz.
+        fonte = manifesto.relative_to(base).as_posix() if base in manifesto.parents else None
+        try:
+            dados = yaml.safe_load(manifesto.read_text(encoding="utf-8")) or {}
+            feature = dados.get("feature") or {}
+            descricao = dados.get("description")
+            curta = descricao.get("short") if isinstance(descricao, dict) else (descricao or "").strip().split("\n")[0]
+            features.append({"name": feature.get("name", pasta), "display_name": feature.get("display_name", pasta),
+                             "version": feature.get("version"), "status": feature.get("status", "unknown"),
+                             "category": feature.get("category"), "short_desc": curta or "", "source": fonte})
+        except (OSError, yaml.YAMLError, AttributeError) as exc:
+            features.append({"name": pasta, "display_name": pasta, "version": None, "status": "error",
+                             "category": None, "short_desc": f"manifest could not be read: {exc}", "source": fonte})
+    contagem = {}
+    for f in features:
+        contagem[f["status"]] = contagem.get(f["status"], 0) + 1
+    ativas, planejadas = contagem.get("active", 0), contagem.get("planned", 0)
+    return {"features": features, "by_status": contagem,
+            "summary": {"active": ativas, "planned": planejadas, "other": len(features) - ativas - planejadas}}
+
+
+@service("admin.agents.list")
+def list_agents():
+    """q:agent e q:team declarados em components/, examples/ e projects/."""
+    base = raiz()
+    atributos = re.compile(r'(\w+)\s*=\s*"([^"]*)"')
+    agentes, times = [], []
+    for pasta in ("components", "examples", "projects"):
+        for arquivo in _arquivos(base / pasta, "*.q"):
+            texto = arquivo.read_text(encoding="utf-8", errors="ignore")
+            origem = arquivo.relative_to(base).as_posix()
+            for m in re.finditer(r"<q:agent\s+([^>]*?)/?>", texto, re.S):
+                a = dict(atributos.findall(m.group(1)))
+                agentes.append({"name": a.get("name"), "model": a.get("model"),
+                                "provider": a.get("provider"), "source": origem})
+            for m in re.finditer(r"<q:team\s+([^>]*?)/?>", texto, re.S):
+                a = dict(atributos.findall(m.group(1)))
+                times.append({"name": a.get("name"), "supervisor": a.get("supervisor"), "source": origem})
+    llm = _config_da_raiz().get("llm")
+    return {"agents": agentes, "teams": times,
+            "sources": sorted({a["source"] for a in agentes} | {t["source"] for t in times}),
+            "providers": sorted({a["provider"] for a in agentes if a["provider"]}),
+            # Só estes três campos: a seção llm pode ter api_key.
+            "llm": {"base_url": llm.get("base_url"), "default_model": llm.get("default_model"),
+                    "timeout": llm.get("timeout", 60)} if isinstance(llm, dict) else None}
+
+
+@service("admin.source.read")
+def read_source(path: str):
+    relativo = (path or "").strip().replace("\\", "/")
+    if not relativo:
+        raise RepositoryError("a file path is required")
+    base = raiz()
+    arquivo = (base / relativo).resolve()
+    if base not in arquivo.parents:
+        raise RepositoryError(f"{relativo!r} is outside the project root")
+    partes = arquivo.relative_to(base).parts
+    if SENSIVEIS_NOMES.search(arquivo.name) or partes[:2] == ("quantum_admin", "settings"):
+        raise RepositoryError(f"{relativo} may contain credentials and is not shown here")
+    if not arquivo.is_file():
+        raise RepositoryError(f"file not found: {relativo}")
+    conteudo = arquivo.read_text(encoding="utf-8", errors="replace")
+    estado = arquivo.stat()
+    return {"path": arquivo.relative_to(base).as_posix(), "type": TIPOS.get(arquivo.suffix.lower(), "Unknown"),
+            "size": _tamanho(estado.st_size), "lines": conteudo.count("\n") + 1, "content": conteudo,
+            "modified": datetime.datetime.fromtimestamp(estado.st_mtime).strftime("%Y-%m-%d %H:%M")}
+
+
+@service("admin.databases.list")
+def list_databases():
+    """Arquivos .db da raiz, abertos SOMENTE LEITURA, com tabelas e linhas."""
+    base = raiz()
+    bancos = []
+    for arquivo in _arquivos(base, "*.db"):
+        tabelas, erro = [], None
+        try:
+            conexao = sqlite3.connect(f"{arquivo.resolve().as_uri()}?mode=ro", uri=True, timeout=2)
+            try:
+                for (nome,) in conexao.execute("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name"):
+                    try:
+                        linhas = conexao.execute(f'SELECT COUNT(*) FROM "{nome}"').fetchone()[0]
+                    except sqlite3.DatabaseError:
+                        linhas = None
+                    tabelas.append({"name": nome, "rows": linhas})
+            finally:
+                conexao.close()
+        except sqlite3.DatabaseError as exc:
+            erro = str(exc)
+        estado = arquivo.stat()
+        bancos.append({"path": arquivo.relative_to(base).as_posix(), "size": _tamanho(estado.st_size),
+                       "modified": datetime.datetime.fromtimestamp(estado.st_mtime).strftime("%Y-%m-%d %H:%M"),
+                       "tables": tabelas, "error": erro})
+    fontes = _config_da_raiz().get("datasources") or {}
+    # Nome, driver e banco — host, usuário e senha ficam de fora.
+    declaradas = [{"name": nome, "driver": (cfg or {}).get("driver") or (cfg or {}).get("type"),
+                   "database": (cfg or {}).get("database")} for nome, cfg in sorted(fontes.items())
+                  if isinstance(cfg, dict)] if isinstance(fontes, dict) else []
+    return {"databases": bancos, "total_tables": sum(len(b["tables"]) for b in bancos), "datasources": declaradas}
+
+
+@service("admin.jobs.list")
+def list_jobs(limit: int = 50):
+    """Fila de q:job (quantum_jobs.db na raiz), somente leitura."""
+    arquivo = raiz() / "quantum_jobs.db"
+    # Os quatro estados da fila sempre presentes, para a tela não testar chave.
+    vazio = {"found": False, "counts": dict.fromkeys(ESTADOS_DE_JOB, 0), "total": 0, "jobs": []}
+    if not arquivo.is_file():
+        return vazio
+    try:
+        conexao = sqlite3.connect(f"{arquivo.resolve().as_uri()}?mode=ro", uri=True, timeout=2)
+        conexao.row_factory = sqlite3.Row
+        try:
+            contagem = dict.fromkeys(ESTADOS_DE_JOB, 0)
+            contagem.update({r["status"]: r["cnt"] for r in
+                        conexao.execute("SELECT status, COUNT(*) AS cnt FROM quantum_jobs GROUP BY status")})
+            jobs = [dict(r) for r in conexao.execute(
+                "SELECT id, name, queue, status, attempts, max_attempts, created_at, error "
+                "FROM quantum_jobs ORDER BY id DESC LIMIT ?", (int(limit),))]
+        finally:
+            conexao.close()
+    except sqlite3.DatabaseError as exc:
+        return {**vazio, "found": True, "error": str(exc)}
+    return {"found": True, "counts": contagem, "total": sum(contagem.values()), "jobs": jobs}

quantum_admin/services/settings.py

@@ -0,0 +1,150 @@
+"""Serviços da área Configurações (admin.settings.*, admin.system.*).
+
+Duas configurações diferentes, que a interface antiga misturava sob o mesmo nome:
+
+  - quantum.config.yaml da raiz: a configuração do SERVIDOR Quantum que
+    `quantum start` usa. components/admin/settings.q editava esta.
+  - settings/global.yaml: as configurações do próprio admin
+    (settings_service do backend). O FastAPI editava esta.
+
+O que settings.q fazia de errado e mudou:
+  - regravava quantum.config.yaml com yaml.dump, apagando todos os
+    comentários (incluindo os avisos de segurança) — agora só a linha do
+    valor muda (_yaml_editor, que confere o resultado antes de gravar);
+  - porta inválida virava 8080 em silêncio e erro de escrita era engolido —
+    agora é erro;
+  - aceitava debug com host fora do loopback, que o servidor recusa ao
+    subir — agora recusa já ao salvar;
+  - contava parsers e executores em src/core/parsers, pasta que não existe
+    mais: mostrava sempre 0 — agora pergunta aos registros reais.
+"""
+
+import platform
+import sys
+
+import yaml
+
+from quantum.services import service
+from quantum_admin.services._base import raiz
+from quantum_admin.services._yaml_editor import gravar_valores
+
+NIVEIS_DE_LOG = ("DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL")
+LOOPBACK = ("127.0.0.1", "localhost", "::1")
+
+
+class SettingsError(ValueError):
+    """Valor de configuração inválido."""
+
+
+def _arquivo():
+    return raiz() / "quantum.config.yaml"
+
+
+@service("admin.settings.server_config")
+def server_config():
+    """O quantum.config.yaml da raiz, como está no arquivo (sem expandir ${VAR})."""
+    arquivo = _arquivo()
+    if not arquivo.is_file():
+        return {"found": False, "path": str(arquivo)}
+    try:
+        cfg = yaml.safe_load(arquivo.read_text(encoding="utf-8")) or {}
+    except yaml.YAMLError as exc:
+        return {"found": True, "path": str(arquivo), "error": str(exc)}
+    servidor = cfg.get("server") or {}
+    return {
+        "found": True, "path": str(arquivo),
+        "server": {"port": servidor.get("port", 8080), "host": servidor.get("host", "127.0.0.1"),
+                   "debug": bool(servidor.get("debug", False)), "reload": bool(servidor.get("reload", False))},
+        "paths": {"components": "./components", "static": "./static", "logs": "./logs", **(cfg.get("paths") or {})},
+        "performance": {"cache_templates": False, "cache_ttl": 0, "cache_max_size": 0, **(cfg.get("performance") or {})},
+        "security": {"xss_protection": False, "cors_enabled": False, "max_content_length": 0,
+                     **(cfg.get("security") or {})},
+        "llm": cfg.get("llm") or {},
+        "logging": {"level": "INFO", "console": False, "file": False, **(cfg.get("logging") or {})},
+        "datasources": sorted((cfg.get("datasources") or {}).keys()),
+        "services": list(cfg.get("services") or []),
+    }
+
+
+@service("admin.settings.save_server_config")
+def save_server_config(port: int, host: str, debug: bool = False, reload: bool = False,
+                       cache_templates: bool = False, cache_ttl: int = 300, log_level: str = "INFO",
+                       xss_protection: bool = True, cors_enabled: bool = False):
+    """Grava os valores do formulário mudando só as linhas deles no arquivo."""
+    try:
+        porta = int(port)
+    except (TypeError, ValueError):
+        raise SettingsError(f"port must be a number, got {port!r}")
+    if not 1 <= porta <= 65535:
+        raise SettingsError(f"port must be between 1 and 65535, got {porta}")
+    endereco = (host or "").strip()
+    if not endereco:
+        raise SettingsError("host is required (127.0.0.1 keeps the server local)")
+    if debug and endereco not in LOOPBACK:
+        raise SettingsError(
+            f"debug cannot be on with host {endereco}: the debugger runs code for anyone who reaches "
+            f"the port, and quantum start refuses it. Use 127.0.0.1, or turn debug off.")
+    nivel = (log_level or "").upper()
+    if nivel not in NIVEIS_DE_LOG:
+        raise SettingsError(f"log_level must be one of {', '.join(NIVEIS_DE_LOG)}")
+    ttl = int(cache_ttl)
+    if ttl < 0:
+        raise SettingsError("cache_ttl cannot be negative")
+    gravar_valores(_arquivo(), {
+        ("server", "port"): porta, ("server", "host"): endereco,
+        ("server", "debug"): bool(debug), ("server", "reload"): bool(reload),
+        ("performance", "cache_templates"): bool(cache_templates), ("performance", "cache_ttl"): ttl,
+        ("logging", "level"): nivel,
+        ("security", "xss_protection"): bool(xss_protection), ("security", "cors_enabled"): bool(cors_enabled),
+    })
+    return server_config()
+
+
+_CHAVE_SECRETA = ("password", "secret", "token", "api_key", "apikey", "private_key")
+
+
+def _mascarar(valor, chave=""):
+    """Troca o valor de chaves que parecem segredo por '****' (uma referência ${VAR} fica visível)."""
+    if isinstance(valor, dict):
+        return {k: _mascarar(v, str(k)) for k, v in valor.items()}
+    if isinstance(valor, list):
+        return [_mascarar(v, chave) for v in valor]
+    if any(p in chave.lower() for p in _CHAVE_SECRETA) and valor not in (None, "") \
+            and not (isinstance(valor, str) and valor.startswith("${")):
+        return "****"
+    return valor
+
+
+@service("admin.settings.global_get")
+def global_get():
+    """settings/global.yaml do admin (settings_service), com segredos mascarados.
+
+    A biblioteca devolve os valores como estão no arquivo; senhas e tokens
+    escritos ali sairiam na página. Uma referência ${VAR} continua visível.
+    """
+    from quantum_admin.backend.settings_service import get_settings_service
+    return _mascarar(get_settings_service().get_global_settings(resolve_env=False))
+
+
+@service("admin.system.info")
+def system_info():
+    """Versões e o que a linguagem tem registrado — medido nos registros, não em pastas."""
+    from quantum.core.parser import QuantumParser
+    from quantum.runtime.component import ComponentRuntime
+    try:
+        from importlib.metadata import version
+        versao = version("quantum-framework")
+    except Exception:  # noqa: BLE001 — rodando de um clone sem instalar
+        versao = None
+    parser = QuantumParser()
+    runtime = ComponentRuntime(config={})
+    return {
+        "quantum_version": versao,
+        "python_version": sys.version.split()[0],
+        "platform": platform.platform(),
+        "root": str(raiz()).replace("\\", "/"),
+        # só tags da linguagem: o registro também guarda os nomes de tags HTML
+        "parser_tags": sum(1 for tag in parser._parser_registry.registered_tags
+                           if type(parser._parser_registry.get_parser(tag)).__name__ != "HTMLParser"),
+        "executors": runtime._executor_registry.executor_count,
+    }

quantum_admin/services/yaml_import.py

@@ -0,0 +1,118 @@
+"""Importa os projetos do YAML antigo das telas .q para o banco (admin.import.*).
+
+As telas .q gravavam projetos em quantum_admin/settings/projects.yaml; o
+FastAPI (crud), no banco. Medido em 2026-09-10: nenhum projeto em comum — os
+14 reais estavam no YAML, e o banco só tinha os três de demonstração do
+seed_db. O serviço admin.projects usa o banco; esta importação traz os
+projetos para lá.
+
+Connectors NÃO são importados: a biblioteca do backend (connector_service)
+os mantém em settings/connectors.yaml, o mesmo arquivo das telas — não há
+divisão. A tabela `connectors` do banco não é usada por nada. O que a
+importação faz com connectors é só apontar os que estão presos a um projeto
+pelo id antigo do YAML (um uuid), que connector_service não reconhece.
+
+Garantias (os dados são do dono, não são recriáveis):
+  - antes de gravar, copia o arquivo do banco para quantum_admin/backups/;
+  - nunca altera nem apaga os YAML;
+  - idempotente: projeto já existente (mesmo nome, sem diferenciar
+    maiúsculas) é pulado.
+"""
+
+import datetime
+import shutil
+from pathlib import Path
+
+import yaml
+
+from quantum.services import service
+from quantum_admin.services._base import pasta_de_configuracao, raiz, sessao
+
+
+def _ler_yaml(nome):
+    arquivo = pasta_de_configuracao() / nome
+    if not arquivo.is_file():
+        return []
+    dados = yaml.safe_load(arquivo.read_text(encoding="utf-8")) or []
+    return dados if isinstance(dados, list) else []
+
+
+def _data(valor):
+    if isinstance(valor, datetime.datetime):
+        return valor
+    try:
+        return datetime.datetime.fromisoformat(str(valor).replace("Z", "+00:00")).replace(tzinfo=None)
+    except (TypeError, ValueError):
+        return None
+
+
+def _models():
+    from quantum_admin.backend import models
+    return models
+
+
+@service("admin.import.pending")
+def pending():
+    """Projetos do YAML que o banco ainda não tem, e connectors presos a ids antigos."""
+    models = _models()
+    projetos = _ler_yaml("projects.yaml")
+    with sessao() as db:
+        nomes = {(p.name or "").lower() for p in db.query(models.Project).all()}
+    return {
+        "projects": [p.get("name") for p in projetos if p.get("name") and p["name"].lower() not in nomes],
+        "connectors_to_review": _connectors_com_id_antigo(projetos),
+    }
+
+
+def _connectors_com_id_antigo(projetos):
+    ids_yaml = {str(p.get("id")): p.get("name") for p in projetos if p.get("id")}
+    revisar = []
+    for c in _ler_yaml("connectors.yaml"):
+        dono = c.get("application_id")
+        if dono is not None and str(dono) in ids_yaml:
+            revisar.append(f"{c.get('name')} (project {ids_yaml[str(dono)]})")
+    return revisar
+
+
+def _backup():
+    from quantum_admin.backend import database
+    arquivo = database.engine.url.database
+    if database.engine.url.get_backend_name() != "sqlite" or not arquivo or not Path(arquivo).is_file():
+        return None
+    destino = raiz() / "quantum_admin" / "backups"
+    destino.mkdir(parents=True, exist_ok=True)
+    copia = destino / f"quantum_admin-{datetime.datetime.now():%Y%m%d-%H%M%S}.db"
+    database.engine.dispose()               # nada pendente em conexões abertas
+    shutil.copy2(arquivo, copia)
+    return str(copia)
+
+
+@service("admin.import.run")
+def run():
+    """Importa os projetos que faltam; devolve o relatório. Não mexe nos YAML."""
+    models = _models()
+    projetos = _ler_yaml("projects.yaml")
+    faltando = pending()
+    relatorio = {"backup": None, "projects": [], "connectors_to_review": faltando["connectors_to_review"]}
+    if not faltando["projects"]:
+        return relatorio
+    relatorio["backup"] = _backup()
+    with sessao() as db:
+        nomes = {(p.name or "").lower() for p in db.query(models.Project).all()}
+        for item in projetos:
+            nome = (item.get("name") or "").strip()
+            if not nome or nome.lower() in nomes:
+                continue
+            projeto = models.Project(
+                name=nome, description=item.get("description") or "",
+                status=item.get("status") or "active",
+                source_path=(item.get("source_path") or "").replace("\\", "/"))
+            criado, alterado = _data(item.get("created_at")), _data(item.get("updated_at"))
+            if criado:
+                projeto.created_at = criado
+            if alterado:
+                projeto.updated_at = alterado
+            db.add(projeto)
+            nomes.add(nome.lower())
+            relatorio["projects"].append(nome)
+    return relatorio