Add request message size setting

Cargo.lock

@@ -10052,6 +10052,7 @@ dependencies = [
  "tempfile",
  "thiserror 2.0.17",
  "tokio",
+ "yaak-core",
  "yaak-crypto",
  "yaak-http",
  "yaak-models",
@@ -10182,6 +10183,7 @@ dependencies = [
  "webbrowser",
  "yaak",
  "yaak-api",
+ "yaak-core",
  "yaak-crypto",
  "yaak-http",
  "yaak-models",

apps/yaak-client/components/CookieDialog.tsx

@@ -130,7 +130,7 @@ export const CookieDialog = ({ cookieJarId }: Props) => {
       return key !== nextCookieKey;
     });
 
-    patchModel(cookieJar, { cookies: [...nextCookies, nextCookie] });
+    void patchModel(cookieJar, { cookies: [...nextCookies, nextCookie] });
     setSelectedCookieKey(nextCookieKey);
     setEditingCookieKey(null);
     setDraftCookie(null);
@@ -210,7 +210,7 @@ export const CookieDialog = ({ cookieJarId }: Props) => {
                           setEditingCookieKey(null);
                           setDraftCookie(null);
                           setDraftExpiresInput("");
-                          patchModel(cookieJar, { cookies: [] });
+                          void patchModel(cookieJar, { cookies: [] });
                         }}
                       />
                     </TableHeaderCell>
@@ -276,7 +276,7 @@ export const CookieDialog = ({ cookieJarId }: Props) => {
                                 setDraftCookie(null);
                                 setDraftExpiresInput("");
                               }
-                              patchModel(cookieJar, {
+                              void patchModel(cookieJar, {
                                 cookies: cookieJar.cookies.filter(
                                   (c2: Cookie) => cookieKey(c2) !== key,
                                 ),
@@ -570,6 +570,8 @@ function CookieTextInput({
   return (
     <input
       autoFocus={autoFocus}
+      autoCapitalize="off"
+      autoCorrect="off"
       className={cookieInputClassName}
       disabled={disabled}
       onChange={(event) => onChange(event.target.value)}
@@ -585,6 +587,8 @@ function CookieTextInput({
 function CookieTextarea({ onChange, value }: { onChange: (value: string) => void; value: string }) {
   return (
     <textarea
+      autoCapitalize="off"
+      autoCorrect="off"
       className={classNames(cookieInputClassName, "min-h-[5rem] resize-y")}
       onChange={(event) => onChange(event.target.value)}
       value={value}

apps/yaak-client/components/ModelSettingsEditor.tsx

@@ -13,6 +13,7 @@ import {
   modelSupportsSetting,
   type RequestSettingDefinition,
   SETTING_FOLLOW_REDIRECTS,
+  SETTING_REQUEST_MESSAGE_SIZE,
   SETTING_REQUEST_TIMEOUT,
   SETTING_SEND_COOKIES,
   SETTING_STORE_COOKIES,
@@ -33,10 +34,29 @@ interface Props {
   model: ModelWithSettings;
 }
 
-type ModelWithSettings = Workspace | Folder | HttpRequest | WebsocketRequest | GrpcRequest;
+type ModelWithSettings =
+  | Workspace
+  | Folder
+  | HttpRequest
+  | WebsocketRequest
+  | GrpcRequest;
 type ModelWithHttpSettings = Workspace | Folder | HttpRequest;
-type ModelWithTlsSettings = Workspace | Folder | HttpRequest | WebsocketRequest | GrpcRequest;
-type ModelWithCookieSettings = Workspace | Folder | HttpRequest | WebsocketRequest;
+type ModelWithTlsSettings =
+  | Workspace
+  | Folder
+  | HttpRequest
+  | WebsocketRequest
+  | GrpcRequest;
+type ModelWithCookieSettings =
+  | Workspace
+  | Folder
+  | HttpRequest
+  | WebsocketRequest;
+type ModelWithMessageSizeSettings =
+  | Workspace
+  | Folder
+  | WebsocketRequest
+  | GrpcRequest;
 type BooleanSetting = boolean | InheritedBoolSetting;
 type IntegerSetting = number | InheritedIntSetting;
 type CookieSettingsPatch = {
@@ -50,12 +70,19 @@ type HttpSettingsPatch = {
 type TlsSettingsPatch = {
   settingValidateCertificates?: ModelWithTlsSettings["settingValidateCertificates"];
 };
+type MessageSizeSettingsPatch = {
+  settingRequestMessageSize?: ModelWithMessageSizeSettings["settingRequestMessageSize"];
+};
 
-export function ModelSettingsEditor({ model, showSectionTitles = false }: Props) {
+export function ModelSettingsEditor({
+  model,
+  showSectionTitles = false,
+}: Props) {
   const ancestors = useModelAncestors(model);
   const supportsHttpSettings = modelSupportsHttpSettings(model);
   const supportsCookieSettings = modelSupportsCookieSettings(model);
   const supportsTlsSettings = modelSupportsTlsSettings(model);
+  const supportsMessageSizeSettings = modelSupportsMessageSizeSettings(model);
 
   return (
     <SettingsList className="space-y-8">
@@ -77,6 +104,22 @@ export function ModelSettingsEditor({ model, showSectionTitles = false }: Props)
               }
             />
           )}
+          {supportsMessageSizeSettings && (
+            <IntegerSettingRow
+              settingDefinition={SETTING_REQUEST_MESSAGE_SIZE}
+              setting={model.settingRequestMessageSize}
+              inheritedValue={resolveInheritedValue(
+                ancestors,
+                SETTING_REQUEST_MESSAGE_SIZE.modelKey,
+                model.settingRequestMessageSize,
+              )}
+              onChange={(settingRequestMessageSize) =>
+                patchMessageSizeSettings(model, {
+                  settingRequestMessageSize,
+                })
+              }
+            />
+          )}
           <BooleanSettingRow
             settingDefinition={SETTING_VALIDATE_CERTIFICATES}
             setting={model.settingValidateCertificates}
@@ -110,7 +153,9 @@ export function ModelSettingsEditor({ model, showSectionTitles = false }: Props)
         </SettingsSection>
       )}
       {supportsCookieSettings && (
-        <SettingsSection title={supportsTlsSettings || showSectionTitles ? "Cookies" : null}>
+        <SettingsSection
+          title={supportsTlsSettings || showSectionTitles ? "Cookies" : null}
+        >
           <BooleanSettingRow
             settingDefinition={SETTING_SEND_COOKIES}
             setting={model.settingSendCookies}
@@ -158,46 +203,93 @@ export function countOverriddenSettings(model: ModelWithSettings) {
     settings.push(model.settingFollowRedirects, model.settingRequestTimeout);
   }
 
-  return settings.filter((setting) => isInheritedSetting(setting) && setting.enabled === true)
-    .length;
+  if (modelSupportsMessageSizeSettings(model)) {
+    settings.push(model.settingRequestMessageSize);
+  }
+
+  return settings.filter(
+    (setting) => isInheritedSetting(setting) && setting.enabled === true,
+  ).length;
 }
 
-function patchCookieSettings(model: ModelWithCookieSettings, patch: Partial<CookieSettingsPatch>) {
-  if (model.model === "workspace") return patchModel(model, patch as Partial<Workspace>);
-  if (model.model === "folder") return patchModel(model, patch as Partial<Folder>);
-  if (model.model === "http_request") return patchModel(model, patch as Partial<HttpRequest>);
+function patchCookieSettings(
+  model: ModelWithCookieSettings,
+  patch: Partial<CookieSettingsPatch>,
+) {
+  if (model.model === "workspace")
+    return patchModel(model, patch as Partial<Workspace>);
+  if (model.model === "folder")
+    return patchModel(model, patch as Partial<Folder>);
+  if (model.model === "http_request")
+    return patchModel(model, patch as Partial<HttpRequest>);
   if (model.model === "websocket_request")
     return patchModel(model, patch as Partial<WebsocketRequest>);
   throw new Error("Unsupported cookie settings model");
 }
 
-function patchHttpSettings(model: ModelWithHttpSettings, patch: Partial<HttpSettingsPatch>) {
-  if (model.model === "workspace") return patchModel(model, patch as Partial<Workspace>);
-  if (model.model === "folder") return patchModel(model, patch as Partial<Folder>);
+function patchHttpSettings(
+  model: ModelWithHttpSettings,
+  patch: Partial<HttpSettingsPatch>,
+) {
+  if (model.model === "workspace")
+    return patchModel(model, patch as Partial<Workspace>);
+  if (model.model === "folder")
+    return patchModel(model, patch as Partial<Folder>);
   return patchModel(model, patch as Partial<HttpRequest>);
 }
 
-function patchTlsSettings(model: ModelWithTlsSettings, patch: Partial<TlsSettingsPatch>) {
-  if (model.model === "workspace") return patchModel(model, patch as Partial<Workspace>);
-  if (model.model === "folder") return patchModel(model, patch as Partial<Folder>);
-  if (model.model === "http_request") return patchModel(model, patch as Partial<HttpRequest>);
+function patchTlsSettings(
+  model: ModelWithTlsSettings,
+  patch: Partial<TlsSettingsPatch>,
+) {
+  if (model.model === "workspace")
+    return patchModel(model, patch as Partial<Workspace>);
+  if (model.model === "folder")
+    return patchModel(model, patch as Partial<Folder>);
+  if (model.model === "http_request")
+    return patchModel(model, patch as Partial<HttpRequest>);
   if (model.model === "websocket_request")
     return patchModel(model, patch as Partial<WebsocketRequest>);
   return patchModel(model, patch as Partial<GrpcRequest>);
 }
 
-function modelSupportsHttpSettings(model: ModelWithSettings): model is ModelWithHttpSettings {
+function patchMessageSizeSettings(
+  model: ModelWithMessageSizeSettings,
+  patch: Partial<MessageSizeSettingsPatch>,
+) {
+  if (model.model === "workspace")
+    return patchModel(model, patch as Partial<Workspace>);
+  if (model.model === "folder")
+    return patchModel(model, patch as Partial<Folder>);
+  if (model.model === "websocket_request")
+    return patchModel(model, patch as Partial<WebsocketRequest>);
+  return patchModel(model, patch as Partial<GrpcRequest>);
+}
+
+function modelSupportsHttpSettings(
+  model: ModelWithSettings,
+): model is ModelWithHttpSettings {
   return modelSupportsSetting(model, SETTING_REQUEST_TIMEOUT);
 }
 
-function modelSupportsCookieSettings(model: ModelWithSettings): model is ModelWithCookieSettings {
+function modelSupportsCookieSettings(
+  model: ModelWithSettings,
+): model is ModelWithCookieSettings {
   return modelSupportsSetting(model, SETTING_SEND_COOKIES);
 }
 
-function modelSupportsTlsSettings(model: ModelWithSettings): model is ModelWithTlsSettings {
+function modelSupportsTlsSettings(
+  model: ModelWithSettings,
+): model is ModelWithTlsSettings {
   return modelSupportsSetting(model, SETTING_VALIDATE_CERTIFICATES);
 }
 
+function modelSupportsMessageSizeSettings(
+  model: ModelWithSettings,
+): model is ModelWithMessageSizeSettings {
+  return modelSupportsSetting(model, SETTING_REQUEST_MESSAGE_SIZE);
+}
+
 function BooleanSettingRow({
   inheritedValue,
   setting,
@@ -211,7 +303,11 @@ function BooleanSettingRow({
 }) {
   const inherited = isInheritedSetting(setting);
   const overridden = inherited ? setting.enabled === true : false;
-  const value = inherited ? (overridden ? setting.value : inheritedValue) : setting;
+  const value = inherited
+    ? overridden
+      ? setting.value
+      : inheritedValue
+    : setting;
 
   if (!inherited) {
     return (
@@ -250,12 +346,18 @@ function IntegerSettingRow({
 }: {
   inheritedValue: number;
   setting: IntegerSetting;
-  settingDefinition: RequestSettingDefinition<"settingRequestTimeout">;
+  settingDefinition: RequestSettingDefinition<
+    "settingRequestTimeout" | "settingRequestMessageSize"
+  >;
   onChange: (setting: IntegerSetting) => void;
 }) {
   const inherited = isInheritedSetting(setting);
   const overridden = inherited ? setting.enabled === true : false;
-  const value = inherited ? (overridden ? setting.value : inheritedValue) : setting;
+  const value = inherited
+    ? overridden
+      ? setting.value
+      : inheritedValue
+    : setting;
 
   if (!inherited) {
     return (
@@ -308,7 +410,7 @@ function isInheritedSetting<T>(
 
 function resolveInheritedValue(
   ancestors: (Folder | Workspace)[],
-  key: "settingRequestTimeout",
+  key: "settingRequestTimeout" | "settingRequestMessageSize",
   fallback: IntegerSetting,
 ): number;
 function resolveInheritedValue(
@@ -338,10 +440,14 @@ function resolveInheritedValue(
 type WorkspaceSettings = Pick<
   Workspace,
   | "settingFollowRedirects"
+  | "settingRequestMessageSize"
   | "settingRequestTimeout"
   | "settingSendCookies"
   | "settingStoreCookies"
   | "settingValidateCertificates"
 >;
 
-type BooleanWorkspaceSettingKey = Exclude<keyof WorkspaceSettings, "settingRequestTimeout">;
+type BooleanWorkspaceSettingKey = Exclude<
+  keyof WorkspaceSettings,
+  "settingRequestTimeout" | "settingRequestMessageSize"
+>;

apps/yaak-client/components/WorkspaceSettingsDialog.tsx

@@ -1,5 +1,5 @@
 import { patchModel, workspaceMetasAtom, workspacesAtom } from "@yaakapp-internal/models";
-import { Banner, HStack, InlineCode, VStack } from "@yaakapp-internal/ui";
+import { Banner, HStack, InlineCode } from "@yaakapp-internal/ui";
 import { useAtomValue } from "jotai";
 import { useAuthTab } from "../hooks/useAuthTab";
 import { useHeadersTab } from "../hooks/useHeadersTab";

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

@@ -580,6 +580,10 @@ function getExtensions({
 
   return [
     ...baseExtensions, // Must be first
+    EditorView.contentAttributes.of({
+      autocapitalize: "off",
+      autocorrect: "off",
+    }),
     EditorView.domEventHandlers({
       focus: () => {
         onFocus.current?.();

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

@@ -55,6 +55,8 @@ export function KeyValueRow({
   const textToCopy =
     copyText ??
     (typeof children === "string" || typeof children === "number" ? `${children}` : null);
+  const copyTitle =
+    typeof label === "string" || typeof label === "number" ? `Copy ${label}` : "Copy value";
   const resolvedRightSlot =
     rightSlot ??
     (enableCopy && textToCopy != null ? (
@@ -62,7 +64,7 @@ export function KeyValueRow({
         text={textToCopy}
         className="text-text-subtle"
         size="2xs"
-        title={`Copy ${label}`}
+        title={copyTitle}
         iconSize="sm"
       />
     ) : null);

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

@@ -1,6 +1,6 @@
 import { useGitFileDiffForCommit, useGitLog, useGitMutations } from "@yaakapp-internal/git";
 import type { GitCommit } from "@yaakapp-internal/git";
-import { InlineCode, SplitLayout } from "@yaakapp-internal/ui";
+import { SplitLayout } from "@yaakapp-internal/ui";
 import classNames from "classnames";
 import { formatDistanceToNowStrict } from "date-fns";
 import { useCallback, useEffect, useMemo, useState } from "react";

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

@@ -8,7 +8,7 @@ import type {
   WebsocketRequest,
   Workspace,
 } from "@yaakapp-internal/models";
-import { Banner, HStack, Icon, IconButton, InlineCode, SplitLayout } from "@yaakapp-internal/ui";
+import { Banner, HStack, Icon, InlineCode, SplitLayout } from "@yaakapp-internal/ui";
 import classNames from "classnames";
 import { useCallback, useMemo, useState } from "react";
 import { modelToYaml } from "../../lib/diffYaml";

apps/yaak-client/hooks/useSendAnyHttpRequest.ts

@@ -1,40 +1,32 @@
 import type { HttpResponse } from "@yaakapp-internal/models";
-import { getModel } from "@yaakapp-internal/models";
+import { flushAllModelWrites } from "@yaakapp-internal/models";
 import { invokeCmd } from "../lib/tauri";
 import { getActiveCookieJar } from "./useActiveCookieJar";
 import { getActiveEnvironment } from "./useActiveEnvironment";
 import { createFastMutation, useFastMutation } from "./useFastMutation";
 
+async function sendAnyHttpRequestById(id: string | null): Promise<HttpResponse | null> {
+  if (id == null) {
+    return null;
+  }
+
+  await flushAllModelWrites();
+
+  return invokeCmd("cmd_send_http_request", {
+    requestId: id,
+    environmentId: getActiveEnvironment()?.id,
+    cookieJarId: getActiveCookieJar()?.id,
+  });
+}
+
 export function useSendAnyHttpRequest() {
   return useFastMutation<HttpResponse | null, string, string | null>({
     mutationKey: ["send_any_request"],
-    mutationFn: async (id) => {
-      const request = getModel("http_request", id ?? "n/a");
-      if (request == null) {
-        return null;
-      }
-
-      return invokeCmd("cmd_send_http_request", {
-        request,
-        environmentId: getActiveEnvironment()?.id,
-        cookieJarId: getActiveCookieJar()?.id,
-      });
-    },
+    mutationFn: sendAnyHttpRequestById,
   });
 }
 
 export const sendAnyHttpRequest = createFastMutation<HttpResponse | null, string, string | null>({
   mutationKey: ["send_any_request"],
-  mutationFn: async (id) => {
-    const request = getModel("http_request", id ?? "n/a");
-    if (request == null) {
-      return null;
-    }
-
-    return invokeCmd("cmd_send_http_request", {
-      request,
-      environmentId: getActiveEnvironment()?.id,
-      cookieJarId: getActiveCookieJar()?.id,
-    });
-  },
+  mutationFn: sendAnyHttpRequestById,
 });

apps/yaak-client/lib/requestSettings.ts

@@ -5,6 +5,7 @@ type ModelType = AnyModel["model"];
 type WorkspaceRequestSettings = Pick<
   Workspace,
   | "settingFollowRedirects"
+  | "settingRequestMessageSize"
   | "settingRequestTimeout"
   | "settingSendCookies"
   | "settingStoreCookies"
@@ -17,7 +18,9 @@ type ModelTypeWithSetting<K extends RequestSettingKey> = {
   [M in ModelType]: K extends keyof ModelForType<M> ? M : never;
 }[ModelType];
 
-export type RequestSettingDefinition<K extends RequestSettingKey = RequestSettingKey> = {
+export type RequestSettingDefinition<
+  K extends RequestSettingKey = RequestSettingKey,
+> = {
   defaultValue: WorkspaceRequestSettings[K];
   description: string;
   modelKey: K;
@@ -41,11 +44,26 @@ export const SETTING_REQUEST_TIMEOUT = defineRequestSetting({
   title: "Request Timeout",
 });
 
+export const SETTING_REQUEST_MESSAGE_SIZE = defineRequestSetting({
+  defaultValue: 64 * 1024 * 1024,
+  description:
+    "Maximum gRPC or WebSocket message size in bytes. Set to 0 to disable.",
+  modelKey: "settingRequestMessageSize",
+  models: ["workspace", "folder", "websocket_request", "grpc_request"],
+  title: "Message Size Limit",
+});
+
 export const SETTING_VALIDATE_CERTIFICATES = defineRequestSetting({
   defaultValue: true,
   description: "When disabled, skip validation of server certificates.",
   modelKey: "settingValidateCertificates",
-  models: ["workspace", "folder", "http_request", "websocket_request", "grpc_request"],
+  models: [
+    "workspace",
+    "folder",
+    "http_request",
+    "websocket_request",
+    "grpc_request",
+  ],
   title: "Validate TLS certificates",
 });
 
@@ -59,7 +77,8 @@ export const SETTING_FOLLOW_REDIRECTS = defineRequestSetting({
 
 export const SETTING_SEND_COOKIES = defineRequestSetting({
   defaultValue: true,
-  description: "Attach matching cookies from the active cookie jar to outgoing requests.",
+  description:
+    "Attach matching cookies from the active cookie jar to outgoing requests.",
   modelKey: "settingSendCookies",
   models: ["workspace", "folder", "http_request", "websocket_request"],
   title: "Automatically send cookies",
@@ -67,7 +86,8 @@ export const SETTING_SEND_COOKIES = defineRequestSetting({
 
 export const SETTING_STORE_COOKIES = defineRequestSetting({
   defaultValue: true,
-  description: "Save cookies from Set-Cookie response headers to the active cookie jar.",
+  description:
+    "Save cookies from Set-Cookie response headers to the active cookie jar.",
   modelKey: "settingStoreCookies",
   models: ["workspace", "folder", "http_request", "websocket_request"],
   title: "Automatically store cookies",

crates-cli/yaak-cli/Cargo.toml

@@ -42,6 +42,7 @@ webbrowser = "1"
 zip = "4"
 yaak = { workspace = true }
 yaak-api = { workspace = true }
+yaak-core = { workspace = true }
 yaak-crypto = { workspace = true }
 yaak-http = { workspace = true }
 yaak-models = { workspace = true }

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

@@ -42,6 +42,12 @@ pub enum Commands {
     /// Authentication commands
     Auth(AuthArgs),
 
+    /// Import API data from Yaak, OpenAPI, Postman, Insomnia, Swagger, or cURL
+    Import(ImportArgs),
+
+    /// Export Yaak workspace data
+    Export(ExportArgs),
+
     /// Plugin development and publishing commands
     Plugin(PluginArgs),
 
@@ -92,6 +98,34 @@ pub struct SendArgs {
     pub fail_fast: bool,
 }
 
+#[derive(Args)]
+pub struct ImportArgs {
+    /// Path to the file to import
+    pub file: PathBuf,
+
+    /// Existing workspace ID to import into when supported by the importer
+    #[arg(long = "workspace-id", value_name = "WORKSPACE_ID")]
+    pub workspace_id: Option<String>,
+}
+
+#[derive(Args)]
+pub struct ExportArgs {
+    /// Path to write the Yaak export JSON file
+    pub file: PathBuf,
+
+    /// Workspace IDs to export (defaults to the only workspace when exactly one exists)
+    #[arg(value_name = "WORKSPACE_ID")]
+    pub workspace_ids: Vec<String>,
+
+    /// Export all workspaces
+    #[arg(long, conflicts_with = "workspace_ids")]
+    pub all: bool,
+
+    /// Include private environments in the export
+    #[arg(long)]
+    pub include_private_environments: bool,
+}
+
 #[derive(Args)]
 #[command(disable_help_subcommand = true)]
 pub struct CookieJarArgs {
@@ -447,6 +481,10 @@ pub enum PluginCommands {
     /// Install a plugin from a local directory or from the registry
     Install(InstallPluginArgs),
 
+    /// Generate plugin metadata for the registry
+    #[command(hide = true)]
+    Metadata(PluginPathArg),
+
     /// Publish a Yaak plugin version to the plugin registry
     Publish(PluginPathArg),
 }

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

@@ -0,0 +1,176 @@
+use crate::cli::{ExportArgs, ImportArgs};
+use crate::context::CliContext;
+use crate::utils::workspace::resolve_workspace_id;
+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_plugins::events::{ImportResources, PluginContext};
+
+type CommandResult<T = ()> = std::result::Result<T, String>;
+
+pub async fn run_import(ctx: &CliContext, args: ImportArgs) -> i32 {
+    match import(ctx, args).await {
+        Ok(result) => {
+            println!("Imported {}", format_counts(&result));
+            0
+        }
+        Err(error) => {
+            eprintln!("Error: {error}");
+            1
+        }
+    }
+}
+
+pub fn run_export(ctx: &CliContext, args: ExportArgs) -> i32 {
+    match export(ctx, args) {
+        Ok(count) => {
+            println!("Exported {count} workspace(s)");
+            0
+        }
+        Err(error) => {
+            eprintln!("Error: {error}");
+            1
+        }
+    }
+}
+
+async fn import(ctx: &CliContext, args: ImportArgs) -> CommandResult<BatchUpsertResult> {
+    if let Some(workspace_id) = args.workspace_id.as_deref() {
+        ctx.db()
+            .get_workspace(workspace_id)
+            .map_err(|e| format!("Failed to get workspace '{workspace_id}': {e}"))?;
+    }
+
+    let file_contents = read_import_file(&args.file)?;
+    let plugin_context = PluginContext::new(None, args.workspace_id.clone());
+    let plugin_manager = ctx.plugin_manager();
+    let import_result = plugin_manager
+        .import_data(&plugin_context, &file_contents)
+        .await
+        .map_err(|e| format!("Failed to import data: {e}"))?;
+    let resources = import_result.resources;
+    let workspace_id = args.workspace_id;
+    if workspace_id.is_none() && resources_need_current_workspace(&resources) {
+        return Err(
+            "This import requires a workspace context. Provide --workspace-id <WORKSPACE_ID>."
+                .to_string(),
+        );
+    }
+    let workspace_context = WorkspaceContext {
+        workspace_id,
+        environment_id: None,
+        cookie_jar_id: None,
+        request_id: None,
+    };
+    let imported = import::import_resources(ctx.query_manager(), workspace_context, resources)
+        .map_err(|e| format!("Failed to import data: {e}"))?;
+    Ok(imported)
+}
+
+fn export(ctx: &CliContext, args: ExportArgs) -> CommandResult<usize> {
+    let workspace_ids = resolve_export_workspace_ids(ctx, args.workspace_ids, args.all)?;
+    let workspace_id_refs: Vec<&str> = workspace_ids.iter().map(String::as_str).collect();
+    export::export_data(ExportDataParams {
+        query_manager: ctx.query_manager(),
+        yaak_version: env!("CARGO_PKG_VERSION"),
+        export_path: &args.file,
+        workspace_ids: workspace_id_refs,
+        include_private_environments: args.include_private_environments,
+    })
+    .map_err(|e| format!("Failed to export data: {e}"))?;
+
+    Ok(workspace_ids.len())
+}
+
+fn resolve_export_workspace_ids(
+    ctx: &CliContext,
+    workspace_ids: Vec<String>,
+    all: bool,
+) -> CommandResult<Vec<String>> {
+    if all {
+        let workspaces =
+            ctx.db().list_workspaces().map_err(|e| format!("Failed to list workspaces: {e}"))?;
+        if workspaces.is_empty() {
+            return Err("No workspaces found to export".to_string());
+        }
+        return Ok(workspaces.into_iter().map(|w| w.id).collect());
+    }
+
+    if workspace_ids.is_empty() {
+        return resolve_workspace_id(ctx, None, "export").map(|id| vec![id]);
+    }
+
+    for workspace_id in &workspace_ids {
+        ctx.db()
+            .get_workspace(workspace_id)
+            .map_err(|e| format!("Failed to get workspace '{workspace_id}': {e}"))?;
+    }
+    Ok(workspace_ids)
+}
+
+fn read_import_file(path: &std::path::Path) -> CommandResult<String> {
+    fs::read_to_string(path).map_err(|err| {
+        if err.kind() == ErrorKind::InvalidData {
+            format!(
+                "Import file must be UTF-8 text; binary files are not supported: {}",
+                path.display()
+            )
+        } else {
+            format!("Unable to read import file {}: {err}", path.display())
+        }
+    })
+}
+
+fn resources_need_current_workspace(resources: &ImportResources) -> bool {
+    resources.workspaces.iter().any(|w| w.id == "CURRENT_WORKSPACE")
+        || resources.environments.iter().any(|e| {
+            e.workspace_id == "CURRENT_WORKSPACE"
+                || e.parent_id.as_deref() == Some("CURRENT_WORKSPACE")
+        })
+        || resources.folders.iter().any(|f| {
+            f.workspace_id == "CURRENT_WORKSPACE"
+                || f.folder_id.as_deref() == Some("CURRENT_WORKSPACE")
+        })
+        || resources.http_requests.iter().any(|r| {
+            r.workspace_id == "CURRENT_WORKSPACE"
+                || r.folder_id.as_deref() == Some("CURRENT_WORKSPACE")
+        })
+        || resources.grpc_requests.iter().any(|r| {
+            r.workspace_id == "CURRENT_WORKSPACE"
+                || r.folder_id.as_deref() == Some("CURRENT_WORKSPACE")
+        })
+        || resources.websocket_requests.iter().any(|r| {
+            r.workspace_id == "CURRENT_WORKSPACE"
+                || r.folder_id.as_deref() == Some("CURRENT_WORKSPACE")
+        })
+}
+
+fn format_counts(result: &BatchUpsertResult) -> String {
+    let names = [
+        "workspace",
+        "environment",
+        "folder",
+        "HTTP request",
+        "gRPC request",
+        "WebSocket request",
+    ];
+    let counts = [
+        (result.workspaces.len(), names[0]),
+        (result.environments.len(), names[1]),
+        (result.folders.len(), names[2]),
+        (result.http_requests.len(), names[3]),
+        (result.grpc_requests.len(), names[4]),
+        (result.websocket_requests.len(), names[5]),
+    ];
+
+    let non_zero: Vec<String> = counts
+        .into_iter()
+        .filter(|(count, _)| *count > 0)
+        .map(|(count, name)| format!("{count} {name}{}", if count == 1 { "" } else { "s" }))
+        .collect();
+
+    if non_zero.is_empty() { "nothing".to_string() } else { non_zero.join(", ") }
+}

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

@@ -2,6 +2,7 @@ pub mod auth;
 pub mod cookie_jar;
 pub mod environment;
 pub mod folder;
+pub mod import_export;
 pub mod plugin;
 pub mod request;
 pub mod send;

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

@@ -13,6 +13,7 @@ use std::collections::HashSet;
 use std::fs;
 use std::io::{self, IsTerminal, Read, Write};
 use std::path::{Path, PathBuf};
+use std::process::Command;
 use std::sync::Arc;
 use tokio::sync::Mutex;
 use walkdir::WalkDir;
@@ -27,6 +28,11 @@ use zip::write::SimpleFileOptions;
 type CommandResult<T = ()> = std::result::Result<T, String>;
 
 const KEYRING_USER: &str = "yaak";
+const METADATA_NODE_BIN: &str = "node";
+const PLUGIN_RUNTIME_NODE_VERSION: &str = include_str!(concat!(
+    env!("CARGO_MANIFEST_DIR"),
+    "/../../packages/plugin-runtime/.node-version"
+));
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 enum Environment {
@@ -103,6 +109,16 @@ pub async fn run_publish(args: PluginPathArg) -> i32 {
     }
 }
 
+pub async fn run_metadata(args: PluginPathArg) -> i32 {
+    match metadata(args) {
+        Ok(()) => 0,
+        Err(error) => {
+            ui::error(&error);
+            1
+        }
+    }
+}
+
 async fn build(args: PluginPathArg) -> CommandResult {
     let plugin_dir = resolve_plugin_dir(args.path)?;
     ensure_plugin_build_inputs(&plugin_dir)?;
@@ -112,10 +128,21 @@ async fn build(args: PluginPathArg) -> CommandResult {
     for warning in warnings {
         ui::warning(&warning);
     }
+    generate_plugin_metadata(&plugin_dir)?;
     ui::success(&format!("Built plugin bundle at {}", plugin_dir.join("build/index.js").display()));
     Ok(())
 }
 
+fn metadata(args: PluginPathArg) -> CommandResult {
+    let plugin_dir = resolve_plugin_dir(args.path)?;
+    generate_plugin_metadata(&plugin_dir)?;
+    ui::success(&format!(
+        "Generated plugin metadata at {}",
+        plugin_dir.join("build/metadata.json").display()
+    ));
+    Ok(())
+}
+
 async fn dev(args: PluginPathArg) -> CommandResult {
     let plugin_dir = resolve_plugin_dir(args.path)?;
     ensure_plugin_build_inputs(&plugin_dir)?;
@@ -153,7 +180,15 @@ async fn dev(args: PluginPathArg) -> CommandResult {
                         });
                     ui::info(&format!("Rebuilding plugin {display_path}"));
                 }
-                WatcherEvent::Event(BundleEvent::BundleEnd(_)) => {}
+                WatcherEvent::Event(BundleEvent::BundleEnd(_)) => {
+                    match generate_plugin_metadata(&watch_root) {
+                        Ok(()) => ui::success(&format!(
+                            "Generated plugin metadata at {}",
+                            watch_root.join("build/metadata.json").display()
+                        )),
+                        Err(error) => ui::error(&error),
+                    }
+                }
                 WatcherEvent::Event(BundleEvent::Error(event)) => {
                     if event.error.diagnostics.is_empty() {
                         ui::error("Plugin build failed");
@@ -228,6 +263,7 @@ async fn publish(args: PluginPathArg) -> CommandResult {
     for warning in warnings {
         ui::warning(&warning);
     }
+    generate_plugin_metadata(&plugin_dir)?;
 
     ui::info("Archiving plugin");
     let archive = create_publish_archive(&plugin_dir)?;
@@ -379,6 +415,79 @@ async fn build_plugin_bundle(plugin_dir: &Path) -> CommandResult<Vec<String>> {
     Ok(output.warnings.into_iter().map(|w| w.to_string()).collect())
 }
 
+fn generate_plugin_metadata(plugin_dir: &Path) -> CommandResult {
+    let entry_path = plugin_dir.join("build/index.js");
+    if !entry_path.is_file() {
+        return Err("build/index.js does not exist. Run `yaak plugin build` first.".to_string());
+    }
+
+    ensure_metadata_node_version()?;
+
+    let metadata_path = plugin_dir.join("build/metadata.json");
+    let output = Command::new(METADATA_NODE_BIN)
+        .arg("-e")
+        .arg(METADATA_SCRIPT)
+        .arg(entry_path.canonicalize().map_err(|e| {
+            format!("Failed to resolve plugin entrypoint {}: {e}", entry_path.display())
+        })?)
+        .arg(&metadata_path)
+        .current_dir(plugin_dir)
+        .output()
+        .map_err(|e| format!("Failed to run Node.js to generate plugin metadata: {e}"))?;
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string();
+        let message = if stderr.is_empty() {
+            format!("Node.js exited with status {}", output.status)
+        } else {
+            stderr
+        };
+        return Err(format!("Failed to generate plugin metadata: {message}"));
+    }
+
+    Ok(())
+}
+
+fn ensure_metadata_node_version() -> CommandResult {
+    let minimum_major = PLUGIN_RUNTIME_NODE_VERSION
+        .trim()
+        .trim_start_matches('v')
+        .split('.')
+        .next()
+        .and_then(|part| part.parse::<u32>().ok())
+        .ok_or_else(|| {
+            format!(
+                "Invalid plugin runtime Node.js version {:?} in packages/plugin-runtime/.node-version",
+                PLUGIN_RUNTIME_NODE_VERSION.trim()
+            )
+        })?;
+    let output = Command::new(METADATA_NODE_BIN)
+        .arg("--version")
+        .output()
+        .map_err(|e| format!("Node.js {minimum_major} or newer is required: {e}"))?;
+
+    if !output.status.success() {
+        return Err(format!(
+            "`{METADATA_NODE_BIN} --version` failed with status {}",
+            output.status
+        ));
+    }
+
+    let version = String::from_utf8_lossy(&output.stdout).trim().to_string();
+    let major = version
+        .trim_start_matches('v')
+        .split('.')
+        .next()
+        .and_then(|part| part.parse::<u32>().ok())
+        .ok_or_else(|| format!("Could not parse Node.js version {version:?}"))?;
+
+    if major >= minimum_major {
+        return Ok(());
+    }
+
+    Err(format!("Node.js {minimum_major} or newer is required. Found {version}."))
+}
+
 fn prepare_build_output_dir(plugin_dir: &Path) -> CommandResult {
     let build_dir = plugin_dir.join("build");
     if build_dir.exists() {
@@ -578,6 +687,11 @@ const TEMPLATE_PACKAGE_JSON: &str = r#"{
 }
 "#;
 
+const METADATA_SCRIPT: &str = include_str!(concat!(
+    env!("CARGO_MANIFEST_DIR"),
+    "/../../packages/plugin-runtime/src/metadata.ts"
+));
+
 const TEMPLATE_TSCONFIG: &str = r#"{
   "compilerOptions": {
     "target": "es2021",
@@ -636,7 +750,8 @@ describe("Example Plugin", () => {
 
 #[cfg(test)]
 mod tests {
-    use super::create_publish_archive;
+    use super::{create_publish_archive, generate_plugin_metadata};
+    use serde_json::Value;
     use std::collections::HashSet;
     use std::fs;
     use std::io::Cursor;
@@ -659,6 +774,7 @@ mod tests {
             .expect("write src/index.ts");
         fs::write(root.join("build/index.js"), "exports.plugin = {};\n")
             .expect("write build/index.js");
+        fs::write(root.join("build/metadata.json"), "{}\n").expect("write build/metadata.json");
         fs::write(root.join("ignored/secret.txt"), "do-not-ship").expect("write ignored file");
 
         let archive = create_publish_archive(root).expect("create archive");
@@ -673,8 +789,74 @@ mod tests {
         assert!(names.contains("README.md"));
         assert!(names.contains("package.json"));
         assert!(names.contains("package-lock.json"));
+        assert!(names.contains("build/metadata.json"));
         assert!(names.contains("src/index.ts"));
         assert!(names.contains("build/index.js"));
         assert!(!names.contains("ignored/secret.txt"));
     }
+
+    #[test]
+    fn generate_plugin_metadata_detects_api_types() {
+        let dir = TempDir::new().expect("temp dir");
+        let root = dir.path();
+        fs::create_dir_all(root.join("build")).expect("create build");
+        fs::write(
+            root.join("build/index.js"),
+            r##"
+exports.plugin = {
+  themes: [{
+    id: "midnight",
+    label: "Midnight",
+    dark: true,
+    base: { surface: "#000000", text: "#ffffff" },
+  }],
+  templateFunctions: [{
+    name: "signature",
+    description: "Create a signature",
+    args: [{ type: "text", name: "secret", dynamic() {} }],
+    onRender() {},
+  }],
+  workspaceActions: [{
+    label: "Sync workspace",
+    icon: "info",
+    onSelect() {},
+  }],
+  folderActions: [{
+    label: "Export folder",
+    icon: "copy",
+    onSelect() {},
+  }],
+  async init() {},
+};
+"##,
+        )
+        .expect("write build/index.js");
+
+        generate_plugin_metadata(root).expect("generate metadata");
+
+        let contents = fs::read_to_string(root.join("build/metadata.json")).expect("read metadata");
+        let metadata: Value = serde_json::from_str(&contents).expect("metadata json");
+        let api_types = metadata["apiTypes"].as_array().expect("apiTypes array");
+
+        for expected in [
+            "folderActions",
+            "templateFunctions",
+            "themes",
+            "workspaceActions",
+            "lifecycle",
+        ] {
+            assert!(
+                api_types.iter().any(|value| value.as_str() == Some(expected)),
+                "missing api type {expected}: {api_types:?}"
+            );
+        }
+
+        assert_eq!(metadata["apis"]["themes"]["items"][0]["id"], "midnight");
+        assert_eq!(metadata["apis"]["workspaceActions"]["items"][0]["label"], "Sync workspace");
+        assert_eq!(metadata["apis"]["lifecycle"]["items"][0]["name"], "init");
+        assert!(metadata["apis"]["templateFunctions"]["items"][0]["onRender"].is_null());
+        assert!(
+            metadata["apis"]["templateFunctions"]["items"][0]["args"][0]["dynamic"].is_null()
+        );
+    }
 }

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

@@ -37,11 +37,29 @@ async fn main() {
 
     let exit_code = match command {
         Commands::Auth(args) => commands::auth::run(args).await,
+        Commands::Import(args) => {
+            let mut context = CliContext::new(data_dir.clone(), app_id);
+            let execution_context = CliExecutionContext {
+                workspace_id: args.workspace_id.clone(),
+                ..CliExecutionContext::default()
+            };
+            context.init_plugins(execution_context).await;
+            let exit_code = commands::import_export::run_import(&context, args).await;
+            context.shutdown().await;
+            exit_code
+        }
+        Commands::Export(args) => {
+            let context = CliContext::new(data_dir.clone(), app_id);
+            let exit_code = commands::import_export::run_export(&context, args);
+            context.shutdown().await;
+            exit_code
+        }
         Commands::Plugin(args) => match args.command {
             PluginCommands::Build(args) => commands::plugin::run_build(args).await,
             PluginCommands::Dev(args) => commands::plugin::run_dev(args).await,
             PluginCommands::Generate(args) => commands::plugin::run_generate(args).await,
             PluginCommands::Publish(args) => commands::plugin::run_publish(args).await,
+            PluginCommands::Metadata(args) => commands::plugin::run_metadata(args).await,
             PluginCommands::Install(install_args) => {
                 let mut context = CliContext::new(data_dir.clone(), app_id);
                 context.init_plugins(CliExecutionContext::default()).await;

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

@@ -0,0 +1,162 @@
+mod common;
+
+use common::{cli_cmd, parse_created_id, query_manager, seed_request};
+use predicates::str::contains;
+use serde_json::Value;
+use tempfile::TempDir;
+
+#[test]
+fn export_writes_yaak_workspace_file() {
+    let temp_dir = TempDir::new().expect("Failed to create temp dir");
+    let data_dir = temp_dir.path();
+    let export_path = temp_dir.path().join("export.json");
+
+    let create_assert =
+        cli_cmd(data_dir).args(["workspace", "create", "--name", "Export Me"]).assert().success();
+    let workspace_id = parse_created_id(&create_assert.get_output().stdout, "workspace create");
+    seed_request(data_dir, &workspace_id, "req_export");
+
+    cli_cmd(data_dir)
+        .args([
+            "export",
+            export_path.to_str().expect("export path is utf-8"),
+            &workspace_id,
+        ])
+        .assert()
+        .success()
+        .stdout(contains("Exported 1 workspace(s)"));
+
+    let exported: Value = serde_json::from_str(
+        &std::fs::read_to_string(export_path).expect("export file should exist"),
+    )
+    .expect("export should be JSON");
+
+    assert_eq!(exported["yaakSchema"], 4);
+    assert_eq!(exported["resources"]["workspaces"][0]["id"], workspace_id);
+    assert_eq!(exported["resources"]["httpRequests"][0]["id"], "req_export");
+}
+
+#[test]
+fn import_reads_yaak_workspace_file() {
+    let temp_dir = TempDir::new().expect("Failed to create temp dir");
+    let data_dir = temp_dir.path();
+    let import_path = temp_dir.path().join("import.json");
+
+    std::fs::write(
+        &import_path,
+        r#"{
+  "yaakVersion": "test",
+  "yaakSchema": 4,
+  "resources": {
+    "workspaces": [
+      {
+        "model": "workspace",
+        "id": "wrk_import",
+        "name": "Imported Workspace"
+      }
+    ],
+    "httpRequests": [
+      {
+        "model": "http_request",
+        "id": "req_import",
+        "workspaceId": "wrk_import",
+        "name": "Imported Request",
+        "method": "GET",
+        "url": "https://example.com"
+      }
+    ]
+  }
+}"#,
+    )
+    .expect("write import fixture");
+
+    cli_cmd(data_dir)
+        .args([
+            "import",
+            import_path.to_str().expect("import path is utf-8"),
+        ])
+        .assert()
+        .success()
+        .stdout(contains("Imported 1 workspace, 1 HTTP request"));
+
+    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"
+    );
+}
+
+fn write_postman_environment_fixture(path: &std::path::Path) {
+    std::fs::write(
+        path,
+        r#"{
+  "name": "Local",
+  "_postman_variable_scope": "environment",
+  "values": [
+    {
+      "key": "token",
+      "value": "abc123",
+      "enabled": true
+    }
+  ]
+}"#,
+    )
+    .expect("write postman environment fixture");
+}
+
+#[test]
+fn import_postman_environment_requires_workspace_id() {
+    let temp_dir = TempDir::new().expect("Failed to create temp dir");
+    let data_dir = temp_dir.path();
+    let import_path = temp_dir.path().join("postman-env.json");
+
+    cli_cmd(data_dir).args(["workspace", "create", "--name", "Env Target"]).assert().success();
+    write_postman_environment_fixture(&import_path);
+
+    cli_cmd(data_dir)
+        .args([
+            "import",
+            import_path.to_str().expect("import path is utf-8"),
+        ])
+        .assert()
+        .failure()
+        .stderr(contains("requires a workspace context"))
+        .stderr(contains("--workspace-id"));
+}
+
+#[test]
+fn import_postman_environment_uses_workspace_id() {
+    let temp_dir = TempDir::new().expect("Failed to create temp dir");
+    let data_dir = temp_dir.path();
+    let import_path = temp_dir.path().join("postman-env.json");
+
+    let create_assert =
+        cli_cmd(data_dir).args(["workspace", "create", "--name", "Env Target"]).assert().success();
+    let workspace_id = parse_created_id(&create_assert.get_output().stdout, "workspace create");
+    write_postman_environment_fixture(&import_path);
+
+    cli_cmd(data_dir)
+        .args([
+            "import",
+            import_path.to_str().expect("import path is utf-8"),
+            "--workspace-id",
+            &workspace_id,
+        ])
+        .assert()
+        .success()
+        .stdout(contains("Imported 1 environment"));
+
+    let query_manager = query_manager(data_dir);
+    let db = query_manager.connect();
+    let environments =
+        db.list_environments_ensure_base(&workspace_id).expect("list imported environments");
+
+    let imported_environment =
+        environments.iter().find(|e| e.name == "Local").expect("postman environment imported");
+    assert_eq!(imported_environment.workspace_id, workspace_id);
+}

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

@@ -38,6 +38,9 @@ pub enum Error {
     #[error(transparent)]
     ApiError(#[from] yaak_api::Error),
 
+    #[error(transparent)]
+    YaakError(#[from] yaak::Error),
+
     #[error(transparent)]
     ClipboardError(#[from] tauri_plugin_clipboard_manager::Error),
 

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

@@ -1,16 +1,12 @@
 use crate::PluginContextExt;
 use crate::error::{Error, Result};
 use crate::models_ext::QueryManagerExt;
-use log::info;
-use std::collections::BTreeMap;
 use std::fs::read_to_string;
 use std::io::ErrorKind;
 use tauri::{Manager, Runtime, WebviewWindow};
+use yaak::import::{self, ImportDataParams};
 use yaak_core::WorkspaceContext;
-use yaak_models::models::{
-    Environment, Folder, GrpcRequest, HttpRequest, WebsocketRequest, Workspace,
-};
-use yaak_models::util::{BatchUpsertResult, UpdateSource, maybe_gen_id, maybe_gen_id_opt};
+use yaak_models::util::BatchUpsertResult;
 use yaak_plugins::manager::PluginManager;
 use yaak_tauri_utils::window::WorkspaceWindowTrait;
 
@@ -19,113 +15,24 @@ pub(crate) async fn import_data<R: Runtime>(
     file_path: &str,
 ) -> Result<BatchUpsertResult> {
     let plugin_manager = window.state::<PluginManager>();
+    let query_manager = window.db_manager();
     let file = read_import_file(file_path)?;
-    let file_contents = file.as_str();
-    let import_result = plugin_manager.import_data(&window.plugin_context(), file_contents).await?;
-
-    let mut id_map: BTreeMap<String, String> = BTreeMap::new();
-
-    // Create WorkspaceContext from window
-    let ctx = WorkspaceContext {
+    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,
     };
 
-    let resources = import_result.resources;
-
-    let workspaces: Vec<Workspace> = resources
-        .workspaces
-        .into_iter()
-        .map(|mut v| {
-            v.id = maybe_gen_id::<Workspace>(&ctx, v.id.as_str(), &mut id_map);
-            v
-        })
-        .collect();
-
-    let environments: Vec<Environment> = resources
-        .environments
-        .into_iter()
-        .map(|mut v| {
-            v.id = maybe_gen_id::<Environment>(&ctx, v.id.as_str(), &mut id_map);
-            v.workspace_id = maybe_gen_id::<Workspace>(&ctx, 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>(&ctx, &parent_id, &mut id_map));
-                }
-                ("", _) => {
-                    // Fix any empty ones
-                    v.parent_model = "workspace".to_string();
-                }
-                _ => {
-                    // Parent ID only required for the folder case
-                    v.parent_id = None;
-                }
-            };
-            v
-        })
-        .collect();
-
-    let folders: Vec<Folder> = resources
-        .folders
-        .into_iter()
-        .map(|mut v| {
-            v.id = maybe_gen_id::<Folder>(&ctx, v.id.as_str(), &mut id_map);
-            v.workspace_id = maybe_gen_id::<Workspace>(&ctx, v.workspace_id.as_str(), &mut id_map);
-            v.folder_id = maybe_gen_id_opt::<Folder>(&ctx, v.folder_id, &mut id_map);
-            v
-        })
-        .collect();
-
-    let http_requests: Vec<HttpRequest> = resources
-        .http_requests
-        .into_iter()
-        .map(|mut v| {
-            v.id = maybe_gen_id::<HttpRequest>(&ctx, v.id.as_str(), &mut id_map);
-            v.workspace_id = maybe_gen_id::<Workspace>(&ctx, v.workspace_id.as_str(), &mut id_map);
-            v.folder_id = maybe_gen_id_opt::<Folder>(&ctx, v.folder_id, &mut id_map);
-            v
-        })
-        .collect();
-
-    let grpc_requests: Vec<GrpcRequest> = resources
-        .grpc_requests
-        .into_iter()
-        .map(|mut v| {
-            v.id = maybe_gen_id::<GrpcRequest>(&ctx, v.id.as_str(), &mut id_map);
-            v.workspace_id = maybe_gen_id::<Workspace>(&ctx, v.workspace_id.as_str(), &mut id_map);
-            v.folder_id = maybe_gen_id_opt::<Folder>(&ctx, v.folder_id, &mut id_map);
-            v
-        })
-        .collect();
-
-    let websocket_requests: Vec<WebsocketRequest> = resources
-        .websocket_requests
-        .into_iter()
-        .map(|mut v| {
-            v.id = maybe_gen_id::<WebsocketRequest>(&ctx, v.id.as_str(), &mut id_map);
-            v.workspace_id = maybe_gen_id::<Workspace>(&ctx, v.workspace_id.as_str(), &mut id_map);
-            v.folder_id = maybe_gen_id_opt::<Folder>(&ctx, v.folder_id, &mut id_map);
-            v
-        })
-        .collect();
-
-    info!("Importing data");
-
-    let upserted = window.with_tx(|tx| {
-        tx.batch_upsert(
-            workspaces,
-            environments,
-            folders,
-            http_requests,
-            grpc_requests,
-            websocket_requests,
-            &UpdateSource::Import,
-        )
-    })?;
-
-    Ok(upserted)
+    Ok(import::import_data(ImportDataParams {
+        query_manager: &query_manager,
+        plugin_manager: &plugin_manager,
+        plugin_context: &plugin_context,
+        workspace_context,
+        contents: &file,
+    })
+    .await?)
 }
 
 fn read_import_file(file_path: &str) -> Result<String> {

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

@@ -14,8 +14,7 @@ use error::Result as YaakResult;
 use eventsource_client::{EventParser, SSE};
 use log::{debug, error, info, warn};
 use std::collections::HashMap;
-use std::fs::File;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 use std::str::FromStr;
 use std::sync::Arc;
 use std::time::Duration;
@@ -31,6 +30,7 @@ use tauri_plugin_window_state::{AppHandleExt, StateFlags};
 use tokio::sync::Mutex;
 use tokio::task::block_in_place;
 use tokio::time;
+use yaak::export::{self, ExportDataParams};
 use yaak_common::command::new_checked_command;
 use yaak_crypto::manager::EncryptionManager;
 use yaak_grpc::manager::{GrpcConfig, GrpcHandle};
@@ -41,7 +41,7 @@ use yaak_models::models::{
     GrpcEventType, HttpRequest, HttpResponse, HttpResponseEvent, HttpResponseState, Workspace,
     WorkspaceMeta,
 };
-use yaak_models::util::{BatchUpsertResult, UpdateSource, get_workspace_export_resources};
+use yaak_models::util::{BatchUpsertResult, UpdateSource};
 use yaak_plugins::events::{
     CallFolderActionArgs, CallFolderActionRequest, CallGrpcRequestActionArgs,
     CallGrpcRequestActionRequest, CallHttpRequestActionArgs, CallHttpRequestActionRequest,
@@ -295,7 +295,8 @@ async fn cmd_grpc_reflect<R: Runtime>(
         unrendered_request.folder_id.as_deref(),
         environment_id,
     )?;
-    let resolved_settings = app_handle.db().resolve_settings_for_grpc_request(&unrendered_request)?;
+    let resolved_settings =
+        app_handle.db().resolve_settings_for_grpc_request(&unrendered_request)?;
 
     let plugin_manager = Arc::new((*app_handle.state::<PluginManager>()).clone());
     let encryption_manager = Arc::new((*app_handle.state::<EncryptionManager>()).clone());
@@ -332,6 +333,7 @@ async fn cmd_grpc_reflect<R: Runtime>(
             &metadata,
             resolved_settings.validate_certificates.value,
             client_certificate,
+            resolved_settings.request_message_size.value,
         )
         .await
         .map_err(|e| GenericError(e.to_string()))?)
@@ -353,7 +355,8 @@ async fn cmd_grpc_go<R: Runtime>(
         unrendered_request.folder_id.as_deref(),
         environment_id,
     )?;
-    let resolved_settings = app_handle.db().resolve_settings_for_grpc_request(&unrendered_request)?;
+    let resolved_settings =
+        app_handle.db().resolve_settings_for_grpc_request(&unrendered_request)?;
 
     let plugin_manager = Arc::new((*app_handle.state::<PluginManager>()).clone());
     let encryption_manager = Arc::new((*app_handle.state::<EncryptionManager>()).clone());
@@ -425,6 +428,7 @@ async fn cmd_grpc_go<R: Runtime>(
             &metadata,
             resolved_settings.validate_certificates.value,
             client_cert.clone(),
+            resolved_settings.request_message_size.value,
         )
         .await;
 
@@ -1384,24 +1388,14 @@ async fn cmd_export_data<R: Runtime>(
     workspace_ids: Vec<&str>,
     include_private_environments: bool,
 ) -> YaakResult<()> {
-    let db = app_handle.db();
     let version = app_handle.package_info().version.to_string();
-    let export_data =
-        get_workspace_export_resources(&db, &version, workspace_ids, include_private_environments)?;
-    let f = File::options()
-        .create(true)
-        .truncate(true)
-        .write(true)
-        .open(export_path)
-        .expect("Unable to create file");
-
-    serde_json::to_writer_pretty(&f, &export_data)
-        .map_err(|e| GenericError(e.to_string()))
-        .expect("Failed to write");
-
-    f.sync_all().expect("Failed to sync");
-
-    Ok(())
+    Ok(export::export_data(ExportDataParams {
+        query_manager: &app_handle.db_manager(),
+        yaak_version: &version,
+        export_path: Path::new(export_path),
+        workspace_ids,
+        include_private_environments,
+    })?)
 }
 
 #[tauri::command]
@@ -1425,11 +1419,10 @@ async fn cmd_send_http_request<R: Runtime>(
     window: WebviewWindow<R>,
     environment_id: Option<&str>,
     cookie_jar_id: Option<&str>,
-    // NOTE: We receive the entire request because to account for the race
-    //   condition where the user may have just edited a field before sending
-    //   that has not yet been saved in the DB.
-    request: HttpRequest,
+    request_id: String,
 ) -> YaakResult<HttpResponse> {
+    let request = app_handle.db().get_http_request(&request_id)?;
+
     let blobs = app_handle.blob_manager();
     let response = app_handle.db().upsert_http_response(
         &HttpResponse {

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

@@ -299,6 +299,7 @@ pub async fn cmd_ws_connect<R: Runtime>(
             receive_tx,
             resolved_settings.validate_certificates.value,
             client_cert,
+            resolved_settings.request_message_size.value,
         )
         .await
     {

crates/yaak-git/bindings/gen_models.ts

@@ -46,6 +46,7 @@ export type Folder = {
   settingValidateCertificates: InheritedBoolSetting;
   settingFollowRedirects: InheritedBoolSetting;
   settingRequestTimeout: InheritedIntSetting;
+  settingRequestMessageSize: InheritedIntSetting;
 };
 
 export type GrpcRequest = {
@@ -69,6 +70,7 @@ export type GrpcRequest = {
    */
   url: string;
   settingValidateCertificates: InheritedBoolSetting;
+  settingRequestMessageSize: InheritedIntSetting;
 };
 
 export type HttpRequest = {
@@ -146,6 +148,7 @@ export type WebsocketRequest = {
   settingSendCookies: InheritedBoolSetting;
   settingStoreCookies: InheritedBoolSetting;
   settingValidateCertificates: InheritedBoolSetting;
+  settingRequestMessageSize: InheritedIntSetting;
 };
 
 export type Workspace = {
@@ -162,6 +165,7 @@ export type Workspace = {
   settingValidateCertificates: boolean;
   settingFollowRedirects: boolean;
   settingRequestTimeout: number;
+  settingRequestMessageSize: number;
   settingDnsOverrides: Array<DnsOverride>;
   settingSendCookies: boolean;
   settingStoreCookies: boolean;

crates/yaak-grpc/src/client.rs

@@ -33,15 +33,21 @@ impl AutoReflectionClient {
         uri: &Uri,
         validate_certificates: bool,
         client_cert: Option<ClientCertificateConfig>,
+        max_message_size: usize,
     ) -> Result<Self> {
         let client_v1 = v1::server_reflection_client::ServerReflectionClient::with_origin(
             get_transport(validate_certificates, client_cert.clone())?,
             uri.clone(),
-        );
-        let client_v1alpha = v1alpha::server_reflection_client::ServerReflectionClient::with_origin(
-            get_transport(validate_certificates, client_cert.clone())?,
-            uri.clone(),
-        );
+        )
+        .max_decoding_message_size(max_message_size)
+        .max_encoding_message_size(max_message_size);
+        let client_v1alpha =
+            v1alpha::server_reflection_client::ServerReflectionClient::with_origin(
+                get_transport(validate_certificates, client_cert.clone())?,
+                uri.clone(),
+            )
+            .max_decoding_message_size(max_message_size)
+            .max_encoding_message_size(max_message_size);
         Ok(AutoReflectionClient { use_v1alpha: false, client_v1, client_v1alpha })
     }
 

crates/yaak-grpc/src/manager.rs

@@ -39,6 +39,7 @@ pub struct GrpcConnection {
     conn: Client<HttpsConnector<HttpConnector>, BoxBody>,
     pub uri: Uri,
     use_reflection: bool,
+    max_message_size: usize,
 }
 
 #[derive(Default, Debug)]
@@ -97,8 +98,15 @@ impl GrpcConnection {
         client_cert: Option<ClientCertificateConfig>,
     ) -> Result<Response<DynamicMessage>> {
         if self.use_reflection {
-            reflect_types_for_message(self.pool.clone(), &self.uri, message, metadata, client_cert)
-                .await?;
+            reflect_types_for_message(
+                self.pool.clone(),
+                &self.uri,
+                message,
+                metadata,
+                client_cert,
+                self.max_message_size,
+            )
+            .await?;
         }
         let method = &self.method(&service, &method).await?;
         let input_message = method.input();
@@ -107,7 +115,7 @@ impl GrpcConnection {
         let req_message = DynamicMessage::deserialize(input_message, &mut deserializer)?;
         deserializer.end()?;
 
-        let mut client = tonic::client::Grpc::with_origin(self.conn.clone(), self.uri.clone());
+        let mut client = grpc_client(self.conn.clone(), self.uri.clone(), self.max_message_size);
 
         let mut req = req_message.into_request();
         decorate_req(metadata, &mut req)?;
@@ -132,6 +140,7 @@ impl GrpcConnection {
                 message,
                 metadata,
                 client_cert,
+                self.max_message_size,
             )
             .await?;
 
@@ -171,6 +180,7 @@ impl GrpcConnection {
             let md = metadata.clone();
             let use_reflection = self.use_reflection.clone();
             let client_cert = client_cert.clone();
+            let max_message_size = self.max_message_size;
             stream
                 .then(move |json| {
                     let pool = pool.clone();
@@ -183,8 +193,15 @@ impl GrpcConnection {
                     let json_clone = json.clone();
                     async move {
                         if use_reflection {
-                            if let Err(e) =
-                                reflect_types_for_message(pool, &uri, &json, &md, client_cert).await
+                            if let Err(e) = reflect_types_for_message(
+                                pool,
+                                &uri,
+                                &json,
+                                &md,
+                                client_cert,
+                                max_message_size,
+                            )
+                            .await
                             {
                                 warn!("Failed to resolve Any types: {e}");
                             }
@@ -206,7 +223,7 @@ impl GrpcConnection {
                 .filter_map(|x| x)
         };
 
-        let mut client = tonic::client::Grpc::with_origin(self.conn.clone(), self.uri.clone());
+        let mut client = grpc_client(self.conn.clone(), self.uri.clone(), self.max_message_size);
         let path = method_desc_to_path(method);
         let codec = DynamicCodec::new(method.clone());
 
@@ -237,6 +254,7 @@ impl GrpcConnection {
             let md = metadata.clone();
             let use_reflection = self.use_reflection.clone();
             let client_cert = client_cert.clone();
+            let max_message_size = self.max_message_size;
             stream
                 .then(move |json| {
                     let pool = pool.clone();
@@ -249,8 +267,15 @@ impl GrpcConnection {
                     let json_clone = json.clone();
                     async move {
                         if use_reflection {
-                            if let Err(e) =
-                                reflect_types_for_message(pool, &uri, &json, &md, client_cert).await
+                            if let Err(e) = reflect_types_for_message(
+                                pool,
+                                &uri,
+                                &json,
+                                &md,
+                                client_cert,
+                                max_message_size,
+                            )
+                            .await
                             {
                                 warn!("Failed to resolve Any types: {e}");
                             }
@@ -272,7 +297,7 @@ impl GrpcConnection {
                 .filter_map(|x| x)
         };
 
-        let mut client = tonic::client::Grpc::with_origin(self.conn.clone(), self.uri.clone());
+        let mut client = grpc_client(self.conn.clone(), self.uri.clone(), self.max_message_size);
         let path = method_desc_to_path(method);
         let codec = DynamicCodec::new(method.clone());
 
@@ -300,7 +325,7 @@ impl GrpcConnection {
         let req_message = DynamicMessage::deserialize(input_message, &mut deserializer)?;
         deserializer.end()?;
 
-        let mut client = tonic::client::Grpc::with_origin(self.conn.clone(), self.uri.clone());
+        let mut client = grpc_client(self.conn.clone(), self.uri.clone(), self.max_message_size);
 
         let mut req = req_message.into_request();
         decorate_req(metadata, &mut req)?;
@@ -312,6 +337,23 @@ impl GrpcConnection {
     }
 }
 
+fn grpc_client(
+    conn: Client<HttpsConnector<HttpConnector>, BoxBody>,
+    uri: Uri,
+    max_message_size: usize,
+) -> tonic::client::Grpc<Client<HttpsConnector<HttpConnector>, BoxBody>> {
+    tonic::client::Grpc::with_origin(conn, uri)
+        .max_decoding_message_size(max_message_size)
+        .max_encoding_message_size(max_message_size)
+}
+
+fn message_size_limit(setting: i32) -> usize {
+    match setting.try_into() {
+        Ok(0) | Err(_) => usize::MAX,
+        Ok(limit) => limit,
+    }
+}
+
 /// Configuration for GrpcHandle to compile proto files
 #[derive(Clone)]
 pub struct GrpcConfig {
@@ -348,6 +390,7 @@ impl GrpcHandle {
         metadata: &BTreeMap<String, String>,
         validate_certificates: bool,
         client_cert: Option<ClientCertificateConfig>,
+        request_message_size: i32,
     ) -> Result<bool> {
         let server_reflection = proto_files.is_empty();
         let key = make_pool_key(id, uri, proto_files);
@@ -359,7 +402,14 @@ impl GrpcHandle {
 
         let pool = if server_reflection {
             let full_uri = uri_from_str(uri)?;
-            fill_pool_from_reflection(&full_uri, metadata, validate_certificates, client_cert).await
+            fill_pool_from_reflection(
+                &full_uri,
+                metadata,
+                validate_certificates,
+                client_cert,
+                message_size_limit(request_message_size),
+            )
+            .await
         } else {
             fill_pool_from_files(&self.config, proto_files).await
         }?;
@@ -376,12 +426,21 @@ impl GrpcHandle {
         metadata: &BTreeMap<String, String>,
         validate_certificates: bool,
         client_cert: Option<ClientCertificateConfig>,
+        request_message_size: i32,
     ) -> Result<Vec<ServiceDefinition>> {
         // Ensure we have a pool; reflect only if missing
         if self.get_pool(id, uri, proto_files).is_none() {
             info!("Reflecting gRPC services for {} at {}", id, uri);
-            self.reflect(id, uri, proto_files, metadata, validate_certificates, client_cert)
-                .await?;
+            self.reflect(
+                id,
+                uri,
+                proto_files,
+                metadata,
+                validate_certificates,
+                client_cert,
+                request_message_size,
+            )
+            .await?;
         }
 
         let pool = self
@@ -421,8 +480,10 @@ impl GrpcHandle {
         metadata: &BTreeMap<String, String>,
         validate_certificates: bool,
         client_cert: Option<ClientCertificateConfig>,
+        request_message_size: i32,
     ) -> Result<GrpcConnection> {
         let use_reflection = proto_files.is_empty();
+        let max_message_size = message_size_limit(request_message_size);
         if self.get_pool(id, uri, proto_files).is_none() {
             self.reflect(
                 id,
@@ -431,6 +492,7 @@ impl GrpcHandle {
                 metadata,
                 validate_certificates,
                 client_cert.clone(),
+                request_message_size,
             )
             .await?;
         }
@@ -440,7 +502,13 @@ impl GrpcHandle {
             .clone();
         let uri = uri_from_str(uri)?;
         let conn = get_transport(validate_certificates, client_cert.clone())?;
-        Ok(GrpcConnection { pool: Arc::new(RwLock::new(pool)), use_reflection, conn, uri })
+        Ok(GrpcConnection {
+            pool: Arc::new(RwLock::new(pool)),
+            use_reflection,
+            conn,
+            uri,
+            max_message_size,
+        })
     }
 
     fn get_pool(&self, id: &str, uri: &str, proto_files: &Vec<PathBuf>) -> Option<&DescriptorPool> {

crates/yaak-grpc/src/reflection.rs

@@ -119,9 +119,11 @@ pub async fn fill_pool_from_reflection(
     metadata: &BTreeMap<String, String>,
     validate_certificates: bool,
     client_cert: Option<ClientCertificateConfig>,
+    max_message_size: usize,
 ) -> Result<DescriptorPool> {
     let mut pool = DescriptorPool::new();
-    let mut client = AutoReflectionClient::new(uri, validate_certificates, client_cert)?;
+    let mut client =
+        AutoReflectionClient::new(uri, validate_certificates, client_cert, max_message_size)?;
 
     for service in list_services(&mut client, metadata).await? {
         if service == "grpc.reflection.v1alpha.ServerReflection" {
@@ -192,6 +194,7 @@ pub(crate) async fn reflect_types_for_message(
     json: &str,
     metadata: &BTreeMap<String, String>,
     client_cert: Option<ClientCertificateConfig>,
+    max_message_size: usize,
 ) -> Result<()> {
     // 1. Collect all Any types in the JSON
     let mut extra_types = Vec::new();
@@ -201,7 +204,7 @@ pub(crate) async fn reflect_types_for_message(
         return Ok(()); // nothing to do
     }
 
-    let mut client = AutoReflectionClient::new(uri, false, client_cert)?;
+    let mut client = AutoReflectionClient::new(uri, false, client_cert, max_message_size)?;
     for extra_type in extra_types {
         {
             let guard = pool.read().await;
@@ -239,6 +242,7 @@ pub(crate) async fn reflect_types_for_dynamic_message(
     message: &DynamicMessage,
     metadata: &BTreeMap<String, String>,
     client_cert: Option<ClientCertificateConfig>,
+    max_message_size: usize,
 ) -> Result<()> {
     let mut extra_types = HashSet::new();
     collect_any_types_from_dynamic_message(message, &mut extra_types);
@@ -247,7 +251,7 @@ pub(crate) async fn reflect_types_for_dynamic_message(
         return Ok(());
     }
 
-    let mut client = AutoReflectionClient::new(uri, false, client_cert)?;
+    let mut client = AutoReflectionClient::new(uri, false, client_cert, max_message_size)?;
     for extra_type in extra_types {
         {
             let guard = pool.read().await;

crates/yaak-models/bindings/gen_models.ts

@@ -109,6 +109,7 @@ export type Folder = {
   settingValidateCertificates: InheritedBoolSetting;
   settingFollowRedirects: InheritedBoolSetting;
   settingRequestTimeout: InheritedIntSetting;
+  settingRequestMessageSize: InheritedIntSetting;
 };
 
 export type GraphQlIntrospection = {
@@ -184,6 +185,7 @@ export type GrpcRequest = {
    */
   url: string;
   settingValidateCertificates: InheritedBoolSetting;
+  settingRequestMessageSize: InheritedIntSetting;
 };
 
 export type HttpRequest = {
@@ -482,6 +484,7 @@ export type WebsocketRequest = {
   settingSendCookies: InheritedBoolSetting;
   settingStoreCookies: InheritedBoolSetting;
   settingValidateCertificates: InheritedBoolSetting;
+  settingRequestMessageSize: InheritedIntSetting;
 };
 
 export type Workspace = {
@@ -498,6 +501,7 @@ export type Workspace = {
   settingValidateCertificates: boolean;
   settingFollowRedirects: boolean;
   settingRequestTimeout: number;
+  settingRequestMessageSize: number;
   settingDnsOverrides: Array<DnsOverride>;
   settingSendCookies: boolean;
   settingStoreCookies: boolean;

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

@@ -8,6 +8,8 @@ import { newStoreData } from "./util";
 
 let _store: JotaiStore | null = null;
 
+const pendingModelWrites = new Set<Promise<unknown>>();
+
 export function initModelStore(store: JotaiStore) {
   _store = store;
 
@@ -42,6 +44,23 @@ function mustStore(): JotaiStore {
   return _store;
 }
 
+function trackModelWrite<T>(write: Promise<T>): Promise<T> {
+  const tracked = write.finally(() => {
+    pendingModelWrites.delete(tracked);
+  });
+
+  pendingModelWrites.add(tracked);
+  return tracked;
+}
+
+export async function flushAllModelWrites(): Promise<void> {
+  const results = await Promise.allSettled([...pendingModelWrites]);
+  const rejected = results.find((result) => result.status === "rejected");
+  if (rejected?.status === "rejected") {
+    throw rejected.reason;
+  }
+}
+
 let _activeWorkspaceId: string | null = null;
 
 export async function changeModelStoreWorkspace(workspaceId: string | null) {
@@ -117,7 +136,7 @@ export async function patchModel<M extends AnyModel["model"], T extends ExtractM
 export async function updateModel<M extends AnyModel["model"], T extends ExtractModel<AnyModel, M>>(
   model: T,
 ): Promise<string> {
-  return invoke<string>("models_upsert", { model });
+  return trackModelWrite(invoke<string>("models_upsert", { model }));
 }
 
 export async function deleteModelById<
@@ -134,7 +153,7 @@ export async function deleteModel<M extends AnyModel["model"], T extends Extract
   if (model == null) {
     throw new Error("Failed to delete null model");
   }
-  await invoke<string>("models_delete", { model });
+  await trackModelWrite(invoke<string>("models_delete", { model }));
 }
 
 export function duplicateModel<M extends AnyModel["model"], T extends ExtractModel<AnyModel, M>>(
@@ -174,19 +193,19 @@ export function duplicateModel<M extends AnyModel["model"], T extends ExtractMod
     }
   }
 
-  return invoke<string>("models_duplicate", { model: { ...model, name } });
+  return trackModelWrite(invoke<string>("models_duplicate", { model: { ...model, name } }));
 }
 
 export async function createGlobalModel<T extends Exclude<AnyModel, { workspaceId: string }>>(
   patch: Partial<T> & Pick<T, "model">,
 ): Promise<string> {
-  return invoke<string>("models_upsert", { model: patch });
+  return trackModelWrite(invoke<string>("models_upsert", { model: patch }));
 }
 
 export async function createWorkspaceModel<T extends Extract<AnyModel, { workspaceId: string }>>(
   patch: Partial<T> & Pick<T, "model" | "workspaceId">,
 ): Promise<string> {
-  return invoke<string>("models_upsert", { model: patch });
+  return trackModelWrite(invoke<string>("models_upsert", { model: patch }));
 }
 
 export function replaceModelsInStore<

crates/yaak-models/migrations/20260629000000_request-message-size.sql

@@ -0,0 +1,7 @@
+ALTER TABLE workspaces ADD COLUMN setting_request_message_size INTEGER DEFAULT 67108864 NOT NULL;
+
+ALTER TABLE folders ADD COLUMN setting_request_message_size TEXT DEFAULT '{"enabled":false,"value":67108864}' NOT NULL;
+
+ALTER TABLE websocket_requests ADD COLUMN setting_request_message_size TEXT DEFAULT '{"enabled":false,"value":67108864}' NOT NULL;
+
+ALTER TABLE grpc_requests ADD COLUMN setting_request_message_size TEXT DEFAULT '{"enabled":false,"value":67108864}' NOT NULL;

crates/yaak-models/src/models.rs

@@ -21,6 +21,8 @@ use ts_rs::TS;
 use yaak_database::{Result as DbResult, UpdateSource};
 pub use yaak_database::{UpsertModelInfo, upsert_date};
 
+pub const DEFAULT_REQUEST_MESSAGE_SIZE: i32 = 64 * 1024 * 1024;
+
 #[macro_export]
 macro_rules! impl_model {
     ($t:ty, $variant:ident) => {
@@ -120,6 +122,7 @@ pub struct ResolvedHttpRequestSettings {
     pub validate_certificates: ResolvedSetting<bool>,
     pub follow_redirects: ResolvedSetting<bool>,
     pub request_timeout: ResolvedSetting<i32>,
+    pub request_message_size: ResolvedSetting<i32>,
     pub send_cookies: ResolvedSetting<bool>,
     pub store_cookies: ResolvedSetting<bool>,
 }
@@ -130,6 +133,7 @@ impl Default for ResolvedHttpRequestSettings {
             validate_certificates: ResolvedSetting::default_source(true),
             follow_redirects: ResolvedSetting::default_source(true),
             request_timeout: ResolvedSetting::default_source(0),
+            request_message_size: ResolvedSetting::default_source(DEFAULT_REQUEST_MESSAGE_SIZE),
             send_cookies: ResolvedSetting::default_source(true),
             store_cookies: ResolvedSetting::default_source(true),
         }
@@ -400,6 +404,8 @@ pub struct Workspace {
     #[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")]
@@ -445,6 +451,7 @@ impl UpsertModelInfo for Workspace {
             (EncryptionKeyChallenge, self.encryption_key_challenge.into()),
             (SettingFollowRedirects, self.setting_follow_redirects.into()),
             (SettingRequestTimeout, self.setting_request_timeout.into()),
+            (SettingRequestMessageSize, self.setting_request_message_size.into()),
             (SettingValidateCertificates, self.setting_validate_certificates.into()),
             (SettingDnsOverrides, serde_json::to_string(&self.setting_dns_overrides)?.into()),
             (SettingSendCookies, self.setting_send_cookies.into()),
@@ -463,7 +470,7 @@ impl UpsertModelInfo for Workspace {
             WorkspaceIden::EncryptionKeyChallenge,
             WorkspaceIden::SettingRequestTimeout,
             WorkspaceIden::SettingFollowRedirects,
-            WorkspaceIden::SettingRequestTimeout,
+            WorkspaceIden::SettingRequestMessageSize,
             WorkspaceIden::SettingValidateCertificates,
             WorkspaceIden::SettingDnsOverrides,
             WorkspaceIden::SettingSendCookies,
@@ -491,6 +498,7 @@ impl UpsertModelInfo for Workspace {
             authentication_type: row.get("authentication_type")?,
             setting_follow_redirects: row.get("setting_follow_redirects")?,
             setting_request_timeout: row.get("setting_request_timeout")?,
+            setting_request_message_size: row.get("setting_request_message_size")?,
             setting_validate_certificates: row.get("setting_validate_certificates")?,
             setting_dns_overrides: serde_json::from_str(&setting_dns_overrides).unwrap_or_default(),
             setting_send_cookies: row.get("setting_send_cookies")?,
@@ -962,6 +970,8 @@ 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,
 }
 
 impl UpsertModelInfo for Folder {
@@ -1009,6 +1019,10 @@ impl UpsertModelInfo for Folder {
             ),
             (SettingFollowRedirects, serde_json::to_string(&self.setting_follow_redirects)?.into()),
             (SettingRequestTimeout, serde_json::to_string(&self.setting_request_timeout)?.into()),
+            (
+                SettingRequestMessageSize,
+                serde_json::to_string(&self.setting_request_message_size)?.into(),
+            ),
         ])
     }
 
@@ -1027,6 +1041,7 @@ impl UpsertModelInfo for Folder {
             FolderIden::SettingValidateCertificates,
             FolderIden::SettingFollowRedirects,
             FolderIden::SettingRequestTimeout,
+            FolderIden::SettingRequestMessageSize,
         ]
     }
 
@@ -1041,6 +1056,7 @@ impl UpsertModelInfo for Folder {
         let setting_validate_certificates: String = row.get("setting_validate_certificates")?;
         let setting_follow_redirects: String = row.get("setting_follow_redirects")?;
         let setting_request_timeout: String = row.get("setting_request_timeout")?;
+        let setting_request_message_size: String = row.get("setting_request_message_size")?;
         Ok(Self {
             id: row.get("id")?,
             model: row.get("model")?,
@@ -1062,6 +1078,8 @@ impl UpsertModelInfo for Folder {
                 .unwrap_or_default(),
             setting_request_timeout: serde_json::from_str(&setting_request_timeout)
                 .unwrap_or_default(),
+            setting_request_message_size: serde_json::from_str(&setting_request_message_size)
+                .unwrap_or_else(|_| default_request_message_size_setting()),
         })
     }
 }
@@ -1398,6 +1416,8 @@ 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,
 }
 
 impl UpsertModelInfo for WebsocketRequest {
@@ -1446,6 +1466,10 @@ impl UpsertModelInfo for WebsocketRequest {
                 SettingValidateCertificates,
                 serde_json::to_string(&self.setting_validate_certificates)?.into(),
             ),
+            (
+                SettingRequestMessageSize,
+                serde_json::to_string(&self.setting_request_message_size)?.into(),
+            ),
         ])
     }
 
@@ -1466,6 +1490,7 @@ impl UpsertModelInfo for WebsocketRequest {
             WebsocketRequestIden::SettingSendCookies,
             WebsocketRequestIden::SettingStoreCookies,
             WebsocketRequestIden::SettingValidateCertificates,
+            WebsocketRequestIden::SettingRequestMessageSize,
         ]
     }
 
@@ -1479,6 +1504,7 @@ impl UpsertModelInfo for WebsocketRequest {
         let setting_send_cookies: String = row.get("setting_send_cookies")?;
         let setting_store_cookies: String = row.get("setting_store_cookies")?;
         let setting_validate_certificates: String = row.get("setting_validate_certificates")?;
+        let setting_request_message_size: String = row.get("setting_request_message_size")?;
         Ok(Self {
             id: row.get("id")?,
             model: row.get("model")?,
@@ -1499,6 +1525,8 @@ impl UpsertModelInfo for WebsocketRequest {
             setting_store_cookies: serde_json::from_str(&setting_store_cookies).unwrap_or_default(),
             setting_validate_certificates: serde_json::from_str(&setting_validate_certificates)
                 .unwrap_or_default(),
+            setting_request_message_size: serde_json::from_str(&setting_request_message_size)
+                .unwrap_or_else(|_| default_request_message_size_setting()),
         })
     }
 }
@@ -2039,6 +2067,8 @@ 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,
 }
 
 impl UpsertModelInfo for GrpcRequest {
@@ -2086,6 +2116,10 @@ impl UpsertModelInfo for GrpcRequest {
                 SettingValidateCertificates,
                 serde_json::to_string(&self.setting_validate_certificates)?.into(),
             ),
+            (
+                SettingRequestMessageSize,
+                serde_json::to_string(&self.setting_request_message_size)?.into(),
+            ),
         ])
     }
 
@@ -2105,6 +2139,7 @@ impl UpsertModelInfo for GrpcRequest {
             GrpcRequestIden::Authentication,
             GrpcRequestIden::Metadata,
             GrpcRequestIden::SettingValidateCertificates,
+            GrpcRequestIden::SettingRequestMessageSize,
         ]
     }
 
@@ -2115,6 +2150,7 @@ impl UpsertModelInfo for GrpcRequest {
         let authentication: String = row.get("authentication")?;
         let metadata: String = row.get("metadata")?;
         let setting_validate_certificates: String = row.get("setting_validate_certificates")?;
+        let setting_request_message_size: String = row.get("setting_request_message_size")?;
         Ok(Self {
             id: row.get("id")?,
             model: row.get("model")?,
@@ -2134,6 +2170,8 @@ impl UpsertModelInfo for GrpcRequest {
             metadata: serde_json::from_str(metadata.as_str()).unwrap_or_default(),
             setting_validate_certificates: serde_json::from_str(&setting_validate_certificates)
                 .unwrap_or_default(),
+            setting_request_message_size: serde_json::from_str(&setting_request_message_size)
+                .unwrap_or_else(|_| default_request_message_size_setting()),
         })
     }
 }
@@ -2684,6 +2722,14 @@ 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()
 }

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

@@ -180,6 +180,14 @@ impl<'a> ClientDb<'a> {
             } else {
                 parent.request_timeout
             },
+            request_message_size: if folder.setting_request_message_size.enabled {
+                ResolvedSetting::from_model(
+                    folder.setting_request_message_size.value,
+                    AnyModel::Folder(folder.clone()),
+                )
+            } else {
+                parent.request_message_size
+            },
             send_cookies: if folder.setting_send_cookies.enabled {
                 ResolvedSetting::from_model(
                     folder.setting_send_cookies.value,

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

@@ -129,6 +129,14 @@ impl<'a> ClientDb<'a> {
             } else {
                 parent.validate_certificates
             },
+            request_message_size: if grpc_request.setting_request_message_size.enabled {
+                ResolvedSetting::from_model(
+                    grpc_request.setting_request_message_size.value,
+                    AnyModel::GrpcRequest(grpc_request.clone()),
+                )
+            } else {
+                parent.request_message_size
+            },
             ..parent
         })
     }

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

@@ -131,6 +131,7 @@ impl<'a> ClientDb<'a> {
             } else {
                 parent.request_timeout
             },
+            request_message_size: parent.request_message_size,
             send_cookies: if http_request.setting_send_cookies.enabled {
                 ResolvedSetting::from_model(
                     http_request.setting_send_cookies.value,

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

@@ -139,6 +139,14 @@ impl<'a> ClientDb<'a> {
             } else {
                 parent.validate_certificates
             },
+            request_message_size: if websocket_request.setting_request_message_size.enabled {
+                ResolvedSetting::from_model(
+                    websocket_request.setting_request_message_size.value,
+                    AnyModel::WebsocketRequest(websocket_request.clone()),
+                )
+            } else {
+                parent.request_message_size
+            },
             send_cookies: if websocket_request.setting_send_cookies.enabled {
                 ResolvedSetting::from_model(
                     websocket_request.setting_send_cookies.value,

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

@@ -21,6 +21,7 @@ impl<'a> ClientDb<'a> {
                 &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()
                 },
@@ -102,6 +103,10 @@ impl<'a> ClientDb<'a> {
                 workspace.setting_request_timeout,
                 AnyModel::Workspace(workspace.clone()),
             ),
+            request_message_size: ResolvedSetting::from_model(
+                workspace.setting_request_message_size,
+                AnyModel::Workspace(workspace.clone()),
+            ),
             send_cookies: ResolvedSetting::from_model(
                 workspace.setting_send_cookies,
                 AnyModel::Workspace(workspace.clone()),

crates/yaak-plugins/bindings/gen_models.ts

@@ -108,6 +108,7 @@ export type Folder = {
   settingValidateCertificates: InheritedBoolSetting;
   settingFollowRedirects: InheritedBoolSetting;
   settingRequestTimeout: InheritedIntSetting;
+  settingRequestMessageSize: InheritedIntSetting;
 };
 
 export type GraphQlIntrospection = {
@@ -183,6 +184,7 @@ export type GrpcRequest = {
    */
   url: string;
   settingValidateCertificates: InheritedBoolSetting;
+  settingRequestMessageSize: InheritedIntSetting;
 };
 
 export type HttpRequest = {
@@ -450,6 +452,7 @@ export type WebsocketRequest = {
   settingSendCookies: InheritedBoolSetting;
   settingStoreCookies: InheritedBoolSetting;
   settingValidateCertificates: InheritedBoolSetting;
+  settingRequestMessageSize: InheritedIntSetting;
 };
 
 export type Workspace = {
@@ -466,6 +469,7 @@ export type Workspace = {
   settingValidateCertificates: boolean;
   settingFollowRedirects: boolean;
   settingRequestTimeout: number;
+  settingRequestMessageSize: number;
   settingDnsOverrides: Array<DnsOverride>;
   settingSendCookies: boolean;
   settingStoreCookies: boolean;

crates/yaak-sync/bindings/gen_models.ts

@@ -46,6 +46,7 @@ export type Folder = {
   settingValidateCertificates: InheritedBoolSetting;
   settingFollowRedirects: InheritedBoolSetting;
   settingRequestTimeout: InheritedIntSetting;
+  settingRequestMessageSize: InheritedIntSetting;
 };
 
 export type GrpcRequest = {
@@ -69,6 +70,7 @@ export type GrpcRequest = {
    */
   url: string;
   settingValidateCertificates: InheritedBoolSetting;
+  settingRequestMessageSize: InheritedIntSetting;
 };
 
 export type HttpRequest = {
@@ -159,6 +161,7 @@ export type WebsocketRequest = {
   settingSendCookies: InheritedBoolSetting;
   settingStoreCookies: InheritedBoolSetting;
   settingValidateCertificates: InheritedBoolSetting;
+  settingRequestMessageSize: InheritedIntSetting;
 };
 
 export type Workspace = {
@@ -175,6 +178,7 @@ export type Workspace = {
   settingValidateCertificates: boolean;
   settingFollowRedirects: boolean;
   settingRequestTimeout: number;
+  settingRequestMessageSize: number;
   settingDnsOverrides: Array<DnsOverride>;
   settingSendCookies: boolean;
   settingStoreCookies: boolean;

crates/yaak-ws/src/connect.rs

@@ -20,6 +20,7 @@ pub async fn ws_connect(
     headers: HeaderMap<HeaderValue>,
     validate_certificates: bool,
     client_cert: Option<ClientCertificateConfig>,
+    request_message_size: i32,
 ) -> Result<(WebSocketStream<MaybeTlsStream<TcpStream>>, Response)> {
     info!("Connecting to WS {url}");
     let tls_config = get_tls_config(validate_certificates, WITH_ALPN, client_cert.clone())?;
@@ -34,7 +35,7 @@ pub async fn ws_connect(
 
     let (stream, response) = connect_async_tls_with_config(
         req,
-        Some(WebSocketConfig::default()),
+        Some(websocket_config(request_message_size)),
         false,
         Some(Connector::Rustls(Arc::new(tls_config))),
     )
@@ -48,3 +49,12 @@ pub async fn ws_connect(
 
     Ok((stream, response))
 }
+
+fn websocket_config(request_message_size: i32) -> WebSocketConfig {
+    let max_message_size = message_size_limit(request_message_size);
+    WebSocketConfig::default().max_message_size(max_message_size).max_frame_size(max_message_size)
+}
+
+pub(crate) fn message_size_limit(setting: i32) -> Option<usize> {
+    setting.try_into().ok().filter(|limit| *limit > 0)
+}

crates/yaak-ws/src/manager.rs

@@ -1,4 +1,5 @@
-use crate::connect::ws_connect;
+use crate::connect::{message_size_limit, ws_connect};
+use crate::error::Error::GenericError;
 use crate::error::Result;
 use futures_util::stream::SplitSink;
 use futures_util::{SinkExt, StreamExt};
@@ -15,10 +16,16 @@ use tokio_tungstenite::tungstenite::http::HeaderValue;
 use tokio_tungstenite::{MaybeTlsStream, WebSocketStream};
 use yaak_tls::ClientCertificateConfig;
 
+type WebsocketSink = SplitSink<WebSocketStream<MaybeTlsStream<TcpStream>>, Message>;
+
+struct WebsocketConnection {
+    max_message_size: Option<usize>,
+    sink: WebsocketSink,
+}
+
 #[derive(Clone)]
 pub struct WebsocketManager {
-    connections:
-        Arc<Mutex<HashMap<String, SplitSink<WebSocketStream<MaybeTlsStream<TcpStream>>, Message>>>>,
+    connections: Arc<Mutex<HashMap<String, WebsocketConnection>>>,
     read_tasks: Arc<Mutex<HashMap<String, tokio::task::JoinHandle<()>>>>,
 }
 
@@ -35,14 +42,20 @@ impl WebsocketManager {
         receive_tx: mpsc::Sender<Message>,
         validate_certificates: bool,
         client_cert: Option<ClientCertificateConfig>,
+        request_message_size: i32,
     ) -> Result<Response> {
         let tx = receive_tx.clone();
+        let max_message_size = message_size_limit(request_message_size);
 
         let (stream, response) =
-            ws_connect(url, headers, validate_certificates, client_cert).await?;
+            ws_connect(url, headers, validate_certificates, client_cert, request_message_size)
+                .await?;
         let (write, mut read) = stream.split();
 
-        self.connections.lock().await.insert(id.to_string(), write);
+        self.connections
+            .lock()
+            .await
+            .insert(id.to_string(), WebsocketConnection { max_message_size, sink: write });
 
         let handle = {
             let connection_id = id.to_string();
@@ -76,7 +89,15 @@ impl WebsocketManager {
             None => return Ok(()),
             Some(c) => c,
         };
-        connection.send(msg).await?;
+        if let Some(limit) = connection.max_message_size {
+            let message_size = msg.len();
+            if message_size > limit {
+                return Err(GenericError(format!(
+                    "WebSocket message too large: found {message_size} bytes, the limit is {limit} bytes"
+                )));
+            }
+        }
+        connection.sink.send(msg).await?;
         Ok(())
     }
 
@@ -84,7 +105,7 @@ impl WebsocketManager {
         info!("Closing websocket");
         if let Some(mut connection) = self.connections.lock().await.remove(id) {
             // Wait a maximum of 1 second for the connection to close
-            if let Err(e) = connection.close().await {
+            if let Err(e) = connection.sink.close().await {
                 warn!("Failed to close websocket connection {e:?}");
             };
         }

crates/yaak/Cargo.toml

@@ -12,6 +12,7 @@ serde_json = { workspace = true }
 thiserror = { workspace = true }
 tokio = { workspace = true, features = ["sync", "rt"] }
 yaak-http = { workspace = true }
+yaak-core = { workspace = true }
 yaak-crypto = { workspace = true }
 yaak-models = { workspace = true }
 yaak-plugins = { workspace = true }

crates/yaak/src/error.rs

@@ -4,6 +4,18 @@ use thiserror::Error;
 pub enum Error {
     #[error(transparent)]
     Send(#[from] crate::send::SendHttpRequestError),
+
+    #[error(transparent)]
+    Model(#[from] yaak_models::error::Error),
+
+    #[error(transparent)]
+    Plugin(#[from] yaak_plugins::error::Error),
+
+    #[error("I/O error: {0}")]
+    Io(#[from] std::io::Error),
+
+    #[error("JSON error: {0}")]
+    Json(#[from] serde_json::Error),
 }
 
 pub type Result<T> = std::result::Result<T, Error>;

crates/yaak/src/export.rs

@@ -0,0 +1,29 @@
+use crate::Result;
+use std::fs::File;
+use std::path::Path;
+use yaak_models::query_manager::QueryManager;
+use yaak_models::util::get_workspace_export_resources;
+
+pub struct ExportDataParams<'a> {
+    pub query_manager: &'a QueryManager,
+    pub yaak_version: &'a str,
+    pub export_path: &'a Path,
+    pub workspace_ids: Vec<&'a str>,
+    pub include_private_environments: bool,
+}
+
+pub fn export_data(params: ExportDataParams<'_>) -> Result<()> {
+    let db = params.query_manager.connect();
+    let export_data = get_workspace_export_resources(
+        &db,
+        params.yaak_version,
+        params.workspace_ids,
+        params.include_private_environments,
+    )?;
+
+    let file = File::options().create(true).truncate(true).write(true).open(params.export_path)?;
+    serde_json::to_writer_pretty(&file, &export_data)?;
+    file.sync_all()?;
+
+    Ok(())
+}

crates/yaak/src/import.rs

@@ -0,0 +1,129 @@
+use crate::Result;
+use log::info;
+use std::collections::BTreeMap;
+use yaak_core::WorkspaceContext;
+use yaak_models::models::{
+    Environment, Folder, GrpcRequest, HttpRequest, WebsocketRequest, Workspace,
+};
+use yaak_models::query_manager::QueryManager;
+use yaak_models::util::{BatchUpsertResult, UpdateSource, maybe_gen_id, maybe_gen_id_opt};
+use yaak_plugins::events::{ImportResources, PluginContext};
+use yaak_plugins::manager::PluginManager;
+
+pub struct ImportDataParams<'a> {
+    pub query_manager: &'a QueryManager,
+    pub plugin_manager: &'a PluginManager,
+    pub plugin_context: &'a PluginContext,
+    pub workspace_context: WorkspaceContext,
+    pub contents: &'a str,
+}
+
+pub async fn import_data(params: ImportDataParams<'_>) -> Result<BatchUpsertResult> {
+    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)
+}
+
+pub fn import_resources(
+    query_manager: &QueryManager,
+    workspace_context: WorkspaceContext,
+    resources: ImportResources,
+) -> Result<BatchUpsertResult> {
+    let mut id_map: BTreeMap<String, String> = BTreeMap::new();
+
+    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 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 folders: Vec<Folder> = 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
+        })
+        .collect();
+
+    let http_requests: Vec<HttpRequest> = 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
+        })
+        .collect();
+
+    let grpc_requests: Vec<GrpcRequest> = 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
+        })
+        .collect();
+
+    let websocket_requests: Vec<WebsocketRequest> = 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
+        })
+        .collect();
+
+    info!("Importing data");
+
+    query_manager.with_tx(|tx| {
+        tx.batch_upsert(
+            workspaces,
+            environments,
+            folders,
+            http_requests,
+            grpc_requests,
+            websocket_requests,
+            &UpdateSource::Import,
+        )
+        .map_err(crate::Error::from)
+    })
+}

crates/yaak/src/lib.rs

@@ -1,4 +1,6 @@
 pub mod error;
+pub mod export;
+pub mod import;
 pub mod plugin_events;
 pub mod render;
 pub mod send;

package-lock.json

@@ -16970,6 +16970,7 @@
         "ws": "^8.20.1"
       },
       "devDependencies": {
+        "@types/node": "^24.0.13",
         "@types/ws": "^8.5.13"
       }
     },
@@ -16991,6 +16992,23 @@
         "undici-types": "~7.16.0"
       }
     },
+    "packages/plugin-runtime/node_modules/@types/node": {
+      "version": "24.13.2",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-24.13.2.tgz",
+      "integrity": "sha512-fRa09kZTgu8o71KFcDjUFuc7F+dEbZYZmkI0mg5YBTRs0yMKjYHsq/c0urDKeDb+D5qVgXOdFcuu+DZPKOITwA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~7.18.0"
+      }
+    },
+    "packages/plugin-runtime/node_modules/undici-types": {
+      "version": "7.18.2",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.18.2.tgz",
+      "integrity": "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w==",
+      "dev": true,
+      "license": "MIT"
+    },
     "packages/tailwind-config": {
       "name": "@yaakapp-internal/tailwind-config",
       "version": "1.0.0",

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

@@ -108,6 +108,7 @@ export type Folder = {
   settingValidateCertificates: InheritedBoolSetting;
   settingFollowRedirects: InheritedBoolSetting;
   settingRequestTimeout: InheritedIntSetting;
+  settingRequestMessageSize: InheritedIntSetting;
 };
 
 export type GraphQlIntrospection = {
@@ -183,6 +184,7 @@ export type GrpcRequest = {
    */
   url: string;
   settingValidateCertificates: InheritedBoolSetting;
+  settingRequestMessageSize: InheritedIntSetting;
 };
 
 export type HttpRequest = {
@@ -450,6 +452,7 @@ export type WebsocketRequest = {
   settingSendCookies: InheritedBoolSetting;
   settingStoreCookies: InheritedBoolSetting;
   settingValidateCertificates: InheritedBoolSetting;
+  settingRequestMessageSize: InheritedIntSetting;
 };
 
 export type Workspace = {
@@ -466,6 +469,7 @@ export type Workspace = {
   settingValidateCertificates: boolean;
   settingFollowRedirects: boolean;
   settingRequestTimeout: number;
+  settingRequestMessageSize: number;
   settingDnsOverrides: Array<DnsOverride>;
   settingSendCookies: boolean;
   settingStoreCookies: boolean;

packages/plugin-runtime/.node-version

@@ -0,0 +1 @@
+24.11.1

packages/plugin-runtime/package.json

@@ -9,6 +9,7 @@
     "ws": "^8.20.1"
   },
   "devDependencies": {
+    "@types/node": "^24.0.13",
     "@types/ws": "^8.5.13"
   }
 }

packages/plugin-runtime/src/metadata.ts

@@ -0,0 +1,190 @@
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import type { PluginDefinition } from "@yaakapp/api";
+
+type PluginFeatureKey = Exclude<
+  Extract<keyof PluginDefinition, string>,
+  "init" | "dispose"
+>;
+type PluginAPIKey = PluginFeatureKey | "lifecycle";
+
+type MetadataDefinition = {
+  key: PluginFeatureKey;
+  label: string;
+  array: boolean;
+};
+
+type MetadataItem =
+  | string
+  | number
+  | boolean
+  | null
+  | MetadataItem[]
+  | { [key: string]: MetadataItem };
+
+type APITypeMetadata = {
+  label: string;
+  source: string;
+  count: number;
+  items: MetadataItem[];
+};
+
+type PluginMetadata = {
+  schemaVersion: 1;
+  apiTypes: PluginAPIKey[];
+  apis: Partial<Record<PluginAPIKey, APITypeMetadata>>;
+};
+
+const definitions: MetadataDefinition[] = [
+  {
+    key: "authentication",
+    label: "Authentication",
+    array: false,
+  },
+  { key: "filter", label: "Filter", array: false },
+  {
+    key: "folderActions",
+    label: "Folder Action",
+    array: true,
+  },
+  {
+    key: "grpcRequestActions",
+    label: "gRPC Request Action",
+    array: true,
+  },
+  {
+    key: "httpRequestActions",
+    label: "HTTP Request Action",
+    array: true,
+  },
+  { key: "importer", label: "Importer", array: false },
+  {
+    key: "templateFunctions",
+    label: "Template Tag",
+    array: true,
+  },
+  { key: "themes", label: "Theme", array: true },
+  {
+    key: "websocketRequestActions",
+    label: "WebSocket Request Action",
+    array: true,
+  },
+  {
+    key: "workspaceActions",
+    label: "Workspace Action",
+    array: true,
+  },
+];
+
+export function generatePluginMetadata(
+  plugin: PluginDefinition,
+): PluginMetadata {
+  const metadata: PluginMetadata = {
+    schemaVersion: 1,
+    apiTypes: [],
+    apis: {},
+  };
+
+  for (const definition of definitions) {
+    const value = plugin[definition.key];
+    const items = definition.array ? value : value ? [value] : [];
+
+    if (!Array.isArray(items) || items.length === 0) {
+      continue;
+    }
+
+    metadata.apiTypes.push(definition.key);
+    metadata.apis[definition.key] = {
+      label: definition.label,
+      source: definition.key,
+      count: items.length,
+      items: sanitize(items) as MetadataItem[],
+    };
+  }
+
+  const lifecycleHooks = ["init", "dispose"].filter(
+    (key) =>
+      typeof plugin[key as keyof Pick<PluginDefinition, "init" | "dispose">] ===
+      "function",
+  );
+  if (lifecycleHooks.length > 0) {
+    metadata.apiTypes.push("lifecycle");
+    metadata.apis.lifecycle = {
+      label: "Lifecycle Hook",
+      source: lifecycleHooks.join(","),
+      count: lifecycleHooks.length,
+      items: lifecycleHooks.map((name) => ({ name })),
+    };
+  }
+
+  return metadata;
+}
+
+const entryPath = process.argv[1];
+const outputPath = process.argv[2];
+
+if (!entryPath) {
+  throw new Error("Missing plugin entrypoint path");
+}
+if (!outputPath) {
+  throw new Error("Missing plugin metadata output path");
+}
+
+const require = createRequire(path.join(process.cwd(), "plugin-metadata.js"));
+const moduleExports = require(path.resolve(entryPath)) as PluginDefinition & {
+  plugin?: PluginDefinition;
+  default?: PluginDefinition;
+};
+const plugin = moduleExports.plugin ?? moduleExports.default ?? moduleExports;
+
+if (!plugin || typeof plugin !== "object") {
+  throw new Error("Plugin entrypoint must export a plugin object");
+}
+
+const metadata = generatePluginMetadata(plugin);
+fs.writeFileSync(outputPath, `${JSON.stringify(metadata, null, 2)}\n`);
+
+function sanitize(
+  value: unknown,
+  seen = new WeakSet<object>(),
+): MetadataItem | undefined {
+  if (value === null) return null;
+
+  switch (typeof value) {
+    case "boolean":
+    case "number":
+    case "string":
+      return value;
+    case "bigint":
+      return value.toString();
+    case "function":
+    case "symbol":
+    case "undefined":
+      return undefined;
+  }
+
+  const objectValue = value as object;
+  if (seen.has(objectValue)) {
+    return "[Circular]";
+  }
+
+  seen.add(objectValue);
+
+  if (Array.isArray(value)) {
+    const output = value.map((item) => sanitize(item, seen) ?? null);
+    seen.delete(objectValue);
+    return output;
+  }
+
+  const output: Record<string, MetadataItem> = {};
+  for (const [key, item] of Object.entries(objectValue)) {
+    const sanitized = sanitize(item, seen);
+    if (sanitized !== undefined) {
+      output[key] = sanitized;
+    }
+  }
+
+  seen.delete(objectValue);
+  return output;
+}

packages/ui/src/components/tree/TreeItem.tsx

@@ -364,6 +364,8 @@ function TreeItem_<T extends { id: string }>({
                   ref={handleEditFocus}
                   defaultValue={defaultValue}
                   placeholder={placeholder}
+                  autoCapitalize="off"
+                  autoCorrect="off"
                   className="bg-transparent outline-none w-full cursor-text"
                   onBlur={handleEditBlur}
                   onKeyDown={handleEditKeyDown}

scripts/vendor-node.cjs

@@ -6,7 +6,8 @@ const Downloader = require("nodejs-file-downloader");
 const { rmSync, cpSync, mkdirSync, existsSync } = require("node:fs");
 const { execSync } = require("node:child_process");
 
-const NODE_VERSION = "v24.11.1";
+const nodeVersionFile = path.join(__dirname, "..", "packages", "plugin-runtime", ".node-version");
+const NODE_VERSION = `v${fs.readFileSync(nodeVersionFile, "utf8").trim().replace(/^v/, "")}`;
 
 // `${process.platform}_${process.arch}`
 const MAC_ARM = "darwin_arm64";