Fix plugin (again)

Bundle plugin in Git
Move plugins back
2026-01-03 03:49:06 -05:00 · 2023-11-08 13:33:15 -08:00 · 2023-11-08 13:06:49 -08:00 · 2023-11-08 12:34:14 -08:00 · 2023-11-08 12:02:17 -08:00 · 2023-11-08 10:12:01 -08:00
239 changed files with 16346 additions and 12691 deletions
--- a/.eslintrc.cjs
+++ b/.eslintrc.cjs
@@ -1,31 +1,37 @@
 module.exports = {
-    extends: [
-        'eslint:recommended',
-        'plugin:react/recommended',
-        'plugin:import/recommended',
-        'plugin:jsx-a11y/recommended',
-        'plugin:@typescript-eslint/recommended',
-        'eslint-config-prettier',
-    ],
-    ignorePatterns: ['src-tauri/**/*'],
-    settings: {
-        react: {
-            version: 'detect',
-        },
-        'import/resolver': {
-            node: {
-                paths: ['src-web'],
-                extensions: ['.js', '.jsx', '.ts', '.tsx'],
-            },
-        },
-    },
-    rules: {
-        "jsx-a11y/no-autofocus": "warn",
-        "react/react-in-jsx-scope": "off",
-        "@typescript-eslint/consistent-type-imports": ["error", {
-            prefer: "type-imports",
-            disallowTypeAnnotations: true,
-            fixStyle: "separate-type-imports",
-        }]
+  extends: [
+    "eslint:recommended",
+    "plugin:react/recommended",
+    "plugin:react-hooks/recommended",
+    "plugin:import/recommended",
+    "plugin:jsx-a11y/recommended",
+    "plugin:@typescript-eslint/recommended",
+    "eslint-config-prettier"
+  ],
+  parser: "@typescript-eslint/parser",
+  parserOptions: {
+    project: ["./tsconfig.json"]
+  },
+  ignorePatterns: ["src-tauri/**/*", "plugins/**/*"],
+  settings: {
+    react: {
+      version: "detect"
    },
+    "import/resolver": {
+      node: {
+        paths: ["src-web"],
+        extensions: [".ts", ".tsx"]
+      }
+    }
+  },
+  rules: {
+    "jsx-a11y/no-autofocus": "off",
+    "react/react-in-jsx-scope": "off",
+    "import/no-unresolved": "off",
+    "@typescript-eslint/consistent-type-imports": ["error", {
+      prefer: "type-imports",
+      disallowTypeAnnotations: true,
+      fixStyle: "separate-type-imports"
+    }]
+  }
 };
--- a/.github/workflows/artifacts.yml
+++ b/.github/workflows/artifacts.yml
@@ -3,18 +3,30 @@ on:
  push:
    tags: [ v* ]

+permissions: write-all
+
 jobs:
  build-artifacts:
-    runs-on: ${{ matrix.platform }}
-
    strategy:
      fail-fast: false
      matrix:
-        platform: [ ubuntu-latest, macos-latest, windows-latest ]
+        include:
+          - os: macos-12
+            target: aarch64-apple-darwin
+          - os: macos-latest
+            target: x86_64-apple-darwin
+          - os: windows-2022
+            target: x86_64-pc-windows-msvc
+          - os: ubuntu-20.04
+            target: x86_64-unknown-linux-gnu
+
+    runs-on: ${{ matrix.os }}

    steps:
      - uses: actions/checkout@v3
      - uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: ${{ matrix.target }}
      - name: Cache Rust
        uses: actions/cache@v2
        with:
@@ -28,7 +40,7 @@ jobs:
          node-version: 18
          cache: 'npm'
      - name: install dependencies (ubuntu only)
-        if: matrix.platform == 'ubuntu-latest'
+        if: matrix.os == 'ubuntu-20.04'
        run: |
          sudo apt-get update
          sudo apt-get install -y libgtk-3-dev libwebkit2gtk-4.0-dev libappindicator3-dev librsvg2-dev patchelf
@@ -36,14 +48,24 @@ jobs:
        run: npm ci
      - name: Run tests
        run: npm test
-      - uses: tauri-apps/tauri-action@v0
+      # Pin dev version to get non-default targets
+      # https://github.com/tauri-apps/tauri-action/issues/356
+      - uses: tauri-apps/tauri-action@dev
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          TAURI_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
          TAURI_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
+          ENABLE_CODE_SIGNING: ${{ secrets.APPLE_CERTIFICATE }}
+          APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
+          APPLE_CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
+          APPLE_SIGNING_IDENTITY: ${{ secrets.APPLE_SIGNING_IDENTITY }}
+          APPLE_ID: ${{ secrets.APPLE_ID }}
+          APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
+          APPLE_PASSWORD: ${{ secrets.APPLE_PASSWORD }}
        with:
-          tagName: v__VERSION__
-          releaseName: 'App v__VERSION__'
-          releaseBody: 'See the assets to download this version and install.'
+          tagName: 'v__VERSION__'
+          releaseName: 'Release __VERSION__'
+          releaseBody: '<!-- Release Notes -->'
          releaseDraft: true
          prerelease: false
+          args: '--target ${{ matrix.target }}'
--- a/.gitignore
+++ b/.gitignore
@@ -22,5 +22,6 @@ dist-ssr
 *.njsproj
 *.sln
 *.sw?
+.eslintcache

 *.sqlite
--- a/.husky/.gitignore
+++ b/.husky/.gitignore
@@ -0,0 +1 @@
+_
--- a/.husky/pre-commit
+++ b/.husky/pre-commit
@@ -0,0 +1,4 @@
+#!/bin/sh
+. "$(dirname "$0")/_/husky.sh"
+
+npx lint-staged
--- a/.nvmrc
+++ b/.nvmrc
@@ -1 +1 @@
-18
+20
--- a/Desktop.run.xml
+++ b/Desktop.run.xml
@@ -6,9 +6,7 @@
      <script value="tauri-dev" />
    </scripts>
    <node-interpreter value="project" />
-    <envs>
-      <env name="DATABASE_URL" value="sqlite://$USER_HOME$/Library/Application%20Support/co.schier.yaak/db.sqlite" />
-    </envs>
+    <envs />
    <method v="2" />
  </configuration>
-</component>
+</component>
--- a/.sqllsrc.json
+++ b/.sqllsrc.json
@@ -0,0 +1,5 @@
+{
+  "name": "yaak-dev",
+  "adapter": "sqlite3",
+  "filename": "src-tauri/db.sqlite"
+}
--- a/13
+++ b/13
@@ -0,0 +1,13 @@
+.PHONY: sqlx-prepare, dev, migrate, build
+
+sqlx-prepare:
+	cd src-tauri && cargo sqlx prepare --database-url 'sqlite://db.sqlite'
+
+dev:
+	npm run tauri-dev
+
+migrate:
+	cd src-tauri && cargo sqlx migrate run --database-url 'sqlite://db.sqlite?mode=rw'
+
+build:
+	./node_modules/.bin/tauri build
--- a/README.md
+++ b/README.md
@@ -1,3 +1,16 @@
-# Tauri REST Client
+# Yaak Network Toolkit

-It's a REST client, yo.
+The most fun you'll ever have working with APIs.
+
+## Common Commands
+
+```sh
+# Start dev app
+npm run tauri-dev
+
+# Migration commands
+cd src-tauri
+cargo sqlx migrate add ${MIGRATION_NAME}
+cargo sqlx migrate run --database-url 'sqlite://db.sqlite?mode=rw'
+cargo sqlx prepare --database-url 'sqlite://db.sqlite'
+```
--- a/design/Icons.afdesign
+++ b/design/Icons.afdesign
--- a/design/logo.afdesign
+++ b/design/logo.afdesign
--- a/index.html
+++ b/index.html
@@ -1,17 +1,28 @@
 <!DOCTYPE html>
 <html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Yaak App</title>
-<!--    <script src="http://localhost:8097"></script>-->
-  </head>
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>Yaak App</title>
+<!--  <script src="http://localhost:8097"></script>-->
+  <style>
+      body {
+          background-color: white;
+      }

-  <body>
-    <div id="root"></div>
-    <div id="cm-portal" class="cm-portal" style="pointer-events: auto"></div>
-    <div id="radix-portal" class="cm-portal"></div>
-    <script type="module" src="/src-web/main.tsx"></script>
-  </body>
+      @media (prefers-color-scheme: dark) {
+          body {
+              background-color: black;
+          }
+      }
+  </style>
+</head>
+
+<body>
+<div id="root"></div>
+<div id="cm-portal" class="cm-portal"></div>
+<div id="react-portal"></div>
+<div id="radix-portal" class="cm-portal"></div>
+<script type="module" src="/src-web/main.tsx"></script>
+</body>
 </html>
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@@ -1,22 +1,23 @@
 {
-  "name": "tauri-app",
+  "name": "yaak-app",
  "private": true,
  "version": "0.0.0",
  "type": "module",
  "scripts": {
-    "tauri-dev": "tauri dev",
-    "tauri-build": "npm run build:icon && tauri build",
+    "tauri-dev": "YAAK_ENV=development tauri dev",
+    "tauri-build": "tauri build",
+    "tauri": "tauri",
    "build": "npm run build:frontend",
    "dev": "vite dev",
    "lint": "tsc && eslint . --ext .ts,.tsx",
    "build:icon": "tauri icon src-tauri/icons/icon.png",
    "build:frontend": "vite build",
    "test": "vitest",
-    "coverage": "vitest run --coverage"
+    "coverage": "vitest run --coverage",
+    "prepare": "husky install"
  },
  "dependencies": {
    "@codemirror/commands": "^6.2.1",
-    "@codemirror/lang-html": "^6.4.2",
    "@codemirror/lang-javascript": "^6.1.4",
    "@codemirror/lang-json": "^6.0.1",
    "@codemirror/lang-xml": "^6.0.2",
@@ -25,51 +26,66 @@
    "@lezer/generator": "^1.2.2",
    "@lezer/highlight": "^1.1.3",
    "@lezer/lr": "^1.3.3",
-    "@radix-ui/react-dialog": "^1.0.2",
-    "@radix-ui/react-dropdown-menu": "^2.0.2",
    "@radix-ui/react-icons": "^1.2.0",
-    "@radix-ui/react-popover": "1.0.3",
-    "@radix-ui/react-scroll-area": "^1.0.2",
-    "@radix-ui/react-separator": "^1.0.1",
-    "@radix-ui/react-tabs": "^1.0.3",
-    "@tanstack/react-query": "^4.24.10",
-    "@tauri-apps/api": "^1.2.0",
-    "@vitejs/plugin-react": "^3.1.0",
+    "@react-hook/resize-observer": "^1.2.6",
+    "@tailwindcss/container-queries": "^0.1.0",
+    "@tanstack/query-sync-storage-persister": "^4.27.1",
+    "@tanstack/react-query": "^4.28.0",
+    "@tanstack/react-query-devtools": "^4.28.0",
+    "@tanstack/react-query-persist-client": "^4.28.0",
+    "@tauri-apps/api": "^1.5.1",
+    "buffer": "^6.0.3",
    "classnames": "^2.3.2",
-    "react": "^18.2.0",
-    "react-dom": "^18.2.0",
-    "react-router-dom": "^6.8.1",
-    "cm6-graphql": "^0.0.4-canary-b30a2325.0",
+    "cm6-graphql": "^0.0.9",
    "codemirror": "^6.0.1",
+    "focus-trap-react": "^10.1.1",
    "format-graphql": "^1.4.0",
    "framer-motion": "^9.0.4",
+    "papaparse": "^5.4.1",
    "parse-color": "^1.0.0",
+    "react": "^18.2.0",
+    "react-dnd": "^16.0.1",
+    "react-dnd-html5-backend": "^16.0.1",
+    "react-dom": "^18.2.0",
    "react-helmet-async": "^1.3.0",
-    "react-use": "^17.4.0"
+    "react-router-dom": "^6.8.1",
+    "react-use": "^17.4.0",
+    "uuid": "^9.0.0"
  },
  "devDependencies": {
    "@tailwindcss/nesting": "^0.0.0-insiders.565cd3e",
-    "@tauri-apps/cli": "^1.2.2",
+    "@tauri-apps/cli": "^1.5.4",
    "@types/node": "^18.7.10",
+    "@types/papaparse": "^5.3.7",
    "@types/parse-color": "^1.0.1",
    "@types/parse-json": "^4.0.0",
-    "@types/react-dom": "^18.0.6",
-    "@typescript-eslint/eslint-plugin": "^5.52.0",
-    "@typescript-eslint/parser": "^5.52.0",
+    "@types/react": "^18.0.31",
+    "@types/react-dom": "^18.0.11",
+    "@types/uuid": "^9.0.1",
+    "@typescript-eslint/eslint-plugin": "^5.57.0",
+    "@typescript-eslint/parser": "^5.57.0",
+    "@vitejs/plugin-react": "^3.1.0",
    "autoprefixer": "^10.4.13",
-    "concurrently": "^7.6.0",
    "eslint": "^8.34.0",
    "eslint-config-prettier": "^8.6.0",
    "eslint-plugin-import": "^2.27.5",
    "eslint-plugin-jsx-a11y": "^6.7.1",
    "eslint-plugin-react": "^7.32.2",
+    "eslint-plugin-react-hooks": "^4.6.0",
+    "husky": "^8.0.3",
+    "lint-staged": "^15.0.2",
    "postcss": "^8.4.21",
    "postcss-nesting": "^11.2.1",
    "prettier": "^2.8.4",
    "tailwindcss": "^3.2.7",
-    "typescript": "^4.6.4",
+    "typescript": "^5.0.2",
    "vite": "^4.0.0",
+    "vite-plugin-svgr": "^2.4.0",
    "vite-plugin-top-level-await": "^1.2.4",
    "vitest": "^0.29.2"
+  },
+  "lint-staged": {
+    "*.{ts,tsx}": "eslint --cache --fix",
+    "*.{js,css,md}": "prettier --write"
  }
 }
--- a/rustfmt.toml
+++ b/rustfmt.toml
@@ -0,0 +1 @@
+edition = "2018"
--- a/src-tauri/Cargo.lock
+++ b/src-tauri/Cargo.lock
--- a/src-tauri/Cargo.toml
+++ b/src-tauri/Cargo.toml
@@ -7,29 +7,44 @@ license = "MIT"
 repository = "https://github.com/gschier/yaak-app"
 edition = "2021"

-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[profile.release]
+strip = true  # Automatically strip symbols from the binary.

 [build-dependencies]
 tauri-build = { version = "1.2", features = [] }

 [target.'cfg(target_os = "macos")'.dependencies]
-objc = { version = "0.2.7" }
-cocoa = { version = "0.24.1" }
+objc = "0.2.7"
+cocoa = "0.25.0"

 [dependencies]
-serde_json = { version = "1.0", features = ["raw_value"] }
-serde = { version = "1.0", features = ["derive"] }
-tauri = { version = "1.2", features = ["config-toml", "devtools", "shell-open", "system-tray", "updater", "window-start-dragging"] }
-http = { version = "0.2.8" }
-reqwest = { version = "0.11.14", features = ["json"] }
-tokio = { version = "1.25.0", features = ["sync"] }
-futures = { version = "0.3.26" }
-deno_core = { version = "0.174.0" }
-deno_ast = { version = "0.24.0", features = ["transpiling"] }
-sqlx = { version = "0.6.2", features = ["sqlite", "runtime-tokio-rustls", "json", "chrono", "time", "offline"] }
-uuid = { version = "1.3.0" }
-rand = { version = "0.8.5" }
+base64 = "0.21.0"
+boa_engine = "0.17.3"
+boa_runtime = "0.17.3"
 chrono = { version = "0.4.23", features = ["serde"] }
+futures = "0.3.26"
+http = "0.2.8"
+rand = "0.8.5"
+reqwest = { version = "0.11.14", features = ["json"] }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = { version = "1.0", features = ["raw_value"] }
+sqlx = { version = "0.6.2", features = ["sqlite", "runtime-tokio-rustls", "json", "chrono", "time", "offline"] }
+tauri = { version = "1.3", features = [
+    "cli",
+    "config-toml",
+    "devtools",
+    "fs-read-file",
+    "os-all",
+    "protocol-asset",
+    "shell-open",
+    "system-tray",
+    "updater",
+    "window-start-dragging",
+    "dialog-open",
+] }
+tauri-plugin-window-state = { git = "https://github.com/tauri-apps/plugins-workspace", branch = "v1" }
+tokio = { version = "1.25.0", features = ["sync"] }
+uuid = "1.3.0"

 [features]
 # by default Tauri runs in production mode
--- a/src-tauri/icons/128x128.png
+++ b/src-tauri/icons/128x128.png
--- a/src-tauri/icons/128x128@2x.png
+++ b/src-tauri/icons/128x128@2x.png
--- a/src-tauri/icons/32x32.png
+++ b/src-tauri/icons/32x32.png
--- a/src-tauri/icons/Square107x107Logo.png
+++ b/src-tauri/icons/Square107x107Logo.png
--- a/src-tauri/icons/Square142x142Logo.png
+++ b/src-tauri/icons/Square142x142Logo.png
--- a/src-tauri/icons/Square150x150Logo.png
+++ b/src-tauri/icons/Square150x150Logo.png
--- a/src-tauri/icons/Square284x284Logo.png
+++ b/src-tauri/icons/Square284x284Logo.png
--- a/src-tauri/icons/Square30x30Logo.png
+++ b/src-tauri/icons/Square30x30Logo.png
--- a/src-tauri/icons/Square310x310Logo.png
+++ b/src-tauri/icons/Square310x310Logo.png
--- a/src-tauri/icons/Square44x44Logo.png
+++ b/src-tauri/icons/Square44x44Logo.png
--- a/src-tauri/icons/Square71x71Logo.png
+++ b/src-tauri/icons/Square71x71Logo.png
--- a/src-tauri/icons/Square89x89Logo.png
+++ b/src-tauri/icons/Square89x89Logo.png
--- a/src-tauri/icons/StoreLogo.png
+++ b/src-tauri/icons/StoreLogo.png
--- a/src-tauri/icons/icon.afdesign
+++ b/src-tauri/icons/icon.afdesign
--- a/src-tauri/icons/icon.icns
+++ b/src-tauri/icons/icon.icns
--- a/src-tauri/icons/icon.ico
+++ b/src-tauri/icons/icon.ico
--- a/src-tauri/icons/icon.png
+++ b/src-tauri/icons/icon.png
--- a/src-tauri/macos/entitlements.plist
+++ b/src-tauri/macos/entitlements.plist
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>com.apple.security.cs.allow-unsigned-executable-memory</key>
+    <true/>
+</dict>
+</plist>
--- a/src-tauri/migrations/20230225181302_init.sql
+++ b/src-tauri/migrations/20230225181302_init.sql
@@ -1,39 +1,65 @@
+CREATE TABLE key_values
+(
+    model      TEXT     DEFAULT 'key_value'       NOT NULL,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP NOT NULL,
+    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP NOT NULL,
+    deleted_at DATETIME,
+    namespace  TEXT                               NOT NULL,
+    key        TEXT                               NOT NULL,
+    value      TEXT                               NOT NULL,
+    PRIMARY KEY (namespace, key)
+);
+
 CREATE TABLE workspaces
 (
-    id          TEXT     NOT NULL PRIMARY KEY,
-    created_at  DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    updated_at  DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    id          TEXT                               NOT NULL
+        PRIMARY KEY,
+    model       TEXT     DEFAULT 'workspace'       NOT NULL,
+    created_at  DATETIME DEFAULT CURRENT_TIMESTAMP NOT NULL,
+    updated_at  DATETIME DEFAULT CURRENT_TIMESTAMP NOT NULL,
    deleted_at  DATETIME,
-    name        TEXT     NOT NULL,
-    description TEXT     NOT NULL
+    name        TEXT                               NOT NULL,
+    description TEXT                               NOT NULL
 );

 CREATE TABLE http_requests
 (
-    id           TEXT     NOT NULL PRIMARY KEY,
-    workspace_id TEXT     NOT NULL REFERENCES workspaces (id) ON DELETE CASCADE,
-    created_at   DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    updated_at   DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    id           TEXT                               NOT NULL
+        PRIMARY KEY,
+    model        TEXT     DEFAULT 'http_request'    NOT NULL,
+    workspace_id TEXT                               NOT NULL
+        REFERENCES workspaces
+            ON DELETE CASCADE,
+    created_at   DATETIME DEFAULT CURRENT_TIMESTAMP NOT NULL,
+    updated_at   DATETIME DEFAULT CURRENT_TIMESTAMP NOT NULL,
    deleted_at   DATETIME,
-    name         TEXT     NOT NULL,
-    url          TEXT     NOT NULL,
-    method       TEXT     NOT NULL,
-    headers      TEXT     NOT NULL,
-    body         TEXT
+    name         TEXT                               NOT NULL,
+    url          TEXT                               NOT NULL,
+    method       TEXT                               NOT NULL,
+    headers      TEXT                               NOT NULL,
+    body         TEXT,
+    body_type    TEXT
 );

 CREATE TABLE http_responses
 (
-    id            TEXT     NOT NULL PRIMARY KEY,
-    request_id    TEXT     NOT NULL REFERENCES http_requests (id) ON DELETE CASCADE,
-    workspace_id  TEXT     NOT NULL REFERENCES workspaces (id) ON DELETE CASCADE,
-    created_at    DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    updated_at    DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    id            TEXT                               NOT NULL
+        PRIMARY KEY,
+    model         TEXT     DEFAULT 'http_response'   NOT NULL,
+    request_id    TEXT                               NOT NULL
+        REFERENCES http_requests
+            ON DELETE CASCADE,
+    workspace_id  TEXT                               NOT NULL
+        REFERENCES workspaces
+            ON DELETE CASCADE,
+    created_at    DATETIME DEFAULT CURRENT_TIMESTAMP NOT NULL,
+    updated_at    DATETIME DEFAULT CURRENT_TIMESTAMP NOT NULL,
    deleted_at    DATETIME,
-    elapsed       INTEGER  NOT NULL,
-    status        INTEGER  NOT NULL,
+    elapsed       INTEGER                            NOT NULL,
+    status        INTEGER                            NOT NULL,
    status_reason TEXT,
-    url           TEXT     NOT NULL,
-    body          TEXT     NOT NULL,
-    headers       TEXT     NOT NULL
+    url           TEXT                               NOT NULL,
+    body          TEXT                               NOT NULL,
+    headers       TEXT                               NOT NULL,
+    error         TEXT
 );
--- a/src-tauri/migrations/20230301163450_add-response-error.sql
+++ b/src-tauri/migrations/20230301163450_add-response-error.sql
@@ -1 +0,0 @@
-ALTER TABLE http_responses ADD COLUMN error TEXT NULL;
--- a/src-tauri/migrations/20230319042610_sort-priority.sql
+++ b/src-tauri/migrations/20230319042610_sort-priority.sql
@@ -0,0 +1 @@
+ALTER TABLE main.http_requests ADD COLUMN sort_priority REAL NOT NULL DEFAULT 0;
--- a/src-tauri/migrations/20230330143214_request-auth.sql
+++ b/src-tauri/migrations/20230330143214_request-auth.sql
@@ -0,0 +1,2 @@
+ALTER TABLE http_requests ADD COLUMN authentication TEXT NOT NULL DEFAULT '{}';
+ALTER TABLE http_requests ADD COLUMN authentication_type TEXT;
--- a/src-tauri/migrations/20230413232435_response-body-blob.sql
+++ b/src-tauri/migrations/20230413232435_response-body-blob.sql
@@ -0,0 +1,5 @@
+DELETE FROM main.http_responses;
+ALTER TABLE http_responses DROP COLUMN body;
+ALTER TABLE http_responses ADD COLUMN body BLOB;
+ALTER TABLE http_responses ADD COLUMN body_path TEXT;
+ALTER TABLE http_responses ADD COLUMN content_length INTEGER;
--- a/src-tauri/migrations/20231022205109_environments.sql
+++ b/src-tauri/migrations/20231022205109_environments.sql
@@ -0,0 +1,15 @@
+CREATE TABLE environments
+(
+    id          TEXT                               NOT NULL
+        PRIMARY KEY,
+    model       TEXT     DEFAULT 'workspace'       NOT NULL,
+    created_at  DATETIME DEFAULT CURRENT_TIMESTAMP NOT NULL,
+    updated_at  DATETIME DEFAULT CURRENT_TIMESTAMP NOT NULL,
+    deleted_at  DATETIME,
+    workspace_id TEXT                               NOT NULL
+        REFERENCES workspaces
+            ON DELETE CASCADE,
+    name        TEXT                               NOT NULL,
+    data        TEXT                               NOT NULL
+        DEFAULT '{}'
+);
--- a/src-tauri/migrations/20231028161007_variables.sql
+++ b/src-tauri/migrations/20231028161007_variables.sql
@@ -0,0 +1,2 @@
+ALTER TABLE environments DROP COLUMN data;
+ALTER TABLE environments ADD COLUMN variables DEFAULT '[]' NOT NULL;
--- a/src-tauri/migrations/20231103004111_workspace-variables.sql
+++ b/src-tauri/migrations/20231103004111_workspace-variables.sql
@@ -0,0 +1 @@
+ALTER TABLE workspaces ADD COLUMN variables DEFAULT '[]' NOT NULL;
--- a/src-tauri/migrations/20231103142807_folders.sql
+++ b/src-tauri/migrations/20231103142807_folders.sql
@@ -0,0 +1,19 @@
+CREATE TABLE folders
+(
+    id            TEXT                               NOT NULL
+        PRIMARY   KEY,
+    model         TEXT     DEFAULT 'folder'          NOT NULL,
+    created_at    DATETIME DEFAULT CURRENT_TIMESTAMP NOT NULL,
+    updated_at    DATETIME DEFAULT CURRENT_TIMESTAMP NOT NULL,
+    deleted_at    DATETIME,
+    workspace_id  TEXT                               NOT NULL
+        REFERENCES workspaces
+            ON DELETE CASCADE,
+    folder_id     TEXT                               NULL
+        REFERENCES folders
+            ON DELETE CASCADE,
+    name          TEXT                               NOT NULL,
+    sort_priority REAL     DEFAULT 0                 NOT NULL
+);
+
+ALTER TABLE http_requests ADD COLUMN folder_id TEXT REFERENCES folders(id) ON DELETE CASCADE;
--- a/src-tauri/plugins/hello-world/greet.js
+++ b/src-tauri/plugins/hello-world/greet.js
@@ -0,0 +1,4 @@
+export function greet() {
+  // Call Rust-provided fn!
+  sayHello('Plugin');
+}
--- a/src-tauri/plugins/hello-world/index.js
+++ b/src-tauri/plugins/hello-world/index.js
@@ -0,0 +1,7 @@
+import { greet } from './greet.js';
+
+export function hello() {
+  greet();
+  console.log('Try JSON parse', JSON.parse(`{ "hello": 123 }`).hello);
+  console.log('Try RegExp', '123'.match(/[\d]+/));
+}
--- a/src-tauri/plugins/insomnia-importer/out/index.js
+++ b/src-tauri/plugins/insomnia-importer/out/index.js
@@ -0,0 +1,156 @@
+function O(e, t) {
+  return (
+    console.log('IMPORTING Environment', e._id, e.name, JSON.stringify(e, null, 2)),
+    {
+      id: e._id,
+      createdAt: new Date(e.created ?? Date.now()).toISOString().replace('Z', ''),
+      updatedAt: new Date(e.updated ?? Date.now()).toISOString().replace('Z', ''),
+      workspaceId: t,
+      model: 'environment',
+      name: e.name,
+      variables: Object.entries(e.data).map(([i, s]) => ({
+        enabled: !0,
+        name: i,
+        value: `${s}`,
+      })),
+    }
+  );
+}
+function g(e) {
+  return d(e) && e._type === 'workspace';
+}
+function y(e) {
+  return d(e) && e._type === 'request_group';
+}
+function _(e) {
+  return d(e) && e._type === 'request';
+}
+function I(e) {
+  return d(e) && e._type === 'environment';
+}
+function d(e) {
+  return Object.prototype.toString.call(e) === '[object Object]';
+}
+function h(e) {
+  return Object.prototype.toString.call(e) === '[object String]';
+}
+function N(e) {
+  return Object.entries(e).map(([t, i]) => ({
+    enabled: !0,
+    name: t,
+    value: `${i}`,
+  }));
+}
+function c(e) {
+  return h(e) ? e.replaceAll(/{{\s*(_\.)?([^}]+)\s*}}/g, '${[$2]}') : e;
+}
+function D(e, t, i = 0) {
+  var a, u;
+  console.log('IMPORTING REQUEST', e._id, e.name, JSON.stringify(e, null, 2));
+  let s = null,
+    n = null;
+  ((a = e.body) == null ? void 0 : a.mimeType) === 'application/graphql'
+    ? ((s = 'graphql'), (n = c(e.body.text)))
+    : ((u = e.body) == null ? void 0 : u.mimeType) === 'application/json' &&
+      ((s = 'application/json'), (n = c(e.body.text)));
+  let p = null,
+    o = {};
+  return (
+    e.authentication.type === 'bearer'
+      ? ((p = 'bearer'),
+        (o = {
+          token: c(e.authentication.token),
+        }))
+      : e.authentication.type === 'basic' &&
+        ((p = 'basic'),
+        (o = {
+          username: c(e.authentication.username),
+          password: c(e.authentication.password),
+        })),
+    {
+      id: e._id,
+      createdAt: new Date(e.created ?? Date.now()).toISOString().replace('Z', ''),
+      updatedAt: new Date(e.updated ?? Date.now()).toISOString().replace('Z', ''),
+      workspaceId: t,
+      folderId: e.parentId === t ? null : e.parentId,
+      model: 'http_request',
+      sortPriority: i,
+      name: e.name,
+      url: c(e.url),
+      body: n,
+      bodyType: s,
+      authentication: o,
+      authenticationType: p,
+      method: e.method,
+      headers: (e.headers ?? []).map(({ name: m, value: r, disabled: f }) => ({
+        enabled: !f,
+        name: m,
+        value: r,
+      })),
+    }
+  );
+}
+function w(e, t) {
+  return (
+    console.log('IMPORTING Workspace', e._id, e.name, JSON.stringify(e, null, 2)),
+    {
+      id: e._id,
+      createdAt: new Date(e.created ?? Date.now()).toISOString().replace('Z', ''),
+      updatedAt: new Date(e.updated ?? Date.now()).toISOString().replace('Z', ''),
+      model: 'workspace',
+      name: e.name,
+      variables: t,
+    }
+  );
+}
+function b(e, t) {
+  return (
+    console.log('IMPORTING FOLDER', e._id, e.name, JSON.stringify(e, null, 2)),
+    {
+      id: e._id,
+      createdAt: new Date(e.created ?? Date.now()).toISOString().replace('Z', ''),
+      updatedAt: new Date(e.updated ?? Date.now()).toISOString().replace('Z', ''),
+      folderId: e.parentId === t ? null : e.parentId,
+      workspaceId: t,
+      model: 'folder',
+      name: e.name,
+    }
+  );
+}
+function T(e) {
+  const t = JSON.parse(e);
+  if (!d(t)) return;
+  const { _type: i, __export_format: s } = t;
+  if (i !== 'export' || s !== 4 || !Array.isArray(t.resources)) return;
+  const n = {
+      workspaces: [],
+      requests: [],
+      environments: [],
+      folders: [],
+    },
+    p = t.resources.filter(g);
+  for (const o of p) {
+    console.log('IMPORTING WORKSPACE', o.name);
+    const a = t.resources.find((r) => I(r) && r.parentId === o._id);
+    console.log('FOUND BASE ENV', a.name),
+      n.workspaces.push(w(o, a ? N(a.data) : [])),
+      console.log('IMPORTING ENVIRONMENTS', a.name);
+    const u = t.resources.filter((r) => I(r) && r.parentId === (a == null ? void 0 : a._id));
+    console.log('FOUND', u.length, 'ENVIRONMENTS'),
+      n.environments.push(...u.map((r) => O(r, o._id)));
+    const m = (r) => {
+      const f = t.resources.filter((l) => l.parentId === r);
+      let S = 0;
+      for (const l of f)
+        y(l) ? (n.folders.push(b(l, o._id)), m(l._id)) : _(l) && n.requests.push(D(l, o._id, S++));
+    };
+    m(o._id);
+  }
+  return (
+    (n.requests = n.requests.filter(Boolean)),
+    (n.environments = n.environments.filter(Boolean)),
+    (n.workspaces = n.workspaces.filter(Boolean)),
+    n
+  );
+}
+export { T as pluginHookImport };
--- a/src-tauri/plugins/insomnia-importer/src/helpers/types.js
+++ b/src-tauri/plugins/insomnia-importer/src/helpers/types.js
@@ -0,0 +1,23 @@
+export function isWorkspace(obj) {
+  return isJSObject(obj) && obj._type === 'workspace';
+}
+
+export function isRequestGroup(obj) {
+  return isJSObject(obj) && obj._type === 'request_group';
+}
+
+export function isRequest(obj) {
+  return isJSObject(obj) && obj._type === 'request';
+}
+
+export function isEnvironment(obj) {
+  return isJSObject(obj) && obj._type === 'environment';
+}
+
+export function isJSObject(obj) {
+  return Object.prototype.toString.call(obj) === '[object Object]';
+}
+
+export function isJSString(obj) {
+  return Object.prototype.toString.call(obj) === '[object String]';
+}
--- a/src-tauri/plugins/insomnia-importer/src/helpers/variables.js
+++ b/src-tauri/plugins/insomnia-importer/src/helpers/variables.js
@@ -0,0 +1,18 @@
+import { isJSString } from './types.js';
+
+export function parseVariables(data) {
+  return Object.entries(data).map(([name, value]) => ({
+    enabled: true,
+    name,
+    value: `${value}`,
+  }));
+}
+
+/**
+ * Convert Insomnia syntax to Yaak syntax
+ * @param {string} variable - Text to convert
+ */
+export function convertSyntax(variable) {
+  if (!isJSString(variable)) return variable;
+  return variable.replaceAll(/{{\s*(_\.)?([^}]+)\s*}}/g, '${[$2]}');
+}
--- a/src-tauri/plugins/insomnia-importer/src/importers/environment.js
+++ b/src-tauri/plugins/insomnia-importer/src/importers/environment.js
@@ -0,0 +1,21 @@
+/**
+ * Import an Insomnia environment object.
+ * @param {Object} e - The environment object to import.
+ * @param workspaceId - Workspace to import into.
+ */
+export function importEnvironment(e, workspaceId) {
+  console.log('IMPORTING Environment', e._id, e.name, JSON.stringify(e, null, 2));
+  return {
+    id: e._id,
+    createdAt: new Date(e.created ?? Date.now()).toISOString().replace('Z', ''),
+    updatedAt: new Date(e.updated ?? Date.now()).toISOString().replace('Z', ''),
+    workspaceId,
+    model: 'environment',
+    name: e.name,
+    variables: Object.entries(e.data).map(([name, value]) => ({
+      enabled: true,
+      name,
+      value: `${value}`,
+    })),
+  };
+}
--- a/src-tauri/plugins/insomnia-importer/src/importers/folder.js
+++ b/src-tauri/plugins/insomnia-importer/src/importers/folder.js
@@ -0,0 +1,17 @@
+/**
+ * Import an Insomnia folder object.
+ * @param {Object} f - The environment object to import.
+ * @param workspaceId - Workspace to import into.
+ */
+export function importFolder(f, workspaceId) {
+  console.log('IMPORTING FOLDER', f._id, f.name, JSON.stringify(f, null, 2));
+  return {
+    id: f._id,
+    createdAt: new Date(f.created ?? Date.now()).toISOString().replace('Z', ''),
+    updatedAt: new Date(f.updated ?? Date.now()).toISOString().replace('Z', ''),
+    folderId: f.parentId === workspaceId ? null : f.parentId,
+    workspaceId,
+    model: 'folder',
+    name: f.name,
+  };
+}
--- a/src-tauri/plugins/insomnia-importer/src/importers/request.js
+++ b/src-tauri/plugins/insomnia-importer/src/importers/request.js
@@ -0,0 +1,58 @@
+import { convertSyntax } from '../helpers/variables.js';
+
+/**
+ * Import an Insomnia request object.
+ * @param {Object} r - The request object to import.
+ * @param workspaceId - The workspace ID to use for the request.
+ * @param {number} sortPriority - The sort priority to use for the request.
+ */
+export function importRequest(r, workspaceId, sortPriority = 0) {
+  console.log('IMPORTING REQUEST', r._id, r.name, JSON.stringify(r, null, 2));
+
+  let bodyType = null;
+  let body = null;
+  if (r.body?.mimeType === 'application/graphql') {
+    bodyType = 'graphql';
+    body = convertSyntax(r.body.text);
+  } else if (r.body?.mimeType === 'application/json') {
+    bodyType = 'application/json';
+    body = convertSyntax(r.body.text);
+  }
+
+  let authenticationType = null;
+  let authentication = {};
+  if (r.authentication.type === 'bearer') {
+    authenticationType = 'bearer';
+    authentication = {
+      token: convertSyntax(r.authentication.token),
+    };
+  } else if (r.authentication.type === 'basic') {
+    authenticationType = 'basic';
+    authentication = {
+      username: convertSyntax(r.authentication.username),
+      password: convertSyntax(r.authentication.password),
+    };
+  }
+
+  return {
+    id: r._id,
+    createdAt: new Date(r.created ?? Date.now()).toISOString().replace('Z', ''),
+    updatedAt: new Date(r.updated ?? Date.now()).toISOString().replace('Z', ''),
+    workspaceId,
+    folderId: r.parentId === workspaceId ? null : r.parentId,
+    model: 'http_request',
+    sortPriority,
+    name: r.name,
+    url: convertSyntax(r.url),
+    body,
+    bodyType,
+    authentication,
+    authenticationType,
+    method: r.method,
+    headers: (r.headers ?? []).map(({ name, value, disabled }) => ({
+      enabled: !disabled,
+      name,
+      value,
+    })),
+  };
+}
--- a/src-tauri/plugins/insomnia-importer/src/importers/workspace.js
+++ b/src-tauri/plugins/insomnia-importer/src/importers/workspace.js
@@ -0,0 +1,15 @@
+/**
+ * Import an Insomnia workspace object.
+ * @param {Object} w - The workspace object to import.
+ */
+export function importWorkspace(w, variables) {
+  console.log('IMPORTING Workspace', w._id, w.name, JSON.stringify(w, null, 2));
+  return {
+    id: w._id,
+    createdAt: new Date(w.created ?? Date.now()).toISOString().replace('Z', ''),
+    updatedAt: new Date(w.updated ?? Date.now()).toISOString().replace('Z', ''),
+    model: 'workspace',
+    name: w.name,
+    variables,
+  };
+}
--- a/src-tauri/plugins/insomnia-importer/src/index.js
+++ b/src-tauri/plugins/insomnia-importer/src/index.js
@@ -0,0 +1,78 @@
+import { importEnvironment } from './importers/environment.js';
+import { importRequest } from './importers/request.js';
+import { importWorkspace } from './importers/workspace.js';
+import {
+  isEnvironment,
+  isJSObject,
+  isRequest,
+  isRequestGroup,
+  isWorkspace,
+} from './helpers/types.js';
+import { parseVariables } from './helpers/variables.js';
+import { importFolder } from './importers/folder.js';
+
+export function pluginHookImport(contents) {
+  const parsed = JSON.parse(contents);
+  if (!isJSObject(parsed)) {
+    return;
+  }
+
+  const { _type, __export_format } = parsed;
+  if (_type !== 'export' || __export_format !== 4 || !Array.isArray(parsed.resources)) {
+    return;
+  }
+
+  const resources = {
+    workspaces: [],
+    requests: [],
+    environments: [],
+    folders: [],
+  };
+
+  // Import workspaces
+  const workspacesToImport = parsed.resources.filter(isWorkspace);
+  for (const workspaceToImport of workspacesToImport) {
+    console.log('IMPORTING WORKSPACE', workspaceToImport.name);
+    const baseEnvironment = parsed.resources.find(
+      (r) => isEnvironment(r) && r.parentId === workspaceToImport._id,
+    );
+    console.log('FOUND BASE ENV', baseEnvironment.name);
+    resources.workspaces.push(
+      importWorkspace(
+        workspaceToImport,
+        baseEnvironment ? parseVariables(baseEnvironment.data) : [],
+      ),
+    );
+    console.log('IMPORTING ENVIRONMENTS', baseEnvironment.name);
+    const environmentsToImport = parsed.resources.filter(
+      (r) => isEnvironment(r) && r.parentId === baseEnvironment?._id,
+    );
+    console.log('FOUND', environmentsToImport.length, 'ENVIRONMENTS');
+    resources.environments.push(
+      ...environmentsToImport.map((r) => importEnvironment(r, workspaceToImport._id)),
+    );
+
+    const nextFolder = (parentId) => {
+      const children = parsed.resources.filter((r) => r.parentId === parentId);
+      let sortPriority = 0;
+      for (const child of children) {
+        if (isRequestGroup(child)) {
+          resources.folders.push(importFolder(child, workspaceToImport._id));
+          nextFolder(child._id);
+        } else if (isRequest(child)) {
+          resources.requests.push(importRequest(child, workspaceToImport._id, sortPriority++));
+        }
+      }
+    };
+
+    // Import folders
+    nextFolder(workspaceToImport._id);
+  }
+
+  // Filter out any `null` values
+  resources.requests = resources.requests.filter(Boolean);
+  resources.environments = resources.environments.filter(Boolean);
+  resources.workspaces = resources.workspaces.filter(Boolean);
+
+  return resources;
+}
--- a/src-tauri/plugins/insomnia-importer/vite.config.js
+++ b/src-tauri/plugins/insomnia-importer/vite.config.js
@@ -0,0 +1,13 @@
+import { resolve } from 'path';
+import { defineConfig } from 'vite';
+
+export default defineConfig({
+  build: {
+    lib: {
+      entry: resolve(__dirname, 'src/index.js'),
+      fileName: 'index',
+      formats: ['es'],
+    },
+    outDir: resolve(__dirname, 'out'),
+  },
+});
--- a/src-tauri/plugins/plugin.ts
+++ b/src-tauri/plugins/plugin.ts
@@ -1 +0,0 @@
-Deno.core.opAsync('op_hello', 'Deno');
--- a/src-tauri/sqlx-data.json
+++ b/src-tauri/sqlx-data.json
--- a/src-tauri/src/analytics.rs
+++ b/src-tauri/src/analytics.rs
@@ -0,0 +1,118 @@
+use sqlx::types::JsonValue;
+use tauri::{async_runtime, AppHandle, Manager};
+
+use crate::is_dev;
+
+pub enum AnalyticsResource {
+    App,
+    // Workspace,
+    // Environment,
+    // Folder,
+    // HttpRequest,
+    // HttpResponse,
+}
+
+pub enum AnalyticsAction {
+    Launch,
+    // Create,
+    // Update,
+    // Upsert,
+    // Delete,
+    // Send,
+    // Duplicate,
+}
+
+fn resource_name(resource: AnalyticsResource) -> &'static str {
+    match resource {
+        AnalyticsResource::App => "app",
+        // AnalyticsResource::Workspace => "workspace",
+        // AnalyticsResource::Environment => "environment",
+        // AnalyticsResource::Folder => "folder",
+        // AnalyticsResource::HttpRequest => "http_request",
+        // AnalyticsResource::HttpResponse => "http_response",
+    }
+}
+
+fn action_name(action: AnalyticsAction) -> &'static str {
+    match action {
+        AnalyticsAction::Launch => "launch",
+        // AnalyticsAction::Create => "create",
+        // AnalyticsAction::Update => "update",
+        // AnalyticsAction::Upsert => "upsert",
+        // AnalyticsAction::Delete => "delete",
+        // AnalyticsAction::Send => "send",
+        // AnalyticsAction::Duplicate => "duplicate",
+    }
+}
+
+pub fn track_event(
+    app_handle: &AppHandle,
+    resource: AnalyticsResource,
+    action: AnalyticsAction,
+    attributes: Option<JsonValue>,
+) {
+    async_runtime::block_on(async move {
+        let event = format!("{}.{}", resource_name(resource), action_name(action));
+        let attributes_json = attributes.unwrap_or("{}".to_string().into()).to_string();
+        let info = app_handle.package_info();
+        let params = vec![
+            ("e", event.clone()),
+            ("a", attributes_json.clone()),
+            ("id", "site_zOK0d7jeBy2TLxFCnZ".to_string()),
+            ("v", info.version.clone().to_string()),
+            ("os", get_os().to_string()),
+            ("xy", get_window_size(app_handle)),
+        ];
+        let url = format!("https://t.yaak.app/t/e");
+        let req = reqwest::Client::builder()
+            .build()
+            .unwrap()
+            .get(&url)
+            .query(&params);
+
+        if is_dev() {
+            println!("Ignore dev analytics event: {} {:?}", event, params);
+        } else {
+            if let Err(e) = req.send().await {
+                println!("Error sending analytics event: {}", e);
+            } else {
+                println!("Sent analytics event: {}", event);
+            }
+        }
+    });
+}
+
+fn get_os() -> &'static str {
+    if cfg!(target_os = "windows") {
+        "windows"
+    } else if cfg!(target_os = "macos") {
+        "macos"
+    } else if cfg!(target_os = "linux") {
+        "linux"
+    } else {
+        "unknown"
+    }
+}
+
+fn get_window_size(app_handle: &AppHandle) -> String {
+    let window = match app_handle.windows().into_values().next() {
+        Some(w) => w,
+        None => return "unknown".to_string(),
+    };
+
+    let current_monitor = match window.current_monitor() {
+        Ok(Some(m)) => m,
+        _ => return "unknown".to_string(),
+    };
+
+    let scale_factor = current_monitor.scale_factor();
+    let size = current_monitor.size();
+    let width: f64 = size.width as f64 / scale_factor;
+    let height: f64 = size.height as f64 / scale_factor;
+
+    format!(
+        "{}x{}",
+        (width / 100.0).round() * 100.0,
+        (height / 100.0).round() * 100.0
+    )
+}
--- a/src-tauri/src/main.rs
+++ b/src-tauri/src/main.rs
--- a/src-tauri/src/models.rs
+++ b/src-tauri/src/models.rs
@@ -1,72 +1,193 @@
+use std::collections::HashMap;
+use std::fs;
+
 use rand::distributions::{Alphanumeric, DistString};
 use serde::{Deserialize, Serialize};
 use sqlx::types::chrono::NaiveDateTime;
-use sqlx::types::Json;
+use sqlx::types::{Json, JsonValue};
 use sqlx::{Pool, Sqlite};

-#[derive(sqlx::FromRow, Debug, Clone, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
+#[derive(sqlx::FromRow, Debug, Clone, Serialize, Deserialize, Default)]
+#[serde(default, rename_all = "camelCase")]
 pub struct Workspace {
    pub id: String,
+    pub model: String,
    pub created_at: NaiveDateTime,
    pub updated_at: NaiveDateTime,
-    pub deleted_at: Option<NaiveDateTime>,
    pub name: String,
    pub description: String,
+    pub variables: Json<Vec<EnvironmentVariable>>,
 }

-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct HttpRequestHeader {
+#[derive(sqlx::FromRow, Debug, Clone, Serialize, Deserialize, Default)]
+#[serde(default, rename_all = "camelCase")]
+pub struct Environment {
+    pub id: String,
+    pub workspace_id: String,
+    pub model: String,
+    pub created_at: NaiveDateTime,
+    pub updated_at: NaiveDateTime,
+    pub name: String,
+    pub variables: Json<Vec<EnvironmentVariable>>,
+}
+
+fn default_enabled() -> bool {
+    true
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+#[serde(default, rename_all = "camelCase")]
+pub struct EnvironmentVariable {
+    #[serde(default = "default_enabled")]
+    pub enabled: bool,
    pub name: String,
    pub value: String,
 }

-#[derive(sqlx::FromRow, Debug, Clone, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+#[serde(default, rename_all = "camelCase")]
+pub struct HttpRequestHeader {
+    #[serde(default = "default_enabled")]
+    pub enabled: bool,
+    pub name: String,
+    pub value: String,
+}
+
+fn default_http_request_method() -> String {
+    "GET".to_string()
+}
+
+#[derive(sqlx::FromRow, Debug, Clone, Serialize, Deserialize, Default)]
+#[serde(default, rename_all = "camelCase")]
 pub struct HttpRequest {
-    pub id: String,
    pub created_at: NaiveDateTime,
    pub updated_at: NaiveDateTime,
-    pub deleted_at: Option<NaiveDateTime>,
+    pub id: String,
    pub workspace_id: String,
+    pub folder_id: Option<String>,
+    pub model: String,
+    pub sort_priority: f64,
    pub name: String,
    pub url: String,
+    #[serde(default = "default_http_request_method")]
    pub method: String,
    pub body: Option<String>,
+    pub body_type: Option<String>,
+    pub authentication: Json<HashMap<String, JsonValue>>,
+    pub authentication_type: Option<String>,
    pub headers: Json<Vec<HttpRequestHeader>>,
 }

-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
+#[derive(sqlx::FromRow, Debug, Clone, Serialize, Deserialize, Default)]
+#[serde(default, rename_all = "camelCase")]
+pub struct Folder {
+    pub created_at: NaiveDateTime,
+    pub updated_at: NaiveDateTime,
+    pub id: String,
+    pub workspace_id: String,
+    pub folder_id: Option<String>,
+    pub model: String,
+    pub name: String,
+    pub sort_priority: f64,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+#[serde(default, rename_all = "camelCase")]
 pub struct HttpResponseHeader {
    pub name: String,
    pub value: String,
 }

-#[derive(sqlx::FromRow, Debug, Clone, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
+#[derive(sqlx::FromRow, Debug, Clone, Serialize, Deserialize, Default)]
+#[serde(default, rename_all = "camelCase")]
 pub struct HttpResponse {
    pub id: String,
+    pub model: String,
    pub workspace_id: String,
    pub request_id: String,
    pub created_at: NaiveDateTime,
    pub updated_at: NaiveDateTime,
-    pub deleted_at: Option<NaiveDateTime>,
    pub error: Option<String>,
    pub url: String,
+    pub content_length: Option<i64>,
    pub elapsed: i64,
    pub status: i64,
    pub status_reason: Option<String>,
-    pub body: String,
+    pub body: Option<Vec<u8>>,
+    pub body_path: Option<String>,
    pub headers: Json<Vec<HttpResponseHeader>>,
 }

+impl HttpResponse {
+    pub(crate) fn new() -> Self {
+        Self {
+            model: "http_response".to_string(),
+            ..Default::default()
+        }
+    }
+}
+
+#[derive(sqlx::FromRow, Debug, Clone, Serialize, Deserialize, Default)]
+#[serde(default, rename_all = "camelCase")]
+pub struct KeyValue {
+    pub model: String,
+    pub created_at: NaiveDateTime,
+    pub updated_at: NaiveDateTime,
+    pub namespace: String,
+    pub key: String,
+    pub value: String,
+}
+
+pub async fn set_key_value(
+    namespace: &str,
+    key: &str,
+    value: &str,
+    pool: &Pool<Sqlite>,
+) -> (KeyValue, bool) {
+    let existing = get_key_value(namespace, key, pool).await;
+    sqlx::query!(
+        r#"
+            INSERT INTO key_values (namespace, key, value)
+            VALUES (?, ?, ?) ON CONFLICT DO UPDATE SET
+               updated_at = CURRENT_TIMESTAMP,
+               value = excluded.value
+        "#,
+        namespace,
+        key,
+        value,
+    )
+    .execute(pool)
+    .await
+    .expect("Failed to insert key value");
+
+    let kv = get_key_value(namespace, key, pool)
+        .await
+        .expect("Failed to get key value");
+    return (kv, existing.is_none());
+}
+
+pub async fn get_key_value(namespace: &str, key: &str, pool: &Pool<Sqlite>) -> Option<KeyValue> {
+    sqlx::query_as!(
+        KeyValue,
+        r#"
+            SELECT model, created_at, updated_at, namespace, key, value
+            FROM key_values
+            WHERE namespace = ? AND key = ?
+        "#,
+        namespace,
+        key,
+    )
+    .fetch_one(pool)
+    .await
+    .ok()
+}
+
 pub async fn find_workspaces(pool: &Pool<Sqlite>) -> Result<Vec<Workspace>, sqlx::Error> {
    sqlx::query_as!(
        Workspace,
        r#"
-            SELECT id, created_at, updated_at, deleted_at, name, description
+            SELECT id, model, created_at, updated_at, name, description,
+                variables AS "variables!: sqlx::types::Json<Vec<EnvironmentVariable>>"
            FROM workspaces
        "#,
    )
@@ -78,8 +199,114 @@ pub async fn get_workspace(id: &str, pool: &Pool<Sqlite>) -> Result<Workspace, s
    sqlx::query_as!(
        Workspace,
        r#"
-            SELECT id, created_at, updated_at, deleted_at, name, description
-            FROM workspaces
+            SELECT id, model, created_at, updated_at, name, description,
+                variables AS "variables!: sqlx::types::Json<Vec<EnvironmentVariable>>"
+            FROM workspaces WHERE id = ?
+        "#,
+        id,
+    )
+    .fetch_one(pool)
+    .await
+}
+
+pub async fn delete_workspace(id: &str, pool: &Pool<Sqlite>) -> Result<Workspace, sqlx::Error> {
+    let workspace = get_workspace(id, pool).await?;
+    let _ = sqlx::query!(
+        r#"
+            DELETE FROM workspaces
+            WHERE id = ?
+        "#,
+        id,
+    )
+    .execute(pool)
+    .await;
+
+    for r in find_responses_by_workspace_id(id, pool).await? {
+        delete_response(&r.id, pool).await?;
+    }
+
+    Ok(workspace)
+}
+
+pub async fn find_environments(
+    workspace_id: &str,
+    pool: &Pool<Sqlite>,
+) -> Result<Vec<Environment>, sqlx::Error> {
+    sqlx::query_as!(
+        Environment,
+        r#"
+            SELECT id, workspace_id, model, created_at, updated_at, name,
+                variables AS "variables!: sqlx::types::Json<Vec<EnvironmentVariable>>"
+            FROM environments
+            WHERE workspace_id = ?
+        "#,
+        workspace_id,
+    )
+    .fetch_all(pool)
+    .await
+}
+
+pub async fn delete_environment(id: &str, pool: &Pool<Sqlite>) -> Result<Environment, sqlx::Error> {
+    let env = get_environment(id, pool).await?;
+    let _ = sqlx::query!(
+        r#"
+            DELETE FROM environments
+            WHERE id = ?
+        "#,
+        id,
+    )
+    .execute(pool)
+    .await;
+
+    Ok(env)
+}
+
+pub async fn upsert_environment(
+    pool: &Pool<Sqlite>,
+    environment: Environment,
+) -> Result<Environment, sqlx::Error> {
+    let id = match environment.id.as_str() {
+        "" => generate_id(Some("ev")),
+        _ => environment.id.to_string(),
+    };
+    let trimmed_name = environment.name.trim();
+    sqlx::query!(
+        r#"
+            INSERT INTO environments (
+                id,
+                workspace_id,
+                name,
+                variables
+            )
+            VALUES (?, ?, ?, ?)
+            ON CONFLICT (id) DO UPDATE SET
+               updated_at = CURRENT_TIMESTAMP,
+               name = excluded.name,
+               variables = excluded.variables
+        "#,
+        id,
+        environment.workspace_id,
+        trimmed_name,
+        environment.variables,
+    )
+    .execute(pool)
+    .await?;
+    get_environment(&id, pool).await
+}
+
+pub async fn get_environment(id: &str, pool: &Pool<Sqlite>) -> Result<Environment, sqlx::Error> {
+    sqlx::query_as!(
+        Environment,
+        r#"
+            SELECT
+                id,
+                model,
+                workspace_id,
+                created_at,
+                updated_at,
+                name,
+                variables AS "variables!: sqlx::types::Json<Vec<EnvironmentVariable>>"
+            FROM environments
            WHERE id = ?
        "#,
        id,
@@ -88,71 +315,168 @@ pub async fn get_workspace(id: &str, pool: &Pool<Sqlite>) -> Result<Workspace, s
    .await
 }

-pub async fn create_workspace(
-    name: &str,
-    description: &str,
-    pool: &Pool<Sqlite>,
-) -> Result<Workspace, sqlx::Error> {
-    let id = generate_id("wk");
-    sqlx::query!(
+pub async fn get_folder(id: &str, pool: &Pool<Sqlite>) -> Result<Folder, sqlx::Error> {
+    sqlx::query_as!(
+        Folder,
        r#"
-            INSERT INTO workspaces (id, name, description)
-            VALUES (?, ?, ?)
+            SELECT
+                id,
+                model,
+                workspace_id,
+                created_at,
+                updated_at,
+                folder_id,
+                name,
+                sort_priority
+            FROM folders
+            WHERE id = ?
        "#,
        id,
-        name,
-        description,
    )
-    .execute(pool)
+    .fetch_one(pool)
    .await
-    .expect("Failed to insert new workspace");
-
-    get_workspace(&id, pool).await
 }

-pub async fn upsert_request(
-    id: Option<&str>,
+pub async fn find_folders(
    workspace_id: &str,
-    name: &str,
-    method: &str,
-    body: Option<&str>,
-    url: &str,
-    headers: Vec<HttpRequestHeader>,
    pool: &Pool<Sqlite>,
-) -> Result<HttpRequest, sqlx::Error> {
-    let generated_id;
-    let id = match id {
-        Some(v) => v,
-        None => {
-            generated_id = generate_id("rq");
-            generated_id.as_str()
-        }
+) -> Result<Vec<Folder>, sqlx::Error> {
+    sqlx::query_as!(
+        Folder,
+        r#"
+            SELECT
+                id,
+                model,
+                workspace_id,
+                created_at,
+                updated_at,
+                folder_id,
+                name,
+                sort_priority
+            FROM folders
+            WHERE workspace_id = ?
+        "#,
+        workspace_id,
+    )
+    .fetch_all(pool)
+    .await
+}
+
+pub async fn delete_folder(id: &str, pool: &Pool<Sqlite>) -> Result<Folder, sqlx::Error> {
+    let env = get_folder(id, pool).await?;
+    let _ = sqlx::query!(
+        r#"
+            DELETE FROM folders
+            WHERE id = ?
+        "#,
+        id,
+    )
+    .execute(pool)
+    .await;
+
+    Ok(env)
+}
+
+pub async fn upsert_folder(pool: &Pool<Sqlite>, r: Folder) -> Result<Folder, sqlx::Error> {
+    let id = match r.id.as_str() {
+        "" => generate_id(Some("fl")),
+        _ => r.id.to_string(),
    };
-    let headers_json = Json(headers);
+    let trimmed_name = r.name.trim();
+
    sqlx::query!(
        r#"
-            INSERT INTO http_requests (id, workspace_id, name, url, method, body, headers, updated_at)
-            VALUES (?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
+            INSERT INTO folders (
+                id,
+                workspace_id,
+                folder_id,
+                name,
+                sort_priority
+            )
+            VALUES (?, ?, ?, ?, ?)
            ON CONFLICT (id) DO UPDATE SET
               updated_at = CURRENT_TIMESTAMP,
               name = excluded.name,
+               folder_id = excluded.folder_id,
+               sort_priority = excluded.sort_priority
+        "#,
+        id,
+        r.workspace_id,
+        r.folder_id,
+        trimmed_name,
+        r.sort_priority,
+    )
+    .execute(pool)
+    .await?;
+
+    get_folder(&id, pool).await
+}
+
+pub async fn duplicate_request(id: &str, pool: &Pool<Sqlite>) -> Result<HttpRequest, sqlx::Error> {
+    let mut request = get_request(id, pool).await?.clone();
+    request.id = "".to_string();
+    upsert_request(pool, request).await
+}
+
+pub async fn upsert_request(
+    pool: &Pool<Sqlite>,
+    r: HttpRequest,
+) -> Result<HttpRequest, sqlx::Error> {
+    let id = match r.id.as_str() {
+        "" => generate_id(Some("rq")),
+        _ => r.id.to_string(),
+    };
+    let headers_json = Json(r.headers);
+    let auth_json = Json(r.authentication);
+    let trimmed_name = r.name.trim();
+
+    sqlx::query!(
+        r#"
+            INSERT INTO http_requests (
+                id,
+                workspace_id,
+                folder_id,
+                name,
+                url,
+                method,
+                body,
+                body_type,
+                authentication,
+                authentication_type,
+                headers,
+                sort_priority
+            )
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT (id) DO UPDATE SET
+               updated_at = CURRENT_TIMESTAMP,
+               name = excluded.name,
+               folder_id = excluded.folder_id,
               method = excluded.method,
               headers = excluded.headers,
               body = excluded.body,
-               url = excluded.url
+               body_type = excluded.body_type,
+               authentication = excluded.authentication,
+               authentication_type = excluded.authentication_type,
+               url = excluded.url,
+               sort_priority = excluded.sort_priority
        "#,
        id,
-        workspace_id,
-        name,
-        url,
-        method,
-        body,
+        r.workspace_id,
+        r.folder_id,
+        trimmed_name,
+        r.url,
+        r.method,
+        r.body,
+        r.body_type,
+        auth_json,
+        r.authentication_type,
        headers_json,
+        r.sort_priority,
    )
    .execute(pool)
-    .await
-    .expect("Failed to insert new request");
-    get_request(id, pool).await
+    .await?;
+
+    get_request(&id, pool).await
 }

 pub async fn find_requests(
@@ -162,7 +486,21 @@ pub async fn find_requests(
    sqlx::query_as!(
        HttpRequest,
        r#"
-            SELECT id, workspace_id, created_at, updated_at, deleted_at, name, url, method, body,
+            SELECT
+                id,
+                model,
+                workspace_id,
+                folder_id,
+                created_at,
+                updated_at,
+                name,
+                url,
+                method,
+                body,
+                body_type,
+                authentication AS "authentication!: Json<HashMap<String, JsonValue>>",
+                authentication_type,
+                sort_priority,
                headers AS "headers!: sqlx::types::Json<Vec<HttpRequestHeader>>"
            FROM http_requests
            WHERE workspace_id = ?
@@ -177,11 +515,24 @@ pub async fn get_request(id: &str, pool: &Pool<Sqlite>) -> Result<HttpRequest, s
    sqlx::query_as!(
        HttpRequest,
        r#"
-            SELECT id, workspace_id, created_at, updated_at, deleted_at, name, url, method, body,
+            SELECT
+                id,
+                model,
+                workspace_id,
+                folder_id,
+                created_at,
+                updated_at,
+                name,
+                url,
+                method,
+                body,
+                body_type,
+                authentication AS "authentication!: Json<HashMap<String, JsonValue>>",
+                authentication_type,
+                sort_priority,
                headers AS "headers!: sqlx::types::Json<Vec<HttpRequestHeader>>"
            FROM http_requests
            WHERE id = ?
-            ORDER BY created_at DESC
        "#,
        id,
    )
@@ -190,9 +541,11 @@ pub async fn get_request(id: &str, pool: &Pool<Sqlite>) -> Result<HttpRequest, s
 }

 pub async fn delete_request(id: &str, pool: &Pool<Sqlite>) -> Result<HttpRequest, sqlx::Error> {
-    let req = get_request(id, pool)
-        .await
-        .expect("Failed to get request to delete");
+    let req = get_request(id, pool).await?;
+
+    // DB deletes will cascade but this will delete the files
+    delete_all_responses(id, pool).await?;
+
    let _ = sqlx::query!(
        r#"
            DELETE FROM http_requests
@@ -212,19 +565,31 @@ pub async fn create_response(
    url: &str,
    status: i64,
    status_reason: Option<&str>,
-    body: &str,
+    content_length: Option<i64>,
+    body: Option<Vec<u8>>,
+    body_path: Option<&str>,
    headers: Vec<HttpResponseHeader>,
    pool: &Pool<Sqlite>,
 ) -> Result<HttpResponse, sqlx::Error> {
-    let req = get_request(request_id, pool)
-        .await
-        .expect("Failed to get request");
-    let id = generate_id("rp");
+    let req = get_request(request_id, pool).await?;
+    let id = generate_id(Some("rp"));
    let headers_json = Json(headers);
    sqlx::query!(
        r#"
-            INSERT INTO http_responses (id, request_id, workspace_id, elapsed, url, status, status_reason, body, headers)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?);
+            INSERT INTO http_responses (
+                id,
+                request_id,
+                workspace_id,
+                elapsed,
+                url,
+                status,
+                status_reason,
+                content_length,
+                body,
+                body_path,
+                headers
+            )
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);
        "#,
        id,
        request_id,
@@ -233,47 +598,112 @@ pub async fn create_response(
        url,
        status,
        status_reason,
+        content_length,
        body,
+        body_path,
        headers_json,
    )
    .execute(pool)
-    .await
-    .expect("Failed to insert new response");
+    .await?;

    get_response(&id, pool).await
 }

-pub async fn update_response(
-    response: HttpResponse,
-    pool: &Pool<Sqlite>,
-) -> Result<HttpResponse, sqlx::Error> {
-    let headers_json = Json(response.headers);
+pub async fn cancel_pending_responses(pool: &Pool<Sqlite>) -> Result<(), sqlx::Error> {
    sqlx::query!(
        r#"
-            UPDATE http_responses SET (elapsed, url, status, status_reason, body, error, headers, updated_at) =
-            (?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP) WHERE id = ?;
+            UPDATE http_responses
+            SET (elapsed, status_reason) = (-1, 'Cancelled')
+            WHERE elapsed = 0;
+        "#,
+    )
+    .execute(pool)
+    .await?;
+    Ok(())
+}
+
+pub async fn update_response_if_id(
+    response: &HttpResponse,
+    pool: &Pool<Sqlite>,
+) -> Result<HttpResponse, sqlx::Error> {
+    if response.id == "" {
+        return Ok(response.clone());
+    }
+    return update_response(response, pool).await;
+}
+
+pub async fn upsert_workspace(
+    pool: &Pool<Sqlite>,
+    workspace: Workspace,
+) -> Result<Workspace, sqlx::Error> {
+    let id = match workspace.id.as_str() {
+        "" => generate_id(Some("wk")),
+        _ => workspace.id.to_string(),
+    };
+    let trimmed_name = workspace.name.trim();
+    sqlx::query!(
+        r#"
+            INSERT INTO workspaces (id, name, description, variables)
+            VALUES (?, ?, ?, ?)
+            ON CONFLICT (id) DO UPDATE SET
+               updated_at = CURRENT_TIMESTAMP,
+               name = excluded.name,
+               description = excluded.description,
+               variables = excluded.variables
+        "#,
+        id,
+        trimmed_name,
+        workspace.description,
+        workspace.variables,
+    )
+    .execute(pool)
+    .await?;
+
+    get_workspace(&id, pool).await
+}
+
+pub async fn update_response(
+    response: &HttpResponse,
+    pool: &Pool<Sqlite>,
+) -> Result<HttpResponse, sqlx::Error> {
+    let headers_json = Json(&response.headers);
+    sqlx::query!(
+        r#"
+            UPDATE http_responses SET (
+                elapsed,
+                url,
+                status,
+                status_reason,
+                content_length,
+                body,
+                body_path,
+                error,
+                headers,
+                updated_at
+            ) = (?, ?, ?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP) WHERE id = ?;
        "#,
        response.elapsed,
        response.url,
        response.status,
        response.status_reason,
+        response.content_length,
        response.body,
+        response.body_path,
        response.error,
        headers_json,
        response.id,
    )
    .execute(pool)
-    .await
-    .expect("Failed to update response");
+    .await?;
    get_response(&response.id, pool).await
 }

 pub async fn get_response(id: &str, pool: &Pool<Sqlite>) -> Result<HttpResponse, sqlx::Error> {
-    sqlx::query_as_unchecked!(
+    sqlx::query_as!(
        HttpResponse,
        r#"
-            SELECT id, workspace_id, request_id, updated_at, deleted_at, created_at,
-                status, status_reason, body, elapsed, url, error,
+            SELECT id, model, workspace_id, request_id, updated_at, created_at, url,
+                status, status_reason, content_length, body, body_path, elapsed, error,
                headers AS "headers!: sqlx::types::Json<Vec<HttpResponseHeader>>"
            FROM http_responses
            WHERE id = ?
@@ -291,12 +721,12 @@ pub async fn find_responses(
    sqlx::query_as!(
        HttpResponse,
        r#"
-            SELECT id, workspace_id, request_id, updated_at, deleted_at,
-                created_at, status, status_reason, body, elapsed, url, error,
+            SELECT id, model, workspace_id, request_id, updated_at, created_at, url,
+                status, status_reason, content_length, body, body_path, elapsed, error,
                headers AS "headers!: sqlx::types::Json<Vec<HttpResponseHeader>>"
            FROM http_responses
            WHERE request_id = ?
-            ORDER BY created_at ASC
+            ORDER BY created_at DESC
        "#,
        request_id,
    )
@@ -304,7 +734,36 @@ pub async fn find_responses(
    .await
 }

-pub async fn delete_response(id: &str, pool: &Pool<Sqlite>) -> Result<(), sqlx::Error> {
+pub async fn find_responses_by_workspace_id(
+    workspace_id: &str,
+    pool: &Pool<Sqlite>,
+) -> Result<Vec<HttpResponse>, sqlx::Error> {
+    sqlx::query_as!(
+        HttpResponse,
+        r#"
+            SELECT id, model, workspace_id, request_id, updated_at, created_at, url,
+                status, status_reason, content_length, body, body_path, elapsed, error,
+                headers AS "headers!: sqlx::types::Json<Vec<HttpResponseHeader>>"
+            FROM http_responses
+            WHERE workspace_id = ?
+            ORDER BY created_at DESC
+        "#,
+        workspace_id,
+    )
+    .fetch_all(pool)
+    .await
+}
+
+pub async fn delete_response(id: &str, pool: &Pool<Sqlite>) -> Result<HttpResponse, sqlx::Error> {
+    let resp = get_response(id, pool).await?;
+
+    // Delete the body file if it exists
+    if let Some(p) = resp.body_path.clone() {
+        if let Err(e) = fs::remove_file(p) {
+            println!("Failed to delete body file: {}", e);
+        };
+    }
+
    let _ = sqlx::query!(
        r#"
            DELETE FROM http_responses
@@ -315,29 +774,23 @@ pub async fn delete_response(id: &str, pool: &Pool<Sqlite>) -> Result<(), sqlx::
    .execute(pool)
    .await;

-    Ok(())
+    Ok(resp)
 }

 pub async fn delete_all_responses(
    request_id: &str,
    pool: &Pool<Sqlite>,
 ) -> Result<(), sqlx::Error> {
-    let _ = sqlx::query!(
-        r#"
-            DELETE FROM http_responses
-            WHERE request_id = ?
-        "#,
-        request_id,
-    )
-    .execute(pool)
-    .await;
-
+    for r in find_responses(request_id, pool).await? {
+        delete_response(&r.id, pool).await?;
+    }
    Ok(())
 }

-pub fn generate_id(prefix: &str) -> String {
-    format!(
-        "{prefix}_{}",
-        Alphanumeric.sample_string(&mut rand::thread_rng(), 10)
-    )
+pub fn generate_id(prefix: Option<&str>) -> String {
+    let id = Alphanumeric.sample_string(&mut rand::thread_rng(), 10);
+    return match prefix {
+        None => id,
+        Some(p) => format!("{p}_{id}"),
+    };
 }
--- a/src-tauri/src/plugin.rs
+++ b/src-tauri/src/plugin.rs
@@ -0,0 +1,187 @@
+use std::fs;
+
+use boa_engine::builtins::promise::PromiseState;
+use boa_engine::{
+    js_string,
+    module::{ModuleLoader, SimpleModuleLoader},
+    property::Attribute,
+    Context, JsArgs, JsNativeError, JsValue, Module, NativeFunction, Source,
+};
+use boa_runtime::Console;
+use serde::{Deserialize, Serialize};
+use serde_json::json;
+use sqlx::{Pool, Sqlite};
+use tauri::AppHandle;
+
+use crate::models::{self, Environment, Folder, HttpRequest, Workspace};
+
+pub fn run_plugin_hello(app_handle: &AppHandle, plugin_name: &str) {
+    run_plugin(app_handle, plugin_name, "hello", &[]);
+}
+
+#[derive(Default, Debug, Deserialize, Serialize)]
+pub struct ImportedResources {
+    workspaces: Vec<Workspace>,
+    environments: Vec<Environment>,
+    folders: Vec<Folder>,
+    requests: Vec<HttpRequest>,
+}
+
+pub async fn run_plugin_import(
+    app_handle: &AppHandle,
+    pool: &Pool<Sqlite>,
+    plugin_name: &str,
+    file_path: &str,
+) -> ImportedResources {
+    let file = fs::read_to_string(file_path)
+        .expect(format!("Unable to read file {}", file_path.to_string()).as_str());
+    let file_contents = file.as_str();
+    let result_json = run_plugin(
+        app_handle,
+        plugin_name,
+        "pluginHookImport",
+        &[js_string!(file_contents).into()],
+    );
+    let resources: ImportedResources =
+        serde_json::from_value(result_json).expect("failed to parse result json");
+    let mut imported_resources = ImportedResources::default();
+
+    println!("Importing resources");
+    for w in resources.workspaces {
+        println!("Importing workspace: {:?}", w);
+        let x = models::upsert_workspace(&pool, w)
+            .await
+            .expect("Failed to create workspace");
+        imported_resources.workspaces.push(x.clone());
+        println!("Imported workspace: {}", x.name);
+    }
+
+    for e in resources.environments {
+        println!("Importing environment: {:?}", e);
+        let x = models::upsert_environment(&pool, e)
+            .await
+            .expect("Failed to create environment");
+        imported_resources.environments.push(x.clone());
+        println!("Imported environment: {}", x.name);
+    }
+
+    for f in resources.folders {
+        println!("Importing folder: {:?}", f);
+        let x = models::upsert_folder(&pool, f)
+            .await
+            .expect("Failed to create folder");
+        imported_resources.folders.push(x.clone());
+        println!("Imported folder: {}", x.name);
+    }
+
+    for r in resources.requests {
+        println!("Importing request: {:?}", r);
+        let x = models::upsert_request(&pool, r)
+            .await
+            .expect("Failed to create request");
+        imported_resources.requests.push(x.clone());
+        println!("Imported request: {}", x.name);
+    }
+
+    imported_resources
+}
+
+fn run_plugin(
+    app_handle: &AppHandle,
+    plugin_name: &str,
+    entrypoint: &str,
+    js_args: &[JsValue],
+) -> serde_json::Value {
+    let plugin_dir = app_handle
+        .path_resolver()
+        .resolve_resource("plugins")
+        .expect("failed to resolve plugin directory resource")
+        .join(plugin_name);
+    let plugin_index_file = plugin_dir.join("out/index.js");
+
+    println!("Plugin dir={:?} file={:?}", plugin_dir, plugin_index_file);
+
+    // Module loader for the specific plugin
+    let loader = &SimpleModuleLoader::new(plugin_dir).expect("failed to create module loader");
+    let dyn_loader: &dyn ModuleLoader = loader;
+
+    let context = &mut Context::builder()
+        .module_loader(dyn_loader)
+        .build()
+        .expect("failed to create context");
+
+    add_runtime(context);
+    add_globals(context);
+
+    let source = Source::from_filepath(&plugin_index_file).expect("Error opening file");
+
+    // Can also pass a `Some(realm)` if you need to execute the module in another realm.
+    let module = Module::parse(source, None, context).expect("failed to parse module");
+
+    // Insert parsed entrypoint into the module loader
+    // TODO: Is this needed if loaded from file already?
+    loader.insert(plugin_index_file, module.clone());
+
+    let promise_result = module
+        .load_link_evaluate(context)
+        .expect("failed to evaluate module");
+
+    // Very important to push forward the job queue after queueing promises.
+    context.run_jobs();
+
+    // Checking if the final promise didn't return an error.
+    match promise_result.state().expect("failed to get promise state") {
+        PromiseState::Pending => {
+            panic!("Promise was pending");
+        }
+        PromiseState::Fulfilled(v) => {
+            assert_eq!(v, JsValue::undefined())
+        }
+        PromiseState::Rejected(err) => {
+            panic!("Failed to link: {}", err.display());
+        }
+    }
+
+    let namespace = module.namespace(context);
+
+    let result = namespace
+        .get(js_string!(entrypoint), context)
+        .expect("failed to get entrypoint")
+        .as_callable()
+        .cloned()
+        .ok_or_else(|| JsNativeError::typ().with_message("export wasn't a function!"))
+        .expect("Failed to get entrypoint")
+        .call(&JsValue::undefined(), js_args, context)
+        .expect("Failed to call entrypoint");
+
+    match result.is_undefined() {
+        true => json!(null), // to_json doesn't work with undefined (yet)
+        false => result
+            .to_json(context)
+            .expect("failed to convert result to json"),
+    }
+}
+
+fn add_runtime(context: &mut Context<'_>) {
+    let console = Console::init(context);
+    context
+        .register_global_property(js_string!(Console::NAME), console, Attribute::all())
+        .expect("the console builtin shouldn't exist");
+}
+
+fn add_globals(context: &mut Context<'_>) {
+    context
+        .register_global_builtin_callable(
+            "sayHello",
+            1,
+            NativeFunction::from_fn_ptr(|_, args, context| {
+                let value: String = args
+                    .get_or_undefined(0)
+                    .try_js_into(context)
+                    .expect("failed to convert arg");
+                println!("Hello {}!", value);
+                Ok(value.into())
+            }),
+        )
+        .expect("failed to register global");
+}
--- a/src-tauri/src/render.rs
+++ b/src-tauri/src/render.rs
@@ -0,0 +1,32 @@
+use crate::models::{Environment, Workspace};
+use std::collections::HashMap;
+use tauri::regex::Regex;
+
+pub fn render(template: &str, workspace: &Workspace, environment: Option<&Environment>) -> String {
+    let mut map = HashMap::new();
+    let workspace_variables = &workspace.variables.0;
+    for variable in workspace_variables {
+        if !variable.enabled || variable.value.is_empty() {
+            continue;
+        }
+        map.insert(variable.name.as_str(), variable.value.as_str());
+    }
+
+    if let Some(e) = environment {
+        let environment_variables = &e.variables.0;
+        for variable in environment_variables {
+            if !variable.enabled || variable.value.is_empty() {
+                continue;
+            }
+            map.insert(variable.name.as_str(), variable.value.as_str());
+        }
+    }
+
+    Regex::new(r"\$\{\[\s*([^]\s]+)\s*]}")
+        .expect("Failed to create regex")
+        .replace_all(template, |caps: &tauri::regex::Captures| {
+            let key = caps.get(1).unwrap().as_str();
+            map.get(key).unwrap_or(&"")
+        })
+        .to_string()
+}
--- a/src-tauri/src/runtime.js
+++ b/src-tauri/src/runtime.js
@@ -1,16 +0,0 @@
-(function (globalThis) {
-  // Deno.core.print(Object.keys(Deno.core).join('\n'));
-
-  function argsToMessage(...args) {
-    return args.map((arg) => JSON.stringify(arg)).join(' ');
-  }
-
-  globalThis.console = {
-    log: (...args) => {
-      Deno.core.print(`[log]: ${argsToMessage(...args)}\n`, false);
-    },
-    error: (...args) => {
-      Deno.core.print(`[err]: ${argsToMessage(...args)}\n`, true);
-    },
-  };
-})(globalThis);
--- a/src-tauri/src/runtime.rs
+++ b/src-tauri/src/runtime.rs
@@ -1,117 +0,0 @@
-use deno_ast::{MediaType, ParseParams, SourceTextInfo};
-use deno_core::error::AnyError;
-use deno_core::{op, Extension, JsRuntime, ModuleSource, ModuleType, RuntimeOptions};
-use std::rc::Rc;
-
-use deno_core::futures::FutureExt;
-use futures::executor;
-
-pub fn run_plugin_sync(file_path: &str) -> Result<(), AnyError> {
-    executor::block_on(run_plugin(file_path))
-}
-
-pub async fn run_plugin(file_path: &str) -> Result<(), AnyError> {
-    let extension = Extension::builder("runtime")
-        .ops(vec![op_hello::decl()])
-        .build();
-
-    // Initialize a runtime instance
-    let mut runtime = JsRuntime::new(RuntimeOptions {
-        module_loader: Some(Rc::new(TsModuleLoader)),
-        extensions: vec![extension],
-        ..Default::default()
-    });
-
-    runtime
-        .execute_script("<runtime>", include_str!("runtime.js"))
-        .expect("Failed to execute runtime.js");
-
-    let main_module = deno_core::resolve_path(file_path).expect("Failed to resolve path");
-    let mod_id = runtime
-        .load_main_module(&main_module, None)
-        .await
-        .expect("Failed to load main module");
-    let result = runtime.mod_evaluate(mod_id);
-    runtime
-        .run_event_loop(false)
-        .await
-        .expect("Failed to run event loop");
-    result.await?
-}
-
-#[op]
-async fn op_hello(name: String) -> Result<String, AnyError> {
-    let contents = format!("Hello {} from Rust!", name);
-    println!("{}", contents);
-    Ok(contents)
-}
-
-struct TsModuleLoader;
-
-impl deno_core::ModuleLoader for TsModuleLoader {
-    fn resolve(
-        &self,
-        specifier: &str,
-        referrer: &str,
-        _kind: deno_core::ResolutionKind,
-    ) -> Result<deno_core::ModuleSpecifier, AnyError> {
-        deno_core::resolve_import(specifier, referrer).map_err(|e| e.into())
-    }
-
-    fn load(
-        &self,
-        module_specifier: &deno_core::ModuleSpecifier,
-        _maybe_referrer: Option<deno_core::ModuleSpecifier>,
-        _is_dyn_import: bool,
-    ) -> std::pin::Pin<Box<deno_core::ModuleSourceFuture>> {
-        let module_specifier = module_specifier.clone();
-        async move {
-            let path = module_specifier.to_file_path().unwrap();
-
-            // Determine what the MediaType is (this is done based on the file
-            // extension) and whether transpiling is required.
-            let media_type = MediaType::from(&path);
-            let (module_type, should_transpile) = match MediaType::from(&path) {
-                MediaType::JavaScript | MediaType::Mjs | MediaType::Cjs => {
-                    (ModuleType::JavaScript, false)
-                }
-                MediaType::Jsx => (ModuleType::JavaScript, true),
-                MediaType::TypeScript
-                | MediaType::Mts
-                | MediaType::Cts
-                | MediaType::Dts
-                | MediaType::Dmts
-                | MediaType::Dcts
-                | MediaType::Tsx => (ModuleType::JavaScript, true),
-                MediaType::Json => (ModuleType::Json, false),
-                _ => panic!("Unknown extension {:?}", path.extension()),
-            };
-
-            // Read the file, transpile if necessary.
-            let code = std::fs::read_to_string(&path)?;
-            let code = if should_transpile {
-                let parsed = deno_ast::parse_module(ParseParams {
-                    specifier: module_specifier.to_string(),
-                    text_info: SourceTextInfo::from_string(code),
-                    media_type,
-                    capture_tokens: false,
-                    scope_analysis: false,
-                    maybe_syntax: None,
-                })?;
-                parsed.transpile(&Default::default())?.text
-            } else {
-                code
-            };
-
-            // Load and return module.
-            let module = ModuleSource {
-                code: code.into_bytes().into_boxed_slice(),
-                module_type,
-                module_url_specified: module_specifier.to_string(),
-                module_url_found: module_specifier.to_string(),
-            };
-            Ok(module)
-        }
-        .boxed_local()
-    }
-}
--- a/src-tauri/src/window_ext.rs
+++ b/src-tauri/src/window_ext.rs
@@ -1,13 +1,18 @@
 use tauri::{Runtime, Window};

-const TRAFFIC_LIGHT_OFFSET_X: f64 = 15.0;
-const TRAFFIC_LIGHT_OFFSET_Y: f64 = 22.0;
+const TRAFFIC_LIGHT_OFFSET_X: f64 = 13.0;
+const TRAFFIC_LIGHT_OFFSET_Y: f64 = 18.0;

-pub trait WindowExt {
+pub trait TrafficLightWindowExt {
    fn position_traffic_lights(&self);
 }

-impl<R: Runtime> WindowExt for Window<R> {
+impl<R: Runtime> TrafficLightWindowExt for Window<R> {
+    #[cfg(not(target_os = "macos"))]
+    fn position_traffic_lights(&self) {
+        // No-op
+    }
+
    #[cfg(target_os = "macos")]
    fn position_traffic_lights(&self) {
        use cocoa::appkit::{NSView, NSWindow, NSWindowButton};
--- a/src-tauri/src/window_menu.rs
+++ b/src-tauri/src/window_menu.rs
@@ -0,0 +1,119 @@
+use tauri::{AboutMetadata, CustomMenuItem, Menu, MenuItem, Submenu};
+
+pub fn os_default(#[allow(unused)] app_name: &str) -> Menu {
+    let mut menu = Menu::new();
+    #[cfg(target_os = "macos")]
+    {
+        menu = menu.add_submenu(Submenu::new(
+            app_name,
+            Menu::new()
+                .add_native_item(MenuItem::About(
+                    app_name.to_string(),
+                    AboutMetadata::default(),
+                ))
+                .add_native_item(MenuItem::Separator)
+                .add_native_item(MenuItem::Services)
+                .add_native_item(MenuItem::Separator)
+                .add_native_item(MenuItem::Hide)
+                .add_native_item(MenuItem::HideOthers)
+                .add_native_item(MenuItem::ShowAll)
+                .add_native_item(MenuItem::Separator)
+                .add_native_item(MenuItem::Quit),
+        ));
+    }
+
+    let mut file_menu = Menu::new();
+    file_menu = file_menu.add_native_item(MenuItem::CloseWindow);
+    #[cfg(not(target_os = "macos"))]
+    {
+        file_menu = file_menu.add_native_item(MenuItem::Quit);
+    }
+    menu = menu.add_submenu(Submenu::new("File", file_menu));
+
+    #[cfg(not(target_os = "linux"))]
+    let mut edit_menu = Menu::new();
+    #[cfg(target_os = "macos")]
+    {
+        edit_menu = edit_menu.add_native_item(MenuItem::Undo);
+        edit_menu = edit_menu.add_native_item(MenuItem::Redo);
+        edit_menu = edit_menu.add_native_item(MenuItem::Separator);
+    }
+    #[cfg(not(target_os = "linux"))]
+    {
+        edit_menu = edit_menu.add_native_item(MenuItem::Cut);
+        edit_menu = edit_menu.add_native_item(MenuItem::Copy);
+        edit_menu = edit_menu.add_native_item(MenuItem::Paste);
+    }
+    #[cfg(target_os = "macos")]
+    {
+        edit_menu = edit_menu.add_native_item(MenuItem::SelectAll);
+    }
+    #[cfg(not(target_os = "linux"))]
+    {
+        menu = menu.add_submenu(Submenu::new("Edit", edit_menu));
+    }
+    let mut view_menu = Menu::new();
+    #[cfg(target_os = "macos")]
+    {
+        view_menu = view_menu
+            .add_native_item(MenuItem::EnterFullScreen)
+            .add_native_item(MenuItem::Separator);
+    }
+    view_menu = view_menu
+        .add_item(
+            CustomMenuItem::new("zoom_reset".to_string(), "Zoom to Actual Size")
+                .accelerator("CmdOrCtrl+0"),
+        )
+        .add_item(
+            CustomMenuItem::new("zoom_in".to_string(), "Zoom In").accelerator("CmdOrCtrl+Plus"),
+        )
+        .add_item(
+            CustomMenuItem::new("zoom_out".to_string(), "Zoom Out").accelerator("CmdOrCtrl+-"),
+        )
+        .add_native_item(MenuItem::Separator)
+        .add_item(
+            CustomMenuItem::new("toggle_sidebar".to_string(), "Toggle Sidebar")
+                .accelerator("CmdOrCtrl+b"),
+        )
+        .add_item(
+            CustomMenuItem::new("focus_sidebar".to_string(), "Focus Sidebar")
+                .accelerator("CmdOrCtrl+1"),
+        )
+        .add_item(
+            CustomMenuItem::new("toggle_settings".to_string(), "Toggle Settings")
+                .accelerator("CmdOrCtrl+,"),
+        )
+        .add_item(
+            CustomMenuItem::new("focus_url".to_string(), "Focus URL").accelerator("CmdOrCtrl+l"),
+        );
+    menu = menu.add_submenu(Submenu::new("View", view_menu));
+
+    let mut window_menu = Menu::new();
+    window_menu = window_menu.add_native_item(MenuItem::Minimize);
+    #[cfg(target_os = "macos")]
+    {
+        window_menu = window_menu.add_native_item(MenuItem::Zoom);
+        window_menu = window_menu.add_native_item(MenuItem::Separator);
+    }
+    window_menu = window_menu.add_native_item(MenuItem::CloseWindow);
+    menu = menu.add_submenu(Submenu::new("Window", window_menu));
+
+    menu = menu.add_submenu(Submenu::new(
+        "Workspace",
+        Menu::new()
+            .add_item(
+                CustomMenuItem::new("send_request".to_string(), "Send Request")
+                    .accelerator("CmdOrCtrl+r"),
+            )
+            .add_item(
+                CustomMenuItem::new("new_request".to_string(), "New Request")
+                    .accelerator("CmdOrCtrl+n"),
+            )
+            .add_item(
+                CustomMenuItem::new("duplicate_request".to_string(), "Duplicate Request")
+                    .accelerator("CmdOrCtrl+d"),
+            ),
+    ));
+
+    menu
+}
--- a/src-tauri/tauri.conf.json
+++ b/src-tauri/tauri.conf.json
@@ -8,25 +8,43 @@
  },
  "package": {
    "productName": "Yaak",
-    "version": "0.0.2"
+    "version": "2023.2.0"
  },
  "tauri": {
-    "windows": [
-      {
-        "fullscreen": false,
-        "height": 800,
-        "hiddenTitle": true,
-        "resizable": true,
-        "title": "Yaak",
-        "titleBarStyle": "Overlay",
-        "width": 1400
+    "windows": [],
+    "cli": {
+      "description": "Yaak CLI",
+      "longDescription": "This is the Yaak CLI, yo",
+      "beforeHelp": "u can use it to build, develop and manage your Yaak application.",
+      "afterHelp": "Have fun!",
+      "args": [],
+      "subcommands": {
+        "import": {
+          "args": [{
+            "name": "file",
+            "short": "f",
+            "takesValue": true
+          }]
+        },
+        "hello": {}
      }
-    ],
+    },
    "allowlist": {
      "all": false,
+      "os": {
+        "all": true
+      },
+      "protocol": {
+        "assetScope": [
+          "$APPDATA/responses/*"
+        ],
+        "asset": true
+      },
      "fs": {
+        "readFile": true,
        "scope": [
-          "$RESOURCE/*"
+          "$RESOURCE/*",
+          "$APPDATA/responses/*"
        ]
      },
      "shell": {
@@ -35,6 +53,10 @@
      },
      "window": {
        "startDragging": true
+      },
+      "dialog": {
+        "all": false,
+        "open": true
      }
    },
    "bundle": {
@@ -50,18 +72,26 @@
        "icons/icon.ico"
      ],
      "identifier": "co.schier.yaak",
-      "longDescription": "",
+      "longDescription": "The best cross-platform visual API client",
      "resources": [
-        "plugins/*",
-        "migrations/*"
+        "migrations/*",
+        "plugins/*"
+      ],
+      "shortDescription": "The best API client",
+      "targets": [
+        "deb",
+        "appimage",
+        "nsis",
+        "app",
+        "dmg",
+        "updater"
      ],
-      "shortDescription": "",
-      "targets": "all",
      "deb": {
        "depends": []
      },
      "macOS": {
        "exceptionDomain": "",
+        "entitlements": "macos/entitlements.plist",
        "frameworks": []
      },
      "windows": {
@@ -78,7 +108,7 @@
      "active": true,
      "dialog": true,
      "endpoints": [
-        "https://update.yaak.app/check/{{target}}/{{current_version}}"
+        "https://update.yaak.app/check/{{target}}/{{arch}}/{{current_version}}"
      ],
      "pubkey": "dW50cnVzdGVkIGNvbW1lbnQ6IG1pbmlzaWduIHB1YmxpYyBrZXk6IEMxRDJFREQ1MjExQjdGN0IKUldSN2Z4c2gxZTNTd1FHNCtmYnFXMHVVQzhuNkJOM1cwOFBodmdLall3ckhKenpKUytHSTR1MlkK"
    }
--- a/src-web/assets/icons/LeftPanelHiddenIcon.svg
+++ b/src-web/assets/icons/LeftPanelHiddenIcon.svg
@@ -0,0 +1,5 @@
+<svg width="100%" height="100%" viewBox="0 0 15 15" version="1.1" xmlns="http://www.w3.org/2000/svg"
+     style="fill-rule:evenodd;clip-rule:evenodd;stroke-linejoin:round;stroke-miterlimit:2;">
+        <path fill="currentColor"
+              d="M2.5,1C1.672,1 1,1.672 1,2.5L1,12.5C1,13.328 1.672,14 2.5,14L12.5,14C13.328,14 14,13.328 14,12.5L14,2.5C14,1.672 13.328,1 12.5,1L2.5,1ZM12.5,13C12.776,13 13,12.776 13,12.5L13,2.5C13,2.224 12.776,2 12.5,2L6,2L6,13L12.5,13ZM2.5,2L5,2L5,13L2.5,13C2.224,13 2,12.776 2,12.5L2,2.5C2,2.224 2.224,2 2.5,2Z"/>
+</svg>
--- a/src-web/assets/icons/LeftPanelVisibleIcon.svg
+++ b/src-web/assets/icons/LeftPanelVisibleIcon.svg
@@ -0,0 +1,6 @@
+<svg width="100%" height="100%" viewBox="0 0 15 15" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xml:space="preserve" xmlns:serif="http://www.serif.com/" style="fill-rule:evenodd;clip-rule:evenodd;stroke-linejoin:round;stroke-miterlimit:2;">
+            <rect x="0" y="0" width="15" height="15" style="fill:none;"/>
+            <g transform="matrix(1,0,0,1,-16,-8.88178e-16)">
+                <path fill="currentColor" d="M18.5,1C17.672,1 17,1.672 17,2.5L17,12.5C17,13.328 17.672,14 18.5,14L28.5,14C29.328,14 30,13.328 30,12.5L30,2.5C30,1.672 29.328,1 28.5,1L18.5,1ZM28.5,13C28.776,13 29,12.776 29,12.5L29,2.5C29,2.224 28.776,2 28.5,2L22,2L22,13L28.5,13ZM18,11.535L21,12.285L21,13L18.5,13C18.224,13 18,12.776 18,12.5L18,11.535ZM18,10.504L21,11.254L21,9.81L18,9.06L18,10.504ZM18,8.029L21,8.779L21,7.327L18,6.577L18,8.029ZM18,5.546L21,6.296L21,4.833L18,4.083L18,5.546ZM21,3.802L18,3.052L18,2.5C18,2.224 18.224,2 18.5,2L21,2L21,3.802Z"/>
+            </g>
+</svg>
--- a/src-web/components/App.tsx
+++ b/src-web/components/App.tsx
@@ -1,79 +1,20 @@
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
-import { listen } from '@tauri-apps/api/event';
 import { MotionConfig } from 'framer-motion';
+import { Suspense } from 'react';
+import { DndProvider } from 'react-dnd';
+import { HTML5Backend } from 'react-dnd-html5-backend';
 import { HelmetProvider } from 'react-helmet-async';
 import { AppRouter } from './AppRouter';
-import { requestsQueryKey } from '../hooks/useRequests';
-import { responsesQueryKey } from '../hooks/useResponses';
-import { DEFAULT_FONT_SIZE } from '../lib/constants';
-import type { HttpRequest, HttpResponse } from '../lib/models';
-import { convertDates } from '../lib/models';

-const queryClient = new QueryClient();
-
-await listen('updated_request', ({ payload: request }: { payload: HttpRequest }) => {
-  queryClient.setQueryData(
-    requestsQueryKey(request.workspaceId),
-    (requests: HttpRequest[] = []) => {
-      const newRequests = [];
-      let found = false;
-      for (const r of requests) {
-        if (r.id === request.id) {
-          found = true;
-          newRequests.push(convertDates(request));
-        } else {
-          newRequests.push(r);
-        }
-      }
-      if (!found) {
-        newRequests.push(convertDates(request));
-      }
-      return newRequests;
+const queryClient = new QueryClient({
+  logger: undefined,
+  defaultOptions: {
+    queries: {
+      retry: false,
+      refetchOnWindowFocus: true,
+      networkMode: 'offlineFirst',
    },
-  );
-});
-
-await listen('deleted_request', ({ payload: request }: { payload: HttpRequest }) => {
-  queryClient.setQueryData(requestsQueryKey(request.workspaceId), (requests: HttpRequest[] = []) =>
-    requests.filter((r) => r.id !== request.id),
-  );
-});
-
-await listen('updated_response', ({ payload: response }: { payload: HttpResponse }) => {
-  queryClient.setQueryData(
-    responsesQueryKey(response.requestId),
-    (responses: HttpResponse[] = []) => {
-      const newResponses = [];
-      let found = false;
-      for (const r of responses) {
-        if (r.id === response.id) {
-          found = true;
-          newResponses.push(convertDates(response));
-        } else {
-          newResponses.push(r);
-        }
-      }
-      if (!found) {
-        newResponses.push(convertDates(response));
-      }
-      return newResponses;
-    },
-  );
-});
-
-await listen('zoom', ({ payload: zoomDelta }: { payload: number }) => {
-  const fontSize = parseFloat(window.getComputedStyle(document.documentElement).fontSize);
-
-  let newFontSize;
-  if (zoomDelta === 0) {
-    newFontSize = DEFAULT_FONT_SIZE;
-  } else if (zoomDelta > 0) {
-    newFontSize = Math.min(fontSize * 1.1, DEFAULT_FONT_SIZE * 5);
-  } else if (zoomDelta < 0) {
-    newFontSize = Math.max(fontSize * 0.9, DEFAULT_FONT_SIZE * 0.4);
-  }
-
-  document.documentElement.style.fontSize = `${newFontSize}px`;
+  },
 });

 export function App() {
@@ -81,7 +22,12 @@ export function App() {
    <QueryClientProvider client={queryClient}>
      <MotionConfig transition={{ duration: 0.1 }}>
        <HelmetProvider>
-          <AppRouter />
+          <DndProvider backend={HTML5Backend}>
+              <Suspense>
+                <AppRouter />
+                {/*<ReactQueryDevtools initialIsOpen={false} />*/}
+              </Suspense>
+          </DndProvider>
        </HelmetProvider>
      </MotionConfig>
    </QueryClientProvider>
--- a/src-web/components/AppRouter.tsx
+++ b/src-web/components/AppRouter.tsx
@@ -1,25 +1,41 @@
-import { lazy, Suspense } from 'react';
-import { createBrowserRouter, RouterProvider } from 'react-router-dom';
-
-const Workspaces = lazy(() => import('./Workspaces'));
-const Workspace = lazy(() => import('./Workspace'));
-const RouteError = lazy(() => import('./RouteError'));
+import { createBrowserRouter, Navigate, Outlet, RouterProvider } from 'react-router-dom';
+import { routePaths, useAppRoutes } from '../hooks/useAppRoutes';
+import { useRecentRequests } from '../hooks/useRecentRequests';
+import { useRequests } from '../hooks/useRequests';
+import { GlobalHooks } from './GlobalHooks';
+import Workspace from './Workspace';
+import Workspaces from './Workspaces';
+import { DialogProvider } from './DialogContext';
+import { useActiveEnvironmentId } from '../hooks/useActiveEnvironmentId';
+import RouteError from './RouteError';

 const router = createBrowserRouter([
  {
    path: '/',
    errorElement: <RouteError />,
+    element: <Layout />,
    children: [
      {
        path: '/',
+        element: <Navigate to={routePaths.workspaces()} replace={true} />,
+      },
+      {
+        path: routePaths.workspaces(),
        element: <Workspaces />,
      },
      {
-        path: '/workspaces/:workspaceId',
-        element: <Workspace />,
+        path: routePaths.workspace({
+          workspaceId: ':workspaceId',
+          environmentId: ':environmentId',
+        }),
+        element: <WorkspaceOrRedirect />,
      },
      {
-        path: '/workspaces/:workspaceId/requests/:requestId',
+        path: routePaths.request({
+          workspaceId: ':workspaceId',
+          environmentId: ':environmentId',
+          requestId: ':requestId',
+        }),
        element: <Workspace />,
      },
    ],
@@ -27,9 +43,39 @@ const router = createBrowserRouter([
 ]);

 export function AppRouter() {
+  return <RouterProvider router={router} />;
+}
+
+function WorkspaceOrRedirect() {
+  const recentRequests = useRecentRequests();
+  const activeEnvironmentId = useActiveEnvironmentId();
+  const requests = useRequests();
+  const request = requests.find((r) => r.id === recentRequests[0]);
+  const routes = useAppRoutes();
+
+  if (request === undefined) {
+    return <Workspace />;
+  }
+
+  const { id: requestId, workspaceId } = request;
+  const environmentId = activeEnvironmentId ?? undefined;
+
  return (
-    <Suspense>
-      <RouterProvider router={router} />
-    </Suspense>
+    <Navigate
+      to={routes.paths.request({
+        workspaceId,
+        environmentId,
+        requestId,
+      })}
+    />
+  );
+}
+
+function Layout() {
+  return (
+    <DialogProvider>
+      <Outlet />
+      <GlobalHooks />
+    </DialogProvider>
  );
 }
--- a/src-web/components/BasicAuth.tsx
+++ b/src-web/components/BasicAuth.tsx
@@ -0,0 +1,45 @@
+import { useUpdateRequest } from '../hooks/useUpdateRequest';
+import type { HttpRequest } from '../lib/models';
+import { Input } from './core/Input';
+import { VStack } from './core/Stacks';
+
+interface Props {
+  requestId: string;
+  authentication: HttpRequest['authentication'];
+}
+
+export function BasicAuth({ requestId, authentication }: Props) {
+  const updateRequest = useUpdateRequest(requestId);
+
+  return (
+    <VStack className="my-2" space={2}>
+      <Input
+        useTemplating
+        label="Username"
+        name="username"
+        size="sm"
+        defaultValue={`${authentication.username}`}
+        onChange={(username: string) => {
+          updateRequest.mutate((r) => ({
+            ...r,
+            authentication: { password: r.authentication.password, username },
+          }));
+        }}
+      />
+      <Input
+        useTemplating
+        label="Password"
+        name="password"
+        size="sm"
+        type="password"
+        defaultValue={`${authentication.password}`}
+        onChange={(password: string) => {
+          updateRequest.mutate((r) => ({
+            ...r,
+            authentication: { username: r.authentication.username, password },
+          }));
+        }}
+      />
+    </VStack>
+  );
+}
--- a/src-web/components/BearerAuth.tsx
+++ b/src-web/components/BearerAuth.tsx
@@ -0,0 +1,33 @@
+import { useUpdateRequest } from '../hooks/useUpdateRequest';
+import type { HttpRequest } from '../lib/models';
+import { Input } from './core/Input';
+import { VStack } from './core/Stacks';
+
+interface Props {
+  requestId: string;
+  authentication: HttpRequest['authentication'];
+}
+
+export function BearerAuth({ requestId, authentication }: Props) {
+  const updateRequest = useUpdateRequest(requestId);
+
+  return (
+    <VStack className="my-2" space={2}>
+      <Input
+        useTemplating
+        autocompleteVariables
+        type="password"
+        label="Token"
+        name="token"
+        size="sm"
+        defaultValue={`${authentication.token}`}
+        onChange={(token: string) => {
+          updateRequest.mutate((r) => ({
+            ...r,
+            authentication: { token },
+          }));
+        }}
+      />
+    </VStack>
+  );
+}
--- a/src-web/components/DialogContext.tsx
+++ b/src-web/components/DialogContext.tsx
@@ -0,0 +1,65 @@
+import React, { createContext, useContext, useMemo, useState } from 'react';
+import type { DialogProps } from './core/Dialog';
+import { Dialog } from './core/Dialog';
+
+type DialogEntry = {
+  id: string;
+  render: ({ hide }: { hide: () => void }) => React.ReactNode;
+} & Pick<DialogProps, 'title' | 'description' | 'hideX' | 'className' | 'size'>;
+
+type DialogEntryOptionalId = Omit<DialogEntry, 'id'> & { id?: string };
+
+interface State {
+  dialogs: DialogEntry[];
+  actions: Actions;
+}
+
+interface Actions {
+  show: (d: DialogEntryOptionalId) => void;
+  hide: (id: string) => void;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const DialogContext = createContext<State>({} as any);
+
+export const DialogProvider = ({ children }: { children: React.ReactNode }) => {
+  const [dialogs, setDialogs] = useState<State['dialogs']>([]);
+  const actions = useMemo<Actions>(
+    () => ({
+      show: ({ id: oid, ...props }: DialogEntryOptionalId) => {
+        const id = oid ?? Math.random().toString(36).slice(2);
+        setDialogs((a) => [...a.filter((d) => d.id !== id), { id, ...props }]);
+      },
+      hide: (id: string) => {
+        setDialogs((a) => a.filter((d) => d.id !== id));
+      },
+    }),
+    [],
+  );
+
+  const state: State = {
+    dialogs,
+    actions,
+  };
+
+  return (
+    <DialogContext.Provider value={state}>
+      {children}
+      {dialogs.map((props: DialogEntry) => (
+        <DialogInstance key={props.id} {...props} />
+      ))}
+    </DialogContext.Provider>
+  );
+};
+
+function DialogInstance({ id, render, ...props }: DialogEntry) {
+  const { actions } = useContext(DialogContext);
+  const children = render({ hide: () => actions.hide(id) });
+  return (
+    <Dialog open onClose={() => actions.hide(id)} {...props}>
+      {children}
+    </Dialog>
+  );
+}
+
+export const useDialog = () => useContext(DialogContext).actions;
--- a/src-web/components/DropMarker.tsx
+++ b/src-web/components/DropMarker.tsx
@@ -0,0 +1,22 @@
+import classNames from 'classnames';
+import React, { memo } from 'react';
+
+interface Props {
+  className?: string;
+}
+
+export const DropMarker = memo(
+  function DropMarker({ className }: Props) {
+    return (
+      <div
+        className={classNames(
+          className,
+          'relative w-full h-0 overflow-visible pointer-events-none',
+        )}
+      >
+        <div className="absolute z-50 left-2 right-2 -bottom-[0.1rem] h-[0.2rem] bg-blue-500/50 rounded-full" />
+      </div>
+    );
+  },
+  () => true,
+);
--- a/src-web/components/EmptyStateText.tsx
+++ b/src-web/components/EmptyStateText.tsx
@@ -0,0 +1,13 @@
+import type { ReactNode } from 'react';
+
+interface Props {
+  children: ReactNode;
+}
+
+export function EmptyStateText({ children }: Props) {
+  return (
+    <div className="rounded-lg border border-dashed border-highlight h-full text-gray-400 flex items-center justify-center">
+      {children}
+    </div>
+  );
+}
--- a/src-web/components/EnvironmentActionsDropdown.tsx
+++ b/src-web/components/EnvironmentActionsDropdown.tsx
@@ -0,0 +1,79 @@
+import classNames from 'classnames';
+import { memo, useCallback, useMemo } from 'react';
+import { useActiveEnvironment } from '../hooks/useActiveEnvironment';
+import { useAppRoutes } from '../hooks/useAppRoutes';
+import { useEnvironments } from '../hooks/useEnvironments';
+import type { ButtonProps } from './core/Button';
+import { Button } from './core/Button';
+import type { DropdownItem } from './core/Dropdown';
+import { Dropdown } from './core/Dropdown';
+import { Icon } from './core/Icon';
+import { useDialog } from './DialogContext';
+import { EnvironmentEditDialog } from './EnvironmentEditDialog';
+
+type Props = {
+  className?: string;
+} & Pick<ButtonProps, 'forDropdown' | 'leftSlot'>;
+
+export const EnvironmentActionsDropdown = memo(function EnvironmentActionsDropdown({
+  className,
+  ...buttonProps
+}: Props) {
+  const environments = useEnvironments();
+  const activeEnvironment = useActiveEnvironment();
+  const dialog = useDialog();
+  const routes = useAppRoutes();
+
+  const showEnvironmentDialog = useCallback(() => {
+    dialog.show({
+      title: 'Manage Environments',
+      render: () => <EnvironmentEditDialog initialEnvironment={activeEnvironment} />,
+    });
+  }, [dialog, activeEnvironment]);
+
+  const items: DropdownItem[] = useMemo(
+    () => [
+      ...environments.map(
+        (e) => ({
+          key: e.id,
+          label: e.name,
+          rightSlot: e.id === activeEnvironment?.id ? <Icon icon="check" /> : undefined,
+          onSelect: async () => {
+            if (e.id !== activeEnvironment?.id) {
+              routes.setEnvironment(e);
+            } else {
+              routes.setEnvironment(null);
+            }
+          },
+        }),
+        [activeEnvironment?.id],
+      ),
+      ...((environments.length > 0
+        ? [{ type: 'separator', label: 'Environments' }]
+        : []) as DropdownItem[]),
+      {
+        key: 'edit',
+        label: 'Manage Environments',
+        leftSlot: <Icon icon="gear" />,
+        onSelect: showEnvironmentDialog,
+      },
+    ],
+    [activeEnvironment, environments, routes, showEnvironmentDialog],
+  );
+
+  return (
+    <Dropdown items={items}>
+      <Button
+        size="sm"
+        className={classNames(
+          className,
+          'text-gray-800 !px-2 truncate',
+          activeEnvironment == null && 'text-opacity-disabled italic',
+        )}
+        {...buttonProps}
+      >
+        {activeEnvironment?.name ?? 'No Environment'}
+      </Button>
+    </Dropdown>
+  );
+});
--- a/src-web/components/EnvironmentEditDialog.tsx
+++ b/src-web/components/EnvironmentEditDialog.tsx
@@ -0,0 +1,238 @@
+import classNames from 'classnames';
+import { useCallback, useMemo, useState } from 'react';
+import { useWindowSize } from 'react-use';
+import { useActiveWorkspace } from '../hooks/useActiveWorkspace';
+import { useCreateEnvironment } from '../hooks/useCreateEnvironment';
+import { useDeleteEnvironment } from '../hooks/useDeleteEnvironment';
+import { useEnvironments } from '../hooks/useEnvironments';
+import { usePrompt } from '../hooks/usePrompt';
+import { useUpdateEnvironment } from '../hooks/useUpdateEnvironment';
+import { useUpdateWorkspace } from '../hooks/useUpdateWorkspace';
+import type { Environment, Workspace } from '../lib/models';
+import { Button } from './core/Button';
+import type { DropdownItem } from './core/Dropdown';
+import { Dropdown } from './core/Dropdown';
+import type {
+  GenericCompletionConfig,
+  GenericCompletionOption,
+} from './core/Editor/genericCompletion';
+import { Icon } from './core/Icon';
+import { IconButton } from './core/IconButton';
+import { InlineCode } from './core/InlineCode';
+import type { PairEditorProps } from './core/PairEditor';
+import { PairEditor } from './core/PairEditor';
+import { HStack, VStack } from './core/Stacks';
+
+interface Props {
+  initialEnvironment: Environment | null;
+}
+
+export const EnvironmentEditDialog = function ({ initialEnvironment }: Props) {
+  const [selectedEnvironmentId, setSelectedEnvironmentId] = useState<string | null>(
+    initialEnvironment?.id ?? null,
+  );
+  const environments = useEnvironments();
+  const createEnvironment = useCreateEnvironment();
+  const activeWorkspace = useActiveWorkspace();
+
+  const windowSize = useWindowSize();
+  const showSidebar = windowSize.width > 500;
+
+  const selectedEnvironment = useMemo(
+    () => environments.find((e) => e.id === selectedEnvironmentId) ?? null,
+    [environments, selectedEnvironmentId],
+  );
+
+  return (
+    <div
+      className={classNames(
+        'h-full grid gap-x-8 grid-rows-[minmax(0,1fr)]',
+        showSidebar ? 'grid-cols-[auto_minmax(0,1fr)]' : 'grid-cols-[minmax(0,1fr)]',
+      )}
+    >
+      {showSidebar && (
+        <aside className="grid grid-rows-[minmax(0,1fr)_auto] gap-y-0.5 h-full max-w-[250px] pr-3 border-r border-gray-100 -ml-2">
+          <div className="min-w-0 h-full w-full overflow-y-scroll">
+            <SidebarButton
+              active={selectedEnvironment == null}
+              onClick={() => setSelectedEnvironmentId(null)}
+            >
+              Base Environment
+            </SidebarButton>
+            <div className="ml-3 pl-2 border-l border-highlight">
+              {environments.map((e) => (
+                <SidebarButton
+                  key={e.id}
+                  active={selectedEnvironment?.id === e.id}
+                  onClick={() => setSelectedEnvironmentId(e.id)}
+                >
+                  {e.name}
+                </SidebarButton>
+              ))}
+            </div>
+          </div>
+          <Button
+            size="sm"
+            className="w-full text-center"
+            color="gray"
+            justify="center"
+            onClick={() => createEnvironment.mutate()}
+          >
+            New Environment
+          </Button>
+        </aside>
+      )}
+      {activeWorkspace != null ? (
+        <EnvironmentEditor environment={selectedEnvironment} workspace={activeWorkspace} />
+      ) : (
+        <div className="flex w-full h-full items-center justify-center text-gray-400 italic">
+          select an environment
+        </div>
+      )}
+    </div>
+  );
+};
+
+const EnvironmentEditor = function ({
+  environment,
+  workspace,
+}: {
+  environment: Environment | null;
+  workspace: Workspace;
+}) {
+  const environments = useEnvironments();
+  const updateEnvironment = useUpdateEnvironment(environment?.id ?? 'n/a');
+  const updateWorkspace = useUpdateWorkspace(workspace.id);
+  const deleteEnvironment = useDeleteEnvironment(environment);
+  const variables = environment == null ? workspace.variables : environment.variables;
+  const handleChange = useCallback<PairEditorProps['onChange']>(
+    (variables) => {
+      if (environment != null) {
+        updateEnvironment.mutate({ variables });
+      } else {
+        updateWorkspace.mutate({ variables });
+      }
+    },
+    [updateWorkspace, updateEnvironment, environment],
+  );
+
+  // Gather a list of env names from other environments, to help the user get them aligned
+  const nameAutocomplete = useMemo<GenericCompletionConfig>(() => {
+    const otherEnvironments = environments.filter((e) => e.id !== environment?.id);
+    const allVariableNames =
+      environment == null
+        ? [
+            // Nothing to autocomplete if we're in the base environment
+          ]
+        : [
+            ...workspace.variables.map((v) => v.name),
+            ...otherEnvironments.flatMap((e) => e.variables.map((v) => v.name)),
+          ];
+
+    // Filter out empty strings and variables that already exist
+    const variableNames = allVariableNames.filter(
+      (name) => name != '' && !variables.find((v) => v.name === name),
+    );
+    const uniqueVariableNames = [...new Set(variableNames)];
+    const options = uniqueVariableNames.map(
+      (name): GenericCompletionOption => ({
+        label: name,
+        type: 'constant',
+      }),
+    );
+    return { options };
+  }, [environments, variables, workspace, environment]);
+
+  const prompt = usePrompt();
+  const items = useMemo<DropdownItem[] | null>(
+    () =>
+      environment == null
+        ? null
+        : [
+            {
+              key: 'rename',
+              label: 'Rename',
+              leftSlot: <Icon icon="pencil" size="sm" />,
+              onSelect: async () => {
+                const name = await prompt({
+                  title: 'Rename Environment',
+                  description: (
+                    <>
+                      Enter a new name for <InlineCode>{environment.name}</InlineCode>
+                    </>
+                  ),
+                  name: 'name',
+                  label: 'Name',
+                  defaultValue: environment.name,
+                });
+                updateEnvironment.mutate({ name });
+              },
+            },
+            {
+              key: 'delete',
+              variant: 'danger',
+              label: 'Delete',
+              leftSlot: <Icon icon="trash" size="sm" />,
+              onSelect: () => deleteEnvironment.mutate(),
+            },
+          ],
+    [deleteEnvironment, updateEnvironment, prompt, environment],
+  );
+
+  const validateName = useCallback((name: string) => {
+    // Empty just means the variable doesn't have a name yet, and is unusable
+    if (name === '') return true;
+    return name.match(/^[a-z_][a-z0-9_]*$/i) != null;
+  }, []);
+
+  return (
+    <VStack space={2}>
+      <HStack space={2} className="justify-between">
+        <h1 className="text-xl">{environment?.name ?? 'Base Environment'}</h1>
+        {items != null && (
+          <Dropdown items={items}>
+            <IconButton icon="gear" title="Environment Actions" size="sm" className="!h-auto w-8" />
+          </Dropdown>
+        )}
+      </HStack>
+      <PairEditor
+        nameAutocomplete={nameAutocomplete}
+        nameAutocompleteVariables={false}
+        namePlaceholder="VAR_NAME"
+        valuePlaceholder="variable value"
+        nameValidate={validateName}
+        valueAutocompleteVariables={false}
+        forceUpdateKey={environment?.id ?? workspace?.id ?? 'n/a'}
+        pairs={variables}
+        onChange={handleChange}
+      />
+    </VStack>
+  );
+};
+
+function SidebarButton({
+  children,
+  className,
+  active,
+  onClick,
+}: {
+  className?: string;
+  children: string;
+  active: boolean;
+  onClick: () => void;
+}) {
+  return (
+    <button
+      tabIndex={active ? 0 : -1}
+      onClick={onClick}
+      className={classNames(
+        className,
+        'flex items-center text-sm text-left w-full mb-1 h-xs rounded px-2',
+        'text-gray-600 hocus:text-gray-800 focus:bg-highlightSecondary outline-none',
+        active && '!text-gray-900',
+      )}
+    >
+      {children}
+    </button>
+  );
+}
--- a/src-web/components/GlobalHooks.tsx
+++ b/src-web/components/GlobalHooks.tsx
@@ -0,0 +1,143 @@
+import { useQueryClient } from '@tanstack/react-query';
+import { appWindow } from '@tauri-apps/api/window';
+import { useEffect } from 'react';
+import { useLocation } from 'react-router-dom';
+import { useEffectOnce } from 'react-use';
+import { keyValueQueryKey } from '../hooks/useKeyValue';
+import { useListenToTauriEvent } from '../hooks/useListenToTauriEvent';
+import { useRecentEnvironments } from '../hooks/useRecentEnvironments';
+import { useRecentRequests } from '../hooks/useRecentRequests';
+import { useRecentWorkspaces } from '../hooks/useRecentWorkspaces';
+import { requestsQueryKey } from '../hooks/useRequests';
+import { useRequestUpdateKey } from '../hooks/useRequestUpdateKey';
+import { responsesQueryKey } from '../hooks/useResponses';
+import { workspacesQueryKey } from '../hooks/useWorkspaces';
+import { trackPage } from '../lib/analytics';
+import { DEFAULT_FONT_SIZE } from '../lib/constants';
+import { NAMESPACE_NO_SYNC } from '../lib/keyValueStore';
+import type { HttpRequest, HttpResponse, Model, Workspace } from '../lib/models';
+import { modelsEq } from '../lib/models';
+import { setPathname } from '../lib/persistPathname';
+
+export function GlobalHooks() {
+  // Include here so they always update, even
+  // if no component references them
+  useRecentWorkspaces();
+  useRecentEnvironments();
+  useRecentRequests();
+
+  const queryClient = useQueryClient();
+  const { wasUpdatedExternally } = useRequestUpdateKey(null);
+
+  // Listen for location changes and update the pathname
+  const location = useLocation();
+  useEffect(() => {
+    setPathname(location.pathname).catch(console.error);
+  }, [location.pathname]);
+
+  useEffectOnce(() => {
+    trackPage('/');
+  });
+
+  useListenToTauriEvent<Model>('created_model', ({ payload, windowLabel }) => {
+    if (shouldIgnoreEvent(payload, windowLabel)) return;
+
+    const queryKey =
+      payload.model === 'http_request'
+        ? requestsQueryKey(payload)
+        : payload.model === 'http_response'
+        ? responsesQueryKey(payload)
+        : payload.model === 'workspace'
+        ? workspacesQueryKey(payload)
+        : payload.model === 'key_value'
+        ? keyValueQueryKey(payload)
+        : null;
+
+    if (queryKey === null) {
+      console.log('Unrecognized created model:', payload);
+      return;
+    }
+
+    if (!shouldIgnoreModel(payload)) {
+      // Order newest first
+      queryClient.setQueryData<Model[]>(queryKey, (values) => [payload, ...(values ?? [])]);
+    }
+  });
+
+  useListenToTauriEvent<Model>('updated_model', ({ payload, windowLabel }) => {
+    if (shouldIgnoreEvent(payload, windowLabel)) return;
+
+    const queryKey =
+      payload.model === 'http_request'
+        ? requestsQueryKey(payload)
+        : payload.model === 'http_response'
+        ? responsesQueryKey(payload)
+        : payload.model === 'workspace'
+        ? workspacesQueryKey(payload)
+        : payload.model === 'key_value'
+        ? keyValueQueryKey(payload)
+        : null;
+
+    if (queryKey === null) {
+      console.log('Unrecognized updated model:', payload);
+      return;
+    }
+
+    if (payload.model === 'http_request') {
+      wasUpdatedExternally(payload.id);
+    }
+
+    if (!shouldIgnoreModel(payload)) {
+      queryClient.setQueryData<Model[]>(queryKey, (values) =>
+        values?.map((v) => (modelsEq(v, payload) ? payload : v)),
+      );
+    }
+  });
+
+  useListenToTauriEvent<Model>('deleted_model', ({ payload, windowLabel }) => {
+    if (shouldIgnoreEvent(payload, windowLabel)) return;
+
+    if (shouldIgnoreModel(payload)) return;
+
+    if (payload.model === 'workspace') {
+      queryClient.setQueryData<Workspace[]>(workspacesQueryKey(), removeById(payload));
+    } else if (payload.model === 'http_request') {
+      queryClient.setQueryData<HttpRequest[]>(requestsQueryKey(payload), removeById(payload));
+    } else if (payload.model === 'http_response') {
+      queryClient.setQueryData<HttpResponse[]>(responsesQueryKey(payload), removeById(payload));
+    } else if (payload.model === 'key_value') {
+      queryClient.setQueryData(keyValueQueryKey(payload), undefined);
+    }
+  });
+  useListenToTauriEvent<number>('zoom', ({ payload: zoomDelta, windowLabel }) => {
+    if (windowLabel !== appWindow.label) return;
+    const fontSize = parseFloat(window.getComputedStyle(document.documentElement).fontSize);
+
+    let newFontSize;
+    if (zoomDelta === 0) {
+      newFontSize = DEFAULT_FONT_SIZE;
+    } else if (zoomDelta > 0) {
+      newFontSize = Math.min(fontSize * 1.1, DEFAULT_FONT_SIZE * 5);
+    } else if (zoomDelta < 0) {
+      newFontSize = Math.max(fontSize * 0.9, DEFAULT_FONT_SIZE * 0.4);
+    }
+
+    document.documentElement.style.fontSize = `${newFontSize}px`;
+  });
+
+  return null;
+}
+
+function removeById<T extends { id: string }>(model: T) {
+  return (entries: T[] | undefined) => entries?.filter((e) => e.id !== model.id);
+}
+
+const shouldIgnoreEvent = (payload: Model, windowLabel: string) =>
+  windowLabel === appWindow.label && payload.model !== 'http_response';
+
+const shouldIgnoreModel = (payload: Model) => {
+  if (payload.model === 'key_value') {
+    return payload.namespace === NAMESPACE_NO_SYNC;
+  }
+  return false;
+};
--- a/src-web/components/GraphQLEditor.tsx
+++ b/src-web/components/GraphQLEditor.tsx
@@ -0,0 +1,135 @@
+import { updateSchema } from 'cm6-graphql';
+import type { EditorView } from 'codemirror';
+import { useCallback, useEffect, useMemo, useRef } from 'react';
+import { useIntrospectGraphQL } from '../hooks/useIntrospectGraphQL';
+import type { HttpRequest } from '../lib/models';
+import { Button } from './core/Button';
+import type { EditorProps } from './core/Editor';
+import { Editor, formatGraphQL } from './core/Editor';
+import { FormattedError } from './core/FormattedError';
+import { Separator } from './core/Separator';
+import { useDialog } from './DialogContext';
+
+type Props = Pick<
+  EditorProps,
+  'heightMode' | 'onChange' | 'defaultValue' | 'className' | 'forceUpdateKey'
+> & {
+  baseRequest: HttpRequest;
+};
+
+interface GraphQLBody {
+  query: string;
+  variables?: Record<string, string | number | boolean | null>;
+  operationName?: string;
+}
+
+export function GraphQLEditor({ defaultValue, onChange, baseRequest, ...extraEditorProps }: Props) {
+  const editorViewRef = useRef<EditorView>(null);
+  const { schema, isLoading, error, refetch } = useIntrospectGraphQL(baseRequest);
+  const { query, variables } = useMemo<GraphQLBody>(() => {
+    if (defaultValue === undefined) {
+      return { query: '', variables: {} };
+    }
+    try {
+      const p = JSON.parse(defaultValue ?? '{}');
+      const query = p.query ?? '';
+      const variables = p.variables;
+      const operationName = p.operationName;
+      return { query, variables, operationName };
+    } catch (err) {
+      return { query: 'failed to parse' };
+    }
+  }, [defaultValue]);
+
+  const handleChange = useCallback(
+    (b: GraphQLBody) => onChange?.(JSON.stringify(b, null, 2)),
+    [onChange],
+  );
+
+  const handleChangeQuery = useCallback(
+    (query: string) => handleChange({ query, variables }),
+    [handleChange, variables],
+  );
+
+  const handleChangeVariables = useCallback(
+    (variables: string) => {
+      try {
+        handleChange({ query, variables: JSON.parse(variables) });
+      } catch (e) {
+        // Meh, not much we can do here
+      }
+    },
+    [handleChange, query],
+  );
+
+  // Refetch the schema when the URL changes
+  useEffect(() => {
+    if (editorViewRef.current === null) return;
+    updateSchema(editorViewRef.current, schema);
+  }, [schema]);
+
+  const dialog = useDialog();
+
+  return (
+    <div className="pb-2 h-full w-full grid grid-cols-1 grid-rows-[minmax(0,100%)_auto_auto_minmax(0,auto)]">
+      <Editor
+        contentType="application/graphql"
+        defaultValue={query ?? ''}
+        format={formatGraphQL}
+        heightMode="auto"
+        onChange={handleChangeQuery}
+        placeholder="..."
+        ref={editorViewRef}
+        actions={
+          (error || isLoading) && (
+            <Button
+              size="xs"
+              color={error ? 'danger' : 'gray'}
+              isLoading={isLoading}
+              onClick={() => {
+                dialog.show({
+                  title: 'Introspection Failed',
+                  size: 'sm',
+                  id: 'introspection-failed',
+                  render: () => (
+                    <div className="whitespace-pre-wrap">
+                      <FormattedError>{error ?? 'unknown'}</FormattedError>
+                      <div className="w-full mt-3">
+                        <Button
+                          onClick={() => {
+                            dialog.hide('introspection-failed');
+                            refetch();
+                          }}
+                          className="ml-auto"
+                          color="secondary"
+                          size="sm"
+                        >
+                          Try Again
+                        </Button>
+                      </div>
+                    </div>
+                  ),
+                });
+              }}
+            >
+              {error ? 'Introspection Failed' : 'Introspecting'}
+            </Button>
+          )
+        }
+        {...extraEditorProps}
+      />
+      <Separator variant="primary" />
+      <p className="pt-1 text-gray-500 text-sm">Variables</p>
+      <Editor
+        contentType="application/json"
+        defaultValue={JSON.stringify(variables, null, 2)}
+        heightMode="auto"
+        onChange={handleChangeVariables}
+        placeholder="{}"
+        useTemplating
+        autocompleteVariables
+        {...extraEditorProps}
+      />
+    </div>
+  );
+}
--- a/src-web/components/HeaderEditor.tsx
+++ b/src-web/components/HeaderEditor.tsx
@@ -1,117 +1,71 @@
-import classnames from 'classnames';
-import { useEffect, useState } from 'react';
-import { useUpdateRequest } from '../hooks/useUpdateRequest';
-import type { HttpHeader, HttpRequest } from '../lib/models';
-import { IconButton } from './core/IconButton';
-import { Input } from './core/Input';
-import { VStack } from './core/Stacks';
+import { charsets } from '../lib/data/charsets';
+import { connections } from '../lib/data/connections';
+import { encodings } from '../lib/data/encodings';
+import { headerNames } from '../lib/data/headerNames';
+import { mimeTypes } from '../lib/data/mimetypes';
+import type { HttpRequest } from '../lib/models';
+import type { GenericCompletionConfig } from './core/Editor/genericCompletion';
+import type { PairEditorProps } from './core/PairEditor';
+import { PairEditor } from './core/PairEditor';

-interface Props {
-  request: HttpRequest;
-  className?: string;
-}
-
-type PairWithId = { header: Partial<HttpHeader>; id: string };
-
-export function HeaderEditor({ request, className }: Props) {
-  const updateRequest = useUpdateRequest(request);
-  const saveHeaders = (pairs: PairWithId[]) => {
-    const headers = pairs.map((p) => ({ name: '', value: '', ...p.header }));
-    updateRequest.mutate({ headers });
-  };
-
-  const newPair = () => {
-    return { header: { name: '', value: '' }, id: Math.random().toString() };
-  };
-
-  const [pairs, setPairs] = useState<PairWithId[]>(
-    request.headers.map((h) => ({ header: h, id: Math.random().toString() })),
-  );
-
-  const setPairsAndSave = (fn: (pairs: PairWithId[]) => PairWithId[]) => {
-    setPairs((oldPairs) => {
-      const newPairs = fn(oldPairs);
-      saveHeaders(newPairs);
-      return newPairs;
-    });
-  };
-
-  const handleChangeHeader = (pair: PairWithId) => {
-    setPairsAndSave((pairs) =>
-      pairs.map((p) =>
-        pair.id !== p.id ? p : { id: p.id, header: { ...p.header, ...pair.header } },
-      ),
-    );
-  };
-
-  useEffect(() => {
-    const lastPair = pairs[pairs.length - 1];
-    if (lastPair === undefined) {
-      setPairs([newPair()]);
-      return;
-    }
-
-    if (lastPair.header.name !== '' || lastPair.header.value !== '') {
-      setPairsAndSave((pairs) => [...pairs, newPair()]);
-    }
-  }, [pairs]);
-
-  const handleDelete = (pair: PairWithId) => {
-    setPairsAndSave((oldPairs) => oldPairs.filter((p) => p.id !== pair.id));
-  };
+type Props = {
+  forceUpdateKey: string;
+  headers: HttpRequest['headers'];
+  onChange: (headers: HttpRequest['headers']) => void;
+};

+export function HeaderEditor({ headers, onChange, forceUpdateKey }: Props) {
  return (
-    <div className={classnames(className, 'pb-6 grid')}>
-      <VStack space={2}>
-        {pairs.map((p, i) => (
-          <FormRow
-            key={p.id}
-            pair={p}
-            onChange={handleChangeHeader}
-            onDelete={i < pairs.length - 1 ? handleDelete : undefined}
-          />
-        ))}
-      </VStack>
-    </div>
+    <PairEditor
+      valueAutocompleteVariables
+      nameAutocompleteVariables
+      pairs={headers}
+      onChange={onChange}
+      forceUpdateKey={forceUpdateKey}
+      nameValidate={validateHttpHeader}
+      nameAutocomplete={nameAutocomplete}
+      valueAutocomplete={valueAutocomplete}
+      namePlaceholder="Header-Name"
+    />
  );
 }

-function FormRow({
-  pair,
-  onChange,
-  onDelete,
-}: {
-  pair: PairWithId;
-  onChange: (pair: PairWithId) => void;
-  onDelete?: (pair: PairWithId) => void;
-}) {
-  return (
-    <div className="group grid grid-cols-[1fr_1fr_2.5rem] grid-rows-1 gap-2 items-center">
-      <Input
-        hideLabel
-        useEditor={{ useTemplating: true }}
-        name="name"
-        label="Name"
-        placeholder="name"
-        defaultValue={pair.header.name}
-        onChange={(name) => onChange({ id: pair.id, header: { name } })}
-      />
-      <Input
-        hideLabel
-        name="value"
-        label="Value"
-        useEditor={{ useTemplating: true }}
-        placeholder="value"
-        defaultValue={pair.header.value}
-        onChange={(value) => onChange({ id: pair.id, header: { value } })}
-      />
-      {onDelete && (
-        <IconButton
-          icon="trash"
-          onClick={() => onDelete(pair)}
-          className="invisible group-hover:visible"
-        />
-      )}
-    </div>
-  );
-}
+const MIN_MATCH = 3;
+
+const headerOptionsMap: Record<string, string[]> = {
+  'content-type': mimeTypes,
+  accept: ['*/*', ...mimeTypes],
+  'accept-encoding': encodings,
+  connection: connections,
+  'accept-charset': charsets,
+};
+
+const valueAutocomplete = (headerName: string): GenericCompletionConfig | undefined => {
+  const name = headerName.toLowerCase().trim();
+  const options: GenericCompletionConfig['options'] =
+    headerOptionsMap[name]?.map((o) => ({
+      label: o,
+      type: 'constant',
+      boost: 1, // Put above other completions
+    })) ?? [];
+  return { minMatch: MIN_MATCH, options };
+};
+
+const nameAutocomplete: PairEditorProps['nameAutocomplete'] = {
+  minMatch: MIN_MATCH,
+  options: headerNames.map((t) => ({
+    label: t,
+    type: 'constant',
+    boost: 1, // Put above other completions
+  })),
+};
+
+const validateHttpHeader = (v: string) => {
+  if (v === '') {
+    return true;
+  }
+
+  // Template strings are not allowed so we replace them with a valid example string
+  const withoutTemplateStrings = v.replace(/\$\{\[\s*[^\]\s]+\s*]}/gi, '123');
+  return withoutTemplateStrings.match(/^[a-zA-Z0-9-_]+$/) !== null;
+};
--- a/src-web/components/Overlay.tsx
+++ b/src-web/components/Overlay.tsx
@@ -0,0 +1,55 @@
+import classNames from 'classnames';
+import FocusTrap from 'focus-trap-react';
+import { motion } from 'framer-motion';
+import type { ReactNode } from 'react';
+import { Portal } from './Portal';
+
+interface Props {
+  children: ReactNode;
+  portalName: string;
+  open: boolean;
+  onClose?: () => void;
+  zIndex?: keyof typeof zIndexes;
+  variant?: 'default' | 'transparent';
+}
+
+const zIndexes: Record<number, string> = {
+  10: 'z-10',
+  20: 'z-20',
+  30: 'z-30',
+  40: 'z-40',
+  50: 'z-50',
+};
+
+export function Overlay({
+  variant = 'default',
+  zIndex = 30,
+  open,
+  onClose,
+  portalName,
+  children,
+}: Props) {
+  return (
+    <Portal name={portalName}>
+      {open && (
+        <FocusTrap> 
+          <motion.div
+            className={classNames('fixed inset-0', zIndexes[zIndex])}
+            initial={{ opacity: 0 }}
+            animate={{ opacity: 1 }}
+          >
+            <div
+              aria-hidden
+              onClick={onClose}
+              className={classNames(
+                'absolute inset-0',
+                variant === 'default' && 'bg-gray-600/30 dark:bg-black/30 backdrop-blur-sm',
+              )}
+            />
+            <div className="bg-red-100">{children}</div>
+          </motion.div>
+        </FocusTrap>
+      )}
+    </Portal>
+  );
+}
--- a/src-web/components/ParameterEditor.tsx
+++ b/src-web/components/ParameterEditor.tsx
@@ -0,0 +1,19 @@
+import type { HttpRequest } from '../lib/models';
+import { PairEditor } from './core/PairEditor';
+
+type Props = {
+  forceUpdateKey: string;
+  parameters: { name: string; value: string }[];
+  onChange: (headers: HttpRequest['headers']) => void;
+};
+
+export function ParametersEditor({ parameters, forceUpdateKey, onChange }: Props) {
+  return (
+    <PairEditor
+      forceUpdateKey={forceUpdateKey}
+      pairs={parameters}
+      onChange={onChange}
+      namePlaceholder="name"
+    />
+  );
+}
--- a/src-web/components/Portal.tsx
+++ b/src-web/components/Portal.tsx
@@ -0,0 +1,12 @@
+import type { ReactNode } from 'react';
+import { createPortal } from 'react-dom';
+import { usePortal } from '../hooks/usePortal';
+interface Props {
+  children: ReactNode;
+  name: string;
+}
+
+export function Portal({ children, name }: Props) {
+  const portal = usePortal(name);
+  return createPortal(children, portal);
+}
--- a/src-web/components/RecentRequestsDropdown.tsx
+++ b/src-web/components/RecentRequestsDropdown.tsx
@@ -0,0 +1,105 @@
+import classNames from 'classnames';
+import { useMemo, useRef } from 'react';
+import { useKey, useKeyPressEvent } from 'react-use';
+import { useActiveEnvironmentId } from '../hooks/useActiveEnvironmentId';
+import { useActiveRequest } from '../hooks/useActiveRequest';
+import { useActiveWorkspaceId } from '../hooks/useActiveWorkspaceId';
+import { useAppRoutes } from '../hooks/useAppRoutes';
+import { useRecentRequests } from '../hooks/useRecentRequests';
+import { useRequests } from '../hooks/useRequests';
+import type { ButtonProps } from './core/Button';
+import { Button } from './core/Button';
+import type { DropdownItem, DropdownRef } from './core/Dropdown';
+import { Dropdown } from './core/Dropdown';
+
+export function RecentRequestsDropdown({ className }: Pick<ButtonProps, 'className'>) {
+  const dropdownRef = useRef<DropdownRef>(null);
+  const activeRequest = useActiveRequest();
+  const activeWorkspaceId = useActiveWorkspaceId();
+  const activeEnvironmentId = useActiveEnvironmentId();
+  const requests = useRequests();
+  const routes = useAppRoutes();
+  const allRecentRequestIds = useRecentRequests();
+  const recentRequestIds = useMemo(() => allRecentRequestIds.slice(1), [allRecentRequestIds]);
+
+  // Toggle the menu on Cmd+k
+  useKey('k', (e) => {
+    if (e.metaKey) {
+      e.preventDefault();
+      dropdownRef.current?.toggle(0);
+    }
+  });
+
+  // Handle key-up
+  useKeyPressEvent('Control', undefined, () => {
+    dropdownRef.current?.select?.();
+  });
+
+  useKey(
+    'Tab',
+    (e) => {
+      if (!e.ctrlKey || recentRequestIds.length === 0) return;
+
+      if (!dropdownRef.current?.isOpen) {
+        dropdownRef.current?.open(e.shiftKey ? -1 : 0);
+        return;
+      }
+
+      if (e.shiftKey) dropdownRef.current?.prev?.();
+      else dropdownRef.current?.next?.();
+    },
+    undefined,
+    [recentRequestIds.length],
+  );
+
+  const items = useMemo<DropdownItem[]>(() => {
+    if (activeWorkspaceId === null) return [];
+
+    const recentRequestItems: DropdownItem[] = [];
+    for (const id of recentRequestIds) {
+      const request = requests.find((r) => r.id === id);
+      if (request === undefined) continue;
+
+      recentRequestItems.push({
+        key: request.id,
+        label: request.name,
+        // leftSlot: <CountBadge className="!ml-0 px-0 w-5" count={recentRequestItems.length + 1} />,
+        onSelect: () => {
+          routes.navigate('request', {
+            requestId: request.id,
+            environmentId: activeEnvironmentId ?? undefined,
+            workspaceId: activeWorkspaceId,
+          });
+        },
+      });
+    }
+
+    // No recent requests to show
+    if (recentRequestItems.length === 0) {
+      return [
+        {
+          label: 'No recent requests',
+          disabled: true,
+        },
+      ] as DropdownItem[];
+    }
+
+    return recentRequestItems.slice(0, 20);
+  }, [activeWorkspaceId, activeEnvironmentId, recentRequestIds, requests, routes]);
+
+  return (
+    <Dropdown ref={dropdownRef} items={items}>
+      <Button
+        data-tauri-drag-region
+        size="sm"
+        className={classNames(
+          className,
+          'text-gray-800 text-sm truncate pointer-events-auto',
+          activeRequest === null && 'text-opacity-disabled italic',
+        )}
+      >
+        {activeRequest?.name ?? 'No Request'}
+      </Button>
+    </Dropdown>
+  );
+}
--- a/src-web/components/RecentResponsesDropdown.tsx
+++ b/src-web/components/RecentResponsesDropdown.tsx
@@ -0,0 +1,64 @@
+import { useDeleteResponse } from '../hooks/useDeleteResponse';
+import { useDeleteResponses } from '../hooks/useDeleteResponses';
+import type { HttpResponse } from '../lib/models';
+import { Dropdown } from './core/Dropdown';
+import { pluralize } from '../lib/pluralize';
+import { HStack } from './core/Stacks';
+import { StatusTag } from './core/StatusTag';
+import { Icon } from './core/Icon';
+import { IconButton } from './core/IconButton';
+
+interface Props {
+  responses: HttpResponse[];
+  activeResponse: HttpResponse;
+  onPinnedResponse: (r: HttpResponse) => void;
+}
+
+export const RecentResponsesDropdown = function ResponsePane({
+  activeResponse,
+  responses,
+  onPinnedResponse,
+}: Props) {
+  const deleteResponse = useDeleteResponse(activeResponse?.id ?? null);
+  const deleteAllResponses = useDeleteResponses(activeResponse?.requestId);
+
+  return (
+    <Dropdown
+      items={[
+        {
+          key: 'clear-single',
+          label: 'Clear Response',
+          onSelect: deleteResponse.mutate,
+          disabled: responses.length === 0,
+        },
+        {
+          key: 'clear-all',
+          label: `Clear ${responses.length} ${pluralize('Response', responses.length)}`,
+          onSelect: deleteAllResponses.mutate,
+          hidden: responses.length <= 1,
+          disabled: responses.length === 0,
+        },
+        { type: 'separator', label: 'History' },
+        ...responses.slice(0, 20).map((r) => ({
+          key: r.id,
+          label: (
+            <HStack space={2} alignItems="center">
+              <StatusTag className="text-xs" response={r} />
+              <span>&bull;</span> <span className="font-mono text-xs">{r.elapsed}ms</span>
+            </HStack>
+          ),
+          leftSlot: activeResponse?.id === r.id ? <Icon icon="check" /> : <Icon icon="empty" />,
+          onSelect: () => onPinnedResponse(r),
+        })),
+      ]}
+    >
+      <IconButton
+        title="Show response history"
+        icon="triangleDown"
+        className="ml-auto"
+        size="sm"
+        iconSize="md"
+      />
+    </Dropdown>
+  );
+};
--- a/src-web/components/RequestActionsDropdown.tsx
+++ b/src-web/components/RequestActionsDropdown.tsx
@@ -0,0 +1,56 @@
+import { useRef } from 'react';
+import { useDeleteRequest } from '../hooks/useDeleteRequest';
+import { useDuplicateRequest } from '../hooks/useDuplicateRequest';
+import { useListenToTauriEvent } from '../hooks/useListenToTauriEvent';
+import type { DropdownProps, DropdownRef } from './core/Dropdown';
+import { Dropdown } from './core/Dropdown';
+import { HotKey } from './core/HotKey';
+import { Icon } from './core/Icon';
+
+interface Props {
+  requestId: string | null;
+  children: DropdownProps['children'];
+}
+
+export function RequestActionsDropdown({ requestId, children }: Props) {
+  const deleteRequest = useDeleteRequest(requestId);
+  const duplicateRequest = useDuplicateRequest({ id: requestId, navigateAfter: true });
+  const dropdownRef = useRef<DropdownRef>(null);
+
+  useListenToTauriEvent('toggle_settings', () => {
+    dropdownRef.current?.toggle();
+  });
+
+  // TODO: Put this somewhere better
+  useListenToTauriEvent('duplicate_request', () => {
+    duplicateRequest.mutate();
+  });
+
+  if (requestId == null) {
+    return null;
+  }
+
+  return (
+    <Dropdown
+      ref={dropdownRef}
+      items={[
+        {
+          key: 'duplicate',
+          label: 'Duplicate',
+          onSelect: duplicateRequest.mutate,
+          leftSlot: <Icon icon="copy" />,
+          rightSlot: <HotKey modifier="Meta" keyName="D" />,
+        },
+        {
+          key: 'delete',
+          label: 'Delete',
+          onSelect: deleteRequest.mutate,
+          variant: 'danger',
+          leftSlot: <Icon icon="trash" />,
+        },
+      ]}
+    >
+      {children}
+    </Dropdown>
+  );
+}
--- a/src-web/components/RequestMethodDropdown.tsx
+++ b/src-web/components/RequestMethodDropdown.tsx
@@ -0,0 +1,28 @@
+import { memo } from 'react';
+import { Button } from './core/Button';
+import { RadioDropdown } from './core/RadioDropdown';
+
+type Props = {
+  method: string;
+  className?: string;
+  onChange: (method: string) => void;
+};
+
+const methodItems = ['GET', 'PUT', 'POST', 'PATCH', 'DELETE', 'OPTIONS', 'HEAD'].map((m) => ({
+  value: m,
+  label: m,
+}));
+
+export const RequestMethodDropdown = memo(function RequestMethodDropdown({
+  method,
+  onChange,
+  className,
+}: Props) {
+  return (
+    <RadioDropdown value={method} items={methodItems} onChange={onChange}>
+      <Button size="xs" className={className}>
+        {method.toUpperCase()}
+      </Button>
+    </RadioDropdown>
+  );
+});
--- a/src-web/components/RequestPane.tsx
+++ b/src-web/components/RequestPane.tsx
@@ -1,64 +1,248 @@
-import classnames from 'classnames';
+import { invoke } from '@tauri-apps/api';
+import { appWindow } from '@tauri-apps/api/window';
+import classNames from 'classnames';
+import type { CSSProperties } from 'react';
+import { memo, useCallback, useMemo, useState } from 'react';
+import { createGlobalState } from 'react-use';
+import { useActiveEnvironmentId } from '../hooks/useActiveEnvironmentId';
 import { useActiveRequest } from '../hooks/useActiveRequest';
-import { useSendRequest } from '../hooks/useSendRequest';
+import { useListenToTauriEvent } from '../hooks/useListenToTauriEvent';
+import { useRequestUpdateKey } from '../hooks/useRequestUpdateKey';
 import { useUpdateRequest } from '../hooks/useUpdateRequest';
+import { tryFormatJson } from '../lib/formatters';
+import type { HttpHeader, HttpRequest } from '../lib/models';
+import {
+  AUTH_TYPE_BASIC,
+  AUTH_TYPE_BEARER,
+  AUTH_TYPE_NONE,
+  BODY_TYPE_GRAPHQL,
+  BODY_TYPE_JSON,
+  BODY_TYPE_NONE,
+  BODY_TYPE_XML,
+} from '../lib/models';
+import { BasicAuth } from './BasicAuth';
+import { BearerAuth } from './BearerAuth';
+import { CountBadge } from './core/CountBadge';
 import { Editor } from './core/Editor';
-import { HeaderEditor } from './HeaderEditor';
+import type { TabItem } from './core/Tabs/Tabs';
 import { TabContent, Tabs } from './core/Tabs/Tabs';
+import { EmptyStateText } from './EmptyStateText';
+import { GraphQLEditor } from './GraphQLEditor';
+import { HeaderEditor } from './HeaderEditor';
+import { ParametersEditor } from './ParameterEditor';
 import { UrlBar } from './UrlBar';

 interface Props {
+  style?: CSSProperties;
  fullHeight: boolean;
  className?: string;
 }

-export function RequestPane({ fullHeight, className }: Props) {
-  const activeRequest = useActiveRequest();
-  const updateRequest = useUpdateRequest(activeRequest);
-  const sendRequest = useSendRequest(activeRequest);
+const useActiveTab = createGlobalState<string>('body');

-  if (activeRequest === null) return null;
+export const RequestPane = memo(function RequestPane({ style, fullHeight, className }: Props) {
+  const activeRequest = useActiveRequest();
+  const activeRequestId = activeRequest?.id ?? null;
+  const activeEnvironmentId = useActiveEnvironmentId();
+  const updateRequest = useUpdateRequest(activeRequestId);
+  const [activeTab, setActiveTab] = useActiveTab();
+  const [forceUpdateHeaderEditorKey, setForceUpdateHeaderEditorKey] = useState<number>(0);
+  const { updateKey: forceUpdateKey } = useRequestUpdateKey(activeRequest?.id ?? null);
+
+  const tabs: TabItem[] = useMemo(
+    () =>
+      activeRequest === null
+        ? []
+        : [
+            {
+              value: 'body',
+              options: {
+                value: activeRequest.bodyType,
+                items: [
+                  { label: 'JSON', value: BODY_TYPE_JSON },
+                  { label: 'XML', value: BODY_TYPE_XML },
+                  { label: 'GraphQL', value: BODY_TYPE_GRAPHQL },
+                  { type: 'separator' },
+                  { label: 'No Body', shortLabel: 'Body', value: BODY_TYPE_NONE },
+                ],
+                onChange: async (bodyType) => {
+                  const patch: Partial<HttpRequest> = { bodyType };
+                  if (bodyType === BODY_TYPE_NONE) {
+                    patch.headers = activeRequest?.headers.filter(
+                      (h) => h.name.toLowerCase() !== 'content-type',
+                    );
+                  } else if (bodyType == BODY_TYPE_GRAPHQL || bodyType === BODY_TYPE_JSON) {
+                    patch.method = 'POST';
+                    patch.headers = [
+                      ...(activeRequest?.headers.filter(
+                        (h) => h.name.toLowerCase() !== 'content-type',
+                      ) ?? []),
+                      {
+                        name: 'Content-Type',
+                        value: 'application/json',
+                        enabled: true,
+                      },
+                    ];
+                  }
+
+                  // Force update header editor so any changed headers are reflected
+                  setTimeout(() => setForceUpdateHeaderEditorKey((u) => u + 1), 100);
+
+                  updateRequest.mutate(patch);
+                },
+              },
+            },
+            // { value: 'params', label: 'URL Params' },
+            {
+              value: 'headers',
+              label: (
+                <div className="flex items-center">
+                  Headers
+                  <CountBadge count={activeRequest.headers.filter((h) => h.name).length} />
+                </div>
+              ),
+            },
+            {
+              value: 'auth',
+              label: 'Auth',
+              options: {
+                value: activeRequest.authenticationType,
+                items: [
+                  { label: 'Basic Auth', shortLabel: 'Basic', value: AUTH_TYPE_BASIC },
+                  { label: 'Bearer Token', shortLabel: 'Bearer', value: AUTH_TYPE_BEARER },
+                  { type: 'separator' },
+                  { label: 'No Authentication', shortLabel: 'Auth', value: AUTH_TYPE_NONE },
+                ],
+                onChange: async (authenticationType) => {
+                  let authentication: HttpRequest['authentication'] = activeRequest?.authentication;
+                  if (authenticationType === AUTH_TYPE_BASIC) {
+                    authentication = {
+                      username: authentication.username ?? '',
+                      password: authentication.password ?? '',
+                    };
+                  } else if (authenticationType === AUTH_TYPE_BEARER) {
+                    authentication = {
+                      token: authentication.token ?? '',
+                    };
+                  }
+                  updateRequest.mutate({ authenticationType, authentication });
+                },
+              },
+            },
+          ],
+    [activeRequest, updateRequest],
+  );
+
+  const handleBodyChange = useCallback(
+    (body: string) => updateRequest.mutate({ body }),
+    [updateRequest],
+  );
+  const handleHeadersChange = useCallback(
+    (headers: HttpHeader[]) => updateRequest.mutate({ headers }),
+    [updateRequest],
+  );
+
+  useListenToTauriEvent(
+    'send_request',
+    async ({ windowLabel }) => {
+      if (windowLabel !== appWindow.label) return;
+      await invoke('send_request', {
+        requestId: activeRequestId,
+        environmentId: activeEnvironmentId,
+      });
+    },
+    [activeRequestId, activeEnvironmentId],
+  );

  return (
-    <div className={classnames(className, 'py-2 grid grid-rows-[auto_minmax(0,1fr)] grid-cols-1')}>
-      <div className="pl-2">
-        <UrlBar
-          key={activeRequest.id}
-          method={activeRequest.method}
-          url={activeRequest.url}
-          loading={sendRequest.isLoading}
-          onMethodChange={(method) => updateRequest.mutate({ method })}
-          onUrlChange={(url) => updateRequest.mutate({ url })}
-          sendRequest={sendRequest.mutate}
-        />
-      </div>
-      <Tabs
-        tabs={[
-          { value: 'body', label: 'JSON' },
-          { value: 'params', label: 'Params' },
-          { value: 'headers', label: 'Headers' },
-          { value: 'auth', label: 'Auth' },
-        ]}
-        className="mt-2"
-        tabListClassName="px-2"
-        defaultValue="body"
-        label="Request body"
-      >
-        <TabContent value="headers" className="pl-2">
-          <HeaderEditor key={activeRequest.id} request={activeRequest} />
-        </TabContent>
-        <TabContent value="body">
-          <Editor
-            key={activeRequest.id}
-            className="!bg-gray-50"
-            heightMode={fullHeight ? 'full' : 'auto'}
-            useTemplating
-            defaultValue={activeRequest.body ?? ''}
-            contentType="application/graphql+json"
-            onChange={(body) => updateRequest.mutate({ body })}
-          />
-        </TabContent>
-      </Tabs>
+    <div
+      style={style}
+      className={classNames(className, 'h-full grid grid-rows-[auto_minmax(0,1fr)] grid-cols-1')}
+    >
+      {activeRequest && (
+        <>
+          <UrlBar id={activeRequest.id} url={activeRequest.url} method={activeRequest.method} />
+          <Tabs
+            value={activeTab}
+            label="Request"
+            onChangeValue={setActiveTab}
+            tabs={tabs}
+            tabListClassName="mt-2 !mb-1.5"
+          >
+            <TabContent value="auth">
+              {activeRequest.authenticationType === AUTH_TYPE_BASIC ? (
+                <BasicAuth
+                  key={forceUpdateKey}
+                  requestId={activeRequest.id}
+                  authentication={activeRequest.authentication}
+                />
+              ) : activeRequest.authenticationType === AUTH_TYPE_BEARER ? (
+                <BearerAuth
+                  key={forceUpdateKey}
+                  requestId={activeRequest.id}
+                  authentication={activeRequest.authentication}
+                />
+              ) : (
+                <EmptyStateText>
+                  No Authentication {activeRequest.authenticationType}
+                </EmptyStateText>
+              )}
+            </TabContent>
+            <TabContent value="headers">
+              <HeaderEditor
+                forceUpdateKey={`${forceUpdateHeaderEditorKey}::${forceUpdateKey}`}
+                headers={activeRequest.headers}
+                onChange={handleHeadersChange}
+              />
+            </TabContent>
+            <TabContent value="params">
+              <ParametersEditor
+                forceUpdateKey={forceUpdateKey}
+                parameters={[]}
+                onChange={() => null}
+              />
+            </TabContent>
+            <TabContent value="body">
+              {activeRequest.bodyType === BODY_TYPE_JSON ? (
+                <Editor
+                  forceUpdateKey={forceUpdateKey}
+                  useTemplating
+                  autocompleteVariables
+                  placeholder="..."
+                  className="!bg-gray-50"
+                  heightMode={fullHeight ? 'full' : 'auto'}
+                  defaultValue={activeRequest.body ?? ''}
+                  contentType="application/json"
+                  onChange={handleBodyChange}
+                  format={(v) => tryFormatJson(v)}
+                />
+              ) : activeRequest.bodyType === BODY_TYPE_XML ? (
+                <Editor
+                  forceUpdateKey={forceUpdateKey}
+                  useTemplating
+                  autocompleteVariables
+                  placeholder="..."
+                  className="!bg-gray-50"
+                  heightMode={fullHeight ? 'full' : 'auto'}
+                  defaultValue={activeRequest.body ?? ''}
+                  contentType="text/xml"
+                  onChange={handleBodyChange}
+                />
+              ) : activeRequest.bodyType === BODY_TYPE_GRAPHQL ? (
+                <GraphQLEditor
+                  forceUpdateKey={forceUpdateKey}
+                  baseRequest={activeRequest}
+                  className="!bg-gray-50"
+                  defaultValue={activeRequest?.body ?? ''}
+                  onChange={handleBodyChange}
+                />
+              ) : (
+                <EmptyStateText>No Body</EmptyStateText>
+              )}
+            </TabContent>
+          </Tabs>
+        </>
+      )}
    </div>
  );
-}
+});
--- a/src-web/components/RequestResponse.tsx
+++ b/src-web/components/RequestResponse.tsx
@@ -0,0 +1,132 @@
+import useResizeObserver from '@react-hook/resize-observer';
+import classNames from 'classnames';
+import type { CSSProperties, MouseEvent as ReactMouseEvent } from 'react';
+import React, { memo, useCallback, useMemo, useRef, useState } from 'react';
+import { useLocalStorage } from 'react-use';
+import { useActiveWorkspaceId } from '../hooks/useActiveWorkspaceId';
+import { clamp } from '../lib/clamp';
+import { RequestPane } from './RequestPane';
+import { ResizeHandle } from './ResizeHandle';
+import { ResponsePane } from './ResponsePane';
+
+interface Props {
+  style: CSSProperties;
+}
+
+const rqst = { gridArea: 'rqst' };
+const resp = { gridArea: 'resp' };
+const drag = { gridArea: 'drag' };
+
+const DEFAULT = 0.5;
+const MIN_WIDTH_PX = 10;
+const MIN_HEIGHT_PX = 30;
+const STACK_VERTICAL_WIDTH = 650;
+
+export const RequestResponse = memo(function RequestResponse({ style }: Props) {
+  const containerRef = useRef<HTMLDivElement>(null);
+  const [vertical, setVertical] = useState<boolean>(false);
+  const [widthRaw, setWidth] = useLocalStorage<number>(`body_width::${useActiveWorkspaceId()}`);
+  const [heightRaw, setHeight] = useLocalStorage<number>(`body_height::${useActiveWorkspaceId()}`);
+  const width = widthRaw ?? DEFAULT;
+  const height = heightRaw ?? DEFAULT;
+  const [isResizing, setIsResizing] = useState<boolean>(false);
+  const moveState = useRef<{ move: (e: MouseEvent) => void; up: (e: MouseEvent) => void } | null>(
+    null,
+  );
+
+  useResizeObserver(containerRef, ({ contentRect }) => {
+    setVertical(contentRect.width < STACK_VERTICAL_WIDTH);
+  });
+
+  const styles = useMemo<CSSProperties>(
+    () => ({
+      ...style,
+      gridTemplate: vertical
+        ? `
+          ' ${rqst.gridArea}' minmax(0,${1 - height}fr)
+          ' ${drag.gridArea}' 0
+          ' ${resp.gridArea}' minmax(0,${height}fr)
+          / 1fr            
+        `
+        : `
+          ' ${rqst.gridArea} ${drag.gridArea} ${resp.gridArea}' minmax(0,1fr)
+          / ${1 - width}fr   0                ${width}fr           
+        `,
+    }),
+    [vertical, width, height, style],
+  );
+
+  const unsub = () => {
+    if (moveState.current !== null) {
+      document.documentElement.removeEventListener('mousemove', moveState.current.move);
+      document.documentElement.removeEventListener('mouseup', moveState.current.up);
+    }
+  };
+
+  const handleReset = useCallback(
+    () => (vertical ? setHeight(DEFAULT) : setWidth(DEFAULT)),
+    [setHeight, vertical, setWidth],
+  );
+
+  const handleResizeStart = useCallback(
+    (e: ReactMouseEvent<HTMLDivElement>) => {
+      if (containerRef.current === null) return;
+      unsub();
+
+      const containerRect = containerRef.current.getBoundingClientRect();
+
+      const mouseStartX = e.clientX;
+      const mouseStartY = e.clientY;
+      const startWidth = containerRect.width * width;
+      const startHeight = containerRect.height * height;
+
+      moveState.current = {
+        move: (e: MouseEvent) => {
+          e.preventDefault(); // Prevent text selection and things
+          if (vertical) {
+            const maxHeightPx = containerRect.height - MIN_HEIGHT_PX;
+            const newHeightPx = clamp(
+              startHeight - (e.clientY - mouseStartY),
+              MIN_HEIGHT_PX,
+              maxHeightPx,
+            );
+            setHeight(newHeightPx / containerRect.height);
+          } else {
+            const maxWidthPx = containerRect.width - MIN_WIDTH_PX;
+            const newWidthPx = clamp(
+              startWidth - (e.clientX - mouseStartX),
+              MIN_WIDTH_PX,
+              maxWidthPx,
+            );
+            setWidth(newWidthPx / containerRect.width);
+          }
+        },
+        up: (e: MouseEvent) => {
+          e.preventDefault();
+          unsub();
+          setIsResizing(false);
+        },
+      };
+      document.documentElement.addEventListener('mousemove', moveState.current.move);
+      document.documentElement.addEventListener('mouseup', moveState.current.up);
+      setIsResizing(true);
+    },
+    [width, height, vertical, setHeight, setWidth],
+  );
+
+  return (
+    <div ref={containerRef} className="grid gap-1.5 w-full h-full p-3" style={styles}>
+      <RequestPane style={rqst} fullHeight={!vertical} />
+      <ResizeHandle
+        style={drag}
+        isResizing={isResizing}
+        className={classNames(vertical ? 'translate-y-0.5' : 'translate-x-0.5')}
+        onResizeStart={handleResizeStart}
+        onReset={handleReset}
+        side={vertical ? 'top' : 'left'}
+        justify="center"
+      />
+      <ResponsePane style={resp} />
+    </div>
+  );
+});
--- a/src-web/components/ResizeHandle.tsx
+++ b/src-web/components/ResizeHandle.tsx
@@ -0,0 +1,57 @@
+import classNames from 'classnames';
+import type { CSSProperties, MouseEvent as ReactMouseEvent } from 'react';
+import React from 'react';
+
+interface ResizeBarProps {
+  style?: CSSProperties;
+  className?: string;
+  barClassName?: string;
+  isResizing: boolean;
+  onResizeStart: (e: ReactMouseEvent<HTMLDivElement>) => void;
+  onReset?: () => void;
+  side: 'left' | 'right' | 'top';
+  justify: 'center' | 'end' | 'start';
+}
+
+export function ResizeHandle({
+  style,
+  justify,
+  className,
+  onResizeStart,
+  onReset,
+  isResizing,
+  side,
+}: ResizeBarProps) {
+  const vertical = side === 'top';
+  return (
+    <div
+      aria-hidden
+      draggable
+      style={style}
+      className={classNames(
+        className,
+        'group z-10 flex',
+        vertical ? 'w-full h-3 cursor-row-resize' : 'h-full w-3 cursor-col-resize',
+        justify === 'center' && 'justify-center',
+        justify === 'end' && 'justify-end',
+        justify === 'start' && 'justify-start',
+        side === 'right' && 'right-0',
+        side === 'left' && 'left-0',
+        side === 'top' && 'top-0',
+      )}
+      onDragStart={onResizeStart}
+      onDoubleClick={onReset}
+    >
+      {/* Show global overlay with cursor style to ensure cursor remains the same when moving quickly */}
+      {isResizing && (
+        <div
+          className={classNames(
+            'fixed -left-20 -right-20 -top-20 -bottom-20',
+            vertical && 'cursor-row-resize',
+            !vertical && 'cursor-col-resize',
+          )}
+        />
+      )}
+    </div>
+  );
+}
--- a/src-web/components/ResponseHeaders.tsx
+++ b/src-web/components/ResponseHeaders.tsx
@@ -0,0 +1,26 @@
+import classNames from 'classnames';
+import type { HttpResponse } from '../lib/models';
+import { HStack } from './core/Stacks';
+
+interface Props {
+  headers: HttpResponse['headers'];
+}
+
+export function ResponseHeaders({ headers }: Props) {
+  return (
+    <dl className="text-xs w-full h-full font-mono overflow-auto">
+      {headers.map((h, i) => {
+        return (
+          <HStack
+            space={3}
+            key={i}
+            className={classNames(i > 0 ? 'border-t border-highlightSecondary py-1' : 'pb-1')}
+          >
+            <dd className="w-1/3 text-violet-600 select-text cursor-text">{h.name}</dd>
+            <dt className="w-2/3 select-text cursor-text break-all">{h.value}</dt>
+          </HStack>
+        );
+      })}
+    </dl>
+  );
+}
--- a/src-web/components/ResponsePane.tsx
+++ b/src-web/components/ResponsePane.tsx
@@ -1,131 +1,163 @@
-import classnames from 'classnames';
-import { memo, useEffect, useMemo, useState } from 'react';
-import { useDeleteResponses } from '../hooks/useDeleteResponses';
-import { useDeleteResponse } from '../hooks/useResponseDelete';
+import classNames from 'classnames';
+import type { CSSProperties } from 'react';
+import { useCallback, memo, useEffect, useMemo, useState } from 'react';
+import { createGlobalState } from 'react-use';
+import { useActiveRequestId } from '../hooks/useActiveRequestId';
+import { useLatestResponse } from '../hooks/useLatestResponse';
+import { useResponseContentType } from '../hooks/useResponseContentType';
 import { useResponses } from '../hooks/useResponses';
-import { tryFormatJson } from '../lib/formatters';
+import { useResponseViewMode } from '../hooks/useResponseViewMode';
 import type { HttpResponse } from '../lib/models';
-import { Dropdown } from './core/Dropdown';
-import { Editor } from './core/Editor';
-import { Icon } from './core/Icon';
-import { IconButton } from './core/IconButton';
+import { isResponseLoading } from '../lib/models';
+import { Banner } from './core/Banner';
+import { CountBadge } from './core/CountBadge';
+import { DurationTag } from './core/DurationTag';
+import { SizeTag } from './core/SizeTag';
 import { HStack } from './core/Stacks';
-import { StatusColor } from './core/StatusColor';
-import { Webview } from './core/Webview';
+import { StatusTag } from './core/StatusTag';
+import type { TabItem } from './core/Tabs/Tabs';
+import { TabContent, Tabs } from './core/Tabs/Tabs';
+import { EmptyStateText } from './EmptyStateText';
+import { ResponseHeaders } from './ResponseHeaders';
+import { CsvViewer } from './responseViewers/CsvViewer';
+import { ImageViewer } from './responseViewers/ImageViewer';
+import { TextViewer } from './responseViewers/TextViewer';
+import { WebPageViewer } from './responseViewers/WebPageViewer';
+import { RecentResponsesDropdown } from './RecentResponsesDropdown';

 interface Props {
+  style?: CSSProperties;
  className?: string;
 }

-export const ResponsePane = memo(function ResponsePane({ className }: Props) {
-  const [activeResponseId, setActiveResponseId] = useState<string | null>(null);
-  const [viewMode, setViewMode] = useState<'pretty' | 'raw'>('pretty');
-  const responses = useResponses();
-  const activeResponse: HttpResponse | null = activeResponseId
-    ? responses.find((r) => r.id === activeResponseId) ?? null
-    : responses[responses.length - 1] ?? null;
-  const deleteResponse = useDeleteResponse(activeResponse);
-  const deleteAllResponses = useDeleteResponses(activeResponse?.requestId);
+const useActiveTab = createGlobalState<string>('body');

-  useEffect(() => {
-    setActiveResponseId(null);
-  }, [responses.length]);
+export const ResponsePane = memo(function ResponsePane({ style, className }: Props) {
+  const [pinnedResponseId, setPinnedResponseId] = useState<string | null>(null);
+  const activeRequestId = useActiveRequestId();
+  const latestResponse = useLatestResponse(activeRequestId);
+  const responses = useResponses(activeRequestId);
+  const activeResponse: HttpResponse | null = pinnedResponseId
+    ? responses.find((r) => r.id === pinnedResponseId) ?? null
+    : latestResponse ?? null;
+  const [viewMode, setViewMode] = useResponseViewMode(activeResponse?.requestId);
+  const [activeTab, setActiveTab] = useActiveTab();

-  const contentType = useMemo(
-    () =>
-      activeResponse?.headers.find((h) => h.name.toLowerCase() === 'content-type')?.value ??
-      'text/plain',
-    [activeResponse],
+  // Unset pinned response when a new one comes in
+  useEffect(() => setPinnedResponseId(null), [responses.length]);
+
+  const contentType = useResponseContentType(activeResponse);
+
+  const handlePinnedResponse = useCallback((r: HttpResponse) => {
+    setPinnedResponseId(r.id);
+  }, [setPinnedResponseId])
+
+  const tabs: TabItem[] = useMemo(
+    () => [
+      {
+        value: 'body',
+        label: 'Preview',
+        options: {
+          value: viewMode,
+          onChange: setViewMode,
+          items: [
+            { label: 'Pretty', value: 'pretty' },
+            { label: 'Raw', value: 'raw' },
+          ],
+        },
+      },
+      {
+        label: (
+          <div className="flex items-center">
+            Headers
+            <CountBadge
+              count={activeResponse?.headers.filter((h) => h.name && h.value).length ?? 0}
+            />
+          </div>
+        ),
+        value: 'headers',
+      },
+    ],
+    [activeResponse?.headers, setViewMode, viewMode],
  );

-  if (activeResponse === null) {
-    return null;
-  }
-
  return (
-    <div className="p-2">
-      <div
-        className={classnames(
-          className,
-          'max-h-full h-full grid grid-rows-[auto_minmax(0,1fr)] grid-cols-1 ',
-          'dark:bg-gray-100 rounded-md overflow-hidden border border-gray-200',
-          'shadow shadow-gray-100 dark:shadow-gray-0',
-        )}
-      >
-        {/*<HStack as={WindowDragRegion} items="center" className="pl-1.5 pr-1">*/}
-        {/*</HStack>*/}
-        <HStack
-          alignItems="center"
-          className="italic text-gray-700 text-sm w-full mb-1 flex-shrink-0 pl-2"
-        >
-          {activeResponse && activeResponse.status > 0 && (
-            <div className="whitespace-nowrap">
-              <StatusColor statusCode={activeResponse.status}>
-                {activeResponse.status}
-                {activeResponse.statusReason && ` ${activeResponse.statusReason}`}
-              </StatusColor>
-              &nbsp;&bull;&nbsp;
-              {activeResponse.elapsed}ms &nbsp;&bull;&nbsp;
-              {Math.round(activeResponse.body.length / 1000)} KB
-            </div>
-          )}
+    <div
+      style={style}
+      className={classNames(
+        className,
+        'bg-gray-50 max-h-full h-full grid grid-rows-[auto_minmax(0,1fr)] grid-cols-1',
+        'dark:bg-gray-100 rounded-md border border-highlight',
+        'shadow shadow-gray-100 dark:shadow-gray-0 relative',
+      )}
+    >
+      {activeResponse?.error && <Banner className="m-2">{activeResponse.error}</Banner>}
+      {activeResponse && !activeResponse.error && !isResponseLoading(activeResponse) && (
+        <>
+          <HStack
+            alignItems="center"
+            className={classNames(
+              'text-gray-700 text-sm w-full flex-shrink-0',
+              // Remove a bit of space because the tabs have lots too
+              '-mb-1.5',
+            )}
+          >
+            {activeResponse && (
+              <HStack alignItems="center" className="w-full">
+                <div className="whitespace-nowrap px-3">
+                  <HStack space={2}>
+                    <StatusTag showReason response={activeResponse} />
+                    {activeResponse.elapsed > 0 && (
+                      <>
+                        <span>&bull;</span>
+                        <DurationTag millis={activeResponse.elapsed} />
+                      </>
+                    )}
+                    {!!activeResponse.contentLength && (
+                      <>
+                        <span>&bull;</span>
+                        <SizeTag contentLength={activeResponse.contentLength} />
+                      </>
+                    )}
+                  </HStack>
+                </div>

-          <HStack alignItems="center" className="ml-auto h-8">
-            <IconButton
-              icon={viewMode === 'pretty' ? 'eye' : 'code'}
-              size="sm"
-              className="ml-1"
-              onClick={() => setViewMode((m) => (m === 'pretty' ? 'raw' : 'pretty'))}
-            />
-            <Dropdown
-              items={[
-                {
-                  label: 'Clear Response',
-                  onSelect: deleteResponse.mutate,
-                  disabled: responses.length === 0,
-                },
-                {
-                  label: 'Clear All Responses',
-                  onSelect: deleteAllResponses.mutate,
-                  disabled: responses.length === 0,
-                },
-                '-----',
-                ...responses.slice(0, 10).map((r) => ({
-                  label: r.status + ' - ' + r.elapsed + ' ms',
-                  leftSlot: activeResponse?.id === r.id ? <Icon icon="check" /> : <></>,
-                  onSelect: () => setActiveResponseId(r.id),
-                })),
-              ]}
-            >
-              <IconButton icon="clock" className="ml-auto" size="sm" />
-            </Dropdown>
+                <RecentResponsesDropdown
+                  responses={responses}
+                  activeResponse={activeResponse}
+                  onPinnedResponse={handlePinnedResponse}
+                />
+              </HStack>
+            )}
          </HStack>
-        </HStack>

-        {activeResponse?.error ? (
-          <div className="p-1">
-            <div className="text-white bg-red-500 px-3 py-2 rounded">{activeResponse.error}</div>
-          </div>
-        ) : viewMode === 'pretty' && contentType.includes('html') ? (
-          <Webview body={activeResponse.body} contentType={contentType} url={activeResponse.url} />
-        ) : viewMode === 'pretty' && contentType.includes('json') ? (
-          <Editor
-            readOnly
-            key={`${contentType}:${activeResponse.updatedAt}:pretty`}
-            className="bg-gray-50 dark:!bg-gray-100"
-            defaultValue={tryFormatJson(activeResponse?.body)}
-            contentType={contentType}
-          />
-        ) : activeResponse?.body ? (
-          <Editor
-            readOnly
-            key={`${contentType}:${activeResponse.updatedAt}`}
-            className="bg-gray-50 dark:!bg-gray-100"
-            defaultValue={activeResponse?.body}
-            contentType={contentType}
-          />
-        ) : null}
-      </div>
+          <Tabs
+            value={activeTab}
+            onChangeValue={setActiveTab}
+            label="Response"
+            tabs={tabs}
+            className="ml-3 mr-1"
+            tabListClassName="mt-1.5"
+          >
+            <TabContent value="headers">
+              <ResponseHeaders headers={activeResponse?.headers ?? []} />
+            </TabContent>
+            <TabContent value="body">
+              {!activeResponse.contentLength ? (
+                <EmptyStateText>Empty Body</EmptyStateText>
+              ) : viewMode === 'pretty' && contentType?.includes('html') ? (
+                <WebPageViewer response={activeResponse} />
+              ) : contentType?.startsWith('image') ? (
+                <ImageViewer className="pb-2" response={activeResponse} />
+              ) : contentType?.match(/csv|tab-separated/) ? (
+                <CsvViewer className="pb-2" response={activeResponse} />
+              ) : (
+                <TextViewer response={activeResponse} pretty={viewMode === 'pretty'} />
+              )}
+            </TabContent>
+          </Tabs>
+        </>
+      )}
    </div>
  );
 });
--- a/src-web/components/RouteError.tsx
+++ b/src-web/components/RouteError.tsx
@@ -1,22 +1,35 @@
 import { useRouteError } from 'react-router-dom';
+import { useAppRoutes } from '../hooks/useAppRoutes';
 import { Button } from './core/Button';
+import { FormattedError } from './core/FormattedError';
 import { Heading } from './core/Heading';
 import { VStack } from './core/Stacks';

 export default function RouteError() {
  const error = useRouteError();
+  console.log("Error", error);
  const stringified = JSON.stringify(error);
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  const message = (error as any).message ?? stringified;
+  const routes = useAppRoutes();
  return (
    <div className="flex items-center justify-center h-full">
-      <VStack space={5} className="max-w-[30rem] !h-auto">
+      <VStack space={5} className="max-w-[50rem] !h-auto">
        <Heading>Route Error 🔥</Heading>
-        <pre className="text-sm select-auto cursor-text bg-gray-100 p-3 rounded whitespace-normal">
-          {message}
-        </pre>
-        <Button to="/" color="primary">
-          Go Home
-        </Button>
+        <FormattedError>{message}</FormattedError>
+        <VStack space={2}>
+          <Button
+            color="primary"
+            onClick={() => {
+              routes.navigate('workspaces');
+            }}
+          >
+            Go Home
+          </Button>
+          <Button color="secondary" onClick={() => window.location.reload()}>
+            Refresh
+          </Button>
+        </VStack>
      </VStack>
    </div>
  );
--- a/src-web/components/Sidebar.tsx
+++ b/src-web/components/Sidebar.tsx
@@ -1,118 +1,741 @@
-import classnames from 'classnames';
-import { useState } from 'react';
-import { useActiveRequest } from '../hooks/useActiveRequest';
+import classNames from 'classnames';
+import type { ForwardedRef, ReactNode } from 'react';
+import React, { forwardRef, Fragment, useCallback, useMemo, useRef, useState } from 'react';
+import type { XYCoord } from 'react-dnd';
+import { useDrag, useDrop } from 'react-dnd';
+import { useKey, useKeyPressEvent } from 'react-use';
+import { useActiveEnvironmentId } from '../hooks/useActiveEnvironmentId';
+import { useActiveRequestId } from '../hooks/useActiveRequestId';
+import { useActiveWorkspace } from '../hooks/useActiveWorkspace';
+import { useAppRoutes } from '../hooks/useAppRoutes';
+import { useCreateFolder } from '../hooks/useCreateFolder';
 import { useCreateRequest } from '../hooks/useCreateRequest';
-import { useDeleteRequest } from '../hooks/useDeleteRequest';
+import { useDeleteAnyRequest } from '../hooks/useDeleteAnyRequest';
+import { useDeleteFolder } from '../hooks/useDeleteFolder';
+import { useFolders } from '../hooks/useFolders';
+import { useKeyValue } from '../hooks/useKeyValue';
+import { useLatestResponse } from '../hooks/useLatestResponse';
+import { useListenToTauriEvent } from '../hooks/useListenToTauriEvent';
+import { usePrompt } from '../hooks/usePrompt';
 import { useRequests } from '../hooks/useRequests';
-import { useTheme } from '../hooks/useTheme';
+import { useSendAnyRequest } from '../hooks/useSendAnyRequest';
+import { useSidebarHidden } from '../hooks/useSidebarHidden';
+import { useUpdateAnyFolder } from '../hooks/useUpdateAnyFolder';
+import { useUpdateAnyRequest } from '../hooks/useUpdateAnyRequest';
 import { useUpdateRequest } from '../hooks/useUpdateRequest';
-import type { HttpRequest } from '../lib/models';
-import { Button } from './core/Button';
+import { NAMESPACE_NO_SYNC } from '../lib/keyValueStore';
+import type { Folder, HttpRequest, Workspace } from '../lib/models';
+import { isResponseLoading } from '../lib/models';
+import { Dropdown } from './core/Dropdown';
+import { Icon } from './core/Icon';
 import { IconButton } from './core/IconButton';
-import { HStack, VStack } from './core/Stacks';
-import { WindowDragRegion } from './core/WindowDragRegion';
+import { InlineCode } from './core/InlineCode';
+import { VStack } from './core/Stacks';
+import { StatusTag } from './core/StatusTag';
+import { DropMarker } from './DropMarker';

 interface Props {
  className?: string;
 }

+enum ItemTypes {
+  REQUEST = 'request',
+}
+
+interface TreeNode {
+  item: Workspace | Folder | HttpRequest;
+  children: TreeNode[];
+  depth: number;
+}
+
 export function Sidebar({ className }: Props) {
+  const { hidden } = useSidebarHidden();
+  const createRequest = useCreateRequest();
+  const sidebarRef = useRef<HTMLLIElement>(null);
+  const activeRequestId = useActiveRequestId();
+  const activeEnvironmentId = useActiveEnvironmentId();
  const requests = useRequests();
-  const activeRequest = useActiveRequest();
-  const deleteRequest = useDeleteRequest(activeRequest);
-  const createRequest = useCreateRequest({ navigateAfter: true });
-  const { appearance, toggleAppearance } = useTheme();
+  const folders = useFolders();
+  const deleteAnyRequest = useDeleteAnyRequest();
+  const activeWorkspace = useActiveWorkspace();
+  const routes = useAppRoutes();
+  const [hasFocus, setHasFocus] = useState<boolean>(false);
+  const [selectedId, setSelectedId] = useState<string | null>(null);
+  const [selectedTree, setSelectedTree] = useState<TreeNode | null>(null);
+  const updateAnyRequest = useUpdateAnyRequest();
+  const updateAnyFolder = useUpdateAnyFolder();
+  const [draggingId, setDraggingId] = useState<string | null>(null);
+  const [hoveredTree, setHoveredTree] = useState<TreeNode | null>(null);
+  const [hoveredIndex, setHoveredIndex] = useState<number | null>(null);
+  const collapsed = useKeyValue<Record<string, boolean>>({
+    key: ['sidebar_collapsed', activeWorkspace?.id ?? 'n/a'],
+    defaultValue: {},
+    namespace: NAMESPACE_NO_SYNC,
+  });
+
+  const { tree, treeParentMap, selectableRequests } = useMemo<{
+    tree: TreeNode | null;
+    treeParentMap: Record<string, TreeNode>;
+    selectableRequests: { id: string; index: number; tree: TreeNode }[];
+  }>(() => {
+    const treeParentMap: Record<string, TreeNode> = {};
+    const selectableRequests: { id: string; index: number; tree: TreeNode }[] = [];
+    if (activeWorkspace == null) {
+      return { tree: null, treeParentMap, selectableRequests };
+    }
+
+    let selectableRequestIndex = 0;
+
+    // Put requests and folders into a tree structure
+    const next = (node: TreeNode): TreeNode => {
+      const childItems = [...requests, ...folders].filter((f) =>
+        node.item.model === 'workspace' ? f.folderId == null : f.folderId === node.item.id,
+      );
+
+      childItems.sort((a, b) => a.sortPriority - b.sortPriority);
+      const depth = node.depth + 1;
+      for (const item of childItems) {
+        treeParentMap[item.id] = node;
+        node.children.push(next({ item, children: [], depth }));
+        if (item.model === 'http_request') {
+          selectableRequests.push({ id: item.id, index: selectableRequestIndex++, tree: node });
+        }
+      }
+      return node;
+    };
+
+    const tree = next({ item: activeWorkspace, children: [], depth: 0 });
+
+    return { tree, treeParentMap, selectableRequests };
+  }, [activeWorkspace, requests, folders]);
+
+  // TODO: Move these listeners to a central place
+  useListenToTauriEvent('new_request', async () => createRequest.mutate({}));
+
+  const focusActiveRequest = useCallback(
+    (args: { forced?: { id: string; tree: TreeNode }; noFocusSidebar?: boolean } = {}) => {
+      const { forced, noFocusSidebar } = args;
+      const tree = forced?.tree ?? treeParentMap[activeRequestId ?? 'n/a'] ?? null;
+      const children = tree?.children ?? [];
+      const id = forced?.id ?? children.find((m) => m.item.id === activeRequestId)?.item.id ?? null;
+      if (id == null) {
+        return;
+      }
+
+      setSelectedId(id);
+      setSelectedTree(tree);
+      setHasFocus(true);
+      if (!noFocusSidebar) {
+        sidebarRef.current?.focus();
+      }
+    },
+    [activeRequestId, treeParentMap],
+  );
+
+  const handleSelect = useCallback(
+    (id: string) => {
+      const tree = treeParentMap[id ?? 'n/a'] ?? null;
+      const children = tree?.children ?? [];
+      const node = children.find((m) => m.item.id === id) ?? null;
+      if (node == null || tree == null || node.item.model === 'workspace') {
+        return;
+      }
+
+      const { item } = node;
+
+      if (item.model === 'folder') {
+        collapsed.set((c) => ({ ...c, [item.id]: !c[item.id] }));
+      } else {
+        routes.navigate('request', {
+          requestId: id,
+          workspaceId: item.workspaceId,
+          environmentId: activeEnvironmentId ?? undefined,
+        });
+        setSelectedId(id);
+        setSelectedTree(tree);
+        focusActiveRequest({ forced: { id, tree } });
+      }
+    },
+    [treeParentMap, collapsed, routes, activeEnvironmentId, focusActiveRequest],
+  );
+
+  const handleClearSelected = useCallback(() => {
+    setSelectedId(null);
+    setSelectedTree(null);
+  }, []);
+
+  const handleFocus = useCallback(() => {
+    if (hasFocus) return;
+    focusActiveRequest({ noFocusSidebar: true });
+  }, [focusActiveRequest, hasFocus]);
+
+  const handleBlur = useCallback(() => setHasFocus(false), []);
+
+  const handleDeleteKey = useCallback(
+    (e: KeyboardEvent) => {
+      if (!hasFocus) return;
+      e.preventDefault();
+
+      const selected = selectableRequests.find((r) => r.id === selectedId);
+      if (selected == null) return;
+      deleteAnyRequest.mutate(selected.id);
+    },
+    [deleteAnyRequest, hasFocus, selectableRequests, selectedId],
+  );
+
+  useKeyPressEvent('Backspace', handleDeleteKey);
+  useKeyPressEvent('Delete', handleDeleteKey);
+
+  useListenToTauriEvent(
+    'focus_sidebar',
+    () => {
+      if (hidden || hasFocus) return;
+      // Select 0 index on focus if none selected
+      focusActiveRequest(
+        selectedTree != null && selectedId != null
+          ? { forced: { id: selectedId, tree: selectedTree } }
+          : undefined,
+      );
+    },
+    [focusActiveRequest, hidden, activeRequestId],
+  );
+
+  useKeyPressEvent('Enter', (e) => {
+    if (!hasFocus) return;
+    const selected = selectableRequests.find((r) => r.id === selectedId);
+    if (!selected || selected.id === activeRequestId || activeWorkspace == null) {
+      return;
+    }
+
+    e.preventDefault();
+    routes.navigate('request', {
+      requestId: selected.id,
+      workspaceId: activeWorkspace?.id,
+      environmentId: activeEnvironmentId ?? undefined,
+    });
+  });
+
+  useKey(
+    'ArrowUp',
+    () => {
+      if (!hasFocus) return;
+      const i = selectableRequests.findIndex((r) => r.id === selectedId);
+      const newSelectable = selectableRequests[i - 1];
+      if (newSelectable == null) {
+        return;
+      }
+
+      setSelectedId(newSelectable.id);
+      setSelectedTree(newSelectable.tree);
+    },
+    undefined,
+    [hasFocus, selectableRequests, selectedId, setSelectedId, setSelectedTree],
+  );
+
+  useKey(
+    'ArrowDown',
+    () => {
+      if (!hasFocus) return;
+      const i = selectableRequests.findIndex((r) => r.id === selectedId);
+      const newSelectable = selectableRequests[i + 1];
+      if (newSelectable == null) {
+        return;
+      }
+
+      setSelectedId(newSelectable.id);
+      setSelectedTree(newSelectable.tree);
+    },
+    undefined,
+    [hasFocus, selectableRequests, selectedId, setSelectedId, setSelectedTree],
+  );
+
+  const handleMove = useCallback<DraggableSidebarItemProps['onMove']>(
+    (id, side) => {
+      const hoveredTree = treeParentMap[id] ?? null;
+      const dragIndex = hoveredTree?.children.findIndex((n) => n.item.id === id) ?? -99;
+      const hoveredIndex = dragIndex + (side === 'above' ? 0 : 1);
+      setHoveredTree(hoveredTree);
+      setHoveredIndex(hoveredIndex);
+    },
+    [treeParentMap],
+  );
+
+  const handleDragStart = useCallback<DraggableSidebarItemProps['onDragStart']>((id: string) => {
+    setDraggingId(id);
+  }, []);
+
+  const handleEnd = useCallback<DraggableSidebarItemProps['onEnd']>(
+    async (itemId) => {
+      setHoveredTree(null);
+      handleClearSelected();
+
+      if (hoveredTree == null || hoveredIndex == null) {
+        return;
+      }
+
+      const parentTree = treeParentMap[itemId] ?? null;
+      const index = parentTree?.children.findIndex((n) => n.item.id === itemId) ?? -1;
+      const child = parentTree?.children[index ?? -1];
+      if (child == null || parentTree == null) return;
+
+      const movedToDifferentTree = hoveredTree.item.id !== parentTree.item.id;
+      const movedUpInSameTree = !movedToDifferentTree && hoveredIndex < index;
+
+      const newChildren = hoveredTree.children.filter((c) => c.item.id !== itemId);
+      if (movedToDifferentTree || movedUpInSameTree) {
+        // Moving up or into a new tree is simply inserting before the hovered item
+        newChildren.splice(hoveredIndex, 0, child);
+      } else {
+        // Moving down has to account for the fact that the original item will be removed
+        newChildren.splice(hoveredIndex - 1, 0, child);
+      }
+
+      const prev = newChildren[hoveredIndex - 1]?.item;
+      const next = newChildren[hoveredIndex + 1]?.item;
+      const beforePriority = prev == null || prev.model === 'workspace' ? 0 : prev.sortPriority;
+      const afterPriority = next == null || next.model === 'workspace' ? 0 : next.sortPriority;
+
+      const folderId = hoveredTree.item.model === 'folder' ? hoveredTree.item.id : null;
+      const shouldUpdateAll = afterPriority - beforePriority < 1;
+
+      if (shouldUpdateAll) {
+        await Promise.all(
+          newChildren.map((child, i) => {
+            const sortPriority = i * 1000;
+            if (child.item.model === 'folder') {
+              const updateFolder = (f: Folder) => ({ ...f, sortPriority, folderId });
+              return updateAnyFolder.mutateAsync({ id: child.item.id, update: updateFolder });
+            } else if (child.item.model === 'http_request') {
+              const updateRequest = (r: HttpRequest) => ({ ...r, sortPriority, folderId });
+              return updateAnyRequest.mutateAsync({ id: child.item.id, update: updateRequest });
+            }
+          }),
+        );
+      } else {
+        const sortPriority = afterPriority - (afterPriority - beforePriority) / 2;
+        if (child.item.model === 'folder') {
+          const updateFolder = (f: Folder) => ({ ...f, sortPriority, folderId });
+          await updateAnyFolder.mutateAsync({ id: child.item.id, update: updateFolder });
+        } else if (child.item.model === 'http_request') {
+          const updateRequest = (r: HttpRequest) => ({ ...r, sortPriority, folderId });
+          await updateAnyRequest.mutateAsync({ id: child.item.id, update: updateRequest });
+        }
+      }
+      setDraggingId(null);
+    },
+    [
+      hoveredIndex,
+      hoveredTree,
+      handleClearSelected,
+      treeParentMap,
+      updateAnyFolder,
+      updateAnyRequest,
+    ],
+  );
+
+  if (tree == null) {
+    return null;
+  }
+
+  if (collapsed.value == null) {
+    return null;
+  }
+
  return (
-    <div
-      className={classnames(
+    <aside
+      aria-hidden={hidden}
+      ref={sidebarRef}
+      onFocus={handleFocus}
+      onBlur={handleBlur}
+      tabIndex={hidden ? -1 : 0}
+      className={classNames(
        className,
-        'w-[15rem] bg-gray-100 h-full border-r border-gray-200 relative grid grid-rows-[auto,1fr]',
+        'h-full pb-3 overflow-y-scroll overflow-x-visible hide-scrollbars pt-2',
      )}
    >
-      <HStack as={WindowDragRegion} alignItems="center" justifyContent="end">
-        <IconButton
-          className="mx-1"
-          icon="plusCircle"
-          onClick={async () => {
-            await createRequest.mutate({ name: 'Test Request' });
-          }}
-        />
-      </HStack>
-      <VStack as="ul" className="py-3 px-2 overflow-auto h-full" space={1}>
-        {requests.map((r) => (
-          <SidebarItem key={r.id} request={r} active={r.id === activeRequest?.id} />
-        ))}
-        {/*<Colors />*/}
-
-        <HStack
-          className="absolute bottom-1 left-1 right-0 mx-1"
-          alignItems="center"
-          justifyContent="end"
-        >
-          <IconButton icon="trash" onClick={() => deleteRequest.mutate()} />
-          <IconButton icon={appearance === 'dark' ? 'moon' : 'sun'} onClick={toggleAppearance} />
-        </HStack>
-      </VStack>
-    </div>
+      <SidebarItems
+        treeParentMap={treeParentMap}
+        selectedId={selectedId}
+        selectedTree={selectedTree}
+        collapsed={collapsed.value}
+        tree={tree}
+        focused={hasFocus}
+        draggingId={draggingId}
+        onSelect={handleSelect}
+        hoveredIndex={hoveredIndex}
+        hoveredTree={hoveredTree}
+        handleMove={handleMove}
+        handleEnd={handleEnd}
+        handleDragStart={handleDragStart}
+      />
+    </aside>
  );
 }

-function SidebarItem({ request, active }: { request: HttpRequest; active: boolean }) {
-  const updateRequest = useUpdateRequest(request);
-  const [editing, setEditing] = useState<boolean>(false);
-  const handleSubmitNameEdit = async (el: HTMLInputElement) => {
-    await updateRequest.mutate({ name: el.value });
-    setEditing(false);
-  };
+interface SidebarItemsProps {
+  tree: TreeNode;
+  focused: boolean;
+  draggingId: string | null;
+  selectedId: string | null;
+  selectedTree: TreeNode | null;
+  treeParentMap: Record<string, TreeNode>;
+  hoveredTree: TreeNode | null;
+  hoveredIndex: number | null;
+  handleMove: (id: string, side: 'above' | 'below') => void;
+  handleEnd: (id: string) => void;
+  handleDragStart: (id: string) => void;
+  onSelect: (requestId: string) => void;
+  collapsed: Record<string, boolean>;
+}

-  const handleFocus = (el: HTMLInputElement | null) => {
+function SidebarItems({
+  tree,
+  focused,
+  selectedId,
+  selectedTree,
+  draggingId,
+  onSelect,
+  treeParentMap,
+  collapsed,
+  hoveredTree,
+  hoveredIndex,
+  handleEnd,
+  handleMove,
+  handleDragStart,
+}: SidebarItemsProps) {
+  return (
+    <VStack
+      as="ul"
+      role="menu"
+      aria-orientation="vertical"
+      dir="ltr"
+      className={classNames(
+        tree.depth > 0 && 'border-l border-highlight',
+        tree.depth === 0 && 'ml-0',
+        tree.depth >= 1 && 'ml-[1.3em]',
+      )}
+    >
+      {tree.children.map((child, i) => (
+        <Fragment key={child.item.id}>
+          {hoveredIndex === i && hoveredTree?.item.id === tree.item.id && <DropMarker />}
+          <DraggableSidebarItem
+            selected={selectedId === child.item.id}
+            itemId={child.item.id}
+            itemName={child.item.name}
+            itemModel={child.item.model}
+            onMove={handleMove}
+            onEnd={handleEnd}
+            onSelect={onSelect}
+            onDragStart={handleDragStart}
+            useProminentStyles={focused}
+            collapsed={collapsed}
+            child={child}
+          >
+            {child.item.model === 'folder' &&
+              !collapsed[child.item.id] &&
+              draggingId !== child.item.id && (
+                <SidebarItems
+                  treeParentMap={treeParentMap}
+                  tree={child}
+                  collapsed={collapsed}
+                  draggingId={draggingId}
+                  hoveredTree={hoveredTree}
+                  hoveredIndex={hoveredIndex}
+                  focused={focused}
+                  selectedId={selectedId}
+                  selectedTree={selectedTree}
+                  onSelect={onSelect}
+                  handleMove={handleMove}
+                  handleEnd={handleEnd}
+                  handleDragStart={handleDragStart}
+                />
+              )}
+          </DraggableSidebarItem>
+        </Fragment>
+      ))}
+      {hoveredIndex === tree.children.length && hoveredTree?.item.id === tree.item.id && (
+        <DropMarker />
+      )}
+    </VStack>
+  );
+}
+
+type SidebarItemProps = {
+  className?: string;
+  itemId: string;
+  itemName: string;
+  itemModel: string;
+  useProminentStyles?: boolean;
+  selected?: boolean;
+  onSelect: (id: string) => void;
+  draggable?: boolean;
+  children?: ReactNode;
+  collapsed: Record<string, boolean>;
+  child: TreeNode;
+};
+
+const SidebarItem = forwardRef(function SidebarItem(
+  {
+    children,
+    className,
+    itemName,
+    itemId,
+    itemModel,
+    useProminentStyles,
+    selected,
+    onSelect,
+    collapsed,
+    child,
+  }: SidebarItemProps,
+  ref: ForwardedRef<HTMLLIElement>,
+) {
+  const sendAnyRequest = useSendAnyRequest();
+  const createRequest = useCreateRequest();
+  const createFolder = useCreateFolder();
+  const deleteRequest = useDeleteFolder(itemId);
+  const latestResponse = useLatestResponse(itemId);
+  const updateRequest = useUpdateRequest(itemId);
+  const updateAnyFolder = useUpdateAnyFolder();
+  const prompt = usePrompt();
+  const [editing, setEditing] = useState<boolean>(false);
+  const activeRequestId = useActiveRequestId();
+  const isActive = activeRequestId === itemId;
+
+  const handleSubmitNameEdit = useCallback(
+    (el: HTMLInputElement) => {
+      updateRequest.mutate((r) => ({ ...r, name: el.value }));
+      setEditing(false);
+    },
+    [updateRequest],
+  );
+
+  const handleFocus = useCallback((el: HTMLInputElement | null) => {
    el?.focus();
    el?.select();
-  };
+  }, []);
+
+  const handleInputKeyDown = useCallback(
+    async (e: React.KeyboardEvent<HTMLInputElement>) => {
+      e.stopPropagation();
+      switch (e.key) {
+        case 'Enter':
+          e.preventDefault();
+          handleSubmitNameEdit(e.currentTarget);
+          break;
+        case 'Escape':
+          e.preventDefault();
+          setEditing(false);
+          break;
+      }
+    },
+    [handleSubmitNameEdit],
+  );
+
+  const handleStartEditing = useCallback(() => {
+    if (itemModel !== 'http_request') return;
+    setEditing(true);
+  }, [setEditing, itemModel]);
+
+  const handleBlur = useCallback(
+    (e: React.FocusEvent<HTMLInputElement>) => {
+      handleSubmitNameEdit(e.currentTarget);
+    },
+    [handleSubmitNameEdit],
+  );
+
+  const handleSelect = useCallback(() => {
+    onSelect(itemId);
+  }, [onSelect, itemId]);

  return (
-    <li>
-      <Button
-        color="custom"
-        size="sm"
-        className={classnames(
-          editing && 'focus-within:border-blue-400/40',
-          active
-            ? 'bg-gray-200/70 text-gray-900'
-            : 'text-gray-600 hover:text-gray-800 active:bg-gray-200/30',
+    <li ref={ref}>
+      <div className={classNames(className, 'block relative group/item px-2 pb-0.5')}>
+        {itemModel === 'folder' && (
+          <Dropdown
+            items={[
+              {
+                key: 'sendAll',
+                label: 'Send All',
+                leftSlot: <Icon icon="paperPlane" />,
+                onSelect: () => {
+                  for (const { item } of child.children) {
+                    if (item.model === 'http_request') {
+                      sendAnyRequest.mutate(item.id);
+                    }
+                  }
+                },
+              },
+              { type: 'separator', label: itemName },
+              {
+                key: 'rename',
+                label: 'Rename',
+                leftSlot: <Icon icon="pencil" />,
+                onSelect: async () => {
+                  const name = await prompt({
+                    title: 'Rename Folder',
+                    description: (
+                      <>
+                        Enter a new name for <InlineCode>{itemName}</InlineCode>
+                      </>
+                    ),
+                    name: 'name',
+                    label: 'Name',
+                    defaultValue: itemName,
+                  });
+                  updateAnyFolder.mutate({ id: itemId, update: (f) => ({ ...f, name }) });
+                },
+              },
+              {
+                key: 'deleteFolder',
+                label: 'Delete',
+                variant: 'danger',
+                leftSlot: <Icon icon="trash" />,
+                onSelect: () => deleteRequest.mutate(),
+              },
+              { type: 'separator' },
+              {
+                key: 'createRequest',
+                label: 'New Request',
+                leftSlot: <Icon icon="plus" />,
+                onSelect: () => createRequest.mutate({ folderId: itemId, sortPriority: -1 }),
+              },
+              {
+                key: 'createFolder',
+                label: 'New Folder',
+                leftSlot: <Icon icon="plus" />,
+                onSelect: () => createFolder.mutate({ folderId: itemId, sortPriority: -1 }),
+              },
+            ]}
+          >
+            <IconButton
+              title="Folder options"
+              size="xs"
+              icon="dotsV"
+              className="ml-auto !bg-transparent absolute right-2 opacity-0 group-hover/item:opacity-70 transition-opacity"
+            />
+          </Dropdown>
        )}
-        onKeyDown={(e) => {
-          // Hitting enter on active request during keyboard nav will start edit
-          if (active && e.key === 'Enter') {
-            e.preventDefault();
-            setEditing(true);
-          }
-        }}
-        to={`/workspaces/${request.workspaceId}/requests/${request.id}`}
-        onDoubleClick={() => setEditing(true)}
-        justify="start"
-      >
-        {editing ? (
-          <input
-            ref={handleFocus}
-            defaultValue={request.name}
-            className="bg-transparent outline-none w-full"
-            onBlur={(e) => handleSubmitNameEdit(e.currentTarget)}
-            onKeyDown={async (e) => {
-              switch (e.key) {
-                case 'Enter':
-                  await handleSubmitNameEdit(e.currentTarget);
-                  break;
-                case 'Escape':
-                  setEditing(false);
-                  break;
-              }
-            }}
-          />
-        ) : (
-          <span className="truncate">{request.name || request.url}</span>
-        )}
-      </Button>
+        <button
+          // tabIndex={-1} // Will prevent drag-n-drop
+          onClick={handleSelect}
+          disabled={editing}
+          onDoubleClick={handleStartEditing}
+          data-active={isActive}
+          data-selected={selected}
+          className={classNames(
+            'w-full flex items-center text-sm h-xs px-2 rounded-md transition-colors',
+            editing && 'ring-1 focus-within:ring-focus',
+            isActive && 'bg-highlightSecondary text-gray-800',
+            !isActive &&
+              'text-gray-600 group-hover/item:text-gray-800 active:bg-highlightSecondary',
+            selected && useProminentStyles && '!bg-violet-400/20 text-gray-950',
+          )}
+        >
+          {itemModel === 'folder' && (
+            <Icon
+              size="sm"
+              icon="chevronRight"
+              className={classNames(
+                '-ml-0.5 mr-2 transition-transform',
+                !collapsed[itemId] && 'transform rotate-90',
+              )}
+            />
+          )}
+          {editing ? (
+            <input
+              ref={handleFocus}
+              defaultValue={itemName}
+              className="bg-transparent outline-none w-full"
+              onBlur={handleBlur}
+              onKeyDown={handleInputKeyDown}
+            />
+          ) : (
+            <span className={classNames('truncate', !itemName && 'text-gray-400 italic')}>
+              {itemName || 'New Request'}
+            </span>
+          )}
+          {latestResponse && (
+            <div className="ml-auto">
+              {isResponseLoading(latestResponse) ? (
+                <Icon spin size="sm" icon="update" />
+              ) : (
+                <StatusTag className="text-2xs dark:opacity-80" response={latestResponse} />
+              )}
+            </div>
+          )}
+        </button>
+      </div>
+      {children}
    </li>
  );
+});
+
+type DraggableSidebarItemProps = SidebarItemProps & {
+  onMove: (id: string, side: 'above' | 'below') => void;
+  onEnd: (id: string) => void;
+  onDragStart: (id: string) => void;
+  children?: ReactNode;
+  child?: TreeNode;
+};
+
+type DragItem = {
+  id: string;
+  itemName: string;
+};
+
+function DraggableSidebarItem({
+  itemName,
+  itemId,
+  itemModel,
+  child,
+  onMove,
+  onEnd,
+  onDragStart,
+  ...props
+}: DraggableSidebarItemProps) {
+  const ref = useRef<HTMLLIElement>(null);
+
+  const [, connectDrop] = useDrop<DragItem, void>(
+    {
+      accept: ItemTypes.REQUEST,
+      hover: (_, monitor) => {
+        if (!ref.current) return;
+        const hoverBoundingRect = ref.current?.getBoundingClientRect();
+        const hoverMiddleY = (hoverBoundingRect.bottom - hoverBoundingRect.top) / 2;
+        const clientOffset = monitor.getClientOffset();
+        const hoverClientY = (clientOffset as XYCoord).y - hoverBoundingRect.top;
+        onMove(itemId, hoverClientY < hoverMiddleY ? 'above' : 'below');
+      },
+    },
+    [onMove],
+  );
+
+  const [{ isDragging }, connectDrag] = useDrag<DragItem, unknown, { isDragging: boolean }>(
+    () => ({
+      type: ItemTypes.REQUEST,
+      item: () => {
+        onDragStart(itemId);
+        return { id: itemId, itemName };
+      },
+      collect: (m) => ({ isDragging: m.isDragging() }),
+      options: { dropEffect: 'move' },
+      end: () => onEnd(itemId),
+    }),
+    [onEnd],
+  );
+
+  connectDrag(connectDrop(ref));
+
+  return (
+    <SidebarItem
+      ref={ref}
+      draggable
+      className={classNames(isDragging && 'opacity-20')}
+      itemName={itemName}
+      itemId={itemId}
+      itemModel={itemModel}
+      child={child}
+      {...props}
+    />
+  );
 }
--- a/src-web/components/SidebarActions.tsx
+++ b/src-web/components/SidebarActions.tsx
@@ -0,0 +1,43 @@
+import { memo } from 'react';
+import { useCreateFolder } from '../hooks/useCreateFolder';
+import { useCreateRequest } from '../hooks/useCreateRequest';
+import { useSidebarHidden } from '../hooks/useSidebarHidden';
+import { Dropdown } from './core/Dropdown';
+import { IconButton } from './core/IconButton';
+import { HStack } from './core/Stacks';
+
+export const SidebarActions = memo(function SidebarActions() {
+  const createRequest = useCreateRequest();
+  const createFolder = useCreateFolder();
+  const { hidden, toggle } = useSidebarHidden();
+
+  return (
+    <HStack>
+      {hidden && (
+        <IconButton
+          onClick={toggle}
+          className="pointer-events-auto"
+          size="sm"
+          title="Show sidebar"
+          icon={hidden ? 'leftPanelHidden' : 'leftPanelVisible'}
+        />
+      )}
+      <Dropdown
+        items={[
+          {
+            key: 'create-request',
+            label: 'Create Request',
+            onSelect: () => createRequest.mutate({}),
+          },
+          {
+            key: 'create-folder',
+            label: 'Create Folder',
+            onSelect: () => createFolder.mutate({}),
+          },
+        ]}
+      >
+        <IconButton size="sm" icon="plusCircle" title="Add Resource" />
+      </Dropdown>
+    </HStack>
+  );
+});
--- a/src-web/components/UrlBar.tsx
+++ b/src-web/components/UrlBar.tsx
@@ -1,67 +1,87 @@
-import { Button } from './core/Button';
-import { DropdownMenuRadio } from './core/Dropdown';
+import classNames from 'classnames';
+import type { EditorView } from 'codemirror';
+import type { FormEvent } from 'react';
+import { memo, useCallback, useRef, useState } from 'react';
+import { useIsResponseLoading } from '../hooks/useIsResponseLoading';
+import { useListenToTauriEvent } from '../hooks/useListenToTauriEvent';
+import { useRequestUpdateKey } from '../hooks/useRequestUpdateKey';
+import { useSendRequest } from '../hooks/useSendRequest';
+import { useUpdateRequest } from '../hooks/useUpdateRequest';
+import type { HttpRequest } from '../lib/models';
 import { IconButton } from './core/IconButton';
 import { Input } from './core/Input';
+import { RequestMethodDropdown } from './RequestMethodDropdown';

-interface Props {
-  sendRequest: () => void;
-  loading: boolean;
-  method: string;
-  url: string;
-  onMethodChange: (method: string) => void;
-  onUrlChange: (url: string) => void;
-}
+type Props = Pick<HttpRequest, 'id' | 'url' | 'method'> & {
+  className?: string;
+};
+
+export const UrlBar = memo(function UrlBar({ id: requestId, url, method, className }: Props) {
+  const inputRef = useRef<EditorView>(null);
+  const sendRequest = useSendRequest(requestId);
+  const updateRequest = useUpdateRequest(requestId);
+  const [isFocused, setIsFocused] = useState<boolean>(false);
+  const handleMethodChange = useCallback(
+    (method: string) => updateRequest.mutate({ method }),
+    [updateRequest],
+  );
+  const handleUrlChange = useCallback(
+    (url: string) => updateRequest.mutate({ url }),
+    [updateRequest],
+  );
+  const loading = useIsResponseLoading(requestId);
+  const { updateKey } = useRequestUpdateKey(requestId);
+
+  const handleSubmit = useCallback(
+    async (e: FormEvent) => {
+      e.preventDefault();
+      sendRequest.mutate();
+    },
+    [sendRequest],
+  );
+
+  useListenToTauriEvent('focus_url', () => {
+    inputRef.current?.focus();
+  });

-export function UrlBar({ sendRequest, loading, onMethodChange, method, onUrlChange, url }: Props) {
  return (
-    <form
-      onSubmit={async (e) => {
-        e.preventDefault();
-        sendRequest();
-      }}
-      className="w-full flex items-center"
-    >
+    <form onSubmit={handleSubmit} className={classNames('url-bar', className)}>
      <Input
+        autocompleteVariables
+        ref={inputRef}
+        size={isFocused ? 'auto' : 'sm'}
        hideLabel
-        useEditor={{ useTemplating: true, contentType: 'url' }}
-        className="px-0"
+        useTemplating
+        contentType="url"
+        className="px-0 py-0.5"
        name="url"
        label="Enter URL"
-        containerClassName="shadow shadow-gray-100 dark:shadow-gray-0"
-        onChange={onUrlChange}
+        forceUpdateKey={updateKey}
+        onFocus={() => setIsFocused(true)}
+        onBlur={() => setIsFocused(false)}
+        containerClassName="shadow shadow-gray-100 dark:shadow-gray-50"
+        onChange={handleUrlChange}
        defaultValue={url}
-        placeholder="Enter a URL..."
+        placeholder="https://example.com"
        leftSlot={
-          <DropdownMenuRadio
-            onValueChange={(v) => onMethodChange(v.value)}
-            value={method.toUpperCase()}
-            items={[
-              { label: 'GET', value: 'GET' },
-              { label: 'PUT', value: 'PUT' },
-              { label: 'POST', value: 'POST' },
-              { label: 'PATCH', value: 'PATCH' },
-              { label: 'DELETE', value: 'DELETE' },
-              { label: 'OPTIONS', value: 'OPTIONS' },
-              { label: 'HEAD', value: 'HEAD' },
-            ]}
-          >
-            <Button type="button" disabled={loading} size="sm" className="mx-0.5" justify="start">
-              {method.toUpperCase()}
-            </Button>
-          </DropdownMenuRadio>
+          <RequestMethodDropdown
+            method={method}
+            onChange={handleMethodChange}
+            className="!h-auto mx-0.5 my-0.5"
+          />
        }
        rightSlot={
          <IconButton
+            size="xs"
+            iconSize="sm"
+            title="Send Request"
            type="submit"
-            className="mr-0.5"
-            size="sm"
+            className="!h-auto w-8 mr-0.5 my-0.5"
            icon={loading ? 'update' : 'paperPlane'}
            spin={loading}
-            disabled={loading}
-            title="Send Request"
          />
        }
      />
    </form>
  );
-}
+});
--- a/src-web/components/Workspace.tsx
+++ b/src-web/components/Workspace.tsx
@@ -1,40 +1,184 @@
-import classnames from 'classnames';
+import classNames from 'classnames';
+import { motion } from 'framer-motion';
+import type {
+  CSSProperties,
+  HTMLAttributes,
+  MouseEvent as ReactMouseEvent,
+  ReactNode,
+} from 'react';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { useWindowSize } from 'react-use';
-import { RequestPane } from './RequestPane';
-import { ResponsePane } from './ResponsePane';
-import { Sidebar } from './Sidebar';
+import { useOsInfo } from '../hooks/useOsInfo';
+import { useSidebarHidden } from '../hooks/useSidebarHidden';
+import { useSidebarWidth } from '../hooks/useSidebarWidth';
+import { useListenToTauriEvent } from '../hooks/useListenToTauriEvent';
+import { WINDOW_FLOATING_SIDEBAR_WIDTH } from '../lib/constants';
+import { Button } from './core/Button';
 import { HStack } from './core/Stacks';
-import { WindowDragRegion } from './core/WindowDragRegion';
-import { useActiveRequest } from '../hooks/useActiveRequest';
+import { Overlay } from './Overlay';
+import { RequestResponse } from './RequestResponse';
+import { ResizeHandle } from './ResizeHandle';
+import { Sidebar } from './Sidebar';
+import { SidebarActions } from './SidebarActions';
+import { WorkspaceHeader } from './WorkspaceHeader';
+
+const side = { gridArea: 'side' };
+const head = { gridArea: 'head' };
+const body = { gridArea: 'body' };
+const drag = { gridArea: 'drag' };

 export default function Workspace() {
-  const activeRequest = useActiveRequest();
-  const { width } = useWindowSize();
-  const isH = width > 900;
+  const { setWidth, width, resetWidth } = useSidebarWidth();
+  const { hide, show, hidden, toggle } = useSidebarHidden();
+
+  const windowSize = useWindowSize();
+  const [floating, setFloating] = useState<boolean>(false);
+  const [isResizing, setIsResizing] = useState<boolean>(false);
+  const moveState = useRef<{ move: (e: MouseEvent) => void; up: (e: MouseEvent) => void } | null>(
+    null,
+  );
+
+  useListenToTauriEvent('toggle_sidebar', toggle);
+
+  // float/un-float sidebar on window resize
+  useEffect(() => {
+    const shouldHide = windowSize.width <= WINDOW_FLOATING_SIDEBAR_WIDTH;
+    if (shouldHide) setFloating(true);
+    else if (!shouldHide) setFloating(false);
+  }, [windowSize.width]);
+
+  const unsub = () => {
+    if (moveState.current !== null) {
+      document.documentElement.removeEventListener('mousemove', moveState.current.move);
+      document.documentElement.removeEventListener('mouseup', moveState.current.up);
+    }
+  };
+
+  const handleResizeStart = useCallback(
+    (e: ReactMouseEvent<HTMLDivElement>) => {
+      if (width === undefined) return;
+
+      unsub();
+      const mouseStartX = e.clientX;
+      const startWidth = width;
+      moveState.current = {
+        move: async (e: MouseEvent) => {
+          e.preventDefault(); // Prevent text selection and things
+          const newWidth = startWidth + (e.clientX - mouseStartX);
+          if (newWidth < 100) {
+            hide(); 
+            resetWidth();
+          } else  {
+            show();
+            setWidth(newWidth);
+          }
+        },
+        up: (e: MouseEvent) => {
+          e.preventDefault();
+          unsub();
+          setIsResizing(false);
+        },
+      };
+      document.documentElement.addEventListener('mousemove', moveState.current.move);
+      document.documentElement.addEventListener('mouseup', moveState.current.up);
+      setIsResizing(true);
+    },
+    [setWidth, resetWidth, width, hide, show],
+  );
+
+  const sideWidth = hidden ? 0 : width;
+  const styles = useMemo<CSSProperties>(
+    () => ({
+      gridTemplate: floating
+        ? `
+        ' ${head.gridArea}' auto
+        ' ${body.gridArea}' minmax(0,1fr)
+        / 1fr`
+        : `
+        ' ${head.gridArea} ${head.gridArea} ${head.gridArea}' auto
+        ' ${side.gridArea} ${drag.gridArea} ${body.gridArea}' minmax(0,1fr)
+        / ${sideWidth}px   0                1fr`,
+    }),
+    [sideWidth, floating],
+  );
+
+  if (windowSize.width <= 100) {
+    return (
+      <div>
+        <Button>Send</Button>
+      </div>
+    );
+  }

  return (
-    <div className="grid grid-cols-[auto_1fr] grid-rows-1 h-full text-gray-900">
-      <Sidebar />
-      <div className="grid grid-rows-[auto_minmax(0,1fr)] h-full">
-        <HStack
-          as={WindowDragRegion}
-          className="px-3 bg-gray-50 text-gray-900 border-b border-b-gray-200 pt-[1px]"
-          alignItems="center"
-        >
-          {activeRequest?.name}
-        </HStack>
-        <div
-          className={classnames(
-            'grid',
-            isH
-              ? 'grid-cols-[1fr_1fr] grid-rows-1'
-              : 'grid-cols-1 grid-rows-[minmax(0,auto)_minmax(0,100%)]',
-          )}
-        >
-          <RequestPane fullHeight={isH} className={classnames(!isH && 'pr-2 pb-0')} />
-          <ResponsePane />
-        </div>
-      </div>
+    <div
+      style={styles}
+      className={classNames(
+        'grid w-full h-full',
+        // Animate sidebar width changes but only when not resizing
+        // because it's too slow to animate on mouse move
+        !isResizing && 'transition-all',
+      )}
+    >
+      {floating ? (
+        <Overlay open={!hidden} portalName="sidebar" onClose={hide} zIndex={10}>
+          <motion.div
+            initial={{ opacity: 0, x: -10 }}
+            animate={{ opacity: 1, x: 0 }}
+            className={classNames(
+              'absolute top-0 left-0 bottom-0 bg-gray-100 border-r border-highlight w-[14rem]',
+              'grid grid-rows-[auto_1fr]',
+            )}
+          >
+            <HeaderSize className="border-transparent">
+              <HStack space={0.5}>
+                <SidebarActions />
+              </HStack>
+            </HeaderSize>
+            <Sidebar />
+          </motion.div>
+        </Overlay>
+      ) : (
+        <>
+          <div style={side} className={classNames('overflow-hidden bg-gray-100')}>
+            <Sidebar className="border-r border-highlight" />
+          </div>
+          <ResizeHandle
+            className="-translate-x-3"
+            justify="end"
+            side="right"
+            isResizing={isResizing}
+            onResizeStart={handleResizeStart}
+            onReset={resetWidth}
+          />
+        </>
+      )}
+      <HeaderSize
+        data-tauri-drag-region
+        className="w-full bg-gray-50 border-b border-b-highlight text-gray-900"
+        style={head}
+      >
+        <WorkspaceHeader className="pointer-events-none" />
+      </HeaderSize>
+      <RequestResponse style={body} />
    </div>
  );
 }
+
+interface HeaderSizeProps extends HTMLAttributes<HTMLDivElement> {
+  children: ReactNode;
+}
+
+function HeaderSize({ className, ...props }: HeaderSizeProps) {
+  const platform = useOsInfo();
+  return (
+    <div
+      className={classNames(
+        className,
+        'h-md pt-[1px] flex items-center w-full pr-3 pl-20 border-b',
+        platform?.osType === 'Darwin' && 'pl-20',
+      )}
+      {...props}
+    />
+  );
+}
--- a/src-web/components/WorkspaceActionsDropdown.tsx
+++ b/src-web/components/WorkspaceActionsDropdown.tsx
@@ -0,0 +1,247 @@
+import { invoke } from '@tauri-apps/api';
+import { open } from '@tauri-apps/api/dialog';
+import classNames from 'classnames';
+import { memo, useCallback, useMemo } from 'react';
+import { useActiveWorkspace } from '../hooks/useActiveWorkspace';
+import { useAppRoutes } from '../hooks/useAppRoutes';
+import { useCreateWorkspace } from '../hooks/useCreateWorkspace';
+import { useDeleteWorkspace } from '../hooks/useDeleteWorkspace';
+import { usePrompt } from '../hooks/usePrompt';
+import { getRecentEnvironments } from '../hooks/useRecentEnvironments';
+import { useTheme } from '../hooks/useTheme';
+import { useUpdateWorkspace } from '../hooks/useUpdateWorkspace';
+import { useWorkspaces } from '../hooks/useWorkspaces';
+import type { Environment, Folder, HttpRequest, Workspace } from '../lib/models';
+import { pluralize } from '../lib/pluralize';
+import type { ButtonProps } from './core/Button';
+import { Button } from './core/Button';
+import type { DropdownItem } from './core/Dropdown';
+import { Dropdown } from './core/Dropdown';
+import { Icon } from './core/Icon';
+import { InlineCode } from './core/InlineCode';
+import { HStack, VStack } from './core/Stacks';
+import { useDialog } from './DialogContext';
+
+type Props = Pick<ButtonProps, 'className' | 'justify' | 'forDropdown' | 'leftSlot'>;
+
+export const WorkspaceActionsDropdown = memo(function WorkspaceActionsDropdown({
+  className,
+  ...buttonProps
+}: Props) {
+  const workspaces = useWorkspaces();
+  const activeWorkspace = useActiveWorkspace();
+  const activeWorkspaceId = activeWorkspace?.id ?? null;
+  const createWorkspace = useCreateWorkspace({ navigateAfter: true });
+  const updateWorkspace = useUpdateWorkspace(activeWorkspaceId);
+  const deleteWorkspace = useDeleteWorkspace(activeWorkspace);
+  const { appearance, toggleAppearance } = useTheme();
+  const dialog = useDialog();
+  const prompt = usePrompt();
+  const routes = useAppRoutes();
+
+  const importData = useCallback(async () => {
+    const selected = await open({
+      multiple: true,
+      filters: [
+        {
+          name: 'Export File',
+          extensions: ['json'],
+        },
+      ],
+    });
+    if (selected == null || selected.length === 0) return;
+    const imported: {
+      workspaces: Workspace[];
+      environments: Environment[];
+      folders: Folder[];
+      requests: HttpRequest[];
+    } = await invoke('import_data', {
+      filePaths: selected,
+    });
+    const importedWorkspace = imported.workspaces[0];
+
+    dialog.show({
+      title: 'Import Complete',
+      size: 'dynamic',
+      hideX: true,
+      render: ({ hide }) => {
+        const { workspaces, environments, folders, requests } = imported;
+        return (
+          <VStack space={3}>
+            <ul className="list-disc pl-6">
+              <li>
+                {workspaces.length} {pluralize('Workspace', workspaces.length)}
+              </li>
+              <li>
+                {environments.length} {pluralize('Environment', environments.length)}
+              </li>
+              <li>
+                {folders.length} {pluralize('Folder', folders.length)}
+              </li>
+              <li>
+                {requests.length} {pluralize('Request', requests.length)}
+              </li>
+            </ul>
+            <div>
+              <Button className="ml-auto" onClick={hide} color="primary">
+                Done
+              </Button>
+            </div>
+          </VStack>
+        );
+      },
+    });
+
+    if (importedWorkspace != null) {
+      routes.navigate('workspace', {
+        workspaceId: importedWorkspace.id,
+        environmentId: imported.environments[0]?.id,
+      });
+    }
+  }, [routes, dialog]);
+
+  const items: DropdownItem[] = useMemo(() => {
+    const workspaceItems: DropdownItem[] = workspaces.map((w) => ({
+      key: w.id,
+      label: w.name,
+      rightSlot: w.id === activeWorkspaceId ? <Icon icon="check" /> : undefined,
+      onSelect: async () => {
+        dialog.show({
+          id: 'open-workspace',
+          size: 'sm',
+          title: 'Open Workspace',
+          description: (
+            <>
+              Where would you like to open <InlineCode>{w.name}</InlineCode>?
+            </>
+          ),
+          render: ({ hide }) => {
+            return (
+              <HStack space={2} justifyContent="end" alignItems="center" className="mt-6">
+                <Button
+                  className="focus"
+                  color="gray"
+                  rightSlot={<Icon icon="openNewWindow" />}
+                  onClick={async () => {
+                    hide();
+                    const environmentId = (await getRecentEnvironments(w.id))[0];
+                    await invoke('new_window', {
+                      url: routes.paths.workspace({ workspaceId: w.id, environmentId }),
+                    });
+                  }}
+                >
+                  New Window
+                </Button>
+                <Button
+                  autoFocus
+                  className="focus"
+                  color="gray"
+                  onClick={async () => {
+                    hide();
+                    const environmentId = (await getRecentEnvironments(w.id))[0];
+                    routes.navigate('workspace', { workspaceId: w.id, environmentId });
+                  }}
+                >
+                  This Window
+                </Button>
+              </HStack>
+            );
+          },
+        });
+      },
+    }));
+
+    const activeWorkspaceItems: DropdownItem[] =
+      workspaces.length <= 1
+        ? []
+        : [
+            ...workspaceItems,
+            {
+              type: 'separator',
+              label: activeWorkspace?.name,
+            },
+          ];
+
+    return [
+      ...activeWorkspaceItems,
+      {
+        key: 'rename',
+        label: 'Rename',
+        leftSlot: <Icon icon="pencil" />,
+        onSelect: async () => {
+          const name = await prompt({
+            title: 'Rename Workspace',
+            description: (
+              <>
+                Enter a new name for <InlineCode>{activeWorkspace?.name}</InlineCode>
+              </>
+            ),
+            name: 'name',
+            label: 'Name',
+            defaultValue: activeWorkspace?.name,
+          });
+          updateWorkspace.mutate({ name });
+        },
+      },
+      {
+        key: 'delete',
+        label: 'Delete',
+        leftSlot: <Icon icon="trash" />,
+        onSelect: deleteWorkspace.mutate,
+        variant: 'danger',
+      },
+      { type: 'separator' },
+      {
+        key: 'create-workspace',
+        label: 'Create Workspace',
+        leftSlot: <Icon icon="plus" />,
+        onSelect: async () => {
+          const name = await prompt({
+            name: 'name',
+            label: 'Name',
+            defaultValue: 'My Workspace',
+            title: 'Create Workspace',
+          });
+          createWorkspace.mutate({ name });
+        },
+      },
+      {
+        key: 'import',
+        label: 'Import Data',
+        onSelect: importData,
+        leftSlot: <Icon icon="download" />,
+      },
+      {
+        key: 'appearance',
+        label: 'Toggle Theme',
+        onSelect: toggleAppearance,
+        leftSlot: <Icon icon={appearance === 'dark' ? 'sun' : 'moon'} />,
+      },
+    ];
+  }, [
+    activeWorkspace?.name,
+    activeWorkspaceId,
+    appearance,
+    createWorkspace,
+    deleteWorkspace.mutate,
+    dialog,
+    importData,
+    prompt,
+    routes,
+    toggleAppearance,
+    updateWorkspace,
+    workspaces,
+  ]);
+
+  return (
+    <Dropdown items={items}>
+      <Button
+        size="sm"
+        className={classNames(className, 'text-gray-800 !px-2 truncate')}
+        {...buttonProps}
+      >
+        {activeWorkspace?.name}
+      </Button>
+    </Dropdown>
+  );
+});
--- a/Show More
+++ b/Show More
				`@@ -1 +0,0 @@`
				`ALTER TABLE http_responses ADD COLUMN error TEXT NULL;`
				`@@ -0,0 +1 @@`
				`ALTER TABLE main.http_requests ADD COLUMN sort_priority REAL NOT NULL DEFAULT 0;`
				`@@ -0,0 +1 @@`
				`ALTER TABLE workspaces ADD COLUMN variables DEFAULT '[]' NOT NULL;`