fix: status & statusText swap (#7589)

* fix: status & statusText swap

* chore: typo

* test: tests for swapping status and statusText

---------

Co-authored-by: shubh-bruno <shubh-bruno@shubh-bruno.local>

.coderabbit.yaml

@@ -23,6 +23,19 @@ reviews:
     drafts: false
     base_branches: ['main', 'release/*']
   path_instructions:
+    - path: '**/*'
+      instructions: |
+        Bruno is a cross-platform Electron desktop app that runs on macOS, Windows, and Linux. Ensure that all code is OS-agnostic:
+        - File paths must use `path.join()` or `path.resolve()` instead of hardcoded `/` or `\\` separators
+        - Never assume case-sensitive or case-insensitive filesystems
+        - Use `os.homedir()`, `app.getPath()`, or environment-appropriate APIs instead of hardcoded paths like `/home/`, `C:\\Users\\`, or `~/`
+        - Line endings should be handled consistently (be aware of CRLF vs LF issues)
+        - Use `path.sep` or `path.posix`/`path.win32` when platform-specific separators are needed
+        - Shell commands or child_process calls must account for platform differences (e.g., `which` vs `where`, `/bin/sh` vs `cmd.exe`)
+        - File permissions (e.g., `fs.chmod`, `fs.access`) should account for Windows not supporting Unix-style permission bits
+        - Avoid relying on Unix-only signals (e.g., `SIGKILL`) without Windows fallbacks
+        - Use `os.tmpdir()` instead of hardcoding `/tmp`
+        - Environment variable access should handle platform differences (e.g., `HOME` vs `USERPROFILE`)
     - path: 'tests/**/**.*'
       instructions: |
         Review the following e2e test code written using the Playwright test library. Ensure that:

.github/actions/common/setup-node-deps/action.yml

@@ -1,5 +1,10 @@
 name: 'Setup Node Dependencies'
 description: 'Install Node.js and npm dependencies'
+inputs:
+  skip-build:
+    description: 'Skip building libraries'
+    required: false
+    default: 'false'
 runs:
   using: 'composite'
   steps:
@@ -9,12 +14,13 @@ runs:
         node-version: v22.17.0
         cache: 'npm'
         cache-dependency-path: './package-lock.json'
-    
+
     - name: Install node dependencies
       shell: bash
       run: npm ci --legacy-peer-deps
-    
+
     - name: Build libraries
+      if: inputs.skip-build != 'true'
       shell: bash
       run: |
         npm run build:graphql-docs

.github/actions/tests/run-cli-tests/action.yml

@@ -0,0 +1,20 @@
+name: 'Run CLI Tests'
+description: 'Setup dependencies, start local testbench and run CLI tests'
+runs:
+  using: 'composite'
+  steps:
+    - name: Run Local Testbench
+      shell: bash
+      run: |
+        npm start --workspace=packages/bruno-tests &
+        sleep 5
+
+    - name: Install Test Collection Dependencies
+      shell: bash
+      run: npm ci --prefix packages/bruno-tests/collection
+
+    - name: Run CLI Tests
+      shell: bash
+      run: |
+        cd packages/bruno-tests/collection
+        node ../../bruno-cli/bin/bru.js run --env Prod --output junit.xml --format junit --sandbox developer

.github/actions/tests/run-e2e-tests/action.yml

@@ -0,0 +1,22 @@
+name: 'Run E2E Tests'
+description: 'Setup dependencies, configure environment, and run Playwright E2E tests'
+inputs:
+  os:
+    description: 'Operating system (ubuntu, macos, windows)'
+    default: 'ubuntu'
+runs:
+  using: 'composite'
+  steps:
+    - name: Install Test Collection Dependencies
+      shell: bash
+      run: npm ci --prefix packages/bruno-tests/collection
+
+    - name: Run Playwright Tests (Ubuntu)
+      if: inputs.os == 'ubuntu'
+      shell: bash
+      run: xvfb-run npm run test:e2e
+
+    - name: Run Playwright Tests
+      if: inputs.os != 'ubuntu'
+      shell: bash
+      run: npm run test:e2e

.github/actions/tests/run-unit-tests/action.yml

@@ -0,0 +1,48 @@
+name: 'Run Unit Tests'
+description: 'Setup dependencies and run unit tests for all packages'
+runs:
+  using: 'composite'
+  steps:
+    - name: Test Package bruno-js
+      shell: bash
+      run: npm run test --workspace=packages/bruno-js
+
+    - name: Test Package bruno-cli
+      shell: bash
+      run: npm run test --workspace=packages/bruno-cli
+
+    - name: Test Package bruno-query
+      shell: bash
+      run: npm run test --workspace=packages/bruno-query
+
+    - name: Test Package bruno-lang
+      shell: bash
+      run: npm run test --workspace=packages/bruno-lang
+
+    - name: Test Package bruno-schema
+      shell: bash
+      run: npm run test --workspace=packages/bruno-schema
+
+    - name: Test Package bruno-app
+      shell: bash
+      run: npm run test --workspace=packages/bruno-app
+
+    - name: Test Package bruno-common
+      shell: bash
+      run: npm run test --workspace=packages/bruno-common
+
+    - name: Test Package bruno-converters
+      shell: bash
+      run: npm run test --workspace=packages/bruno-converters
+
+    - name: Test Package bruno-electron
+      shell: bash
+      run: npm run test --workspace=packages/bruno-electron
+
+    - name: Test Package bruno-requests
+      shell: bash
+      run: npm run test --workspace=packages/bruno-requests
+
+    - name: Test Package bruno-filestore
+      shell: bash
+      run: npm run test --workspace=packages/bruno-filestore

.github/scripts/comment-on-flaky-tests.js

@@ -0,0 +1,70 @@
+const fs = require('fs');
+const { execSync } = require('child_process');
+
+// Check if flaky-tests.json exists
+if (!fs.existsSync('flaky-tests.json')) {
+  console.log('No flaky-tests.json found');
+  process.exit(0);
+}
+
+// Get changed files in PR
+let changedFiles = [];
+try {
+  changedFiles = execSync('git diff --name-only origin/main...HEAD')
+    .toString()
+    .split('\n')
+    .filter(f => f.endsWith('.spec.ts'));
+} catch (error) {
+  console.log('Could not determine changed files:', error.message);
+  process.exit(0);
+}
+
+if (changedFiles.length === 0) {
+  console.log('No test files were modified in this PR');
+  process.exit(0);
+}
+
+// Read flaky tests
+const flakyTests = JSON.parse(fs.readFileSync('flaky-tests.json', 'utf8'));
+
+if (flakyTests.length === 0) {
+  console.log('No flaky/failed tests found');
+  process.exit(0);
+}
+
+// Find modified flaky tests
+const modifiedFlakyTests = flakyTests.filter(test =>
+  changedFiles.some(file => test.file.includes(file))
+);
+
+if (modifiedFlakyTests.length === 0) {
+  console.log('No modified test files are flaky');
+  process.exit(0);
+}
+
+// Generate comment markdown
+let comment = '## ⚠️ Warning: You modified flaky/failed test files\n\n';
+comment += 'The following test files you modified have reliability issues:\n\n';
+
+modifiedFlakyTests.forEach(test => {
+  const testType = test.status === 'failed' ? '❌ Failed' : '⚠️ Flaky';
+  comment += `### ${testType}: \`${test.file}\`\n`;
+  comment += `**Test:** ${test.testTitle}\n`;
+  comment += `**Status:** ${test.status}\n`;
+  if (test.retryAttempt > 0) {
+    comment += `**Retry Attempt:** ${test.retryAttempt}\n`;
+  }
+  comment += '\n**To debug locally, run:**\n';
+  comment += '```bash\n';
+  comment += `npx playwright test ${test.file} --repeat-each=5 --workers=1\n`;
+  comment += '```\n\n';
+});
+
+comment += '---\n';
+comment += '**Note:** Flaky tests passed after retrying, failed tests did not pass. ';
+comment += 'Please investigate and fix the root cause before merging.\n';
+
+// Save comment to file for GitHub Action to post
+fs.writeFileSync('pr-comment.md', comment);
+
+console.log(`Found ${modifiedFlakyTests.length} modified flaky tests`);

.github/scripts/detect-flaky-tests.js

@@ -0,0 +1,78 @@
+const fs = require('fs');
+
+
+// Read Playwright JSON report
+const resultsPath = 'playwright-report/results.json';
+
+if (!fs.existsSync(resultsPath)) {
+  console.log('No Playwright results found at', resultsPath);
+  process.exit(0);
+}
+
+const results = JSON.parse(fs.readFileSync(resultsPath, 'utf8'));
+
+// Extract flaky tests
+// A test is flaky if: status === "passed" AND retry > 0
+// A test is failed if: status === "failed"
+// This means it failed initially but passed on retry OR failed completely
+const flakyTests = [];
+
+function traverseSuites(suites) {
+  for (const suite of suites) {
+    // Process specs in this suite
+    for (const spec of suite.specs || []) {
+      for (const test of spec.tests || []) {
+        // Check each test result
+        for (const result of test.results || []) {
+          // Track two types of problematic tests:
+          // 1. Flaky: passed on a retry attempt (retry > 0)
+          // 2. Failed: failed on all attempts
+          if ((result.status === 'passed' && result.retry > 0) || result.status === 'failed') {
+            flakyTests.push({
+              file: spec.file,
+              title: spec.title,
+              testTitle: spec.title,
+              line: spec.line,
+              status: result.status,
+              retryAttempt: result.retry
+            });
+            break; // Only record once per test
+          }
+        }
+      }
+    }
+
+    // Recursively process nested suites
+    if (suite.suites && suite.suites.length > 0) {
+      traverseSuites(suite.suites);
+    }
+  }
+}
+
+traverseSuites(results.suites || []);
+
+// Save flaky tests to JSON
+fs.writeFileSync('flaky-tests.json', JSON.stringify(flakyTests, null, 2));
+
+// Generate markdown report
+let markdown = '## ⚠️ Flaky/Failed Tests Detected\n\n';
+markdown += 'The following tests are problematic:\n\n';
+
+flakyTests.forEach(test => {
+  const testType = test.status === 'failed' ? '❌ Failed' : '⚠️ Flaky';
+  markdown += `### ${testType}: \`${test.file}\`\n`;
+  markdown += `- **Test:** ${test.testTitle}\n`;
+  markdown += `- **Status:** ${test.status}\n`;
+  if (test.retryAttempt > 0) {
+    markdown += `- **Retry Attempt:** ${test.retryAttempt}\n`;
+  }
+  markdown += `- **Debug command:**\n`;
+  markdown += '```bash\n';
+  markdown += `npx playwright test ${test.file} --repeat-each=5 --workers=1\n`;
+  markdown += '```\n\n';
+});
+
+fs.writeFileSync('flaky-report.md', markdown);
+
+console.log(`Found ${flakyTests.length} flaky/failed tests`);
+process.exit(flakyTests.length > 0 ? 1 : 0);

.github/workflows/flaky-test-detector.yml

@@ -0,0 +1,120 @@
+name: Flaky Test Detector
+
+on:
+  pull_request:
+    branches: [main]
+    paths:
+      - 'tests/**/*.spec.ts'
+
+permissions:
+  contents: read
+  pull-requests: write
+  issues: write
+  checks: write
+
+jobs:
+  detect-flaky-tests:
+    name: Detect Flaky Tests
+    runs-on: ubuntu-24.04
+    timeout-minutes: 60
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v6
+        with:
+          fetch-depth: 0  # Need full history to compare with main
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v5
+        with:
+          node-version-file: '.nvmrc'
+          cache: 'npm'
+
+      - name: Install system dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get --no-install-recommends install -y \
+            libglib2.0-0 libnss3 libdbus-1-3 libatk1.0-0 libatk-bridge2.0-0 \
+            libcups2 libgtk-3-0 libasound2t64 xvfb
+
+      - name: Install npm dependencies
+        run: |
+          npm ci --legacy-peer-deps
+          sudo chown root /home/runner/work/bruno/bruno/node_modules/electron/dist/chrome-sandbox
+          sudo chmod 4755 /home/runner/work/bruno/bruno/node_modules/electron/dist/chrome-sandbox
+
+      - name: Install test collection dependencies
+        run: npm ci --prefix packages/bruno-tests/collection
+
+      - name: Build libraries
+        run: |
+          npm run build:graphql-docs
+          npm run build:bruno-query
+          npm run build:bruno-common
+          npm run sandbox:bundle-libraries --workspace=packages/bruno-js
+          npm run build:bruno-converters
+          npm run build:bruno-requests
+          npm run build:schema-types
+          npm run build:bruno-filestore
+
+      - name: Run Playwright tests
+        run: xvfb-run npm run test:e2e
+        continue-on-error: true  # Continue even if tests fail
+
+      - name: Detect flaky tests
+        id: detect
+        run: node .github/scripts/detect-flaky-tests.js
+        continue-on-error: true  # Don't fail workflow if flaky tests found
+
+      - name: Check modified flaky tests
+        id: check-modified
+        run: node .github/scripts/comment-on-flaky-tests.js
+        continue-on-error: true
+
+      - name: Post PR comment
+        if: hashFiles('pr-comment.md') != ''
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const fs = require('fs');
+            const comment = fs.readFileSync('pr-comment.md', 'utf8');
+
+            // Check if we already commented
+            const { data: comments } = await github.rest.issues.listComments({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: context.issue.number
+            });
+
+            const botComment = comments.find(c =>
+              c.user.type === 'Bot' && c.body.includes('Warning: You modified flaky/failed test files')
+            );
+
+            if (botComment) {
+              // Update existing comment
+              await github.rest.issues.updateComment({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                comment_id: botComment.id,
+                body: comment
+              });
+            } else {
+              // Create new comment
+              await github.rest.issues.createComment({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: context.issue.number,
+                body: comment
+              });
+            }
+
+      - name: Upload flaky test artifacts
+        if: always()
+        uses: actions/upload-artifact@v6
+        with:
+          name: flaky-test-results
+          path: |
+            flaky-tests.json
+            flaky-report.md
+            playwright-report/
+          retention-days: 30

.github/workflows/lint-checks.yml

@@ -0,0 +1,26 @@
+name: Lint Checks
+on:
+  workflow_dispatch:
+  push:
+    branches: [main, 'release/v*']
+  pull_request:
+    branches: [main, 'release/v*']
+
+jobs:
+  lint:
+    name: Lint Check
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Setup Node Dependencies
+        uses: ./.github/actions/common/setup-node-deps
+        with:
+          skip-build: 'true'
+
+      - name: Lint Check
+        run: npm run lint
+        env:
+          ESLINT_PLUGIN_DIFF_COMMIT: ${{ github.event_name == 'pull_request' && github.event.pull_request.base.ref || 'main' }}

.github/workflows/tests.yml

@@ -1,9 +1,10 @@
 name: Tests
 on:
+  workflow_dispatch:
   push:
-    branches: [main]
+    branches: [main, 'release/v*']
   pull_request:
-    branches: [main]
+    branches: [main, 'release/v*']
 
 jobs:
   unit-test:
@@ -14,52 +15,12 @@ jobs:
       contents: read
     steps:
       - uses: actions/checkout@v6
-      - uses: actions/setup-node@v5
-        with:
-          node-version-file: '.nvmrc'
-          cache: 'npm'
-          cache-dependency-path: './package-lock.json'
-      - name: Install dependencies
-        run: npm ci --legacy-peer-deps
 
-      # build libraries
-      - name: Build libraries
-        run: |
-          npm run build --workspace=packages/bruno-common
-          npm run build --workspace=packages/bruno-query
-          npm run sandbox:bundle-libraries --workspace=packages/bruno-js
-          npm run build --workspace=packages/bruno-converters
-          npm run build --workspace=packages/bruno-requests
-          npm run build --workspace=packages/bruno-schema-types
-          npm run build --workspace=packages/bruno-filestore
+      - name: Setup Node Dependencies
+        uses: ./.github/actions/common/setup-node-deps
 
-      - name: Lint Check
-        run: npm run lint
-        env:
-          ESLINT_PLUGIN_DIFF_COMMIT: ${{ github.event_name == 'pull_request' && github.event.pull_request.base.ref || 'main' }}
-
-      # tests
-      - name: Test Package bruno-js
-        run: npm run test --workspace=packages/bruno-js
-      - name: Test Package bruno-cli
-        run: npm run test --workspace=packages/bruno-cli
-
-      - name: Test Package bruno-query
-        run: npm run test --workspace=packages/bruno-query
-      - name: Test Package bruno-lang
-        run: npm run test --workspace=packages/bruno-lang
-      - name: Test Package bruno-schema
-        run: npm run test --workspace=packages/bruno-schema
-      - name: Test Package bruno-app
-        run: npm run test --workspace=packages/bruno-app
-      - name: Test Package bruno-common
-        run: npm run test --workspace=packages/bruno-common
-      - name: Test Package bruno-converters
-        run: npm run test --workspace=packages/bruno-converters
-      - name: Test Package bruno-electron
-        run: npm run test --workspace=packages/bruno-electron
-      - name: Test Package bruno-requests
-        run: npm run test --workspace=packages/bruno-requests
+      - name: Run Unit Tests
+        uses: ./.github/actions/tests/run-unit-tests
 
   cli-test:
     name: CLI Tests
@@ -70,35 +31,12 @@ jobs:
       contents: read
     steps:
       - uses: actions/checkout@v6
-      - uses: actions/setup-node@v5
-        with:
-          node-version-file: '.nvmrc'
-          cache: 'npm'
-          cache-dependency-path: './package-lock.json'
 
-      - name: Install dependencies
-        run: npm ci --legacy-peer-deps
+      - name: Setup Node Dependencies
+        uses: ./.github/actions/common/setup-node-deps
 
-      - name: Build Libraries
-        run: |
-          npm run build --workspace=packages/bruno-query
-          npm run build --workspace=packages/bruno-common
-          npm run sandbox:bundle-libraries --workspace=packages/bruno-js
-          npm run build --workspace=packages/bruno-converters
-          npm run build --workspace=packages/bruno-requests
-          npm run build --workspace=packages/bruno-schema-types
-          npm run build --workspace=packages/bruno-filestore
-
-      - name: Run Local Testbench
-        run: |
-          npm start --workspace=packages/bruno-tests &
-          sleep 5
-
-      - name: Run tests
-        run: |
-          cd packages/bruno-tests/collection
-          npm install
-          node ../../bruno-cli/bin/bru.js run --env Prod --output junit.xml --format junit --sandbox developer
+      - name: Run CLI Tests
+        uses: ./.github/actions/tests/run-cli-tests
 
       - name: Publish Test Report
         uses: EnricoMi/publish-unit-test-result-action@v2
@@ -107,46 +45,38 @@ jobs:
           check_name: CLI Test Results
           files: packages/bruno-tests/collection/junit.xml
           comment_mode: always
+
   e2e-test:
     name: Playwright E2E Tests
     timeout-minutes: 60
     runs-on: ubuntu-24.04
     steps:
-    - uses: actions/checkout@v6
-    - uses: actions/setup-node@v5
-      with:
-        node-version: v22.11.x
-    - name: Install dependencies
-      run: |
-        sudo apt-get update
-        sudo apt-get --no-install-recommends install -y \
-          libglib2.0-0 libnss3 libdbus-1-3 libatk1.0-0 libatk-bridge2.0-0 libcups2 libgtk-3-0 libasound2t64 \
-          xvfb
-        npm ci --legacy-peer-deps
-        sudo chown root /home/runner/work/bruno/bruno/node_modules/electron/dist/chrome-sandbox
-        sudo chmod 4755 /home/runner/work/bruno/bruno/node_modules/electron/dist/chrome-sandbox
+      - uses: actions/checkout@v6
 
-    - name: Install dependencies for test collection environment
-      run: |
-        npm ci --prefix packages/bruno-tests/collection
+      - name: Install System Dependencies (Ubuntu)
+        run: |
+          sudo apt-get update
+          sudo apt-get --no-install-recommends install -y \
+            libglib2.0-0 libnss3 libdbus-1-3 libatk1.0-0 libatk-bridge2.0-0 libcups2 libgtk-3-0 libasound2t64 \
+            xvfb
 
-    - name: Build libraries
-      run: |
-        npm run build:graphql-docs
-        npm run build:bruno-query
-        npm run build:bruno-common
-        npm run sandbox:bundle-libraries --workspace=packages/bruno-js
-        npm run build:bruno-converters
-        npm run build:bruno-requests
-        npm run build:schema-types
-        npm run build:bruno-filestore
+      - name: Setup Node Dependencies
+        uses: ./.github/actions/common/setup-node-deps
 
-    - name: Run Playwright tests
-      run: |
-        xvfb-run npm run test:e2e
-    - uses: actions/upload-artifact@v6
-      if: ${{ !cancelled() }}
-      with:
-        name: playwright-report
-        path: playwright-report/
-        retention-days: 30
+      - name: Configure Chrome Sandbox
+        run: |
+          sudo chown root node_modules/electron/dist/chrome-sandbox
+          sudo chmod 4755 node_modules/electron/dist/chrome-sandbox
+
+      - name: Run playwright Tests
+        uses: ./.github/actions/tests/run-e2e-tests
+        with:
+          os: ubuntu
+
+      - name: Upload Playwright Report
+        uses: actions/upload-artifact@v6
+        if: ${{ !cancelled() }}
+        with:
+          name: playwright-report
+          path: playwright-report/
+          retention-days: 30

.gitignore

@@ -49,12 +49,18 @@ bruno.iml
 .idea
 .vscode
 .cursor
+.claude
+.codex
+.agents
+.agent
+skills-lock.json
 
 # Playwright
 /blob-report/
 
 # Development plan files
 CLAUDE.md
+AGENTS.md
 *.plan.md
 
 # packages dist

.prettierrc.json

@@ -1,7 +0,0 @@
-{
-  "trailingComma": "none",
-  "tabWidth": 2,
-  "semi": true,
-  "singleQuote": true,
-  "printWidth": 120
-}

CODING_STANDARDS.md

@@ -66,7 +66,16 @@ Remember, these rules are here to make our codebase harmonious. If something doe
 
 - Use styled component's theme prop to manage CSS colors and not CSS variables when in the context of a styled component or any react component using the styled component 
 - Styled Components are used as wrappers to define both self and children components style, tailwind classes are used specifically for layout based styles. 
-- Styled Component CSS might also change layout but tailwind classes shouldn't define colors. 
+- Styled Component CSS might also change layout but tailwind classes shouldn't define colors.
+- MUST: Prefer custom hooks for business logic, data fetching, and side-effects.
+- MUST: Avoid `useEffect` unless absolutely needed. Prefer derived state, event handlers.
+- SHOULD: Memoize only when necessary (`useMemo`/`useCallback`), and prefer moving logic into hooks first.
+- MUST: Do not use namespace access for hooks in app code (e.g., `React.useCallback`, `React.useMemo`, `React.useState`). Import hooks directly.
+  - Correct: `import { useCallback, useMemo, useState } from "react";`
+  - Avoid: `import * as React from "react";` then `React.useCallback(...)`
+- Add `data-testid` to testable elements for Playwright
+- Co-locate utilities that are truly component-specific next to the component, otherwise place shared items under a common folder
+
 
 ## Readability and Abstractions
 

eslint.config.js

@@ -178,7 +178,8 @@ module.exports = runESMImports().then(() => defineConfig([
       }
     },
     rules: {
-      'no-undef': 'error'
+      'no-undef': 'error',
+      'no-case-declarations': 'error'
     }
   },
   {

package.json

@@ -23,7 +23,7 @@
     "@eslint/compat": "^1.3.2",
     "@faker-js/faker": "^7.6.0",
     "@jest/globals": "^29.2.0",
-    "@opencollection/types": "~0.7.0",
+    "@opencollection/types": "~0.8.0",
     "@playwright/test": "^1.51.1",
     "@rollup/plugin-json": "^6.1.0",
     "@storybook/addon-webpack5-compiler-babel": "^4.0.0",
@@ -36,6 +36,7 @@
     "@types/node": "^22.14.1",
     "@typescript-eslint/parser": "^8.39.0",
     "concurrently": "^8.2.2",
+    "cross-env": "10.1.0",
     "eslint": "^9.26.0",
     "eslint-plugin-diff": "^2.0.3",
     "fs-extra": "^11.1.1",
@@ -59,7 +60,6 @@
     "dev:watch": "node ./scripts/dev-hot-reload.js",
     "dev:web": "npm run dev --workspace=packages/bruno-app",
     "build:web": "npm run build --workspace=packages/bruno-app",
-    "prettier:web": "npm run prettier --workspace=packages/bruno-app",
     "dev:electron": "npm run dev --workspace=packages/bruno-electron",
     "dev:electron:debug": "npm run debug --workspace=packages/bruno-electron",
     "storybook": "npm run storybook --workspace=packages/bruno-app",
@@ -82,9 +82,8 @@
     "test:codegen": "node playwright/codegen.ts",
     "test:e2e": "playwright test --project=default",
     "test:e2e:ssl": "playwright test --project=ssl",
-    "test:prettier:web": "npm run test:prettier --workspace=packages/bruno-app",
-    "lint": "node --max_old_space_size=4096 $(npx which eslint)",
-    "lint:fix": "node --max_old_space_size=4096 $(npx which eslint) --fix",
+    "lint": "cross-env NODE_OPTIONS=\"--max_old_space_size=4096\" npx eslint",
+    "lint:fix": "cross-env NODE_OPTIONS=\"--max_old_space_size=4096\" npx eslint --fix",
     "prepare": "husky"
   },
   "nano-staged": {
@@ -101,6 +100,7 @@
     }
   },
   "dependencies": {
-    "ajv": "^8.17.1"
+    "ajv": "^8.17.1",
+    "git-url-parse": "^14.1.0"
   }
-}
+}

packages/bruno-app/.prettierrc.json

@@ -1,7 +0,0 @@
-{
-  "trailingComma": "none",
-  "tabWidth": 2,
-  "semi": true,
-  "singleQuote": true,
-  "printWidth": 120
-}

packages/bruno-app/package.json

@@ -8,8 +8,6 @@
     "build": "rsbuild build -m production",
     "preview": "rsbuild preview",
     "test": "jest",
-    "test:prettier": "prettier --check \"./src/**/*.{js,jsx,json,ts,tsx}\"",
-    "prettier": "prettier --write \"./src/**/*.{js,jsx,json,ts,tsx}\"",
     "storybook": "storybook dev -p 6006 --config-dir storybook",
     "build-storybook": "storybook build --config-dir storybook"
   },
@@ -29,6 +27,7 @@
     "codemirror": "5.65.2",
     "codemirror-graphql": "2.1.1",
     "cookie": "0.7.1",
+    "diff2html": "^3.4.47",
     "dompurify": "^3.2.4",
     "escape-html": "^1.0.3",
     "fast-fuzzy": "^1.12.0",
@@ -40,7 +39,7 @@
     "github-markdown-css": "^5.2.0",
     "graphiql": "3.7.1",
     "graphql": "^16.6.0",
-    "graphql-request": "^3.7.0",
+    "graphql-request": "4.2.0",
     "hexy": "^0.3.5",
     "httpsnippet": "^3.0.9",
     "i18next": "24.1.2",
@@ -90,7 +89,7 @@
     "shell-quote": "^1.8.3",
     "strip-json-comments": "^5.0.1",
     "styled-components": "^5.3.3",
-    "swagger-ui-react": "5.17.12",
+    "swagger-ui-react": "^5.31.0",
     "system": "^2.0.1",
     "url": "^0.11.3",
     "xml-formatter": "^3.5.0",
@@ -103,7 +102,7 @@
     "@babel/preset-react": "^7.27.1",
     "@rsbuild/core": "^1.1.2",
     "@rsbuild/plugin-babel": "^1.0.3",
-    "@rsbuild/plugin-node-polyfill": "^1.2.0",
+    "@rsbuild/plugin-node-polyfill": "1.2.0",
     "@rsbuild/plugin-react": "^1.0.7",
     "@rsbuild/plugin-sass": "^1.1.0",
     "@rsbuild/plugin-styled-components": "1.1.0",

packages/bruno-app/public/static/diff2Html.min.css

@@ -0,0 +1,713 @@
+:host,
+:root {
+  --d2h-bg-color: #fff;
+  --d2h-border-color: #ddd;
+  --d2h-dim-color: rgba(0, 0, 0, 0.3);
+  --d2h-line-border-color: #eee;
+  --d2h-file-header-bg-color: #f7f7f7;
+  --d2h-file-header-border-color: #d8d8d8;
+  --d2h-empty-placeholder-bg-color: #f1f1f1;
+  --d2h-empty-placeholder-border-color: #e1e1e1;
+  --d2h-selected-color: #c8e1ff;
+  --d2h-ins-bg-color: #dfd;
+  --d2h-ins-border-color: #b4e2b4;
+  --d2h-ins-highlight-bg-color: #97f295;
+  --d2h-ins-label-color: #399839;
+  --d2h-del-bg-color: #fee8e9;
+  --d2h-del-border-color: #e9aeae;
+  --d2h-del-highlight-bg-color: #ffb6ba;
+  --d2h-del-label-color: #c33;
+  --d2h-change-del-color: #fdf2d0;
+  --d2h-change-ins-color: #ded;
+  --d2h-info-bg-color: #f8fafd;
+  --d2h-info-border-color: #d5e4f2;
+  --d2h-change-label-color: #d0b44c;
+  --d2h-moved-label-color: #3572b0;
+  --d2h-dark-color: #e6edf3;
+  --d2h-dark-bg-color: #0d1117;
+  --d2h-dark-border-color: #30363d;
+  --d2h-dark-dim-color: #6e7681;
+  --d2h-dark-line-border-color: #21262d;
+  --d2h-dark-file-header-bg-color: #161b22;
+  --d2h-dark-file-header-border-color: #30363d;
+  --d2h-dark-empty-placeholder-bg-color: hsla(215, 8%, 47%, 0.1);
+  --d2h-dark-empty-placeholder-border-color: #30363d;
+  --d2h-dark-selected-color: rgba(56, 139, 253, 0.1);
+  --d2h-dark-ins-bg-color: rgba(46, 160, 67, 0.15);
+  --d2h-dark-ins-border-color: rgba(46, 160, 67, 0.4);
+  --d2h-dark-ins-highlight-bg-color: rgba(46, 160, 67, 0.4);
+  --d2h-dark-ins-label-color: #3fb950;
+  --d2h-dark-del-bg-color: rgba(248, 81, 73, 0.1);
+  --d2h-dark-del-border-color: rgba(248, 81, 73, 0.4);
+  --d2h-dark-del-highlight-bg-color: rgba(248, 81, 73, 0.4);
+  --d2h-dark-del-label-color: #f85149;
+  --d2h-dark-change-del-color: rgba(210, 153, 34, 0.2);
+  --d2h-dark-change-ins-color: rgba(46, 160, 67, 0.25);
+  --d2h-dark-info-bg-color: rgba(56, 139, 253, 0.1);
+  --d2h-dark-info-border-color: rgba(56, 139, 253, 0.4);
+  --d2h-dark-change-label-color: #d29922;
+  --d2h-dark-moved-label-color: #3572b0;
+}
+.d2h-wrapper {
+  text-align: left;
+}
+.d2h-file-header {
+  background-color: #f7f7f7;
+  background-color: var(--d2h-file-header-bg-color);
+  border-bottom: 1px solid #d8d8d8;
+  border-bottom: 1px solid var(--d2h-file-header-border-color);
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+  font-family: Source Sans Pro, Helvetica Neue, Helvetica, Arial, sans-serif;
+  height: 35px;
+  padding: 5px 10px;
+}
+.d2h-file-header.d2h-sticky-header {
+  position: sticky;
+  top: 0;
+  z-index: 1;
+}
+.d2h-file-stats {
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+  font-size: 14px;
+  margin-left: auto;
+}
+.d2h-lines-added {
+  border: 1px solid #b4e2b4;
+  border: 1px solid var(--d2h-ins-border-color);
+  border-radius: 5px 0 0 5px;
+  color: #399839;
+  color: var(--d2h-ins-label-color);
+  padding: 2px;
+  text-align: right;
+  vertical-align: middle;
+}
+.d2h-lines-deleted {
+  border: 1px solid #e9aeae;
+  border: 1px solid var(--d2h-del-border-color);
+  border-radius: 0 5px 5px 0;
+  color: #c33;
+  color: var(--d2h-del-label-color);
+  margin-left: 1px;
+  padding: 2px;
+  text-align: left;
+  vertical-align: middle;
+}
+.d2h-file-name-wrapper {
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+  -webkit-box-align: center;
+  -ms-flex-align: center;
+  align-items: center;
+  font-size: 15px;
+  width: 100%;
+}
+.d2h-file-name {
+  overflow-x: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.d2h-file-wrapper {
+  border: 1px solid #ddd;
+  border: 1px solid var(--d2h-border-color);
+  border-radius: 3px;
+  margin-bottom: 1em;
+}
+.d2h-file-collapse {
+  -webkit-box-pack: end;
+  -ms-flex-pack: end;
+  cursor: pointer;
+  display: none;
+  font-size: 12px;
+  justify-content: flex-end;
+  -webkit-box-align: center;
+  -ms-flex-align: center;
+  align-items: center;
+  border: 1px solid #ddd;
+  border: 1px solid var(--d2h-border-color);
+  border-radius: 3px;
+  padding: 4px 8px;
+}
+.d2h-file-collapse.d2h-selected {
+  background-color: #c8e1ff;
+  background-color: var(--d2h-selected-color);
+}
+.d2h-file-collapse-input {
+  margin: 0 4px 0 0;
+}
+.d2h-diff-table {
+  border-collapse: collapse;
+  font-family: Menlo, Consolas, monospace;
+  font-size: 13px;
+  width: 100%;
+}
+.d2h-files-diff {
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+  width: 100%;
+}
+.d2h-file-diff {
+  overflow-y: hidden;
+}
+.d2h-file-diff.d2h-d-none,
+.d2h-files-diff.d2h-d-none {
+  display: none;
+}
+.d2h-file-side-diff {
+  display: inline-block;
+  overflow-x: scroll;
+  overflow-y: hidden;
+  width: 50%;
+}
+.d2h-code-line {
+  padding: 0 8em;
+  width: calc(100% - 16em);
+}
+.d2h-code-line,
+.d2h-code-side-line {
+  display: inline-block;
+  -webkit-user-select: none;
+  -moz-user-select: none;
+  -ms-user-select: none;
+  user-select: none;
+  white-space: nowrap;
+}
+.d2h-code-side-line {
+  padding: 0 4.5em;
+  width: calc(100% - 9em);
+}
+.d2h-code-line-ctn {
+  background: none;
+  display: inline-block;
+  padding: 0;
+  word-wrap: normal;
+  -webkit-user-select: text;
+  -moz-user-select: text;
+  -ms-user-select: text;
+  user-select: text;
+  vertical-align: middle;
+  white-space: pre;
+  width: 100%;
+}
+.d2h-code-line del,
+.d2h-code-side-line del {
+  background-color: #ffb6ba;
+  background-color: var(--d2h-del-highlight-bg-color);
+}
+.d2h-code-line del,
+.d2h-code-line ins,
+.d2h-code-side-line del,
+.d2h-code-side-line ins {
+  border-radius: 0.2em;
+  display: inline-block;
+  margin-top: -1px;
+  -webkit-text-decoration: none;
+  text-decoration: none;
+}
+.d2h-code-line ins,
+.d2h-code-side-line ins {
+  background-color: #97f295;
+  background-color: var(--d2h-ins-highlight-bg-color);
+  text-align: left;
+}
+.d2h-code-line-prefix {
+  background: none;
+  display: inline;
+  padding: 0;
+  word-wrap: normal;
+  white-space: pre;
+}
+.line-num1 {
+  float: left;
+}
+.line-num1,
+.line-num2 {
+  -webkit-box-sizing: border-box;
+  box-sizing: border-box;
+  overflow: hidden;
+  padding: 0 0.5em;
+  text-overflow: ellipsis;
+  width: 3.5em;
+}
+.line-num2 {
+  float: right;
+}
+.d2h-code-linenumber {
+  background-color: #fff;
+  background-color: var(--d2h-bg-color);
+  border: solid #eee;
+  border: solid var(--d2h-line-border-color);
+  border-width: 0 1px;
+  -webkit-box-sizing: border-box;
+  box-sizing: border-box;
+  color: rgba(0, 0, 0, 0.3);
+  color: var(--d2h-dim-color);
+  cursor: pointer;
+  display: inline-block;
+  position: absolute;
+  text-align: right;
+  width: 7.5em;
+}
+.d2h-code-linenumber:after {
+  content: '\200b';
+}
+.d2h-code-side-linenumber {
+  background-color: #fff;
+  background-color: var(--d2h-bg-color);
+  border: solid #eee;
+  border: solid var(--d2h-line-border-color);
+  border-width: 0 1px;
+  -webkit-box-sizing: border-box;
+  box-sizing: border-box;
+  color: rgba(0, 0, 0, 0.3);
+  color: var(--d2h-dim-color);
+  cursor: pointer;
+  display: inline-block;
+  overflow: hidden;
+  padding: 0 0.5em;
+  position: absolute;
+  text-align: right;
+  text-overflow: ellipsis;
+  width: 4em;
+}
+.d2h-code-side-linenumber:after {
+  content: '\200b';
+}
+.d2h-code-side-emptyplaceholder,
+.d2h-emptyplaceholder {
+  background-color: #f1f1f1;
+  background-color: var(--d2h-empty-placeholder-bg-color);
+  border-color: #e1e1e1;
+  border-color: var(--d2h-empty-placeholder-border-color);
+}
+.d2h-code-line-prefix,
+.d2h-code-linenumber,
+.d2h-code-side-linenumber,
+.d2h-emptyplaceholder {
+  -webkit-user-select: none;
+  -moz-user-select: none;
+  -ms-user-select: none;
+  user-select: none;
+}
+.d2h-code-linenumber,
+.d2h-code-side-linenumber {
+  direction: rtl;
+}
+.d2h-del {
+  background-color: #fee8e9;
+  background-color: var(--d2h-del-bg-color);
+  border-color: #e9aeae;
+  border-color: var(--d2h-del-border-color);
+}
+.d2h-ins {
+  background-color: #dfd;
+  background-color: var(--d2h-ins-bg-color);
+  border-color: #b4e2b4;
+  border-color: var(--d2h-ins-border-color);
+}
+.d2h-info {
+  background-color: #f8fafd;
+  background-color: var(--d2h-info-bg-color);
+  border-color: #d5e4f2;
+  border-color: var(--d2h-info-border-color);
+  color: rgba(0, 0, 0, 0.3);
+  color: var(--d2h-dim-color);
+}
+.d2h-file-diff .d2h-del.d2h-change {
+  background-color: #fdf2d0;
+  background-color: var(--d2h-change-del-color);
+}
+.d2h-file-diff .d2h-ins.d2h-change {
+  background-color: #ded;
+  background-color: var(--d2h-change-ins-color);
+}
+.d2h-file-list-wrapper {
+  margin-bottom: 10px;
+}
+.d2h-file-list-wrapper a {
+  -webkit-text-decoration: none;
+  text-decoration: none;
+}
+.d2h-file-list-wrapper a,
+.d2h-file-list-wrapper a:visited {
+  color: #3572b0;
+  color: var(--d2h-moved-label-color);
+}
+.d2h-file-list-header {
+  text-align: left;
+}
+.d2h-file-list-title {
+  font-weight: 700;
+}
+.d2h-file-list-line {
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+  text-align: left;
+}
+.d2h-file-list {
+  display: block;
+  list-style: none;
+  margin: 0;
+  padding: 0;
+}
+.d2h-file-list > li {
+  border-bottom: 1px solid #ddd;
+  border-bottom: 1px solid var(--d2h-border-color);
+  margin: 0;
+  padding: 5px 10px;
+}
+.d2h-file-list > li:last-child {
+  border-bottom: none;
+}
+.d2h-file-switch {
+  cursor: pointer;
+  display: none;
+  font-size: 10px;
+}
+.d2h-icon {
+  margin-right: 10px;
+  vertical-align: middle;
+  fill: currentColor;
+}
+.d2h-deleted {
+  color: #c33;
+  color: var(--d2h-del-label-color);
+}
+.d2h-added {
+  color: #399839;
+  color: var(--d2h-ins-label-color);
+}
+.d2h-changed {
+  color: #d0b44c;
+  color: var(--d2h-change-label-color);
+}
+.d2h-moved {
+  color: #3572b0;
+  color: var(--d2h-moved-label-color);
+}
+.d2h-tag {
+  background-color: #fff;
+  background-color: var(--d2h-bg-color);
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+  font-size: 10px;
+  margin-left: 5px;
+  padding: 0 2px;
+}
+.d2h-deleted-tag {
+  border: 1px solid #c33;
+  border: 1px solid var(--d2h-del-label-color);
+}
+.d2h-added-tag {
+  border: 1px solid #399839;
+  border: 1px solid var(--d2h-ins-label-color);
+}
+.d2h-changed-tag {
+  border: 1px solid #d0b44c;
+  border: 1px solid var(--d2h-change-label-color);
+}
+.d2h-moved-tag {
+  border: 1px solid #3572b0;
+  border: 1px solid var(--d2h-moved-label-color);
+}
+.d2h-dark-color-scheme {
+  background-color: #0d1117;
+  background-color: var(--d2h-dark-bg-color);
+  color: #e6edf3;
+  color: var(--d2h-dark-color);
+}
+.d2h-dark-color-scheme .d2h-file-header {
+  background-color: #161b22;
+  background-color: var(--d2h-dark-file-header-bg-color);
+  border-bottom: #30363d;
+  border-bottom: var(--d2h-dark-file-header-border-color);
+}
+.d2h-dark-color-scheme .d2h-lines-added {
+  border: 1px solid rgba(46, 160, 67, 0.4);
+  border: 1px solid var(--d2h-dark-ins-border-color);
+  color: #3fb950;
+  color: var(--d2h-dark-ins-label-color);
+}
+.d2h-dark-color-scheme .d2h-lines-deleted {
+  border: 1px solid rgba(248, 81, 73, 0.4);
+  border: 1px solid var(--d2h-dark-del-border-color);
+  color: #f85149;
+  color: var(--d2h-dark-del-label-color);
+}
+.d2h-dark-color-scheme .d2h-code-line del,
+.d2h-dark-color-scheme .d2h-code-side-line del {
+  background-color: rgba(248, 81, 73, 0.4);
+  background-color: var(--d2h-dark-del-highlight-bg-color);
+}
+.d2h-dark-color-scheme .d2h-code-line ins,
+.d2h-dark-color-scheme .d2h-code-side-line ins {
+  background-color: rgba(46, 160, 67, 0.4);
+  background-color: var(--d2h-dark-ins-highlight-bg-color);
+}
+.d2h-dark-color-scheme .d2h-diff-tbody {
+  border-color: #30363d;
+  border-color: var(--d2h-dark-border-color);
+}
+.d2h-dark-color-scheme .d2h-code-side-linenumber {
+  background-color: #0d1117;
+  background-color: var(--d2h-dark-bg-color);
+  border-color: #21262d;
+  border-color: var(--d2h-dark-line-border-color);
+  color: #6e7681;
+  color: var(--d2h-dark-dim-color);
+}
+.d2h-dark-color-scheme .d2h-files-diff .d2h-code-side-emptyplaceholder,
+.d2h-dark-color-scheme .d2h-files-diff .d2h-emptyplaceholder {
+  background-color: hsla(215, 8%, 47%, 0.1);
+  background-color: var(--d2h-dark-empty-placeholder-bg-color);
+  border-color: #30363d;
+  border-color: var(--d2h-dark-empty-placeholder-border-color);
+}
+.d2h-dark-color-scheme .d2h-code-linenumber {
+  background-color: #0d1117;
+  background-color: var(--d2h-dark-bg-color);
+  border-color: #21262d;
+  border-color: var(--d2h-dark-line-border-color);
+  color: #6e7681;
+  color: var(--d2h-dark-dim-color);
+}
+.d2h-dark-color-scheme .d2h-del {
+  background-color: rgba(248, 81, 73, 0.1);
+  background-color: var(--d2h-dark-del-bg-color);
+  border-color: rgba(248, 81, 73, 0.4);
+  border-color: var(--d2h-dark-del-border-color);
+}
+.d2h-dark-color-scheme .d2h-ins {
+  background-color: rgba(46, 160, 67, 0.15);
+  background-color: var(--d2h-dark-ins-bg-color);
+  border-color: rgba(46, 160, 67, 0.4);
+  border-color: var(--d2h-dark-ins-border-color);
+}
+.d2h-dark-color-scheme .d2h-info {
+  background-color: rgba(56, 139, 253, 0.1);
+  background-color: var(--d2h-dark-info-bg-color);
+  border-color: rgba(56, 139, 253, 0.4);
+  border-color: var(--d2h-dark-info-border-color);
+  color: #6e7681;
+  color: var(--d2h-dark-dim-color);
+}
+.d2h-dark-color-scheme .d2h-file-diff .d2h-del.d2h-change {
+  background-color: rgba(210, 153, 34, 0.2);
+  background-color: var(--d2h-dark-change-del-color);
+}
+.d2h-dark-color-scheme .d2h-file-diff .d2h-ins.d2h-change {
+  background-color: rgba(46, 160, 67, 0.25);
+  background-color: var(--d2h-dark-change-ins-color);
+}
+.d2h-dark-color-scheme .d2h-file-wrapper {
+  border: 1px solid #30363d;
+  border: 1px solid var(--d2h-dark-border-color);
+}
+.d2h-dark-color-scheme .d2h-file-collapse {
+  border: 1px solid #0d1117;
+  border: 1px solid var(--d2h-dark-bg-color);
+}
+.d2h-dark-color-scheme .d2h-file-collapse.d2h-selected {
+  background-color: rgba(56, 139, 253, 0.1);
+  background-color: var(--d2h-dark-selected-color);
+}
+.d2h-dark-color-scheme .d2h-file-list-wrapper a,
+.d2h-dark-color-scheme .d2h-file-list-wrapper a:visited {
+  color: #3572b0;
+  color: var(--d2h-dark-moved-label-color);
+}
+.d2h-dark-color-scheme .d2h-file-list > li {
+  border-bottom: 1px solid #0d1117;
+  border-bottom: 1px solid var(--d2h-dark-bg-color);
+}
+.d2h-dark-color-scheme .d2h-deleted {
+  color: #f85149;
+  color: var(--d2h-dark-del-label-color);
+}
+.d2h-dark-color-scheme .d2h-added {
+  color: #3fb950;
+  color: var(--d2h-dark-ins-label-color);
+}
+.d2h-dark-color-scheme .d2h-changed {
+  color: #d29922;
+  color: var(--d2h-dark-change-label-color);
+}
+.d2h-dark-color-scheme .d2h-moved {
+  color: #3572b0;
+  color: var(--d2h-dark-moved-label-color);
+}
+.d2h-dark-color-scheme .d2h-tag {
+  background-color: #0d1117;
+  background-color: var(--d2h-dark-bg-color);
+}
+.d2h-dark-color-scheme .d2h-deleted-tag {
+  border: 1px solid #f85149;
+  border: 1px solid var(--d2h-dark-del-label-color);
+}
+.d2h-dark-color-scheme .d2h-added-tag {
+  border: 1px solid #3fb950;
+  border: 1px solid var(--d2h-dark-ins-label-color);
+}
+.d2h-dark-color-scheme .d2h-changed-tag {
+  border: 1px solid #d29922;
+  border: 1px solid var(--d2h-dark-change-label-color);
+}
+.d2h-dark-color-scheme .d2h-moved-tag {
+  border: 1px solid #3572b0;
+  border: 1px solid var(--d2h-dark-moved-label-color);
+}
+@media (prefers-color-scheme: dark) {
+  .d2h-auto-color-scheme {
+    background-color: #0d1117;
+    background-color: var(--d2h-dark-bg-color);
+    color: #e6edf3;
+    color: var(--d2h-dark-color);
+  }
+  .d2h-auto-color-scheme .d2h-file-header {
+    background-color: #161b22;
+    background-color: var(--d2h-dark-file-header-bg-color);
+    border-bottom: #30363d;
+    border-bottom: var(--d2h-dark-file-header-border-color);
+  }
+  .d2h-auto-color-scheme .d2h-lines-added {
+    border: 1px solid rgba(46, 160, 67, 0.4);
+    border: 1px solid var(--d2h-dark-ins-border-color);
+    color: #3fb950;
+    color: var(--d2h-dark-ins-label-color);
+  }
+  .d2h-auto-color-scheme .d2h-lines-deleted {
+    border: 1px solid rgba(248, 81, 73, 0.4);
+    border: 1px solid var(--d2h-dark-del-border-color);
+    color: #f85149;
+    color: var(--d2h-dark-del-label-color);
+  }
+  .d2h-auto-color-scheme .d2h-code-line del,
+  .d2h-auto-color-scheme .d2h-code-side-line del {
+    background-color: rgba(248, 81, 73, 0.4);
+    background-color: var(--d2h-dark-del-highlight-bg-color);
+  }
+  .d2h-auto-color-scheme .d2h-code-line ins,
+  .d2h-auto-color-scheme .d2h-code-side-line ins {
+    background-color: rgba(46, 160, 67, 0.4);
+    background-color: var(--d2h-dark-ins-highlight-bg-color);
+  }
+  .d2h-auto-color-scheme .d2h-diff-tbody {
+    border-color: #30363d;
+    border-color: var(--d2h-dark-border-color);
+  }
+  .d2h-auto-color-scheme .d2h-code-side-linenumber {
+    background-color: #0d1117;
+    background-color: var(--d2h-dark-bg-color);
+    border-color: #21262d;
+    border-color: var(--d2h-dark-line-border-color);
+    color: #6e7681;
+    color: var(--d2h-dark-dim-color);
+  }
+  .d2h-auto-color-scheme .d2h-files-diff .d2h-code-side-emptyplaceholder,
+  .d2h-auto-color-scheme .d2h-files-diff .d2h-emptyplaceholder {
+    background-color: hsla(215, 8%, 47%, 0.1);
+    background-color: var(--d2h-dark-empty-placeholder-bg-color);
+    border-color: #30363d;
+    border-color: var(--d2h-dark-empty-placeholder-border-color);
+  }
+  .d2h-auto-color-scheme .d2h-code-linenumber {
+    background-color: #0d1117;
+    background-color: var(--d2h-dark-bg-color);
+    border-color: #21262d;
+    border-color: var(--d2h-dark-line-border-color);
+    color: #6e7681;
+    color: var(--d2h-dark-dim-color);
+  }
+  .d2h-auto-color-scheme .d2h-del {
+    background-color: rgba(248, 81, 73, 0.1);
+    background-color: var(--d2h-dark-del-bg-color);
+    border-color: rgba(248, 81, 73, 0.4);
+    border-color: var(--d2h-dark-del-border-color);
+  }
+  .d2h-auto-color-scheme .d2h-ins {
+    background-color: rgba(46, 160, 67, 0.15);
+    background-color: var(--d2h-dark-ins-bg-color);
+    border-color: rgba(46, 160, 67, 0.4);
+    border-color: var(--d2h-dark-ins-border-color);
+  }
+  .d2h-auto-color-scheme .d2h-info {
+    background-color: rgba(56, 139, 253, 0.1);
+    background-color: var(--d2h-dark-info-bg-color);
+    border-color: rgba(56, 139, 253, 0.4);
+    border-color: var(--d2h-dark-info-border-color);
+    color: #6e7681;
+    color: var(--d2h-dark-dim-color);
+  }
+  .d2h-auto-color-scheme .d2h-file-diff .d2h-del.d2h-change {
+    background-color: rgba(210, 153, 34, 0.2);
+    background-color: var(--d2h-dark-change-del-color);
+  }
+  .d2h-auto-color-scheme .d2h-file-diff .d2h-ins.d2h-change {
+    background-color: rgba(46, 160, 67, 0.25);
+    background-color: var(--d2h-dark-change-ins-color);
+  }
+  .d2h-auto-color-scheme .d2h-file-wrapper {
+    border: 1px solid #30363d;
+    border: 1px solid var(--d2h-dark-border-color);
+  }
+  .d2h-auto-color-scheme .d2h-file-collapse {
+    border: 1px solid #0d1117;
+    border: 1px solid var(--d2h-dark-bg-color);
+  }
+  .d2h-auto-color-scheme .d2h-file-collapse.d2h-selected {
+    background-color: rgba(56, 139, 253, 0.1);
+    background-color: var(--d2h-dark-selected-color);
+  }
+  .d2h-auto-color-scheme .d2h-file-list-wrapper a,
+  .d2h-auto-color-scheme .d2h-file-list-wrapper a:visited {
+    color: #3572b0;
+    color: var(--d2h-dark-moved-label-color);
+  }
+  .d2h-auto-color-scheme .d2h-file-list > li {
+    border-bottom: 1px solid #0d1117;
+    border-bottom: 1px solid var(--d2h-dark-bg-color);
+  }
+  .d2h-dark-color-scheme .d2h-deleted {
+    color: #f85149;
+    color: var(--d2h-dark-del-label-color);
+  }
+  .d2h-auto-color-scheme .d2h-added {
+    color: #3fb950;
+    color: var(--d2h-dark-ins-label-color);
+  }
+  .d2h-auto-color-scheme .d2h-changed {
+    color: #d29922;
+    color: var(--d2h-dark-change-label-color);
+  }
+  .d2h-auto-color-scheme .d2h-moved {
+    color: #3572b0;
+    color: var(--d2h-dark-moved-label-color);
+  }
+  .d2h-auto-color-scheme .d2h-tag {
+    background-color: #0d1117;
+    background-color: var(--d2h-dark-bg-color);
+  }
+  .d2h-auto-color-scheme .d2h-deleted-tag {
+    border: 1px solid #f85149;
+    border: 1px solid var(--d2h-dark-del-label-color);
+  }
+  .d2h-auto-color-scheme .d2h-added-tag {
+    border: 1px solid #3fb950;
+    border: 1px solid var(--d2h-dark-ins-label-color);
+  }
+  .d2h-auto-color-scheme .d2h-changed-tag {
+    border: 1px solid #d29922;
+    border: 1px solid var(--d2h-dark-change-label-color);
+  }
+  .d2h-auto-color-scheme .d2h-moved-tag {
+    border: 1px solid #3572b0;
+    border: 1px solid var(--d2h-dark-moved-label-color);
+  }
+}

packages/bruno-app/src/components/ApiSpecPanel/FileEditor/CodeEditor/StyledWrapper.js

@@ -2,10 +2,11 @@ import styled from 'styled-components';
 
 const StyledWrapper = styled.div`
   div.CodeMirror {
-    height: calc(100vh - 4rem);
+    height: calc(100vh - 9rem);
     background: ${(props) => props.theme.codemirror.bg};
     border: solid 1px ${(props) => props.theme.codemirror.border};
     font-family: ${(props) => (props.font ? props.font : 'default')};
+    font-size: ${(props) => props.theme.font.size.base};
     line-break: anywhere;
   }
 

packages/bruno-app/src/components/ApiSpecPanel/FileEditor/index.js

@@ -1,51 +0,0 @@
-import get from 'lodash/get';
-import { useTheme } from 'providers/Theme';
-import { useDispatch, useSelector } from 'react-redux';
-import CodeEditor from './CodeEditor/index';
-import { IconDeviceFloppy } from '@tabler/icons';
-import { saveApiSpecToFile } from 'providers/ReduxStore/slices/apiSpec';
-import { useState } from 'react';
-
-const FileEditor = ({ apiSpec }) => {
-  const dispatch = useDispatch();
-  const { displayedTheme, theme } = useTheme();
-  const preferences = useSelector((state) => state.app.preferences);
-
-  const [content, setContent] = useState(apiSpec?.raw);
-
-  const onEdit = (value) => {
-    setContent(value);
-  };
-
-  const onSave = () => {
-    dispatch(saveApiSpecToFile({ uid: apiSpec?.uid, content }));
-  };
-
-  const hasChanges = Boolean(content != apiSpec?.raw);
-
-  const editorMode = 'yaml';
-
-  return (
-    <div className="flex flex-grow relative">
-      <CodeEditor
-        theme={displayedTheme}
-        value={content}
-        onEdit={onEdit}
-        onSave={onSave}
-        mode={editorMode}
-        font={get(preferences, 'font.codeFont', 'default')}
-      />
-      <IconDeviceFloppy
-        onClick={onSave}
-        color={hasChanges ? theme.draftColor : theme.requestTabs.icon.color}
-        strokeWidth={1.5}
-        size={22}
-        className={`absolute right-0 top-0 m-4 ${
-          hasChanges ? 'cursor-pointer oapcity-100' : 'cursor-default opacity-50'
-        }`}
-      />
-    </div>
-  );
-};
-
-export default FileEditor;

packages/bruno-app/src/components/ApiSpecPanel/Renderers/Swagger/StyledWrapper.js

@@ -2,15 +2,868 @@ import styled from 'styled-components';
 
 const StyledWrapper = styled.div`
   .swagger-root {
-    height: calc(100vh - 4rem);
-    border: solid 1px ${(props) => props.theme.codemirror.border};
+    height: calc(100vh - 7rem);
+    border-left: solid 1px ${(props) => props.theme.border.border1};
+    overflow-y: auto;
+    background: ${(props) => props.theme.bg};
+    padding-bottom: 20px;
 
-    &.dark {
-      .swagger-ui {
-        filter: invert(88%) hue-rotate(180deg);
+    /* ── Global reset ── */
+    .swagger-ui {
+      font-family: inherit;
+      font-size: ${(props) => props.theme.font.size.base};
+      color: ${(props) => props.theme.text};
+
+      * {
+        border-color: ${(props) => props.theme.border.border1};
       }
-      .swagger-ui .microlight {
-        filter: invert(100%) hue-rotate(180deg);
+
+      .auth-container {
+        padding: 0;
+      }
+
+      select {
+        box-shadow: none !important;
+      }
+
+      .wrapper {
+        padding: 0 20px;
+        max-width: none;
+      }
+
+      /* ── Info section ── */
+      .info {
+        margin: 16px 0 12px;
+
+        hgroup.main {
+          margin: 0;
+        }
+
+        .title {
+          font-size: 16px;
+          font-weight: 600;
+          color: ${(props) => props.theme.text};
+
+          small {
+            padding: 2px 6px !important;
+            font-size: 10px;
+            vertical-align: middle;
+            border-radius: 3px;
+
+            pre {
+              color: ${(props) => props.theme.text} !important;
+              font-size: 10px;
+            }
+          }
+        }
+
+        .base-url {
+          font-size: ${(props) => props.theme.font.size.xs};
+          color: ${(props) => props.theme.colors.text.muted};
+        }
+
+        .description {
+          font-size: ${(props) => props.theme.font.size.sm};
+          color: ${(props) => props.theme.colors.text.muted};
+
+          p, li {
+            font-size: ${(props) => props.theme.font.size.sm};
+            color: ${(props) => props.theme.colors.text.muted};
+            margin: 3px 0;
+            line-height: 1.5;
+          }
+
+          h1, h2, h3, h4, h5, h6 {
+            color: ${(props) => props.theme.text};
+          }
+
+          a {
+            color: ${(props) => props.theme.textLink};
+          }
+        }
+      }
+
+      /* Version / OAS badges */
+      .version-stamp span.version {
+        background: ${(props) => props.theme.border.border1} !important;
+        border: 1px solid ${(props) => props.theme.colors.text.muted} !important;
+        color: ${(props) => props.theme.text} !important;
+        font-size: 9px;
+        padding: 2px 6px;
+        border-radius: 3px;
+      }
+
+      .version-pragma {
+        font-size: ${(props) => props.theme.font.size.xs};
+        color: ${(props) => props.theme.colors.text.muted};
+      }
+
+      /* ── Tag section headings ── */
+      .opblock-tag-section {
+        .opblock-tag {
+          font-size: ${(props) => props.theme.font.size.md};
+          color: ${(props) => props.theme.text};
+          border-bottom: none;
+          padding: 0;
+
+          &:hover {
+            background: ${(props) => props.theme.background.mantle};
+          }
+
+          a {
+            color: ${(props) => props.theme.text} !important;
+          }
+
+          small {
+            font-size: ${(props) => props.theme.font.size.xs};
+            color: ${(props) => props.theme.colors.text.muted};
+            padding: 0 10px;
+          }
+        }
+      }
+
+      /* ── Operation blocks (GET, POST, PUT, DELETE, PATCH) ── */
+      .opblock {
+        margin: 0 0 8px;
+        border-radius: 4px;
+        border: 1px solid ${(props) => props.theme.border.border1} !important;
+        background: ${(props) => props.theme.bg} !important;
+        box-shadow: none !important;
+
+        .opblock-summary {
+          padding: 6px 10px;
+          border: none !important;
+          background: transparent !important;
+
+          .opblock-summary-method {
+            font-size: 10px;
+            font-weight: 700;
+            padding: 3px 8px;
+            min-width: 50px;
+            text-align: center;
+            border-radius: 3px;
+          }
+
+          .opblock-summary-path {
+            font-size: ${(props) => props.theme.font.size.sm};
+
+            a, span {
+              color: ${(props) => props.theme.text} !important;
+            }
+          }
+
+          .opblock-summary-description {
+            font-size: ${(props) => props.theme.font.size.xs};
+            color: ${(props) => props.theme.colors.text.muted};
+          }
+
+          .opblock-summary-control {
+            svg {
+              fill: ${(props) => props.theme.colors.text.muted};
+              width: 14px;
+              height: 14px;
+            }
+          }
+        }
+
+        .opblock-body {
+          font-size: ${(props) => props.theme.font.size.sm};
+          color: ${(props) => props.theme.text};
+          background: ${(props) => props.theme.bg};
+          border-top: 1px solid ${(props) => props.theme.border.border1};
+
+          .opblock-description-wrapper,
+          .opblock-section {
+            p {
+              color: ${(props) => props.theme.colors.text.muted};
+              font-size: ${(props) => props.theme.font.size.sm};
+            }
+          }
+
+          .tab-header .tab-item {
+            color: ${(props) => props.theme.colors.text.muted};
+
+            &.active {
+              color: ${(props) => props.theme.text};
+            }
+          }
+
+          select {
+            color: ${(props) => props.theme.text};
+            background: ${(props) => props.theme.bg};
+            border: 1px solid ${(props) => props.theme.border.border1};
+            border-radius: 3px;
+            font-size: ${(props) => props.theme.font.size.xs};
+            padding: 2px 6px;
+          }
+
+          input[type="text"] {
+            color: ${(props) => props.theme.text};
+            background: ${(props) => props.theme.bg};
+            border: 1px solid ${(props) => props.theme.border.border1};
+            border-radius: 3px;
+            font-size: ${(props) => props.theme.font.size.sm};
+          }
+        }
+      }
+
+      /* Method badge colors — keep them but tone down */
+      .opblock.opblock-get .opblock-summary-method { background: #61affe; color: #fff; }
+      .opblock.opblock-post .opblock-summary-method { background: #49cc90; color: #fff; }
+      .opblock.opblock-put .opblock-summary-method { background: #fca130; color: #fff; }
+      .opblock.opblock-delete .opblock-summary-method { background: #f93e3e; color: #fff; }
+      .opblock.opblock-patch .opblock-summary-method { background: #50e3c2; color: #000; }
+
+      /* Lock / authorization icons */
+      .authorization__btn {
+
+        svg {
+          fill: ${(props) => props.theme.colors.text.muted};
+          width: 14px;
+          height: 14px;
+        }
+      }
+
+      /* ── Tables ── */
+      table {
+        font-size: ${(props) => props.theme.font.size.sm};
+
+        thead {
+          tr {
+            th {
+              font-size: ${(props) => props.theme.font.size.xs} !important;
+              color: ${(props) => props.theme.colors.text.muted} !important;
+              border-bottom: 1px solid ${(props) => props.theme.border.border1} !important;
+              padding: 6px 0;
+            }
+          }
+        }
+
+        td {
+          padding: 6px 0;
+          border-bottom: 1px solid ${(props) => props.theme.border.border1};
+          color: ${(props) => props.theme.text};
+        }
+      }
+
+      .parameter__name {
+        font-size: ${(props) => props.theme.font.size.sm};
+        color: ${(props) => props.theme.text};
+
+        &.required::after {
+          color: ${(props) => props.theme.colors.text.danger || '#c0392b'};
+          font-size: ${(props) => props.theme.font.size.xs};
+        }
+      }
+
+      .parameter__type {
+        font-size: ${(props) => props.theme.font.size.xs};
+        color: ${(props) => props.theme.colors.text.muted};
+      }
+
+      .parameter__in {
+        font-size: ${(props) => props.theme.font.size.xs};
+        color: ${(props) => props.theme.colors.text.muted};
+      }
+
+      /* ── Models / Schemas ── */
+      section.models {
+        border: 1px solid ${(props) => props.theme.border.border1};
+        border-radius: 4px;
+        background: ${(props) => props.theme.bg};
+        padding-bottom: 0px;
+        margin-bottom: 40px;
+        margin-top: 8px;
+
+        h4 {
+          font-size: ${(props) => props.theme.font.size.sm};
+          color: ${(props) => props.theme.text};
+          border-bottom: none;
+          padding: 6px 10px;
+          margin: 0;
+
+          svg {
+            fill: ${(props) => props.theme.colors.text.muted};
+            width: 16px;
+            height: 16px;
+          }
+        }
+
+        .model-container {
+          background: ${(props) => props.theme.bg} !important;
+          margin: 0;
+          padding: 4px 8px;
+          border-bottom: 1px solid ${(props) => props.theme.border.border1};
+
+          &:last-child {
+            border-bottom: none;
+          }
+
+          .model-box {
+            background: ${(props) => props.theme.bg} !important;
+            padding: 2px 0;
+          }
+        }
+      }
+
+      .model {
+        font-size: 11px;
+        color: ${(props) => props.theme.text};
+        line-height: 1.4;
+
+        .prop-type {
+          color: ${(props) => props.theme.textLink};
+          font-size: 11px;
+        }
+
+        .prop-format {
+          color: ${(props) => props.theme.colors.text.muted};
+          font-size: 10px;
+        }
+
+        span.prop-enum {
+          display: block;
+          color: ${(props) => props.theme.colors.text.muted};
+          font-size: 10px;
+        }
+      }
+
+      .model-example {
+
+        .tab li {
+          color: ${(props) => props.theme.colors.text.muted} !important;
+        }
+      }
+
+      /* Model expand/collapse toggle */
+      .model-toggle {
+        cursor: pointer;
+        font-size: 10px;
+        color: ${(props) => props.theme.colors.text.muted};
+
+        &::after {
+          color: ${(props) => props.theme.colors.text.muted};
+        }
+      }
+
+      /* Model box inner styling */
+      .model-box {
+        background: ${(props) => props.theme.bg} !important;
+        color: ${(props) => props.theme.text};
+      }
+
+      /* Inner model details */
+      .inner-object {
+        color: ${(props) => props.theme.text};
+      }
+
+      /* Model title (schema name) */
+      .model-title {
+        color: ${(props) => props.theme.text};
+        font-size: 12px;
+        font-weight: 600;
+      }
+
+      /* ── JSON Schema 2020-12 (OpenAPI 3.1) schema overrides ── */
+      .json-schema-2020-12-accordion,
+      .json-schema-2020-12-expand-deep-button,
+      section.models h4 button,
+      .model-box button,
+      .models-control,
+      .opblock-summary,
+      .opblock-summary-control,
+      .opblock-tag {
+        outline: none !important;
+        box-shadow: none !important;
+      }
+
+      button:focus-visible,
+      .opblock-summary:focus-visible,
+      .opblock-tag:focus-visible,
+      .models-control:focus-visible {
+        outline: 2px solid ${(props) => props.theme.textLink} !important;
+        outline-offset: 2px;
+      }
+
+      .json-schema-2020-12__title {
+        font-size: 12px !important;
+        font-weight: 600;
+        color: ${(props) => props.theme.text} !important;
+      }
+
+      .json-schema-2020-12-head {
+        padding: 4px 8px !important;
+        background: ${(props) => props.theme.bg} !important;
+
+        .json-schema-2020-12-accordion {
+          padding: 0 !important;
+          color: ${(props) => props.theme.text} !important;
+          background: transparent !important;
+        }
+
+        /* chevron / arrow icon */
+        .json-schema-2020-12-accordion__icon {
+          fill: ${(props) => props.theme.colors.text.muted} !important;
+        }
+
+        button.json-schema-2020-12-expand-deep-button {
+          font-size: 10px !important;
+          color: ${(props) => props.theme.colors.text.muted} !important;
+          background: transparent !important;
+          padding: 0 4px !important;
+        }
+
+        strong.json-schema-2020-12__attribute--primary {
+          font-size: 11px !important;
+          color: ${(props) => props.theme.textLink} !important;
+          font-weight: normal;
+        }
+      }
+
+      .json-schema-2020-12-body {
+        font-size: 11px !important;
+        margin-left: 16px;
+        color: ${(props) => props.theme.text} !important;
+
+        .json-schema-2020-12-property {
+          margin-left: 8px;
+          color: ${(props) => props.theme.text} !important;
+          border-color: ${(props) => props.theme.border.border1} !important;
+        }
+
+        /* property names */
+        .json-schema-2020-12__title {
+          font-size: 11px !important;
+          font-weight: normal;
+          color: ${(props) => props.theme.text} !important;
+        }
+
+        /* type badges inside expanded schema */
+        strong.json-schema-2020-12__attribute--primary {
+          font-size: 10px !important;
+          color: ${(props) => props.theme.textLink} !important;
+          font-weight: normal;
+        }
+
+        strong.json-schema-2020-12__attribute {
+          font-size: 10px !important;
+          color: ${(props) => props.theme.colors.text.muted} !important;
+          font-weight: normal;
+        }
+      }
+
+      .json-schema-2020-12 {
+        font-size: 11px !important;
+        margin: 0 !important;
+        width: 100%;
+        height: 100%;
+        color: ${(props) => props.theme.text} !important;
+        background: ${(props) => props.theme.bg} !important;
+      }
+
+      /* JSON viewer (Examples section inside schema properties) */
+      .json-schema-2020-12-json-viewer {
+        background: transparent !important;
+        color: ${(props) => props.theme.text} !important;
+      }
+
+      .json-schema-2020-12-json-viewer__name {
+        color: ${(props) => props.theme.text} !important;
+      }
+
+      .json-schema-2020-12-json-viewer__name--secondary {
+        color: ${(props) => props.theme.colors.text.muted} !important;
+        font-weight: normal !important;
+      }
+
+      .json-schema-2020-12-json-viewer__value {
+        color: ${(props) => props.theme.text} !important;
+      }
+
+      .json-schema-2020-12-json-viewer__value--secondary {
+        color: ${(props) => props.theme.colors.text.subtext0} !important;
+      }
+
+      .json-schema-2020-12-json-viewer__value--string,
+      .json-schema-2020-12-json-viewer__value--string.json-schema-2020-12-json-viewer__value--secondary {
+        color: ${(props) => props.theme.colors.text.green} !important;
+      }
+
+      .json-schema-2020-12-json-viewer__value--number,
+      .json-schema-2020-12-json-viewer__value--bigint,
+      .json-schema-2020-12-json-viewer__value--number.json-schema-2020-12-json-viewer__value--secondary,
+      .json-schema-2020-12-json-viewer__value--bigint.json-schema-2020-12-json-viewer__value--secondary {
+        color: ${(props) => props.theme.textLink} !important;
+      }
+
+      .json-schema-2020-12-json-viewer__value--boolean,
+      .json-schema-2020-12-json-viewer__value--boolean.json-schema-2020-12-json-viewer__value--secondary {
+        color: ${(props) => props.theme.colors.text.warning} !important;
+      }
+
+      .json-schema-2020-12-json-viewer__value--null,
+      .json-schema-2020-12-json-viewer__value--undefined {
+        color: ${(props) => props.theme.colors.text.muted} !important;
+      }
+
+      /* enum/keyword example values container */
+      .json-schema-2020-12-keyword--examples,
+      [data-json-schema-keyword="examples"] {
+        color: ${(props) => props.theme.text} !important;
+      }
+
+      /* Model collapse/expand all link */
+      span.model-toggle {
+        color: ${(props) => props.theme.colors.text.muted};
+        font-size: 10px;
+      }
+
+      /* Brace styling in models */
+      .brace-open, .brace-close {
+        color: ${(props) => props.theme.colors.text.muted};
+        font-size: 11px;
+      }
+
+      /* ── Code / Response blocks ── */
+      .microlight {
+        background: ${(props) => props.theme.codemirror.bg} !important;
+        color: ${(props) => props.theme.text} !important;
+        font-size: ${(props) => props.theme.font.size.xs};
+        border-radius: 4px;
+        padding: 8px;
+        border: 1px solid ${(props) => props.theme.border.border1};
+      }
+
+      .highlight-code {
+        background: ${(props) => props.theme.codemirror.bg} !important;
+
+        > .microlight {
+          border: none;
+        }
+      }
+
+      pre {
+        color: ${(props) => props.theme.text};
+        font-size: ${(props) => props.theme.font.size.xs};
+        border-radius: 4px;
+      }
+
+      .response-col_status {
+        font-size: ${(props) => props.theme.font.size.sm};
+        color: ${(props) => props.theme.text};
+      }
+
+      .response-col_description {
+        font-size: ${(props) => props.theme.font.size.sm};
+        color: ${(props) => props.theme.colors.text.muted};
+      }
+
+      .responses-inner {
+        h4, h5 {
+          font-size: ${(props) => props.theme.font.size.sm};
+          color: ${(props) => props.theme.text};
+        }
+      }
+
+      /* ── Buttons ── */
+      .btn {
+        font-size: ${(props) => props.theme.font.size.xs};
+        border-radius: 4px;
+        box-shadow: none !important;
+        color: ${(props) => props.theme.text};
+        border-color: ${(props) => props.theme.border.border1};
+        background: transparent;
+      }
+
+      .btn.authorize {
+        color: ${(props) => props.theme.text};
+        border-color: ${(props) => props.theme.border.border1};
+        background: transparent;
+
+        svg {
+          fill: ${(props) => props.theme.text};
+        }
+
+        span {
+          color: ${(props) => props.theme.text};
+        }
+      }
+
+      .btn.execute {
+        background: ${(props) => props.theme.primary?.solid || props.theme.textLink};
+        color: #fff;
+        border-color: transparent;
+      }
+
+      .btn-group {
+        .btn {
+          background: ${(props) => props.theme.bg};
+          color: ${(props) => props.theme.text};
+        }
+      }
+
+      /* ── Links ── */
+      a {
+        color: ${(props) => props.theme.textLink};
+      }
+
+      /* ── Servers / Scheme container ── */
+      .scheme-container {
+        background: ${(props) => props.theme.background.mantle} !important;
+        border-top: 1px solid ${(props) => props.theme.border.border1};
+        border-bottom: 1px solid ${(props) => props.theme.border.border1};
+        padding: 10px;
+        box-shadow: none !important;
+
+        .schemes-title {
+          font-size: ${(props) => props.theme.font.size.sm};
+          color: ${(props) => props.theme.colors.text.muted};
+        }
+
+        label {
+          font-size: ${(props) => props.theme.font.size.sm};
+          color: ${(props) => props.theme.colors.text.muted};
+        }
+
+        select {
+          font-size: ${(props) => props.theme.font.size.sm};
+          color: ${(props) => props.theme.text};
+          background: ${(props) => props.theme.bg};
+          border: 1px solid ${(props) => props.theme.border.border1};
+          border-radius: 4px;
+          padding: 4px 8px;
+        }
+      }
+
+      /* ── SVGs / icons ── */
+      svg {
+        fill: ${(props) => props.theme.colors.text.muted};
+      }
+
+      svg.arrow {
+        fill: ${(props) => props.theme.text};
+        width: 12px;
+        height: 12px;
+        margin-left: 4px;
+      }
+
+      .expand-operation svg {
+        fill: ${(props) => props.theme.colors.text.muted};
+        width: 14px;
+        height: 14px;
+      }
+
+      /* ── Misc / catch-all ── */
+      .loading-container .loading::after {
+        color: ${(props) => props.theme.colors.text.muted};
+        font-size: ${(props) => props.theme.font.size.sm};
+      }
+
+      .renderedMarkdown p {
+        color: ${(props) => props.theme.colors.text.muted};
+        font-size: ${(props) => props.theme.font.size.sm};
+      }
+
+      .opblock-section-header {
+        background: ${(props) => props.theme.background.mantle} !important;
+        box-shadow: none !important;
+        border-bottom: 1px solid ${(props) => props.theme.border.border1};
+        padding: 6px 10px;
+
+        h4 {
+          font-size: ${(props) => props.theme.font.size.sm};
+          color: ${(props) => props.theme.text};
+        }
+
+        label {
+          font-size: ${(props) => props.theme.font.size.xs};
+          color: ${(props) => props.theme.colors.text.muted};
+        }
+      }
+
+      .copy-to-clipboard {
+        button {
+          background: ${(props) => props.theme.background.mantle};
+          border: 1px solid ${(props) => props.theme.border.border1};
+          border-radius: 3px;
+        }
+      }
+
+      /* Dialog / modal overrides */
+      .dialog-ux {
+        .modal-ux {
+          background: ${(props) => props.theme.bg};
+          border: 1px solid ${(props) => props.theme.border.border1};
+          border-radius: 6px;
+          color: ${(props) => props.theme.text};
+          box-shadow: 0 8px 32px rgba(0,0,0,0.4);
+
+          .modal-ux-header {
+            border-bottom: 1px solid ${(props) => props.theme.border.border1};
+            padding: 12px 0px;
+
+            h3 {
+              font-size: ${(props) => props.theme.font.size.md};
+              font-weight: 600;
+              color: ${(props) => props.theme.text};
+            }
+
+            .close-modal {
+              opacity: 0.6;
+              &:hover { opacity: 1; }
+              svg { fill: ${(props) => props.theme.text}; }
+            }
+          }
+
+          .modal-ux-content {
+            color: ${(props) => props.theme.text};
+            padding: 12px 16px;
+
+            p {
+              font-size: ${(props) => props.theme.font.size.sm};
+              color: ${(props) => props.theme.colors.text.muted};
+            }
+
+            /* Section headings like "api_key (apiKey)" */
+            h4, h5, h6 {
+              font-size: ${(props) => props.theme.font.size.sm};
+              font-weight: 600;
+              color: ${(props) => props.theme.textLink};
+              margin: 12px 0 6px;
+            }
+
+            /* Labels: "Name:", "In:", "Flow:", "Value:", etc. */
+            label {
+              font-size: ${(props) => props.theme.font.size.sm};
+              color: ${(props) => props.theme.text};
+
+              > span {
+                font-size: ${(props) => props.theme.font.size.sm};
+                color: ${(props) => props.theme.colors.text.muted};
+              }
+            }
+
+            /* "Scopes:" heading */
+            .scopes h2 {
+              font-size: ${(props) => props.theme.font.size.sm} !important;
+              font-weight: 500;
+              color: ${(props) => props.theme.text} !important;
+            }
+
+            /* Scope item name + description */
+            .scopes .checkbox {
+              p.name {
+                font-size: ${(props) => props.theme.font.size.sm} !important;
+                color: ${(props) => props.theme.text} !important;
+                font-weight: 500;
+                margin: 0;
+              }
+
+              p.description {
+                font-size: ${(props) => props.theme.font.size.xs} !important;
+                color: ${(props) => props.theme.colors.text.muted} !important;
+                margin: 0;
+              }
+            }
+
+            /* Text inputs */
+            input[type="text"],
+            input[type="password"],
+            input[type="email"] {
+              background: ${(props) => props.theme.background.mantle} !important;
+              color: ${(props) => props.theme.text} !important;
+              border: 1px solid ${(props) => props.theme.border.border1} !important;
+              border-radius: 4px !important;
+              font-size: ${(props) => props.theme.font.size.sm} !important;
+              padding: 6px 10px !important;
+              outline: none !important;
+              box-shadow: none !important;
+
+              &:focus {
+                border-color: ${(props) => props.theme.textLink} !important;
+                outline: none !important;
+                box-shadow: none !important;
+              }
+            }
+
+            /* Checkboxes — custom styled to match theme */
+            input[type="checkbox"] {
+              appearance: none !important;
+              -webkit-appearance: none !important;
+              width: 14px !important;
+              height: 14px !important;
+              min-width: 14px;
+              border: 1px solid ${(props) => props.theme.border.border1} !important;
+              border-radius: 3px !important;
+              background: ${(props) => props.theme.background.mantle} !important;
+              cursor: pointer;
+              position: relative;
+              vertical-align: middle;
+
+              &:checked {
+                background: ${(props) => props.theme.textLink} !important;
+                border-color: ${(props) => props.theme.textLink} !important;
+
+                &::after {
+                  content: '';
+                  position: absolute;
+                  left: 3px;
+                  top: 1px;
+                  width: 5px;
+                  height: 8px;
+                  border: 2px solid #fff;
+                  border-top: none;
+                  border-left: none;
+                  transform: rotate(45deg);
+                }
+              }
+            }
+
+            /* "select all / select none" links */
+            a {
+              font-size: ${(props) => props.theme.font.size.xs};
+              color: ${(props) => props.theme.textLink};
+            }
+
+            /* Dividers between auth sections */
+            hr {
+              border-color: ${(props) => props.theme.border.border1};
+              margin: 12px 0;
+            }
+
+            /* Authorize / Close buttons */
+            .btn-done,
+            .auth-btn-wrapper .btn {
+              font-size: ${(props) => props.theme.font.size.sm};
+              border-radius: 4px;
+              padding: 6px 16px;
+              border: 1px solid ${(props) => props.theme.border.border1};
+              background: transparent;
+              color: ${(props) => props.theme.text};
+              cursor: pointer;
+              outline: none !important;
+              box-shadow: none !important;
+
+              &:hover {
+                background: ${(props) => props.theme.background.mantle};
+              }
+
+              &.modal-btn-operation {
+                background: ${(props) => props.theme.textLink};
+                color: #fff;
+                border-color: transparent;
+
+                &:hover {
+                  opacity: 0.9;
+                }
+              }
+            }
+          }
+        }
+
+        .backdrop-ux {
+          background: rgba(0, 0, 0, 0.5);
+        }
       }
     }
   }

packages/bruno-app/src/components/ApiSpecPanel/Renderers/Swagger/index.js

@@ -1,16 +1,11 @@
 import SwaggerUI from 'swagger-ui-react';
 import StyledWrapper from './StyledWrapper';
-import { useTheme } from 'providers/Theme';
-
-const Swagger = ({ string }) => {
-  const { displayedTheme } = useTheme();
-
-  console.log('string', string);
 
+const Swagger = ({ spec }) => {
   return (
     <StyledWrapper>
-      <div className={`swagger-root w-full overflow-y-scroll ${displayedTheme}`}>
-        <SwaggerUI spec={string} />
+      <div className="swagger-root w-full">
+        <SwaggerUI spec={spec} />
       </div>
     </StyledWrapper>
   );

packages/bruno-app/src/components/ApiSpecPanel/SpecViewer.js

@@ -0,0 +1,71 @@
+import React, { useState, useEffect, Suspense } from 'react';
+import get from 'lodash/get';
+import { useTheme } from 'providers/Theme';
+import { useSelector } from 'react-redux';
+import { IconDeviceFloppy } from '@tabler/icons';
+import CodeEditor from './FileEditor/CodeEditor/index';
+import Swagger from './Renderers/Swagger';
+
+/**
+ * Shared split-pane spec viewer: CodeEditor (left) + Swagger preview (right).
+ *
+ * Props:
+ *  - content    (string)   The spec content (YAML/JSON string)
+ *  - readOnly   (boolean)  If true, editor is not editable and save icon is hidden
+ *  - onSave     (function) Called with current editor content on save (editable mode only)
+ */
+const SpecViewer = ({ content, readOnly, onSave }) => {
+  const { displayedTheme, theme } = useTheme();
+  const preferences = useSelector((state) => state.app.preferences);
+
+  const [editorContent, setEditorContent] = useState(content);
+
+  // Sync editor when saved content changes from outside (e.g. after save completes)
+  useEffect(() => {
+    setEditorContent(content);
+  }, [content]);
+
+  const hasChanges = !readOnly && editorContent !== content;
+
+  const handleSave = () => {
+    if (onSave) onSave(editorContent);
+  };
+
+  return (
+    <section className="main flex flex-grow pl-4 relative">
+      <div className="w-full grid grid-cols-2">
+        <div className="col-span-1">
+          <div className="flex flex-grow relative">
+            <CodeEditor
+              theme={displayedTheme}
+              value={readOnly ? content : editorContent}
+              readOnly={readOnly ? 'nocursor' : false}
+              onEdit={readOnly ? undefined : (val) => setEditorContent(val)}
+              onSave={readOnly ? undefined : handleSave}
+              mode="yaml"
+              font={get(preferences, 'font.codeFont', 'default')}
+            />
+            {!readOnly && onSave && (
+              <IconDeviceFloppy
+                onClick={handleSave}
+                color={hasChanges ? theme.draftColor : theme.requestTabs.icon.color}
+                strokeWidth={1.5}
+                size={22}
+                className={`absolute right-0 top-0 m-4 ${
+                  hasChanges ? 'cursor-pointer opacity-100' : 'cursor-default opacity-50'
+                }`}
+              />
+            )}
+          </div>
+        </div>
+        <div className="col-span-1">
+          <Suspense fallback="">
+            <Swagger spec={content} />
+          </Suspense>
+        </div>
+      </div>
+    </section>
+  );
+};
+
+export default SpecViewer;

packages/bruno-app/src/components/ApiSpecPanel/index.js

@@ -3,13 +3,11 @@ import find from 'lodash/find';
 import { useSelector, useDispatch } from 'react-redux';
 import { IconFileCode, IconDots } from '@tabler/icons';
 import StyledWrapper from './StyledWrapper';
-import FileEditor from './FileEditor';
+import SpecViewer from './SpecViewer';
 import Dropdown from 'components/Dropdown';
-import { openApiSpec } from 'providers/ReduxStore/slices/apiSpec';
+import { openApiSpec, saveApiSpecToFile } from 'providers/ReduxStore/slices/apiSpec';
 import { useState } from 'react';
 import CreateApiSpec from 'components/Sidebar/ApiSpecs/CreateApiSpec';
-import { Suspense } from 'react';
-import Swagger from './Renderers/Swagger';
 import toast from 'react-hot-toast';
 
 const ApiSpecPanel = () => {
@@ -78,18 +76,10 @@ const ApiSpecPanel = () => {
           </Dropdown>
         </div>
       </div>
-      <section className="main flex flex-grow px-4 relative">
-        <div className="w-full grid grid-cols-2">
-          <div className="col-span-1">
-            <FileEditor apiSpec={apiSpec} />
-          </div>
-          <div className="col-span-1">
-            <Suspense fallback="">
-              <Swagger string={raw} />
-            </Suspense>
-          </div>
-        </div>
-      </section>
+      <SpecViewer
+        content={raw}
+        onSave={(content) => dispatch(saveApiSpecToFile({ uid, content }))}
+      />
     </StyledWrapper>
   );
 };

packages/bruno-app/src/components/AppTitleBar/AppMenu/StyledWrapper.js

@@ -0,0 +1,15 @@
+import styled from 'styled-components';
+
+const StyledWrapper = styled.div`
+  display: flex;
+  align-items: center;
+  height: 100%;
+  -webkit-app-region: no-drag;
+
+  .shortcut {
+    font-size: 11px;
+    color: ${(props) => props.theme.dropdown.mutedText};
+  }
+`;
+
+export default StyledWrapper;

packages/bruno-app/src/components/AppTitleBar/AppMenu/index.js

@@ -0,0 +1,154 @@
+import React, { useState } from 'react';
+import { IconMenu2 } from '@tabler/icons';
+import MenuDropdown from 'ui/MenuDropdown';
+import ActionIcon from 'ui/ActionIcon';
+import StyledWrapper from './StyledWrapper';
+
+const AppMenu = () => {
+  const [isOpen, setIsOpen] = useState(false);
+  const { ipcRenderer } = window;
+
+  const menuItems = [
+    {
+      id: 'file',
+      label: 'File',
+      submenu: [
+        {
+          id: 'open-collection',
+          label: 'Open Collection',
+          onClick: () => ipcRenderer?.invoke('renderer:open-collection')
+        },
+        { type: 'divider', id: 'file-div-1' },
+        {
+          id: 'preferences',
+          label: 'Preferences',
+          rightSection: <span className="shortcut">Ctrl+,</span>,
+          onClick: () => ipcRenderer?.invoke('renderer:open-preferences')
+        },
+        { type: 'divider', id: 'file-div-2' },
+        {
+          id: 'quit',
+          label: 'Quit',
+          rightSection: <span className="shortcut">Alt+F4</span>,
+          onClick: () => ipcRenderer?.send('renderer:window-close')
+        }
+      ]
+    },
+    {
+      id: 'edit',
+      label: 'Edit',
+      submenu: [
+        {
+          id: 'undo',
+          label: 'Undo',
+          rightSection: <span className="shortcut">Ctrl+Z</span>,
+          onClick: () => document.execCommand('undo')
+        },
+        {
+          id: 'redo',
+          label: 'Redo',
+          rightSection: <span className="shortcut">Ctrl+Y</span>,
+          onClick: () => document.execCommand('redo')
+        },
+        { type: 'divider', id: 'edit-div-1' },
+        {
+          id: 'cut',
+          label: 'Cut',
+          rightSection: <span className="shortcut">Ctrl+X</span>,
+          onClick: () => document.execCommand('cut')
+        },
+        {
+          id: 'copy',
+          label: 'Copy',
+          rightSection: <span className="shortcut">Ctrl+C</span>,
+          onClick: () => document.execCommand('copy')
+        },
+        {
+          id: 'paste',
+          label: 'Paste',
+          rightSection: <span className="shortcut">Ctrl+V</span>,
+          onClick: () => document.execCommand('paste')
+        },
+        { type: 'divider', id: 'edit-div-2' },
+        {
+          id: 'select-all',
+          label: 'Select All',
+          rightSection: <span className="shortcut">Ctrl+A</span>,
+          onClick: () => document.execCommand('selectAll')
+        }
+      ]
+    },
+    {
+      id: 'view',
+      label: 'View',
+      submenu: [
+        {
+          id: 'toggle-devtools',
+          label: 'Developer Tools',
+          rightSection: <span className="shortcut">Ctrl+Shift+I</span>,
+          onClick: () => ipcRenderer?.invoke('renderer:toggle-devtools')
+        },
+        { type: 'divider', id: 'view-div-1' },
+        {
+          id: 'reset-zoom',
+          label: 'Reset Zoom',
+          rightSection: <span className="shortcut">Ctrl+0</span>,
+          onClick: () => ipcRenderer?.invoke('renderer:reset-zoom')
+        },
+        {
+          id: 'zoom-in',
+          label: 'Zoom In',
+          rightSection: <span className="shortcut">Ctrl++</span>,
+          onClick: () => ipcRenderer?.invoke('renderer:zoom-in')
+        },
+        {
+          id: 'zoom-out',
+          label: 'Zoom Out',
+          rightSection: <span className="shortcut">Ctrl+-</span>,
+          onClick: () => ipcRenderer?.invoke('renderer:zoom-out')
+        },
+        { type: 'divider', id: 'view-div-2' },
+        {
+          id: 'toggle-fullscreen',
+          label: 'Full Screen',
+          rightSection: <span className="shortcut">F11</span>,
+          onClick: () => ipcRenderer?.invoke('renderer:toggle-fullscreen')
+        }
+      ]
+    },
+    {
+      id: 'help',
+      label: 'Help',
+      submenu: [
+        {
+          id: 'about',
+          label: 'About Bruno',
+          onClick: () => ipcRenderer?.invoke('renderer:open-about')
+        },
+        {
+          id: 'documentation',
+          label: 'Documentation',
+          onClick: () => ipcRenderer?.invoke('renderer:open-docs')
+        }
+      ]
+    }
+  ];
+
+  return (
+    <StyledWrapper>
+      <MenuDropdown
+        opened={isOpen}
+        onChange={setIsOpen}
+        placement="bottom-start"
+        showTickMark={false}
+        items={menuItems}
+      >
+        <ActionIcon label="Menu" size="lg">
+          <IconMenu2 size={16} stroke={1.5} />
+        </ActionIcon>
+      </MenuDropdown>
+    </StyledWrapper>
+  );
+};
+
+export default AppMenu;

packages/bruno-app/src/components/AppTitleBar/StyledWrapper.js

@@ -210,6 +210,10 @@ const Wrapper = styled.div`
     margin-left: 6px;
   }
 
+  .app-menu {
+    margin-left: 8px;
+  }
+
   /* Custom window control buttons for Windows - always interactive, above modal overlay */
   .window-controls {
     display: flex;

packages/bruno-app/src/components/AppTitleBar/index.js

@@ -4,10 +4,12 @@ import { forwardRef, useCallback, useEffect, useMemo, useState } from 'react';
 import toast from 'react-hot-toast';
 import { useDispatch, useSelector } from 'react-redux';
 
-import { savePreferences, showHomePage, showManageWorkspacePage, toggleSidebarCollapse } from 'providers/ReduxStore/slices/app';
+import { savePreferences, showManageWorkspacePage, toggleSidebarCollapse } from 'providers/ReduxStore/slices/app';
 import { closeConsole, openConsole } from 'providers/ReduxStore/slices/logs';
-import { openWorkspaceDialog, switchWorkspace } from 'providers/ReduxStore/slices/workspaces/actions';
+import { createWorkspaceWithUniqueName, openWorkspaceDialog, switchWorkspace } from 'providers/ReduxStore/slices/workspaces/actions';
 import { sortWorkspaces, toggleWorkspacePin } from 'utils/workspaces';
+import { focusTab } from 'providers/ReduxStore/slices/tabs';
+import get from 'lodash/get';
 
 import Bruno from 'components/Bruno';
 import MenuDropdown from 'ui/MenuDropdown';
@@ -17,6 +19,7 @@ import CreateWorkspace from 'components/WorkspaceSidebar/CreateWorkspace';
 import ImportWorkspace from 'components/WorkspaceSidebar/ImportWorkspace';
 
 import IconBottombarToggle from 'components/Icons/IconBottombarToggle/index';
+import AppMenu from './AppMenu';
 import StyledWrapper from './StyledWrapper';
 import ResponseLayoutToggle from 'components/ResponsePane/ResponseLayoutToggle';
 import { isMacOS, isWindowsOS, isLinuxOS } from 'utils/common/platform';
@@ -128,7 +131,10 @@ const AppTitleBar = () => {
   });
 
   const handleHomeClick = () => {
-    dispatch(showHomePage());
+    const scratchCollectionUid = activeWorkspace?.scratchCollectionUid;
+    if (scratchCollectionUid) {
+      dispatch(focusTab({ uid: `${scratchCollectionUid}-overview` }));
+    }
   };
 
   const handleWorkspaceSwitch = (workspaceUid) => {
@@ -145,9 +151,19 @@ const AppTitleBar = () => {
     }
   };
 
-  const handleCreateWorkspace = () => {
-    setCreateWorkspaceModalOpen(true);
-  };
+  const handleCreateWorkspace = useCallback(async () => {
+    const defaultLocation = get(preferences, 'general.defaultLocation', '');
+    if (!defaultLocation) {
+      setCreateWorkspaceModalOpen(true);
+      return;
+    }
+
+    try {
+      await dispatch(createWorkspaceWithUniqueName(defaultLocation));
+    } catch (error) {
+      toast.error(error?.message || 'Failed to create workspace');
+    }
+  }, [preferences, dispatch]);
 
   const handleManageWorkspaces = () => {
     dispatch(showManageWorkspacePage());
@@ -235,7 +251,7 @@ const AppTitleBar = () => {
     );
 
     return items;
-  }, [sortedWorkspaces, activeWorkspaceUid, preferences, handlePinWorkspace]);
+  }, [sortedWorkspaces, activeWorkspaceUid, preferences, handlePinWorkspace, handleCreateWorkspace]);
 
   return (
     <StyledWrapper className={`app-titlebar ${osClass} ${isFullScreen ? 'fullscreen' : ''}`}>
@@ -247,8 +263,9 @@ const AppTitleBar = () => {
       )}
 
       <div className="titlebar-content">
-        {/* Left section: Home + Workspace */}
         <div className="titlebar-left">
+          {showWindowControls && <AppMenu />}
+
           <ActionIcon onClick={handleHomeClick} label="Home" size="lg" className="home-button">
             <IconHome size={16} stroke={1.5} />
           </ActionIcon>

packages/bruno-app/src/components/CodeEditor/index.js

@@ -5,7 +5,7 @@
  *  LICENSE file in the root directory of this source tree.
  */
 
-import React from 'react';
+import React, { createRef } from 'react';
 import { isEqual, escapeRegExp } from 'lodash';
 import { defineCodeMirrorBrunoVariablesMode } from 'utils/common/codemirror';
 import { setupAutoComplete, showRootHints } from 'utils/codemirror/autocomplete';
@@ -16,7 +16,7 @@ import stripJsonComments from 'strip-json-comments';
 import { getAllVariables } from 'utils/collections';
 import { setupLinkAware } from 'utils/codemirror/linkAware';
 import { setupLintErrorTooltip } from 'utils/codemirror/lint-errors';
-import CodeMirrorSearch from 'components/CodeMirrorSearch';
+import CodeMirrorSearch from 'components/CodeMirrorSearch/index';
 
 const CodeMirror = require('codemirror');
 window.jsonlint = jsonlint;
@@ -34,6 +34,7 @@ export default class CodeEditor extends React.Component {
     this.cachedValue = props.value || '';
     this.variables = {};
     this.searchResultsCountElementId = 'search-results-count';
+    this.searchBarRef = createRef();
 
     this.lintOptions = {
       esversion: 11,
@@ -94,14 +95,14 @@ export default class CodeEditor extends React.Component {
           }
         },
         'Cmd-F': (cm) => {
-          if (!this.state.searchBarVisible) {
-            this.setState({ searchBarVisible: true });
-          }
+          this.setState({ searchBarVisible: true }, () => {
+            this.searchBarRef.current?.focus();
+          });
         },
         'Ctrl-F': (cm) => {
-          if (!this.state.searchBarVisible) {
-            this.setState({ searchBarVisible: true });
-          }
+          this.setState({ searchBarVisible: true }, () => {
+            this.searchBarRef.current?.focus();
+          });
         },
         'Cmd-H': 'replace',
         'Ctrl-H': 'replace',
@@ -232,10 +233,18 @@ export default class CodeEditor extends React.Component {
       CodeMirror.signal(this.editor, 'change', this.editor);
     }
     if (this.props.value !== prevProps.value && this.props.value !== this.cachedValue && this.editor) {
-      const cursor = this.editor.getCursor();
-      this.cachedValue = this.props.value;
-      this.editor.setValue(this.props.value);
-      this.editor.setCursor(cursor);
+      // TODO: temporary fix for keeping cursor state when auto save and new line insertion collide PR#7098
+      const nextValue = this.props.value ?? '';
+      const currentValue = this.editor.getValue();
+      // Skip updating only when focused and editable; read-only editors (e.g. response viewer) must always show new value
+      if (this.editor.hasFocus?.() && currentValue !== nextValue && !this.props.readOnly) {
+        this.cachedValue = currentValue;
+      } else {
+        const cursor = this.editor.getCursor();
+        this.cachedValue = nextValue;
+        this.editor.setValue(nextValue);
+        this.editor.setCursor(cursor);
+      }
     }
 
     if (this.editor) {
@@ -309,6 +318,10 @@ export default class CodeEditor extends React.Component {
         fontSize={this.props.fontSize}
       >
         <CodeMirrorSearch
+          ref={(node) => {
+            if (!node) return;
+            this.searchBarRef.current = node;
+          }}
           visible={this.state.searchBarVisible}
           editor={this.editor}
           onClose={() => this.setState({ searchBarVisible: false })}

packages/bruno-app/src/components/CodeMirrorSearch/index.js

@@ -1,4 +1,4 @@
-import React, { useState, useEffect, useRef, useCallback, useMemo } from 'react';
+import React, { useState, useEffect, useRef, useCallback, useMemo, forwardRef, useImperativeHandle } from 'react';
 import { IconRegex, IconArrowUp, IconArrowDown, IconX, IconLetterCase, IconLetterW } from '@tabler/icons';
 import ToolHint from 'components/ToolHint';
 import StyledWrapper from './StyledWrapper';
@@ -8,7 +8,45 @@ function escapeRegExp(string) {
   return string.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');
 }
 
-const CodeMirrorSearch = ({ visible, editor, onClose }) => {
+const MAX_MATCHES = 99_999;
+function findSearchMatches(editor, searchText, regex, caseSensitive, wholeWord) {
+  try {
+    let query, options = {};
+    if (regex) {
+      try {
+        query = new RegExp(searchText, caseSensitive ? 'g' : 'gi');
+      } catch (error) {
+        console.warn('Invalid regex provided in search!', error);
+        return [];
+      }
+    } else if (wholeWord) {
+      const escaped = escapeRegExp(searchText);
+      query = new RegExp(`\\b${escaped}\\b`, caseSensitive ? 'g' : 'gi');
+    } else {
+      query = searchText;
+      options = { caseFold: !caseSensitive };
+    }
+
+    const cursor = editor.getSearchCursor(query, { line: 0, ch: 0 }, options);
+    const out = [];
+    while (cursor.findNext()) {
+      out.push({ from: cursor.from(), to: cursor.to() });
+      if (out.length >= MAX_MATCHES) {
+        break;
+      }
+    }
+    return out;
+  } catch (e) {
+    console.error('Search error:', e);
+    return [];
+  }
+}
+
+function createCacheKey(editor, searchText, regex, caseSensitive, wholeWord) {
+  return `${editor.getValue().length}⇴${searchText}⇴${regex}⇴${caseSensitive}⇴${wholeWord}`;
+}
+
+const CodeMirrorSearch = forwardRef(({ visible, editor, onClose }, ref) => {
   const [searchText, setSearchText] = useState('');
   const [regex, setRegex] = useState(false);
   const [caseSensitive, setCaseSensitive] = useState(false);
@@ -19,48 +57,15 @@ const CodeMirrorSearch = ({ visible, editor, onClose }) => {
   const searchMarks = useRef([]);
   const searchLineHighlight = useRef(null);
   const searchMatches = useRef([]);
+  const searchCacheKey = useRef('');
+  const inputRef = useRef(null);
 
-  const debouncedSearchText = useDebounce(searchText, 150);
-
-  const memoizedMatches = useMemo(() => {
-    if (!editor || !visible) return [];
-    if (!debouncedSearchText) return [];
-
-    try {
-      let query, options = {};
-      if (regex) {
-        try {
-          query = new RegExp(debouncedSearchText, caseSensitive ? 'g' : 'gi');
-        } catch {
-          return [];
-        }
-      } else if (wholeWord) {
-        const escaped = escapeRegExp(debouncedSearchText);
-        query = new RegExp(`\\b${escaped}\\b`, caseSensitive ? 'g' : 'gi');
-      } else {
-        query = debouncedSearchText;
-        options = { caseFold: !caseSensitive };
-      }
-
-      const cursor = editor.getSearchCursor(query, { line: 0, ch: 0 }, options);
-      const out = [];
-      while (cursor.findNext()) {
-        out.push({ from: cursor.from(), to: cursor.to() });
-      }
-      return out;
-    } catch (e) {
-      console.error('Search error:', e);
-      return [];
-    }
-  }, [editor, visible, debouncedSearchText, regex, caseSensitive, wholeWord]);
-
+  const debouncedSearchText = useDebounce(searchText, 250);
   const doSearch = useCallback((newIndex = 0) => {
-    if (!editor) return;
+    if (!editor || !visible) {
+      return;
+    }
 
-    // Clear previous marks
-    searchMarks.current.forEach((mark) => mark.clear());
-    searchMarks.current = [];
-    // Clear previous line highlight
     if (searchLineHighlight.current !== null) {
       editor.removeLineClass(searchLineHighlight.current, 'wrap', 'cm-search-line-highlight');
       searchLineHighlight.current = null;
@@ -70,44 +75,100 @@ const CodeMirrorSearch = ({ visible, editor, onClose }) => {
       setMatchCount(0);
       setMatchIndex(0);
       searchMatches.current = [];
+      searchMarks.current.forEach((mark) => mark.clear());
+      searchMarks.current = [];
       return;
     }
 
     try {
-      const matches = memoizedMatches;
-      let matchIndex = matches.length ? Math.max(0, Math.min(newIndex, matches.length - 1)) : 0;
-      matches.forEach((m, i) => {
-        const mark = editor.markText(m.from, m.to, {
-          className: i === matchIndex ? 'cm-search-current' : 'cm-search-match',
-          clearOnEnter: true
-        });
-        searchMarks.current.push(mark);
-      });
+      const newCacheKey = createCacheKey(editor, debouncedSearchText, regex, caseSensitive, wholeWord);
+      const isCacheHit = newCacheKey === searchCacheKey.current;
 
-      if (matches.length) {
-        const currentLine = matches[matchIndex].from.line;
-        editor.addLineClass(currentLine, 'wrap', 'cm-search-line-highlight');
-        searchLineHighlight.current = currentLine;
-
-        editor.scrollIntoView(matches[matchIndex].from, 100);
-        editor.setSelection(matches[matchIndex].from, matches[matchIndex].to);
-      } else {
-        searchLineHighlight.current = null;
+      let matches = searchMatches.current;
+      if (!isCacheHit) {
+        matches = findSearchMatches(editor, debouncedSearchText, regex, caseSensitive, wholeWord);
+        searchMatches.current = matches;
+        searchCacheKey.current = newCacheKey;
+        setMatchCount(matches.length);
       }
 
-      setMatchCount(matches.length);
+      if (!matches.length) {
+        setMatchIndex(0);
+        // Clear previous marks
+        searchMarks.current.forEach((mark) => mark.clear());
+        searchMarks.current = [];
+        return;
+      }
+
+      const matchIndex = Math.max(0, Math.min(newIndex, matches.length - 1));
       setMatchIndex(matchIndex);
-      searchMatches.current = matches;
+
+      if (isCacheHit) {
+        // Clear only old current mark
+        const oldIndex = searchMarks.current.findIndex((mark) => mark.className?.includes('cm-search-current'));
+
+        if (oldIndex !== -1) {
+          searchMarks.current[oldIndex].clear();
+          searchMarks.current.splice(oldIndex, 1);
+        }
+
+        // Add mark to the new current and remark the previous and next
+        const toMark = [
+          // Previous
+          matchIndex > 0 ? matchIndex - 1 : null,
+          // Current
+          matchIndex,
+          // Next
+          matchIndex < matches.length - 1 ? matchIndex + 1 : null
+        ].filter((i) => i !== null);
+
+        toMark.forEach((i) => {
+          const mark = editor.markText(matches[i].from, matches[i].to, {
+            className: i === matchIndex ? 'cm-search-current' : 'cm-search-match',
+            clearOnEnter: true
+          });
+          searchMarks.current.push(mark);
+        });
+      } else {
+        // Clear previous marks
+        searchMarks.current.forEach((mark) => mark.clear());
+        searchMarks.current = [];
+
+        // Mark all on new search
+        matches.forEach((m, i) => {
+          const mark = editor.markText(m.from, m.to, {
+            className: i === matchIndex ? 'cm-search-current' : 'cm-search-match',
+            clearOnEnter: true
+          });
+          searchMarks.current.push(mark);
+        });
+      }
+
+      const currentLine = matches[matchIndex].from.line;
+      editor.addLineClass(currentLine, 'wrap', 'cm-search-line-highlight');
+      searchLineHighlight.current = currentLine;
+
+      editor.scrollIntoView(matches[matchIndex].from, 100);
+      editor.setSelection(matches[matchIndex].from, matches[matchIndex].to);
     } catch (e) {
       console.error('Search error:', e);
       setMatchCount(0);
       setMatchIndex(0);
       searchMatches.current = [];
+      searchCacheKey.current = '';
     }
-  }, [debouncedSearchText, regex, caseSensitive, wholeWord, editor, memoizedMatches]);
+  }, [debouncedSearchText, regex, caseSensitive, wholeWord, editor, visible]);
+
+  useImperativeHandle(ref, () => ({
+    focus: () => {
+      if (inputRef.current) {
+        inputRef.current.focus();
+      }
+    }
+  }));
 
   useEffect(() => {
-    doSearch(0, debouncedSearchText);
+    doSearch(0);
   }, [debouncedSearchText, doSearch]);
 
   const handleSearchBarClose = useCallback(() => {
@@ -118,6 +179,7 @@ const CodeMirrorSearch = ({ visible, editor, onClose }) => {
       searchLineHighlight.current = null;
     }
     searchMatches.current = [];
+    searchCacheKey.current = '';
     if (onClose) onClose();
     // Focus the editor after closing the search bar
     if (editor) {
@@ -133,32 +195,27 @@ const CodeMirrorSearch = ({ visible, editor, onClose }) => {
   const handleToggleRegex = () => {
     setRegex((prev) => !prev);
     setMatchIndex(0);
-    doSearch(0);
   };
 
   const handleToggleCase = () => {
     setCaseSensitive((prev) => !prev);
     setMatchIndex(0);
-    doSearch(0);
   };
 
   const handleToggleWholeWord = () => {
     setWholeWord((prev) => !prev);
     setMatchIndex(0);
-    doSearch(0);
   };
 
   const handleNext = () => {
     if (!searchMatches.current || !searchMatches.current.length) return;
-    let next = (matchIndex + 1) % searchMatches.current.length;
-    setMatchIndex(next);
+    const next = (matchIndex + 1) % searchMatches.current.length;
     doSearch(next);
   };
 
   const handlePrev = () => {
     if (!searchMatches.current || !searchMatches.current.length) return;
-    let prev = (matchIndex - 1 + searchMatches.current.length) % searchMatches.current.length;
-    setMatchIndex(prev);
+    const prev = (matchIndex - 1 + searchMatches.current.length) % searchMatches.current.length;
     doSearch(prev);
   };
 
@@ -168,6 +225,7 @@ const CodeMirrorSearch = ({ visible, editor, onClose }) => {
     <StyledWrapper>
       <div className="bruno-search-bar">
         <input
+          ref={inputRef}
           autoFocus
           type="text"
           value={searchText}
@@ -196,6 +254,6 @@ const CodeMirrorSearch = ({ visible, editor, onClose }) => {
       </div>
     </StyledWrapper>
   );
-};
+});
 
 export default CodeMirrorSearch;

packages/bruno-app/src/components/CollectionSettings/Headers/index.js

@@ -11,6 +11,7 @@ import { headers as StandardHTTPHeaders } from 'know-your-http-well';
 import { MimeTypes } from 'utils/codemirror/autocompleteConstants';
 import BulkEditor from 'components/BulkEditor/index';
 import Button from 'ui/Button';
+import { headerNameRegex, headerValueRegex } from 'utils/common/regex';
 
 const headerAutoCompleteList = StandardHTTPHeaders.map((e) => e.header);
 
@@ -32,6 +33,22 @@ const Headers = ({ collection }) => {
 
   const handleSave = () => dispatch(saveCollectionSettings(collection.uid));
 
+  const getRowError = useCallback((row, index, key) => {
+    if (key === 'name') {
+      if (!row.name || row.name.trim() === '') return null;
+      if (!headerNameRegex.test(row.name)) {
+        return 'Header name cannot contain spaces or newlines';
+      }
+    }
+    if (key === 'value') {
+      if (!row.value) return null;
+      if (!headerValueRegex.test(row.value)) {
+        return 'Header value cannot contain newlines';
+      }
+    }
+    return null;
+  }, []);
+
   const columns = [
     {
       key: 'name',
@@ -39,7 +56,7 @@ const Headers = ({ collection }) => {
       isKeyField: true,
       placeholder: 'Name',
       width: '30%',
-      render: ({ row, value, onChange, isLastEmptyRow }) => (
+      render: ({ value, onChange }) => (
         <SingleLineEditor
           value={value || ''}
           theme={storedTheme}
@@ -47,7 +64,7 @@ const Headers = ({ collection }) => {
           onChange={(newValue) => onChange(newValue.replace(/[\r\n]/g, ''))}
           autocomplete={headerAutoCompleteList}
           collection={collection}
-          placeholder={isLastEmptyRow ? 'Name' : ''}
+          placeholder={!value ? 'Name' : ''}
         />
       )
     },
@@ -55,7 +72,7 @@ const Headers = ({ collection }) => {
       key: 'value',
       name: 'Value',
       placeholder: 'Value',
-      render: ({ row, value, onChange, isLastEmptyRow }) => (
+      render: ({ value, onChange }) => (
         <SingleLineEditor
           value={value || ''}
           theme={storedTheme}
@@ -63,7 +80,7 @@ const Headers = ({ collection }) => {
           onChange={onChange}
           collection={collection}
           autocomplete={MimeTypes}
-          placeholder={isLastEmptyRow ? 'Value' : ''}
+          placeholder={!value ? 'Value' : ''}
         />
       )
     }
@@ -101,6 +118,7 @@ const Headers = ({ collection }) => {
         rows={headers}
         onChange={handleHeadersChange}
         defaultRow={defaultRow}
+        getRowError={getRowError}
       />
       <div className="flex justify-end mt-2">
         <button className="text-link select-none" onClick={toggleBulkEditMode}>

packages/bruno-app/src/components/CollectionSettings/Script/index.js

@@ -6,20 +6,39 @@ import { updateCollectionRequestScript, updateCollectionResponseScript } from 'p
 import { saveCollectionSettings } from 'providers/ReduxStore/slices/collections/actions';
 import { useTheme } from 'providers/Theme';
 import { Tabs, TabsList, TabsTrigger, TabsContent } from 'components/Tabs';
+import StatusDot from 'components/StatusDot';
+import { flattenItems, isItemARequest } from 'utils/collections';
 import StyledWrapper from './StyledWrapper';
 import Button from 'ui/Button';
 
 const Script = ({ collection }) => {
   const dispatch = useDispatch();
-  const [activeTab, setActiveTab] = useState('pre-request');
   const preRequestEditorRef = useRef(null);
   const postResponseEditorRef = useRef(null);
   const requestScript = collection.draft?.root ? get(collection, 'draft.root.request.script.req', '') : get(collection, 'root.request.script.req', '');
   const responseScript = collection.draft?.root ? get(collection, 'draft.root.request.script.res', '') : get(collection, 'root.request.script.res', '');
 
+  // Default to post-response if pre-request script is empty
+  const getInitialTab = () => {
+    const hasPreRequestScript = requestScript && requestScript.trim().length > 0;
+    return hasPreRequestScript ? 'pre-request' : 'post-response';
+  };
+
+  const [activeTab, setActiveTab] = useState(getInitialTab);
+  const prevCollectionUidRef = useRef(collection.uid);
+
   const { displayedTheme } = useTheme();
   const preferences = useSelector((state) => state.app.preferences);
 
+  // Update active tab only when switching to a different collection
+  useEffect(() => {
+    if (prevCollectionUidRef.current !== collection.uid) {
+      prevCollectionUidRef.current = collection.uid;
+      const hasPreRequestScript = requestScript && requestScript.trim().length > 0;
+      setActiveTab(hasPreRequestScript ? 'pre-request' : 'post-response');
+    }
+  }, [collection.uid, requestScript]);
+
   // Refresh CodeMirror when tab becomes visible
   useEffect(() => {
     const timer = setTimeout(() => {
@@ -55,6 +74,10 @@ const Script = ({ collection }) => {
     dispatch(saveCollectionSettings(collection.uid));
   };
 
+  const items = flattenItems(collection.items || []);
+  const hasPreRequestScriptError = items.some((i) => isItemARequest(i) && i.preRequestScriptErrorMessage);
+  const hasPostResponseScriptError = items.some((i) => isItemARequest(i) && i.postResponseScriptErrorMessage);
+
   return (
     <StyledWrapper className="w-full flex flex-col h-full">
       <div className="text-xs mb-4 text-muted">
@@ -63,8 +86,18 @@ const Script = ({ collection }) => {
 
       <Tabs value={activeTab} onValueChange={setActiveTab}>
         <TabsList>
-          <TabsTrigger value="pre-request">Pre Request</TabsTrigger>
-          <TabsTrigger value="post-response">Post Response</TabsTrigger>
+          <TabsTrigger value="pre-request">
+            Pre Request
+            {requestScript && requestScript.trim().length > 0 && (
+              <StatusDot type={hasPreRequestScriptError ? 'error' : 'default'} />
+            )}
+          </TabsTrigger>
+          <TabsTrigger value="post-response">
+            Post Response
+            {responseScript && responseScript.trim().length > 0 && (
+              <StatusDot type={hasPostResponseScriptError ? 'error' : 'default'} />
+            )}
+          </TabsTrigger>
         </TabsList>
 
         <TabsContent value="pre-request" className="mt-2">

packages/bruno-app/src/components/CollectionSettings/Vars/VarsTable/index.js

@@ -46,14 +46,14 @@ const VarsTable = ({ collection, vars, varType }) => {
         </div>
       ),
       placeholder: varType === 'request' ? 'Value' : 'Expr',
-      render: ({ row, value, onChange, isLastEmptyRow }) => (
+      render: ({ value, onChange }) => (
         <MultiLineEditor
           value={value || ''}
           theme={storedTheme}
           onSave={onSave}
           onChange={onChange}
           collection={collection}
-          placeholder={isLastEmptyRow ? (varType === 'request' ? 'Value' : 'Expr') : ''}
+          placeholder={!value ? (varType === 'request' ? 'Value' : 'Expr') : ''}
         />
       )
     }

packages/bruno-app/src/components/ColorBadge/index.js

@@ -0,0 +1,20 @@
+import React from 'react';
+import { useTheme } from 'providers/Theme';
+
+const ColorBadge = ({ color, size = 10 }) => {
+  const sizeValue = typeof size === 'string' ? size : `${size}px`;
+  const { theme } = useTheme();
+
+  return (
+    <div
+      className="flex-shrink-0 rounded-full"
+      style={{
+        width: sizeValue,
+        height: sizeValue,
+        backgroundColor: color || 'transparent'
+      }}
+    />
+  );
+};
+
+export default ColorBadge;

packages/bruno-app/src/components/ColorPicker/StyledWrapper.js

@@ -1,5 +1,7 @@
 import styled from 'styled-components';
 
-const StyledWrapper = styled.div``;
+const StyledWrapper = styled.div`
+  
+`;
 
 export default StyledWrapper;

packages/bruno-app/src/components/ColorPicker/index.js

@@ -0,0 +1,164 @@
+import React, { useState, useEffect, useRef } from 'react';
+import { IconBan, IconBrush } from '@tabler/icons';
+import Dropdown from 'components/Dropdown';
+import ColorBadge from 'components/ColorBadge';
+import StyledWrapper from './StyledWrapper';
+import { parseToRgb, toColorString } from 'polished';
+import ColorRangePicker from 'components/ColorRange/index';
+
+const PRESET_COLORS = [
+  '#CE4F3B',
+  '#2E8A54',
+  '#346AB2',
+  '#C77A0F',
+  '#B83D7F',
+  '#8D44B2'
+];
+
+const COLOR_RANGE_SEQUENCE = ['#D85D43', '#F4BB74', '#61DCB1', '#7EBDF2', '#D48ADE', '#B491E5'];
+
+/**
+ * @param {string} hex
+ * @returns {red:string,green:string,blue:string}
+ */
+const hexToRgb = (hex) => {
+  try {
+    return parseToRgb(hex);
+  } catch (err) {
+    return { red: 0, green: 0, blue: 0 };
+  }
+};
+
+const rgbToHex = (r, g, b) => {
+  return toColorString({ red: Math.round(r), green: Math.round(g), blue: Math.round(b) });
+};
+
+const interpolateColor = (position) => {
+  const numColors = COLOR_RANGE_SEQUENCE.length;
+  const scaledPos = (position / 100) * (numColors - 1);
+  const index = Math.floor(scaledPos);
+  const fraction = scaledPos - index;
+
+  if (index >= numColors - 1) {
+    return COLOR_RANGE_SEQUENCE[numColors - 1];
+  }
+
+  const color1 = hexToRgb(COLOR_RANGE_SEQUENCE[index]);
+  const color2 = hexToRgb(COLOR_RANGE_SEQUENCE[index + 1]);
+
+  const r = color1.red + (color2.red - color1.red) * fraction;
+  const g = color1.green + (color2.green - color1.green) * fraction;
+  const b = color1.blue + (color2.blue - color1.blue) * fraction;
+
+  return rgbToHex(r, g, b);
+};
+
+const findClosestPosition = (hex) => {
+  if (!hex) return 0;
+  const target = hexToRgb(hex);
+  let closestPos = 0;
+  let minDistance = Infinity;
+
+  for (let pos = 0; pos <= 100; pos++) {
+    const color = hexToRgb(interpolateColor(pos));
+    const distance = Math.sqrt(
+      Math.pow(target.red - color.red, 2) + Math.pow(target.green - color.green, 2) + Math.pow(target.blue - color.blue, 2)
+    );
+    if (distance < minDistance) {
+      minDistance = distance;
+      closestPos = pos;
+    }
+  }
+  return closestPos;
+};
+
+const ColorPickerIcon = ({ color }) => {
+  if (color) {
+    return <ColorBadge color={color} size={8} />;
+  }
+  return <IconBrush size={14} strokeWidth={1.5} className="opacity-70" />;
+};
+
+const ColorPicker = ({ color, onChange, icon }) => {
+  const [sliderPosition, setSliderPosition] = useState(() =>
+    color && !PRESET_COLORS.includes(color) ? findClosestPosition(color) : 0
+  );
+  const [customColor, setCustomColor] = useState(() =>
+    color && !PRESET_COLORS.includes(color) ? color : COLOR_RANGE_SEQUENCE[0]
+  );
+  const pendingColorRef = useRef(customColor);
+
+  const handleColorSelect = (selectedColor) => {
+    onChange(selectedColor);
+  };
+
+  const handleSliderChange = (e) => {
+    const newPosition = parseInt(e.target.value, 10);
+    setSliderPosition(newPosition);
+    const newColor = interpolateColor(newPosition);
+    setCustomColor(newColor);
+    pendingColorRef.current = newColor;
+  };
+
+  const handleSliderEnd = () => {
+    onChange(pendingColorRef.current);
+  };
+
+  const defaultIcon = (
+    <div className="cursor-pointer flex items-center" title="Change color">
+      <ColorPickerIcon color={color} />
+    </div>
+  );
+
+  const colorPickerContent = (
+    <StyledWrapper>
+      <div className="p-2">
+        <div className="flex flex-wrap gap-1.5 justify-between items-center">
+          <div
+            className="w-5 h-5 cursor-pointer flex items-center justify-center transition-transform duration-100 hover:scale-110"
+            onClick={() => handleColorSelect(null)}
+            title="No color"
+          >
+            <IconBan size={20} strokeWidth={1.5} />
+          </div>
+          {PRESET_COLORS.map((presetColor, index) => (
+            <div
+              key={index}
+              className={`w-5 h-5 rounded cursor-pointer flex items-center justify-center transition-transform duration-100 hover:scale-110 border-2 border-transparent
+                ${color === presetColor ? 'border-solid !border-current' : ''}
+              `}
+              style={{ backgroundColor: presetColor }}
+              onClick={() => handleColorSelect(presetColor)}
+              title={presetColor}
+            />
+          ))}
+        </div>
+
+        <div className="flex items-center gap-2 mt-2 pt-0.5">
+          <div
+            className="w-5 h-5 rounded-full flex-shrink-0 cursor-pointer"
+            style={{ backgroundColor: customColor }}
+            onClick={() => handleColorSelect(customColor)}
+            title="Custom color"
+          />
+          <ColorRangePicker
+            className="flex-1 flex"
+            value={sliderPosition}
+            onChange={handleSliderChange}
+            onMouseUp={handleSliderEnd}
+            selectedColor={customColor}
+            colorRange={COLOR_RANGE_SEQUENCE}
+          />
+        </div>
+      </div>
+    </StyledWrapper>
+  );
+
+  return (
+    <Dropdown icon={icon || defaultIcon} placement="bottom-start">
+      {colorPickerContent}
+    </Dropdown>
+  );
+};
+
+export default ColorPicker;

packages/bruno-app/src/components/ColorRange/StyledWrapper.js

@@ -0,0 +1,46 @@
+import styled from 'styled-components';
+
+const StyledWrapper = styled.div`
+  .hue-slider {
+    -webkit-appearance: none;
+    appearance: none;
+    width: 100%;
+    height: 4px;
+    border-radius: 2px;
+    outline: none;
+  }
+
+  .hue-slider::-webkit-slider-thumb {
+    -webkit-appearance: none;
+    appearance: none;
+    width: 14px;
+    height: 14px;
+    border-radius: 50%;
+    background: ${(props) => props.color ?? props.theme.bg};
+    border: none;
+    cursor: pointer;
+    box-shadow: 0 1px 3px rgba(0, 0, 0, 0.3);
+    transition: transform 0.1s ease;
+  }
+
+  .hue-slider::-webkit-slider-thumb:hover {
+    transform: scale(1.1);
+  }
+
+  .hue-slider::-moz-range-thumb {
+    width: 14px;
+    height: 14px;
+    border-radius: 50%;
+    background: ${(props) => props.color ?? props.theme.bg};
+    border: none;
+    cursor: pointer;
+    box-shadow: 0 1px 3px rgba(0, 0, 0, 0.3);
+    transition: transform 0.1s ease;
+  }
+
+  .hue-slider::-moz-range-thumb:hover {
+    transform: scale(1.1);
+  }
+`;
+
+export default StyledWrapper;

packages/bruno-app/src/components/ColorRange/index.js

@@ -0,0 +1,23 @@
+import StyledWrapper from './StyledWrapper';
+
+const ColorRangePicker = ({ selectedColor, className, value, onChange, colorRange, ...props }) => {
+  return (
+    <StyledWrapper color={selectedColor} className={className}>
+      <input
+        type="range"
+        min="0"
+        max="100"
+        value={value}
+        onChange={onChange}
+        className="hue-slider"
+        style={{
+          background: `linear-gradient(to right, ${colorRange.join(',')})`
+        }}
+        title="Adjust color"
+        {...props}
+      />
+    </StyledWrapper>
+  );
+};
+
+export default ColorRangePicker;

packages/bruno-app/src/components/CreateTransientRequest/index.js

@@ -0,0 +1,246 @@
+import React, { useState, useRef, useCallback, useMemo } from 'react';
+import { IconPlus, IconApi, IconBrandGraphql, IconPlugConnected, IconCode } from '@tabler/icons';
+import ActionIcon from 'ui/ActionIcon/index';
+import Dropdown from 'components/Dropdown';
+import { newHttpRequest, newGrpcRequest, newWsRequest } from 'providers/ReduxStore/slices/collections/actions';
+import { sanitizeName } from 'utils/common/regex';
+import toast from 'react-hot-toast';
+import { useDispatch, useSelector } from 'react-redux';
+import { flattenItems, isItemARequest, isItemTransientRequest } from 'utils/collections';
+import filter from 'lodash/filter';
+import { get } from 'lodash';
+import { formatIpcError } from 'utils/common/error';
+
+const REQUEST_TYPE = {
+  HTTP: 'http',
+  GRAPHQL: 'graphql',
+  GRPC: 'grpc',
+  WEBSOCKET: 'websocket'
+};
+
+/**
+ * Generate a request name for transient requests in the pattern "Untitled {Count}"
+ * @param {Object} collection - The collection object
+ * @returns {string} A request name like "Untitled 1", "Untitled 2", etc.
+ */
+const generateTransientRequestName = (collection) => {
+  if (!collection || !collection.items) {
+    return 'Untitled 1';
+  }
+  const allItems = flattenItems(collection.items);
+  const transientRequests = filter(allItems, (item) => {
+    return isItemTransientRequest(item);
+  });
+
+  // Find the highest "Untitled X" number among transient requests
+  let maxNumber = 0;
+  transientRequests.forEach((item) => {
+    const match = item.name?.match(/^Untitled (\d+)$/);
+    if (match) {
+      const number = parseInt(match[1], 10);
+      if (number > maxNumber) {
+        maxNumber = number;
+      }
+    }
+  });
+
+  // Increment from the highest number found, or start at 1 if none found
+  const count = maxNumber + 1;
+
+  return `Untitled ${count}`;
+};
+
+const CreateTransientRequest = ({ collectionUid }) => {
+  const [dropdownVisible, setDropdownVisible] = useState(false);
+  const dropdownTippyRef = useRef();
+  const dispatch = useDispatch();
+  const collections = useSelector((state) => state.collections.collections);
+
+  const collection = useMemo(() => {
+    return collections?.find((c) => c.uid === collectionUid);
+  }, [collections, collectionUid]);
+
+  const collectionPresets = useMemo(() => {
+    return get(collection, collection?.draft?.brunoConfig ? 'draft.brunoConfig.presets' : 'brunoConfig.presets', {
+      requestType: 'http',
+      requestUrl: ''
+    });
+  }, [collection]);
+
+  const onDropdownCreate = (ref) => {
+    dropdownTippyRef.current = ref;
+    if (ref) {
+      ref.setProps({
+        onHide: () => {
+          setDropdownVisible(false);
+        }
+      });
+    }
+  };
+
+  const handleLeftClick = () => {
+    handleItemClick(collectionPresets.requestType);
+  };
+
+  const handleRightClick = (e) => {
+    e.preventDefault();
+    setDropdownVisible(true);
+  };
+
+  const handleCreateHttpRequest = useCallback(() => {
+    if (!collection) return;
+
+    const uniqueName = generateTransientRequestName(collection);
+    const filename = sanitizeName(uniqueName);
+
+    dispatch(
+      newHttpRequest({
+        requestName: uniqueName,
+        filename: filename,
+        requestType: 'http-request',
+        requestUrl: collectionPresets.requestUrl,
+        requestMethod: 'GET',
+        collectionUid: collection.uid,
+        itemUid: null,
+        isTransient: true
+      })
+    ).catch((err) => toast.error(formatIpcError(err) || 'An error occurred while adding the request'));
+  }, [dispatch, collection, collectionPresets.requestUrl]);
+
+  const handleCreateGraphQLRequest = useCallback(() => {
+    if (!collection) return;
+
+    const uniqueName = generateTransientRequestName(collection);
+    const filename = sanitizeName(uniqueName);
+
+    dispatch(
+      newHttpRequest({
+        requestName: uniqueName,
+        filename: filename,
+        requestType: 'graphql-request',
+        requestUrl: collectionPresets.requestUrl,
+        requestMethod: 'POST',
+        collectionUid: collection.uid,
+        itemUid: null,
+        isTransient: true,
+        body: {
+          mode: 'graphql',
+          graphql: {
+            query: '',
+            variables: ''
+          }
+        }
+      })
+    ).catch((err) => toast.error(formatIpcError(err) || 'An error occurred while adding the request'));
+  }, [dispatch, collection, collectionPresets.requestUrl]);
+
+  const handleCreateWebSocketRequest = useCallback(() => {
+    if (!collection) return;
+
+    const uniqueName = generateTransientRequestName(collection);
+    const filename = sanitizeName(uniqueName);
+
+    dispatch(
+      newWsRequest({
+        requestName: uniqueName,
+        filename: filename,
+        requestUrl: collectionPresets.requestUrl,
+        requestMethod: 'ws',
+        collectionUid: collection.uid,
+        itemUid: null,
+        isTransient: true
+      })
+    ).catch((err) => toast.error(formatIpcError(err) || 'An error occurred while adding the request'));
+  }, [dispatch, collection, collectionPresets.requestUrl]);
+
+  const handleCreateGrpcRequest = useCallback(() => {
+    if (!collection) return;
+
+    const uniqueName = generateTransientRequestName(collection);
+    const filename = sanitizeName(uniqueName);
+
+    dispatch(
+      newGrpcRequest({
+        requestName: uniqueName,
+        filename: filename,
+        requestUrl: collectionPresets.requestUrl,
+        collectionUid: collection.uid,
+        itemUid: null,
+        isTransient: true
+      })
+    ).catch((err) => toast.error(formatIpcError(err) || 'An error occurred while adding the request'));
+  }, [dispatch, collection, collectionPresets.requestUrl]);
+
+  const handleItemClick = (type) => {
+    if (dropdownTippyRef.current) {
+      dropdownTippyRef.current.hide();
+    }
+    switch (type) {
+      case REQUEST_TYPE.HTTP:
+        handleCreateHttpRequest();
+        break;
+      case REQUEST_TYPE.GRAPHQL:
+        handleCreateGraphQLRequest();
+        break;
+      case REQUEST_TYPE.GRPC:
+        handleCreateGrpcRequest();
+        break;
+      case REQUEST_TYPE.WEBSOCKET:
+        handleCreateWebSocketRequest();
+        break;
+    }
+  };
+
+  if (!collection) {
+    return null;
+  }
+
+  const IconButton = (
+    <ActionIcon
+      onClick={handleLeftClick}
+      onContextMenu={handleRightClick}
+      aria-label="New Transient Request"
+      size="lg"
+      style={{ marginBottom: '3px' }}
+    >
+      <IconPlus size={18} strokeWidth={1.5} />
+    </ActionIcon>
+  );
+
+  return (
+    <Dropdown
+      icon={IconButton}
+      visible={dropdownVisible}
+      onCreate={onDropdownCreate}
+      onClickOutside={() => setDropdownVisible(false)}
+      placement="bottom-end"
+    >
+      <div className="dropdown-item" onClick={() => handleItemClick(REQUEST_TYPE.HTTP)}>
+        <div className="dropdown-icon">
+          <IconApi size={16} strokeWidth={2} />
+        </div>
+        <div className="dropdown-label">HTTP</div>
+      </div>
+      <div className="dropdown-item" onClick={() => handleItemClick(REQUEST_TYPE.GRAPHQL)}>
+        <div className="dropdown-icon">
+          <IconBrandGraphql size={16} strokeWidth={2} />
+        </div>
+        <div className="dropdown-label">GraphQL</div>
+      </div>
+      <div className="dropdown-item" onClick={() => handleItemClick(REQUEST_TYPE.GRPC)}>
+        <div className="dropdown-icon">
+          <IconCode size={16} strokeWidth={2} />
+        </div>
+        <div className="dropdown-label">gRPC</div>
+      </div>
+      <div className="dropdown-item" onClick={() => handleItemClick(REQUEST_TYPE.WEBSOCKET)}>
+        <div className="dropdown-icon">
+          <IconPlugConnected size={16} strokeWidth={2} />
+        </div>
+        <div className="dropdown-label">WebSocket</div>
+      </div>
+    </Dropdown>
+  );
+};
+
+export default CreateTransientRequest;

packages/bruno-app/src/components/Devtools/Console/TerminalTab/index.js

@@ -2,10 +2,37 @@ import React, { useRef, useEffect, useState, useCallback } from 'react';
 import { Terminal } from '@xterm/xterm';
 import { FitAddon } from '@xterm/addon-fit';
 import { IconTerminal2, IconPlus } from '@tabler/icons';
+import { useTheme } from 'providers/Theme';
 import StyledWrapper from './StyledWrapper';
 import SessionList from './SessionList';
 import '@xterm/xterm/css/xterm.css';
 
+// Build xterm.js theme from app theme
+const getTerminalTheme = (theme) => {
+  return {
+    background: theme.console.bg,
+    foreground: theme.console.messageColor,
+    cursor: theme.console.messageColor,
+    selectionBackground: theme.status.info.background,
+    black: theme.background.base,
+    red: theme.status.danger.text,
+    green: theme.status.success.text,
+    yellow: theme.status.warning.text,
+    blue: theme.status.info.text,
+    magenta: theme.colors.text.purple,
+    cyan: theme.codemirror.variable.prompt,
+    white: theme.text,
+    brightBlack: theme.colors.text.muted,
+    brightRed: theme.status.danger.text,
+    brightGreen: theme.status.success.text,
+    brightYellow: theme.status.warning.text,
+    brightBlue: theme.status.info.text,
+    brightMagenta: theme.colors.text.purple,
+    brightCyan: theme.codemirror.variable.prompt,
+    brightWhite: theme.text
+  };
+};
+
 // Terminal instances per session - Map<sessionId, { terminal, fitAddon, inputDisposable, resizeDisposable }>
 const terminalInstances = new Map();
 
@@ -33,7 +60,7 @@ const ensureParkingHost = () => {
   return parkingHost;
 };
 
-const createTerminalForSession = (sessionId) => {
+const createTerminalForSession = (sessionId, terminalTheme) => {
   if (terminalInstances.has(sessionId)) {
     return terminalInstances.get(sessionId);
   }
@@ -42,28 +69,7 @@ const createTerminalForSession = (sessionId) => {
     cursorBlink: true,
     fontSize: 14,
     fontFamily: 'Menlo, Monaco, "Courier New", monospace',
-    theme: {
-      background: '#1e1e1e',
-      foreground: '#d4d4d4',
-      cursor: '#d4d4d4',
-      selection: '#264f78',
-      black: '#1e1e1e',
-      red: '#f14c4c',
-      green: '#23d18b',
-      yellow: '#f5f543',
-      blue: '#3b8eea',
-      magenta: '#d670d6',
-      cyan: '#29b8db',
-      white: '#e5e5e5',
-      brightBlack: '#666666',
-      brightRed: '#f14c4c',
-      brightGreen: '#23d18b',
-      brightYellow: '#f5f543',
-      brightBlue: '#3b8eea',
-      brightMagenta: '#d670d6',
-      brightCyan: '#29b8db',
-      brightWhite: '#e5e5e5'
-    },
+    theme: terminalTheme,
     allowProposedApi: true
   });
 
@@ -156,10 +162,10 @@ const cleanupTerminalInstance = (sessionId) => {
   }
 };
 
-const openTerminalIntoContainer = async (container, sessionId) => {
+const openTerminalIntoContainer = async (container, sessionId, terminalTheme) => {
   if (!container || !sessionId) return;
 
-  const instance = createTerminalForSession(sessionId);
+  const instance = createTerminalForSession(sessionId, terminalTheme);
   const { terminal, fitAddon } = instance;
 
   if (!terminal.element) {
@@ -174,6 +180,7 @@ const openTerminalIntoContainer = async (container, sessionId) => {
   await new Promise((resolve) => setTimeout(resolve, 50));
   try {
     fitAddon.fit();
+    terminal.focus();
     const { cols, rows } = terminal;
     if (cols && rows && window.ipcRenderer) {
       window.ipcRenderer.send('terminal:resize', sessionId, { cols, rows });
@@ -211,6 +218,8 @@ const TerminalTab = () => {
   const [sessions, setSessions] = useState([]);
   const [activeSessionId, setActiveSessionId] = useState(null);
   const [isLoading, setIsLoading] = useState(true);
+  const { theme } = useTheme();
+  const terminalTheme = getTerminalTheme(theme);
 
   // Load sessions list
   const loadSessions = useCallback(async (currentActiveSessionId = null) => {
@@ -354,6 +363,15 @@ const TerminalTab = () => {
     };
   }, []);
 
+  // Update all terminal themes when app theme changes
+  useEffect(() => {
+    terminalInstances.forEach((instance) => {
+      if (instance.terminal) {
+        instance.terminal.options.theme = terminalTheme;
+      }
+    });
+  }, [theme.mode]);
+
   // Handle terminal display for active session
   useEffect(() => {
     if (!activeSessionId || !terminalRef.current) return;
@@ -361,7 +379,7 @@ const TerminalTab = () => {
     let mounted = true;
 
     const setupTerminal = async () => {
-      await openTerminalIntoContainer(terminalRef.current, activeSessionId);
+      await openTerminalIntoContainer(terminalRef.current, activeSessionId, terminalTheme);
 
       if (mounted) {
         const instance = terminalInstances.get(activeSessionId);

packages/bruno-app/src/components/Devtools/Console/index.js

@@ -64,6 +64,89 @@ const LogTimestamp = ({ timestamp }) => {
   return <span className="log-timestamp">{time}</span>;
 };
 
+// Helper function to check if an object is a plain object (not a class instance)
+const isPlainObject = (obj) => {
+  if (typeof obj !== 'object' || obj === null) return false;
+  const proto = Object.getPrototypeOf(obj);
+  return proto === null || proto === Object.prototype;
+};
+
+// Helper function to transform Bruno special types back to readable format
+// Extracted outside component to avoid recreation on every render
+const transformBrunoTypes = (obj, seen = new WeakSet()) => {
+  if (typeof obj !== 'object' || obj === null) {
+    return obj;
+  }
+
+  // Guard against circular references
+  if (seen.has(obj)) {
+    return '[Circular]';
+  }
+  seen.add(obj);
+
+  // Handle Bruno special types
+  if (obj.__brunoType) {
+    switch (obj.__brunoType) {
+      case 'Set':
+        // Transform Set to display values at top level with numeric indices
+        if (Array.isArray(obj.__brunoValue)) {
+          return Object.fromEntries(
+            obj.__brunoValue.map((value, index) => [index, transformBrunoTypes(value, seen)])
+          );
+        }
+        return {};
+      case 'Map':
+        // Transform Map to display entries at top level with => notation
+        if (Array.isArray(obj.__brunoValue)) {
+          const mapEntries = {};
+          for (const entry of obj.__brunoValue) {
+            // Defensive check: ensure entry is a valid [key, value] pair
+            if (Array.isArray(entry) && entry.length >= 2) {
+              const [key, value] = entry;
+              mapEntries[`${String(key)} =>`] = transformBrunoTypes(value, seen);
+            }
+          }
+          return mapEntries;
+        }
+        return {};
+      case 'Function':
+        return `[Function: ${obj.__brunoValue?.split?.('\n')?.[0]?.substring(0, 50) ?? 'anonymous'}...]`;
+      case 'undefined':
+        return 'undefined';
+      default:
+        return obj;
+    }
+  }
+
+  // Handle arrays - recurse into elements
+  if (Array.isArray(obj)) {
+    return obj.map((item) => transformBrunoTypes(item, seen));
+  }
+
+  // Preserve non-plain objects (Date, Error, RegExp, class instances, etc.)
+  if (!isPlainObject(obj)) {
+    return obj;
+  }
+
+  // Only deep-clone plain objects
+  const transformed = {};
+  for (const [key, value] of Object.entries(obj)) {
+    transformed[key] = transformBrunoTypes(value, seen);
+  }
+  return transformed;
+};
+
+// Helper to get metadata about Bruno types for display purposes
+const getBrunoTypeMetadata = (obj) => {
+  if (typeof obj !== 'object' || obj === null) {
+    return {};
+  }
+  if (obj.__brunoType === 'Set' || obj.__brunoType === 'Map') {
+    return { type: obj.__brunoType };
+  }
+  return {};
+};
+
 const LogMessage = ({ message, args }) => {
   const { displayedTheme } = useTheme();
 
@@ -71,18 +154,30 @@ const LogMessage = ({ message, args }) => {
     if (originalArgs && originalArgs.length > 0) {
       return originalArgs.map((arg, index) => {
         if (typeof arg === 'object' && arg !== null) {
+          const metadata = getBrunoTypeMetadata(arg);
+          const transformedArg = transformBrunoTypes(arg);
+
+          // Determine the name to display based on the type
+          let displayName = false;
+          let shouldCollapse = 1; // Default: collapse at depth 1 for regular objects
+
+          if (metadata.type === 'Map' || metadata.type === 'Set') {
+            displayName = metadata.type;
+            shouldCollapse = true; // Fully collapse Maps/Sets by default
+          }
+
           return (
             <div key={index} className="log-object">
               <ReactJson
-                src={arg}
+                src={transformedArg}
                 theme={displayedTheme === 'light' ? 'rjv-default' : 'monokai'}
                 iconStyle="triangle"
                 indentWidth={2}
-                collapsed={1}
+                collapsed={shouldCollapse}
                 displayDataTypes={false}
                 displayObjectSize={false}
                 enableClipboard={false}
-                name={false}
+                name={displayName}
                 style={{
                   backgroundColor: 'transparent',
                   fontSize: '${(props) => props.theme.font.size.sm}',

packages/bruno-app/src/components/Dropdown/StyledWrapper.js

@@ -85,6 +85,17 @@ const Wrapper = styled.div`
       justify-content: center;
     }
 
+    .dropdown-tab-count {
+      margin-left: auto;
+      font-size: 11px;
+      font-weight: 500;
+      padding: 1px 6px;
+      border-radius: 10px;
+      background: ${(props) => props.theme.dropdown.hoverBg};
+      min-width: 18px;
+      text-align: center;
+    }
+
     &:hover:not(:disabled):not(.disabled) {
       background-color: ${(props) => props.theme.dropdown.hoverBg};
     }
@@ -173,6 +184,18 @@ const Wrapper = styled.div`
     background-color: ${(props) => props.theme.dropdown.separator};
     margin: 0.25rem 0;
   }
+
+  .submenu-trigger {
+    position: relative;
+  }
+
+  .submenu-arrow {
+    color: ${(props) => props.theme.dropdown.mutedText};
+    flex-shrink: 0;
+    display: flex;
+    align-items: center;
+    margin-left: auto;
+  }
 `;
 
 export default Wrapper;

packages/bruno-app/src/components/Dropdown/index.js

@@ -2,7 +2,7 @@ import React from 'react';
 import Tippy from '@tippyjs/react';
 import StyledWrapper from './StyledWrapper';
 
-const Dropdown = ({ icon, children, onCreate, placement, transparent, visible, appendTo, ...props }) => {
+const Dropdown = ({ icon, children, onCreate, placement, transparent, visible, appendTo, onMouseEnter, onMouseLeave, ...props }) => {
   // When in controlled mode (visible prop is provided), don't use trigger prop
   const tippyProps = visible !== undefined
     ? { ...props, visible, interactive: true, appendTo: appendTo || 'parent' }
@@ -11,7 +11,14 @@ const Dropdown = ({ icon, children, onCreate, placement, transparent, visible, a
   return (
     <Tippy
       render={(attrs) => (
-        <StyledWrapper className="tippy-box dropdown" transparent={transparent} tabIndex={-1} {...attrs}>
+        <StyledWrapper
+          className="tippy-box dropdown"
+          transparent={transparent}
+          tabIndex={-1}
+          onMouseEnter={onMouseEnter}
+          onMouseLeave={onMouseLeave}
+          {...attrs}
+        >
           {children}
         </StyledWrapper>
       )}

packages/bruno-app/src/components/EditableTable/StyledWrapper.js

@@ -6,8 +6,13 @@ const StyledWrapper = styled.div`
   flex: 1;
   overflow: hidden;
 
+  &.is-resizing {
+    cursor: col-resize !important;
+    user-select: none;
+  }
+
   .table-container {
-    overflow-y: auto;
+    overflow: auto;
     border-radius: ${(props) => props.theme.border.radius.base};
     border: solid 1px ${(props) => props.theme.border.border0};
   }
@@ -24,6 +29,7 @@ const StyledWrapper = styled.div`
     color: ${(props) => props.theme.table.thead.color} !important;
     background: ${(props) => props.theme.sidebar.bg};
     user-select: none;
+    overflow: visible;
 
     border: none !important;
 
@@ -34,10 +40,36 @@ const StyledWrapper = styled.div`
       border-bottom: solid 1px ${(props) => props.theme.border.border0};
       border-right: solid 1px ${(props) => props.theme.border.border0};
       vertical-align: middle;
+      position: relative;
+      overflow: visible;
 
       &:last-child {
         border-right: none;
       }
+
+      .column-name {
+        display: block;
+        overflow: hidden;
+        text-overflow: ellipsis;
+        white-space: nowrap;
+        padding-right: 4px;
+      }
+
+      .resize-handle {
+        position: absolute;
+        right: 0;
+        top: 0;
+        width: 4px;
+        height: 100%;
+        cursor: col-resize;
+        background: transparent;
+        z-index: 100;
+
+        &:hover,
+        &.resizing {
+          background: ${(props) => props.theme.colors.accent};
+        }
+      }
     }
   }
 
@@ -61,10 +93,32 @@ const StyledWrapper = styled.div`
         border-bottom: solid 1px ${(props) => props.theme.border.border0};
         border-right: solid 1px ${(props) => props.theme.border.border0};
         vertical-align: middle;
+        overflow: hidden;
+        text-overflow: ellipsis;
+        white-space: nowrap;
 
         &:last-child {
           border-right: none;
         }
+
+        /* Handle CodeMirror editors overflow */
+        .cm-editor {
+          max-width: 100%;
+
+          .cm-scroller {
+            overflow: hidden !important;
+          }
+
+          .cm-content {
+            max-width: 100%;
+          }
+
+          .cm-line {
+            overflow: hidden;
+            text-overflow: ellipsis;
+            white-space: nowrap;
+          }
+        }
       }
     }
   }
@@ -75,6 +129,7 @@ const StyledWrapper = styled.div`
     text-align: center;
     vertical-align: middle;
     line-height: 1;
+    text-overflow: clip;
 
     input[type='checkbox'] {
       vertical-align: baseline;
@@ -84,6 +139,9 @@ const StyledWrapper = styled.div`
 
   .tooltip-mod {
     max-width: 200px !important;
+    word-wrap: break-word !important;
+    overflow-wrap: break-word !important;
+    white-space: normal !important;
   }
 
   input[type='text'] {

packages/bruno-app/src/components/EditableTable/index.js

@@ -1,9 +1,11 @@
-import React, { useCallback, useMemo, useRef, useState } from 'react';
+import React, { useCallback, useMemo, useRef, useState, useEffect } from 'react';
 import { IconTrash, IconAlertCircle, IconGripVertical, IconMinusVertical } from '@tabler/icons';
 import { Tooltip } from 'react-tooltip';
 import { uuid } from 'utils/common';
 import StyledWrapper from './StyledWrapper';
 
+const MIN_COLUMN_WIDTH = 80;
+
 const EditableTable = ({
   columns,
   rows,
@@ -23,7 +25,101 @@ const EditableTable = ({
   const tableRef = useRef(null);
   const emptyRowUidRef = useRef(null);
   const [hoveredRow, setHoveredRow] = useState(null);
-  const [dragStart, setDragStart] = useState(null);
+  const [resizing, setResizing] = useState(null);
+  const [tableHeight, setTableHeight] = useState(0);
+  const [columnWidths, setColumnWidths] = useState(() => {
+    const initialWidths = {};
+    columns.forEach((col) => {
+      initialWidths[col.key] = col.width || 'auto';
+    });
+    return initialWidths;
+  });
+
+  const handleResizeStart = useCallback((e, columnKey) => {
+    e.preventDefault();
+    e.stopPropagation();
+
+    const currentCell = e.target.closest('td');
+    const nextCell = currentCell?.nextElementSibling;
+    if (!currentCell || !nextCell) return;
+
+    const columnIndex = columns.findIndex((col) => col.key === columnKey);
+    if (columnIndex >= columns.length - 1) return;
+
+    const startX = e.clientX;
+    const startWidth = currentCell.offsetWidth;
+    const nextColumnKey = columns[columnIndex + 1].key;
+    const nextColumnStartWidth = nextCell.offsetWidth;
+
+    setResizing(columnKey);
+
+    const handleMouseMove = (moveEvent) => {
+      const diff = moveEvent.clientX - startX;
+      const maxGrow = nextColumnStartWidth - MIN_COLUMN_WIDTH;
+      const maxShrink = startWidth - MIN_COLUMN_WIDTH;
+      const clampedDiff = Math.max(-maxShrink, Math.min(maxGrow, diff));
+
+      setColumnWidths((prev) => ({
+        ...prev,
+        [columnKey]: `${startWidth + clampedDiff}px`,
+        [nextColumnKey]: `${nextColumnStartWidth - clampedDiff}px`
+      }));
+    };
+
+    const handleMouseUp = () => {
+      // Convert pixel widths to percentages for responsive scaling
+      const table = tableRef.current?.querySelector('table');
+      if (table) {
+        const tableWidth = table.offsetWidth;
+        const headerCells = table.querySelectorAll('thead td');
+        const newWidths = {};
+
+        headerCells.forEach((cell, cellIndex) => {
+          const checkboxOffset = showCheckbox ? 1 : 0;
+          const colIndex = cellIndex - checkboxOffset;
+
+          if (colIndex >= 0 && colIndex < columns.length) {
+            const colKey = columns[colIndex]?.key;
+            if (colKey) {
+              const percentage = (cell.offsetWidth / tableWidth) * 100;
+              newWidths[colKey] = `${percentage}%`;
+            }
+          }
+        });
+
+        if (Object.keys(newWidths).length > 0) {
+          setColumnWidths((prev) => ({ ...prev, ...newWidths }));
+        }
+      }
+      setResizing(null);
+      document.removeEventListener('mousemove', handleMouseMove);
+      document.removeEventListener('mouseup', handleMouseUp);
+    };
+
+    document.addEventListener('mousemove', handleMouseMove);
+    document.addEventListener('mouseup', handleMouseUp);
+  }, [columns, showCheckbox]);
+
+  // Track table height for resize handles
+  useEffect(() => {
+    const table = tableRef.current?.querySelector('table');
+    if (!table) return;
+
+    const updateHeight = () => {
+      setTableHeight(table.offsetHeight);
+    };
+
+    updateHeight();
+
+    const resizeObserver = new ResizeObserver(updateHeight);
+    resizeObserver.observe(table);
+
+    return () => resizeObserver.disconnect();
+  }, [rows.length]);
+
+  const getColumnWidth = useCallback((column) => {
+    return columnWidths[column.key] || column.width || 'auto';
+  }, [columnWidths]);
 
   const createEmptyRow = useCallback(() => {
     const newUid = uuid();
@@ -138,15 +234,9 @@ const EditableTable = ({
     onChange(filteredRows);
   }, [rows, onChange]);
 
-  const getColumnWidth = useCallback((column) => {
-    if (column.width) return column.width;
-    return 'auto';
-  }, []);
-
   const handleDragStart = useCallback((e, index) => {
     e.dataTransfer.effectAllowed = 'move';
     e.dataTransfer.setData('text/plain', index);
-    setDragStart(index);
   }, []);
 
   const handleDragOver = useCallback((e, index) => {
@@ -162,15 +252,17 @@ const EditableTable = ({
       const reorderableRows = showAddRow ? rowsWithEmpty.slice(0, -1) : rowsWithEmpty;
       const updatedOrder = [...reorderableRows];
       const [movedRow] = updatedOrder.splice(fromIndex, 1);
+      if (!movedRow) {
+        setHoveredRow(null);
+        return;
+      }
       updatedOrder.splice(toIndex, 0, movedRow);
       onReorder({ updateReorderedItem: updatedOrder.map((row) => row.uid) });
     }
-    setDragStart(null);
     setHoveredRow(null);
   }, [onReorder, rowsWithEmpty, showAddRow]);
 
   const handleDragEnd = useCallback(() => {
-    setDragStart(null);
     setHoveredRow(null);
   }, []);
 
@@ -179,15 +271,34 @@ const EditableTable = ({
     const value = column.getValue ? column.getValue(row) : row[column.key];
     const error = getRowError?.(row, rowIndex, column.key);
 
+    const errorIcon = error && !isEmpty ? (
+      <span>
+        <IconAlertCircle
+          data-tooltip-id={`error-${row.uid}-${column.key}`}
+          className="text-red-600 cursor-pointer ml-1"
+          size={20}
+        />
+        <Tooltip
+          className="tooltip-mod"
+          id={`error-${row.uid}-${column.key}`}
+          html={error}
+        />
+      </span>
+    ) : null;
+
     if (column.render) {
-      return column.render({
-        row,
-        value,
-        rowIndex,
-        isLastEmptyRow: isEmpty,
-        onChange: (newValue) => handleValueChange(row.uid, column.key, newValue),
-        error
-      });
+      return (
+        <div className="flex items-center">
+          {column.render({
+            row,
+            value,
+            rowIndex,
+            isLastEmptyRow: isEmpty,
+            onChange: (newValue) => handleValueChange(row.uid, column.key, newValue)
+          })}
+          {errorIcon}
+        </div>
+      );
     }
 
     return (
@@ -201,23 +312,10 @@ const EditableTable = ({
           className="mousetrap"
           value={value || ''}
           readOnly={column.readOnly}
-          placeholder={isEmpty ? column.placeholder || column.name : ''}
+          placeholder={!value ? column.placeholder || column.name : ''}
           onChange={(e) => handleValueChange(row.uid, column.key, e.target.value)}
         />
-        {error && !isEmpty && (
-          <span>
-            <IconAlertCircle
-              data-tooltip-id={`error-${row.uid}-${column.key}`}
-              className="text-red-600 cursor-pointer"
-              size={20}
-            />
-            <Tooltip
-              className="tooltip-mod"
-              id={`error-${row.uid}-${column.key}`}
-              html={error}
-            />
-          </span>
-        )}
+        {errorIcon}
       </div>
     );
   }, [isLastEmptyRow, getRowError, handleValueChange]);
@@ -225,7 +323,7 @@ const EditableTable = ({
   const reorderableRowCount = showAddRow ? rowsWithEmpty.length - 1 : rowsWithEmpty.length;
 
   return (
-    <StyledWrapper className={showCheckbox ? 'has-checkbox' : 'no-checkbox'}>
+    <StyledWrapper className={`${showCheckbox ? 'has-checkbox' : 'no-checkbox'} ${resizing ? 'is-resizing' : ''}`}>
       <div className="table-container" ref={tableRef} data-testid={testId}>
         <table>
           <thead>
@@ -233,12 +331,19 @@ const EditableTable = ({
               {showCheckbox && (
                 <td className="text-center">{checkboxLabel}</td>
               )}
-              {columns.map((column) => (
+              {columns.map((column, colIndex) => (
                 <td
                   key={column.key}
                   style={{ width: getColumnWidth(column) }}
                 >
-                  {column.name}
+                  <span className="column-name">{column.name}</span>
+                  {colIndex < columns.length - 1 && (
+                    <div
+                      className={`resize-handle ${resizing === column.key ? 'resizing' : ''}`}
+                      style={{ height: tableHeight > 0 ? `${tableHeight}px` : undefined }}
+                      onMouseDown={(e) => handleResizeStart(e, column.key)}
+                    />
+                  )}
                 </td>
               ))}
               {showDelete && (

packages/bruno-app/src/components/EnvironmentVariablesTable/StyledWrapper.js

@@ -6,6 +6,11 @@ const Wrapper = styled.div`
   flex: 1;
   overflow: hidden;
 
+  &.is-resizing {
+    cursor: col-resize !important;
+    user-select: none;
+  }
+
   .table-container {
     overflow-y: auto;
     border-radius: 8px;
@@ -32,10 +37,6 @@ const Wrapper = styled.div`
       &:nth-child(5) {
         width: 60px;
       }
-
-      &:nth-child(2) {
-        width: 30%;
-      }
     }
 
     thead {
@@ -48,10 +49,26 @@ const Wrapper = styled.div`
         padding: 5px 10px !important;
         border-bottom: solid 1px ${(props) => props.theme.border.border0};
         border-right: solid 1px ${(props) => props.theme.border.border0};
+        position: relative;
 
         &:last-child {
           border-right: none;
         }
+
+        .resize-handle {
+          position: absolute;
+          right: 0;
+          top: 0;
+          width: 4px;
+          cursor: col-resize;
+          background: transparent;
+          z-index: 100;
+
+          &:hover,
+          &.resizing {
+            background: ${(props) => props.theme.colors.accent};
+          }
+        }
       }
     }
 
@@ -79,6 +96,18 @@ const Wrapper = styled.div`
     max-width: 200px !important;
   }
 
+  .name-cell-wrapper {
+    position: relative;
+    width: 100%;
+  }
+
+  .no-results {
+    padding: 24px;
+    text-align: center;
+    font-size: ${(props) => props.theme.font.size.sm};
+    color: ${(props) => props.theme.colors.text.muted};
+  }
+
   input[type='text'] {
     width: 100%;
     border: 1px solid transparent;
@@ -147,21 +176,6 @@ const Wrapper = styled.div`
       opacity: 0.9;
     }
   }
-
-  .discard {
-    padding: 6px 16px;
-    font-size: ${(props) => props.theme.font.size.sm};
-    border-radius: ${(props) => props.theme.border.radius.base};
-    background: transparent;
-    color: ${(props) => props.theme.text};
-    border: 1px solid ${(props) => props.theme.border.border1};
-    cursor: pointer;
-    transition: all 0.15s ease;
-
-    &:hover {
-      background: ${(props) => props.theme.sidebar.collection.item.hoverBg};
-    }
-  }
 `;
 
 export default Wrapper;

packages/bruno-app/src/components/EnvironmentVariablesTable/index.js

@@ -0,0 +1,589 @@
+import React, { useCallback, useRef, useState, useEffect, useMemo } from 'react';
+import { TableVirtuoso } from 'react-virtuoso';
+import cloneDeep from 'lodash/cloneDeep';
+import { IconTrash, IconAlertCircle, IconInfoCircle } from '@tabler/icons';
+import { useTheme } from 'providers/Theme';
+import { useSelector } from 'react-redux';
+import MultiLineEditor from 'components/MultiLineEditor/index';
+import StyledWrapper from './StyledWrapper';
+import { uuid } from 'utils/common';
+import { useFormik } from 'formik';
+import * as Yup from 'yup';
+import { variableNameRegex } from 'utils/common/regex';
+import toast from 'react-hot-toast';
+import { Tooltip } from 'react-tooltip';
+import { getGlobalEnvironmentVariables } from 'utils/collections';
+import { stripEnvVarUid } from 'utils/environments';
+
+const MIN_H = 35 * 2;
+const MIN_COLUMN_WIDTH = 80;
+
+const TableRow = React.memo(
+  ({ children, item }) => (
+    <tr key={item.uid} data-testid={`env-var-row-${item.name}`}>
+      {children}
+    </tr>
+  ),
+  (prevProps, nextProps) => {
+    const prevUid = prevProps?.item?.uid;
+    const nextUid = nextProps?.item?.uid;
+    return prevUid === nextUid && prevProps.children === nextProps.children;
+  }
+);
+
+const EnvironmentVariablesTable = ({
+  environment,
+  collection,
+  onSave,
+  draft,
+  onDraftChange,
+  onDraftClear,
+  setIsModified,
+  renderExtraValueContent,
+  searchQuery = ''
+}) => {
+  const { storedTheme } = useTheme();
+  const { globalEnvironments, activeGlobalEnvironmentUid } = useSelector((state) => state.globalEnvironments);
+
+  const hasDraftForThisEnv = draft?.environmentUid === environment.uid;
+
+  const [tableHeight, setTableHeight] = useState(MIN_H);
+  const [columnWidths, setColumnWidths] = useState({ name: '30%', value: 'auto' });
+  const [resizing, setResizing] = useState(null);
+  const [pinnedData, setPinnedData] = useState({ query: '', uids: new Set() });
+
+  const handleResizeStart = useCallback((e, columnKey) => {
+    e.preventDefault();
+    e.stopPropagation();
+
+    const currentCell = e.target.closest('td');
+    const nextCell = currentCell?.nextElementSibling;
+    if (!currentCell || !nextCell) return;
+
+    const startX = e.clientX;
+    const startWidth = currentCell.offsetWidth;
+    const nextColumnKey = 'value';
+    const nextColumnStartWidth = nextCell.offsetWidth;
+
+    setResizing(columnKey);
+
+    const handleMouseMove = (moveEvent) => {
+      const diff = moveEvent.clientX - startX;
+      const maxGrow = nextColumnStartWidth - MIN_COLUMN_WIDTH;
+      const maxShrink = startWidth - MIN_COLUMN_WIDTH;
+      const clampedDiff = Math.max(-maxShrink, Math.min(maxGrow, diff));
+
+      setColumnWidths({
+        [columnKey]: `${startWidth + clampedDiff}px`,
+        [nextColumnKey]: `${nextColumnStartWidth - clampedDiff}px`
+      });
+    };
+
+    const handleMouseUp = () => {
+      setResizing(null);
+      document.removeEventListener('mousemove', handleMouseMove);
+      document.removeEventListener('mouseup', handleMouseUp);
+    };
+
+    document.addEventListener('mousemove', handleMouseMove);
+    document.addEventListener('mouseup', handleMouseUp);
+  }, []);
+
+  const handleTotalHeightChanged = useCallback((h) => {
+    setTableHeight(h);
+  }, []);
+
+  const handleRowFocus = useCallback((uid) => {
+    setPinnedData((prev) => ({
+      query: searchQuery,
+      uids: prev.query === searchQuery ? new Set([...prev.uids, uid]) : new Set([uid])
+    }));
+  }, [searchQuery]);
+
+  const prevEnvUidRef = useRef(null);
+  const prevEnvVariablesRef = useRef(environment.variables);
+  const mountedRef = useRef(false);
+
+  let _collection = collection ? cloneDeep(collection) : {};
+  const globalEnvironmentVariables = getGlobalEnvironmentVariables({ globalEnvironments, activeGlobalEnvironmentUid });
+  if (_collection) {
+    _collection.globalEnvironmentVariables = globalEnvironmentVariables;
+  }
+
+  const initialValues = useMemo(() => {
+    const vars = environment.variables || [];
+    return [
+      ...vars,
+      {
+        uid: uuid(),
+        name: '',
+        value: '',
+        type: 'text',
+        secret: false,
+        enabled: true
+      }
+    ];
+  }, [environment.uid, environment.variables]);
+
+  const formik = useFormik({
+    enableReinitialize: true,
+    initialValues: initialValues,
+    validationSchema: Yup.array().of(
+      Yup.object({
+        enabled: Yup.boolean(),
+        name: Yup.string().when('$isLastRow', {
+          is: true,
+          then: (schema) => schema.optional(),
+          otherwise: (schema) =>
+            schema
+              .required('Name cannot be empty')
+              .matches(
+                variableNameRegex,
+                'Name contains invalid characters. Must only contain alphanumeric characters, "-", "_", "." and cannot start with a digit.'
+              )
+              .trim()
+        }),
+        secret: Yup.boolean(),
+        type: Yup.string(),
+        uid: Yup.string(),
+        value: Yup.mixed().nullable()
+      })
+    ),
+    validate: (values) => {
+      const errors = {};
+      values.forEach((variable, index) => {
+        const isLastRow = index === values.length - 1;
+        const isEmptyRow = !variable.name || variable.name.trim() === '';
+
+        if (isLastRow && isEmptyRow) {
+          return;
+        }
+
+        if (!variable.name || variable.name.trim() === '') {
+          if (!errors[index]) errors[index] = {};
+          errors[index].name = 'Name cannot be empty';
+        } else if (!variableNameRegex.test(variable.name)) {
+          if (!errors[index]) errors[index] = {};
+          errors[index].name
+            = 'Name contains invalid characters. Must only contain alphanumeric characters, "-", "_", "." and cannot start with a digit.';
+        }
+      });
+      return Object.keys(errors).length > 0 ? errors : {};
+    },
+    onSubmit: () => {}
+  });
+
+  // Restore draft values on mount or environment switch
+  useEffect(() => {
+    const isMount = !mountedRef.current;
+    const envChanged = prevEnvUidRef.current !== null && prevEnvUidRef.current !== environment.uid;
+    const variablesReloaded = !isMount && !envChanged && prevEnvVariablesRef.current !== environment.variables;
+
+    prevEnvUidRef.current = environment.uid;
+    prevEnvVariablesRef.current = environment.variables;
+    mountedRef.current = true;
+
+    if ((isMount || envChanged || variablesReloaded) && hasDraftForThisEnv && draft?.variables) {
+      formik.setValues([
+        ...draft.variables,
+        {
+          uid: uuid(),
+          name: '',
+          value: '',
+          type: 'text',
+          secret: false,
+          enabled: true
+        }
+      ]);
+    }
+  }, [environment.uid, environment.variables, hasDraftForThisEnv, draft?.variables]);
+
+  const savedValuesJson = useMemo(() => {
+    return JSON.stringify((environment.variables || []).map(stripEnvVarUid));
+  }, [environment.variables]);
+
+  useEffect(() => {
+    setPinnedData({ query: '', uids: new Set() });
+  }, [savedValuesJson]);
+
+  // Sync modified state
+  useEffect(() => {
+    const currentValues = formik.values.filter((variable) => variable.name && variable.name.trim() !== '');
+    const currentValuesJson = JSON.stringify(currentValues.map(stripEnvVarUid));
+    const hasActualChanges = currentValuesJson !== savedValuesJson;
+    setIsModified(hasActualChanges);
+  }, [formik.values, savedValuesJson, setIsModified]);
+
+  // Sync draft state
+  useEffect(() => {
+    const timeoutId = setTimeout(() => {
+      const currentValues = formik.values.filter((variable) => variable.name && variable.name.trim() !== '');
+      const currentValuesJson = JSON.stringify(currentValues.map(stripEnvVarUid));
+      const hasActualChanges = currentValuesJson !== savedValuesJson;
+
+      const existingDraftVariables = hasDraftForThisEnv ? draft?.variables : null;
+      const existingDraftJson = existingDraftVariables ? JSON.stringify(existingDraftVariables.map(stripEnvVarUid)) : null;
+
+      if (hasActualChanges) {
+        if (currentValuesJson !== existingDraftJson) {
+          onDraftChange(currentValues);
+        }
+      } else if (hasDraftForThisEnv) {
+        onDraftClear();
+      }
+    }, 300);
+
+    return () => clearTimeout(timeoutId);
+  }, [formik.values, savedValuesJson, environment.uid, hasDraftForThisEnv, draft?.variables, onDraftChange, onDraftClear]);
+
+  const ErrorMessage = ({ name, index }) => {
+    const meta = formik.getFieldMeta(name);
+    const id = `error-${name}-${index}`;
+
+    const isLastRow = index === formik.values.length - 1;
+    const variable = formik.values[index];
+    const isEmptyRow = !variable?.name || variable.name.trim() === '';
+
+    if (isLastRow && isEmptyRow) {
+      return null;
+    }
+
+    if (!meta.error || !meta.touched) {
+      return null;
+    }
+    return (
+      <span>
+        <IconAlertCircle id={id} className="text-red-600 cursor-pointer" size={20} />
+        <Tooltip className="tooltip-mod" anchorId={id} html={meta.error || ''} />
+      </span>
+    );
+  };
+
+  const handleRemoveVar = useCallback(
+    (id) => {
+      const currentValues = formik.values;
+
+      if (!currentValues || currentValues.length === 0) {
+        return;
+      }
+
+      const lastRow = currentValues[currentValues.length - 1];
+      const isLastEmptyRow = lastRow?.uid === id && (!lastRow.name || lastRow.name.trim() === '');
+
+      if (isLastEmptyRow) {
+        return;
+      }
+
+      const filteredValues = currentValues.filter((variable) => variable.uid !== id);
+
+      const hasEmptyLastRow
+        = filteredValues.length > 0
+          && (!filteredValues[filteredValues.length - 1].name
+            || filteredValues[filteredValues.length - 1].name.trim() === '');
+
+      const newValues = hasEmptyLastRow
+        ? filteredValues
+        : [
+            ...filteredValues,
+            {
+              uid: uuid(),
+              name: '',
+              value: '',
+              type: 'text',
+              secret: false,
+              enabled: true
+            }
+          ];
+
+      formik.setValues(newValues);
+    },
+    [formik.values]
+  );
+
+  const handleNameChange = (index, e) => {
+    formik.handleChange(e);
+    const isLastRow = index === formik.values.length - 1;
+
+    if (isLastRow) {
+      const newVariable = {
+        uid: uuid(),
+        name: '',
+        value: '',
+        type: 'text',
+        secret: false,
+        enabled: true
+      };
+      setTimeout(() => {
+        formik.setFieldValue(formik.values.length, newVariable, false);
+      }, 0);
+    }
+  };
+
+  const handleNameBlur = (index) => {
+    formik.setFieldTouched(`${index}.name`, true, true);
+  };
+
+  const handleNameKeyDown = (index, e) => {
+    if (e.key === 'Enter') {
+      e.preventDefault();
+      formik.setFieldTouched(`${index}.name`, true, true);
+    }
+  };
+
+  const handleSave = useCallback(() => {
+    const variablesToSave = formik.values.filter((variable) => variable.name && variable.name.trim() !== '');
+    const savedValues = environment.variables || [];
+
+    // Compare without UIDs since they can be different but the actual data is the same
+    const hasChanges = JSON.stringify(variablesToSave.map(stripEnvVarUid)) !== JSON.stringify(savedValues.map(stripEnvVarUid));
+    if (!hasChanges) {
+      toast.error('No changes to save');
+      return;
+    }
+
+    const hasValidationErrors = variablesToSave.some((variable) => {
+      if (!variable.name || variable.name.trim() === '') {
+        return true;
+      }
+      if (!variableNameRegex.test(variable.name)) {
+        return true;
+      }
+      return false;
+    });
+
+    if (hasValidationErrors) {
+      toast.error('Please fix validation errors before saving');
+      return;
+    }
+
+    onSave(cloneDeep(variablesToSave))
+      .then(() => {
+        toast.success('Changes saved successfully');
+        onDraftClear();
+        const newValues = [
+          ...variablesToSave,
+          {
+            uid: uuid(),
+            name: '',
+            value: '',
+            type: 'text',
+            secret: false,
+            enabled: true
+          }
+        ];
+        formik.resetForm({ values: newValues });
+        setIsModified(false);
+      })
+      .catch((error) => {
+        console.error(error);
+        toast.error('An error occurred while saving the changes');
+      });
+  }, [formik.values, environment.variables, onSave, onDraftClear, setIsModified]);
+
+  const handleReset = useCallback(() => {
+    const originalVars = environment.variables || [];
+    const resetValues = [
+      ...originalVars,
+      {
+        uid: uuid(),
+        name: '',
+        value: '',
+        type: 'text',
+        secret: false,
+        enabled: true
+      }
+    ];
+    formik.resetForm({ values: resetValues });
+    setIsModified(false);
+  }, [environment.variables, setIsModified]);
+
+  const handleSaveRef = useRef(handleSave);
+  handleSaveRef.current = handleSave;
+
+  useEffect(() => {
+    const handleSaveEvent = () => {
+      handleSaveRef.current();
+    };
+
+    window.addEventListener('environment-save', handleSaveEvent);
+
+    return () => {
+      window.removeEventListener('environment-save', handleSaveEvent);
+    };
+  }, []);
+
+  const filteredVariables = useMemo(() => {
+    const allVariables = formik.values.map((variable, index) => ({ variable, index }));
+    if (!searchQuery?.trim()) {
+      return allVariables;
+    }
+
+    const query = searchQuery.toLowerCase().trim();
+
+    const effectivePins = pinnedData.query === searchQuery ? pinnedData.uids : new Set();
+    return allVariables.filter(({ variable }) => {
+      if (effectivePins.has(variable.uid)) return true;
+      const nameMatch = variable.name ? variable.name.toLowerCase().includes(query) : false;
+      const valueText
+        = typeof variable.value === 'string'
+          ? variable.value
+          : typeof variable.value === 'number' || typeof variable.value === 'boolean'
+            ? String(variable.value)
+            : '';
+      const valueMatch = valueText.toLowerCase().includes(query);
+      return !!(nameMatch || valueMatch);
+    });
+  }, [formik.values, searchQuery, pinnedData]);
+
+  const isSearchActive = !!searchQuery?.trim();
+
+  return (
+    <StyledWrapper className={resizing ? 'is-resizing' : ''}>
+      {isSearchActive && filteredVariables.length === 0 ? (
+        <div className="no-results">No results found for &ldquo;{searchQuery.trim()}&rdquo;</div>
+      ) : (
+        <TableVirtuoso
+          className="table-container"
+          style={{ height: tableHeight }}
+          components={{ TableRow }}
+          data={filteredVariables}
+          totalListHeightChanged={handleTotalHeightChanged}
+          fixedHeaderContent={() => (
+            <tr>
+              <td className="text-center"></td>
+              <td style={{ width: columnWidths.name }}>
+                Name
+                <div
+                  className={`resize-handle ${resizing === 'name' ? 'resizing' : ''}`}
+                  style={{ height: tableHeight > 0 ? `${tableHeight}px` : undefined }}
+                  onMouseDown={(e) => handleResizeStart(e, 'name')}
+                />
+              </td>
+              <td style={{ width: columnWidths.value }}>Value</td>
+              <td className="text-center">Secret</td>
+              <td></td>
+            </tr>
+          )}
+          fixedItemHeight={35}
+          computeItemKey={(virtualIndex, item) => `${environment.uid}-${item.index}`}
+          itemContent={(virtualIndex, { variable, index: actualIndex }) => {
+            const isLastRow = actualIndex === formik.values.length - 1;
+            const isEmptyRow = !variable.name || variable.name.trim() === '';
+            const isLastEmptyRow = isLastRow && isEmptyRow;
+
+            return (
+              <>
+                <td className="text-center">
+                  {!isLastEmptyRow && (
+                    <input
+                      type="checkbox"
+                      className="mousetrap"
+                      name={`${actualIndex}.enabled`}
+                      checked={variable.enabled}
+                      onChange={formik.handleChange}
+                    />
+                  )}
+                </td>
+                <td style={{ width: columnWidths.name }}>
+                  <div className="flex items-center">
+                    <div className="name-cell-wrapper">
+                      <input
+                        type="text"
+                        autoComplete="off"
+                        autoCorrect="off"
+                        autoCapitalize="off"
+                        spellCheck="false"
+                        className="mousetrap"
+                        id={`${actualIndex}.name`}
+                        name={`${actualIndex}.name`}
+                        value={variable.name}
+                        placeholder={!variable.value || (typeof variable.value === 'string' && variable.value.trim() === '') ? 'Name' : ''}
+                        onChange={(e) => handleNameChange(actualIndex, e)}
+                        onFocus={() => handleRowFocus(variable.uid)}
+                        onBlur={() => {
+                          handleNameBlur(actualIndex);
+                        }}
+                        onKeyDown={(e) => handleNameKeyDown(actualIndex, e)}
+                      />
+                    </div>
+                    <ErrorMessage name={`${actualIndex}.name`} index={actualIndex} />
+                  </div>
+                </td>
+                <td
+                  className="flex flex-row flex-nowrap items-center"
+                  style={{ width: columnWidths.value }}
+                >
+                  <div
+                    className="overflow-hidden grow w-full relative"
+                    onFocus={() => handleRowFocus(variable.uid)}
+                  >
+                    <MultiLineEditor
+                      theme={storedTheme}
+                      collection={_collection}
+                      name={`${actualIndex}.value`}
+                      value={variable.value}
+                      placeholder={isLastEmptyRow ? 'Value' : ''}
+                      isSecret={variable.secret}
+                      readOnly={typeof variable.value !== 'string'}
+                      onChange={(newValue) => {
+                        formik.setFieldValue(`${actualIndex}.value`, newValue, true);
+                        // Clear ephemeral metadata when user manually edits the value
+                        if (variable.ephemeral) {
+                          formik.setFieldValue(`${actualIndex}.ephemeral`, undefined, false);
+                          formik.setFieldValue(`${actualIndex}.persistedValue`, undefined, false);
+                        }
+                      }}
+                      onSave={handleSave}
+                    />
+                  </div>
+                  {typeof variable.value !== 'string' && (
+                    <span className="ml-2 flex items-center">
+                      <IconInfoCircle id={`${variable.uid}-disabled-info-icon`} className="text-muted" size={16} />
+                      <Tooltip
+                        anchorId={`${variable.uid}-disabled-info-icon`}
+                        content="Non-string values set via scripts are read-only and can only be updated through scripts."
+                        place="top"
+                      />
+                    </span>
+                  )}
+                  {renderExtraValueContent && renderExtraValueContent(variable)}
+                </td>
+                <td className="text-center">
+                  {!isLastEmptyRow && (
+                    <input
+                      type="checkbox"
+                      className="mousetrap"
+                      name={`${actualIndex}.secret`}
+                      checked={variable.secret}
+                      onChange={formik.handleChange}
+                    />
+                  )}
+                </td>
+                <td>
+                  {!isLastEmptyRow && (
+                    <button onClick={() => handleRemoveVar(variable.uid)}>
+                      <IconTrash strokeWidth={1.5} size={18} />
+                    </button>
+                  )}
+                </td>
+              </>
+            );
+          }}
+        />
+      )}
+
+      <div className="button-container">
+        <div className="flex items-center">
+          <button type="button" className="submit" onClick={handleSave} data-testid="save-env">
+            Save
+          </button>
+          <button type="button" className="submit reset ml-2" onClick={handleReset} data-testid="reset-env">
+            Reset
+          </button>
+        </div>
+      </div>
+    </StyledWrapper>
+  );
+};
+
+export default EnvironmentVariablesTable;

packages/bruno-app/src/components/Environments/CollapsibleSection/StyledWrapper.js

@@ -0,0 +1,106 @@
+import styled from 'styled-components';
+
+const StyledWrapper = styled.div`
+  display: flex;
+  flex-direction: column;
+
+  &.collapsed {
+    flex-shrink: 0;
+
+    .section-content {
+      display: none;
+    }
+  }
+
+  &.expanded {
+    flex: 1;
+    min-height: 0;
+    overflow: hidden;
+
+    .section-content {
+      flex: 1;
+      overflow-y: auto;
+      overflow-x: hidden;
+    }
+  }
+
+  .section-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 8px 12px;
+    cursor: pointer;
+    user-select: none;
+    border-radius: 4px;
+    transition: background 0.15s ease;
+    flex-shrink: 0;
+
+    &:hover {
+      background: ${(props) => props.theme.workspace.button.bg};
+    }
+
+    .section-title-wrapper {
+      display: flex;
+      align-items: center;
+      gap: 6px;
+    }
+
+    .section-icon {
+      color: ${(props) => props.theme.colors.text.muted};
+      transition: transform 0.2s ease;
+
+      &.expanded {
+        transform: rotate(90deg);
+      }
+    }
+
+    .section-title {
+      padding-right: 4px;
+      font-size: 11px;
+      font-weight: 600;
+      text-transform: uppercase;
+      letter-spacing: 0.5px;
+      color: ${(props) => props.theme.sidebar.color};
+    }
+
+    .section-badge {
+      font-size: 10px;
+      padding: 1px 6px;
+      background: ${(props) => props.theme.sidebar.collection.item.hoverBg};
+      border-radius: 10px;
+      color: ${(props) => props.theme.colors.text.muted};
+    }
+
+    .section-actions {
+      display: flex;
+      align-items: center;
+      gap: 2px;
+
+      .btn-action {
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        width: 22px;
+        height: 22px;
+        padding: 0;
+        background: transparent;
+        border: none;
+        border-radius: 4px;
+        color: ${(props) => props.theme.colors.text.muted};
+        cursor: pointer;
+        transition: all 0.15s ease;
+
+        &:hover {
+          background: ${(props) => props.theme.sidebar.collection.item.hoverBg};
+          color: ${(props) => props.theme.text};
+        }
+      }
+    }
+  }
+
+  .section-content {
+    padding: 4px 0;
+  }
+`;
+
+export default StyledWrapper;

packages/bruno-app/src/components/Environments/CollapsibleSection/index.js

@@ -0,0 +1,40 @@
+import React from 'react';
+import { IconChevronRight } from '@tabler/icons';
+import StyledWrapper from './StyledWrapper';
+
+const CollapsibleSection = ({
+  title,
+  expanded,
+  onToggle,
+  badge,
+  actions,
+  children
+}) => {
+  return (
+    <StyledWrapper className={expanded ? 'expanded' : 'collapsed'}>
+      <div className="section-header" onClick={onToggle}>
+        <div className="section-title-wrapper">
+          <IconChevronRight
+            size={14}
+            strokeWidth={2}
+            className={`section-icon ${expanded ? 'expanded' : ''}`}
+          />
+          <span className="section-title">{title}</span>
+          {badge !== undefined && badge !== null && (
+            <span className="section-badge">{badge}</span>
+          )}
+        </div>
+        {actions && (
+          <div className="section-actions" onClick={(e) => e.stopPropagation()}>
+            {actions}
+          </div>
+        )}
+      </div>
+      <div className="section-content">
+        {children}
+      </div>
+    </StyledWrapper>
+  );
+};
+
+export default CollapsibleSection;

packages/bruno-app/src/components/Environments/Common/ImportEnvironmentModal/index.js

@@ -46,8 +46,8 @@ const ImportEnvironmentModal = ({ type = 'collection', collection, onClose, onEn
       let importedCount = 0;
       for (const environment of validEnvironments) {
         const action = isGlobal
-          ? addGlobalEnvironment({ name: environment.name, variables: environment.variables })
-          : importEnvironment({ name: environment.name, variables: environment.variables, collectionUid: collection?.uid });
+          ? addGlobalEnvironment({ name: environment.name, variables: environment.variables, color: environment.color })
+          : importEnvironment({ name: environment.name, variables: environment.variables, color: environment.color, collectionUid: collection?.uid });
 
         await dispatch(action);
         importedCount++;

packages/bruno-app/src/components/Environments/ConfirmCloseEnvironment/index.js

@@ -4,7 +4,14 @@ import Modal from 'components/Modal';
 import Portal from 'components/Portal';
 import Button from 'ui/Button';
 
-const ConfirmCloseEnvironment = ({ onCancel, onCloseWithoutSave, onSaveAndClose, isGlobal }) => {
+const ConfirmCloseEnvironment = ({ onCancel, onCloseWithoutSave, onSaveAndClose, isGlobal, isDotEnv }) => {
+  let settingsLabel = 'collection environment settings';
+  if (isDotEnv) {
+    settingsLabel = '.env file';
+  } else if (isGlobal) {
+    settingsLabel = 'global environment settings';
+  }
+
   return (
     <Portal>
       <Modal
@@ -21,7 +28,7 @@ const ConfirmCloseEnvironment = ({ onCancel, onCloseWithoutSave, onSaveAndClose,
           <h1 className="ml-2 text-lg font-medium">Hold on...</h1>
         </div>
         <div className="font-normal mt-4">
-          You have unsaved changes in {isGlobal ? 'global' : 'collection'} environment settings.
+          You have unsaved changes in {settingsLabel}.
         </div>
 
         <div className="flex justify-between mt-6">

packages/bruno-app/src/components/Environments/DotEnvFileDetails/StyledWrapper.js

@@ -0,0 +1,93 @@
+import styled from 'styled-components';
+
+const StyledWrapper = styled.div`
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+  background: ${(props) => props.theme.bg};
+
+  .header {
+    position: relative;
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 16px 20px 8px 20px;
+    flex-shrink: 0;
+
+    .title {
+      font-size: ${(props) => props.theme.font.size.base};
+      font-weight: 500;
+      color: ${(props) => props.theme.text};
+      margin: 0;
+    }
+
+    .actions {
+      display: flex;
+      align-items: center;
+      gap: 12px;
+
+      .view-toggle {
+        display: flex;
+        border: 1px solid ${(props) => props.theme.border.border0};
+        border-radius: 4px;
+        overflow: hidden;
+
+        .toggle-btn {
+          padding: 4px 12px;
+          font-size: 12px;
+          border: none;
+          background: transparent;
+          color: ${(props) => props.theme.colors.text.muted};
+          cursor: pointer;
+          transition: all 0.15s ease;
+
+          &:first-child {
+            border-right: 1px solid ${(props) => props.theme.border.border0};
+          }
+
+          &:hover {
+            background: ${(props) => props.theme.sidebar.bg};
+          }
+
+          &.active {
+            background: ${(props) => props.theme.brand};
+            color: ${(props) => props.theme.bg};
+          }
+        }
+      }
+
+      .action-btn {
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        padding: 6px;
+        border: none;
+        background: transparent;
+        color: ${(props) => props.theme.colors.text.muted};
+        cursor: pointer;
+        border-radius: 4px;
+        transition: all 0.15s ease;
+
+        &:hover {
+          background: ${(props) => props.theme.sidebar.bg};
+          color: ${(props) => props.theme.text};
+        }
+
+        &.delete-btn:hover {
+          color: ${(props) => props.theme.colors.text.danger};
+        }
+      }
+    }
+  }
+
+  .content {
+    flex: 1;
+    overflow: hidden;
+    display: flex;
+    flex-direction: column;
+    padding: 0 20px 20px 20px;
+  }
+`;
+
+export default StyledWrapper;

packages/bruno-app/src/components/Environments/DotEnvFileDetails/index.js

@@ -0,0 +1,74 @@
+import React, { useState } from 'react';
+import { IconTrash } from '@tabler/icons';
+import DeleteDotEnvFile from 'components/Environments/EnvironmentSettings/DeleteDotEnvFile';
+import StyledWrapper from './StyledWrapper';
+
+const DotEnvFileDetails = ({
+  title,
+  children,
+  onDelete,
+  dotEnvExists,
+  viewMode,
+  onViewModeChange
+}) => {
+  const [showDeleteModal, setShowDeleteModal] = useState(false);
+
+  const handleDeleteClick = () => {
+    setShowDeleteModal(true);
+  };
+
+  const handleConfirmDelete = () => {
+    if (onDelete) {
+      onDelete();
+    }
+  };
+
+  return (
+    <StyledWrapper>
+      <div className="header">
+        <h3 className="title">{title}</h3>
+        <div className="actions">
+          {dotEnvExists && (
+            <>
+              <div className="view-toggle" role="group" aria-label="View mode">
+                <button
+                  type="button"
+                  className={`toggle-btn ${viewMode === 'table' ? 'active' : ''}`}
+                  onClick={() => onViewModeChange?.('table')}
+                  aria-pressed={viewMode === 'table'}
+                >
+                  Table
+                </button>
+                <button
+                  type="button"
+                  className={`toggle-btn ${viewMode === 'raw' ? 'active' : ''}`}
+                  onClick={() => onViewModeChange?.('raw')}
+                  aria-pressed={viewMode === 'raw'}
+                >
+                  Raw
+                </button>
+              </div>
+              <button type="button" onClick={handleDeleteClick} title="Delete .env file" className="action-btn delete-btn">
+                <IconTrash size={15} strokeWidth={1.5} />
+              </button>
+            </>
+          )}
+        </div>
+      </div>
+
+      {showDeleteModal && (
+        <DeleteDotEnvFile
+          onClose={() => setShowDeleteModal(false)}
+          onConfirm={handleConfirmDelete}
+          filename={title}
+        />
+      )}
+
+      <div className="content">
+        {children}
+      </div>
+    </StyledWrapper>
+  );
+};
+
+export default DotEnvFileDetails;

packages/bruno-app/src/components/Environments/DotEnvFileEditor/DotEnvEmptyState.js

@@ -0,0 +1,16 @@
+import React from 'react';
+import { IconFileOff } from '@tabler/icons';
+
+const DotEnvEmptyState = () => {
+  return (
+    <div className="empty-state">
+      <IconFileOff size={48} strokeWidth={1.5} />
+      <div className="title">No .env File</div>
+      <div className="description">
+        Add a variable below to create a .env file in this location.
+      </div>
+    </div>
+  );
+};
+
+export default DotEnvEmptyState;

packages/bruno-app/src/components/Environments/DotEnvFileEditor/DotEnvErrorMessage.js

@@ -0,0 +1,25 @@
+import React from 'react';
+import { IconAlertCircle } from '@tabler/icons';
+import { Tooltip } from 'react-tooltip';
+
+const DotEnvErrorMessage = React.memo(({ formik, name, index }) => {
+  const meta = formik.getFieldMeta(name);
+  const id = `error-${name}-${index}`;
+
+  const isLastRow = index === formik.values.length - 1;
+  const variable = formik.values[index];
+  const isEmptyRow = !variable?.name || variable.name.trim() === '';
+
+  if ((isLastRow && isEmptyRow) || !meta.error || !meta.touched) {
+    return null;
+  }
+
+  return (
+    <span>
+      <IconAlertCircle id={id} className="text-red-600 cursor-pointer" size={20} />
+      <Tooltip className="tooltip-mod" anchorId={id} html={meta.error || ''} />
+    </span>
+  );
+});
+
+export default DotEnvErrorMessage;

packages/bruno-app/src/components/Environments/DotEnvFileEditor/DotEnvRawView.js

@@ -0,0 +1,43 @@
+import React from 'react';
+import CodeEditor from 'components/CodeEditor';
+
+const DotEnvRawView = ({
+  collection,
+  item,
+  theme,
+  value,
+  onChange,
+  onSave,
+  onReset,
+  isSaving
+}) => {
+  return (
+    <>
+      <div className="raw-editor-container">
+        <CodeEditor
+          collection={collection}
+          item={item}
+          theme={theme}
+          value={value}
+          onEdit={onChange}
+          onSave={onSave}
+          mode="text/plain"
+          enableVariableHighlighting={false}
+          enableBrunoVarInfo={false}
+        />
+      </div>
+      <div className="button-container">
+        <div className="flex items-center">
+          <button type="button" className="submit" onClick={onSave} disabled={isSaving} data-testid="save-dotenv-raw">
+            {isSaving ? 'Saving...' : 'Save'}
+          </button>
+          <button type="button" className="submit reset ml-2" onClick={onReset} disabled={isSaving} data-testid="reset-dotenv-raw">
+            Reset
+          </button>
+        </div>
+      </div>
+    </>
+  );
+};
+
+export default DotEnvRawView;

packages/bruno-app/src/components/Environments/DotEnvFileEditor/DotEnvTableView.js

@@ -0,0 +1,130 @@
+import React, { useCallback, useRef } from 'react';
+import { TableVirtuoso } from 'react-virtuoso';
+import { IconTrash } from '@tabler/icons';
+import MultiLineEditor from 'components/MultiLineEditor/index';
+import DotEnvErrorMessage from './DotEnvErrorMessage';
+import { MIN_TABLE_HEIGHT } from './utils';
+
+const TableRow = React.memo(({ children, item }) => (
+  <tr key={item.uid} data-testid={`dotenv-var-row-${item.name}`}>{children}</tr>
+), (prevProps, nextProps) => {
+  const prevUid = prevProps?.item?.uid;
+  const nextUid = nextProps?.item?.uid;
+  return prevUid === nextUid && prevProps.children === nextProps.children;
+});
+
+const DotEnvTableView = ({
+  formik,
+  theme,
+  showValueColumn,
+  tableHeight,
+  onHeightChange,
+  onNameChange,
+  onNameBlur,
+  onNameKeyDown,
+  onRemoveVar,
+  onSave,
+  onReset,
+  isSaving
+}) => {
+  const handleTotalHeightChanged = useCallback((h) => {
+    onHeightChange(h);
+  }, [onHeightChange]);
+
+  // Use refs for stable access to formik values in callbacks
+  const formikRef = useRef(formik);
+  formikRef.current = formik;
+
+  // Don't memoize itemContent - TableVirtuoso handles this internally
+  // and we need fresh access to formik values
+  const itemContent = (index, variable) => {
+    const currentFormik = formikRef.current;
+    const isLastRow = index === currentFormik.values.length - 1;
+    const isEmptyRow = !variable.name || variable.name.trim() === '';
+    const isLastEmptyRow = isLastRow && isEmptyRow;
+
+    return (
+      <>
+        <td>
+          <div className="flex items-center">
+            <input
+              type="text"
+              autoComplete="off"
+              autoCorrect="off"
+              autoCapitalize="off"
+              spellCheck="false"
+              className="mousetrap"
+              id={`${index}.name`}
+              name={`${index}.name`}
+              value={variable.name}
+              placeholder={isLastEmptyRow ? 'Name' : ''}
+              onChange={(e) => onNameChange(index, e)}
+              onBlur={() => onNameBlur(index)}
+              onKeyDown={(e) => onNameKeyDown(index, e)}
+            />
+            <DotEnvErrorMessage formik={currentFormik} name={`${index}.name`} index={index} />
+          </div>
+        </td>
+        {showValueColumn && (
+          <td className="flex flex-row flex-nowrap items-center">
+            <div className="overflow-hidden grow w-full relative">
+              <MultiLineEditor
+                theme={theme}
+                name={`${index}.value`}
+                value={variable.value}
+                placeholder={isLastEmptyRow ? 'Value' : ''}
+                onChange={(newValue) => currentFormik.setFieldValue(`${index}.value`, newValue, true)}
+                onSave={onSave}
+              />
+            </div>
+          </td>
+        )}
+        <td className="delete-col">
+          {!isLastEmptyRow && (
+            <button
+              type="button"
+              aria-label="Delete variable"
+              onClick={() => onRemoveVar(variable.uid)}
+            >
+              <IconTrash strokeWidth={1.5} size={18} />
+            </button>
+          )}
+        </td>
+      </>
+    );
+  };
+
+  return (
+    <>
+      <TableVirtuoso
+        className="table-container"
+        style={{ height: tableHeight || MIN_TABLE_HEIGHT }}
+        components={{ TableRow }}
+        data={formik.values}
+        totalListHeightChanged={handleTotalHeightChanged}
+        fixedHeaderContent={() => (
+          <tr>
+            <td>Name</td>
+            {showValueColumn && <td>Value</td>}
+            <td className="delete-col"></td>
+          </tr>
+        )}
+        fixedItemHeight={35}
+        computeItemKey={(index, variable) => variable.uid}
+        itemContent={itemContent}
+      />
+      <div className="button-container">
+        <div className="flex items-center">
+          <button type="button" className="submit" onClick={onSave} disabled={isSaving} data-testid="save-dotenv">
+            {isSaving ? 'Saving...' : 'Save'}
+          </button>
+          <button type="button" className="submit reset ml-2" onClick={onReset} disabled={isSaving} data-testid="reset-dotenv">
+            Reset
+          </button>
+        </div>
+      </div>
+    </>
+  );
+};
+
+export default DotEnvTableView;

packages/bruno-app/src/components/Environments/DotEnvFileEditor/StyledWrapper.js

@@ -1,11 +1,22 @@
 import styled from 'styled-components';
 
-const Wrapper = styled.div`
+const StyledWrapper = styled.div`
   display: flex;
   flex-direction: column;
   flex: 1;
   overflow: hidden;
-  
+
+  .raw-editor-container {
+    flex: 1;
+    overflow: hidden;
+    border-radius: 8px;
+    border: solid 1px ${(props) => props.theme.border.border0};
+
+    .CodeMirror {
+      font-size: ${(props) => props.theme.font.size.base};
+    }
+  }
+
   .table-container {
     overflow-y: auto;
     border-radius: 8px;
@@ -16,24 +27,20 @@ const Wrapper = styled.div`
     width: 100%;
     border-collapse: collapse;
     table-layout: fixed;
+    font-size: 12px;
 
     td {
       vertical-align: middle;
       padding: 2px 10px;
 
-      &:nth-child(1) {
-        width: 25px;
-        border-right: none;
-      }
-      &:nth-child(4) {
-        width: 80px;
-      }
-      &:nth-child(5) {
-        width: 60px;
+      &:first-child {
+        width: 35%;
       }
 
-      &:nth-child(2) {
-        width: 30%;
+      &.delete-col {
+        width: 40px;
+        text-align: center;
+        padding: 2px 4px;
       }
     }
 
@@ -42,30 +49,30 @@ const Wrapper = styled.div`
       background: ${(props) => props.theme.sidebar.bg};
       font-size: ${(props) => props.theme.font.size.base};
       user-select: none;
-      
+
       td {
         padding: 5px 10px !important;
         border-bottom: solid 1px ${(props) => props.theme.border.border0};
         border-right: solid 1px ${(props) => props.theme.border.border0};
-        
+
         &:last-child {
           border-right: none;
         }
       }
     }
-    
+
     tbody {
       tr {
         transition: background 0.1s ease;
-        
+
         &:last-child td {
           border-bottom: none;
         }
-        
+
         td {
           border-bottom: solid 1px ${(props) => props.theme.border.border0};
           border-right: solid 1px ${(props) => props.theme.border.border0};
-          
+
           &:last-child {
             border-right: none;
           }
@@ -101,12 +108,78 @@ const Wrapper = styled.div`
     vertical-align: middle;
     margin: 0;
   }
-  
+
+  button {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    padding: 4px;
+    color: ${(props) => props.theme.colors.text.muted};
+    background: transparent;
+    border: none;
+    cursor: pointer;
+    border-radius: 4px;
+    transition: color 0.15s ease, background 0.15s ease;
+  }
+
   .button-container {
+    padding: 12px 2px;
+    background: ${(props) => props.theme.bg};
     flex-shrink: 0;
     display: flex;
     gap: 8px;
   }
+
+  .submit {
+    padding: 6px 16px;
+    font-size: ${(props) => props.theme.font.size.sm};
+    border-radius: ${(props) => props.theme.border.radius.base};
+    border: none;
+    background: ${(props) => props.theme.brand};
+    color: ${(props) => props.theme.bg};
+    cursor: pointer;
+    transition: opacity 0.15s ease;
+
+    &:hover {
+      opacity: 0.9;
+    }
+  }
+
+  .reset {
+    background: transparent;
+    padding: 6px 16px;
+    color: ${(props) => props.theme.brand};
+    &:hover {
+      opacity: 0.9;
+    }
+  }
+
+  .empty-state {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    padding: 40px 20px;
+    color: ${(props) => props.theme.colors.text.muted};
+
+    svg {
+      opacity: 0.4;
+      margin-bottom: 12px;
+    }
+
+    .title {
+      font-size: 13px;
+      font-weight: 500;
+      margin-bottom: 8px;
+    }
+
+    .description {
+      font-size: 12px;
+      text-align: center;
+      max-width: 300px;
+      line-height: 1.5;
+    }
+  }
 `;
 
-export default Wrapper;
+export default StyledWrapper;

packages/bruno-app/src/components/Environments/DotEnvFileEditor/index.js

@@ -0,0 +1,346 @@
+import React, { useCallback, useRef, useMemo, useEffect, useState } from 'react';
+import { useTheme } from 'providers/Theme';
+import { uuid } from 'utils/common';
+import { useFormik } from 'formik';
+import { variableNameRegex } from 'utils/common/regex';
+import toast from 'react-hot-toast';
+import useDeferredLoading from 'hooks/useDeferredLoading';
+
+import StyledWrapper from './StyledWrapper';
+import DotEnvTableView from './DotEnvTableView';
+import DotEnvRawView from './DotEnvRawView';
+import DotEnvEmptyState from './DotEnvEmptyState';
+import { variablesToRaw, rawToVariables, MIN_TABLE_HEIGHT } from './utils';
+
+const DotEnvFileEditor = ({
+  variables,
+  onSave,
+  onSaveRaw,
+  isModified,
+  setIsModified,
+  dotEnvExists,
+  rawContent,
+  viewMode = 'table',
+  collection,
+  item
+}) => {
+  const { displayedTheme } = useTheme();
+  const [tableHeight, setTableHeight] = useState(MIN_TABLE_HEIGHT);
+  // Derive a single baseline raw value for consistent dirty-tracking
+  const baselineRaw = rawContent ?? variablesToRaw(variables || []);
+  const initialRawValue = baselineRaw;
+  const [rawValue, setRawValue] = useState(initialRawValue);
+  const [prevViewMode, setPrevViewMode] = useState(viewMode);
+  const [isSaving, setIsSaving] = useState(false);
+  const showSaving = useDeferredLoading(isSaving, 200);
+
+  const formikRef = useRef(null);
+
+  const initialValues = useMemo(() => {
+    const vars = (variables || []).map((v) => ({
+      ...v,
+      uid: v.uid || uuid()
+    }));
+    return [
+      ...vars,
+      {
+        uid: uuid(),
+        name: '',
+        value: ''
+      }
+    ];
+  }, [variables]);
+
+  const formik = useFormik({
+    enableReinitialize: true,
+    initialValues: initialValues,
+    validate: (values) => {
+      const errors = {};
+      values.forEach((variable, index) => {
+        const isLastRow = index === values.length - 1;
+        const isEmptyRow = !variable.name || variable.name.trim() === '';
+
+        if (isLastRow && isEmptyRow) {
+          return;
+        }
+
+        if (!variable.name || variable.name.trim() === '') {
+          if (!errors[index]) errors[index] = {};
+          errors[index].name = 'Name cannot be empty';
+        } else if (!variableNameRegex.test(variable.name)) {
+          if (!errors[index]) errors[index] = {};
+          errors[index].name
+            = 'Name contains invalid characters. Must only contain alphanumeric characters, "-", "_", "." and cannot start with a digit.';
+        }
+      });
+      return Object.keys(errors).length > 0 ? errors : {};
+    },
+    onSubmit: () => {}
+  });
+
+  formikRef.current = formik;
+
+  // Sync raw value with external changes
+  useEffect(() => {
+    setRawValue(baselineRaw);
+  }, [baselineRaw]);
+
+  // Handle view mode switching
+  useEffect(() => {
+    if (viewMode !== prevViewMode) {
+      if (viewMode === 'raw' && prevViewMode === 'table') {
+        const currentVars = formikRef.current.values.filter((v) => v.name && v.name.trim() !== '');
+        const newRawValue = variablesToRaw(currentVars);
+        setRawValue(newRawValue);
+      } else if (viewMode === 'table' && prevViewMode === 'raw') {
+        const parsedVars = rawToVariables(rawValue);
+        const newValues = [
+          ...parsedVars,
+          { uid: uuid(), name: '', value: '' }
+        ];
+        formikRef.current.setValues(newValues);
+      }
+      setPrevViewMode(viewMode);
+    }
+  }, [viewMode, prevViewMode, rawValue]);
+
+  const normalizeForComparison = (vars) => {
+    return vars
+      .filter((v) => v.name && v.name.trim() !== '')
+      .map(({ name, value }) => ({ name, value: value || '' }));
+  };
+
+  const savedValuesJson = useMemo(() => {
+    return JSON.stringify(normalizeForComparison(variables || []));
+  }, [variables]);
+
+  useEffect(() => {
+    if (viewMode === 'raw') {
+      const hasRawChanges = rawValue !== baselineRaw;
+      setIsModified(hasRawChanges);
+    } else {
+      const currentValuesJson = JSON.stringify(normalizeForComparison(formik.values));
+      const hasActualChanges = currentValuesJson !== savedValuesJson;
+      setIsModified(hasActualChanges);
+    }
+  }, [formik.values, savedValuesJson, setIsModified, viewMode, rawValue, baselineRaw]);
+
+  // Ref for stable formik.values access
+  const valuesRef = useRef(formik.values);
+  valuesRef.current = formik.values;
+
+  const handleRemoveVar = useCallback((id) => {
+    const currentValues = valuesRef.current;
+
+    if (!currentValues || currentValues.length === 0) {
+      return;
+    }
+
+    const lastRow = currentValues[currentValues.length - 1];
+    const isLastEmptyRow = lastRow?.uid === id && (!lastRow.name || lastRow.name.trim() === '');
+
+    if (isLastEmptyRow) {
+      return;
+    }
+
+    const filteredValues = currentValues.filter((variable) => variable.uid !== id);
+
+    const hasEmptyLastRow
+      = filteredValues.length > 0
+        && (!filteredValues[filteredValues.length - 1].name
+          || filteredValues[filteredValues.length - 1].name.trim() === '');
+
+    const newValues = hasEmptyLastRow
+      ? filteredValues
+      : [
+          ...filteredValues,
+          { uid: uuid(), name: '', value: '' }
+        ];
+
+    formikRef.current.setValues(newValues);
+  }, []);
+
+  const handleNameChange = useCallback((index, e) => {
+    formik.handleChange(e);
+    const isLastRow = index === valuesRef.current.length - 1;
+
+    if (isLastRow) {
+      const newVariable = { uid: uuid(), name: '', value: '' };
+      setTimeout(() => {
+        formik.setValues((prev) => {
+          const lastRow = prev[prev.length - 1];
+          if (lastRow?.name?.trim()) {
+            return [...prev, newVariable];
+          }
+          return prev;
+        });
+      }, 0);
+    }
+  }, []);
+
+  const handleNameBlur = useCallback((index) => {
+    formik.setFieldTouched(`${index}.name`, true, true);
+  }, []);
+
+  const handleNameKeyDown = useCallback((index, e) => {
+    if (e.key === 'Enter') {
+      e.preventDefault();
+      formik.setFieldTouched(`${index}.name`, true, true);
+    }
+  }, []);
+
+  const handleSave = useCallback(() => {
+    if (isSaving) return;
+
+    const variablesToSave = formik.values.filter((variable) => variable.name && variable.name.trim() !== '');
+
+    const hasValidationErrors = variablesToSave.some((variable) => {
+      if (!variable.name || variable.name.trim() === '') {
+        return true;
+      }
+      if (!variableNameRegex.test(variable.name)) {
+        return true;
+      }
+      return false;
+    });
+
+    if (hasValidationErrors) {
+      toast.error('Please fix validation errors before saving');
+      return;
+    }
+
+    setIsSaving(true);
+    onSave(variablesToSave)
+      .then(() => {
+        toast.success('Changes saved successfully');
+        const newValues = [
+          ...variablesToSave,
+          { uid: uuid(), name: '', value: '' }
+        ];
+        formik.resetForm({ values: newValues });
+        setIsModified(false);
+        window.dispatchEvent(new Event('dotenv-save-complete'));
+      })
+      .catch((error) => {
+        console.error(error);
+        toast.error('An error occurred while saving the changes');
+        window.dispatchEvent(new Event('dotenv-save-failed'));
+      })
+      .finally(() => {
+        setIsSaving(false);
+      });
+  }, [isSaving, formik.values, onSave, setIsModified]);
+
+  const handleSaveRaw = useCallback(() => {
+    if (isSaving) return;
+
+    if (!onSaveRaw) {
+      toast.error('Raw save is not supported');
+      return;
+    }
+
+    setIsSaving(true);
+    onSaveRaw(rawValue)
+      .then(() => {
+        toast.success('Changes saved successfully');
+        setIsModified(false);
+        window.dispatchEvent(new Event('dotenv-save-complete'));
+      })
+      .catch((error) => {
+        console.error(error);
+        toast.error('An error occurred while saving the changes');
+        window.dispatchEvent(new Event('dotenv-save-failed'));
+      })
+      .finally(() => {
+        setIsSaving(false);
+      });
+  }, [isSaving, rawValue, onSaveRaw, setIsModified]);
+
+  const handleReset = useCallback(() => {
+    if (viewMode === 'raw') {
+      setRawValue(baselineRaw);
+      setIsModified(false);
+    } else {
+      const originalVars = (variables || []).map((v) => ({
+        ...v,
+        uid: v.uid || uuid()
+      }));
+      const resetValues = [
+        ...originalVars,
+        { uid: uuid(), name: '', value: '' }
+      ];
+      formik.resetForm({ values: resetValues });
+      setIsModified(false);
+    }
+  }, [viewMode, baselineRaw, variables, setIsModified]);
+
+  const handleRawChange = useCallback((newValue) => {
+    setRawValue(newValue);
+  }, []);
+
+  // Global save event listener
+  const handleSaveRef = useRef(handleSave);
+  handleSaveRef.current = handleSave;
+
+  const handleSaveRawRef = useRef(handleSaveRaw);
+  handleSaveRawRef.current = handleSaveRaw;
+
+  useEffect(() => {
+    const handleSaveEvent = () => {
+      if (viewMode === 'raw') {
+        handleSaveRawRef.current();
+      } else {
+        handleSaveRef.current();
+      }
+    };
+
+    window.addEventListener('dotenv-save', handleSaveEvent);
+
+    return () => {
+      window.removeEventListener('dotenv-save', handleSaveEvent);
+    };
+  }, [viewMode]);
+
+  // Raw view mode
+  if (viewMode === 'raw') {
+    return (
+      <StyledWrapper>
+        <DotEnvRawView
+          collection={collection}
+          item={item}
+          theme={displayedTheme}
+          value={rawValue}
+          onChange={handleRawChange}
+          onSave={handleSaveRaw}
+          onReset={handleReset}
+          isSaving={showSaving}
+        />
+      </StyledWrapper>
+    );
+  }
+
+  // Empty state (no .env file exists yet)
+  const showEmptyState = !dotEnvExists && (!variables || variables.length === 0);
+
+  return (
+    <StyledWrapper>
+      {showEmptyState && <DotEnvEmptyState />}
+      <DotEnvTableView
+        formik={formik}
+        theme={displayedTheme}
+        showValueColumn={!showEmptyState}
+        tableHeight={showEmptyState ? MIN_TABLE_HEIGHT : tableHeight}
+        onHeightChange={setTableHeight}
+        onNameChange={handleNameChange}
+        onNameBlur={handleNameBlur}
+        onNameKeyDown={handleNameKeyDown}
+        onRemoveVar={handleRemoveVar}
+        onSave={handleSave}
+        onReset={handleReset}
+        isSaving={showSaving}
+      />
+    </StyledWrapper>
+  );
+};
+
+export default DotEnvFileEditor;

packages/bruno-app/src/components/Environments/DotEnvFileEditor/utils.js

@@ -0,0 +1,59 @@
+import { uuid } from 'utils/common';
+
+export const variablesToRaw = (variables) => {
+  return variables
+    .filter((v) => v.name && v.name.trim() !== '')
+    .map((v) => {
+      const value = v.value || '';
+      if (value.includes('\n') || value.includes('"') || value.includes('\'')) {
+        const escapedValue = value.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n');
+        return `${v.name}="${escapedValue}"`;
+      }
+      return `${v.name}=${value}`;
+    })
+    .join('\n');
+};
+
+export const rawToVariables = (rawContent) => {
+  if (!rawContent || rawContent.trim() === '') {
+    return [];
+  }
+
+  const variables = [];
+  const lines = rawContent.split('\n');
+
+  for (const line of lines) {
+    const trimmedLine = line.trim();
+
+    if (!trimmedLine || trimmedLine.startsWith('#')) {
+      continue;
+    }
+
+    const equalIndex = trimmedLine.indexOf('=');
+    if (equalIndex === -1) {
+      continue;
+    }
+
+    const name = trimmedLine.substring(0, equalIndex).trim();
+    let value = trimmedLine.substring(equalIndex + 1);
+
+    if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith('\'') && value.endsWith('\''))) {
+      value = value.slice(1, -1);
+      value = value.replace(/\\n/g, '\n').replace(/\\"/g, '"').replace(/\\\\/g, '\\');
+    }
+
+    if (name) {
+      variables.push({
+        uid: uuid(),
+        name,
+        value,
+        enabled: true,
+        secret: false
+      });
+    }
+  }
+
+  return variables;
+};
+
+export const MIN_TABLE_HEIGHT = 35 * 2;

packages/bruno-app/src/components/Environments/EnvironmentSelector/EnvironmentListContent/index.js

@@ -1,6 +1,7 @@
 import React from 'react';
 import { IconPlus, IconDownload, IconSettings } from '@tabler/icons';
 import ToolHint from 'components/ToolHint';
+import ColorBadge from 'components/ColorBadge';
 
 const EnvironmentListContent = ({
   environments,
@@ -38,6 +39,7 @@ const EnvironmentListContent = ({
                     data-tooltip-content={env.name}
                     data-tooltip-hidden={env.name?.length < 90}
                   >
+                    <ColorBadge color={env.color} size={8} />
                     <span className="max-w-100% truncate no-wrap">{env.name}</span>
                   </div>
                 ))}

packages/bruno-app/src/components/Environments/EnvironmentSelector/StyledWrapper.js

@@ -9,6 +9,7 @@ const Wrapper = styled.div`
     border: 1px solid ${(props) => props.theme.app.collection.toolbar.environmentSelector.border};
     line-height: 1rem;
     transition: all 0.15s ease;
+    height: 24px;
 
     &:hover {
       border-color: ${(props) => props.theme.app.collection.toolbar.environmentSelector.hoverBorder};
@@ -33,8 +34,7 @@ const Wrapper = styled.div`
     }
 
     .env-separator {
-      color: ${(props) => props.theme.app.collection.toolbar.environmentSelector.separator};
-      margin: 0 0.35rem;
+      background-color: ${(props) => props.theme.app.collection.toolbar.environmentSelector.separator};
     }
 
     .env-text-inactive {
@@ -74,7 +74,7 @@ const Wrapper = styled.div`
     border-top: 0.0625rem solid ${(props) => props.theme.dropdown.separator};
     z-index: 10;
     margin: 0;
-    
+
     &:hover {
       background-color: ${(props) => props.theme.dropdown.bg + ' !important'};
     }
@@ -120,7 +120,7 @@ const Wrapper = styled.div`
   .environment-list {
     flex: 1;
     overflow-y: auto;
-    max-height: calc(75vh - 8rem); 
+    max-height: calc(75vh - 8rem);
     padding-bottom: 2.625rem;
   }
 

packages/bruno-app/src/components/Environments/EnvironmentSelector/index.js

@@ -13,6 +13,166 @@ import ImportEnvironmentModal from 'components/Environments/Common/ImportEnviron
 import CreateGlobalEnvironment from 'components/WorkspaceHome/WorkspaceEnvironments/CreateEnvironment';
 import ToolHint from 'components/ToolHint';
 import StyledWrapper from './StyledWrapper';
+import { transparentize, toColorString, parseToRgb } from 'polished';
+
+const TABS = [
+  { id: 'collection', label: 'Collection', icon: <IconDatabase size={16} strokeWidth={1.5} /> },
+  { id: 'global', label: 'Global', icon: <IconWorld size={16} strokeWidth={1.5} /> }
+];
+
+const EMPTY_STATE_DESCRIPTIONS = {
+  collection: 'Create your first environment to begin working with your collection.',
+  global: 'Create your first global environment to begin working across collections.'
+};
+
+/**
+ * Generates background color with transparency for environment badges
+ */
+const getEnvBackgroundColor = (color) => (color ? transparentize(1 - 0.12, color) : 'transparent');
+
+/**
+ * Calculates the style for an environment badge section
+ */
+const getEnvBadgeStyle = (environment, position, hasOtherEnv) => {
+  const color = environment?.color;
+  const isLeft = position === 'left';
+
+  // Determine border radius based on position and whether other env exists
+  let borderRadius = '0.3rem';
+  if (hasOtherEnv) {
+    borderRadius = isLeft ? '0.3rem 0 0 0.3rem' : '0 0.3rem 0.3rem 0';
+  }
+
+  // Determine padding based on position
+  const padding = isLeft
+    ? hasOtherEnv
+      ? '0.25rem 0.5rem 0.25rem 0.5rem'
+      : '0.25rem 0.3rem 0.25rem 0.5rem'
+    : '0.25rem 0.3rem 0.25rem 0.5rem';
+
+  return {
+    backgroundColor: getEnvBackgroundColor(color),
+    padding,
+    borderRadius
+  };
+};
+
+/**
+ * Calculates dropdown width based on longest environment name
+ */
+const calculateDropdownWidth = (environments, globalEnvironments) => {
+  const allEnvironments = [...environments, ...globalEnvironments];
+  if (allEnvironments.length === 0) return 0;
+
+  const maxCharLength = Math.max(...allEnvironments.map((env) => env.name?.length || 0));
+  // 8 pixels per character (rough estimate for average character width)
+  return maxCharLength * 8;
+};
+
+/**
+ * Displays a single environment with icon, name, and optional color styling
+ */
+const EnvironmentBadge = ({ environment, icon: Icon }) => {
+  if (!environment) return null;
+
+  const colorStyle = environment.color ? { color: environment.color } : {};
+
+  return (
+    <>
+      <Icon size={14} strokeWidth={1.5} className="env-icon" style={colorStyle} />
+      <ToolHint
+        text={environment.name}
+        toolhintId={`env-${environment.uid}`}
+        place="bottom-start"
+        delayShow={1000}
+        hidden={environment.name?.length < 7}
+      >
+        <span className="env-text max-w-24 truncate overflow-hidden" style={colorStyle}>
+          {environment.name}
+        </span>
+      </ToolHint>
+    </>
+  );
+};
+
+/**
+ * Dropdown trigger component showing active environments
+ */
+const DropdownTrigger = forwardRef(({ collectionEnv, globalEnv }, ref) => {
+  const hasAnyEnv = collectionEnv || globalEnv;
+
+  // Empty state - no environments selected
+  if (!hasAnyEnv) {
+    return (
+      <div
+        ref={ref}
+        className="current-environment flex align-center justify-center cursor-pointer bg-transparent no-environments"
+        data-testid="environment-selector-trigger"
+      >
+        <span className="env-text-inactive max-w-36 truncate no-wrap">No Environment</span>
+        <IconCaretDown className="caret flex items-center justify-center" size={12} strokeWidth={2} />
+      </div>
+    );
+  }
+
+  // Only collection env selected - caret goes with collection env
+  if (collectionEnv && !globalEnv) {
+    return (
+      <div
+        ref={ref}
+        className="current-environment flex align-center justify-center cursor-pointer bg-transparent"
+        style={{ padding: 0 }}
+        data-testid="environment-selector-trigger"
+      >
+        <div className="flex items-center" style={getEnvBadgeStyle(collectionEnv, 'left', false)}>
+          <EnvironmentBadge environment={collectionEnv} icon={IconDatabase} />
+          <IconCaretDown className="caret flex items-center justify-center" size={12} strokeWidth={2} />
+        </div>
+      </div>
+    );
+  }
+
+  // Only global env selected - caret goes with global env
+  if (!collectionEnv && globalEnv) {
+    return (
+      <div
+        ref={ref}
+        className="current-environment flex align-center justify-center cursor-pointer bg-transparent"
+        style={{ padding: 0 }}
+        data-testid="environment-selector-trigger"
+      >
+        <div className="flex items-center" style={getEnvBadgeStyle(globalEnv, 'right', false)}>
+          <EnvironmentBadge environment={globalEnv} icon={IconWorld} />
+          <IconCaretDown className="caret flex items-center justify-center" size={12} strokeWidth={2} />
+        </div>
+      </div>
+    );
+  }
+
+  // Both environments selected
+  return (
+    <div
+      ref={ref}
+      className="current-environment flex align-center justify-center cursor-pointer bg-transparent"
+      style={{ padding: 0 }}
+      data-testid="environment-selector-trigger"
+    >
+      {/* Collection Environment Section */}
+      <div className="flex items-center" style={getEnvBadgeStyle(collectionEnv, 'left', true)}>
+        <EnvironmentBadge environment={collectionEnv} icon={IconDatabase} />
+      </div>
+
+      {/* Separator */}
+      <div className="env-separator" style={{ width: '1px', alignSelf: 'stretch' }} />
+
+      {/* Global Environment Section + Caret */}
+      <div className="flex items-center" style={getEnvBadgeStyle(globalEnv, 'right', true)}>
+        <EnvironmentBadge environment={globalEnv} icon={IconWorld} />
+        <IconCaretDown className="caret flex items-center justify-center" size={12} strokeWidth={2} />
+      </div>
+    </div>
+  );
+});
 
 const EnvironmentSelector = ({ collection }) => {
   const dispatch = useDispatch();
@@ -35,159 +195,82 @@ const EnvironmentSelector = ({ collection }) => {
     ? find(environments, (e) => e.uid === activeEnvironmentUid)
     : null;
 
-  const tabs = [
-    { id: 'collection', label: 'Collection', icon: <IconDatabase size={16} strokeWidth={1.5} /> },
-    { id: 'global', label: 'Global', icon: <IconWorld size={16} strokeWidth={1.5} /> }
-  ];
+  const dropdownWidth = useMemo(
+    () => calculateDropdownWidth(environments, globalEnvironments),
+    [environments, globalEnvironments]
+  );
 
-  const onDropdownCreate = (ref) => {
-    dropdownTippyRef.current = ref;
-  };
+  const description = EMPTY_STATE_DESCRIPTIONS[activeTab];
 
-  // Get description based on active tab
-  const description
-    = activeTab === 'collection'
-      ? 'Create your first environment to begin working with your collection.'
-      : 'Create your first global environment to begin working across collections.';
+  const hideDropdown = () => dropdownTippyRef.current?.hide();
 
-  // Environment selection handler
   const handleEnvironmentSelect = (environment) => {
     const action
       = activeTab === 'collection'
-        ? selectEnvironment(environment ? environment.uid : null, collection.uid)
-        : selectGlobalEnvironment({ environmentUid: environment ? environment.uid : null });
+        ? selectEnvironment(environment?.uid || null, collection.uid)
+        : selectGlobalEnvironment({ environmentUid: environment?.uid || null });
 
     dispatch(action)
       .then(() => {
-        if (environment) {
-          toast.success(`Environment changed to ${environment.name}`);
-        } else {
-          toast.success('No Environments are active now');
-        }
-        dropdownTippyRef.current.hide();
+        toast.success(environment ? `Environment changed to ${environment.name}` : 'No Environments are active now');
+        hideDropdown();
       })
-      .catch((err) => {
+      .catch(() => {
         toast.error('An error occurred while selecting the environment');
       });
   };
 
-  // Settings handler - opens environment settings tab
   const handleSettingsClick = () => {
-    if (activeTab === 'collection') {
-      dispatch(
-        addTab({
-          uid: `${collection.uid}-environment-settings`,
-          collectionUid: collection.uid,
-          type: 'environment-settings'
-        })
-      );
-    } else {
-      dispatch(
-        addTab({
-          uid: `${collection.uid}-global-environment-settings`,
-          collectionUid: collection.uid,
-          type: 'global-environment-settings'
-        })
-      );
-    }
-    dropdownTippyRef.current.hide();
+    const isCollection = activeTab === 'collection';
+    dispatch(
+      addTab({
+        uid: `${collection.uid}-${isCollection ? 'environment' : 'global-environment'}-settings`,
+        collectionUid: collection.uid,
+        type: isCollection ? 'environment-settings' : 'global-environment-settings'
+      })
+    );
+    hideDropdown();
   };
 
-  // Create handler
   const handleCreateClick = () => {
     if (activeTab === 'collection') {
       setShowCreateCollectionModal(true);
     } else {
       setShowCreateGlobalModal(true);
     }
-    dropdownTippyRef.current.hide();
+    hideDropdown();
   };
 
-  // Import handler
   const handleImportClick = () => {
     if (activeTab === 'collection') {
       setShowImportCollectionModal(true);
     } else {
       setShowImportGlobalModal(true);
     }
-    dropdownTippyRef.current.hide();
+    hideDropdown();
   };
 
-  // Calculate dropdown width based on the longest environment name.
-  // To prevent resizing while switching between collection and global environments.
-  const dropdownWidth = useMemo(() => {
-    const allEnvironments = [...environments, ...globalEnvironments];
-    if (allEnvironments.length === 0) return 0;
-
-    const maxCharLength = Math.max(...allEnvironments.map((env) => env.name?.length || 0));
-    // 8 pixels per character: This is a rough estimate for the average character width in most fonts
-    // (monospace fonts are typically 8-10px, proportional fonts vary but 8px is a safe average)
-    return maxCharLength * 8;
-  }, [environments, globalEnvironments]);
-
-  // Create icon component for dropdown trigger
-  const Icon = forwardRef((props, ref) => {
-    const hasAnyEnv = activeGlobalEnvironment || activeCollectionEnvironment;
-
-    const displayContent = hasAnyEnv ? (
-      <>
-        {activeCollectionEnvironment && (
-          <>
-            <div className="flex items-center">
-              <IconDatabase size={14} strokeWidth={1.5} className="env-icon" />
-              <ToolHint
-                text={activeCollectionEnvironment.name}
-                toolhintId={`collection-env-${activeCollectionEnvironment.uid}`}
-                place="bottom-start"
-                delayShow={1000}
-                hidden={activeCollectionEnvironment.name?.length < 7}
-              >
-                <span className="env-text max-w-24 truncate overflow-hidden">{activeCollectionEnvironment.name}</span>
-              </ToolHint>
-            </div>
-            {activeGlobalEnvironment && <span className="env-separator">|</span>}
-          </>
-        )}
-        {activeGlobalEnvironment && (
-          <div className="flex items-center">
-            <IconWorld size={14} strokeWidth={1.5} className="env-icon" />
-            <ToolHint
-              text={activeGlobalEnvironment.name}
-              toolhintId={`global-env-${activeGlobalEnvironment.uid}`}
-              place="bottom-start"
-              delayShow={1000}
-              hidden={activeGlobalEnvironment.name?.length < 7}
-            >
-              <span className="env-text max-w-24 truncate overflow-hidden">{activeGlobalEnvironment.name}</span>
-            </ToolHint>
-          </div>
-        )}
-      </>
-    ) : (
-      <span className="env-text-inactive max-w-36 truncate no-wrap">No Environment</span>
+  const openEnvironmentSettingsTab = (type) => {
+    dispatch(
+      addTab({
+        uid: `${collection.uid}-${type}-settings`,
+        collectionUid: collection.uid,
+        type: `${type}-settings`
+      })
     );
-
-    return (
-      <div
-        ref={ref}
-        className={`current-environment flex align-center justify-center cursor-pointer bg-transparent ${
-          !hasAnyEnv ? 'no-environments' : ''
-        }`}
-        data-testid="environment-selector-trigger"
-      >
-        {displayContent}
-        <IconCaretDown className="caret flex items-center justify-center" size={12} strokeWidth={2} />
-      </div>
-    );
-  });
+  };
 
   return (
     <StyledWrapper width={dropdownWidth}>
       <div className="environment-selector flex align-center cursor-pointer">
-        <Dropdown onCreate={onDropdownCreate} icon={<Icon />} placement="bottom-end">
+        <Dropdown
+          onCreate={(ref) => (dropdownTippyRef.current = ref)}
+          icon={<DropdownTrigger collectionEnv={activeCollectionEnvironment} globalEnv={activeGlobalEnvironment} />}
+          placement="bottom-end"
+        >
           {/* Tab Headers */}
           <div className="tab-header flex pt-3 pb-2 px-3">
-            {tabs.map((tab) => (
+            {TABS.map((tab) => (
               <button
                 key={tab.id}
                 className={`tab-button whitespace-nowrap pb-[0.375rem] border-b-[0.125rem] bg-transparent flex align-center cursor-pointer transition-all duration-200 mr-[1.25rem] ${
@@ -222,15 +305,7 @@ const EnvironmentSelector = ({ collection }) => {
       {showCreateGlobalModal && (
         <CreateGlobalEnvironment
           onClose={() => setShowCreateGlobalModal(false)}
-          onEnvironmentCreated={() => {
-            dispatch(
-              addTab({
-                uid: `${collection.uid}-global-environment-settings`,
-                collectionUid: collection.uid,
-                type: 'global-environment-settings'
-              })
-            );
-          }}
+          onEnvironmentCreated={() => openEnvironmentSettingsTab('global-environment')}
         />
       )}
 
@@ -238,15 +313,7 @@ const EnvironmentSelector = ({ collection }) => {
         <ImportEnvironmentModal
           type="global"
           onClose={() => setShowImportGlobalModal(false)}
-          onEnvironmentCreated={() => {
-            dispatch(
-              addTab({
-                uid: `${collection.uid}-global-environment-settings`,
-                collectionUid: collection.uid,
-                type: 'global-environment-settings'
-              })
-            );
-          }}
+          onEnvironmentCreated={() => openEnvironmentSettingsTab('global-environment')}
         />
       )}
 
@@ -254,15 +321,7 @@ const EnvironmentSelector = ({ collection }) => {
         <CreateEnvironment
           collection={collection}
           onClose={() => setShowCreateCollectionModal(false)}
-          onEnvironmentCreated={() => {
-            dispatch(
-              addTab({
-                uid: `${collection.uid}-environment-settings`,
-                collectionUid: collection.uid,
-                type: 'environment-settings'
-              })
-            );
-          }}
+          onEnvironmentCreated={() => openEnvironmentSettingsTab('environment')}
         />
       )}
 
@@ -271,15 +330,7 @@ const EnvironmentSelector = ({ collection }) => {
           type="collection"
           collection={collection}
           onClose={() => setShowImportCollectionModal(false)}
-          onEnvironmentCreated={() => {
-            dispatch(
-              addTab({
-                uid: `${collection.uid}-environment-settings`,
-                collectionUid: collection.uid,
-                type: 'environment-settings'
-              })
-            );
-          }}
+          onEnvironmentCreated={() => openEnvironmentSettingsTab('environment')}
         />
       )}
     </StyledWrapper>

packages/bruno-app/src/components/Environments/EnvironmentSettings/DeleteDotEnvFile/StyledWrapper.js

@@ -0,0 +1,15 @@
+import styled from 'styled-components';
+
+const Wrapper = styled.div`
+  button.submit {
+    color: white;
+    background-color: var(--color-background-danger) !important;
+    border: inherit !important;
+
+    &:hover {
+      border: inherit !important;
+    }
+  }
+`;
+
+export default Wrapper;

packages/bruno-app/src/components/Environments/EnvironmentSettings/DeleteDotEnvFile/index.js

@@ -0,0 +1,30 @@
+import React from 'react';
+import Portal from 'components/Portal/index';
+import Modal from 'components/Modal/index';
+import StyledWrapper from './StyledWrapper';
+
+const DeleteDotEnvFile = ({ onClose, onConfirm, filename = '.env' }) => {
+  const handleConfirm = () => {
+    onConfirm();
+    onClose();
+  };
+
+  return (
+    <Portal>
+      <StyledWrapper>
+        <Modal
+          size="sm"
+          title={`Delete ${filename} File`}
+          confirmText="Delete"
+          handleConfirm={handleConfirm}
+          handleCancel={onClose}
+          confirmButtonColor="danger"
+        >
+          Are you sure you want to delete <span className="font-medium">{filename}</span> file?
+        </Modal>
+      </StyledWrapper>
+    </Portal>
+  );
+};
+
+export default DeleteDotEnvFile;

packages/bruno-app/src/components/Environments/EnvironmentSettings/EnvironmentList/EnvironmentDetails/EnvironmentVariables/index.js

@@ -1,57 +1,20 @@
-import React, { useCallback, useRef, useMemo, useEffect } from 'react';
-import { TableVirtuoso } from 'react-virtuoso';
+import React, { useMemo, useCallback } from 'react';
 import cloneDeep from 'lodash/cloneDeep';
 import { get } from 'lodash';
-import { IconTrash, IconAlertCircle, IconInfoCircle } from '@tabler/icons';
-import { useTheme } from 'providers/Theme';
-import { useDispatch, useSelector } from 'react-redux';
-import MultiLineEditor from 'components/MultiLineEditor/index';
-import StyledWrapper from './StyledWrapper';
-import { uuid } from 'utils/common';
-import { useFormik } from 'formik';
-import * as Yup from 'yup';
-import { variableNameRegex } from 'utils/common/regex';
-import toast from 'react-hot-toast';
+import { useDispatch } from 'react-redux';
 import { saveEnvironment } from 'providers/ReduxStore/slices/collections/actions';
 import { setEnvironmentsDraft, clearEnvironmentsDraft } from 'providers/ReduxStore/slices/collections';
-import { Tooltip } from 'react-tooltip';
-import { getGlobalEnvironmentVariables, flattenItems, isItemARequest } from 'utils/collections';
+import { flattenItems, isItemARequest } from 'utils/collections';
 import SensitiveFieldWarning from 'components/SensitiveFieldWarning';
+import EnvironmentVariablesTable from 'components/EnvironmentVariablesTable';
 import { sensitiveFields } from './constants';
 
-const TableRow = React.memo(({ children, item }) => <tr key={item.uid} data-testid={`env-var-row-${item.name}`}>{children}</tr>, (prevProps, nextProps) => {
-  const prevUid = prevProps?.item?.uid;
-  const nextUid = nextProps?.item?.uid;
-  return prevUid === nextUid && prevProps.children === nextProps.children;
-});
-
-const MIN_H = 35 * 2; // 2 rows worth of height
-
-const EnvironmentVariables = ({ environment, setIsModified, collection }) => {
+const EnvironmentVariables = ({ environment, setIsModified, collection, searchQuery = '' }) => {
   const dispatch = useDispatch();
-  const { storedTheme } = useTheme();
-  const { globalEnvironments, activeGlobalEnvironmentUid } = useSelector((state) => state.globalEnvironments);
-
-  const [tableHeight, setTableHeight] = React.useState(MIN_H);
 
   const environmentsDraft = collection?.environmentsDraft;
   const hasDraftForThisEnv = environmentsDraft?.environmentUid === environment.uid;
 
-  const handleTotalHeightChanged = React.useCallback((h) => {
-    setTableHeight(h);
-  }, []);
-
-  // Track environment changes for draft restoration
-  const prevEnvUidRef = React.useRef(null);
-  const mountedRef = React.useRef(false);
-
-  let _collection = collection ? cloneDeep(collection) : {};
-
-  const globalEnvironmentVariables = getGlobalEnvironmentVariables({ globalEnvironments, activeGlobalEnvironmentUid });
-  if (_collection) {
-    _collection.globalEnvironmentVariables = globalEnvironmentVariables;
-  }
-
   // Check for non-secret variables used in sensitive fields
   const nonSecretSensitiveVarUsageMap = useMemo(() => {
     const result = {};
@@ -97,428 +60,59 @@ const EnvironmentVariables = ({ environment, setIsModified, collection }) => {
     return result;
   }, [collection, environment]);
 
-  const hasSensitiveUsage = (name) => !!nonSecretSensitiveVarUsageMap[name];
+  const hasSensitiveUsage = useCallback((name) => !!nonSecretSensitiveVarUsageMap[name], [nonSecretSensitiveVarUsageMap]);
 
-  // Initial values based only on saved environment variables (not draft)
-  // Draft restoration happens in a separate effect to avoid infinite loops
-  const initialValues = React.useMemo(() => {
-    const vars = environment.variables || [];
-    return [
-      ...vars,
-      {
-        uid: uuid(),
-        name: '',
-        value: '',
-        type: 'text',
-        secret: false,
-        enabled: true
-      }
-    ];
-  }, [environment.uid, environment.variables]);
-
-  const formik = useFormik({
-    enableReinitialize: true,
-    initialValues: initialValues,
-    validationSchema: Yup.array().of(
-      Yup.object({
-        enabled: Yup.boolean(),
-        name: Yup.string()
-          .when('$isLastRow', {
-            is: true,
-            then: (schema) => schema.optional(),
-            otherwise: (schema) =>
-              schema
-                .required('Name cannot be empty')
-                .matches(
-                  variableNameRegex,
-                  'Name contains invalid characters. Must only contain alphanumeric characters, "-", "_", "." and cannot start with a digit.'
-                )
-                .trim()
-          }),
-        secret: Yup.boolean(),
-        type: Yup.string(),
-        uid: Yup.string(),
-        value: Yup.mixed().nullable()
-      })
-    ),
-    validate: (values) => {
-      const errors = {};
-      values.forEach((variable, index) => {
-        const isLastRow = index === values.length - 1;
-        const isEmptyRow = !variable.name || variable.name.trim() === '';
-
-        if (isLastRow && isEmptyRow) {
-          return;
-        }
-
-        if (!variable.name || variable.name.trim() === '') {
-          if (!errors[index]) errors[index] = {};
-          errors[index].name = 'Name cannot be empty';
-        } else if (!variableNameRegex.test(variable.name)) {
-          if (!errors[index]) errors[index] = {};
-          errors[index].name
-            = 'Name contains invalid characters. Must only contain alphanumeric characters, "-", "_", "." and cannot start with a digit.';
-        }
-      });
-      return Object.keys(errors).length > 0 ? errors : {};
+  const handleSave = useCallback(
+    (variables) => {
+      return dispatch(saveEnvironment(cloneDeep(variables), environment.uid, collection.uid));
     },
-    onSubmit: () => {}
-  });
+    [dispatch, environment.uid, collection.uid]
+  );
 
-  // Restore draft values on mount or environment switch
-  useEffect(() => {
-    const isMount = !mountedRef.current;
-    const envChanged = prevEnvUidRef.current !== null && prevEnvUidRef.current !== environment.uid;
+  const handleDraftChange = useCallback(
+    (variables) => {
+      dispatch(
+        setEnvironmentsDraft({
+          collectionUid: collection.uid,
+          environmentUid: environment.uid,
+          variables
+        })
+      );
+    },
+    [dispatch, collection.uid, environment.uid]
+  );
 
-    prevEnvUidRef.current = environment.uid;
-    mountedRef.current = true;
+  const handleDraftClear = useCallback(() => {
+    dispatch(clearEnvironmentsDraft({ collectionUid: collection.uid }));
+  }, [dispatch, collection.uid]);
 
-    if ((isMount || envChanged) && hasDraftForThisEnv && environmentsDraft?.variables) {
-      formik.setValues([
-        ...environmentsDraft.variables,
-        {
-          uid: uuid(),
-          name: '',
-          value: '',
-          type: 'text',
-          secret: false,
-          enabled: true
-        }
-      ]);
-    }
-  }, [environment.uid, hasDraftForThisEnv, environmentsDraft?.variables]);
-
-  const savedValuesJson = useMemo(() => {
-    return JSON.stringify(environment.variables || []);
-  }, [environment.variables]);
-
-  useEffect(() => {
-    const currentValues = formik.values.filter((variable) => variable.name && variable.name.trim() !== '');
-    const currentValuesJson = JSON.stringify(currentValues);
-    const hasActualChanges = currentValuesJson !== savedValuesJson;
-    setIsModified(hasActualChanges);
-  }, [formik.values, savedValuesJson, setIsModified]);
-
-  useEffect(() => {
-    const timeoutId = setTimeout(() => {
-      const currentValues = formik.values.filter((variable) => variable.name && variable.name.trim() !== '');
-      const currentValuesJson = JSON.stringify(currentValues);
-      const hasActualChanges = currentValuesJson !== savedValuesJson;
-
-      // Get existing draft for comparison
-      const existingDraftVariables = hasDraftForThisEnv ? environmentsDraft?.variables : null;
-      const existingDraftJson = existingDraftVariables ? JSON.stringify(existingDraftVariables) : null;
-
-      if (hasActualChanges) {
-        // Only dispatch if draft values are actually different
-        if (currentValuesJson !== existingDraftJson) {
-          dispatch(setEnvironmentsDraft({
-            collectionUid: collection.uid,
-            environmentUid: environment.uid,
-            variables: currentValues
-          }));
-        }
-      } else if (hasDraftForThisEnv) {
-        dispatch(clearEnvironmentsDraft({ collectionUid: collection.uid }));
+  const renderExtraValueContent = useCallback(
+    (variable) => {
+      if (!variable.secret && hasSensitiveUsage(variable.name)) {
+        return (
+          <SensitiveFieldWarning
+            fieldName={variable.name}
+            warningMessage="This variable is used in sensitive fields. Mark it as a secret for security"
+          />
+        );
       }
-    }, 300);
-
-    return () => clearTimeout(timeoutId);
-  }, [formik.values, savedValuesJson, environment.uid, collection.uid, dispatch, hasDraftForThisEnv, environmentsDraft?.variables]);
-
-  const ErrorMessage = ({ name, index }) => {
-    const meta = formik.getFieldMeta(name);
-    const id = `error-${name}-${index}`;
-
-    const isLastRow = index === formik.values.length - 1;
-    const variable = formik.values[index];
-    const isEmptyRow = !variable?.name || variable.name.trim() === '';
-
-    if (isLastRow && isEmptyRow) {
       return null;
-    }
-
-    if (!meta.error || !meta.touched) {
-      return null;
-    }
-    return (
-      <span>
-        <IconAlertCircle id={id} className="text-red-600 cursor-pointer" size={20} />
-        <Tooltip className="tooltip-mod" anchorId={id} html={meta.error || ''} />
-      </span>
-    );
-  };
-
-  const handleRemoveVar = useCallback((id) => {
-    const currentValues = formik.values;
-
-    if (!currentValues || currentValues.length === 0) {
-      return;
-    }
-
-    const lastRow = currentValues[currentValues.length - 1];
-    const isLastEmptyRow = lastRow?.uid === id && (!lastRow.name || lastRow.name.trim() === '');
-
-    if (isLastEmptyRow) {
-      return;
-    }
-
-    const filteredValues = currentValues.filter((variable) => variable.uid !== id);
-
-    const hasEmptyLastRow
-      = filteredValues.length > 0
-        && (!filteredValues[filteredValues.length - 1].name
-          || filteredValues[filteredValues.length - 1].name.trim() === '');
-
-    const newValues = hasEmptyLastRow
-      ? filteredValues
-      : [
-          ...filteredValues,
-          {
-            uid: uuid(),
-            name: '',
-            value: '',
-            type: 'text',
-            secret: false,
-            enabled: true
-          }
-        ];
-
-    formik.setValues(newValues);
-  }, [formik.values]);
-
-  const handleNameChange = (index, e) => {
-    formik.handleChange(e);
-    const isLastRow = index === formik.values.length - 1;
-
-    if (isLastRow) {
-      const newVariable = {
-        uid: uuid(),
-        name: '',
-        value: '',
-        type: 'text',
-        secret: false,
-        enabled: true
-      };
-      setTimeout(() => {
-        formik.setFieldValue(formik.values.length, newVariable, false);
-      }, 0);
-    }
-  };
-
-  const handleNameBlur = (index) => {
-    formik.setFieldTouched(`${index}.name`, true, true);
-  };
-
-  const handleNameKeyDown = (index, e) => {
-    if (e.key === 'Enter') {
-      e.preventDefault();
-      formik.setFieldTouched(`${index}.name`, true, true);
-    }
-  };
-
-  const handleSave = () => {
-    const variablesToSave = formik.values.filter((variable) => variable.name && variable.name.trim() !== '');
-    const savedValues = environment.variables || [];
-
-    const hasChanges = JSON.stringify(variablesToSave) !== JSON.stringify(savedValues);
-    if (!hasChanges) {
-      toast.error('No changes to save');
-      return;
-    }
-
-    const hasValidationErrors = variablesToSave.some((variable) => {
-      if (!variable.name || variable.name.trim() === '') {
-        return true;
-      }
-      if (!variableNameRegex.test(variable.name)) {
-        return true;
-      }
-      return false;
-    });
-
-    if (hasValidationErrors) {
-      toast.error('Please fix validation errors before saving');
-      return;
-    }
-
-    dispatch(saveEnvironment(cloneDeep(variablesToSave), environment.uid, collection.uid))
-      .then(() => {
-        toast.success('Changes saved successfully');
-        const newValues = [
-          ...variablesToSave,
-          {
-            uid: uuid(),
-            name: '',
-            value: '',
-            type: 'text',
-            secret: false,
-            enabled: true
-          }
-        ];
-        formik.resetForm({ values: newValues });
-        setIsModified(false);
-      })
-      .catch((error) => {
-        console.error(error);
-        toast.error('An error occurred while saving the changes');
-      });
-  };
-
-  const handleReset = () => {
-    const originalVars = environment.variables || [];
-    const resetValues = [
-      ...originalVars,
-      {
-        uid: uuid(),
-        name: '',
-        value: '',
-        type: 'text',
-        secret: false,
-        enabled: true
-      }
-    ];
-    formik.resetForm({ values: resetValues });
-    setIsModified(false);
-  };
-
-  const handleSaveRef = useRef(handleSave);
-  handleSaveRef.current = handleSave;
-
-  useEffect(() => {
-    const handleSaveEvent = () => {
-      handleSaveRef.current();
-    };
-
-    window.addEventListener('environment-save', handleSaveEvent);
-
-    return () => {
-      window.removeEventListener('environment-save', handleSaveEvent);
-    };
-  }, []);
+    },
+    [hasSensitiveUsage]
+  );
 
   return (
-    <StyledWrapper>
-      <TableVirtuoso
-        className="table-container"
-        style={{ height: tableHeight }}
-        components={{ TableRow }}
-        data={formik.values}
-        totalListHeightChanged={handleTotalHeightChanged}
-        fixedHeaderContent={() => (
-          <tr>
-            <td className="text-center"></td>
-            <td>Name</td>
-            <td>Value</td>
-            <td className="text-center">Secret</td>
-            <td></td>
-          </tr>
-        )}
-        fixedItemHeight={35}
-        computeItemKey={(index, variable) => variable.uid}
-        itemContent={(index, variable) => {
-          const isLastRow = index === formik.values.length - 1;
-          const isEmptyRow = !variable.name || variable.name.trim() === '';
-          const isLastEmptyRow = isLastRow && isEmptyRow;
-
-          return (
-            <>
-              <td className="text-center">
-                {!isLastEmptyRow && (
-                  <input
-                    type="checkbox"
-                    className="mousetrap"
-                    name={`${index}.enabled`}
-                    checked={variable.enabled}
-                    onChange={formik.handleChange}
-                  />
-                )}
-              </td>
-              <td>
-                <div className="flex items-center">
-                  <input
-                    type="text"
-                    autoComplete="off"
-                    autoCorrect="off"
-                    autoCapitalize="off"
-                    spellCheck="false"
-                    className="mousetrap"
-                    id={`${index}.name`}
-                    name={`${index}.name`}
-                    value={variable.name}
-                    placeholder={isLastEmptyRow ? 'Name' : ''}
-                    onChange={(e) => handleNameChange(index, e)}
-                    onBlur={() => handleNameBlur(index)}
-                    onKeyDown={(e) => handleNameKeyDown(index, e)}
-                  />
-                  <ErrorMessage name={`${index}.name`} index={index} />
-                </div>
-              </td>
-              <td className="flex flex-row flex-nowrap items-center">
-                <div className="overflow-hidden grow w-full relative">
-                  <MultiLineEditor
-                    theme={storedTheme}
-                    collection={_collection}
-                    name={`${index}.value`}
-                    value={variable.value}
-                    placeholder={isLastEmptyRow ? 'Value' : ''}
-                    isSecret={variable.secret}
-                    readOnly={typeof variable.value !== 'string'}
-                    onChange={(newValue) => formik.setFieldValue(`${index}.value`, newValue, true)}
-                    onSave={handleSave}
-                  />
-                </div>
-                {typeof variable.value !== 'string' && (
-                  <span className="ml-2 flex items-center">
-                    <IconInfoCircle id={`${variable.uid}-disabled-info-icon`} className="text-muted" size={16} />
-                    <Tooltip
-                      anchorId={`${variable.uid}-disabled-info-icon`}
-                      content="Non-string values set via scripts are read-only and can only be updated through scripts."
-                      place="top"
-                    />
-                  </span>
-                )}
-                {!variable.secret && hasSensitiveUsage(variable.name) && (
-                  <SensitiveFieldWarning
-                    fieldName={variable.name}
-                    warningMessage="This variable is used in sensitive fields. Mark it as a secret for security"
-                  />
-                )}
-              </td>
-              <td className="text-center">
-                {!isLastEmptyRow && (
-                  <input
-                    type="checkbox"
-                    className="mousetrap"
-                    name={`${index}.secret`}
-                    checked={variable.secret}
-                    onChange={formik.handleChange}
-                  />
-                )}
-              </td>
-              <td>
-                {!isLastEmptyRow && (
-                  <button onClick={() => handleRemoveVar(variable.uid)}>
-                    <IconTrash strokeWidth={1.5} size={18} />
-                  </button>
-                )}
-              </td>
-            </>
-          );
-        }}
-      />
-
-      <div className="button-container">
-        <div className="flex items-center">
-          <button type="button" className="submit" onClick={handleSave} data-testid="save-env">
-            Save
-          </button>
-          <button type="button" className="submit reset ml-2" onClick={handleReset} data-testid="reset-env">
-            Reset
-          </button>
-        </div>
-      </div>
-    </StyledWrapper>
+    <EnvironmentVariablesTable
+      environment={environment}
+      collection={collection}
+      onSave={handleSave}
+      draft={hasDraftForThisEnv ? environmentsDraft : null}
+      onDraftChange={handleDraftChange}
+      onDraftClear={handleDraftClear}
+      setIsModified={setIsModified}
+      renderExtraValueContent={renderExtraValueContent}
+      searchQuery={searchQuery}
+    />
   );
 };
 

packages/bruno-app/src/components/Environments/EnvironmentSettings/EnvironmentList/EnvironmentDetails/StyledWrapper.js

@@ -12,7 +12,7 @@ const StyledWrapper = styled.div`
     display: flex;
     align-items: center;
     justify-content: space-between;
-    padding: 16px 20px 8px 20px;
+    padding: 9px 20px 8px 20px;
     flex-shrink: 0;
 
     .title {
@@ -94,8 +94,63 @@ const StyledWrapper = styled.div`
 
     .actions {
       display: flex;
+      align-items: center;
       gap: 2px;
 
+      .search-input-wrapper {
+        position: relative;
+        display: flex;
+        align-items: center;
+
+        .search-icon {
+          position: absolute;
+          left: 8px;
+          color: ${(props) => props.theme.colors.text.muted};
+          pointer-events: none;
+        }
+
+        .search-input {
+          width: 200px;
+          padding: 5px 32px 5px 32px;
+          border: 1px solid ${(props) => props.theme.input.border};
+          border-radius: ${(props) => props.theme.border.radius.sm};
+          background: ${(props) => props.theme.input.bg};
+          color: ${(props) => props.theme.text};
+          font-size: ${(props) => props.theme.font.size.base};
+          outline: none;
+          transition: border-color 0.15s ease;
+
+          &:focus {
+            border-color: ${(props) => props.theme.input.focusBorder};
+          }
+
+          &::placeholder {
+            color: ${(props) => props.theme.input.placeholder.color};
+            opacity: ${(props) => props.theme.input.placeholder.opacity};
+          }
+        }
+
+        .clear-search {
+          position: absolute;
+          right: 1px;
+          padding: 4px;
+          display: flex;
+          align-items: center;
+          justify-content: center;
+          color: ${(props) => props.theme.colors.text.muted};
+          background: transparent;
+          border: none;
+          cursor: pointer;
+          border-radius: ${(props) => props.theme.border.radius.sm};
+          transition: all 0.15s ease;
+
+          &:hover {
+            color: ${(props) => props.theme.text};
+            background: ${(props) => props.theme.sidebar.collection.item.hoverBg};
+          }
+        }
+      }
+
       button {
         display: inline-flex;
         align-items: center;

packages/bruno-app/src/components/Environments/EnvironmentSettings/EnvironmentList/EnvironmentDetails/index.js

@@ -1,15 +1,16 @@
-import { IconCopy, IconEdit, IconTrash, IconCheck, IconX } from '@tabler/icons';
+import { IconCopy, IconEdit, IconTrash, IconCheck, IconX, IconSearch } from '@tabler/icons';
 import { useState, useRef } from 'react';
 import { useDispatch } from 'react-redux';
-import { renameEnvironment } from 'providers/ReduxStore/slices/collections/actions';
+import { renameEnvironment, updateEnvironmentColor } from 'providers/ReduxStore/slices/collections/actions';
 import { validateName, validateNameError } from 'utils/common/regex';
 import toast from 'react-hot-toast';
 import CopyEnvironment from 'components/Environments/EnvironmentSettings/CopyEnvironment';
 import DeleteEnvironment from 'components/Environments/EnvironmentSettings/DeleteEnvironment';
 import EnvironmentVariables from './EnvironmentVariables';
+import ColorPicker from 'components/ColorPicker';
 import StyledWrapper from './StyledWrapper';
 
-const EnvironmentDetails = ({ environment, setIsModified, collection }) => {
+const EnvironmentDetails = ({ environment, setIsModified, collection, searchQuery, setSearchQuery, isSearchExpanded, setIsSearchExpanded, debouncedSearchQuery, searchInputRef }) => {
   const dispatch = useDispatch();
   const environments = collection?.environments || [];
 
@@ -111,6 +112,27 @@ const EnvironmentDetails = ({ environment, setIsModified, collection }) => {
     }
   };
 
+  const handleSearchIconClick = () => {
+    setIsSearchExpanded(true);
+    setTimeout(() => {
+      searchInputRef.current?.focus();
+    }, 50);
+  };
+
+  const handleClearSearch = () => {
+    setSearchQuery('');
+  };
+
+  const handleSearchBlur = () => {
+    if (searchQuery === '') {
+      setIsSearchExpanded(false);
+    }
+  };
+
+  const handleColorChange = (color) => {
+    dispatch(updateEnvironmentColor(environment.uid, color, collection.uid));
+  };
+
   return (
     <StyledWrapper>
       {openDeleteModal && (
@@ -157,11 +179,46 @@ const EnvironmentDetails = ({ environment, setIsModified, collection }) => {
               </div>
             </>
           ) : (
-            <h2 className="title">{environment.name}</h2>
+            <div className="flex items-center gap-2">
+              <h2 className="title">{environment.name}</h2>
+              <ColorPicker color={environment.color} onChange={handleColorChange} />
+            </div>
           )}
         </div>
         {nameError && isRenaming && <div className="title-error">{nameError}</div>}
         <div className="actions">
+          {isSearchExpanded ? (
+            <div className="search-input-wrapper">
+              <IconSearch size={14} strokeWidth={1.5} className="search-icon" />
+              <input
+                ref={searchInputRef}
+                type="text"
+                placeholder="Search variables..."
+                value={searchQuery}
+                onChange={(e) => setSearchQuery(e.target.value)}
+                onBlur={handleSearchBlur}
+                className="search-input"
+                autoComplete="off"
+                autoCorrect="off"
+                autoCapitalize="off"
+                spellCheck="false"
+              />
+              {searchQuery && (
+                <button
+                  className="clear-search"
+                  onClick={handleClearSearch}
+                  onMouseDown={(e) => e.preventDefault()}
+                  title="Clear search"
+                >
+                  <IconX size={14} strokeWidth={1.5} />
+                </button>
+              )}
+            </div>
+          ) : (
+            <button onClick={handleSearchIconClick} title="Search variables">
+              <IconSearch size={15} strokeWidth={1.5} />
+            </button>
+          )}
           <button onClick={handleRenameClick} title="Rename">
             <IconEdit size={15} strokeWidth={1.5} />
           </button>
@@ -175,7 +232,12 @@ const EnvironmentDetails = ({ environment, setIsModified, collection }) => {
       </div>
 
       <div className="content">
-        <EnvironmentVariables environment={environment} setIsModified={setIsModified} collection={collection} />
+        <EnvironmentVariables
+          environment={environment}
+          setIsModified={setIsModified}
+          collection={collection}
+          searchQuery={debouncedSearchQuery}
+        />
       </div>
     </StyledWrapper>
   );

packages/bruno-app/src/components/Environments/EnvironmentSettings/EnvironmentList/StyledWrapper.js

@@ -32,19 +32,6 @@ const StyledWrapper = styled.div`
     flex-direction: column;
   }
 
-  .sidebar-header {
-    display: flex;
-    align-items: center;
-    justify-content: space-between;
-    padding: 16px 16px 12px 16px;
-    
-    .title {
-      font-size: ${(props) => props.theme.font.size.base};
-      font-weight: 500;
-      color: ${(props) => props.theme.text};
-      margin: 0;
-    }
-    
     .btn-action {
       display: flex;
       align-items: center;
@@ -66,43 +53,101 @@ const StyledWrapper = styled.div`
     }
   }
 
-  .search-container {
+  .env-list-search {
     position: relative;
-    padding: 0 12px 12px 12px;
-    
-    .search-icon {
+    display: flex;
+    align-items: center;
+    margin: 0 4px 6px 4px;
+
+    .env-list-search-icon {
       position: absolute;
-      left: 20px;
-      top: 50%;
-      transform: translateY(-100%);
+      left: 8px;
       color: ${(props) => props.theme.colors.text.muted};
       pointer-events: none;
     }
-    
-    .search-input {
+
+    .env-list-search-input {
       width: 100%;
-      padding: 6px 8px 6px 28px;
+      padding: 5px 24px 5px 26px;
       font-size: 12px;
       background: transparent;
       border: 1px solid ${(props) => props.theme.border.border1};
-      border-radius: 5px;
+      border-radius: 6px;
       color: ${(props) => props.theme.text};
-      transition: all 0.15s ease;
-      
+      transition: border-color 0.15s ease;
+
       &::placeholder {
         color: ${(props) => props.theme.colors.text.muted};
       }
       
       &:focus {
         outline: none;
+        border-color: ${(props) => props.theme.colors.accent};
+      }
+    }
+
+    .env-list-search-clear {
+      position: absolute;
+      right: 4px;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      padding: 2px;
+      background: transparent;
+      border: none;
+      cursor: pointer;
+      color: ${(props) => props.theme.colors.text.muted};
+      border-radius: 3px;
+
+      &:hover {
+        color: ${(props) => props.theme.text};
       }
     }
   }
 
-  .environments-list {
+  .sections-container {
     flex: 1;
+    display: flex;
+    flex-direction: column;
+    overflow: hidden;
+    padding: 8px;
+  }
+
+  .section-header {
+    margin-inline: 4px !important;
+    padding-left: 6px !important;
+    border-radius: 6px ;
+    padding-right: 3px !important;
+    padding-block: 4px !important;
+  }
+
+  .environments-list {
     overflow-y: auto;
-    padding: 0 8px;
+    padding: 0 4px;
+  }
+
+  .btn-action {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    width: 22px;
+    height: 22px;
+    padding: 0;
+    background: transparent;
+    border: none;
+    border-radius: 4px;
+    color: ${(props) => props.theme.colors.text.muted};
+    cursor: pointer;
+    transition: all 0.15s ease;
+
+    &:hover {
+      background: ${(props) => props.theme.sidebar.collection.item.hoverBg};
+      color: ${(props) => props.theme.text};
+    }
+
+    &.active {
+      color: ${(props) => props.theme.colors.accent};
+    }
   }
 
   .environment-item {
@@ -110,12 +155,13 @@ const StyledWrapper = styled.div`
     display: flex;
     align-items: center;
     justify-content: space-between;
+    gap: 8px;
     padding: 4px 8px;
     margin-bottom: 1px;
     font-size: 13px;
     color: ${(props) => props.theme.text};
     cursor: pointer;
-    border-radius: 5px;
+    border-radius: 6px;
     transition: background 0.15s ease;
     
     .environment-name {
@@ -280,6 +326,39 @@ const StyledWrapper = styled.div`
     background: ${(props) => `${props.theme.colors.text.danger}15`};
     border-radius: 4px;
   }
+
+  .no-env-file {
+    padding: 8px 12px;
+    font-size: 12px;
+    color: ${(props) => props.theme.colors.text.muted};
+    font-style: italic;
+  }
+
+  .empty-state {
+    flex: 1;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    padding-top: 10%;
+    color: ${(props) => props.theme.colors.text.muted};
+
+    svg {
+      opacity: 0.3;
+      margin-bottom: 8px;
+    }
+
+    .title {
+      font-size: 13px;
+      font-weight: 500;
+      margin-bottom: 12px;
+      color: ${(props) => props.theme.colors.text.muted};
+    }
+
+    .actions {
+      display: flex;
+      gap: 8px;
+    }
+  }
 `;
 
 export default StyledWrapper;

packages/bruno-app/src/components/Environments/EnvironmentSettings/EnvironmentList/index.js

@@ -1,16 +1,35 @@
-import React, { useEffect, useState, useRef } from 'react';
+import React, { useEffect, useState, useRef, useCallback } from 'react';
 import usePrevious from 'hooks/usePrevious';
+import useOnClickOutside from 'hooks/useOnClickOutside';
+import useDebounce from 'hooks/useDebounce';
 import EnvironmentDetails from './EnvironmentDetails';
-import CreateEnvironment from 'components/Environments/EnvironmentSettings/CreateEnvironment';
-import { IconDownload, IconUpload, IconSearch, IconPlus, IconCheck, IconX } from '@tabler/icons';
+import { IconDownload, IconUpload, IconSearch, IconPlus, IconCheck, IconX, IconFileAlert } from '@tabler/icons';
+import Button from 'ui/Button';
 import StyledWrapper from './StyledWrapper';
 import ConfirmSwitchEnv from 'components/WorkspaceHome/WorkspaceEnvironments/EnvironmentList/ConfirmSwitchEnv';
 import ImportEnvironmentModal from 'components/Environments/Common/ImportEnvironmentModal';
+import CollapsibleSection from 'components/Environments/CollapsibleSection';
+import DotEnvFileEditor from 'components/Environments/DotEnvFileEditor';
+import DotEnvFileDetails from 'components/Environments/DotEnvFileDetails';
+import ColorBadge from 'components/ColorBadge';
 import { isEqual } from 'lodash';
-import { useDispatch } from 'react-redux';
-import { addEnvironment, renameEnvironment, selectEnvironment } from 'providers/ReduxStore/slices/collections/actions';
+import { useDispatch, useSelector } from 'react-redux';
+import {
+  addEnvironment,
+  renameEnvironment,
+  selectEnvironment,
+  saveDotEnvVariables,
+  saveDotEnvRaw,
+  createDotEnvFile,
+  deleteDotEnvFile
+} from 'providers/ReduxStore/slices/collections/actions';
+import { setEnvironmentsDraft, clearEnvironmentsDraft } from 'providers/ReduxStore/slices/collections';
+import { setEnvVarSearchQuery, setEnvVarSearchExpanded } from 'providers/ReduxStore/slices/app';
 import { validateName, validateNameError } from 'utils/common/regex';
 import toast from 'react-hot-toast';
+import classnames from 'classnames';
+
+const EMPTY_ARRAY = [];
 
 const EnvironmentList = ({
   environments,
@@ -23,10 +42,14 @@ const EnvironmentList = ({
   setShowExportModal
 }) => {
   const dispatch = useDispatch();
+  const envSearchQuery = useSelector((state) => state.app.envVarSearch?.collection?.query ?? '');
+  const isEnvSearchExpanded = useSelector((state) => state.app.envVarSearch?.collection?.expanded ?? false);
+  const setEnvSearchQuery = (q) => dispatch(setEnvVarSearchQuery({ context: 'collection', query: q }));
+  const setIsEnvSearchExpanded = (v) => dispatch(setEnvVarSearchExpanded({ context: 'collection', expanded: v }));
 
-  const [openCreateModal, setOpenCreateModal] = useState(false);
   const [openImportModal, setOpenImportModal] = useState(false);
   const [searchText, setSearchText] = useState('');
+  const envListSearchInputRef = useRef(null);
   const [isCreatingInline, setIsCreatingInline] = useState(false);
   const [renamingEnvUid, setRenamingEnvUid] = useState(null);
   const [newEnvName, setNewEnvName] = useState('');
@@ -37,10 +60,58 @@ const EnvironmentList = ({
 
   const [switchEnvConfirmClose, setSwitchEnvConfirmClose] = useState(false);
   const [originalEnvironmentVariables, setOriginalEnvironmentVariables] = useState([]);
+  const [environmentsExpanded, setEnvironmentsExpanded] = useState(true);
+  const [dotEnvExpanded, setDotEnvExpanded] = useState(false);
+  const [activeView, setActiveView] = useState('environment');
+  const [isDotEnvModified, setIsDotEnvModified] = useState(false);
+  const [dotEnvViewMode, setDotEnvViewMode] = useState('table');
+  const [selectedDotEnvFile, setSelectedDotEnvFile] = useState(null);
+  const [isCreatingDotEnvInline, setIsCreatingDotEnvInline] = useState(false);
+  const [newDotEnvName, setNewDotEnvName] = useState('.env');
+  const [dotEnvNameError, setDotEnvNameError] = useState('');
+  const dotEnvInputRef = useRef(null);
+  const dotEnvCreateContainerRef = useRef(null);
+
+  const debouncedEnvSearchQuery = useDebounce(envSearchQuery, 300);
+  const envSearchInputRef = useRef(null);
+
+  const dotEnvFiles = useSelector((state) => {
+    const coll = state.collections.collections.find((c) => c.uid === collection?.uid);
+    return coll?.dotEnvFiles || EMPTY_ARRAY;
+  });
 
   const envUids = environments ? environments.map((env) => env.uid) : [];
   const prevEnvUids = usePrevious(envUids);
 
+  const environmentsDraftUid = collection?.environmentsDraft?.environmentUid;
+
+  const handleDotEnvModifiedChange = useCallback((modified) => {
+    setIsDotEnvModified(modified);
+    if (modified) {
+      dispatch(setEnvironmentsDraft({
+        collectionUid: collection.uid,
+        environmentUid: `dotenv:${selectedDotEnvFile}`,
+        variables: []
+      }));
+    } else if (environmentsDraftUid?.startsWith('dotenv:')) {
+      dispatch(clearEnvironmentsDraft({ collectionUid: collection.uid }));
+    }
+  }, [dispatch, collection.uid, selectedDotEnvFile, environmentsDraftUid]);
+
+  useEffect(() => {
+    if (dotEnvFiles.length === 0) {
+      setSelectedDotEnvFile(null);
+      setActiveView('environment');
+      handleDotEnvModifiedChange(false);
+      return;
+    }
+
+    const fileExists = dotEnvFiles.some((f) => f.filename === selectedDotEnvFile);
+    if (!selectedDotEnvFile || !fileExists) {
+      setSelectedDotEnvFile(dotEnvFiles[0].filename);
+    }
+  }, [dotEnvFiles]);
+
   useEffect(() => {
     if (!environments?.length) {
       setSelectedEnvironment(null);
@@ -86,44 +157,34 @@ const EnvironmentList = ({
     }
   }, [envUids, environments, prevEnvUids]);
 
-  useEffect(() => {
-    if (!renamingEnvUid) return;
-
-    const handleClickOutside = (event) => {
-      if (renameContainerRef.current && !renameContainerRef.current.contains(event.target)) {
-        handleCancelRename();
-      }
-    };
-
-    document.addEventListener('mousedown', handleClickOutside);
-    return () => {
-      document.removeEventListener('mousedown', handleClickOutside);
-    };
-  }, [renamingEnvUid]);
-
-  useEffect(() => {
-    if (!isCreatingInline) return;
-
-    const handleClickOutside = (event) => {
-      if (createContainerRef.current && !createContainerRef.current.contains(event.target)) {
-        handleCancelCreate();
-      }
-    };
-
-    document.addEventListener('mousedown', handleClickOutside);
-    return () => {
-      document.removeEventListener('mousedown', handleClickOutside);
-    };
-  }, [isCreatingInline]);
-
   const handleEnvironmentClick = (env) => {
+    if (activeView === 'dotenv' && isDotEnvModified) {
+      setSwitchEnvConfirmClose(true);
+      return;
+    }
     if (!isModified) {
       setSelectedEnvironment(env);
+      setActiveView('environment');
+      setEnvironmentsExpanded(true);
     } else {
       setSwitchEnvConfirmClose(true);
     }
   };
 
+  const handleDotEnvClick = (filename) => {
+    if (isModified) {
+      setSwitchEnvConfirmClose(true);
+      return;
+    }
+    if (activeView === 'dotenv' && isDotEnvModified && selectedDotEnvFile !== filename) {
+      setSwitchEnvConfirmClose(true);
+      return;
+    }
+    setSelectedDotEnvFile(filename);
+    setActiveView('dotenv');
+    setDotEnvExpanded(true);
+  };
+
   const handleEnvironmentDoubleClick = (env) => {
     setRenamingEnvUid(env.uid);
     setNewEnvName(env.name);
@@ -134,7 +195,7 @@ const EnvironmentList = ({
     }, 50);
   };
 
-  const handleActivateEnvironment = (e, env) => {
+  const handleActivateEnvironment = useCallback((e, env) => {
     e.stopPropagation();
     dispatch(selectEnvironment(env.uid, collection.uid))
       .then(() => {
@@ -143,11 +204,7 @@ const EnvironmentList = ({
       .catch(() => {
         toast.error('Failed to activate environment');
       });
-  };
-
-  if (!selectedEnvironment) {
-    return null;
-  }
+  }, [dispatch, collection.uid]);
 
   const validateEnvironmentName = (name, excludeUid = null) => {
     if (!name || name.trim() === '') {
@@ -170,7 +227,7 @@ const EnvironmentList = ({
   };
 
   const handleCreateEnvClick = () => {
-    if (!isModified) {
+    if (!isModified && !isDotEnvModified) {
       setIsCreatingInline(true);
       setNewEnvName('');
       setEnvNameError('');
@@ -182,11 +239,13 @@ const EnvironmentList = ({
     }
   };
 
-  const handleCancelCreate = () => {
+  const handleCancelCreate = useCallback(() => {
     setIsCreatingInline(false);
     setNewEnvName('');
     setEnvNameError('');
-  };
+  }, []);
+
+  useOnClickOutside(createContainerRef, handleCancelCreate, isCreatingInline);
 
   const handleSaveNewEnv = () => {
     const error = validateEnvironmentName(newEnvName);
@@ -253,14 +312,16 @@ const EnvironmentList = ({
       });
   };
 
-  const handleCancelRename = () => {
+  const handleCancelRename = useCallback(() => {
     setRenamingEnvUid(null);
     setNewEnvName('');
     setEnvNameError('');
-  };
+  }, []);
+
+  useOnClickOutside(renameContainerRef, handleCancelRename, !!renamingEnvUid);
 
   const handleImportClick = () => {
-    if (!isModified) {
+    if (!isModified && !isDotEnvModified) {
       setOpenImportModal(true);
     } else {
       setSwitchEnvConfirmClose(true);
@@ -279,12 +340,203 @@ const EnvironmentList = ({
     }
   };
 
+  const handleSaveDotEnv = (variables) => {
+    if (!selectedDotEnvFile) return Promise.reject(new Error('No file selected'));
+    return dispatch(saveDotEnvVariables(collection.uid, variables, selectedDotEnvFile));
+  };
+
+  const handleSaveDotEnvRaw = (content) => {
+    if (!selectedDotEnvFile) return Promise.reject(new Error('No file selected'));
+    return dispatch(saveDotEnvRaw(collection.uid, content, selectedDotEnvFile));
+  };
+
+  const handleCreateDotEnvInlineClick = () => {
+    if (isModified || isDotEnvModified) {
+      setSwitchEnvConfirmClose(true);
+      return;
+    }
+    setIsCreatingDotEnvInline(true);
+    setNewDotEnvName('.env');
+    setDotEnvNameError('');
+    setTimeout(() => {
+      dotEnvInputRef.current?.focus();
+      const input = dotEnvInputRef.current;
+      if (input) {
+        input.setSelectionRange(input.value.length, input.value.length);
+      }
+    }, 50);
+  };
+
+  const handleCancelDotEnvCreate = useCallback(() => {
+    setIsCreatingDotEnvInline(false);
+    setNewDotEnvName('.env');
+    setDotEnvNameError('');
+  }, []);
+
+  useOnClickOutside(dotEnvCreateContainerRef, handleCancelDotEnvCreate, isCreatingDotEnvInline);
+
+  const validateDotEnvName = (name) => {
+    if (!name || name.trim() === '') {
+      return 'Name is required';
+    }
+
+    if (!name.startsWith('.env')) {
+      return 'File name must start with .env';
+    }
+
+    const validPattern = /^\.env[a-zA-Z0-9._-]*$/;
+    if (!validPattern.test(name)) {
+      return 'Invalid file name';
+    }
+
+    const exists = dotEnvFiles.some((f) => f.filename === name);
+    if (exists) {
+      return 'File already exists';
+    }
+
+    return null;
+  };
+
+  const handleSaveNewDotEnv = () => {
+    const error = validateDotEnvName(newDotEnvName);
+    if (error) {
+      setDotEnvNameError(error);
+      return;
+    }
+
+    dispatch(createDotEnvFile(collection.uid, newDotEnvName))
+      .then(() => {
+        toast.success(`${newDotEnvName} file created!`);
+        setIsCreatingDotEnvInline(false);
+        setNewDotEnvName('.env');
+        setDotEnvNameError('');
+        setSelectedDotEnvFile(newDotEnvName);
+        setActiveView('dotenv');
+        setDotEnvExpanded(true);
+      })
+      .catch((error) => {
+        toast.error(error.message || 'Failed to create .env file');
+      });
+  };
+
+  const handleDotEnvNameChange = (e) => {
+    const value = e.target.value;
+    if (!value.startsWith('.env')) {
+      setNewDotEnvName('.env');
+    } else {
+      setNewDotEnvName(value);
+    }
+    if (dotEnvNameError) {
+      setDotEnvNameError('');
+    }
+  };
+
+  const handleDotEnvNameKeyDown = (e) => {
+    if (e.key === 'Enter') {
+      e.preventDefault();
+      handleSaveNewDotEnv();
+    } else if (e.key === 'Escape') {
+      e.preventDefault();
+      handleCancelDotEnvCreate();
+    } else if (e.key === 'Backspace') {
+      const input = e.target;
+      if (input.selectionStart <= 4 && input.selectionEnd <= 4) {
+        e.preventDefault();
+      }
+    }
+  };
+
+  const handleDeleteDotEnvFile = (filename) => {
+    dispatch(deleteDotEnvFile(collection.uid, filename))
+      .then(() => {
+        toast.success(`${filename} file deleted!`);
+        handleDotEnvModifiedChange(false);
+        if (selectedDotEnvFile === filename) {
+          const remainingFiles = dotEnvFiles.filter((f) => f.filename !== filename);
+          if (remainingFiles.length > 0) {
+            setSelectedDotEnvFile(remainingFiles[0].filename);
+          } else {
+            setActiveView('environment');
+            if (environments?.length) {
+              const env = environments.find((e) => e.uid === activeEnvironmentUid) || environments[0];
+              setSelectedEnvironment(env);
+            }
+          }
+        }
+      })
+      .catch((error) => {
+        toast.error(error.message || 'Failed to delete .env file');
+      });
+  };
+
+  const handleDotEnvViewModeChange = (mode) => {
+    setDotEnvViewMode(mode);
+  };
+
   const filteredEnvironments
     = environments?.filter((env) => env.name.toLowerCase().includes(searchText.toLowerCase())) || [];
 
+  const selectedDotEnvData = dotEnvFiles.find((f) => f.filename === selectedDotEnvFile);
+
+  const renderContent = () => {
+    if (activeView === 'dotenv' && selectedDotEnvFile && selectedDotEnvData) {
+      return (
+        <DotEnvFileDetails
+          title={selectedDotEnvFile}
+          onDelete={() => handleDeleteDotEnvFile(selectedDotEnvFile)}
+          dotEnvExists={selectedDotEnvData?.exists}
+          viewMode={dotEnvViewMode}
+          onViewModeChange={handleDotEnvViewModeChange}
+        >
+          <DotEnvFileEditor
+            variables={selectedDotEnvData?.variables || []}
+            onSave={handleSaveDotEnv}
+            onSaveRaw={handleSaveDotEnvRaw}
+            isModified={isDotEnvModified}
+            setIsModified={handleDotEnvModifiedChange}
+            dotEnvExists={selectedDotEnvData?.exists}
+            viewMode={dotEnvViewMode}
+            collection={collection}
+          />
+        </DotEnvFileDetails>
+      );
+    }
+
+    if (selectedEnvironment) {
+      return (
+        <EnvironmentDetails
+          environment={selectedEnvironment}
+          setIsModified={setIsModified}
+          originalEnvironmentVariables={originalEnvironmentVariables}
+          collection={collection}
+          searchQuery={envSearchQuery}
+          setSearchQuery={setEnvSearchQuery}
+          isSearchExpanded={isEnvSearchExpanded}
+          setIsSearchExpanded={setIsEnvSearchExpanded}
+          debouncedSearchQuery={debouncedEnvSearchQuery}
+          searchInputRef={envSearchInputRef}
+        />
+      );
+    }
+
+    return (
+      <div className="empty-state">
+        <IconFileAlert size={48} strokeWidth={1.5} />
+        <div className="title">No Environments</div>
+        <div className="actions">
+          <Button size="sm" color="secondary" onClick={() => handleCreateEnvClick()}>
+            Create Environment
+          </Button>
+          <Button size="sm" color="secondary" onClick={() => handleImportClick()}>
+            Import Environment
+          </Button>
+        </div>
+      </div>
+    );
+  };
+
   return (
     <StyledWrapper>
-      {openCreateModal && <CreateEnvironment collection={collection} onClose={() => setOpenCreateModal(false)} />}
       {openImportModal && (
         <ImportEnvironmentModal type="collection" collection={collection} onClose={() => setOpenImportModal(false)} />
       )}
@@ -297,43 +549,147 @@ const EnvironmentList = ({
         )}
 
         <div className="sidebar">
-          <div className="sidebar-header">
-            <h2 className="title">Environments</h2>
-            <div className="flex items-center gap-2">
-              <button className="btn-action" onClick={() => handleCreateEnvClick()} title="Create environment">
-                <IconPlus size={16} strokeWidth={1.5} />
-              </button>
-              <button className="btn-action" onClick={() => handleImportClick()} title="Import environment">
-                <IconDownload size={16} strokeWidth={1.5} />
-              </button>
-              <button className="btn-action" onClick={() => handleExportClick()} title="Export environment">
-                <IconUpload size={16} strokeWidth={1.5} />
-              </button>
-            </div>
-          </div>
 
-          <div className="search-container">
-            <IconSearch size={14} strokeWidth={1.5} className="search-icon" />
-            <input
-              type="text"
-              placeholder="Search environments..."
-              value={searchText}
-              onChange={(e) => setSearchText(e.target.value)}
-              className="search-input"
-            />
-          </div>
+          <div className="sections-container">
+            <CollapsibleSection
+              title="Environments"
+              expanded={environmentsExpanded}
+              onToggle={() => setEnvironmentsExpanded(!environmentsExpanded)}
+              actions={(
+                <>
+                  <button
+                    type="button"
+                    className="btn-action"
+                    onClick={() => {
+                      if (!environmentsExpanded) setEnvironmentsExpanded(true);
+                      handleCreateEnvClick();
+                    }}
+                    title="Create environment"
+                  >
+                    <IconPlus size={14} strokeWidth={1.5} />
+                  </button>
+                  <button
+                    type="button"
+                    className="btn-action"
+                    onClick={() => {
+                      if (!environmentsExpanded) setEnvironmentsExpanded(true);
+                      handleImportClick();
+                    }}
+                    title="Import environment"
+                  >
+                    <IconDownload size={14} strokeWidth={1.5} />
+                  </button>
+                  <button
+                    type="button"
+                    className="btn-action"
+                    onClick={() => {
+                      if (!environmentsExpanded) setEnvironmentsExpanded(true);
+                      handleExportClick();
+                    }}
+                    title="Export environment"
+                  >
+                    <IconUpload size={14} strokeWidth={1.5} />
+                  </button>
+                </>
+              )}
+            >
+              <div className="env-list-search">
+                <IconSearch size={13} strokeWidth={1.5} className="env-list-search-icon" />
+                <input
+                  ref={envListSearchInputRef}
+                  type="text"
+                  placeholder="Search environments..."
+                  value={searchText}
+                  onChange={(e) => setSearchText(e.target.value)}
+                  className="env-list-search-input"
+                  autoComplete="off"
+                  autoCorrect="off"
+                  autoCapitalize="off"
+                  spellCheck="false"
+                />
+                {searchText && (
+                  <button
+                    className="env-list-search-clear"
+                    title="Clear search"
+                    onClick={() => setSearchText('')}
+                    onMouseDown={(e) => e.preventDefault()}
+                  >
+                    <IconX size={12} strokeWidth={1.5} />
+                  </button>
+                )}
+              </div>
+              <div className="environments-list">
+                {filteredEnvironments.map((env) => (
+                  <div
+                    key={env.uid}
+                    id={env.uid}
+                    className={classnames('environment-item', {
+                      active: activeView === 'environment' && selectedEnvironment?.uid === env.uid,
+                      renaming: renamingEnvUid === env.uid,
+                      activated: activeEnvironmentUid === env.uid
+                    })}
+                    onClick={() => renamingEnvUid !== env.uid && handleEnvironmentClick(env)}
+                    onDoubleClick={() => handleEnvironmentDoubleClick(env)}
+                  >
+                    {renamingEnvUid === env.uid ? (
+                      <div className="rename-container" ref={renameContainerRef}>
+                        <input
+                          ref={inputRef}
+                          type="text"
+                          className="environment-name-input"
+                          value={newEnvName}
+                          onChange={handleEnvNameChange}
+                          onKeyDown={handleEnvNameKeyDown}
+                          autoComplete="off"
+                          autoCorrect="off"
+                          autoCapitalize="off"
+                          spellCheck="false"
+                        />
+                        <div className="inline-actions">
+                          <button
+                            className="inline-action-btn save"
+                            onClick={handleSaveRename}
+                            onMouseDown={(e) => e.preventDefault()}
+                            title="Save"
+                          >
+                            <IconCheck size={14} strokeWidth={2} />
+                          </button>
+                          <button
+                            className="inline-action-btn cancel"
+                            onClick={handleCancelRename}
+                            onMouseDown={(e) => e.preventDefault()}
+                            title="Cancel"
+                          >
+                            <IconX size={14} strokeWidth={2} />
+                          </button>
+                        </div>
+                      </div>
+                    ) : (
+                      <>
+                        <ColorBadge color={env.color} size={8} />
+                        <span className="environment-name">{env.name}</span>
+                        <div className="environment-actions">
+                          {activeEnvironmentUid === env.uid ? (
+                            <div className="activated-checkmark" title="Active environment">
+                              <IconCheck size={16} strokeWidth={2} />
+                            </div>
+                          ) : (
+                            <button
+                              className="activate-btn"
+                              onClick={(e) => handleActivateEnvironment(e, env)}
+                              title="Activate environment"
+                            >
+                              <IconCheck size={16} strokeWidth={2} />
+                            </button>
+                          )}
+                        </div>
+                      </>
+                    )}
+                  </div>
+                ))}
 
-          <div className="environments-list">
-            {filteredEnvironments.map((env) => (
-              <div
-                key={env.uid}
-                id={env.uid}
-                className={`environment-item ${selectedEnvironment.uid === env.uid ? 'active' : ''} ${renamingEnvUid === env.uid ? 'renaming' : ''} ${activeEnvironmentUid === env.uid ? 'activated' : ''}`}
-                onClick={() => renamingEnvUid !== env.uid && handleEnvironmentClick(env)}
-                onDoubleClick={() => handleEnvironmentDoubleClick(env)}
-              >
-                {renamingEnvUid === env.uid ? (
-                  <div className="rename-container" ref={renameContainerRef}>
+                {isCreatingInline && (
+                  <div className="environment-item creating" ref={createContainerRef}>
                     <input
                       ref={inputRef}
                       type="text"
@@ -341,6 +697,7 @@ const EnvironmentList = ({
                       value={newEnvName}
                       onChange={handleEnvNameChange}
                       onKeyDown={handleEnvNameKeyDown}
+                      placeholder="Environment name..."
                       autoComplete="off"
                       autoCorrect="off"
                       autoCapitalize="off"
@@ -349,7 +706,7 @@ const EnvironmentList = ({
                     <div className="inline-actions">
                       <button
                         className="inline-action-btn save"
-                        onClick={handleSaveRename}
+                        onClick={handleSaveNewEnv}
                         onMouseDown={(e) => e.preventDefault()}
                         title="Save"
                       >
@@ -357,7 +714,7 @@ const EnvironmentList = ({
                       </button>
                       <button
                         className="inline-action-btn cancel"
-                        onClick={handleCancelRename}
+                        onClick={handleCancelCreate}
                         onMouseDown={(e) => e.preventDefault()}
                         title="Cancel"
                       >
@@ -365,75 +722,94 @@ const EnvironmentList = ({
                       </button>
                     </div>
                   </div>
-                ) : (
-                  <>
-                    <span className="environment-name">{env.name}</span>
-                    <div className="environment-actions">
-                      {activeEnvironmentUid === env.uid ? (
-                        <div className="activated-checkmark" title="Active environment">
-                          <IconCheck size={16} strokeWidth={2} />
-                        </div>
-                      ) : (
-                        <button
-                          className="activate-btn"
-                          onClick={(e) => handleActivateEnvironment(e, env)}
-                          title="Activate environment"
-                        >
-                          <IconCheck size={16} strokeWidth={2} />
-                        </button>
-                      )}
-                    </div>
-                  </>
+                )}
+
+                {envNameError && (isCreatingInline || renamingEnvUid) && <div className="env-error">{envNameError}</div>}
+
+                {filteredEnvironments.length === 0 && !isCreatingInline && (
+                  <div className="no-env-file">
+                    <span>No environments</span>
+                  </div>
                 )}
               </div>
-            ))}
+            </CollapsibleSection>
 
-            {isCreatingInline && (
-              <div className="environment-item creating" ref={createContainerRef}>
-                <input
-                  ref={inputRef}
-                  type="text"
-                  className="environment-name-input"
-                  value={newEnvName}
-                  onChange={handleEnvNameChange}
-                  onKeyDown={handleEnvNameKeyDown}
-                  placeholder="Environment name..."
-                  autoComplete="off"
-                  autoCorrect="off"
-                  autoCapitalize="off"
-                  spellCheck="false"
-                />
-                <div className="inline-actions">
-                  <button
-                    className="inline-action-btn save"
-                    onClick={handleSaveNewEnv}
-                    onMouseDown={(e) => e.preventDefault()}
-                    title="Save"
+            <CollapsibleSection
+              title=".env Files"
+              expanded={dotEnvExpanded}
+              onToggle={() => setDotEnvExpanded(!dotEnvExpanded)}
+              badge={dotEnvFiles.length}
+              actions={(
+                <button
+                  className="btn-action"
+                  onClick={handleCreateDotEnvInlineClick}
+                  title="Create .env file"
+                >
+                  <IconPlus size={14} strokeWidth={1.5} />
+                </button>
+              )}
+            >
+              <div className="environments-list">
+                {dotEnvFiles.map((file) => (
+                  <div
+                    key={file.filename}
+                    className={classnames('environment-item', {
+                      active: activeView === 'dotenv' && selectedDotEnvFile === file.filename
+                    })}
+                    onClick={() => handleDotEnvClick(file.filename)}
                   >
-                    <IconCheck size={14} strokeWidth={2} />
-                  </button>
-                  <button
-                    className="inline-action-btn cancel"
-                    onClick={handleCancelCreate}
-                    onMouseDown={(e) => e.preventDefault()}
-                    title="Cancel"
-                  >
-                    <IconX size={14} strokeWidth={2} />
-                  </button>
-                </div>
+                    <span className="environment-name">{file.filename}</span>
+                  </div>
+                ))}
+
+                {isCreatingDotEnvInline && (
+                  <div className="environment-item creating" ref={dotEnvCreateContainerRef}>
+                    <input
+                      ref={dotEnvInputRef}
+                      type="text"
+                      className="environment-name-input"
+                      value={newDotEnvName}
+                      onChange={handleDotEnvNameChange}
+                      onKeyDown={handleDotEnvNameKeyDown}
+                      autoComplete="off"
+                      autoCorrect="off"
+                      autoCapitalize="off"
+                      spellCheck="false"
+                    />
+                    <div className="inline-actions">
+                      <button
+                        className="inline-action-btn save"
+                        onClick={handleSaveNewDotEnv}
+                        onMouseDown={(e) => e.preventDefault()}
+                        title="Create"
+                      >
+                        <IconCheck size={14} strokeWidth={2} />
+                      </button>
+                      <button
+                        className="inline-action-btn cancel"
+                        onClick={handleCancelDotEnvCreate}
+                        onMouseDown={(e) => e.preventDefault()}
+                        title="Cancel"
+                      >
+                        <IconX size={14} strokeWidth={2} />
+                      </button>
+                    </div>
+                  </div>
+                )}
+
+                {dotEnvNameError && isCreatingDotEnvInline && <div className="env-error">{dotEnvNameError}</div>}
+
+                {dotEnvFiles.length === 0 && !isCreatingDotEnvInline && (
+                  <div className="no-env-file">
+                    <span>No .env files</span>
+                  </div>
+                )}
               </div>
-            )}
-
-            {envNameError && (isCreatingInline || renamingEnvUid) && <div className="env-error">{envNameError}</div>}
+            </CollapsibleSection>
           </div>
         </div>
 
-        <EnvironmentDetails
-          environment={selectedEnvironment}
-          setIsModified={setIsModified}
-          originalEnvironmentVariables={originalEnvironmentVariables}
-          collection={collection}
-        />
+        {renderContent()}
       </div>
     </StyledWrapper>
   );

packages/bruno-app/src/components/Environments/EnvironmentSettings/index.js

@@ -1,26 +1,7 @@
 import React, { useState } from 'react';
-import CreateEnvironment from 'components/Environments/EnvironmentSettings/CreateEnvironment';
 import EnvironmentList from './EnvironmentList';
 import StyledWrapper from './StyledWrapper';
-import { IconFileAlert } from '@tabler/icons';
-import ImportEnvironmentModal from 'components/Environments/Common/ImportEnvironmentModal';
 import ExportEnvironmentModal from 'components/Environments/Common/ExportEnvironmentModal';
-import Button from 'ui/Button';
-
-const DefaultTab = ({ setTab }) => (
-  <div className="empty-state">
-    <IconFileAlert size={48} strokeWidth={1.5} />
-    <div className="title">No Environments</div>
-    <div className="actions">
-      <Button size="sm" color="secondary" onClick={() => setTab('create')}>
-        Create Environment
-      </Button>
-      <Button size="sm" color="secondary" onClick={() => setTab('import')}>
-        Import Environment
-      </Button>
-    </div>
-  </div>
-);
 
 const EnvironmentSettings = ({ collection }) => {
   const [isModified, setIsModified] = useState(false);
@@ -30,23 +11,8 @@ const EnvironmentSettings = ({ collection }) => {
     if (!environments.length) return null;
     return environments.find((env) => env.uid === collection?.activeEnvironmentUid) || environments[0];
   });
-  const [tab, setTab] = useState('default');
   const [showExportModal, setShowExportModal] = useState(false);
 
-  if (!environments || !environments.length) {
-    return (
-      <StyledWrapper>
-        {tab === 'create' ? (
-          <CreateEnvironment collection={collection} onClose={() => setTab('default')} />
-        ) : tab === 'import' ? (
-          <ImportEnvironmentModal type="collection" collection={collection} onClose={() => setTab('default')} />
-        ) : (
-          <DefaultTab setTab={setTab} />
-        )}
-      </StyledWrapper>
-    );
-  }
-
   return (
     <StyledWrapper>
       <EnvironmentList

packages/bruno-app/src/components/Environments/GlobalEnvironmentSettings/index.js

@@ -1,8 +1,14 @@
 import React from 'react';
+import { useSelector } from 'react-redux';
 import WorkspaceEnvironments from 'components/WorkspaceHome/WorkspaceEnvironments';
 
 const GlobalEnvironmentSettings = () => {
-  return <WorkspaceEnvironments />;
+  const activeWorkspaceUid = useSelector((state) => state.workspaces.activeWorkspaceUid);
+  const workspace = useSelector((state) =>
+    state.workspaces.workspaces.find((w) => w.uid === activeWorkspaceUid)
+  );
+
+  return <WorkspaceEnvironments workspace={workspace} />;
 };
 
 export default GlobalEnvironmentSettings;

packages/bruno-app/src/components/ErrorCapture/index.js

@@ -34,23 +34,36 @@ class ErrorBoundary extends Component {
 
 const serializeArgs = (args) => {
   return args.map((arg) => {
+    const seen = new WeakSet();
+
+    const replacer = (key, value) => {
+      if (typeof value === 'object' && value !== null) {
+        if (seen.has(value)) {
+          return '[Circular Reference]';
+        }
+        seen.add(value);
+
+        if (value instanceof Error || Object.prototype.toString.call(value) === '[object Error]' || (typeof value.message === 'string' && typeof value.stack === 'string')) {
+          const error = {};
+          Object.getOwnPropertyNames(value).forEach((prop) => {
+            error[prop] = value[prop];
+          });
+          return error;
+        }
+      }
+      return value;
+    };
+
     try {
       if (arg === null) return 'null';
       if (arg === undefined) return 'undefined';
       if (typeof arg === 'string' || typeof arg === 'number' || typeof arg === 'boolean') {
         return arg;
       }
-      if (arg instanceof Error) {
-        return {
-          __type: 'Error',
-          name: arg.name,
-          message: arg.message,
-          stack: arg.stack
-        };
-      }
+
       if (typeof arg === 'object') {
         try {
-          return JSON.parse(JSON.stringify(arg));
+          return JSON.parse(JSON.stringify(arg, replacer));
         } catch {
           return String(arg);
         }

packages/bruno-app/src/components/Errors/IpcErrorModal/StyledWrapper.js

@@ -0,0 +1,10 @@
+import styled from 'styled-components';
+
+const StyledWrapper = styled.div`
+  color: ${(props) => props.theme.colors.danger};
+  pre {
+    color: ${(props) => props.theme.colors.danger};
+  }
+`;
+
+export default StyledWrapper;

packages/bruno-app/src/components/Errors/IpcErrorModal/index.js

@@ -0,0 +1,34 @@
+import React from 'react';
+import Portal from 'components/Portal';
+import Modal from 'components/Modal';
+import { useState } from 'react';
+import StyledWrapper from './StyledWrapper';
+
+const IpcErrorModal = ({ error }) => {
+  const [showModal, setShowModal] = useState(true);
+  return (
+    <>
+      {showModal ? (
+        <StyledWrapper>
+          <Portal>
+            <Modal
+              size="sm"
+              title="Error"
+              hideFooter={true}
+              hideCancel={true}
+              handleCancel={() => {
+                setShowModal(false);
+              }}
+              disableCloseOnOutsideClick={true}
+              disableEscapeKey={true}
+            >
+              <pre className="w-full flex flex-wrap whitespace-pre-wrap">{error}</pre>
+            </Modal>
+          </Portal>
+        </StyledWrapper>
+      ) : null}
+    </>
+  );
+};
+
+export default IpcErrorModal;

packages/bruno-app/src/components/FolderSettings/Headers/index.js

@@ -11,6 +11,7 @@ import { headers as StandardHTTPHeaders } from 'know-your-http-well';
 import { MimeTypes } from 'utils/codemirror/autocompleteConstants';
 import BulkEditor from 'components/BulkEditor/index';
 import Button from 'ui/Button';
+import { headerNameRegex, headerValueRegex } from 'utils/common/regex';
 
 const headerAutoCompleteList = StandardHTTPHeaders.map((e) => e.header);
 
@@ -36,6 +37,22 @@ const Headers = ({ collection, folder }) => {
 
   const handleSave = () => dispatch(saveFolderRoot(collection.uid, folder.uid));
 
+  const getRowError = useCallback((row, index, key) => {
+    if (key === 'name') {
+      if (!row.name || row.name.trim() === '') return null;
+      if (!headerNameRegex.test(row.name)) {
+        return 'Header name cannot contain spaces or newlines';
+      }
+    }
+    if (key === 'value') {
+      if (!row.value) return null;
+      if (!headerValueRegex.test(row.value)) {
+        return 'Header value cannot contain newlines';
+      }
+    }
+    return null;
+  }, []);
+
   const columns = [
     {
       key: 'name',
@@ -43,7 +60,7 @@ const Headers = ({ collection, folder }) => {
       isKeyField: true,
       placeholder: 'Name',
       width: '30%',
-      render: ({ row, value, onChange, isLastEmptyRow }) => (
+      render: ({ value, onChange }) => (
         <SingleLineEditor
           value={value || ''}
           theme={storedTheme}
@@ -51,7 +68,7 @@ const Headers = ({ collection, folder }) => {
           onChange={(newValue) => onChange(newValue.replace(/[\r\n]/g, ''))}
           autocomplete={headerAutoCompleteList}
           collection={collection}
-          placeholder={isLastEmptyRow ? 'Name' : ''}
+          placeholder={!value ? 'Name' : ''}
         />
       )
     },
@@ -59,7 +76,7 @@ const Headers = ({ collection, folder }) => {
       key: 'value',
       name: 'Value',
       placeholder: 'Value',
-      render: ({ row, value, onChange, isLastEmptyRow }) => (
+      render: ({ value, onChange }) => (
         <SingleLineEditor
           value={value || ''}
           theme={storedTheme}
@@ -68,7 +85,7 @@ const Headers = ({ collection, folder }) => {
           collection={collection}
           item={folder}
           autocomplete={MimeTypes}
-          placeholder={isLastEmptyRow ? 'Value' : ''}
+          placeholder={!value ? 'Value' : ''}
         />
       )
     }
@@ -106,6 +123,7 @@ const Headers = ({ collection, folder }) => {
         rows={headers}
         onChange={handleHeadersChange}
         defaultRow={defaultRow}
+        getRowError={getRowError}
       />
       <div className="flex justify-end mt-2">
         <button className="text-link select-none" onClick={toggleBulkEditMode}>

packages/bruno-app/src/components/FolderSettings/Script/index.js

@@ -6,20 +6,39 @@ import { updateFolderRequestScript, updateFolderResponseScript } from 'providers
 import { saveFolderRoot } from 'providers/ReduxStore/slices/collections/actions';
 import { useTheme } from 'providers/Theme';
 import { Tabs, TabsList, TabsTrigger, TabsContent } from 'components/Tabs';
+import StatusDot from 'components/StatusDot';
+import { flattenItems, isItemARequest } from 'utils/collections';
 import StyledWrapper from './StyledWrapper';
 import Button from 'ui/Button';
 
 const Script = ({ collection, folder }) => {
   const dispatch = useDispatch();
-  const [activeTab, setActiveTab] = useState('pre-request');
   const preRequestEditorRef = useRef(null);
   const postResponseEditorRef = useRef(null);
   const requestScript = folder.draft ? get(folder, 'draft.request.script.req', '') : get(folder, 'root.request.script.req', '');
   const responseScript = folder.draft ? get(folder, 'draft.request.script.res', '') : get(folder, 'root.request.script.res', '');
 
+  // Default to post-response if pre-request script is empty
+  const getInitialTab = () => {
+    const hasPreRequestScript = requestScript && requestScript.trim().length > 0;
+    return hasPreRequestScript ? 'pre-request' : 'post-response';
+  };
+
+  const [activeTab, setActiveTab] = useState(getInitialTab);
+  const prevFolderUidRef = useRef(folder.uid);
+
   const { displayedTheme } = useTheme();
   const preferences = useSelector((state) => state.app.preferences);
 
+  // Update active tab only when switching to a different folder
+  useEffect(() => {
+    if (prevFolderUidRef.current !== folder.uid) {
+      prevFolderUidRef.current = folder.uid;
+      const hasPreRequestScript = requestScript && requestScript.trim().length > 0;
+      setActiveTab(hasPreRequestScript ? 'pre-request' : 'post-response');
+    }
+  }, [folder.uid, requestScript]);
+
   // Refresh CodeMirror when tab becomes visible
   useEffect(() => {
     const timer = setTimeout(() => {
@@ -57,6 +76,10 @@ const Script = ({ collection, folder }) => {
     dispatch(saveFolderRoot(collection.uid, folder.uid));
   };
 
+  const items = flattenItems(folder.items || []);
+  const hasPreRequestScriptError = items.some((i) => isItemARequest(i) && i.preRequestScriptErrorMessage);
+  const hasPostResponseScriptError = items.some((i) => isItemARequest(i) && i.postResponseScriptErrorMessage);
+
   return (
     <StyledWrapper className="w-full flex flex-col h-full">
       <div className="text-xs mb-4 text-muted">
@@ -65,8 +88,18 @@ const Script = ({ collection, folder }) => {
 
       <Tabs value={activeTab} onValueChange={setActiveTab}>
         <TabsList>
-          <TabsTrigger value="pre-request">Pre Request</TabsTrigger>
-          <TabsTrigger value="post-response">Post Response</TabsTrigger>
+          <TabsTrigger value="pre-request">
+            Pre Request
+            {requestScript && requestScript.trim().length > 0 && (
+              <StatusDot type={hasPreRequestScriptError ? 'error' : 'default'} />
+            )}
+          </TabsTrigger>
+          <TabsTrigger value="post-response">
+            Post Response
+            {responseScript && responseScript.trim().length > 0 && (
+              <StatusDot type={hasPostResponseScriptError ? 'error' : 'default'} />
+            )}
+          </TabsTrigger>
         </TabsList>
 
         <TabsContent value="pre-request" className="mt-2">

packages/bruno-app/src/components/FolderSettings/Vars/VarsTable/index.js

@@ -51,7 +51,7 @@ const VarsTable = ({ folder, collection, vars, varType }) => {
         </div>
       ),
       placeholder: varType === 'request' ? 'Value' : 'Expr',
-      render: ({ row, value, onChange, isLastEmptyRow }) => (
+      render: ({ value, onChange }) => (
         <MultiLineEditor
           value={value || ''}
           theme={storedTheme}
@@ -59,7 +59,7 @@ const VarsTable = ({ folder, collection, vars, varType }) => {
           onChange={onChange}
           collection={collection}
           item={folder}
-          placeholder={isLastEmptyRow ? (varType === 'request' ? 'Value' : 'Expr') : ''}
+          placeholder={!value ? (varType === 'request' ? 'Value' : 'Expr') : ''}
         />
       )
     }

packages/bruno-app/src/components/Git/GitNotFoundModal/index.js

@@ -0,0 +1,62 @@
+import React from 'react';
+import Modal from 'components/Modal/index';
+import Portal from 'components/Portal/index';
+
+const getOSName = () => {
+  const platform = window.navigator.userAgentData?.platform || '';
+  if (platform.startsWith('Win')) {
+    return 'Windows';
+  } else if (platform.startsWith('Mac')) {
+    return 'macOS';
+  } else if (platform.startsWith('Linux')) {
+    return 'Linux';
+  } else {
+    return 'your OS';
+  }
+};
+
+const getDownloadUrl = (os) => {
+  switch (os) {
+    case 'Windows':
+      return 'https://git-scm.com/download/win';
+    case 'macOS':
+      return 'https://git-scm.com/download/mac';
+    case 'Linux':
+      return 'https://git-scm.com/download/linux';
+    default:
+      return 'https://git-scm.com/download';
+  }
+};
+
+const GitNotFoundModal = ({ onClose }) => {
+  const osName = getOSName();
+  const downloadUrl = getDownloadUrl(osName);
+
+  return (
+    <Portal>
+      <Modal
+        size="sm"
+        title="Git Not Found"
+        handleCancel={onClose}
+        hideFooter={true}
+      >
+        <div>
+          <p>Git was not detected on your system. You need to install Git to proceed.</p>
+          <p className="mt-2">
+            You can download Git for <strong>{osName}</strong> here:
+          </p>
+          <p>
+            <span
+              className="text-blue-600 cursor-pointer border-b border-blue-600"
+              onClick={() => window.open(downloadUrl, '_blank')}
+            >
+              Download Git for {osName}
+            </span>
+          </p>
+        </div>
+      </Modal>
+    </Portal>
+  );
+};
+
+export default GitNotFoundModal;

packages/bruno-app/src/components/Git/VisualDiffViewer/CollapsibleDiffRow.js

@@ -0,0 +1,35 @@
+import React from 'react';
+import { IconChevronDown, IconChevronRight } from '@tabler/icons';
+
+const CollapsibleDiffRow = ({ title, isCollapsed, onToggle, oldContent, newContent, hasOldContent, hasNewContent }) => {
+  if (!hasOldContent && !hasNewContent) {
+    return null;
+  }
+
+  return (
+    <div className="diff-row">
+      <div className="diff-row-header" onClick={onToggle}>
+        <span className="collapse-toggle">
+          {isCollapsed ? (
+            <IconChevronRight size={14} strokeWidth={2} />
+          ) : (
+            <IconChevronDown size={14} strokeWidth={2} />
+          )}
+        </span>
+        <span className="diff-row-title">{title}</span>
+      </div>
+      {!isCollapsed && (
+        <div className="diff-row-content">
+          <div className="diff-row-pane old">
+            {hasOldContent ? oldContent : <div className="empty-placeholder" />}
+          </div>
+          <div className="diff-row-pane new">
+            {hasNewContent ? newContent : <div className="empty-placeholder" />}
+          </div>
+        </div>
+      )}
+    </div>
+  );
+};
+
+export default CollapsibleDiffRow;

packages/bruno-app/src/components/Git/VisualDiffViewer/VisualDiffAuth.js

@@ -0,0 +1,199 @@
+import React, { useMemo } from 'react';
+import get from 'lodash/get';
+import isEqual from 'lodash/isEqual';
+
+const AUTH_TYPE_LABELS = {
+  awsv4: 'AWS Signature v4',
+  basic: 'Basic Auth',
+  bearer: 'Bearer Token',
+  digest: 'Digest Auth',
+  ntlm: 'NTLM',
+  oauth2: 'OAuth 2.0',
+  wsse: 'WSSE',
+  apikey: 'API Key'
+};
+
+const AUTH_FIELD_LABELS = {
+  // AWS v4
+  accessKeyId: 'Access Key ID',
+  secretAccessKey: 'Secret Access Key',
+  sessionToken: 'Session Token',
+  service: 'Service',
+  region: 'Region',
+  profileName: 'Profile Name',
+  // Basic/Digest/NTLM/WSSE
+  username: 'Username',
+  password: 'Password',
+  domain: 'Domain',
+  // Bearer
+  token: 'Token',
+  // API Key
+  key: 'Key',
+  value: 'Value',
+  placement: 'Placement',
+  // OAuth2
+  grantType: 'Grant Type',
+  callbackUrl: 'Callback URL',
+  authorizationUrl: 'Authorization URL',
+  accessTokenUrl: 'Access Token URL',
+  refreshTokenUrl: 'Refresh Token URL',
+  clientId: 'Client ID',
+  clientSecret: 'Client Secret',
+  scope: 'Scope',
+  state: 'State',
+  pkce: 'PKCE',
+  credentialsPlacement: 'Credentials Placement',
+  credentialsId: 'Credentials ID',
+  tokenPlacement: 'Token Placement',
+  tokenHeaderPrefix: 'Token Header Prefix',
+  tokenQueryKey: 'Token Query Key',
+  autoFetchToken: 'Auto Fetch Token',
+  autoRefreshToken: 'Auto Refresh Token'
+};
+
+const VisualDiffAuth = ({ oldData, newData, showSide }) => {
+  const oldAuth = get(oldData, 'request.auth', {});
+  const newAuth = get(newData, 'request.auth', {});
+
+  const currentAuth = showSide === 'old' ? oldAuth : newAuth;
+  const otherAuth = showSide === 'old' ? newAuth : oldAuth;
+
+  const authTypes = useMemo(() => {
+    const types = new Set([...Object.keys(currentAuth), ...Object.keys(otherAuth)]);
+    types.delete('mode');
+    return Array.from(types);
+  }, [currentAuth, otherAuth]);
+
+  const authSections = useMemo(() => {
+    return authTypes.map((authType) => {
+      const rawCurrentConfig = currentAuth[authType];
+      const rawOtherConfig = otherAuth[authType];
+      const currentConfig = (typeof rawCurrentConfig === 'object' && rawCurrentConfig !== null) ? rawCurrentConfig : {};
+      const otherConfig = (typeof rawOtherConfig === 'object' && rawOtherConfig !== null) ? rawOtherConfig : {};
+
+      if (Object.keys(currentConfig).length === 0 && showSide === 'old') {
+        return null;
+      }
+      if (Object.keys(currentConfig).length === 0 && showSide === 'new') {
+        return null;
+      }
+
+      let sectionStatus = 'unchanged';
+      if (Object.keys(otherConfig).length === 0) {
+        sectionStatus = showSide === 'old' ? 'deleted' : 'added';
+      } else if (!isEqual(currentConfig, otherConfig)) {
+        sectionStatus = 'modified';
+      }
+
+      const allFields = new Set([...Object.keys(currentConfig), ...Object.keys(otherConfig)]);
+      const fields = Array.from(allFields).map((field) => {
+        const currentValue = currentConfig[field];
+        const otherValue = otherConfig[field];
+
+        let status = 'unchanged';
+        if (otherValue === undefined) {
+          status = showSide === 'old' ? 'deleted' : 'added';
+        } else if (currentValue !== otherValue) {
+          status = 'modified';
+        }
+
+        let displayValue = currentValue;
+        if (typeof displayValue === 'boolean') {
+          displayValue = displayValue ? 'true' : 'false';
+        } else if (displayValue === undefined || displayValue === null) {
+          displayValue = '';
+        }
+
+        return {
+          key: AUTH_FIELD_LABELS[field] || field,
+          value: String(displayValue),
+          status
+        };
+      });
+
+      return {
+        type: authType,
+        label: AUTH_TYPE_LABELS[authType] || authType,
+        status: sectionStatus,
+        fields
+      };
+    }).filter(Boolean);
+  }, [authTypes, currentAuth, otherAuth, showSide]);
+
+  const currentMode = currentAuth.mode;
+  const otherMode = otherAuth.mode;
+  const modeStatus = currentMode !== otherMode ? (otherMode === undefined ? (showSide === 'old' ? 'deleted' : 'added') : 'modified') : 'unchanged';
+
+  if (authSections.length === 0 && !currentMode) {
+    return null;
+  }
+
+  return (
+    <>
+      {currentMode && (
+        <div className="diff-section">
+          <table className="diff-table">
+            <thead>
+              <tr>
+                <th style={{ width: '30px' }}></th>
+                <th style={{ width: '40%' }}>Field</th>
+                <th>Value</th>
+              </tr>
+            </thead>
+            <tbody>
+              <tr className={modeStatus}>
+                <td>
+                  {modeStatus !== 'unchanged' && (
+                    <span className={`status-badge ${modeStatus}`}>
+                      {modeStatus === 'added' ? 'A' : modeStatus === 'deleted' ? 'D' : 'M'}
+                    </span>
+                  )}
+                </td>
+                <td className="key-cell">Auth Mode</td>
+                <td className="value-cell">{AUTH_TYPE_LABELS[currentMode] || currentMode}</td>
+              </tr>
+            </tbody>
+          </table>
+        </div>
+      )}
+      {authSections.map((section) => (
+        <div key={section.type} className="diff-section">
+          <div className="diff-section-header">
+            <span>{section.label}</span>
+            {section.status !== 'unchanged' && (
+              <span className={`status-badge ${section.status}`}>
+                {section.status === 'added' ? 'A' : section.status === 'deleted' ? 'D' : 'M'}
+              </span>
+            )}
+          </div>
+          <table className="diff-table">
+            <thead>
+              <tr>
+                <th style={{ width: '30px' }}></th>
+                <th style={{ width: '40%' }}>Field</th>
+                <th>Value</th>
+              </tr>
+            </thead>
+            <tbody>
+              {section.fields.map((field, index) => (
+                <tr key={index} className={field.status}>
+                  <td>
+                    {field.status !== 'unchanged' && (
+                      <span className={`status-badge ${field.status}`}>
+                        {field.status === 'added' ? 'A' : field.status === 'deleted' ? 'D' : 'M'}
+                      </span>
+                    )}
+                  </td>
+                  <td className="key-cell">{field.key}</td>
+                  <td className="value-cell">{field.value}</td>
+                </tr>
+              ))}
+            </tbody>
+          </table>
+        </div>
+      ))}
+    </>
+  );
+};
+
+export default VisualDiffAuth;

packages/bruno-app/src/components/Git/VisualDiffViewer/VisualDiffBody.js

@@ -0,0 +1,353 @@
+import React, { useMemo } from 'react';
+import get from 'lodash/get';
+import isEqual from 'lodash/isEqual';
+import { computeLineDiffForOld, computeLineDiffForNew } from './utils/diffUtils';
+
+const BODY_TYPE_LABELS = {
+  json: 'JSON',
+  text: 'Text',
+  xml: 'XML',
+  sparql: 'SPARQL',
+  graphql: 'GraphQL',
+  formUrlEncoded: 'Form URL Encoded',
+  multipartForm: 'Multipart Form',
+  file: 'File',
+  grpc: 'gRPC',
+  ws: 'WebSocket'
+};
+
+const TEXT_BODY_TYPES = ['json', 'text', 'xml', 'sparql'];
+const FORM_BODY_TYPES = ['formUrlEncoded', 'multipartForm'];
+const ALL_BODY_TYPES = Object.keys(BODY_TYPE_LABELS);
+
+const VisualDiffBody = ({ oldData, newData, showSide }) => {
+  const oldBody = get(oldData, 'request.body', {});
+  const newBody = get(newData, 'request.body', {});
+
+  const currentBody = showSide === 'old' ? oldBody : newBody;
+  const otherBody = showSide === 'old' ? newBody : oldBody;
+
+  const bodyTypes = useMemo(() => {
+    const currentMode = currentBody.mode;
+    const otherMode = otherBody.mode;
+
+    // Collect body types that match either side's active mode
+    const relevantTypes = new Set();
+    if (currentMode && currentMode !== 'none') {
+      relevantTypes.add(currentMode);
+    }
+    if (otherMode && otherMode !== 'none') {
+      relevantTypes.add(otherMode);
+    }
+
+    // If neither side has a mode (legacy data), fall back to showing all defined types
+    if (relevantTypes.size === 0) {
+      return ALL_BODY_TYPES.filter((type) => {
+        const currentVal = currentBody[type];
+        const otherVal = otherBody[type];
+        return currentVal !== undefined || otherVal !== undefined;
+      });
+    }
+
+    // Only show body types that match the active mode on either side
+    return ALL_BODY_TYPES.filter((type) => {
+      if (!relevantTypes.has(type)) return false;
+      const currentVal = currentBody[type];
+      const otherVal = otherBody[type];
+      return currentVal !== undefined || otherVal !== undefined;
+    });
+  }, [currentBody, otherBody]);
+
+  const renderLineDiff = (segments) => {
+    return segments.map((segment, index) => (
+      <div key={index} className={`diff-line ${segment.status}`}>
+        {segment.text || '\u00A0'}
+      </div>
+    ));
+  };
+
+  const renderFormData = (items, otherItems) => {
+    if (!items || items.length === 0) return null;
+
+    const otherItemMap = new Map();
+    (otherItems || []).forEach((item) => {
+      otherItemMap.set(item.name, item);
+    });
+
+    return (
+      <table className="diff-table">
+        <thead>
+          <tr>
+            <th style={{ width: '30px' }}></th>
+            <th className="checkbox-cell"></th>
+            <th style={{ width: '40%' }}>Key</th>
+            <th>Value</th>
+          </tr>
+        </thead>
+        <tbody>
+          {items.map((item, index) => {
+            const otherItem = otherItemMap.get(item.name);
+            let status = 'unchanged';
+            if (!otherItem) {
+              status = showSide === 'old' ? 'deleted' : 'added';
+            } else if (item.value !== otherItem.value || item.enabled !== otherItem.enabled) {
+              status = 'modified';
+            }
+
+            return (
+              <tr key={`${item.name}-${index}`} className={status}>
+                <td>
+                  {status !== 'unchanged' && (
+                    <span className={`status-badge ${status}`}>
+                      {status === 'added' ? 'A' : status === 'deleted' ? 'D' : 'M'}
+                    </span>
+                  )}
+                </td>
+                <td className="checkbox-cell">
+                  <input
+                    type="checkbox"
+                    checked={item.enabled !== false}
+                    readOnly
+                    disabled
+                  />
+                </td>
+                <td className="key-cell">{item.name}</td>
+                <td className="value-cell">{item.value}</td>
+              </tr>
+            );
+          })}
+        </tbody>
+      </table>
+    );
+  };
+
+  const renderFileBody = (files, otherFiles) => {
+    if (!files || files.length === 0) return null;
+
+    const otherFileMap = new Map();
+    (otherFiles || []).forEach((f, idx) => {
+      otherFileMap.set(f.filePath || idx, f);
+    });
+
+    return (
+      <table className="diff-table">
+        <thead>
+          <tr>
+            <th style={{ width: '30px' }}></th>
+            <th className="checkbox-cell"></th>
+            <th>File Path</th>
+            <th style={{ width: '100px' }}>Content Type</th>
+          </tr>
+        </thead>
+        <tbody>
+          {files.map((file, index) => {
+            const otherFile = otherFileMap.get(file.filePath || index);
+            let status = 'unchanged';
+            if (!otherFile) {
+              status = showSide === 'old' ? 'deleted' : 'added';
+            } else if (file.filePath !== otherFile.filePath || file.contentType !== otherFile.contentType) {
+              status = 'modified';
+            }
+
+            return (
+              <tr key={index} className={status}>
+                <td>
+                  {status !== 'unchanged' && (
+                    <span className={`status-badge ${status}`}>
+                      {status === 'added' ? 'A' : status === 'deleted' ? 'D' : 'M'}
+                    </span>
+                  )}
+                </td>
+                <td className="checkbox-cell">
+                  <input type="checkbox" checked={file.selected !== false} readOnly disabled />
+                </td>
+                <td className="value-cell">{file.filePath}</td>
+                <td className="value-cell">{file.contentType || '-'}</td>
+              </tr>
+            );
+          })}
+        </tbody>
+      </table>
+    );
+  };
+
+  const renderMessageBody = (messages, otherMessages, typeLabel) => {
+    if (!messages || messages.length === 0) return null;
+
+    return messages.map((msg, index) => {
+      const otherMsg = (otherMessages || [])[index];
+      const contentDiff = showSide === 'old'
+        ? computeLineDiffForOld(msg.content || '', otherMsg?.content || '')
+        : computeLineDiffForNew(otherMsg?.content || '', msg.content || '');
+
+      let msgStatus = 'unchanged';
+      if (!otherMsg) {
+        msgStatus = showSide === 'old' ? 'deleted' : 'added';
+      } else if (msg.name !== otherMsg.name || msg.type !== otherMsg.type) {
+        msgStatus = 'modified';
+      }
+
+      return (
+        <div key={index}>
+          <div className="diff-section-header">
+            <span>{typeLabel}: {msg.name || `Message ${index + 1}`}{msg.type ? ` (${msg.type})` : ''}</span>
+            {msgStatus !== 'unchanged' && (
+              <span className={`status-badge ${msgStatus}`}>
+                {msgStatus === 'added' ? 'A' : msgStatus === 'deleted' ? 'D' : 'M'}
+              </span>
+            )}
+          </div>
+          <div className="code-diff-content">{renderLineDiff(contentDiff)}</div>
+        </div>
+      );
+    });
+  };
+
+  const renderGraphqlBody = (graphql, otherGraphql) => {
+    const currentQuery = graphql?.query || '';
+    const otherQuery = otherGraphql?.query || '';
+    const currentVariables = graphql?.variables || '';
+    const otherVariables = otherGraphql?.variables || '';
+
+    const queryDiff = showSide === 'old'
+      ? computeLineDiffForOld(currentQuery, otherQuery)
+      : computeLineDiffForNew(otherQuery, currentQuery);
+
+    const variablesDiff = showSide === 'old'
+      ? computeLineDiffForOld(currentVariables, otherVariables)
+      : computeLineDiffForNew(otherVariables, currentVariables);
+
+    return (
+      <>
+        {(currentQuery || otherQuery) && (
+          <div>
+            <div className="diff-section-header">Query</div>
+            <div className="code-diff-content">{renderLineDiff(queryDiff)}</div>
+          </div>
+        )}
+        {(currentVariables || otherVariables) && (
+          <div>
+            <div className="diff-section-header">Variables</div>
+            <div className="code-diff-content">{renderLineDiff(variablesDiff)}</div>
+          </div>
+        )}
+      </>
+    );
+  };
+
+  const renderTextBody = (currentContent, otherContent) => {
+    const diffSegments = showSide === 'old'
+      ? computeLineDiffForOld(currentContent || '', otherContent || '')
+      : computeLineDiffForNew(otherContent || '', currentContent || '');
+
+    return (
+      <div className="code-diff-content">
+        {renderLineDiff(diffSegments)}
+      </div>
+    );
+  };
+
+  const renderBodyType = (type) => {
+    const currentVal = currentBody[type];
+    const otherVal = otherBody[type];
+
+    if (currentVal === undefined && otherVal === undefined) return null;
+
+    // For text-based body types
+    if (TEXT_BODY_TYPES.includes(type)) {
+      if (!currentVal) return null;
+      return renderTextBody(currentVal, otherVal);
+    }
+
+    // For form data types
+    if (FORM_BODY_TYPES.includes(type)) {
+      return renderFormData(currentVal, otherVal);
+    }
+
+    // GraphQL
+    if (type === 'graphql') {
+      return renderGraphqlBody(currentVal, otherVal);
+    }
+
+    // File
+    if (type === 'file') {
+      return renderFileBody(currentVal, otherVal);
+    }
+
+    // gRPC
+    if (type === 'grpc') {
+      return renderMessageBody(currentVal, otherVal, 'gRPC');
+    }
+
+    // WebSocket
+    if (type === 'ws') {
+      return renderMessageBody(currentVal, otherVal, 'WebSocket');
+    }
+
+    return null;
+  };
+
+  // Show body mode if present
+  const currentMode = currentBody.mode;
+  const otherMode = otherBody.mode;
+  const modeStatus = currentMode !== otherMode ? (otherMode === undefined ? (showSide === 'old' ? 'deleted' : 'added') : 'modified') : 'unchanged';
+
+  if (bodyTypes.length === 0 && !currentMode) {
+    return null;
+  }
+
+  return (
+    <>
+      {currentMode && (
+        <div className="diff-section">
+          <table className="diff-table">
+            <thead>
+              <tr>
+                <th style={{ width: '30px' }}></th>
+                <th style={{ width: '40%' }}>Field</th>
+                <th>Value</th>
+              </tr>
+            </thead>
+            <tbody>
+              <tr className={modeStatus}>
+                <td>
+                  {modeStatus !== 'unchanged' && (
+                    <span className={`status-badge ${modeStatus}`}>
+                      {modeStatus === 'added' ? 'A' : modeStatus === 'deleted' ? 'D' : 'M'}
+                    </span>
+                  )}
+                </td>
+                <td className="key-cell">Body Mode</td>
+                <td className="value-cell">{BODY_TYPE_LABELS[currentMode] || currentMode}</td>
+              </tr>
+            </tbody>
+          </table>
+        </div>
+      )}
+      {bodyTypes.map((type) => {
+        const content = renderBodyType(type);
+        if (!content) return null;
+
+        const currentVal = currentBody[type];
+        const otherVal = otherBody[type];
+        const hasChanges = !isEqual(currentVal, otherVal);
+
+        return (
+          <div key={type} className="diff-section">
+            <div className="diff-section-header">
+              <span>{BODY_TYPE_LABELS[type] || type}</span>
+              {hasChanges && (
+                <span className={`status-badge ${otherVal === undefined ? (showSide === 'old' ? 'deleted' : 'added') : 'modified'}`}>
+                  {otherVal === undefined ? (showSide === 'old' ? 'D' : 'A') : 'M'}
+                </span>
+              )}
+            </div>
+            {content}
+          </div>
+        );
+      })}
+    </>
+  );
+};
+
+export default VisualDiffBody;

packages/bruno-app/src/components/Git/VisualDiffViewer/VisualDiffContent/StyledWrapper.js

@@ -0,0 +1,443 @@
+import styled from 'styled-components';
+
+const StyledWrapper = styled.div`
+  height: 100%;
+  display: flex;
+  flex-direction: column;
+
+  .visual-diff-content {
+    flex: 1;
+    overflow: auto;
+  }
+
+  .diff-header-row {
+    display: flex;
+    border: 1px solid ${(props) => props.theme.border.border1};
+    border-radius: ${(props) => props.theme.border.radius.base};
+    margin-bottom: 1rem;
+  }
+
+  .diff-header-pane {
+     flex: 1;
+      padding: 0.5rem 0.75rem;
+      font-size: ${(props) => props.theme.font.size.xs};
+      font-weight: 600;
+      color: ${(props) => props.theme.colors.text.muted};
+      text-transform: uppercase;
+
+      &.old {
+        border-right: 1px solid ${(props) => props.theme.border.border1};
+      }
+  }
+
+  .diff-sections {
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+  }
+
+  .diff-row {
+    border: 1px solid ${(props) => props.theme.border.border1};
+    border-radius: ${(props) => props.theme.border.radius.base};
+    overflow: hidden;
+  }
+
+  .diff-row-header {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    padding: 0.5rem 0.75rem;
+    background: ${(props) => props.theme.sidebar.bg};
+    cursor: pointer;
+    user-select: none;
+    border-bottom: 1px solid ${(props) => props.theme.border.border1};
+
+    &:hover {
+      background: ${(props) => props.theme.sidebar.collection.item.hoverBg};
+    }
+  }
+
+  .collapse-toggle {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    color: ${(props) => props.theme.colors.text.muted};
+  }
+
+  .diff-row-title {
+    font-size: ${(props) => props.theme.font.size.sm};
+    font-weight: 500;
+    color: ${(props) => props.theme.text};
+  }
+
+  .diff-row-content {
+    display: flex;
+    gap: 1rem;
+    padding: 0.75rem;
+    background: ${(props) => props.theme.background.base};
+  }
+
+  .diff-row-pane {
+    flex: 1;
+    min-width: 0;
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+
+    &.old {
+      border-left: 2px solid ${(props) => props.theme.colors.text.danger}20;
+      padding-left: 0.5rem;
+    }
+
+    &.new {
+      border-left: 2px solid ${(props) => props.theme.colors.text.green}20;
+      padding-left: 0.5rem;
+    }
+  }
+
+  .empty-placeholder {
+    flex: 1;
+    min-height: 40px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    background: ${(props) => props.theme.sidebar.bg};
+    border: 1px dashed ${(props) => props.theme.border.border1};
+    border-radius: ${(props) => props.theme.border.radius.sm};
+    color: ${(props) => props.theme.colors.text.muted};
+    font-size: ${(props) => props.theme.font.size.xs};
+  }
+
+  .empty-placeholder::after {
+    content: 'No content';
+  }
+
+  .diff-section {
+    border: 1px solid ${(props) => props.theme.border.border1};
+    border-radius: ${(props) => props.theme.border.radius.sm};
+    overflow: hidden;
+
+    &.added {
+      border-color: ${(props) => props.theme.colors.text.green};
+    }
+
+    &.deleted {
+      border-color: ${(props) => props.theme.colors.text.danger};
+    }
+  }
+
+  .diff-section-header {
+    padding: 0.375rem 0.5rem;
+    font-size: ${(props) => props.theme.font.size.xs};
+    font-weight: 500;
+    background: ${(props) => props.theme.sidebar.bg};
+    border-bottom: 1px solid ${(props) => props.theme.border.border1};
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+  }
+
+  .diff-section-content {
+    padding: 0.5rem;
+  }
+
+  .url-bar {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    padding: 0.375rem 0.5rem;
+
+    .method {
+      font-weight: 600;
+      font-size: ${(props) => props.theme.font.size.xs};
+      text-transform: uppercase;
+      padding: 0.125rem 0.375rem;
+      border-radius: ${(props) => props.theme.border.radius.sm};
+      background: ${(props) => props.theme.brand}15;
+      color: ${(props) => props.theme.brand};
+    }
+
+    .url {
+      flex: 1;
+      font-family: 'Fira Code', monospace;
+      font-size: ${(props) => props.theme.font.size.xs};
+      color: ${(props) => props.theme.text};
+      word-break: break-all;
+
+      &.changed {
+        background: color-mix(in srgb, ${(props) => props.theme.colors.text.warning} 20%, transparent);
+        padding: 0.125rem 0.25rem;
+        border-radius: ${(props) => props.theme.border.radius.sm};
+      }
+    }
+
+    .method.changed {
+      background: color-mix(in srgb, ${(props) => props.theme.colors.text.warning} 30%, transparent);
+      color: ${(props) => props.theme.colors.text.warning};
+    }
+  }
+
+  .diff-inline {
+    padding: 0.125rem 0.25rem;
+    border-radius: 2px;
+
+    &.added {
+      background: color-mix(in srgb, ${(props) => props.theme.colors.text.green} 25%, transparent);
+      color: ${(props) => props.theme.colors.text.green};
+    }
+
+    &.deleted {
+      background: color-mix(in srgb, ${(props) => props.theme.colors.text.danger} 25%, transparent);
+      color: ${(props) => props.theme.colors.text.danger};
+      text-decoration: line-through;
+    }
+
+    &.modified {
+      background: color-mix(in srgb, ${(props) => props.theme.colors.text.warning} 25%, transparent);
+      color: ${(props) => props.theme.colors.text.warning};
+    }
+  }
+
+
+
+  .diff-table {
+    width: 100%;
+    border-collapse: collapse;
+    font-size: ${(props) => props.theme.font.size.xs};
+
+    th, td {
+      padding: 0.375rem 0.5rem;
+      text-align: left;
+      border-bottom: 1px solid ${(props) => props.theme.border.border1};
+    }
+
+    th {
+      font-weight: 500;
+      color: ${(props) => props.theme.colors.text.muted};
+      background: ${(props) => props.theme.sidebar.bg};
+    }
+
+    tr.added {
+      background: color-mix(in srgb, ${(props) => props.theme.colors.text.green} 10%, transparent);
+    }
+
+    tr.deleted {
+      background: color-mix(in srgb, ${(props) => props.theme.colors.text.danger} 10%, transparent);
+    }
+
+    tr.modified {
+      background: color-mix(in srgb, ${(props) => props.theme.colors.text.warning} 10%, transparent);
+    }
+
+    .checkbox-cell {
+      width: 24px;
+      text-align: center;
+
+      input[type='checkbox'] {
+        cursor: default;
+        width: 12px;
+        height: 12px;
+        accent-color: ${(props) => props.theme.colors.accent};
+        vertical-align: middle;
+        margin: 0;
+      }
+    }
+
+    .key-cell {
+      font-family: 'Fira Code', monospace;
+      color: ${(props) => props.theme.text};
+    }
+
+    .value-cell {
+      font-family: 'Fira Code', monospace;
+      color: ${(props) => props.theme.colors.text.muted};
+      word-break: break-all;
+    }
+
+    .status-badge {
+      display: inline-flex;
+      align-items: center;
+      justify-content: center;
+      width: 0.875rem;
+      height: 0.875rem;
+      border-radius: 2px;
+      font-size: 8px;
+      font-weight: 600;
+
+      &.added {
+        background: color-mix(in srgb, ${(props) => props.theme.colors.text.green} 13%, transparent);
+        color: ${(props) => props.theme.colors.text.green};
+      }
+
+      &.deleted {
+        background: color-mix(in srgb, ${(props) => props.theme.colors.text.danger} 13%, transparent);
+        color: ${(props) => props.theme.colors.text.danger};
+      }
+
+      &.modified {
+        background: color-mix(in srgb, ${(props) => props.theme.colors.text.warning} 13%, transparent);
+        color: ${(props) => props.theme.colors.text.warning};
+      }
+    }
+  }
+
+  .code-diff-content {
+    max-height: 250px;
+    overflow: auto;
+    font-family: 'Fira Code', monospace;
+    font-size: ${(props) => props.theme.font.size.xs};
+    line-height: 1.5;
+
+    .diff-line {
+      padding: 0 0.5rem;
+      white-space: pre-wrap;
+      word-break: break-word;
+
+      &.unchanged {
+        color: ${(props) => props.theme.text};
+      }
+
+      &.added {
+        background: color-mix(in srgb, ${(props) => props.theme.colors.text.green} 15%, transparent);
+        color: ${(props) => props.theme.colors.text.green};
+      }
+
+      &.deleted {
+        background: color-mix(in srgb, ${(props) => props.theme.colors.text.danger} 15%, transparent);
+        color: ${(props) => props.theme.colors.text.danger};
+        text-decoration: line-through;
+      }
+    }
+  }
+
+  .example-content {
+    padding: 0.5rem;
+  }
+
+  .example-block {
+    margin-bottom: 0.5rem;
+
+    &:last-child {
+      margin-bottom: 0;
+    }
+  }
+
+  .example-block-header {
+    font-size: ${(props) => props.theme.font.size.xs};
+    font-weight: 600;
+    color: ${(props) => props.theme.colors.text.muted};
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    padding: 0.25rem 0.5rem;
+    background: ${(props) => props.theme.sidebar.bg};
+    border-radius: ${(props) => props.theme.border.radius.sm};
+    margin-bottom: 0.375rem;
+  }
+
+  .example-subsection {
+    margin-bottom: 0.375rem;
+
+    &:last-child {
+      margin-bottom: 0;
+    }
+  }
+
+  .example-subsection-title {
+    font-size: ${(props) => props.theme.font.size.xs};
+    font-weight: 500;
+    color: ${(props) => props.theme.colors.text.muted};
+    padding: 0.25rem 0.5rem;
+    margin-bottom: 0.25rem;
+  }
+
+  .example-description {
+    font-weight: 400;
+    color: ${(props) => props.theme.colors.text.muted};
+    font-style: italic;
+  }
+
+  .status-display {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    padding: 0.25rem 0.5rem;
+    font-family: 'Fira Code', monospace;
+    font-size: ${(props) => props.theme.font.size.xs};
+
+    .status-code {
+      font-weight: 600;
+      padding: 0.125rem 0.375rem;
+      border-radius: ${(props) => props.theme.border.radius.sm};
+      background: ${(props) => props.theme.sidebar.bg};
+
+      &.changed {
+        background: color-mix(in srgb, ${(props) => props.theme.colors.text.warning} 20%, transparent);
+        color: ${(props) => props.theme.colors.text.warning};
+      }
+    }
+
+    .status-text {
+      color: ${(props) => props.theme.colors.text.muted};
+
+      &.changed {
+        color: ${(props) => props.theme.colors.text.warning};
+      }
+    }
+  }
+
+  .example-subsection .diff-table {
+    margin: 0;
+  }
+
+  .example-subsection .code-diff-content {
+    max-height: 150px;
+    border: 1px solid ${(props) => props.theme.border.border1};
+    border-radius: ${(props) => props.theme.border.radius.sm};
+  }
+
+  .empty-state {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    padding: 2rem;
+    color: ${(props) => props.theme.colors.text.muted};
+    font-size: ${(props) => props.theme.font.size.sm};
+  }
+
+  .tags-container {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.25rem;
+  }
+
+  .tag-badge {
+    display: inline-block;
+    padding: 0.125rem 0.375rem;
+    font-size: ${(props) => props.theme.font.size.xs};
+    font-family: 'Fira Code', monospace;
+    border-radius: ${(props) => props.theme.border.radius.sm};
+    background: ${(props) => props.theme.sidebar.bg};
+    border: 1px solid ${(props) => props.theme.border.border1};
+
+    &.added {
+      background: color-mix(in srgb, ${(props) => props.theme.colors.text.green} 15%, transparent);
+      border-color: ${(props) => props.theme.colors.text.green};
+      color: ${(props) => props.theme.colors.text.green};
+    }
+
+    &.deleted {
+      background: color-mix(in srgb, ${(props) => props.theme.colors.text.danger} 15%, transparent);
+      border-color: ${(props) => props.theme.colors.text.danger};
+      color: ${(props) => props.theme.colors.text.danger};
+      text-decoration: line-through;
+    }
+
+    &.modified {
+      background: color-mix(in srgb, ${(props) => props.theme.colors.text.warning} 15%, transparent);
+      border-color: ${(props) => props.theme.colors.text.warning};
+      color: ${(props) => props.theme.colors.text.warning};
+    }
+  }
+`;
+
+export default StyledWrapper;

packages/bruno-app/src/components/Git/VisualDiffViewer/VisualDiffContent/index.js

@@ -0,0 +1,109 @@
+import React, { useState, useEffect } from 'react';
+import CollapsibleDiffRow from '../CollapsibleDiffRow';
+import StyledWrapper from './StyledWrapper';
+
+/**
+ * VisualDiffContent - Presentational component for rendering visual diffs
+ *
+ * This is a reusable component that renders the visual diff UI.
+ * It can be used by:
+ * - Git VisualDiffViewer (for git diffs)
+ * - OpenAPI ChangeSection (for spec diffs)
+ *
+ * Props:
+ * - oldData: The "before" data
+ * - newData: The "after" data
+ * - sections: Array of section configs { key, title, Component, hasContent }
+ * - sectionHasChanges: Function (sectionKey, oldData, newData) => boolean
+ * - oldLabel: Label for the left/old pane (default: "Before")
+ * - newLabel: Label for the right/new pane (default: "After")
+ * - hideUnchanged: Hide sections without changes entirely (default: false)
+ */
+const VisualDiffContent = ({
+  oldData,
+  newData,
+  sections,
+  sectionHasChanges,
+  oldLabel = 'Before',
+  newLabel = 'After',
+  hideUnchanged = false
+}) => {
+  const [collapsedSections, setCollapsedSections] = useState({});
+
+  const toggleSection = (sectionKey) => {
+    setCollapsedSections((prev) => ({
+      ...prev,
+      [sectionKey]: !prev[sectionKey]
+    }));
+  };
+
+  // Auto-collapse unchanged sections (collapsed but still visible)
+  useEffect(() => {
+    if (!sectionHasChanges || (!oldData && !newData)) return;
+
+    const initialCollapsed = {};
+    sections.forEach(({ key }) => {
+      const hasChanges = sectionHasChanges(key, oldData, newData);
+      initialCollapsed[key] = !hasChanges;
+    });
+
+    setCollapsedSections(initialCollapsed);
+  }, [oldData, newData, sections, sectionHasChanges]);
+
+  if (!oldData && !newData) {
+    return (
+      <StyledWrapper>
+        <div className="empty-state">
+          No content to display
+        </div>
+      </StyledWrapper>
+    );
+  }
+
+  return (
+    <StyledWrapper>
+
+      <div className="visual-diff-content">
+        <div className="diff-header-row">
+          <div className="diff-header-pane old">{oldLabel}</div>
+          <div className="diff-header-pane new">{newLabel}</div>
+        </div>
+
+        <div className="diff-sections">
+          {sections.map(({ key, title, Component, hasContent: checkContent }) => {
+            const hasOld = oldData && checkContent(oldData);
+            const hasNew = newData && checkContent(newData);
+
+            if (!hasOld && !hasNew) {
+              return null;
+            }
+
+            // Hide sections without changes entirely when hideUnchanged is enabled
+            if (hideUnchanged && sectionHasChanges && !sectionHasChanges(key, oldData, newData)) {
+              return null;
+            }
+
+            return (
+              <CollapsibleDiffRow
+                key={key}
+                title={title}
+                isCollapsed={collapsedSections[key] || false}
+                onToggle={() => toggleSection(key)}
+                hasOldContent={hasOld}
+                hasNewContent={hasNew}
+                oldContent={
+                  <Component oldData={oldData} newData={newData} showSide="old" />
+                }
+                newContent={
+                  <Component oldData={oldData} newData={newData} showSide="new" />
+                }
+              />
+            );
+          })}
+        </div>
+      </div>
+    </StyledWrapper>
+  );
+};
+
+export default VisualDiffContent;

packages/bruno-app/src/components/Git/VisualDiffViewer/VisualDiffHeaders.js

@@ -0,0 +1,74 @@
+import React, { useMemo } from 'react';
+import get from 'lodash/get';
+
+const VisualDiffHeaders = ({ oldData, newData, showSide }) => {
+  const oldHeaders = get(oldData, 'request.headers', []);
+  const newHeaders = get(newData, 'request.headers', []);
+
+  const currentHeaders = showSide === 'old' ? oldHeaders : newHeaders;
+  const otherHeaders = showSide === 'old' ? newHeaders : oldHeaders;
+
+  const headersWithStatus = useMemo(() => {
+    const otherHeaderMap = new Map();
+    otherHeaders.forEach((h) => {
+      otherHeaderMap.set(h.name, h);
+    });
+
+    return currentHeaders.map((header) => {
+      const otherHeader = otherHeaderMap.get(header.name);
+
+      let status = 'unchanged';
+      if (!otherHeader) {
+        status = showSide === 'old' ? 'deleted' : 'added';
+      } else if (header.value !== otherHeader.value || header.enabled !== otherHeader.enabled) {
+        status = 'modified';
+      }
+
+      return { ...header, status };
+    });
+  }, [currentHeaders, otherHeaders, showSide]);
+
+  if (headersWithStatus.length === 0) {
+    return null;
+  }
+
+  return (
+    <div className="diff-section">
+      <table className="diff-table">
+        <thead>
+          <tr>
+            <th style={{ width: '30px' }}></th>
+            <th className="checkbox-cell"></th>
+            <th style={{ width: '40%' }}>Key</th>
+            <th>Value</th>
+          </tr>
+        </thead>
+        <tbody>
+          {headersWithStatus.map((header, index) => (
+            <tr key={`${header.name}-${index}`} className={header.status}>
+              <td>
+                {header.status !== 'unchanged' && (
+                  <span className={`status-badge ${header.status}`}>
+                    {header.status === 'added' ? 'A' : header.status === 'deleted' ? 'D' : 'M'}
+                  </span>
+                )}
+              </td>
+              <td className="checkbox-cell">
+                <input
+                  type="checkbox"
+                  checked={header.enabled !== false}
+                  readOnly
+                  disabled
+                />
+              </td>
+              <td className="key-cell">{header.name}</td>
+              <td className="value-cell">{header.value}</td>
+            </tr>
+          ))}
+        </tbody>
+      </table>
+    </div>
+  );
+};
+
+export default VisualDiffHeaders;

packages/bruno-app/src/components/Git/VisualDiffViewer/VisualDiffParams.js

@@ -0,0 +1,89 @@
+import React, { useMemo } from 'react';
+import get from 'lodash/get';
+
+const VisualDiffParams = ({ oldData, newData, showSide }) => {
+  const oldParams = get(oldData, 'request.params', []);
+  const newParams = get(newData, 'request.params', []);
+
+  const currentParams = showSide === 'old' ? oldParams : newParams;
+  const otherParams = showSide === 'old' ? newParams : oldParams;
+
+  const paramsWithStatus = useMemo(() => {
+    const otherParamMap = new Map();
+    otherParams.forEach((p) => {
+      otherParamMap.set(p.name, p);
+    });
+
+    return currentParams.map((param) => {
+      const otherParam = otherParamMap.get(param.name);
+
+      let status = 'unchanged';
+      if (!otherParam) {
+        status = showSide === 'old' ? 'deleted' : 'added';
+      } else if (param.value !== otherParam.value || param.enabled !== otherParam.enabled) {
+        status = 'modified';
+      }
+
+      return { ...param, status };
+    });
+  }, [currentParams, otherParams, showSide]);
+
+  const queryParams = paramsWithStatus.filter((p) => p.type === 'query');
+  const pathParams = paramsWithStatus.filter((p) => p.type === 'path');
+
+  if (queryParams.length === 0 && pathParams.length === 0) {
+    return null;
+  }
+
+  const renderTable = (params, title) => {
+    if (params.length === 0) return null;
+
+    return (
+      <div className="diff-section">
+        <div className="diff-section-header">{title}</div>
+        <table className="diff-table">
+          <thead>
+            <tr>
+              <th style={{ width: '30px' }}></th>
+              <th className="checkbox-cell"></th>
+              <th style={{ width: '40%' }}>Key</th>
+              <th>Value</th>
+            </tr>
+          </thead>
+          <tbody>
+            {params.map((param, index) => (
+              <tr key={`${param.name}-${index}`} className={param.status}>
+                <td>
+                  {param.status !== 'unchanged' && (
+                    <span className={`status-badge ${param.status}`}>
+                      {param.status === 'added' ? 'A' : param.status === 'deleted' ? 'D' : 'M'}
+                    </span>
+                  )}
+                </td>
+                <td className="checkbox-cell">
+                  <input
+                    type="checkbox"
+                    checked={param.enabled !== false}
+                    readOnly
+                    disabled
+                  />
+                </td>
+                <td className="key-cell">{param.name}</td>
+                <td className="value-cell">{param.value}</td>
+              </tr>
+            ))}
+          </tbody>
+        </table>
+      </div>
+    );
+  };
+
+  return (
+    <>
+      {renderTable(queryParams, 'Query Parameters')}
+      {renderTable(pathParams, 'Path Parameters')}
+    </>
+  );
+};
+
+export default VisualDiffParams;

packages/bruno-app/src/components/Git/VisualDiffViewer/VisualDiffUrlBar.js

@@ -0,0 +1,55 @@
+import React, { useMemo } from 'react';
+import { computeWordDiffForOld, computeWordDiffForNew } from './utils/diffUtils';
+import { getMethod, getUrl } from './utils/bruUtils';
+
+const VisualDiffUrlBar = ({ oldData, newData, showSide }) => {
+  const oldMethod = getMethod(oldData);
+  const newMethod = getMethod(newData);
+  const oldUrl = getUrl(oldData);
+  const newUrl = getUrl(newData);
+
+  const currentMethod = showSide === 'old' ? oldMethod : newMethod;
+
+  const urlDiffSegments = useMemo(() => {
+    if (showSide === 'old') {
+      return computeWordDiffForOld(oldUrl, newUrl);
+    } else {
+      return computeWordDiffForNew(oldUrl, newUrl);
+    }
+  }, [oldUrl, newUrl, showSide]);
+
+  const methodChanged = oldMethod !== newMethod;
+  const methodStatus = useMemo(() => {
+    if (!methodChanged) return 'unchanged';
+    if (showSide === 'old') return 'deleted';
+    return 'added';
+  }, [methodChanged, showSide]);
+
+  const renderDiffSegments = (segments) => {
+    return segments.map((segment, index) => {
+      if (segment.status === 'unchanged') {
+        return <span key={index}>{segment.text}</span>;
+      }
+      return (
+        <span key={index} className={`diff-inline ${segment.status}`}>
+          {segment.text}
+        </span>
+      );
+    });
+  };
+
+  return (
+    <div className="diff-section">
+      <div className="url-bar">
+        <span className={`method ${methodStatus !== 'unchanged' ? `diff-inline ${methodStatus}` : ''}`}>
+          {currentMethod?.toUpperCase() || 'GET'}
+        </span>
+        <span className="url">
+          {renderDiffSegments(urlDiffSegments)}
+        </span>
+      </div>
+    </div>
+  );
+};
+
+export default VisualDiffUrlBar;

packages/bruno-app/src/components/Git/VisualDiffViewer/utils/bruUtils.js

@@ -0,0 +1,53 @@
+import get from 'lodash/get';
+
+export const DIFF_STATUS = Object.freeze({
+  ADDED: 'added',
+  DELETED: 'deleted',
+  MODIFIED: 'modified',
+  UNCHANGED: 'unchanged'
+});
+
+export const getBodyContent = (body) => {
+  if (!body) return '';
+  if (body.json) return body.json;
+  if (body.text) return body.text;
+  if (body.xml) return body.xml;
+  if (body.sparql) return body.sparql;
+  if (body.graphql?.query) return body.graphql.query;
+  if (body.content) return body.content;
+  return '';
+};
+
+export const getBodyMode = (body) => {
+  if (!body) return 'none';
+  if (body.json !== undefined) return 'json';
+  if (body.text !== undefined) return 'text';
+  if (body.xml !== undefined) return 'xml';
+  if (body.sparql !== undefined) return 'sparql';
+  if (body.graphql) return 'graphql';
+  if (body.formUrlEncoded) return 'formUrlEncoded';
+  if (body.multipartForm) return 'multipartForm';
+  if (body.file) return 'file';
+  if (body.grpc) return 'grpc';
+  if (body.ws) return 'ws';
+  if (body.mode === 'none') return 'none';
+  return 'none';
+};
+
+export const getMethod = (data) => {
+  return get(data, 'request.method', 'GET');
+};
+
+export const getUrl = (data) => {
+  return get(data, 'request.url', '');
+};
+
+export const computeItemDiffStatus = (currentItem, otherItem, showSide) => {
+  if (!otherItem) {
+    return showSide === 'old' ? DIFF_STATUS.DELETED : DIFF_STATUS.ADDED;
+  }
+  if (currentItem.value !== otherItem.value || currentItem.enabled !== otherItem.enabled) {
+    return DIFF_STATUS.MODIFIED;
+  }
+  return DIFF_STATUS.UNCHANGED;
+};

packages/bruno-app/src/components/Git/VisualDiffViewer/utils/bruUtils.spec.js

@@ -0,0 +1,194 @@
+const { describe, it, expect } = require('@jest/globals');
+
+import {
+  getBodyContent,
+  getBodyMode,
+  getMethod,
+  getUrl,
+  computeItemDiffStatus
+} from './bruUtils';
+
+describe('bruUtils', () => {
+  describe('getBodyContent', () => {
+    it('should return empty string for null or undefined body', () => {
+      expect(getBodyContent(null)).toBe('');
+      expect(getBodyContent(undefined)).toBe('');
+    });
+
+    it('should return empty string for empty body', () => {
+      expect(getBodyContent({})).toBe('');
+    });
+
+    it('should return json content', () => {
+      expect(getBodyContent({ json: '{"key": "value"}' })).toBe('{"key": "value"}');
+    });
+
+    it('should return text content', () => {
+      expect(getBodyContent({ text: 'plain text content' })).toBe('plain text content');
+    });
+
+    it('should return xml content', () => {
+      expect(getBodyContent({ xml: '<root><item>value</item></root>' })).toBe('<root><item>value</item></root>');
+    });
+
+    it('should return sparql content', () => {
+      expect(getBodyContent({ sparql: 'SELECT * WHERE { ?s ?p ?o }' })).toBe('SELECT * WHERE { ?s ?p ?o }');
+    });
+
+    it('should return graphql query content', () => {
+      expect(getBodyContent({ graphql: { query: 'query { users { id } }' } })).toBe('query { users { id } }');
+    });
+
+    it('should return generic content', () => {
+      expect(getBodyContent({ content: 'generic content' })).toBe('generic content');
+    });
+
+    it('should return empty string for graphql without query', () => {
+      expect(getBodyContent({ graphql: {} })).toBe('');
+      expect(getBodyContent({ graphql: { variables: '{}' } })).toBe('');
+    });
+
+    it('should prioritize json over other types', () => {
+      expect(getBodyContent({ json: '{"a":1}', text: 'text' })).toBe('{"a":1}');
+    });
+  });
+
+  describe('getBodyMode', () => {
+    it('should return none for null or undefined body', () => {
+      expect(getBodyMode(null)).toBe('none');
+      expect(getBodyMode(undefined)).toBe('none');
+    });
+
+    it('should return none for empty body', () => {
+      expect(getBodyMode({})).toBe('none');
+    });
+
+    it('should return json mode', () => {
+      expect(getBodyMode({ json: '{}' })).toBe('json');
+      expect(getBodyMode({ json: '' })).toBe('json');
+    });
+
+    it('should return text mode', () => {
+      expect(getBodyMode({ text: 'content' })).toBe('text');
+      expect(getBodyMode({ text: '' })).toBe('text');
+    });
+
+    it('should return xml mode', () => {
+      expect(getBodyMode({ xml: '<root/>' })).toBe('xml');
+    });
+
+    it('should return sparql mode', () => {
+      expect(getBodyMode({ sparql: 'SELECT *' })).toBe('sparql');
+    });
+
+    it('should return graphql mode', () => {
+      expect(getBodyMode({ graphql: { query: '' } })).toBe('graphql');
+    });
+
+    it('should return formUrlEncoded mode', () => {
+      expect(getBodyMode({ formUrlEncoded: [] })).toBe('formUrlEncoded');
+      expect(getBodyMode({ formUrlEncoded: [{ name: 'key', value: 'val' }] })).toBe('formUrlEncoded');
+    });
+
+    it('should return multipartForm mode', () => {
+      expect(getBodyMode({ multipartForm: [] })).toBe('multipartForm');
+    });
+
+    it('should return file mode', () => {
+      expect(getBodyMode({ file: [] })).toBe('file');
+    });
+
+    it('should return grpc mode', () => {
+      expect(getBodyMode({ grpc: [] })).toBe('grpc');
+    });
+
+    it('should return ws mode', () => {
+      expect(getBodyMode({ ws: [] })).toBe('ws');
+    });
+
+    it('should return none for explicit none mode', () => {
+      expect(getBodyMode({ mode: 'none' })).toBe('none');
+    });
+
+    it('should prioritize json over other modes', () => {
+      expect(getBodyMode({ json: '{}', text: 'text' })).toBe('json');
+    });
+  });
+
+  describe('getMethod', () => {
+    it('should return GET as default', () => {
+      expect(getMethod(null)).toBe('GET');
+      expect(getMethod(undefined)).toBe('GET');
+      expect(getMethod({})).toBe('GET');
+    });
+
+    it('should return request method', () => {
+      expect(getMethod({ request: { method: 'POST' } })).toBe('POST');
+      expect(getMethod({ request: { method: 'PUT' } })).toBe('PUT');
+      expect(getMethod({ request: { method: 'DELETE' } })).toBe('DELETE');
+    });
+
+    it('should return GET when request exists but method is missing', () => {
+      expect(getMethod({ request: {} })).toBe('GET');
+    });
+  });
+
+  describe('getUrl', () => {
+    it('should return empty string as default', () => {
+      expect(getUrl(null)).toBe('');
+      expect(getUrl(undefined)).toBe('');
+      expect(getUrl({})).toBe('');
+    });
+
+    it('should return request url', () => {
+      expect(getUrl({ request: { url: 'https://api.example.com/users' } })).toBe('https://api.example.com/users');
+    });
+
+    it('should return empty string when request exists but url is missing', () => {
+      expect(getUrl({ request: {} })).toBe('');
+    });
+
+    it('should return url with different protocols', () => {
+      expect(getUrl({ request: { url: 'http://localhost:3000' } })).toBe('http://localhost:3000');
+      expect(getUrl({ request: { url: 'ws://localhost:8080' } })).toBe('ws://localhost:8080');
+      expect(getUrl({ request: { url: 'grpc://localhost:50051' } })).toBe('grpc://localhost:50051');
+    });
+  });
+
+  describe('computeItemDiffStatus', () => {
+    it('should return deleted when other item is missing and showing old side', () => {
+      expect(computeItemDiffStatus({ name: 'key', value: 'val' }, null, 'old')).toBe('deleted');
+      expect(computeItemDiffStatus({ name: 'key', value: 'val' }, undefined, 'old')).toBe('deleted');
+    });
+
+    it('should return added when other item is missing and showing new side', () => {
+      expect(computeItemDiffStatus({ name: 'key', value: 'val' }, null, 'new')).toBe('added');
+      expect(computeItemDiffStatus({ name: 'key', value: 'val' }, undefined, 'new')).toBe('added');
+    });
+
+    it('should return unchanged when items are equal', () => {
+      const item = { name: 'key', value: 'val', enabled: true };
+      const otherItem = { name: 'key', value: 'val', enabled: true };
+      expect(computeItemDiffStatus(item, otherItem, 'old')).toBe('unchanged');
+      expect(computeItemDiffStatus(item, otherItem, 'new')).toBe('unchanged');
+    });
+
+    it('should return modified when values differ', () => {
+      const item = { name: 'key', value: 'val1', enabled: true };
+      const otherItem = { name: 'key', value: 'val2', enabled: true };
+      expect(computeItemDiffStatus(item, otherItem, 'old')).toBe('modified');
+    });
+
+    it('should return modified when enabled status differs', () => {
+      const item = { name: 'key', value: 'val', enabled: true };
+      const otherItem = { name: 'key', value: 'val', enabled: false };
+      expect(computeItemDiffStatus(item, otherItem, 'old')).toBe('modified');
+    });
+
+    it('should handle undefined enabled as different from explicit false', () => {
+      const item = { name: 'key', value: 'val' };
+      const otherItem = { name: 'key', value: 'val', enabled: false };
+      expect(computeItemDiffStatus(item, otherItem, 'old')).toBe('modified');
+    });
+  });
+});

packages/bruno-app/src/components/Git/VisualDiffViewer/utils/diffUtils.js

@@ -0,0 +1,202 @@
+// Matches word-boundary separators: whitespace, slashes, query/path delimiters (?&=), dots, hyphens, underscores, colons, @
+const WORD_SEPARATOR = /[\s\/\?\&\=\.\-\_\:\@]/;
+
+const splitWithSeparators = (str) => {
+  const result = [];
+  let current = '';
+  for (const char of str) {
+    if (WORD_SEPARATOR.test(char)) {
+      if (current) {
+        result.push(current);
+        current = '';
+      }
+      result.push(char);
+    } else {
+      current += char;
+    }
+  }
+  if (current) {
+    result.push(current);
+  }
+  return result;
+};
+
+export const computeWordDiffForOld = (oldStr, newStr) => {
+  if (oldStr === newStr) {
+    return [{ text: oldStr, status: 'unchanged' }];
+  }
+
+  if (!oldStr) {
+    return [];
+  }
+
+  if (!newStr) {
+    return [{ text: oldStr, status: 'deleted' }];
+  }
+
+  const oldWords = splitWithSeparators(oldStr);
+  const newWords = splitWithSeparators(newStr);
+  const lcs = computeLCS(oldWords, newWords);
+
+  const segments = [];
+  let oldIdx = 0;
+  let lcsIdx = 0;
+
+  while (oldIdx < oldWords.length) {
+    if (lcsIdx < lcs.length && oldIdx === lcs[lcsIdx].oldIndex) {
+      segments.push({ text: oldWords[oldIdx], status: 'unchanged' });
+      lcsIdx++;
+    } else {
+      segments.push({ text: oldWords[oldIdx], status: 'deleted' });
+    }
+    oldIdx++;
+  }
+
+  return mergeSegments(segments);
+};
+
+export const computeWordDiffForNew = (oldStr, newStr) => {
+  if (oldStr === newStr) {
+    return [{ text: newStr, status: 'unchanged' }];
+  }
+
+  if (!newStr) {
+    return [];
+  }
+
+  if (!oldStr) {
+    return [{ text: newStr, status: 'added' }];
+  }
+
+  const oldWords = splitWithSeparators(oldStr);
+  const newWords = splitWithSeparators(newStr);
+  const lcs = computeLCS(oldWords, newWords);
+
+  const segments = [];
+  let newIdx = 0;
+  let lcsIdx = 0;
+
+  while (newIdx < newWords.length) {
+    if (lcsIdx < lcs.length && newIdx === lcs[lcsIdx].newIndex) {
+      segments.push({ text: newWords[newIdx], status: 'unchanged' });
+      lcsIdx++;
+    } else {
+      segments.push({ text: newWords[newIdx], status: 'added' });
+    }
+    newIdx++;
+  }
+
+  return mergeSegments(segments);
+};
+
+const mergeSegments = (segments) => {
+  const merged = [];
+  for (const segment of segments) {
+    if (merged.length > 0 && merged[merged.length - 1].status === segment.status) {
+      merged[merged.length - 1].text += segment.text;
+    } else {
+      merged.push({ ...segment });
+    }
+  }
+  return merged;
+};
+
+const computeLCS = (arr1, arr2) => {
+  const m = arr1.length;
+  const n = arr2.length;
+  const dp = Array(m + 1).fill(null).map(() => Array(n + 1).fill(0));
+
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      if (arr1[i - 1] === arr2[j - 1]) {
+        dp[i][j] = dp[i - 1][j - 1] + 1;
+      } else {
+        dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+      }
+    }
+  }
+
+  const lcs = [];
+  let i = m, j = n;
+  while (i > 0 && j > 0) {
+    if (arr1[i - 1] === arr2[j - 1]) {
+      lcs.unshift({ value: arr1[i - 1], oldIndex: i - 1, newIndex: j - 1 });
+      i--;
+      j--;
+    } else if (dp[i - 1][j] > dp[i][j - 1]) {
+      i--;
+    } else {
+      j--;
+    }
+  }
+
+  return lcs;
+};
+
+export const computeLineDiffForOld = (oldStr, newStr) => {
+  if (oldStr === newStr) {
+    return (oldStr || '').split('\n').map((line) => ({ text: line, status: 'unchanged' }));
+  }
+
+  if (!oldStr) {
+    return [];
+  }
+
+  if (!newStr) {
+    return oldStr.split('\n').map((line) => ({ text: line, status: 'deleted' }));
+  }
+
+  const oldLines = oldStr.split('\n');
+  const newLines = newStr.split('\n');
+  const lcs = computeLCS(oldLines, newLines);
+
+  const segments = [];
+  let oldIdx = 0;
+  let lcsIdx = 0;
+
+  while (oldIdx < oldLines.length) {
+    if (lcsIdx < lcs.length && oldIdx === lcs[lcsIdx].oldIndex) {
+      segments.push({ text: oldLines[oldIdx], status: 'unchanged' });
+      lcsIdx++;
+    } else {
+      segments.push({ text: oldLines[oldIdx], status: 'deleted' });
+    }
+    oldIdx++;
+  }
+
+  return segments;
+};
+
+export const computeLineDiffForNew = (oldStr, newStr) => {
+  if (oldStr === newStr) {
+    return (newStr || '').split('\n').map((line) => ({ text: line, status: 'unchanged' }));
+  }
+
+  if (!newStr) {
+    return [];
+  }
+
+  if (!oldStr) {
+    return newStr.split('\n').map((line) => ({ text: line, status: 'added' }));
+  }
+
+  const oldLines = oldStr.split('\n');
+  const newLines = newStr.split('\n');
+  const lcs = computeLCS(oldLines, newLines);
+
+  const segments = [];
+  let newIdx = 0;
+  let lcsIdx = 0;
+
+  while (newIdx < newLines.length) {
+    if (lcsIdx < lcs.length && newIdx === lcs[lcsIdx].newIndex) {
+      segments.push({ text: newLines[newIdx], status: 'unchanged' });
+      lcsIdx++;
+    } else {
+      segments.push({ text: newLines[newIdx], status: 'added' });
+    }
+    newIdx++;
+  }
+
+  return segments;
+};

packages/bruno-app/src/components/Git/VisualDiffViewer/utils/diffUtils.spec.js

@@ -0,0 +1,198 @@
+const { describe, it, expect } = require('@jest/globals');
+
+import {
+  computeWordDiffForOld,
+  computeWordDiffForNew,
+  computeLineDiffForOld,
+  computeLineDiffForNew
+} from './diffUtils';
+
+describe('diffUtils', () => {
+  describe('computeWordDiffForOld', () => {
+    it('should return unchanged for identical strings', () => {
+      expect(computeWordDiffForOld('hello world', 'hello world')).toEqual([
+        { text: 'hello world', status: 'unchanged' }
+      ]);
+    });
+
+    it('should return empty array for empty old string', () => {
+      expect(computeWordDiffForOld('', 'new text')).toEqual([]);
+      expect(computeWordDiffForOld(null, 'new text')).toEqual([]);
+      expect(computeWordDiffForOld(undefined, 'new text')).toEqual([]);
+    });
+
+    it('should return deleted for entire old string when new is empty', () => {
+      expect(computeWordDiffForOld('old text', '')).toEqual([
+        { text: 'old text', status: 'deleted' }
+      ]);
+      expect(computeWordDiffForOld('old text', null)).toEqual([
+        { text: 'old text', status: 'deleted' }
+      ]);
+    });
+
+    it('should detect deleted words', () => {
+      const result = computeWordDiffForOld('hello world', 'hello');
+      expect(result).toContainEqual({ text: 'hello', status: 'unchanged' });
+      expect(result.some((s) => s.status === 'deleted' && s.text.includes('world'))).toBe(true);
+    });
+
+    it('should handle URL paths', () => {
+      const result = computeWordDiffForOld(
+        'https://api.example.com/users/123',
+        'https://api.example.com/users/456'
+      );
+      expect(result.some((s) => s.status === 'unchanged')).toBe(true);
+      expect(result.some((s) => s.status === 'deleted')).toBe(true);
+    });
+
+    it('should preserve separators', () => {
+      const result = computeWordDiffForOld('a/b/c', 'a/b/c');
+      expect(result).toEqual([{ text: 'a/b/c', status: 'unchanged' }]);
+    });
+  });
+
+  describe('computeWordDiffForNew', () => {
+    it('should return unchanged for identical strings', () => {
+      expect(computeWordDiffForNew('hello world', 'hello world')).toEqual([
+        { text: 'hello world', status: 'unchanged' }
+      ]);
+    });
+
+    it('should return empty array for empty new string', () => {
+      expect(computeWordDiffForNew('old text', '')).toEqual([]);
+      expect(computeWordDiffForNew('old text', null)).toEqual([]);
+      expect(computeWordDiffForNew('old text', undefined)).toEqual([]);
+    });
+
+    it('should return added for entire new string when old is empty', () => {
+      expect(computeWordDiffForNew('', 'new text')).toEqual([
+        { text: 'new text', status: 'added' }
+      ]);
+      expect(computeWordDiffForNew(null, 'new text')).toEqual([
+        { text: 'new text', status: 'added' }
+      ]);
+    });
+
+    it('should detect added words', () => {
+      const result = computeWordDiffForNew('hello', 'hello world');
+      expect(result).toContainEqual({ text: 'hello', status: 'unchanged' });
+      expect(result.some((s) => s.status === 'added' && s.text.includes('world'))).toBe(true);
+    });
+
+    it('should handle URL paths', () => {
+      const result = computeWordDiffForNew(
+        'https://api.example.com/users/123',
+        'https://api.example.com/users/456'
+      );
+      expect(result.some((s) => s.status === 'unchanged')).toBe(true);
+      expect(result.some((s) => s.status === 'added')).toBe(true);
+    });
+  });
+
+  describe('computeLineDiffForOld', () => {
+    it('should return unchanged for identical multiline strings', () => {
+      const text = 'line1\nline2\nline3';
+      expect(computeLineDiffForOld(text, text)).toEqual([
+        { text: 'line1', status: 'unchanged' },
+        { text: 'line2', status: 'unchanged' },
+        { text: 'line3', status: 'unchanged' }
+      ]);
+    });
+
+    it('should return empty array for empty old string', () => {
+      expect(computeLineDiffForOld('', 'new\ntext')).toEqual([]);
+      expect(computeLineDiffForOld(null, 'new\ntext')).toEqual([]);
+    });
+
+    it('should return deleted for all lines when new is empty', () => {
+      expect(computeLineDiffForOld('line1\nline2', '')).toEqual([
+        { text: 'line1', status: 'deleted' },
+        { text: 'line2', status: 'deleted' }
+      ]);
+    });
+
+    it('should detect deleted lines', () => {
+      const result = computeLineDiffForOld('line1\nline2\nline3', 'line1\nline3');
+      expect(result).toContainEqual({ text: 'line1', status: 'unchanged' });
+      expect(result).toContainEqual({ text: 'line2', status: 'deleted' });
+      expect(result).toContainEqual({ text: 'line3', status: 'unchanged' });
+    });
+
+    it('should handle single line strings', () => {
+      expect(computeLineDiffForOld('single line', 'single line')).toEqual([
+        { text: 'single line', status: 'unchanged' }
+      ]);
+    });
+
+    it('should handle code blocks', () => {
+      const oldCode = 'function foo() {\n  return 1;\n}';
+      const newCode = 'function foo() {\n  return 2;\n}';
+      const result = computeLineDiffForOld(oldCode, newCode);
+      expect(result).toContainEqual({ text: 'function foo() {', status: 'unchanged' });
+      expect(result).toContainEqual({ text: '  return 1;', status: 'deleted' });
+      expect(result).toContainEqual({ text: '}', status: 'unchanged' });
+    });
+  });
+
+  describe('computeLineDiffForNew', () => {
+    it('should return unchanged for identical multiline strings', () => {
+      const text = 'line1\nline2\nline3';
+      expect(computeLineDiffForNew(text, text)).toEqual([
+        { text: 'line1', status: 'unchanged' },
+        { text: 'line2', status: 'unchanged' },
+        { text: 'line3', status: 'unchanged' }
+      ]);
+    });
+
+    it('should return empty array for empty new string', () => {
+      expect(computeLineDiffForNew('old\ntext', '')).toEqual([]);
+      expect(computeLineDiffForNew('old\ntext', null)).toEqual([]);
+    });
+
+    it('should return added for all lines when old is empty', () => {
+      expect(computeLineDiffForNew('', 'line1\nline2')).toEqual([
+        { text: 'line1', status: 'added' },
+        { text: 'line2', status: 'added' }
+      ]);
+    });
+
+    it('should detect added lines', () => {
+      const result = computeLineDiffForNew('line1\nline3', 'line1\nline2\nline3');
+      expect(result).toContainEqual({ text: 'line1', status: 'unchanged' });
+      expect(result).toContainEqual({ text: 'line2', status: 'added' });
+      expect(result).toContainEqual({ text: 'line3', status: 'unchanged' });
+    });
+
+    it('should handle code blocks', () => {
+      const oldCode = 'function foo() {\n  return 1;\n}';
+      const newCode = 'function foo() {\n  return 2;\n}';
+      const result = computeLineDiffForNew(oldCode, newCode);
+      expect(result).toContainEqual({ text: 'function foo() {', status: 'unchanged' });
+      expect(result).toContainEqual({ text: '  return 2;', status: 'added' });
+      expect(result).toContainEqual({ text: '}', status: 'unchanged' });
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle empty strings', () => {
+      expect(computeWordDiffForOld('', '')).toEqual([{ text: '', status: 'unchanged' }]);
+      expect(computeWordDiffForNew('', '')).toEqual([{ text: '', status: 'unchanged' }]);
+    });
+
+    it('should handle strings with only whitespace', () => {
+      const result = computeWordDiffForOld('   ', '   ');
+      expect(result).toEqual([{ text: '   ', status: 'unchanged' }]);
+    });
+
+    it('should handle special characters in URLs', () => {
+      const url = 'https://api.example.com/users?id=123&name=test';
+      expect(computeWordDiffForOld(url, url)).toEqual([{ text: url, status: 'unchanged' }]);
+    });
+
+    it('should handle JSON-like content', () => {
+      const json = '{"key": "value", "number": 123}';
+      const result = computeLineDiffForOld(json, json);
+      expect(result).toEqual([{ text: json, status: 'unchanged' }]);
+    });
+  });
+});

packages/bruno-app/src/components/Help/StyledWrapper.js

@@ -3,6 +3,8 @@ import styled from 'styled-components';
 const Wrapper = styled.div`
   font-weight: 400;
   font-size: ${(props) => props.theme.font.size.sm};
+  color: ${(props) => props.theme.text};
+  white-space: normal;
   background-color: ${(props) => props.theme.infoTip.bg};
   border: 1px solid ${(props) => props.theme.infoTip.border};
   box-shadow: ${(props) => props.theme.infoTip.boxShadow};

packages/bruno-app/src/components/Help/index.js

@@ -4,34 +4,84 @@
  * We should allow icon and placement props to be passed in
  */
 
-import React, { useState } from 'react';
-import HelpIcon from 'components/Icons/Help';
+import React, { useState, useRef, useCallback } from 'react';
+import { createPortal } from 'react-dom';
+import QuestionCircle from 'components/Icons/QuestionCircle';
+import InfoCircle from 'components/Icons/InfoCircle';
 import StyledWrapper from './StyledWrapper';
 
-const Help = ({ children, width = 200 }) => {
+const GAP = 8;
+
+const getPortalPosition = (rect, placement, width) => {
+  switch (placement) {
+    case 'top':
+      return {
+        top: rect.top - GAP,
+        left: rect.left + rect.width / 2 - width / 2,
+        transform: 'translateY(-100%)'
+      };
+    case 'bottom':
+      return {
+        top: rect.bottom + GAP,
+        left: rect.left + rect.width / 2 - width / 2
+      };
+    case 'left':
+      return {
+        top: rect.top + rect.height / 2,
+        left: rect.left - GAP - width,
+        transform: 'translateY(-50%)'
+      };
+    case 'right':
+    default:
+      return {
+        top: rect.top + rect.height / 2,
+        left: rect.right + GAP,
+        transform: 'translateY(-50%)'
+      };
+  }
+};
+
+const iconMap = {
+  question: QuestionCircle,
+  info: InfoCircle
+};
+
+const Help = ({ children, width = 200, placement = 'right', icon = 'question', iconComponent: IconComponent, size = 14 }) => {
   const [showTooltip, setShowTooltip] = useState(false);
+  const [position, setPosition] = useState(null);
+  const iconRef = useRef(null);
+  const ResolvedIcon = IconComponent || iconMap[icon] || QuestionCircle;
+
+  const handleMouseEnter = useCallback(() => {
+    if (iconRef.current) {
+      const rect = iconRef.current.getBoundingClientRect();
+      setPosition(getPortalPosition(rect, placement, width));
+    }
+    setShowTooltip(true);
+  }, [placement, width]);
 
   return (
-    <div className="flex items-center relative">
+    <div className="flex items-center">
       <span
+        ref={iconRef}
         className="flex items-center"
-        onMouseEnter={() => setShowTooltip(true)}
+        onMouseEnter={handleMouseEnter}
         onMouseLeave={() => setShowTooltip(false)}
       >
-        <HelpIcon size={14} />
+        <ResolvedIcon size={size} />
       </span>
-      {showTooltip && (
+      {showTooltip && position && createPortal(
         <StyledWrapper
-          className="absolute z-50 rounded-md p-3"
+          className="z-50 rounded-md p-3"
           style={{
-            top: '50%',
-            left: 'calc(100% + 8px)',
-            transform: 'translateY(-50%)',
+            position: 'fixed',
+            ...position,
             width: `${width}px`
           }}
         >
           {children}
-        </StyledWrapper>
+        </StyledWrapper>,
+        document.body
       )}
     </div>
   );

packages/bruno-app/src/components/Icons/InfoCircle/index.js

@@ -0,0 +1,20 @@
+import React from 'react';
+
+const InfoCircle = ({ size = 14 }) => {
+  return (
+    <svg
+      tabIndex="-1"
+      xmlns="http://www.w3.org/2000/svg"
+      width={size}
+      height={size}
+      fill="currentColor"
+      className="inline-block ml-2 cursor-pointer"
+      viewBox="0 0 16 16"
+    >
+      <path d="M8 15A7 7 0 1 1 8 1a7 7 0 0 1 0 14zm0 1A8 8 0 1 0 8 0a8 8 0 0 0 0 16z" />
+      <path d="m8.93 6.588-2.29.287-.082.38.45.083c.294.07.352.176.288.469l-.738 3.468c-.194.897.105 1.319.808 1.319.545 0 1.178-.252 1.465-.598l.088-.416c-.2.176-.492.246-.686.246-.275 0-.375-.193-.304-.533L8.93 6.588zM9 4.5a1 1 0 1 1-2 0 1 1 0 0 1 2 0z" />
+    </svg>
+  );
+};
+
+export default InfoCircle;

packages/bruno-app/src/components/Icons/OpenAPISync/index.js

@@ -0,0 +1,13 @@
+import React from 'react';
+
+const OpenAPISyncIcon = ({ size = 16, color = 'currentColor', ...props }) => {
+  return (
+    <svg width={size} height={size} viewBox="0 0 46 46" fill="none" xmlns="http://www.w3.org/2000/svg" {...props}>
+      <path d="M39.1499 0.0455742C36.8449 0.458965 35.0171 2.12048 34.4267 4.37029C34.2407 5.06987 34.2245 6.31799 34.3944 7.02553C34.4591 7.30377 34.4914 7.56612 34.4672 7.61382C34.4348 7.66152 34.4429 7.67742 34.4914 7.65357C34.5319 7.62972 34.6208 7.76486 34.6936 7.94771L34.823 8.28955L32.9305 10.1498C31.8872 11.1753 30.9976 12.0021 30.9491 11.9862C30.9006 11.9783 30.8844 12.0021 30.9087 12.0419C30.9329 12.0816 29.6227 13.4172 27.9971 15.0072C26.3716 16.5892 24.6085 18.3222 24.0828 18.8469L23.1284 19.793L22.3278 19.4193C21.1794 18.8787 20.4515 18.7118 19.2707 18.7118C17.726 18.7038 16.715 18.99 15.4776 19.793C14.2079 20.6118 13.3506 21.5499 12.7198 22.8059C12.1779 23.8792 12.0081 24.6503 12 25.962C12 27.0671 12.0809 27.5202 12.4448 28.506C13.205 30.5411 15.138 32.1788 17.5319 32.8068C18.5509 33.0771 20.1765 33.0612 21.2683 32.775C25.5224 31.6621 27.803 27.393 26.2583 23.426C26.1208 23.0683 26.0157 22.7582 26.0319 22.7423C26.048 22.7264 27.0994 21.6771 28.3692 20.421C29.6389 19.1649 31.1108 17.6863 31.6446 17.1377C34.2488 14.4666 37.8397 10.8573 37.8882 10.8573C37.9044 10.8573 38.058 10.9289 38.2198 11.0084C39.1984 11.5013 40.8402 11.5887 41.9967 11.223C42.8782 10.9448 43.5737 10.5235 44.245 9.87157C45.4581 8.67909 45.9919 7.44687 46 5.80126C46 4.37824 45.539 3.16191 44.5442 1.96148C44.2774 1.63554 44.059 1.39705 44.059 1.42885C44.059 1.46065 43.9134 1.36525 43.7274 1.2142C43.2664 0.824657 42.4253 0.403316 41.7136 0.212521C41.01 0.0217247 39.7645 -0.0577736 39.1499 0.0455742Z" fill={color} />
+      <circle cx="20" cy="26" r="18.5" stroke={color} strokeWidth="3" />
+      <path d="M26 15.4988C22 13.4999 17.793 13.752 15.2009 14.6172C12.6088 15.4823 10.3896 17.2063 8.91029 19.504C7.431 21.8016 6.78025 24.5354 7.06564 27.2531C7.35103 29.9709 8.55548 32.5098 10.4798 34.4501C12.4041 36.3904 14.933 37.6157 17.6483 37.9235C20.3636 38.2314 23.1027 37.6032 25.4125 36.1429C27.7223 34.6826 29.6135 32.5849 30.5 30C31.3865 27.4151 31.5 25 31 20L28 22.5C28.5 24.5 28.0118 26.9632 27.359 28.8667C26.7061 30.7702 25.4231 32.3939 23.7222 33.4693C22.0212 34.5446 20.0042 35.0072 18.0046 34.7805C16.0051 34.5539 14.1427 33.6515 12.7257 32.2227C11.3086 30.7939 10.4216 28.9242 10.2115 26.9228C10.0013 24.9214 10.4805 22.9083 11.5699 21.2163C12.6592 19.5242 14.2935 18.2547 16.2023 17.6176C18.1112 16.9805 20 16.9999 23.5 17.9999L26 15.4988Z" fill={color} />
+    </svg>
+  );
+};
+
+export default OpenAPISyncIcon;

packages/bruno-app/src/components/Icons/QuestionCircle/index.js

@@ -1,6 +1,6 @@
 import React from 'react';
 
-const HelpIcon = ({ size = 14 }) => {
+const QuestionCircle = ({ size = 14 }) => {
   return (
     <svg
       tabIndex="-1"
@@ -17,4 +17,4 @@ const HelpIcon = ({ size = 14 }) => {
   );
 };
 
-export default HelpIcon;
+export default QuestionCircle;

packages/bruno-app/src/components/ManageWorkspace/RenameWorkspace/index.js

@@ -25,7 +25,7 @@ const RenameWorkspace = ({ onClose, workspace }) => {
         .test('unique-name', 'A workspace with this name already exists', function (value) {
           if (!value) return true;
           return !workspaces.some((w) =>
-            w.uid !== workspace.uid && w.name.toLowerCase() === value.toLowerCase()
+            w.uid !== workspace.uid && w.name && w.name.toLowerCase() === value.toLowerCase()
           );
         })
     }),

packages/bruno-app/src/components/ManageWorkspace/index.js

@@ -3,8 +3,9 @@ import { useSelector, useDispatch } from 'react-redux';
 import { IconArrowLeft, IconPlus, IconFolder, IconLock, IconDots, IconCategory, IconLogin } from '@tabler/icons';
 import toast from 'react-hot-toast';
 
+import get from 'lodash/get';
 import { showHomePage } from 'providers/ReduxStore/slices/app';
-import { switchWorkspace } from 'providers/ReduxStore/slices/workspaces/actions';
+import { createWorkspaceWithUniqueName, switchWorkspace } from 'providers/ReduxStore/slices/workspaces/actions';
 import { showInFolder } from 'providers/ReduxStore/slices/collections/actions';
 import { sortWorkspaces } from 'utils/workspaces';
 
@@ -26,7 +27,8 @@ const ManageWorkspace = () => {
   const [deleteWorkspaceModal, setDeleteWorkspaceModal] = useState({ open: false, workspace: null });
 
   const sortedWorkspaces = useMemo(() => {
-    return sortWorkspaces(workspaces, preferences);
+    const persistedWorkspaces = workspaces.filter((w) => !w.isCreating);
+    return sortWorkspaces(persistedWorkspaces, preferences);
   }, [workspaces, preferences]);
 
   const handleBack = () => {
@@ -59,6 +61,20 @@ const ManageWorkspace = () => {
     setDeleteWorkspaceModal({ open: true, workspace });
   };
 
+  const handleCreateWorkspace = async () => {
+    const defaultLocation = get(preferences, 'general.defaultLocation', '');
+    if (!defaultLocation) {
+      setCreateWorkspaceModalOpen(true);
+      return;
+    }
+
+    try {
+      await dispatch(createWorkspaceWithUniqueName(defaultLocation));
+    } catch (error) {
+      toast.error(error?.message || 'Failed to create workspace');
+    }
+  };
+
   return (
     <StyledWrapper>
       {createWorkspaceModalOpen && (
@@ -86,7 +102,7 @@ const ManageWorkspace = () => {
           </div>
           <span className="header-title">Manage Workspace</span>
         </div>
-        <Button size="sm" onClick={() => setCreateWorkspaceModalOpen(true)} icon={<IconPlus size={14} strokeWidth={2} />}>
+        <Button size="sm" onClick={handleCreateWorkspace} icon={<IconPlus size={14} strokeWidth={2} />}>
           Create Workspace
         </Button>
       </div>