app.py

import gradio as gr
import re
import json
import os
import tempfile
import shlex
from huggingface_hub import HfApi

from build_logic import (
    _get_api_token as build_logic_get_api_token,
    whoami as build_logic_whoami,
    list_space_files_for_browsing,
    get_space_repository_info,
    get_space_file_content,
    update_space_file,
    parse_markdown as build_logic_parse_markdown,
    delete_space_file as build_logic_delete_space_file,
    get_space_runtime_status,
    apply_staged_changes,
)

from model_logic import (
    get_available_providers,
    get_models_for_provider,
    get_default_model_for_provider,
    generate_stream
)

backtick = chr(96)
bbb = f'{backtick}{backtick}{backtick}'

parsed_code_blocks_state_cache = []
BOT_ROLE_NAME = "assistant"

DEFAULT_SYSTEM_PROMPT = f"""You are an expert AI programmer and Hugging Face assistant. Your role is to generate code and file structures based on user requests, or to modify existing code provided by the user.

You operate in the context of a Hugging Face Space. You can propose file changes and trigger specific actions.

**File and Code Formatting:**
When you provide NEW code for a file, or MODIFIED code for an existing file, use the following format exactly:
### File: path/to/filename.ext
(You can add a short, optional, parenthesized description after the filename on the SAME line)
{bbb}language
# Your full code here
{bbb}

If the file is binary, or you cannot show its content, use this format:
### File: path/to/binaryfile.ext
[Binary file - approximate_size bytes]

When you provide a project file structure, use this format (for informational purposes, not parsed for changes):
## File Structure
{bbb}
📁 Root
  📄 file1.py
  📁 subfolder
    📄 file2.js
{bbb}

**Instructions and Rules:**
- The role name for your responses in the chat history must be '{BOT_ROLE_NAME}'.
- Adhere strictly to these formatting instructions.
- If you update a file, provide the FULL file content again under the same filename.
- Only the latest version of each file mentioned throughout the chat will be used for the final output. The system will merge your changes with the prior state before applying.

**Hugging Face Space Actions:**
To perform direct actions on the Hugging Face Space, use the `### HF_ACTION: COMMAND arguments...` command on a single line.
The system will parse these actions from your response and present them to the user for confirmation before executing.

Available commands:
- `CREATE_SPACE <owner>/<repo_name> --sdk <sdk> --private <true|false>`: Creates a new, empty space. SDK can be gradio, streamlit, docker, or static. Private is optional and defaults to false. Use this ONLY when the user explicitly asks to create a *new* space with a specific name. When using this action, also provide the initial file structure (e.g., app.py, README.md) using `### File:` blocks in the same response. The system will apply these files to the new space.
- `DELETE_FILE path/to/file.ext`: Deletes a specific file from the current space.
- `SET_PRIVATE <true|false>`: Sets the privacy for the current space.
- `DELETE_SPACE`: Deletes the entire current space. THIS IS PERMANENT AND REQUIRES CAUTION. Only use this if the user explicitly and clearly asks to delete the space.

You can issue multiple file updates and action commands in a single response. The system will process all of them into a single change plan.

**Current Space Context:**
You will be provided with the current state of the files in the Space the user is interacting with. Use this information to understand the current project structure and content before proposing changes or actions. This context will appear after the user's message, starting with "## Current Space Context:". Do NOT include this context in your response. Only generate your response based on the user's request and the formatting rules above.

If no code or actions are requested, respond conversationally and help the user understand the Space Commander's capabilities.
"""

def escape_html_for_markdown(text):
    if not isinstance(text, str): return ""
    return text.replace("&", "&").replace("<", "<").replace(">", ">")

def _infer_lang_from_filename(filename):
    if not filename: return "plaintext"
    if '.' in filename:
        ext = filename.split('.')[-1].lower()
        mapping = {
            'py': 'python', 'js': 'javascript', 'ts': 'typescript', 'jsx': 'javascript', 'tsx': 'typescript',
            'html': 'html', 'htm': 'html', 'css': 'css', 'scss': 'scss', 'sass': 'sass', 'less': 'less',
            'json': 'json', 'xml': 'xml', 'yaml': 'yaml', 'yml': 'yaml', 'toml': 'toml',
            'md': 'markdown', 'rst': 'rst',
            'sh': 'bash', 'bash': 'bash', 'zsh': 'bash', 'bat': 'batch', 'cmd': 'batch', 'ps1': 'powershell',
            'c': 'c', 'h': 'c', 'cpp': 'cpp', 'hpp': 'cpp', 'cs': 'csharp', 'java': 'java',
            'rb': 'ruby', 'php': 'php', 'go': 'go', 'rs': 'rust', 'swift': 'swift', 'kt': 'kotlin', 'kts': 'kotlin',
            'sql': 'sql', 'dockerfile': 'docker', 'tf': 'terraform', 'hcl': 'terraform',
            'txt': 'plaintext', 'log': 'plaintext', 'ini': 'ini', 'conf': 'plaintext', 'cfg': 'plaintext',
            'csv': 'plaintext', 'tsv': 'plaintext', 'err': 'plaintext',
            '.env': 'plaintext', '.gitignore': 'plaintext', '.npmrc': 'plaintext', '.gitattributes': 'plaintext',
            'makefile': 'makefile',
        }
        return mapping.get(ext, "plaintext")
    base_filename = os.path.basename(filename)
    if base_filename == 'Dockerfile': return 'docker'
    if base_filename == 'Makefile': return 'makefile'
    if base_filename.startswith('.'): return 'plaintext'
    return "plaintext"

def _clean_filename(filename_line_content):
    text = filename_line_content.strip()
    text = re.sub(r'[`\*_#]+', '', text).strip()
    text = re.split(r'\s*\(', text, 1)[0].strip()
    text = text.strip('\'":;,')
    text = text.lstrip('/')
    return text

def _parse_and_update_state_cache(latest_bot_message_content, current_files_state):
    current_files_dict = {f["filename"]: f.copy() for f in current_files_state if not f.get("is_structure_block")}
    structure_block_state = next((b for b in current_files_state if b.get("is_structure_block")), None)

    content = latest_bot_message_content or ""

    file_pattern = re.compile(r"### File:\s*(?P<filename_line>[^\n]+)\n(?:```(?P<lang>[\w\.\-\+]*)\n(?P<code>[\s\S]*?)\n```|(?P<binary_msg>\[Binary file(?: - [^\]]+)?\]))", re.MULTILINE)
    structure_pattern = re.compile(r"## File Structure\n```(?:(?P<struct_lang>[\w.-]*)\n)?(?P<structure_code>[\s\S]*?)\n```", re.MULTILINE)

    structure_match = structure_pattern.search(content)
    if structure_match:
        structure_block_state = {"filename": "File Structure (from AI)", "language": structure_match.group("struct_lang") or "plaintext", "code": structure_match.group("structure_code").strip(), "is_binary": False, "is_structure_block": True}

    current_message_proposed_filenames = []
    for match in file_pattern.finditer(content):
        filename = _clean_filename(match.group("filename_line"))
        if not filename: continue

        lang, code_block, binary_msg = match.group("lang"), match.group("code"), match.group("binary_msg")

        item_data = {"filename": filename, "is_binary": False, "is_structure_block": False}

        if code_block is not None:
            item_data["code"] = code_block.strip()
            item_data["language"] = (lang.strip().lower() if lang else _infer_lang_from_filename(filename))
            item_data["is_binary"] = False
        elif binary_msg is not None:
            item_data["code"] = binary_msg.strip()
            item_data["language"] = "binary"
            item_data["is_binary"] = True
        else: continue

        current_files_dict[filename] = item_data
        current_message_proposed_filenames.append(filename)

    updated_parsed_blocks = list(current_files_dict.values())
    if structure_block_state:
        updated_parsed_blocks.insert(0, structure_block_state)

    updated_parsed_blocks.sort(key=lambda b: (0, b["filename"]) if b.get("is_structure_block") else (1, b["filename"]))

    return updated_parsed_blocks, current_message_proposed_filenames

def _export_selected_logic(selected_filenames, space_line_name_for_md, parsed_blocks_for_export):
    results = {"output_str": "", "error_message": None, "download_filepath": None}
    file_blocks_for_export = [b for b in parsed_blocks_for_export if not b.get("is_structure_block")]
    all_filenames_in_state = sorted(list(set(b["filename"] for b in file_blocks_for_export)))

    output_lines = [f"# Space: {space_line_name_for_md}"]

    structure_block = next((b for b in parsed_blocks_for_export if b.get("is_structure_block")), None)
    if structure_block:
        output_lines.extend(["## File Structure", bbb, structure_block["code"].strip(), bbb, ""])
    else:
        output_lines.extend(["## File Structure", bbb, "📁 Root"])
        if all_filenames_in_state:
            for fname in all_filenames_in_state: output_lines.append(f"  📄 {fname}")
        output_lines.extend([bbb, ""])

    output_lines.append("Below are the contents of all files in the space:\n")

    blocks_to_export_content = sorted([b for b in file_blocks_for_export if not selected_filenames or b["filename"] in selected_filenames], key=lambda b: b["filename"])

    exported_content_count = 0
    for block in blocks_to_export_content:
        output_lines.append(f"### File: {block['filename']}")
        content = block.get('code', '')
        if block.get('is_binary') or content.startswith(("[Binary file", "[Error loading content:", "[Binary or Skipped file]")):
             output_lines.append(content)
        else:
            lang = block.get('language', 'plaintext') or 'plaintext'
            output_lines.extend([f"{bbb}{lang}", content, bbb])
        output_lines.append("")
        exported_content_count += 1

    if not exported_content_count:
        if selected_filenames: output_lines.append("*No selected files have editable content in the state.*")
        elif not all_filenames_in_state: output_lines.append("*No files in state to list structure or export.*")


    final_output_str = "\n".join(output_lines)
    results["output_str"] = final_output_str
    try:
        with tempfile.NamedTemporaryFile(mode="w", delete=False, suffix=".md", encoding='utf-8') as tmpfile:
            tmpfile.write(final_output_str); results["download_filepath"] = tmpfile.name
    except Exception as e:
        print(f"Error creating temp file for download: {e}")
        results["error_message"] = "Could not prepare file for download."
        results["download_filepath"] = None

    return results

def _convert_gr_history_to_api_messages(system_prompt, gr_history, current_user_message=None):
    messages = [{"role": "system", "content": system_prompt}] if system_prompt else []
    for user_msg, bot_msg in gr_history:
        if user_msg: messages.append({"role": "user", "content": user_msg})
        if bot_msg and isinstance(bot_msg, str): messages.append({"role": BOT_ROLE_NAME, "content": bot_msg})
    if current_user_message: messages.append({"role": "user", "content": current_user_message})
    return messages

def _generate_ui_outputs_from_cache(owner, space_name):
    global parsed_code_blocks_state_cache
    preview_md_val = "*No files in cache to display.*"
    space_line_name = f"{owner}/{space_name}" if owner and space_name else (owner or space_name or "your-space")
    export_result = _export_selected_logic(None, space_line_name, parsed_code_blocks_state_cache)
    formatted_md_val = export_result["output_str"]
    download_file = export_result["download_filepath"]
    formatted_md_val = formatted_md_val or "*Load or define a Space to see its Markdown structure.*"

    if parsed_code_blocks_state_cache:
        preview_md_lines = ["## Detected/Updated Files & Content (Latest Versions):"]
        file_blocks_in_cache = sorted([b for b in parsed_code_blocks_state_cache if not b.get("is_structure_block")], key=lambda b: b["filename"])
        structure_block_in_cache = next((b for b in parsed_code_blocks_state_cache if b.get("is_structure_block")), None)

        if structure_block_in_cache:
             preview_md_lines.append(f"\n----\n**File Structure:** (from AI)\n{bbb}\n{escape_html_for_markdown(structure_block_in_cache['code'].strip())}\n{bbb}\n")

        if file_blocks_in_cache:
            for block in file_blocks_in_cache:
                preview_md_lines.append(f"\n----\n**File:** `{escape_html_for_markdown(block['filename'])}`")
                if block.get('is_binary'): preview_md_lines.append(f" (Binary File or Skipped)\n")
                else: preview_md_lines.append(f" (Language: `{block['language']}`)\n")

                content = block.get('code', '')
                if block.get('is_binary') or content.startswith(("[Binary file", "[Error loading content:", "[Binary or Skipped file]")):
                     preview_md_lines.append(f"\n`{escape_html_for_markdown(content.strip())}`\n")
                else:
                     lang = block.get('language', 'plaintext') or 'plaintext'
                     preview_md_lines.append(f"\n{bbb}{lang}\n{content.strip()}\n{bbb}\n")
        preview_md_val = "\n".join(preview_md_lines)

    return formatted_md_val, preview_md_val, gr.update(value=download_file, interactive=download_file is not None)

def generate_and_stage_changes(ai_response_content, current_files_state, hf_owner_name, hf_repo_name):
    changeset = []
    current_files_dict = {f["filename"]: f for f in current_files_state if not f.get("is_structure_block")}
    ai_parsed_md = build_logic_parse_markdown(ai_response_content)
    ai_proposed_files_list = ai_parsed_md.get("files", [])
    ai_proposed_files_dict = {f["path"]: f for f in ai_proposed_files_list}

    action_pattern = re.compile(r"### HF_ACTION:\s*(?P<command_line>[^\n]+)", re.MULTILINE)
    for match in action_pattern.finditer(ai_response_content):
        try:
            cmd_parts = shlex.split(match.group("command_line").strip())
            if not cmd_parts: continue
            command, args = cmd_parts[0].upper(), cmd_parts[1:]

            if command == "CREATE_SPACE" and args:
                repo_id = args[0]
                sdk = "gradio"
                private = False
                if '--sdk' in args:
                    try: sdk = args[args.index('--sdk') + 1]
                    except IndexError: print("Warning: CREATE_SPACE --sdk requires an argument.")
                if '--private' in args:
                     try: private_str = args[args.index('--private') + 1].lower()
                     except IndexError: print("Warning: CREATE_SPACE --private requires an argument.")
                     else: private = private_str == 'true'
                changeset.append({"type": "CREATE_SPACE", "repo_id": repo_id, "sdk": sdk, "private": private})

            elif command == "DELETE_FILE" and args:
                file_path = args[0]
                changeset.append({"type": "DELETE_FILE", "path": file_path})

            elif command == "SET_PRIVATE" and args:
                private = args[0].lower() == 'true'
                changeset.append({"type": "SET_PRIVACY", "private": private, "repo_id": f"{hf_owner_name}/{hf_repo_name}"})

            elif command == "DELETE_SPACE":
                changeset.append({"type": "DELETE_SPACE", "owner": hf_owner_name, "space_name": hf_repo_name})

        except Exception as e:
             print(f"Error parsing HF_ACTION line '{match.group('command_line').strip()}': {e}")


    for file_info in ai_proposed_files_list:
        filename = file_info["path"]
        proposed_content = file_info["content"]

        if filename in current_files_dict:
            current_content = current_files_dict[filename]["code"]
            is_proposed_placeholder = proposed_content.startswith(("[Binary file", "[Error loading content:", "[Binary or Skipped file]"))

            if not is_proposed_placeholder and proposed_content != current_content:
                lang = current_files_dict[filename].get("language") or _infer_lang_from_filename(filename)
                changeset.append({"type": "UPDATE_FILE", "path": filename, "content": proposed_content, "lang": lang})
            elif is_proposed_placeholder:
                 print(f"Skipping staging update for {filename}: Proposed content is a placeholder.")

        else:
            proposed_content = file_info["content"]
            if not (proposed_content.startswith("[Binary file") or proposed_content.startswith("[Error loading content:") or proposed_content.startswith("[Binary or Skipped file]")):
                lang = _infer_lang_from_filename(filename)
                changeset.append({"type": "CREATE_FILE", "path": filename, "content": proposed_content, "lang": lang})
            else:
                 print(f"Skipping staging create for {filename}: Proposed content is a placeholder.")

    if not changeset:
        md_summary = ["### 📋 Proposed Changes Plan", "\nThe AI did not propose any specific changes to files or the space.\n"]
    else:
        md_summary = ["### 📋 Proposed Changes Plan\n"]
        md_summary.append("The AI has proposed the following changes. Please review and confirm.")

        file_changes = [c for c in changeset if c['type'] in ['CREATE_FILE', 'UPDATE_FILE', 'DELETE_FILE']]
        space_actions = [c for c in changeset if c['type'] not in ['CREATE_FILE', 'UPDATE_FILE', 'DELETE_FILE']]

        if space_actions:
             md_summary.append("\n**Space Actions:**")
             for change in space_actions:
                 if change["type"] == "CREATE_SPACE":
                     md_summary.append(f"- **🚀 Create New Space:** `{change.get('repo_id', '...')}` (SDK: {change.get('sdk', 'gradio')}, Private: {change.get('private', False)})")
                 elif change["type"] == "SET_PRIVACY":
                     md_summary.append(f"- **🔒 Set Privacy:** Set `{change.get('repo_id', '...')}` to `private={change.get('private', False)}`")
                 elif change["type"] == "DELETE_SPACE":
                     md_summary.append(f"- **💥 DELETE ENTIRE SPACE:** `{change.get('owner', '...')}/{change.get('space_name', '...')}` **(DESTRUCTIVE ACTION)**")
             md_summary.append("")

        if file_changes:
             md_summary.append("**File Changes:**")
             for change in file_changes:
                 if change["type"] == "CREATE_FILE":
                     md_summary.append(f"- **➕ Create File:** `{change['path']}`")
                 elif change["type"] == "UPDATE_FILE":
                     md_summary.append(f"- **🔄 Update File:** `{change['path']}`")
                 elif change["type"] == "DELETE_FILE":
                     md_summary.append(f"- **➖ Delete File:** `{change['path']}`")

    return changeset, "\n".join(md_summary)


def handle_chat_submit(user_message, chat_history, hf_api_key_input, provider_api_key_input, provider_select, model_select, system_prompt, hf_owner_name, hf_repo_name):
    global parsed_code_blocks_state_cache
    _chat_msg_in, _chat_hist = "", list(chat_history)
    _status = "Initializing..."

    yield (
        _chat_msg_in, _chat_hist, _status,
        gr.update(), gr.update(), gr.update(interactive=False), gr.update(value="*No changes proposed.*"),
        [], gr.update(visible=False), gr.update(visible=False), gr.update(visible=False)
    )

    if not user_message.strip():
        _status = "Cannot send an empty message."
        yield (
            _chat_msg_in, _chat_hist, _status,
            gr.update(), gr.update(), gr.update(), gr.update(),
            [], gr.update(visible=False), gr.update(visible=False), gr.update(visible=False)
        )
        return

    _chat_hist.append((user_message, None))
    _status = f"Sending to {model_select}..."
    yield (
        _chat_msg_in, _chat_hist, _status,
        gr.update(), gr.update(), gr.update(), gr.update(),
        [], gr.update(visible=False), gr.update(visible=False), gr.update(visible=False)
    )

    current_sys_prompt = system_prompt.strip() or DEFAULT_SYSTEM_PROMPT
    space_id_for_context = f"{hf_owner_name}/{hf_repo_name}" if hf_owner_name and hf_repo_name else "your-space"
    export_result = _export_selected_logic(None, space_id_for_context, parsed_code_blocks_state_cache)
    current_files_context_md = export_result['output_str'] or "*No files currently loaded or defined.*"
    current_files_context = f"\n\n## Current Space Context: {space_id_for_context}\n{current_files_context_md}"

    user_message_with_context = user_message.strip() + current_files_context
    api_msgs = _convert_gr_history_to_api_messages(current_sys_prompt, _chat_hist[:-1], user_message_with_context)

    full_bot_response_content = ""
    try:
        streamer = generate_stream(provider_select, model_select, provider_api_key_input, api_msgs)
        for chunk in streamer:
            if chunk is None: continue
            full_bot_response_content += str(chunk)
            _chat_hist[-1] = (user_message, full_bot_response_content)
            _status = f"Streaming from {model_select}..."
            yield (
                _chat_msg_in, _chat_hist, _status,
                gr.update(), gr.update(), gr.update(), gr.update(),
                [], gr.update(visible=False), gr.update(visible=False), gr.update(visible=False)
            )

        if full_bot_response_content.startswith("Error:") or full_bot_response_content.startswith("API HTTP Error"):
            _status = full_bot_response_content
            yield (_chat_msg_in, _chat_hist, _status, gr.update(), gr.update(), gr.update(), gr.update(), [], gr.update(visible=False), gr.update(visible=False), gr.update(visible=False))
            return

        _status = "Stream complete. Parsing response and staging changes..."
        yield (_chat_msg_in, _chat_hist, _status, gr.update(), gr.update(), gr.update(), gr.update(), [], gr.update(visible=False), gr.update(visible=False), gr.update(visible=False))

        parsed_code_blocks_state_cache, proposed_filenames_in_turn = _parse_and_update_state_cache(full_bot_response_content, parsed_code_blocks_state_cache)
        _formatted, _detected, _download = _generate_ui_outputs_from_cache(hf_owner_name, hf_repo_name)

        staged_changeset, summary_md = generate_and_stage_changes(full_bot_response_content, parsed_code_blocks_state_cache, hf_owner_name, hf_repo_name)

        if not staged_changeset:
            _status = summary_md
            yield (
                _chat_msg_in, _chat_hist, _status,
                _detected, _formatted, _download,
                [],
                gr.update(value=summary_md),
                gr.update(visible=False), gr.update(visible=False), gr.update(visible=False)
            )
        else:
            _status = "Change plan generated. Please review and confirm below."
            yield (
                _chat_msg_in, _chat_hist, _status,
                _detected, _formatted, _download,
                staged_changeset,
                gr.update(value=summary_md),
                gr.update(visible=True),
                gr.update(visible=True),
                gr.update(visible=True)
            )

    except Exception as e:
        error_msg = f"An unexpected error occurred during chat submission: {e}"
        print(f"Error in handle_chat_submit: {e}")
        import traceback
        traceback.print_exc()
        if _chat_hist:
            if _chat_hist[-1] and _chat_hist[-1][0] == user_message:
                 _chat_hist[-1] = (user_message, (full_bot_response_content + "\n\n" if full_bot_response_content and full_bot_response_content != user_message else "") + error_msg)
            else:
                 _chat_hist.append((user_message, error_msg))

        _formatted, _detected, _download = _generate_ui_outputs_from_cache(hf_owner_name, hf_repo_name)

        yield (
            _chat_msg_in, _chat_hist, error_msg,
            _detected, _formatted, _download,
            [],
            gr.update(value="*Error occurred, changes plan cleared.*"),
            gr.update(visible=False), gr.update(visible=False), gr.update(visible=False)
        )


def handle_confirm_changes(hf_api_key, owner_name, space_name, changeset):
    global parsed_code_blocks_state_cache

    _status = "Applying changes..."
    yield _status, gr.update(visible=False), gr.update(visible=False), gr.update(visible=False), gr.update(value="*Applying changes...*")

    if not changeset:
        return "No changes to apply.", gr.update(visible=False), gr.update(visible=False), gr.update(visible=False), gr.update(value="No changes were staged.")

    status_message = apply_staged_changes(hf_api_key, owner_name, space_name, changeset)

    _status_reload = f"{status_message} | Reloading Space state..."
    yield _status_reload, gr.update(visible=False), gr.update(visible=False), gr.update(visible=False), gr.update(value="*Reloading Space state...*")

    refreshed_file_list = []
    reload_error = None
    repo_id_for_reload = f"{owner_name}/{space_name}" if owner_name and space_name else None

    if repo_id_for_reload:
        sdk, file_list, err_list = get_space_repository_info(hf_api_key, space_name, owner_name)
        if err_list:
            reload_error = f"Error reloading file list after changes: {err_list}"
            parsed_code_blocks_state_cache = []
        else:
            refreshed_file_list = file_list
            loaded_files = []
            for file_path in refreshed_file_list:
                content, err_get = get_space_file_content(hf_api_key, space_name, owner_name, file_path)
                lang = _infer_lang_from_filename(file_path)
                is_binary = lang == "binary" or (err_get is not None)
                code = f"[Error loading content: {err_get}]" if err_get else (content or "")
                loaded_files.append({"filename": file_path, "code": code, "language": lang, "is_binary": is_binary, "is_structure_block": False})
            parsed_code_blocks_state_cache = loaded_files

    else:
        reload_error = "Cannot reload Space state: Owner or Space Name missing."

    _formatted, _detected, _download = _generate_ui_outputs_from_cache(owner_name, space_name)

    final_overall_status = status_message + (f" | Reload Status: {reload_error}" if reload_error else " | Reload Status: Space state refreshed.")

    cleared_changeset = []

    return (
        final_overall_status,
        _formatted,
        _detected,
        _download,
        gr.update(visible=False),
        gr.update(visible=False),
        gr.update(visible=False),
        cleared_changeset,
        gr.update(value="*No changes proposed.*")
    )


def handle_cancel_changes():
    global parsed_code_blocks_state_cache
    return (
        "Changes cancelled.",
        [],
        gr.update(value="*No changes proposed.*"),
        gr.update(visible=False),
        gr.update(visible=False),
        gr.update(visible=False)
    )


def update_models_dropdown(provider_select):
    if not provider_select: return gr.update(choices=[], value=None)
    models = get_models_for_provider(provider_select)
    default_model = get_default_model_for_provider(provider_select)
    selected_value = default_model if default_model in models else (models[0] if models else None)
    return gr.update(choices=models, value=selected_value)

def handle_load_existing_space(hf_api_key_ui, ui_owner_name, ui_space_name):
    global parsed_code_blocks_state_cache
    _formatted_md_val, _detected_preview_val, _status_val = "*Loading files...*", "*Loading files...*", f"Loading Space: {ui_owner_name}/{ui_space_name}..."
    _file_browser_update, _iframe_html_update, _download_btn_update = gr.update(visible=False, choices=[], value=None), gr.update(value=None, visible=False), gr.update(interactive=False, value=None)
    _build_status_clear, _edit_status_clear, _runtime_status_clear = "*Build status...*", "*Select a file...*", "*Runtime status...*"
    _changeset_clear = []
    _changeset_summary_clear = "*No changes proposed.*"
    _confirm_ui_hidden = gr.update(visible=False)

    outputs = [
        _formatted_md_val, _detected_preview_val, _status_val, _file_browser_update,
        gr.update(value=ui_owner_name), gr.update(value=ui_space_name),
        _iframe_html_update, _download_btn_update, _build_status_clear,
        _edit_status_clear, _runtime_status_clear,
        changeset_state, changeset_display, confirm_accordion, confirm_button, cancel_button
    ]
    yield outputs

    owner_to_use = ui_owner_name
    if not owner_to_use:
        token, token_err = build_logic_get_api_token(hf_api_key_ui)
        if token_err:
            _status_val = f"Load Error: {token_err}"
            outputs[2] = _status_val; yield outputs; return
        try:
            user_info = build_logic_whoami(token=token)
            owner_to_use = user_info.get('name')
            if not owner_to_use: raise Exception("Could not find user name from token.")
            outputs[4] = gr.update(value=owner_to_use)
            _status_val += f" (Auto-detected owner: {owner_to_use})"
        except Exception as e:
            _status_val = f"Load Error: Error auto-detecting owner: {e}"; outputs[2] = _status_val; yield outputs; return

    if not owner_to_use or not ui_space_name:
        _status_val = "Load Error: Owner and Space Name are required."; outputs[2] = _status_val; yield outputs; return

    sdk, file_list, err = get_space_repository_info(hf_api_key_ui, ui_space_name, owner_to_use)

    outputs[4] = gr.update(value=owner_to_use)
    outputs[5] = gr.update(value=ui_space_name)

    if err:
        _status_val = f"Load Error: {err}"
        parsed_code_blocks_state_cache = []
        _formatted, _detected, _download = _generate_ui_outputs_from_cache(owner_to_use, ui_space_name)
        outputs[0], outputs[1], outputs[2], outputs[7] = _formatted, _detected, _status_val, _download
        outputs[3] = gr.update(visible=False, choices=[], value=None)
        outputs[6] = gr.update(value=None, visible=False)
        yield outputs; return

    loaded_files = []
    for file_path in file_list:
        content, err_get = get_space_file_content(hf_api_key_ui, ui_space_name, owner_to_use, file_path)
        lang = _infer_lang_from_filename(file_path)
        is_binary = lang == "binary" or (err_get is not None)
        code = f"[Error loading content: {err_get}]" if err_get else (content or "")
        loaded_files.append({"filename": file_path, "code": code, "language": lang, "is_binary": is_binary, "is_structure_block": False})

    parsed_code_blocks_state_cache = loaded_files

    _formatted, _detected, _download = _generate_ui_outputs_from_cache(owner_to_use, ui_space_name)
    _status_val = f"Successfully loaded {len(file_list)} files from {owner_to_use}/{ui_space_name}. SDK: {sdk or 'unknown'}."
    outputs[0], outputs[1], outputs[2], outputs[7] = _formatted, _detected, _status_val, _download

    outputs[3] = gr.update(visible=True, choices=sorted(file_list or []), value=None)

    if owner_to_use and ui_space_name:
        sub_owner = re.sub(r'[^a-z0-9\-]+', '-', owner_to_use.lower()).strip('-') or 'owner'
        sub_repo = re.sub(r'[^a-z0-9\-]+', '-', ui_space_name.lower()).strip('-') or 'space'
        iframe_url = f"https://{sub_owner}-{sub_repo}{'.static.hf.space' if sdk == 'static' else '.hf.space'}"
        outputs[6] = gr.update(value=f'<iframe src="{iframe_url}?__theme=light&embed=true" width="100%" height="500px"></iframe>', visible=True)
    else:
         outputs[6] = gr.update(value=None, visible=False)

    yield outputs

def handle_build_space_button(hf_api_key_ui, ui_space_name_part, ui_owner_name_part, space_sdk_ui, is_private_ui, formatted_markdown_content):
    global parsed_code_blocks_state_cache
    _build_status = "Starting manual space build process..."
    _iframe_html, _file_browser_update = gr.update(value=None, visible=False), gr.update(visible=False, choices=[], value=None)
    _changeset_clear = []
    _changeset_summary_clear = "*Manual build initiated, changes plan cleared.*"
    _confirm_ui_hidden = gr.update(visible=False)

    yield (_build_status, _iframe_html, _file_browser_update, gr.update(value=ui_owner_name_part), gr.update(value=ui_space_name_part),
           _changeset_clear, _changeset_summary_clear, _confirm_ui_hidden, _confirm_ui_hidden, _confirm_ui_hidden,
           gr.update(), gr.update(), gr.update())


    if not ui_space_name_part or "/" in ui_space_name_part:
        _build_status = f"Build Error: Invalid Space Name '{ui_space_name_part}'."
        yield (_build_status, _iframe_html, _file_browser_update, gr.update(), gr.update(),
               gr.update(), gr.update(), gr.update(), gr.update(), gr.update(),
               gr.update(), gr.update(), gr.update()); return

    parsed_content = build_logic_parse_markdown(formatted_markdown_content)
    proposed_files_list = parsed_content.get("files", [])

    manual_changeset = []
    if ui_owner_name_part and ui_space_name_part:
         manual_changeset.append({"type": "CREATE_SPACE", "repo_id": f"{ui_owner_name_part}/{ui_space_name_part}", "sdk": space_sdk_ui, "private": is_private_ui})
         for file_info in proposed_files_list:
              manual_changeset.append({"type": "CREATE_FILE", "path": file_info["path"], "content": file_info["content"], "lang": _infer_lang_from_filename(file_info["path"])})

    if not manual_changeset:
         _build_status = "Build Error: No target space specified or no files parsed from markdown."
         yield (_build_status, _iframe_html, _file_browser_update, gr.update(), gr.update(),
                gr.update(), gr.update(), gr.update(), gr.update(), gr.update(),
                gr.update(), gr.update(), gr.update()); return


    result_message = apply_staged_changes(hf_api_key_ui, ui_owner_name_part, ui_space_name_part, manual_changeset)
    _build_status = f"Manual Build/Update Result: {result_message}"

    owner_to_use = ui_owner_name_part
    space_to_use = ui_space_name_part
    _formatted_md, _detected_preview, _download = formatted_markdown_content, "*Loading files after build...*", gr.update(interactive=False, value=None)

    yield (_build_status, _iframe_html, _file_browser_update, gr.update(value=owner_to_use), gr.update(value=space_to_use),
           _changeset_clear, _changeset_summary_clear, _confirm_ui_hidden, _confirm_ui_hidden, _confirm_ui_hidden,
           _formatted_md, _detected_preview, _download)

    sdk_built, file_list, err_list = get_space_repository_info(hf_api_key_ui, space_to_use, owner_to_use)

    if err_list:
        _build_status += f" | Error reloading file list after build: {err_list}"
        parsed_code_blocks_state_cache = []
        _file_browser_update = gr.update(visible=False, choices=[], value=None)
        _iframe_html = gr.update(value=None, visible=False)
    else:
        loaded_files = []
        for file_path in file_list:
             content, err_get = get_space_file_content(hf_api_key_ui, space_to_use, owner_to_use, file_path)
             lang = _infer_lang_from_filename(file_path)
             is_binary = lang == "binary" or (err_get is not None)
             code = f"[Error loading content: {err_get}]" if err_get else (content or "")
             loaded_files.append({"filename": file_path, "code": code, "language": lang, "is_binary": is_binary, "is_structure_block": False})
        parsed_code_blocks_state_cache = loaded_files

        _file_browser_update = gr.update(visible=True, choices=sorted(file_list or []), value=None)

        if owner_to_use and space_to_use:
            sub_owner = re.sub(r'[^a-z0-9\-]+', '-', owner_to_use.lower()).strip('-') or 'owner'
            sub_repo = re.sub(r'[^a-z0-9\-]+', '-', ui_space_name_part.lower()).strip('-') or 'space'
            iframe_url = f"https://{sub_owner}-{sub_repo}{'.static.hf.space' if sdk_built == 'static' else '.hf.space'}"
            _iframe_html = gr.update(value=f'<iframe src="{iframe_url}?__theme=light&embed=true" width="100%" height="700px"></iframe>', visible=True)
        else:
             _iframe_html = gr.update(value=None, visible=False)

    _formatted_md, _detected_preview, _download = _generate_ui_outputs_from_cache(owner_to_use, space_to_use)

    yield (_build_status, _iframe_html, _file_browser_update, gr.update(value=owner_to_use), gr.update(value=space_to_use),
           _changeset_clear, _changeset_summary_clear, _confirm_ui_hidden, _confirm_ui_hidden, _confirm_ui_hidden,
           _formatted_md, _detected_preview, _download
           )


def handle_load_file_for_editing(hf_api_key_ui, ui_space_name_part, ui_owner_name_part, selected_file_path):
    if not selected_file_path:
        return "", "Select a file.", "", gr.update(language="plaintext")

    content, err = get_space_file_content(hf_api_key_ui, ui_space_name_part, ui_owner_name_part, selected_file_path)
    if err:
        return "", f"Load Error: {err}", "", gr.update(language="plaintext")

    lang = _infer_lang_from_filename(selected_file_path)
    commit_msg = f"Update {selected_file_path}"
    return content, f"Loaded `{selected_file_path}`", commit_msg, gr.update(language=lang)

def handle_commit_file_changes(hf_api_key_ui, ui_space_name_part, ui_owner_name_part, file_to_edit_path, edited_content, commit_message):
    if not file_to_edit_path:
         return "Commit Error: No file selected for commit.", gr.update(), gr.update(), gr.update(), gr.update()

    status_msg = update_space_file(hf_api_key_ui, ui_space_name_part, ui_owner_name_part, file_to_edit_path, edited_content, commit_message)

    global parsed_code_blocks_state_cache
    if "Successfully" in status_msg:
        found = False
        for block in parsed_code_blocks_state_cache:
            if block["filename"] == file_to_edit_path and not block.get("is_structure_block"):
                block["code"] = edited_content
                block["language"] = _infer_lang_from_filename(file_to_edit_path)
                block["is_binary"] = False
                found = True
                break
        if not found:
             parsed_code_blocks_state_cache.append({
                 "filename": file_to_edit_path,
                 "code": edited_content,
                 "language": _infer_lang_from_filename(file_to_edit_path),
                 "is_binary": False,
                 "is_structure_block": False
             })
             parsed_code_blocks_state_cache.sort(key=lambda b: (0, b["filename"]) if b.get("is_structure_block") else (1, b["filename"]))

        file_list, _ = list_space_files_for_browsing(hf_api_key_ui, ui_space_name_part, ui_owner_name_part)
        file_browser_update = gr.update(choices=sorted(file_list or []))

    else:
         file_browser_update = gr.update()


    _formatted, _detected, _download = _generate_ui_outputs_from_cache(ui_owner_name_part, ui_space_name_part)
    return status_msg, file_browser_update, _formatted, _detected, _download

def handle_delete_file(hf_api_key_ui, ui_space_name_part, ui_owner_name_part, file_to_delete_path):
    if not file_to_delete_path:
        return "Delete Error: No file selected to delete.", gr.update(), "", "", "plaintext", gr.update(), gr.update(), gr.update()

    status_msg = build_logic_delete_space_file(hf_api_key_ui, ui_space_name_part, ui_owner_name_part, file_to_delete_path)

    global parsed_code_blocks_state_cache
    file_browser_update = gr.update()
    file_content_editor_update = gr.update()
    commit_message_update = gr.update()
    editor_lang_update = gr.update()

    if "Successfully" in status_msg:
        parsed_code_blocks_state_cache = [b for b in parsed_code_blocks_state_cache if b["filename"] != file_to_delete_path]
        file_content_editor_update = gr.update(value="")
        commit_message_update = gr.update(value="")
        editor_lang_update = gr.update(language="plaintext")
        file_list, _ = list_space_files_for_browsing(hf_api_key_ui, ui_space_name_part, ui_owner_name_part)
        file_browser_update = gr.update(choices=sorted(file_list or []), value=None)

    _formatted, _detected, _download = _generate_ui_outputs_from_cache(ui_owner_name_part, ui_space_name_part)
    return (
        status_msg,
        file_browser_update,
        file_content_editor_update,
        commit_message_update,
        editor_lang_update,
        _formatted,
        _detected,
        _download
    )

def handle_refresh_space_status(hf_api_key_ui, ui_owner_name, ui_space_name):
    if not ui_owner_name or not ui_space_name:
        return "**Status Error:** Owner and Space Name must be provided to get status."

    status_details, err = get_space_runtime_status(hf_api_key_ui, ui_space_name, ui_owner_name)
    if err: return f"**Status Error:** {err}"
    if not status_details: return "*Could not retrieve status details.*"

    md = f"### Status for {ui_owner_name}/{ui_space_name}\n"
    md += f"- **Stage:** `{status_details.get('stage', 'N/A')}`\n"
    md += f"- **Status:** `{status_details.get('status', 'N/A')}`\n"
    md += f"- **Hardware:** `{status_details.get('hardware', 'N/A')}`\n"
    requested_hw = status_details.get('requested_hardware')
    if requested_hw: md += f"- **Requested Hardware:** `{requested_hw}`\n"
    error_msg = status_details.get('error_message')
    if error_msg: md += f"- **Error:** `{escape_html_for_markdown(error_msg)}`\n"
    log_link = status_details.get('full_log_link')
    if log_link and log_link != "#": md += f"- [View Full Logs]({log_link})\n"

    return md


custom_theme = gr.themes.Base(primary_hue="teal", secondary_hue="purple", neutral_hue="zinc", text_size="sm", spacing_size="md", radius_size="sm", font=["System UI", "sans-serif"])
custom_css = """
body { background: linear-gradient(to bottom right, #2c3e50, #34495e); color: #ecf0f1; }
.gradio-container { background: transparent !important; }
.gr-box, .gr-panel, .gr-pill { background-color: rgba(44, 62, 80, 0.8) !important; border-color: rgba(189, 195, 199, 0.2) !important; }
.gr-textbox, .gr-dropdown, .gr-button, .gr-code, .gr-chat-message { border-color: rgba(189, 195, 199, 0.3) !important; background-color: rgba(52, 73, 94, 0.9) !important; color: #ecf0f1 !important; }
.gr-button.gr-button-primary { background-color: #1abc9c !important; color: white !important; border-color: #16a085 !important; }
.gr-button.gr-button-secondary { background-color: #9b59b6 !important; color: white !important; border-color: #8e44ad !important; }
.gr-button.gr-button-stop { background-color: #e74c3c !important; color: white !important; border-color: #c0392b !important; }
.gr-markdown { background-color: rgba(44, 62, 80, 0.7) !important; padding: 10px; border-radius: 5px; overflow-x: auto; }
.gr-markdown h1, .gr-markdown h2, .gr-markdown h3, .gr-markdown h4, .gr-markdown h5, .gr-markdown h6 { color: #ecf0f1 !important; border-bottom-color: rgba(189, 195, 199, 0.3) !important; }
.gr-markdown pre code { background-color: rgba(52, 73, 94, 0.95) !important; border-color: rgba(189, 195, 199, 0.3) !important; }
.gr-chatbot { background-color: rgba(44, 62, 80, 0.7) !important; border-color: rgba(189, 195, 199, 0.2) !important; }
.gr-chatbot .message { background-color: rgba(52, 73, 94, 0.9) !important; color: #ecf0f1 !important; border-color: rgba(189, 195, 199, 0.3) !important; }
.gr-chatbot .message.user { background-color: rgba(46, 204, 113, 0.9) !important; color: black !important; }
.gradio-container .gr-accordion { border-color: rgba(189, 195, 199, 0.3) !important; }
.gradio-container .gr-accordion.closed { background-color: rgba(52, 73, 94, 0.9) !important; }
.gradio-container .gr-accordion.open { background-color: rgba(44, 62, 80, 0.8) !important; }

"""

with gr.Blocks(theme=custom_theme, css=custom_css) as demo:
    changeset_state = gr.State([])

    gr.Markdown("# 🤖 AI-Powered Hugging Face Space Commander")
    gr.Markdown("Use an AI assistant to create, modify, build, and manage your Hugging Face Spaces directly from this interface.")
    gr.Markdown("## ❗ This will cause changes to your huggingface spaces if you give it your Huggingface Key")
    gr.Markdown("⚒ Under Development - Use with Caution")


    with gr.Sidebar():
        with gr.Column(scale=1):
            with gr.Accordion("⚙️ Configuration", open=True):
                hf_api_key_input = gr.Textbox(label="Hugging Face Token", type="password", placeholder="hf_... (uses env var HF_TOKEN if empty)")
                owner_name_input = gr.Textbox(label="HF Owner Name", placeholder="e.g., your-username")
                space_name_input = gr.Textbox(label="HF Space Name", value="")
                load_space_button = gr.Button("🔄 Load Existing Space", variant="secondary")

            with gr.Accordion("🤖 AI Model Settings", open=True):
                available_providers = get_available_providers()
                default_provider = 'Groq'
                if default_provider not in available_providers:
                    default_provider = available_providers[0] if available_providers else None
                elif len(available_providers) < 3:
                     default_provider = available_providers[0] if available_providers else None

                initial_models = get_models_for_provider(default_provider) if default_provider else []
                initial_model = get_default_model_for_provider(default_provider) if default_provider else None
                if initial_model not in initial_models:
                    initial_model = initial_models[0] if initial_models else None

                provider_select = gr.Dropdown(
                    label="AI Provider",
                    choices=available_providers,
                    value=default_provider,
                    allow_custom_value=False
                )
                model_select = gr.Dropdown(
                    label="AI Model",
                    choices=initial_models,
                    value=initial_model,
                    allow_custom_value=False
                )
                provider_api_key_input = gr.Textbox(label="Model Provider API Key (Optional)", type="password", placeholder="sk_... (overrides backend settings)")
                system_prompt_input = gr.Textbox(label="System Prompt", lines=10, value=DEFAULT_SYSTEM_PROMPT, elem_id="system-prompt")

    with gr.Column(scale=2):
        gr.Markdown("## 💬 AI Assistant Chat")
        chatbot_display = gr.Chatbot(label="AI Chat", height=500, bubble_full_width=False, avatar_images=(None))
        with gr.Row():
            chat_message_input = gr.Textbox(show_label=False, placeholder="Your Message...", scale=7)
            send_chat_button = gr.Button("Send", variant="primary", scale=1)
        status_output = gr.Textbox(label="Last Action Status", interactive=False, value="Ready.")

    with gr.Accordion("📝 Proposed Changes (Pending Confirmation)", open=False, visible=False) as confirm_accordion:
        changeset_display = gr.Markdown("*No changes proposed.*")
        with gr.Row():
            confirm_button = gr.Button("✅ Confirm & Apply Changes", variant="primary", visible=False)
            cancel_button = gr.Button("❌ Cancel", variant="stop", visible=False)

    with gr.Tabs():
        with gr.TabItem("📝 Generated Markdown & Build"):
            with gr.Row():
                with gr.Column(scale=2):
                    formatted_space_output_display = gr.Textbox(label="Current Space Definition (Generated Markdown)", lines=20, interactive=True, value="*Load or create a space to see its definition.*")
                    download_button = gr.DownloadButton(label="Download .md", interactive=False)
                with gr.Column(scale=1):
                    gr.Markdown("### Manual Build & Status")
                    space_sdk_select = gr.Dropdown(label="Space SDK", choices=["gradio", "streamlit", "docker", "static"], value="gradio", interactive=True)
                    space_private_checkbox = gr.Checkbox(label="Make Space Private", value=False, interactive=True)
                    build_space_button = gr.Button("🚀 Build / Update Space from Markdown", variant="primary")
                    build_status_display = gr.Textbox(label="Manual Build/Update Status", interactive=False, value="*Manual build status...*")
                    gr.Markdown("---")
                    refresh_status_button = gr.Button("🔄 Refresh Runtime Status")
                    space_runtime_status_display = gr.Markdown("*Runtime status will appear here.*")

        with gr.TabItem("🔍 Files Preview"):
            detected_files_preview = gr.Markdown(value="*A preview of the latest file versions will appear here.*")

        with gr.TabItem("✏️ Live File Editor & Preview"):
             with gr.Row():
                with gr.Column(scale=1):
                    gr.Markdown("### Live Editor")
                    file_browser_dropdown = gr.Dropdown(label="Select File in Space", choices=[], interactive=True)
                    file_content_editor = gr.Code(label="File Content Editor", language="python", lines=15, interactive=True, value="")
                    commit_message_input = gr.Textbox(label="Commit Message", placeholder="e.g., Updated app.py", interactive=True, value="")
                    with gr.Row():
                        update_file_button = gr.Button("Commit Changes", variant="primary", interactive=True)
                        delete_file_button = gr.Button("🗑️ Delete Selected File", variant="stop", interactive=True)
                    edit_status_display = gr.Textbox(label="File Edit/Delete Status", interactive=False, value="")
                with gr.Column(scale=1):
                    gr.Markdown("### Live Space Preview")
                    space_iframe_display = gr.HTML(value="", visible=True)

    provider_select.change(update_models_dropdown, inputs=provider_select, outputs=model_select)

    chat_inputs = [
        chat_message_input, chatbot_display, hf_api_key_input,
        provider_api_key_input, provider_select, model_select, system_prompt_input,
        owner_name_input, space_name_input
    ]
    chat_outputs = [
        chat_message_input, chatbot_display, status_output,
        detected_files_preview, formatted_space_output_display, download_button,
        changeset_state, changeset_display, confirm_accordion, confirm_button, cancel_button
    ]
    send_chat_button.click(handle_chat_submit, inputs=chat_inputs, outputs=chat_outputs)
    chat_message_input.submit(handle_chat_submit, inputs=chat_inputs, outputs=chat_outputs)

    confirm_inputs = [hf_api_key_input, owner_name_input, space_name_input, changeset_state]
    confirm_outputs = [
        status_output, formatted_space_output_display, detected_files_preview, download_button,
        confirm_accordion, confirm_button, cancel_button, changeset_state, changeset_display
    ]
    confirm_button.click(handle_confirm_changes, inputs=confirm_inputs, outputs=confirm_outputs)

    cancel_outputs = [
        status_output, changeset_state, changeset_display,
        confirm_accordion, confirm_button, cancel_button
    ]
    cancel_button.click(handle_cancel_changes, inputs=None, outputs=cancel_outputs)

    load_space_outputs = [
        formatted_space_output_display, detected_files_preview, status_output,
        file_browser_dropdown, owner_name_input, space_name_input,
        space_iframe_display, download_button, build_status_display,
        edit_status_display, space_runtime_status_display,
        changeset_state, changeset_display, confirm_accordion, confirm_button, cancel_button
    ]
    load_space_button.click(
        fn=handle_load_existing_space,
        inputs=[hf_api_key_input, owner_name_input, space_name_input],
        outputs=load_space_outputs
    )

    build_outputs = [
        build_status_display, space_iframe_display, file_browser_dropdown,
        owner_name_input, space_name_input,
        changeset_state, changeset_display, confirm_accordion, confirm_button, cancel_button,
        formatted_space_output_display, detected_files_preview, download_button
    ]
    build_inputs = [
        hf_api_key_input, space_name_input, owner_name_input, space_sdk_select,
        space_private_checkbox, formatted_space_output_display
    ]
    build_space_button.click(fn=handle_build_space_button, inputs=build_inputs, outputs=build_outputs)

    file_edit_load_outputs = [file_content_editor, edit_status_display, commit_message_input, file_content_editor]
    file_browser_dropdown.change(fn=handle_load_file_for_editing, inputs=[hf_api_key_input, space_name_input, owner_name_input, file_browser_dropdown], outputs=file_edit_load_outputs)

    commit_file_outputs = [edit_status_display, file_browser_dropdown, formatted_space_output_display, detected_files_preview, download_button]
    update_file_button.click(fn=handle_commit_file_changes, inputs=[hf_api_key_input, space_name_input, owner_name_input, file_browser_dropdown, file_content_editor, commit_message_input], outputs=commit_file_outputs)

    delete_file_outputs = [
        edit_status_display, file_browser_dropdown,
        file_content_editor, commit_message_input, file_content_editor,
        formatted_space_output_display, detected_files_preview, download_button
    ]
    delete_file_button.click(fn=handle_delete_file, inputs=[hf_api_key_input, space_name_input, owner_name_input, file_browser_dropdown], outputs=delete_file_outputs)

    refresh_status_button.click(fn=handle_refresh_space_status, inputs=[hf_api_key_input, owner_name_input, space_name_input], outputs=[space_runtime_status_display])

if __name__ == "__main__":
    demo.launch(debug=False, mcp_server=True)