Fix vite and top-level-await build error

Closes https://feedback.yaak.app/p/grpc-address-reflection-and-address-bar-issues

.eslintrc.cjs

@@ -8,14 +8,15 @@ module.exports = {
     'plugin:@typescript-eslint/recommended',
     'eslint-config-prettier',
   ],
+  plugins: ['react-refresh'],
   parser: '@typescript-eslint/parser',
   parserOptions: {
     project: ['./tsconfig.json'],
   },
   ignorePatterns: [
     'scripts/**/*',
-    'plugin-runtime/**/*',
-    'plugin-runtime-types/**/*',
+    'packages/plugin-runtime/**/*',
+    'packages/plugin-runtime-types/**/*',
     'src-tauri/**/*',
     'src-web/tailwind.config.cjs',
     'src-web/vite.config.ts',
@@ -32,6 +33,7 @@ module.exports = {
     },
   },
   rules: {
+    'react-refresh/only-export-components': 'error',
     'jsx-a11y/no-autofocus': 'off',
     'react/react-in-jsx-scope': 'off',
     'import/no-unresolved': 'off',

.github/FUNDING.yml

@@ -0,0 +1,15 @@
+# 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

@@ -0,0 +1,38 @@
+---
+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

@@ -22,13 +22,14 @@ jobs:
           - platform: 'macos-latest' # for Intel-based Macs.
             args: '--target x86_64-apple-darwin'
             yaak_arch: 'x64'
-          - platform: 'ubuntu-22.04' # for Tauri v1, you could replace this with ubuntu-20.04.
+          - platform: 'ubuntu-22.04'
             args: ''
             yaak_arch: 'x64'
           - platform: 'windows-latest'
             args: ''
             yaak_arch: 'x64'
     runs-on: ${{ matrix.platform }}
+    timeout-minutes: 40
     steps:
       - name: Checkout yaakapp/app
         uses: actions/checkout@v4
@@ -38,10 +39,6 @@ jobs:
         with:
           node-version: 22
 
-      - uses: actions/setup-go@v5
-        with:
-          go-version: '1.22'
-
       - name: install Rust stable
         uses: dtolnay/rust-toolchain@stable
         with:
@@ -56,7 +53,7 @@ jobs:
             ~/.cargo/registry/index/
             ~/.cargo/registry/cache/
             ~/.cargo/git/db/
-            target/
+            src-tauri/target/
           key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
           restore-keys: ${{ runner.os }}-cargo-
 
@@ -66,6 +63,10 @@ jobs:
           sudo apt-get update
           sudo apt-get install -y libwebkit2gtk-4.1-dev libappindicator3-dev librsvg2-dev patchelf
 
+      - name: install dependencies (windows only)
+        if: matrix.platform == 'windows-latest'
+        run: cargo install --force trusted-signing-cli
+
       - name: Install NPM Dependencies
         run: |
           npm ci
@@ -76,6 +77,9 @@ jobs:
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
 
+      - name: Run JS build
+        run: npm run build
+
       - name: Run lint
         run: npm run lint
 
@@ -94,20 +98,28 @@ jobs:
         env:
           YAAK_PLUGINS_DIR: ${{ env.YAAK_PLUGINS_DIR }}
           YAAK_TARGET_ARCH: ${{ matrix.yaak_arch }}
+
+          ENABLE_CODE_SIGNING: ${{ secrets.APPLE_CERTIFICATE }}
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
           TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
-          ENABLE_CODE_SIGNING: ${{ secrets.APPLE_CERTIFICATE }}
-          APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
-          APPLE_CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
-          APPLE_SIGNING_IDENTITY: ${{ secrets.APPLE_SIGNING_IDENTITY }}
-          APPLE_ID: ${{ secrets.APPLE_ID }}
-          APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
-          APPLE_PASSWORD: ${{ secrets.APPLE_PASSWORD }}
+
+          # Apple signing stuff
+          APPLE_CERTIFICATE: ${{ matrix.platform == 'macos-latest' && secrets.APPLE_CERTIFICATE }}
+          APPLE_CERTIFICATE_PASSWORD: ${{ matrix.platform == 'macos-latest' && secrets.APPLE_CERTIFICATE_PASSWORD }}
+          APPLE_ID: ${{ matrix.platform == 'macos-latest' && secrets.APPLE_ID }}
+          APPLE_PASSWORD: ${{ matrix.platform == 'macos-latest' && secrets.APPLE_PASSWORD }}
+          APPLE_SIGNING_IDENTITY: ${{ matrix.platform == 'macos-latest' && secrets.APPLE_SIGNING_IDENTITY }}
+          APPLE_TEAM_ID: ${{ matrix.platform == 'macos-latest' && secrets.APPLE_TEAM_ID }}
+
+          # Windows signing stuff
+          AZURE_CLIENT_ID: ${{ matrix.platform == 'windows-latest' && secrets.AZURE_CLIENT_ID }}
+          AZURE_CLIENT_SECRET: ${{ matrix.platform == 'windows-latest' && secrets.AZURE_CLIENT_SECRET }}
+          AZURE_TENANT_ID: ${{ matrix.platform == 'windows-latest' && secrets.AZURE_TENANT_ID }}
         with:
           tagName: 'v__VERSION__'
           releaseName: 'Release __VERSION__'
-          releaseBody: 'https://yaak.app/blog/__VERSION__'
+          releaseBody: '[Changelog __VERSION__](https://yaak.app/blog/__VERSION__)'
           releaseDraft: true
           prerelease: false
           args: ${{ matrix.args }}

.prettierrc.cjs

@@ -1,8 +0,0 @@
-module.exports = {
-    "trailingComma": "all",
-    "tabWidth": 2,
-    "semi": true,
-    "singleQuote": true,
-    "printWidth": 100,
-    "bracketSpacing": true
-}

.prettierrc.js

@@ -0,0 +1,8 @@
+export default {
+  "trailingComma": "all",
+  "tabWidth": 2,
+  "semi": true,
+  "singleQuote": true,
+  "printWidth": 100,
+  "bracketSpacing": true
+}

DEVELOPMENT.md

@@ -60,3 +60,10 @@ 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,20 +1,37 @@
-# [Yaak API Client](https://yaak.app)
+# Yaak API Client
 
-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.
+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.
 
 ![screenshot](https://github.com/user-attachments/assets/f18e963f-0b68-4ecb-b8b8-cb71aa9aec02)
 
+## 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/>
+- 🏷️ 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
+
 ## 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.
+[feedback.yaak.app](https://feedback.yaak.app).
+
+## Community Projects
+
+- [`yaak2postman`](https://github.com/BiteCraft/yaak2postman) CLI for converting Yaak data
+  exports to Postman-compatible collections
 
 ## Contribution Policy
 
-Yaak 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.
-
-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. To get started, 
+visit [`DEVELOPMENT.md`](DEVELOPMENT.md) for tips on setting up your environment.

package.json

@@ -4,22 +4,29 @@
   "version": "0.0.0",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/yaakapp/app.git"
+    "url": "git+https://github.com/mountain-loop/yaak.git"
   },
   "workspaces": [
-    "plugin-runtime",
-    "plugin-runtime-types",
-    "src-tauri/yaak_models",
-    "src-tauri/yaak_plugin_runtime",
-    "src-tauri/yaak_sync",
-    "src-tauri/yaak_templates",
-    "src-tauri/yaak_sse",
+    "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": {
     "start": "npm run app-dev",
     "app-build": "tauri build",
     "app-dev": "tauri dev --no-watch --config ./src-tauri/tauri-dev.conf.json",
+    "build": "npm run --workspaces --if-present build",
     "bootstrap": "run-p bootstrap:* && npm run --workspaces --if-present bootstrap",
     "bootstrap:vendor-node": "node scripts/vendor-node.cjs",
     "bootstrap:vendor-plugins": "node scripts/vendor-plugins.cjs",
@@ -30,19 +37,22 @@
     "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.0.3",
-    "@typescript-eslint/eslint-plugin": "^8.5.0",
-    "@typescript-eslint/parser": "^8.5.0",
+    "@tauri-apps/cli": "^2.4.1",
+    "@typescript-eslint/eslint-plugin": "^8.27.0",
+    "@typescript-eslint/parser": "^8.27.0",
     "eslint": "^8",
     "eslint-config-prettier": "^8",
-    "eslint-plugin-import": "^2.30.0",
-    "eslint-plugin-jsx-a11y": "^6.10.0",
-    "eslint-plugin-react": "^7.35.2",
-    "eslint-plugin-react-hooks": "^4.6.2",
+    "eslint-plugin-import": "^2.31.0",
+    "eslint-plugin-jsx-a11y": "^6.10.2",
+    "eslint-plugin-react": "^7.37.2",
+    "eslint-plugin-react-hooks": "^5.1.0",
     "nodejs-file-downloader": "^4.13.0",
     "npm-run-all": "^4.1.5",
-    "prettier": "^3.3.3",
-    "typescript": "^5.6.2"
+    "prettier": "^3.4.2",
+    "typescript": "^5.8.2"
   }
 }

packages/common-lib/formatSize.ts

@@ -0,0 +1,20 @@
+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/common-lib/index.ts

@@ -0,0 +1 @@
+export * from './debounce';

packages/common-lib/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "@yaakapp-internal/plugin",
+  "name": "@yaakapp-internal/lib",
   "private": true,
   "version": "1.0.0",
   "main": "index.ts"

packages/plugin-runtime-types/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yaakapp/api",
-  "version": "0.2.16",
+  "version": "0.5.0",
   "main": "lib/index.js",
   "typings": "./lib/index.d.ts",
   "files": [
@@ -11,16 +11,15 @@
     "build": "run-s build:copy-types build:tsc",
     "build:tsc": "tsc",
     "build:copy-types": "run-p build:copy-types:*",
-    "build:copy-types:root": "cpy --flat ../src-tauri/yaak_plugin_runtime/bindings/*.ts ./src/bindings",
-    "build:copy-types:next": "cpy --flat ../src-tauri/yaak_plugin_runtime/bindings/serde_json/*.ts ./src/bindings/serde_json",
+    "build:copy-types:root": "cpy --flat ../../src-tauri/yaak-plugins/bindings/*.ts ./src/bindings",
+    "build:copy-types:next": "cpy --flat ../../src-tauri/yaak-plugins/bindings/serde_json/*.ts ./src/bindings/serde_json",
+    "publish": "npm publish",
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
     "@types/node": "^22.5.4"
   },
   "devDependencies": {
-    "cpy-cli": "^5.0.0",
-    "npm-run-all": "^4.1.5",
-    "typescript": "^5.6.2"
+    "cpy-cli": "^5.0.0"
   }
 }

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

@@ -0,0 +1,411 @@
+// 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, };
+
+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, };
+
+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, };
+
+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, };
+
+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, };
+
+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, };
+
+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, };
+
+export type GenericCompletionOption = { label: string, detail?: string, info?: string, type?: CompletionOptionType, boost?: number, };
+
+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": "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 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/gen_models.ts

@@ -1,18 +1,18 @@
 // 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, 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, };
+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, 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 GrpcMetadataEntry = { enabled?: boolean, name: string, value: 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>, message: string, metadata: Array<GrpcMetadataEntry>, method: string | null, name: string, service: string | null, sortPriority: number, url: 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, headers: Array<HttpRequestHeader>, method: string, name: string, sortPriority: number, url: string, urlParameters: Array<HttpUrlParameter>, };
+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>, };
 
-export type HttpRequestHeader = { enabled?: boolean, name: string, value: string, };
+export type HttpRequestHeader = { enabled?: boolean, name: string, value: string, id?: string, };
 
 export type HttpResponse = { model: "http_response", id: string, createdAt: string, updatedAt: string, workspaceId: string, requestId: string, bodyPath: string | null, contentLength: number | null, elapsed: number, elapsedHeaders: number, error: string | null, headers: Array<HttpResponseHeader>, remoteAddr: string | null, status: number, statusReason: string | null, state: HttpResponseState, url: string, version: string | null, };
 
@@ -20,6 +20,8 @@ export type HttpResponseHeader = { name: string, value: string, };
 
 export type HttpResponseState = "initialized" | "connected" | "closed";
 
-export type HttpUrlParameter = { enabled?: boolean, name: string, value: string, };
+export type HttpUrlParameter = { enabled?: boolean, name: string, value: string, id?: string, };
 
-export type Workspace = { model: "workspace", id: string, createdAt: string, updatedAt: string, name: string, description: string, variables: Array<EnvironmentVariable>, settingValidateCertificates: boolean, settingFollowRedirects: boolean, settingRequestTimeout: number, };
+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, name: string, description: string, encryptionKeyChallenge: string | null, settingValidateCertificates: boolean, settingFollowRedirects: boolean, settingRequestTimeout: number, };

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

@@ -0,0 +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;

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

@@ -1 +1,2 @@
 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

@@ -0,0 +1,5 @@
+export type * from './plugins';
+export type * from './themes';
+
+export * from './bindings/gen_models';
+export * from './bindings/gen_events';

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

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

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

@@ -1,8 +1,9 @@
-import {
+import type {
   FindHttpResponsesRequest,
   FindHttpResponsesResponse,
   GetHttpRequestByIdRequest,
   GetHttpRequestByIdResponse,
+  OpenWindowRequest,
   PromptTextRequest,
   PromptTextResponse,
   RenderHttpRequestRequest,
@@ -12,18 +13,31 @@ import {
   ShowToastRequest,
   TemplateRenderRequest,
   TemplateRenderResponse,
-} from '..';
+} from '../bindings/gen_events.ts';
 
-export type Context = {
+export interface Context {
   clipboard: {
-    copyText(text: string): void;
+    copyText(text: string): Promise<void>;
   };
   toast: {
-    show(args: ShowToastRequest): void;
+    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 }>;
+  };
   httpRequest: {
     send(args: SendHttpRequestRequest): Promise<SendHttpRequestResponse['httpResponse']>;
     getById(args: GetHttpRequestByIdRequest): Promise<GetHttpRequestByIdResponse['httpRequest']>;
@@ -35,4 +49,4 @@ export type Context = {
   templates: {
     render(args: TemplateRenderRequest): Promise<TemplateRenderResponse['data']>;
   };
-};
+}

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

@@ -0,0 +1,12 @@
+import type { Context } from './Context';
+
+export type FilterPluginResponse = { filtered: string };
+
+export type FilterPlugin = {
+  name: string;
+  description?: string;
+  onFilter(
+    ctx: Context,
+    args: { payload: string; filter: string; mimeType: string },
+  ): Promise<FilterPluginResponse> | FilterPluginResponse;
+};

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

@@ -1,5 +1,5 @@
-import { CallHttpRequestActionArgs, HttpRequestAction } from '..';
-import { Context } from './Context';
+import type { CallHttpRequestActionArgs, HttpRequestAction } from '../bindings/gen_events';
+import type { Context } from './Context';
 
 export type HttpRequestActionPlugin = HttpRequestAction & {
   onSelect(ctx: Context, args: CallHttpRequestActionArgs): Promise<void> | void;

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

@@ -0,0 +1,19 @@
+import { Environment, Folder, GrpcRequest, HttpRequest, Workspace } from '../bindings/gen_models';
+import type { AtLeast } from '../helpers';
+import type { Context } from './Context';
+
+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 = {
+  name: string;
+  description?: string;
+  onImport(ctx: Context, args: { text: string }): Promise<ImportPluginResponse>;
+};

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

@@ -0,0 +1,12 @@
+import {
+  CallTemplateFunctionArgs,
+  TemplateFunction,
+} from "../bindings/gen_events";
+import { Context } from "./Context";
+
+export type TemplateFunctionPlugin = TemplateFunction & {
+  onRender(
+    ctx: Context,
+    args: CallTemplateFunctionArgs,
+  ): Promise<string | null>;
+};

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

@@ -0,0 +1,8 @@
+import { Index } from "../themes";
+import { Context } from "./Context";
+
+export type ThemePlugin = {
+  name: string;
+  description?: string;
+  getTheme(ctx: Context, fileContents: string): Promise<Index>;
+};

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

@@ -0,0 +1,20 @@
+import { AuthenticationPlugin } from './AuthenticationPlugin';
+import type { FilterPlugin } from './FilterPlugin';
+import type { HttpRequestActionPlugin } from './HttpRequestActionPlugin';
+import type { ImporterPlugin } from './ImporterPlugin';
+import type { TemplateFunctionPlugin } from './TemplateFunctionPlugin';
+import type { ThemePlugin } from './ThemePlugin';
+
+export type { Context } from './Context';
+
+/**
+ * The global structure of a Yaak plugin
+ */
+export type PluginDefinition = {
+  importer?: ImporterPlugin;
+  theme?: ThemePlugin;
+  filter?: FilterPlugin;
+  authentication?: AuthenticationPlugin;
+  httpRequestActions?: HttpRequestActionPlugin[];
+  templateFunctions?: TemplateFunctionPlugin[];
+};

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

@@ -24,7 +24,7 @@ export type Colors = {
   danger?: string;
 };
 
-export type Theme = Colors & {
+export type Index = Colors & {
   id: string;
   name: string;
   components?: Partial<{

packages/plugin-runtime/package-lock.json

@@ -0,0 +1,10 @@
+{
+  "name": "@yaakapp-internal/plugin-runtime",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "@yaakapp-internal/plugin-runtime"
+    }
+  }
+}

packages/plugin-runtime/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "@yaakapp-internal/plugin-runtime",
+  "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"
+  },
+  "dependencies": {
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@types/ws": "^8.5.13"
+  }
+}

packages/plugin-runtime/src/EventChannel.ts

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

packages/plugin-runtime/src/PluginHandle.ts

@@ -0,0 +1,27 @@
+import type { BootRequest, InternalEvent } from '@yaakapp/api';
+import type { EventChannel } from './EventChannel';
+import { PluginInstance, PluginWorkerData } from './PluginInstance';
+
+export class PluginHandle {
+  #instance: PluginInstance;
+
+  constructor(
+    readonly pluginRefId: string,
+    readonly bootRequest: BootRequest,
+    readonly pluginToAppEvents: EventChannel,
+  ) {
+    const workerData: PluginWorkerData = {
+      pluginRefId: this.pluginRefId,
+      bootRequest: this.bootRequest,
+    };
+    this.#instance = new PluginInstance(workerData, pluginToAppEvents);
+  }
+
+  sendToWorker(event: InternalEvent) {
+    this.#instance.postMessage(event);
+  }
+
+  terminate() {
+    this.#instance.terminate();
+  }
+}

packages/plugin-runtime/src/PluginInstance.ts

@@ -0,0 +1,582 @@
+import { PluginWindowContext, TemplateFunctionArg } from '@yaakapp-internal/plugins';
+import type {
+  BootRequest,
+  Context,
+  DeleteKeyValueResponse,
+  FindHttpResponsesResponse,
+  FormInput,
+  GetHttpRequestByIdResponse,
+  GetKeyValueResponse,
+  HttpAuthenticationAction,
+  HttpRequestAction,
+  InternalEvent,
+  InternalEventPayload,
+  JsonPrimitive,
+  PluginDefinition,
+  PromptTextResponse,
+  RenderHttpRequestResponse,
+  SendHttpRequestResponse,
+  TemplateFunction,
+  TemplateRenderResponse,
+} from '@yaakapp/api';
+import console from 'node:console';
+import { readFileSync, type Stats, statSync, watch } from 'node:fs';
+import path from 'node:path';
+// import util from 'node:util';
+import { EventChannel } from './EventChannel';
+// import { interceptStdout } from './interceptStdout';
+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;
+        },
+      },
+      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

@@ -0,0 +1,55 @@
+import type { InternalEvent } from '@yaakapp/api';
+import { EventChannel } from './EventChannel';
+import { PluginHandle } from './PluginHandle';
+import WebSocket from 'ws';
+
+const port = process.env.PORT;
+if (!port) {
+  throw new Error('Plugin runtime missing PORT')
+}
+
+const pluginToAppEvents = new EventChannel();
+const plugins: Record<string, PluginHandle> = {};
+
+const ws = new WebSocket(`ws://localhost:${port}`);
+
+ws.on('message', async (e: Buffer) => {
+  try {
+    await handleIncoming(e.toString());
+  } catch (err) {
+    console.log('Failed to handle incoming plugin event', err);
+  }
+});
+ws.on('open', () => console.log('Plugin runtime connected to websocket'));
+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) => {
+  const eventStr = JSON.stringify(e);
+  ws.send(eventStr);
+});
+
+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);
+    plugins[pluginEvent.pluginRefId] = plugin;
+  }
+
+  // Once booted, forward all events to the plugin worker
+  const plugin = plugins[pluginEvent.pluginRefId];
+  if (!plugin) {
+    console.warn('Failed to get plugin for event by', pluginEvent.pluginRefId);
+    return;
+  }
+
+  if (pluginEvent.payload.type === 'terminate_request') {
+    plugin.terminate();
+    console.log('Terminated plugin worker', pluginEvent.pluginRefId);
+    delete plugins[pluginEvent.pluginRefId];
+  }
+
+  plugin.sendToWorker(pluginEvent);
+}

packages/plugin-runtime/src/interceptStdout.ts

@@ -0,0 +1,37 @@
+import process from "node:process";
+
+export function interceptStdout(
+  intercept: (text: string) => string,
+) {
+  const old_stdout_write = process.stdout.write;
+  const old_stderr_write = process.stderr.write;
+
+  process.stdout.write = (function (write) {
+    return function (text: string) {
+      arguments[0] = interceptor(text, intercept);
+      // deno-lint-ignore no-explicit-any
+      write.apply(process.stdout, arguments as any);
+      return true;
+    };
+  })(process.stdout.write);
+
+  process.stderr.write = (function (write) {
+    return function (text: string) {
+      arguments[0] = interceptor(text, intercept);
+      // deno-lint-ignore no-explicit-any
+      write.apply(process.stderr, arguments as any);
+      return true;
+    };
+  })(process.stderr.write);
+
+  // puts back to original
+  return function unhook() {
+    process.stdout.write = old_stdout_write;
+    process.stderr.write = old_stderr_write;
+  };
+}
+
+function interceptor(text: string, fn: (text: string) => string) {
+  return fn(text).replace(/\n$/, "") +
+    (fn(text) && /\n$/.test(text) ? "\n" : "");
+}

packages/plugin-runtime/src/migrations.ts

@@ -0,0 +1,18 @@
+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,
+  };
+}

packages/plugin-runtime/tsconfig.json

@@ -8,6 +8,7 @@
     "lib": ["es2021"],
     "noImplicitAny": false,
     "moduleResolution": "node16",
+    "resolveJsonModule": true,
     "sourceMap": true,
     "outDir": "build",
     "baseUrl": ".",

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

@@ -1,237 +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 "./models";
-import type { Folder } from "./models";
-import type { GrpcRequest } from "./models";
-import type { HttpRequest } from "./models";
-import type { HttpResponse } from "./models";
-import type { JsonValue } from "./serde_json/JsonValue";
-import type { Workspace } from "./models";
-
-export type BootRequest = { dir: string, watch: boolean, };
-
-export type BootResponse = { name: string, version: string, capabilities: Array<string>, };
-
-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 ExportHttpRequestRequest = { httpRequest: HttpRequest, };
-
-export type ExportHttpRequestResponse = { content: 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 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 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, replyId: string | null, payload: InternalEventPayload, windowContext: WindowContext, };
-
-export type InternalEventPayload = { "type": "boot_request" } & BootRequest | { "type": "boot_response" } & BootResponse | { "type": "reload_request" } | { "type": "reload_response" } | { "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" } & GetHttpRequestActionsRequest | { "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": "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" };
-
-export type OpenFileFilter = { name: string, 
-/**
- * File extensions to require
- */
-extensions: Array<string>, };
-
-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
- */
-require?: 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<TemplateFunctionArg>, };
-
-export type TemplateFunctionArg = { "type": "text" } & TemplateFunctionTextArg | { "type": "select" } & TemplateFunctionSelectArg | { "type": "checkbox" } & TemplateFunctionCheckboxArg | { "type": "http_request" } & TemplateFunctionHttpRequestArg | { "type": "file" } & TemplateFunctionFileArg;
-
-export type TemplateFunctionBaseArg = { 
-/**
- * The name of the argument. Should be `camelCase` format
- */
-name: string, 
-/**
- * Whether the user must fill in the argument
- */
-optional?: boolean, 
-/**
- * The label of the input 
- */
-label?: string, 
-/**
- * The default value
- */
-defaultValue?: string, };
-
-export type TemplateFunctionCheckboxArg = { 
-/**
- * The name of the argument. Should be `camelCase` format
- */
-name: string, 
-/**
- * Whether the user must fill in the argument
- */
-optional?: boolean, 
-/**
- * The label of the input 
- */
-label?: string, 
-/**
- * The default value
- */
-defaultValue?: string, };
-
-export type TemplateFunctionFileArg = { 
-/**
- * The title of the file selection window
- */
-title: string, 
-/**
- * Allow selecting multiple files
- */
-multiple?: boolean, directory?: boolean, defaultPath?: string, filters?: Array<OpenFileFilter>, 
-/**
- * The name of the argument. Should be `camelCase` format
- */
-name: string, 
-/**
- * Whether the user must fill in the argument
- */
-optional?: boolean, 
-/**
- * The label of the input 
- */
-label?: string, 
-/**
- * The default value
- */
-defaultValue?: string, };
-
-export type TemplateFunctionHttpRequestArg = { 
-/**
- * The name of the argument. Should be `camelCase` format
- */
-name: string, 
-/**
- * Whether the user must fill in the argument
- */
-optional?: boolean, 
-/**
- * The label of the input 
- */
-label?: string, 
-/**
- * The default value
- */
-defaultValue?: string, };
-
-export type TemplateFunctionSelectArg = { 
-/**
- * The options that will be available in the select input
- */
-options: Array<TemplateFunctionSelectOption>, 
-/**
- * The name of the argument. Should be `camelCase` format
- */
-name: string, 
-/**
- * Whether the user must fill in the argument
- */
-optional?: boolean, 
-/**
- * The label of the input 
- */
-label?: string, 
-/**
- * The default value
- */
-defaultValue?: string, };
-
-export type TemplateFunctionSelectOption = { label: string, value: string, };
-
-export type TemplateFunctionTextArg = { 
-/**
- * Placeholder for the text input
- */
-placeholder?: string, 
-/**
- * The name of the argument. Should be `camelCase` format
- */
-name: string, 
-/**
- * Whether the user must fill in the argument
- */
-optional?: boolean, 
-/**
- * The label of the input 
- */
-label?: string, 
-/**
- * The default value
- */
-defaultValue?: string, };
-
-export type TemplateRenderRequest = { data: JsonValue, purpose: RenderPurpose, };
-
-export type TemplateRenderResponse = { data: JsonValue, };
-
-export type WindowContext = { "type": "none" } | { "type": "label", label: string, };

plugin-runtime-types/src/index.ts

@@ -1,5 +0,0 @@
-export type * from './plugins';
-export type * from './themes';
-
-export * from './bindings/models';
-export * from './bindings/events';

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

@@ -1,13 +0,0 @@
-import { Context } from './Context';
-
-export type FilterPluginResponse = string[];
-
-export type FilterPlugin = {
-  name: string;
-  description?: string;
-  canFilter(ctx: Context, args: { mimeType: string }): Promise<boolean>;
-  onFilter(
-    ctx: Context,
-    args: { payload: string; mimeType: string },
-  ): Promise<FilterPluginResponse>;
-};

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

@@ -1,16 +0,0 @@
-import { Environment, Folder, HttpRequest, Workspace } from '..';
-import { AtLeast } from '../helpers';
-import { Context } from './Context';
-
-export type ImportPluginResponse = null | {
-  workspaces: AtLeast<Workspace, 'name' | 'id' | 'model'>[];
-  environments: AtLeast<Environment, 'name' | 'id' | 'model' | 'workspaceId'>[];
-  httpRequests: AtLeast<HttpRequest, 'name' | 'id' | 'model' | 'workspaceId'>[];
-  folders: AtLeast<Folder, 'name' | 'id' | 'model' | 'workspaceId'>[];
-};
-
-export type ImporterPlugin = {
-  name: string;
-  description?: string;
-  onImport(ctx: Context, args: { text: string }): Promise<ImportPluginResponse>;
-};

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

@@ -1,6 +0,0 @@
-import { CallTemplateFunctionArgs, TemplateFunction } from '..';
-import { Context } from './Context';
-
-export type TemplateFunctionPlugin = TemplateFunction & {
-  onRender(ctx: Context, args: CallTemplateFunctionArgs): Promise<string | null>;
-};

plugin-runtime-types/src/plugins/ThemePlugin.ts

@@ -1,8 +0,0 @@
-import { Theme } from '../themes';
-import { Context } from './Context';
-
-export type ThemePlugin = {
-  name: string;
-  description?: string;
-  getTheme(ctx: Context, fileContents: string): Promise<Theme>;
-};

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

@@ -1,18 +0,0 @@
-import { FilterPlugin } from './FilterPlugin';
-import { HttpRequestActionPlugin } from './HttpRequestActionPlugin';
-import { ImporterPlugin } from './ImporterPlugin';
-import { TemplateFunctionPlugin } from './TemplateFunctionPlugin';
-import { ThemePlugin } from './ThemePlugin';
-
-export type { Context } from './Context';
-
-/**
- * The global structure of a Yaak plugin
- */
-export type PluginDefinition = {
-  importer?: ImporterPlugin;
-  theme?: ThemePlugin;
-  filter?: FilterPlugin;
-  httpRequestActions?: HttpRequestActionPlugin[];
-  templateFunctions?: TemplateFunctionPlugin[];
-};

plugin-runtime/.gitignore

@@ -1,3 +0,0 @@
-build
-node_modules
-*.blob

plugin-runtime/package.json

@@ -1,21 +0,0 @@
-{
-  "name": "@yaakapp-internal/plugin-runtime",
-  "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:worker": "esbuild src/index.worker.ts --bundle --platform=node --outfile=../src-tauri/vendored/plugin-runtime/index.worker.cjs",
-    "build:proto": "grpc_tools_node_protoc --ts_proto_out=src/gen --ts_proto_opt=outputServices=nice-grpc,outputServices=generic-definitions,useExactTypes=false --proto_path=../proto ../proto/plugins/*.proto"
-  },
-  "dependencies": {
-    "intercept-stdout": "^0.1.2",
-    "long": "^5.2.3",
-    "nice-grpc": "^2.1.9",
-    "protobufjs": "^7.4.0"
-  },
-  "devDependencies": {
-    "@types/intercept-stdout": "^0.1.3",
-    "grpc-tools": "^1.12.4",
-    "ts-proto": "^2.2.0"
-  }
-}

plugin-runtime/src/EventChannel.ts

@@ -1,21 +0,0 @@
-import { InternalEvent } from '@yaakapp/api';
-import EventEmitter from 'node:events';
-import { EventStreamEvent } from './gen/plugins/runtime';
-
-export class EventChannel {
-  emitter: EventEmitter = new EventEmitter();
-
-  emit(e: InternalEvent) {
-    this.emitter.emit('__plugin_event__', { event: JSON.stringify(e) });
-  }
-
-  async *listen(): AsyncGenerator<EventStreamEvent> {
-    while (true) {
-      yield new Promise<EventStreamEvent>((resolve) => {
-        this.emitter.once('__plugin_event__', (event: EventStreamEvent) => {
-          resolve(event);
-        });
-      });
-    }
-  }
-}

plugin-runtime/src/PluginHandle.ts

@@ -1,56 +0,0 @@
-import { BootRequest, InternalEvent } from '@yaakapp-internal/plugin';
-import path from 'node:path';
-import { Worker } from 'node:worker_threads';
-import { EventChannel } from './EventChannel';
-import { PluginWorkerData } from './index.worker';
-
-export class PluginHandle {
-  #worker: Worker;
-
-  constructor(
-    readonly pluginRefId: string,
-    readonly bootRequest: BootRequest,
-    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,
-    };
-    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;
-  }
-
-  async #handleError(err: Error) {
-    console.error('Plugin errored', this.bootRequest.dir, err);
-  }
-
-  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);
-    }
-  }
-}

plugin-runtime/src/gen/plugins/runtime.ts

@@ -1,126 +0,0 @@
-// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
-// versions:
-//   protoc-gen-ts_proto  v2.2.3
-//   protoc               v3.19.1
-// source: plugins/runtime.proto
-
-/* eslint-disable */
-import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
-import { type CallContext, type CallOptions } from "nice-grpc-common";
-
-export const protobufPackage = "yaak.plugins.runtime";
-
-export interface EventStreamEvent {
-  event: string;
-}
-
-function createBaseEventStreamEvent(): EventStreamEvent {
-  return { event: "" };
-}
-
-export const EventStreamEvent: MessageFns<EventStreamEvent> = {
-  encode(message: EventStreamEvent, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
-    if (message.event !== "") {
-      writer.uint32(10).string(message.event);
-    }
-    return writer;
-  },
-
-  decode(input: BinaryReader | Uint8Array, length?: number): EventStreamEvent {
-    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-    let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseEventStreamEvent();
-    while (reader.pos < end) {
-      const tag = reader.uint32();
-      switch (tag >>> 3) {
-        case 1: {
-          if (tag !== 10) {
-            break;
-          }
-
-          message.event = reader.string();
-          continue;
-        }
-      }
-      if ((tag & 7) === 4 || tag === 0) {
-        break;
-      }
-      reader.skip(tag & 7);
-    }
-    return message;
-  },
-
-  fromJSON(object: any): EventStreamEvent {
-    return { event: isSet(object.event) ? globalThis.String(object.event) : "" };
-  },
-
-  toJSON(message: EventStreamEvent): unknown {
-    const obj: any = {};
-    if (message.event !== "") {
-      obj.event = message.event;
-    }
-    return obj;
-  },
-
-  create(base?: DeepPartial<EventStreamEvent>): EventStreamEvent {
-    return EventStreamEvent.fromPartial(base ?? {});
-  },
-  fromPartial(object: DeepPartial<EventStreamEvent>): EventStreamEvent {
-    const message = createBaseEventStreamEvent();
-    message.event = object.event ?? "";
-    return message;
-  },
-};
-
-export type PluginRuntimeDefinition = typeof PluginRuntimeDefinition;
-export const PluginRuntimeDefinition = {
-  name: "PluginRuntime",
-  fullName: "yaak.plugins.runtime.PluginRuntime",
-  methods: {
-    eventStream: {
-      name: "EventStream",
-      requestType: EventStreamEvent,
-      requestStream: true,
-      responseType: EventStreamEvent,
-      responseStream: true,
-      options: {},
-    },
-  },
-} as const;
-
-export interface PluginRuntimeServiceImplementation<CallContextExt = {}> {
-  eventStream(
-    request: AsyncIterable<EventStreamEvent>,
-    context: CallContext & CallContextExt,
-  ): ServerStreamingMethodResult<DeepPartial<EventStreamEvent>>;
-}
-
-export interface PluginRuntimeClient<CallOptionsExt = {}> {
-  eventStream(
-    request: AsyncIterable<DeepPartial<EventStreamEvent>>,
-    options?: CallOptions & CallOptionsExt,
-  ): AsyncIterable<EventStreamEvent>;
-}
-
-type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
-
-export type DeepPartial<T> = T extends Builtin ? T
-  : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>>
-  : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
-  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
-  : Partial<T>;
-
-function isSet(value: any): boolean {
-  return value !== null && value !== undefined;
-}
-
-export type ServerStreamingMethodResult<Response> = { [Symbol.asyncIterator](): AsyncIterator<Response, void> };
-
-export interface MessageFns<T> {
-  encode(message: T, writer?: BinaryWriter): BinaryWriter;
-  decode(input: BinaryReader | Uint8Array, length?: number): T;
-  fromJSON(object: any): T;
-  toJSON(message: T): unknown;
-  create(base?: DeepPartial<T>): T;
-  fromPartial(object: DeepPartial<T>): T;
-}

plugin-runtime/src/index.ts

@@ -1,48 +0,0 @@
-import { InternalEvent } from '@yaakapp/api';
-import { createChannel, createClient, Status } from 'nice-grpc';
-import { EventChannel } from './EventChannel';
-import { PluginRuntimeClient, PluginRuntimeDefinition } from './gen/plugins/runtime';
-import { PluginHandle } from './PluginHandle';
-
-const port = process.env.PORT || '50051';
-
-const channel = createChannel(`localhost:${port}`);
-const client: PluginRuntimeClient = createClient(PluginRuntimeDefinition, channel);
-
-const events = new EventChannel();
-const plugins: Record<string, PluginHandle> = {};
-
-(async () => {
-  try {
-    for await (const e of client.eventStream(events.listen())) {
-      const pluginEvent: InternalEvent = JSON.parse(e.event);
-      // Handle special event to bootstrap plugin
-      if (pluginEvent.payload.type === 'boot_request') {
-        const plugin = new PluginHandle(pluginEvent.pluginRefId, pluginEvent.payload, events);
-        plugins[pluginEvent.pluginRefId] = plugin;
-      }
-
-      // Once booted, forward all events to the plugin worker
-      const plugin = plugins[pluginEvent.pluginRefId];
-      if (!plugin) {
-        console.warn('Failed to get plugin for event by', pluginEvent.pluginRefId);
-        continue;
-      }
-
-      if (pluginEvent.payload.type === 'terminate_request') {
-        await plugin.terminate();
-        console.log('Terminated plugin worker', pluginEvent.pluginRefId);
-        delete plugins[pluginEvent.pluginRefId];
-      }
-
-      plugin.sendToWorker(pluginEvent);
-    }
-    console.log('Stream ended');
-  } catch (err: any) {
-    if (err.code === Status.CANCELLED) {
-      console.log('Stream was cancelled by server');
-    } else {
-      console.log('Client stream errored', err);
-    }
-  }
-})();

plugin-runtime/src/index.worker.ts

@@ -1,397 +0,0 @@
-import {
-  BootRequest,
-  FindHttpResponsesResponse,
-  GetHttpRequestByIdResponse,
-  HttpRequestAction,
-  ImportResponse,
-  InternalEvent,
-  InternalEventPayload,
-  PromptTextResponse,
-  RenderHttpRequestResponse,
-  SendHttpRequestResponse,
-  TemplateFunction,
-  TemplateRenderResponse,
-  WindowContext,
-} from '@yaakapp-internal/plugin';
-import { Context } from '@yaakapp/api';
-import { HttpRequestActionPlugin } from '@yaakapp/api/lib/plugins/HttpRequestActionPlugin';
-import { TemplateFunctionPlugin } from '@yaakapp/api/lib/plugins/TemplateFunctionPlugin';
-import interceptStdout from 'intercept-stdout';
-import * as console from 'node:console';
-import { readFileSync, Stats, statSync, watch } from 'node:fs';
-import path from 'node:path';
-import * as util from 'node:util';
-import { parentPort, workerData } from 'node:worker_threads';
-
-export interface PluginWorkerData {
-  bootRequest: BootRequest;
-  pluginRefId: string;
-}
-
-async function initialize() {
-  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');
-
-  async function importModule() {
-    const id = require.resolve(pathMod);
-    delete require.cache[id];
-    return require(id);
-  }
-
-  const pkg = JSON.parse(readFileSync(pathPkg, 'utf8'));
-
-  prefixStdout(`[plugin][${pkg.name}] %s`);
-
-  let mod = await importModule();
-
-  const capabilities: string[] = [];
-  if (typeof mod.pluginHookExport === 'function') capabilities.push('export');
-  if (typeof mod.pluginHookImport === 'function') capabilities.push('import');
-  if (typeof mod.pluginHookResponseFilter === 'function') capabilities.push('filter');
-
-  console.log('Plugin initialized', pkg.name, { capabilities, enableWatch });
-
-  function buildEventToSend(
-    windowContext: WindowContext,
-    payload: InternalEventPayload,
-    replyId: string | null = null,
-  ): InternalEvent {
-    return { pluginRefId, 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);
-  }
-
-  async 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>(async (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>;
-  }
-
-  async function reloadModule() {
-    mod = await importModule();
-  }
-
-  // Reload plugin if JS or package.json changes
-  const windowContextNone: WindowContext = { type: 'none' };
-  const cb = async () => {
-    await reloadModule();
-    return sendPayload(windowContextNone, { type: 'reload_response' }, null);
-  };
-
-  if (enableWatch) {
-    watchFile(pathMod, cb);
-    watchFile(pathPkg, cb);
-  }
-
-  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;
-      },
-    },
-  });
-
-  // Message comes into the plugin to be processed
-  parentPort!.on('message', async (event: InternalEvent) => {
-    let { windowContext, payload, id: replyId } = event;
-    const ctx = newCtx(event);
-    try {
-      if (payload.type === 'boot_request') {
-        const payload: InternalEventPayload = {
-          type: 'boot_response',
-          name: pkg.name,
-          version: pkg.version,
-          capabilities,
-        };
-        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 mod.pluginHookImport === 'function') {
-        const reply: ImportResponse | null = await mod.pluginHookImport(ctx, payload.content);
-        if (reply != null) {
-          const replyPayload: InternalEventPayload = {
-            type: 'import_response',
-            resources: reply?.resources,
-          };
-          sendPayload(windowContext, replyPayload, replyId);
-          return;
-        } else {
-          // Continue, to send back an empty reply
-        }
-      }
-
-      if (
-        payload.type === 'export_http_request_request' &&
-        typeof mod.pluginHookExport === 'function'
-      ) {
-        const reply: string = await mod.pluginHookExport(ctx, payload.httpRequest);
-        const replyPayload: InternalEventPayload = {
-          type: 'export_http_request_response',
-          content: reply,
-        };
-        sendPayload(windowContext, replyPayload, replyId);
-        return;
-      }
-
-      if (payload.type === 'filter_request' && typeof mod.pluginHookResponseFilter === 'function') {
-        const reply: string = await mod.pluginHookResponseFilter(ctx, {
-          filter: payload.filter,
-          body: payload.content,
-        });
-        const replyPayload: InternalEventPayload = {
-          type: 'filter_response',
-          content: reply,
-        };
-        sendPayload(windowContext, replyPayload, replyId);
-        return;
-      }
-
-      if (
-        payload.type === 'get_http_request_actions_request' &&
-        Array.isArray(mod.plugin?.httpRequestActions)
-      ) {
-        const reply: HttpRequestAction[] = mod.plugin.httpRequestActions.map(
-          (a: HttpRequestActionPlugin) => ({
-            ...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(mod.plugin?.templateFunctions)
-      ) {
-        const reply: TemplateFunction[] = mod.plugin.templateFunctions.map(
-          (a: TemplateFunctionPlugin) => ({
-            ...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 === 'call_http_request_action_request' &&
-        Array.isArray(mod.plugin?.httpRequestActions)
-      ) {
-        const action = mod.plugin.httpRequestActions.find(
-          (a: HttpRequestActionPlugin) => 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(mod.plugin?.templateFunctions)
-      ) {
-        const action = mod.plugin.templateFunctions.find(
-          (a: TemplateFunctionPlugin) => 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 reloadModule();
-      }
-    } catch (err) {
-      console.log('Plugin call threw exception', payload.type, err);
-      // TODO: Return errors to server
-    }
-
-    // No matches, so send back an empty response so the caller doesn't block forever
-    sendEmpty(windowContext, replyId);
-  });
-}
-
-initialize().catch((err) => {
-  console.log('failed to boot plugin', err);
-});
-
-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) => {
-    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, (_event, _name) => {
-    const stat = statSync(filepath);
-    if (stat.mtimeMs !== watchedFiles[filepath]?.mtimeMs) {
-      cb(filepath);
-    }
-    watchedFiles[filepath] = stat;
-  });
-}

rustfmt.toml

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

scripts/vendor-protoc.cjs

@@ -1,10 +1,10 @@
 const decompress = require('decompress');
 const Downloader = require('nodejs-file-downloader');
 const path = require('node:path');
-const { rmSync, mkdirSync, cpSync, existsSync } = require('node:fs');
+const { rmSync, mkdirSync, cpSync, existsSync, statSync, chmodSync } = require('node:fs');
 const { execSync } = require('node:child_process');
 
-const VERSION = '27.2';
+const VERSION = '28.3';
 
 // `${process.platform}_${process.arch}`
 const MAC_ARM = 'darwin_arm64';
@@ -67,6 +67,11 @@ mkdirSync(dstDir, { recursive: true });
   cpSync(includeSrc, includeDst, { recursive: true });
   rmSync(tmpDir, { recursive: true, force: true });
 
+  // Make binary writable, so we can sign it during release
+  const stat = statSync(binDst);
+  const newMode = stat.mode | 0o200;
+  chmodSync(binDst, newMode);
+
   console.log('Downloaded protoc to', binDst);
 })().catch((err) => console.log('Script failed:', err));
 

src-tauri/.gitignore

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

src-tauri/Cargo.toml

@@ -1,11 +1,25 @@
 [workspace]
-members = ["yaak_grpc", "yaak_templates", "yaak_plugin_runtime", "yaak_models", "yaak_sse"]
+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 = "2021"
+edition = "2024"
 authors = ["Gregory Schier"]
+publish = false
 
 # Produce a library for mobile support
 [lib]
@@ -15,55 +29,74 @@ crate-type = ["staticlib", "cdylib", "lib"]
 [profile.release]
 strip = true  # Automatically strip symbols from the binary.
 
-[build-dependencies]
-tauri-build = { version = "2.0.1", features = [] }
+[features]
+cargo-clippy = []
 
-[target.'cfg(target_os = "macos")'.dependencies]
-objc = "0.2.7"
-cocoa = "0.26.0"
+[build-dependencies]
+tauri-build = { version = "2.1.1", features = [] }
 
 [target.'cfg(target_os = "linux")'.dependencies]
-openssl-sys = { version = "0.9", features = ["vendored"] } # For Ubuntu installation to work
+openssl-sys = { version = "0.9.105", features = ["vendored"] } # For Ubuntu installation to work
 
 [dependencies]
-yaak_grpc = { path = "yaak_grpc" }
-yaak_templates = { path = "yaak_templates" }
-yaak_plugin_runtime = { workspace = true }
-yaak_models = { workspace = true }
-yaak_sse = { path = "yaak_sse" }
-anyhow = "1.0.86"
-base64 = "0.22.0"
 chrono = { version = "0.4.31", features = ["serde"] }
-datetime = "0.5.2"
-hex_color = "3.0.0"
-http = "1"
-log = "0.4.21"
-rand = "0.8.5"
-regex = "1.10.2"
-reqwest = { version = "0.12.4", features = ["multipart", "cookies", "gzip", "brotli", "deflate", "json", "native-tls-alpn"] }
-reqwest_cookie_store = "0.8.0"
-serde = { version = "1.0.198", features = ["derive"] }
-serde_json = { version = "1.0.116", features = ["raw_value"] }
-serde_yaml = "0.9.34"
-tauri = { workspace = true }
-tauri-plugin-shell = { workspace = true }
-tauri-plugin-clipboard-manager = "2.0.1"
-tauri-plugin-dialog = "2.0.1"
-tauri-plugin-fs = "2.0.1"
-tauri-plugin-log = { version = "2.0.1", features = ["colored"] }
-tauri-plugin-os = "2.0.1"
-tauri-plugin-updater = "2.0.2"
-tauri-plugin-window-state = "2.0.1"
-tokio = { version = "1.36.0", features = ["sync"] }
-tokio-stream = "0.1.15"
-uuid = "1.7.0"
-thiserror = "1.0.61"
+encoding_rs = "0.8.35"
+eventsource-client = { git = "https://github.com/yaakapp/rust-eventsource-client", version = "0.14.0" }
+http = { version = "1.2.0", default-features = false }
+log = "0.4.27"
+md5 = "0.7.0"
 mime_guess = "2.0.5"
-urlencoding = "2.1.3"
-eventsource-client = { git = "https://github.com/yaakapp/rust-eventsource-client", version = "0.13.0" }
+rand = "0.9.0"
+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"
+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-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-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" }
+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]
-yaak_models = { path = "yaak_models" }
-yaak_plugin_runtime = { path = "yaak_plugin_runtime" }
-tauri-plugin-shell = "2.0.1"
-tauri = { version = "2.0.4", features = ["devtools", "protocol-asset"] }
+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" }

src-tauri/capabilities/capabilities.json

@@ -16,6 +16,7 @@
     "clipboard-manager:allow-read-text",
     "dialog:allow-open",
     "dialog:allow-save",
+    "fs:allow-read-dir",
     "fs:allow-read-file",
     "fs:allow-read-text-file",
     {
@@ -29,11 +30,13 @@
         }
       ]
     },
-    "shell:allow-open",
+    "clipboard-manager:allow-read-text",
+    "clipboard-manager:allow-write-text",
     "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",
@@ -41,9 +44,18 @@
     "core:window:allow-show",
     "core:window:allow-start-dragging",
     "core:window:allow-theme",
-    "core:window:allow-toggle-maximize",
     "core:window:allow-unmaximize",
-    "clipboard-manager:allow-read-text",
-    "clipboard-manager:allow-write-text"
+    "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",
+    "yaak-license:default",
+    "yaak-mac-window:default",
+    "yaak-models:default",
+    "yaak-sync:default",
+    "yaak-ws:default"
   ]
 }

src-tauri/gen/schemas/capabilities.json

@@ -1 +0,0 @@
-{"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-file","fs:allow-read-text-file",{"identifier":"fs:scope","allow":[{"path":"$APPDATA"},{"path":"$APPDATA/**"}]},"shell:allow-open","core:webview:allow-set-webview-zoom","core:window:allow-close","core:window:allow-internal-toggle-maximize","core:window:allow-is-fullscreen","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-toggle-maximize","core:window:allow-unmaximize","clipboard-manager:allow-read-text","clipboard-manager:allow-write-text"]}}

src-tauri/migrations/20241217204951_docs.sql

@@ -0,0 +1,8 @@
+ALTER TABLE http_requests
+    ADD COLUMN description TEXT DEFAULT '' NOT NULL;
+
+ALTER TABLE grpc_requests
+    ADD COLUMN description TEXT DEFAULT '' NOT NULL;
+
+ALTER TABLE folders
+    ADD COLUMN description TEXT DEFAULT '' NOT NULL;

src-tauri/migrations/20241219140051_base-environments.sql

@@ -0,0 +1,45 @@
+-- Add the new field
+ALTER TABLE environments
+    ADD COLUMN environment_id TEXT REFERENCES environments (id) ON DELETE CASCADE;
+
+-- Create temporary column so we know which rows are meant to be base environments. We'll use this to update
+-- child environments to point to them.
+ALTER TABLE environments
+    ADD COLUMN migrated_base_env BOOLEAN DEFAULT FALSE NOT NULL;
+
+-- Create a base environment for each workspace
+INSERT INTO environments (id, workspace_id, name, variables, migrated_base_env)
+SELECT (
+           -- This is the best way to generate a random string in SQLite, apparently
+           'ev_' || 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)
+           ),
+       workspaces.id,
+       'Global Variables',
+       variables,
+       TRUE
+FROM workspaces;
+
+-- Update all non-base environments to point to newly created base environments
+UPDATE environments
+SET environment_id = ( SELECT base_env.id
+                       FROM environments AS base_env
+                       WHERE base_env.workspace_id = environments.workspace_id
+                         AND base_env.migrated_base_env IS TRUE )
+WHERE migrated_base_env IS FALSE;
+
+-- Drop temporary column
+ALTER TABLE environments
+    DROP COLUMN migrated_base_env;
+
+-- Drop the old variables column
+-- IMPORTANT: Skip to give the user the option to roll back to a previous app version. We can drop it once the migration working in the real world
+-- ALTER TABLE workspaces DROP COLUMN variables;

src-tauri/migrations/20250102141937_sync.sql

@@ -0,0 +1,21 @@
+ALTER TABLE workspaces
+    ADD COLUMN setting_sync_dir TEXT;
+
+CREATE TABLE sync_states
+(
+    id           TEXT                               NOT NULL
+        PRIMARY KEY,
+    model        TEXT     DEFAULT 'sync_state'      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,
+    flushed_at   DATETIME DEFAULT CURRENT_TIMESTAMP NOT NULL,
+    checksum     TEXT                               NOT NULL,
+    model_id     TEXT                               NOT NULL,
+    sync_dir     TEXT                               NOT NULL,
+    rel_path     TEXT                               NOT NULL,
+
+    UNIQUE (workspace_id, model_id)
+);

src-tauri/migrations/20250108035425_editor-keymap.sql

@@ -0,0 +1,2 @@
+ALTER TABLE settings
+    ADD COLUMN editor_keymap TEXT DEFAULT 'codemirror' NOT NULL;

src-tauri/migrations/20250108205117_workspace-meta.sql

@@ -0,0 +1,11 @@
+CREATE TABLE workspace_metas
+(
+    id               TEXT                               NOT NULL
+        PRIMARY KEY,
+    model            TEXT     DEFAULT 'workspace_meta'  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,
+    setting_sync_dir TEXT
+);

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

@@ -0,0 +1,2 @@
+-- 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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,66 @@
+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/20250326193143_key-value-id.sql

@@ -0,0 +1,43 @@
+-- 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

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

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

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

src-tauri/src/analytics.rs

@@ -1,249 +0,0 @@
-use std::fmt::Display;
-
-use log::{debug, info};
-use serde::{Deserialize, Serialize};
-use serde_json::{json, Value};
-use tauri::{Manager, Runtime, WebviewWindow};
-
-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};
-
-use crate::is_dev;
-
-const NAMESPACE: &str = "analytics";
-const NUM_LAUNCHES_KEY: &str = "num_launches";
-
-// serializable
-#[derive(Serialize, Deserialize, Debug)]
-#[serde(rename_all = "snake_case")]
-pub enum AnalyticsResource {
-    App,
-    Appearance,
-    CookieJar,
-    Dialog,
-    Environment,
-    Folder,
-    GrpcConnection,
-    GrpcEvent,
-    GrpcRequest,
-    HttpRequest,
-    HttpResponse,
-    KeyValue,
-    Plugin,
-    Setting,
-    Sidebar,
-    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)]
-#[serde(rename_all = "snake_case")]
-pub enum AnalyticsAction {
-    Cancel,
-    Commit,
-    Create,
-    Delete,
-    DeleteMany,
-    Duplicate,
-    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(),
-    )
-    .await;
-    set_key_value_int(w, NAMESPACE, NUM_LAUNCHES_KEY, info.num_launches).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()).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

@@ -0,0 +1,40 @@
+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/encoding.rs

@@ -0,0 +1,16 @@
+use encoding_rs::SHIFT_JIS;
+use tokio::fs;
+use yaak_models::models::HttpResponse;
+
+pub async fn read_response_body<'a>(
+    response: HttpResponse,
+) -> Option<String> {
+    let body_path = match response.body_path {
+        None => return None,
+        Some(p) => p,
+    };
+
+    let body = fs::read(body_path).await.unwrap();
+    let (s, _, _) = SHIFT_JIS.decode(body.as_slice());
+    Some(s.to_string())
+}

src-tauri/src/error.rs

@@ -0,0 +1,62 @@
+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/export_resources.rs

@@ -1,77 +0,0 @@
-use chrono::NaiveDateTime;
-use serde::{Deserialize, Serialize};
-use tauri::{Manager, WebviewWindow};
-use yaak_models::models::{Environment, Folder, GrpcRequest, HttpRequest, Workspace};
-
-#[derive(Default, Debug, Deserialize, Serialize)]
-#[serde(default, rename_all = "camelCase")]
-pub struct WorkspaceExport {
-    pub yaak_version: String,
-    pub yaak_schema: i64,
-    pub timestamp: NaiveDateTime,
-    pub resources: WorkspaceExportResources,
-}
-
-#[derive(Default, Debug, Deserialize, Serialize)]
-#[serde(default, rename_all = "camelCase")]
-pub struct WorkspaceExportResources {
-    pub workspaces: Vec<Workspace>,
-    pub environments: Vec<Environment>,
-    pub folders: Vec<Folder>,
-    pub http_requests: Vec<HttpRequest>,
-    pub grpc_requests: Vec<GrpcRequest>,
-}
-
-#[derive(Default, Debug, Deserialize, Serialize)]
-pub struct ImportResult {
-    pub resources: WorkspaceExportResources,
-}
-
-pub async fn get_workspace_export_resources(
-    window: &WebviewWindow,
-    workspace_ids: Vec<&str>,
-) -> WorkspaceExport {
-    let app_handle = window.app_handle();
-    let mut data = WorkspaceExport {
-        yaak_version: app_handle.package_info().version.clone().to_string(),
-        yaak_schema: 2,
-        timestamp: chrono::Utc::now().naive_utc(),
-        resources: WorkspaceExportResources {
-            workspaces: Vec::new(),
-            environments: Vec::new(),
-            folders: Vec::new(),
-            http_requests: Vec::new(),
-            grpc_requests: Vec::new(),
-        },
-    };
-
-    for workspace_id in workspace_ids {
-        data.resources.workspaces.push(
-            yaak_models::queries::get_workspace(window, workspace_id)
-                .await
-                .expect("Failed to get workspace"),
-        );
-        data.resources.environments.append(
-            &mut yaak_models::queries::list_environments(window, workspace_id)
-                .await
-                .expect("Failed to get environments"),
-        );
-        data.resources.folders.append(
-            &mut yaak_models::queries::list_folders(window, workspace_id)
-                .await
-                .expect("Failed to get folders"),
-        );
-        data.resources.http_requests.append(
-            &mut yaak_models::queries::list_http_requests(window, workspace_id)
-                .await
-                .expect("Failed to get http requests"),
-        );
-        data.resources.grpc_requests.append(
-            &mut yaak_models::queries::list_grpc_requests(window, workspace_id)
-                .await
-                .expect("Failed to get grpc requests"),
-        );
-    }
-
-    return data;
-}

src-tauri/src/history.rs

@@ -0,0 +1,60 @@
+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,22 +1,23 @@
-use std::collections::BTreeMap;
-use std::path::PathBuf;
-use std::str::FromStr;
-use std::sync::Arc;
-use std::time::Duration;
-
+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 base64::prelude::BASE64_STANDARD;
-use base64::Engine;
 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 rustls::crypto::ring;
+use rustls::ClientConfig;
+use rustls_platform_verifier::BuilderVerifierExt;
 use serde_json::Value;
+use std::collections::BTreeMap;
+use std::path::PathBuf;
+use std::str::FromStr;
+use std::sync::Arc;
+use std::time::Duration;
 use tauri::{Manager, Runtime, WebviewWindow};
 use tokio::fs;
 use tokio::fs::{create_dir_all, File};
@@ -27,42 +28,69 @@ use yaak_models::models::{
     Cookie, CookieJar, Environment, HttpRequest, HttpResponse, HttpResponseHeader,
     HttpResponseState, ProxySetting, ProxySettingAuth,
 };
-use yaak_models::queries::{
-    get_http_response, get_or_create_settings, get_workspace, update_response_if_id,
-    upsert_cookie_jar,
+use yaak_models::query_manager::QueryManagerExt;
+use yaak_models::util::UpdateSource;
+use yaak_plugins::events::{
+    CallHttpAuthenticationRequest, HttpHeader, PluginWindowContext, RenderPurpose,
 };
-use yaak_plugin_runtime::events::{RenderPurpose, WindowContext};
+use yaak_plugins::manager::PluginManager;
+use yaak_plugins::template_callback::PluginTemplateCallback;
 
 pub async fn send_http_request<R: Runtime>(
     window: &WebviewWindow<R>,
-    request: &HttpRequest,
+    unrendered_request: &HttpRequest,
     og_response: &HttpResponse,
     environment: Option<Environment>,
     cookie_jar: Option<CookieJar>,
     cancelled_rx: &mut Receiver<bool>,
-) -> Result<HttpResponse, String> {
-    let workspace =
-        get_workspace(window, &request.workspace_id).await.expect("Failed to get Workspace");
-    let settings = get_or_create_settings(window).await;
-    let cb = PluginTemplateCallback::new(
-        window.app_handle(),
-        &WindowContext::from_window(window),
-        RenderPurpose::Send,
-    );
+) -> 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)?;
 
     let response_id = og_response.id.clone();
     let response = Arc::new(Mutex::new(og_response.clone()));
 
-    let rendered_request =
-        render_http_request(&request, &workspace, environment.as_ref(), &cb).await;
+    let cb = PluginTemplateCallback::new(
+        window.app_handle(),
+        &PluginWindowContext::new(window),
+        RenderPurpose::Send,
+    );
+    let update_source = UpdateSource::from_window(window);
 
-    let mut url_string = rendered_request.url;
+    let request = match render_http_request(
+        &unrendered_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,
+            ))
+        }
+    };
+
+    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}");
+    debug!("Sending request to {} {url_string}", request.method);
 
     let mut client_builder = reqwest::Client::builder()
         .redirect(match workspace.setting_follow_redirects {
@@ -74,9 +102,25 @@ pub async fn send_http_request<R: Runtime>(
         .brotli(true)
         .deflate(true)
         .referer(false)
-        .danger_accept_invalid_certs(!workspace.setting_validate_certificates)
         .tls_info(true);
 
+    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)
+    } else {
+        // 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)
+            .danger_accept_invalid_certs(true);
+    }
+
     match settings.proxy {
         Some(ProxySetting::Disabled) => client_builder = client_builder.no_proxy(),
         Some(ProxySetting::Enabled { http, https, auth }) => {
@@ -114,10 +158,9 @@ 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)
-                .expect("Failed to create cookie store");
+            let store = reqwest_cookie_store::CookieStore::from_cookies(cookies, true)?;
             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));
@@ -133,26 +176,26 @@ pub async fn send_http_request<R: Runtime>(
         ));
     }
 
-    let client = client_builder.build().expect("Failed to build client");
+    let client = client_builder.build()?;
 
     // Render query parameters
     let mut query_params = Vec::new();
-    for p in rendered_request.url_parameters {
+    for p in request.url_parameters.clone() {
         if !p.enabled || p.name.is_empty() {
             continue;
         }
         query_params.push((p.name, p.value));
     }
 
-    let uri = match http::Uri::from_str(url_string.as_str()) {
+    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()),
-                window,
-            )
-            .await);
+                &update_source,
+            ));
         }
     };
     // Yes, we're parsing both URI and URL because they could return different errors
@@ -160,16 +203,16 @@ pub async fn send_http_request<R: Runtime>(
         Ok(u) => u,
         Err(e) => {
             return Ok(response_err(
+                &app_handle,
                 &*response.lock().await,
                 format!("Failed to parse URL \"{}\": {}", url_string, e.to_string()),
-                window,
-            )
-            .await);
+                &update_source,
+            ));
         }
     };
 
-    let m = Method::from_bytes(rendered_request.method.to_uppercase().as_bytes())
-        .expect("Failed to create method");
+    let m = Method::from_str(&request.method.to_uppercase())
+        .map_err(|e| GenericError(e.to_string()))?;
     let mut request_builder = client.request(m, url).query(&query_params);
 
     let mut headers = HeaderMap::new();
@@ -191,7 +234,7 @@ pub async fn send_http_request<R: Runtime>(
     //     );
     // }
 
-    for h in rendered_request.headers {
+    for h in request.headers.clone() {
         if h.name.is_empty() && h.value.is_empty() {
             continue;
         }
@@ -200,14 +243,14 @@ pub async fn send_http_request<R: Runtime>(
             continue;
         }
 
-        let header_name = match HeaderName::from_bytes(h.name.as_bytes()) {
+        let header_name = match HeaderName::from_str(&h.name) {
             Ok(n) => n,
             Err(e) => {
                 error!("Failed to create header name: {}", e);
                 continue;
             }
         };
-        let header_value = match HeaderValue::from_str(h.value.as_str()) {
+        let header_value = match HeaderValue::from_str(&h.value) {
             Ok(n) => n,
             Err(e) => {
                 error!("Failed to create header value: {}", e);
@@ -218,32 +261,9 @@ pub async fn send_http_request<R: Runtime>(
         headers.insert(header_name, header_value);
     }
 
-    if let Some(b) = &rendered_request.authentication_type {
-        let empty_value = &serde_json::to_value("").unwrap();
-        let a = rendered_request.authentication;
-
-        if b == "basic" {
-            let username = a.get("username").unwrap_or(empty_value).as_str().unwrap_or_default();
-            let password = a.get("password").unwrap_or(empty_value).as_str().unwrap_or_default();
-
-            let auth = format!("{username}:{password}");
-            let encoded = BASE64_STANDARD.encode(auth);
-            headers.insert(
-                "Authorization",
-                HeaderValue::from_str(&format!("Basic {}", encoded)).unwrap(),
-            );
-        } else if b == "bearer" {
-            let token = a.get("token").unwrap_or(empty_value).as_str().unwrap_or_default();
-            headers.insert(
-                "Authorization",
-                HeaderValue::from_str(&format!("Bearer {token}")).unwrap(),
-            );
-        }
-    }
-
-    let request_body = rendered_request.body;
-    if let Some(body_type) = &rendered_request.body_type {
-        if request_body.contains_key("query") && request_body.contains_key("variables") {
+    let request_body = request.body.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");
             let body = if variables.trim().is_empty() {
@@ -255,9 +275,6 @@ pub async fn send_http_request<R: Runtime>(
                 )
             };
             request_builder = request_builder.body(body.to_owned());
-        } else if request_body.contains_key("text") {
-            let body = get_str_h(&request_body, "text");
-            request_builder = request_builder.body(body.to_owned());
         } else if body_type == "application/x-www-form-urlencoded"
             && request_body.contains_key("form")
         {
@@ -268,7 +285,7 @@ pub async fn send_http_request<R: Runtime>(
                     None => {}
                     Some(a) => {
                         for p in a {
-                            let enabled = get_bool(p, "enabled");
+                            let enabled = get_bool(p, "enabled", true);
                             let name = get_str(p, "name");
                             if !enabled || name.is_empty() {
                                 continue;
@@ -283,7 +300,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("filePath not set")?
+                .ok_or(GenericError("filePath not set".to_string()))?
                 .as_str()
                 .unwrap_or_default();
 
@@ -292,7 +309,12 @@ pub async fn send_http_request<R: Runtime>(
                     request_builder = request_builder.body(f);
                 }
                 Err(e) => {
-                    return Ok(response_err(&*response.lock().await, e, window).await);
+                    return Ok(response_err(
+                        &app_handle,
+                        &*response.lock().await,
+                        e,
+                        &update_source,
+                    ));
                 }
             }
         } else if body_type == "multipart/form-data" && request_body.contains_key("form") {
@@ -302,7 +324,7 @@ pub async fn send_http_request<R: Runtime>(
                     None => {}
                     Some(fd) => {
                         for p in fd {
-                            let enabled = get_bool(p, "enabled");
+                            let enabled = get_bool(p, "enabled", true);
                             let name = get_str(p, "name").to_string();
 
                             if !enabled || name.is_empty() {
@@ -319,11 +341,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(),
-                                            window,
-                                        )
-                                        .await);
+                                            &update_source,
+                                        ));
                                     }
                                 }
                             };
@@ -332,17 +354,36 @@ pub async fn send_http_request<R: Runtime>(
 
                             // Set or guess mimetype
                             if !content_type.is_empty() {
-                                part = part.mime_str(content_type).map_err(|e| e.to_string())?;
+                                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,
+                                        ));
+                                    }
+                                };
                             } 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 =
-                                    part.mime_str(mime.essence_str()).map_err(|e| e.to_string())?;
+                                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,
+                                        ));
+                                    }
+                                };
                             }
 
-                            // Set file path if not empty
+                            // Set file path if it is not empty
                             if !file_path.is_empty() {
                                 let filename = PathBuf::from(file_path)
                                     .file_name()
@@ -359,6 +400,9 @@ pub async fn send_http_request<R: Runtime>(
             }
             headers.remove("Content-Type"); // reqwest will add this automatically
             request_builder = request_builder.multipart(multipart_form);
+        } else if request_body.contains_key("text") {
+            let body = get_str_h(&request_body, "text");
+            request_builder = request_builder.body(body.to_owned());
         } else {
             warn!("Unsupported body type: {}", body_type);
         }
@@ -367,15 +411,60 @@ pub async fn send_http_request<R: Runtime>(
     // Add headers last, because previous steps may modify them
     request_builder = request_builder.headers(headers);
 
-    let sendable_req = match request_builder.build() {
+    let mut sendable_req = match request_builder.build() {
         Ok(r) => r,
         Err(e) => {
             warn!("Failed to build request builder {e:?}");
-            return Ok(response_err(&*response.lock().await, e.to_string(), window).await);
+            return Ok(response_err(
+                &app_handle,
+                &*response.lock().await,
+                e.to_string(),
+                &update_source,
+            ));
         }
     };
 
-    let (resp_tx, resp_rx) = oneshot::channel::<Result<Response, reqwest::Error>>();
+    // Apply authentication
+
+    if let Some(auth_name) = request.authentication_type.to_owned() {
+        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, &auth_name, 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,
+                ));
+            }
+        };
+
+        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 (done_tx, done_rx) = oneshot::channel::<HttpResponse>();
 
     let start = std::time::Instant::now();
@@ -388,21 +477,23 @@ pub async fn send_http_request<R: Runtime>(
         Ok(r) = resp_rx => r,
         _ = cancelled_rx.changed() => {
             debug!("Request cancelled");
-            return Ok(response_err(&*response.lock().await, "Request was cancelled".to_string(), window).await);
+            return Ok(response_err(&app_handle, &*response.lock().await, "Request was cancelled".to_string(), &update_source));
         }
     };
 
     {
+        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 = window.app_handle().path().app_data_dir().unwrap();
+                    let dir = 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() {
@@ -436,13 +527,13 @@ pub async fn send_http_request<R: Runtime>(
                         };
 
                         r.state = HttpResponseState::Connected;
-                        update_response_if_id(&window, &r)
-                            .await
+                        app_handle
+                            .db()
+                            .update_http_response_if_id(&r, &update_source)
                             .expect("Failed to update response after connected");
                     }
 
                     // Write body to FS
-                    println!("BODYPATH {body_path:?}");
                     let mut f = File::options()
                         .create(true)
                         .truncate(true)
@@ -460,21 +551,27 @@ pub async fn send_http_request<R: Runtime>(
                         }
                         match chunk {
                             Ok(Some(bytes)) => {
+                                let mut r = response.lock().await;
+                                r.elapsed = start.elapsed().as_millis() as i32;
                                 f.write_all(&bytes).await.expect("Failed to write to file");
                                 f.flush().await.expect("Failed to flush file");
                                 written_bytes += bytes.len();
-                                let mut r = response.lock().await;
-                                r.elapsed = start.elapsed().as_millis() as i32;
                                 r.content_length = Some(written_bytes as i32);
-                                update_response_if_id(&window, &r)
-                                    .await
+                                app_handle
+                                    .db()
+                                    .update_http_response_if_id(&r, &update_source)
                                     .expect("Failed to update response");
                             }
                             Ok(None) => {
                                 break;
                             }
                             Err(e) => {
-                                response_err(&*response.lock().await, e.to_string(), &window).await;
+                                response_err(
+                                    &app_handle,
+                                    &*response.lock().await,
+                                    e.to_string(),
+                                    &update_source,
+                                );
                                 break;
                             }
                         }
@@ -488,8 +585,9 @@ pub async fn send_http_request<R: Runtime>(
                             None => Some(written_bytes as i32),
                         };
                         r.state = HttpResponseState::Closed;
-                        update_response_if_id(&window, &r)
-                            .await
+                        app_handle
+                            .db()
+                            .update_http_response_if_id(&r, &UpdateSource::from_window(&window))
                             .expect("Failed to update response");
                     };
 
@@ -514,14 +612,22 @@ pub async fn send_http_request<R: Runtime>(
                             })
                             .collect::<Vec<_>>();
                         cookie_jar.cookies = json_cookies;
-                        if let Err(e) = upsert_cookie_jar(&window, &cookie_jar).await {
+                        if let Err(e) = app_handle
+                            .db()
+                            .upsert_cookie_jar(&cookie_jar, &UpdateSource::from_window(&window))
+                        {
                             error!("Failed to update cookie jar: {}", e);
                         };
                     }
                 }
                 Err(e) => {
                     warn!("Failed to execute request {e}");
-                    response_err(&*response.lock().await, format!("{e} → {e:?}"), &window).await;
+                    response_err(
+                        &app_handle,
+                        &*response.lock().await,
+                        format!("{e} → {e:?}"),
+                        &update_source,
+                    );
                 }
             };
 
@@ -530,16 +636,18 @@ 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 get_http_response(window, response_id.as_str()).await {
+            match app_handle.with_db(|c| c.get_http_response(&response_id)) {
                 Ok(mut r) => {
                     r.state = HttpResponseState::Closed;
-                    update_response_if_id(&window, &r).await.expect("Failed to update response")
+                    app_handle.db().update_http_response_if_id(&r, &UpdateSource::from_window(window))
+                        .expect("Failed to update response")
                 },
                 _ => {
-                    response_err(&*response.lock().await, "Ephemeral request was cancelled".to_string(), &window).await
+                    response_err(&app_handle, &*response.lock().await, "Ephemeral request was cancelled".to_string(), &update_source)
                 }.clone(),
             }
         }
@@ -569,10 +677,10 @@ fn ensure_proto(url_str: &str) -> String {
     format!("http://{url_str}")
 }
 
-fn get_bool(v: &Value, key: &str) -> bool {
+fn get_bool(v: &Value, key: &str, fallback: bool) -> bool {
     match v.get(key) {
-        None => false,
-        Some(v) => v.as_bool().unwrap_or_default(),
+        None => fallback,
+        Some(v) => v.as_bool().unwrap_or(fallback),
     }
 }
 

src-tauri/src/notifications.rs

@@ -1,12 +1,15 @@
 use std::time::SystemTime;
 
-use crate::analytics::get_num_launches;
+use crate::error::Result;
+use crate::history::{get_num_launches, get_os};
 use chrono::{DateTime, Duration, Utc};
 use log::debug;
 use reqwest::Method;
 use serde::{Deserialize, Serialize};
-use tauri::{Emitter, Manager, Runtime, WebviewWindow};
-use yaak_models::queries::{get_key_value_raw, set_key_value_raw};
+use serde_json::Value;
+use tauri::{AppHandle, Emitter, Manager, Runtime, WebviewWindow};
+use yaak_models::query_manager::QueryManagerExt;
+use yaak_models::util::UpdateSource;
 
 // Check for updates every hour
 const MAX_UPDATE_CHECK_SECONDS: u64 = 60 * 60;
@@ -42,16 +45,23 @@ impl YaakNotifier {
         }
     }
 
-    pub async fn seen<R: Runtime>(&mut self, w: &WebviewWindow<R>, id: &str) -> Result<(), String> {
-        let mut seen = get_kv(w).await?;
+    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?;
         seen.push(id.to_string());
         debug!("Marked notification as seen {}", id);
-        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()).await;
+        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),
+        );
         Ok(())
     }
 
-    pub async fn check<R: Runtime>(&mut self, window: &WebviewWindow<R>) -> Result<(), String> {
+    pub async fn check<R: Runtime>(&mut self, window: &WebviewWindow<R>) -> Result<()> {
+        let app_handle = window.app_handle();
         let ignore_check = self.last_check.elapsed().unwrap().as_secs() < MAX_UPDATE_CHECK_SECONDS;
 
         if ignore_check {
@@ -60,42 +70,53 @@ impl YaakNotifier {
 
         self.last_check = SystemTime::now();
 
-        let num_launches = get_num_launches(window).await;
-        let info = window.app_handle().package_info().clone();
+        let num_launches = get_num_launches(app_handle).await;
+        let info = app_handle.package_info().clone();
         let req = reqwest::Client::default()
             .request(Method::GET, "https://notify.yaak.app/notifications")
             .query(&[
-                ("version", info.version.to_string()),
-                ("launches", num_launches.to_string()),
+                ("version", info.version.to_string().as_str()),
+                ("launches", num_launches.to_string().as_str()),
+                ("platform", get_os()),
             ]);
-        let resp = req.send().await.map_err(|e| e.to_string())?;
+        let resp = req.send().await?;
         if resp.status() != 200 {
             debug!("Skipping notification status code {}", resp.status());
             return Ok(());
         }
 
-        let notification = resp
-            .json::<YaakNotification>()
-            .await
-            .map_err(|e| e.to_string())?;
+        let result = resp.json::<Value>().await?;
 
-        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(());
+        // 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
         }
-        debug!("Got notification {:?}", notification);
-
-        let _ = window.emit_to(window.label(), "notification", notification.clone());
 
         Ok(())
     }
 }
 
-async fn get_kv<R: Runtime>(w: &WebviewWindow<R>) -> Result<Vec<String>, String> {
-    match get_key_value_raw(w, "notifications", "seen").await {
+async fn get_kv<R: Runtime>(app_handle: &AppHandle<R>) -> Result<Vec<String>> {
+    match app_handle.db().get_key_value_raw("notifications", "seen") {
         None => Ok(Vec::new()),
-        Some(v) => serde_json::from_str(&v.value).map_err(|e| e.to_string()),
+        Some(v) => Ok(serde_json::from_str(&v.value)?),
     }
 }

src-tauri/src/plugin_events.rs

@@ -0,0 +1,281 @@
+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 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,
+    GetHttpRequestByIdResponse, GetKeyValueResponse, Icon, InternalEvent, InternalEventPayload,
+    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 }))
+        }
+        _ => 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,78 +1,80 @@
-use crate::template_callback::PluginTemplateCallback;
-use serde_json::{json, Map, Value};
+use serde_json::Value;
 use std::collections::{BTreeMap, HashMap};
+use yaak_http::apply_path_placeholders;
 use yaak_models::models::{
-    Environment, EnvironmentVariable, GrpcMetadataEntry, GrpcRequest, HttpRequest,
-    HttpRequestHeader, HttpUrlParameter, Workspace,
+    Environment, GrpcMetadataEntry, GrpcRequest, HttpRequest, HttpRequestHeader, HttpUrlParameter,
 };
-use yaak_templates::{parse_and_render, TemplateCallback};
+use yaak_models::render::make_vars_hashmap;
+use yaak_templates::{parse_and_render, render_json_value_raw, TemplateCallback};
 
 pub async fn render_template<T: TemplateCallback>(
     template: &str,
-    w: &Workspace,
-    e: Option<&Environment>,
+    base_environment: &Environment,
+    environment: Option<&Environment>,
     cb: &T,
-) -> String {
-    let vars = &make_vars_hashmap(w, e);
+) -> yaak_templates::error::Result<String> {
+    let vars = &make_vars_hashmap(base_environment, environment);
     render(template, vars, cb).await
 }
 
 pub async fn render_json_value<T: TemplateCallback>(
     value: Value,
-    w: &Workspace,
-    e: Option<&Environment>,
+    base_environment: &Environment,
+    environment: Option<&Environment>,
     cb: &T,
-) -> Value {
-    let vars = &make_vars_hashmap(w, e);
+) -> yaak_templates::error::Result<Value> {
+    let vars = &make_vars_hashmap(base_environment, environment);
     render_json_value_raw(value, vars, cb).await
 }
 
 pub async fn render_grpc_request<T: TemplateCallback>(
     r: &GrpcRequest,
-    w: &Workspace,
-    e: Option<&Environment>,
+    base_environment: &Environment,
+    environment: Option<&Environment>,
     cb: &T,
-) -> GrpcRequest {
-    let vars = &make_vars_hashmap(w, e);
+) -> yaak_templates::error::Result<GrpcRequest> {
+    let vars = &make_vars_hashmap(base_environment, environment);
 
     let mut metadata = Vec::new();
     for p in r.metadata.clone() {
         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?;
 
-    GrpcRequest {
+    Ok(GrpcRequest {
         url,
         metadata,
         authentication,
         ..r.to_owned()
-    }
+    })
 }
 
-pub async fn render_http_request(
+pub async fn render_http_request<T: TemplateCallback>(
     r: &HttpRequest,
-    w: &Workspace,
-    e: Option<&Environment>,
-    cb: &PluginTemplateCallback,
-) -> HttpRequest {
-    let vars = &make_vars_hashmap(w, e);
+    base_environment: &Environment,
+    environment: Option<&Environment>,
+    cb: &T,
+) -> yaak_templates::error::Result<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,
         })
     }
 
@@ -80,343 +82,41 @@ pub async fn render_http_request(
     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;
-    let req = HttpRequest {
+    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 {
         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(
-    workspace: &Workspace,
-    environment: Option<&Environment>,
-) -> HashMap<String, String> {
-    let mut variables = HashMap::new();
-    variables = add_variable_to_map(variables, &workspace.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,
-) -> String {
+) -> yaak_templates::error::Result<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,
-        };
-        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,
-        };
-        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,
-        };
-        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(),
-        };
-        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(),
-        };
-        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,
-        };
-        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,
-        };
-        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,
-                },
-                HttpUrlParameter {
-                    name: ":a".to_string(),
-                    value: "aaa".to_string(),
-                    enabled: true,
-                },
-            ],
-            ..Default::default()
-        });
-        println!("HELLO?: {result:?}");
-
-        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/template_callback.rs

@@ -1,78 +0,0 @@
-use std::collections::HashMap;
-use tauri::{AppHandle, Manager, Runtime};
-use yaak_plugin_runtime::events::{RenderPurpose, TemplateFunctionArg, WindowContext};
-use yaak_plugin_runtime::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 a_def in function.args {
-            let base = match a_def {
-                TemplateFunctionArg::Text(a) => a.base,
-                TemplateFunctionArg::Select(a) => a.base,
-                TemplateFunctionArg::Checkbox(a) => a.base,
-                TemplateFunctionArg::File(a) => a.base,
-                TemplateFunctionArg::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,12 +1,14 @@
 use std::fmt::{Display, Formatter};
 use std::time::SystemTime;
 
+use crate::error::Result;
 use log::info;
-use tauri::{AppHandle, Manager};
+use tauri::{Manager, Runtime, WebviewWindow};
 use tauri_plugin_dialog::{DialogExt, MessageDialogButtons};
 use tauri_plugin_updater::UpdaterExt;
 use tokio::task::block_in_place;
-use yaak_plugin_runtime::manager::PluginManager;
+use yaak_models::query_manager::QueryManagerExt;
+use yaak_plugins::manager::PluginManager;
 
 use crate::is_dev;
 
@@ -46,6 +48,11 @@ impl UpdateMode {
     }
 }
 
+pub enum UpdateTrigger {
+    Background,
+    User,
+}
+
 impl YaakUpdater {
     pub fn new() -> Self {
         Self {
@@ -53,41 +60,52 @@ impl YaakUpdater {
         }
     }
 
-    pub async fn force_check(
+    pub async fn check_now<R: Runtime>(
         &mut self,
-        app_handle: &AppHandle,
+        window: &WebviewWindow<R>,
         mode: UpdateMode,
-    ) -> Result<bool, tauri_plugin_updater::Error> {
+        update_trigger: UpdateTrigger,
+    ) -> Result<bool> {
+        let settings = window.db().get_settings();
+        let update_key = format!("{:x}", md5::compute(settings.id));
         self.last_update_check = SystemTime::now();
 
         info!("Checking for updates mode={}", mode);
 
-        let h = app_handle.clone();
-        let update_check_result = app_handle
+        let w = window.clone();
+        let update_check_result = w
             .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 h = h.clone();
+                let w = w.clone();
                 block_in_place(|| {
                     tauri::async_runtime::block_on(async move {
                         info!("Shutting down plugin manager before update");
-                        let plugin_manager = h.state::<PluginManager>();
+                        let plugin_manager = w.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;
 
-        match update_check_result {
-            Ok(Some(update)) => {
-                let h = app_handle.clone();
-                app_handle
-                    .dialog()
+        let result = match update_check_result? {
+            None => false,
+            Some(update) => {
+                let w = window.clone();
+                w.dialog()
                     .message(format!(
                         "{} is available. Would you like to download and install it now?",
                         update.version
@@ -104,7 +122,7 @@ impl YaakUpdater {
                         tauri::async_runtime::spawn(async move {
                             match update.download_and_install(|_, _| {}, || {}).await {
                                 Ok(_) => {
-                                    if h.dialog()
+                                    if w.dialog()
                                         .message("Would you like to restart the app?")
                                         .title("Update Installed")
                                         .buttons(MessageDialogButtons::OkCancelCustom(
@@ -113,27 +131,27 @@ impl YaakUpdater {
                                         ))
                                         .blocking_show()
                                     {
-                                        h.restart();
+                                        w.app_handle().restart();
                                     }
                                 }
                                 Err(e) => {
-                                    h.dialog()
+                                    w.dialog()
                                         .message(format!("The update failed to install: {}", e));
                                 }
                             }
                         });
                     });
-                Ok(true)
+                true
             }
-            Ok(None) => Ok(false),
-            Err(e) => Err(e),
-        }
+        };
+
+        Ok(result)
     }
-    pub async fn check(
+    pub async fn maybe_check<R: Runtime>(
         &mut self,
-        app_handle: &AppHandle,
+        window: &WebviewWindow<R>,
         mode: UpdateMode,
-    ) -> Result<bool, tauri_plugin_updater::Error> {
+    ) -> Result<bool> {
         let update_period_seconds = match mode {
             UpdateMode::Stable => MAX_UPDATE_CHECK_HOURS_STABLE,
             UpdateMode::Beta => MAX_UPDATE_CHECK_HOURS_BETA,
@@ -150,6 +168,6 @@ impl YaakUpdater {
             return Ok(false);
         }
 
-        self.force_check(app_handle, mode).await
+        self.check_now(window, mode, UpdateTrigger::Background).await
     }
 }

src-tauri/src/uri_scheme.rs

@@ -0,0 +1,25 @@
+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

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

src-tauri/tauri.conf.json

@@ -45,8 +45,8 @@
     "active": true,
     "category": "DeveloperTool",
     "externalBin": [
-      "vendored/protoc/yaakprotoc",
-      "vendored/node/yaaknode"
+      "vendored/node/yaaknode",
+      "vendored/protoc/yaakprotoc"
     ],
     "icon": [
       "icons/release/32x32.png",
@@ -72,9 +72,6 @@
       "rpm"
     ],
     "createUpdaterArtifacts": "v1Compatible",
-    "iOS": {
-      "developmentTeam": "7PU3P6ELJ8"
-    },
     "macOS": {
       "minimumSystemVersion": "13.0",
       "exceptionDomain": "",
@@ -82,8 +79,7 @@
       "frameworks": []
     },
     "windows": {
-      "digestAlgorithm": "sha256",
-      "timestampUrl": ""
+      "signCommand": "trusted-signing-cli -e https://eus.codesigning.azure.net/ -a Yaak -c yaakapp %1"
     }
   }
 }

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

@@ -1,9 +1,7 @@
 "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)
@@ -17,14 +15,6 @@ 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
@@ -33,20 +23,29 @@ __export(src_exports, {
   plugin: () => plugin
 });
 module.exports = __toCommonJS(src_exports);
-var import_node_fs = __toESM(require("node:fs"));
 var plugin = {
-  templateFunctions: [{
-    name: "fs.readFile",
-    args: [{ title: "Select File", type: "file", name: "path", label: "File" }],
-    async onRender(_ctx, args) {
-      if (!args.values.path) return null;
-      try {
-        return import_node_fs.default.promises.readFile(args.values.path, "utf-8");
-      } catch (err) {
-        return null;
-      }
+  authentication: {
+    name: "basic",
+    label: "Basic Auth",
+    shortLabel: "Basic",
+    args: [{
+      type: "text",
+      name: "username",
+      label: "Username",
+      optional: true
+    }, {
+      type: "text",
+      name: "password",
+      label: "Password",
+      optional: true,
+      password: true
+    }],
+    async onApply(_ctx, { values }) {
+      const { username, password } = values;
+      const value = "Basic " + Buffer.from(`${username}:${password}`).toString("base64");
+      return { setHeaders: [{ name: "Authorization", value }] };
     }
-  }]
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

src-tauri/vendored/plugins/auth-basic/package.json

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

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

@@ -0,0 +1,48 @@
+"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 = {
+  authentication: {
+    name: "bearer",
+    label: "Bearer Token",
+    shortLabel: "Bearer",
+    args: [{
+      type: "text",
+      name: "token",
+      label: "Token",
+      optional: true,
+      password: true
+    }],
+    async onApply(_ctx, { values }) {
+      const { token } = values;
+      const value = `Bearer ${token}`.trim();
+      return { setHeaders: [{ name: "Authorization", value }] };
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  plugin
+});

src-tauri/vendored/plugins/auth-bearer/package.json

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