Update build_logic.py

build_logic.py

@@ -67,54 +67,99 @@ def parse_markdown(markdown_input):
     in_code_block = False
 
     lines = markdown_input.strip().split("\n")
-    if any(("# # Space:" in line.strip() or "# Space:" in line.strip()) for line in lines):
-        cleaned_lines_temp = []
-        for line_idx, line in enumerate(lines):
-            if line.startswith("# ") and (
-                "# Space:" in line or "### File:" in line or "## File Structure" in line or
-                (line_idx > 0 and "### File:" in lines[line_idx-1])
-            ):
-                cleaned_lines_temp.append(line[2:])
-            else:
-                cleaned_lines_temp.append(line)
-        lines = cleaned_lines_temp
+
+    # Clean up potential leading '#' added by Gradio's Markdown sometimes
+    cleaned_lines = []
+    for line_content_orig in lines:
+         if line_content_orig.strip().startswith("# "):
+             # Only strip leading # if it looks like a Markdown heading related to our format
+             if line_content_orig.strip().startswith("# ### File:") or \
+                line_content_orig.strip().startswith("# ## File Structure") or \
+                line_content_orig.strip().startswith("# # Space:"):
+                 cleaned_lines.append(line_content_orig.strip()[2:])
+             else:
+                 cleaned_lines.append(line_content_orig)
+         else:
+              cleaned_lines.append(line_content_orig)
+
+    lines = cleaned_lines
+
 
     for line_content_orig in lines:
         line_content_stripped = line_content_orig.strip()
 
         if line_content_stripped.startswith("### File:"):
-            if current_file_path and in_file_definition:
+            # Before processing a new file, save the content of the previous one
+            if current_file_path is not None and in_file_definition: # Check if we were inside a file definition
                 space_info["files"].append({"path": current_file_path, "content": "\n".join(current_file_content_lines).strip()})
+
             current_file_path = line_content_stripped.replace("### File:", "").strip()
+            # Clean up potential trailing descriptions like "(main application)"
             current_file_path = re.split(r'\s*\(', current_file_path, 1)[0].strip()
+            # Clean up potential backticks around the filename
+            current_file_path = current_file_path.strip('`')
+
+
             current_file_content_lines = []
             in_file_definition = True
-            in_code_block = False
+            in_code_block = False # Reset code block flag for the new file
             continue
 
+        # If we are not currently inside a file definition block (i.e., before the first "### File:")
         if not in_file_definition:
             if line_content_stripped.startswith("# Space:"):
                 full_space_name_md = line_content_stripped.replace("# Space:", "").strip()
                 if "/" in full_space_name_md:
-                    space_info["owner_md"], space_info["repo_name_md"] = full_space_name_md.split("/", 1)
+                    parts = full_space_name_md.split("/", 1)
+                    if len(parts) == 2:
+                         space_info["owner_md"], space_info["repo_name_md"] = parts[0].strip(), parts[1].strip()
+                    else:
+                         space_info["repo_name_md"] = full_space_name_md # Handle case like "user/repo/"
                 else:
                     space_info["repo_name_md"] = full_space_name_md
+            # Ignore other lines outside a file block for now (like "## File Structure" preamble)
             continue
 
+        # If we are inside a file definition block
         if in_file_definition:
             if line_content_stripped.startswith("```"):
+                # Toggle code block status
                 in_code_block = not in_code_block
-                continue
+                # If exiting a code block, the next lines are not part of the code
+                if not in_code_block:
+                     # We consume the ``` line itself, don't add it to content
+                     pass
+                else:
+                     # If entering a code block, we consume the ```lang line itself
+                     pass
+                continue # Do not add the ``` line to content
 
+            # If inside a code block, add the line as-is (original content, including leading/trailing whitespace)
             if in_code_block:
                 current_file_content_lines.append(line_content_orig)
-            elif not in_code_block and line_content_stripped.startswith("[Binary file"):
+            # If not inside a code block, check for binary file marker
+            elif line_content_stripped.startswith("[Binary file") or line_content_stripped.startswith("[Error loading content:") or line_content_stripped.startswith("[Binary or Skipped file]"):
+                 # Handle binary file markers or error messages as content if not in code block
                  current_file_content_lines.append(line_content_orig)
+            # Any other lines outside code blocks within a file definition are ignored (e.g., descriptions, blank lines)
+            # This assumes all code/content *must* be within ``` blocks or be a specific marker line.
 
-    if current_file_path and in_file_definition:
+
+    # After the loop, save the content of the last file
+    if current_file_path is not None and in_file_definition:
         space_info["files"].append({"path": current_file_path, "content": "\n".join(current_file_content_lines).strip()})
 
-    space_info["files"] = [f for f in space_info["files"] if f.get("path")]
+    # Ensure all file paths are valid and clean up empty files if necessary (based on content parsing)
+    # The parsing logic above should handle stripping content, but this is a final check
+    space_info["files"] = [f for f in space_info["files"] if f.get("path")] # Ensure path exists
+    # Optional: Filter out files where content became empty after strip() if that's desired behavior.
+    # Currently, it keeps files with empty content, which is fine for creating empty files.
+
+    # Clean up owner/repo names from potential whitespace
+    space_info["owner_md"] = space_info["owner_md"].strip()
+    space_info["repo_name_md"] = space_info["repo_name_md"].strip()
+
+
     return space_info
 
 
@@ -124,6 +169,7 @@ def get_space_repository_info(ui_api_token_from_textbox, space_name_ui, owner_ui
     sdk = None
     files = []
     error = None
+    repo_id = None # Define repo_id here to ensure it's available for error logging after _determine_repo_id
 
     try:
         resolved_api_token, token_err = _get_api_token(ui_api_token_from_textbox)
@@ -131,51 +177,66 @@ def get_space_repository_info(ui_api_token_from_textbox, space_name_ui, owner_ui
 
         repo_id, err_repo_id = _determine_repo_id(ui_api_token_from_textbox, space_name_ui, owner_ui)
         if err_repo_id: return None, None, err_repo_id
-        repo_id_for_error_logging = repo_id
+        repo_id_for_error_logging = repo_id # Update logging name
 
         api = HfApi(token=resolved_api_token)
-        repo_info_obj = api.repo_info(repo_id=repo_id, repo_type="space")
+        # Use repo_info endpoint as it's more robust and gives SDK
+        repo_info_obj = api.repo_info(repo_id=repo_id, repo_type="space", timeout=10) # Added timeout
         sdk = repo_info_obj.sdk
         files = [sibling.rfilename for sibling in repo_info_obj.siblings if sibling.rfilename]
+
         if not files and repo_info_obj.siblings:
             logger.warning(f"Repo {repo_id} has siblings but no rfilenames extracted.")
+
     except HfHubHTTPError as e_http: # Catch specific HF HTTP errors first
-        logger.error(f"HTTP error getting repo info for {repo_id_for_error_logging}: {e_http}")
+        logger.error(f"HTTP error getting repo info for {repo_id_for_error_logging or 'unknown repo'}: {e_http}")
         error_message = str(e_http)
-        if e_http.response is not None: # Check if response object exists
-            if e_http.response.status_code == 404:
-                error = f"Space '{repo_id_for_error_logging}' not found (404)."
-            elif e_http.response.status_code in (401,403):
-                error = f"Access denied for '{repo_id_for_error_logging}' (401/403). Check token permissions."
-            else:
-                error = f"HTTP Error {e_http.response.status_code} for '{repo_id_for_error_logging}': {error_message}"
-        else: # No response object, use generic message
-            error = f"Network or HTTP Error for '{repo_id_for_error_logging}': {error_message}"
+        status_code = e_http.response.status_code if e_http.response is not None else None
+
+        if status_code == 404:
+            error = f"Space '{repo_id_for_error_logging or 'unknown repo'}' not found (404)."
+        elif status_code in (401,403):
+            error = f"Access denied for '{repo_id_for_error_logging or 'unknown repo'}' ({status_code}). Check token permissions."
+        else:
+            error = f"HTTP Error {status_code or 'unknown'} for '{repo_id_for_error_logging or 'unknown repo'}': {error_message}"
+
     except Exception as e: # Catch other general exceptions
-        logger.warning(f"Could not get full repo_info for {repo_id_for_error_logging}, falling back to list_repo_files: {e}")
+        # If repo_info failed, try listing files as a fallback
+        logger.warning(f"Could not get full repo_info for {repo_id_for_error_logging or 'unknown repo'}, attempting list_repo_files fallback: {e}")
+        error = f"Error retrieving Space info for `{repo_id_for_error_logging or 'unknown repo'}`: {str(e)}. Attempting file list fallback." # Set a warning message
+
         try:
+            # Re-determine repo_id and get token for fallback
             resolved_api_token_fb, token_err_fb = _get_api_token(ui_api_token_from_textbox)
-            if token_err_fb: return None, None, token_err_fb # Propagate error
+            if token_err_fb: return None, None, f"{error}\nAPI Token Error during fallback: {token_err_fb}" # Propagate token error
             repo_id_fb, err_repo_id_fb = _determine_repo_id(ui_api_token_from_textbox, space_name_ui, owner_ui)
-            if err_repo_id_fb: return None, None, err_repo_id_fb # Propagate error
-            files = list_repo_files(repo_id=repo_id_fb, token=resolved_api_token_fb, repo_type="space")
+            if err_repo_id_fb: return None, None, f"{error}\nRepo ID Error during fallback: {err_repo_id_fb}" # Propagate repo ID error
+
+            # Attempt to list files
+            files = list_repo_files(repo_id=repo_id_fb, token=resolved_api_token_fb, repo_type="space", timeout=10) # Added timeout
+            # If fallback is successful, update error message to a warning about repo_info
+            error = f"Warning: Could not fetch full Space info (SDK etc.) for `{repo_id_for_error_logging or 'unknown repo'}`: {str(e)}. File list loaded via fallback."
+
         except HfHubHTTPError as e2_http:
-            logger.error(f"HTTP error during fallback list_repo_files for {repo_id_for_error_logging}: {e2_http}")
+            logger.error(f"HTTP error during fallback list_repo_files for {repo_id_for_error_logging or 'unknown repo'}: {e2_http}")
             error_message_fb = str(e2_http)
-            if e2_http.response is not None:
-                 if e2_http.response.status_code == 404:
-                    error = f"Space '{repo_id_for_error_logging}' not found during fallback (404)."
-                 else:
-                    error = f"HTTP Error {e2_http.response.status_code} for '{repo_id_for_error_logging}' during fallback: {error_message_fb}"
+            status_code_fb = e2_http.response.status_code if e2_http.response is not None else None
+            if status_code_fb == 404:
+                error = f"Space '{repo_id_for_error_logging or 'unknown repo'}' not found during fallback (404)."
             else:
-                 error = f"Network or HTTP Error for '{repo_id_for_error_logging}' during fallback: {error_message_fb}"
+                error = f"HTTP Error {status_code_fb or 'unknown'} for '{repo_id_for_error_logging or 'unknown repo'}' during fallback: {error_message_fb}"
+            files = [] # Ensure files list is empty on fallback error
+
         except Exception as e2:
-            logger.exception(f"Error listing files for {repo_id_for_error_logging} during fallback: {e2}")
-            error = f"Error listing files for `{repo_id_for_error_logging}`: {str(e2)}"
+            logger.exception(f"Error listing files for {repo_id_for_error_logging or 'unknown repo'} during fallback: {e2}")
+            error = f"{error}\nError listing files during fallback for `{repo_id_for_error_logging or 'unknown repo'}`: {str(e2)}"
+            files = [] # Ensure files list is empty on fallback error
 
 
+    # Final check: if files are still empty and there's no specific error, provide a generic "no files" message
     if not files and not error:
-        error = f"No files found in Space `{repo_id_for_error_logging}` (or an issue fetching them)."
+         error = f"No files found in Space `{repo_id_for_error_logging or 'unknown repo'}` (or an issue fetching them)."
+
     return sdk, files, error
 
 
@@ -188,6 +249,7 @@ def list_space_files_for_browsing(ui_api_token_from_textbox, space_name_ui, owne
 # --- Function to Fetch File Content from Hub ---
 def get_space_file_content(ui_api_token_from_textbox, space_name_ui, owner_ui, file_path_in_repo):
     repo_id_for_error_logging = f"{owner_ui}/{space_name_ui}" if owner_ui else space_name_ui
+    repo_id = None
     try:
         resolved_api_token, token_err = _get_api_token(ui_api_token_from_textbox)
         if token_err: return None, token_err
@@ -195,170 +257,334 @@ def get_space_file_content(ui_api_token_from_textbox, space_name_ui, owner_ui, f
         if err_repo_id: return None, err_repo_id
         repo_id_for_error_logging = repo_id
         if not file_path_in_repo: return None, "Error: File path cannot be empty."
-        downloaded_file_path = hf_hub_download(repo_id=repo_id, filename=file_path_in_repo, repo_type="space", token=resolved_api_token)
+        # Ensure file_path_in_repo uses forward slashes
+        file_path_in_repo = file_path_in_repo.replace("\\", "/")
+
+        # Use hf_hub_download first, which caches locally
+        downloaded_file_path = hf_hub_download(
+            repo_id=repo_id,
+            filename=file_path_in_repo,
+            repo_type="space",
+            token=resolved_api_token,
+            local_dir_use_symlinks=False, # Avoid symlinks issues
+            cache_dir=None # Use default cache dir
+        )
         content = Path(downloaded_file_path).read_text(encoding="utf-8")
         return content, None
+    except FileNotFoundError:
+         return None, f"Error: File '{file_path_in_repo}' not found locally after download attempt."
+    except UnicodeDecodeError:
+        # If read_text fails, it's likely binary or non-utf8 text
+        return None, f"Error: File '{file_path_in_repo}' is not valid UTF-8 text. Cannot display."
     except HfHubHTTPError as e_http:
-        logger.error(f"HTTP error fetching file {file_path_in_repo} from {repo_id_for_error_logging}: {e_http}")
+        logger.error(f"HTTP error fetching file {file_path_in_repo} from {repo_id_for_error_logging or 'unknown repo'}: {e_http}")
         error_message = str(e_http)
-        if e_http.response is not None and e_http.response.status_code == 404:
-            return None, f"Error: File '{file_path_in_repo}' not found in Space '{repo_id_for_error_logging}' (404)."
+        status_code = e_http.response.status_code if e_http.response is not None else None
+        if status_code == 404:
+            return None, f"Error: File '{file_path_in_repo}' not found in Space '{repo_id_for_error_logging or 'unknown repo'}' (404)."
+        if status_code in (401, 403):
+             return None, f"Error: Access denied or authentication required for '{repo_id_for_error_logging or 'unknown repo'}' ({status_code}). Check token permissions."
         return None, f"HTTP Error fetching file '{file_path_in_repo}': {error_message}"
     except Exception as e:
-        logger.exception(f"Error fetching file content for {file_path_in_repo} from {repo_id_for_error_logging}:")
+        logger.exception(f"Error fetching file content for {file_path_in_repo} from {repo_id_for_error_logging or 'unknown repo'}:")
         return None, f"Error fetching file content: {str(e)}"
 
 # --- Create/Update Space ---
 def create_space(ui_api_token_from_textbox, space_name_ui, owner_ui, sdk_ui, markdown_input):
     repo_id_for_error_logging = f"{owner_ui}/{space_name_ui}" if owner_ui else space_name_ui
+    repo_id = None
     try:
         resolved_api_token, token_err = _get_api_token(ui_api_token_from_textbox)
         if token_err: return token_err
         repo_id, err_repo_id = _determine_repo_id(ui_api_token_from_textbox, space_name_ui, owner_ui)
         if err_repo_id: return err_repo_id
-        repo_id_for_error_logging = repo_id
+        repo_id_for_error_logging = repo_id # Update logging name
+
         space_info = parse_markdown(markdown_input)
 
         with tempfile.TemporaryDirectory() as temp_dir:
             repo_staging_path = Path(temp_dir) / "repo_staging_content"
             repo_staging_path.mkdir(exist_ok=True)
-            if not space_info["files"]:
-                with open(repo_staging_path / ".gitattributes", "w") as f: f.write("* text=auto eol=lf\n")
-                logger.info(f"Markdown contained no files. Staging dummy .gitattributes for {repo_id}.")
+
+            # Always write .gitattributes to ensure LF line endings
+            gitattributes_path = repo_staging_path / ".gitattributes"
+            with open(gitattributes_path, "w") as f:
+                f.write("* text=auto eol=lf\n")
+
+            # If there are no files parsed from markdown *other than* the structure block,
+            # ensure the .gitattributes file is still staged.
+            if not [f for f in space_info["files"] if not f.get("is_structure_block")]:
+                 logger.info(f"Markdown contained no standard files. Staging only .gitattributes for {repo_id}.")
+
+
             for file_info in space_info["files"]:
-                if not file_info.get("path"):
-                    logger.warning(f"Skipping file_info with no path: {file_info}")
+                if not file_info.get("path") or file_info.get("is_structure_block"):
+                    # Skip entries without a path or the structure block representation
+                    if not file_info.get("path"): logger.warning(f"Skipping file_info with no path: {file_info}")
                     continue
-                file_path_abs = repo_staging_path / file_info["path"]
-                file_path_abs.parent.mkdir(parents=True, exist_ok=True)
+
+                # Skip files that were marked as binary/error during loading
                 content_to_write = file_info.get("content", "")
-                with open(file_path_abs, "w", encoding="utf-8") as f: f.write(content_to_write)
-            
+                if content_to_write.startswith("[Binary file") or content_to_write.startswith("[Error loading content:") or content_to_write.startswith("[Binary or Skipped file]"):
+                     logger.info(f"Skipping binary/error placeholder file from build: {file_info['path']}")
+                     continue
+
+
+                file_path_abs = repo_staging_path / file_info["path"]
+                file_path_abs.parent.mkdir(parents=True, exist_ok=True) # Create parent directories
+                try:
+                    # Ensure content is treated as text and written with utf-8 encoding
+                    with open(file_path_abs, "w", encoding="utf-8") as f:
+                         f.write(content_to_write)
+                except Exception as file_write_error:
+                    logger.error(f"Error writing file {file_info['path']} during staging: {file_write_error}")
+                    return f"Error staging file {file_info['path']}: {file_write_error}"
+
+
+            # Create or ensure repo exists
             create_repo(repo_id=repo_id, token=resolved_api_token, repo_type="space", space_sdk=sdk_ui, private=False, exist_ok=True)
-            
+
+            api = HfApi(token=resolved_api_token)
+
+            # Determine files to delete (files on Hub not in markdown)
             try:
-                api = HfApi(token=resolved_api_token)
                 current_hub_files_info = api.list_repo_files(repo_id=repo_id, repo_type="space", recursive=True)
                 current_hub_files = set(current_hub_files_info)
-                markdown_filenames = set(f_info["path"] for f_info in space_info["files"])
-                files_to_delete_on_hub = list(current_hub_files - markdown_filenames)
-                files_to_delete_on_hub = [f for f in files_to_delete_on_hub if not (f.startswith('.git') or (f == "README.md" and "README.md" not in markdown_filenames))]
+                # Get filenames from the markdown that were actually staged (not skipped binaries/structure)
+                markdown_staged_filenames = set(str(Path(temp_dir) / "repo_staging_content" / f.get("path")).relative_to(repo_staging_path) for f in space_info["files"] if f.get("path") and not f.get("is_structure_block") and not (f.get("content", "").startswith("[Binary file") or f.get("content", "").startswith("[Error loading content:") or f.get("content", "").startswith("[Binary or Skipped file]")))
+                markdown_staged_filenames.add(".gitattributes") # Always keep .gitattributes if we staged it
+
+                files_to_delete_on_hub = list(current_hub_files - markdown_staged_filenames)
+
+                # Exclude .git/ files and potentially README.md if we didn't explicitly include it in markdown
+                files_to_delete_on_hub = [f for f in files_to_delete_on_hub if not (f.startswith('.git') or (f == "README.md" and "README.md" not in markdown_staged_filenames))]
 
 
                 if files_to_delete_on_hub:
-                    logger.info(f"Deleting {len(files_to_delete_on_hub)} files from {repo_id} not in new markdown: {files_to_delete_on_hub}")
+                    logger.info(f"Deleting {len(files_to_delete_on_hub)} files from {repo_id} not in new markdown structure: {files_to_delete_on_hub}")
                     delete_operations = [CommitOperationDelete(path_in_repo=f) for f in files_to_delete_on_hub]
-                    if delete_operations: 
-                        api.create_commit(
-                            repo_id=repo_id,
-                            repo_type="space",
-                            operations=delete_operations,
-                            commit_message=f"AI Space Builder: Removed {len(files_to_delete_on_hub)} files not in updated structure."
-                        )
-            except Exception as e_delete_old:
-                logger.error(f"Error during pre-upload deletion of old files in {repo_id}: {e_delete_old}. Proceeding with upload.")
-
-            upload_folder(repo_id=repo_id, folder_path=str(repo_staging_path), path_in_repo=".", token=resolved_api_token, repo_type="space", commit_message=f"Space content update for {repo_id} via AI Builder")
+                    if delete_operations:
+                         # Check if there are also files to upload in this commit
+                         if list(repo_staging_path.iterdir()): # Check if staging dir has anything to upload
+                            # Combine delete and upload if possible (advanced scenario, requires specific hf_api methods)
+                            # For simplicity here, do deletes in a separate commit before upload_folder
+                            try:
+                                 api.create_commit(
+                                     repo_id=repo_id,
+                                     repo_type="space",
+                                     operations=delete_operations,
+                                     commit_message=f"AI Space Builder: Removed {len(files_to_delete_on_hub)} files not in updated structure."
+                                 )
+                                 logger.info("Successfully committed deletions.")
+                            except Exception as e_delete_commit:
+                                 logger.error(f"Error committing deletions in {repo_id}: {e_delete_commit}. Proceeding with upload.")
+                                 # If delete commit fails, maybe upload_folder can handle concurrent ops?
+                                 # Or perhaps the files will be overwritten anyway if present in staging?
+                                 # It's safest to report the delete error but attempt upload.
+                         else:
+                             # If only deletions are happening (staging is empty except maybe .gitattributes)
+                             try:
+                                 api.create_commit(
+                                     repo_id=repo_id,
+                                     repo_type="space",
+                                     operations=delete_operations,
+                                     commit_message=f"AI Space Builder: Removed {len(files_to_delete_on_hub)} files."
+                                 )
+                                 logger.info("Successfully committed deletions (only deletions).")
+                                 # If only deleting, we are done.
+                                 return f"Successfully updated Space: [{repo_id}](https://huggingface.co/spaces/{repo_id}) (Files deleted)."
+                             except Exception as e_only_delete_commit:
+                                  logger.error(f"Error committing deletions (only deletions) in {repo_id}: {e_only_delete_commit}.")
+                                  return f"Error during Space update (deletions only): {str(e_only_delete_commit)}"
+
+
+            except Exception as e_delete_old_prep:
+                logger.error(f"Error during preparation for deletion of old files in {repo_id}: {e_delete_old_prep}. Proceeding with upload.")
+                # Don't return here, allow the upload to happen.
+
+
+            # Upload the staged files (including .gitattributes and any new/updated files)
+            logger.info(f"Uploading staged files from {str(repo_staging_path)} to {repo_id}")
+            # Use upload_folder which handles creating/updating files based on the staging directory content
+            upload_folder(
+                repo_id=repo_id,
+                folder_path=str(repo_staging_path),
+                path_in_repo=".", # Upload to the root of the repository
+                token=resolved_api_token,
+                repo_type="space",
+                commit_message=f"AI Space Builder: Space content update for {repo_id}"
+            )
+
             return f"Successfully created/updated Space: [{repo_id}](https://huggingface.co/spaces/{repo_id})"
+
+    except HfHubHTTPError as e_http:
+        logger.error(f"HTTP error during create_space for {repo_id_for_error_logging or 'unknown repo'}: {e_http}")
+        error_message = str(e_http)
+        status_code = e_http.response.status_code if e_http.response is not None else None
+        if status_code == 409: # Conflict, often means repo exists but maybe wrong type/owner?
+             return f"Error creating/updating Space '{repo_id_for_error_logging or 'unknown repo'}': Conflict (Space might exist with different owner/settings)."
+        if status_code in (401, 403):
+             return f"Error creating/updating Space '{repo_id_for_error_logging or 'unknown repo'}': Access denied or authentication required ({status_code}). Check token permissions."
+        return f"HTTP Error {status_code or 'unknown'} during Space creation/update: {error_message}"
     except Exception as e:
-        logger.exception(f"Error in create_space for {repo_id_for_error_logging}:")
+        logger.exception(f"Error in create_space for {repo_id_for_error_logging or 'unknown repo'}:")
         return f"Error during Space creation/update: {str(e)}"
 
 # --- Update Single File ---
 def update_space_file(ui_api_token_from_textbox, space_name_ui, owner_ui, file_path_in_repo, file_content, commit_message_ui):
     repo_id_for_error_logging = f"{owner_ui}/{space_name_ui}" if owner_ui else space_name_ui
+    repo_id = None
     try:
         resolved_api_token, token_err = _get_api_token(ui_api_token_from_textbox)
         if token_err: return token_err
         repo_id, err_repo_id = _determine_repo_id(ui_api_token_from_textbox, space_name_ui, owner_ui)
         if err_repo_id: return err_repo_id
-        repo_id_for_error_logging = repo_id
+        repo_id_for_error_logging = repo_id # Update logging name
+
         if not file_path_in_repo: return "Error: File Path to update cannot be empty."
-        file_path_in_repo = file_path_in_repo.lstrip('/').replace(os.sep, '/')
+        file_path_in_repo = file_path_in_repo.lstrip('/').replace(os.sep, '/') # Clean path for Hub
         commit_msg = commit_message_ui or f"Update {file_path_in_repo} via AI Space Editor"
+
         api = HfApi(token=resolved_api_token)
-        file_content_bytes = file_content.encode('utf-8')
-        with tempfile.NamedTemporaryFile(delete=False) as tmp_file_obj:
-            tmp_file_obj.write(file_content_bytes)
+
+        # Use a temporary file to upload content safely
+        with tempfile.NamedTemporaryFile(mode='w', delete=False, encoding='utf-8') as tmp_file_obj:
+            tmp_file_obj.write(file_content)
             tmp_file_path = tmp_file_obj.name
+
         try:
-            api.upload_file(path_or_fileobj=tmp_file_path, path_in_repo=file_path_in_repo, repo_id=repo_id, repo_type="space", commit_message=commit_msg)
+            # Upload the temporary file to the specified path in the repo
+            api.upload_file(
+                path_or_fileobj=tmp_file_path,
+                path_in_repo=file_path_in_repo,
+                repo_id=repo_id,
+                repo_type="space",
+                commit_message=commit_msg
+            )
             return f"Successfully updated `{file_path_in_repo}` in Space [{repo_id}](https://huggingface.co/spaces/{repo_id})"
         finally:
-            os.remove(tmp_file_path)
+            # Ensure the temporary file is removed
+            if os.path.exists(tmp_file_path):
+                 os.remove(tmp_file_path)
+
+    except FileNotFoundError:
+         return f"Error: Local temporary file not found during upload for '{file_path_in_repo}'."
+    except HfHubHTTPError as e_http:
+        logger.error(f"HTTP error in update_space_file for {repo_id_for_error_logging or 'unknown repo'}, file {file_path_in_repo}: {e_http}")
+        error_message = str(e_http)
+        status_code = e_http.response.status_code if e_http.response is not None else None
+        if status_code == 404:
+            return f"Error: Space '{repo_id_for_error_logging or 'unknown repo'}' or file '{file_path_in_repo}' not found (404)."
+        if status_code in (401, 403):
+             return f"Error: Access denied or authentication required for '{repo_id_for_error_logging or 'unknown repo'}' ({status_code}). Check token permissions."
+        return f"HTTP Error {status_code or 'unknown'} updating file '{file_path_in_repo}': {error_message}"
     except Exception as e:
-        logger.exception(f"Error in update_space_file for {repo_id_for_error_logging}, file {file_path_in_repo}:")
-        return f"Error updating file for `{repo_id_for_error_logging}`: {str(e)}"
+        logger.exception(f"Error in update_space_file for {repo_id_for_error_logging or 'unknown repo'}, file {file_path_in_repo}:")
+        return f"Error updating file for `{repo_id_for_error_logging or 'unknown repo'}`: {str(e)}"
+
 
 # --- Delete Single File ---
 def delete_space_file(ui_api_token_from_textbox, space_name_ui, owner_ui, file_path_in_repo, commit_message_ui=None):
     repo_id_for_error_logging = f"{owner_ui}/{space_name_ui}" if owner_ui else space_name_ui
+    repo_id = None
     try:
         resolved_api_token, token_err = _get_api_token(ui_api_token_from_textbox)
         if token_err: return f"API Token Error: {token_err}"
         repo_id, err_repo_id = _determine_repo_id(ui_api_token_from_textbox, space_name_ui, owner_ui)
         if err_repo_id: return f"Repo ID Error: {err_repo_id}"
-        repo_id_for_error_logging = repo_id
+        repo_id_for_error_logging = repo_id # Update logging name
+
         if not file_path_in_repo: return "Error: File path cannot be empty for deletion."
+        file_path_in_repo = file_path_in_repo.lstrip('/').replace(os.sep, '/') # Clean path for Hub
+
+        # Prevent deleting essential files like .gitattributes or README.md unless explicitly handled?
+        # For now, allow deleting anything selected in the dropdown.
+
         effective_commit_message = commit_message_ui or f"Deleted file: {file_path_in_repo} via AI Space Editor"
-        hf_delete_file(path_in_repo=file_path_in_repo, repo_id=repo_id, repo_type="space", token=resolved_api_token, commit_message=effective_commit_message)
+
+        # Use hf_delete_file directly
+        hf_delete_file(
+            path_in_repo=file_path_in_repo,
+            repo_id=repo_id,
+            repo_type="space",
+            token=resolved_api_token,
+            commit_message=effective_commit_message
+        )
         return f"Successfully deleted file: {file_path_in_repo}"
+
     except HfHubHTTPError as e_http: # Catch specific HF HTTP errors
-        logger.error(f"HTTP error deleting file {file_path_in_repo} from {repo_id_for_error_logging}: {e_http}")
+        logger.error(f"HTTP error deleting file {file_path_in_repo} from {repo_id_for_error_logging or 'unknown repo'}: {e_http}")
         error_message = str(e_http)
-        if e_http.response is not None and e_http.response.status_code == 404:
-             return f"Error: File '{file_path_in_repo}' not found in Space '{repo_id_for_error_logging}' for deletion (404)."
-        return f"HTTP Error deleting file '{file_path_in_repo}': {error_message}"
+        status_code = e_http.response.status_code if e_http.response is not None else None
+
+        if status_code == 404:
+             return f"Error: File '{file_path_in_repo}' not found in Space '{repo_id_for_error_logging or 'unknown repo'}' for deletion (404)."
+        if status_code in (401, 403):
+             return f"Error: Access denied or authentication required for '{repo_id_for_error_logging or 'unknown repo'}' ({status_code}). Check token permissions."
+        return f"HTTP Error {status_code or 'unknown'} deleting file '{file_path_in_repo}': {error_message}"
     except Exception as e:
-        logger.exception(f"Error deleting file {file_path_in_repo} from {repo_id_for_error_logging}:")
+        logger.exception(f"Error deleting file {file_path_in_repo} from {repo_id_for_error_logging or 'unknown repo'}:")
         return f"Error deleting file '{file_path_in_repo}': {str(e)}"
 
 # --- Get Space Runtime Status ---
 def get_space_runtime_status(ui_api_token_from_textbox, space_name_ui, owner_ui):
     repo_id_for_error_logging = f"{owner_ui}/{space_name_ui}" if owner_ui else space_name_ui
+    repo_id = None
     try:
         resolved_api_token, token_err = _get_api_token(ui_api_token_from_textbox)
         if token_err: return None, f"API Token Error: {token_err}"
         repo_id, err_repo_id = _determine_repo_id(ui_api_token_from_textbox, space_name_ui, owner_ui)
         if err_repo_id: return None, f"Repo ID Error: {err_repo_id}"
-        repo_id_for_error_logging = repo_id
+        repo_id_for_error_logging = repo_id # Update logging name
+
         api = HfApi(token=resolved_api_token)
         logger.info(f"Fetching runtime status for Space: {repo_id}")
-        
+
+        # Use get_space_runtime which provides details like stage, hardware, etc.
         runtime_info = api.get_space_runtime(repo_id=repo_id)
-        
+
+        # Structure the details for display
         status_details = {
             "stage": runtime_info.stage,
             "hardware": runtime_info.hardware,
-            "requested_hardware": runtime_info.requested_hardware,
-            "error_message": None, 
+            "requested_hardware": runtime_info.requested_hardware if hasattr(runtime_info, 'requested_hardware') else None, # requested_hardware might not always be present
+            "error_message": None,
             "full_log_link": f"https://huggingface.co/spaces/{repo_id}/logs",
-            "raw_data": runtime_info.raw 
+            "raw_data": runtime_info.raw # Include raw data for detailed inspection if needed
         }
+
+        # Check for specific error states or messages
         if runtime_info.stage == "ERRORED":
             error_content = None
+            # Look for error details in various places within the raw data or the error attribute
             if hasattr(runtime_info, 'error') and runtime_info.error: error_content = str(runtime_info.error)
-            elif 'message' in runtime_info.raw and isinstance(runtime_info.raw['message'], str) and 'error' in runtime_info.raw['message'].lower(): error_content = runtime_info.raw['message']
+            elif 'message' in runtime_info.raw and isinstance(runtime_info.raw['message'], str) and ('error' in runtime_info.raw['message'].lower() or runtime_info.raw['message'].strip().endswith('!')): # Basic check for message indicative of error
+                error_content = runtime_info.raw['message']
             elif 'error' in runtime_info.raw: error_content = str(runtime_info.raw['error'])
-            
+
+            # Check build/run specific error messages in raw data
             if 'build' in runtime_info.raw and isinstance(runtime_info.raw['build'], dict) and runtime_info.raw['build'].get('status') == 'error':
-                error_content = f"Build Error: {runtime_info.raw['build'].get('message', error_content or 'Unknown build error')}"
+                 error_content = f"Build Error: {runtime_info.raw['build'].get('message', error_content or 'Unknown build error')}"
             elif 'run' in runtime_info.raw and isinstance(runtime_info.raw['run'], dict) and runtime_info.raw['run'].get('status') == 'error':
                  error_content = f"Runtime Error: {runtime_info.raw['run'].get('message', error_content or 'Unknown runtime error')}"
-            
+
             status_details["error_message"] = error_content if error_content else "Space is in an errored state. Check logs for details."
 
         logger.info(f"Runtime status for {repo_id}: {status_details['stage']}")
         return status_details, None
+
     except HfHubHTTPError as e_http: # Catch specific HF HTTP errors
-        logger.error(f"HTTP error fetching runtime status for {repo_id_for_error_logging}: {e_http}")
+        logger.error(f"HTTP error fetching runtime status for {repo_id_for_error_logging or 'unknown repo'}: {e_http}")
         error_message = str(e_http)
-        if e_http.response is not None:
-            if e_http.response.status_code == 404:
-                return None, f"Error: Space '{repo_id_for_error_logging}' not found or has no active runtime (404)."
-            elif e_http.response.status_code in (401,403):
-                 return None, f"Error: Access denied or authentication required for '{repo_id_for_error_logging}' ({e_http.response.status_code})."
-        return None, f"HTTP Error fetching runtime status for '{repo_id_for_error_logging}': {error_message}"
+        status_code = e_http.response.status_code if e_http.response is not None else None
+
+        if status_code == 404:
+            # A 404 could mean the space doesn't exist or doesn't have an active runtime state recorded
+            return None, f"Error: Space '{repo_id_for_error_logging or 'unknown repo'}' not found or has no active runtime status (404)."
+        if status_code in (401, 403):
+             return None, f"Error: Access denied or authentication required for '{repo_id_for_error_logging or 'unknown repo'}' ({status_code}). Check token permissions."
+        return None, f"HTTP Error {status_code or 'unknown'} fetching runtime status for '{repo_id_for_error_logging or 'unknown repo'}': {error_message}"
+
     except Exception as e:
-        logger.exception(f"Error fetching runtime status for {repo_id_for_error_logging}:")
+        logger.exception(f"Error fetching runtime status for {repo_id_for_error_logging or 'unknown repo'}:")
         return None, f"Error fetching runtime status: {str(e)}"