In `@packages/bruno-app/src/providers/ReduxStore/slices/collections/actions.js`:
- Around line 2673-2678: Replace the brittle split('/').pop() extraction with
the platform-aware path.basename to get the collection name; in the block that
checks activeWorkspace (the code that computes collectionName from
collectionPath before calling
ipcRenderer.invoke('renderer:add-collection-to-workspace', ...)), use
path.basename(collectionPath) so Windows backslashes are handled correctly and
pass that name into the payload.
- Around line 2663-2685: The importCollectionFromZip thunk uses an async Promise
executor which is an antipattern; replace the new Promise(async (resolve,
reject) => { ... }) wrapper by making the thunk itself async: export const
importCollectionFromZip = (zipFilePath, collectionLocation) => async (dispatch,
getState) => { ... }; inside, await
ipcRenderer.invoke('renderer:import-collection-zip', ...), perform the workspace
add via ipcRenderer.invoke if needed, then return collectionPath (and let thrown
errors propagate instead of calling reject) so callers receive the resolved
value or exception normally; update references to resolve/reject accordingly.

In `@packages/bruno-electron/src/ipc/collection.js`:
- Around line 2065-2071: If sanitizeName(collectionName) can return an empty
string, ensure you provide a safe fallback before building finalCollectionPath:
after computing sanitizedName in the function handling collection creation
(where sanitizeName, finalCollectionPath, collectionLocation and collectionName
are used) check if sanitizedName is falsy and replace it with a default like
"untitled" (optionally append a timestamp or UUID to avoid collisions), then run
the existing existsSync loop to append " (n)" as needed so finalCollectionPath
never resolves to the parent directory.
- Around line 2018-2086: The import handler (ipcMain.handle
'renderer:import-collection-zip') must reject ZIPs that create symlinks pointing
outside the extraction dir: after extraction to tempDir but before touching
brunoJsonPath/openCollectionYmlPath or calling fs.statSync/fs.readFileSync,
recursively walk collectionDir/extractedItems and for each entry use
fs.lstatSync to detect symbolic links; for any symlink use fs.realpathSync (or
path.resolve) to compute its target and ensure the resolved target is inside
tempDir (startsWith tempDir) — if any symlink points outside, abort the import
(clean up tempDir) and throw; additionally, when reading
bruno.json/opencollection.yml check with lstat that those specific files are not
symlinks and fail if they are, then proceed to move with fsExtra.move only after
validation.

In `@packages/bruno-electron/src/ipc/collection.js`:
- Line 2109: The ZIP import branch returns finalCollectionPath without emitting
the UI event, so add the same emit used by renderer:import-collection: after
computing finalCollectionPath and before returning, send the
main:collection-opened event (with finalCollectionPath) for non-workspace
imports; keep the existing main:workspace-config-updated behavior for workspace
imports and ensure you call the same sending helper (the code path that
currently emits main:collection-opened at renderer:import-collection) so the
sidebar auto-loads the imported collection.

In `@packages/bruno-app/src/components/Sidebar/ImportCollection/FileTab.js`:
- Around line 123-148: The processFiles function currently processes only the
first non-ZIP file (fileArray[0]) and silently ignores others; update
processFiles to detect multiple non-ZIP files and either (a) setErrorMessage
with a clear warning like "Multiple collection files selected. Please select
only one collection file or a single ZIP." and return, or (b) iterate and call
processFile for each file if batch imports are supported; locate and change
logic inside processFiles (referencing processFiles, processFile,
processZipFile, and setErrorMessage) to enforce one-of-two behaviors (explicit
error on multiple non-ZIP files or loop through fileArray and call processFile
for each) and ensure user feedback is shown when files are rejected.
- Around line 165-169: The file input's onChange can fail to fire when a user
re-selects the same file because the input value isn't cleared; inside
handleFileInputChange (which calls processFiles), after awaiting
processFiles(e.target.files) reset the file input value (e.target.value = '') so
subsequent selections of the same file trigger onChange again. Ensure this reset
happens only after processing completes and keep the existing null/length guard.

In `@packages/bruno-electron/src/ipc/collection.js`:
- Around line 2119-2131: The two empty catch blocks around parsing
opencollection.yml and bruno.json should log the parsing errors instead of
swallowing them; update the catch for the parseCollection call (relating to
openCollectionYmlPath and brunoConfig) and the catch for JSON.parse (relating to
brunoJsonPath) to emit a clear error message including the file path and the
exception (e.g., console.error or the project's logger) while preserving the
existing fallback to 'Imported Collection'.

In `@packages/bruno-app/src/components/Sidebar/ImportCollection/FileTab.js`:
- Around line 75-86: The processZipFile function clears loading too early
because handleSubmit is not awaited; change processZipFile to await
handleSubmit({ rawData: { zipFilePath: filePath, collectionName }, type:
'bruno-zip' }) inside the try so setIsLoading(false) in the finally runs only
after the async import completes, and keep the existing catch (toastError) to
surface any errors from handleSubmit; reference the processZipFile function, the
handleSubmit call, setIsLoading and toastError when making this change.
- Around line 88-121: The processFile function calls handleSubmit({ rawData:
data, type }) without awaiting it, which can cause loading state to clear before
submission completes; update processFile to await handleSubmit(...) (i.e., use
await handleSubmit({ rawData: data, type })) so the try/finally lifecycle and
setIsLoading state behave correctly — locate the call inside processFile in
FileTab.js and add the missing await.

In `@packages/bruno-electron/src/ipc/collection.js`:
- Around line 2069-2086: The code uses fs.realpathSync in
validateNoExternalSymlinks which throws on dangling symlinks; replace that with
resolving the symlink target via fs.readlinkSync combined with path.resolve so
broken links don't cause ENOENT. Specifically, inside validateNoExternalSymlinks
where stat.isSymbolicLink() is checked, call const linkTarget =
fs.readlinkSync(fullPath) and then const resolvedTarget =
path.resolve(path.dirname(fullPath), linkTarget) (this handles both relative and
absolute link contents), and keep the existing check that resolvedTarget
startsWith(baseDir + path.sep) || resolvedTarget === baseDir, throwing the same
security error if it points outside; leave the surrounding recursion and
directory checks unchanged.
- Around line 2148-2153: The ZIP-import flow currently returns
finalCollectionPath after performing fsExtra.move(...) (and cleaning tempDir)
but never notifies the app; before returning finalCollectionPath add the same
notifications used by the renderer:import-collection handler: call
mainWindow.webContents.send('main:collection-opened', finalCollectionPath) and
ipcMain.emit('main:collection-opened', finalCollectionPath) (or the same payload
object used elsewhere) so the renderer sidebar picks up the new collection;
locate the block with fsExtra.move(collectionDir, finalCollectionPath), tempDir
checks, and the return finalCollectionPath and insert the two emits just prior
to the return.

In `@packages/bruno-app/src/components/Sidebar/ImportCollection/FileTab.js`:
- Around line 75-86: processZipFile can produce an empty collectionName for a
file literally named ".zip"; after computing collectionName from zipFile.name in
processZipFile, add a guard: if collectionName is empty, derive a safe fallback
(for example use the file basename from filePath without extension, or
zipFile.name if non-empty, or a deterministic default like
"imported-zip-<timestamp>"). Update the logic inside processZipFile (the
collectionName assignment and immediately before calling handleSubmit) to ensure
collectionName is never an empty string.
- Around line 13-34: The current convertFileToObject function treats any XML
MIME as WSDL which short-circuits JSON/YAML parsing; change the WSDL detection
to be specific: keep filename check (file.name.endsWith('.wsdl')) and accept the
official MIME 'application/wsdl+xml', and otherwise detect WSDL by inspecting
the file text for WSDL-specific root elements (e.g. '<definitions' or
'wsdl:definitions') before returning raw text; if none of those are present,
allow the JSON/YAML parsing branches (JSON.parse and jsyaml.load) to run so
valid JSON served with an XML MIME still gets parsed; update convertFileToObject
accordingly and leave processFile behavior unchanged.