@danhachuel/thunderbolt 0.2.39 → 0.2.40

package/MANUAL-INSTALACAO.md

@@ -2,7 +2,7 @@
 
 Este manual descreve a instalação local da UI Thunderbolt, baseada no MoneyPrinterTurbo, utilizando o pacote npm `@danhachuel/thunderbolt`. O fluxo recomendado instala automaticamente o ambiente Python, as dependências da aplicação, as dependências do MoneyPrinterTurbo, o Streamlit e o suporte FFmpeg através de `imageio-ffmpeg`.
 
-> **Versão deste manual:** 0.2.39
+> **Versão deste manual:** 0.2.40
 > **Pacote npm:** `@danhachuel/thunderbolt`
 > **Porta padrão da UI:** `localhost:3030`  
 > **Repositório:** [github.com/DanHachuel/thunderbolt](https://github.com/DanHachuel/thunderbolt)
@@ -100,13 +100,13 @@ Execute:
 Windows PowerShell ou MobaXterm:
 
 ```powershell
-npx.cmd --yes @danhachuel/thunderbolt@0.2.39 install
+npx.cmd --yes @danhachuel/thunderbolt@0.2.40 install
 ```
 
 Linux/macOS:
 
 ```bash
-npx --yes @danhachuel/thunderbolt@0.2.39 install
+npx --yes @danhachuel/thunderbolt@0.2.40 install
 ```
 
 A instalação normal é **segura para actualizações**: preserva `storage`, Blueprints, Brandings, configurações e artefactos do utilizador. Remove apenas `.venv`, o clone técnico do MoneyPrinterTurbo e dependências que serão recriadas. Uma pasta antiga sem dados do utilizador, como `C:\Users\<utilizador>\AppData\Local\hermes` da tentativa incompleta, pode ser removida; uma pasta antiga que contenha Blueprints, Brandings ou storage é preservada e apenas avisada no terminal. Feche processos Python, Node, Streamlit e MobaXterm que estejam a usar as pastas antes de executar.
@@ -396,7 +396,7 @@ Ao abrir a página, o Thunderbolt não prepara dados públicos, não descarrega
 
 Os parâmetros da UI são número de clusters entre 2 e 10, suporte mínimo entre 0,01 e 0,50, país, engagement, intervalo de datas e tags, todos dentro da área principal da aba. O núcleo normaliza os dados, calcula engagement, aplica filtros, faz transformação logarítmica e standardização, executa K-Means e calcula itemsets/regras com FP-Growth. Não são apresentados resultados até ao primeiro clique em **Analisar Nichos**; o mesmo botão aplica alterações posteriores aos filtros. Os resultados são DataFrames de clusters, itemsets frequentes, regras de associação e dados analisados; o gráfico de dispersão é criado nativamente com Plotly.
 
-As dependências adicionais — `scikit-learn`, `mlxtend`, `plotly`, `seaborn`, `matplotlib` e `kagglehub` — são instaladas pelo procedimento normal de `npx`. Em instalações existentes, execute novamente `npx.cmd --yes @danhachuel/thunderbolt@0.2.39 install`; o instalador detecta e reutiliza o que já estiver válido.
+As dependências adicionais — `scikit-learn`, `mlxtend`, `plotly`, `seaborn`, `matplotlib` e `kagglehub` — são instaladas pelo procedimento normal de `npx`. Em instalações existentes, execute novamente `npx.cmd --yes @danhachuel/thunderbolt@0.2.40 install`; o instalador detecta e reutiliza o que já estiver válido.
 
 ### Niche Finder Apify
 
@@ -408,7 +408,13 @@ O menu **Models AI** foi adicionado abaixo de **Edição**. As abas **Personagen
 
 ## Edição: Limpador de Metadados, Cortes e Editor Python
 
-A aba **Limpador de Metadados** continua funcional e foi movida para **Edição**. As abas **Cortes** e **Editor Python** estão visíveis na mesma ordem e mostram apenas uma mensagem de reserva para desenvolvimento futuro; não executam operações.
+A aba **Limpador de Metadados** continua funcional e foi movida para **Edição**. A aba **Cortes** permanece reservada e não executa operações. A aba **Editor Python** é funcional e permite escolher vídeos gerados, indicar uma pasta local ou fazer upload manual; as operações são manuais e criam cópias sem alterar os originais.
+
+## Editor Python baseado no PYEdit
+
+O **Editor Python** adapta o recorte do [PYEdit](https://github.com/Congren/PYEdit) ao Thunderbolt. Na subaba **Vídeos**, pode seleccionar um vídeo já gerado e registado nos artefactos da pipeline, indicar uma pasta local de vídeos ou fazer upload manual. As operações disponíveis são cortar trecho, remover áudio, extrair áudio, substituir áudio, alterar velocidade e redimensionar vídeo.
+
+Cada operação usa FFmpeg local, preserva o original, cria a saída em `storage/python_editor/outputs/`, guarda o histórico em `storage/state/python_editor_edits.json` e permite descarregar o resultado e um manifesto JSON. Na subaba **Código Python**, pode criar e guardar scripts em `storage/python_editor/scripts/` ou carregar scripts existentes. Por segurança, a UI não executa código Python e não executa scripts automaticamente.
 
 ## Pipeline: Criação de Vídeos, Criação de Músicas e Automação
 

package/README.md

@@ -19,7 +19,7 @@ A primeira versão implementa a camada UI independente com:
 | Automação | Lista de vídeos e canais, selectores editáveis de Blueprint/voz padrão, Automação ON, horário diário HH:MM e worker local baseado no relógio do computador |
 | Models AI | Menu expansível com Personagens e Redes Sociais reservados para desenvolvimento futuro |
 | Niche Finder | Menu expansível com duas alternativas independentes: Niche Finder Kaggle e Niche Finder Apify, com parâmetros, execução e resultados separados |
-| Edição | Menu expansível abaixo de Automação com Limpador de Metadados funcional, Cortes reservado e Editor Python reservado |
+| Edição | Menu expansível abaixo de Automação com Limpador de Metadados funcional, Cortes reservado e Editor Python inspirado no PYEdit para vídeos e scripts locais |
 | Upload | YouTube via `youtube-automation-agent` adaptado internamente, OAuth directo de redundância, Upload directo experimental, TikTok, Instagram e Facebook Pages no front end |
 | MCP | Catálogo local opcional de Short Video Maker, AutoVio, OpenMontage e OpenCut, com portas editáveis e activação |
 | Configurações Técnicas | Provedores LLM, TTS/voz, preview de vozes, Suno, materiais, Whisper, FFmpeg, OAuth YouTube, Data API Key opcional, Kaggle Username/API Key, Apify API Token/Actor ID/limites, Upload directo, TikTok Client ID/Secret e Upload-Post |
@@ -27,7 +27,7 @@ A primeira versão implementa a camada UI independente com:
 
 Os adaptadores do MoneyPrinterTurbo e de publicação nas plataformas são ligados pelas configurações locais e pelos pontos de integração em `integrations/`. A UI não inventa dados quando um serviço externo ou credencial não está disponível.
 
-## Navegação da UI 0.2.39
+## Navegação da UI 0.2.40
 
 A barra lateral mantém os níveis principais, nesta ordem: **Início**, **Niche Finder**, **Pipeline**, **Automação**, **Edição**, **Models AI** e **Configurações**. **Pipeline** é expansível e contém **Criação de Vídeos**, **Criação de Músicas** e **Upload**. **Edição** é expansível e contém **Limpador de Metadados**, **Cortes** e **Editor Python**, nessa ordem. **Models AI** é expansível e contém **Personagens** e **Redes Sociais**, nessa ordem. **Niche Finder** é expansível e contém **Niche Finder Kaggle** e **Niche Finder Apify**. **Configurações** é expansível e contém **Canais**, **Blueprints**, **MCP** e **Configurações Técnicas**. O Início reúne o dashboard e as filas do Pipeline, sem botões de acções rápidas.
 
@@ -116,9 +116,9 @@ thunderbolt
 No Windows PowerShell, se `npx` for bloqueado por `npx.ps1`, use directamente `npx.cmd`:
 
 ```powershell
-npx.cmd --yes @danhachuel/thunderbolt@0.2.39 install
-npx.cmd --yes @danhachuel/thunderbolt@0.2.39 doctor
-npx.cmd --yes @danhachuel/thunderbolt@0.2.39
+npx.cmd --yes @danhachuel/thunderbolt@0.2.40 install
+npx.cmd --yes @danhachuel/thunderbolt@0.2.40 doctor
+npx.cmd --yes @danhachuel/thunderbolt@0.2.40
 ```
 
 Como alternativa, pode permitir scripts para o seu utilizador:
@@ -142,7 +142,15 @@ O menu expansível **Niche Finder** contém duas alternativas independentes. **N
 
 A interface apresenta dentro da aba os parâmetros da busca: número de clusters entre 2 e 10, suporte mínimo entre 0,01 e 0,50, país, categoria de engagement, intervalo de datas e tags. A página permanece sem resultados até o primeiro clique em **Analisar Nichos**; depois, se os parâmetros forem alterados, mostra os resultados anteriores e pede novo clique para aplicar os filtros actuais. O núcleo aplica normalização, filtros, `log1p`, `StandardScaler`, K-Means e FP-Growth. Os resultados aparecem em DataFrames para clusters, itemsets frequentes, regras de associação e dados analisados, acompanhados por uma visualização Plotly nativa e pesquisa de palavras nos clusters.
 
-**Niche Finder Apify** é a segunda alternativa e não usa o dataset, filtros, execução ou resultados Kaggle. Define três palavras-chave, período, limite de resultados, Shorts, duração, idioma de legendas e ordenação; depois de clicar em **Pesquisar no Apify**, inicia o actor `streamers~youtube-scraper`, acompanha o run, carrega o dataset, normaliza vídeos, limpa SRT, calcula VSC Ratio e tenta resumir as transcrições com o provider LLM configurado. Os resultados ficam na sessão própria `niche_apify_results`, o histórico pequeno fica em `storage/state/niche_apify_runs.json` e existem exportações JSON/CSV. Configure o **Apify API Token** em Configurações Técnicas. As dependências adicionais são instaladas pelo fluxo normal do pacote: `requests`, `pandas` e os componentes já existentes da análise. Em instalações existentes, execute novamente `npx.cmd --yes @danhachuel/thunderbolt@0.2.36 install`; o instalador detecta e reutiliza componentes já válidos.
+**Niche Finder Apify** é a segunda alternativa e não usa o dataset, filtros, execução ou resultados Kaggle. Define três palavras-chave, período, limite de resultados, Shorts, duração, idioma de legendas e ordenação; depois de clicar em **Pesquisar no Apify**, inicia o actor `streamers~youtube-scraper`, acompanha o run, carrega o dataset, normaliza vídeos, limpa SRT, calcula VSC Ratio e tenta resumir as transcrições com o provider LLM configurado. Os resultados ficam na sessão própria `niche_apify_results`, o histórico pequeno fica em `storage/state/niche_apify_runs.json` e existem exportações JSON/CSV. Configure o **Apify API Token** em Configurações Técnicas. As dependências adicionais são instaladas pelo fluxo normal do pacote: `requests`, `pandas` e os componentes já existentes da análise. Em instalações existentes, execute novamente `npx.cmd --yes @danhachuel/thunderbolt@0.2.40 install`; o instalador detecta e reutiliza componentes já válidos.
+
+## Editor Python baseado no PYEdit
+
+O **Editor Python** combina o recorte seguro do [PYEdit](https://github.com/Congren/PYEdit) com o armazenamento local do Thunderbolt. Na subaba **Vídeos**, pode escolher um vídeo já gerado e registado nos artefactos da pipeline, indicar qualquer pasta local de vídeos ou fazer upload manual. A página não inicia nenhuma edição ao ser aberta.
+
+As operações disponíveis são cortar trecho, remover áudio, extrair áudio, substituir áudio, alterar velocidade e redimensionar vídeo. Cada operação cria uma cópia em `storage/python_editor/outputs/`, preserva o original, regista um histórico separado em `storage/state/python_editor_edits.json` e permite descarregar o resultado e um manifesto JSON. As operações usam FFmpeg local, aproveitando o caminho configurado em **Configurações Técnicas** ou o fallback `imageio-ffmpeg`.
+
+Na subaba **Código Python**, pode criar e guardar scripts em `storage/python_editor/scripts/` ou carregar scripts existentes. Por segurança, a UI não executa código Python, não possui botão de execução e não executa scripts automaticamente.
 
 ## Armazenamento local
 

package/app/main.py

@@ -19,13 +19,14 @@ except (OSError, json.JSONDecodeError):
 
 from hermes_ui.domain import STAGES, create_batch, create_channel, create_tasks_for_batch, delete_channel, pipeline_summary, set_channel_defaults, transition_task, update_channel
 from hermes_ui.automation_worker import load_worker_status
-from hermes_ui.storage import BLUEPRINTS, ensure_storage, list_blueprint_files, load_blueprint_file, now, read_json, write_json
+from hermes_ui.storage import BLUEPRINTS, STORAGE, ensure_storage, list_blueprint_files, load_blueprint_file, now, read_json, write_json
 from app.modules.niche_finder.apify import ApifyError, DEFAULT_ACTOR_ID, abort_actor_run, build_actor_input, get_dataset_items, normalize_video_items, start_actor_run, wait_for_actor_run
 from app.modules.niche_finder.core import NicheAnalysisError, run_niche_analysis
 from app.modules.niche_finder.data_loader import DatasetError, download_kaggle_dataset
 from app.modules.niche_finder.summarizer import summarize_items
 from hermes_ui.blueprints import create_blueprint_from_link, list_branding_files, save_generated_blueprint
 from hermes_ui.metadata_cleaner import build_description, clean_video_metadata, list_edit_records, metadata_manifest, normalize_tags, save_edit_record, store_external_video
+from hermes_ui.python_editor import AUDIO_EXTENSIONS, VIDEO_EXTENSIONS, PythonEditorError, change_speed, editor_manifest, extract_audio, list_edit_records as list_python_editor_records, list_generated_videos, list_scripts, list_video_files, read_script, remove_audio, replace_audio, resize_video, save_edit_record as save_python_editor_record, save_script, store_uploaded_asset, trim_video
 from hermes_ui.mcp import detect_local_service, install_skill_locally, load_integrations, load_server_config, read_packaged_skill, save_server_config, update_integration
 from hermes_ui.mcp_server import server_status, start_server, stop_server
 from hermes_ui.music import list_music_files, materialize_suno_audio, request_suno_generation, store_music_file
@@ -888,6 +889,134 @@ def render_edit_placeholder(page_title: str, description: str):
     st.info("Esta aba está reservada para desenvolvimento futuro e ainda não executa nenhuma operação.")
 
 
+def render_python_editor():
+    st.title("Editor Python")
+    st.caption("Editor local inspirado no PYEdit para scripts Python e edição manual de vídeos do Thunderbolt.")
+    st.info("Escolha um vídeo gerado, indique uma pasta local ou faça upload de um vídeo. Nenhum código Python é executado nesta aba; as operações de vídeo só começam depois de clicar no botão da operação.")
+
+    video_tab, code_tab = st.tabs(["Vídeos", "Código Python"])
+    with video_tab:
+        st.subheader("Escolher vídeo")
+        source_mode = st.radio("Origem", ["Vídeos gerados", "Pasta local", "Upload manual"], horizontal=True, key="python_editor_source_mode")
+        source_path = None
+        if source_mode == "Vídeos gerados":
+            tasks = read_json("tasks.json", [])
+            generated_paths = list_generated_videos(tasks)
+            if not generated_paths:
+                st.info("Ainda não existem vídeos gerados com caminho registado nos artefactos da pipeline.")
+            else:
+                labels = [f"{path.name} — {path}" for path in generated_paths]
+                selected_index = st.selectbox("Vídeo gerado", range(len(generated_paths)), format_func=lambda index: labels[index], key="python_editor_generated_index")
+                source_path = generated_paths[selected_index]
+        elif source_mode == "Pasta local":
+            default_folder = str(STORAGE / "videos")
+            folder_value = st.text_input("Pasta de vídeos", value=st.session_state.get("python_editor_folder", default_folder), key="python_editor_folder")
+            folder_paths = list_video_files(folder_value)
+            if not folder_paths:
+                st.info("Não foram encontrados vídeos nessa pasta. Pode indicar a pasta de vídeos gerados ou qualquer outra pasta local.")
+            else:
+                labels = [f"{path.name} — {path}" for path in folder_paths]
+                selected_index = st.selectbox("Vídeo da pasta", range(len(folder_paths)), format_func=lambda index: labels[index], key="python_editor_folder_index")
+                source_path = folder_paths[selected_index]
+        else:
+            uploaded_video = st.file_uploader("Subir vídeo para editar", type=sorted(extension.lstrip(".") for extension in VIDEO_EXTENSIONS), key="python_editor_video_upload")
+            if uploaded_video is not None:
+                try:
+                    source_path = store_uploaded_asset(uploaded_video.name, uploaded_video.getvalue())
+                except PythonEditorError as exc:
+                    st.error(str(exc))
+
+        if source_path and source_path.is_file():
+            st.session_state["python_editor_source_path"] = str(source_path)
+            st.caption(f"Fonte seleccionada: `{source_path}` · {source_path.stat().st_size / (1024 * 1024):.2f} MB")
+            st.video(str(source_path))
+            st.divider()
+            st.subheader("Operação PYEdit")
+            operation_options = ["Cortar trecho", "Remover áudio", "Extrair áudio", "Substituir áudio", "Alterar velocidade", "Redimensionar vídeo"]
+            operation = st.selectbox("Operação", operation_options, key="python_editor_operation")
+            with st.form("python_editor_video_form", clear_on_submit=False):
+                start_seconds = end_seconds = speed = None
+                width = height = None
+                replacement_audio = None
+                if operation == "Cortar trecho":
+                    op_cols = st.columns(2)
+                    with op_cols[0]:
+                        start_seconds = st.number_input("Início (segundos)", min_value=0.0, value=0.0, step=0.5, key="python_editor_trim_start")
+                    with op_cols[1]:
+                        end_seconds = st.number_input("Fim (segundos)", min_value=0.5, value=10.0, step=0.5, key="python_editor_trim_end")
+                elif operation == "Substituir áudio":
+                    replacement_audio = st.file_uploader("Novo áudio", type=sorted(extension.lstrip(".") for extension in AUDIO_EXTENSIONS), key="python_editor_audio_upload")
+                    st.caption("O áudio substitui a faixa original e a duração final fica limitada ao menor fluxo.")
+                elif operation == "Alterar velocidade":
+                    speed = st.number_input("Velocidade", min_value=0.25, max_value=4.0, value=1.0, step=0.25, key="python_editor_speed")
+                elif operation == "Redimensionar vídeo":
+                    resize_cols = st.columns(2)
+                    with resize_cols[0]:
+                        width = st.number_input("Largura", min_value=16, max_value=7680, value=1280, step=2, key="python_editor_width")
+                    with resize_cols[1]:
+                        height = st.number_input("Altura", min_value=16, max_value=7680, value=720, step=2, key="python_editor_height")
+                apply_operation = st.form_submit_button(f"Aplicar: {operation}", type="primary", use_container_width=True)
+            if apply_operation:
+                try:
+                    ffmpeg_path = read_json("settings.json", {}).get("ffmpeg_path", "")
+                    if operation == "Cortar trecho":
+                        output, run_info = trim_video(source_path, float(start_seconds), float(end_seconds), ffmpeg_path=ffmpeg_path)
+                    elif operation == "Remover áudio":
+                        output, run_info = remove_audio(source_path, ffmpeg_path=ffmpeg_path)
+                    elif operation == "Extrair áudio":
+                        output, run_info = extract_audio(source_path, ffmpeg_path=ffmpeg_path)
+                    elif operation == "Substituir áudio":
+                        if replacement_audio is None:
+                            raise PythonEditorError("Seleccione o novo áudio antes de aplicar a operação.")
+                        audio_path = store_uploaded_asset(replacement_audio.name, replacement_audio.getvalue(), audio=True)
+                        output, run_info = replace_audio(source_path, audio_path, ffmpeg_path=ffmpeg_path)
+                    elif operation == "Alterar velocidade":
+                        output, run_info = change_speed(source_path, float(speed), ffmpeg_path=ffmpeg_path)
+                    else:
+                        output, run_info = resize_video(source_path, int(width), int(height), ffmpeg_path=ffmpeg_path)
+                    record = save_python_editor_record(source_path, output, run_info)
+                    st.session_state["python_editor_last_record"] = record
+                    st.success(f"Operação concluída: {output.name}")
+                    if output.suffix.lower() in AUDIO_EXTENSIONS:
+                        st.audio(output.read_bytes(), format="audio/mpeg")
+                    else:
+                        st.video(str(output))
+                    st.download_button("Descarregar resultado", data=output.read_bytes(), file_name=output.name, mime="video/mp4" if output.suffix.lower() in VIDEO_EXTENSIONS else "audio/mpeg", key=f"python_editor_download_{record['id']}")
+                    st.download_button("Descarregar manifesto JSON", data=editor_manifest(record), file_name=f"{output.stem}.json", mime="application/json", key=f"python_editor_manifest_{record['id']}")
+                except (PythonEditorError, OSError, ValueError) as exc:
+                    st.error(str(exc))
+        else:
+            st.caption("Seleccione uma fonte de vídeo para activar as operações inspiradas no PYEdit.")
+
+        records = list_python_editor_records()
+        if records:
+            with st.expander("Histórico do Editor Python"):
+                st.dataframe([{key: record.get(key, "") for key in ("created_at", "operation", "source_name", "output_name")} for record in records[:20]], use_container_width=True, hide_index=True)
+
+    with code_tab:
+        st.subheader("Scripts Python locais")
+        st.warning("Por segurança, o Editor Python guarda e edita scripts, mas não oferece execução de código dentro da UI.")
+        scripts = list_scripts()
+        script_options = ["Novo script"] + [str(path.name) for path in scripts]
+        selected_script = st.selectbox("Script", script_options, key="python_editor_script_name")
+        if selected_script != "Novo script":
+            selected_path = next((path for path in scripts if path.name == selected_script), None)
+            if selected_path and st.button("Carregar script", key="python_editor_load_script"):
+                st.session_state["python_editor_code"] = read_script(selected_path)
+                st.rerun()
+        with st.form("python_editor_code_form", clear_on_submit=False):
+            script_name = st.text_input("Nome do script", value="script.py" if selected_script == "Novo script" else selected_script, key="python_editor_code_name")
+            script_content = st.text_area("Código Python", value=st.session_state.get("python_editor_code", ""), height=420, key="python_editor_code_text")
+            save_code = st.form_submit_button("Guardar script localmente", type="primary")
+        if save_code:
+            try:
+                path = save_script(script_name, script_content)
+                st.session_state["python_editor_code"] = script_content
+                st.success(f"Script guardado em `{path}`.")
+            except PythonEditorError as exc:
+                st.error(str(exc))
+
+
 def render_videos():
     st.subheader("Vídeos e backlog")
     st.caption("Acompanhamento dos vídeos criados, estados da pipeline e controlos de execução.")
@@ -1735,7 +1864,7 @@ def main():
         "Edição": lambda: render_edit_placeholder("Edição", "Seleccione uma das abas de edição no menu expansível."),
         "Limpador de Metadados": render_metadata_cleaner,
         "Cortes": lambda: render_edit_placeholder("Cortes", "Área reservada para a futura funcionalidade de cortes de vídeo."),
-        "Editor Python": lambda: render_edit_placeholder("Editor Python", "Área reservada para o futuro editor Python."),
+        "Editor Python": render_python_editor,
         "Models AI": lambda: render_edit_placeholder("Models AI", "Seleccione uma das abas Models AI no menu expansível."),
         "Personagens": lambda: render_edit_placeholder("Personagens", "Área reservada para a futura funcionalidade de personagens."),
         "Redes Sociais": lambda: render_edit_placeholder("Redes Sociais", "Área reservada para a futura funcionalidade de redes sociais."),

package/hermes_ui/python_editor.py

@@ -0,0 +1,269 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+import shutil
+import subprocess
+import unicodedata
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from . import storage
+from .metadata_cleaner import VIDEO_EXTENSIONS as METADATA_VIDEO_EXTENSIONS
+from .metadata_cleaner import _resolve_ffmpeg
+
+VIDEO_EXTENSIONS = {f".{extension.lower().lstrip('.')}" for extension in METADATA_VIDEO_EXTENSIONS}
+AUDIO_EXTENSIONS = {".mp3", ".wav", ".m4a", ".aac", ".flac", ".ogg"}
+
+
+class PythonEditorError(RuntimeError):
+    """Raised when a controlled local editing operation cannot be completed."""
+
+
+def _root() -> Path:
+    return storage.STORAGE / "python_editor"
+
+
+def _outputs() -> Path:
+    path = _root() / "outputs"
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def _scripts() -> Path:
+    path = _root() / "scripts"
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def _now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _safe_filename(name: str, fallback: str = "video") -> str:
+    normalized = unicodedata.normalize("NFKD", Path(name).name)
+    ascii_name = normalized.encode("ascii", "ignore").decode("ascii")
+    ascii_name = re.sub(r"[^A-Za-z0-9._-]+", "-", ascii_name).strip(".-")
+    return ascii_name or fallback
+
+
+def _output_path(source: Path, operation: str, suffix: str | None = None) -> Path:
+    stamp = datetime.now().strftime("%Y%m%d-%H%M%S")
+    source_name = _safe_filename(source.stem, "video")
+    extension = suffix or source.suffix or ".mp4"
+    if not extension.startswith("."):
+        extension = f".{extension}"
+    return _outputs() / f"{operation}-{stamp}-{source_name}{extension.lower()}"
+
+
+def _validate_video(source: Path) -> Path:
+    candidate = Path(source).expanduser()
+    if not candidate.is_file():
+        raise PythonEditorError("O vídeo seleccionado não existe ou não é um ficheiro.")
+    if candidate.suffix.lower() not in VIDEO_EXTENSIONS:
+        raise PythonEditorError("O ficheiro seleccionado não tem uma extensão de vídeo suportada.")
+    return candidate.resolve()
+
+
+def _validate_audio(source: Path) -> Path:
+    candidate = Path(source).expanduser()
+    if not candidate.is_file():
+        raise PythonEditorError("O áudio seleccionado não existe ou não é um ficheiro.")
+    if candidate.suffix.lower() not in AUDIO_EXTENSIONS:
+        raise PythonEditorError("O ficheiro seleccionado não tem uma extensão de áudio suportada.")
+    return candidate.resolve()
+
+
+def list_video_files(folder: str | Path) -> list[Path]:
+    candidate = Path(folder).expanduser()
+    if not candidate.exists():
+        return []
+    if candidate.is_file():
+        return [candidate.resolve()] if candidate.suffix.lower() in VIDEO_EXTENSIONS else []
+    try:
+        return sorted(
+            (path.resolve() for path in candidate.iterdir() if path.is_file() and path.suffix.lower() in VIDEO_EXTENSIONS),
+            key=lambda path: path.stat().st_mtime,
+            reverse=True,
+        )
+    except OSError as exc:
+        raise PythonEditorError(f"Não foi possível ler a pasta de vídeos: {exc}") from exc
+
+
+def list_generated_videos(tasks: list[dict[str, Any]]) -> list[Path]:
+    paths: dict[str, Path] = {}
+    for task in tasks:
+        artifacts = task.get("artifacts") or {}
+        value = artifacts.get("video")
+        if isinstance(value, str) and value.strip():
+            candidate = Path(value).expanduser()
+            if candidate.is_file() and candidate.suffix.lower() in VIDEO_EXTENSIONS:
+                paths[str(candidate.resolve())] = candidate.resolve()
+    return sorted(paths.values(), key=lambda path: path.stat().st_mtime, reverse=True)
+
+
+def list_scripts() -> list[Path]:
+    return sorted((path for path in _scripts().glob("*.py") if path.is_file()), key=lambda path: path.stat().st_mtime, reverse=True)
+
+
+def read_script(path: Path) -> str:
+    candidate = path.resolve()
+    if _scripts().resolve() not in candidate.parents:
+        raise PythonEditorError("O script seleccionado tem de estar na pasta local de scripts do Thunderbolt.")
+    try:
+        return candidate.read_text(encoding="utf-8")
+    except OSError as exc:
+        raise PythonEditorError(f"Não foi possível ler o script: {exc}") from exc
+
+
+def save_script(name: str, content: str) -> Path:
+    safe_name = _safe_filename(name, "script")
+    if not safe_name.lower().endswith(".py"):
+        safe_name += ".py"
+    if not content.strip():
+        raise PythonEditorError("O script não pode ficar vazio.")
+    target = (_scripts() / safe_name).resolve()
+    if _scripts().resolve() not in target.parents:
+        raise PythonEditorError("O nome do script não é válido.")
+    target.write_text(content, encoding="utf-8")
+    return target
+
+
+def store_uploaded_asset(name: str, content: bytes, *, audio: bool = False) -> Path:
+    if not content:
+        raise PythonEditorError("O ficheiro enviado está vazio.")
+    allowed = AUDIO_EXTENSIONS if audio else VIDEO_EXTENSIONS
+    suffix = Path(name).suffix.lower()
+    if suffix not in allowed:
+        raise PythonEditorError("O ficheiro enviado não tem uma extensão suportada.")
+    directory = _root() / ("audio_inputs" if audio else "video_inputs")
+    directory.mkdir(parents=True, exist_ok=True)
+    digest = hashlib.sha256(content).hexdigest()[:16]
+    target = directory / f"{digest}-{_safe_filename(name, 'media')}"
+    if not target.exists():
+        target.write_bytes(content)
+    return target
+
+
+def _run(command: list[str], output: Path, operation: str, source: Path, *, extra: dict[str, Any] | None = None) -> tuple[Path, dict[str, Any]]:
+    output.parent.mkdir(parents=True, exist_ok=True)
+    try:
+        completed = subprocess.run(command, capture_output=True, text=True, check=False)
+    except OSError as exc:
+        raise PythonEditorError(f"Não foi possível iniciar FFmpeg: {exc}") from exc
+    if completed.returncode != 0 or not output.is_file() or output.stat().st_size == 0:
+        if output.exists():
+            output.unlink()
+        detail = (completed.stderr or completed.stdout or "erro desconhecido").strip()
+        raise PythonEditorError(f"A operação {operation} falhou: {detail[-1200:]}")
+    run_info = {
+        "operation": operation,
+        "source": str(source),
+        "output": str(output),
+        "command": command,
+        "created_at": _now(),
+    }
+    if extra:
+        run_info.update(extra)
+    return output, run_info
+
+
+def _ffmpeg(ffmpeg_path: str | None = None) -> str:
+    try:
+        return _resolve_ffmpeg(ffmpeg_path)
+    except RuntimeError as exc:
+        raise PythonEditorError(str(exc)) from exc
+
+
+def _atempo_chain(speed: float) -> str:
+    factors: list[float] = []
+    remaining = float(speed)
+    while remaining > 2.0:
+        factors.append(2.0)
+        remaining /= 2.0
+    while remaining < 0.5:
+        factors.append(0.5)
+        remaining /= 0.5
+    factors.append(remaining)
+    return ",".join(f"atempo={factor:.6f}" for factor in factors)
+
+
+def trim_video(source: Path, start_seconds: float, end_seconds: float, *, ffmpeg_path: str | None = None) -> tuple[Path, dict[str, Any]]:
+    source = _validate_video(source)
+    start = max(0.0, float(start_seconds))
+    end = float(end_seconds)
+    if end <= start:
+        raise PythonEditorError("O fim do corte deve ser superior ao início.")
+    output = _output_path(source, "corte")
+    command = [_ffmpeg(ffmpeg_path), "-y", "-hide_banner", "-loglevel", "error", "-ss", f"{start:.3f}", "-to", f"{end:.3f}", "-i", str(source), "-map", "0", "-c", "copy", "-avoid_negative_ts", "make_zero", str(output)]
+    return _run(command, output, "corte", source, extra={"start_seconds": start, "end_seconds": end})
+
+
+def remove_audio(source: Path, *, ffmpeg_path: str | None = None) -> tuple[Path, dict[str, Any]]:
+    source = _validate_video(source)
+    output = _output_path(source, "sem-audio")
+    command = [_ffmpeg(ffmpeg_path), "-y", "-hide_banner", "-loglevel", "error", "-i", str(source), "-map", "0:v:0", "-c:v", "copy", "-an", str(output)]
+    return _run(command, output, "remoção de áudio", source)
+
+
+def extract_audio(source: Path, *, ffmpeg_path: str | None = None) -> tuple[Path, dict[str, Any]]:
+    source = _validate_video(source)
+    output = _output_path(source, "audio", ".mp3")
+    command = [_ffmpeg(ffmpeg_path), "-y", "-hide_banner", "-loglevel", "error", "-i", str(source), "-vn", "-codec:a", "libmp3lame", "-q:a", "2", str(output)]
+    return _run(command, output, "extracção de áudio", source)
+
+
+def resize_video(source: Path, width: int, height: int, *, ffmpeg_path: str | None = None) -> tuple[Path, dict[str, Any]]:
+    source = _validate_video(source)
+    width = int(width)
+    height = int(height)
+    if width < 16 or height < 16:
+        raise PythonEditorError("As dimensões do vídeo devem ser pelo menos 16x16.")
+    output = _output_path(source, "redimensionado")
+    scale = f"scale={width}:{height}:force_original_aspect_ratio=decrease,pad={width}:{height}:(ow-iw)/2:(oh-ih)/2"
+    command = [_ffmpeg(ffmpeg_path), "-y", "-hide_banner", "-loglevel", "error", "-i", str(source), "-vf", scale, "-c:v", "libx264", "-preset", "medium", "-crf", "18", "-c:a", "aac", "-movflags", "+faststart", str(output)]
+    return _run(command, output, "redimensionamento", source, extra={"width": width, "height": height})
+
+
+def change_speed(source: Path, speed: float, *, ffmpeg_path: str | None = None) -> tuple[Path, dict[str, Any]]:
+    source = _validate_video(source)
+    speed = float(speed)
+    if speed < 0.25 or speed > 4.0:
+        raise PythonEditorError("A velocidade deve estar entre 0,25x e 4x.")
+    output = _output_path(source, "velocidade")
+    command = [_ffmpeg(ffmpeg_path), "-y", "-hide_banner", "-loglevel", "error", "-i", str(source), "-filter:v", f"setpts=PTS/{speed:.6f}", "-filter:a", _atempo_chain(speed), "-c:v", "libx264", "-preset", "medium", "-crf", "18", "-c:a", "aac", "-movflags", "+faststart", str(output)]
+    return _run(command, output, "alteração de velocidade", source, extra={"speed": speed})
+
+
+def replace_audio(source: Path, audio: Path, *, ffmpeg_path: str | None = None) -> tuple[Path, dict[str, Any]]:
+    source = _validate_video(source)
+    audio = _validate_audio(audio)
+    output = _output_path(source, "audio-substituido")
+    command = [_ffmpeg(ffmpeg_path), "-y", "-hide_banner", "-loglevel", "error", "-i", str(source), "-i", str(audio), "-map", "0:v:0", "-map", "1:a:0", "-c:v", "copy", "-c:a", "aac", "-shortest", str(output)]
+    return _run(command, output, "substituição de áudio", source, extra={"audio": str(audio)})
+
+
+def save_edit_record(source: Path, output: Path, run_info: dict[str, Any]) -> dict[str, Any]:
+    record = {
+        "id": hashlib.sha256(f"{source}:{output}:{run_info.get('created_at', '')}".encode("utf-8")).hexdigest()[:16],
+        "source_name": source.name,
+        "source_path": str(source),
+        "output_name": output.name,
+        "output_path": str(output),
+        "operation": run_info.get("operation", "editor"),
+        "parameters": {key: value for key, value in run_info.items() if key not in {"command", "source", "output", "created_at", "operation"}},
+        "created_at": run_info.get("created_at", _now()),
+    }
+    storage.append_json("python_editor_edits.json", record)
+    return record
+
+
+def editor_manifest(record: dict[str, Any]) -> bytes:
+    return (json.dumps(record, ensure_ascii=False, indent=2) + "\n").encode("utf-8")
+
+
+def list_edit_records() -> list[dict[str, Any]]:
+    records = storage.read_json("python_editor_edits.json", [])
+    return list(reversed(records)) if isinstance(records, list) else []

package/hermes_ui/storage.py

@@ -23,6 +23,7 @@ DEFAULTS: dict[str, Any] = {
     "uploads.json": [],
     "niche_apify_runs.json": [],
     "metadata_edits.json": [],
+    "python_editor_edits.json": [],
     "mcp_server.json": {
         "enabled": False,
         "host": "127.0.0.1",
@@ -227,7 +228,7 @@ def seed_blueprints() -> None:
 
 
 def ensure_storage() -> None:
-    for path in [STATE, BLUEPRINTS / "canais", BLUEPRINTS / "nichos", BLUEPRINTS / "importados", BLUEPRINTS / "brandings", STORAGE / "brand", STORAGE / "scripts", STORAGE / "thumbnails", STORAGE / "videos", STORAGE / "artifacts", STORAGE / "skills", STORAGE / "metadata_cleaner", STORAGE / "metadata_cleaner" / "outputs", STORAGE / "music", STORAGE / "voice_previews", NICHES_DATA]:
+    for path in [STATE, BLUEPRINTS / "canais", BLUEPRINTS / "nichos", BLUEPRINTS / "importados", BLUEPRINTS / "brandings", STORAGE / "brand", STORAGE / "scripts", STORAGE / "thumbnails", STORAGE / "videos", STORAGE / "artifacts", STORAGE / "skills", STORAGE / "metadata_cleaner", STORAGE / "metadata_cleaner" / "outputs", STORAGE / "music", STORAGE / "voice_previews", STORAGE / "python_editor", NICHES_DATA]:
         path.mkdir(parents=True, exist_ok=True)
     seed_blueprints()
     for filename, default in DEFAULTS.items():

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danhachuel/thunderbolt",
-  "version": "0.2.39",
+  "version": "0.2.40",
   "description": "Thunderbolt — interface local para operação de canais faceless e motor MoneyPrinterTurbo",
   "main": "scripts/cli.mjs",
   "type": "module",