Transform CPU

.github/FUNDING.yml

@@ -1,15 +0,0 @@
-# These are supported funding model platforms
-
-github: gschier
-patreon: # Replace with a single Patreon username
-open_collective: # Replace with a single Open Collective username
-ko_fi: # Replace with a single Ko-fi username
-tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
-community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
-liberapay: # Replace with a single Liberapay username
-issuehunt: # Replace with a single IssueHunt username
-lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
-polar: # Replace with a single Polar username
-buy_me_a_coffee: # Replace with a single Buy Me a Coffee username
-thanks_dev: # Replace with a single thanks.dev username
-custom: https://yaak.app/pricing

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,38 +0,0 @@
----
-name: Bug report
-about: Create a report to help us improve
-title: ''
-labels: ''
-assignees: ''
-
----
-
-**Describe the bug**
-A clear and concise description of what the bug is.
-
-**To Reproduce**
-Steps to reproduce the behavior:
-1. Go to '...'
-2. Click on '....'
-3. Scroll down to '....'
-4. See error
-
-**Expected behavior**
-A clear and concise description of what you expected to happen.
-
-**Screenshots**
-If applicable, add screenshots to help explain your problem.
-
-**Desktop (please complete the following information):**
- - OS: [e.g. iOS]
- - Browser [e.g. chrome, safari]
- - Version [e.g. 22]
-
-**Smartphone (please complete the following information):**
- - Device: [e.g. iPhone6]
- - OS: [e.g. iOS8.1]
- - Browser [e.g. stock browser, safari]
- - Version [e.g. 22]
-
-**Additional context**
-Add any other context about the problem here.

.github/workflows/release.yml

@@ -65,7 +65,7 @@ jobs:
 
       - name: install dependencies (windows only)
         if: matrix.platform == 'windows-latest'
-        run: cargo install --force trusted-signing-cli --version 0.5.0
+        run: cargo install --force trusted-signing-cli
 
       - name: Install NPM Dependencies
         run: |

DEVELOPMENT.md

@@ -60,10 +60,3 @@ Run the app to apply the migrations.
 If nothing happens, try `cargo clean` and run the app again.
 
 _Note: Development builds use a separate database location from production builds._
-
-## Lezer Grammer Generation
-
-```sh
-# Example
-lezer-generator components/core/Editor/<LANG>/<LANG>.grammar > components/core/Editor/<LANG>/<LANG>.ts
-```

README.md

@@ -1,34 +1,26 @@
 # Yaak API Client
 
-Yaak is a desktop API client for interacting with REST, GraphQL, Server Sent Events (SSE), WebSocket, and gRPC
-APIs. It's built using [Tauri](https://tauri.app), Rust, and ReactJS.
+Yaak is a desktop API client for organizing and executing REST, GraphQL, and gRPC
+requests. It's built using [Tauri](https://tauri.app), Rust, and ReactJS.
 
-![366149288-f18e963f-0b68-4ecb-b8b8-cb71aa9aec02](https://github.com/user-attachments/assets/ca83b7ad-5708-411b-8faf-e36b365841a4)
+![screenshot](https://github.com/user-attachments/assets/f18e963f-0b68-4ecb-b8b8-cb71aa9aec02)
+
+## Feedback and Bug Reports
+
+All feedback, bug reports, questions, and feature requests should be reported to
+[feedback.yaak.app](https://feedback.yaak.app). Issues will be duplicated
+in this repository if applicable.
+
+## Community Projects
+
+- [`yaak2postman`](https://github.com/BiteCraft/yaak2postman) CLI for converting Yaak data
+  exports to Postman-compatible collections
 
 ## Contribution Policy
 
-Yaak is open source, but only accepting contributions for bug fixes. To get started, 
-visit [`DEVELOPMENT.md`](DEVELOPMENT.md) for tips on setting up your environment.
+Yaak is open source, but only accepting contributions for bug fixes. See the
+[`good first issue`](https://github.com/yaakapp/app/labels/good%20first%20issue) label for
+issues that are more approachable for contribution.
 
-## Feature Overview
-
-- 🪂 Import data from Postman, Insomnia, OpenAPI, Swagger, or Curl.<br/>
-- 📤 Send requests via REST, GraphQL, Server Sent Events (SSE), WebSockets, or gRPC.<br/>
-- 🔐 Automatically authorize requests with OAuth 2.0, JWT tokens, Basic Auth, and more.<br/>
-- 🔎 Filter response bodies using JSONPath or XPath queries.<br/>
-- ⛓️ Chain together multiple requests to dynamically reference values.<br/>
-- 📂 Organize requests into workspaces and nested folders.<br/>
-- 🧮 Use environment variables to easily switch between Prod and Dev.<br/>
-- 🛡️ Secure arbitrary text values with end-to-end encryption<br/>
-- 🏷️ Send dynamic values like UUIDs or timestamps using template tags.<br/>
-- 🎨 Choose from many of the included themes, or make your own.<br/>
-- 💽 Mirror workspace data to a directory for integration with Git or Dropbox.<br/>
-- 📜 View response history for each request.<br/>
-- 🔌 Create your own plugins for authentication, template tags, and more!<br/>
-- 🛜 Configure a proxy to access firewall-blocked APIs
-
-## Useful Resources
-
-- [Feedback and Bug Reports](https://feedback.yaak.app)
-- [Documentation](https://feedback.yaak.app/help)
-- [Yaak vs Postman](https://yaak.app/blog/postman-alternative)
+To get started, visit [`DEVELOPMENT.md`](DEVELOPMENT.md) for tips on setting up your
+environment.

package.json

@@ -10,16 +10,12 @@
     "packages/plugin-runtime",
     "packages/plugin-runtime-types",
     "packages/common-lib",
-    "src-tauri/yaak-crypto",
-    "src-tauri/yaak-git",
     "src-tauri/yaak-license",
-    "src-tauri/yaak-mac-window",
     "src-tauri/yaak-models",
     "src-tauri/yaak-plugins",
     "src-tauri/yaak-sse",
     "src-tauri/yaak-sync",
     "src-tauri/yaak-templates",
-    "src-tauri/yaak-ws",
     "src-web"
   ],
   "scripts": {
@@ -37,13 +33,10 @@
     "tauri-before-build": "npm run bootstrap && npm run --workspaces --if-present build",
     "tauri-before-dev": "npm run --workspaces --if-present dev"
   },
-  "dependencies": {
-    "jotai": "^2.12.2"
-  },
   "devDependencies": {
-    "@tauri-apps/cli": "^2.4.1",
-    "@typescript-eslint/eslint-plugin": "^8.27.0",
-    "@typescript-eslint/parser": "^8.27.0",
+    "@tauri-apps/cli": "^2.2.4",
+    "@typescript-eslint/eslint-plugin": "^8.18.1",
+    "@typescript-eslint/parser": "^8.18.1",
     "eslint": "^8",
     "eslint-config-prettier": "^8",
     "eslint-plugin-import": "^2.31.0",
@@ -53,6 +46,6 @@
     "nodejs-file-downloader": "^4.13.0",
     "npm-run-all": "^4.1.5",
     "prettier": "^3.4.2",
-    "typescript": "^5.8.2"
+    "typescript": "^5.7.2"
   }
 }

packages/common-lib/formatSize.ts

@@ -1,20 +0,0 @@
-export function formatSize(bytes: number): string {
-    let num;
-    let unit;
-
-    if (bytes > 1000 * 1000 * 1000) {
-        num = bytes / 1000 / 1000 / 1000;
-        unit = 'GB';
-    } else if (bytes > 1000 * 1000) {
-        num = bytes / 1000 / 1000;
-        unit = 'MB';
-    } else if (bytes > 1000) {
-        num = bytes / 1000;
-        unit = 'KB';
-    } else {
-        num = bytes;
-        unit = 'B';
-    }
-
-    return `${Math.round(num * 10) / 10} ${unit}`;
-}

packages/plugin-runtime-types/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yaakapp/api",
-  "version": "0.6.0",
+  "version": "0.3.4",
   "main": "lib/index.js",
   "typings": "./lib/index.d.ts",
   "files": [
@@ -20,6 +20,8 @@
     "@types/node": "^22.5.4"
   },
   "devDependencies": {
-    "cpy-cli": "^5.0.0"
+    "cpy-cli": "^5.0.0",
+    "npm-run-all": "^4.1.5",
+    "typescript": "^5.6.2"
   }
 }

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

@@ -0,0 +1,290 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+import type { Environment } from "./models.js";
+import type { Folder } from "./models.js";
+import type { GrpcRequest } from "./models.js";
+import type { HttpRequest } from "./models.js";
+import type { HttpResponse } from "./models.js";
+import type { JsonValue } from "./serde_json/JsonValue.js";
+import type { Workspace } from "./models.js";
+
+export type BootRequest = { dir: string, watch: boolean, };
+
+export type BootResponse = { name: string, version: string, };
+
+export type CallHttpAuthenticationRequest = { config: { [key in string]?: JsonValue }, method: string, url: string, headers: Array<HttpHeader>, };
+
+export type CallHttpAuthenticationResponse = { 
+/**
+ * HTTP headers to add to the request. Existing headers will be replaced, while
+ * new headers will be added.
+ */
+setHeaders: Array<HttpHeader>, };
+
+export type CallHttpRequestActionArgs = { httpRequest: HttpRequest, };
+
+export type CallHttpRequestActionRequest = { key: string, pluginRefId: string, args: CallHttpRequestActionArgs, };
+
+export type CallTemplateFunctionArgs = { purpose: RenderPurpose, values: { [key in string]?: string }, };
+
+export type CallTemplateFunctionRequest = { name: string, args: CallTemplateFunctionArgs, };
+
+export type CallTemplateFunctionResponse = { value: string | null, };
+
+export type Color = "custom" | "default" | "primary" | "secondary" | "info" | "success" | "notice" | "warning" | "danger";
+
+export type CopyTextRequest = { text: string, };
+
+export type EditorLanguage = "text" | "javascript" | "json" | "html" | "xml" | "graphql" | "markdown";
+
+export type EmptyPayload = {};
+
+export type ErrorResponse = { error: string, };
+
+export type ExportHttpRequestRequest = { httpRequest: HttpRequest, };
+
+export type ExportHttpRequestResponse = { content: string, };
+
+export type FileFilter = { name: string, 
+/**
+ * File extensions to require
+ */
+extensions: Array<string>, };
+
+export type FilterRequest = { content: string, filter: string, };
+
+export type FilterResponse = { content: string, };
+
+export type FindHttpResponsesRequest = { requestId: string, limit?: number, };
+
+export type FindHttpResponsesResponse = { httpResponses: Array<HttpResponse>, };
+
+export type FormInput = { "type": "text" } & FormInputText | { "type": "editor" } & FormInputEditor | { "type": "select" } & FormInputSelect | { "type": "checkbox" } & FormInputCheckbox | { "type": "file" } & FormInputFile | { "type": "http_request" } & FormInputHttpRequest;
+
+export type FormInputBase = { name: string, 
+/**
+ * Whether the user must fill in the argument
+ */
+optional?: boolean, 
+/**
+ * The label of the input
+ */
+label?: string, 
+/**
+ * Visually hide the label of the input
+ */
+hideLabel?: boolean, 
+/**
+ * The default value
+ */
+defaultValue?: string, };
+
+export type FormInputCheckbox = { name: string, 
+/**
+ * Whether the user must fill in the argument
+ */
+optional?: boolean, 
+/**
+ * The label of the input
+ */
+label?: string, 
+/**
+ * Visually hide the label of the input
+ */
+hideLabel?: boolean, 
+/**
+ * The default value
+ */
+defaultValue?: string, };
+
+export type FormInputEditor = { 
+/**
+ * Placeholder for the text input
+ */
+placeholder?: string | null, 
+/**
+ * Don't show the editor gutter (line numbers, folds, etc.)
+ */
+hideGutter?: boolean, 
+/**
+ * Language for syntax highlighting
+ */
+language?: EditorLanguage, name: string, 
+/**
+ * Whether the user must fill in the argument
+ */
+optional?: boolean, 
+/**
+ * The label of the input
+ */
+label?: string, 
+/**
+ * Visually hide the label of the input
+ */
+hideLabel?: boolean, 
+/**
+ * The default value
+ */
+defaultValue?: string, };
+
+export type FormInputFile = { 
+/**
+ * The title of the file selection window
+ */
+title: string, 
+/**
+ * Allow selecting multiple files
+ */
+multiple?: boolean, directory?: boolean, defaultPath?: string, filters?: Array<FileFilter>, name: string, 
+/**
+ * Whether the user must fill in the argument
+ */
+optional?: boolean, 
+/**
+ * The label of the input
+ */
+label?: string, 
+/**
+ * Visually hide the label of the input
+ */
+hideLabel?: boolean, 
+/**
+ * The default value
+ */
+defaultValue?: string, };
+
+export type FormInputHttpRequest = { name: string, 
+/**
+ * Whether the user must fill in the argument
+ */
+optional?: boolean, 
+/**
+ * The label of the input
+ */
+label?: string, 
+/**
+ * Visually hide the label of the input
+ */
+hideLabel?: boolean, 
+/**
+ * The default value
+ */
+defaultValue?: string, };
+
+export type FormInputSelect = { 
+/**
+ * The options that will be available in the select input
+ */
+options: Array<FormInputSelectOption>, name: string, 
+/**
+ * Whether the user must fill in the argument
+ */
+optional?: boolean, 
+/**
+ * The label of the input
+ */
+label?: string, 
+/**
+ * Visually hide the label of the input
+ */
+hideLabel?: boolean, 
+/**
+ * The default value
+ */
+defaultValue?: string, };
+
+export type FormInputSelectOption = { name: string, value: string, };
+
+export type FormInputText = { 
+/**
+ * Placeholder for the text input
+ */
+placeholder?: string | null, 
+/**
+ * Placeholder for the text input
+ */
+password?: boolean, name: string, 
+/**
+ * Whether the user must fill in the argument
+ */
+optional?: boolean, 
+/**
+ * The label of the input
+ */
+label?: string, 
+/**
+ * Visually hide the label of the input
+ */
+hideLabel?: boolean, 
+/**
+ * The default value
+ */
+defaultValue?: string, };
+
+export type GetHttpAuthenticationResponse = { name: string, label: string, shortLabel: string, config: Array<FormInput>, };
+
+export type GetHttpRequestActionsRequest = Record<string, never>;
+
+export type GetHttpRequestActionsResponse = { actions: Array<HttpRequestAction>, pluginRefId: string, };
+
+export type GetHttpRequestByIdRequest = { id: string, };
+
+export type GetHttpRequestByIdResponse = { httpRequest: HttpRequest | null, };
+
+export type GetTemplateFunctionsResponse = { functions: Array<TemplateFunction>, pluginRefId: string, };
+
+export type HttpHeader = { name: string, value: string, };
+
+export type HttpRequestAction = { key: string, label: string, icon?: Icon, };
+
+export type Icon = "copy" | "info" | "check_circle" | "alert_triangle" | "_unknown";
+
+export type ImportRequest = { content: string, };
+
+export type ImportResources = { workspaces: Array<Workspace>, environments: Array<Environment>, folders: Array<Folder>, httpRequests: Array<HttpRequest>, grpcRequests: Array<GrpcRequest>, };
+
+export type ImportResponse = { resources: ImportResources, };
+
+export type InternalEvent = { id: string, pluginRefId: string, pluginName: string, replyId: string | null, windowContext: WindowContext, payload: InternalEventPayload, };
+
+export type InternalEventPayload = { "type": "boot_request" } & BootRequest | { "type": "boot_response" } & BootResponse | { "type": "reload_request" } & EmptyPayload | { "type": "reload_response" } & EmptyPayload | { "type": "terminate_request" } | { "type": "terminate_response" } | { "type": "import_request" } & ImportRequest | { "type": "import_response" } & ImportResponse | { "type": "filter_request" } & FilterRequest | { "type": "filter_response" } & FilterResponse | { "type": "export_http_request_request" } & ExportHttpRequestRequest | { "type": "export_http_request_response" } & ExportHttpRequestResponse | { "type": "send_http_request_request" } & SendHttpRequestRequest | { "type": "send_http_request_response" } & SendHttpRequestResponse | { "type": "get_http_request_actions_request" } & EmptyPayload | { "type": "get_http_request_actions_response" } & GetHttpRequestActionsResponse | { "type": "call_http_request_action_request" } & CallHttpRequestActionRequest | { "type": "get_template_functions_request" } | { "type": "get_template_functions_response" } & GetTemplateFunctionsResponse | { "type": "call_template_function_request" } & CallTemplateFunctionRequest | { "type": "call_template_function_response" } & CallTemplateFunctionResponse | { "type": "get_http_authentication_request" } & EmptyPayload | { "type": "get_http_authentication_response" } & GetHttpAuthenticationResponse | { "type": "call_http_authentication_request" } & CallHttpAuthenticationRequest | { "type": "call_http_authentication_response" } & CallHttpAuthenticationResponse | { "type": "copy_text_request" } & CopyTextRequest | { "type": "render_http_request_request" } & RenderHttpRequestRequest | { "type": "render_http_request_response" } & RenderHttpRequestResponse | { "type": "template_render_request" } & TemplateRenderRequest | { "type": "template_render_response" } & TemplateRenderResponse | { "type": "show_toast_request" } & ShowToastRequest | { "type": "prompt_text_request" } & PromptTextRequest | { "type": "prompt_text_response" } & PromptTextResponse | { "type": "get_http_request_by_id_request" } & GetHttpRequestByIdRequest | { "type": "get_http_request_by_id_response" } & GetHttpRequestByIdResponse | { "type": "find_http_responses_request" } & FindHttpResponsesRequest | { "type": "find_http_responses_response" } & FindHttpResponsesResponse | { "type": "empty_response" } & EmptyPayload | { "type": "error_response" } & ErrorResponse;
+
+export type PromptTextRequest = { id: string, title: string, label: string, description?: string, defaultValue?: string, placeholder?: string, 
+/**
+ * Text to add to the confirmation button
+ */
+confirmText?: string, 
+/**
+ * Text to add to the cancel button
+ */
+cancelText?: string, 
+/**
+ * Require the user to enter a non-empty value
+ */
+required?: boolean, };
+
+export type PromptTextResponse = { value: string | null, };
+
+export type RenderHttpRequestRequest = { httpRequest: HttpRequest, purpose: RenderPurpose, };
+
+export type RenderHttpRequestResponse = { httpRequest: HttpRequest, };
+
+export type RenderPurpose = "send" | "preview";
+
+export type SendHttpRequestRequest = { httpRequest: HttpRequest, };
+
+export type SendHttpRequestResponse = { httpResponse: HttpResponse, };
+
+export type ShowToastRequest = { message: string, color?: Color, icon?: Icon, };
+
+export type TemplateFunction = { name: string, description?: string, 
+/**
+ * Also support alternative names. This is useful for not breaking existing
+ * tags when changing the `name` property
+ */
+aliases?: Array<string>, args: Array<FormInput>, };
+
+export type TemplateRenderRequest = { data: JsonValue, purpose: RenderPurpose, };
+
+export type TemplateRenderResponse = { data: JsonValue, };
+
+export type WindowContext = { "type": "none" } | { "type": "label", label: string, };

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

@@ -1,447 +0,0 @@
-// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
-import type { Environment } from "./gen_models.js";
-import type { Folder } from "./gen_models.js";
-import type { GrpcRequest } from "./gen_models.js";
-import type { HttpRequest } from "./gen_models.js";
-import type { HttpResponse } from "./gen_models.js";
-import type { JsonValue } from "./serde_json/JsonValue.js";
-import type { WebsocketRequest } from "./gen_models.js";
-import type { Workspace } from "./gen_models.js";
-
-export type BootRequest = { dir: string, watch: boolean, };
-
-export type BootResponse = { name: string, version: string, };
-
-export type CallHttpAuthenticationActionArgs = { contextId: string, values: { [key in string]?: JsonPrimitive }, };
-
-export type CallHttpAuthenticationActionRequest = { index: number, pluginRefId: string, args: CallHttpAuthenticationActionArgs, };
-
-export type CallHttpAuthenticationRequest = { contextId: string, values: { [key in string]?: JsonPrimitive }, method: string, url: string, headers: Array<HttpHeader>, };
-
-export type CallHttpAuthenticationResponse = { 
-/**
- * HTTP headers to add to the request. Existing headers will be replaced, while
- * new headers will be added.
- */
-setHeaders: Array<HttpHeader>, };
-
-export type CallHttpRequestActionArgs = { httpRequest: HttpRequest, };
-
-export type CallHttpRequestActionRequest = { index: number, pluginRefId: string, args: CallHttpRequestActionArgs, };
-
-export type CallTemplateFunctionArgs = { purpose: RenderPurpose, values: { [key in string]?: string }, };
-
-export type CallTemplateFunctionRequest = { name: string, args: CallTemplateFunctionArgs, };
-
-export type CallTemplateFunctionResponse = { value: string | null, };
-
-export type CloseWindowRequest = { label: string, };
-
-export type Color = "primary" | "secondary" | "info" | "success" | "notice" | "warning" | "danger";
-
-export type CompletionOptionType = "constant" | "variable";
-
-export type Content = { "type": "text", content: string, } | { "type": "markdown", content: string, };
-
-export type CopyTextRequest = { text: string, };
-
-export type DeleteKeyValueRequest = { key: string, };
-
-export type DeleteKeyValueResponse = { deleted: boolean, };
-
-export type EditorLanguage = "text" | "javascript" | "json" | "html" | "xml" | "graphql" | "markdown";
-
-export type EmptyPayload = {};
-
-export type ErrorResponse = { error: string, };
-
-export type ExportHttpRequestRequest = { httpRequest: HttpRequest, };
-
-export type ExportHttpRequestResponse = { content: string, };
-
-export type FileFilter = { name: string, 
-/**
- * File extensions to require
- */
-extensions: Array<string>, };
-
-export type FilterRequest = { content: string, filter: string, };
-
-export type FilterResponse = { content: string, };
-
-export type FindHttpResponsesRequest = { requestId: string, limit?: number, };
-
-export type FindHttpResponsesResponse = { httpResponses: Array<HttpResponse>, };
-
-export type FormInput = { "type": "text" } & FormInputText | { "type": "editor" } & FormInputEditor | { "type": "select" } & FormInputSelect | { "type": "checkbox" } & FormInputCheckbox | { "type": "file" } & FormInputFile | { "type": "http_request" } & FormInputHttpRequest | { "type": "accordion" } & FormInputAccordion | { "type": "banner" } & FormInputBanner | { "type": "markdown" } & FormInputMarkdown;
-
-export type FormInputAccordion = { label: string, inputs?: Array<FormInput>, hidden?: boolean, };
-
-export type FormInputBanner = { inputs?: Array<FormInput>, hidden?: boolean, color?: Color, };
-
-export type FormInputBase = { 
-/**
- * The name of the input. The value will be stored at this object attribute in the resulting data
- */
-name: string, 
-/**
- * Whether this input is visible for the given configuration. Use this to
- * make branching forms.
- */
-hidden?: boolean, 
-/**
- * Whether the user must fill in the argument
- */
-optional?: boolean, 
-/**
- * The label of the input
- */
-label?: string, 
-/**
- * Visually hide the label of the input
- */
-hideLabel?: boolean, 
-/**
- * The default value
- */
-defaultValue?: string, disabled?: boolean, 
-/**
- * Longer description of the input, likely shown in a tooltip
- */
-description?: string, };
-
-export type FormInputCheckbox = { 
-/**
- * The name of the input. The value will be stored at this object attribute in the resulting data
- */
-name: string, 
-/**
- * Whether this input is visible for the given configuration. Use this to
- * make branching forms.
- */
-hidden?: boolean, 
-/**
- * Whether the user must fill in the argument
- */
-optional?: boolean, 
-/**
- * The label of the input
- */
-label?: string, 
-/**
- * Visually hide the label of the input
- */
-hideLabel?: boolean, 
-/**
- * The default value
- */
-defaultValue?: string, disabled?: boolean, 
-/**
- * Longer description of the input, likely shown in a tooltip
- */
-description?: string, };
-
-export type FormInputEditor = { 
-/**
- * Placeholder for the text input
- */
-placeholder?: string | null, 
-/**
- * Don't show the editor gutter (line numbers, folds, etc.)
- */
-hideGutter?: boolean, 
-/**
- * Language for syntax highlighting
- */
-language?: EditorLanguage, readOnly?: boolean, completionOptions?: Array<GenericCompletionOption>, 
-/**
- * The name of the input. The value will be stored at this object attribute in the resulting data
- */
-name: string, 
-/**
- * Whether this input is visible for the given configuration. Use this to
- * make branching forms.
- */
-hidden?: boolean, 
-/**
- * Whether the user must fill in the argument
- */
-optional?: boolean, 
-/**
- * The label of the input
- */
-label?: string, 
-/**
- * Visually hide the label of the input
- */
-hideLabel?: boolean, 
-/**
- * The default value
- */
-defaultValue?: string, disabled?: boolean, 
-/**
- * Longer description of the input, likely shown in a tooltip
- */
-description?: string, };
-
-export type FormInputFile = { 
-/**
- * The title of the file selection window
- */
-title: string, 
-/**
- * Allow selecting multiple files
- */
-multiple?: boolean, directory?: boolean, defaultPath?: string, filters?: Array<FileFilter>, 
-/**
- * The name of the input. The value will be stored at this object attribute in the resulting data
- */
-name: string, 
-/**
- * Whether this input is visible for the given configuration. Use this to
- * make branching forms.
- */
-hidden?: boolean, 
-/**
- * Whether the user must fill in the argument
- */
-optional?: boolean, 
-/**
- * The label of the input
- */
-label?: string, 
-/**
- * Visually hide the label of the input
- */
-hideLabel?: boolean, 
-/**
- * The default value
- */
-defaultValue?: string, disabled?: boolean, 
-/**
- * Longer description of the input, likely shown in a tooltip
- */
-description?: string, };
-
-export type FormInputHttpRequest = { 
-/**
- * The name of the input. The value will be stored at this object attribute in the resulting data
- */
-name: string, 
-/**
- * Whether this input is visible for the given configuration. Use this to
- * make branching forms.
- */
-hidden?: boolean, 
-/**
- * Whether the user must fill in the argument
- */
-optional?: boolean, 
-/**
- * The label of the input
- */
-label?: string, 
-/**
- * Visually hide the label of the input
- */
-hideLabel?: boolean, 
-/**
- * The default value
- */
-defaultValue?: string, disabled?: boolean, 
-/**
- * Longer description of the input, likely shown in a tooltip
- */
-description?: string, };
-
-export type FormInputMarkdown = { content: string, hidden?: boolean, };
-
-export type FormInputSelect = { 
-/**
- * The options that will be available in the select input
- */
-options: Array<FormInputSelectOption>, 
-/**
- * The name of the input. The value will be stored at this object attribute in the resulting data
- */
-name: string, 
-/**
- * Whether this input is visible for the given configuration. Use this to
- * make branching forms.
- */
-hidden?: boolean, 
-/**
- * Whether the user must fill in the argument
- */
-optional?: boolean, 
-/**
- * The label of the input
- */
-label?: string, 
-/**
- * Visually hide the label of the input
- */
-hideLabel?: boolean, 
-/**
- * The default value
- */
-defaultValue?: string, disabled?: boolean, 
-/**
- * Longer description of the input, likely shown in a tooltip
- */
-description?: string, };
-
-export type FormInputSelectOption = { label: string, value: string, };
-
-export type FormInputText = { 
-/**
- * Placeholder for the text input
- */
-placeholder?: string | null, 
-/**
- * Placeholder for the text input
- */
-password?: boolean, 
-/**
- * Whether to allow newlines in the input, like a <textarea/>
- */
-multiLine?: boolean, completionOptions?: Array<GenericCompletionOption>, 
-/**
- * The name of the input. The value will be stored at this object attribute in the resulting data
- */
-name: string, 
-/**
- * Whether this input is visible for the given configuration. Use this to
- * make branching forms.
- */
-hidden?: boolean, 
-/**
- * Whether the user must fill in the argument
- */
-optional?: boolean, 
-/**
- * The label of the input
- */
-label?: string, 
-/**
- * Visually hide the label of the input
- */
-hideLabel?: boolean, 
-/**
- * The default value
- */
-defaultValue?: string, disabled?: boolean, 
-/**
- * Longer description of the input, likely shown in a tooltip
- */
-description?: string, };
-
-export type GenericCompletionOption = { label: string, detail?: string, info?: string, type?: CompletionOptionType, boost?: number, };
-
-export type GetCookieValueRequest = { name: string, };
-
-export type GetCookieValueResponse = { value: string | null, };
-
-export type GetHttpAuthenticationConfigRequest = { contextId: string, values: { [key in string]?: JsonPrimitive }, };
-
-export type GetHttpAuthenticationConfigResponse = { args: Array<FormInput>, pluginRefId: string, actions?: Array<HttpAuthenticationAction>, };
-
-export type GetHttpAuthenticationSummaryResponse = { name: string, label: string, shortLabel: string, };
-
-export type GetHttpRequestActionsRequest = Record<string, never>;
-
-export type GetHttpRequestActionsResponse = { actions: Array<HttpRequestAction>, pluginRefId: string, };
-
-export type GetHttpRequestByIdRequest = { id: string, };
-
-export type GetHttpRequestByIdResponse = { httpRequest: HttpRequest | null, };
-
-export type GetKeyValueRequest = { key: string, };
-
-export type GetKeyValueResponse = { value?: string, };
-
-export type GetTemplateFunctionsResponse = { functions: Array<TemplateFunction>, pluginRefId: string, };
-
-export type HttpAuthenticationAction = { label: string, icon?: Icon, };
-
-export type HttpHeader = { name: string, value: string, };
-
-export type HttpRequestAction = { label: string, icon?: Icon, };
-
-export type Icon = "alert_triangle" | "check" | "check_circle" | "chevron_down" | "copy" | "info" | "pin" | "search" | "trash" | "_unknown";
-
-export type ImportRequest = { content: string, };
-
-export type ImportResources = { workspaces: Array<Workspace>, environments: Array<Environment>, folders: Array<Folder>, httpRequests: Array<HttpRequest>, grpcRequests: Array<GrpcRequest>, websocketRequests: Array<WebsocketRequest>, };
-
-export type ImportResponse = { resources: ImportResources, };
-
-export type InternalEvent = { id: string, pluginRefId: string, pluginName: string, replyId: string | null, windowContext: PluginWindowContext, payload: InternalEventPayload, };
-
-export type InternalEventPayload = { "type": "boot_request" } & BootRequest | { "type": "boot_response" } & BootResponse | { "type": "reload_request" } & EmptyPayload | { "type": "reload_response" } & EmptyPayload | { "type": "terminate_request" } | { "type": "terminate_response" } | { "type": "import_request" } & ImportRequest | { "type": "import_response" } & ImportResponse | { "type": "filter_request" } & FilterRequest | { "type": "filter_response" } & FilterResponse | { "type": "export_http_request_request" } & ExportHttpRequestRequest | { "type": "export_http_request_response" } & ExportHttpRequestResponse | { "type": "send_http_request_request" } & SendHttpRequestRequest | { "type": "send_http_request_response" } & SendHttpRequestResponse | { "type": "list_cookie_names_request" } & ListCookieNamesRequest | { "type": "list_cookie_names_response" } & ListCookieNamesResponse | { "type": "get_cookie_value_request" } & GetCookieValueRequest | { "type": "get_cookie_value_response" } & GetCookieValueResponse | { "type": "get_http_request_actions_request" } & EmptyPayload | { "type": "get_http_request_actions_response" } & GetHttpRequestActionsResponse | { "type": "call_http_request_action_request" } & CallHttpRequestActionRequest | { "type": "get_template_functions_request" } | { "type": "get_template_functions_response" } & GetTemplateFunctionsResponse | { "type": "call_template_function_request" } & CallTemplateFunctionRequest | { "type": "call_template_function_response" } & CallTemplateFunctionResponse | { "type": "get_http_authentication_summary_request" } & EmptyPayload | { "type": "get_http_authentication_summary_response" } & GetHttpAuthenticationSummaryResponse | { "type": "get_http_authentication_config_request" } & GetHttpAuthenticationConfigRequest | { "type": "get_http_authentication_config_response" } & GetHttpAuthenticationConfigResponse | { "type": "call_http_authentication_request" } & CallHttpAuthenticationRequest | { "type": "call_http_authentication_response" } & CallHttpAuthenticationResponse | { "type": "call_http_authentication_action_request" } & CallHttpAuthenticationActionRequest | { "type": "call_http_authentication_action_response" } & EmptyPayload | { "type": "copy_text_request" } & CopyTextRequest | { "type": "copy_text_response" } & EmptyPayload | { "type": "render_http_request_request" } & RenderHttpRequestRequest | { "type": "render_http_request_response" } & RenderHttpRequestResponse | { "type": "get_key_value_request" } & GetKeyValueRequest | { "type": "get_key_value_response" } & GetKeyValueResponse | { "type": "set_key_value_request" } & SetKeyValueRequest | { "type": "set_key_value_response" } & SetKeyValueResponse | { "type": "delete_key_value_request" } & DeleteKeyValueRequest | { "type": "delete_key_value_response" } & DeleteKeyValueResponse | { "type": "open_window_request" } & OpenWindowRequest | { "type": "window_navigate_event" } & WindowNavigateEvent | { "type": "window_close_event" } | { "type": "close_window_request" } & CloseWindowRequest | { "type": "template_render_request" } & TemplateRenderRequest | { "type": "template_render_response" } & TemplateRenderResponse | { "type": "show_toast_request" } & ShowToastRequest | { "type": "show_toast_response" } & EmptyPayload | { "type": "prompt_text_request" } & PromptTextRequest | { "type": "prompt_text_response" } & PromptTextResponse | { "type": "get_http_request_by_id_request" } & GetHttpRequestByIdRequest | { "type": "get_http_request_by_id_response" } & GetHttpRequestByIdResponse | { "type": "find_http_responses_request" } & FindHttpResponsesRequest | { "type": "find_http_responses_response" } & FindHttpResponsesResponse | { "type": "empty_response" } & EmptyPayload | { "type": "error_response" } & ErrorResponse;
-
-export type JsonPrimitive = string | number | boolean | null;
-
-export type ListCookieNamesRequest = {};
-
-export type ListCookieNamesResponse = { names: Array<string>, };
-
-export type OpenWindowRequest = { url: string, 
-/**
- * Label for the window. If not provided, a random one will be generated.
- */
-label: string, title?: string, size?: WindowSize, dataDirKey?: string, };
-
-export type PluginWindowContext = { "type": "none" } | { "type": "label", label: string, workspace_id: string | null, };
-
-export type PromptTextRequest = { id: string, title: string, label: string, description?: string, defaultValue?: string, placeholder?: string, 
-/**
- * Text to add to the confirmation button
- */
-confirmText?: string, 
-/**
- * Text to add to the cancel button
- */
-cancelText?: string, 
-/**
- * Require the user to enter a non-empty value
- */
-required?: boolean, };
-
-export type PromptTextResponse = { value: string | null, };
-
-export type RenderHttpRequestRequest = { httpRequest: HttpRequest, purpose: RenderPurpose, };
-
-export type RenderHttpRequestResponse = { httpRequest: HttpRequest, };
-
-export type RenderPurpose = "send" | "preview";
-
-export type SendHttpRequestRequest = { httpRequest: Partial<HttpRequest>, };
-
-export type SendHttpRequestResponse = { httpResponse: HttpResponse, };
-
-export type SetKeyValueRequest = { key: string, value: string, };
-
-export type SetKeyValueResponse = {};
-
-export type ShowToastRequest = { message: string, color?: Color, icon?: Icon, };
-
-export type TemplateFunction = { name: string, description?: string, 
-/**
- * Also support alternative names. This is useful for not breaking existing
- * tags when changing the `name` property
- */
-aliases?: Array<string>, args: Array<TemplateFunctionArg>, };
-
-/**
- * Similar to FormInput, but contains
- */
-export type TemplateFunctionArg = FormInput;
-
-export type TemplateRenderRequest = { data: JsonValue, purpose: RenderPurpose, };
-
-export type TemplateRenderResponse = { data: JsonValue, };
-
-export type WindowNavigateEvent = { url: string, };
-
-export type WindowSize = { width: number, height: number, };

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

@@ -1,12 +1,14 @@
 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
 
-export type Environment = { model: "environment", id: string, workspaceId: string, createdAt: string, updatedAt: string, name: string, public: boolean, base: boolean, variables: Array<EnvironmentVariable>, };
+export type Environment = { model: "environment", id: string, workspaceId: string, environmentId: string | null, createdAt: string, updatedAt: string, name: string, variables: Array<EnvironmentVariable>, };
 
 export type EnvironmentVariable = { enabled?: boolean, name: string, value: string, id?: string, };
 
-export type Folder = { model: "folder", id: string, createdAt: string, updatedAt: string, workspaceId: string, folderId: string | null, authentication: Record<string, any>, authenticationType: string | null, description: string, headers: Array<HttpRequestHeader>, name: string, sortPriority: number, };
+export type Folder = { model: "folder", id: string, createdAt: string, updatedAt: string, workspaceId: string, folderId: string | null, name: string, description: string, sortPriority: number, };
 
-export type GrpcRequest = { model: "grpc_request", id: string, createdAt: string, updatedAt: string, workspaceId: string, folderId: string | null, authenticationType: string | null, authentication: Record<string, any>, description: string, message: string, metadata: Array<HttpRequestHeader>, method: string | null, name: string, service: string | null, sortPriority: number, url: string, };
+export type GrpcMetadataEntry = { enabled?: boolean, name: string, value: string, id?: string, };
+
+export type GrpcRequest = { model: "grpc_request", id: string, createdAt: string, updatedAt: string, workspaceId: string, folderId: string | null, authenticationType: string | null, authentication: Record<string, any>, description: string, message: string, metadata: Array<GrpcMetadataEntry>, method: string | null, name: string, service: string | null, sortPriority: number, url: string, };
 
 export type HttpRequest = { model: "http_request", id: string, createdAt: string, updatedAt: string, workspaceId: string, folderId: string | null, authentication: Record<string, any>, authenticationType: string | null, body: Record<string, any>, bodyType: string | null, description: string, headers: Array<HttpRequestHeader>, method: string, name: string, sortPriority: number, url: string, urlParameters: Array<HttpUrlParameter>, };
 
@@ -20,6 +22,4 @@ export type HttpResponseState = "initialized" | "connected" | "closed";
 
 export type HttpUrlParameter = { enabled?: boolean, name: string, value: string, id?: string, };
 
-export type WebsocketRequest = { model: "websocket_request", id: string, createdAt: string, updatedAt: string, workspaceId: string, folderId: string | null, authentication: Record<string, any>, authenticationType: string | null, description: string, headers: Array<HttpRequestHeader>, message: string, name: string, sortPriority: number, url: string, urlParameters: Array<HttpUrlParameter>, };
-
-export type Workspace = { model: "workspace", id: string, createdAt: string, updatedAt: string, authentication: Record<string, any>, authenticationType: string | null, description: string, headers: Array<HttpRequestHeader>, name: string, encryptionKeyChallenge: string | null, settingValidateCertificates: boolean, settingFollowRedirects: boolean, settingRequestTimeout: number, };
+export type Workspace = { model: "workspace", id: string, createdAt: string, updatedAt: string, name: string, description: string, settingValidateCertificates: boolean, settingFollowRedirects: boolean, settingRequestTimeout: number, };

packages/plugin-runtime-types/src/bindings/serde_json/JsonValue.ts

@@ -1,3 +1,3 @@
 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
 
-export type JsonValue = number | string | boolean | Array<JsonValue> | { [key in string]?: JsonValue } | null;
+export type JsonValue = number | string | Array<JsonValue> | { [key in string]?: JsonValue };

packages/plugin-runtime-types/src/helpers.ts

@@ -1,2 +1 @@
 export type AtLeast<T, K extends keyof T> = Partial<T> & Pick<T, K>;
-export type MaybePromise<T> = Promise<T> | T;

packages/plugin-runtime-types/src/index.ts

@@ -1,9 +1,5 @@
 export type * from './plugins';
 export type * from './themes';
 
-export * from './bindings/gen_models';
-export * from './bindings/gen_events';
-
-// Some extras for utility
-
-export type { PartialImportResources } from './plugins/ImporterPlugin';
+export * from './bindings/models';
+export * from './bindings/events';

packages/plugin-runtime-types/src/plugins/AuthenticationPlugin.ts

@@ -1,29 +1,13 @@
 import {
-  CallHttpAuthenticationActionArgs,
   CallHttpAuthenticationRequest,
   CallHttpAuthenticationResponse,
-  FormInput,
-  GetHttpAuthenticationConfigRequest,
-  GetHttpAuthenticationSummaryResponse,
-  HttpAuthenticationAction,
-} from '../bindings/gen_events';
-import { MaybePromise } from '../helpers';
+  GetHttpAuthenticationResponse,
+} from '../bindings/events';
 import { Context } from './Context';
 
-type DynamicFormInput = FormInput & {
-  dynamic(
-    ctx: Context,
-    args: GetHttpAuthenticationConfigRequest,
-  ): MaybePromise<Partial<FormInput> | undefined | null>;
-};
-
-export type AuthenticationPlugin = GetHttpAuthenticationSummaryResponse & {
-  args: (FormInput | DynamicFormInput)[];
+export type AuthenticationPlugin = Omit<GetHttpAuthenticationResponse, 'pluginName'> & {
   onApply(
     ctx: Context,
     args: CallHttpAuthenticationRequest,
-  ): MaybePromise<CallHttpAuthenticationResponse>;
-  actions?: (HttpAuthenticationAction & {
-    onSelect(ctx: Context, args: CallHttpAuthenticationActionArgs): Promise<void> | void;
-  })[];
+  ): Promise<CallHttpAuthenticationResponse> | CallHttpAuthenticationResponse;
 };

packages/plugin-runtime-types/src/plugins/Context.ts

@@ -1,12 +1,8 @@
 import type {
   FindHttpResponsesRequest,
   FindHttpResponsesResponse,
-  GetCookieValueRequest,
-  GetCookieValueResponse,
   GetHttpRequestByIdRequest,
   GetHttpRequestByIdResponse,
-  ListCookieNamesResponse,
-  OpenWindowRequest,
   PromptTextRequest,
   PromptTextResponse,
   RenderHttpRequestRequest,
@@ -16,7 +12,7 @@ import type {
   ShowToastRequest,
   TemplateRenderRequest,
   TemplateRenderResponse,
-} from '../bindings/gen_events.ts';
+} from "../bindings/events.ts";
 
 export interface Context {
   clipboard: {
@@ -26,34 +22,27 @@ export interface Context {
     show(args: ShowToastRequest): Promise<void>;
   };
   prompt: {
-    text(args: PromptTextRequest): Promise<PromptTextResponse['value']>;
-  };
-  store: {
-    set<T>(key: string, value: T): Promise<void>;
-    get<T>(key: string): Promise<T | undefined>;
-    delete(key: string): Promise<boolean>;
-  };
-  window: {
-    openUrl(
-      args: OpenWindowRequest & {
-        onNavigate?: (args: { url: string }) => void;
-        onClose?: () => void;
-      },
-    ): Promise<{ close: () => void }>;
-  };
-  cookies: {
-    listNames(): Promise<ListCookieNamesResponse['names']>;
-    getValue(args: GetCookieValueRequest): Promise<GetCookieValueResponse['value']>;
+    text(args: PromptTextRequest): Promise<PromptTextResponse["value"]>;
   };
   httpRequest: {
-    send(args: SendHttpRequestRequest): Promise<SendHttpRequestResponse['httpResponse']>;
-    getById(args: GetHttpRequestByIdRequest): Promise<GetHttpRequestByIdResponse['httpRequest']>;
-    render(args: RenderHttpRequestRequest): Promise<RenderHttpRequestResponse['httpRequest']>;
+    send(
+      args: SendHttpRequestRequest,
+    ): Promise<SendHttpRequestResponse["httpResponse"]>;
+    getById(
+      args: GetHttpRequestByIdRequest,
+    ): Promise<GetHttpRequestByIdResponse["httpRequest"]>;
+    render(
+      args: RenderHttpRequestRequest,
+    ): Promise<RenderHttpRequestResponse["httpRequest"]>;
   };
   httpResponse: {
-    find(args: FindHttpResponsesRequest): Promise<FindHttpResponsesResponse['httpResponses']>;
+    find(
+      args: FindHttpResponsesRequest,
+    ): Promise<FindHttpResponsesResponse["httpResponses"]>;
   };
   templates: {
-    render(args: TemplateRenderRequest): Promise<TemplateRenderResponse['data']>;
+    render(
+      args: TemplateRenderRequest,
+    ): Promise<TemplateRenderResponse["data"]>;
   };
 }

packages/plugin-runtime-types/src/plugins/FilterPlugin.ts

@@ -1,6 +1,6 @@
 import type { Context } from './Context';
 
-type FilterPluginResponse = { filtered: string };
+export type FilterPluginResponse = { filtered: string };
 
 export type FilterPlugin = {
   name: string;

packages/plugin-runtime-types/src/plugins/HttpRequestActionPlugin.ts

@@ -1,4 +1,4 @@
-import type { CallHttpRequestActionArgs, HttpRequestAction } from '../bindings/gen_events';
+import type { CallHttpRequestActionArgs, HttpRequestAction } from '../bindings/events';
 import type { Context } from './Context';
 
 export type HttpRequestActionPlugin = HttpRequestAction & {

packages/plugin-runtime-types/src/plugins/ImporterPlugin.ts

@@ -1,21 +1,30 @@
-import { ImportResources } from '../bindings/gen_events';
-import { AtLeast } from '../helpers';
-import type { Context } from './Context';
+import {
+  Environment,
+  Folder,
+  GrpcRequest,
+  HttpRequest,
+  Workspace,
+} from "../bindings/models";
+import type { AtLeast } from "../helpers";
+import type { Context } from "./Context";
 
-type RootFields = 'name' | 'id' | 'model';
-type CommonFields = RootFields | 'workspaceId';
-
-export type PartialImportResources = {
-  workspaces: Array<AtLeast<ImportResources['workspaces'][0], RootFields>>;
-  environments: Array<AtLeast<ImportResources['environments'][0], CommonFields>>;
-  folders: Array<AtLeast<ImportResources['folders'][0], CommonFields>>;
-  httpRequests: Array<AtLeast<ImportResources['httpRequests'][0], CommonFields>>;
-  grpcRequests: Array<AtLeast<ImportResources['grpcRequests'][0], CommonFields>>;
-  websocketRequests: Array<AtLeast<ImportResources['websocketRequests'][0], CommonFields>>;
-};
-
-export type ImportPluginResponse = null | {
-  resources: PartialImportResources;
+type ImportPluginResponse = null | {
+  resources: {
+    workspaces: AtLeast<Workspace, "name" | "id" | "model">[];
+    environments: AtLeast<
+      Environment,
+      "name" | "id" | "model" | "workspaceId"
+    >[];
+    folders: AtLeast<Folder, "name" | "id" | "model" | "workspaceId">[];
+    httpRequests: AtLeast<
+      HttpRequest,
+      "name" | "id" | "model" | "workspaceId"
+    >[];
+    grpcRequests: AtLeast<
+      GrpcRequest,
+      "name" | "id" | "model" | "workspaceId"
+    >[];
+  };
 };
 
 export type ImporterPlugin = {

packages/plugin-runtime-types/src/plugins/TemplateFunctionPlugin.ts

@@ -1,7 +1,7 @@
 import {
   CallTemplateFunctionArgs,
   TemplateFunction,
-} from "../bindings/gen_events";
+} from "../bindings/events";
 import { Context } from "./Context";
 
 export type TemplateFunctionPlugin = TemplateFunction & {

packages/plugin-runtime/package.json

@@ -3,7 +3,10 @@
   "scripts": {
     "bootstrap": "npm run build",
     "build": "run-p build:*",
-    "build:main": "esbuild src/index.ts --bundle --platform=node --outfile=../../src-tauri/vendored/plugin-runtime/index.cjs"
+    "build:main": "esbuild src/index.ts --bundle --platform=node --outfile=../../src-tauri/vendored/plugin-runtime/index.cjs",
+    "build:worker": "esbuild src/index.worker.ts --bundle --platform=node --outfile=../../src-tauri/vendored/plugin-runtime/index.worker.cjs",
+    "build:__main": "esbuild src/index.ts --bundle --platform=node --outfile=../../src-tauri/target/debug/vendored/plugin-runtime/index.cjs",
+    "build:__worker": "esbuild src/index.ts --bundle --platform=node --outfile=../../src-tauri/target/debug/vendored/plugin-runtime/index.worker.cjs"
   },
   "dependencies": {
     "ws": "^8.18.0"

packages/plugin-runtime/src/EventChannel.ts

@@ -1,19 +1,14 @@
-import type { InternalEvent } from '@yaakapp/api';
+import type { InternalEvent } from "@yaakapp/api";
+import EventEmitter from "node:events";
 
 export class EventChannel {
-  #listeners = new Set<(event: InternalEvent) => void>();
+  emitter: EventEmitter = new EventEmitter();
 
   emit(e: InternalEvent) {
-    for (const l of this.#listeners) {
-      l(e);
-    }
+    this.emitter.emit("__plugin_event__", e);
   }
 
   listen(cb: (e: InternalEvent) => void) {
-    this.#listeners.add(cb);
-  }
-
-  unlisten(cb: (e: InternalEvent) => void) {
-    this.#listeners.delete(cb);
+    this.emitter.on("__plugin_event__", cb);
   }
 }

packages/plugin-runtime/src/PluginHandle.ts

@@ -1,27 +1,56 @@
 import type { BootRequest, InternalEvent } from '@yaakapp/api';
+import path from 'node:path';
+import { Worker } from 'node:worker_threads';
 import type { EventChannel } from './EventChannel';
-import { PluginInstance, PluginWorkerData } from './PluginInstance';
+import type { PluginWorkerData } from './index.worker';
 
 export class PluginHandle {
-  #instance: PluginInstance;
+  #worker: Worker;
 
   constructor(
     readonly pluginRefId: string,
     readonly bootRequest: BootRequest,
-    readonly pluginToAppEvents: EventChannel,
+    readonly events: EventChannel,
   ) {
+    this.#worker = this.#createWorker();
+  }
+
+  sendToWorker(event: InternalEvent) {
+    this.#worker.postMessage(event);
+  }
+
+  async terminate() {
+    await this.#worker.terminate();
+  }
+
+  #createWorker(): Worker {
+    const workerPath = process.env.YAAK_WORKER_PATH ?? path.join(__dirname, 'index.worker.cjs');
     const workerData: PluginWorkerData = {
       pluginRefId: this.pluginRefId,
       bootRequest: this.bootRequest,
     };
-    this.#instance = new PluginInstance(workerData, pluginToAppEvents);
+    const worker = new Worker(workerPath, {
+      workerData,
+    });
+
+    worker.on('message', (e) => this.events.emit(e));
+    worker.on('error', this.#handleError.bind(this));
+    worker.on('exit', this.#handleExit.bind(this));
+
+    console.log('Created plugin worker for ', this.bootRequest.dir);
+
+    return worker;
   }
 
-  sendToWorker(event: InternalEvent) {
-    this.#instance.postMessage(event);
+  async #handleError(err: Error) {
+    console.error('Plugin errored', this.bootRequest.dir, err);
   }
 
-  terminate() {
-    this.#instance.terminate();
+  async #handleExit(code: number) {
+    if (code === 0) {
+      console.log('Plugin exited successfully', this.bootRequest.dir);
+    } else {
+      console.log('Plugin exited with status', code, this.bootRequest.dir);
+    }
   }
 }

packages/plugin-runtime/src/PluginInstance.ts

@@ -1,604 +0,0 @@
-import {
-  BootRequest,
-  DeleteKeyValueResponse,
-  FindHttpResponsesResponse,
-  FormInput,
-  GetCookieValueRequest,
-  GetCookieValueResponse,
-  GetHttpRequestByIdResponse,
-  GetKeyValueResponse,
-  HttpAuthenticationAction,
-  HttpRequestAction,
-  InternalEvent,
-  InternalEventPayload,
-  JsonPrimitive,
-  ListCookieNamesResponse,
-  PluginWindowContext,
-  PromptTextResponse,
-  RenderHttpRequestResponse,
-  SendHttpRequestResponse,
-  TemplateFunction,
-  TemplateFunctionArg,
-  TemplateRenderResponse,
-} from '@yaakapp-internal/plugins';
-import { Context, PluginDefinition } from '@yaakapp/api';
-import console from 'node:console';
-import { readFileSync, type Stats, statSync, watch } from 'node:fs';
-import path from 'node:path';
-import { EventChannel } from './EventChannel';
-import { migrateTemplateFunctionSelectOptions } from './migrations';
-
-export interface PluginWorkerData {
-  bootRequest: BootRequest;
-  pluginRefId: string;
-}
-
-export class PluginInstance {
-  #workerData: PluginWorkerData;
-  #mod: PluginDefinition;
-  #pkg: { name?: string; version?: string };
-  #pluginToAppEvents: EventChannel;
-  #appToPluginEvents: EventChannel;
-
-  constructor(workerData: PluginWorkerData, pluginEvents: EventChannel) {
-    this.#workerData = workerData;
-    this.#pluginToAppEvents = pluginEvents;
-    this.#appToPluginEvents = new EventChannel();
-
-    // Forward incoming events to onMessage()
-    this.#appToPluginEvents.listen(async (event) => {
-      await this.#onMessage(event);
-    });
-
-    // Reload plugin if the JS or package.json changes
-    const windowContextNone: PluginWindowContext = { type: 'none' };
-    const fileChangeCallback = async () => {
-      this.#importModule();
-      return this.#sendPayload(windowContextNone, { type: 'reload_response' }, null);
-    };
-
-    if (this.#workerData.bootRequest.watch) {
-      watchFile(this.#pathMod(), fileChangeCallback);
-      watchFile(this.#pathPkg(), fileChangeCallback);
-    }
-
-    this.#mod = {};
-    this.#pkg = JSON.parse(readFileSync(this.#pathPkg(), 'utf8'));
-
-    // TODO: Re-implement this now that we're not using workers
-    // prefixStdout(`[plugin][${this.#pkg.name}] %s`);
-
-    this.#importModule();
-  }
-
-  postMessage(event: InternalEvent) {
-    this.#appToPluginEvents.emit(event);
-  }
-
-  terminate() {
-    this.#unimportModule();
-  }
-
-  async #onMessage(event: InternalEvent) {
-    const ctx = this.#newCtx(event);
-
-    const { windowContext, payload, id: replyId } = event;
-    try {
-      if (payload.type === 'boot_request') {
-        // console.log('Plugin initialized', pkg.name, { capabilities, enableWatch });
-        const payload: InternalEventPayload = {
-          type: 'boot_response',
-          name: this.#pkg.name ?? 'unknown',
-          version: this.#pkg.version ?? '0.0.1',
-        };
-        this.#sendPayload(windowContext, payload, replyId);
-        return;
-      }
-
-      if (payload.type === 'terminate_request') {
-        const payload: InternalEventPayload = {
-          type: 'terminate_response',
-        };
-        this.#sendPayload(windowContext, payload, replyId);
-        return;
-      }
-
-      if (
-        payload.type === 'import_request' &&
-        typeof this.#mod?.importer?.onImport === 'function'
-      ) {
-        const reply = await this.#mod.importer.onImport(ctx, {
-          text: payload.content,
-        });
-        if (reply != null) {
-          const replyPayload: InternalEventPayload = {
-            type: 'import_response',
-            // deno-lint-ignore no-explicit-any
-            resources: reply.resources as any,
-          };
-          this.#sendPayload(windowContext, replyPayload, replyId);
-          return;
-        } else {
-          // Continue, to send back an empty reply
-        }
-      }
-
-      if (payload.type === 'filter_request' && typeof this.#mod?.filter?.onFilter === 'function') {
-        const reply = await this.#mod.filter.onFilter(ctx, {
-          filter: payload.filter,
-          payload: payload.content,
-          mimeType: payload.type,
-        });
-        const replyPayload: InternalEventPayload = {
-          type: 'filter_response',
-          content: reply.filtered,
-        };
-        this.#sendPayload(windowContext, replyPayload, replyId);
-        return;
-      }
-
-      if (
-        payload.type === 'get_http_request_actions_request' &&
-        Array.isArray(this.#mod?.httpRequestActions)
-      ) {
-        const reply: HttpRequestAction[] = this.#mod.httpRequestActions.map((a) => ({
-          ...a,
-          // Add everything except onSelect
-          onSelect: undefined,
-        }));
-        const replyPayload: InternalEventPayload = {
-          type: 'get_http_request_actions_response',
-          pluginRefId: this.#workerData.pluginRefId,
-          actions: reply,
-        };
-        this.#sendPayload(windowContext, replyPayload, replyId);
-        return;
-      }
-
-      if (
-        payload.type === 'get_template_functions_request' &&
-        Array.isArray(this.#mod?.templateFunctions)
-      ) {
-        const reply: TemplateFunction[] = this.#mod.templateFunctions.map((templateFunction) => {
-          return {
-            ...migrateTemplateFunctionSelectOptions(templateFunction),
-            // Add everything except render
-            onRender: undefined,
-          };
-        });
-        const replyPayload: InternalEventPayload = {
-          type: 'get_template_functions_response',
-          pluginRefId: this.#workerData.pluginRefId,
-          functions: reply,
-        };
-        this.#sendPayload(windowContext, replyPayload, replyId);
-        return;
-      }
-
-      if (payload.type === 'get_http_authentication_summary_request' && this.#mod?.authentication) {
-        const { name, shortLabel, label } = this.#mod.authentication;
-        const replyPayload: InternalEventPayload = {
-          type: 'get_http_authentication_summary_response',
-          name,
-          label,
-          shortLabel,
-        };
-
-        this.#sendPayload(windowContext, replyPayload, replyId);
-        return;
-      }
-
-      if (payload.type === 'get_http_authentication_config_request' && this.#mod?.authentication) {
-        const { args, actions } = this.#mod.authentication;
-        const resolvedArgs: FormInput[] = [];
-        for (let i = 0; i < args.length; i++) {
-          let v = args[i];
-          if ('dynamic' in v) {
-            const dynamicAttrs = await v.dynamic(ctx, payload);
-            const { dynamic, ...other } = v;
-            resolvedArgs.push({ ...other, ...dynamicAttrs } as FormInput);
-          } else {
-            resolvedArgs.push(v);
-          }
-        }
-        const resolvedActions: HttpAuthenticationAction[] = [];
-        for (const { onSelect, ...action } of actions ?? []) {
-          resolvedActions.push(action);
-        }
-
-        const replyPayload: InternalEventPayload = {
-          type: 'get_http_authentication_config_response',
-          args: resolvedArgs,
-          actions: resolvedActions,
-          pluginRefId: this.#workerData.pluginRefId,
-        };
-
-        this.#sendPayload(windowContext, replyPayload, replyId);
-        return;
-      }
-
-      if (payload.type === 'call_http_authentication_request' && this.#mod?.authentication) {
-        const auth = this.#mod.authentication;
-        if (typeof auth?.onApply === 'function') {
-          applyFormInputDefaults(auth.args, payload.values);
-          const result = await auth.onApply(ctx, payload);
-          this.#sendPayload(
-            windowContext,
-            {
-              type: 'call_http_authentication_response',
-              setHeaders: result.setHeaders,
-            },
-            replyId,
-          );
-          return;
-        }
-      }
-
-      if (
-        payload.type === 'call_http_authentication_action_request' &&
-        this.#mod.authentication != null
-      ) {
-        const action = this.#mod.authentication.actions?.[payload.index];
-        if (typeof action?.onSelect === 'function') {
-          await action.onSelect(ctx, payload.args);
-          this.#sendEmpty(windowContext, replyId);
-          return;
-        }
-      }
-
-      if (
-        payload.type === 'call_http_request_action_request' &&
-        Array.isArray(this.#mod.httpRequestActions)
-      ) {
-        const action = this.#mod.httpRequestActions[payload.index];
-        if (typeof action?.onSelect === 'function') {
-          await action.onSelect(ctx, payload.args);
-          this.#sendEmpty(windowContext, replyId);
-          return;
-        }
-      }
-
-      if (
-        payload.type === 'call_template_function_request' &&
-        Array.isArray(this.#mod?.templateFunctions)
-      ) {
-        const fn = this.#mod.templateFunctions.find((a) => a.name === payload.name);
-        if (typeof fn?.onRender === 'function') {
-          applyFormInputDefaults(fn.args, payload.args.values);
-          const result = await fn.onRender(ctx, payload.args);
-          this.#sendPayload(
-            windowContext,
-            {
-              type: 'call_template_function_response',
-              value: result ?? null,
-            },
-            replyId,
-          );
-          return;
-        }
-      }
-
-      if (payload.type === 'reload_request') {
-        this.#importModule();
-      }
-    } catch (err) {
-      console.log('Plugin call threw exception', payload.type, err);
-      this.#sendPayload(
-        windowContext,
-        {
-          type: 'error_response',
-          error: `${err}`,
-        },
-        replyId,
-      );
-      return;
-    }
-
-    // No matches, so send back an empty response so the caller doesn't block forever
-    this.#sendEmpty(windowContext, replyId);
-  }
-
-  #pathMod() {
-    return path.posix.join(this.#workerData.bootRequest.dir, 'build', 'index.js');
-  }
-
-  #pathPkg() {
-    return path.join(this.#workerData.bootRequest.dir, 'package.json');
-  }
-
-  #unimportModule() {
-    const id = require.resolve(this.#pathMod());
-    delete require.cache[id];
-  }
-
-  #importModule() {
-    const id = require.resolve(this.#pathMod());
-    delete require.cache[id];
-    this.#mod = require(id).plugin;
-  }
-
-  #buildEventToSend(
-    windowContext: PluginWindowContext,
-    payload: InternalEventPayload,
-    replyId: string | null = null,
-  ): InternalEvent {
-    return {
-      pluginRefId: this.#workerData.pluginRefId,
-      pluginName: path.basename(this.#workerData.bootRequest.dir),
-      id: genId(),
-      replyId,
-      payload,
-      windowContext,
-    };
-  }
-
-  #sendPayload(
-    windowContext: PluginWindowContext,
-    payload: InternalEventPayload,
-    replyId: string | null,
-  ): string {
-    const event = this.#buildEventToSend(windowContext, payload, replyId);
-    this.#sendEvent(event);
-    return event.id;
-  }
-
-  #sendEvent(event: InternalEvent) {
-    // if (event.payload.type !== 'empty_response') {
-    //   console.log('Sending event to app', this.#pkg.name, event.id, event.payload.type);
-    // }
-    this.#pluginToAppEvents.emit(event);
-  }
-
-  #sendEmpty(windowContext: PluginWindowContext, replyId: string | null = null): string {
-    return this.#sendPayload(windowContext, { type: 'empty_response' }, replyId);
-  }
-
-  #sendAndWaitForReply<T extends Omit<InternalEventPayload, 'type'>>(
-    windowContext: PluginWindowContext,
-    payload: InternalEventPayload,
-  ): Promise<T> {
-    // 1. Build event to send
-    const eventToSend = this.#buildEventToSend(windowContext, payload, null);
-
-    // 2. Spawn listener in background
-    const promise = new Promise<T>((resolve) => {
-      const cb = (event: InternalEvent) => {
-        if (event.replyId === eventToSend.id) {
-          this.#appToPluginEvents.unlisten(cb); // Unlisten, now that we're done
-          const { type: _, ...payload } = event.payload;
-          resolve(payload as T);
-        }
-      };
-      this.#appToPluginEvents.listen(cb);
-    });
-
-    // 3. Send the event after we start listening (to prevent race)
-    this.#sendEvent(eventToSend);
-
-    // 4. Return the listener promise
-    return promise as unknown as Promise<T>;
-  }
-
-  #sendAndListenForEvents(
-    windowContext: PluginWindowContext,
-    payload: InternalEventPayload,
-    onEvent: (event: InternalEventPayload) => void,
-  ): void {
-    // 1. Build event to send
-    const eventToSend = this.#buildEventToSend(windowContext, payload, null);
-
-    // 2. Listen for replies in the background
-    this.#appToPluginEvents.listen((event: InternalEvent) => {
-      if (event.replyId === eventToSend.id) {
-        onEvent(event.payload);
-      }
-    });
-
-    // 3. Send the event after we start listening (to prevent race)
-    this.#sendEvent(eventToSend);
-  }
-
-  #newCtx(event: InternalEvent): Context {
-    return {
-      clipboard: {
-        copyText: async (text) => {
-          await this.#sendAndWaitForReply(event.windowContext, {
-            type: 'copy_text_request',
-            text,
-          });
-        },
-      },
-      toast: {
-        show: async (args) => {
-          await this.#sendAndWaitForReply(event.windowContext, {
-            type: 'show_toast_request',
-            ...args,
-          });
-        },
-      },
-      window: {
-        openUrl: async ({ onNavigate, onClose, ...args }) => {
-          args.label = args.label || `${Math.random()}`;
-          const payload: InternalEventPayload = { type: 'open_window_request', ...args };
-          const onEvent = (event: InternalEventPayload) => {
-            if (event.type === 'window_navigate_event') {
-              onNavigate?.(event);
-            } else if (event.type === 'window_close_event') {
-              onClose?.();
-            }
-          };
-          this.#sendAndListenForEvents(event.windowContext, payload, onEvent);
-          return {
-            close: () => {
-              const closePayload: InternalEventPayload = {
-                type: 'close_window_request',
-                label: args.label,
-              };
-              this.#sendPayload(event.windowContext, closePayload, null);
-            },
-          };
-        },
-      },
-      prompt: {
-        text: async (args) => {
-          const reply: PromptTextResponse = await this.#sendAndWaitForReply(event.windowContext, {
-            type: 'prompt_text_request',
-            ...args,
-          });
-          return reply.value;
-        },
-      },
-      httpResponse: {
-        find: async (args) => {
-          const payload = {
-            type: 'find_http_responses_request',
-            ...args,
-          } as const;
-          const { httpResponses } = await this.#sendAndWaitForReply<FindHttpResponsesResponse>(
-            event.windowContext,
-            payload,
-          );
-          return httpResponses;
-        },
-      },
-      httpRequest: {
-        getById: async (args) => {
-          const payload = {
-            type: 'get_http_request_by_id_request',
-            ...args,
-          } as const;
-          const { httpRequest } = await this.#sendAndWaitForReply<GetHttpRequestByIdResponse>(
-            event.windowContext,
-            payload,
-          );
-          return httpRequest;
-        },
-        send: async (args) => {
-          const payload = {
-            type: 'send_http_request_request',
-            ...args,
-          } as const;
-          const { httpResponse } = await this.#sendAndWaitForReply<SendHttpRequestResponse>(
-            event.windowContext,
-            payload,
-          );
-          return httpResponse;
-        },
-        render: async (args) => {
-          const payload = {
-            type: 'render_http_request_request',
-            ...args,
-          } as const;
-          const { httpRequest } = await this.#sendAndWaitForReply<RenderHttpRequestResponse>(
-            event.windowContext,
-            payload,
-          );
-          return httpRequest;
-        },
-      },
-      cookies: {
-        getValue: async (args: GetCookieValueRequest) => {
-          const payload = {
-            type: 'get_cookie_value_request',
-            ...args,
-          } as const;
-          const { value } = await this.#sendAndWaitForReply<GetCookieValueResponse>(
-            event.windowContext,
-            payload,
-          );
-          return value;
-        },
-        listNames: async () => {
-          const payload = { type: 'list_cookie_names_request' } as const;
-          const { names } = await this.#sendAndWaitForReply<ListCookieNamesResponse>(
-            event.windowContext,
-            payload,
-          );
-          return names;
-        },
-      },
-      templates: {
-        /**
-         * Invoke Yaak's template engine to render a value. If the value is a nested type
-         * (eg. object), it will be recursively rendered.
-         */
-        render: async (args) => {
-          const payload = { type: 'template_render_request', ...args } as const;
-          const result = await this.#sendAndWaitForReply<TemplateRenderResponse>(
-            event.windowContext,
-            payload,
-          );
-          return result.data;
-        },
-      },
-      store: {
-        get: async <T>(key: string) => {
-          const payload = { type: 'get_key_value_request', key } as const;
-          const result = await this.#sendAndWaitForReply<GetKeyValueResponse>(
-            event.windowContext,
-            payload,
-          );
-          return result.value ? (JSON.parse(result.value) as T) : undefined;
-        },
-        set: async <T>(key: string, value: T) => {
-          const valueStr = JSON.stringify(value);
-          const payload: InternalEventPayload = {
-            type: 'set_key_value_request',
-            key,
-            value: valueStr,
-          };
-          await this.#sendAndWaitForReply<GetKeyValueResponse>(event.windowContext, payload);
-        },
-        delete: async (key: string) => {
-          const payload = { type: 'delete_key_value_request', key } as const;
-          const result = await this.#sendAndWaitForReply<DeleteKeyValueResponse>(
-            event.windowContext,
-            payload,
-          );
-          return result.deleted;
-        },
-      },
-    };
-  }
-}
-
-function genId(len = 5): string {
-  const alphabet = '01234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
-  let id = '';
-  for (let i = 0; i < len; i++) {
-    id += alphabet[Math.floor(Math.random() * alphabet.length)];
-  }
-  return id;
-}
-
-/** Recursively apply form input defaults to a set of values */
-function applyFormInputDefaults(
-  inputs: TemplateFunctionArg[],
-  values: { [p: string]: JsonPrimitive | undefined },
-) {
-  for (const input of inputs) {
-    if ('inputs' in input) {
-      applyFormInputDefaults(input.inputs ?? [], values);
-    } else if ('defaultValue' in input && values[input.name] === undefined) {
-      values[input.name] = input.defaultValue;
-    }
-  }
-}
-
-const watchedFiles: Record<string, Stats> = {};
-
-/**
- * Watch a file and trigger callback on change.
- *
- * We also track the stat for each file because fs.watch() will
- * trigger a "change" event when the access date changes
- */
-function watchFile(filepath: string, cb: (filepath: string) => void) {
-  watch(filepath, () => {
-    const stat = statSync(filepath);
-    if (stat.mtimeMs !== watchedFiles[filepath]?.mtimeMs) {
-      cb(filepath);
-    }
-    watchedFiles[filepath] = stat;
-  });
-}

packages/plugin-runtime/src/index.ts

@@ -8,7 +8,7 @@ if (!port) {
   throw new Error('Plugin runtime missing PORT')
 }
 
-const pluginToAppEvents = new EventChannel();
+const events = new EventChannel();
 const plugins: Record<string, PluginHandle> = {};
 
 const ws = new WebSocket(`ws://localhost:${port}`);
@@ -25,7 +25,7 @@ ws.on('error', (err: any) => console.error('Plugin runtime websocket error', err
 ws.on('close', (code: number) => console.log('Plugin runtime websocket closed', code));
 
 // Listen for incoming events from plugins
-pluginToAppEvents.listen((e) => {
+events.listen((e) => {
   const eventStr = JSON.stringify(e);
   ws.send(eventStr);
 });
@@ -34,7 +34,7 @@ async function handleIncoming(msg: string) {
   const pluginEvent: InternalEvent = JSON.parse(msg);
   // Handle special event to bootstrap plugin
   if (pluginEvent.payload.type === 'boot_request') {
-    const plugin = new PluginHandle(pluginEvent.pluginRefId, pluginEvent.payload, pluginToAppEvents);
+    const plugin = new PluginHandle(pluginEvent.pluginRefId, pluginEvent.payload, events);
     plugins[pluginEvent.pluginRefId] = plugin;
   }
 
@@ -46,7 +46,7 @@ async function handleIncoming(msg: string) {
   }
 
   if (pluginEvent.payload.type === 'terminate_request') {
-    plugin.terminate();
+    await plugin.terminate();
     console.log('Terminated plugin worker', pluginEvent.pluginRefId);
     delete plugins[pluginEvent.pluginRefId];
   }

packages/plugin-runtime/src/index.worker.ts

@@ -0,0 +1,436 @@
+import type {
+  BootRequest,
+  Context,
+  FindHttpResponsesResponse,
+  GetHttpRequestByIdResponse,
+  HttpRequestAction,
+  InternalEvent,
+  InternalEventPayload,
+  PluginDefinition,
+  PromptTextResponse,
+  RenderHttpRequestResponse,
+  SendHttpRequestResponse,
+  TemplateFunction,
+  TemplateRenderResponse,
+  WindowContext,
+} from '@yaakapp/api';
+import * as console from 'node:console';
+import type { Stats } from 'node:fs';
+import { readFileSync, statSync, watch } from 'node:fs';
+import path from 'node:path';
+import * as util from 'node:util';
+import { interceptStdout } from './interceptStdout';
+import { parentPort, workerData } from 'node:worker_threads';
+
+export interface PluginWorkerData {
+  bootRequest: BootRequest;
+  pluginRefId: string;
+}
+
+function initialize(workerData: PluginWorkerData) {
+  const {
+    bootRequest: { dir: pluginDir, watch: enableWatch },
+    pluginRefId,
+  }: PluginWorkerData = workerData;
+
+  const pathPkg = path.join(pluginDir, 'package.json');
+  const pathMod = path.posix.join(pluginDir, 'build', 'index.js');
+
+  const pkg = JSON.parse(readFileSync(pathPkg, 'utf8'));
+
+  prefixStdout(`[plugin][${pkg.name}] %s`);
+
+  function buildEventToSend(
+    windowContext: WindowContext,
+    payload: InternalEventPayload,
+    replyId: string | null = null,
+  ): InternalEvent {
+    return {
+      pluginRefId,
+      pluginName: path.basename(pluginDir),
+      id: genId(),
+      replyId,
+      payload,
+      windowContext,
+    };
+  }
+
+  function sendEmpty(windowContext: WindowContext, replyId: string | null = null): string {
+    return sendPayload(windowContext, { type: 'empty_response' }, replyId);
+  }
+
+  function sendPayload(
+    windowContext: WindowContext,
+    payload: InternalEventPayload,
+    replyId: string | null,
+  ): string {
+    const event = buildEventToSend(windowContext, payload, replyId);
+    sendEvent(event);
+    return event.id;
+  }
+
+  function sendEvent(event: InternalEvent) {
+    if (event.payload.type !== 'empty_response') {
+      console.log('Sending event to app', event.id, event.payload.type);
+    }
+    parentPort!.postMessage(event);
+  }
+
+  function sendAndWaitForReply<T extends Omit<InternalEventPayload, 'type'>>(
+    windowContext: WindowContext,
+    payload: InternalEventPayload,
+  ): Promise<T> {
+    // 1. Build event to send
+    const eventToSend = buildEventToSend(windowContext, payload, null);
+
+    // 2. Spawn listener in background
+    const promise = new Promise<InternalEventPayload>((resolve) => {
+      const cb = (event: InternalEvent) => {
+        if (event.replyId === eventToSend.id) {
+          parentPort!.off('message', cb); // Unlisten, now that we're done
+          resolve(event.payload); // Not type-safe but oh well
+        }
+      };
+      parentPort!.on('message', cb);
+    });
+
+    // 3. Send the event after we start listening (to prevent race)
+    sendEvent(eventToSend);
+
+    // 4. Return the listener promise
+    return promise as unknown as Promise<T>;
+  }
+
+  // Reload plugin if the JS or package.json changes
+  const windowContextNone: WindowContext = { type: 'none' };
+  const fileChangeCallback = async () => {
+    await importModule();
+    return sendPayload(windowContextNone, { type: 'reload_response' }, null);
+  };
+
+  if (enableWatch) {
+    watchFile(pathMod, fileChangeCallback);
+    watchFile(pathPkg, fileChangeCallback);
+  }
+
+  const newCtx = (event: InternalEvent): Context => ({
+    clipboard: {
+      async copyText(text) {
+        await sendAndWaitForReply(event.windowContext, {
+          type: 'copy_text_request',
+          text,
+        });
+      },
+    },
+    toast: {
+      async show(args) {
+        await sendAndWaitForReply(event.windowContext, {
+          type: 'show_toast_request',
+          ...args,
+        });
+      },
+    },
+    prompt: {
+      async text(args) {
+        const reply: PromptTextResponse = await sendAndWaitForReply(event.windowContext, {
+          type: 'prompt_text_request',
+          ...args,
+        });
+        return reply.value;
+      },
+    },
+    httpResponse: {
+      async find(args) {
+        const payload = {
+          type: 'find_http_responses_request',
+          ...args,
+        } as const;
+        const { httpResponses } = await sendAndWaitForReply<FindHttpResponsesResponse>(
+          event.windowContext,
+          payload,
+        );
+        return httpResponses;
+      },
+    },
+    httpRequest: {
+      async getById(args) {
+        const payload = {
+          type: 'get_http_request_by_id_request',
+          ...args,
+        } as const;
+        const { httpRequest } = await sendAndWaitForReply<GetHttpRequestByIdResponse>(
+          event.windowContext,
+          payload,
+        );
+        return httpRequest;
+      },
+      async send(args) {
+        const payload = {
+          type: 'send_http_request_request',
+          ...args,
+        } as const;
+        const { httpResponse } = await sendAndWaitForReply<SendHttpRequestResponse>(
+          event.windowContext,
+          payload,
+        );
+        return httpResponse;
+      },
+      async render(args) {
+        const payload = {
+          type: 'render_http_request_request',
+          ...args,
+        } as const;
+        const { httpRequest } = await sendAndWaitForReply<RenderHttpRequestResponse>(
+          event.windowContext,
+          payload,
+        );
+        return httpRequest;
+      },
+    },
+    templates: {
+      /**
+       * Invoke Yaak's template engine to render a value. If the value is a nested type
+       * (eg. object), it will be recursively rendered.
+       */
+      async render(args) {
+        const payload = { type: 'template_render_request', ...args } as const;
+        const result = await sendAndWaitForReply<TemplateRenderResponse>(
+          event.windowContext,
+          payload,
+        );
+        return result.data;
+      },
+    },
+  });
+
+  let plug: PluginDefinition | null = null;
+
+  function importModule() {
+    const id = require.resolve(pathMod);
+    delete require.cache[id];
+    plug = require(id).plugin;
+  }
+  importModule();
+
+  if (pkg.name?.includes('yaak-faker')) {
+    sendPayload(
+      { type: 'none' },
+      { type: 'error_response', error: 'Failed to initialize Faker plugin' },
+      null,
+    );
+    return;
+  }
+
+  // Message comes into the plugin to be processed
+  parentPort!.on('message', async (event: InternalEvent) => {
+    const ctx = newCtx(event);
+    const { windowContext, payload, id: replyId } = event;
+    try {
+      if (payload.type === 'boot_request') {
+        // console.log('Plugin initialized', pkg.name, { capabilities, enableWatch });
+        const payload: InternalEventPayload = {
+          type: 'boot_response',
+          name: pkg.name,
+          version: pkg.version,
+        };
+        sendPayload(windowContext, payload, replyId);
+        return;
+      }
+
+      if (payload.type === 'terminate_request') {
+        const payload: InternalEventPayload = {
+          type: 'terminate_response',
+        };
+        sendPayload(windowContext, payload, replyId);
+        return;
+      }
+
+      if (payload.type === 'import_request' && typeof plug?.importer?.onImport === 'function') {
+        const reply = await plug.importer.onImport(ctx, {
+          text: payload.content,
+        });
+        if (reply != null) {
+          const replyPayload: InternalEventPayload = {
+            type: 'import_response',
+            // deno-lint-ignore no-explicit-any
+            resources: reply.resources as any,
+          };
+          sendPayload(windowContext, replyPayload, replyId);
+          return;
+        } else {
+          // Continue, to send back an empty reply
+        }
+      }
+
+      if (payload.type === 'filter_request' && typeof plug?.filter?.onFilter === 'function') {
+        const reply = await plug.filter.onFilter(ctx, {
+          filter: payload.filter,
+          payload: payload.content,
+          mimeType: payload.type,
+        });
+        const replyPayload: InternalEventPayload = {
+          type: 'filter_response',
+          content: reply.filtered,
+        };
+        sendPayload(windowContext, replyPayload, replyId);
+        return;
+      }
+
+      if (
+        payload.type === 'get_http_request_actions_request' &&
+        Array.isArray(plug?.httpRequestActions)
+      ) {
+        const reply: HttpRequestAction[] = plug.httpRequestActions.map((a) => ({
+          ...a,
+          // Add everything except onSelect
+          onSelect: undefined,
+        }));
+        const replyPayload: InternalEventPayload = {
+          type: 'get_http_request_actions_response',
+          pluginRefId,
+          actions: reply,
+        };
+        sendPayload(windowContext, replyPayload, replyId);
+        return;
+      }
+
+      if (
+        payload.type === 'get_template_functions_request' &&
+        Array.isArray(plug?.templateFunctions)
+      ) {
+        const reply: TemplateFunction[] = plug.templateFunctions.map((a) => ({
+          ...a,
+          // Add everything except render
+          onRender: undefined,
+        }));
+        const replyPayload: InternalEventPayload = {
+          type: 'get_template_functions_response',
+          pluginRefId,
+          functions: reply,
+        };
+        sendPayload(windowContext, replyPayload, replyId);
+        return;
+      }
+
+      if (payload.type === 'get_http_authentication_request' && plug?.authentication) {
+        const { onApply: _, ...auth } = plug.authentication;
+        const replyPayload: InternalEventPayload = {
+          ...auth,
+          type: 'get_http_authentication_response',
+        };
+
+        sendPayload(windowContext, replyPayload, replyId);
+        return;
+      }
+
+      if (payload.type === 'call_http_authentication_request' && plug?.authentication) {
+        const auth = plug.authentication;
+        if (typeof auth?.onApply === 'function') {
+          const result = await auth.onApply(ctx, payload);
+          sendPayload(
+            windowContext,
+            {
+              ...result,
+              type: 'call_http_authentication_response',
+            },
+            replyId,
+          );
+          return;
+        }
+      }
+
+      if (
+        payload.type === 'call_http_request_action_request' &&
+        Array.isArray(plug?.httpRequestActions)
+      ) {
+        const action = plug.httpRequestActions.find((a) => a.key === payload.key);
+        if (typeof action?.onSelect === 'function') {
+          await action.onSelect(ctx, payload.args);
+          sendEmpty(windowContext, replyId);
+          return;
+        }
+      }
+
+      if (
+        payload.type === 'call_template_function_request' &&
+        Array.isArray(plug?.templateFunctions)
+      ) {
+        const action = plug.templateFunctions.find((a) => a.name === payload.name);
+        if (typeof action?.onRender === 'function') {
+          const result = await action.onRender(ctx, payload.args);
+          sendPayload(
+            windowContext,
+            {
+              type: 'call_template_function_response',
+              value: result ?? null,
+            },
+            replyId,
+          );
+          return;
+        }
+      }
+
+      if (payload.type === 'reload_request') {
+        await importModule();
+      }
+    } catch (err) {
+      console.log('Plugin call threw exception', payload.type, err);
+      sendPayload(
+        windowContext,
+        {
+          type: 'error_response',
+          error: `${err}`,
+        },
+        replyId,
+      );
+      // TODO: Return errors to server
+    }
+
+    // No matches, so send back an empty response so the caller doesn't block forever
+    sendEmpty(windowContext, replyId);
+  });
+}
+
+initialize(workerData);
+
+function genId(len = 5): string {
+  const alphabet = '01234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+  let id = '';
+  for (let i = 0; i < len; i++) {
+    id += alphabet[Math.floor(Math.random() * alphabet.length)];
+  }
+  return id;
+}
+
+function prefixStdout(s: string) {
+  if (!s.includes('%s')) {
+    throw new Error('Console prefix must contain a "%s" replacer');
+  }
+  interceptStdout((text: string) => {
+    const lines = text.split(/\n/);
+    let newText = '';
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i] == '') continue;
+      newText += util.format(s, lines[i]) + '\n';
+    }
+    return newText.trimEnd();
+  });
+}
+
+const watchedFiles: Record<string, Stats> = {};
+
+/**
+ * Watch a file and trigger callback on change.
+ *
+ * We also track the stat for each file because fs.watch() will
+ * trigger a "change" event when the access date changes
+ */
+function watchFile(filepath: string, cb: (filepath: string) => void) {
+  watch(filepath, () => {
+    const stat = statSync(filepath);
+    if (stat.mtimeMs !== watchedFiles[filepath]?.mtimeMs) {
+      cb(filepath);
+    }
+    watchedFiles[filepath] = stat;
+  });
+}

packages/plugin-runtime/src/migrations.ts

@@ -1,18 +0,0 @@
-import { TemplateFunction } from '@yaakapp/api';
-
-export function migrateTemplateFunctionSelectOptions(f: TemplateFunction): TemplateFunction {
-  const migratedArgs = f.args.map((a) => {
-    if (a.type === 'select') {
-      a.options = a.options.map((o) => ({
-        ...o,
-        label: o.label || (o as any).name,
-      }));
-    }
-    return a;
-  });
-
-  return {
-    ...f,
-    args: migratedArgs,
-  };
-}

rustfmt.toml

@@ -1,4 +1,4 @@
-edition = "2024"
+edition = "2018"
 
 # Widths
 chain_width = 100

scripts/vendor-node.cjs

@@ -9,14 +9,12 @@ const NODE_VERSION = 'v22.9.0';
 // `${process.platform}_${process.arch}`
 const MAC_ARM = 'darwin_arm64';
 const MAC_X64 = 'darwin_x64';
-const LNX_ARM = 'linux_arm64';
 const LNX_X64 = 'linux_x64';
 const WIN_X64 = 'win32_x64';
 
 const URL_MAP = {
   [MAC_ARM]: `https://nodejs.org/download/release/${NODE_VERSION}/node-${NODE_VERSION}-darwin-arm64.tar.gz`,
   [MAC_X64]: `https://nodejs.org/download/release/${NODE_VERSION}/node-${NODE_VERSION}-darwin-x64.tar.gz`,
-  [LNX_ARM]: `https://nodejs.org/download/release/${NODE_VERSION}/node-${NODE_VERSION}-linux-arm64.tar.gz`,
   [LNX_X64]: `https://nodejs.org/download/release/${NODE_VERSION}/node-${NODE_VERSION}-linux-x64.tar.gz`,
   [WIN_X64]: `https://nodejs.org/download/release/${NODE_VERSION}/node-${NODE_VERSION}-win-x64.zip`,
 };
@@ -24,17 +22,15 @@ const URL_MAP = {
 const SRC_BIN_MAP = {
   [MAC_ARM]: `node-${NODE_VERSION}-darwin-arm64/bin/node`,
   [MAC_X64]: `node-${NODE_VERSION}-darwin-x64/bin/node`,
-  [LNX_ARM]: `node-${NODE_VERSION}-linux-arm64/bin/node`,
   [LNX_X64]: `node-${NODE_VERSION}-linux-x64/bin/node`,
   [WIN_X64]: `node-${NODE_VERSION}-win-x64/node.exe`,
 };
 
 const DST_BIN_MAP = {
-  [MAC_ARM]: 'yaaknode-aarch64-apple-darwin',
-  [MAC_X64]: 'yaaknode-x86_64-apple-darwin',
-  [LNX_ARM]: 'yaaknode-aarch64-unknown-linux-gnu',
-  [LNX_X64]: 'yaaknode-x86_64-unknown-linux-gnu',
-  [WIN_X64]: 'yaaknode-x86_64-pc-windows-msvc.exe',
+  darwin_arm64: 'yaaknode-aarch64-apple-darwin',
+  darwin_x64: 'yaaknode-x86_64-apple-darwin',
+  linux_x64: 'yaaknode-x86_64-unknown-linux-gnu',
+  win32_x64: 'yaaknode-x86_64-pc-windows-msvc.exe',
 };
 
 const key = `${process.platform}_${process.env.YAAK_TARGET_ARCH ?? process.arch}`;

scripts/vendor-protoc.cjs

@@ -9,14 +9,12 @@ const VERSION = '28.3';
 // `${process.platform}_${process.arch}`
 const MAC_ARM = 'darwin_arm64';
 const MAC_X64 = 'darwin_x64';
-const LNX_ARM = 'linux_arm64';
 const LNX_X64 = 'linux_x64';
 const WIN_X64 = 'win32_x64';
 
 const URL_MAP = {
   [MAC_ARM]: `https://github.com/protocolbuffers/protobuf/releases/download/v${VERSION}/protoc-${VERSION}-osx-aarch_64.zip`,
   [MAC_X64]: `https://github.com/protocolbuffers/protobuf/releases/download/v${VERSION}/protoc-${VERSION}-osx-x86_64.zip`,
-  [LNX_ARM]: `https://github.com/protocolbuffers/protobuf/releases/download/v${VERSION}/protoc-${VERSION}-linux-aarch_64.zip`,
   [LNX_X64]: `https://github.com/protocolbuffers/protobuf/releases/download/v${VERSION}/protoc-${VERSION}-linux-x86_64.zip`,
   [WIN_X64]: `https://github.com/protocolbuffers/protobuf/releases/download/v${VERSION}/protoc-${VERSION}-win64.zip`,
 };
@@ -24,7 +22,6 @@ const URL_MAP = {
 const SRC_BIN_MAP = {
   [MAC_ARM]: 'bin/protoc',
   [MAC_X64]: 'bin/protoc',
-  [LNX_ARM]: 'bin/protoc',
   [LNX_X64]: 'bin/protoc',
   [WIN_X64]: 'bin/protoc.exe',
 };
@@ -32,7 +29,6 @@ const SRC_BIN_MAP = {
 const DST_BIN_MAP = {
   [MAC_ARM]: 'yaakprotoc-aarch64-apple-darwin',
   [MAC_X64]: 'yaakprotoc-x86_64-apple-darwin',
-  [LNX_ARM]: 'yaakprotoc-aarch64-unknown-linux-gnu',
   [LNX_X64]: 'yaakprotoc-x86_64-unknown-linux-gnu',
   [WIN_X64]: 'yaakprotoc-x86_64-pc-windows-msvc.exe',
 };

src-tauri/.gitignore

@@ -4,8 +4,3 @@ target/
 
 vendored/*
 !vendored/plugins
-
-gen/*
-
-**/permissions/autogenerated
-**/permissions/schemas

src-tauri/Cargo.toml

@@ -1,23 +1,18 @@
 [workspace]
 members = [
-    "yaak-crypto",
-    "yaak-git",
     "yaak-grpc",
-    "yaak-http",
     "yaak-license",
-    "yaak-mac-window",
     "yaak-models",
     "yaak-plugins",
     "yaak-sse",
     "yaak-sync",
     "yaak-templates",
-    "yaak-ws",
 ]
 
 [package]
 name = "yaak-app"
 version = "0.0.0"
-edition = "2024"
+edition = "2021"
 authors = ["Gregory Schier"]
 publish = false
 
@@ -33,71 +28,64 @@ strip = true  # Automatically strip symbols from the binary.
 cargo-clippy = []
 
 [build-dependencies]
-tauri-build = { version = "2.1.1", features = [] }
+tauri-build = { version = "2.0.5", features = [] }
+
+[target.'cfg(target_os = "macos")'.dependencies]
+objc = "0.2.7"
+cocoa = "0.26.0"
 
 [target.'cfg(target_os = "linux")'.dependencies]
-openssl-sys = { version = "0.9.105", features = ["vendored"] } # For Ubuntu installation to work
+openssl-sys = { version = "0.9", features = ["vendored"] } # For Ubuntu installation to work
 
 [dependencies]
 chrono = { version = "0.4.31", features = ["serde"] }
-cookie = "0.18.1"
-encoding_rs = "0.8.35"
+datetime = "0.5.2"
 eventsource-client = { git = "https://github.com/yaakapp/rust-eventsource-client", version = "0.14.0" }
+hex_color = "3.0.0"
 http = { version = "1.2.0", default-features = false }
-log = "0.4.27"
-md5 = "0.7.0"
-mime_guess = "2.0.5"
-rand = "0.9.0"
+log = "0.4.21"
+rand = "0.8.5"
+regex = "1.10.2"
 reqwest = { workspace = true, features = ["multipart", "cookies", "gzip", "brotli", "deflate", "json", "rustls-tls-manual-roots-no-provider"] }
 reqwest_cookie_store = "0.8.0"
-rustls = { version = "0.23.25", default-features = false, features = ["custom-provider", "ring"] }
-rustls-platform-verifier = "0.5.1"
+rustls = { version = "0.23.21", default-features = false }
+rustls-platform-verifier = "0.5.0"
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true, features = ["raw_value"] }
 tauri = { workspace = true, features = ["devtools", "protocol-asset"] }
-tauri-plugin-clipboard-manager = "2.2.2"
+tauri-plugin-clipboard-manager = "2.2.0"
 tauri-plugin-dialog = "2.2.0"
 tauri-plugin-fs = "2.2.0"
-tauri-plugin-log = { version = "2.3.1", features = ["colored"] }
-tauri-plugin-opener = "2.2.6"
-tauri-plugin-os = "2.2.1"
+tauri-plugin-log = { version = "2.2.0", features = ["colored"] }
+tauri-plugin-opener = "2.2.4"
+tauri-plugin-os = "2.2.0"
 tauri-plugin-shell = { workspace = true }
-tauri-plugin-single-instance = "2.2.2"
-tauri-plugin-updater = "2.6.1"
-tauri-plugin-window-state = "2.2.1"
-thiserror = { workspace = true }
-tokio = { workspace = true, features = ["sync"] }
-tokio-stream = "0.1.17"
-uuid = "1.12.1"
-yaak-common = { workspace = true }
-yaak-crypto = { workspace = true }
-yaak-git = { path = "yaak-git" }
+tauri-plugin-single-instance = "2.2.1"
+tauri-plugin-updater = "2.3.1"
+tauri-plugin-window-state = "2.2.0"
+tokio = { version = "1.36.0", features = ["sync"] }
+tokio-stream = "0.1.15"
+ts-rs = { workspace = true }
+mime_guess = "2.0.5"
+urlencoding = "2.1.3"
+uuid = "1.7.0"
 yaak-grpc = { path = "yaak-grpc" }
-yaak-http = { workspace = true }
 yaak-license = { path = "yaak-license" }
-yaak-mac-window = { path = "yaak-mac-window" }
 yaak-models = { workspace = true }
 yaak-plugins = { workspace = true }
 yaak-sse = { workspace = true }
-yaak-sync = { workspace = true }
-yaak-templates = { workspace = true }
-yaak-ws = { path = "yaak-ws" }
-
-[workspace.dependencies]
-reqwest = "0.12.15"
-serde = "1.0.219"
-serde_json = "1.0.140"
-tauri = "2.4.1"
-tauri-plugin = "2.1.1"
-tauri-plugin-shell = "2.2.1"
-tokio = "1.44.2"
-thiserror = "2.0.12"
-ts-rs = "10.1.0"
-yaak-common = { path = "yaak-common" }
-yaak-http = { path = "yaak-http" }
-yaak-models = { path = "yaak-models" }
-yaak-plugins = { path = "yaak-plugins" }
-yaak-sse = { path = "yaak-sse" }
 yaak-sync = { path = "yaak-sync" }
 yaak-templates = { path = "yaak-templates" }
-yaak-crypto = { path = "yaak-crypto" }
+encoding_rs = "0.8.35"
+
+[workspace.dependencies]
+yaak-models = { path = "yaak-models" }
+yaak-sse = { path = "yaak-sse" }
+yaak-plugins = { path = "yaak-plugins" }
+serde = "1.0.215"
+serde_json = "1.0.132"
+tauri-plugin-shell = "2.2.0"
+tauri = "2.2.0"
+thiserror = "2.0.3"
+ts-rs = "10.0.0"
+reqwest = "0.12.12"

src-tauri/bindings/analytics.ts

@@ -0,0 +1,5 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+export type AnalyticsAction = "cancel" | "click" | "commit" | "create" | "delete" | "delete_many" | "duplicate" | "error" | "export" | "hide" | "import" | "launch" | "launch_first" | "launch_update" | "send" | "show" | "toggle" | "update" | "upsert";
+
+export type AnalyticsResource = "app" | "appearance" | "button" | "checkbox" | "cookie_jar" | "dialog" | "environment" | "folder" | "grpc_connection" | "grpc_event" | "grpc_request" | "http_request" | "http_response" | "key_value" | "link" | "mutation" | "plugin" | "select" | "setting" | "sidebar" | "tab" | "theme" | "workspace";

src-tauri/capabilities/capabilities.json

@@ -7,7 +7,6 @@
     "*"
   ],
   "permissions": [
-    "core:app:allow-identifier",
     "core:event:allow-emit",
     "core:event:allow-listen",
     "core:event:allow-unlisten",
@@ -31,8 +30,10 @@
         }
       ]
     },
-    "clipboard-manager:allow-read-text",
-    "clipboard-manager:allow-write-text",
+    "opener:allow-open-url",
+    "opener:allow-open-path",
+    "opener:allow-default-urls",
+    "opener:allow-reveal-item-in-dir",
     "core:webview:allow-set-webview-zoom",
     "core:window:allow-close",
     "core:window:allow-internal-toggle-maximize",
@@ -46,17 +47,9 @@
     "core:window:allow-start-dragging",
     "core:window:allow-theme",
     "core:window:allow-unmaximize",
-    "opener:allow-default-urls",
-    "opener:allow-open-path",
-    "opener:allow-open-url",
-    "opener:allow-reveal-item-in-dir",
-    "shell:allow-open",
-    "yaak-crypto:default",
-    "yaak-git:default",
+    "clipboard-manager:allow-read-text",
+    "clipboard-manager:allow-write-text",
     "yaak-license:default",
-    "yaak-mac-window:default",
-    "yaak-models:default",
-    "yaak-sync:default",
-    "yaak-ws:default"
+    "yaak-sync:default"
   ]
 }

src-tauri/gen/schemas/capabilities.json

@@ -0,0 +1 @@
+{"main":{"identifier":"main","description":"Main permissions","local":true,"windows":["*"],"permissions":["core:event:allow-emit","core:event:allow-listen","core:event:allow-unlisten","os:allow-os-type","clipboard-manager:allow-clear","clipboard-manager:allow-write-text","clipboard-manager:allow-read-text","dialog:allow-open","dialog:allow-save","fs:allow-read-dir","fs:allow-read-file","fs:allow-read-text-file",{"identifier":"fs:scope","allow":[{"path":"$APPDATA"},{"path":"$APPDATA/**"}]},"opener:allow-open-url","opener:allow-open-path","opener:allow-default-urls","opener:allow-reveal-item-in-dir","core:webview:allow-set-webview-zoom","core:window:allow-close","core:window:allow-internal-toggle-maximize","core:window:allow-is-fullscreen","core:window:allow-is-maximized","core:window:allow-maximize","core:window:allow-minimize","core:window:allow-set-decorations","core:window:allow-set-title","core:window:allow-show","core:window:allow-start-dragging","core:window:allow-theme","core:window:allow-unmaximize","clipboard-manager:allow-read-text","clipboard-manager:allow-write-text","yaak-license:default","yaak-sync:default"]}}

src-tauri/migrations/20250114160022_remove-workspace-sync-setting.sql

@@ -1,2 +0,0 @@
--- This setting was moved to the new workspace_metas table
-ALTER TABLE workspaces DROP COLUMN setting_sync_dir;

src-tauri/migrations/20250123192023_plugin-kv.sql

@@ -1,11 +0,0 @@
-CREATE TABLE plugin_key_values
-(
-    model       TEXT     DEFAULT 'plugin_key_value' NOT NULL,
-    created_at  DATETIME DEFAULT CURRENT_TIMESTAMP  NOT NULL,
-    updated_at  DATETIME DEFAULT CURRENT_TIMESTAMP  NOT NULL,
-    deleted_at  DATETIME,
-    plugin_name TEXT                                NOT NULL,
-    key         TEXT                                NOT NULL,
-    value       TEXT                                NOT NULL,
-    PRIMARY KEY (plugin_name, key)
-);

src-tauri/migrations/20250128155623_websockets.sql

@@ -1,66 +0,0 @@
-CREATE TABLE websocket_requests
-(
-    id                  TEXT                                 NOT NULL
-        PRIMARY KEY,
-    model               TEXT     DEFAULT 'websocket_request' NOT NULL,
-    workspace_id        TEXT                                 NOT NULL
-        REFERENCES workspaces
-            ON DELETE CASCADE,
-    folder_id           TEXT
-        REFERENCES folders
-            ON DELETE CASCADE,
-    created_at          DATETIME DEFAULT CURRENT_TIMESTAMP   NOT NULL,
-    updated_at          DATETIME DEFAULT CURRENT_TIMESTAMP   NOT NULL,
-    deleted_at          DATETIME,
-    authentication      TEXT     DEFAULT '{}'                NOT NULL,
-    authentication_type TEXT,
-    description         TEXT                                 NOT NULL,
-    name                TEXT                                 NOT NULL,
-    url                 TEXT                                 NOT NULL,
-    headers             TEXT                                 NOT NULL,
-    message             TEXT                                 NOT NULL,
-    sort_priority       REAL                                 NOT NULL,
-    url_parameters      TEXT     DEFAULT '[]'                NOT NULL
-);
-
-CREATE TABLE websocket_connections
-(
-    id           TEXT                                    NOT NULL
-        PRIMARY KEY,
-    model        TEXT     DEFAULT 'websocket_connection' NOT NULL,
-    workspace_id TEXT                                    NOT NULL
-        REFERENCES workspaces
-            ON DELETE CASCADE,
-    request_id   TEXT                                    NOT NULL
-        REFERENCES websocket_requests
-            ON DELETE CASCADE,
-    created_at   DATETIME DEFAULT CURRENT_TIMESTAMP      NOT NULL,
-    updated_at   DATETIME DEFAULT CURRENT_TIMESTAMP      NOT NULL,
-    url          TEXT                                    NOT NULL,
-    state        TEXT                                    NOT NULL,
-    status       INTEGER  DEFAULT -1                     NOT NULL,
-    error        TEXT                                    NULL,
-    elapsed      INTEGER  DEFAULT 0                      NOT NULL,
-    headers      TEXT     DEFAULT '{}'                   NOT NULL
-);
-
-CREATE TABLE websocket_events
-(
-    id            TEXT                                                    NOT NULL
-        PRIMARY KEY,
-    model         TEXT     DEFAULT 'websocket_event'                      NOT NULL,
-    workspace_id  TEXT                                                    NOT NULL
-        REFERENCES workspaces
-            ON DELETE CASCADE,
-    request_id    TEXT                                                    NOT NULL
-        REFERENCES websocket_requests
-            ON DELETE CASCADE,
-    connection_id TEXT                                                    NOT NULL
-        REFERENCES websocket_connections
-            ON DELETE CASCADE,
-    created_at    DATETIME DEFAULT (STRFTIME('%Y-%m-%d %H:%M:%f', 'NOW')) NOT NULL,
-    updated_at    DATETIME DEFAULT (STRFTIME('%Y-%m-%d %H:%M:%f', 'NOW')) NOT NULL,
-    is_server     BOOLEAN                                                 NOT NULL,
-    message_type  TEXT                                                    NOT NULL,
-    message       BLOB                                                    NOT NULL
-);

src-tauri/migrations/20250302041707_hide-window-controls.sql

@@ -1,2 +0,0 @@
-ALTER TABLE settings
-    ADD COLUMN hide_window_controls BOOLEAN DEFAULT FALSE NOT NULL;

src-tauri/migrations/20250326193143_key-value-id.sql

@@ -1,43 +0,0 @@
--- 1. Create the new table with `id` as the primary key
-CREATE TABLE key_values_new
-(
-    id         TEXT PRIMARY KEY,
-    model      TEXT     DEFAULT 'key_value'       NOT NULL,
-    created_at DATETIME DEFAULT CURRENT_TIMESTAMP NOT NULL,
-    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP NOT NULL,
-    deleted_at DATETIME,
-    namespace  TEXT                               NOT NULL,
-    key        TEXT                               NOT NULL,
-    value      TEXT                               NOT NULL
-);
-
--- 2. Copy data from the old table
-INSERT INTO key_values_new (id, model, created_at, updated_at, deleted_at, namespace, key, value)
-SELECT (
-           -- This is the best way to generate a random string in SQLite, apparently
-           'kv_' || SUBSTR('abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23457789', (ABS(RANDOM()) % 57) + 1, 1) ||
-           SUBSTR('abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23457789', (ABS(RANDOM()) % 57) + 1, 1) ||
-           SUBSTR('abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23457789', (ABS(RANDOM()) % 57) + 1, 1) ||
-           SUBSTR('abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23457789', (ABS(RANDOM()) % 57) + 1, 1) ||
-           SUBSTR('abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23457789', (ABS(RANDOM()) % 57) + 1, 1) ||
-           SUBSTR('abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23457789', (ABS(RANDOM()) % 57) + 1, 1) ||
-           SUBSTR('abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23457789', (ABS(RANDOM()) % 57) + 1, 1) ||
-           SUBSTR('abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23457789', (ABS(RANDOM()) % 57) + 1, 1) ||
-           SUBSTR('abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23457789', (ABS(RANDOM()) % 57) + 1, 1) ||
-           SUBSTR('abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23457789', (ABS(RANDOM()) % 57) + 1, 1)
-           ) AS id,
-       model,
-       created_at,
-       updated_at,
-       deleted_at,
-       namespace,
-       key,
-       value
-FROM key_values;
-
--- 3. Drop the old table
-DROP TABLE key_values;
-
--- 4. Rename the new table
-ALTER TABLE key_values_new
-    RENAME TO key_values;

src-tauri/migrations/20250401122407_encrypted-key.sql

@@ -1 +0,0 @@
-ALTER TABLE workspace_metas ADD COLUMN encryption_key TEXT NULL DEFAULT NULL;

src-tauri/migrations/20250402144842_encryption-key-challenge.sql

@@ -1 +0,0 @@
-ALTER TABLE workspaces ADD COLUMN encryption_key_challenge TEXT NULL;

src-tauri/migrations/20250424152740_remove-fks.sql

@@ -1,245 +0,0 @@
--- NOTE: SQLite does not support dropping foreign keys, so we need to create new
--- tables and copy data instead. To prevent cascade deletes from wrecking stuff,
--- we start with the leaf tables and finish with the parent tables (eg. folder).
-
-----------------------------
--- Remove http request FK --
-----------------------------
-
-CREATE TABLE http_requests_dg_tmp
-(
-    id                  TEXT                               NOT NULL
-        PRIMARY KEY,
-    model               TEXT     DEFAULT 'http_request'    NOT NULL,
-    workspace_id        TEXT                               NOT NULL
-        REFERENCES workspaces
-            ON DELETE CASCADE,
-    created_at          DATETIME DEFAULT CURRENT_TIMESTAMP NOT NULL,
-    updated_at          DATETIME DEFAULT CURRENT_TIMESTAMP NOT NULL,
-    deleted_at          DATETIME,
-    name                TEXT                               NOT NULL,
-    url                 TEXT                               NOT NULL,
-    method              TEXT                               NOT NULL,
-    headers             TEXT                               NOT NULL,
-    body_type           TEXT,
-    sort_priority       REAL     DEFAULT 0                 NOT NULL,
-    authentication      TEXT     DEFAULT '{}'              NOT NULL,
-    authentication_type TEXT,
-    folder_id           TEXT,
-    body                TEXT     DEFAULT '{}'              NOT NULL,
-    url_parameters      TEXT     DEFAULT '[]'              NOT NULL,
-    description         TEXT     DEFAULT ''                NOT NULL
-);
-
-INSERT INTO http_requests_dg_tmp(id, model, workspace_id, created_at, updated_at, deleted_at, name, url, method,
-                                 headers, body_type, sort_priority, authentication, authentication_type, folder_id,
-                                 body, url_parameters, description)
-SELECT id,
-       model,
-       workspace_id,
-       created_at,
-       updated_at,
-       deleted_at,
-       name,
-       url,
-       method,
-       headers,
-       body_type,
-       sort_priority,
-       authentication,
-       authentication_type,
-       folder_id,
-       body,
-       url_parameters,
-       description
-FROM http_requests;
-
-DROP TABLE http_requests;
-
-ALTER TABLE http_requests_dg_tmp
-    RENAME TO http_requests;
-
-----------------------------
--- Remove grpc request FK --
-----------------------------
-
-CREATE TABLE grpc_requests_dg_tmp
-(
-    id                  TEXT                                                    NOT NULL
-        PRIMARY KEY,
-    model               TEXT     DEFAULT 'grpc_request'                         NOT NULL,
-    workspace_id        TEXT                                                    NOT NULL
-        REFERENCES workspaces
-            ON DELETE CASCADE,
-    folder_id           TEXT,
-    created_at          DATETIME DEFAULT (STRFTIME('%Y-%m-%d %H:%M:%f', 'NOW')) NOT NULL,
-    updated_at          DATETIME DEFAULT (STRFTIME('%Y-%m-%d %H:%M:%f', 'NOW')) NOT NULL,
-    name                TEXT                                                    NOT NULL,
-    sort_priority       REAL                                                    NOT NULL,
-    url                 TEXT                                                    NOT NULL,
-    service             TEXT,
-    method              TEXT,
-    message             TEXT                                                    NOT NULL,
-    authentication      TEXT     DEFAULT '{}'                                   NOT NULL,
-    authentication_type TEXT,
-    metadata            TEXT     DEFAULT '[]'                                   NOT NULL,
-    description         TEXT     DEFAULT ''                                     NOT NULL
-);
-
-INSERT INTO grpc_requests_dg_tmp(id, model, workspace_id, folder_id, created_at, updated_at, name, sort_priority, url,
-                                 service, method, message, authentication, authentication_type, metadata, description)
-SELECT id,
-       model,
-       workspace_id,
-       folder_id,
-       created_at,
-       updated_at,
-       name,
-       sort_priority,
-       url,
-       service,
-       method,
-       message,
-       authentication,
-       authentication_type,
-       metadata,
-       description
-FROM grpc_requests;
-
-DROP TABLE grpc_requests;
-
-ALTER TABLE grpc_requests_dg_tmp
-    RENAME TO grpc_requests;
-
----------------------------------
--- Remove websocket request FK --
----------------------------------
-
-CREATE TABLE websocket_requests_dg_tmp
-(
-    id                  TEXT                                 NOT NULL
-        PRIMARY KEY,
-    model               TEXT     DEFAULT 'websocket_request' NOT NULL,
-    workspace_id        TEXT                                 NOT NULL
-        REFERENCES workspaces
-            ON DELETE CASCADE,
-    folder_id           TEXT,
-    created_at          DATETIME DEFAULT CURRENT_TIMESTAMP   NOT NULL,
-    updated_at          DATETIME DEFAULT CURRENT_TIMESTAMP   NOT NULL,
-    deleted_at          DATETIME,
-    authentication      TEXT     DEFAULT '{}'                NOT NULL,
-    authentication_type TEXT,
-    description         TEXT                                 NOT NULL,
-    name                TEXT                                 NOT NULL,
-    url                 TEXT                                 NOT NULL,
-    headers             TEXT                                 NOT NULL,
-    message             TEXT                                 NOT NULL,
-    sort_priority       REAL                                 NOT NULL,
-    url_parameters      TEXT     DEFAULT '[]'                NOT NULL
-);
-
-INSERT INTO websocket_requests_dg_tmp(id, model, workspace_id, folder_id, created_at, updated_at, deleted_at,
-                                      authentication, authentication_type, description, name, url, headers, message,
-                                      sort_priority, url_parameters)
-SELECT id,
-       model,
-       workspace_id,
-       folder_id,
-       created_at,
-       updated_at,
-       deleted_at,
-       authentication,
-       authentication_type,
-       description,
-       name,
-       url,
-       headers,
-       message,
-       sort_priority,
-       url_parameters
-FROM websocket_requests;
-
-DROP TABLE websocket_requests;
-
-ALTER TABLE websocket_requests_dg_tmp
-    RENAME TO websocket_requests;
-
-PRAGMA foreign_keys = ON;
-
----------------------------
--- Remove environment FK --
----------------------------
-
-CREATE TABLE environments_dg_tmp
-(
-    id             TEXT                               NOT NULL
-        PRIMARY KEY,
-    created_at     DATETIME DEFAULT CURRENT_TIMESTAMP NOT NULL,
-    updated_at     DATETIME DEFAULT CURRENT_TIMESTAMP NOT NULL,
-    deleted_at     DATETIME,
-    workspace_id   TEXT                               NOT NULL
-        REFERENCES workspaces
-            ON DELETE CASCADE,
-    name           TEXT                               NOT NULL,
-    variables               DEFAULT '[]'              NOT NULL,
-    model          TEXT     DEFAULT 'environment',
-    environment_id TEXT
-);
-
-INSERT INTO environments_dg_tmp(id, created_at, updated_at, deleted_at, workspace_id, name, variables, model,
-                                environment_id)
-SELECT id,
-       created_at,
-       updated_at,
-       deleted_at,
-       workspace_id,
-       name,
-       variables,
-       model,
-       environment_id
-FROM environments;
-
-DROP TABLE environments;
-
-ALTER TABLE environments_dg_tmp
-    RENAME TO environments;
-
-----------------------
--- Remove folder FK --
-----------------------
-
-CREATE TABLE folders_dg_tmp
-(
-    id            TEXT                               NOT NULL
-        PRIMARY KEY,
-    model         TEXT     DEFAULT 'folder'          NOT NULL,
-    created_at    DATETIME DEFAULT CURRENT_TIMESTAMP NOT NULL,
-    updated_at    DATETIME DEFAULT CURRENT_TIMESTAMP NOT NULL,
-    deleted_at    DATETIME,
-    workspace_id  TEXT                               NOT NULL
-        REFERENCES workspaces
-            ON DELETE CASCADE,
-    folder_id     TEXT,
-    name          TEXT                               NOT NULL,
-    sort_priority REAL     DEFAULT 0                 NOT NULL,
-    description   TEXT     DEFAULT ''                NOT NULL
-);
-
-INSERT INTO folders_dg_tmp(id, model, created_at, updated_at, deleted_at, workspace_id, folder_id, name, sort_priority,
-                           description)
-SELECT id,
-       model,
-       created_at,
-       updated_at,
-       deleted_at,
-       workspace_id,
-       folder_id,
-       name,
-       sort_priority,
-       description
-FROM folders;
-
-DROP TABLE folders;
-
-ALTER TABLE folders_dg_tmp
-    RENAME TO folders;

src-tauri/migrations/20250507140702_remove-ev-sync-states.sql

@@ -1,11 +0,0 @@
--- There used to be sync code that skipped over environments because we didn't
--- want to sync potentially insecure data. With encryption, it is now possible
--- to sync environments securely. However, there were already sync states in the
--- DB that marked environments as "Synced". Running the sync code on these envs
--- would mark them as deleted by FS (exist in SyncState but not on FS).
---
--- To undo this mess, we have this migration to delete all environment-related
--- sync states so we can sync from a clean slate.
-DELETE
-FROM sync_states
-WHERE model_id LIKE 'ev_%';

src-tauri/migrations/20250508161145_public-environments.sql

@@ -1,20 +0,0 @@
--- Add a public column to represent whether an environment can be shared or exported
-ALTER TABLE environments
-    ADD COLUMN public BOOLEAN DEFAULT FALSE;
-
--- Add a base column to represent whether an environment is a base or sub environment. We used to
--- do this with environment_id, but we need a more flexible solution now that envs can be optionally
--- synced. E.g., it's now possible to only import a sub environment from a different client without
--- its base environment "parent."
-ALTER TABLE environments
-    ADD COLUMN base BOOLEAN DEFAULT FALSE;
-
--- SQLite doesn't support dynamic default values, so we update `base` based on the value of
--- environment_id.
-UPDATE environments
-SET base = TRUE
-WHERE environment_id IS NULL;
-
--- Finally, we drop the old `environment_id` column that will no longer be used
-ALTER TABLE environments
-    DROP COLUMN environment_id;

src-tauri/migrations/20250516182745_default-attrs.sql

@@ -1,15 +0,0 @@
--- Auth
-ALTER TABLE workspaces
-    ADD COLUMN authentication TEXT NOT NULL DEFAULT '{}';
-ALTER TABLE folders
-    ADD COLUMN authentication TEXT NOT NULL DEFAULT '{}';
-ALTER TABLE workspaces
-    ADD COLUMN authentication_type TEXT;
-ALTER TABLE folders
-    ADD COLUMN authentication_type TEXT;
-
--- Headers
-ALTER TABLE workspaces
-    ADD COLUMN headers TEXT NOT NULL DEFAULT '[]';
-ALTER TABLE folders
-    ADD COLUMN headers TEXT NOT NULL DEFAULT '[]';

src-tauri/src/analytics.rs

@@ -0,0 +1,243 @@
+use std::fmt::Display;
+
+use log::{debug, info};
+use serde::{Deserialize, Serialize};
+use serde_json::{json, Value};
+use tauri::{Manager, Runtime, WebviewWindow};
+use ts_rs::TS;
+use yaak_models::queries::{
+    generate_id, get_key_value_int, get_key_value_string, get_or_create_settings,
+    set_key_value_int, set_key_value_string, UpdateSource,
+};
+
+use crate::is_dev;
+
+const NAMESPACE: &str = "analytics";
+const NUM_LAUNCHES_KEY: &str = "num_launches";
+
+// serializable
+#[derive(Serialize, Deserialize, Debug, TS)]
+#[serde(rename_all = "snake_case")]
+#[ts(export, export_to = "analytics.ts")]
+pub enum AnalyticsResource {
+    App,
+    Appearance,
+    Button,
+    Checkbox,
+    CookieJar,
+    Dialog,
+    Environment,
+    Folder,
+    GrpcConnection,
+    GrpcEvent,
+    GrpcRequest,
+    HttpRequest,
+    HttpResponse,
+    KeyValue,
+    Link,
+    Mutation,
+    Plugin,
+    Select,
+    Setting,
+    Sidebar,
+    Tab,
+    Theme,
+    Workspace,
+}
+
+impl AnalyticsResource {
+    pub fn from_str(s: &str) -> serde_json::Result<AnalyticsResource> {
+        serde_json::from_str(format!("\"{s}\"").as_str())
+    }
+}
+
+impl Display for AnalyticsResource {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", serde_json::to_string(self).unwrap().replace("\"", ""))
+    }
+}
+
+#[derive(Serialize, Deserialize, Debug, TS)]
+#[serde(rename_all = "snake_case")]
+#[ts(export, export_to = "analytics.ts")]
+pub enum AnalyticsAction {
+    Cancel,
+    Click,
+    Commit,
+    Create,
+    Delete,
+    DeleteMany,
+    Duplicate,
+    Error,
+    Export,
+    Hide,
+    Import,
+    Launch,
+    LaunchFirst,
+    LaunchUpdate,
+    Send,
+    Show,
+    Toggle,
+    Update,
+    Upsert,
+}
+
+impl AnalyticsAction {
+    pub fn from_str(s: &str) -> serde_json::Result<AnalyticsAction> {
+        serde_json::from_str(format!("\"{s}\"").as_str())
+    }
+}
+
+impl Display for AnalyticsAction {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", serde_json::to_string(self).unwrap().replace("\"", ""))
+    }
+}
+
+#[derive(Default, Debug)]
+pub struct LaunchEventInfo {
+    pub current_version: String,
+    pub previous_version: String,
+    pub launched_after_update: bool,
+    pub num_launches: i32,
+}
+
+pub async fn track_launch_event<R: Runtime>(w: &WebviewWindow<R>) -> LaunchEventInfo {
+    let last_tracked_version_key = "last_tracked_version";
+
+    let mut info = LaunchEventInfo::default();
+
+    info.num_launches = get_num_launches(w).await + 1;
+    info.previous_version = get_key_value_string(w, NAMESPACE, last_tracked_version_key, "").await;
+    info.current_version = w.package_info().version.to_string();
+
+    if info.previous_version.is_empty() {
+        track_event(w, AnalyticsResource::App, AnalyticsAction::LaunchFirst, None).await;
+    } else {
+        info.launched_after_update = info.current_version != info.previous_version;
+        if info.launched_after_update {
+            track_event(
+                w,
+                AnalyticsResource::App,
+                AnalyticsAction::LaunchUpdate,
+                Some(json!({ NUM_LAUNCHES_KEY: info.num_launches })),
+            )
+            .await;
+        }
+    };
+
+    // Track a launch event in all cases
+    track_event(
+        w,
+        AnalyticsResource::App,
+        AnalyticsAction::Launch,
+        Some(json!({ NUM_LAUNCHES_KEY: info.num_launches })),
+    )
+    .await;
+
+    // Update key values
+
+    set_key_value_string(
+        w,
+        NAMESPACE,
+        last_tracked_version_key,
+        info.current_version.as_str(),
+        &UpdateSource::Background,
+    )
+    .await;
+    set_key_value_int(w, NAMESPACE, NUM_LAUNCHES_KEY, info.num_launches, &UpdateSource::Background)
+        .await;
+
+    info
+}
+
+pub async fn track_event<R: Runtime>(
+    w: &WebviewWindow<R>,
+    resource: AnalyticsResource,
+    action: AnalyticsAction,
+    attributes: Option<Value>,
+) {
+    let id = get_id(w).await;
+    let event = format!("{}.{}", resource, action);
+    let attributes_json = attributes.unwrap_or("{}".to_string().into()).to_string();
+    let info = w.app_handle().package_info();
+    let tz = datetime::sys_timezone().unwrap_or("unknown".to_string());
+    let site = match is_dev() {
+        true => "site_TkHWjoXwZPq3HfhERb",
+        false => "site_zOK0d7jeBy2TLxFCnZ",
+    };
+    let base_url = match is_dev() {
+        true => "http://localhost:7194",
+        false => "https://t.yaak.app",
+    };
+    let params = vec![
+        ("u", id),
+        ("e", event.clone()),
+        ("a", attributes_json.clone()),
+        ("id", site.to_string()),
+        ("v", info.version.clone().to_string()),
+        ("os", get_os().to_string()),
+        ("tz", tz),
+        ("xy", get_window_size(w)),
+    ];
+    let req =
+        reqwest::Client::builder().build().unwrap().get(format!("{base_url}/t/e")).query(&params);
+
+    let settings = get_or_create_settings(w).await;
+    if !settings.telemetry {
+        info!("Track event (disabled): {}", event);
+        return;
+    }
+
+    // Disable analytics actual sending in dev
+    if is_dev() {
+        debug!("Track event: {} {}", event, attributes_json);
+        return;
+    }
+
+    if let Err(e) = req.send().await {
+        info!("Error sending analytics event: {}", e);
+    }
+}
+
+fn get_os() -> &'static str {
+    if cfg!(target_os = "windows") {
+        "windows"
+    } else if cfg!(target_os = "macos") {
+        "macos"
+    } else if cfg!(target_os = "linux") {
+        "linux"
+    } else {
+        "unknown"
+    }
+}
+
+fn get_window_size<R: Runtime>(w: &WebviewWindow<R>) -> String {
+    let current_monitor = match w.current_monitor() {
+        Ok(Some(m)) => m,
+        _ => return "unknown".to_string(),
+    };
+
+    let scale_factor = current_monitor.scale_factor();
+    let size = current_monitor.size();
+    let width: f64 = size.width as f64 / scale_factor;
+    let height: f64 = size.height as f64 / scale_factor;
+
+    format!("{}x{}", (width / 100.0).round() * 100.0, (height / 100.0).round() * 100.0)
+}
+
+async fn get_id<R: Runtime>(w: &WebviewWindow<R>) -> String {
+    let id = get_key_value_string(w, "analytics", "id", "").await;
+    if id.is_empty() {
+        let new_id = generate_id();
+        set_key_value_string(w, "analytics", "id", new_id.as_str(), &UpdateSource::Background)
+            .await;
+        new_id
+    } else {
+        id
+    }
+}
+
+pub async fn get_num_launches<R: Runtime>(w: &WebviewWindow<R>) -> i32 {
+    get_key_value_int(w, NAMESPACE, NUM_LAUNCHES_KEY, 0).await
+}

src-tauri/src/commands.rs

@@ -1,40 +0,0 @@
-use crate::error::Result;
-use tauri::{command, AppHandle, Manager, Runtime, WebviewWindow};
-use tauri_plugin_dialog::{DialogExt, MessageDialogKind};
-use yaak_crypto::manager::EncryptionManagerExt;
-use yaak_plugins::events::PluginWindowContext;
-use yaak_plugins::native_template_functions::{decrypt_secure_template_function, encrypt_secure_template_function};
-
-#[command]
-pub(crate) async fn cmd_show_workspace_key<R: Runtime>(
-    window: WebviewWindow<R>,
-    workspace_id: &str,
-) -> Result<()> {
-    let key = window.crypto().reveal_workspace_key(workspace_id)?;
-    window
-        .dialog()
-        .message(format!("Your workspace key is \n\n{}", key))
-        .kind(MessageDialogKind::Info)
-        .show(|_v| {});
-    Ok(())
-}
-
-#[command]
-pub(crate) async fn cmd_decrypt_template<R: Runtime>(
-    window: WebviewWindow<R>,
-    template: &str,
-) -> Result<String> {
-    let app_handle = window.app_handle();
-    let window_context = &PluginWindowContext::new(&window);
-    Ok(decrypt_secure_template_function(&app_handle, window_context, template)?)
-}
-
-#[command]
-pub(crate) async fn cmd_secure_template<R: Runtime>(
-    app_handle: AppHandle<R>,
-    window: WebviewWindow<R>,
-    template: &str,
-) -> Result<String> {
-    let window_context = &PluginWindowContext::new(&window);
-    Ok(encrypt_secure_template_function(&app_handle, window_context, template)?)
-}

src-tauri/src/error.rs

@@ -1,62 +0,0 @@
-use std::io;
-use serde::{Serialize, Serializer};
-use thiserror::Error;
-
-#[derive(Error, Debug)]
-pub enum Error {
-    #[error(transparent)]
-    TemplateError(#[from] yaak_templates::error::Error),
-
-    #[error(transparent)]
-    ModelError(#[from] yaak_models::error::Error),
-
-    #[error(transparent)]
-    SyncError(#[from] yaak_sync::error::Error),
-    
-    #[error(transparent)]
-    CryptoError(#[from] yaak_crypto::error::Error),
-
-    #[error(transparent)]
-    GitError(#[from] yaak_git::error::Error),
-
-    #[error(transparent)]
-    WebsocketError(#[from] yaak_ws::error::Error),
-
-    #[error(transparent)]
-    LicenseError(#[from] yaak_license::error::Error),
-
-    #[error(transparent)]
-    PluginError(#[from] yaak_plugins::error::Error),
-
-    #[error("Updater error: {0}")]
-    UpdaterError(#[from] tauri_plugin_updater::Error),
-    
-    #[error("JSON error: {0}")]
-    JsonError(#[from] serde_json::error::Error),
-    
-    #[error("Tauri error: {0}")]
-    TauriError(#[from] tauri::Error),
-    
-    #[error("Event source error: {0}")]
-    EventSourceError(#[from] eventsource_client::Error),
-    
-    #[error("I/O error: {0}")]
-    IOError(#[from] io::Error),
-
-    #[error("Request error: {0}")]
-    RequestError(#[from] reqwest::Error),
-
-    #[error("Generic error: {0}")]
-    GenericError(String),
-}
-
-impl Serialize for Error {
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        serializer.serialize_str(self.to_string().as_ref())
-    }
-}
-
-pub type Result<T> = std::result::Result<T, Error>;

src-tauri/src/grpc.rs

@@ -1,15 +1,10 @@
 use std::collections::BTreeMap;
 
-use crate::error::Result;
-use tauri::{Manager, Runtime, WebviewWindow};
-use yaak_grpc::{KeyAndValueRef, MetadataMap};
-use yaak_models::models::GrpcRequest;
-use yaak_models::query_manager::QueryManagerExt;
-use yaak_plugins::events::{CallHttpAuthenticationRequest, HttpHeader};
-use yaak_plugins::manager::PluginManager;
 use KeyAndValueRef::{Ascii, Binary};
 
-pub(crate) fn metadata_to_map(metadata: MetadataMap) -> BTreeMap<String, String> {
+use yaak_grpc::{KeyAndValueRef, MetadataMap};
+
+pub fn metadata_to_map(metadata: MetadataMap) -> BTreeMap<String, String> {
     let mut entries = BTreeMap::new();
     for r in metadata.iter() {
         match r {
@@ -19,74 +14,3 @@ pub(crate) fn metadata_to_map(metadata: MetadataMap) -> BTreeMap<String, String>
     }
     entries
 }
-
-pub(crate) fn resolve_grpc_request<R: Runtime>(
-    window: &WebviewWindow<R>,
-    request: &GrpcRequest,
-) -> Result<GrpcRequest> {
-    let mut new_request = request.clone();
-
-    let (authentication_type, authentication) =
-        window.db().resolve_auth_for_grpc_request(request)?;
-    new_request.authentication_type = authentication_type;
-    new_request.authentication = authentication;
-
-    let metadata = window.db().resolve_metadata_for_grpc_request(request)?;
-    new_request.metadata = metadata;
-
-    Ok(new_request)
-}
-
-pub(crate) async fn build_metadata<R: Runtime>(
-    window: &WebviewWindow<R>,
-    request: &GrpcRequest,
-) -> Result<BTreeMap<String, String>> {
-    let plugin_manager = window.state::<PluginManager>();
-    let mut metadata = BTreeMap::new();
-
-    // Add the rest of metadata
-    for h in request.metadata.clone() {
-        if h.name.is_empty() && h.value.is_empty() {
-            continue;
-        }
-
-        if !h.enabled {
-            continue;
-        }
-
-        metadata.insert(h.name, h.value);
-    }
-
-    match request.authentication_type.clone() {
-        None => {
-            // No authentication found. Not even inherited
-        }
-        Some(authentication_type) if authentication_type == "none" => {
-            // Explicitly no authentication
-        }
-        Some(authentication_type) => {
-            let auth = request.authentication.clone();
-            let plugin_req = CallHttpAuthenticationRequest {
-                context_id: format!("{:x}", md5::compute(request.id.clone())),
-                values: serde_json::from_value(serde_json::to_value(&auth).unwrap()).unwrap(),
-                method: "POST".to_string(),
-                url: request.url.clone(),
-                headers: metadata
-                    .iter()
-                    .map(|(name, value)| HttpHeader {
-                        name: name.to_string(),
-                        value: value.to_string(),
-                    })
-                    .collect(),
-            };
-            let plugin_result = plugin_manager
-                .call_http_authentication(&window, &authentication_type, plugin_req)
-                .await?;
-            for header in plugin_result.set_headers {
-                metadata.insert(header.name, header.value);
-            }
-        }
-    }
-
-    Ok(metadata)
-}

src-tauri/src/history.rs

@@ -1,60 +0,0 @@
-use tauri::{AppHandle, Runtime};
-use yaak_models::query_manager::QueryManagerExt;
-use yaak_models::util::UpdateSource;
-
-const NAMESPACE: &str = "analytics";
-const NUM_LAUNCHES_KEY: &str = "num_launches";
-
-#[derive(Default, Debug)]
-pub struct LaunchEventInfo {
-    pub current_version: String,
-    pub previous_version: String,
-    pub launched_after_update: bool,
-    pub num_launches: i32,
-}
-
-pub async fn store_launch_history<R: Runtime>(app_handle: &AppHandle<R>) -> LaunchEventInfo {
-    let last_tracked_version_key = "last_tracked_version";
-
-    let mut info = LaunchEventInfo::default();
-
-    info.num_launches = get_num_launches(app_handle).await + 1;
-    info.current_version = app_handle.package_info().version.to_string();
-
-    app_handle
-        .with_tx(|tx| {
-            info.previous_version =
-                tx.get_key_value_string(NAMESPACE, last_tracked_version_key, "");
-
-            if !info.previous_version.is_empty() {
-                info.launched_after_update = info.current_version != info.previous_version;
-            };
-
-            // Update key values
-
-            let source = &UpdateSource::Background;
-            let version = info.current_version.as_str();
-            tx.set_key_value_string(NAMESPACE, last_tracked_version_key, version, source);
-            tx.set_key_value_int(NAMESPACE, NUM_LAUNCHES_KEY, info.num_launches, source);
-            Ok(())
-        })
-        .unwrap();
-
-    info
-}
-
-pub fn get_os() -> &'static str {
-    if cfg!(target_os = "windows") {
-        "windows"
-    } else if cfg!(target_os = "macos") {
-        "macos"
-    } else if cfg!(target_os = "linux") {
-        "linux"
-    } else {
-        "unknown"
-    }
-}
-
-pub async fn get_num_launches<R: Runtime>(app_handle: &AppHandle<R>) -> i32 {
-    app_handle.db().get_key_value_int(NAMESPACE, NUM_LAUNCHES_KEY, 0)
-}

src-tauri/src/http_request.rs

@@ -1,17 +1,15 @@
-use crate::error::Error::GenericError;
-use crate::error::Result;
 use crate::render::render_http_request;
 use crate::response_err;
+use crate::template_callback::PluginTemplateCallback;
 use http::header::{ACCEPT, USER_AGENT};
-use http::{HeaderMap, HeaderName, HeaderValue};
+use http::{HeaderMap, HeaderName, HeaderValue, Uri};
 use log::{debug, error, warn};
 use mime_guess::Mime;
 use reqwest::redirect::Policy;
+use reqwest::{multipart, Proxy, Url};
 use reqwest::{Method, Response};
-use reqwest::{Proxy, Url, multipart};
 use rustls::ClientConfig;
-use rustls::crypto::ring;
-use rustls_platform_verifier::BuilderVerifierExt;
+use rustls_platform_verifier::ConfigVerifierExt;
 use serde_json::Value;
 use std::collections::BTreeMap;
 use std::path::PathBuf;
@@ -20,21 +18,22 @@ use std::sync::Arc;
 use std::time::Duration;
 use tauri::{Manager, Runtime, WebviewWindow};
 use tokio::fs;
-use tokio::fs::{File, create_dir_all};
+use tokio::fs::{create_dir_all, File};
 use tokio::io::AsyncWriteExt;
 use tokio::sync::watch::Receiver;
-use tokio::sync::{Mutex, oneshot};
+use tokio::sync::{oneshot, Mutex};
 use yaak_models::models::{
     Cookie, CookieJar, Environment, HttpRequest, HttpResponse, HttpResponseHeader,
     HttpResponseState, ProxySetting, ProxySettingAuth,
 };
-use yaak_models::query_manager::QueryManagerExt;
-use yaak_models::util::UpdateSource;
+use yaak_models::queries::{
+    get_base_environment, get_http_response, get_or_create_settings, get_workspace,
+    update_response_if_id, upsert_cookie_jar, UpdateSource,
+};
 use yaak_plugins::events::{
-    CallHttpAuthenticationRequest, HttpHeader, PluginWindowContext, RenderPurpose,
+    CallHttpAuthenticationRequest, HttpHeader, RenderPurpose, WindowContext,
 };
 use yaak_plugins::manager::PluginManager;
-use yaak_plugins::template_callback::PluginTemplateCallback;
 
 pub async fn send_http_request<R: Runtime>(
     window: &WebviewWindow<R>,
@@ -43,62 +42,35 @@ pub async fn send_http_request<R: Runtime>(
     environment: Option<Environment>,
     cookie_jar: Option<CookieJar>,
     cancelled_rx: &mut Receiver<bool>,
-) -> Result<HttpResponse> {
-    let app_handle = window.app_handle().clone();
-    let plugin_manager = app_handle.state::<PluginManager>();
-    let (settings, workspace) = {
-        let db = window.db();
-        let settings = db.get_settings();
-        let workspace = db.get_workspace(&unrendered_request.workspace_id)?;
-        (settings, workspace)
-    };
-    let base_environment =
-        app_handle.db().get_base_environment(&unrendered_request.workspace_id)?;
+) -> Result<HttpResponse, String> {
+    let plugin_manager = window.state::<PluginManager>();
+    let workspace = get_workspace(window, &unrendered_request.workspace_id)
+        .await
+        .expect("Failed to get Workspace");
+    let base_environment = get_base_environment(window, &unrendered_request.workspace_id)
+        .await
+        .expect("Failed to get base environment");
+    let settings = get_or_create_settings(window).await;
+    let cb = PluginTemplateCallback::new(
+        window.app_handle(),
+        &WindowContext::from_window(window),
+        RenderPurpose::Send,
+    );
 
     let response_id = og_response.id.clone();
     let response = Arc::new(Mutex::new(og_response.clone()));
 
-    let cb = PluginTemplateCallback::new(
-        window.app_handle(),
-        &PluginWindowContext::new(window),
-        RenderPurpose::Send,
-    );
-    let update_source = UpdateSource::from_window(window);
-
-    let resolved_request = match resolve_http_request(window, unrendered_request) {
-        Ok(r) => r,
-        Err(e) => {
-            return Ok(response_err(
-                &app_handle,
-                &*response.lock().await,
-                e.to_string(),
-                &update_source,
-            ));
-        }
-    };
-
     let request =
-        match render_http_request(&resolved_request, &base_environment, environment.as_ref(), &cb)
-            .await
-        {
-            Ok(r) => r,
-            Err(e) => {
-                return Ok(response_err(
-                    &app_handle,
-                    &*response.lock().await,
-                    e.to_string(),
-                    &update_source,
-                ));
-            }
-        };
+        render_http_request(&unrendered_request, &base_environment, environment.as_ref(), &cb)
+            .await;
 
-    let mut url_string = request.url.clone();
+    let mut url_string = request.url;
 
     url_string = ensure_proto(&url_string);
     if !url_string.starts_with("http://") && !url_string.starts_with("https://") {
         url_string = format!("http://{}", url_string);
     }
-    debug!("Sending request to {} {url_string}", request.method);
+    debug!("Sending request to {url_string}");
 
     let mut client_builder = reqwest::Client::builder()
         .redirect(match workspace.setting_follow_redirects {
@@ -114,15 +86,11 @@ pub async fn send_http_request<R: Runtime>(
 
     if workspace.setting_validate_certificates {
         // Use platform-native verifier to validate certificates
-        let arc_crypto_provider = Arc::new(ring::default_provider());
-        let config = ClientConfig::builder_with_provider(arc_crypto_provider)
-            .with_safe_default_protocol_versions()
-            .unwrap()
-            .with_platform_verifier()
-            .with_no_client_auth();
-        client_builder = client_builder.use_preconfigured_tls(config)
+        client_builder =
+            client_builder.use_preconfigured_tls(ClientConfig::with_platform_verifier())
     } else {
-        // Use rustls to skip validation because rustls_platform_verifier does not have this ability
+        // Use rustls to skip validation because rustls_platform_verifier does not have this
+        // ability
         client_builder = client_builder
             .use_rustls_tls()
             .danger_accept_invalid_hostnames(true)
@@ -131,12 +99,7 @@ pub async fn send_http_request<R: Runtime>(
 
     match settings.proxy {
         Some(ProxySetting::Disabled) => client_builder = client_builder.no_proxy(),
-        Some(ProxySetting::Enabled {
-            http,
-            https,
-            auth,
-            disabled,
-        }) if !disabled => {
+        Some(ProxySetting::Enabled { http, https, auth }) => {
             debug!("Using proxy http={http} https={https}");
             let mut proxy = Proxy::custom(move |url| {
                 let http = if http.is_empty() { None } else { Some(http.to_owned()) };
@@ -156,15 +119,12 @@ pub async fn send_http_request<R: Runtime>(
 
             client_builder = client_builder.proxy(proxy);
         }
-        _ => {} // Nothing to do for this one, as it is the default
+        None => {} // Nothing to do for this one, as it is the default
     }
 
     // Add cookie store if specified
     let maybe_cookie_manager = match cookie_jar.clone() {
-        Some(CookieJar { id, .. }) => {
-            // NOTE: WE need to refetch the cookie jar because a chained request might have
-            //  updated cookies when we rendered the request.
-            let cj = window.db().get_cookie_jar(&id)?;
+        Some(cj) => {
             // HACK: Can't construct Cookie without serde, so we have to do this
             let cookies = cj
                 .cookies
@@ -174,9 +134,10 @@ pub async fn send_http_request<R: Runtime>(
                     serde_json::from_value(json_cookie).expect("Failed to deserialize cookie")
                 })
                 .map(|c| Ok(c))
-                .collect::<Vec<Result<_>>>();
+                .collect::<Vec<Result<_, ()>>>();
 
-            let store = reqwest_cookie_store::CookieStore::from_cookies(cookies, true)?;
+            let store = reqwest_cookie_store::CookieStore::from_cookies(cookies, true)
+                .expect("Failed to create cookie store");
             let cookie_store = reqwest_cookie_store::CookieStoreMutex::new(store);
             let cookie_store = Arc::new(cookie_store);
             client_builder = client_builder.cookie_provider(Arc::clone(&cookie_store));
@@ -192,7 +153,7 @@ pub async fn send_http_request<R: Runtime>(
         ));
     }
 
-    let client = client_builder.build()?;
+    let client = client_builder.build().expect("Failed to build client");
 
     // Render query parameters
     let mut query_params = Vec::new();
@@ -203,20 +164,32 @@ pub async fn send_http_request<R: Runtime>(
         query_params.push((p.name, p.value));
     }
 
-    let url = match Url::from_str(&url_string) {
+    let uri = match Uri::from_str(url_string.as_str()) {
         Ok(u) => u,
         Err(e) => {
             return Ok(response_err(
-                &app_handle,
                 &*response.lock().await,
                 format!("Failed to parse URL \"{}\": {}", url_string, e.to_string()),
-                &update_source,
-            ));
+                window,
+            )
+            .await);
+        }
+    };
+    // Yes, we're parsing both URI and URL because they could return different errors
+    let url = match Url::from_str(uri.to_string().as_str()) {
+        Ok(u) => u,
+        Err(e) => {
+            return Ok(response_err(
+                &*response.lock().await,
+                format!("Failed to parse URL \"{}\": {}", url_string, e.to_string()),
+                window,
+            )
+            .await);
         }
     };
 
-    let m = Method::from_str(&request.method.to_uppercase())
-        .map_err(|e| GenericError(e.to_string()))?;
+    let m = Method::from_bytes(request.method.to_uppercase().as_bytes())
+        .expect("Failed to create method");
     let mut request_builder = client.request(m, url).query(&query_params);
 
     let mut headers = HeaderMap::new();
@@ -247,14 +220,14 @@ pub async fn send_http_request<R: Runtime>(
             continue;
         }
 
-        let header_name = match HeaderName::from_str(&h.name) {
+        let header_name = match HeaderName::from_bytes(h.name.as_bytes()) {
             Ok(n) => n,
             Err(e) => {
                 error!("Failed to create header name: {}", e);
                 continue;
             }
         };
-        let header_value = match HeaderValue::from_str(&h.value) {
+        let header_value = match HeaderValue::from_str(h.value.as_str()) {
             Ok(n) => n,
             Err(e) => {
                 error!("Failed to create header value: {}", e);
@@ -266,7 +239,7 @@ pub async fn send_http_request<R: Runtime>(
     }
 
     let request_body = request.body.clone();
-    if let Some(body_type) = &request.body_type.clone() {
+    if let Some(body_type) = &request.body_type {
         if body_type == "graphql" {
             let query = get_str_h(&request_body, "query");
             let variables = get_str_h(&request_body, "variables");
@@ -289,7 +262,7 @@ pub async fn send_http_request<R: Runtime>(
                     None => {}
                     Some(a) => {
                         for p in a {
-                            let enabled = get_bool(p, "enabled", true);
+                            let enabled = get_bool(p, "enabled");
                             let name = get_str(p, "name");
                             if !enabled || name.is_empty() {
                                 continue;
@@ -304,7 +277,7 @@ pub async fn send_http_request<R: Runtime>(
         } else if body_type == "binary" && request_body.contains_key("filePath") {
             let file_path = request_body
                 .get("filePath")
-                .ok_or(GenericError("filePath not set".to_string()))?
+                .ok_or("filePath not set")?
                 .as_str()
                 .unwrap_or_default();
 
@@ -313,12 +286,7 @@ pub async fn send_http_request<R: Runtime>(
                     request_builder = request_builder.body(f);
                 }
                 Err(e) => {
-                    return Ok(response_err(
-                        &app_handle,
-                        &*response.lock().await,
-                        e,
-                        &update_source,
-                    ));
+                    return Ok(response_err(&*response.lock().await, e, window).await);
                 }
             }
         } else if body_type == "multipart/form-data" && request_body.contains_key("form") {
@@ -328,7 +296,7 @@ pub async fn send_http_request<R: Runtime>(
                     None => {}
                     Some(fd) => {
                         for p in fd {
-                            let enabled = get_bool(p, "enabled", true);
+                            let enabled = get_bool(p, "enabled");
                             let name = get_str(p, "name").to_string();
 
                             if !enabled || name.is_empty() {
@@ -345,11 +313,11 @@ pub async fn send_http_request<R: Runtime>(
                                     Ok(f) => multipart::Part::bytes(f),
                                     Err(e) => {
                                         return Ok(response_err(
-                                            &app_handle,
                                             &*response.lock().await,
                                             e.to_string(),
-                                            &update_source,
-                                        ));
+                                            window,
+                                        )
+                                        .await);
                                     }
                                 }
                             };
@@ -358,36 +326,17 @@ pub async fn send_http_request<R: Runtime>(
 
                             // Set or guess mimetype
                             if !content_type.is_empty() {
-                                part = match part.mime_str(content_type) {
-                                    Ok(p) => p,
-                                    Err(e) => {
-                                        return Ok(response_err(
-                                            &app_handle,
-                                            &*response.lock().await,
-                                            format!("Invalid mime for multi-part entry {e:?}"),
-                                            &update_source,
-                                        ));
-                                    }
-                                };
+                                part = part.mime_str(content_type).map_err(|e| e.to_string())?;
                             } else if !file_path.is_empty() {
                                 let default_mime =
                                     Mime::from_str("application/octet-stream").unwrap();
                                 let mime =
                                     mime_guess::from_path(file_path.clone()).first_or(default_mime);
-                                part = match part.mime_str(mime.essence_str()) {
-                                    Ok(p) => p,
-                                    Err(e) => {
-                                        return Ok(response_err(
-                                            &app_handle,
-                                            &*response.lock().await,
-                                            format!("Invalid mime for multi-part entry {e:?}"),
-                                            &update_source,
-                                        ));
-                                    }
-                                };
+                                part =
+                                    part.mime_str(mime.essence_str()).map_err(|e| e.to_string())?;
                             }
 
-                            // Set a file path if it is not empty
+                            // Set file path if not empty
                             if !file_path.is_empty() {
                                 let filename = PathBuf::from(file_path)
                                     .file_name()
@@ -410,15 +359,6 @@ pub async fn send_http_request<R: Runtime>(
         } else {
             warn!("Unsupported body type: {}", body_type);
         }
-    } else {
-        // No body set
-        let method = request.method.to_ascii_lowercase();
-        let is_body_method = method == "post" || method == "put" || method == "patch";
-        // Add Content-Length for methods that commonly accept a body because some servers
-        // will error if they don't receive it.
-        if is_body_method && !headers.contains_key("content-length") {
-            headers.insert("Content-Length", HeaderValue::from_static("0"));
-        }
     }
 
     // Add headers last, because previous steps may modify them
@@ -428,65 +368,48 @@ pub async fn send_http_request<R: Runtime>(
         Ok(r) => r,
         Err(e) => {
             warn!("Failed to build request builder {e:?}");
-            return Ok(response_err(
-                &app_handle,
-                &*response.lock().await,
-                e.to_string(),
-                &update_source,
-            ));
+            return Ok(response_err(&*response.lock().await, e.to_string(), window).await);
         }
     };
 
-    match request.authentication_type {
-        None => {
-            // No authentication found. Not even inherited
-        }
-        Some(authentication_type) if authentication_type == "none" => {
-            // Explicitly no authentication
-        }
-        Some(authentication_type) => {
-            let req = CallHttpAuthenticationRequest {
-                context_id: format!("{:x}", md5::compute(request.id)),
-                values: serde_json::from_value(
-                    serde_json::to_value(&request.authentication).unwrap(),
-                )
-                .unwrap(),
-                url: sendable_req.url().to_string(),
-                method: sendable_req.method().to_string(),
-                headers: sendable_req
-                    .headers()
-                    .iter()
-                    .map(|(name, value)| HttpHeader {
-                        name: name.to_string(),
-                        value: value.to_str().unwrap_or_default().to_string(),
-                    })
-                    .collect(),
-            };
-            let auth_result =
-                plugin_manager.call_http_authentication(&window, &authentication_type, req).await;
-            let plugin_result = match auth_result {
-                Ok(r) => r,
-                Err(e) => {
-                    return Ok(response_err(
-                        &app_handle,
-                        &*response.lock().await,
-                        e.to_string(),
-                        &update_source,
-                    ));
-                }
-            };
+    // Apply authentication
 
-            let headers = sendable_req.headers_mut();
-            for header in plugin_result.set_headers {
-                headers.insert(
-                    HeaderName::from_str(&header.name).unwrap(),
-                    HeaderValue::from_str(&header.value).unwrap(),
-                );
+    if let Some(auth_name) = request.authentication_type.to_owned() {
+        let req = CallHttpAuthenticationRequest {
+            config: serde_json::to_value(&request.authentication)
+                .unwrap()
+                .as_object()
+                .unwrap()
+                .to_owned(),
+            method: sendable_req.method().to_string(),
+            url: sendable_req.url().to_string(),
+            headers: sendable_req
+                .headers()
+                .iter()
+                .map(|(name, value)| HttpHeader {
+                    name: name.to_string(),
+                    value: value.to_str().unwrap_or_default().to_string(),
+                })
+                .collect(),
+        };
+        let auth_result = plugin_manager.call_http_authentication(window, &auth_name, req).await;
+        let plugin_result = match auth_result {
+            Ok(r) => r,
+            Err(e) => {
+                return Ok(response_err(&*response.lock().await, e.to_string(), window).await);
             }
+        };
+
+        let headers = sendable_req.headers_mut();
+        for header in plugin_result.set_headers {
+            headers.insert(
+                HeaderName::from_str(&header.name).unwrap(),
+                HeaderValue::from_str(&header.value).unwrap(),
+            );
         }
     }
 
-    let (resp_tx, resp_rx) = oneshot::channel::<std::result::Result<Response, reqwest::Error>>();
+    let (resp_tx, resp_rx) = oneshot::channel::<Result<Response, reqwest::Error>>();
     let (done_tx, done_rx) = oneshot::channel::<HttpResponse>();
 
     let start = std::time::Instant::now();
@@ -498,26 +421,22 @@ pub async fn send_http_request<R: Runtime>(
     let raw_response = tokio::select! {
         Ok(r) = resp_rx => r,
         _ = cancelled_rx.changed() => {
-            let mut r = response.lock().await;
-            r.elapsed_headers = start.elapsed().as_millis() as i32;
-            r.elapsed = start.elapsed().as_millis() as i32;
-            return Ok(response_err(&app_handle, &r, "Request was cancelled".to_string(), &update_source));
+            debug!("Request cancelled");
+            return Ok(response_err(&*response.lock().await, "Request was cancelled".to_string(), window).await);
         }
     };
 
     {
-        let app_handle = app_handle.clone();
         let window = window.clone();
         let cancelled_rx = cancelled_rx.clone();
         let response_id = response_id.clone();
         let response = response.clone();
-        let update_source = update_source.clone();
         tokio::spawn(async move {
             match raw_response {
                 Ok(mut v) => {
                     let content_length = v.content_length();
                     let response_headers = v.headers().clone();
-                    let dir = app_handle.path().app_data_dir().unwrap();
+                    let dir = window.app_handle().path().app_data_dir().unwrap();
                     let base_dir = dir.join("responses");
                     create_dir_all(base_dir.clone()).await.expect("Failed to create responses dir");
                     let body_path = if response_id.is_empty() {
@@ -530,7 +449,6 @@ pub async fn send_http_request<R: Runtime>(
                         let mut r = response.lock().await;
                         r.body_path = Some(body_path.to_str().unwrap().to_string());
                         r.elapsed_headers = start.elapsed().as_millis() as i32;
-                        r.elapsed = start.elapsed().as_millis() as i32;
                         r.status = v.status().as_u16() as i32;
                         r.status_reason = v.status().canonical_reason().map(|s| s.to_string());
                         r.headers = response_headers
@@ -552,9 +470,8 @@ pub async fn send_http_request<R: Runtime>(
                         };
 
                         r.state = HttpResponseState::Connected;
-                        app_handle
-                            .db()
-                            .update_http_response_if_id(&r, &update_source)
+                        update_response_if_id(&window, &r, &UpdateSource::Window)
+                            .await
                             .expect("Failed to update response after connected");
                     }
 
@@ -582,27 +499,21 @@ pub async fn send_http_request<R: Runtime>(
                                 f.flush().await.expect("Failed to flush file");
                                 written_bytes += bytes.len();
                                 r.content_length = Some(written_bytes as i32);
-                                app_handle
-                                    .db()
-                                    .update_http_response_if_id(&r, &update_source)
+                                update_response_if_id(&window, &r, &UpdateSource::Window)
+                                    .await
                                     .expect("Failed to update response");
                             }
                             Ok(None) => {
                                 break;
                             }
                             Err(e) => {
-                                response_err(
-                                    &app_handle,
-                                    &*response.lock().await,
-                                    e.to_string(),
-                                    &update_source,
-                                );
+                                response_err(&*response.lock().await, e.to_string(), &window).await;
                                 break;
                             }
                         }
                     }
 
-                    // Set the final content length
+                    // Set final content length
                     {
                         let mut r = response.lock().await;
                         r.content_length = match content_length {
@@ -610,9 +521,8 @@ pub async fn send_http_request<R: Runtime>(
                             None => Some(written_bytes as i32),
                         };
                         r.state = HttpResponseState::Closed;
-                        app_handle
-                            .db()
-                            .update_http_response_if_id(&r, &UpdateSource::from_window(&window))
+                        update_response_if_id(&window, &r, &UpdateSource::Window)
+                            .await
                             .expect("Failed to update response");
                     };
 
@@ -637,9 +547,8 @@ pub async fn send_http_request<R: Runtime>(
                             })
                             .collect::<Vec<_>>();
                         cookie_jar.cookies = json_cookies;
-                        if let Err(e) = app_handle
-                            .db()
-                            .upsert_cookie_jar(&cookie_jar, &UpdateSource::from_window(&window))
+                        if let Err(e) =
+                            upsert_cookie_jar(&window, &cookie_jar, &UpdateSource::Window).await
                         {
                             error!("Failed to update cookie jar: {}", e);
                         };
@@ -647,12 +556,7 @@ pub async fn send_http_request<R: Runtime>(
                 }
                 Err(e) => {
                     warn!("Failed to execute request {e}");
-                    response_err(
-                        &app_handle,
-                        &*response.lock().await,
-                        format!("{e} → {e:?}"),
-                        &update_source,
-                    );
+                    response_err(&*response.lock().await, format!("{e} → {e:?}"), &window).await;
                 }
             };
 
@@ -661,43 +565,22 @@ pub async fn send_http_request<R: Runtime>(
         });
     };
 
-    let app_handle = app_handle.clone();
     Ok(tokio::select! {
         Ok(r) = done_rx => r,
         _ = cancelled_rx.changed() => {
-            match app_handle.with_db(|c| c.get_http_response(&response_id)) {
+            match get_http_response(window, response_id.as_str()).await {
                 Ok(mut r) => {
                     r.state = HttpResponseState::Closed;
-                    r.elapsed = start.elapsed().as_millis() as i32;
-                    r.elapsed_headers = start.elapsed().as_millis() as i32;
-                    app_handle.db().update_http_response_if_id(&r, &UpdateSource::from_window(window))
-                        .expect("Failed to update response")
+                    update_response_if_id(&window, &r, &UpdateSource::Window).await.expect("Failed to update response")
                 },
                 _ => {
-                    response_err(&app_handle, &*response.lock().await, "Ephemeral request was cancelled".to_string(), &update_source)
+                    response_err(&*response.lock().await, "Ephemeral request was cancelled".to_string(), &window).await
                 }.clone(),
             }
         }
     })
 }
 
-fn resolve_http_request<R: Runtime>(
-    window: &WebviewWindow<R>,
-    request: &HttpRequest,
-) -> Result<HttpRequest> {
-    let mut new_request = request.clone();
-
-    let (authentication_type, authentication) =
-        window.db().resolve_auth_for_http_request(request)?;
-    new_request.authentication_type = authentication_type;
-    new_request.authentication = authentication;
-
-    let headers = window.db().resolve_headers_for_http_request(request)?;
-    new_request.headers = headers;
-
-    Ok(new_request)
-}
-
 fn ensure_proto(url_str: &str) -> String {
     if url_str.starts_with("http://") || url_str.starts_with("https://") {
         return url_str.to_string();
@@ -721,10 +604,10 @@ fn ensure_proto(url_str: &str) -> String {
     format!("http://{url_str}")
 }
 
-fn get_bool(v: &Value, key: &str, fallback: bool) -> bool {
+fn get_bool(v: &Value, key: &str) -> bool {
     match v.get(key) {
-        None => fallback,
-        Some(v) => v.as_bool().unwrap_or(fallback),
+        None => false,
+        Some(v) => v.as_bool().unwrap_or_default(),
     }
 }
 

src-tauri/src/notifications.rs

@@ -1,16 +1,12 @@
 use std::time::SystemTime;
 
-use crate::error::Result;
-use crate::history::{get_num_launches, get_os};
+use crate::analytics::get_num_launches;
 use chrono::{DateTime, Duration, Utc};
 use log::debug;
 use reqwest::Method;
 use serde::{Deserialize, Serialize};
-use serde_json::Value;
-use tauri::{AppHandle, Emitter, Manager, Runtime, WebviewWindow};
-use yaak_license::{LicenseCheckStatus, check_license};
-use yaak_models::query_manager::QueryManagerExt;
-use yaak_models::util::UpdateSource;
+use tauri::{Emitter, Manager, Runtime, WebviewWindow};
+use yaak_models::queries::{get_key_value_raw, set_key_value_raw, UpdateSource};
 
 // Check for updates every hour
 const MAX_UPDATE_CHECK_SECONDS: u64 = 60 * 60;
@@ -46,23 +42,16 @@ impl YaakNotifier {
         }
     }
 
-    pub async fn seen<R: Runtime>(&mut self, window: &WebviewWindow<R>, id: &str) -> Result<()> {
-        let app_handle = window.app_handle();
-        let mut seen = get_kv(app_handle).await?;
+    pub async fn seen<R: Runtime>(&mut self, w: &WebviewWindow<R>, id: &str) -> Result<(), String> {
+        let mut seen = get_kv(w).await?;
         seen.push(id.to_string());
         debug!("Marked notification as seen {}", id);
-        let seen_json = serde_json::to_string(&seen)?;
-        window.db().set_key_value_raw(
-            KV_NAMESPACE,
-            KV_KEY,
-            seen_json.as_str(),
-            &UpdateSource::from_window(window),
-        );
+        let seen_json = serde_json::to_string(&seen).map_err(|e| e.to_string())?;
+        set_key_value_raw(w, KV_NAMESPACE, KV_KEY, seen_json.as_str(), &UpdateSource::Window).await;
         Ok(())
     }
 
-    pub async fn check<R: Runtime>(&mut self, window: &WebviewWindow<R>) -> Result<()> {
-        let app_handle = window.app_handle();
+    pub async fn check<R: Runtime>(&mut self, window: &WebviewWindow<R>) -> Result<(), String> {
         let ignore_check = self.last_check.elapsed().unwrap().as_secs() < MAX_UPDATE_CHECK_SECONDS;
 
         if ignore_check {
@@ -71,62 +60,39 @@ impl YaakNotifier {
 
         self.last_check = SystemTime::now();
 
-        let license_check = match check_license(window).await? {
-            LicenseCheckStatus::PersonalUse { .. } => "personal".to_string(),
-            LicenseCheckStatus::CommercialUse => "commercial".to_string(),
-            LicenseCheckStatus::InvalidLicense => "invalid_license".to_string(),
-            LicenseCheckStatus::Trialing { .. } => "trialing".to_string(),
-        };
-        let settings = window.db().get_settings();
-        let num_launches = get_num_launches(app_handle).await;
-        let info = app_handle.package_info().clone();
+        let num_launches = get_num_launches(window).await;
+        let info = window.app_handle().package_info().clone();
         let req = reqwest::Client::default()
             .request(Method::GET, "https://notify.yaak.app/notifications")
             .query(&[
-                ("version", info.version.to_string().as_str()),
-                ("launches", num_launches.to_string().as_str()),
-                ("installed", settings.created_at.format("%Y-%m-%d").to_string().as_str()),
-                ("license", &license_check),
-                ("platform", get_os()),
+                ("version", info.version.to_string()),
+                ("launches", num_launches.to_string()),
             ]);
-        let resp = req.send().await?;
+        let resp = req.send().await.map_err(|e| e.to_string())?;
         if resp.status() != 200 {
             debug!("Skipping notification status code {}", resp.status());
             return Ok(());
         }
 
-        let result = resp.json::<Value>().await?;
+        let notification = resp.json::<YaakNotification>().await.map_err(|e| e.to_string())?;
 
-        // Support both single and multiple notifications.
-        // TODO: Remove support for single after April 2025
-        let notifications = match result {
-            Value::Array(a) => a
-                .into_iter()
-                .map(|a| serde_json::from_value(a).unwrap())
-                .collect::<Vec<YaakNotification>>(),
-            a @ _ => vec![serde_json::from_value(a).unwrap()],
-        };
-
-        for notification in notifications {
-            let age = notification.timestamp.signed_duration_since(Utc::now());
-            let seen = get_kv(app_handle).await?;
-            if seen.contains(&notification.id) || (age > Duration::days(2)) {
-                debug!("Already seen notification {}", notification.id);
-                continue;
-            }
-            debug!("Got notification {:?}", notification);
-
-            let _ = app_handle.emit_to(window.label(), "notification", notification.clone());
-            break; // Only show one notification
+        let age = notification.timestamp.signed_duration_since(Utc::now());
+        let seen = get_kv(window).await?;
+        if seen.contains(&notification.id) || (age > Duration::days(2)) {
+            debug!("Already seen notification {}", notification.id);
+            return Ok(());
         }
+        debug!("Got notification {:?}", notification);
+
+        let _ = window.emit_to(window.label(), "notification", notification.clone());
 
         Ok(())
     }
 }
 
-async fn get_kv<R: Runtime>(app_handle: &AppHandle<R>) -> Result<Vec<String>> {
-    match app_handle.db().get_key_value_raw("notifications", "seen") {
+async fn get_kv<R: Runtime>(w: &WebviewWindow<R>) -> Result<Vec<String>, String> {
+    match get_key_value_raw(w, "notifications", "seen").await {
         None => Ok(Vec::new()),
-        Some(v) => Ok(serde_json::from_str(&v.value)?),
+        Some(v) => serde_json::from_str(&v.value).map_err(|e| e.to_string()),
     }
 }

src-tauri/src/plugin_events.rs

@@ -1,310 +0,0 @@
-use crate::http_request::send_http_request;
-use crate::render::{render_http_request, render_json_value};
-use crate::window::{CreateWindowConfig, create_window};
-use crate::{
-    call_frontend, cookie_jar_from_window, environment_from_window, get_window_from_window_context,
-    workspace_from_window,
-};
-use chrono::Utc;
-use cookie::Cookie;
-use log::warn;
-use tauri::{AppHandle, Emitter, Manager, Runtime, State};
-use tauri_plugin_clipboard_manager::ClipboardExt;
-use yaak_models::models::{HttpResponse, Plugin};
-use yaak_models::query_manager::QueryManagerExt;
-use yaak_models::util::UpdateSource;
-use yaak_plugins::events::{
-    Color, DeleteKeyValueResponse, EmptyPayload, FindHttpResponsesResponse, GetCookieValueResponse,
-    GetHttpRequestByIdResponse, GetKeyValueResponse, Icon, InternalEvent, InternalEventPayload,
-    ListCookieNamesResponse, PluginWindowContext, RenderHttpRequestResponse,
-    SendHttpRequestResponse, SetKeyValueResponse, ShowToastRequest, TemplateRenderResponse,
-    WindowNavigateEvent,
-};
-use yaak_plugins::manager::PluginManager;
-use yaak_plugins::plugin_handle::PluginHandle;
-use yaak_plugins::template_callback::PluginTemplateCallback;
-
-pub(crate) async fn handle_plugin_event<R: Runtime>(
-    app_handle: &AppHandle<R>,
-    event: &InternalEvent,
-    plugin_handle: &PluginHandle,
-) {
-    // debug!("Got event to app {event:?}");
-    let window_context = event.window_context.to_owned();
-    let response_event: Option<InternalEventPayload> = match event.clone().payload {
-        InternalEventPayload::CopyTextRequest(req) => {
-            app_handle
-                .clipboard()
-                .write_text(req.text.as_str())
-                .expect("Failed to write text to clipboard");
-            Some(InternalEventPayload::CopyTextResponse(EmptyPayload {}))
-        }
-        InternalEventPayload::ShowToastRequest(req) => {
-            match window_context {
-                PluginWindowContext::Label { label, .. } => app_handle
-                    .emit_to(label, "show_toast", req)
-                    .expect("Failed to emit show_toast to window"),
-                _ => app_handle.emit("show_toast", req).expect("Failed to emit show_toast"),
-            };
-            Some(InternalEventPayload::ShowToastResponse(EmptyPayload {}))
-        }
-        InternalEventPayload::PromptTextRequest(_) => {
-            let window = get_window_from_window_context(app_handle, &window_context)
-                .expect("Failed to find window for render");
-            call_frontend(window, event).await
-        }
-        InternalEventPayload::FindHttpResponsesRequest(req) => {
-            let http_responses = app_handle
-                .db()
-                .list_http_responses_for_request(&req.request_id, req.limit.map(|l| l as u64))
-                .unwrap_or_default();
-            Some(InternalEventPayload::FindHttpResponsesResponse(FindHttpResponsesResponse {
-                http_responses,
-            }))
-        }
-        InternalEventPayload::GetHttpRequestByIdRequest(req) => {
-            let http_request = app_handle.db().get_http_request(&req.id).ok();
-            Some(InternalEventPayload::GetHttpRequestByIdResponse(GetHttpRequestByIdResponse {
-                http_request,
-            }))
-        }
-        InternalEventPayload::RenderHttpRequestRequest(req) => {
-            let window = get_window_from_window_context(app_handle, &window_context)
-                .expect("Failed to find window for render http request");
-
-            let workspace =
-                workspace_from_window(&window).expect("Failed to get workspace_id from window URL");
-            let environment = environment_from_window(&window);
-            let base_environment = app_handle
-                .db()
-                .get_base_environment(&workspace.id)
-                .expect("Failed to get base environment");
-            let cb = PluginTemplateCallback::new(app_handle, &window_context, req.purpose);
-            let http_request = render_http_request(
-                &req.http_request,
-                &base_environment,
-                environment.as_ref(),
-                &cb,
-            )
-            .await
-            .expect("Failed to render http request");
-            Some(InternalEventPayload::RenderHttpRequestResponse(RenderHttpRequestResponse {
-                http_request,
-            }))
-        }
-        InternalEventPayload::TemplateRenderRequest(req) => {
-            let window = get_window_from_window_context(app_handle, &window_context)
-                .expect("Failed to find window for render");
-
-            let workspace =
-                workspace_from_window(&window).expect("Failed to get workspace_id from window URL");
-            let environment = environment_from_window(&window);
-            let base_environment = app_handle
-                .db()
-                .get_base_environment(&workspace.id)
-                .expect("Failed to get base environment");
-            let cb = PluginTemplateCallback::new(app_handle, &window_context, req.purpose);
-            let data = render_json_value(req.data, &base_environment, environment.as_ref(), &cb)
-                .await
-                .expect("Failed to render template");
-            Some(InternalEventPayload::TemplateRenderResponse(TemplateRenderResponse { data }))
-        }
-        InternalEventPayload::ErrorResponse(resp) => {
-            let toast_event = plugin_handle.build_event_to_send(
-                &window_context,
-                &InternalEventPayload::ShowToastRequest(ShowToastRequest {
-                    message: format!(
-                        "Plugin error from {}: {}",
-                        plugin_handle.name().await,
-                        resp.error
-                    ),
-                    color: Some(Color::Danger),
-                    ..Default::default()
-                }),
-                None,
-            );
-            Box::pin(handle_plugin_event(app_handle, &toast_event, plugin_handle)).await;
-            None
-        }
-        InternalEventPayload::ReloadResponse(_) => {
-            let plugins = app_handle.db().list_plugins().unwrap();
-            for plugin in plugins {
-                if plugin.directory != plugin_handle.dir {
-                    continue;
-                }
-
-                let new_plugin = Plugin {
-                    updated_at: Utc::now().naive_utc(), // TODO: Add reloaded_at field to use instead
-                    ..plugin
-                };
-                app_handle.db().upsert_plugin(&new_plugin, &UpdateSource::Plugin).unwrap();
-            }
-            let toast_event = plugin_handle.build_event_to_send(
-                &window_context,
-                &InternalEventPayload::ShowToastRequest(ShowToastRequest {
-                    message: format!("Reloaded plugin {}", plugin_handle.dir),
-                    icon: Some(Icon::Info),
-                    ..Default::default()
-                }),
-                None,
-            );
-            Box::pin(handle_plugin_event(app_handle, &toast_event, plugin_handle)).await;
-            None
-        }
-        InternalEventPayload::SendHttpRequestRequest(req) => {
-            let window = get_window_from_window_context(app_handle, &window_context)
-                .expect("Failed to find window for sending HTTP request");
-            let mut http_request = req.http_request;
-            let workspace =
-                workspace_from_window(&window).expect("Failed to get workspace_id from window URL");
-            let cookie_jar = cookie_jar_from_window(&window);
-            let environment = environment_from_window(&window);
-
-            if http_request.workspace_id.is_empty() {
-                http_request.workspace_id = workspace.id;
-            }
-
-            let http_response = if http_request.id.is_empty() {
-                HttpResponse::default()
-            } else {
-                window
-                    .db()
-                    .upsert_http_response(
-                        &HttpResponse {
-                            request_id: http_request.id.clone(),
-                            workspace_id: http_request.workspace_id.clone(),
-                            ..Default::default()
-                        },
-                        &UpdateSource::Plugin,
-                    )
-                    .unwrap()
-            };
-
-            let result = send_http_request(
-                &window,
-                &http_request,
-                &http_response,
-                environment,
-                cookie_jar,
-                &mut tokio::sync::watch::channel(false).1, // No-op cancel channel
-            )
-            .await;
-
-            let http_response = match result {
-                Ok(r) => r,
-                Err(_e) => return,
-            };
-
-            Some(InternalEventPayload::SendHttpRequestResponse(SendHttpRequestResponse {
-                http_response,
-            }))
-        }
-        InternalEventPayload::OpenWindowRequest(req) => {
-            let label = req.label;
-            let (navigation_tx, mut navigation_rx) = tokio::sync::mpsc::channel(128);
-            let (close_tx, mut close_rx) = tokio::sync::mpsc::channel(128);
-            let win_config = CreateWindowConfig {
-                url: &req.url,
-                label: &label.clone(),
-                title: &req.title.unwrap_or_default(),
-                navigation_tx: Some(navigation_tx),
-                close_tx: Some(close_tx),
-                inner_size: req.size.map(|s| (s.width, s.height)),
-                data_dir_key: req.data_dir_key,
-                ..Default::default()
-            };
-            create_window(app_handle, win_config);
-
-            {
-                let event_id = event.id.clone();
-                let plugin_handle = plugin_handle.clone();
-                let window_context = window_context.clone();
-                tauri::async_runtime::spawn(async move {
-                    while let Some(url) = navigation_rx.recv().await {
-                        let url = url.to_string();
-                        let event_to_send = plugin_handle.build_event_to_send(
-                            &window_context, // NOTE: Sending existing context on purpose here
-                            &InternalEventPayload::WindowNavigateEvent(WindowNavigateEvent { url }),
-                            Some(event_id.clone()),
-                        );
-                        plugin_handle.send(&event_to_send).await.unwrap();
-                    }
-                });
-            }
-
-            {
-                let event_id = event.id.clone();
-                let plugin_handle = plugin_handle.clone();
-                let window_context = window_context.clone();
-                tauri::async_runtime::spawn(async move {
-                    while let Some(_) = close_rx.recv().await {
-                        let event_to_send = plugin_handle.build_event_to_send(
-                            &window_context,
-                            &InternalEventPayload::WindowCloseEvent,
-                            Some(event_id.clone()),
-                        );
-                        plugin_handle.send(&event_to_send).await.unwrap();
-                    }
-                });
-            }
-
-            None
-        }
-        InternalEventPayload::CloseWindowRequest(req) => {
-            if let Some(window) = app_handle.webview_windows().get(&req.label) {
-                window.close().expect("Failed to close window");
-            }
-            None
-        }
-        InternalEventPayload::SetKeyValueRequest(req) => {
-            let name = plugin_handle.name().await;
-            app_handle.db().set_plugin_key_value(&name, &req.key, &req.value);
-            Some(InternalEventPayload::SetKeyValueResponse(SetKeyValueResponse {}))
-        }
-        InternalEventPayload::GetKeyValueRequest(req) => {
-            let name = plugin_handle.name().await;
-            let value = app_handle.db().get_plugin_key_value(&name, &req.key).map(|v| v.value);
-            Some(InternalEventPayload::GetKeyValueResponse(GetKeyValueResponse { value }))
-        }
-        InternalEventPayload::DeleteKeyValueRequest(req) => {
-            let name = plugin_handle.name().await;
-            let deleted = app_handle.db().delete_plugin_key_value(&name, &req.key).unwrap();
-            Some(InternalEventPayload::DeleteKeyValueResponse(DeleteKeyValueResponse { deleted }))
-        }
-        InternalEventPayload::ListCookieNamesRequest(_req) => {
-            let window = get_window_from_window_context(app_handle, &window_context)
-                .expect("Failed to find window for listing cookies");
-            let names = match cookie_jar_from_window(&window) {
-                None => Vec::new(),
-                Some(j) => j
-                    .cookies
-                    .into_iter()
-                    .filter_map(|c| Cookie::parse(c.raw_cookie).ok().map(|c| c.name().to_string()))
-                    .collect(),
-            };
-            Some(InternalEventPayload::ListCookieNamesResponse(ListCookieNamesResponse { names }))
-        }
-        InternalEventPayload::GetCookieValueRequest(req) => {
-            let window = get_window_from_window_context(app_handle, &window_context)
-                .expect("Failed to find window for listing cookies");
-            let value = match cookie_jar_from_window(&window) {
-                None => None,
-                Some(j) => j.cookies.into_iter().find_map(|c| match Cookie::parse(c.raw_cookie) {
-                    Ok(c) if c.name().to_string().eq(&req.name) => {
-                        Some(c.value_trimmed().to_string())
-                    }
-                    _ => None,
-                }),
-            };
-            Some(InternalEventPayload::GetCookieValueResponse(GetCookieValueResponse { value }))
-        }
-        _ => None,
-    };
-
-    if let Some(e) = response_event {
-        let plugin_manager: State<'_, PluginManager> = app_handle.state();
-        if let Err(e) = plugin_manager.reply(&event, &e).await {
-            warn!("Failed to reply to plugin manager: {:?}", e)
-        }
-    }
-}

src-tauri/src/render.rs

@@ -1,18 +1,18 @@
-use serde_json::Value;
+use crate::template_callback::PluginTemplateCallback;
+use serde_json::{json, Map, Value};
 use std::collections::{BTreeMap, HashMap};
-use yaak_http::apply_path_placeholders;
 use yaak_models::models::{
-    Environment, GrpcRequest, HttpRequest, HttpRequestHeader, HttpUrlParameter,
+    Environment, EnvironmentVariable, GrpcMetadataEntry, GrpcRequest, HttpRequest,
+    HttpRequestHeader, HttpUrlParameter,
 };
-use yaak_models::render::make_vars_hashmap;
-use yaak_templates::{parse_and_render, render_json_value_raw, TemplateCallback};
+use yaak_templates::{parse_and_render, TemplateCallback};
 
 pub async fn render_template<T: TemplateCallback>(
     template: &str,
     base_environment: &Environment,
     environment: Option<&Environment>,
     cb: &T,
-) -> yaak_templates::error::Result<String> {
+) -> String {
     let vars = &make_vars_hashmap(base_environment, environment);
     render(template, vars, cb).await
 }
@@ -22,7 +22,7 @@ pub async fn render_json_value<T: TemplateCallback>(
     base_environment: &Environment,
     environment: Option<&Environment>,
     cb: &T,
-) -> yaak_templates::error::Result<Value> {
+) -> Value {
     let vars = &make_vars_hashmap(base_environment, environment);
     render_json_value_raw(value, vars, cb).await
 }
@@ -32,48 +32,48 @@ pub async fn render_grpc_request<T: TemplateCallback>(
     base_environment: &Environment,
     environment: Option<&Environment>,
     cb: &T,
-) -> yaak_templates::error::Result<GrpcRequest> {
+) -> GrpcRequest {
     let vars = &make_vars_hashmap(base_environment, environment);
 
     let mut metadata = Vec::new();
     for p in r.metadata.clone() {
-        metadata.push(HttpRequestHeader {
+        metadata.push(GrpcMetadataEntry {
             enabled: p.enabled,
-            name: render(p.name.as_str(), vars, cb).await?,
-            value: render(p.value.as_str(), vars, cb).await?,
+            name: render(p.name.as_str(), vars, cb).await,
+            value: render(p.value.as_str(), vars, cb).await,
             id: p.id,
         })
     }
 
     let mut authentication = BTreeMap::new();
     for (k, v) in r.authentication.clone() {
-        authentication.insert(k, render_json_value_raw(v, vars, cb).await?);
+        authentication.insert(k, render_json_value_raw(v, vars, cb).await);
     }
 
-    let url = render(r.url.as_str(), vars, cb).await?;
+    let url = render(r.url.as_str(), vars, cb).await;
 
-    Ok(GrpcRequest {
+    GrpcRequest {
         url,
         metadata,
         authentication,
         ..r.to_owned()
-    })
+    }
 }
 
-pub async fn render_http_request<T: TemplateCallback>(
+pub async fn render_http_request(
     r: &HttpRequest,
     base_environment: &Environment,
     environment: Option<&Environment>,
-    cb: &T,
-) -> yaak_templates::error::Result<HttpRequest> {
+    cb: &PluginTemplateCallback,
+) -> HttpRequest {
     let vars = &make_vars_hashmap(base_environment, environment);
 
     let mut url_parameters = Vec::new();
     for p in r.url_parameters.clone() {
         url_parameters.push(HttpUrlParameter {
             enabled: p.enabled,
-            name: render(p.name.as_str(), vars, cb).await?,
-            value: render(p.value.as_str(), vars, cb).await?,
+            name: render(p.name.as_str(), vars, cb).await,
+            value: render(p.value.as_str(), vars, cb).await,
             id: p.id,
         })
     }
@@ -82,41 +82,351 @@ pub async fn render_http_request<T: TemplateCallback>(
     for p in r.headers.clone() {
         headers.push(HttpRequestHeader {
             enabled: p.enabled,
-            name: render(p.name.as_str(), vars, cb).await?,
-            value: render(p.value.as_str(), vars, cb).await?,
+            name: render(p.name.as_str(), vars, cb).await,
+            value: render(p.value.as_str(), vars, cb).await,
             id: p.id,
         })
     }
 
     let mut body = BTreeMap::new();
     for (k, v) in r.body.clone() {
-        body.insert(k, render_json_value_raw(v, vars, cb).await?);
+        body.insert(k, render_json_value_raw(v, vars, cb).await);
     }
 
     let mut authentication = BTreeMap::new();
     for (k, v) in r.authentication.clone() {
-        authentication.insert(k, render_json_value_raw(v, vars, cb).await?);
+        authentication.insert(k, render_json_value_raw(v, vars, cb).await);
     }
 
-    let url = render(r.url.clone().as_str(), vars, cb).await?;
-
-    // This doesn't fit perfectly with the concept of "rendering" but it kind of does
-    let (url, url_parameters) = apply_path_placeholders(&url, url_parameters);
-
-    Ok(HttpRequest {
+    let url = render(r.url.clone().as_str(), vars, cb).await;
+    let req = HttpRequest {
         url,
         url_parameters,
         headers,
         body,
         authentication,
         ..r.to_owned()
-    })
+    };
+
+    // This doesn't fit perfectly with the concept of "rendering" but it kind of does
+    apply_path_placeholders(req)
+}
+
+pub fn make_vars_hashmap(
+    base_environment: &Environment,
+    environment: Option<&Environment>,
+) -> HashMap<String, String> {
+    let mut variables = HashMap::new();
+    variables = add_variable_to_map(variables, &base_environment.variables);
+
+    if let Some(e) = environment {
+        variables = add_variable_to_map(variables, &e.variables);
+    }
+
+    variables
 }
 
 pub async fn render<T: TemplateCallback>(
     template: &str,
     vars: &HashMap<String, String>,
     cb: &T,
-) -> yaak_templates::error::Result<String> {
+) -> String {
     parse_and_render(template, vars, cb).await
 }
+
+fn add_variable_to_map(
+    m: HashMap<String, String>,
+    variables: &Vec<EnvironmentVariable>,
+) -> HashMap<String, String> {
+    let mut map = m.clone();
+    for variable in variables {
+        if !variable.enabled || variable.value.is_empty() {
+            continue;
+        }
+        let name = variable.name.as_str();
+        let value = variable.value.as_str();
+        map.insert(name.into(), value.into());
+    }
+
+    map
+}
+
+async fn render_json_value_raw<T: TemplateCallback>(
+    v: Value,
+    vars: &HashMap<String, String>,
+    cb: &T,
+) -> Value {
+    match v {
+        Value::String(s) => json!(render(s.as_str(), vars, cb).await),
+        Value::Array(a) => {
+            let mut new_a = Vec::new();
+            for v in a {
+                new_a.push(Box::pin(render_json_value_raw(v, vars, cb)).await)
+            }
+            json!(new_a)
+        }
+        Value::Object(o) => {
+            let mut new_o = Map::new();
+            for (k, v) in o {
+                let key = Box::pin(render(k.as_str(), vars, cb)).await;
+                let value = Box::pin(render_json_value_raw(v, vars, cb)).await;
+                new_o.insert(key, value);
+            }
+            json!(new_o)
+        }
+        v => v,
+    }
+}
+
+#[cfg(test)]
+mod render_tests {
+    use serde_json::json;
+    use std::collections::HashMap;
+    use yaak_templates::TemplateCallback;
+
+    struct EmptyCB {}
+
+    impl TemplateCallback for EmptyCB {
+        async fn run(
+            &self,
+            _fn_name: &str,
+            _args: HashMap<String, String>,
+        ) -> Result<String, String> {
+            todo!()
+        }
+    }
+
+    #[tokio::test]
+    async fn render_json_value_string() {
+        let v = json!("${[a]}");
+        let mut vars = HashMap::new();
+        vars.insert("a".to_string(), "aaa".to_string());
+
+        let result = super::render_json_value_raw(v, &vars, &EmptyCB {}).await;
+        assert_eq!(result, json!("aaa"))
+    }
+
+    #[tokio::test]
+    async fn render_json_value_array() {
+        let v = json!(["${[a]}", "${[a]}"]);
+        let mut vars = HashMap::new();
+        vars.insert("a".to_string(), "aaa".to_string());
+
+        let result = super::render_json_value_raw(v, &vars, &EmptyCB {}).await;
+        assert_eq!(result, json!(["aaa", "aaa"]))
+    }
+
+    #[tokio::test]
+    async fn render_json_value_object() {
+        let v = json!({"${[a]}": "${[a]}"});
+        let mut vars = HashMap::new();
+        vars.insert("a".to_string(), "aaa".to_string());
+
+        let result = super::render_json_value_raw(v, &vars, &EmptyCB {}).await;
+        assert_eq!(result, json!({"aaa": "aaa"}))
+    }
+
+    #[tokio::test]
+    async fn render_json_value_nested() {
+        let v = json!([
+            123,
+            {"${[a]}": "${[a]}"},
+            null,
+            "${[a]}",
+            false,
+            {"x": ["${[a]}"]}
+        ]);
+        let mut vars = HashMap::new();
+        vars.insert("a".to_string(), "aaa".to_string());
+
+        let result = super::render_json_value_raw(v, &vars, &EmptyCB {}).await;
+        assert_eq!(
+            result,
+            json!([
+                123,
+                {"aaa": "aaa"},
+                null,
+                "aaa",
+                false,
+                {"x": ["aaa"]}
+            ])
+        )
+    }
+}
+
+fn replace_path_placeholder(p: &HttpUrlParameter, url: &str) -> String {
+    if !p.enabled {
+        return url.to_string();
+    }
+
+    if !p.name.starts_with(":") {
+        return url.to_string();
+    }
+
+    let re = regex::Regex::new(format!("(/){}([/?#]|$)", p.name).as_str()).unwrap();
+    let result = re
+        .replace_all(url, |cap: &regex::Captures| {
+            format!(
+                "{}{}{}",
+                cap[1].to_string(),
+                urlencoding::encode(p.value.as_str()),
+                cap[2].to_string()
+            )
+        })
+        .into_owned();
+    result
+}
+
+fn apply_path_placeholders(rendered_request: HttpRequest) -> HttpRequest {
+    let mut url = rendered_request.url.to_owned();
+    let mut url_parameters = Vec::new();
+    for p in rendered_request.url_parameters.clone() {
+        if !p.enabled || p.name.is_empty() {
+            continue;
+        }
+
+        // Replace path parameters with values from URL parameters
+        let old_url_string = url.clone();
+        url = replace_path_placeholder(&p, url.as_str());
+
+        // Remove as param if it modified the URL
+        if old_url_string == url {
+            url_parameters.push(p);
+        }
+    }
+
+    let mut request = rendered_request.clone();
+    request.url_parameters = url_parameters;
+    request.url = url;
+    request
+}
+
+#[cfg(test)]
+mod placeholder_tests {
+    use crate::render::{apply_path_placeholders, replace_path_placeholder};
+    use yaak_models::models::{HttpRequest, HttpUrlParameter};
+
+    #[test]
+    fn placeholder_middle() {
+        let p = HttpUrlParameter {
+            name: ":foo".into(),
+            value: "xxx".into(),
+            enabled: true,
+            id: None,
+        };
+        assert_eq!(
+            replace_path_placeholder(&p, "https://example.com/:foo/bar"),
+            "https://example.com/xxx/bar",
+        );
+    }
+
+    #[test]
+    fn placeholder_end() {
+        let p = HttpUrlParameter {
+            name: ":foo".into(),
+            value: "xxx".into(),
+            enabled: true,
+            id: None,
+        };
+        assert_eq!(
+            replace_path_placeholder(&p, "https://example.com/:foo"),
+            "https://example.com/xxx",
+        );
+    }
+
+    #[test]
+    fn placeholder_query() {
+        let p = HttpUrlParameter {
+            name: ":foo".into(),
+            value: "xxx".into(),
+            enabled: true,
+            id: None,
+        };
+        assert_eq!(
+            replace_path_placeholder(&p, "https://example.com/:foo?:foo"),
+            "https://example.com/xxx?:foo",
+        );
+    }
+
+    #[test]
+    fn placeholder_missing() {
+        let p = HttpUrlParameter {
+            enabled: true,
+            name: "".to_string(),
+            value: "".to_string(),
+            id: None,
+        };
+        assert_eq!(
+            replace_path_placeholder(&p, "https://example.com/:missing"),
+            "https://example.com/:missing",
+        );
+    }
+
+    #[test]
+    fn placeholder_disabled() {
+        let p = HttpUrlParameter {
+            enabled: false,
+            name: ":foo".to_string(),
+            value: "xxx".to_string(),
+            id: None,
+        };
+        assert_eq!(
+            replace_path_placeholder(&p, "https://example.com/:foo"),
+            "https://example.com/:foo",
+        );
+    }
+
+    #[test]
+    fn placeholder_prefix() {
+        let p = HttpUrlParameter {
+            name: ":foo".into(),
+            value: "xxx".into(),
+            enabled: true,
+            id: None,
+        };
+        assert_eq!(
+            replace_path_placeholder(&p, "https://example.com/:foooo"),
+            "https://example.com/:foooo",
+        );
+    }
+
+    #[test]
+    fn placeholder_encode() {
+        let p = HttpUrlParameter {
+            name: ":foo".into(),
+            value: "Hello World".into(),
+            enabled: true,
+            id: None,
+        };
+        assert_eq!(
+            replace_path_placeholder(&p, "https://example.com/:foo"),
+            "https://example.com/Hello%20World",
+        );
+    }
+
+    #[test]
+    fn apply_placeholder() {
+        let result = apply_path_placeholders(HttpRequest {
+            url: "example.com/:a/bar".to_string(),
+            url_parameters: vec![
+                HttpUrlParameter {
+                    name: "b".to_string(),
+                    value: "bbb".to_string(),
+                    enabled: true,
+                    id: None,
+                },
+                HttpUrlParameter {
+                    name: ":a".to_string(),
+                    value: "aaa".to_string(),
+                    enabled: true,
+                    id: None,
+                },
+            ],
+            ..Default::default()
+        });
+        assert_eq!(result.url, "example.com/aaa/bar");
+        assert_eq!(result.url_parameters.len(), 1);
+        assert_eq!(result.url_parameters[0].name, "b");
+        assert_eq!(result.url_parameters[0].value, "bbb");
+    }
+}

src-tauri/src/tauri_plugin_mac_window.rs

@@ -1,6 +1,15 @@
+use crate::MAIN_WINDOW_PREFIX;
 use hex_color::HexColor;
+use log::warn;
 use objc::{msg_send, sel, sel_impl};
-use tauri::{Emitter, Runtime, Window};
+use rand::{distributions::Alphanumeric, Rng};
+use tauri::{
+    plugin::{Builder, TauriPlugin},
+    Emitter, Listener, Manager, Runtime, Window, WindowEvent,
+};
+
+const WINDOW_CONTROL_PAD_X: f64 = 13.0;
+const WINDOW_CONTROL_PAD_Y: f64 = 18.0;
 
 struct UnsafeWindowHandle(*mut std::ffi::c_void);
 
@@ -8,11 +17,65 @@ unsafe impl Send for UnsafeWindowHandle {}
 
 unsafe impl Sync for UnsafeWindowHandle {}
 
-const WINDOW_CONTROL_PAD_X: f64 = 13.0;
-const WINDOW_CONTROL_PAD_Y: f64 = 18.0;
-const MAIN_WINDOW_PREFIX: &str = "main_";
+pub fn init<R: Runtime>() -> TauriPlugin<R> {
+    Builder::new("mac_window")
+        .on_window_ready(|window| {
+            #[cfg(target_os = "macos")]
+            {
+                setup_traffic_light_positioner(&window);
+                let h = window.app_handle();
 
-pub(crate) fn update_window_title<R: Runtime>(window: Window<R>, title: String) {
+                let window_for_theme = window.clone();
+                let id1 = h.listen("yaak_bg_changed", move |ev| {
+                    let color_str: String = match serde_json::from_str(ev.payload()) {
+                        Ok(color) => color,
+                        Err(err) => {
+                            warn!("Failed to JSON parse color '{}': {}", ev.payload(), err);
+                            return;
+                        }
+                    };
+
+                    match HexColor::parse_rgb(color_str.trim()) {
+                        Ok(color) => {
+                            update_window_theme(window_for_theme.clone(), color);
+                        }
+                        Err(err) => {
+                            warn!("Failed to parse background color '{}': {}", color_str, err)
+                        }
+                    }
+                });
+
+                let window_for_title = window.clone();
+                let id2 = h.listen("yaak_title_changed", move |ev| {
+                    let title: String = match serde_json::from_str(ev.payload()) {
+                        Ok(title) => title,
+                        Err(err) => {
+                            warn!("Failed to parse window title \"{}\": {}", ev.payload(), err);
+                            return;
+                        }
+                    };
+
+                    update_window_title(window_for_title.clone(), title);
+                });
+
+                let h = h.clone();
+                window.on_window_event(move |e| {
+                    match e {
+                        WindowEvent::Destroyed => {
+                            h.unlisten(id1);
+                            h.unlisten(id2);
+                        }
+                        _ => {}
+                    };
+                });
+            }
+            return;
+        })
+        .build()
+}
+
+#[cfg(target_os = "macos")]
+fn update_window_title<R: Runtime>(window: Window<R>, title: String) {
     use cocoa::{appkit::NSWindow, base::nil, foundation::NSString};
 
     unsafe {
@@ -34,7 +97,8 @@ pub(crate) fn update_window_title<R: Runtime>(window: Window<R>, title: String)
     }
 }
 
-pub(crate) fn update_window_theme<R: Runtime>(window: Window<R>, color: HexColor) {
+#[cfg(target_os = "macos")]
+fn update_window_theme<R: Runtime>(window: Window<R>, color: HexColor) {
     use cocoa::appkit::{
         NSAppearance, NSAppearanceNameVibrantDark, NSAppearanceNameVibrantLight, NSWindow,
     };
@@ -65,12 +129,8 @@ pub(crate) fn update_window_theme<R: Runtime>(window: Window<R>, color: HexColor
     }
 }
 
-fn position_traffic_lights(
-    ns_window_handle: UnsafeWindowHandle,
-    x: f64,
-    y: f64,
-    label: String,
-) {
+#[cfg(target_os = "macos")]
+fn position_traffic_lights(ns_window_handle: UnsafeWindowHandle, x: f64, y: f64, label: String) {
     if !label.starts_with(MAIN_WINDOW_PREFIX) {
         return;
     }
@@ -79,7 +139,6 @@ fn position_traffic_lights(
     use cocoa::foundation::NSRect;
 
     let ns_window = ns_window_handle.0 as cocoa::base::id;
-    #[allow(unexpected_cfgs)]
     unsafe {
         let close = ns_window.standardWindowButton_(NSWindowButton::NSWindowCloseButton);
         let miniaturize =
@@ -108,19 +167,19 @@ fn position_traffic_lights(
     }
 }
 
+#[cfg(target_os = "macos")]
 #[derive(Debug)]
 struct WindowState<R: Runtime> {
     window: Window<R>,
 }
 
+#[cfg(target_os = "macos")]
 pub fn setup_traffic_light_positioner<R: Runtime>(window: &Window<R>) {
     use cocoa::appkit::NSWindow;
-    use cocoa::base::{BOOL, id};
+    use cocoa::base::{id, BOOL};
     use cocoa::delegate;
     use cocoa::foundation::NSUInteger;
     use objc::runtime::{Object, Sel};
-    use rand::Rng;
-    use rand::distr::Alphanumeric;
     use std::ffi::c_void;
 
     position_traffic_lights(
@@ -142,7 +201,6 @@ pub fn setup_traffic_light_positioner<R: Runtime>(window: &Window<R>) {
         func(ptr);
     }
 
-    #[allow(unexpected_cfgs)]
     unsafe {
         let ns_win =
             window.ns_window().expect("NS Window should exist to mount traffic light delegate.")
@@ -362,7 +420,7 @@ pub fn setup_traffic_light_positioner<R: Runtime>(window: &Window<R>) {
         };
         let app_box = Box::into_raw(Box::new(app_state)) as *mut c_void;
         let random_str: String =
-            rand::rng().sample_iter(&Alphanumeric).take(20).map(char::from).collect();
+            rand::thread_rng().sample_iter(&Alphanumeric).take(20).map(char::from).collect();
 
         // We need to ensure we have a unique delegate name, otherwise we will panic while trying to create a duplicate
         // delegate with the same name.
@@ -373,26 +431,26 @@ pub fn setup_traffic_light_positioner<R: Runtime>(window: &Window<R>) {
             app_box: *mut c_void = app_box,
             toolbar: id = cocoa::base::nil,
             super_delegate: id = current_delegate,
-            (windowShouldClose:) => on_window_should_close as extern "C" fn(&Object, Sel, id) -> BOOL,
-            (windowWillClose:) => on_window_will_close as extern "C" fn(&Object, Sel, id),
-            (windowDidResize:) => on_window_did_resize::<R> as extern "C" fn(&Object, Sel, id),
-            (windowDidMove:) => on_window_did_move as extern "C" fn(&Object, Sel, id),
-            (windowDidChangeBackingProperties:) => on_window_did_change_backing_properties as extern "C" fn(&Object, Sel, id),
-            (windowDidBecomeKey:) => on_window_did_become_key as extern "C" fn(&Object, Sel, id),
-            (windowDidResignKey:) => on_window_did_resign_key as extern "C" fn(&Object, Sel, id),
-            (draggingEntered:) => on_dragging_entered as extern "C" fn(&Object, Sel, id) -> BOOL,
-            (prepareForDragOperation:) => on_prepare_for_drag_operation as extern "C" fn(&Object, Sel, id) -> BOOL,
-            (performDragOperation:) => on_perform_drag_operation as extern "C" fn(&Object, Sel, id) -> BOOL,
-            (concludeDragOperation:) => on_conclude_drag_operation as extern "C" fn(&Object, Sel, id),
-            (draggingExited:) => on_dragging_exited as extern "C" fn(&Object, Sel, id),
-            (window:willUseFullScreenPresentationOptions:) => on_window_will_use_full_screen_presentation_options as extern "C" fn(&Object, Sel, id, NSUInteger) -> NSUInteger,
-            (windowDidEnterFullScreen:) => on_window_did_enter_full_screen::<R> as extern "C" fn(&Object, Sel, id),
-            (windowWillEnterFullScreen:) => on_window_will_enter_full_screen::<R> as extern "C" fn(&Object, Sel, id),
-            (windowDidExitFullScreen:) => on_window_did_exit_full_screen::<R> as extern "C" fn(&Object, Sel, id),
-            (windowWillExitFullScreen:) => on_window_will_exit_full_screen::<R> as extern "C" fn(&Object, Sel, id),
-            (windowDidFailToEnterFullScreen:) => on_window_did_fail_to_enter_full_screen as extern "C" fn(&Object, Sel, id),
-            (effectiveAppearanceDidChange:) => on_effective_appearance_did_change as extern "C" fn(&Object, Sel, id),
-            (effectiveAppearanceDidChangedOnMainThread:) => on_effective_appearance_did_changed_on_main_thread as extern "C" fn(&Object, Sel, id)
+            (windowShouldClose:) => on_window_should_close as extern fn(&Object, Sel, id) -> BOOL,
+            (windowWillClose:) => on_window_will_close as extern fn(&Object, Sel, id),
+            (windowDidResize:) => on_window_did_resize::<R> as extern fn(&Object, Sel, id),
+            (windowDidMove:) => on_window_did_move as extern fn(&Object, Sel, id),
+            (windowDidChangeBackingProperties:) => on_window_did_change_backing_properties as extern fn(&Object, Sel, id),
+            (windowDidBecomeKey:) => on_window_did_become_key as extern fn(&Object, Sel, id),
+            (windowDidResignKey:) => on_window_did_resign_key as extern fn(&Object, Sel, id),
+            (draggingEntered:) => on_dragging_entered as extern fn(&Object, Sel, id) -> BOOL,
+            (prepareForDragOperation:) => on_prepare_for_drag_operation as extern fn(&Object, Sel, id) -> BOOL,
+            (performDragOperation:) => on_perform_drag_operation as extern fn(&Object, Sel, id) -> BOOL,
+            (concludeDragOperation:) => on_conclude_drag_operation as extern fn(&Object, Sel, id),
+            (draggingExited:) => on_dragging_exited as extern fn(&Object, Sel, id),
+            (window:willUseFullScreenPresentationOptions:) => on_window_will_use_full_screen_presentation_options as extern fn(&Object, Sel, id, NSUInteger) -> NSUInteger,
+            (windowDidEnterFullScreen:) => on_window_did_enter_full_screen::<R> as extern fn(&Object, Sel, id),
+            (windowWillEnterFullScreen:) => on_window_will_enter_full_screen::<R> as extern fn(&Object, Sel, id),
+            (windowDidExitFullScreen:) => on_window_did_exit_full_screen::<R> as extern fn(&Object, Sel, id),
+            (windowWillExitFullScreen:) => on_window_will_exit_full_screen::<R> as extern fn(&Object, Sel, id),
+            (windowDidFailToEnterFullScreen:) => on_window_did_fail_to_enter_full_screen as extern fn(&Object, Sel, id),
+            (effectiveAppearanceDidChange:) => on_effective_appearance_did_change as extern fn(&Object, Sel, id),
+            (effectiveAppearanceDidChangedOnMainThread:) => on_effective_appearance_did_changed_on_main_thread as extern fn(&Object, Sel, id)
         }))
     }
 }

src-tauri/src/template_callback.rs

@@ -0,0 +1,75 @@
+use std::collections::HashMap;
+use tauri::{AppHandle, Manager, Runtime};
+use yaak_plugins::events::{FormInput, RenderPurpose, WindowContext};
+use yaak_plugins::manager::PluginManager;
+use yaak_templates::TemplateCallback;
+
+#[derive(Clone)]
+pub struct PluginTemplateCallback {
+    plugin_manager: PluginManager,
+    window_context: WindowContext,
+    render_purpose: RenderPurpose,
+}
+
+impl PluginTemplateCallback {
+    pub fn new<R: Runtime>(
+        app_handle: &AppHandle<R>,
+        window_context: &WindowContext,
+        render_purpose: RenderPurpose,
+    ) -> PluginTemplateCallback {
+        let plugin_manager = &*app_handle.state::<PluginManager>();
+        PluginTemplateCallback {
+            plugin_manager: plugin_manager.to_owned(),
+            window_context: window_context.to_owned(),
+            render_purpose,
+        }
+    }
+}
+
+impl TemplateCallback for PluginTemplateCallback {
+    async fn run(&self, fn_name: &str, args: HashMap<String, String>) -> Result<String, String> {
+        let window_context = self.window_context.to_owned();
+        // The beta named the function `Response` but was changed in stable.
+        // Keep this here for a while because there's no easy way to migrate
+        let fn_name = if fn_name == "Response" { "response" } else { fn_name };
+
+        let function = self
+            .plugin_manager
+            .get_template_functions_with_context(window_context.to_owned())
+            .await
+            .map_err(|e| e.to_string())?
+            .iter()
+            .flat_map(|f| f.functions.clone())
+            .find(|f| f.name == fn_name)
+            .ok_or("")?;
+
+        let mut args_with_defaults = args.clone();
+
+        // Fill in default values for all args
+        for arg in function.args {
+            let base = match arg {
+                FormInput::Text(a) => a.base,
+                FormInput::Editor(a) => a.base,
+                FormInput::Select(a) => a.base,
+                FormInput::Checkbox(a) => a.base,
+                FormInput::File(a) => a.base,
+                FormInput::HttpRequest(a) => a.base,
+            };
+            if let None = args_with_defaults.get(base.name.as_str()) {
+                args_with_defaults.insert(base.name, base.default_value.unwrap_or_default());
+            }
+        }
+
+        let resp = self
+            .plugin_manager
+            .call_template_function(
+                window_context,
+                fn_name,
+                args_with_defaults,
+                self.render_purpose.to_owned(),
+            )
+            .await
+            .map_err(|e| e.to_string())?;
+        Ok(resp.unwrap_or_default())
+    }
+}

src-tauri/src/updates.rs

@@ -1,13 +1,11 @@
 use std::fmt::{Display, Formatter};
 use std::time::SystemTime;
 
-use crate::error::Result;
 use log::info;
-use tauri::{Manager, Runtime, WebviewWindow};
+use tauri::{AppHandle, Manager};
 use tauri_plugin_dialog::{DialogExt, MessageDialogButtons};
 use tauri_plugin_updater::UpdaterExt;
 use tokio::task::block_in_place;
-use yaak_models::query_manager::QueryManagerExt;
 use yaak_plugins::manager::PluginManager;
 
 use crate::is_dev;
@@ -48,11 +46,6 @@ impl UpdateMode {
     }
 }
 
-pub enum UpdateTrigger {
-    Background,
-    User,
-}
-
 impl YaakUpdater {
     pub fn new() -> Self {
         Self {
@@ -60,52 +53,41 @@ impl YaakUpdater {
         }
     }
 
-    pub async fn check_now<R: Runtime>(
+    pub async fn force_check(
         &mut self,
-        window: &WebviewWindow<R>,
+        app_handle: &AppHandle,
         mode: UpdateMode,
-        update_trigger: UpdateTrigger,
-    ) -> Result<bool> {
-        let settings = window.db().get_settings();
-        let update_key = format!("{:x}", md5::compute(settings.id));
+    ) -> Result<bool, tauri_plugin_updater::Error> {
         self.last_update_check = SystemTime::now();
 
         info!("Checking for updates mode={}", mode);
 
-        let w = window.clone();
-        let update_check_result = w
+        let h = app_handle.clone();
+        let update_check_result = app_handle
             .updater_builder()
             .on_before_exit(move || {
                 // Kill plugin manager before exit or NSIS installer will fail to replace sidecar
                 // while it's running.
                 // NOTE: This is only called on Windows
-                let w = w.clone();
+                let h = h.clone();
                 block_in_place(|| {
                     tauri::async_runtime::block_on(async move {
                         info!("Shutting down plugin manager before update");
-                        let plugin_manager = w.state::<PluginManager>();
+                        let plugin_manager = h.state::<PluginManager>();
                         plugin_manager.terminate().await;
                     });
                 });
             })
             .header("X-Update-Mode", mode.to_string())?
-            .header("X-Update-Key", update_key)?
-            .header(
-                "X-Update-Trigger",
-                match update_trigger {
-                    UpdateTrigger::Background => "background",
-                    UpdateTrigger::User => "user",
-                },
-            )?
             .build()?
             .check()
             .await;
 
-        let result = match update_check_result? {
-            None => false,
-            Some(update) => {
-                let w = window.clone();
-                w.dialog()
+        match update_check_result {
+            Ok(Some(update)) => {
+                let h = app_handle.clone();
+                app_handle
+                    .dialog()
                     .message(format!(
                         "{} is available. Would you like to download and install it now?",
                         update.version
@@ -122,7 +104,7 @@ impl YaakUpdater {
                         tauri::async_runtime::spawn(async move {
                             match update.download_and_install(|_, _| {}, || {}).await {
                                 Ok(_) => {
-                                    if w.dialog()
+                                    if h.dialog()
                                         .message("Would you like to restart the app?")
                                         .title("Update Installed")
                                         .buttons(MessageDialogButtons::OkCancelCustom(
@@ -131,27 +113,27 @@ impl YaakUpdater {
                                         ))
                                         .blocking_show()
                                     {
-                                        w.app_handle().restart();
+                                        h.restart();
                                     }
                                 }
                                 Err(e) => {
-                                    w.dialog()
+                                    h.dialog()
                                         .message(format!("The update failed to install: {}", e));
                                 }
                             }
                         });
                     });
-                true
+                Ok(true)
             }
-        };
-
-        Ok(result)
+            Ok(None) => Ok(false),
+            Err(e) => Err(e),
+        }
     }
-    pub async fn maybe_check<R: Runtime>(
+    pub async fn check(
         &mut self,
-        window: &WebviewWindow<R>,
+        app_handle: &AppHandle,
         mode: UpdateMode,
-    ) -> Result<bool> {
+    ) -> Result<bool, tauri_plugin_updater::Error> {
         let update_period_seconds = match mode {
             UpdateMode::Stable => MAX_UPDATE_CHECK_HOURS_STABLE,
             UpdateMode::Beta => MAX_UPDATE_CHECK_HOURS_BETA,
@@ -168,6 +150,6 @@ impl YaakUpdater {
             return Ok(false);
         }
 
-        self.check_now(window, mode, UpdateTrigger::Background).await
+        self.force_check(app_handle, mode).await
     }
 }

src-tauri/src/uri_scheme.rs

@@ -1,25 +0,0 @@
-use log::{info, warn};
-use tauri::{Manager, Runtime, UriSchemeContext};
-
-pub(crate) fn handle_uri_scheme<R: Runtime>(
-    a: UriSchemeContext<R>,
-    req: http::Request<Vec<u8>>,
-) -> http::Response<Vec<u8>> {
-    println!("------------- Yaak URI scheme invoked!");
-    let uri = req.uri();
-    let window = a
-        .app_handle()
-        .get_webview_window(a.webview_label())
-        .expect("Failed to get webview window for URI scheme event");
-    info!("Yaak URI scheme invoked with {uri:?} {window:?}");
-
-    let path = uri.path();
-    if path == "/data/import" {
-        warn!("TODO: import data")
-    } else if path == "/plugins/install" {
-        warn!("TODO: install plugin")
-    }
-
-    let msg = format!("No handler found for {path}");
-    tauri::http::Response::builder().status(404).body(msg.as_bytes().to_vec()).unwrap()
-}

src-tauri/src/window.rs

@@ -1,264 +0,0 @@
-use crate::window_menu::app_menu;
-use log::{info, warn};
-use rand::random;
-use std::process::exit;
-use tauri::{
-    AppHandle, Emitter, LogicalSize, Manager, Runtime, WebviewUrl, WebviewWindow, WindowEvent,
-};
-use tauri_plugin_opener::OpenerExt;
-use tokio::sync::mpsc;
-
-const DEFAULT_WINDOW_WIDTH: f64 = 1100.0;
-const DEFAULT_WINDOW_HEIGHT: f64 = 600.0;
-
-const MIN_WINDOW_WIDTH: f64 = 300.0;
-const MIN_WINDOW_HEIGHT: f64 = 300.0;
-
-pub(crate) const MAIN_WINDOW_PREFIX: &str = "main_";
-const OTHER_WINDOW_PREFIX: &str = "other_";
-
-#[derive(Default, Debug)]
-pub(crate) struct CreateWindowConfig<'s> {
-    pub url: &'s str,
-    pub label: &'s str,
-    pub title: &'s str,
-    pub inner_size: Option<(f64, f64)>,
-    pub position: Option<(f64, f64)>,
-    pub navigation_tx: Option<mpsc::Sender<String>>,
-    pub close_tx: Option<mpsc::Sender<()>>,
-    pub data_dir_key: Option<String>,
-    pub hide_titlebar: bool,
-}
-
-pub(crate) fn create_window<R: Runtime>(
-    handle: &AppHandle<R>,
-    config: CreateWindowConfig,
-) -> WebviewWindow<R> {
-    #[allow(unused_variables)]
-    let menu = app_menu(handle).unwrap();
-
-    // This causes the window to not be clickable (in AppImage), so disable on Linux
-    #[cfg(not(target_os = "linux"))]
-    handle.set_menu(menu).expect("Failed to set app menu");
-
-    info!("Create new window label={}", config.label);
-
-    let mut win_builder =
-        tauri::WebviewWindowBuilder::new(handle, config.label, WebviewUrl::App(config.url.into()))
-            .title(config.title)
-            .resizable(true)
-            .visible(false) // To prevent theme flashing, the frontend code calls show() immediately after configuring the theme
-            .fullscreen(false)
-            .disable_drag_drop_handler() // Required for frontend Dnd on windows
-            .min_inner_size(MIN_WINDOW_WIDTH, MIN_WINDOW_HEIGHT);
-
-    if let Some(key) = config.data_dir_key {
-        #[cfg(not(target_os = "macos"))]
-        {
-            use std::fs;
-            let dir = handle.path().temp_dir().unwrap().join("yaak_sessions").join(key);
-            fs::create_dir_all(dir.clone()).unwrap();
-            win_builder = win_builder.data_directory(dir);
-        }
-
-        // macOS doesn't support data dir so must use this fn instead
-        #[cfg(target_os = "macos")]
-        {
-            let hash = md5::compute(key.as_bytes());
-            let mut id = [0u8; 16];
-            id.copy_from_slice(&hash[..16]); // Take the first 16 bytes of the hash
-            win_builder = win_builder.data_store_identifier(id);
-        }
-    }
-
-    if let Some((w, h)) = config.inner_size {
-        win_builder = win_builder.inner_size(w, h);
-    } else {
-        win_builder = win_builder.inner_size(600.0, 600.0);
-    }
-
-    if let Some((x, y)) = config.position {
-        win_builder = win_builder.position(x, y);
-    } else {
-        win_builder = win_builder.center();
-    }
-
-    if let Some(tx) = config.navigation_tx {
-        win_builder = win_builder.on_navigation(move |url| {
-            let url = url.to_string();
-            let tx = tx.clone();
-            tauri::async_runtime::block_on(async move {
-                tx.send(url).await.unwrap();
-            });
-            true
-        });
-    }
-
-    if config.hide_titlebar {
-        #[cfg(target_os = "macos")]
-        {
-            use tauri::TitleBarStyle;
-            win_builder = win_builder.hidden_title(true).title_bar_style(TitleBarStyle::Overlay);
-        }
-        #[cfg(not(target_os = "macos"))]
-        {
-            // Doesn't seem to work from Rust, here, so we do it in main.tsx
-            win_builder = win_builder.decorations(false);
-        }
-    }
-
-    if let Some(w) = handle.webview_windows().get(config.label) {
-        info!("Webview with label {} already exists. Focusing existing", config.label);
-        w.set_focus().unwrap();
-        return w.to_owned();
-    }
-
-    let win = win_builder.build().unwrap();
-
-    if let Some(tx) = config.close_tx {
-        win.on_window_event(move |event| match event {
-            WindowEvent::CloseRequested { .. } => {
-                let tx = tx.clone();
-                tauri::async_runtime::block_on(async move {
-                    tx.send(()).await.unwrap();
-                });
-            }
-            _ => {}
-        });
-    }
-
-    let webview_window = win.clone();
-    win.on_menu_event(move |w, event| {
-        if !w.is_focused().unwrap() {
-            return;
-        }
-
-        let event_id = event.id().0.as_str();
-        match event_id {
-            "quit" => exit(0),
-            "close" => w.close().unwrap(),
-            "zoom_reset" => w.emit("zoom_reset", true).unwrap(),
-            "zoom_in" => w.emit("zoom_in", true).unwrap(),
-            "zoom_out" => w.emit("zoom_out", true).unwrap(),
-            "settings" => w.emit("settings", true).unwrap(),
-            "open_feedback" => {
-                if let Err(e) =
-                    w.app_handle().opener().open_url("https://yaak.app/feedback", None::<&str>)
-                {
-                    warn!("Failed to open feedback {e:?}")
-                }
-            }
-
-            // Commands for development
-            "dev.reset_size" => webview_window
-                .set_size(LogicalSize::new(DEFAULT_WINDOW_WIDTH, DEFAULT_WINDOW_HEIGHT))
-                .unwrap(),
-            "dev.refresh" => webview_window.eval("location.reload()").unwrap(),
-            "dev.generate_theme_css" => {
-                w.emit("generate_theme_css", true).unwrap();
-            }
-            "dev.toggle_devtools" => {
-                if webview_window.is_devtools_open() {
-                    webview_window.close_devtools();
-                } else {
-                    webview_window.open_devtools();
-                }
-            }
-            _ => {}
-        }
-    });
-
-    win
-}
-
-pub(crate) fn create_main_window(handle: &AppHandle, url: &str) -> WebviewWindow {
-    let mut counter = 0;
-    let label = loop {
-        let label = format!("{MAIN_WINDOW_PREFIX}{counter}");
-        match handle.webview_windows().get(label.as_str()) {
-            None => break Some(label),
-            Some(_) => counter += 1,
-        }
-    }
-    .expect("Failed to generate label for new window");
-
-    let config = CreateWindowConfig {
-        url,
-        label: label.as_str(),
-        title: "Yaak",
-        inner_size: Some((DEFAULT_WINDOW_WIDTH, DEFAULT_WINDOW_HEIGHT)),
-        position: Some((
-            // Offset by random amount so it's easier to differentiate
-            100.0 + random::<f64>() * 20.0,
-            100.0 + random::<f64>() * 20.0,
-        )),
-        hide_titlebar: true,
-        ..Default::default()
-    };
-
-    create_window(handle, config)
-}
-
-pub(crate) fn create_child_window(parent_window: &WebviewWindow, url: &str, label: &str, title: &str, inner_size: (f64, f64)) -> WebviewWindow {
-    let app_handle = parent_window.app_handle();
-    let label = format!("{OTHER_WINDOW_PREFIX}_{label}");
-    let scale_factor = parent_window.scale_factor().unwrap();
-
-    let current_pos = parent_window.inner_position().unwrap().to_logical::<f64>(scale_factor);
-    let current_size = parent_window.inner_size().unwrap().to_logical::<f64>(scale_factor);
-
-    // Position the new window in the middle of the parent
-    let position = (
-        current_pos.x + current_size.width / 2.0 - inner_size.0 / 2.0,
-        current_pos.y + current_size.height / 2.0 - inner_size.1 / 2.0,
-    );
-
-    let config = CreateWindowConfig {
-        label: label.as_str(),
-        title,
-        url,
-        inner_size: Some(inner_size),
-        position: Some(position),
-        hide_titlebar: true,
-        ..Default::default()
-    };
-
-    let child_window = create_window(&app_handle, config);
-
-    // NOTE: These listeners will remain active even when the windows close. Unfortunately,
-    //   there's no way to unlisten to events for now, so we just have to be defensive.
-
-    {
-        let parent_window = parent_window.clone();
-        let child_window = child_window.clone();
-        child_window.clone().on_window_event(move |e| match e {
-            // When the new window is destroyed, bring the other up behind it
-            WindowEvent::Destroyed => {
-                if let Some(w) = parent_window.get_webview_window(child_window.label()) {
-                    w.set_focus().unwrap();
-                }
-            }
-            _ => {}
-        });
-    }
-
-    {
-        let parent_window = parent_window.clone();
-        let child_window = child_window.clone();
-        parent_window.clone().on_window_event(move |e| match e {
-            // When the parent window is closed, close the child
-            WindowEvent::CloseRequested { .. } => child_window.destroy().unwrap(),
-            // When the parent window is focused, bring the child above
-            WindowEvent::Focused(focus) => {
-                if *focus {
-                    if let Some(w) = parent_window.get_webview_window(child_window.label()) {
-                        w.set_focus().unwrap();
-                    };
-                }
-            }
-            _ => {}
-        });
-    }
-    
-    child_window
-}

src-tauri/src/window_menu.rs

@@ -3,9 +3,9 @@ use tauri::menu::{
     WINDOW_SUBMENU_ID,
 };
 pub use tauri::AppHandle;
-use tauri::Runtime;
+use tauri::Wry;
 
-pub fn app_menu<R: Runtime>(app_handle: &AppHandle<R>) -> tauri::Result<Menu<R>> {
+pub fn app_menu(app_handle: &AppHandle) -> tauri::Result<Menu<Wry>> {
     let pkg_info = app_handle.package_info();
     let config = app_handle.config();
     let about_metadata = AboutMetadata {
@@ -37,7 +37,7 @@ pub fn app_menu<R: Runtime>(app_handle: &AppHandle<R>) -> tauri::Result<Menu<R>>
         true,
         &[
             #[cfg(not(target_os = "macos"))]
-            &PredefinedMenuItem::about(app_handle, None, Some(about_metadata.clone()))?,
+            &PredefinedMenuItem::about(app_handle, None, Some(about_metadata))?,
             #[cfg(target_os = "macos")]
             &MenuItemBuilder::with_id("open_feedback".to_string(), "Give Feedback")
                 .build(app_handle)?,

src-tauri/vendored/plugins/auth-basic/build/index.js

@@ -28,7 +28,7 @@ var plugin = {
     name: "basic",
     label: "Basic Auth",
     shortLabel: "Basic",
-    args: [{
+    config: [{
       type: "text",
       name: "username",
       label: "Username",
@@ -40,8 +40,8 @@ var plugin = {
       optional: true,
       password: true
     }],
-    async onApply(_ctx, { values }) {
-      const { username, password } = values;
+    async onApply(_ctx, args) {
+      const { username, password } = args.config;
       const value = "Basic " + Buffer.from(`${username}:${password}`).toString("base64");
       return { setHeaders: [{ name: "Authorization", value }] };
     }

src-tauri/vendored/plugins/auth-bearer/build/index.js

@@ -28,15 +28,15 @@ var plugin = {
     name: "bearer",
     label: "Bearer Token",
     shortLabel: "Bearer",
-    args: [{
+    config: [{
       type: "text",
       name: "token",
       label: "Token",
       optional: true,
       password: true
     }],
-    async onApply(_ctx, { values }) {
-      const { token } = values;
+    async onApply(_ctx, args) {
+      const { token } = args.config;
       const value = `Bearer ${token}`.trim();
       return { setHeaders: [{ name: "Authorization", value }] };
     }

src-tauri/vendored/plugins/auth-jwt/build/index.js

@@ -1044,7 +1044,6 @@ var require_re = __commonJS({
     var re = exports2.re = [];
     var safeRe = exports2.safeRe = [];
     var src = exports2.src = [];
-    var safeSrc = exports2.safeSrc = [];
     var t = exports2.t = {};
     var R = 0;
     var LETTERDASHNUMBER = "[a-zA-Z0-9-]";
@@ -1065,7 +1064,6 @@ var require_re = __commonJS({
       debug(name, index, value);
       t[name] = index;
       src[index] = value;
-      safeSrc[index] = safe;
       re[index] = new RegExp(value, isGlobal ? "g" : void 0);
       safeRe[index] = new RegExp(safe, isGlobal ? "g" : void 0);
     };
@@ -1162,7 +1160,7 @@ var require_semver = __commonJS({
   "../../node_modules/semver/classes/semver.js"(exports2, module2) {
     var debug = require_debug();
     var { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants();
-    var { safeRe: re, safeSrc: src, t } = require_re();
+    var { safeRe: re, t } = require_re();
     var parseOptions = require_parse_options();
     var { compareIdentifiers } = require_identifiers();
     var SemVer = class _SemVer {
@@ -1302,18 +1300,6 @@ var require_semver = __commonJS({
       // preminor will bump the version up to the next minor release, and immediately
       // down to pre-release. premajor and prepatch work the same way.
       inc(release, identifier, identifierBase) {
-        if (release.startsWith("pre")) {
-          if (!identifier && identifierBase === false) {
-            throw new Error("invalid increment argument: identifier is empty");
-          }
-          if (identifier) {
-            const r = new RegExp(`^${this.options.loose ? src[t.PRERELEASELOOSE] : src[t.PRERELEASE]}$`);
-            const match = `-${identifier}`.match(r);
-            if (!match || match[1] !== identifier) {
-              throw new Error(`invalid identifier: ${identifier}`);
-            }
-          }
-        }
         switch (release) {
           case "premajor":
             this.prerelease.length = 0;
@@ -1339,12 +1325,6 @@ var require_semver = __commonJS({
             }
             this.inc("pre", identifier, identifierBase);
             break;
-          case "release":
-            if (this.prerelease.length === 0) {
-              throw new Error(`version ${this.raw} is not a prerelease`);
-            }
-            this.prerelease.length = 0;
-            break;
           case "major":
             if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {
               this.major++;
@@ -1368,6 +1348,9 @@ var require_semver = __commonJS({
             break;
           case "pre": {
             const base = Number(identifierBase) ? 1 : 0;
+            if (!identifier && identifierBase === false) {
+              throw new Error("invalid increment argument: identifier is empty");
+            }
             if (this.prerelease.length === 0) {
               this.prerelease = [base];
             } else {
@@ -1502,12 +1485,13 @@ var require_diff = __commonJS({
         if (!lowVersion.patch && !lowVersion.minor) {
           return "major";
         }
-        if (lowVersion.compareMain(highVersion) === 0) {
-          if (lowVersion.minor && !lowVersion.patch) {
-            return "minor";
-          }
+        if (highVersion.patch) {
           return "patch";
         }
+        if (highVersion.minor) {
+          return "minor";
+        }
+        return "major";
       }
       const prefix = highHasPre ? "pre" : "";
       if (v1.major !== v2.major) {
@@ -3830,22 +3814,21 @@ var plugin = {
     name: "jwt",
     label: "JWT Bearer",
     shortLabel: "JWT",
-    args: [
+    config: [
       {
         type: "select",
         name: "algorithm",
         label: "Algorithm",
         hideLabel: true,
         defaultValue: defaultAlgorithm,
-        options: algorithms.map((value) => ({ label: value === "none" ? "None" : value, value }))
+        options: algorithms.map((value) => ({ name: value === "none" ? "None" : value, value }))
       },
       {
-        type: "text",
+        type: "editor",
         name: "secret",
         label: "Secret or Private Key",
-        password: true,
         optional: true,
-        multiLine: true
+        hideGutter: true
       },
       {
         type: "checkbox",
@@ -3861,8 +3844,8 @@ var plugin = {
         placeholder: "{ }"
       }
     ],
-    async onApply(_ctx, { values }) {
-      const { algorithm, secret: _secret, secretBase64, payload } = values;
+    async onApply(_ctx, args) {
+      const { algorithm, secret: _secret, secretBase64, payload } = args.config;
       const secret = secretBase64 ? Buffer.from(`${_secret}`, "base64") : `${_secret}`;
       const token = import_jsonwebtoken.default.sign(`${payload}`, secret, { algorithm });
       const value = `Bearer ${token}`;

src-tauri/vendored/plugins/auth-oauth2/build/index.js

@@ -1,728 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  plugin: () => plugin
-});
-module.exports = __toCommonJS(src_exports);
-
-// src/grants/authorizationCode.ts
-var import_node_crypto = require("node:crypto");
-
-// src/getAccessToken.ts
-var import_node_fs = require("node:fs");
-async function getAccessToken(ctx, {
-  accessTokenUrl,
-  scope,
-  audience,
-  params,
-  grantType,
-  credentialsInBody,
-  clientId,
-  clientSecret
-}) {
-  console.log("Getting access token", accessTokenUrl);
-  const httpRequest = {
-    method: "POST",
-    url: accessTokenUrl,
-    bodyType: "application/x-www-form-urlencoded",
-    body: {
-      form: [
-        { name: "grant_type", value: grantType },
-        ...params
-      ]
-    },
-    headers: [
-      { name: "User-Agent", value: "yaak" },
-      { name: "Accept", value: "application/x-www-form-urlencoded, application/json" },
-      { name: "Content-Type", value: "application/x-www-form-urlencoded" }
-    ]
-  };
-  if (scope) httpRequest.body.form.push({ name: "scope", value: scope });
-  if (scope) httpRequest.body.form.push({ name: "audience", value: audience });
-  if (credentialsInBody) {
-    httpRequest.body.form.push({ name: "client_id", value: clientId });
-    httpRequest.body.form.push({ name: "client_secret", value: clientSecret });
-  } else {
-    const value = "Basic " + Buffer.from(`${clientId}:${clientSecret}`).toString("base64");
-    httpRequest.headers.push({ name: "Authorization", value });
-  }
-  const resp = await ctx.httpRequest.send({ httpRequest });
-  const body = resp.bodyPath ? (0, import_node_fs.readFileSync)(resp.bodyPath, "utf8") : "";
-  if (resp.status < 200 || resp.status >= 300) {
-    throw new Error("Failed to fetch access token with status=" + resp.status + " and body=" + body);
-  }
-  let response;
-  try {
-    response = JSON.parse(body);
-  } catch {
-    response = Object.fromEntries(new URLSearchParams(body));
-  }
-  if (response.error) {
-    throw new Error("Failed to fetch access token with " + response.error);
-  }
-  return response;
-}
-
-// src/getOrRefreshAccessToken.ts
-var import_node_fs2 = require("node:fs");
-
-// src/store.ts
-async function storeToken(ctx, contextId, response) {
-  if (!response.access_token) {
-    throw new Error(`Token not found in response`);
-  }
-  const expiresAt = response.expires_in ? Date.now() + response.expires_in * 1e3 : null;
-  const token = {
-    response,
-    expiresAt
-  };
-  await ctx.store.set(tokenStoreKey(contextId), token);
-  return token;
-}
-async function getToken(ctx, contextId) {
-  return ctx.store.get(tokenStoreKey(contextId));
-}
-async function deleteToken(ctx, contextId) {
-  return ctx.store.delete(tokenStoreKey(contextId));
-}
-async function resetDataDirKey(ctx, contextId) {
-  const key = (/* @__PURE__ */ new Date()).toISOString();
-  return ctx.store.set(dataDirStoreKey(contextId), key);
-}
-async function getDataDirKey(ctx, contextId) {
-  const key = await ctx.store.get(dataDirStoreKey(contextId)) ?? "default";
-  return `${contextId}::${key}`;
-}
-function tokenStoreKey(context_id) {
-  return ["token", context_id].join("::");
-}
-function dataDirStoreKey(context_id) {
-  return ["data_dir", context_id].join("::");
-}
-
-// src/getOrRefreshAccessToken.ts
-async function getOrRefreshAccessToken(ctx, contextId, {
-  scope,
-  accessTokenUrl,
-  credentialsInBody,
-  clientId,
-  clientSecret,
-  forceRefresh
-}) {
-  const token = await getToken(ctx, contextId);
-  if (token == null) {
-    return null;
-  }
-  const now = Date.now();
-  const isExpired = token.expiresAt && now > token.expiresAt;
-  if (!isExpired && !forceRefresh) {
-    return token;
-  }
-  if (!token.response.refresh_token) {
-    return null;
-  }
-  const httpRequest = {
-    method: "POST",
-    url: accessTokenUrl,
-    bodyType: "application/x-www-form-urlencoded",
-    body: {
-      form: [
-        { name: "grant_type", value: "refresh_token" },
-        { name: "refresh_token", value: token.response.refresh_token }
-      ]
-    },
-    headers: [
-      { name: "User-Agent", value: "yaak" },
-      { name: "Accept", value: "application/x-www-form-urlencoded, application/json" },
-      { name: "Content-Type", value: "application/x-www-form-urlencoded" }
-    ]
-  };
-  if (scope) httpRequest.body.form.push({ name: "scope", value: scope });
-  if (credentialsInBody) {
-    httpRequest.body.form.push({ name: "client_id", value: clientId });
-    httpRequest.body.form.push({ name: "client_secret", value: clientSecret });
-  } else {
-    const value = "Basic " + Buffer.from(`${clientId}:${clientSecret}`).toString("base64");
-    httpRequest.headers.push({ name: "Authorization", value });
-  }
-  const resp = await ctx.httpRequest.send({ httpRequest });
-  if (resp.status === 401) {
-    console.log("Unauthorized refresh_token request");
-    await deleteToken(ctx, contextId);
-    return null;
-  }
-  const body = resp.bodyPath ? (0, import_node_fs2.readFileSync)(resp.bodyPath, "utf8") : "";
-  if (resp.status < 200 || resp.status >= 300) {
-    throw new Error("Failed to refresh access token with status=" + resp.status + " and body=" + body);
-  }
-  let response;
-  try {
-    response = JSON.parse(body);
-  } catch {
-    response = Object.fromEntries(new URLSearchParams(body));
-  }
-  if (response.error) {
-    throw new Error(`Failed to fetch access token with ${response.error} -> ${response.error_description}`);
-  }
-  const newResponse = {
-    ...response,
-    // Assign a new one or keep the old one,
-    refresh_token: response.refresh_token ?? token.response.refresh_token
-  };
-  return storeToken(ctx, contextId, newResponse);
-}
-
-// src/grants/authorizationCode.ts
-var PKCE_SHA256 = "S256";
-var PKCE_PLAIN = "plain";
-var DEFAULT_PKCE_METHOD = PKCE_SHA256;
-async function getAuthorizationCode(ctx, contextId, {
-  authorizationUrl: authorizationUrlRaw,
-  accessTokenUrl,
-  clientId,
-  clientSecret,
-  redirectUri,
-  scope,
-  state,
-  audience,
-  credentialsInBody,
-  pkce
-}) {
-  const token = await getOrRefreshAccessToken(ctx, contextId, {
-    accessTokenUrl,
-    scope,
-    clientId,
-    clientSecret,
-    credentialsInBody
-  });
-  if (token != null) {
-    return token;
-  }
-  const authorizationUrl = new URL(`${authorizationUrlRaw ?? ""}`);
-  authorizationUrl.searchParams.set("response_type", "code");
-  authorizationUrl.searchParams.set("client_id", clientId);
-  if (redirectUri) authorizationUrl.searchParams.set("redirect_uri", redirectUri);
-  if (scope) authorizationUrl.searchParams.set("scope", scope);
-  if (state) authorizationUrl.searchParams.set("state", state);
-  if (audience) authorizationUrl.searchParams.set("audience", audience);
-  if (pkce) {
-    const verifier = pkce.codeVerifier || createPkceCodeVerifier();
-    const challengeMethod = pkce.challengeMethod || DEFAULT_PKCE_METHOD;
-    authorizationUrl.searchParams.set("code_challenge", createPkceCodeChallenge(verifier, challengeMethod));
-    authorizationUrl.searchParams.set("code_challenge_method", challengeMethod);
-  }
-  return new Promise(async (resolve, reject) => {
-    const authorizationUrlStr = authorizationUrl.toString();
-    console.log("Authorizing", authorizationUrlStr);
-    let foundCode = false;
-    let { close } = await ctx.window.openUrl({
-      url: authorizationUrlStr,
-      label: "oauth-authorization-url",
-      dataDirKey: await getDataDirKey(ctx, contextId),
-      async onClose() {
-        if (!foundCode) {
-          reject(new Error("Authorization window closed"));
-        }
-      },
-      async onNavigate({ url: urlStr }) {
-        const url = new URL(urlStr);
-        if (url.searchParams.has("error")) {
-          return reject(new Error(`Failed to authorize: ${url.searchParams.get("error")}`));
-        }
-        const code = url.searchParams.get("code");
-        if (!code) {
-          return;
-        }
-        foundCode = true;
-        close();
-        const response = await getAccessToken(ctx, {
-          grantType: "authorization_code",
-          accessTokenUrl,
-          clientId,
-          clientSecret,
-          scope,
-          audience,
-          credentialsInBody,
-          params: [
-            { name: "code", value: code },
-            ...redirectUri ? [{ name: "redirect_uri", value: redirectUri }] : []
-          ]
-        });
-        try {
-          resolve(await storeToken(ctx, contextId, response));
-        } catch (err) {
-          reject(err);
-        }
-      }
-    });
-  });
-}
-function createPkceCodeVerifier() {
-  return encodeForPkce((0, import_node_crypto.randomBytes)(32));
-}
-function createPkceCodeChallenge(verifier, method) {
-  if (method === "plain") {
-    return verifier;
-  }
-  const hash = encodeForPkce((0, import_node_crypto.createHash)("sha256").update(verifier).digest());
-  return hash.replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
-}
-function encodeForPkce(bytes) {
-  return bytes.toString("base64").replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
-}
-
-// src/grants/clientCredentials.ts
-async function getClientCredentials(ctx, contextId, {
-  accessTokenUrl,
-  clientId,
-  clientSecret,
-  scope,
-  audience,
-  credentialsInBody
-}) {
-  const token = await getToken(ctx, contextId);
-  if (token) {
-  }
-  const response = await getAccessToken(ctx, {
-    grantType: "client_credentials",
-    accessTokenUrl,
-    audience,
-    clientId,
-    clientSecret,
-    scope,
-    credentialsInBody,
-    params: []
-  });
-  return storeToken(ctx, contextId, response);
-}
-
-// src/grants/implicit.ts
-function getImplicit(ctx, contextId, {
-  authorizationUrl: authorizationUrlRaw,
-  responseType,
-  clientId,
-  redirectUri,
-  scope,
-  state,
-  audience
-}) {
-  return new Promise(async (resolve, reject) => {
-    const token = await getToken(ctx, contextId);
-    if (token) {
-    }
-    const authorizationUrl = new URL(`${authorizationUrlRaw ?? ""}`);
-    authorizationUrl.searchParams.set("response_type", "token");
-    authorizationUrl.searchParams.set("client_id", clientId);
-    if (redirectUri) authorizationUrl.searchParams.set("redirect_uri", redirectUri);
-    if (scope) authorizationUrl.searchParams.set("scope", scope);
-    if (state) authorizationUrl.searchParams.set("state", state);
-    if (audience) authorizationUrl.searchParams.set("audience", audience);
-    if (responseType.includes("id_token")) {
-      authorizationUrl.searchParams.set("nonce", String(Math.floor(Math.random() * 9999999999999) + 1));
-    }
-    const authorizationUrlStr = authorizationUrl.toString();
-    let foundAccessToken = false;
-    let { close } = await ctx.window.openUrl({
-      url: authorizationUrlStr,
-      label: "oauth-authorization-url",
-      async onClose() {
-        if (!foundAccessToken) {
-          reject(new Error("Authorization window closed"));
-        }
-      },
-      async onNavigate({ url: urlStr }) {
-        const url = new URL(urlStr);
-        if (url.searchParams.has("error")) {
-          return reject(Error(`Failed to authorize: ${url.searchParams.get("error")}`));
-        }
-        const hash = url.hash.slice(1);
-        const params = new URLSearchParams(hash);
-        const accessToken = params.get("access_token");
-        if (!accessToken) {
-          return;
-        }
-        foundAccessToken = true;
-        close();
-        const response = Object.fromEntries(params);
-        try {
-          resolve(await storeToken(ctx, contextId, response));
-        } catch (err) {
-          reject(err);
-        }
-      }
-    });
-  });
-}
-
-// src/grants/password.ts
-async function getPassword(ctx, contextId, {
-  accessTokenUrl,
-  clientId,
-  clientSecret,
-  username,
-  password,
-  credentialsInBody,
-  audience,
-  scope
-}) {
-  const token = await getOrRefreshAccessToken(ctx, contextId, {
-    accessTokenUrl,
-    scope,
-    clientId,
-    clientSecret,
-    credentialsInBody
-  });
-  if (token != null) {
-    return token;
-  }
-  const response = await getAccessToken(ctx, {
-    accessTokenUrl,
-    clientId,
-    clientSecret,
-    scope,
-    audience,
-    grantType: "password",
-    credentialsInBody,
-    params: [
-      { name: "username", value: username },
-      { name: "password", value: password }
-    ]
-  });
-  return storeToken(ctx, contextId, response);
-}
-
-// src/index.ts
-var grantTypes = [
-  { label: "Authorization Code", value: "authorization_code" },
-  { label: "Implicit", value: "implicit" },
-  { label: "Resource Owner Password Credential", value: "password" },
-  { label: "Client Credentials", value: "client_credentials" }
-];
-var defaultGrantType = grantTypes[0].value;
-function hiddenIfNot(grantTypes2, ...other) {
-  return (_ctx, { values }) => {
-    const hasGrantType = grantTypes2.find((t) => t === String(values.grantType ?? defaultGrantType));
-    const hasOtherBools = other.every((t) => t(values));
-    const show = hasGrantType && hasOtherBools;
-    return { hidden: !show };
-  };
-}
-var authorizationUrls = [
-  "https://github.com/login/oauth/authorize",
-  "https://account.box.com/api/oauth2/authorize",
-  "https://accounts.google.com/o/oauth2/v2/auth",
-  "https://api.imgur.com/oauth2/authorize",
-  "https://bitly.com/oauth/authorize",
-  "https://gitlab.example.com/oauth/authorize",
-  "https://medium.com/m/oauth/authorize",
-  "https://public-api.wordpress.com/oauth2/authorize",
-  "https://slack.com/oauth/authorize",
-  "https://todoist.com/oauth/authorize",
-  "https://www.dropbox.com/oauth2/authorize",
-  "https://www.linkedin.com/oauth/v2/authorization",
-  "https://MY_SHOP.myshopify.com/admin/oauth/access_token"
-];
-var accessTokenUrls = [
-  "https://github.com/login/oauth/access_token",
-  "https://api-ssl.bitly.com/oauth/access_token",
-  "https://api.box.com/oauth2/token",
-  "https://api.dropboxapi.com/oauth2/token",
-  "https://api.imgur.com/oauth2/token",
-  "https://api.medium.com/v1/tokens",
-  "https://gitlab.example.com/oauth/token",
-  "https://public-api.wordpress.com/oauth2/token",
-  "https://slack.com/api/oauth.access",
-  "https://todoist.com/oauth/access_token",
-  "https://www.googleapis.com/oauth2/v4/token",
-  "https://www.linkedin.com/oauth/v2/accessToken",
-  "https://MY_SHOP.myshopify.com/admin/oauth/authorize"
-];
-var plugin = {
-  authentication: {
-    name: "oauth2",
-    label: "OAuth 2.0",
-    shortLabel: "OAuth 2",
-    actions: [
-      {
-        label: "Copy Current Token",
-        async onSelect(ctx, { contextId }) {
-          const token = await getToken(ctx, contextId);
-          if (token == null) {
-            await ctx.toast.show({ message: "No token to copy", color: "warning" });
-          } else {
-            await ctx.clipboard.copyText(token.response.access_token);
-            await ctx.toast.show({ message: "Token copied to clipboard", icon: "copy", color: "success" });
-          }
-        }
-      },
-      {
-        label: "Delete Token",
-        async onSelect(ctx, { contextId }) {
-          if (await deleteToken(ctx, contextId)) {
-            await ctx.toast.show({ message: "Token deleted", color: "success" });
-          } else {
-            await ctx.toast.show({ message: "No token to delete", color: "warning" });
-          }
-        }
-      },
-      {
-        label: "Clear Window Session",
-        async onSelect(ctx, { contextId }) {
-          await resetDataDirKey(ctx, contextId);
-        }
-      }
-    ],
-    args: [
-      {
-        type: "select",
-        name: "grantType",
-        label: "Grant Type",
-        hideLabel: true,
-        defaultValue: defaultGrantType,
-        options: grantTypes
-      },
-      // Always-present fields
-      {
-        type: "text",
-        name: "clientId",
-        label: "Client ID",
-        optional: true
-      },
-      {
-        type: "text",
-        name: "clientSecret",
-        label: "Client Secret",
-        optional: true,
-        password: true,
-        dynamic: hiddenIfNot(["authorization_code", "password", "client_credentials"])
-      },
-      {
-        type: "text",
-        name: "authorizationUrl",
-        optional: true,
-        label: "Authorization URL",
-        dynamic: hiddenIfNot(["authorization_code", "implicit"]),
-        placeholder: authorizationUrls[0],
-        completionOptions: authorizationUrls.map((url) => ({ label: url, value: url }))
-      },
-      {
-        type: "text",
-        name: "accessTokenUrl",
-        optional: true,
-        label: "Access Token URL",
-        placeholder: accessTokenUrls[0],
-        dynamic: hiddenIfNot(["authorization_code", "password", "client_credentials"]),
-        completionOptions: accessTokenUrls.map((url) => ({ label: url, value: url }))
-      },
-      {
-        type: "text",
-        name: "redirectUri",
-        label: "Redirect URI",
-        optional: true,
-        dynamic: hiddenIfNot(["authorization_code", "implicit"])
-      },
-      {
-        type: "text",
-        name: "state",
-        label: "State",
-        optional: true,
-        dynamic: hiddenIfNot(["authorization_code", "implicit"])
-      },
-      {
-        type: "text",
-        name: "audience",
-        label: "Audience",
-        optional: true
-      },
-      {
-        type: "checkbox",
-        name: "usePkce",
-        label: "Use PKCE",
-        dynamic: hiddenIfNot(["authorization_code"])
-      },
-      {
-        type: "select",
-        name: "pkceChallengeMethod",
-        label: "Code Challenge Method",
-        options: [{ label: "SHA-256", value: PKCE_SHA256 }, { label: "Plain", value: PKCE_PLAIN }],
-        defaultValue: DEFAULT_PKCE_METHOD,
-        dynamic: hiddenIfNot(["authorization_code"], ({ usePkce }) => !!usePkce)
-      },
-      {
-        type: "text",
-        name: "pkceCodeVerifier",
-        label: "Code Verifier",
-        placeholder: "Automatically generated if not provided",
-        optional: true,
-        dynamic: hiddenIfNot(["authorization_code"], ({ usePkce }) => !!usePkce)
-      },
-      {
-        type: "text",
-        name: "username",
-        label: "Username",
-        optional: true,
-        dynamic: hiddenIfNot(["password"])
-      },
-      {
-        type: "text",
-        name: "password",
-        label: "Password",
-        password: true,
-        optional: true,
-        dynamic: hiddenIfNot(["password"])
-      },
-      {
-        type: "select",
-        name: "responseType",
-        label: "Response Type",
-        defaultValue: "token",
-        options: [
-          { label: "Access Token", value: "token" },
-          { label: "ID Token", value: "id_token" },
-          { label: "ID and Access Token", value: "id_token token" }
-        ],
-        dynamic: hiddenIfNot(["implicit"])
-      },
-      {
-        type: "accordion",
-        label: "Advanced",
-        inputs: [
-          { type: "text", name: "scope", label: "Scope", optional: true },
-          { type: "text", name: "headerPrefix", label: "Header Prefix", optional: true, defaultValue: "Bearer" },
-          {
-            type: "select",
-            name: "credentials",
-            label: "Send Credentials",
-            defaultValue: "body",
-            options: [
-              { label: "In Request Body", value: "body" },
-              { label: "As Basic Authentication", value: "basic" }
-            ]
-          }
-        ]
-      },
-      {
-        type: "accordion",
-        label: "Access Token Response",
-        async dynamic(ctx, { contextId }) {
-          const token = await getToken(ctx, contextId);
-          if (token == null) {
-            return { hidden: true };
-          }
-          return {
-            label: "Access Token Response",
-            inputs: [
-              {
-                type: "editor",
-                defaultValue: JSON.stringify(token.response, null, 2),
-                hideLabel: true,
-                readOnly: true,
-                language: "json"
-              }
-            ]
-          };
-        }
-      }
-    ],
-    async onApply(ctx, { values, contextId }) {
-      const headerPrefix = stringArg(values, "headerPrefix");
-      const grantType = stringArg(values, "grantType");
-      const credentialsInBody = values.credentials === "body";
-      let token;
-      if (grantType === "authorization_code") {
-        const authorizationUrl = stringArg(values, "authorizationUrl");
-        const accessTokenUrl = stringArg(values, "accessTokenUrl");
-        token = await getAuthorizationCode(ctx, contextId, {
-          accessTokenUrl: accessTokenUrl.match(/^https?:\/\//) ? accessTokenUrl : `https://${accessTokenUrl}`,
-          authorizationUrl: authorizationUrl.match(/^https?:\/\//) ? authorizationUrl : `https://${authorizationUrl}`,
-          clientId: stringArg(values, "clientId"),
-          clientSecret: stringArg(values, "clientSecret"),
-          redirectUri: stringArgOrNull(values, "redirectUri"),
-          scope: stringArgOrNull(values, "scope"),
-          audience: stringArgOrNull(values, "audience"),
-          state: stringArgOrNull(values, "state"),
-          credentialsInBody,
-          pkce: values.usePkce ? {
-            challengeMethod: stringArg(values, "pkceChallengeMethod"),
-            codeVerifier: stringArgOrNull(values, "pkceCodeVerifier")
-          } : null
-        });
-      } else if (grantType === "implicit") {
-        const authorizationUrl = stringArg(values, "authorizationUrl");
-        token = await getImplicit(ctx, contextId, {
-          authorizationUrl: authorizationUrl.match(/^https?:\/\//) ? authorizationUrl : `https://${authorizationUrl}`,
-          clientId: stringArg(values, "clientId"),
-          redirectUri: stringArgOrNull(values, "redirectUri"),
-          responseType: stringArg(values, "responseType"),
-          scope: stringArgOrNull(values, "scope"),
-          audience: stringArgOrNull(values, "audience"),
-          state: stringArgOrNull(values, "state")
-        });
-      } else if (grantType === "client_credentials") {
-        const accessTokenUrl = stringArg(values, "accessTokenUrl");
-        token = await getClientCredentials(ctx, contextId, {
-          accessTokenUrl: accessTokenUrl.match(/^https?:\/\//) ? accessTokenUrl : `https://${accessTokenUrl}`,
-          clientId: stringArg(values, "clientId"),
-          clientSecret: stringArg(values, "clientSecret"),
-          scope: stringArgOrNull(values, "scope"),
-          audience: stringArgOrNull(values, "audience"),
-          credentialsInBody
-        });
-      } else if (grantType === "password") {
-        const accessTokenUrl = stringArg(values, "accessTokenUrl");
-        token = await getPassword(ctx, contextId, {
-          accessTokenUrl: accessTokenUrl.match(/^https?:\/\//) ? accessTokenUrl : `https://${accessTokenUrl}`,
-          clientId: stringArg(values, "clientId"),
-          clientSecret: stringArg(values, "clientSecret"),
-          username: stringArg(values, "username"),
-          password: stringArg(values, "password"),
-          scope: stringArgOrNull(values, "scope"),
-          audience: stringArgOrNull(values, "audience"),
-          credentialsInBody
-        });
-      } else {
-        throw new Error("Invalid grant type " + grantType);
-      }
-      const headerValue = `${headerPrefix} ${token.response.access_token}`.trim();
-      return {
-        setHeaders: [{
-          name: "Authorization",
-          value: headerValue
-        }]
-      };
-    }
-  }
-};
-function stringArgOrNull(values, name) {
-  const arg = values[name];
-  if (arg == null || arg == "") return null;
-  return `${arg}`;
-}
-function stringArg(values, name) {
-  const arg = stringArgOrNull(values, name);
-  if (!arg) return "";
-  return arg;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  plugin
-});

src-tauri/vendored/plugins/exporter-curl/build/index.js

@@ -27,13 +27,14 @@ module.exports = __toCommonJS(src_exports);
 var NEWLINE = "\\\n ";
 var plugin = {
   httpRequestActions: [{
+    key: "export-curl",
     label: "Copy as Curl",
     icon: "copy",
     async onSelect(ctx, args) {
       const rendered_request = await ctx.httpRequest.render({ httpRequest: args.httpRequest, purpose: "preview" });
       const data = await convertToCurl(rendered_request);
-      await ctx.clipboard.copyText(data);
-      await ctx.toast.show({ message: "Curl copied to clipboard", icon: "copy", color: "success" });
+      ctx.clipboard.copyText(data);
+      ctx.toast.show({ message: "Curl copied to clipboard", icon: "copy" });
     }
   }]
 };

src-tauri/vendored/plugins/filter-jsonpath/package.json

@@ -7,7 +7,7 @@
     "dev": "yaakcli dev ./src/index.js"
   },
   "dependencies": {
-    "jsonpath-plus": "^10.3.0"
+    "jsonpath-plus": "^9.0.0"
   },
   "devDependencies": {
     "@types/jsonpath": "^0.2.4"

src-tauri/vendored/plugins/importer-curl/build/index.js

@@ -36,9 +36,6 @@ var require_quote = __commonJS({
     "use strict";
     module2.exports = function quote(xs) {
       return xs.map(function(s) {
-        if (s === "") {
-          return "''";
-        }
         if (s && typeof s === "object") {
           return s.op.replace(/(.)/g, "\\$1");
         }
@@ -542,23 +539,20 @@ function pairsToDataParameters(keyedPairs) {
     }
     for (const p of pairs) {
       if (typeof p !== "string") continue;
-      let params = p.split("&");
-      for (const param of params) {
-        const [name, value] = param.split("=");
-        if (param.startsWith("@")) {
-          dataParameters.push({
-            name: name ?? "",
-            value: "",
-            filePath: param.slice(1),
-            enabled: true
-          });
-        } else {
-          dataParameters.push({
-            name: name ?? "",
-            value: flagName === "data-urlencode" ? encodeURIComponent(value ?? "") : value ?? "",
-            enabled: true
-          });
-        }
+      const [name, value] = p.split("=");
+      if (p.startsWith("@")) {
+        dataParameters.push({
+          name: name ?? "",
+          value: "",
+          filePath: p.slice(1),
+          enabled: true
+        });
+      } else {
+        dataParameters.push({
+          name: name ?? "",
+          value: flagName === "data-urlencode" ? encodeURIComponent(value ?? "") : value ?? "",
+          enabled: true
+        });
       }
     }
   }

src-tauri/vendored/plugins/importer-openapi/build/index.js

@@ -49782,11 +49782,7 @@ var require_property_base = __commonJS({
          * @returns {*|undefined}
          */
         parent() {
-          let parent = this.__parent;
-          if (parent && parent._postman_propertyIsList) {
-            parent = parent.__parent || parent;
-          }
-          return parent || void 0;
+          return this && this.__parent && (this.__parent.__parent || this.__parent) || void 0;
         },
         /**
          * Accepts an object and sets it as the parent of the current property.
@@ -77145,7 +77141,7 @@ var require_dynamic_variables = __commonJS({
         description: "A random avatar image",
         generator: () => {
           return faker.random.arrayElement([
-            // eslint-disable-next-line @stylistic/js/max-len
+            // eslint-disable-next-line max-len
             `https://cloudflare-ipfs.com/ipfs/Qmd3W5DuhgHirLHGVixi6V76LhCkZUz6pnFt5AJBiyvHye/avatar/${faker.datatype.number(1249)}.jpg`,
             `https://avatars.githubusercontent.com/u/${faker.datatype.number(1e8)}`
           ]);
@@ -77498,7 +77494,7 @@ var require_superstring = __commonJS({
          * @readOnly
          * @type {RegExp}
          */
-        REGEX_EXTRACT_VARS: /{{([^{}]*?)}}/g,
+        REGEX_EXTRACT_VARS: /\{\{([^{}]*?)}}/g,
         /**
          * Defines the number of times the variable substitution mechanism will repeat until all tokens are resolved
          *
@@ -77593,7 +77589,7 @@ var require_property = __commonJS({
       } else if (typeof value === "object") {
         seen.add(value);
         for (const key in value) {
-          if (Object.hasOwn(value, key)) {
+          if (Object.hasOwnProperty.call(value, key)) {
             _findSubstitutions(value[key], seen, result);
           }
         }
@@ -77898,7 +77894,7 @@ var require_property_list = __commonJS({
           before > -1 ? this.members.splice(before, 0, item) : this.members.push(item);
           if ((index = item[this._postman_listIndexKey]) && (index = String(index))) {
             this._postman_listIndexCaseInsensitive && (index = index.toLowerCase());
-            if (this._postman_listAllowsMultipleValues && Object.hasOwn(this.reference, index)) {
+            if (this._postman_listAllowsMultipleValues && Object.hasOwnProperty.call(this.reference, index)) {
               !_2.isArray(this.reference[index]) && (this.reference[index] = [this.reference[index]]);
               this.reference[index].push(item);
             } else {
@@ -78462,7 +78458,7 @@ var require_parser = __commonJS({
     var ReplacementTracker = require_replacement_tracker();
     var REGEX_ALL_BACKSLASHES = /\\/g;
     var REGEX_LEADING_SLASHES = /^\/+/;
-    var REGEX_ALL_VARIABLES = /{{[^{}]*}}/g;
+    var REGEX_ALL_VARIABLES = /{{[^{}]*[.:/?#@&\]][^{}]*}}/g;
     var HASH_SEPARATOR = "#";
     var PATH_SEPARATOR = "/";
     var PORT_SEPARATOR = ":";
@@ -78617,7 +78613,6 @@ var require_query_param = __commonJS({
   "../../node_modules/postman-collection/lib/collection/query-param.js"(exports2, module2) {
     var _2 = require_util2().lodash;
     var Property = require_property().Property;
-    var Substitutor = require_superstring().Substitutor;
     var PropertyList = require_property_list().PropertyList;
     var E = "";
     var AMPERSAND = "&";
@@ -78628,7 +78623,7 @@ var require_query_param = __commonJS({
     var REGEX_HASH = /#/g;
     var REGEX_EQUALS = /=/g;
     var REGEX_AMPERSAND = /&/g;
-    var REGEX_EXTRACT_VARS = Substitutor.REGEX_EXTRACT_VARS;
+    var REGEX_EXTRACT_VARS = /{{[^{}]*[&#=][^{}]*}}/g;
     var QueryParam;
     var encodeReservedChars = function(str, encodeEquals) {
       if (!str) {
@@ -92131,7 +92126,7 @@ var require_db3 = __commonJS({
         type: "embed",
         format: "pdf"
       },
-      "text/javascript": {
+      "application/ecmascript": {
         type: "text",
         format: "script"
       },
@@ -92139,66 +92134,6 @@ var require_db3 = __commonJS({
         type: "text",
         format: "script"
       },
-      "application/ecmascript": {
-        type: "text",
-        format: "script"
-      },
-      "application/x-ecmascript": {
-        type: "text",
-        format: "script"
-      },
-      "application/x-javascript": {
-        type: "text",
-        format: "script"
-      },
-      "text/ecmascript": {
-        type: "text",
-        format: "script"
-      },
-      "text/javascript1.0": {
-        type: "text",
-        format: "script"
-      },
-      "text/javascript1.1": {
-        type: "text",
-        format: "script"
-      },
-      "text/javascript1.2": {
-        type: "text",
-        format: "script"
-      },
-      "text/javascript1.3": {
-        type: "text",
-        format: "script"
-      },
-      "text/javascript1.4": {
-        type: "text",
-        format: "script"
-      },
-      "text/javascript1.5": {
-        type: "text",
-        format: "script"
-      },
-      "text/jscript": {
-        type: "text",
-        format: "script"
-      },
-      "text/livescript": {
-        type: "text",
-        format: "script"
-      },
-      "text/x-ecmascript": {
-        type: "text",
-        format: "script"
-      },
-      "text/x-javascript": {
-        type: "text",
-        format: "script"
-      },
-      "text/css": {
-        type: "text",
-        format: "stylesheet"
-      },
       "application/json": {
         type: "text",
         format: "json"
@@ -94151,7 +94086,7 @@ var require_content_info = __commonJS({
        * egHeader: inline; filename="test Response.json"
        * Reference: https://github.com/jshttp/content-disposition
        */
-      // eslint-disable-next-line @stylistic/js/max-len
+      // eslint-disable-next-line max-len
       fileNameRegex: /;[ \t]*(?:filename)[ \t]*=[ \t]*("(?:[\x20!\x23-\x5b\x5d-\x7e\x80-\xff]|\\[\x20-\x7e])*"|[!#$%&'*+.0-9A-Z^_`a-z|~-]+)[ \t]*/,
       /**
        * RegExp for extracting filename* from content-disposition header
@@ -94184,7 +94119,7 @@ var require_content_info = __commonJS({
        * egHeader: attachment;filename*=utf-8''%E4%BD%A0%E5%A5%BD.txt
        * Reference: https://github.com/jshttp/content-disposition
        */
-      // eslint-disable-next-line @stylistic/js/max-len, security/detect-unsafe-regex
+      // eslint-disable-next-line max-len, security/detect-unsafe-regex
       encodedFileNameRegex: /;[ \t]*(?:filename\*)[ \t]*=[ \t]*([A-Za-z0-9!#$%&+\-^_`{}~]+)'.*'((?:%[0-9A-Fa-f]{2}|[A-Za-z0-9!#$&+.^_`|~-])+)[ \t]*/,
       /**
        * RegExp to match quoted-pair in RFC 2616
@@ -95378,7 +95313,6 @@ var require_re = __commonJS({
     var re = exports2.re = [];
     var safeRe = exports2.safeRe = [];
     var src = exports2.src = [];
-    var safeSrc = exports2.safeSrc = [];
     var t = exports2.t = {};
     var R = 0;
     var LETTERDASHNUMBER = "[a-zA-Z0-9-]";
@@ -95399,7 +95333,6 @@ var require_re = __commonJS({
       debug(name, index, value);
       t[name] = index;
       src[index] = value;
-      safeSrc[index] = safe;
       re[index] = new RegExp(value, isGlobal ? "g" : void 0);
       safeRe[index] = new RegExp(safe, isGlobal ? "g" : void 0);
     };
@@ -95496,7 +95429,7 @@ var require_semver = __commonJS({
   "../../node_modules/semver/classes/semver.js"(exports2, module2) {
     var debug = require_debug();
     var { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants();
-    var { safeRe: re, safeSrc: src, t } = require_re();
+    var { safeRe: re, t } = require_re();
     var parseOptions = require_parse_options();
     var { compareIdentifiers } = require_identifiers();
     var SemVer = class _SemVer {
@@ -95636,18 +95569,6 @@ var require_semver = __commonJS({
       // preminor will bump the version up to the next minor release, and immediately
       // down to pre-release. premajor and prepatch work the same way.
       inc(release, identifier, identifierBase) {
-        if (release.startsWith("pre")) {
-          if (!identifier && identifierBase === false) {
-            throw new Error("invalid increment argument: identifier is empty");
-          }
-          if (identifier) {
-            const r = new RegExp(`^${this.options.loose ? src[t.PRERELEASELOOSE] : src[t.PRERELEASE]}$`);
-            const match = `-${identifier}`.match(r);
-            if (!match || match[1] !== identifier) {
-              throw new Error(`invalid identifier: ${identifier}`);
-            }
-          }
-        }
         switch (release) {
           case "premajor":
             this.prerelease.length = 0;
@@ -95673,12 +95594,6 @@ var require_semver = __commonJS({
             }
             this.inc("pre", identifier, identifierBase);
             break;
-          case "release":
-            if (this.prerelease.length === 0) {
-              throw new Error(`version ${this.raw} is not a prerelease`);
-            }
-            this.prerelease.length = 0;
-            break;
           case "major":
             if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {
               this.major++;
@@ -95702,6 +95617,9 @@ var require_semver = __commonJS({
             break;
           case "pre": {
             const base = Number(identifierBase) ? 1 : 0;
+            if (!identifier && identifierBase === false) {
+              throw new Error("invalid increment argument: identifier is empty");
+            }
             if (this.prerelease.length === 0) {
               this.prerelease = [base];
             } else {
@@ -95836,12 +95754,13 @@ var require_diff = __commonJS({
         if (!lowVersion.patch && !lowVersion.minor) {
           return "major";
         }
-        if (lowVersion.compareMain(highVersion) === 0) {
-          if (lowVersion.minor && !lowVersion.patch) {
-            return "minor";
-          }
+        if (highVersion.patch) {
           return "patch";
         }
+        if (highVersion.minor) {
+          return "minor";
+        }
+        return "major";
       }
       const prefix = highHasPre ? "pre" : "";
       if (v12.major !== v2.major) {
@@ -136976,6 +136895,8 @@ var require_utils3 = __commonJS({
       originalRequest.url.query = [];
       originalRequest.header = _2.get(response, "originalRequest.headers", []);
       originalRequest.body = requestItem.request.body;
+      response.code = response.code.replace(/X|x/g, "0");
+      response.code = response.code === "default" ? 500 : _2.toSafeInteger(response.code);
       let sdkResponse = new Response({
         name: response.name,
         code: response.code,
@@ -137771,7 +137692,7 @@ var require_schemaUtils2 = __commonJS({
       }
       exampleKey = Object.keys(exampleObj)[0];
       example = exampleObj[exampleKey];
-      if (example && example.$ref) {
+      if (example.$ref) {
         example = resolveExampleData(context, example);
       }
       if (_2.get(example, "value")) {
@@ -137960,65 +137881,6 @@ var require_schemaUtils2 = __commonJS({
       }
       return schema2;
     };
-    var processSchema = (resolvedSchema) => {
-      if (resolvedSchema.type === "object" && resolvedSchema.properties) {
-        const schemaDetails = {
-          type: resolvedSchema.type,
-          properties: {},
-          required: []
-        }, requiredProperties = new Set(resolvedSchema.required || []);
-        for (let [propName, propValue] of Object.entries(resolvedSchema.properties)) {
-          if (!propValue.type) {
-            continue;
-          }
-          const propertyDetails = {
-            type: propValue.type,
-            deprecated: propValue.deprecated,
-            enum: propValue.enum || void 0,
-            minLength: propValue.minLength,
-            maxLength: propValue.maxLength,
-            minimum: propValue.minimum,
-            maximum: propValue.maximum,
-            pattern: propValue.pattern,
-            example: propValue.example,
-            description: propValue.description,
-            format: propValue.format
-          };
-          if (requiredProperties.has(propName)) {
-            schemaDetails.required.push(propName);
-          }
-          if (propValue.properties) {
-            let processedProperties = processSchema(propValue);
-            propertyDetails.properties = processedProperties.properties;
-            if (processedProperties.required) {
-              propertyDetails.required = processedProperties.required;
-            }
-          } else if (propValue.type === "array" && propValue.items) {
-            propertyDetails.items = processSchema(propValue.items);
-          }
-          schemaDetails.properties[propName] = propertyDetails;
-        }
-        if (schemaDetails.required && schemaDetails.required.length === 0) {
-          schemaDetails.required = void 0;
-        }
-        return schemaDetails;
-      } else if (resolvedSchema.type === "array" && resolvedSchema.items) {
-        const arrayDetails = {
-          type: resolvedSchema.type,
-          items: processSchema(resolvedSchema.items)
-        };
-        if (resolvedSchema.minItems !== void 0) {
-          arrayDetails.minItems = resolvedSchema.minItems;
-        }
-        if (resolvedSchema.maxItems !== void 0) {
-          arrayDetails.maxItems = resolvedSchema.maxItems;
-        }
-        return arrayDetails;
-      }
-      return {
-        type: resolvedSchema.type
-      };
-    };
     var resolveSchema = (context, schema2, { stack = 0, resolveFor = CONVERSION, seenRef = {}, isResponseSchema = false } = {}) => {
       resetReadWritePropCache(context);
       let resolvedSchema = _resolveSchema(context, schema2, stack, resolveFor, seenRef);
@@ -138365,16 +138227,12 @@ var require_schemaUtils2 = __commonJS({
       return pmExamples;
     };
     var resolveBodyData = (context, requestBodySchema, bodyType, isExampleBody = false, responseCode = null, requestBodyExamples = {}) => {
-      let { parametersResolution, indentCharacter } = context.computedOptions, headerFamily = getHeaderFamily(bodyType), bodyData = "", shouldGenerateFromExample = parametersResolution === "example", isBodyTypeXML = bodyType === APP_XML || bodyType === TEXT_XML || headerFamily === HEADER_TYPE.XML, bodyKey = isExampleBody ? "response" : "request", responseExamples, example, examples, resolvedSchemaTypes = [];
+      let { parametersResolution, indentCharacter } = context.computedOptions, headerFamily = getHeaderFamily(bodyType), bodyData = "", shouldGenerateFromExample = parametersResolution === "example", isBodyTypeXML = bodyType === APP_XML || bodyType === TEXT_XML || headerFamily === HEADER_TYPE.XML, bodyKey = isExampleBody ? "response" : "request", responseExamples, example, examples;
       if (_2.isEmpty(requestBodySchema)) {
         return [{ [bodyKey]: bodyData }];
       }
       if (requestBodySchema.$ref) {
-        requestBodySchema = resolveSchema(
-          context,
-          requestBodySchema,
-          { isResponseSchema: isExampleBody }
-        );
+        requestBodySchema = resolveSchema(context, requestBodySchema, { isResponseSchema: isExampleBody });
       }
       if (requestBodySchema.example !== void 0) {
         const shouldResolveValueKey = _2.has(requestBodySchema.example, "value") && _2.keys(requestBodySchema.example).length <= 1;
@@ -138385,11 +138243,7 @@ var require_schemaUtils2 = __commonJS({
       }
       examples = requestBodySchema.examples || _2.get(requestBodySchema, "schema.examples");
       requestBodySchema = requestBodySchema.schema || requestBodySchema;
-      requestBodySchema = resolveSchema(
-        context,
-        requestBodySchema,
-        { isResponseSchema: isExampleBody }
-      );
+      requestBodySchema = resolveSchema(context, requestBodySchema, { isResponseSchema: isExampleBody });
       if (example === void 0 && _2.get(requestBodySchema, "example") !== void 0) {
         example = requestBodySchema.example;
       }
@@ -138403,11 +138257,7 @@ var require_schemaUtils2 = __commonJS({
       } else if (requestBodySchema) {
         requestBodySchema = requestBodySchema.schema || requestBodySchema;
         if (requestBodySchema.$ref) {
-          requestBodySchema = resolveSchema(
-            context,
-            requestBodySchema,
-            { isResponseSchema: isExampleBody }
-          );
+          requestBodySchema = resolveSchema(context, requestBodySchema, { isResponseSchema: isExampleBody });
         }
         if (isBodyTypeXML) {
           bodyData = xmlFaker(null, requestBodySchema, indentCharacter, parametersResolution);
@@ -138435,10 +138285,6 @@ var require_schemaUtils2 = __commonJS({
           }
         }
       }
-      if (context.enableTypeFetching && requestBodySchema.type !== void 0) {
-        const requestBodySchemaTypes = processSchema(requestBodySchema);
-        resolvedSchemaTypes.push(requestBodySchemaTypes);
-      }
       if (isExampleBody && shouldGenerateFromExample && (_2.size(examples) > 1 || _2.size(requestBodyExamples) > 1)) {
         responseExamples = [{
           key: "_default",
@@ -138459,37 +138305,22 @@ var require_schemaUtils2 = __commonJS({
         if (_2.isEmpty(matchedRequestBodyExamples)) {
           matchedRequestBodyExamples = requestBodyExamples;
         }
-        const generatedBody = generateExamples(
-          context,
-          responseExamples,
-          matchedRequestBodyExamples,
-          requestBodySchema,
-          isBodyTypeXML
-        );
-        return {
-          generatedBody,
-          resolvedSchemaType: resolvedSchemaTypes[0]
-        };
+        return generateExamples(context, responseExamples, matchedRequestBodyExamples, requestBodySchema, isBodyTypeXML);
       }
-      return {
-        generatedBody: [{ [bodyKey]: bodyData }],
-        resolvedSchemaType: resolvedSchemaTypes[0]
-      };
+      return [{ [bodyKey]: bodyData }];
     };
     var resolveUrlEncodedRequestBodyForPostmanRequest = (context, requestBodyContent) => {
       let bodyData = "", urlEncodedParams = [], requestBodyData = {
         mode: "urlencoded",
         urlencoded: urlEncodedParams
-      }, resolvedBody, resolvedBodyResult, resolvedSchemaTypeObject;
+      }, resolvedBody;
       if (_2.isEmpty(requestBodyContent)) {
         return requestBodyData;
       }
       if (_2.has(requestBodyContent, "schema.$ref")) {
         requestBodyContent.schema = resolveSchema(context, requestBodyContent.schema);
       }
-      resolvedBodyResult = resolveBodyData(context, requestBodyContent.schema);
-      resolvedBody = resolvedBodyResult && Array.isArray(resolvedBodyResult.generatedBody) && resolvedBodyResult.generatedBody[0];
-      resolvedSchemaTypeObject = resolvedBodyResult && resolvedBodyResult.resolvedSchemaType;
+      resolvedBody = resolveBodyData(context, requestBodyContent.schema)[0];
       resolvedBody && (bodyData = resolvedBody.request);
       const encoding = requestBodyContent.encoding || {};
       _2.forOwn(bodyData, (value, key) => {
@@ -138511,21 +138342,18 @@ var require_schemaUtils2 = __commonJS({
         headers: [{
           key: "Content-Type",
           value: URLENCODED
-        }],
-        resolvedSchemaTypeObject
+        }]
       };
     };
     var resolveFormDataRequestBodyForPostmanRequest = (context, requestBodyContent) => {
       let bodyData = "", formDataParams = [], encoding = {}, requestBodyData = {
         mode: "formdata",
         formdata: formDataParams
-      }, resolvedBody, resolvedBodyResult, resolvedSchemaTypeObject;
+      }, resolvedBody;
       if (_2.isEmpty(requestBodyContent)) {
         return requestBodyData;
       }
-      resolvedBodyResult = resolveBodyData(context, requestBodyContent.schema);
-      resolvedBody = resolvedBodyResult && Array.isArray(resolvedBodyResult.generatedBody) && resolvedBodyResult.generatedBody[0];
-      resolvedSchemaTypeObject = resolvedBodyResult && resolvedBodyResult.resolvedSchemaType;
+      resolvedBody = resolveBodyData(context, requestBodyContent.schema)[0];
       resolvedBody && (bodyData = resolvedBody.request);
       encoding = _2.get(requestBodyContent, "encoding", {});
       _2.forOwn(bodyData, (value, key) => {
@@ -138561,8 +138389,7 @@ var require_schemaUtils2 = __commonJS({
         headers: [{
           key: "Content-Type",
           value: FORM_DATA
-        }],
-        resolvedSchemaTypeObject
+        }]
       };
     };
     var getRawBodyType = (content) => {
@@ -138598,16 +138425,14 @@ var require_schemaUtils2 = __commonJS({
       return bodyType;
     };
     var resolveRawModeRequestBodyForPostmanRequest = (context, requestContent) => {
-      let bodyType = getRawBodyType(requestContent), bodyData, headerFamily, dataToBeReturned = {}, { concreteUtils } = context, resolvedBody, resolvedBodyResult, resolvedSchemaTypeObject;
+      let bodyType = getRawBodyType(requestContent), bodyData, headerFamily, dataToBeReturned = {}, { concreteUtils } = context, resolvedBody;
       headerFamily = getHeaderFamily(bodyType);
       if (concreteUtils.isBinaryContentType(bodyType, requestContent)) {
         dataToBeReturned = {
           mode: "file"
         };
       } else {
-        resolvedBodyResult = resolveBodyData(context, requestContent[bodyType], bodyType);
-        resolvedBody = resolvedBodyResult && Array.isArray(resolvedBodyResult.generatedBody) && resolvedBodyResult.generatedBody[0];
-        resolvedSchemaTypeObject = resolvedBodyResult && resolvedBodyResult.resolvedSchemaType;
+        resolvedBody = resolveBodyData(context, requestContent[bodyType], bodyType)[0];
         resolvedBody && (bodyData = resolvedBody.request);
         if (bodyType === TEXT_XML || bodyType === APP_XML || headerFamily === HEADER_TYPE.XML) {
           bodyData = getXmlVersionContent(bodyData);
@@ -138631,8 +138456,7 @@ var require_schemaUtils2 = __commonJS({
         headers: [{
           key: "Content-Type",
           value: bodyType
-        }],
-        resolvedSchemaTypeObject
+        }]
       };
     };
     var resolveRequestBodyForPostmanRequest = (context, operationItem) => {
@@ -138712,25 +138536,8 @@ var require_schemaUtils2 = __commonJS({
       });
       return reqParam;
     };
-    var createProperties = (param) => {
-      const { schema: schema2 } = param;
-      return {
-        type: schema2.type,
-        format: schema2.format,
-        default: schema2.default,
-        required: param.required || false,
-        deprecated: param.deprecated || false,
-        enum: schema2.enum || void 0,
-        minLength: schema2.minLength,
-        maxLength: schema2.maxLength,
-        minimum: schema2.minimum,
-        maximum: schema2.maximum,
-        pattern: schema2.pattern,
-        example: schema2.example
-      };
-    };
     var resolveQueryParamsForPostmanRequest = (context, operationItem, method) => {
-      const params = resolvePathItemParams(context, operationItem[method].parameters, operationItem.parameters), pmParams = [], queryParamTypes = [], { includeDeprecated } = context.computedOptions;
+      const params = resolvePathItemParams(context, operationItem[method].parameters, operationItem.parameters), pmParams = [], { includeDeprecated } = context.computedOptions;
       _2.forEach(params, (param) => {
         if (!_2.isObject(param)) {
           return;
@@ -138738,28 +138545,20 @@ var require_schemaUtils2 = __commonJS({
         if (_2.has(param, "$ref")) {
           param = resolveSchema(context, param);
         }
-        if (_2.has(param.schema, "$ref")) {
-          param.schema = resolveSchema(context, param.schema);
-        }
         if (param.in !== QUERYPARAM || !includeDeprecated && param.deprecated) {
           return;
         }
-        let queryParamTypeInfo = {}, properties = {}, paramValue = resolveValueOfParameter(context, param);
-        if (param && param.name && param.schema && param.schema.type) {
-          properties = createProperties(param);
-          queryParamTypeInfo = { keyName: param.name, properties };
-          queryParamTypes.push(queryParamTypeInfo);
-        }
+        let paramValue = resolveValueOfParameter(context, param);
         if (typeof paramValue === "number" || typeof paramValue === "boolean") {
           paramValue = paramValue.toString();
         }
         const deserialisedParams = serialiseParamsBasedOnStyle(context, param, paramValue);
         pmParams.push(...deserialisedParams);
       });
-      return { queryParamTypes, queryParams: pmParams };
+      return pmParams;
     };
     var resolvePathParamsForPostmanRequest = (context, operationItem, method) => {
-      const params = resolvePathItemParams(context, operationItem[method].parameters, operationItem.parameters), pmParams = [], pathParamTypes = [];
+      const params = resolvePathItemParams(context, operationItem[method].parameters, operationItem.parameters), pmParams = [];
       _2.forEach(params, (param) => {
         if (!_2.isObject(param)) {
           return;
@@ -138767,25 +138566,17 @@ var require_schemaUtils2 = __commonJS({
         if (_2.has(param, "$ref")) {
           param = resolveSchema(context, param);
         }
-        if (_2.has(param.schema, "$ref")) {
-          param.schema = resolveSchema(context, param.schema);
-        }
         if (param.in !== PATHPARAM) {
           return;
         }
-        let pathParamTypeInfo = {}, properties = {}, paramValue = resolveValueOfParameter(context, param);
-        if (param && param.name && param.schema && param.schema.type) {
-          properties = createProperties(param);
-          pathParamTypeInfo = { keyName: param.name, properties };
-          pathParamTypes.push(pathParamTypeInfo);
-        }
+        let paramValue = resolveValueOfParameter(context, param);
         if (typeof paramValue === "number" || typeof paramValue === "boolean") {
           paramValue = paramValue.toString();
         }
         const deserialisedParams = serialiseParamsBasedOnStyle(context, param, paramValue);
         pmParams.push(...deserialisedParams);
       });
-      return { pathParamTypes, pathParams: pmParams };
+      return pmParams;
     };
     var resolveNameForPostmanReqeust = (context, operationItem, requestUrl) => {
       let reqName, { requestNameSource } = context.computedOptions;
@@ -138807,7 +138598,7 @@ var require_schemaUtils2 = __commonJS({
       return reqName;
     };
     var resolveHeadersForPostmanRequest = (context, operationItem, method) => {
-      const params = resolvePathItemParams(context, operationItem[method].parameters, operationItem.parameters), pmParams = [], headerTypes = [], { keepImplicitHeaders, includeDeprecated } = context.computedOptions;
+      const params = resolvePathItemParams(context, operationItem[method].parameters, operationItem.parameters), pmParams = [], { keepImplicitHeaders, includeDeprecated } = context.computedOptions;
       _2.forEach(params, (param) => {
         if (!_2.isObject(param)) {
           return;
@@ -138815,33 +138606,25 @@ var require_schemaUtils2 = __commonJS({
         if (_2.has(param, "$ref")) {
           param = resolveSchema(context, param);
         }
-        if (_2.has(param.schema, "$ref")) {
-          param.schema = resolveSchema(context, param.schema);
-        }
         if (param.in !== HEADER || !includeDeprecated && param.deprecated) {
           return;
         }
         if (!keepImplicitHeaders && _2.includes(IMPLICIT_HEADERS, _2.toLower(_2.get(param, "name")))) {
           return;
         }
-        let headerTypeInfo = {}, properties = {}, paramValue = resolveValueOfParameter(context, param);
-        if (param && param.name && param.schema && param.schema.type) {
-          properties = createProperties(param);
-          headerTypeInfo = { keyName: param.name, properties };
-          headerTypes.push(headerTypeInfo);
-        }
+        let paramValue = resolveValueOfParameter(context, param);
         if (typeof paramValue === "number" || typeof paramValue === "boolean") {
           paramValue = paramValue.toString();
         }
         const deserialisedParams = serialiseParamsBasedOnStyle(context, param, paramValue);
         pmParams.push(...deserialisedParams);
       });
-      return { headerTypes, headers: pmParams };
+      return pmParams;
     };
     var resolveResponseBody = (context, responseBody = {}, requestBodyExamples = {}, code = null) => {
       let responseContent, bodyType, allBodyData, headerFamily, acceptHeader, emptyResponse = [{
         body: void 0
-      }], resolvedResponseBodyResult, resolvedResponseBodyTypes;
+      }];
       if (_2.isEmpty(responseBody)) {
         return emptyResponse;
       }
@@ -138854,16 +138637,7 @@ var require_schemaUtils2 = __commonJS({
       }
       bodyType = getRawBodyType(responseContent);
       headerFamily = getHeaderFamily(bodyType);
-      resolvedResponseBodyResult = resolveBodyData(
-        context,
-        responseContent[bodyType],
-        bodyType,
-        true,
-        code,
-        requestBodyExamples
-      );
-      allBodyData = resolvedResponseBodyResult.generatedBody;
-      resolvedResponseBodyTypes = resolvedResponseBodyResult.resolvedSchemaType;
+      allBodyData = resolveBodyData(context, responseContent[bodyType], bodyType, true, code, requestBodyExamples);
       return _2.map(allBodyData, (bodyData) => {
         let requestBodyData = bodyData.request, responseBodyData = bodyData.response, exampleName = bodyData.name;
         if (bodyType === TEXT_XML || bodyType === APP_XML || headerFamily === HEADER_TYPE.XML) {
@@ -138889,13 +138663,12 @@ var require_schemaUtils2 = __commonJS({
           }],
           name: exampleName,
           bodyType,
-          acceptHeader,
-          resolvedResponseBodyTypes
+          acceptHeader
         };
       });
     };
     var resolveResponseHeaders = (context, responseHeaders) => {
-      const headers = [], { includeDeprecated } = context.computedOptions, headerTypes = [];
+      const headers = [], { includeDeprecated } = context.computedOptions;
       if (_2.has(responseHeaders, "$ref")) {
         responseHeaders = resolveSchema(context, responseHeaders, { isResponseSchema: true });
       }
@@ -138906,33 +138679,14 @@ var require_schemaUtils2 = __commonJS({
         if (!includeDeprecated && value.deprecated) {
           return;
         }
-        let headerValue = resolveValueOfParameter(context, value, { isResponseSchema: true }), headerTypeInfo = {}, properties = {};
+        let headerValue = resolveValueOfParameter(context, value, { isResponseSchema: true });
         if (typeof headerValue === "number" || typeof headerValue === "boolean") {
           headerValue = headerValue.toString();
         }
         const headerData = Object.assign({}, value, { name: headerName }), serialisedHeader = serialiseParamsBasedOnStyle(context, headerData, headerValue, { isResponseSchema: true });
         headers.push(...serialisedHeader);
-        if (headerData && headerData.name && headerData.schema && headerData.schema.type) {
-          const { schema: schema2 } = headerData;
-          properties = {
-            type: schema2.type,
-            format: schema2.format,
-            default: schema2.default,
-            required: schema2.required || false,
-            deprecated: schema2.deprecated || false,
-            enum: schema2.enum || void 0,
-            minLength: schema2.minLength,
-            maxLength: schema2.maxLength,
-            minimum: schema2.minimum,
-            maximum: schema2.maximum,
-            pattern: schema2.pattern,
-            example: schema2.example
-          };
-          headerTypeInfo = { keyName: headerData.name, properties };
-          headerTypes.push(headerTypeInfo);
-        }
       });
-      return { resolvedHeaderTypes: headerTypes, headers };
+      return headers;
     };
     var getPreviewLangugaForResponseBody = (bodyType) => {
       const headerFamily = getHeaderFamily(bodyType);
@@ -138999,7 +138753,7 @@ var require_schemaUtils2 = __commonJS({
       return responseAuthHelper;
     };
     var resolveResponseForPostmanRequest = (context, operationItem, request) => {
-      let responses = [], requestBodyExamples = [], requestAcceptHeader, requestBody = operationItem.requestBody, requestContent, rawBodyType, headerFamily, isBodyTypeXML, resolvedExamplesObject = {}, responseTypes = {};
+      let responses = [], requestBodyExamples = [], requestAcceptHeader, requestBody = operationItem.requestBody, requestContent, rawBodyType, headerFamily, isBodyTypeXML;
       if (typeof requestBody === "object") {
         if (requestBody.$ref) {
           requestBody = resolveSchema(context, requestBody, { isResponseSchema: true });
@@ -139035,15 +138789,7 @@ var require_schemaUtils2 = __commonJS({
         }
       }
       _2.forOwn(operationItem.responses, (responseObj, code) => {
-        let responseSchema = _2.has(responseObj, "$ref") ? resolveSchema(context, responseObj, { isResponseSchema: true }) : responseObj, { includeAuthInfoInExample } = context.computedOptions, auth = request.auth, resolvedExamples = resolveResponseBody(context, responseSchema, requestBodyExamples, code) || {}, { resolvedHeaderTypes, headers } = resolveResponseHeaders(context, responseSchema.headers), responseBodyHeaderObj;
-        resolvedExamplesObject = resolvedExamples[0] && resolvedExamples[0].resolvedResponseBodyTypes;
-        responseBodyHeaderObj = {
-          body: JSON.stringify(resolvedExamplesObject, null, 2),
-          headers: JSON.stringify(resolvedHeaderTypes, null, 2)
-        };
-        code = code.replace(/X|x/g, "0");
-        code = code === "default" ? 500 : _2.toSafeInteger(code);
-        Object.assign(responseTypes, { [code]: responseBodyHeaderObj });
+        let responseSchema = _2.has(responseObj, "$ref") ? resolveSchema(context, responseObj, { isResponseSchema: true }) : responseObj, { includeAuthInfoInExample } = context.computedOptions, auth = request.auth, resolvedExamples = resolveResponseBody(context, responseSchema, requestBodyExamples, code) || {}, headers = resolveResponseHeaders(context, responseSchema.headers);
         _2.forOwn(resolvedExamples, (resolvedExample = {}) => {
           let { body, contentHeader = [], bodyType, acceptHeader, name } = resolvedExample, resolvedRequestBody = _2.get(resolvedExample, "request.body"), originalRequest, response, responseAuthHelper, requestBodyObj = {}, reqHeaders = _2.clone(request.headers) || [], reqQueryParams = _2.clone(_2.get(request, "params.queryParams", []));
           _2.isArray(acceptHeader) && reqHeaders.push(...acceptHeader);
@@ -139083,17 +138829,13 @@ var require_schemaUtils2 = __commonJS({
           responses.push(response);
         });
       });
-      return {
-        responses,
-        acceptHeader: requestAcceptHeader,
-        responseTypes
-      };
+      return { responses, acceptHeader: requestAcceptHeader };
     };
     module2.exports = {
       resolvePostmanRequest: function(context, operationItem, path, method) {
         context.schemaCache = context.schemaCache || {};
         context.schemaFakerCache = context.schemaFakerCache || {};
-        let url = resolveUrlForPostmanRequest(path), baseUrlData = resolveBaseUrlForPostmanRequest(operationItem[method]), requestName = resolveNameForPostmanReqeust(context, operationItem[method], url), { queryParamTypes, queryParams } = resolveQueryParamsForPostmanRequest(context, operationItem, method), { headerTypes, headers } = resolveHeadersForPostmanRequest(context, operationItem, method), { pathParamTypes, pathParams } = resolvePathParamsForPostmanRequest(context, operationItem, method), { pathVariables, collectionVariables } = filterCollectionAndPathVariables(url, pathParams), requestBody = resolveRequestBodyForPostmanRequest(context, operationItem[method]), requestBodyTypes = requestBody && requestBody.resolvedSchemaTypeObject, request, securitySchema = _2.get(operationItem, [method, "security"]), authHelper = generateAuthForCollectionFromOpenAPI(context.openapi, securitySchema), { alwaysInheritAuthentication } = context.computedOptions, requestIdentifier, requestTypesObject = {};
+        let url = resolveUrlForPostmanRequest(path), baseUrlData = resolveBaseUrlForPostmanRequest(operationItem[method]), requestName = resolveNameForPostmanReqeust(context, operationItem[method], url), queryParams = resolveQueryParamsForPostmanRequest(context, operationItem, method), headers = resolveHeadersForPostmanRequest(context, operationItem, method), pathParams = resolvePathParamsForPostmanRequest(context, operationItem, method), { pathVariables, collectionVariables } = filterCollectionAndPathVariables(url, pathParams), requestBody = resolveRequestBodyForPostmanRequest(context, operationItem[method]), request, securitySchema = _2.get(operationItem, [method, "security"]), authHelper = generateAuthForCollectionFromOpenAPI(context.openapi, securitySchema), { alwaysInheritAuthentication } = context.computedOptions;
         headers.push(..._2.get(requestBody, "headers", []));
         pathVariables.push(...baseUrlData.pathVariables);
         collectionVariables.push(...baseUrlData.collectionVariables);
@@ -139111,21 +138853,7 @@ var require_schemaUtils2 = __commonJS({
           body: _2.get(requestBody, "body"),
           auth: alwaysInheritAuthentication ? void 0 : authHelper
         };
-        const requestTypes = {
-          body: JSON.stringify(requestBodyTypes, null, 2),
-          headers: JSON.stringify(headerTypes, null, 2),
-          pathParam: JSON.stringify(pathParamTypes, null, 2),
-          queryParam: JSON.stringify(queryParamTypes, null, 2)
-        }, {
-          responses,
-          acceptHeader,
-          responseTypes
-        } = resolveResponseForPostmanRequest(context, operationItem[method], request);
-        requestIdentifier = method + path;
-        Object.assign(
-          requestTypesObject,
-          { [requestIdentifier]: { request: requestTypes, response: responseTypes } }
-        );
+        const { responses, acceptHeader } = resolveResponseForPostmanRequest(context, operationItem[method], request);
         if (!_2.isEmpty(acceptHeader)) {
           request.headers = _2.concat(request.headers, acceptHeader);
         }
@@ -139136,8 +138864,7 @@ var require_schemaUtils2 = __commonJS({
               responses
             })
           },
-          collectionVariables,
-          requestTypesObject
+          collectionVariables
         };
       },
       resolveResponseForPostmanRequest,
@@ -141493,7 +141220,7 @@ var require_libV2 = __commonJS({
       convertV2: function(context, cb) {
         let collectionTree = generateSkeletonTreeFromOpenAPI(context.openapi, context.computedOptions);
         let preOrderTraversal = GraphLib.alg.preorder(collectionTree, "root:collection");
-        let collection = {}, extractedTypesObject = {};
+        let collection = {};
         _2.forEach(preOrderTraversal, function(nodeIdentified) {
           let node = collectionTree.node(nodeIdentified);
           switch (node.type) {
@@ -141527,16 +141254,15 @@ var require_libV2 = __commonJS({
               break;
             }
             case "request": {
-              let request = {}, collectionVariables = [], requestObject = {}, requestTypesObject = {};
+              let request = {}, collectionVariables = [], requestObject = {};
               try {
-                ({ request, collectionVariables, requestTypesObject } = resolvePostmanRequest(
+                ({ request, collectionVariables } = resolvePostmanRequest(
                   context,
                   context.openapi.paths[node.meta.path],
                   node.meta.path,
                   node.meta.method
                 ));
                 requestObject = generateRequestItemObject(request);
-                extractedTypesObject = Object.assign({}, extractedTypesObject, requestTypesObject);
               } catch (error) {
                 console.error(error);
                 break;
@@ -141611,17 +141337,6 @@ var require_libV2 = __commonJS({
         if (!_2.isEmpty(collection.variable)) {
           collection.variable = _2.uniqBy(collection.variable, "key");
         }
-        if (context.enableTypeFetching) {
-          return cb(null, {
-            result: true,
-            output: [{
-              type: "collection",
-              data: collection
-            }],
-            analytics: this.analytics || {},
-            extractedTypes: extractedTypesObject || {}
-          });
-        }
         return cb(null, {
           result: true,
           output: [{
@@ -145403,7 +145118,7 @@ var require_schemapack = __commonJS({
     var concreteUtils;
     var pathBrowserify = require_path_browserify();
     var SchemaPack = class {
-      constructor(input, options = {}, moduleVersion = MODULE_VERSION.V1, enableTypeFetching = false) {
+      constructor(input, options = {}, moduleVersion = MODULE_VERSION.V1) {
         if (input.type === schemaUtils.MULTI_FILE_API_TYPE_ALLOWED_VALUE && input.data && input.data[0] && input.data[0].path) {
           input = schemaUtils.mapDetectRootFilesInputToFolderInput(input);
         }
@@ -145421,7 +145136,6 @@ var require_schemapack = __commonJS({
           actualStack: 0,
           numberOfRequests: 0
         };
-        this.enableTypeFetching = enableTypeFetching;
         this.computedOptions = utils.mergeOptions(
           // predefined options
           _2.keyBy(this.definedOptions, "id"),
@@ -146100,14 +145814,6 @@ var require_openapi_to_postmanv2 = __commonJS({
         }
         return cb(new UserError(_2.get(schema2, "validationResult.reason", DEFAULT_INVALID_ERROR)));
       },
-      convertV2WithTypes: function(input, options, cb) {
-        const enableTypeFetching = true;
-        var schema2 = new SchemaPack(input, options, MODULE_VERSION.V2, enableTypeFetching);
-        if (schema2.validated) {
-          return schema2.convertV2(cb);
-        }
-        return cb(new UserError(_2.get(schema2, "validationResult.reason", DEFAULT_INVALID_ERROR)));
-      },
       validate: function(input) {
         var schema2 = new SchemaPack(input);
         return schema2.validationResult;

src-tauri/vendored/plugins/importer-openapi/package.json

@@ -7,7 +7,7 @@
     "dev": "yaakcli dev ./src/index.js"
   },
   "dependencies": {
-    "openapi-to-postmanv2": "^5.0.0",
+    "openapi-to-postmanv2": "^4.23.1",
     "yaml": "^2.4.2"
   },
   "devDependencies": {

src-tauri/vendored/plugins/importer-yaak/build/index.js

@@ -69,12 +69,6 @@ function migrateImport(contents) {
       }
     }
   }
-  for (const environment of parsed.resources.environments ?? []) {
-    if ("environmentId" in environment) {
-      environment.base = environment.environmentId == null;
-      delete environment.environmentId;
-    }
-  }
   return { resources: parsed.resources };
 }
 function isJSObject(obj) {

src-tauri/vendored/plugins/template-function-cookie/build/index.js

@@ -1,47 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  plugin: () => plugin
-});
-module.exports = __toCommonJS(src_exports);
-var plugin = {
-  templateFunctions: [
-    {
-      name: "cookie.value",
-      description: "Read the value of a cookie in the jar, by name",
-      args: [
-        {
-          type: "text",
-          name: "cookie_name",
-          label: "Cookie Name"
-        }
-      ],
-      async onRender(ctx, args) {
-        return ctx.cookies.getValue({ name: String(args.values.cookie_name) });
-      }
-    }
-  ]
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  plugin
-});

src-tauri/vendored/plugins/template-function-cookie/package.json

@@ -1,9 +0,0 @@
-{
-  "name": "@yaakapp/template-function-cookie",
-  "private": true,
-  "version": "0.0.1",
-  "scripts": {
-    "build": "yaakcli build ./src/index.ts",
-    "dev": "yaakcli dev ./src/index.js"
-  }
-}

src-tauri/vendored/plugins/template-function-encode/build/index.js

@@ -1,69 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  plugin: () => plugin
-});
-module.exports = __toCommonJS(src_exports);
-var plugin = {
-  templateFunctions: [
-    {
-      name: "base64.encode",
-      description: "Encode a value to base64",
-      args: [{ label: "Plain Text", type: "text", name: "value", multiLine: true }],
-      async onRender(_ctx, args) {
-        return Buffer.from(args.values.value ?? "").toString("base64");
-      }
-    },
-    {
-      name: "base64.decode",
-      description: "Decode a value from base64",
-      args: [{ label: "Encoded Value", type: "text", name: "value", multiLine: true }],
-      async onRender(_ctx, args) {
-        return Buffer.from(args.values.value ?? "", "base64").toString("utf-8");
-      }
-    },
-    {
-      name: "url.encode",
-      description: "Encode a value for use in a URL (percent-encoding)",
-      args: [{ label: "Plain Text", type: "text", name: "value", multiLine: true }],
-      async onRender(_ctx, args) {
-        return encodeURIComponent(args.values.value ?? "");
-      }
-    },
-    {
-      name: "url.decode",
-      description: "Decode a percent-encoded URL value",
-      args: [{ label: "Encoded Value", type: "text", name: "value", multiLine: true }],
-      async onRender(_ctx, args) {
-        try {
-          return decodeURIComponent(args.values.value ?? "");
-        } catch {
-          return "";
-        }
-      }
-    }
-  ]
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  plugin
-});

src-tauri/vendored/plugins/template-function-encode/package.json

@@ -1,9 +0,0 @@
-{
-  "name": "@yaakapp/template-function-encode",
-  "private": true,
-  "version": "0.0.1",
-  "scripts": {
-    "build": "yaakcli build ./src/index.ts",
-    "dev": "yaakcli dev ./src/index.js"
-  }
-}

src-tauri/vendored/plugins/template-function-file/build/index.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -23,26 +33,18 @@ __export(src_exports, {
   plugin: () => plugin
 });
 module.exports = __toCommonJS(src_exports);
+var import_node_fs = __toESM(require("node:fs"));
 var plugin = {
   templateFunctions: [{
-    name: "regex.match",
-    description: "Extract",
-    args: [
-      {
-        type: "text",
-        name: "regex",
-        label: "Regular Expression",
-        placeholder: "^w+=(?<value>w*)$",
-        defaultValue: "^(.*)$",
-        description: "A JavaScript regular expression, evaluated using the Node.js RegExp engine. Capture groups or named groups can be used to extract values."
-      },
-      { type: "text", name: "input", label: "Input Text", multiLine: true }
-    ],
+    name: "fs.readFile",
+    args: [{ title: "Select File", type: "file", name: "path", label: "File" }],
     async onRender(_ctx, args) {
-      if (!args.values.regex) return "";
-      const regex = new RegExp(String(args.values.regex));
-      const match = args.values.input?.match(regex);
-      return match?.groups ? Object.values(match.groups)[0] ?? "" : match?.[1] ?? match?.[0] ?? "";
+      if (!args.values.path) return null;
+      try {
+        return import_node_fs.default.promises.readFile(args.values.path, "utf-8");
+      } catch (err) {
+        return null;
+      }
     }
   }]
 };

src-tauri/vendored/plugins/template-function-file/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "@yaakapp/auth-oauth2",
+  "name": "@yaakapp/template-function-file",
   "private": true,
   "version": "0.0.1",
   "scripts": {

src-tauri/vendored/plugins/template-function-hash/build/index.js

@@ -25,76 +25,24 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 var import_node_crypto = require("node:crypto");
 var algorithms = ["md5", "sha1", "sha256", "sha512"];
-var encodings = ["base64", "hex"];
-var hashFunctions = algorithms.map((algorithm) => ({
-  name: `hash.${algorithm}`,
-  description: "Hash a value to its hexidecimal representation",
-  args: [
-    {
-      type: "text",
-      name: "input",
-      label: "Input",
-      placeholder: "input text",
-      multiLine: true
-    },
-    {
-      type: "select",
-      name: "encoding",
-      label: "Encoding",
-      defaultValue: "base64",
-      options: encodings.map((encoding) => ({
-        label: capitalize(encoding),
-        value: encoding
-      }))
-    }
-  ],
-  async onRender(_ctx, args) {
-    const input = String(args.values.input);
-    const encoding = String(args.values.encoding);
-    return (0, import_node_crypto.createHash)(algorithm).update(input, "utf-8").digest(encoding);
-  }
-}));
-var hmacFunctions = algorithms.map((algorithm) => ({
-  name: `hmac.${algorithm}`,
-  description: "Compute the HMAC of a value",
-  args: [
-    {
-      type: "text",
-      name: "input",
-      label: "Input",
-      placeholder: "input text",
-      multiLine: true
-    },
-    {
-      type: "text",
-      name: "key",
-      label: "Key",
-      password: true
-    },
-    {
-      type: "select",
-      name: "encoding",
-      label: "Encoding",
-      defaultValue: "base64",
-      options: encodings.map((encoding) => ({
-        value: encoding,
-        label: capitalize(encoding)
-      }))
-    }
-  ],
-  async onRender(_ctx, args) {
-    const input = String(args.values.input);
-    const key = String(args.values.key);
-    const encoding = String(args.values.encoding);
-    return (0, import_node_crypto.createHmac)(algorithm, key, {}).update(input).digest(encoding);
-  }
-}));
 var plugin = {
-  templateFunctions: [...hashFunctions, ...hmacFunctions]
+  templateFunctions: algorithms.map((algorithm) => ({
+    name: `hash.${algorithm}`,
+    description: "Hash a value to its hexidecimal representation",
+    args: [
+      {
+        name: "input",
+        label: "Input",
+        placeholder: "input text",
+        type: "text"
+      }
+    ],
+    async onRender(_ctx, args) {
+      if (!args.values.input) return "";
+      return (0, import_node_crypto.createHash)(algorithm).update(args.values.input, "utf-8").digest("hex");
+    }
+  }))
 };
-function capitalize(str) {
-  return str.charAt(0).toUpperCase() + str.slice(1);
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   plugin

src-tauri/vendored/plugins/template-function-json/package.json

@@ -1,15 +0,0 @@
-{
-  "name": "@yaakapp/template-function-json",
-  "private": true,
-  "version": "0.0.1",
-  "scripts": {
-    "build": "yaakcli build ./src/index.ts",
-    "dev": "yaakcli dev ./src/index.js"
-  },
-  "dependencies": {
-    "jsonpath-plus": "^10.3.0"
-  },
-  "devDependencies": {
-    "@types/jsonpath": "^0.2.4"
-  }
-}

src-tauri/vendored/plugins/template-function-regex/package.json

@@ -1,9 +0,0 @@
-{
-  "name": "@yaakapp/template-function-regex",
-  "private": true,
-  "version": "0.0.1",
-  "scripts": {
-    "build": "yaakcli build ./src/index.ts",
-    "dev": "yaakcli dev ./src/index.js"
-  }
-}

src-tauri/vendored/plugins/template-function-response/build/index.js

@@ -8824,8 +8824,8 @@ var behaviorArg = {
   label: "Sending Behavior",
   defaultValue: "smart",
   options: [
-    { label: "When no responses", value: "smart" },
-    { label: "Always", value: "always" }
+    { name: "When no responses", value: "smart" },
+    { name: "Always", value: "always" }
   ]
 };
 var requestArg = {

src-tauri/vendored/plugins/template-function-uuid/build/index.js

@@ -1,417 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  plugin: () => plugin
-});
-module.exports = __toCommonJS(src_exports);
-
-// node_modules/uuid/dist/esm/regex.js
-var regex_default = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i;
-
-// node_modules/uuid/dist/esm/validate.js
-function validate(uuid) {
-  return typeof uuid === "string" && regex_default.test(uuid);
-}
-var validate_default = validate;
-
-// node_modules/uuid/dist/esm/parse.js
-function parse(uuid) {
-  if (!validate_default(uuid)) {
-    throw TypeError("Invalid UUID");
-  }
-  let v;
-  return Uint8Array.of((v = parseInt(uuid.slice(0, 8), 16)) >>> 24, v >>> 16 & 255, v >>> 8 & 255, v & 255, (v = parseInt(uuid.slice(9, 13), 16)) >>> 8, v & 255, (v = parseInt(uuid.slice(14, 18), 16)) >>> 8, v & 255, (v = parseInt(uuid.slice(19, 23), 16)) >>> 8, v & 255, (v = parseInt(uuid.slice(24, 36), 16)) / 1099511627776 & 255, v / 4294967296 & 255, v >>> 24 & 255, v >>> 16 & 255, v >>> 8 & 255, v & 255);
-}
-var parse_default = parse;
-
-// node_modules/uuid/dist/esm/stringify.js
-var byteToHex = [];
-for (let i = 0; i < 256; ++i) {
-  byteToHex.push((i + 256).toString(16).slice(1));
-}
-function unsafeStringify(arr, offset = 0) {
-  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
-}
-
-// node_modules/uuid/dist/esm/rng.js
-var import_crypto = require("crypto");
-var rnds8Pool = new Uint8Array(256);
-var poolPtr = rnds8Pool.length;
-function rng() {
-  if (poolPtr > rnds8Pool.length - 16) {
-    (0, import_crypto.randomFillSync)(rnds8Pool);
-    poolPtr = 0;
-  }
-  return rnds8Pool.slice(poolPtr, poolPtr += 16);
-}
-
-// node_modules/uuid/dist/esm/v1.js
-var _state = {};
-function v1(options, buf, offset) {
-  let bytes;
-  const isV6 = options?._v6 ?? false;
-  if (options) {
-    const optionsKeys = Object.keys(options);
-    if (optionsKeys.length === 1 && optionsKeys[0] === "_v6") {
-      options = void 0;
-    }
-  }
-  if (options) {
-    bytes = v1Bytes(options.random ?? options.rng?.() ?? rng(), options.msecs, options.nsecs, options.clockseq, options.node, buf, offset);
-  } else {
-    const now = Date.now();
-    const rnds = rng();
-    updateV1State(_state, now, rnds);
-    bytes = v1Bytes(rnds, _state.msecs, _state.nsecs, isV6 ? void 0 : _state.clockseq, isV6 ? void 0 : _state.node, buf, offset);
-  }
-  return buf ?? unsafeStringify(bytes);
-}
-function updateV1State(state, now, rnds) {
-  state.msecs ??= -Infinity;
-  state.nsecs ??= 0;
-  if (now === state.msecs) {
-    state.nsecs++;
-    if (state.nsecs >= 1e4) {
-      state.node = void 0;
-      state.nsecs = 0;
-    }
-  } else if (now > state.msecs) {
-    state.nsecs = 0;
-  } else if (now < state.msecs) {
-    state.node = void 0;
-  }
-  if (!state.node) {
-    state.node = rnds.slice(10, 16);
-    state.node[0] |= 1;
-    state.clockseq = (rnds[8] << 8 | rnds[9]) & 16383;
-  }
-  state.msecs = now;
-  return state;
-}
-function v1Bytes(rnds, msecs, nsecs, clockseq, node, buf, offset = 0) {
-  if (rnds.length < 16) {
-    throw new Error("Random bytes length must be >= 16");
-  }
-  if (!buf) {
-    buf = new Uint8Array(16);
-    offset = 0;
-  } else {
-    if (offset < 0 || offset + 16 > buf.length) {
-      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
-    }
-  }
-  msecs ??= Date.now();
-  nsecs ??= 0;
-  clockseq ??= (rnds[8] << 8 | rnds[9]) & 16383;
-  node ??= rnds.slice(10, 16);
-  msecs += 122192928e5;
-  const tl = ((msecs & 268435455) * 1e4 + nsecs) % 4294967296;
-  buf[offset++] = tl >>> 24 & 255;
-  buf[offset++] = tl >>> 16 & 255;
-  buf[offset++] = tl >>> 8 & 255;
-  buf[offset++] = tl & 255;
-  const tmh = msecs / 4294967296 * 1e4 & 268435455;
-  buf[offset++] = tmh >>> 8 & 255;
-  buf[offset++] = tmh & 255;
-  buf[offset++] = tmh >>> 24 & 15 | 16;
-  buf[offset++] = tmh >>> 16 & 255;
-  buf[offset++] = clockseq >>> 8 | 128;
-  buf[offset++] = clockseq & 255;
-  for (let n = 0; n < 6; ++n) {
-    buf[offset++] = node[n];
-  }
-  return buf;
-}
-var v1_default = v1;
-
-// node_modules/uuid/dist/esm/v1ToV6.js
-function v1ToV6(uuid) {
-  const v1Bytes2 = typeof uuid === "string" ? parse_default(uuid) : uuid;
-  const v6Bytes = _v1ToV6(v1Bytes2);
-  return typeof uuid === "string" ? unsafeStringify(v6Bytes) : v6Bytes;
-}
-function _v1ToV6(v1Bytes2) {
-  return Uint8Array.of((v1Bytes2[6] & 15) << 4 | v1Bytes2[7] >> 4 & 15, (v1Bytes2[7] & 15) << 4 | (v1Bytes2[4] & 240) >> 4, (v1Bytes2[4] & 15) << 4 | (v1Bytes2[5] & 240) >> 4, (v1Bytes2[5] & 15) << 4 | (v1Bytes2[0] & 240) >> 4, (v1Bytes2[0] & 15) << 4 | (v1Bytes2[1] & 240) >> 4, (v1Bytes2[1] & 15) << 4 | (v1Bytes2[2] & 240) >> 4, 96 | v1Bytes2[2] & 15, v1Bytes2[3], v1Bytes2[8], v1Bytes2[9], v1Bytes2[10], v1Bytes2[11], v1Bytes2[12], v1Bytes2[13], v1Bytes2[14], v1Bytes2[15]);
-}
-
-// node_modules/uuid/dist/esm/md5.js
-var import_crypto2 = require("crypto");
-function md5(bytes) {
-  if (Array.isArray(bytes)) {
-    bytes = Buffer.from(bytes);
-  } else if (typeof bytes === "string") {
-    bytes = Buffer.from(bytes, "utf8");
-  }
-  return (0, import_crypto2.createHash)("md5").update(bytes).digest();
-}
-var md5_default = md5;
-
-// node_modules/uuid/dist/esm/v35.js
-function stringToBytes(str) {
-  str = unescape(encodeURIComponent(str));
-  const bytes = new Uint8Array(str.length);
-  for (let i = 0; i < str.length; ++i) {
-    bytes[i] = str.charCodeAt(i);
-  }
-  return bytes;
-}
-var DNS = "6ba7b810-9dad-11d1-80b4-00c04fd430c8";
-var URL = "6ba7b811-9dad-11d1-80b4-00c04fd430c8";
-function v35(version, hash, value, namespace, buf, offset) {
-  const valueBytes = typeof value === "string" ? stringToBytes(value) : value;
-  const namespaceBytes = typeof namespace === "string" ? parse_default(namespace) : namespace;
-  if (typeof namespace === "string") {
-    namespace = parse_default(namespace);
-  }
-  if (namespace?.length !== 16) {
-    throw TypeError("Namespace must be array-like (16 iterable integer values, 0-255)");
-  }
-  let bytes = new Uint8Array(16 + valueBytes.length);
-  bytes.set(namespaceBytes);
-  bytes.set(valueBytes, namespaceBytes.length);
-  bytes = hash(bytes);
-  bytes[6] = bytes[6] & 15 | version;
-  bytes[8] = bytes[8] & 63 | 128;
-  if (buf) {
-    offset = offset || 0;
-    for (let i = 0; i < 16; ++i) {
-      buf[offset + i] = bytes[i];
-    }
-    return buf;
-  }
-  return unsafeStringify(bytes);
-}
-
-// node_modules/uuid/dist/esm/v3.js
-function v3(value, namespace, buf, offset) {
-  return v35(48, md5_default, value, namespace, buf, offset);
-}
-v3.DNS = DNS;
-v3.URL = URL;
-var v3_default = v3;
-
-// node_modules/uuid/dist/esm/native.js
-var import_crypto3 = require("crypto");
-var native_default = { randomUUID: import_crypto3.randomUUID };
-
-// node_modules/uuid/dist/esm/v4.js
-function v4(options, buf, offset) {
-  if (native_default.randomUUID && !buf && !options) {
-    return native_default.randomUUID();
-  }
-  options = options || {};
-  const rnds = options.random ?? options.rng?.() ?? rng();
-  if (rnds.length < 16) {
-    throw new Error("Random bytes length must be >= 16");
-  }
-  rnds[6] = rnds[6] & 15 | 64;
-  rnds[8] = rnds[8] & 63 | 128;
-  if (buf) {
-    offset = offset || 0;
-    if (offset < 0 || offset + 16 > buf.length) {
-      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
-    }
-    for (let i = 0; i < 16; ++i) {
-      buf[offset + i] = rnds[i];
-    }
-    return buf;
-  }
-  return unsafeStringify(rnds);
-}
-var v4_default = v4;
-
-// node_modules/uuid/dist/esm/sha1.js
-var import_crypto4 = require("crypto");
-function sha1(bytes) {
-  if (Array.isArray(bytes)) {
-    bytes = Buffer.from(bytes);
-  } else if (typeof bytes === "string") {
-    bytes = Buffer.from(bytes, "utf8");
-  }
-  return (0, import_crypto4.createHash)("sha1").update(bytes).digest();
-}
-var sha1_default = sha1;
-
-// node_modules/uuid/dist/esm/v5.js
-function v5(value, namespace, buf, offset) {
-  return v35(80, sha1_default, value, namespace, buf, offset);
-}
-v5.DNS = DNS;
-v5.URL = URL;
-var v5_default = v5;
-
-// node_modules/uuid/dist/esm/v6.js
-function v6(options, buf, offset) {
-  options ??= {};
-  offset ??= 0;
-  let bytes = v1_default({ ...options, _v6: true }, new Uint8Array(16));
-  bytes = v1ToV6(bytes);
-  if (buf) {
-    for (let i = 0; i < 16; i++) {
-      buf[offset + i] = bytes[i];
-    }
-    return buf;
-  }
-  return unsafeStringify(bytes);
-}
-var v6_default = v6;
-
-// node_modules/uuid/dist/esm/v7.js
-var _state2 = {};
-function v7(options, buf, offset) {
-  let bytes;
-  if (options) {
-    bytes = v7Bytes(options.random ?? options.rng?.() ?? rng(), options.msecs, options.seq, buf, offset);
-  } else {
-    const now = Date.now();
-    const rnds = rng();
-    updateV7State(_state2, now, rnds);
-    bytes = v7Bytes(rnds, _state2.msecs, _state2.seq, buf, offset);
-  }
-  return buf ?? unsafeStringify(bytes);
-}
-function updateV7State(state, now, rnds) {
-  state.msecs ??= -Infinity;
-  state.seq ??= 0;
-  if (now > state.msecs) {
-    state.seq = rnds[6] << 23 | rnds[7] << 16 | rnds[8] << 8 | rnds[9];
-    state.msecs = now;
-  } else {
-    state.seq = state.seq + 1 | 0;
-    if (state.seq === 0) {
-      state.msecs++;
-    }
-  }
-  return state;
-}
-function v7Bytes(rnds, msecs, seq, buf, offset = 0) {
-  if (rnds.length < 16) {
-    throw new Error("Random bytes length must be >= 16");
-  }
-  if (!buf) {
-    buf = new Uint8Array(16);
-    offset = 0;
-  } else {
-    if (offset < 0 || offset + 16 > buf.length) {
-      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
-    }
-  }
-  msecs ??= Date.now();
-  seq ??= rnds[6] * 127 << 24 | rnds[7] << 16 | rnds[8] << 8 | rnds[9];
-  buf[offset++] = msecs / 1099511627776 & 255;
-  buf[offset++] = msecs / 4294967296 & 255;
-  buf[offset++] = msecs / 16777216 & 255;
-  buf[offset++] = msecs / 65536 & 255;
-  buf[offset++] = msecs / 256 & 255;
-  buf[offset++] = msecs & 255;
-  buf[offset++] = 112 | seq >>> 28 & 15;
-  buf[offset++] = seq >>> 20 & 255;
-  buf[offset++] = 128 | seq >>> 14 & 63;
-  buf[offset++] = seq >>> 6 & 255;
-  buf[offset++] = seq << 2 & 255 | rnds[10] & 3;
-  buf[offset++] = rnds[11];
-  buf[offset++] = rnds[12];
-  buf[offset++] = rnds[13];
-  buf[offset++] = rnds[14];
-  buf[offset++] = rnds[15];
-  return buf;
-}
-var v7_default = v7;
-
-// src/index.ts
-var plugin = {
-  templateFunctions: [
-    {
-      name: "uuid.v1",
-      description: "Generate a UUID V1",
-      args: [],
-      async onRender(_ctx, _args) {
-        return v1_default();
-      }
-    },
-    {
-      name: "uuid.v3",
-      description: "Generate a UUID V3",
-      args: [
-        { type: "text", name: "name", label: "Name" },
-        {
-          type: "text",
-          name: "namespace",
-          label: "Namespace UUID",
-          description: "A valid UUID to use as the namespace",
-          placeholder: "24ced880-3bf4-11f0-8329-cd053d577f0e"
-        }
-      ],
-      async onRender(_ctx, args) {
-        return v3_default(String(args.values.name), String(args.values.namespace));
-      }
-    },
-    {
-      name: "uuid.v4",
-      description: "Generate a UUID V4",
-      args: [],
-      async onRender(_ctx, _args) {
-        return v4_default();
-      }
-    },
-    {
-      name: "uuid.v5",
-      description: "Generate a UUID V5",
-      args: [
-        { type: "text", name: "name", label: "Name" },
-        { type: "text", name: "namespace", label: "Namespace" }
-      ],
-      async onRender(_ctx, args) {
-        return v5_default(String(args.values.name), String(args.values.namespace));
-      }
-    },
-    {
-      name: "uuid.v6",
-      description: "Generate a UUID V6",
-      args: [
-        {
-          type: "text",
-          name: "timestamp",
-          label: "Timestamp",
-          optional: true,
-          description: "Can be any format that can be parsed by JavaScript new Date(...)",
-          placeholder: "2025-05-28T11:15:00Z"
-        }
-      ],
-      async onRender(_ctx, args) {
-        return v6_default({ msecs: new Date(String(args.values.timestamp)).getTime() });
-      }
-    },
-    {
-      name: "uuid.v7",
-      description: "Generate a UUID V7",
-      args: [],
-      async onRender(_ctx, _args) {
-        return v7_default();
-      }
-    }
-  ]
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  plugin
-});

src-tauri/vendored/plugins/template-function-uuid/package.json

@@ -1,12 +0,0 @@
-{
-  "name": "@yaakapp/template-function-uuid",
-  "private": true,
-  "version": "0.0.1",
-  "scripts": {
-    "build": "yaakcli build ./src/index.ts",
-    "dev": "yaakcli dev ./src/index.js"
-  },
-  "dependencies": {
-    "uuid": "^11.1.0"
-  }
-}

src-tauri/vendored/plugins/template-function-xml/package.json

@@ -1,13 +0,0 @@
-{
-  "name": "@yaakapp/template-function-xml",
-  "private": true,
-  "version": "0.0.1",
-  "scripts": {
-    "build": "yaakcli build ./src/index.ts",
-    "dev": "yaakcli dev ./src/index.js"
-  },
-  "dependencies": {
-    "@xmldom/xmldom": "^0.8.10",
-    "xpath": "^0.0.34"
-  }
-}

src-tauri/yaak-common/Cargo.toml

@@ -1,9 +0,0 @@
-[package]
-name = "yaak-common"
-version = "0.1.0"
-edition = "2024"
-publish = false
-
-[dependencies]
-tauri = { workspace = true }
-regex = "1.11.0"

src-tauri/yaak-common/src/lib.rs

@@ -1 +0,0 @@
-pub mod window;

src-tauri/yaak-common/src/window.rs

@@ -1,31 +0,0 @@
-use regex::Regex;
-use tauri::{Runtime, WebviewWindow};
-
-pub trait WorkspaceWindowTrait {
-    fn workspace_id(&self) -> Option<String>;
-    fn cookie_jar_id(&self) -> Option<String>;
-    fn environment_id(&self) -> Option<String>;
-}
-
-impl<R: Runtime> WorkspaceWindowTrait for WebviewWindow<R> {
-    fn workspace_id(&self) -> Option<String> {
-        let url = self.url().unwrap();
-        let re = Regex::new(r"/workspaces/(?<id>\w+)").unwrap();
-        match re.captures(url.as_str()) {
-            None => None,
-            Some(captures) => captures.name("id").map(|c| c.as_str().to_string()),
-        }
-    }
-
-    fn cookie_jar_id(&self) -> Option<String> {
-        let url = self.url().unwrap();
-        let mut query_pairs = url.query_pairs();
-        query_pairs.find(|(k, _v)| k == "cookie_jar_id").map(|(_k, v)| v.to_string())
-    }
-
-    fn environment_id(&self) -> Option<String> {
-        let url = self.url().unwrap();
-        let mut query_pairs = url.query_pairs();
-        query_pairs.find(|(k, _v)| k == "environment_id").map(|(_k, v)| v.to_string())
-    }
-}

src-tauri/yaak-crypto/Cargo.toml

@@ -1,20 +0,0 @@
-[package]
-name = "yaak-crypto"
-links = "yaak-crypto"
-version = "0.1.0"
-edition = "2021"
-publish = false
-
-[dependencies]
-base32 = "0.5.1" # For encoding human-readable key
-base64 = "0.22.1" # For encoding in the database
-chacha20poly1305 = "0.10.1"
-keyring = { version = "4.0.0-rc.1" }
-log = "0.4.26"
-serde = { workspace = true, features = ["derive"] }
-tauri = { workspace = true }
-thiserror = "2.0.12"
-yaak-models = { workspace = true }
-
-[build-dependencies]
-tauri-plugin = { workspace = true, features = ["build"] }