@danhachuel/thunderbolt 0.7.16 → 0.7.18

package/app/main.py

@@ -35,7 +35,6 @@ from typing import Any
 
 import requests
 import streamlit as st
-import streamlit.components.v1 as components
 
 ROOT = Path(__file__).resolve().parents[1]
 if str(ROOT) not in sys.path:
@@ -83,7 +82,7 @@ from hermes_ui.channel_import import build_channel_template_xlsx, channel_is_dup
 from hermes_ui.drafts import list_drafts, save_draft
 from hermes_ui.automation_worker import load_worker_status
 from hermes_ui.pipeline_worker import load_pipeline_worker_status, recover_stale_tasks, STALE_TASK_SECONDS, WORKER_HEARTBEAT_TIMEOUT_SECONDS
-from hermes_ui.storage import BLUEPRINTS, DEFAULT_LLM_PROVIDER, MEDIA_DOWNLOADS, STORAGE, TIKTOK_PROMPT_MASTERS, atomic_write, ensure_storage, get_display_name, list_blueprint_files, list_prompt_master_files, load_blueprint_file, load_prompt_master_file, now, read_json, set_display_name, write_json
+from hermes_ui.storage import BLUEPRINTS, DEFAULT_LLM_PROVIDER, MEDIA_DOWNLOADS, STORAGE, TIKTOK_PROMPT_MASTERS, atomic_write, ensure_storage, get_display_name, list_blueprint_files, list_prompt_master_files, load_blueprint_file, load_prompt_master_file, now, read_json, set_display_name, update_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
@@ -115,7 +114,7 @@ from hermes_ui.api_key_tests import test_apify_credentials, test_influencer_data
 from hermes_ui.tutorials import tutorial_body, tutorial_caption, tutorial_title
 from hermes_ui.update_manager import check_version, restart_current_process, update_to_latest
 
-from hermes_ui.script_documents import list_script_documents, read_script_document, save_script_document, script_storage_path
+from hermes_ui.script_documents import delete_script_document, list_script_documents, read_script_document, save_script_document, script_storage_path, update_script_document, update_script_document_metadata
 from hermes_ui.script_generation import generate_script_document
 from hermes_ui.video_length import DEFAULT_AVERAGE_VIDEO_TIME, channel_video_length, channel_video_time_value, default_average_video_time, length_generation_settings, words_from_channel_time
 from hermes_ui.voice_preview import DEFAULT_SAMPLE, load_preview_file, synthesize_preview
@@ -268,8 +267,8 @@ ensure_storage()
 st.set_page_config(page_title="Thunderbolt", page_icon="T", layout="wide", initial_sidebar_state="expanded")
 
 theme_base = (st.get_option("theme.base") or "dark").lower()
-components.html(
-    """
+st.iframe(
+    srcdoc="""
 <script>
 (() => {
     const STYLE_ID = "thunderbolt-light-theme-style";
@@ -698,6 +697,52 @@ def blueprint_for_channel(channel: dict) -> dict[str, Any]:
     return {"id": blueprint_id, "name": blueprint_id}
 
 
+def _script_channel(record: dict[str, Any], channels: list[dict[str, Any]]) -> dict[str, Any]:
+    channel_id = str(record.get("channel_id") or "").strip()
+    channel_name = str(record.get("channel_name") or record.get("channel") or "").strip().casefold()
+    return next(
+        (
+            channel
+            for channel in channels
+            if isinstance(channel, dict)
+            and (
+                (channel_id and str(channel.get("id") or "").strip() == channel_id)
+                or (channel_name and str(channel.get("name") or "").strip().casefold() == channel_name)
+            )
+        ),
+        {},
+    )
+
+
+def _backfill_saved_script_blueprints(records: list[dict[str, Any]] | None = None) -> list[dict[str, Any]]:
+    """Attach every saved video script to the Blueprint configured on its channel."""
+    channels = [item for item in read_json("channels.json", []) if isinstance(item, dict)]
+    updated_records: list[dict[str, Any]] = []
+    for record in records if records is not None else list_script_documents():
+        if str(record.get("document_type") or "video_script").strip() != "video_script":
+            continue
+        channel = _script_channel(record, channels)
+        if not channel:
+            continue
+        blueprint_id = str(channel.get("default_blueprint_id") or channel.get("blueprint_id") or "").strip()
+        blueprint = blueprint_for_channel(channel)
+        blueprint_name = str(blueprint.get("name") or blueprint_id or "SEM BLUEPRINT CONFIGURADO").strip()
+        current_id = str(record.get("blueprint_id") or "").strip()
+        current_name = str(record.get("blueprint_name") or record.get("blueprint") or "").strip()
+        if current_id == blueprint_id and current_name == blueprint_name:
+            updated_records.append(record)
+            continue
+        try:
+            updated = update_script_document_metadata(
+                str(record.get("id") or ""),
+                {"blueprint_id": blueprint_id, "blueprint": blueprint_name},
+            )
+        except (FileNotFoundError, OSError, ValueError):
+            updated = {**record, "blueprint_id": blueprint_id, "blueprint_name": blueprint_name}
+        updated_records.append(updated)
+    return updated_records
+
+
 def channel_video_language(channel: dict[str, Any] | None, fallback: str = "pt") -> str:
     """Return the channel's canonical video language, preserving legacy labels."""
     if not isinstance(channel, dict):
@@ -3355,10 +3400,29 @@ def _create_video_task_from_saved_script(record: dict[str, Any], channel: dict[s
         {
             **payload,
             "topic_source": "saved_script",
+            "script_document_id": str(record.get("id") or ""),
             "channel_payloads": {str(channel.get("id") or ""): payload},
         },
     )
-    return create_tasks_for_batch(batch)
+    tasks = create_tasks_for_batch(batch)
+    for task in tasks:
+        task["script_document_id"] = str(record.get("id") or "")
+        task["manual_start_required"] = True
+        task["created_at"] = str(record.get("created_at") or task.get("created_at") or now())
+        task["updated_at"] = now()
+    if tasks:
+        task_ids = {str(task.get("id") or "") for task in tasks}
+        created_by_id = {str(task.get("id") or ""): task for task in tasks}
+
+        def persist_created_metadata(entries: Any) -> None:
+            if not isinstance(entries, list):
+                return
+            for entry in entries:
+                if isinstance(entry, dict) and str(entry.get("id") or "") in task_ids:
+                    entry.update(created_by_id[str(entry.get("id") or "")])
+
+        update_json("tasks.json", [], persist_created_metadata)
+    return tasks
 
 
 def render_video_from_draft(prefix: str = "new_video") -> None:
@@ -4172,7 +4236,7 @@ def render_scripts():
 
     with history_tab:
         st.caption(f"Histórico persistente: `{script_dir}` · índice em `{STORAGE / 'state' / 'scripts.json'}`")
-        records = list_script_documents()
+        records = _backfill_saved_script_blueprints(list_script_documents())
         if not records:
             st.info("Ainda não existem roteiros ou letras guardados.")
         for record in records[:50]:
@@ -4182,9 +4246,54 @@ def render_scripts():
                 stored_path = Path(str(record.get("path") or ""))
                 content = read_script_document(record)
                 if content:
-                    st.text_area("Conteúdo", value=content, height=220, key=f"stored_script_{record.get('id')}")
+                    document_id = str(record.get("id") or "")
+                    edit_key = f"editing_script_{document_id}"
+                    if st.session_state.get(edit_key):
+                        edited_content = st.text_area("Markdown editável", value=content, height=320, key=f"stored_script_edit_{document_id}")
+                        edit_save_col, edit_cancel_col = st.columns(2, gap="small")
+                        with edit_save_col:
+                            if st.button("Guardar edição", type="primary", width="stretch", key=f"save_script_edit_{document_id}"):
+                                try:
+                                    update_script_document(document_id, edited_content)
+                                    st.session_state.pop(edit_key, None)
+                                    st.success("Roteiro actualizado.")
+                                    st.rerun()
+                                except (FileNotFoundError, OSError, ValueError) as exc:
+                                    st.error(f"Não foi possível actualizar o roteiro: {exc}")
+                        with edit_cancel_col:
+                            if st.button("Cancelar edição", width="stretch", key=f"cancel_script_edit_{document_id}"):
+                                st.session_state.pop(edit_key, None)
+                                st.rerun()
+                    else:
+                        st.text_area("Conteúdo", value=content, height=220, key=f"stored_script_{document_id}")
                     if stored_path.is_file():
-                        st.download_button("Descarregar Markdown", data=stored_path.read_bytes(), file_name=stored_path.name, mime="text/markdown", key=f"download_script_{record.get('id')}")
+                        download_col, edit_col, delete_col = st.columns([1.25, 0.75, 0.75], gap="small")
+                        with download_col:
+                            st.download_button("Descarregar Markdown", data=stored_path.read_bytes(), file_name=stored_path.name, mime="text/markdown", key=f"download_script_{document_id}", width="stretch")
+                        with edit_col:
+                            if st.button("Editar", key=f"edit_script_{document_id}", width="stretch"):
+                                st.session_state[edit_key] = True
+                                st.rerun()
+                        with delete_col:
+                            confirm_delete_key = f"confirm_delete_script_{document_id}"
+                            if st.button("Apagar", key=f"delete_script_{document_id}", type="primary", width="stretch"):
+                                st.session_state[confirm_delete_key] = True
+                                st.rerun()
+                        if st.session_state.get(confirm_delete_key):
+                            st.warning("Apagar este roteiro do histórico e do storage?")
+                            confirm_col, cancel_col = st.columns(2, gap="small")
+                            with confirm_col:
+                                if st.button("Confirmar apagar", key=f"confirm_delete_script_button_{document_id}", type="primary", width="stretch"):
+                                    try:
+                                        delete_script_document(document_id)
+                                        st.session_state.pop(confirm_delete_key, None)
+                                        st.rerun()
+                                    except (OSError, ValueError) as exc:
+                                        st.error(f"Não foi possível apagar o roteiro: {exc}")
+                            with cancel_col:
+                                if st.button("Cancelar", key=f"cancel_delete_script_{document_id}", width="stretch"):
+                                    st.session_state.pop(confirm_delete_key, None)
+                                    st.rerun()
                 else:
                     st.warning("O ficheiro deste registo já não está disponível no storage.")
 
@@ -5002,10 +5111,79 @@ def task_platform(task: dict[str, Any]) -> str:
     return "tiktok" if format_value in {"portrait", "portrait 9:16", "9:16"} else "youtube"
 
 
+def _saved_script_task_matches(task: dict[str, Any], record: dict[str, Any], channel: dict[str, Any], content: str) -> bool:
+    document_id = str(record.get("id") or "").strip()
+    if document_id and str(task.get("script_document_id") or "").strip() == document_id:
+        return True
+    if str(task.get("topic_source") or "").strip() != "saved_script":
+        return False
+    if str(task.get("channel_id") or "").strip() != str(channel.get("id") or "").strip():
+        return False
+    generation_settings = task.get("generation_settings") if isinstance(task.get("generation_settings"), dict) else {}
+    saved_content = str(generation_settings.get("video_script") or task.get("video_script") or "").strip()
+    if saved_content and saved_content == content.strip():
+        return True
+    title = str(record.get("title") or "").strip()
+    return bool(title and str(task.get("title") or task.get("topic") or "").strip() == title)
+
+
+def _sync_saved_scripts_to_youtube_automation() -> None:
+    """Expose every saved video script as one manual YouTube task, without duplicates."""
+    records = _backfill_saved_script_blueprints(list_script_documents())
+    channels = [item for item in read_json("channels.json", []) if isinstance(item, dict)]
+    existing_tasks = load_video_tasks_for_catalog()
+    for raw_record in records:
+        if str(raw_record.get("document_type") or "video_script").strip() != "video_script":
+            continue
+        content = read_script_document(raw_record)
+        if not content:
+            continue
+        channel = _script_channel(raw_record, channels)
+        if not channel or task_platform({"platform": channel.get("platform", "youtube"), "channel_id": channel.get("id")}) != "youtube":
+            continue
+        record = normalise_saved_script({**raw_record, "channel_id": str(channel.get("id") or "")}, content)
+        matched_task = next((task for task in existing_tasks if _saved_script_task_matches(task, record, channel, content)), None)
+        if matched_task:
+            if str(matched_task.get("script_document_id") or "") != str(record.get("id") or "") or (
+                str(matched_task.get("state") or "") == "to_do" and not bool(matched_task.get("manual_start_required", False))
+            ):
+                matched_id = str(matched_task.get("id") or "")
+
+                def mark_existing_script(entries: Any) -> None:
+                    if not isinstance(entries, list):
+                        return
+                    for entry in entries:
+                        if isinstance(entry, dict) and str(entry.get("id") or "") == matched_id:
+                            entry["script_document_id"] = str(record.get("id") or "")
+                            if str(entry.get("state") or "") == "to_do":
+                                entry["manual_start_required"] = True
+
+                update_json("tasks.json", [], mark_existing_script)
+            continue
+        created = _create_video_task_from_saved_script(record, channel, {})
+        existing_tasks.extend(created)
+
+
+def _automation_created_at(task: dict[str, Any]) -> tuple[datetime, str]:
+    value = str(task.get("created_at") or "").strip()
+    try:
+        parsed = datetime.fromisoformat(value)
+        if parsed.tzinfo is None:
+            parsed = parsed.replace(tzinfo=timezone.utc)
+    except ValueError:
+        parsed = datetime.min.replace(tzinfo=timezone.utc)
+    return parsed.astimezone(timezone.utc), str(task.get("id") or "")
+
+
 def load_automation_tasks_for_platform(platform_name: str) -> list[dict[str, Any]]:
     """Return only automation/catalog tasks belonging to one publishing platform."""
     target = str(platform_name or "").strip().casefold()
-    return [task for task in load_video_tasks_for_catalog() if task_platform(task) == target]
+    if target == "youtube":
+        _sync_saved_scripts_to_youtube_automation()
+    return sorted(
+        [task for task in load_video_tasks_for_catalog() if task_platform(task) == target],
+        key=_automation_created_at,
+    )
 
 
 def _task_thumbnail_path(task: dict[str, Any]) -> Path | None:
@@ -5126,6 +5304,8 @@ def _start_pipeline_task(task_id: str, state: str) -> bool:
     """Start or retry a video task from any platform automation card."""
     if state in {"blocked", "failed"}:
         updated = retry_task_with_current_settings(task_id)
+        if updated and bool(updated.get("manual_start_required", False)):
+            updated = transition_task(task_id, "doing")
     else:
         updated = transition_task(task_id, "doing")
     if not updated:

package/hermes_ui/pipeline_worker.py

@@ -297,6 +297,26 @@ def _update(task_id: str, **updates: Any) -> dict[str, Any]:
         orchestration=updated.get("orchestration") or {},
     )
     return updated
+
+
+def _next_runnable_task(tasks: Any) -> dict[str, Any] | None:
+    """Return the first active task, excluding saved scripts awaiting Start."""
+    if not isinstance(tasks, list):
+        return None
+    return next(
+        (
+            task
+            for task in tasks
+            if isinstance(task, dict)
+            and (
+                task.get("state") == "doing"
+                or (task.get("state") == "to_do" and not bool(task.get("manual_start_required", False)))
+            )
+        ),
+        None,
+    )
+
+
 def _channel_for_task(task: dict[str, Any]) -> dict[str, Any]:
     channel_id = str(task.get("channel_id") or "")
     return next((channel for channel in read_json("channels.json", []) if str(channel.get("id")) == channel_id), {})
@@ -1641,7 +1661,7 @@ def run_once() -> dict[str, Any]:
             _worker_heartbeat(session_info_health_error=type(exc).__name__)
         recovered = _recover_stale_tasks()
         tasks = read_json("tasks.json", [])
-        candidate = next((task for task in tasks if isinstance(task, dict) and task.get("state") in {"to_do", "doing"}), None)
+        candidate = _next_runnable_task(tasks)
         if not candidate:
             _worker_heartbeat(last_task_id=None, last_error="", status="idle", stage="idle", progress=0, recovered_task_ids=recovered)
             return {"ok": True, "status": "idle", "recovered_task_ids": recovered}

package/hermes_ui/script_documents.py

@@ -25,6 +25,73 @@ def script_storage_path() -> Path:
     return path
 
 
+def _history_records() -> list[dict[str, Any]]:
+    history = read_json(SCRIPT_HISTORY_FILE, [])
+    return [item for item in history if isinstance(item, dict)] if isinstance(history, list) else []
+
+
+def _record_index(history: list[dict[str, Any]], document_id: str) -> int:
+    return next((index for index, item in enumerate(history) if str(item.get("id") or "") == document_id), -1)
+
+
+def _front_matter_values(markdown: str) -> dict[str, str]:
+    text = str(markdown or "")
+    if not text.startswith("---"):
+        return {}
+    parts = text.split("---", 2)
+    if len(parts) != 3:
+        return {}
+    values: dict[str, str] = {}
+    for line in parts[1].splitlines():
+        key, separator, value = line.partition(":")
+        if separator:
+            values[key.strip()] = value.strip()
+    return values
+
+
+def _with_front_matter(markdown: str, updates: dict[str, Any]) -> str:
+    text = str(markdown or "")
+    if text.startswith("---"):
+        parts = text.split("---", 2)
+        if len(parts) == 3:
+            lines = parts[1].splitlines()
+            update_keys = {str(key): str(value or "") for key, value in updates.items()}
+            seen: set[str] = set()
+            output: list[str] = []
+            for line in lines:
+                key, separator, _value = line.partition(":")
+                normalized_key = key.strip()
+                if separator and normalized_key in update_keys:
+                    output.append(f"{normalized_key}: {update_keys[normalized_key]}")
+                    seen.add(normalized_key)
+                else:
+                    output.append(line)
+            for key, value in update_keys.items():
+                if key not in seen:
+                    output.append(f"{key}: {value}")
+            return "---\n" + "\n".join(output) + "\n---" + parts[2]
+    front_matter = ["---", *[f"{key}: {str(value or '')}" for key, value in updates.items()], "---", ""]
+    return "\n".join(front_matter) + text.lstrip("\r\n")
+
+
+def _merge_record_front_matter(record: dict[str, Any], values: dict[str, str]) -> dict[str, Any]:
+    merged = dict(record)
+    field_mapping = {
+        "id": "id",
+        "type": "document_type",
+        "title": "title",
+        "language": "language",
+        "channel": "channel_name",
+        "blueprint_id": "blueprint_id",
+        "blueprint": "blueprint_name",
+        "created_at": "created_at",
+    }
+    for source, target in field_mapping.items():
+        if source in values:
+            merged[target] = values[source]
+    return merged
+
+
 def save_script_document(document: dict[str, Any]) -> dict[str, Any]:
     content = str(document.get("content") or "").strip()
     if not content:
@@ -63,17 +130,14 @@ def save_script_document(document: dict[str, Any]) -> dict[str, Any]:
         "created_at": created_at,
         "content": content,
     }
-    history = read_json(SCRIPT_HISTORY_FILE, [])
-    if not isinstance(history, list):
-        history = []
+    history = _history_records()
     history.insert(0, {key: value for key, value in record.items() if key != "content"})
     write_json(SCRIPT_HISTORY_FILE, history[:200])
     return record
 
 
 def list_script_documents() -> list[dict[str, Any]]:
-    history = read_json(SCRIPT_HISTORY_FILE, [])
-    return [item for item in history if isinstance(item, dict)] if isinstance(history, list) else []
+    return _history_records()
 
 
 def read_script_document(record: dict[str, Any]) -> str:
@@ -81,3 +145,55 @@ def read_script_document(record: dict[str, Any]) -> str:
     if not path.is_file():
         return ""
     return path.read_text(encoding="utf-8")
+
+
+def update_script_document(document_id: str, content: str) -> dict[str, Any]:
+    """Replace one saved Markdown document and refresh its indexed front matter."""
+    if not str(content or "").strip():
+        raise ValueError("O documento não pode ser guardado vazio.")
+    history = _history_records()
+    index = _record_index(history, str(document_id))
+    if index < 0:
+        raise ValueError("O roteiro já não existe no histórico.")
+    record = history[index]
+    path = Path(str(record.get("path") or ""))
+    if not path.is_file():
+        raise FileNotFoundError("O ficheiro do roteiro já não está disponível no storage.")
+    normalized = str(content).rstrip() + "\n"
+    path.write_text(normalized, encoding="utf-8")
+    history[index] = _merge_record_front_matter(record, _front_matter_values(normalized))
+    write_json(SCRIPT_HISTORY_FILE, history)
+    return history[index]
+
+
+def update_script_document_metadata(document_id: str, metadata: dict[str, Any]) -> dict[str, Any]:
+    """Update front-matter fields in place without changing the Markdown body."""
+    history = _history_records()
+    index = _record_index(history, str(document_id))
+    if index < 0:
+        raise ValueError("O roteiro já não existe no histórico.")
+    record = history[index]
+    path = Path(str(record.get("path") or ""))
+    if not path.is_file():
+        raise FileNotFoundError("O ficheiro do roteiro já não está disponível no storage.")
+    updated_markdown = _with_front_matter(path.read_text(encoding="utf-8"), metadata)
+    path.write_text(updated_markdown.rstrip() + "\n", encoding="utf-8")
+    history[index] = _merge_record_front_matter(record, _front_matter_values(updated_markdown))
+    write_json(SCRIPT_HISTORY_FILE, history)
+    return history[index]
+
+
+def delete_script_document(document_id: str) -> bool:
+    """Remove a saved document from the history index and its Markdown file."""
+    history = _history_records()
+    index = _record_index(history, str(document_id))
+    if index < 0:
+        return False
+    record = history.pop(index)
+    path = Path(str(record.get("path") or ""))
+    try:
+        if path.is_file():
+            path.unlink()
+    finally:
+        write_json(SCRIPT_HISTORY_FILE, history)
+    return True

package/package.json

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