Use model labels in import preview

Cargo.lock

@@ -11199,6 +11199,7 @@ dependencies = [
  "base64 0.22.1",
  "log 0.4.29",
  "md5 0.8.0",
+ "rusqlite",
  "serde_json",
  "tempfile",
  "thiserror 2.0.17",
@@ -11277,7 +11278,6 @@ dependencies = [
  "yaak-grpc",
  "yaak-http",
  "yaak-license",
- "yaak-lifecycle",
  "yaak-mac-window",
  "yaak-models",
  "yaak-plugins",
@@ -11343,7 +11343,6 @@ dependencies = [
  "yaak-core",
  "yaak-crypto",
  "yaak-http",
- "yaak-lifecycle",
  "yaak-models",
  "yaak-plugins",
  "yaak-templates",
@@ -11528,14 +11527,6 @@ dependencies = [
  "yaak-models",
 ]
 
-[[package]]
-name = "yaak-lifecycle"
-version = "0.0.0"
-dependencies = [
- "log 0.4.29",
- "yaak-models",
-]
-
 [[package]]
 name = "yaak-mac-window"
 version = "0.1.0"
@@ -11755,8 +11746,6 @@ dependencies = [
  "sqlite-wasm-vfs",
  "wasm-bindgen",
  "wasm-bindgen-futures",
- "web-sys",
- "yaak-lifecycle",
  "yaak-models",
 ]
 

Cargo.toml

@@ -14,7 +14,6 @@ members = [
   "crates/yaak-git",
   "crates/yaak-grpc",
   "crates/yaak-http",
-  "crates/yaak-lifecycle",
   "crates/yaak-models",
   "crates/yaak-plugins",
   "crates/yaak-sse",
@@ -78,7 +77,6 @@ yaak-crypto = { path = "crates/yaak-crypto" }
 yaak-git = { path = "crates/yaak-git" }
 yaak-grpc = { path = "crates/yaak-grpc" }
 yaak-http = { path = "crates/yaak-http" }
-yaak-lifecycle = { path = "crates/yaak-lifecycle" }
 yaak-models = { path = "crates/yaak-models" }
 yaak-plugins = { path = "crates/yaak-plugins" }
 yaak-sse = { path = "crates/yaak-sse" }

apps/yaak-client/components/ImportDataDialog.tsx

@@ -1,17 +1,34 @@
+import {
+  type Folder,
+  type ImportDestination,
+  type ImportPlan,
+  modelTypeLabel,
+  type Workspace,
+} from "@yaakapp-internal/models";
+import { HStack, Icon, VStack } from "@yaakapp-internal/ui";
 import { platform } from "@yaakapp-internal/platform";
-import { Icon, VStack } from "@yaakapp-internal/ui";
 import classNames from "classnames";
 import { useEffect, useRef, useState } from "react";
 import { useLocalStorage } from "react-use";
+import { pluralizeCount } from "../lib/pluralize";
 import { CommercialUseBanner } from "./CommercialUseBanner";
 import { Button } from "./core/Button";
+import { Checkbox } from "./core/Checkbox";
 import { PlainInput } from "./core/PlainInput";
+import { RadioCards } from "./core/RadioCards";
 
 interface Props {
-  importFile: (filePath: string) => Promise<void>;
-  importUrl: (url: string) => Promise<void>;
+  currentWorkspace: Workspace | null;
+  selectedFolder: Folder | null;
+  planFile: (filePath: string, destination: ImportDestination) => Promise<ImportPlan>;
+  planUrl: (url: string, destination: ImportDestination) => Promise<ImportPlan>;
+  commit: (plan: ImportPlan) => Promise<void>;
+  cancel: () => void;
+  onError: (err: unknown) => void;
 }
 
+type DestinationChoice = "new_workspace" | "current_workspace";
+
 /**
  * An absolute or relative path is unambiguously a file. Everything else is treated as a URL, so a
  * bare host like `example.com/openapi.json` still works (the backend defaults it to https).
@@ -31,8 +48,21 @@ function fileName(path: string): string {
   return path.split(/[/\\]/).at(-1) || path;
 }
 
-export function ImportDataDialog({ importFile, importUrl }: Props) {
+export function ImportDataDialog({
+  currentWorkspace,
+  selectedFolder,
+  planFile,
+  planUrl,
+  commit,
+  cancel,
+  onError,
+}: Props) {
   const [isLoading, setIsLoading] = useState<boolean>(false);
+  const [plan, setPlan] = useState<ImportPlan | null>(null);
+  const [destinationChoice, setDestinationChoice] = useState<DestinationChoice>(
+    currentWorkspace == null ? "new_workspace" : "current_workspace",
+  );
+  const [targetSelectedFolder, setTargetSelectedFolder] = useState(selectedFolder != null);
   // A file path or a URL. Both inputs write here, so there is only ever one thing to import
   const [source, setSource] = useLocalStorage<string | null>("importPathOrUrl", null);
   const [forceUpdateKey, setForceUpdateKey] = useState<number>(0);
@@ -71,19 +101,110 @@ export function ImportDataDialog({ importFile, importUrl }: Props) {
     selectSource(selected);
   };
 
-  const handleImport = async () => {
+  const destination = (): ImportDestination => {
+    if (destinationChoice === "current_workspace" && currentWorkspace != null) {
+      return {
+        type: "current_workspace",
+        workspaceId: currentWorkspace.id,
+        folderId: targetSelectedFolder ? selectedFolder?.id : undefined,
+      };
+    }
+    return { type: "new_workspace" };
+  };
+
+  const handlePreview = async () => {
     setIsLoading(true);
     try {
-      if (filePath != null) {
-        await importFile(filePath);
-      } else {
-        await importUrl(trimmedSource);
-      }
+      const nextPlan =
+        filePath != null
+          ? await planFile(filePath, destination())
+          : await planUrl(trimmedSource, destination());
+      setPlan(nextPlan);
+    } catch (err) {
+      onError(err);
     } finally {
       setIsLoading(false);
     }
   };
 
+  const handleCommit = async () => {
+    if (plan == null) return;
+    setIsLoading(true);
+    try {
+      await commit(plan);
+    } catch (err) {
+      onError(err);
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  if (plan != null) {
+    const counts = [
+      [plan.resources.workspaces[0]?.resource, plan.resources.workspaces.length],
+      [plan.resources.environments[0]?.resource, plan.resources.environments.length],
+      [plan.resources.folders[0]?.resource, plan.resources.folders.length],
+      [plan.resources.httpRequests[0]?.resource, plan.resources.httpRequests.length],
+      [plan.resources.grpcRequests[0]?.resource, plan.resources.grpcRequests.length],
+      [plan.resources.websocketRequests[0]?.resource, plan.resources.websocketRequests.length],
+    ] as const;
+    const destinationLabel =
+      plan.destination.type === "new_workspace"
+        ? "New workspace"
+        : selectedFolder != null && plan.destination.folderId === selectedFolder.id
+          ? `${currentWorkspace?.name ?? "Current workspace"} / ${selectedFolder.name}`
+          : (currentWorkspace?.name ?? "Current workspace");
+
+    return (
+      <VStack space={4} className="pb-4">
+        <div className="rounded-lg border border-border-subtle divide-y divide-border-subtle">
+          <PreviewRow label="Detected format" value={plan.importer} />
+          <PreviewRow label="Destination" value={destinationLabel} />
+        </div>
+
+        <div>
+          <div className="text-sm font-semibold mb-1">Resources</div>
+          <ul className="list-disc pl-6 text-sm text-text-subtle">
+            {counts.map(([model, count]) =>
+              model == null ? null : (
+                <li key={model.model}>{pluralizeCount(modelTypeLabel(model), count)}</li>
+              ),
+            )}
+          </ul>
+        </div>
+
+        {plan.warnings.length > 0 && (
+          <div>
+            <div className="text-sm font-semibold mb-1">Import details</div>
+            <div className="rounded-lg border border-border-subtle divide-y divide-border-subtle">
+              {plan.warnings.map((warning) => (
+                <div
+                  key={`${warning.title}:${warning.detail}`}
+                  className="flex items-start gap-2.5 px-3 py-2.5"
+                >
+                  <Icon icon="info" color="info" size="sm" className="mt-0.5" />
+                  <div className="min-w-0">
+                    <div className="text-sm font-medium">{warning.title}</div>
+                    <div className="text-xs text-text-subtle mt-0.5">{warning.detail}</div>
+                  </div>
+                </div>
+              ))}
+            </div>
+          </div>
+        )}
+
+        <HStack space={2} justifyContent="end">
+          <Button color="secondary" variant="border" disabled={isLoading} onClick={cancel}>
+            Cancel
+          </Button>
+          <Button color="primary" isLoading={isLoading} onClick={handleCommit}>
+            {isLoading ? "Importing" : "Confirm Import"}
+          </Button>
+        </HStack>
+      </VStack>
+    );
+  }
+
   return (
     <VStack ref={ref} space={4} className="pb-4">
       <CommercialUseBanner source="data-import" title="Importing work data?" />
@@ -115,25 +236,69 @@ export function ImportDataDialog({ importFile, importUrl }: Props) {
         </div>
       </button>
 
+      <PlainInput
+        label="Or enter a file path or URL"
+        size="sm"
+        placeholder="https://example.com/openapi.json"
+        defaultValue={source ?? ""}
+        forceUpdateKey={String(forceUpdateKey)}
+        onChange={setSource}
+      />
+
       <VStack space={2}>
-        <PlainInput
-          label="Or enter a file path or URL"
-          size="sm"
-          placeholder="https://example.com/openapi.json"
-          defaultValue={source ?? ""}
-          forceUpdateKey={String(forceUpdateKey)}
-          onChange={setSource}
+        <div className="text-sm font-semibold">Import destination</div>
+        <RadioCards
+          name="import-destination"
+          value={destinationChoice}
+          onChange={setDestinationChoice}
+          options={[
+            {
+              value: "new_workspace",
+              label: "New workspace",
+              description: "Create imported resources in a separate workspace.",
+            },
+            ...(currentWorkspace == null
+              ? []
+              : [
+                  {
+                    value: "current_workspace" as const,
+                    label: currentWorkspace.name,
+                    description: "Add resources without changing this workspace's settings.",
+                  },
+                ]),
+          ]}
         />
+        {destinationChoice === "current_workspace" && selectedFolder != null && (
+          <Checkbox
+            checked={targetSelectedFolder}
+            title={`Place root resources in selected folder “${selectedFolder.name}”`}
+            onChange={setTargetSelectedFolder}
+          />
+        )}
+      </VStack>
+
+      <HStack space={2} justifyContent="end">
+        <Button color="secondary" variant="border" disabled={isLoading} onClick={cancel}>
+          Cancel
+        </Button>
         <Button
           color="primary"
           disabled={trimmedSource === "" || isLoading}
           isLoading={isLoading}
-          size="sm"
-          onClick={handleImport}
+          onClick={handlePreview}
         >
-          {isLoading ? "Importing" : "Import"}
+          {isLoading ? "Analyzing" : "Preview Import"}
         </Button>
-      </VStack>
+      </HStack>
     </VStack>
   );
 }
+
+function PreviewRow({ label, value }: { label: string; value: string }) {
+  return (
+    <div className="flex items-start justify-between gap-4 px-3 py-2 text-sm">
+      <span className="text-text-subtle">{label}</span>
+      <span className="text-right font-medium">{value}</span>
+    </div>
+  );
+}

apps/yaak-client/components/Settings/SettingsHotkeys.tsx

@@ -124,7 +124,7 @@ export function SettingsHotkeys() {
             <HotkeyRow
               key={action}
               action={action}
-              currentKeys={hotkeys[action] ?? []}
+              currentKeys={hotkeys[action]}
               defaultKeys={defaultHotkeys[action]}
               onSave={async (keys) => {
                 const newHotkeys = { ...settings.hotkeys };

apps/yaak-client/components/core/Dialog.tsx

@@ -10,11 +10,13 @@ export interface DialogProps {
   children: ReactNode;
   open: boolean;
   onClose?: () => void;
-  disableBackdropClose?: boolean;
+  /** Block dismissal from the backdrop, Escape key, and built-in close button. */
+  disableClose?: boolean;
   title?: ReactNode;
   description?: ReactNode;
   className?: string;
   size?: DialogSize;
+  /** Hide the built-in close button without changing backdrop or Escape behavior. */
   hideX?: boolean;
   noPadding?: boolean;
   noScroll?: boolean;
@@ -27,7 +29,7 @@ export function Dialog({
   size = "full",
   open,
   onClose,
-  disableBackdropClose,
+  disableClose,
   title,
   description,
   hideX,
@@ -42,7 +44,7 @@ export function Dialog({
   );
 
   return (
-    <Overlay open={open} onClose={disableBackdropClose ? undefined : onClose} portalName="dialog">
+    <Overlay open={open} onClose={disableClose ? undefined : onClose} portalName="dialog">
       <div
         role="dialog"
         className={classNames(
@@ -58,7 +60,7 @@ export function Dialog({
           // NOTE: We handle Escape on the element itself so that it doesn't close multiple
           //   dialogs and can be intercepted by children if needed.
           if (e.key === "Escape") {
-            onClose?.();
+            if (!disableClose) onClose?.();
             e.stopPropagation();
             e.preventDefault();
           }
@@ -110,7 +112,7 @@ export function Dialog({
           </div>
 
           {/*Put close at the end so that it's the last thing to be tabbed to*/}
-          {!hideX && (
+          {!disableClose && !hideX && (
             <div className="ml-auto absolute right-1 top-1">
               <IconButton
                 className="opacity-70 hover:opacity-100"

apps/yaak-client/components/git/diverged.tsx

@@ -86,10 +86,8 @@ export async function promptDivergedStrategy({
     showDialog({
       id: "git-diverged",
       title: "Branches Diverged",
-      hideX: true,
       size: "sm",
-      disableBackdropClose: true,
-      onClose: () => resolve("cancel"),
+      disableClose: true,
       render: ({ hide }) =>
         DivergedDialog({
           remote,

apps/yaak-client/hooks/useHotKey.ts

@@ -112,12 +112,9 @@ export const hotkeysAtom = atom((get) => {
   // Merge default hotkeys with custom hotkeys from settings
   // Custom hotkeys override defaults for the same action
   // An empty array means the hotkey is intentionally disabled
-  const merged: Partial<Record<HotkeyAction, string[]>> = {};
-  for (const action of hotkeyActions) {
-    merged[action] = defaultHotkeys[action];
-  }
+  const merged: Record<HotkeyAction, string[]> = { ...defaultHotkeys };
   for (const [action, keys] of Object.entries(customHotkeys)) {
-    if (action in merged && Array.isArray(keys)) {
+    if (action in defaultHotkeys && Array.isArray(keys)) {
       merged[action as HotkeyAction] = keys;
     }
   }
@@ -125,7 +122,7 @@ export const hotkeysAtom = atom((get) => {
 });
 
 /** Helper function to get current hotkeys from the store */
-function getHotkeys(): Partial<Record<HotkeyAction, string[]>> {
+function getHotkeys(): Record<HotkeyAction, string[]> {
   return jotaiStore.get(hotkeysAtom);
 }
 
@@ -168,25 +165,16 @@ const layoutInsensitiveKeys = [
   "Space",
 ];
 
-/** Zoom is the browser's own on these keys, so the app has no such action there. */
-const ZOOM_ACTIONS: HotkeyAction[] = ["app.zoom_in", "app.zoom_out", "app.zoom_reset"];
-
-/**
- * The actions this host actually has. An action left out of here has no keys in
- * `hotkeysAtom`, so it never matches and never claims the keystroke.
- */
 export const hotkeyActions: HotkeyAction[] = (
   Object.keys(defaultHotkeys) as (keyof typeof defaultHotkeys)[]
-)
-  .filter((a) => platform.capabilities.interfaceZoom || !ZOOM_ACTIONS.includes(a))
-  .sort((a, b) => {
-    const scopeA = a.split(".")[0] || "";
-    const scopeB = b.split(".")[0] || "";
-    if (scopeA !== scopeB) {
-      return scopeA.localeCompare(scopeB);
-    }
-    return hotkeyLabels[a].localeCompare(hotkeyLabels[b]);
-  });
+).sort((a, b) => {
+  const scopeA = a.split(".")[0] || "";
+  const scopeB = b.split(".")[0] || "";
+  if (scopeA !== scopeB) {
+    return scopeA.localeCompare(scopeB);
+  }
+  return hotkeyLabels[a].localeCompare(hotkeyLabels[b]);
+});
 
 export type HotKeyOptions = {
   enable?: boolean | (() => boolean);

apps/yaak-client/lib/alert.ts

@@ -14,9 +14,8 @@ export function showAlert({ id, title, body, size = "sm" }: AlertArgs) {
   showDialog({
     id,
     title,
-    hideX: true,
     size,
-    disableBackdropClose: true, // Prevent accidental dismisses
+    disableClose: true,
     render: ({ hide }) => Alert({ onHide: hide, body }),
   });
 }

apps/yaak-client/lib/confirm.ts

@@ -18,9 +18,8 @@ export async function showConfirm({
   return new Promise((onResult: ConfirmProps["onResult"]) => {
     showDialog({
       ...extraProps,
-      hideX: true,
       size,
-      disableBackdropClose: true, // Prevent accidental dismisses
+      disableClose: true,
       render: ({ hide }) => Confirm({ onHide: hide, color, onResult, confirmText, requireTyping }),
     });
   });

apps/yaak-client/lib/importData.tsx

@@ -1,10 +1,13 @@
-import type { BatchUpsertResult } from "@yaakapp-internal/models";
+import type { BatchUpsertResult, ImportDestination, ImportPlan } from "@yaakapp-internal/models";
 import { FormattedError, VStack } from "@yaakapp-internal/ui";
 import { Button } from "../components/core/Button";
 import { ImportDataDialog } from "../components/ImportDataDialog";
+import { activeFolderAtom } from "../hooks/useActiveFolder";
+import { activeWorkspaceAtom } from "../hooks/useActiveWorkspace";
 import { createFastMutation } from "../hooks/useFastMutation";
 import { showAlert } from "./alert";
 import { showDialog } from "./dialog";
+import { jotaiStore } from "./jotai";
 import { pluralizeCount } from "./pluralize";
 import { router } from "./router";
 import { rpc } from "./rpc";
@@ -21,29 +24,41 @@ export const importData = createFastMutation({
   },
   mutationFn: async () => {
     return new Promise<void>((resolve, reject) => {
+      const currentWorkspace = jotaiStore.get(activeWorkspaceAtom);
+      const selectedFolder = jotaiStore.get(activeFolderAtom);
       showDialog({
         id: "import",
         title: "Import Data",
         size: "sm",
+        disableClose: true,
         render: ({ hide }) => {
-          const importAndHide = async (runImport: () => Promise<BatchUpsertResult>) => {
-            try {
-              await finishImport(await runImport());
-              resolve();
-            } catch (err) {
-              reject(err);
-            } finally {
-              hide();
-            }
+          const cancel = () => {
+            hide();
+            resolve();
+          };
+          const fail = (err: unknown) => {
+            hide();
+            reject(err);
+          };
+          const commit = async (plan: ImportPlan) => {
+            const imported = await rpc<BatchUpsertResult>("cmd_commit_import", { plan });
+            hide();
+            await finishImport(imported);
+            resolve();
           };
           return (
             <ImportDataDialog
-              importFile={(filePath) =>
-                importAndHide(() => rpc<BatchUpsertResult>("cmd_import_data", { filePath }))
+              currentWorkspace={currentWorkspace}
+              selectedFolder={selectedFolder}
+              planFile={(filePath: string, destination: ImportDestination) =>
+                rpc<ImportPlan>("cmd_import_data", { filePath, destination })
               }
-              importUrl={(url) =>
-                importAndHide(() => rpc<BatchUpsertResult>("cmd_import_url", { url }))
+              planUrl={(url: string, destination: ImportDestination) =>
+                rpc<ImportPlan>("cmd_import_url", { url, destination })
               }
+              commit={commit}
+              cancel={cancel}
+              onError={fail}
             />
           );
         },

apps/yaak-client/lib/prompt-form.tsx

@@ -25,13 +25,8 @@ export async function showPromptForm({
       id,
       title,
       description,
-      hideX: true,
       size: size ?? "sm",
-      disableBackdropClose: true, // Prevent accidental dismisses
-      onClose: () => {
-        // Click backdrop, close, or escape
-        resolve(null);
-      },
+      disableClose: true,
       render: ({ hide }) =>
         Prompt({
           onCancel: () => {

crates-cli/yaak-cli/Cargo.toml

@@ -45,7 +45,6 @@ yaak-api = { workspace = true }
 yaak-core = { workspace = true }
 yaak-crypto = { workspace = true }
 yaak-http = { workspace = true }
-yaak-lifecycle = { workspace = true }
 yaak-models = { workspace = true }
 yaak-plugins = { workspace = true }
 yaak-templates = { workspace = true }

crates-cli/yaak-cli/src/commands/import_export.rs

@@ -5,8 +5,7 @@ use std::fs;
 use std::io::ErrorKind;
 use yaak::export::{self, ExportDataParams};
 use yaak::import;
-use yaak_core::WorkspaceContext;
-use yaak_models::util::BatchUpsertResult;
+use yaak_models::util::{BatchUpsertResult, ImportDestination};
 use yaak_plugins::events::{ImportResources, PluginContext};
 
 type CommandResult<T = ()> = std::result::Result<T, String>;
@@ -51,6 +50,7 @@ async fn import(ctx: &CliContext, args: ImportArgs) -> CommandResult<BatchUpsert
         .import_data(&plugin_context, &file_contents)
         .await
         .map_err(|e| format!("Failed to import data: {e}"))?;
+    let importer = import_result.importer;
     let resources = import_result.resources;
     let workspace_id = args.workspace_id;
     if workspace_id.is_none() && resources_need_current_workspace(&resources) {
@@ -59,13 +59,13 @@ async fn import(ctx: &CliContext, args: ImportArgs) -> CommandResult<BatchUpsert
                 .to_string(),
         );
     }
-    let workspace_context = WorkspaceContext {
-        workspace_id,
-        environment_id: None,
-        cookie_jar_id: None,
-        request_id: None,
+    let destination = match workspace_id {
+        Some(workspace_id) => ImportDestination::CurrentWorkspace { workspace_id, folder_id: None },
+        None => ImportDestination::NewWorkspace,
     };
-    let imported = import::import_resources(ctx.query_manager(), workspace_context, resources)
+    let plan = import::plan_import_resources(ctx.query_manager(), importer, destination, resources)
+        .map_err(|e| format!("Failed to plan import: {e}"))?;
+    let imported = import::commit_import_plan(ctx.query_manager(), plan)
         .map_err(|e| format!("Failed to import data: {e}"))?;
     Ok(imported)
 }

crates-cli/yaak-cli/src/commands/request.rs

@@ -435,12 +435,15 @@ fn create(
     let workspace_id = resolve_workspace_id(ctx, workspace_id_arg.as_deref(), "request create")?;
     let name = name.unwrap_or_default();
     let url = url.unwrap_or_default();
-    let mut request = HttpRequest { workspace_id, name, url, ..Default::default() };
-    // Only override the method when one was given; `HttpRequest::default()` is the
-    // single place the fallback ("GET") is defined.
-    if let Some(method) = method {
-        request.method = method.to_uppercase();
-    }
+    let method = method.unwrap_or_else(|| "GET".to_string());
+
+    let request = HttpRequest {
+        workspace_id,
+        name,
+        method: method.to_uppercase(),
+        url,
+        ..Default::default()
+    };
 
     let created = ctx
         .db()

crates-cli/yaak-cli/src/context.rs

@@ -49,14 +49,6 @@ impl CliContext {
                     std::process::exit(1);
                 }
             };
-
-        // Guest: the desktop may have this DB open, so only what's safe beside a live session
-        let _ = yaak_lifecycle::on_launch(
-            &yaak_lifecycle::Host::guest(),
-            &query_manager.connect(),
-            &blob_manager,
-        );
-
         let encryption_manager = Arc::new(EncryptionManager::new(query_manager.clone(), app_id));
 
         Self {

crates-cli/yaak-cli/tests/import_export_commands.rs

@@ -81,14 +81,21 @@ fn import_reads_yaak_workspace_file() {
 
     let query_manager = query_manager(data_dir);
     let db = query_manager.connect();
-    assert_eq!(
-        db.get_workspace("wrk_import").expect("workspace imported").name,
-        "Imported Workspace"
-    );
-    assert_eq!(
-        db.get_http_request("req_import").expect("request imported").url,
-        "https://example.com"
-    );
+    let workspaces = db.list_workspaces().expect("list imported workspaces");
+    let workspace = workspaces
+        .iter()
+        .find(|workspace| workspace.name == "Imported Workspace")
+        .expect("workspace imported");
+    assert_ne!(workspace.id, "wrk_import");
+
+    let requests = db.list_http_requests(&workspace.id).expect("list imported requests");
+    let request = requests
+        .iter()
+        .find(|request| request.name == "Imported Request")
+        .expect("request imported");
+    assert_ne!(request.id, "req_import");
+    assert_eq!(request.workspace_id, workspace.id);
+    assert_eq!(request.url, "https://example.com");
 }
 
 fn write_postman_environment_fixture(path: &std::path::Path) {

crates-tauri/yaak-app-client/Cargo.toml

@@ -88,7 +88,6 @@ yaak-grpc = { workspace = true }
 yaak-http = { workspace = true }
 yaak-license = { workspace = true, optional = true }
 yaak-mac-window = { workspace = true }
-yaak-lifecycle = { workspace = true }
 yaak-models = { workspace = true }
 yaak-plugins = { workspace = true }
 yaak-sse = { workspace = true }

crates-tauri/yaak-app-client/src/import.rs

@@ -4,53 +4,63 @@ use crate::models_ext::QueryManagerExt;
 use std::fs::read_to_string;
 use std::io::ErrorKind;
 use tauri::{Manager, Runtime, WebviewWindow};
-use yaak::import::{self, ImportDataParams};
+use yaak::import::{self, PlanImportDataParams};
 use yaak_api::{ApiClientKind, yaak_api_client};
-use yaak_core::WorkspaceContext;
-use yaak_models::util::BatchUpsertResult;
+use yaak_models::util::{BatchUpsertResult, ImportDestination, ImportPlan};
 use yaak_plugins::manager::PluginManager;
-use yaak_tauri_utils::window::WorkspaceWindowTrait;
 
 pub(crate) async fn import_data<R: Runtime>(
     window: &WebviewWindow<R>,
     file_path: &str,
 ) -> Result<BatchUpsertResult> {
-    let contents = read_import_file(file_path)?;
-    import_contents(window, &contents).await
+    let plan = plan_import_data(window, file_path, ImportDestination::NewWorkspace).await?;
+    commit_import(window, plan)
 }
 
-pub(crate) async fn import_url<R: Runtime>(
+pub(crate) async fn plan_import_data<R: Runtime>(
+    window: &WebviewWindow<R>,
+    file_path: &str,
+    destination: ImportDestination,
+) -> Result<ImportPlan> {
+    let contents = read_import_file(file_path)?;
+    plan_import_contents(window, &contents, destination).await
+}
+
+pub(crate) async fn plan_import_url<R: Runtime>(
     window: &WebviewWindow<R>,
     url: &str,
-) -> Result<BatchUpsertResult> {
+    destination: ImportDestination,
+) -> Result<ImportPlan> {
     let contents = fetch_import_url(window, url).await?;
-    import_contents(window, &contents).await
+    plan_import_contents(window, &contents, destination).await
 }
 
-async fn import_contents<R: Runtime>(
+async fn plan_import_contents<R: Runtime>(
     window: &WebviewWindow<R>,
     contents: &str,
-) -> Result<BatchUpsertResult> {
+    destination: ImportDestination,
+) -> Result<ImportPlan> {
     let plugin_manager = window.state::<PluginManager>();
     let query_manager = window.db_manager();
     let plugin_context = window.plugin_context();
-    let workspace_context = WorkspaceContext {
-        workspace_id: window.workspace_id(),
-        environment_id: window.environment_id(),
-        cookie_jar_id: window.cookie_jar_id(),
-        request_id: None,
-    };
 
-    Ok(import::import_data(ImportDataParams {
+    Ok(import::plan_import_data(PlanImportDataParams {
         query_manager: &query_manager,
         plugin_manager: &plugin_manager,
         plugin_context: &plugin_context,
-        workspace_context,
+        destination,
         contents,
     })
     .await?)
 }
 
+pub(crate) fn commit_import<R: Runtime>(
+    window: &WebviewWindow<R>,
+    plan: ImportPlan,
+) -> Result<BatchUpsertResult> {
+    Ok(import::commit_import_plan(&window.db_manager(), plan)?)
+}
+
 /// Download an importable document (OpenAPI, Postman, Insomnia, …) so it can be fed to the same
 /// pipeline as a file on disk.
 ///

crates-tauri/yaak-app-client/src/lib.rs

@@ -4,7 +4,7 @@ use crate::error::Error::GenericError;
 use crate::error::Result;
 use crate::grpc::{build_metadata, metadata_to_map};
 use crate::http_request::send_http_request;
-use crate::import::{import_data, import_url};
+use crate::import::{commit_import, plan_import_data, plan_import_url};
 use crate::models_ext::{BlobManagerExt, QueryManagerExt};
 use crate::notifications::YaakNotifier;
 use crate::render::{render_grpc_request, render_template};
@@ -40,7 +40,7 @@ use yaak_models::models::{
     CookieJar, Environment, GrpcConnection, GrpcConnectionState, GrpcEvent,
     GrpcEventType, HttpRequest, HttpResponse, HttpResponseState, Workspace,
 };
-use yaak_models::util::{BatchUpsertResult, UpdateSource};
+use yaak_models::util::{BatchUpsertResult, ImportDestination, ImportPlan, UpdateSource};
 use yaak_plugins::events::{
     Color, ErrorResponse, FilterResponse, InternalEvent, InternalEventPayload, PluginContext,
     RenderPurpose, ShowToastRequest,
@@ -1013,15 +1013,24 @@ async fn cmd_get_sse_events<R: Runtime>(
 async fn cmd_import_data<R: Runtime>(
     window: WebviewWindow<R>,
     file_path: &str,
-) -> YaakResult<BatchUpsertResult> {
-    import_data(&window, file_path).await
+    destination: ImportDestination,
+) -> YaakResult<ImportPlan> {
+    plan_import_data(&window, file_path, destination).await
 }
 
 async fn cmd_import_url<R: Runtime>(
     window: WebviewWindow<R>,
     url: &str,
+    destination: ImportDestination,
+) -> YaakResult<ImportPlan> {
+    plan_import_url(&window, url, destination).await
+}
+
+async fn cmd_commit_import<R: Runtime>(
+    window: WebviewWindow<R>,
+    plan: ImportPlan,
 ) -> YaakResult<BatchUpsertResult> {
-    import_url(&window, url).await
+    commit_import(&window, plan)
 }
 
 
@@ -1258,14 +1267,6 @@ pub fn run() {
 
     builder
         .setup(|app| {
-            let lifecycle_host = yaak_lifecycle::Host::owner()
-                .with_responses_dir(app.path().app_data_dir()?.join("responses"));
-            if let Err(e) =
-                yaak_lifecycle::on_launch(&lifecycle_host, &app.db(), &app.blob_manager())
-            {
-                error!("on_launch hook failed: {e:?}");
-            }
-
             // The RPC command registry — every frontend command dispatches
             // through this via the single `rpc` Tauri command
             app.manage(rpc_ext::build_rpc_router::<TauriRuntime>());
@@ -1365,6 +1366,15 @@ pub fn run() {
                         let info = history::get_or_upsert_launch_info(&h);
                         debug!("Launched Yaak {:?}", info);
                     });
+
+                    // Cancel pending requests
+                    let h = app_handle.clone();
+                    tauri::async_runtime::block_on(async move {
+                        let db = h.db();
+                        let _ = db.cancel_pending_http_responses();
+                        let _ = db.cancel_pending_grpc_connections();
+                        let _ = db.cancel_pending_websocket_connections();
+                    });
                 }
                 RunEvent::WindowEvent { event: WindowEvent::Focused(true), label, .. } => {
                     #[cfg(any(target_os = "linux", target_os = "macos"))]

crates-tauri/yaak-app-client/src/models_ext.rs

@@ -15,6 +15,7 @@ use yaak_models::error::Result;
 use yaak_models::query_manager::QueryManager;
 use yaak_models::util::{ModelPayload, UpdateSource};
 
+const MODEL_CHANGES_RETENTION_HOURS: i64 = 1;
 const MODEL_CHANGES_POLL_INTERVAL_MS: u64 = 1000;
 const MODEL_CHANGES_POLL_BATCH_SIZE: usize = 200;
 
@@ -151,11 +152,30 @@ pub fn init<R: Runtime>() -> TauriPlugin<R> {
                     }
                 };
 
+            let db = query_manager.connect();
+            if let Err(err) = db.prune_model_changes_older_than_hours(MODEL_CHANGES_RETENTION_HOURS)
+            {
+                error!("Failed to prune model_changes rows on startup: {err:?}");
+            }
             // Only stream writes that happen after this app launch.
             let cursor = ModelChangeCursor::from_launch_time();
 
             let poll_query_manager = query_manager.clone();
 
+            // GC response bodies orphaned by cascade deletes, which historically
+            // didn't clean the blob DB or responses directory
+            let gc_query_manager = query_manager.clone();
+            let gc_blob_manager = blob_manager.clone();
+            let gc_responses_dir = app_path.join("responses");
+            tauri::async_runtime::spawn_blocking(move || {
+                let db = gc_query_manager.connect();
+                match db.delete_orphaned_response_bodies(&gc_blob_manager, &gc_responses_dir) {
+                    Ok(0) => {}
+                    Ok(n) => log::info!("Deleted {n} orphaned response bodies"),
+                    Err(e) => error!("Failed to delete orphaned response bodies: {e:?}"),
+                }
+            });
+
             app_handle.manage(query_manager);
             app_handle.manage(blob_manager);
 

crates-tauri/yaak-app-client/src/rpc_ext.rs

@@ -40,7 +40,7 @@ use yaak_models::models::{
     HttpResponseEvent, Plugin, Settings, WebsocketConnection, WebsocketEvent, WorkspaceMeta,
 };
 use yaak_models::query_manager::QueryManager;
-use yaak_models::util::BatchUpsertResult;
+use yaak_models::util::{BatchUpsertResult, ImportPlan};
 use yaak_plugins::events::{
     CallFolderActionRequest, CallGrpcRequestActionRequest, CallHttpRequestActionRequest,
     CallWebsocketRequestActionRequest, CallWorkspaceActionRequest, FilterResponse, ImportResponse,
@@ -441,12 +441,16 @@ async fn cmd_get_http_response_events<R: Runtime>(ctx: ClientCtx<R>, req: CmdGet
     Ok(yaak_commands::responses::cmd_get_http_response_events(ctx, req).await?)
 }
 
-async fn cmd_import_data<R: Runtime>(ctx: ClientCtx<R>, req: CmdImportDataReq) -> Result<BatchUpsertResult> {
-    Ok(crate::cmd_import_data(ctx.window.clone(), &req.file_path).await?)
+async fn cmd_import_data<R: Runtime>(ctx: ClientCtx<R>, req: CmdImportDataReq) -> Result<ImportPlan> {
+    Ok(crate::cmd_import_data(ctx.window.clone(), &req.file_path, req.destination).await?)
 }
 
-async fn cmd_import_url<R: Runtime>(ctx: ClientCtx<R>, req: CmdImportUrlReq) -> Result<BatchUpsertResult> {
-    Ok(crate::cmd_import_url(ctx.window.clone(), &req.url).await?)
+async fn cmd_import_url<R: Runtime>(ctx: ClientCtx<R>, req: CmdImportUrlReq) -> Result<ImportPlan> {
+    Ok(crate::cmd_import_url(ctx.window.clone(), &req.url, req.destination).await?)
+}
+
+async fn cmd_commit_import<R: Runtime>(ctx: ClientCtx<R>, req: CmdCommitImportReq) -> Result<BatchUpsertResult> {
+    Ok(crate::cmd_commit_import(ctx.window.clone(), req.plan).await?)
 }
 
 async fn cmd_http_request_actions<R: Runtime>(ctx: ClientCtx<R>, req: CmdHttpRequestActionsReq) -> Result<Vec<GetHttpRequestActionsResponse>> {
@@ -843,4 +847,3 @@ async fn cmd_plugins_updates<R: Runtime>(ctx: ClientCtx<R>, _req: CmdPluginsUpda
 async fn cmd_plugins_update_all<R: Runtime>(ctx: ClientCtx<R>, _req: CmdPluginsUpdateAllReq) -> Result<Vec<PluginNameVersion>> {
     Ok(crate::plugins_ext::cmd_plugins_update_all(ctx.window.clone()).await?)
 }
-

crates/common/yaak-rpc-schema/bindings/gen_util.ts

@@ -2,3 +2,13 @@
 import type { Environment, Folder, GrpcRequest, HttpRequest, WebsocketRequest, Workspace } from "./gen_models";
 
 export type BatchUpsertResult = { workspaces: Array<Workspace>, environments: Array<Environment>, folders: Array<Folder>, httpRequests: Array<HttpRequest>, grpcRequests: Array<GrpcRequest>, websocketRequests: Array<WebsocketRequest>, };
+
+export type ImportDestination = { "type": "new_workspace" } | { "type": "current_workspace", workspaceId: string, folderId?: string, };
+
+export type ImportPlan = { importer: string, destination: ImportDestination, resources: ImportPlanResources, warnings: Array<ImportPlanWarning>, };
+
+export type ImportPlanWarning = { title: string, detail: string, };
+
+export type ImportPlanResources = { workspaces: Array<PlannedImportResource<Workspace>>, environments: Array<PlannedImportResource<Environment>>, folders: Array<PlannedImportResource<Folder>>, httpRequests: Array<PlannedImportResource<HttpRequest>>, grpcRequests: Array<PlannedImportResource<GrpcRequest>>, websocketRequests: Array<PlannedImportResource<WebsocketRequest>>, };
+
+export type PlannedImportResource<T> = { sourceKey?: string, resource: T, };

crates/common/yaak-rpc-schema/src/lib.rs

@@ -23,7 +23,7 @@ use yaak_models::models::{
     AnyModel, GraphQlIntrospection, GrpcEvent, HttpRequest, HttpRequestHeader, HttpResponse,
     HttpResponseEvent, Plugin, Settings, WebsocketConnection, WebsocketEvent, WorkspaceMeta,
 };
-use yaak_models::util::BatchUpsertResult;
+use yaak_models::util::{BatchUpsertResult, ImportDestination, ImportPlan};
 use yaak_plugins::api::{PluginNameVersion, PluginSearchResponse, PluginUpdatesResponse};
 use yaak_plugins::events::{
     CallFolderActionRequest, CallGrpcRequestActionRequest, CallHttpRequestActionRequest,
@@ -229,6 +229,7 @@ pub struct CmdGetHttpResponseEventsReq {
 #[ts(export, export_to = "gen_rpc.ts")]
 pub struct CmdImportDataReq {
     pub file_path: String,
+    pub destination: ImportDestination,
 }
 
 #[derive(Debug, Deserialize, TS)]
@@ -236,6 +237,14 @@ pub struct CmdImportDataReq {
 #[ts(export, export_to = "gen_rpc.ts")]
 pub struct CmdImportUrlReq {
     pub url: String,
+    pub destination: ImportDestination,
+}
+
+#[derive(Debug, Deserialize, TS)]
+#[serde(rename_all = "camelCase")]
+#[ts(export, export_to = "gen_rpc.ts")]
+pub struct CmdCommitImportReq {
+    pub plan: ImportPlan,
 }
 
 #[derive(Debug, Deserialize, TS)]
@@ -909,8 +918,9 @@ macro_rules! with_commands {
     cmd_http_request_body(CmdHttpRequestBodyReq) -> Option<Vec<u8>>,
     cmd_get_sse_events(CmdGetSseEventsReq) -> Vec<ServerSentEvent>,
     cmd_get_http_response_events(CmdGetHttpResponseEventsReq) -> Vec<HttpResponseEvent>,
-    cmd_import_data(CmdImportDataReq) -> BatchUpsertResult,
-    cmd_import_url(CmdImportUrlReq) -> BatchUpsertResult,
+    cmd_import_data(CmdImportDataReq) -> ImportPlan,
+    cmd_import_url(CmdImportUrlReq) -> ImportPlan,
+    cmd_commit_import(CmdCommitImportReq) -> BatchUpsertResult,
     cmd_http_request_actions(CmdHttpRequestActionsReq) -> Vec<GetHttpRequestActionsResponse>,
     cmd_websocket_request_actions(CmdWebsocketRequestActionsReq) -> Vec<GetWebsocketRequestActionsResponse>,
     cmd_call_websocket_request_action(CmdCallWebsocketRequestActionReq) -> (),

crates/yaak-lifecycle/Cargo.toml

@@ -1,10 +0,0 @@
-[package]
-name = "yaak-lifecycle"
-version = "0.0.0"
-edition = "2024"
-authors = ["Gregory Schier"]
-publish = false
-
-[dependencies]
-log = { workspace = true }
-yaak-models = { workspace = true }

crates/yaak-lifecycle/src/lib.rs

@@ -1,130 +0,0 @@
-//! Lifecycle hooks shared by every host (desktop, browser, CLI). The hooks say
-//! what happens at each moment; the host decides when and on which thread.
-//!
-//! Builds for wasm32, so it can depend on `yaak-models` but not on the send
-//! engine or plugin runtime.
-
-use log::info;
-use std::path::PathBuf;
-use yaak_models::blob_manager::BlobManager;
-use yaak_models::client_db::ClientDb;
-use yaak_models::error::Result;
-
-const MODEL_CHANGES_RETENTION_HOURS: i64 = 1;
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum Role {
-    /// Has the database for the life of the app (desktop, browser worker)
-    Owner,
-    /// Short-lived, and an owner may be using the database right now (CLI).
-    /// Must not touch anything in flight.
-    Guest,
-}
-
-/// Paths are `None` on hosts without a filesystem (the browser).
-#[derive(Debug, Clone)]
-pub struct Host {
-    pub role: Role,
-    pub responses_dir: Option<PathBuf>,
-}
-
-impl Host {
-    pub fn owner() -> Self {
-        Self { role: Role::Owner, responses_dir: None }
-    }
-
-    pub fn guest() -> Self {
-        Self { role: Role::Guest, responses_dir: None }
-    }
-
-    pub fn with_responses_dir(mut self, dir: impl Into<PathBuf>) -> Self {
-        self.responses_dir = Some(dir.into());
-        self
-    }
-}
-
-/// Run once after the database is open, before the host answers anything.
-pub fn on_launch(host: &Host, db: &ClientDb, blobs: &BlobManager) -> Result<()> {
-    db.prune_model_changes_older_than_hours(MODEL_CHANGES_RETENTION_HOURS)?;
-
-    if host.role == Role::Owner {
-        // Anything still in flight was left by the last session
-        db.cancel_pending_http_responses()?;
-        db.cancel_pending_grpc_connections()?;
-        db.cancel_pending_websocket_connections()?;
-
-        // Cascaded deletes never cleaned up response bodies
-        let deleted = match host.responses_dir.as_deref() {
-            Some(dir) => db.delete_orphaned_response_bodies(blobs, dir)?,
-            None => db.delete_orphaned_response_body_blobs(blobs)?,
-        };
-        if deleted > 0 {
-            info!("Deleted {deleted} orphaned response bodies");
-        }
-    }
-
-    Ok(())
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use yaak_models::blob_manager::BodyChunk;
-    use yaak_models::init_in_memory;
-    use yaak_models::models::{HttpRequest, HttpResponse, HttpResponseState, Workspace};
-    use yaak_models::util::UpdateSource;
-
-    #[test]
-    fn only_the_owner_closes_what_the_last_session_left_open() {
-        let (query_manager, blob_manager, _rx) = init_in_memory().expect("Failed to init DB");
-        let db = query_manager.connect();
-        let source = &UpdateSource::Background;
-
-        let workspace = db
-            .upsert_workspace(
-                &Workspace { name: "Hooks".to_string(), ..Default::default() },
-                source,
-            )
-            .unwrap();
-        let request = db
-            .upsert_http_request(
-                &HttpRequest { workspace_id: workspace.id.clone(), ..Default::default() },
-                source,
-            )
-            .unwrap();
-        let pending = db
-            .upsert_http_response(
-                &HttpResponse {
-                    request_id: request.id.clone(),
-                    workspace_id: workspace.id.clone(),
-                    state: HttpResponseState::Connected,
-                    ..Default::default()
-                },
-                source,
-                &blob_manager,
-            )
-            .unwrap();
-
-        on_launch(&Host::guest(), &db, &blob_manager).unwrap();
-        let response = db.get_http_response(&pending.id).unwrap();
-        assert!(matches!(response.state, HttpResponseState::Connected));
-
-        on_launch(&Host::owner(), &db, &blob_manager).unwrap();
-        let response = db.get_http_response(&pending.id).unwrap();
-        assert!(matches!(response.state, HttpResponseState::Closed));
-    }
-
-    #[test]
-    fn owner_without_a_filesystem_still_sweeps_blobs() {
-        let (query_manager, blob_manager, _rx) = init_in_memory().expect("Failed to init DB");
-        let db = query_manager.connect();
-        {
-            let blob_ctx = blob_manager.connect();
-            blob_ctx.insert_chunk(&BodyChunk::new("rs_gone", 0, b"dead".to_vec())).unwrap();
-        }
-
-        on_launch(&Host::owner(), &db, &blob_manager).unwrap();
-
-        assert!(!blob_manager.connect().body_exists("rs_gone").unwrap());
-    }
-}

crates/yaak-models/bindings/gen_util.ts

@@ -2,3 +2,13 @@
 import type { Environment, Folder, GrpcRequest, HttpRequest, WebsocketRequest, Workspace } from "./gen_models";
 
 export type BatchUpsertResult = { workspaces: Array<Workspace>, environments: Array<Environment>, folders: Array<Folder>, httpRequests: Array<HttpRequest>, grpcRequests: Array<GrpcRequest>, websocketRequests: Array<WebsocketRequest>, };
+
+export type ImportDestination = { "type": "new_workspace" } | { "type": "current_workspace", workspaceId: string, folderId?: string, };
+
+export type ImportPlan = { importer: string, destination: ImportDestination, resources: ImportPlanResources, warnings: Array<ImportPlanWarning>, };
+
+export type ImportPlanWarning = { title: string, detail: string, };
+
+export type ImportPlanResources = { workspaces: Array<PlannedImportResource<Workspace>>, environments: Array<PlannedImportResource<Environment>>, folders: Array<PlannedImportResource<Folder>>, httpRequests: Array<PlannedImportResource<HttpRequest>>, grpcRequests: Array<PlannedImportResource<GrpcRequest>>, websocketRequests: Array<PlannedImportResource<WebsocketRequest>>, };
+
+export type PlannedImportResource<T> = { sourceKey?: string, resource: T, };

crates/yaak-models/guest-js/atoms.test.ts

@@ -1,59 +0,0 @@
-import { createStore } from "jotai";
-import { expect, test } from "vitest";
-import type { HttpResponseEvent } from "../bindings/gen_models";
-import { httpResponseEventsAtom, modelStoreDataAtom } from "./atoms";
-import { newStoreData } from "./util";
-
-// The five setting events that every send writes, all within the same millisecond
-const SETTING_NAMES = [
-  "validate_certificates",
-  "redirects",
-  "timeout",
-  "send_cookies",
-  "store_cookies",
-];
-
-function settingEvent(id: string, name: string, createdAt: string): HttpResponseEvent {
-  return {
-    model: "http_response_event",
-    id,
-    createdAt,
-    updatedAt: createdAt,
-    workspaceId: "wk_1",
-    responseId: "rs_1",
-    event: { type: "setting", name, value: "true" },
-  };
-}
-
-test("events with equal createdAt keep store (DB) insertion order", () => {
-  const store = createStore();
-  const data = newStoreData();
-  SETTING_NAMES.forEach((name, i) => {
-    data.http_response_event[`hre_${i}`] = settingEvent(
-      `hre_${i}`,
-      name,
-      "2026-08-17T00:00:00.123",
-    );
-  });
-  store.set(modelStoreDataAtom, data);
-
-  const names = store.get(httpResponseEventsAtom).map((e) => {
-    return e.event.type === "setting" ? e.event.name : e.event.type;
-  });
-  expect(names).toEqual(SETTING_NAMES);
-});
-
-test("events with distinct createdAt sort ascending", () => {
-  const store = createStore();
-  const data = newStoreData();
-  for (const [id, createdAt] of [
-    ["hre_b", "2026-08-17T00:00:00.456"],
-    ["hre_a", "2026-08-17T00:00:00.123"],
-    ["hre_c", "2026-08-17T00:00:00.789"],
-  ]) {
-    data.http_response_event[id!] = settingEvent(id!, "timeout", createdAt!);
-  }
-  store.set(modelStoreDataAtom, data);
-
-  expect(store.get(httpResponseEventsAtom).map((e) => e.id)).toEqual(["hre_a", "hre_b", "hre_c"]);
-});

crates/yaak-models/guest-js/atoms.ts

@@ -61,9 +61,7 @@ export function createOrderedModelAtom<M extends AnyModel["model"]>(
       const modelData = data[modelType] ?? {};
       return Object.values(modelData).sort(
         (a: ExtractModel<AnyModel, M>, b: ExtractModel<AnyModel, M>) => {
-          // NOTE: ties must return 0, or the comparator is inconsistent and V8 reorders
-          //  equal-keyed rows. Sort is stable, so 0 preserves store (DB) insertion order.
-          const n = a[field] === b[field] ? 0 : a[field] > b[field] ? 1 : -1;
+          const n = a[field] > b[field] ? 1 : -1;
           return order === "desc" ? n * -1 : n;
         },
       );

crates/yaak-models/src/models.rs

@@ -60,22 +60,8 @@ pub struct ProxySettingAuth {
     pub password: String,
 }
 
-impl Default for ClientCertificate {
-    fn default() -> Self {
-        Self {
-            host: String::new(),
-            port: None,
-            crt_file: None,
-            key_file: None,
-            pfx_file: None,
-            passphrase: None,
-            enabled: true,
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, TS)]
-#[serde(default, rename_all = "camelCase")]
+#[derive(Debug, Clone, Serialize, Deserialize, TS)]
+#[serde(rename_all = "camelCase")]
 #[ts(export, export_to = "gen_models.ts")]
 pub struct ClientCertificate {
     pub host: String,
@@ -89,18 +75,13 @@ pub struct ClientCertificate {
     pub pfx_file: Option<String>,
     #[serde(default)]
     pub passphrase: Option<String>,
+    #[serde(default = "default_true")]
     #[ts(optional, as = "Option<bool>")]
     pub enabled: bool,
 }
 
-impl Default for DnsOverride {
-    fn default() -> Self {
-        Self { hostname: String::new(), ipv4: Vec::new(), ipv6: Vec::new(), enabled: true }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema, TS)]
-#[serde(default, rename_all = "camelCase")]
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default, JsonSchema, TS)]
+#[serde(rename_all = "camelCase")]
 #[ts(export, export_to = "gen_models.ts")]
 pub struct DnsOverride {
     pub hostname: String,
@@ -108,6 +89,7 @@ pub struct DnsOverride {
     pub ipv4: Vec<String>,
     #[serde(default)]
     pub ipv6: Vec<String>,
+    #[serde(default = "default_true")]
     #[ts(optional, as = "Option<bool>")]
     pub enabled: bool,
 }
@@ -165,6 +147,7 @@ pub struct InheritedBoolSetting {
     #[serde(default)]
     #[ts(optional, as = "Option<bool>")]
     pub enabled: bool,
+    #[serde(default = "default_true")]
     pub value: bool,
 }
 
@@ -400,31 +383,7 @@ impl UpsertModelInfo for Settings {
     }
 }
 
-impl Default for Workspace {
-    fn default() -> Self {
-        Self {
-            model: "workspace".to_string(),
-            id: String::new(),
-            created_at: NaiveDateTime::default(),
-            updated_at: NaiveDateTime::default(),
-            authentication: BTreeMap::new(),
-            authentication_type: None,
-            description: String::new(),
-            headers: Vec::new(),
-            name: String::new(),
-            encryption_key_challenge: None,
-            setting_validate_certificates: true,
-            setting_follow_redirects: true,
-            setting_request_timeout: 0,
-            setting_request_message_size: DEFAULT_REQUEST_MESSAGE_SIZE,
-            setting_dns_overrides: Vec::new(),
-            setting_send_cookies: true,
-            setting_store_cookies: true,
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema, TS)]
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default, JsonSchema, TS)]
 #[serde(default, rename_all = "camelCase")]
 #[ts(export, export_to = "gen_models.ts")]
 #[enum_def(table_name = "workspaces")]
@@ -444,13 +403,18 @@ pub struct Workspace {
     pub encryption_key_challenge: Option<String>,
 
     // Settings
+    #[serde(default = "default_true")]
     pub setting_validate_certificates: bool,
+    #[serde(default = "default_true")]
     pub setting_follow_redirects: bool,
     pub setting_request_timeout: i32,
+    #[serde(default = "default_request_message_size")]
     pub setting_request_message_size: i32,
     #[serde(default)]
     pub setting_dns_overrides: Vec<DnsOverride>,
+    #[serde(default = "default_true")]
     pub setting_send_cookies: bool,
+    #[serde(default = "default_true")]
     pub setting_store_cookies: bool,
 }
 
@@ -956,16 +920,11 @@ impl UpsertModelInfo for Environment {
     }
 }
 
-impl Default for EnvironmentVariable {
-    fn default() -> Self {
-        Self { enabled: true, name: String::new(), value: String::new(), id: None }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema, TS)]
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default, JsonSchema, TS)]
 #[serde(default, rename_all = "camelCase")]
 #[ts(export, export_to = "gen_models.ts")]
 pub struct EnvironmentVariable {
+    #[serde(default = "default_true")]
     #[ts(optional, as = "Option<bool>")]
     pub enabled: bool,
     pub name: String,
@@ -990,35 +949,7 @@ pub struct ParentHeaders {
     pub headers: Vec<HttpRequestHeader>,
 }
 
-impl Default for Folder {
-    fn default() -> Self {
-        Self {
-            model: "folder".to_string(),
-            id: String::new(),
-            created_at: NaiveDateTime::default(),
-            updated_at: NaiveDateTime::default(),
-            workspace_id: String::new(),
-            folder_id: None,
-            authentication: BTreeMap::new(),
-            authentication_type: None,
-            description: String::new(),
-            headers: Vec::new(),
-            name: String::new(),
-            sort_priority: 0.0,
-            setting_send_cookies: InheritedBoolSetting::default(),
-            setting_store_cookies: InheritedBoolSetting::default(),
-            setting_validate_certificates: InheritedBoolSetting::default(),
-            setting_follow_redirects: InheritedBoolSetting::default(),
-            setting_request_timeout: InheritedIntSetting::default(),
-            setting_request_message_size: InheritedIntSetting {
-                enabled: false,
-                value: DEFAULT_REQUEST_MESSAGE_SIZE,
-            },
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema, TS)]
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default, JsonSchema, TS)]
 #[serde(default, rename_all = "camelCase")]
 #[ts(export, export_to = "gen_models.ts")]
 #[enum_def(table_name = "folders")]
@@ -1043,6 +974,7 @@ pub struct Folder {
     pub setting_validate_certificates: InheritedBoolSetting,
     pub setting_follow_redirects: InheritedBoolSetting,
     pub setting_request_timeout: InheritedIntSetting,
+    #[serde(default = "default_request_message_size_setting")]
     pub setting_request_message_size: InheritedIntSetting,
 }
 
@@ -1156,16 +1088,11 @@ impl UpsertModelInfo for Folder {
     }
 }
 
-impl Default for HttpRequestHeader {
-    fn default() -> Self {
-        Self { enabled: true, name: String::new(), value: String::new(), id: None }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema, TS)]
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default, JsonSchema, TS)]
 #[serde(default, rename_all = "camelCase")]
 #[ts(export, export_to = "gen_models.ts")]
 pub struct HttpRequestHeader {
+    #[serde(default = "default_true")]
     #[ts(optional, as = "Option<bool>")]
     pub enabled: bool,
     pub name: String,
@@ -1174,16 +1101,11 @@ pub struct HttpRequestHeader {
     pub id: Option<String>,
 }
 
-impl Default for HttpUrlParameter {
-    fn default() -> Self {
-        Self { enabled: true, name: String::new(), value: String::new(), id: None }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema, TS)]
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default, JsonSchema, TS)]
 #[serde(default, rename_all = "camelCase")]
 #[ts(export, export_to = "gen_models.ts")]
 pub struct HttpUrlParameter {
+    #[serde(default = "default_true")]
     #[ts(optional, as = "Option<bool>")]
     pub enabled: bool,
     /// Colon-prefixed parameters are treated as path parameters if they match, like `/users/:id`
@@ -1194,36 +1116,7 @@ pub struct HttpUrlParameter {
     pub id: Option<String>,
 }
 
-impl Default for HttpRequest {
-    fn default() -> Self {
-        Self {
-            model: "http_request".to_string(),
-            id: String::new(),
-            created_at: NaiveDateTime::default(),
-            updated_at: NaiveDateTime::default(),
-            workspace_id: String::new(),
-            folder_id: None,
-            authentication: BTreeMap::new(),
-            authentication_type: None,
-            body: BTreeMap::new(),
-            body_type: None,
-            description: String::new(),
-            headers: Vec::new(),
-            method: "GET".to_string(),
-            name: String::new(),
-            sort_priority: 0.0,
-            url: String::new(),
-            url_parameters: Vec::new(),
-            setting_send_cookies: InheritedBoolSetting::default(),
-            setting_store_cookies: InheritedBoolSetting::default(),
-            setting_validate_certificates: InheritedBoolSetting::default(),
-            setting_follow_redirects: InheritedBoolSetting::default(),
-            setting_request_timeout: InheritedIntSetting::default(),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema, TS)]
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default, JsonSchema, TS)]
 #[serde(default, rename_all = "camelCase")]
 #[ts(export, export_to = "gen_models.ts")]
 #[enum_def(table_name = "http_requests")]
@@ -1244,6 +1137,7 @@ pub struct HttpRequest {
     pub body_type: Option<String>,
     pub description: String,
     pub headers: Vec<HttpRequestHeader>,
+    #[serde(default = "default_http_method")]
     pub method: String,
     pub name: String,
     pub sort_priority: f64,
@@ -1499,36 +1393,7 @@ impl Default for WebsocketMessageType {
     }
 }
 
-impl Default for WebsocketRequest {
-    fn default() -> Self {
-        Self {
-            model: "websocket_request".to_string(),
-            id: String::new(),
-            created_at: NaiveDateTime::default(),
-            updated_at: NaiveDateTime::default(),
-            workspace_id: String::new(),
-            folder_id: None,
-            authentication: BTreeMap::new(),
-            authentication_type: None,
-            description: String::new(),
-            headers: Vec::new(),
-            message: String::new(),
-            name: String::new(),
-            sort_priority: 0.0,
-            url: String::new(),
-            url_parameters: Vec::new(),
-            setting_send_cookies: InheritedBoolSetting::default(),
-            setting_store_cookies: InheritedBoolSetting::default(),
-            setting_validate_certificates: InheritedBoolSetting::default(),
-            setting_request_message_size: InheritedIntSetting {
-                enabled: false,
-                value: DEFAULT_REQUEST_MESSAGE_SIZE,
-            },
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema, TS)]
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default, JsonSchema, TS)]
 #[serde(default, rename_all = "camelCase")]
 #[ts(export, export_to = "gen_models.ts")]
 #[enum_def(table_name = "websocket_requests")]
@@ -1555,6 +1420,7 @@ pub struct WebsocketRequest {
     pub setting_send_cookies: InheritedBoolSetting,
     pub setting_store_cookies: InheritedBoolSetting,
     pub setting_validate_certificates: InheritedBoolSetting,
+    #[serde(default = "default_request_message_size_setting")]
     pub setting_request_message_size: InheritedIntSetting,
 }
 
@@ -2187,35 +2053,7 @@ impl UpsertModelInfo for GraphQlIntrospection {
     }
 }
 
-impl Default for GrpcRequest {
-    fn default() -> Self {
-        Self {
-            model: "grpc_request".to_string(),
-            id: String::new(),
-            created_at: NaiveDateTime::default(),
-            updated_at: NaiveDateTime::default(),
-            workspace_id: String::new(),
-            folder_id: None,
-            authentication_type: None,
-            authentication: BTreeMap::new(),
-            description: String::new(),
-            message: String::new(),
-            metadata: Vec::new(),
-            method: None,
-            name: String::new(),
-            service: None,
-            sort_priority: 0.0,
-            url: String::new(),
-            setting_validate_certificates: InheritedBoolSetting::default(),
-            setting_request_message_size: InheritedIntSetting {
-                enabled: false,
-                value: DEFAULT_REQUEST_MESSAGE_SIZE,
-            },
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema, TS)]
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default, JsonSchema, TS)]
 #[serde(default, rename_all = "camelCase")]
 #[ts(export, export_to = "gen_models.ts")]
 #[enum_def(table_name = "grpc_requests")]
@@ -2241,6 +2079,7 @@ pub struct GrpcRequest {
     /// Server URL (http for plaintext or https for secure)
     pub url: String,
     pub setting_validate_certificates: InheritedBoolSetting,
+    #[serde(default = "default_request_message_size_setting")]
     pub setting_request_message_size: InheritedIntSetting,
 }
 
@@ -2891,12 +2730,22 @@ impl<'s> TryFrom<&Row<'s>> for PluginKeyValue {
     }
 }
 
-/// Only used as a `from_row` fallback for an unparseable settings column. The
-/// value a *new* model gets comes from that model's `Default` impl.
+fn default_true() -> bool {
+    true
+}
+
+fn default_request_message_size() -> i32 {
+    DEFAULT_REQUEST_MESSAGE_SIZE
+}
+
 fn default_request_message_size_setting() -> InheritedIntSetting {
     InheritedIntSetting { enabled: false, value: DEFAULT_REQUEST_MESSAGE_SIZE }
 }
 
+fn default_http_method() -> String {
+    "GET".to_string()
+}
+
 #[macro_export]
 macro_rules! define_any_model {
     ($($type:ident),* $(,)?) => {
@@ -3040,65 +2889,3 @@ impl AnyModel {
         }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    /// Every model below carries `#[serde(default)]` at the container level, so a
-    /// missing key is filled from `Default::default()`, which makes each `Default`
-    /// impl the single definition of that model's defaults.
-    ///
-    /// Deserializing `{}` therefore equals `Default::default()` by construction
-    /// today. What this catches is the two ways that can come apart again, both of
-    /// which have already bitten us:
-    ///
-    /// 1. A field-level `#[serde(default = "...")]` (or bare `#[serde(default)]`)
-    ///    added back on a field whose `Default` says something else. That is exactly
-    ///    the shape of the bug this replaced: `setting_send_cookies` deserialized as
-    ///    true but a derived `Default` produced false, so the bootstrapped workspace
-    ///    silently sent no cookies.
-    /// 2. The container-level `#[serde(default)]` being dropped, which turns every
-    ///    missing key into a deserialization error instead.
-    macro_rules! assert_default_matches_serde {
-        ($($t:ty),+ $(,)?) => {
-            $(
-                assert_eq!(
-                    serde_json::from_str::<$t>("{}").expect(concat!(
-                        stringify!($t),
-                        " must deserialize from an empty object"
-                    )),
-                    <$t>::default(),
-                    concat!(stringify!($t), ": Default::default() disagrees with its serde defaults"),
-                );
-            )+
-        };
-    }
-
-    #[test]
-    fn defaults_match_serde_defaults() {
-        assert_default_matches_serde!(
-            Workspace,
-            HttpRequest,
-            Folder,
-            GrpcRequest,
-            WebsocketRequest,
-            HttpRequestHeader,
-            HttpUrlParameter,
-            EnvironmentVariable,
-            DnsOverride,
-            ClientCertificate,
-            InheritedBoolSetting,
-            InheritedIntSetting,
-        );
-    }
-
-    #[test]
-    fn defaults_carry_their_model_name() {
-        assert_eq!(Workspace::default().model, "workspace");
-        assert_eq!(HttpRequest::default().model, "http_request");
-        assert_eq!(Folder::default().model, "folder");
-        assert_eq!(GrpcRequest::default().model, "grpc_request");
-        assert_eq!(WebsocketRequest::default().model, "websocket_request");
-    }
-}

crates/yaak-models/src/queries/http_responses.rs

@@ -45,31 +45,6 @@ impl<'a> ClientDb<'a> {
         Ok(count)
     }
 
-    /// Delete blob-stored response bodies whose owning HTTP response row no
-    /// longer exists. Blob ids are keyed by the response that owns them —
-    /// "{response_id}" for a response body, "{response_id}.request" for the
-    /// request that produced it — so ownership is the id's first segment.
-    ///
-    /// The blob half of [`Self::delete_orphaned_response_bodies`], on its own
-    /// for hosts with no filesystem to hold body files. See `crate::hooks`.
-    ///
-    /// Returns the number of orphaned bodies deleted.
-    pub fn delete_orphaned_response_body_blobs(&self, blobs: &BlobManager) -> Result<usize> {
-        let mut deleted = 0;
-
-        let blob_ctx = blobs.connect();
-        for body_id in blob_ctx.list_body_ids()? {
-            let response_id = body_id.split('.').next().unwrap_or_default();
-            if self.find_optional::<HttpResponse>(HttpResponseIden::Id, response_id).is_some() {
-                continue;
-            }
-            blob_ctx.delete_chunks(&body_id)?;
-            deleted += 1;
-        }
-
-        Ok(deleted)
-    }
-
     /// Delete response body data (blob chunks and body files) whose owning HTTP
     /// response row no longer exists. Cascaded deletes (request, folder,
     /// workspace) historically never cleaned the blob DB or the responses
@@ -84,7 +59,18 @@ impl<'a> ClientDb<'a> {
         blobs: &BlobManager,
         responses_dir: &std::path::Path,
     ) -> Result<usize> {
-        let mut deleted = self.delete_orphaned_response_body_blobs(blobs)?;
+        let mut deleted = 0;
+
+        // Blob chunks are keyed "{response_id}.request"
+        let blob_ctx = blobs.connect();
+        for body_id in blob_ctx.list_body_ids()? {
+            let response_id = body_id.split('.').next().unwrap_or_default();
+            if self.find_optional::<HttpResponse>(HttpResponseIden::Id, response_id).is_some() {
+                continue;
+            }
+            blob_ctx.delete_chunks(&body_id)?;
+            deleted += 1;
+        }
 
         // Body files are stored as {responses_dir}/{response_id}
         if let Ok(entries) = fs::read_dir(responses_dir) {
@@ -186,20 +172,19 @@ impl<'a> ClientDb<'a> {
 
 #[cfg(test)]
 mod tests {
-    use crate::blob_manager::{BlobManager, BodyChunk};
-    use crate::client_db::ClientDb;
+    use crate::blob_manager::BodyChunk;
     use crate::init_in_memory;
     use crate::models::{HttpRequest, HttpResponse, Workspace};
     use crate::util::UpdateSource;
 
-    /// A workspace, a request, and one response that still exists.
-    fn seed_live_response(db: &ClientDb, blob_manager: &BlobManager) -> HttpResponse {
+    #[test]
+    fn deletes_orphaned_response_bodies() {
+        let (query_manager, blob_manager, _rx) = init_in_memory().expect("Failed to init DB");
+        let db = query_manager.connect();
+
         let source = &UpdateSource::Background;
         let workspace = db
-            .upsert_workspace(
-                &Workspace { name: "GC Test".to_string(), ..Default::default() },
-                source,
-            )
+            .upsert_workspace(&Workspace { name: "GC Test".to_string(), ..Default::default() }, source)
             .expect("Failed to upsert workspace");
         let request = db
             .upsert_http_request(
@@ -207,57 +192,19 @@ mod tests {
                 source,
             )
             .expect("Failed to upsert request");
-        db.upsert_http_response(
-            &HttpResponse {
-                request_id: request.id.clone(),
-                workspace_id: workspace.id.clone(),
-                ..Default::default()
-            },
-            source,
-            blob_manager,
-        )
-        .expect("Failed to upsert response")
-    }
 
-    /// What a browser host runs: no filesystem, so bodies exist only as blob
-    /// chunks, under both id shapes the blob DB uses.
-    #[test]
-    fn deletes_orphaned_response_body_blobs() {
-        let (query_manager, blob_manager, _rx) = init_in_memory().expect("Failed to init DB");
-        let db = query_manager.connect();
+        let live = db
+            .upsert_http_response(
+                &HttpResponse {
+                    request_id: request.id.clone(),
+                    workspace_id: workspace.id.clone(),
+                    ..Default::default()
+                },
+                source,
+                &blob_manager,
+            )
+            .expect("Failed to upsert response");
 
-        let live = seed_live_response(&db, &blob_manager);
-        let live_request_body_id = format!("{}.request", live.id);
-        {
-            // Scope the connection: the in-memory pool only has one, and the GC
-            // needs to take it
-            let blob_ctx = blob_manager.connect();
-            blob_ctx.insert_chunk(&BodyChunk::new(&live.id, 0, b"live".to_vec())).unwrap();
-            blob_ctx
-                .insert_chunk(&BodyChunk::new(&live_request_body_id, 0, b"live".to_vec()))
-                .unwrap();
-            blob_ctx.insert_chunk(&BodyChunk::new("rs_gone", 0, b"dead".to_vec())).unwrap();
-            blob_ctx.insert_chunk(&BodyChunk::new("rs_gone.request", 0, b"dead".to_vec())).unwrap();
-        }
-
-        let deleted = db
-            .delete_orphaned_response_body_blobs(&blob_manager)
-            .expect("Failed to GC response body blobs");
-        assert_eq!(deleted, 2);
-
-        let blob_ctx = blob_manager.connect();
-        assert!(blob_ctx.body_exists(&live.id).unwrap());
-        assert!(blob_ctx.body_exists(&live_request_body_id).unwrap());
-        assert!(!blob_ctx.body_exists("rs_gone").unwrap());
-        assert!(!blob_ctx.body_exists("rs_gone.request").unwrap());
-    }
-
-    #[test]
-    fn deletes_orphaned_response_bodies() {
-        let (query_manager, blob_manager, _rx) = init_in_memory().expect("Failed to init DB");
-        let db = query_manager.connect();
-
-        let live = seed_live_response(&db, &blob_manager);
         let live_body_id = format!("{}.request", live.id);
         {
             // Scope the connection: the in-memory pool only has one, and the GC

crates/yaak-models/src/queries/workspaces.rs

@@ -25,7 +25,13 @@ impl<'a> ClientDb<'a> {
 
         if workspaces.is_empty() {
             workspaces.push(self.upsert_workspace(
-                &Workspace { name: "Yaak".to_string(), ..Default::default() },
+                &Workspace {
+                    name: "Yaak".to_string(),
+                    setting_follow_redirects: true,
+                    setting_request_message_size: crate::models::DEFAULT_REQUEST_MESSAGE_SIZE,
+                    setting_validate_certificates: true,
+                    ..Default::default()
+                },
                 &UpdateSource::Background,
             )?)
         }
@@ -188,40 +194,16 @@ impl<'a> ClientDb<'a> {
 pub fn default_headers() -> Vec<HttpRequestHeader> {
     vec![
         HttpRequestHeader {
+            enabled: true,
             name: "User-Agent".to_string(),
             value: "yaak".to_string(),
-            ..Default::default()
+            id: None,
         },
         HttpRequestHeader {
+            enabled: true,
             name: "Accept".to_string(),
             value: "*/*".to_string(),
-            ..Default::default()
+            id: None,
         },
     ]
 }
-
-#[cfg(test)]
-mod tests {
-    use crate::init_in_memory;
-
-    #[test]
-    fn bootstraps_first_workspace_with_real_defaults() {
-        let (query_manager, _blob_manager, _rx) = init_in_memory().expect("Failed to init DB");
-        let db = query_manager.connect();
-
-        let workspaces = db.list_workspaces().expect("Failed to list workspaces");
-        let workspace = workspaces.first().expect("No workspace was bootstrapped");
-
-        // This workspace is built in Rust and never deserialized, so it only gets
-        // these values if `Workspace::default()` carries them. Asserted through the
-        // DB round trip, since the column values are what a fresh install lives with.
-        assert!(workspace.setting_send_cookies, "setting_send_cookies");
-        assert!(workspace.setting_store_cookies, "setting_store_cookies");
-        assert!(workspace.setting_follow_redirects, "setting_follow_redirects");
-        assert!(workspace.setting_validate_certificates, "setting_validate_certificates");
-        assert_eq!(
-            workspace.setting_request_message_size,
-            crate::models::DEFAULT_REQUEST_MESSAGE_SIZE
-        );
-    }
-}

crates/yaak-models/src/util.rs

@@ -85,6 +85,86 @@ pub struct BatchUpsertResult {
     pub websocket_requests: Vec<WebsocketRequest>,
 }
 
+/// Where a staged import will be committed.
+///
+/// The current workspace and optional folder IDs are captured in the plan so the preview describes
+/// the exact destination that confirmation will use.
+#[derive(Debug, Clone, Deserialize, Serialize, TS)]
+#[serde(rename_all = "snake_case", tag = "type")]
+#[ts(export, export_to = "gen_util.ts")]
+pub enum ImportDestination {
+    NewWorkspace,
+    CurrentWorkspace {
+        #[serde(rename = "workspaceId")]
+        workspace_id: String,
+        #[serde(rename = "folderId")]
+        #[ts(optional)]
+        folder_id: Option<String>,
+    },
+}
+
+/// A model staged for import.
+///
+/// `source_key` is intentionally part of the plan boundary even though the first import slice does
+/// not persist it. Future linked imports can populate it without changing how plans contain models.
+#[derive(Debug, Clone, Deserialize, Serialize, TS)]
+#[serde(rename_all = "camelCase")]
+#[ts(export, export_to = "gen_util.ts")]
+pub struct PlannedImportResource<T> {
+    #[ts(optional)]
+    pub source_key: Option<String>,
+    pub resource: T,
+}
+
+impl<T> PlannedImportResource<T> {
+    pub fn new(resource: T) -> Self {
+        Self { source_key: None, resource }
+    }
+}
+
+#[derive(Default, Debug, Clone, Deserialize, Serialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "gen_util.ts")]
+pub struct ImportPlanResources {
+    pub workspaces: Vec<PlannedImportResource<Workspace>>,
+    pub environments: Vec<PlannedImportResource<Environment>>,
+    pub folders: Vec<PlannedImportResource<Folder>>,
+    pub http_requests: Vec<PlannedImportResource<HttpRequest>>,
+    pub grpc_requests: Vec<PlannedImportResource<GrpcRequest>>,
+    pub websocket_requests: Vec<PlannedImportResource<WebsocketRequest>>,
+}
+
+impl ImportPlanResources {
+    pub fn into_batch(self) -> BatchUpsertResult {
+        BatchUpsertResult {
+            workspaces: self.workspaces.into_iter().map(|v| v.resource).collect(),
+            environments: self.environments.into_iter().map(|v| v.resource).collect(),
+            folders: self.folders.into_iter().map(|v| v.resource).collect(),
+            http_requests: self.http_requests.into_iter().map(|v| v.resource).collect(),
+            grpc_requests: self.grpc_requests.into_iter().map(|v| v.resource).collect(),
+            websocket_requests: self.websocket_requests.into_iter().map(|v| v.resource).collect(),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize, TS)]
+#[serde(rename_all = "camelCase")]
+#[ts(export, export_to = "gen_util.ts")]
+pub struct ImportPlanWarning {
+    pub title: String,
+    pub detail: String,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize, TS)]
+#[serde(rename_all = "camelCase")]
+#[ts(export, export_to = "gen_util.ts")]
+pub struct ImportPlan {
+    pub importer: String,
+    pub destination: ImportDestination,
+    pub resources: ImportPlanResources,
+    pub warnings: Vec<ImportPlanWarning>,
+}
+
 pub fn get_workspace_export_resources(
     db: &ClientDb,
     yaak_version: &str,

crates/yaak-plugins/bindings/gen_events.ts

@@ -474,7 +474,7 @@ export type ImportRequest = { content: string, };
 
 export type ImportResources = { workspaces: Array<Workspace>, environments: Array<Environment>, folders: Array<Folder>, httpRequests: Array<HttpRequest>, grpcRequests: Array<GrpcRequest>, websocketRequests: Array<WebsocketRequest>, };
 
-export type ImportResponse = { resources: ImportResources, };
+export type ImportResponse = { importer: string, resources: ImportResources, };
 
 export type InternalEvent = { id: string, pluginRefId: string, pluginName: string, replyId: string | null, context: PluginContext, payload: InternalEventPayload, };
 

crates/yaak-plugins/src/events.rs

@@ -247,6 +247,8 @@ pub struct ImportRequest {
 #[serde(default, rename_all = "camelCase")]
 #[ts(export, export_to = "gen_events.ts")]
 pub struct ImportResponse {
+    /// Display name of the importer that recognized the input.
+    pub importer: String,
     pub resources: ImportResources,
 }
 

crates/yaak-plugins/src/manager.rs

@@ -1104,8 +1104,19 @@ impl PluginManager {
             .await?;
 
         // TODO: Don't just return the first valid response
-        let result = reply_events.into_iter().find_map(|e| match e.payload {
-            InternalEventPayload::ImportResponse(resp) => Some(resp),
+        let result = reply_events.into_iter().find_map(|e| match e {
+            InternalEvent {
+                plugin_name,
+                payload: InternalEventPayload::ImportResponse(mut resp),
+                ..
+            } => {
+                // Older plugin runtimes do not include the importer's display name. The plugin
+                // package name is still enough to identify the detected format in that case.
+                if resp.importer.is_empty() {
+                    resp.importer = plugin_name;
+                }
+                Some(resp)
+            }
             _ => None,
         });
 

crates/yaak-web/Cargo.toml

@@ -25,7 +25,6 @@ crate-type = ["cdylib", "rlib"]
 log = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
-yaak-lifecycle = { workspace = true }
 yaak-models = { workspace = true }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
@@ -36,4 +35,3 @@ sqlite-wasm-rs = "0.5"
 sqlite-wasm-vfs = "0.2"
 wasm-bindgen = "0.2.100"
 wasm-bindgen-futures = "0.4"
-web-sys = { version = "0.3", features = ["console"] }

crates/yaak-web/pkg/yaak_web_bg.js

@@ -677,26 +677,23 @@ export function __wbg_versions_215a3ab1c9d5745a(arg0) {
     const ret = arg0.versions;
     return ret;
 }
-export function __wbg_warn_b6f36cac66fc96a4(arg0, arg1) {
-    console.warn(arg0, arg1);
-}
 export function __wbindgen_cast_0000000000000001(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 1103, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 1104, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
     const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__hf84d53817e0238b4);
     return ret;
 }
 export function __wbindgen_cast_0000000000000002(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("Event")], shim_idx: 200, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("Event")], shim_idx: 202, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
     const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h7e06bb925b918fbb);
     return ret;
 }
 export function __wbindgen_cast_0000000000000003(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("IDBVersionChangeEvent")], shim_idx: 177, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h400c17219073e521);
+    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("IDBVersionChangeEvent")], shim_idx: 180, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h7e53e249a4dc4aa9);
     return ret;
 }
 export function __wbindgen_cast_0000000000000004(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 198, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 200, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
     const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h87640adb2bbfa2fc);
     return ret;
 }
@@ -749,8 +746,8 @@ function wasm_bindgen__convert__closures_____invoke__hf84d53817e0238b4(arg0, arg
     }
 }
 
-function wasm_bindgen__convert__closures_____invoke__h400c17219073e521(arg0, arg1, arg2) {
-    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h400c17219073e521(arg0, arg1, arg2);
+function wasm_bindgen__convert__closures_____invoke__h7e53e249a4dc4aa9(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h7e53e249a4dc4aa9(arg0, arg1, arg2);
     if (ret[1]) {
         throw takeFromExternrefTable0(ret[0]);
     }

crates/yaak-web/pkg/yaak_web_bg.wasm.d.ts

@@ -17,7 +17,7 @@ export const rust_sqlite_wasm_realloc: (a: number, b: number) => number;
 export const sqlite3_os_end: () => number;
 export const sqlite3_os_init: () => number;
 export const wasm_bindgen__convert__closures_____invoke__hf84d53817e0238b4: (a: number, b: number, c: any) => [number, number];
-export const wasm_bindgen__convert__closures_____invoke__h400c17219073e521: (a: number, b: number, c: any) => [number, number];
+export const wasm_bindgen__convert__closures_____invoke__h7e53e249a4dc4aa9: (a: number, b: number, c: any) => [number, number];
 export const wasm_bindgen__convert__closures_____invoke__h2c72ca09e851b7f3: (a: number, b: number, c: any, d: any) => void;
 export const wasm_bindgen__convert__closures_____invoke__h7e06bb925b918fbb: (a: number, b: number, c: any) => void;
 export const wasm_bindgen__convert__closures_____invoke__h87640adb2bbfa2fc: (a: number, b: number) => void;

crates/yaak-web/src/lib.rs

@@ -43,10 +43,6 @@ struct Host {
     events: mpsc::Receiver<ModelPayload>,
 }
 
-fn lifecycle_host() -> yaak_lifecycle::Host {
-    yaak_lifecycle::Host::owner()
-}
-
 thread_local! {
     static HOST: RefCell<Option<Host>> = const { RefCell::new(None) };
 }
@@ -95,10 +91,6 @@ pub async fn boot() -> Result<()> {
     let (queries, blobs, events) =
         yaak_models::init_standalone(DB_NAME, BLOB_DB_NAME).map_err(js_error)?;
 
-    if let Err(e) = yaak_lifecycle::on_launch(&lifecycle_host(), &queries.connect(), &blobs) {
-        web_sys::console::warn_2(&"on_launch hook failed".into(), &js_error(e));
-    }
-
     HOST.with(|h| *h.borrow_mut() = Some(Host { queries, blobs, events }));
     Ok(())
 }
@@ -320,28 +312,6 @@ fn dispatch(
             to_json(db.get_or_create_workspace_meta(&workspace.id).map_err(js_error)?)
         }
 
-        "cmd_delete_all_http_responses" => {
-            let req: RequestIdReq = from_js(payload)?;
-            host.queries
-                .connect()
-                .delete_all_http_responses_for_request(&req.request_id, source)
-                .map_err(js_error)?;
-            to_json(())
-        }
-
-        "cmd_delete_send_history" => {
-            let req: WorkspaceIdReq = from_js(payload)?;
-            host.queries
-                .with_tx(|tx| {
-                    tx.delete_all_http_responses_for_workspace(&req.workspace_id, source)?;
-                    tx.delete_all_grpc_connections_for_workspace(&req.workspace_id, source)?;
-                    tx.delete_all_websocket_connections_for_workspace(&req.workspace_id, source)?;
-                    Ok::<(), yaak_models::error::Error>(())
-                })
-                .map_err(js_error)?;
-            to_json(())
-        }
-
         other => Err(js_error(format!("yaak-web: `{other}` is not a command this host answers"))),
     }
 }

crates/yaak/Cargo.toml

@@ -21,5 +21,6 @@ yaak-templates = { workspace = true }
 yaak-tls = { workspace = true }
 
 [dev-dependencies]
+rusqlite = { version = "0.38", features = ["bundled"] }
 tempfile = "3"
 tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }

crates/yaak/src/import.rs

@@ -1,129 +1,826 @@
 use crate::Result;
 use log::info;
-use std::collections::BTreeMap;
-use yaak_core::WorkspaceContext;
+use std::collections::{BTreeMap, BTreeSet};
+use yaak_models::client_db::ClientDb;
 use yaak_models::models::{
-    Environment, Folder, GrpcRequest, HttpRequest, WebsocketRequest, Workspace,
+    DEFAULT_REQUEST_MESSAGE_SIZE, Environment, Folder, GrpcRequest, HttpRequest, UpsertModelInfo,
+    WebsocketRequest, Workspace,
 };
 use yaak_models::query_manager::QueryManager;
-use yaak_models::util::{BatchUpsertResult, UpdateSource, maybe_gen_id, maybe_gen_id_opt};
+use yaak_models::util::{
+    BatchUpsertResult, ImportDestination, ImportPlan, ImportPlanResources, ImportPlanWarning,
+    PlannedImportResource, UpdateSource,
+};
 use yaak_plugins::events::{ImportResources, PluginContext};
 use yaak_plugins::manager::PluginManager;
 
-pub struct ImportDataParams<'a> {
+pub struct PlanImportDataParams<'a> {
     pub query_manager: &'a QueryManager,
     pub plugin_manager: &'a PluginManager,
     pub plugin_context: &'a PluginContext,
-    pub workspace_context: WorkspaceContext,
+    pub destination: ImportDestination,
     pub contents: &'a str,
 }
 
-pub async fn import_data(params: ImportDataParams<'_>) -> Result<BatchUpsertResult> {
+/// Parse importer output and turn it into a commit-ready plan without mutating the database.
+pub async fn plan_import_data(params: PlanImportDataParams<'_>) -> Result<ImportPlan> {
     let import_result =
         params.plugin_manager.import_data(params.plugin_context, params.contents).await?;
 
-    import_resources(params.query_manager, params.workspace_context, import_result.resources)
+    plan_import_resources(
+        params.query_manager,
+        import_result.importer,
+        params.destination,
+        import_result.resources,
+    )
 }
 
-pub fn import_resources(
+/// Remap parsed importer resources into their selected destination.
+///
+/// Every imported model gets a fresh ID. This prevents an import from accidentally updating an
+/// existing model and also makes the plan safe to inspect before it is committed.
+pub fn plan_import_resources(
     query_manager: &QueryManager,
-    workspace_context: WorkspaceContext,
+    importer: String,
+    destination: ImportDestination,
     resources: ImportResources,
-) -> Result<BatchUpsertResult> {
-    let mut id_map: BTreeMap<String, String> = BTreeMap::new();
+) -> Result<ImportPlan> {
+    let mut warnings = Vec::new();
+    validate_destination(query_manager, &destination)?;
 
-    let workspaces: Vec<Workspace> = resources
-        .workspaces
-        .into_iter()
-        .map(|mut v| {
-            v.id = maybe_gen_id::<Workspace>(&workspace_context, v.id.as_str(), &mut id_map);
-            v
-        })
-        .collect();
+    let source_folder_ids = resources.folders.iter().map(|v| v.id.clone()).collect::<BTreeSet<_>>();
+    let mut folder_ids = BTreeMap::new();
+    for folder in &resources.folders {
+        folder_ids.insert(folder.id.clone(), Folder::generate_id());
+    }
 
-    let environments: Vec<Environment> = resources
-        .environments
-        .into_iter()
-        .map(|mut v| {
-            v.id = maybe_gen_id::<Environment>(&workspace_context, v.id.as_str(), &mut id_map);
-            v.workspace_id =
-                maybe_gen_id::<Workspace>(&workspace_context, v.workspace_id.as_str(), &mut id_map);
-            match (v.parent_model.as_str(), v.parent_id.clone().as_deref()) {
-                ("folder", Some(parent_id)) => {
-                    v.parent_id =
-                        Some(maybe_gen_id::<Folder>(&workspace_context, parent_id, &mut id_map));
-                }
-                ("", _) => {
-                    v.parent_model = "workspace".to_string();
-                }
-                _ => {
-                    v.parent_id = None;
-                }
-            };
-            v
-        })
-        .collect();
+    let mut workspace_ids = BTreeMap::new();
+    let mut workspaces = Vec::new();
+    let (default_workspace_id, target_folder_id) = match &destination {
+        ImportDestination::NewWorkspace => {
+            for source in &resources.workspaces {
+                let mut workspace = source.clone();
+                workspace.id = Workspace::generate_id();
+                workspace_ids.insert(source.id.clone(), workspace.id.clone());
+                workspaces.push(PlannedImportResource::new(workspace));
+            }
 
-    let folders: Vec<Folder> = resources
+            if workspaces.is_empty() {
+                let workspace = Workspace {
+                    id: Workspace::generate_id(),
+                    model: "workspace".to_string(),
+                    name: format!("{} Import", display_importer_name(&importer)),
+                    setting_follow_redirects: true,
+                    setting_request_message_size: DEFAULT_REQUEST_MESSAGE_SIZE,
+                    setting_validate_certificates: true,
+                    setting_send_cookies: true,
+                    setting_store_cookies: true,
+                    ..Default::default()
+                };
+                workspaces.push(PlannedImportResource::new(workspace));
+            }
+
+            (workspaces[0].resource.id.clone(), None)
+        }
+        ImportDestination::CurrentWorkspace { workspace_id, folder_id } => {
+            for source in &resources.workspaces {
+                workspace_ids.insert(source.id.clone(), workspace_id.clone());
+            }
+            if !resources.workspaces.is_empty() {
+                let destination_workspace = query_manager.connect().get_workspace(workspace_id)?;
+                let skipped_fields = resources
+                    .workspaces
+                    .iter()
+                    .flat_map(|source| {
+                        workspace_fields_not_imported(source, &destination_workspace)
+                    })
+                    .collect::<BTreeSet<_>>();
+                if !skipped_fields.is_empty() {
+                    let source = if resources.workspaces.len() == 1 {
+                        resources.workspaces[0].name.clone()
+                    } else {
+                        format!("{} imported workspaces", resources.workspaces.len())
+                    };
+                    warnings.push(ImportPlanWarning {
+                        title: "Workspace settings skipped".to_string(),
+                        detail: format!("{source} · {}", display_list(&skipped_fields)),
+                    });
+                }
+            }
+            (workspace_id.clone(), folder_id.clone())
+        }
+    };
+
+    let resolve_workspace_id = |source_id: &str| {
+        workspace_ids.get(source_id).cloned().unwrap_or_else(|| default_workspace_id.clone())
+    };
+
+    let resolve_folder_id = |source_id: Option<String>| match source_id {
+        Some(source_id) if source_folder_ids.contains(&source_id) => {
+            folder_ids.get(&source_id).cloned()
+        }
+        _ => target_folder_id.clone(),
+    };
+
+    let folders = resources
         .folders
         .into_iter()
-        .map(|mut v| {
-            v.id = maybe_gen_id::<Folder>(&workspace_context, v.id.as_str(), &mut id_map);
-            v.workspace_id =
-                maybe_gen_id::<Workspace>(&workspace_context, v.workspace_id.as_str(), &mut id_map);
-            v.folder_id = maybe_gen_id_opt::<Folder>(&workspace_context, v.folder_id, &mut id_map);
-            v
+        .map(|mut folder| {
+            folder.id = folder_ids.get(&folder.id).cloned().unwrap_or_else(Folder::generate_id);
+            folder.workspace_id = resolve_workspace_id(&folder.workspace_id);
+            folder.folder_id = resolve_folder_id(folder.folder_id);
+            PlannedImportResource::new(folder)
         })
         .collect();
 
-    let http_requests: Vec<HttpRequest> = resources
+    let http_requests = resources
         .http_requests
         .into_iter()
-        .map(|mut v| {
-            v.id = maybe_gen_id::<HttpRequest>(&workspace_context, v.id.as_str(), &mut id_map);
-            v.workspace_id =
-                maybe_gen_id::<Workspace>(&workspace_context, v.workspace_id.as_str(), &mut id_map);
-            v.folder_id = maybe_gen_id_opt::<Folder>(&workspace_context, v.folder_id, &mut id_map);
-            v
+        .map(|mut request| {
+            request.id = HttpRequest::generate_id();
+            request.workspace_id = resolve_workspace_id(&request.workspace_id);
+            request.folder_id = resolve_folder_id(request.folder_id);
+            PlannedImportResource::new(request)
         })
         .collect();
 
-    let grpc_requests: Vec<GrpcRequest> = resources
+    let grpc_requests = resources
         .grpc_requests
         .into_iter()
-        .map(|mut v| {
-            v.id = maybe_gen_id::<GrpcRequest>(&workspace_context, v.id.as_str(), &mut id_map);
-            v.workspace_id =
-                maybe_gen_id::<Workspace>(&workspace_context, v.workspace_id.as_str(), &mut id_map);
-            v.folder_id = maybe_gen_id_opt::<Folder>(&workspace_context, v.folder_id, &mut id_map);
-            v
+        .map(|mut request| {
+            request.id = GrpcRequest::generate_id();
+            request.workspace_id = resolve_workspace_id(&request.workspace_id);
+            request.folder_id = resolve_folder_id(request.folder_id);
+            PlannedImportResource::new(request)
         })
         .collect();
 
-    let websocket_requests: Vec<WebsocketRequest> = resources
+    let websocket_requests = resources
         .websocket_requests
         .into_iter()
-        .map(|mut v| {
-            v.id = maybe_gen_id::<WebsocketRequest>(&workspace_context, v.id.as_str(), &mut id_map);
-            v.workspace_id =
-                maybe_gen_id::<Workspace>(&workspace_context, v.workspace_id.as_str(), &mut id_map);
-            v.folder_id = maybe_gen_id_opt::<Folder>(&workspace_context, v.folder_id, &mut id_map);
-            v
+        .map(|mut request| {
+            request.id = WebsocketRequest::generate_id();
+            request.workspace_id = resolve_workspace_id(&request.workspace_id);
+            request.folder_id = resolve_folder_id(request.folder_id);
+            PlannedImportResource::new(request)
         })
         .collect();
 
-    info!("Importing data");
+    let importing_into_current = matches!(destination, ImportDestination::CurrentWorkspace { .. });
+    let mut separated_base_environments = Vec::new();
+    let mut converted_duplicate_base_environment = false;
+    let mut converted_duplicate_folder_environment = false;
+    let mut base_environment_workspaces = BTreeSet::new();
+    let mut folder_environment_ids = BTreeSet::new();
+    let environments = resources
+        .environments
+        .into_iter()
+        .map(|mut environment| {
+            environment.id = Environment::generate_id();
+            environment.workspace_id = resolve_workspace_id(&environment.workspace_id);
 
-    query_manager.with_tx(|tx| {
-        tx.batch_upsert(
+            match (environment.parent_model.as_str(), environment.parent_id.clone()) {
+                ("workspace", _) if importing_into_current => {
+                    environment.parent_model = "environment".to_string();
+                    environment.parent_id = None;
+                    let source_name = environment.name.clone();
+                    environment.name = format!("{} (Imported)", environment.name);
+                    separated_base_environments.push((
+                        source_name,
+                        environment.name.clone(),
+                        environment.variables.len(),
+                    ));
+                }
+                ("workspace", _) => {
+                    environment.parent_id = None;
+                    if !base_environment_workspaces.insert(environment.workspace_id.clone()) {
+                        environment.parent_model = "environment".to_string();
+                        environment.name = format!("{} (Imported)", environment.name);
+                        converted_duplicate_base_environment = true;
+                    }
+                }
+                ("folder", Some(parent_id)) if source_folder_ids.contains(&parent_id) => {
+                    environment.parent_id = folder_ids.get(&parent_id).cloned();
+                    if let Some(parent_id) = &environment.parent_id
+                        && !folder_environment_ids.insert(parent_id.clone())
+                    {
+                        environment.parent_model = "environment".to_string();
+                        environment.parent_id = None;
+                        converted_duplicate_folder_environment = true;
+                    }
+                }
+                ("folder", _) => {
+                    // Never attach an imported folder environment to an existing folder: the model
+                    // layer permits only one and would otherwise delete the destination's value.
+                    environment.parent_model = "environment".to_string();
+                    environment.parent_id = None;
+                }
+                ("environment", _) => {
+                    environment.parent_id = None;
+                }
+                _ => {
+                    environment.parent_model = "environment".to_string();
+                    environment.parent_id = None;
+                }
+            }
+
+            PlannedImportResource::new(environment)
+        })
+        .collect();
+
+    for (source_name, imported_name, variable_count) in separated_base_environments {
+        let variables = if variable_count == 1 { "variable" } else { "variables" };
+        warnings.push(ImportPlanWarning {
+            title: "Base environment kept separate".to_string(),
+            detail: format!("{source_name} → {imported_name} · {variable_count} {variables}"),
+        });
+    }
+    if converted_duplicate_base_environment {
+        warnings.push(ImportPlanWarning {
+            title: "Base environments separated".to_string(),
+            detail: "Only the first remains the base environment".to_string(),
+        });
+    }
+    if converted_duplicate_folder_environment {
+        warnings.push(ImportPlanWarning {
+            title: "Folder environments separated".to_string(),
+            detail: "Only the first remains attached to each folder".to_string(),
+        });
+    }
+
+    Ok(ImportPlan {
+        importer,
+        destination,
+        resources: ImportPlanResources {
             workspaces,
             environments,
             folders,
             http_requests,
             grpc_requests,
             websocket_requests,
+        },
+        warnings,
+    })
+}
+
+/// Commit a previously prepared plan in one transaction.
+pub fn commit_import_plan(
+    query_manager: &QueryManager,
+    plan: ImportPlan,
+) -> Result<BatchUpsertResult> {
+    validate_plan(&plan)?;
+    let resources = plan.resources.into_batch();
+
+    info!("Committing staged import from {}", plan.importer);
+    query_manager.with_tx(|tx| {
+        validate_destination_db(tx, &plan.destination)?;
+        tx.batch_upsert(
+            resources.workspaces,
+            resources.environments,
+            resources.folders,
+            resources.http_requests,
+            resources.grpc_requests,
+            resources.websocket_requests,
             &UpdateSource::Import,
         )
         .map_err(crate::Error::from)
     })
 }
+
+fn validate_destination(
+    query_manager: &QueryManager,
+    destination: &ImportDestination,
+) -> Result<()> {
+    let db = query_manager.connect();
+    validate_destination_db(&db, destination)
+}
+
+fn validate_destination_db(db: &ClientDb<'_>, destination: &ImportDestination) -> Result<()> {
+    let ImportDestination::CurrentWorkspace { workspace_id, folder_id } = destination else {
+        return Ok(());
+    };
+
+    db.get_workspace(workspace_id)?;
+    if let Some(folder_id) = folder_id {
+        let folder = db.get_folder(folder_id)?;
+        if folder.workspace_id != *workspace_id {
+            return Err(yaak_models::error::Error::GenericError(format!(
+                "Folder {folder_id} does not belong to workspace {workspace_id}"
+            ))
+            .into());
+        }
+    }
+    Ok(())
+}
+
+fn validate_plan(plan: &ImportPlan) -> Result<()> {
+    let invalid = |message: String| -> Result<()> {
+        Err(yaak_models::error::Error::GenericError(message).into())
+    };
+
+    match &plan.destination {
+        ImportDestination::CurrentWorkspace { workspace_id, .. } => {
+            if !plan.resources.workspaces.is_empty() {
+                return invalid(
+                    "A current-workspace import plan must not contain workspace updates"
+                        .to_string(),
+                );
+            }
+
+            let all_workspace_ids = plan
+                .resources
+                .environments
+                .iter()
+                .map(|v| &v.resource.workspace_id)
+                .chain(plan.resources.folders.iter().map(|v| &v.resource.workspace_id))
+                .chain(plan.resources.http_requests.iter().map(|v| &v.resource.workspace_id))
+                .chain(plan.resources.grpc_requests.iter().map(|v| &v.resource.workspace_id))
+                .chain(plan.resources.websocket_requests.iter().map(|v| &v.resource.workspace_id));
+            if all_workspace_ids.into_iter().any(|id| id != workspace_id) {
+                return invalid(
+                    "A current-workspace import plan contains resources for another workspace"
+                        .to_string(),
+                );
+            }
+
+            if plan.resources.environments.iter().any(|v| v.resource.parent_model == "workspace") {
+                return invalid(
+                    "A current-workspace import plan must not replace the base environment"
+                        .to_string(),
+                );
+            }
+        }
+        ImportDestination::NewWorkspace => {
+            let workspace_ids = plan
+                .resources
+                .workspaces
+                .iter()
+                .map(|v| v.resource.id.as_str())
+                .collect::<BTreeSet<_>>();
+            if workspace_ids.is_empty() {
+                return invalid("A new-workspace import plan has no workspace".to_string());
+            }
+            let all_workspace_ids = plan
+                .resources
+                .environments
+                .iter()
+                .map(|v| v.resource.workspace_id.as_str())
+                .chain(plan.resources.folders.iter().map(|v| v.resource.workspace_id.as_str()))
+                .chain(
+                    plan.resources.http_requests.iter().map(|v| v.resource.workspace_id.as_str()),
+                )
+                .chain(
+                    plan.resources.grpc_requests.iter().map(|v| v.resource.workspace_id.as_str()),
+                )
+                .chain(
+                    plan.resources
+                        .websocket_requests
+                        .iter()
+                        .map(|v| v.resource.workspace_id.as_str()),
+                );
+            if all_workspace_ids.into_iter().any(|id| !workspace_ids.contains(id)) {
+                return invalid(
+                    "A new-workspace import plan contains resources outside its workspaces"
+                        .to_string(),
+                );
+            }
+
+            let mut base_environment_workspaces = BTreeSet::new();
+            if plan.resources.environments.iter().any(|v| {
+                v.resource.parent_model == "workspace"
+                    && !base_environment_workspaces.insert(v.resource.workspace_id.as_str())
+            }) {
+                return invalid(
+                    "A new-workspace import plan contains multiple base environments for one workspace"
+                        .to_string(),
+                );
+            }
+        }
+    }
+
+    let planned_folder_ids =
+        plan.resources.folders.iter().map(|v| v.resource.id.as_str()).collect::<BTreeSet<_>>();
+    if plan.resources.environments.iter().any(|v| {
+        v.resource.parent_model == "folder"
+            && v.resource.parent_id.as_deref().is_none_or(|id| !planned_folder_ids.contains(id))
+    }) {
+        return invalid(
+            "An import plan must not replace an existing folder environment".to_string(),
+        );
+    }
+
+    Ok(())
+}
+
+fn display_importer_name(importer: &str) -> &str {
+    importer.strip_prefix("@yaak/importer-").unwrap_or(importer)
+}
+
+fn workspace_fields_not_imported(source: &Workspace, destination: &Workspace) -> Vec<&'static str> {
+    let mut fields = Vec::new();
+    if source.name != destination.name {
+        fields.push("workspace name");
+    }
+    if source.description != destination.description {
+        fields.push("description");
+    }
+    if source.authentication != destination.authentication
+        || source.authentication_type != destination.authentication_type
+    {
+        fields.push("authentication");
+    }
+    if source.headers != destination.headers {
+        fields.push("default headers");
+    }
+    if source.encryption_key_challenge != destination.encryption_key_challenge {
+        fields.push("encryption configuration");
+    }
+    if source.setting_validate_certificates != destination.setting_validate_certificates {
+        fields.push("certificate validation");
+    }
+    if source.setting_follow_redirects != destination.setting_follow_redirects {
+        fields.push("redirect behavior");
+    }
+    if source.setting_request_timeout != destination.setting_request_timeout {
+        fields.push("request timeout");
+    }
+    if source.setting_request_message_size != destination.setting_request_message_size {
+        fields.push("request message size");
+    }
+    if source.setting_dns_overrides != destination.setting_dns_overrides {
+        fields.push("DNS overrides");
+    }
+    if source.setting_send_cookies != destination.setting_send_cookies
+        || source.setting_store_cookies != destination.setting_store_cookies
+    {
+        fields.push("cookie behavior");
+    }
+    fields
+}
+
+fn display_list(items: &BTreeSet<&str>) -> String {
+    let items = items.iter().copied().collect::<Vec<_>>();
+    match items.as_slice() {
+        [] => String::new(),
+        [item] => (*item).to_string(),
+        [first, second] => format!("{first} and {second}"),
+        _ => format!("{}, and {}", items[..items.len() - 1].join(", "), items[items.len() - 1]),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+    use yaak_models::models::{EnvironmentVariable, HttpRequestHeader};
+
+    fn destination_workspace() -> Workspace {
+        Workspace {
+            id: "wk_destination".to_string(),
+            model: "workspace".to_string(),
+            name: "Destination".to_string(),
+            authentication: BTreeMap::from([("token".to_string(), json!("keep-me"))]),
+            authentication_type: Some("bearer".to_string()),
+            headers: vec![HttpRequestHeader {
+                enabled: true,
+                name: "X-Destination".to_string(),
+                value: "preserved".to_string(),
+                id: None,
+            }],
+            setting_validate_certificates: false,
+            setting_follow_redirects: false,
+            setting_request_timeout: 1234,
+            ..Default::default()
+        }
+    }
+
+    fn imported_resources() -> ImportResources {
+        ImportResources {
+            workspaces: vec![Workspace {
+                id: "wk_source".to_string(),
+                model: "workspace".to_string(),
+                name: "Imported".to_string(),
+                authentication_type: Some("basic".to_string()),
+                setting_validate_certificates: true,
+                ..Default::default()
+            }],
+            environments: vec![Environment {
+                id: "ev_source_base".to_string(),
+                model: "environment".to_string(),
+                workspace_id: "wk_source".to_string(),
+                name: "Global Variables".to_string(),
+                parent_model: "workspace".to_string(),
+                variables: vec![EnvironmentVariable {
+                    enabled: true,
+                    name: "imported".to_string(),
+                    value: "yes".to_string(),
+                    id: None,
+                }],
+                ..Default::default()
+            }],
+            folders: vec![Folder {
+                id: "fl_source".to_string(),
+                model: "folder".to_string(),
+                workspace_id: "wk_source".to_string(),
+                name: "Imported Folder".to_string(),
+                ..Default::default()
+            }],
+            http_requests: vec![
+                HttpRequest {
+                    id: "rq_root".to_string(),
+                    model: "http_request".to_string(),
+                    workspace_id: "wk_source".to_string(),
+                    name: "Root Request".to_string(),
+                    method: "GET".to_string(),
+                    url: "https://example.com/root".to_string(),
+                    ..Default::default()
+                },
+                HttpRequest {
+                    id: "rq_nested".to_string(),
+                    model: "http_request".to_string(),
+                    workspace_id: "wk_source".to_string(),
+                    folder_id: Some("fl_source".to_string()),
+                    name: "Nested Request".to_string(),
+                    method: "GET".to_string(),
+                    url: "https://example.com/nested".to_string(),
+                    ..Default::default()
+                },
+            ],
+            ..Default::default()
+        }
+    }
+
+    #[test]
+    fn current_workspace_plan_does_not_mutate_and_preserves_workspace_settings() {
+        let (query_manager, _blob_manager, _rx) =
+            yaak_models::init_in_memory().expect("initialize database");
+        let mut destination = destination_workspace();
+        let selected_folder = Folder {
+            id: "fl_selected".to_string(),
+            model: "folder".to_string(),
+            workspace_id: destination.id.clone(),
+            name: "Selected Folder".to_string(),
+            ..Default::default()
+        };
+        {
+            let db = query_manager.connect();
+            destination = db
+                .upsert_workspace(&destination, &UpdateSource::Import)
+                .expect("create destination");
+            db.upsert_folder(&selected_folder, &UpdateSource::Import)
+                .expect("create selected folder");
+            db.upsert_environment(
+                &Environment {
+                    id: "ev_destination_base".to_string(),
+                    model: "environment".to_string(),
+                    workspace_id: destination.id.clone(),
+                    name: "Destination Variables".to_string(),
+                    parent_model: "workspace".to_string(),
+                    variables: vec![EnvironmentVariable {
+                        enabled: true,
+                        name: "destination".to_string(),
+                        value: "keep".to_string(),
+                        id: None,
+                    }],
+                    ..Default::default()
+                },
+                &UpdateSource::Import,
+            )
+            .expect("create base environment");
+        }
+
+        let plan = plan_import_resources(
+            &query_manager,
+            "OpenAPI".to_string(),
+            ImportDestination::CurrentWorkspace {
+                workspace_id: destination.id.clone(),
+                folder_id: Some(selected_folder.id.clone()),
+            },
+            imported_resources(),
+        )
+        .expect("plan import");
+
+        // Planning performed only reads.
+        {
+            let db = query_manager.connect();
+            assert_eq!(db.list_workspaces().expect("list workspaces").len(), 1);
+            assert_eq!(db.list_folders(&destination.id).expect("list folders").len(), 1);
+            assert!(db.list_http_requests(&destination.id).expect("list requests").is_empty());
+            assert_eq!(
+                db.list_environments_ensure_base(&destination.id).expect("list environments").len(),
+                1
+            );
+            assert_eq!(db.get_workspace(&destination.id).expect("get destination"), destination);
+        }
+
+        assert!(plan.resources.workspaces.is_empty());
+        assert_eq!(plan.resources.folders[0].resource.workspace_id, destination.id);
+        assert_eq!(
+            plan.resources.folders[0].resource.folder_id.as_deref(),
+            Some(selected_folder.id.as_str())
+        );
+        let root_request = plan
+            .resources
+            .http_requests
+            .iter()
+            .find(|v| v.resource.name == "Root Request")
+            .expect("root request");
+        assert_eq!(root_request.resource.folder_id.as_deref(), Some(selected_folder.id.as_str()));
+        let nested_request = plan
+            .resources
+            .http_requests
+            .iter()
+            .find(|v| v.resource.name == "Nested Request")
+            .expect("nested request");
+        assert_eq!(
+            nested_request.resource.folder_id,
+            Some(plan.resources.folders[0].resource.id.clone())
+        );
+        assert_eq!(plan.resources.environments[0].resource.parent_model, "environment");
+        assert!(plan.resources.environments[0].resource.name.ends_with("(Imported)"));
+        assert_eq!(plan.warnings.len(), 2);
+        assert!(plan.warnings.iter().any(|warning| {
+            warning.title == "Workspace settings skipped"
+                && warning.detail.starts_with("Imported ·")
+                && warning.detail.contains("authentication")
+                && warning.detail.contains("default headers")
+        }));
+        assert!(plan.warnings.iter().any(|warning| {
+            warning.title == "Base environment kept separate"
+                && warning.detail == "Global Variables → Global Variables (Imported) · 1 variable"
+        }));
+
+        let committed = commit_import_plan(&query_manager, plan).expect("commit import");
+        assert!(committed.workspaces.is_empty());
+        assert_eq!(committed.http_requests.len(), 2);
+        assert_eq!(
+            query_manager
+                .connect()
+                .get_workspace(&destination.id)
+                .expect("get destination after commit"),
+            destination
+        );
+    }
+
+    #[test]
+    fn environment_collisions_are_explicit_and_do_not_overwrite() {
+        let (query_manager, _blob_manager, _rx) =
+            yaak_models::init_in_memory().expect("initialize database");
+        let mut resources = imported_resources();
+        resources.environments.extend([
+            Environment {
+                id: "ev_second_base".to_string(),
+                model: "environment".to_string(),
+                workspace_id: "wk_source".to_string(),
+                name: "Second Base".to_string(),
+                parent_model: "workspace".to_string(),
+                ..Default::default()
+            },
+            Environment {
+                id: "ev_folder_one".to_string(),
+                model: "environment".to_string(),
+                workspace_id: "wk_source".to_string(),
+                name: "Folder One".to_string(),
+                parent_model: "folder".to_string(),
+                parent_id: Some("fl_source".to_string()),
+                ..Default::default()
+            },
+            Environment {
+                id: "ev_folder_two".to_string(),
+                model: "environment".to_string(),
+                workspace_id: "wk_source".to_string(),
+                name: "Folder Two".to_string(),
+                parent_model: "folder".to_string(),
+                parent_id: Some("fl_source".to_string()),
+                ..Default::default()
+            },
+        ]);
+
+        let plan = plan_import_resources(
+            &query_manager,
+            "Yaak".to_string(),
+            ImportDestination::NewWorkspace,
+            resources,
+        )
+        .expect("plan import");
+
+        assert_eq!(
+            plan.resources
+                .environments
+                .iter()
+                .filter(|v| v.resource.parent_model == "workspace")
+                .count(),
+            1
+        );
+        assert_eq!(
+            plan.resources
+                .environments
+                .iter()
+                .filter(|v| v.resource.parent_model == "folder")
+                .count(),
+            1
+        );
+        assert_eq!(plan.warnings.len(), 2);
+    }
+
+    #[test]
+    fn importer_id_conventions_all_flow_through_the_same_planner() {
+        let (query_manager, _blob_manager, _rx) =
+            yaak_models::init_in_memory().expect("initialize database");
+        let destination = destination_workspace();
+        query_manager
+            .connect()
+            .upsert_workspace(&destination, &UpdateSource::Import)
+            .expect("create destination");
+        let resources = ImportResources {
+            workspaces: vec![
+                Workspace {
+                    id: "GENERATE_ID::WORKSPACE_0".to_string(),
+                    model: "workspace".to_string(),
+                    name: "Generated ID Importer".to_string(),
+                    ..Default::default()
+                },
+                Workspace {
+                    id: "wk_exported".to_string(),
+                    model: "workspace".to_string(),
+                    name: "Stable ID Importer".to_string(),
+                    ..Default::default()
+                },
+            ],
+            http_requests: [
+                "GENERATE_ID::WORKSPACE_0",
+                "wk_exported",
+                "CURRENT_WORKSPACE",
+            ]
+            .into_iter()
+            .enumerate()
+            .map(|(index, workspace_id)| HttpRequest {
+                id: format!("GENERATE_ID::HTTP_REQUEST_{index}"),
+                model: "http_request".to_string(),
+                workspace_id: workspace_id.to_string(),
+                name: format!("Request {index}"),
+                method: "GET".to_string(),
+                ..Default::default()
+            })
+            .collect(),
+            ..Default::default()
+        };
+
+        let plan = plan_import_resources(
+            &query_manager,
+            "Compatibility".to_string(),
+            ImportDestination::CurrentWorkspace {
+                workspace_id: destination.id.clone(),
+                folder_id: None,
+            },
+            resources,
+        )
+        .expect("plan import");
+
+        assert!(plan.resources.workspaces.is_empty());
+        assert!(
+            plan.resources.http_requests.iter().all(|v| v.resource.workspace_id == destination.id)
+        );
+        assert_eq!(
+            plan.resources
+                .http_requests
+                .iter()
+                .map(|v| v.resource.id.as_str())
+                .collect::<BTreeSet<_>>()
+                .len(),
+            3
+        );
+    }
+
+    #[test]
+    fn commit_rolls_back_every_resource_when_a_late_write_fails() {
+        let dir = tempfile::tempdir().expect("create temp directory");
+        let db_path = dir.path().join("models.sqlite");
+        let blob_path = dir.path().join("blobs.sqlite");
+        let (query_manager, _blob_manager, _rx) =
+            yaak_models::init_standalone(&db_path, &blob_path).expect("initialize database");
+        let plan = plan_import_resources(
+            &query_manager,
+            "OpenAPI".to_string(),
+            ImportDestination::NewWorkspace,
+            imported_resources(),
+        )
+        .expect("plan import");
+        let workspace_id = plan.resources.workspaces[0].resource.id.clone();
+        let environment_id = plan.resources.environments[0].resource.id.clone();
+
+        let connection = rusqlite::Connection::open(&db_path).expect("open test database");
+        connection
+            .execute_batch(&format!(
+                "CREATE TRIGGER fail_import_environment BEFORE INSERT ON environments \
+                 WHEN NEW.id = '{environment_id}' BEGIN SELECT RAISE(FAIL, 'forced failure'); END;"
+            ))
+            .expect("install failure trigger");
+        drop(connection);
+
+        assert!(commit_import_plan(&query_manager, plan).is_err());
+        let db = query_manager.connect();
+        assert!(db.get_workspace(&workspace_id).is_err(), "workspace insert must roll back");
+        assert!(db.get_environment(&environment_id).is_err(), "environment must not exist");
+    }
+}

packages/platform/src/tauri/index.ts

@@ -59,7 +59,6 @@ const ALL_CAPABILITIES: PlatformCapabilities = {
   timeline: true,
   multiWindow: true,
   windowChrome: true,
-  interfaceZoom: true,
   plugins: true,
   encryption: true,
   updater: true,

packages/platform/src/types.ts

@@ -262,11 +262,6 @@ export interface PlatformCapabilities {
    * chrome should be reserved or drawn.
    */
   windowChrome: boolean;
-  /**
-   * The app zooms its own interface, and so owns Cmd/Ctrl `+`, `-` and `0`.
-   * False in a browser, where those keys are already the browser's.
-   */
-  interfaceZoom: boolean;
   /** The plugin runtime. */
   plugins: boolean;
   /** Workspace encryption backed by a key the host keeps. */

packages/platform/src/web/README.md

@@ -129,10 +129,7 @@ Reported honestly, so callers gate on the question rather than on the host:
 
 | True | False |
 | --- | --- |
-| `cookieJar` (the jar stores and edits here; only filling it needs the sender) | `grpc`, `websocket`, `git`, `sync`, `tlsOptions`, `localFiles`, `timeline`, `multiWindow`, `windowChrome`, `interfaceZoom`, `plugins`, `encryption`, `updater`, `clipboardRead`, `systemFonts`, `license` |
-
-`interfaceZoom: false` leaves Cmd/Ctrl `+`, `-` and `0` to the browser instead
-of swallowing them, and drops those three rows from the hotkeys screen.
+| `cookieJar` (the jar stores and edits here; only filling it needs the sender) | `grpc`, `websocket`, `git`, `sync`, `tlsOptions`, `localFiles`, `timeline`, `multiWindow`, `windowChrome`, `plugins`, `encryption`, `updater`, `clipboardRead`, `systemFonts`, `license` |
 
 `multiWindow: false` means the host cannot open a *second window* on demand —
 what `cmd_new_child_window` does for Settings and workspace switching. It is not

packages/platform/src/web/commands.ts

@@ -65,8 +65,6 @@ const HANDLERS: Partial<Record<AppCmd, Handler>> = {
   models_grpc_events: (payload, db) => db.rpc("models_grpc_events", payload),
   models_websocket_events: (payload, db) => db.rpc("models_websocket_events", payload),
   cmd_get_workspace_meta: (payload, db) => db.rpc("cmd_get_workspace_meta", payload),
-  cmd_delete_all_http_responses: (payload, db) => db.rpc("cmd_delete_all_http_responses", payload),
-  cmd_delete_send_history: (payload, db) => db.rpc("cmd_delete_send_history", payload),
 
   /* -------------------------------- app ---------------------------------- */
 
@@ -263,6 +261,7 @@ const DECLINED: Partial<Record<AppCmd, [reason: string, capability: CapabilityNa
   // Anything that needs files the page can't reach.
   cmd_import_data: ["Importing from a file needs a filesystem, which a browser tab has no", "localFiles"],
   cmd_import_url: ["Importing from a URL needs the send proxy, which isn't available yet", null],
+  cmd_commit_import: ["Importing needs a plugin, which this host doesn't run", null],
   cmd_export_data: ["Exporting to a file isn't available in the browser yet", "localFiles"],
   cmd_save_response: ["Saving a response to disk isn't available in the browser", "localFiles"],
   cmd_save_base64_to_binary: ["Saving to disk isn't available in the browser", "localFiles"],
@@ -300,6 +299,10 @@ const DECLINED: Partial<Record<AppCmd, [reason: string, capability: CapabilityNa
   cmd_call_folder_action: ["Plugins aren't available in the browser yet", "plugins"],
   cmd_call_http_authentication_action: ["Plugins aren't available in the browser yet", "plugins"],
 
+  // Sending history and its bookkeeping belong to the send slice.
+  cmd_delete_send_history: ["Sending isn't available in the browser yet", null],
+  cmd_delete_all_http_responses: ["Sending isn't available in the browser yet", null],
+
   cmd_send_feedback: ["Feedback goes through the desktop app for now", null],
 };
 

packages/platform/src/web/index.ts

@@ -52,9 +52,6 @@ function capabilitiesFor(): PlatformCapabilities {
     // The browser draws the frame around the page. There are no traffic lights
     // to leave room for and no window controls to draw.
     windowChrome: false,
-    // The browser already zooms the page, on the same keys, and remembers it
-    // per site. The app stays out of the way.
-    interfaceZoom: false,
     plugins: false,
     encryption: false,
     updater: false,

packages/plugin-runtime-types/src/bindings/gen_events.ts

@@ -474,7 +474,7 @@ export type ImportRequest = { content: string, };
 
 export type ImportResources = { workspaces: Array<Workspace>, environments: Array<Environment>, folders: Array<Folder>, httpRequests: Array<HttpRequest>, grpcRequests: Array<GrpcRequest>, websocketRequests: Array<WebsocketRequest>, };
 
-export type ImportResponse = { resources: ImportResources, };
+export type ImportResponse = { importer: string, resources: ImportResources, };
 
 export type InternalEvent = { id: string, pluginRefId: string, pluginName: string, replyId: string | null, context: PluginContext, payload: InternalEventPayload, };
 

packages/plugin-runtime/src/PluginInstance.ts

@@ -167,6 +167,7 @@ export class PluginInstance {
         if (reply != null) {
           const replyPayload: InternalEventPayload = {
             type: "import_response",
+            importer: this.#mod.importer.name,
             resources: reply.resources as ImportResources,
           };
           this.#sendPayload(context, replyPayload, replyId);

plugins/auth-oauth2/src/fetchAccessToken.ts

@@ -31,13 +31,7 @@ export async function fetchAccessToken(
     ],
   };
 
-  // RFC 6749 §4.1.3 doesn't define scope for the authorization code token
-  // request, so strict servers (OpenIddict) reject it outright. Scope belongs on
-  // the authorize request, which already sends it. Every other grant does define
-  // it: §4.3.2 password, §4.4.2 client credentials, §6 refresh.
-  if (scope && grantType !== "authorization_code") {
-    httpRequest.body?.form.push({ name: "scope", value: scope });
-  }
+  if (scope) httpRequest.body?.form.push({ name: "scope", value: scope });
   if (audience) httpRequest.body?.form.push({ name: "audience", value: audience });
 
   if ("clientAssertion" in args) {

plugins/auth-oauth2/tests/fetchAccessToken.test.ts

@@ -1,93 +0,0 @@
-import type { HttpRequest } from "@yaakapp/api";
-import { describe, expect, test } from "vite-plus/test";
-import { fetchAccessToken } from "../src/fetchAccessToken";
-
-/**
- * Captures the request handed to ctx.httpRequest.send so tests can assert on the
- * form body, and replies with a minimal successful token response.
- */
-function createMockContext() {
-  const sent: Partial<HttpRequest>[] = [];
-
-  const ctx = {
-    httpRequest: {
-      async send({ httpRequest }: { httpRequest: Partial<HttpRequest> }) {
-        sent.push(httpRequest);
-        return {
-          httpResponse: { status: 200, error: null },
-          body: {
-            async text() {
-              return JSON.stringify({ access_token: "token-123" });
-            },
-          },
-        };
-      },
-    },
-  } as never;
-
-  return { ctx, sent };
-}
-
-function formNames(httpRequest: Partial<HttpRequest>) {
-  return (httpRequest.body?.form ?? []).map((p: { name: string }) => p.name);
-}
-
-function formValue(httpRequest: Partial<HttpRequest>, name: string) {
-  return (httpRequest.body?.form ?? []).find((p: { name: string }) => p.name === name)?.value;
-}
-
-const baseArgs = {
-  clientId: "client-123",
-  accessTokenUrl: "https://auth.example.com/token",
-  scope: "openid profile",
-  audience: null,
-  clientSecret: "secret",
-  credentialsInBody: true,
-  params: [],
-};
-
-describe("fetchAccessToken scope handling", () => {
-  test("omits scope for the authorization code grant", async () => {
-    const { ctx, sent } = createMockContext();
-
-    await fetchAccessToken(ctx, {
-      ...baseArgs,
-      grantType: "authorization_code",
-      params: [{ name: "code", value: "abc" }],
-    });
-
-    expect(formNames(sent[0]!)).not.toContain("scope");
-    // The rest of the request is untouched
-    expect(formValue(sent[0]!, "grant_type")).toBe("authorization_code");
-    expect(formValue(sent[0]!, "code")).toBe("abc");
-  });
-
-  test("sends scope for the client credentials grant", async () => {
-    const { ctx, sent } = createMockContext();
-
-    await fetchAccessToken(ctx, { ...baseArgs, grantType: "client_credentials" });
-
-    expect(formValue(sent[0]!, "scope")).toBe("openid profile");
-  });
-
-  test("sends scope for the password grant", async () => {
-    const { ctx, sent } = createMockContext();
-
-    await fetchAccessToken(ctx, { ...baseArgs, grantType: "password" });
-
-    expect(formValue(sent[0]!, "scope")).toBe("openid profile");
-  });
-
-  test("still sends audience for the authorization code grant", async () => {
-    const { ctx, sent } = createMockContext();
-
-    await fetchAccessToken(ctx, {
-      ...baseArgs,
-      grantType: "authorization_code",
-      audience: "https://api.example.com",
-    });
-
-    expect(formValue(sent[0]!, "audience")).toBe("https://api.example.com");
-    expect(formNames(sent[0]!)).not.toContain("scope");
-  });
-});